Logik und Beweisbarkeit

Logik und Beweisbarkeit VL 08 Martin Mundhenk Univ. Jena, Institut für Informatik 11. Januar 2019

Teil 3: Berechenbarkeitstheorie 1. Aussagenlogik 2. Arithmetik 3. Berechenbarkeitstheorie VL08: URM-berechenbare Funktionen und die These von Church VL09: Entscheidbare und semi-entscheidbare Mengen VL10: Reduzierbarkeit VL11: Beweissysteme 4. Unvollständigkeitssätze ( Literatur: Nigel Cutland: Computability (Cambridge University Press) )

VL 8 Übersicht 3.8 Unlimited Register Machines Es wird das Computer-Modell URM (Unlimited Register Machine) vorgestellt, mit dem man Funktionen auf den natürlichen Zahlen berechnen kann. Wir werden für allerlei Funktionen zeigen, wie sie von URM-Programmen berechnet werden können. Das ist (leider) technisch recht aufwendig, überzeugt uns aber davon, dass man alles, was von einem Computer-Modell erwarten kann, auch vom URM-Modell erreicht wird. Das behauptet auch die These von Church und Turing, nach der man alles, was man in diesem Modell berechnen kann, auch intuitiv berechnen kann. Das erlaubt uns für die Zukunft, auch intuitiv statt formal zu argumentieren (wenn wir die Fallstricke der intuitiven Argumentation im Auge behalten).

VL 9 Übersicht 3.9 Entscheidbare und semi-entscheidbare Mengen Unser Ziel ist ja, einen Unterschied zwischen der Menge arithm. Formeln, die mit den Peano-Axiomen bewiesen werden können und der Menge arithm. Formeln, die vom Standard-Modell N erfüllt werden zu zeigen. Dazu übertragen wir den Begriff der Berechenbarkeit bzw. Nicht-Berechenbarkeit auf Mengen und erhalten die Begriffe entscheidbare Menge semi-entscheidbare Menge Uns interessieren besonders die semi-entscheidbaren Mengen, die nicht entscheidbar sind. Diese Eigenschaft ist auch der gesuchte Unterschied zwischen den beiden o.g. Mengen (aber das kommt erst in einer späteren Vorlesung).

VL 10 Übersicht 3.11 Beweissysteme Wir kennen das Beweissystem der Robinson-Arithmetik und anderer Arithmetiken. Wir wissen, wie man Formeln mittels Natürlichem Schließen herleiten kann. Die Axiome-Mengen, aus denen wir Formeln hergeleitet haben, waren stets entscheidbar. Diese Erfahrung nutzen wir jetzt, um zwei allgemeine (abstrakte) Begriffe von Beweissystemen zu definieren, die in die Begriffswelt der berechenbaren Funktionen passen und die uns bekannten Beweissysteme enthalten. Interessanterweise stellen sich die mit diesen Beweissystemen herleitbaren Formelmengen als genau die semi-entscheidbaren Mengen heraus. Das wird sich später als die gesuchte Eigenschaft der Robinson-/Peano-Arithmetik herausstellen.

Vorlesung 8: URM-berechenbare Funktionen und die These von Church und Turing 3. Berechenbarkeitstheorie VL08: URM-berechenbare Funktionen und die These von Church URM-berechenbare Funktionen Die These von Church und Turing Kodierung von URM-Programmen durch Zahlen Nicht alle Funktionen sind URM-berechenbar Universelle URM-Programme VL09: Entscheidbare und semi-entscheidbare Mengen VL10: Reduzierbarkeit VL11: Beweissysteme ( Literatur: Nigel Cutland: Computability (Cambridge University Press) )

8.1 URM-berechenbare Funktionen und die These von Church und Turing In diesem Abschnitt wird das Computer-Modell URM vorgestellt, mit dem man Funktionen auf den natürlichen Zahlen in berechenbare Funktionen (d.h. solche, für die es ein URM-Programm gibt) und nicht-berechenbare Funktionen (d.h. solche, für die es kein URM-Programm gibt) unterscheiden kann. Wir werden für allerlei Funktionen zeigen, wie sie von URM-Programmen berechnet werden können. Das ist (leider) technisch recht aufwendig, überzeugt uns aber davon, dass man alles, was von einem Computer-Modell erwarten kann, auch vom URM-Modell erreicht wird. Am Ende steht die These von Church und Turing, nach der man alles, was man in diesem Modell berechnen kann, auch intuitiv berechnen kann. Das erlaubt uns für die Zukunft davor, intuitiv statt formal zu argumentieren (wenn wir die Fallstricke der intuitiven Argumentation kennen). 3.8.2

