VL-12: LOOP und WHILE Programme II

(1)

VL-12: LOOP und WHILE Programme II

(Berechenbarkeit und Komplexit¨ at, WS 2017) Gerhard Woeginger

WS 2017, RWTH

BuK/WS 2017 VL-12: LOOP und WHILE Programme II 1/45

Organisatorisches

I N¨achste Vorlesung:

Donnerstag, November 30, 12:15–13:45 Uhr, Aula

I Webseite:

http://algo.rwth-aachen.de/Lehre/WS1718/BuK.php

Wiederholung

Wdg.: Programmiersprache LOOP

Wir betrachten eine einfache Programmiersprache namens LOOP, deren Programme aus den folgenden syntaktischen Komponenten aufgebaut sind:

I Variablen: x₁ x₂ x₃ . . .

I Konstanten: 0 1 2 . . .

I Symbole: ; := + −

I Schl¨usselw¨orter: LOOP DO ENDLOOP

(2)

Wdg. LOOP / Semantik

Ein LOOP-ProgrammP mitk Variablen

berechnet einek-stellige Funktion der Form[P] :N^k →N^k. IstP die Zuweisungxi:=xj+c,

so ist [P](r₁, . . . ,r_k) = (r₁, . . . ,r_i−1,r_j+c,r_i+1, . . . ,r_k).

IstP die Zuweisungx_i:=x_j−c,

ist [P](r₁, . . . ,r_k) = (r₁, . . . ,r_i−1,r_j−c,r_i+1, . . . ,r_k)fallsr_j ≥c, und andernfalls[P](r₁, . . . ,r_k) = (r₁, . . . ,r_i−1,0,r_i+1, . . . ,r_k).

IstP =P₁;P₂ eine Hintereinanderausf¨uhrung, so ist [P](r₁, . . . ,r_k) = [P₂]([P₁](r₁, . . . ,r_k)).

IstP =LOOPx_i DOQ ENDLOOPein LOOP-Konstrukt, so gilt [P](r₁, . . . ,r_k) = [Q]^rⁱ(r₁, . . . ,r_k).

Wdg.: WHILE / Semantik

I Die Eingabe ist in den Variablenx₁, . . . ,x_n enthalten.

I Alle anderen Variablen werden mit 0initialisiert.

I Das Resultat eines WHILE-Programms ist die Zahl, die sich am Ende der Abbarbeitung in der Variablenx1 ergibt.

Das ProgrammWHILEx_i 6=0 DOP ENDWHILEhat folgende Bedeutung:

P wird solange ausgef¨uhrt, bisxi den Wert0erreicht.

Ein WHILE-ProgrammP mitk Variablen

berechnet einek-stellige Funktion der Form[P] : N^k →N^k. IstP=WHILExi 6=0 DOQ ENDWHILEein WHILE-Konstrukt,

so ist[P](r1, . . . ,rk) = [Q]^`(r1, . . . ,rk)f¨ur die kleinste Zahl`, f¨ur die diei-te Komponente von[Q]^`(r1, . . . ,rk)gleich0ist.

Falls solch ein` nicht existiert, so ist[P](r1, . . . ,rk)undefiniert.

Wdg.: WHILE versus LOOP

I Es gibt WHILE-Programme, die nicht terminieren.

I LOOP-Programme terminieren immer.

I Jede LOOP-berechenbare Funktionf:N^k →Nist auch WHILE-berechenbar.

Satz

Die Programmiersprache WHILE ist Turing-m¨achtig.

Landschaft um LOOP, WHILE, TM, RAM

TM = RAM = WHILE = entscheidbar

LOOP = primitiv rekursiv + − × ^a_b a^b ⁿk

A(m,n)

Ackermann Funktion

(3)

Vorlesung VL-12

LOOP und WHILE Programme II

IDie Ackermann Funktion

IEigenschaften der Ackermann Funktion IAckermann Funktion und LOOP-Programme IPrimitiv rekursive Funktionen

M¨ achtigkeit von LOOP

Vermutung von David Hilbert (1926)

Die Menge der LOOP-berechenbaren Funktionen

stimmt mit der Menge der berechenbaren Funktionen ¨uberein.

Falsch, falsch, falsch, v¨ollig falsch!!

Satz (Ackermann, 1928)

Es gibt berechenbare Funktionen, die nicht LOOP-berechenbar sind.

Wilhelm Ackermann (1896–1962)

Wikipedia: Wilhelm Friedrich Ackermann war ein deutscher Mathematiker (und ein Sch¨uler von Hilbert).

