Kapitel 1: Die Basistheoreme

Transkript

1 Kapitel 1: Die Basistheoreme 1.1 Stackprogramme Vorauss.: 1) Variablen X 1,X 2,... (auch X,Y,Z,U,V,O, ev. indiziert) 2) Beliebiges, aber fest gewähltes Alphabet Σ := {a 1,...,a k } Slide 1 Jedes X i fungiert als Stack über Σ: X i kann ein belieb. Wort b 1...b l Σ speichern, mit Zugriff nur auf das Topsymbol b l, falls vorhanden. Def. Stackprogramme (über Σ) sind aufgebaut aus Basisanweisungen push(a, X), pop(x), nil(x) mittels Sequenzierung (Anweisungsfolgen) P 1 ; P 2 Konditionale (bedingte Anweisungen) if top(x) a [P] Schleifen foreach X[Q], vorausgesetzt der Rumpf Q enthält keine Basisanweisung bzgl. der Kontrollvariable X (Schleifenbdg.). Stackprogramme 2 Bem. 1) Die Schleifenbdg. bewirkt, dass bei Ausführung einer Schleife foreach X[P] die Kontrollvariable X nicht verändert wird. Slide 2 2) Die Schleifenbdg. beschränkt jedoch nicht die Ausdrucksstärke von Stackprogrammen. Bem (NF). Jedes Stackprogramm P kann eindeutig in Normalform P 1 ;...,; P k (k 1) geschrieben werden, wobei jede Komponente P i entweder eine Basisanweisung oder ein Konditional oder eine Schleife ist. Schreibweise: P NF P 1 ;...; P k

2 Stackprogramme 3 Operationale Semantik: Standard, bis auf die call by value Semantik für Schleifen foreach X[P]: Slide 3 Erstelle zunächst eine lokale Kopie U X ( neu ) von X. Ändere dann P zu P ab: Ersetze jedes freie Vorkommen von X in Q (vgl. Stackprogramme 4) durch U X. Führe nun folgende Anweisungsfolge aus: P ; pop(u X ) ;...; P ; pop(u X ) ( X -mal) Dabei steht X für die Größe von X, d.h. die Länge des in X gespeicherten Wortes. Wirkungsweise bei Ausführung von foreach X[P]: Jedes Symbol der Kontrollvariable X kann inspiziert werden, ohne dabei den Inhalt von X zu verändern. Stackprogramme 4 Def. Ein Vorkommen von X in P heißt frei, falls es im Kontext top(x) eines Teilprogramms if top(x) a [Q] vorkommt, das nicht im Rumpf einer Schleife foreach X[R] von P enthalten ist. Slide 4 Def. Eine Umgebung ist eine Abbildung ϕ: VAR Σ, wobei VAR:={X 1,X 2,...}. Bezeichne ENV die Menge der Umgebungen und ϕ[x i w] die an Stelle X i zu w Σ abgeänderte Umgebung ϕ. Die denotationale Semantik von Stackprogrammen ist ein Funktional [[ ]]: Stackprogramme (ENV ENV) wobei [[P]](ϕ) (lies: die durch Ausführung von P bei initialer Umgebung ϕ erzeugte Umgebung) wie folgt rekursiv definiert ist:

3 Slide 5 Stackprogramme 5 { ϕ(x [[push(a,x i )]](ϕ)(x j ) := j ) falls i j ϕ(x i )a sonst ϕ(x j ) falls i j [[pop(x i )]](ϕ)(x j ) := w falls i=j,ϕ(x i )=wa ε sonst { ϕ(x [[nil(x i )]](ϕ)(x j ) := j ) falls i j ε sonst [[P 1 ; P 2 ]](ϕ) := [[P 2 ]]([[P 1 ]](ϕ)) [[foreach X[Q]]](ϕ) := [[Q ; pop(u X );...; Q ; pop(u X )]](ϕ ) wobei ϕ := ϕ[u X ϕ(x)] und Q aus Q entsteht, indem jedes freie Vorkommen von X in Q durch die lokale Kopie U X von X ersetzt wird. Bem. [[P]](ϕ) hängt nur von ϕ auf Var(P) ab. Stackprogramme 6 Slide 6 Def. Ein Stackprogramm P mit Var(P) {X 1,...,X m } berechnet eine Funktion f : (Σ ) n Σ, falls für gewisse Input-Variablen X i1,...,x il und eine Output-Variable O von P für alle w 1,...,w n Σ gilt: [[P]]([ X w])(o)=f(w 1,...,w n ) Hoare-Notation: {X i1 =w i1,...,x il =w il } P {O=f(w 1,...,w n )} Kurzform: { X= w} P {O=f( w)} Bsp. (Call-by-value). add-ones mit add-ones(u,v) = u + v 1 (o.e. 1 Σ) wird durch ADD ONES in X berechnet: ADD ONES : foreach Y[if top(y) 1 [push(1,x)]] Denn mit ϕ := [X,Y u,v], ϕ := ϕ[u Y v] gilt [[ADD ONES]](ϕ)(X)= [[(if top(u Y ) 1 [push(1,x)]; pop(u Y )) v ]](ϕ )(X) = u1 v 1.

4 Stackprogramme 7 String-Addition (x, y) = x + y wird durch ADD in X berechnet: ADD : foreach Y[push(a,X)]. String-Multiplikation (x, y) = x y wird d. MULT in Z berechn.: Slide 7 MULT : nil(z); foreach X[ADD(Y; Z)]. l (x 1,...,x l ) = x 1... x l wird durch MULT l in Y berechnet: MULT l : nil(y); foreach X 1 [...foreach X l [push(a,y)]...] String-Exponentiation (u) =2 u wird durch EXP in Y berechnet: EXP : nil(y); push(a, Y); foreach X[nil(Z); foreach Y[push(a, Z); push(a, Z)]; nil(y); foreach Z[push(a, Y)]] 1.2 µ-maß für Stackprogramme Slide 8 Kernfrage: Welche Information steckt in der Syntax von (Stack-) Programmen, die es uns ermöglicht Programme P mit polynomieller Laufzeit (bzgl. einer Standardsimulation auf TMn) von Programmen P mit möglicherweise super-polynomieller Laufzeit zu trennen? [Wie ging diese Frage im Super-polynomiellem weiter?] Traditioneller Ansatz: Die Schachtelungstiefe deg(p) von Schleifen in P bestimmt wesentlich das von P erzeugte Größenwachstum, wobei: deg(basisanweisung) := 0 deg(if top(x) a [Q]) := deg(q) deg(p 1 ; P 2 ) := max{deg(p 1 ),deg(p 2 )} deg(foreach X[Q]) := deg(q)+1

5 µ-maß für Stackprogramme 2 Nun: deg(add)=1, deg(mult)=2 und deg(mult l )=l für l 1. Aber: deg kann polynomielle Laufzeit nicht von super-polynomieller Laufzeit trennen, denn z.b. gilt deg(exp)=deg(poly)=2. Slide 9 EXP : nil(y); push(a, Y); foreach X[nil(Z); foreach Y[push(a, Z); push(a, Z)]; nil(y); foreach Z[push(a, Y)]] POLY : nil(y); push(a, Y); nil(z); foreach X[foreach Y[push(a, Z); push(a, Z)]; push(a, Y)]; nil(y); foreach Z[push(a, Y); push(a, Y)] {X=w} EXP { Y =2 w } {X=w} POLY { Y =2 w ( w + 1)} µ-maß für Stackprogramme 3 Der µ Ansatz: Eine Verfeinerung von deg um die Suche nach Kreisen bzgl. der folgenden Relation innerhalb von Schleifen: X regiert Y in P : P enthält foreach X[...push(a,Y)...] Slide 10 Nun gilt: µ(add)=µ(mult)=µ(mult l )=0 für l 1 µ(exp)=1 und µ(poly)=0 EXP nil(y); push(a, Y); foreach X[nil(Z); foreach Y[push(a, Z); push(a, Z)]; nil(y); foreach Z[push(a, Y)]] POLY nil(y); push(a, Y); nil(z); foreach X[foreach Y[push(a, Z); push(a, Z)];push(a, Y)]; nil(y); foreach Z[push(a, Y); push(a, Y)]

6 µ-maß für Stackprogramme 4 Def (Kontrolle). Sei P ein Stackprogramm. PUSH(P) := {Y P enthält eine Anweisung push(a, Y)} Slide 11 X regiert Y in P (auch: X kontrolliert Y direkt in P), in Zeichen X P Y, falls gilt: P enthält eine Schleife foreach X[Q] mit Y PUSH(Q). Die Kontrolle in P, in Zeichen P, ist der transitive Abschluß von P, d.h. es gilt X P Y (lies X kontrolliert Y in P) : X P Y oder ( l 1) Z 1,...,Z l : X P Z 1 P... P Z l P Y Bem. Es gilt (X P X). µ-maß für Stackprogramme 5 Def. Das µ Maß µ(p) eines Stackprogramms P ist induktiv so definiert: Slide 12 µ(basisanweisung) := 0 µ(if top(x) a [Q]) := µ(q) µ(p 1 ; P 2 ) := max{µ(p 1 ),µ(p 2 )} Ist P eine Schleife foreach X[Q], so sei µ(q) + 1 falls Q einen Top Kreis besitzt µ(p) := µ(q) sonst. Q besitzt einen Top Kreis : Q enthält T foreach Y[R] mit µ(t) = µ(q) Z Q Y für ein Z PUSH(R). Bem. Q besitzt den Kontrollkreis Y R Z Q Y.

7 µ-maß für Stackprogramme 6 Lemma (CONTROL). (a) Aus X P Y folgt Y PUSH(P). (b) Aus X P Y mit P foreach Z[Q] folgt X Z oder X Q Y. Slide 13 Beweis. Tafelmitschrift! Lemma (SUB PROGRAM). Ist Q ein Teilprogramm eines Stackprogramms P, so gilt µ(q) µ(p). Beweis. Einfache Induktion nach dem Aufbau von P. Lemma (LOOP LOOP)). µ(foreach X[foreach Y[R]]) = µ(foreach Y[R]) Beweis. Tafelmitschrift! µ-maß für Stackprogramme 7 Slide 14 Lemma (TOP-KREIS). Sei P foreach X[Q] ein Stackprogramm ohne Konditionale und gelte µ(p) = µ(q) + 1. Ferner sei T : foreach Y[R] ein beliebiger Top-Kreis in Q, also µ(t)=µ(q) und Z Q Y für ein Z PUSH(R). Dann gilt: (a) Q NF Q 1 ;...,; Q k mit k 2. (b) Der Top-Kreis T ist in einer Komponente Q i enthalten. (c) Für jede Komponente Q j, die T enthält, gilt: (c1) µ(q j )=µ(q) (c2) (Z Qj Y) Beweis. Tafelmitschrift!