Definition 8.1 (Syntax von URM-Programmen) Eine Unlimited Register Machine (URM) besteht aus Registern R 0, R 1, R 2,..., R k (für k N), die jeweils eine nat. Zahl speichern können und einem URM-Programm. Ein URM-Programm ist eine endliche Folge von Zahlen, die zeilenweise mit den angegebenen Mnemonics dargestellt werden. a, b, c stehen für beliebige natürliche Zahlen. Zeile Wirkung R a = 0 2 0 3 a setze Register R a auf 0 R a += 1 2 1 3 a addiere 1 zum Register R a if R a == R b : goto c 2 2 3 a 5 b 7 c falls Register R a und R b den gleichen Inhalt haben, dann springe zu Zeile c des Programms Sei m das Maximum aller a, b, die in den Zeilen des URM-Programms P vorkommen. Dann benutzt P (höchstens) die Register R 0, R 1,..., R m, und man sagt: P ist URM-Programm mit m Registern (plus Ausgaberegister R 0 ). 3.8.3

Beispiele für URM-Programme Register gleichsetzen (und abkürzende Schreibweisen benutzen) 0: R 0 = 0 1: if R 0 == R 1 : goto 4 2: R 0 += 1 3: if R 0 == R 0 : goto 1 opiere den Inhalt von R 1 nach R 0.

3.8.4 Beispiele für URM-Programme Register gleichsetzen (und abkürzende Schreibweisen benutzen) 0: R 0 = 0 1: if R 0 == R 1 : goto 4 2: R 0 += 1 3: goto 1 Kopiere den Inhalt von R 1 nach R 0. Abkürzende Schreibweisen: goto a springe zu Zeile a des Programms Bei Benutzung abkürzender Schreibweisen weiß man, wie man die Programme ohne abkürzende Schreibweisen schreiben kann.

3.8.4 Beispiele für URM-Programme Register gleichsetzen (und abkürzende Schreibweisen benutzen) 0: R 0 = 0 1: while R 0!= R 1 : 2: R 0 += 1 Kopiere den Inhalt von R 1 nach R 0. Abkürzende Schreibweisen: goto a springe zu Zeile a des Programms while R a!= R b : (klar, Schleifenrumpf wird durch Einrückung gekennzeichnet) Bei Benutzung abkürzender Schreibweisen weiß man, wie man die Programme ohne abkürzende Schreibweisen schreiben kann.

Beispiele für URM-Programme Register gleichsetzen (und abkürzende Schreibweisen benutzen) 0: R 0 = 0 1: while R 0!= R 1 : 2: R 0 += 1 Kopiere den Inhalt von R 1 nach R 0. R b = 0 while R b!= R a : R b += 1 Kopiere den Inhalt von R a nach R b. Abkürzende Schreibweisen: goto a springe zu Zeile a des Programms while R a!= R b : (klar, Schleifenrumpf wird durch Einrückung gekennzeichnet) R b = R a kopiere Inhalt von R a nach R b Bei Benutzung abkürzender Schreibweisen weiß man, wie man die Programme ohne abkürzende Schreibweisen schreiben kann.

Addieren Addiere die Inhalte der Register R a und R b und schreibe das Ergebnis nach R c. R c = R a R t = 0 while R b!= R t : R c += 1 R t += 1 Abkürzende Schreibweise: R c = R a + R b

Multiplizieren und Potenzieren R t = 0 R c = 0 while R b!= R t : R c = R c + R a R t += 1 R t = 0 R c = 0 R c += 1 while R b!= R t : R c = R c R a R t += 1 Abk.: R c = R a R b Abk.: R c = R Rb a