1926 entdeckte er die nach ihm benannte Ackermann Funktion, die in der Berechenbarkeitstheorie eine wichtige Rolle spielt. Ackermann war Gymnasiallehrer an verschiedenen Schulen in Münster, Burgsteinfurt und Lüdenscheid; er hielt auch Vorlesungen an der Universität Münster.

Die Ackermann Funktion

(4)

Ackermann Funktion: Definition

Definition

Die Ackermann FunktionA:N²→Nist folgendermassen definiert:

A(0,n) = n+1 f¨urn≥0

A(m+1,0) = A(m,1) f¨urm≥0 A(m+1,n+1) = A(m,A(m+1,n)) f¨urm,n≥0

Ackermann Funktion: Beispiele (1)

A(0,n) = n+1 f¨urn≥0

Ein paar Beispiele f¨urm=1:

A(1,0) =A(0,1) =2

A(1,1) =A(0,A(1,0)) =A(1,0) +1=3 A(1,2) =A(0,A(1,1)) =A(1,1) +1=4 A(1,3) =A(0,A(1,2)) =A(1,2) +1=5

Beobachtung

A(1,n) =n+2

Ackermann Funktion: Beispiele (2)

A(0,n) = n+1 f¨urn≥0

Ein paar Beispiele f¨urm=2:

A(2,0) =A(1,1) =3

A(2,1) =A(1,A(2,0)) =A(2,0) +2=5 A(2,2) =A(1,A(2,1)) =A(2,1) +2=7

Beobachtung

A(2,n) =2n+3

Ackermann Funktion: Beispiele (3)

A(0,n) = n+1 f¨urn≥0

Und ein paar Beispiele f¨urm=3:

A(3,0) =A(2,1) =5

A(3,1) =A(2,A(3,0)) =2·A(3,0) +3=13 A(3,2) =A(2,A(3,1)) =2·A(3,1) +3=29 A(3,3) =A(2,A(3,2)) =2·A(3,2) +3=61

Beobachtung

A(3,n) =2ⁿ⁺³−3

(5)

Ackermann Funktion: Beispiele (4)

Zusammenfassung der Beispiele

Wenn man den ersten Parameter fixiert ...

I A(1,n) =n+2

I A(2,n) =2n+3

I A(3,n) =2ⁿ⁺³−3

I A(4,n) = 2²^··

·2

| {z } n+3 viele

Zweien

−3

Bereits der Wert A(4,2) =2⁶⁵⁵³⁶−3

ist gr¨osser als die Anzahl aller Atome im Weltraum.

Exkurs: UpArrow-Notation (1)

I Addition ist iterierte Nachfolgerbildung:

