Und es wurde Licht.

Andreas on March 2, 2007 * one comment

Es braucht etwa 100 Zeilen Python-Code, um die Geschichte aller möglichen berechenbaren Universen zu berechnen. 100 Zeilen, um alles zu berechnen, was je berechnet werden kann. Die Physik unseres Universums ist möglicherweise berechenbar.

PLAIN TEXT
PYTHON:
  1. I, L, R, S = 0, 1, 2, 3
  2. ENCODING = [
  3. #   ("111110", ","),
  4.     ("11110" , "S"),
  5.     ("1110"  , "L"),
  6.     ("110"   , "R"),
  7.     ("10"    , "1"),
  8. #   ("0"     , "0"),
  9. ]
  10.  
  11. def to_binary(n):
  12.     return n == 0 and "0" or to_binary(n>>1).lstrip("0") + str(n&1)
  13.  
  14. def to_decimal(x):
  15.     return sum([(int(n) and 2**pos or 0) for (pos, n) in enumerate(x[::-1])])
  16.  
  17.  
  18. class HashableIntegerList(list):
  19.    
  20.     def __init__(self, sequence):
  21.         list.__init__(self, [int(b) for b in sequence])
  22.    
  23.     def __str__(self):
  24.         return "".join([str(n) for n in self])
  25.    
  26.     def __hash__(self):
  27.         return self.__str__().__hash__()
  28.  
  29.  
  30. class TuringMachine:
  31.    
  32.     def __init__(self, rules, tape):
  33.         self.tape    = HashableIntegerList(tape)
  34.         self.state   = HashableIntegerList("0")
  35.         self.rules   = rules
  36.         self.stopped = False
  37.         self.invalid = False
  38.         self.pos     = 0
  39.  
  40.     def move(self, direction):
  41.         if direction == S:
  42.             self.stopped = True
  43.         elif direction == L:
  44.             if self.pos == 0:
  45.                 self.tape.insert(0, 0)
  46.             else:
  47.                 self.pos -= 1
  48.         elif direction == R:
  49.             if self.pos == len(self.tape)-1:
  50.                 self.tape.append(0)
  51.             self.pos += 1
  52.  
  53.     def step(self):
  54.         try:
  55.             self.state, self.tape[self.pos], dir = self.rules[(self.state, self.tape[self.pos])]
  56.         except KeyError:
  57.             self.invalid = True
  58.         else:
  59.             self.move(dir)
  60.  
  61.     def run(self):
  62.         while not self.stopped and not self.invalid:
  63.             self.step()
  64.  
  65.  
  66. class UniversalTuringMachine(TuringMachine):
  67.    
  68.     def __init__(self, tape):
  69.         if tape.count("111110") != 1: self.invalid = True; return
  70.         binary_machine_no, data_tape = tape.split("111110")
  71.         rules = self.get_rules(binary_machine_no)
  72.         TuringMachine.__init__(self, rules, data_tape)
  73.    
  74.     def get_rules(self, binary_machine_no):
  75.         binary_rules = "110%s110" % binary_machine_no
  76.         for (k, v) in ENCODING:
  77.             binary_rules = binary_rules.replace(k, v)
  78.         rules = {}
  79.         cur_rule_num = 0
  80.         tape_state = 0
  81.         cur_rule_parts = []
  82.         for bin in binary_rules:
  83.             if bin in "LRS":
  84.                 rule = "".join(cur_rule_parts)
  85.                 if rule == "":  rule = "00"
  86.                 if rule == "1": rule = "01"
  87.                 int_state = HashableIntegerList(to_binary(cur_rule_num))
  88.                 rules[(int_state, tape_state)] = (HashableIntegerList(rule[:-1]), int(rule[-1:]), eval(bin))
  89.                 cur_rule_parts = []
  90.                 if   tape_state == 0: tape_state = 1
  91.                 elif tape_state == 1: tape_state = 0; cur_rule_num += 1
  92.             else:
  93.                 cur_rule_parts.append(bin)
  94.         return rules
  95.  
  96.  
  97. def universal_dovetailer():
  98.     machines = []
  99.     num_steps = 0
  100.     while True:
  101.         for machine in machines:
  102.             if machine.invalid or machine.stopped:
  103.                 machines.remove(machine)
  104.             else:
  105.                 machine.step()
  106.         new_machine = UniversalTuringMachine(to_binary(num_steps) + "1")
  107.         machines.append(new_machine)
  108.         num_steps += 1
  109.  
  110.  
  111. if __name__ == "__main__":
  112.     universal_dovetailer()

Was, wenn sich erweist, dass die am besten mit der Realität übereinstimmenden physikalischen Theorien die sind, die berechenbar sind? Wir können simulieren, wie Billardkugeln zusammenstoßen und welche sich wohin bewegt. Ein simulierter Zusammenstoß ist kein echter Zusammenstoß. Für uns. Für ein simuliertes Wesen? Führt die Simulation eines bewussten physikalischen Systems zu Bewusstsein?

Die Individualität einer Person ist vom Muster des Zusammenspiels der Materie abhängig, nicht von der Materie selbst. Die Atome jeder Zelle werden nach der Geburt eines Menschen viele Male ausgetauscht. Quantenphysikalisch gesehen sind zwei Teilchen einer Art sowieso nicht nur nicht unterscheidbar, sondern identisch. Wenn alle Protonen eines Körpers durch "andere" Protonen ersetzt werden, so hat das den Zustand nicht verändert. Teilchen haben keine Identität.

Wenn die Physik unseres Universums berechenbar ist oder es keinen subjektiven Unterschied zwischen Bewusstsein und der Simulation von Bewusstsein gibt, so resultiert die Ausführung eines solchen Programms (ein "Universal Dovetailer") in allen bewussten Erfahrungen, die je ein Wesen haben kann. Unabhängig davon, wie man "Wesen" oder "bewusste Erfahrung" definiert.

Aber: Ist die Erfahrung von Bewusstsein auch unabhängig davon, ob bei der Ausführung des Programms, die — wie die Ausführung jedes Programms — in diskreten Schritten abläuft, ein Rechenschritt pro Nanosekunde oder ein Rechenschritt pro Jahr ausgeführt wird? Auch dann, wenn während des Jahres der Computer, auf dem das Programm ausgeführt wird, ausgetauscht und nach Tokio verfrachtet wird? Auch dann, wenn das Ergebnis des Rechenschritts ein Jahr später nicht direkt berechnet wird, sondern bei der Berechnung aller Permutationen der Sequenz von 0en und 1en auftaucht, die die Länge des erwarteten Rechenergebnisses hat?

Stathis Papaiaonnou schreibt an die Singularity-Mailingliste:

If you look at it the right way, anything could be a computation. This has been given by John Searle as a reductio ad absurdum against computationalism, and explored by several other authors (eg. Hilary Putnam, David Chalmers, Greg Egan). The usual counterargument is that in order to map a computation onto an arbitrary physical process, the mapping function must contain the computation already, but this is only significant for an external observer. The inhabitants of a virtual environment will not suddenly cease being conscious if all the manuals showing how an external observer might interpret what is going on in the computation are lost; it matters only that there is some such possible interpretation. Moreover, it is possible to map many computations to the one physical process. In the limiting case, a single state, perhaps the null state, can be mapped onto all computations.

Welche Art von Kontinuität ist für bewusste Erfahrungen nötig?

Categories: Informatik, Philosophie, Physik

One Comment

  1. Benjamin on October 26, 2007, 23:05

    The Prize Is Won; The Simplest Universal Turing Machine Is Proved

    http://blog.wolfram.com/2007/10/the_prize_is_won_the_simplest.html

Write a Comment