Dekrementieren und subtrahieren Die Subtraktion auf den natürlichen Zahlen ist { a. a b, falls a > b b = 0, sonst R a = 0 R t = 0 if R b == R t : goto Ende R t += 1 while R b!= R t : R a += 1 R t += 1 R z = 0 R a = R b R s = R c while R s!= R z : R a = R a -1 R s = R s -1 Abk.: R a = R b -1 Ende Abk.: R a = R b - R c die Nummer der ersten Programmzeile hinter dem Programm 3.8.7

Vorzeichenfunktionen sig(x) = { 1, falls x > 0 0, falls x = 0 sig(x) = 1 sig(x) R a = 0 R c = R b while R c!= R a : R a += 1 R c = R a Abk.: R a = sig(r b ) R t = sig(r b ) R s = 0 R s += 1 R a = R s - R t Abk.: R a = sig(r b )

3.8.9 Vergleiche R a > R b = { 1, falls R a > R b 0, sonst R a R b = R a > R b + 1 R c = R a - R b R c = sig(r c ) Abk.: R c = R a > R b R t = R b R t += 1 R c = R a > R t Abk.: R c = R b R a

Aussagenlogische Verknüpfungen R a und R b = { 1, falls R a > 0 und R b > 0 0, sonst R c = R a R b R c = sig(r c ) Abk.: R c = R a R b nicht R a = { 1, falls R a = 0 0, sonst R a oder R b = { 1, falls R a > 0 oder R b > 0 0, sonst R c = sig(r a ) R c = R a + R b R c = sig(r c ) Abk.: R c =!R a Abk.: R c = R a R b

3.8.11 Ausdrücke auswerten Es ist intuitiv klar, dass arithmetisch-logische Ausdrücke als URM-Programme geschrieben werden können. Beispiel: R c = R a + sig(r a (R b 2)) ist Abkürzung für R t = 0 R t += 1 R t += 1 R t = R b - R t R t = R a R t R t = sig(r t ) R c = R a + R t

3.8.12 Schleifen mit beliebigen Bedingungen while <Ausdruck> : P ist Abkürzung für R t = <Ausdruck> R z = 0 while R t!= R z : P R t = <Ausdruck>

if then else if <Ausdruck> : P else : Q ist Abkürzung für R i = 0 R z = 0 while <Ausdruck>!(R i > R z ) : P R i += 1 R i = 0 while <Ausdruck>!(R i > R z ) : Q R i += 1

3.8.14 Ganzzahlige Division und Rest R t = R a R c = 0 while R t R b : R t = R t - R b R c += 1 R t = R a / R b R s = R t R b R c = R a - R s Abk.: R c = R a mod R b Abk.: R c = R a / R b

Primzahlen R c = 0 if R a > 1 : R t = 2 while R a mod R t : R t += 1 if!(r t ==R a ) : R c += 1 Abk.: R c = R a ist Primzahl R b = 2 R t = 1 while R a > R t : R b += 1 R s = R b ist Primzahl R t = R t + R s Abk.: R b = R a -te Primzahl

Potenzen von Teilern finden maximale Potenz von t als Faktor von n = max{k tk teilt n} R c = 0 while! ( R a mod Rb Rc+1 ) : R c += 1 Abk.: R c = maxpotenz von R b in R a

URM-Programme Semantik Definition 8.2 (Konfiguration eines URM-Programms) Sei P ein URM-Programm mit k Registern. Eine Konfiguration von P ist ein Element von N k+2. Eine Konfiguration (c 0,..., c k, c k+1 ) enthält eines URM-Programms P = (I 0,..., I m ) die Inhalte c 0,..., c k der Register R 0,..., R k und die Nummer c k+1 (Programmzähler) der nächsten auszuführenden Programmzeile I ck+1.

Definition 8.3 (Konfigurationsübergangsrelation P ) Sei P = (I 0, I 1,..., I s 1 ) ein URM-Programm mit k Registern, und c = (c 0,..., c k, pz) sowie c = (c 0,..., c k, pz ) seien zwei Konfigurationen von P. Es gilt c P c gdw. pz < s und I pz = R a = 0, c a = 0, c i = c i für i a, und pz = pz + 1, oder I pz = R a += 1, c a = c a + 1, c i = c i für i a, und pz = pz + 1, oder I pz = if R a == R b : goto c, c i = c i für alle i, und ca = c b und pz = c, oder ca c b und pz = pz + 1. P ist die reflexive und transitive Hülle von P.

URM-berechenbare Funktionen Definition 8.4 (URM-berechenbare Funktionen) Eine partielle Funktion f : N k N ist URM-berechenbar, falls es ein URM-Programm P = (I 0,..., I s 1 ) mit l k Registern gibt, so dass für alle a 1,..., a k N gilt: 1. Wenn f (a 1,..., a k ) definiert ist, dann gibt es c 1,..., c l, pz N mit pz s, so dass P (0, a 1,..., a k, 0,..., 0, 0) (f (a }{{} 1,..., a k ), c 1,..., c l, pz) }{{} Startkonfiguration von P(a 1,..., a k) Endkonfiguration ( umgangssprachlich: die Berechnung P(a 1,..., a k ) hält mit f (a 1,..., a k ) als Inhalt von Register R 0 ). 2. Wenn f (a 1,..., a k ) undefiniert ist, dann gilt für jede Konfiguration c = (c 0,..., c l, pz ) mit (0, a 1,..., a k, 0,..., 0, 0) P c, dass pz < s ( umgangssprachlich: die Berechnung P(a 1,..., a k ) hält nicht ).

3.8.20 8.2 Die These von Church und Turing Es gibt eine Vielzahl formaler Begriffe der Berechenbarkeit (z.b. URM-Berechenbarkeit, Turing-Berechenbarkeit, µ-rek., λ-b., Post-B.,... ), von denen man formal zeigen kann, dass sie äquivalent sind. Man kennt keine Funktion, die intuitiv berechenbar ist und nicht URM-berechenbar (... ) ist. These von Church und Turing Die im intuitiven Sinne berechenbaren Funktionen sind genau die URM-berechenbaren Funktionen.

3.8.21 8.3 Kodierung von URM-Programmen durch Zahlen Jedes URM-Programm lässt sich als eine natürliche Zahl darstellen. Wir schreiben dann auch P i für das Programm, das durch die Zahl i dargestellt wird. Um das zeigen zu können, brauchen wir ein paar Kodierungsfunktionen.

Kodierung von URM-Programmen durch Zahlen mittels τ Tupel (r 1, r 2,..., r k ) N k können kodiert werden mittels τ : N k 0 N mit τ(r 1, r 2,..., r k ) = p0 k p r i i, wobei p i die i-te Primzahl ist (p 0 = 2). i 1 Bsp.: (1, 2, 3, 4) wird kodiert durch τ(1, 2, 3, 4) = 2 4 3 1 5 2 7 3 11 4 = 6026235600. Lemma 8.5 (τ ist eine berechenbare Kodierungsfunktion) Obige Funktion τ : N k 0 N ist injektiv und URM-berechenbar.

3.8.23 Kodierung von URM-Programmen Wir hatten bereits Zeilen von URM-Programmen als Zahlen definiert (und sie mittels umgangssprachlicher Abkürzungen beschrieben). Zeile umgangssprachlich R a = 0 R a += 1 if R a == R b : goto c als Zahl 2 0 3 a 2 1 3 a 2 2 3 a 5 b 7 c Ein URM-Programm P = (I 0, I 1,..., I s 1 ) ist ein Tupel von Zahlen. Seine Kodierung als natürliche Zahl ist τ(p) = τ(i 0, I 1,..., I s 1 ). Bem.: Jede Programmzeile ist eine Zahl 1.

Beispiel: von der Zahl zum URM-Programm und weiter zur Funktion Zahl n : 11390818402802799740004560732733789029991073980 25674244021328319566118290453554296448230855679 84031099788220648378573955873791785094141769232 59520039614096920121966149963554926216602325439 453125000 = τ(144, 60, 100) URM-Programm τ 1 (n) : if R 0 == R 0 : goto 0 R 1 += 1 R 2 = 0 Die Funktion ϕ (1) 11390818...453125000 : N N ist die überall undefinierte Funktion, d.h. für alle n N gilt: ϕ (1) 11390818...453125000 (n) ist undefiniert.

Da τ nicht surjektiv ist, hat τ kein Inverses auf N. Wir bezeichnen mit τ 1 URM eine Erweiterung von τ 1, die jede natürliche Zahl auf ein URM-Programm abbildet. τ 1 URM (n) = (I 1,..., I s ) mit s = max{i 2 i teilt n} und max{i pj i teilt n}, falls das Maximum i I j = eine Programmzeile ist if R 0 == R 0 : goto j, sonst (Endlosschleife) Z.B. ist τ 1 URM (n) für jedes ungerade n das leere Programm. Das stört uns nicht, da uns ausreicht, dass τ injektiv ist. 3.8.25

Definition 8.6 (Bezeichnungen von Programmen und Funktionen) Sei n N. P n ist das URM-Programm mit τ 1 URM (n) = P n. (Für jedes n N gibt es ein URM-Programm P n.) ϕ (k) n bezeichnet die Funktion N k N, die durch das URM-Programm P n berechnet wird. Für ϕ (1) n schreiben wir auch ϕ n.

8.4 Eine Funktion, die nicht URM-berechenbar ist Definiere ψ : N N mit ψ(n) = { 0, falls ϕn (n) = 1 1, sonst Satz 8.7 ψ ist nicht URM-berechenbar. Beweis: Annahme: ψ ist URM-berechenbar, d.h. ψ = ϕ m für ein m N. Dann gilt ψ(m) = 1 Def. ψ ϕ m (m) 1 ϕm=ψ ψ(m) 1 und ψ(m) 1 ϕ m (m) = 1 ψ(m) = 1. Insgesamt: ψ(m) = 1 ψ(m) 1 d 3.8.27

3.8.28 8.5 Universelle Programme Satz 8.8 Es gibt ein universelles URM-Programm U, das beliebige URM-Programme simulieren kann. Das heißt U(i, x) hält genau dann, wenn P i (x) hält, und wenn P i (x) hält, dann liefert U(i, x) das gleiche Ergebnis in Register R 0. Den Satz kann man mit Benutzung der These von Church und Turing leicht beweisen. Im folgenden Exkurs wird ein universelles URM-Programm konstruiert (also die Beweisidee ohne Benutzng der These von Church und Turing).

Was haben wir in dieser Vorlesung gelernt? Alles, was man intuitiv mit natürlichen Zahlen berechnen kann, kann man auch formal mit URM-Programmen berechnen. D.h. für jede intuitiv berechenbare Funktion gibt es ein URM-Programm, das sie berechnet. Jedes URM-Programm lässt sich durch eine natürliche Zahl darstellen. Wir benutzen diese Zahl auch, um die durch das Programm berechnete Funktion darzustellen. Es gibt ein universelles URM-Programm. Es gibt Funktionen, die nicht URM-berechenbar sind.

Exkurs: Das universelle Programm U (k) simuliert die Berechnung k-stelliger Funktionen. Es erhält als Eingabe e, x 1,..., x k und berechnet die gleiche Ausgabe wie P e (x 1,..., x k ) bzw. hält nicht. Der Algorithmus arbeitet grob gesagt wie folgt. Eingabe e, x 1,..., x k der Programmcode steht bereits in R 1 schreibe den Registercode von 0, x 1,..., x k nach R 2 setze R 3 auf 0 (d.h. R 3 enthält den Programmzähler) solange der Programmzähler R 3 < Anzahl Zeilen des Programms in R 1 : simuliere den durch den Programmzähler bestimmten Befehl des Programmcodes in R 1 auf dem Registercode in R 2 und setze den Programmzähler R 3 entsprechend um schreibe den Inhalt von Register 0 aus dem Konfigurationscode nach R 0

3.8.31 Der Programmcode und der Registercode Der Programmcode eines Programms (I 0, I 1,..., I k 1 ) ist τ(i 0, I 1,..., I p ). Die Anzahl der Zeilen des Programms mit Programmcode m ist γ 1 (m). Der Registercode kodiert die Inhalte aller Register einer URM. Jedes Programm benutzt eine feste Zahl R 0, R 1, R 2,..., R k von Ein- und Ausgaberegistern. Alle Registerinhalte r 0, r 1, r 2,..., r k beim Start des Programms können als k kodiert werden. i=0 p r0 i Damit sind auch die übrigen Register mit Inhalt 0 korrekt kodiert.

3.8.32 Lies den Inhalt eines Registers aus dem Registercode in R 2 Dekodiere aus dem Registercode in R 2 den Inhalt des Registers, dessen Index in R b steht, und schreibe ihn nach R c. R t = R 2 R c = 0 R u = R b -te Primzahl while R t mod R u == 0 : R t = R t / R u R c += 1 Abk.: R c = Register R Rb aus Registercode R 2

Schreibe den Inhalt eines Registers im Registercode in R a Schreibe im Registercode in R a den Inhalt von R c in das Register, dessen Index in R b steht. R t = R b -te Primzahl (Teil 1: setze das Register im Registercode auf 0) while!(r a mod R t ==0) : R a = R a / R t R s = R c (Teil 2: setze das Register im Registercode auf R c) while R s : R a = R a R t R s = R s -1 Abk.: R a = schreibe R c als Reg. R Rb in R a

Berechne den Registercode beim Start der Simulation Der Inhalt der Register R 2,..., R k+1 wird als Registercode (für Register (R 0, )R 1,..., R k ) nach R 2 geschrieben. R t = 1 (am Anfang sind alle Register 0, also ist der Reg.code 1) R i = 2 (der Index des nächsten zu kodierenden Registers) R b = 1 (der Index des nächsten Registers im Konfig.code) R t = schreibe R i als Reg. R Rb in R t R i = 3 (der Index des nächsten zu kodierenden Registers) R b = 2 (der Index des nächsten Registers im Konfig.code) R t = schreibe R i als Reg. R Rb in R t. R i = k + 1 (der Index des nächsten zu kodierenden Registers) R b = k (der Index des nächsten Registers im Konfig.code) R t = schreibe R i als Reg. R Rb in R t R 2 = R t Abk.: R 2 = Kodierung von 0, R 2,..., R k+1

Bsp.: nach der Dekodierung von if R 10 == R 8 : goto 6 ist R 4 = 2, R 5 = 10, R 6 = 8 und R 7 = 6 nach der Dekodierung von R 13 += 1 ist R 4 = 1, R 5 = 13, R 6 = 0 und R 7 = 0 3.8.35 Dekodierung des Zeilencodes Jede Zeile eines URM-Programms wird als Zahl kodiert (Zeilencode). Zeile umgangssprachlich als Zahl R a = 0 2 0 3 a R a += 1 if R a == R b : goto c 2 1 3 a 2 2 3 a 5 b 7 c Der Programmcode ist die Kodierung eines Tupels von Zeilencodes. Das universelle Programm dekodiert den Zeilencode, indem es seine Bestandteile in die Register R 4, R 5, R 6 und R 7 schreibt.

Dekodiere aus dem Programmcode in R a die Zeile, deren Nummer in R b steht, und schreibe sie nach R c. R t = R a R c = 0 R p = R b +1 R u = R p -te Primzahl while R t mod R u == 0 : R t = R t / R u R c += 1 Abk.: R c = Zeile R b aus Programmcode R a

Dekodiere aus dem Programmcode in R 1 die Zeile, deren Nummer in R b steht, und schreibe ihre Bestandteile nach R 4,..., R 7. R c = Zeile R b aus Programmcode R 1 R s = 2 R 4 = maxpotenz von R s in R c R s = 3 R 5 = maxpotenz von R s in R c R s = 5 R 6 = maxpotenz von R s in R c R s = 7 R 7 = maxpotenz von R s in R c (falls der Zeilencode nicht korrekt war, wird die Simulation in eine Endlosschleife gehen) if R c /(2 R4 3 R5 5 R6 7 R7 ) > 1 or ( R 4 < 2 and R 6 + R 7 > 0 ) : R 4 = 3 Abk.: decode next line from program code in R 1

Simulation der einzelnen URM-Befehle: R x = 0 sim[r R5 = 0]: simuliere R R5 = 0, d.h. setze im Registercode in R 2 den Inhalt des Registers, dessen Index in R 5 steht, auf 0. R z = 0 R 2 = schreibe R z als Reg. R R5 in R 2 R 3 += 1 (Programmzähler+1)

Simulation der einzelnen URM-Befehle: R x += 1 sim[r R5 += 1]: simuliere R R5 += 1, d.h. addiere 1 im Registercode in R 2 zum Inhalt des Registers, dessen Index in R 5 steht. R t = R 5 -te Primzahl R 2 = R 2 R t R 3 += 1 (Programmzähler+1)

Simulation der URM-Befehle: if R x == R y : goto z sim[if R R5 == R R6 : goto R 7 ]: simuliere if R b == R c : goto d, d.h. setze den Programmzähler in R 3 auf den Inhalt von R 7, falls im Registercode in R 2 die Register, deren Indizes in R 5 und R 6 stehen, den gleichen Inhalt haben. Anderenfalls wird nur der Programmzähler hochgezählt. R a = Register R R5 aus Registercode R 2 R b = Register R R6 aus Registercode R 2 if R a ==R b : R 3 = R 7 else : R 3 += 1

Das universelle Programm U (k) U (k) (e, x 1,..., x k ) simuliert P e (x 1,..., x k ) und berechnet ϕ e (x 1,..., x k ). (bereite die Simulation vor) R 2 = Kodierung von 0, R 2,..., R k+1 R 3 = 0 (setze Programmzähler auf 0) R 8 = 2 (wir brauchen zweimal eine 2) (simuliere jeden Schritt des Programms) while R 3 < maxpotenz von R 8 in R 1 : decode next line from program code in R 1 if R 4 ==0 : sim[r R5 = 0] if R 4 ==1 : sim[r R5 += 1] if R 4 ==2 : sim[if R R5 == R R6 : goto R 7 ] (schreibe das Ergebnis der Simulation nach R 0) R 0 = maxpotenz von R 4 in R 8