S(S(. . .(S(a). . .)

| {z }

bmal

= a+b

I Multiplikation ist iterierte Addition:

a+· · ·+a

| {z }

bmal

= a·b

I Potenzierung ist iterierte Multiplikation:

a× · · · ×a

| {z }

bmal

= a^b =: a↑b

I Der Potenzturm ist iterierte Potenzierung:

a^a^{. .}

.a

| {z }

bmal

=: a↑↑b

I Wiederholte Potenzturmbildung gibt a↑↑a↑↑. . .↑↑a

| {z }

bmal

=: a↑↑↑b

Exkurs: UpArrow-Notation (2)

Definition (UpArrow-Notation von Donald Knuth)

a↑^mb :=











1 wennb=0

a·b wennm=0

a^b wennm=1

a↑^m−1(a↑^m(b−1)) sonst

Es gilt:

I A(1,n) =2+ (n+3)−3

I A(2,n) =2·(n+3)−3

I A(3,n) =2↑(n+3)−3

I A(4,n) =2↑↑(n+3)−3

I A(5,n) =2↑↑↑(n+3)−3 ...

I A(m,n) =2↑^m−2(n+3)−3 f¨urm≥2

Donald Ervin Knuth (1938)

Wikipedia: Don Knuth is an American computer scientist, mathematician, and professor emeritus at Stanford University.

Knuth is the author of the multi-volume work“The Art of Computer Programming”, he popularized the asymptotic notation (big-O), he created theTeXcomputer typesetting system and theMETAFONT font definition language.

I Knuth-Morris-Pratt algorithm I Knuth-Bendix completion algorithm

(6)

Monotonie-Verhalten der Ackermann Funktion

Monotonie-Verhalten (1)

Monotonie

(M.1) A(m,n+1) > A(m,n) (M.2) A(m+1,n) > A(m,n) (M.3) A(m+1,n−1) ≥ A(m,n)

Folgerung

F¨urm≥m⁰ und n≥n⁰ gilt immer:

A(m,n) ≥ A(m⁰,n⁰)

Monotonie-Verhalten (2)

A(0,n) = n+1 f¨urn≥0

Wir wollen nun (M.1) zeigen: A(m,n+1)>A(m,n) Rekursionsgleichung liefert:

A(m,n+1) = A(m−1,A(m,n)) A(m,n) = A(m−1,A(m,n−1))

Induktion liefert zuerstx:=A(m,n)>A(m,n−1)=:y

und danachA(m−1,x)>A(m−1,y).

Ein analoges induktives Argument zeigt (M.2): A(m+1,n)>A(m,n)

Monotonie-Verhalten (3)

(M.3) A(m+1,n−1)≥A(m,n)wird mit einer vollständigen Induktion bewiesen, die über die lexikographisch sortierten Paare (m,n)läuft.

Induktionsanfang:Es giltA(1,n−1) =n+1=A(0,n)f¨ur alle n≥1.

Es giltA(m+1,0) =A(m,1)f¨ur allem≥0.

Induktionsschritt:Wir nehmen an, dass f¨ur(m⁰,n⁰)mit (m⁰<m)oder (m⁰=m)∧(n⁰<n)immerA(m⁰+1,n⁰−1)≥A(m⁰,n⁰)gilt.

A(m+1,n−1) = A(m,A(m+1,n−2)) (Def)

≥ A(m,A(m,n−1)) (Ind+Mono)

≥ A(m−1,A(m,n−1) +1) (Ind)

≥ A(m−1,A(m,n−1)) (Mono)

= A(m,n) (Def)

(7)

Monotonie-Verhalten (4)

Visualisierung der vollst¨andigen Induktion ¨uber die lexikographisch sortierten Paare(m,n):

n

0 m 1

Das Wachstumslemma

Wachstumslemma: Vorbereitung

Ab jetzt betrachten wir ein fixes,wohl-formuliertesLOOP-ProgrammP, das die folgenden zwei Eigenschaften besitzt:

Eigenschaft 1

In allen Zuweisungenxi :=xj+c und xi:=xj−c ist die Konstantec ∈ {0,1}.

Andernfalls ersetzen wirx_i:=x_j+c durchx_i:=x_j gefolgt von einem Block, der ausc Zuweisungenxi:=xi+1besteht.

Eigenschaft 2

In LOOP-KonstruktenLOOPxi DOP ENDLOOP kommt die Z¨ahlvariablexi nicht inP vor.

Andernfalls führen wir für die Schleife eine neue Zählvariablex_i⁰ ein.

Wachstumslemma: Definitionen

I Wir betrachten ein fixes, wohl-formuliertes LOOP-ProgrammP mit denk Variablenx1,x2, . . . ,xk.

I Wir erinnern uns (aus VL-11): Das LOOP-ProgrammP berechnet die k-stellige Funktion[P] : N^k →N^k.

I F¨ur die Anfangswertea= (a1, . . . ,ak)∈N^k der Variablen definieren wir f_P(a) :=b₁+b₂+· · ·+b_k als die Summe aller Ergebniswerte in[P](a) = (b₁, . . . ,b_k).

I Die FunktionF_P:N→Nist definiert durch F_P(n) =max

( f_P(a)

a∈N^k mit

k

X

i=1

a_i ≤n )

Intuitiv: Die FunktionF_P beschreibt das maximale Wachstum / die maximale Zunahme der Variablenwerte im LOOP-ProgrammP.

(8)

Wachstumslemma: Zentrale Aussage

Wir werden nun zeigen,

dass F_P(n)f¨ur allen∈Necht kleiner ist alsA(m,n),

wenn der Parameter mnur genügend gross (in Abhängigkeit vonP) gewählt wird.

Lemma

Für jedes LOOP-ProgrammP gibt es eine natürliche ZahlmP, so dass für alle n∈Ngilt: FP(n)<A(mP,n).

Beachte:

F¨ur jedes feste ProgrammP ist der ParametermP eine Konstante.

Beweis: Induktion ¨ uber den Syntax-Baum

Induktionsanfang (Zuweisungen)

I Es seiP von der Formx_i:=x_j+c f¨urc∈ {−1,0,1}.

I Wir werden zeigen:FP(n)<A(2,n).

Induktionsschritt (Hintereinanderausf¨uhrung)

I Es seiP von der FormP1;P2.

I Induktionsannahme:∃q∈N:F_P₁(`)<A(q, `)und F_P₂(`)<A(q, `).

I Wir werden zeigen:FP(n)<A(q+1,n).

Induktionsschritt (LOOP-Konstrukt)

I Es seiP von der Form “LOOPxi DOQ ENDLOOP”

I Induktionsannahme:∃q∈N:F_Q(`)<A(q, `).

I Wir werden zeigen:FP(n)<A(q+1,n).

Beweis: Induktionsanfang

Induktionsanfang (Zuweisungen)

I Es seiP von der Form “xi :=xj+c” f¨urc ∈ {−1,0,1}

I Dann gilt:F_P(n)≤2n+1, und somit F_P(n)<A(2,n) Argument:

I P ver¨andert nur den Wert der Variablenx_i.

I Am Anfang warxi ≥0, und am Ende istxi=xj+c ≤n+1.

I Die Summe aller Variablenwerte erhöht sich um höchstensn+1, und springt damit von höchstensn (am Anfang) auf höchstens 2n+1(am Ende).

Beweis: Schritt f¨ ur Hintereinanderausf¨ uhrung

Induktionsschritt (Hintereinanderausf¨uhrung)

I Es seiP von der Form “P₁;P₂”

I Induktionsannahme: ∃q∈N:FP1(`)<A(q, `)und F_P₂(`)<A(q, `).

I Dann gilt:FP(n) < A(q+1,n) Argument:

I Wir verwenden die Absch¨atzung (M.3): A(q,n)≤A(q+1,n−1)

I Dann folgt mit den Monotonie Eigenschaften, dass F_P(n) ≤ F_P₂(F_P₁(n)) (Def)

< A(q,A(q,n)) (Ind)

< A(q,A(q+1,n−1)) (Mono)

= A(q+1,n) (Def)

(9)

Beweis: Schritt f¨ urs LOOP-Konstrukt (1)

Induktionsschritt (LOOP-Konstrukt)

I Es seiP von der Form “LOOP xi DOQ ENDLOOP”

I Induktionsannahme liefert: ∃q∈N:F_Q(`)<A(q, `)

I Dann gilt:FP(n) ≤ A(q+1,n).

Argument:

I Wir betrachten jenen Wertα=α(n)f¨ur die Variablexi,

mit dem der gr¨osstm¨ogliche FunktionswertF_P(n)angenommen wird

I Dann giltFP(n) ≤ FQ(FQ(. . .FQ(FQ(n−α)). . .)) +α, wobei die FunktionFQ(·)hier α-fach ineinander eingesetzt ist.

I Die Induktionsannahme gibt uns F_Q(`)<A(q, `)

I Dies wenden wir auf die ¨ausserste FunktionFQ an und erhalten FP(n) < A(q,FQ(. . .FQ(FQ(n−α)). . .)) +α

Beweis: Schritt f¨ urs LOOP-Konstrukt (2)

Und weiter geht’s:

I Wiederholte Anwendung liefert dieα-zeilige Ungleichungskette F_P(n)< A(q,F_Q(,F_Q(. . .F_Q(F_Q(n−α)). . .)) +α

< A(q,A(q,FQ(. . .FQ(FQ(n−α)). . .)) +α ...

< A(q,A(q,A(q, . . . ,A(q,n−α)). . .)) +α

I Daraus ergibt sich F_P(n) ≤ A(q,A(q,A(q, . . . ,A(q,n−α)). . .))

I Im innersten Teil verwenden wirA(q,n−α)≤A(q+1,n−α−1) Ergo: FP(n)≤A(q,A(q,A(q, . . .A(q,A(q+1,n−α−1))). . .))

I Jetzt arbeiten wir uns (α−1)-mal von innen nach aussen vor, und wenden in jedem Schritt die Ackermann Definition an.

I Das ergibtF_P(n)≤A(q+1,n−1)undF_P(n)<A(q+1,n).

Die M¨ achtigkeit von LOOP

Die M¨ achtigkeit von LOOP (1)

Satz

Die Ackermann Funktion ist nicht LOOP-berechenbar.

Beweis:

I Zwecks Widerspruchs nehmen wir an, dass die Ackermann Funktion LOOP-berechenbar ist. Dann gibt es auch ein LOOP-ProgrammP, das die HilfsfunktionB(n) =A(n,n)berechnet.

I Das Wachstumslemma gibt uns eine ZahlmP, sodass f¨ur alle n∈Ngilt: FP(n)<A(mP,n).

I Wird nun das LOOP-Programm P mit der EingabemP aufgerufen, so berechnet es den FunktionswertB(mP).

I Das Wachstumslemma impliziertB(m_P)≤F_P(m_P).

I Zusammengefasst: B(mP)≤FP(mP)<A(mP,mP) =B(mP)

I Widerspruch! QED!

(10)

Die M¨ achtigkeit von LOOP (2)

Da die Ackermann Funktion (durch eine TM) berechenbar ist, folgt:

Korollar

bildet eineechte Teilmengeder berechenbaren Funktionen.

Ergo: Die Programmiersprache LOOP ist nicht Turing-m¨achtig

Satz (ohne Beweis)

f¨allt mit der Menge derprimitiv rekursiven Funktionenzusammen.

Primitiv rekursive Funktionen (1)

I Die primitiv rekursiven Funktionen bilden eine Unterfamilie der Funktionen N^k →Nmitk ≥0.

I Die primitiv rekursiven Funktionen sind induktiv definiert, und k¨onnen im wesentlichen durch zwei Operationen aus den sogenannten Basisfunktionen zusammengebaut werden.

Definition (Basisfunktionen)

Die folgenden drei Funktionsmengen bilden die Basisfunktionen unter den primitiv rekursiven Funktionen:

I Alle konstanten Funktionen sind primitiv rekursiv.

I Alle Projektionen (Abbildungen auf eine der Komponenten) sind primitiv rekursiv.

I Die Nachfolgerfunktions(n) =n+1ist primitiv rekursiv.

Primitiv rekursive Funktionen (2)

Definition

Des weiteren sind die folgenden Funktionen primitiv rekursiv:

I Die Komposition von primitiv rekursiven Funktionen ist primitiv rekursiv.

I Jede Funktion, die durchprimitive Rekursionaus primitiv rekursiven Funktionen entsteht ist primitiv rekursiv.

Wenn die beiden Funktioneng:N^k →Nundh:N^k+2→Nprimitiv rekursiv sind, so ist auch die wie folgt definierte Funktion

f :N^k+1→Nprimitiv rekursiv:

f(0,x₁, . . . ,x_k) = g(x₁, . . . ,x_k)

f(n,x1, . . . ,xk) = h(n,f(n−1,x1, . . . ,xk), x1, . . . ,xk)

Zusammenfassung: Berechenbarkeit

(11)

Zusammenfassung / Berechenbarkeit (1)

Wir haben die folgendenTuring-m¨achtigenRechenmodelle und Programmiersprachen kennen gelernt:

I Turingmaschine (TM)

I k-Band-TM

I Registermaschine (RAM)

I eingeschr¨ankte Registermaschine (Mini-RAM)

I WHILE-Programme (und somit C, Java, Pascal, Postscript, etc.) LOOP-Programme sindnicht Turing-m¨achtig.

Zusammenfassung / Berechenbarkeit (2)

Church-Turing-These

Die Menge der TM-berechenbaren Funktionen stimmt mit der Menge der

“intuitiv berechenbaren” Funktionen ¨uberein.

In anderen Worten:

Ein Problem kann genau dann “algorithmisch gel¨ost werden”, wenn es eine TM f¨ur dieses Problem gibt.

An Stelle von “TM” können wir auch jedes andere Turing-mächtige Rechenmodell in die obigen Sätze einfügen.

Zusammenfassung / Berechenbarkeit (3)

Berechenbarkeitslandschaft:

Rekursiv aufz¨ahlbare

Probleme

H

H D

Probleme mit rekursiv aufz¨ahlbarem

Komplement H H D Rekursive

Probleme

Unentscheidbare Probleme mit unentscheidbarem Komplement Htot

MPCP PCP

Dioph A(·,·)

primitiv rekursive Probleme

Zusammenfassung / Berechenbarkeit (4)

Wichtige nicht berechenbare Probleme:

I Halteproblem, in verschiedenen Varianten

I Satz von Rice:Aussagen ¨uber Eigenschaften von Funktionen, die durch eine gegebene TM berechnet werden, sind nicht entscheidbar

I Schlussfolgerung:Die automatische Verifikation von Programmen in einer TM-m¨achtigen Programmiersprachen ist unm¨oglich

I Postsches Korrespondenzproblem

I Hilberts 10. Problem

(12)

Zusammenfassung / Berechenbarkeit (5)

Methoden zum Nachweis von Nicht-Berechenbarkeit:

I Diagonalisierung

I Unterprogrammtechnik

I Satz von Rice

I Reduktionen (spezielle Variante der Unterprogrammtechnik)