Diplomarbeit Fachbereich Informatik

Diplomarbeit
Entwurf und Implementierung
eines Syntheseverfahrens
für while-Programme
0LFKDHO&KULVWRIIHO
Betreuer: Dipl.-Inform. Jochen Nessel
Arbeitsgruppe Induktive Inferenz
Prof. Dr. Rolf Wiehagen
Fachbereich Informatik
Universität Kaiserslautern ⋅ Postfach 3049 ⋅ 67653 Kaiserslautern

Erklärung:
Hiermit erkläre ich, daß ich die vorliegende Diplomarbeit selbständig
verfaßt habe. Andere als die angegebenen Hilfsmittel und Quellen
wurden von mir nicht verwendet.
Kaiserslautern, den 17. Juli 1997

Vorwort
In dieser Arbeit werden Methoden zur maschinellen Synthese von
Algorithmen anhand von Beispielauswertungen aufgezeigt. Eine
Beispielauswertung ist eine Beschreibung des Ablaufs des zu
synthetisierenden Algorithmus‘ für bestimmte Eingaben. Zur Formulierung
der Algorithmen und der Beispielauswertungen verwenden wir die Sprache
WHILE, die trotz ihrer sehr einfachen Syntax die Beschreibung von
Algorithmen für alle partiell rekursiven Funktionen ermöglicht. Kernstück
der Arbeit ist die Darstellung und Diskussion von Algorithmen zur
Erzeugung der Beispielauswertungen und zur Synthese von Programmen
aus Beispielauswertungen. Des weiteren beinhaltet diese Arbeit einen
objektorientierten Entwurf zur Implementierung dieser Algorithmen. Die
Algorithmen wurden auf mehreren Rechnersystemen erfolgreich
implementiert und getestet.

Danksagung
Ich möchte mich an dieser Stelle bei all denen bedanken, die mich bei der
Erstellung dieser Arbeit unterstützt haben, sei es durch aufmunternde
Worte, sei es durch Hinweise zur Führung der Beweise, sei es durch
praktische Tips zu UNIX, Motif und C++, sei es durch Vorschläge zur
Verbesserung des Layouts und der Bedienung der Benutzeroberfläche
meines Werkzeuges. Insbesondere möchte ich mich bei meinem Professor,
Herrn Prof. Dr. Rolf Wiehagen, und meinem Betreuer, Herrn Dipl.-
Inform. Jochen Nessel, für ihre Unterstützung bei der Erstellung und der
Korrektur dieser Arbeit bedanken.

Inhaltsverzeichnis:
ABBILDUNGSVERZEICHNIS 14
TABELLENVERZEICHNIS 15
1 EINLEITUNG 17
1.1 Vorgeschichte und Motivation 17
1.2 Erste Definition und Einführungsbeispiele 17
1.3 Die Mächtigkeit der Sprache WHILE 23
1.4 Ausführung von Programmen der Sprache WHILE auf einer Registermaschine 33
1.5 Übersicht über die weiteren Kapitel 37
2 DIE SPRACHE WHILE 39
2.1 Zeichenvorrat 39
2.2 Syntax 39
2.3 Programme 40
3 BEISPIELAUSWERTUNGEN 45
3.1 Entfaltungen 45
3.2 Strukturäquivalenz 47
3.3 Werte von Zahlen und Variablen 53
3.4 Konstruktion von Beispielauswertungen 58
3.5 Äquivalente Programme 59
4 AUTOMATISCHE GENERIERUNG VON BEISPIELAUSWERTUNGEN 67
4.1 Variablenlisten 67
4.2 Algorithmus 67
4.3 Korrektheit 70
4.4 Komplexität 82
5 AUTOMATISCHE SYNTHESE VON KLASSE-I-PROGRAMMEN 85
5.1 Idee 85
6HLWH

5.2 Klasse-I-Programme 86
5.3 Algorithmus 86
5.4 Korrektheit 105
5.5 Komplexität 165
6 WEITERE PROGRAMMKLASSEN 181
6.1 Einschränkungen für Klasse-I-Programme 181
6.2 Lokale Variablen 189
6.3 IF-Konstrukte 196
6.4 weitergehende Erweiterungen 199
7 ENTWURFSENTSCHEIDUNGEN 201
8 DER AUFBAU VON ;6$03/( VERSION 2.0 203
8.1 Namenskonventionen 205
8.2 Die Komponente Interface 206
8.3 Die Komponente Text 211
8.4 Die Komponente SampleText 211
8.5 Die Komponente ProgramText 212
8.6 Die Komponente Computer 212
8.7 Die Komponente Synthesizer 213
8.8 Die Komponente Parser 214
8.9 Erweiterungen 217
9 BENUTZERSCHNITTSTELLE 219
9.1 Dateien 219
9.2 Kommandozeilenoptionen 220
9.3 Batch-Mode 222
9.4 Das Hauptformular 223
9.5 Die Menüs 227
9.6 Textbearbeitung 233
9.7 Dialogfenster 236
6HLWH

9.8 Die Syntax der Hilfetexte und Fehlermeldungen 241
10 PORTIERUNGEN 243
11 BEISPIELE VON PROGRAMMLÄUFEN 245
11.1 Programmläufe im Batch-Modus 245
11.2 Programmläufe mit der graphischen Benutzeroberfläche 247
12 ZUSAMMENFASSUNG UND SCHLUßBEMERKUNGEN 255
ANHANG A DIE WIDGETSTRUKTUR VON XSAMPLE 2.0 257
ANHANG B RESOURCEN 263
ANHANG C QUELLTEXT 275
ANHANG D VERZEICHNIS DER VERWENDETEN LITERATUR 277
INDEX 279
6HLWH

Verzeichnis der Abbildungen:
Abbildung 1 : Modell des Roboters aus Beispiel 1.2.3 _______________________________ 21
Abbildung 2 : Struktur der simulierten Turingmaschine ______________________________ 31
Abbildung 3 : Eine Registermaschine zur Implementation von WHILE-Programmen _______ 34
Abbildung 4 : Struktur des Algorithmus’ ComputeProgram ___________________________ 68
Abbildung 5 : Struktur des Algorithmus’ SampleProgram_____________________________ 87
Abbildung 6 : Struktur des Beweises von Satz 5.4.1 ________________________________ 106
Abbildung 7 : Struktur des Beweises von Satz 5.5.1 ________________________________ 166
Abbildung 8 : Struktur von [VDPSOH 2.0 _________________________________________ 204
Abbildung 9 : Struktur der Komponente Interface__________________________________ 206
Abbildung 10 : Struktur der Komponente Parser __________________________________ 214
Abbildung 11 : Das Hauptformular von [VDPSOH 2.0_______________________________ 224
Abbildung 12 : Tear-Off-Menüs ________________________________________________ 231
Abbildung 13 : Das Dialogfenster der Sicherheitsabfrage ___________________________ 237
Abbildung 14 : Die Warnungsbox ______________________________________________ 237
Abbildung 15 : Die Dateiauswahlbox ___________________________________________ 238
Abbildung 16 : Die Hilfebox __________________________________________________ 240
Abbildung 17 : Das Fehlermeldedialogfenster und das Fehlerprotokollfenster ___________ 241
Abbildung 18 : Beispiel 1 - Programmauswertung _________________________________ 248
Abbildung 19 : Beispiel 1 - Programmsynthese____________________________________ 249
Abbildung 20 : Beispiel 2 - Programmauswertung _________________________________ 250
Abbildung 21 : Beispiel 2 - Programmsynthese____________________________________ 251
Abbildung 22 : Beispiel 3 - Programmauswertung _________________________________ 252
Abbildung 23 : Beispiel 3 - Programmsynthese____________________________________ 253
Abbildung 24 : Beispiel 4 _____________________________________________________ 254
Abbildung 25 : Die Widgetstruktur des Hauptformulars von [VDPSOH 2.0 ______________ 257
Abbildung 26 : Die Widgetstruktur des Hauptformulars von [VDPSOH2.0 (Fortsetzung)___ 258
Abbildung 27 : Die Widetstruktur des Hauptformulars von [VDPSOH2.0 (Fortsetzung)____ 259
Abbildung 28 : Die Widgetstruktur des Hauptformulars von [VDPSOH 2.0 (Fortsetzung) ___ 260
Abbildung 29 : Die Widgetstruktur des Hauptformulars von [VDPSOH2.0 (Fortsetzung)___ 261
Abbildung 30 : Die Widgetstruktur des Hauptformulars von [VDPSOH 2.0 (Fortsetzung) ___ 262
6HLWH

Verzeichnis der Tabellen:
Tabelle 1 : Die Befehle der Registermaschine ______________________________________34
Tabelle 2 : Die Syntax der Sprache WHILE ________________________________________39
Tabelle 3 : Erweiterte Syntax der Sprache WHILE _________________________________197
Tabelle 4 : Namenskoventionen ________________________________________________205
Tabelle 5 : Kommandozeilenoptionen ___________________________________________220
Tabelle 6 : Die Pushbuttonezeile _______________________________________________226
Tabelle 7 : Das File-Menü ____________________________________________________227
Tabelle 8 : Das Edit-Menü ____________________________________________________228
Tabelle 9 : Das Help-Menü____________________________________________________229
Tabelle 10 : Das Popupmenü des Samplefensters __________________________________229
Tabelle 11 : Das Popupmenü des Programmfensters________________________________230
Tabelle 12 : Zusammenstellung der Menübefehle __________________________________231
Tabelle 13 : Tastenkombination zum Löschen von Text______________________________234
Tabelle 14 : Tastenkombinationen zum Bewegen des Textcursors______________________234
Tabelle 15 : Die Dateien des Quellcodes _________________________________________275
6HLWH

(LQOHLWXQJ
1 Einleitung
Das effiziente Lernen von Sprachen ist heute ein wichtiger Gegenstand der Forschung in der
Informatik. Bedeutende praktische Anwendungen dieser Theorie sind unter anderem
w
w
w
das maschinelle Verstehen natürlicher Sprache,
verbesserte Mensch-Maschine-Schnittstellen für Softwaresysteme und
die Unterstützung des Softwareentwicklungsprozesses
Diese Arbeit beschäftigt sich mit dem Lernen von Sprachen anhand von Beispielen für die
Verwendung dieser Sprachen. Dabei wollen wir uns auf Programmiersprachen konzentrieren.
Unsere Beispiele zur Verwendung dieser Sprachen sind somit Beschreibungen der
Ausführungen von Programmen der gewählten Programmiersprache sein. Für diese
Beschriebungen werden wir den Namen Beispielauswertung einführen. Ziel des Lernprozesses
ist somit die Synthese der zugrundeliegenden Algorithmen aus den Beispielauswertungen.
Somit überschreitet diese Arbeit die Grenzen der Lerntheorie und enthält auch Aspekte der
Theorie der Programmiersprachen, des Software-Engineerings und der Robotik.
Eine nicht unerhebliche Schwierigkeit beim maschinellen Lernen von Sprachen bereitet die
Komplexität der Sprachen. Da die Programmsynthese aber möglichst effizient verlaufen soll,
muß daher die verwendete Sprache zur Beschreibung der Algorithmen und der
Beispielauswertungen möglichst einfach sein.
In diesem einführenden Kapitel wird eine erste Definition der Sprache WHILE angegeben, die
das Kriterium der Einfachheit erfüllt. Es wird gezeigt, daß jede durch eine Turingmaschine
berechenbare Funktion auch durch ein WHILE-Programm berechnet werden kann. Ebenfalls
wird eine einfache Maschine angegeben, die WHILE-Programme ausführen kann.
1.1 Vorgeschichte und Motivation
Der Autor dieser Diplomarbeit hatte sich bereits für seine Projektarbeit 1 mit der Thematik des
Lernens von Programmiersprachen anhand von Beispielauswertungen befaßt. Damals befaßte
er sich mit der Implementierung eines Ansatzes zur automatischen Programmsynthese von
Efim B. Kinber von der Universität Riga 2 . Das Ergebnis der Untersuchungen entsprach jedoch
nicht den Erwartungen.
Motivation für diese Diplomarbeit war somit die Suche nach einem anderen Ansatz für das
Problem des effizienten Lernens von Programmiersprachen anhand von Beispielauswertungen.
Dieser Ansatz sollte dann ebenfalls auf einem Rechnersystem implementiert werden.
1.2 Erste Definition und Einführungsbeispiele
'HILQLWLRQ
(LQ:+,/(3URJUDPPLVWHLQ7XSHO9(\$ZREHL
9HLQH0HQJHYRQ9DULDEOHQ
(⊆9GLHJHRUGQHWH0HQJHGHU(LQJDEHYDULDEOHQ
\∈9GLH$XVJDEHYDULDEOH
$HLQH)ROJHYRQ$QZHLVXQJHQ
1 „Implementierung von Algorithmen zur Synthese von Programmen rekursiver Funktionen aus
Beispielauswertungen“, eingereicht an der Arbeitsgruppe Induktive Inferenz, Fachbereich
Informatik, Universität Kaiserslautern (1995)
2 Siehe Literatur 14
6HLWH

(LQOHLWXQJ
'DEHLLVWDOV$QZHLVXQJD∈$IROJHQGHVHUODXEW
DGDV,QNUHPHQWHLQHU9DULDEOHQY∈9JHVFKULHEHQY
EGDV'HNUHPHQWHLQHU9DULDEOHQY∈9JHVFKULHEHQY
FGLH,QLWLDOLVDWLRQHLQHU9DULDEOHQY∈9JHVFKULHEHQVHWY PGDEHLGDUI
PHLQH9DULDEOHDX‰HUYRGHUHLQHQDW UOLFKH=DKOVHLQ
GHLQH6FKOHLIHJHVFKULHEHQ
while v > 0 do
A’
end do
'DEHLVHLY∈9XQG$HLQH)ROJHYRQ$QZHLVXQJHQ
(VJHOWHQI UGLH9DULDEOHQIROJHQGH%HGLQJXQJHQ
-HGH9DULDEOHY∈9PX‰HLQH,QLWLDOLVDWLRQEHVLW]HQXQGGDUIYRULKUHU
,QLWLDOLVDWLRQQLFKWYHUZHQGHWZHUGHQ
(LQH,QLWLDOLVDWLRQGDUIQXU
ì YRUHLQHUZHLWHUHQ,QLWLDOLVDWLRQ
ì YRUGHUHUVWHQ$QZHLVXQJDX‰HUHLQHU,QLWLDOLVDWLRQYRQ$
ì YRUHLQHU6FKOHLIH
VWHKHQ
6FKUHLEZHLVH
) UGDV:+,/(3URJUDPP9^[ [ Q`\^D D P`YHUZHQGHQZLUIROJHQGH
1RWDWLRQ
input (x 1 ,..,x n )
a 1
...
a m
output y
'HILQLWLRQ
6HL: ^9^[ [ Q`\$`HLQ:+,/(3URJUDPPXQGVHL1 ^Q Q Q`HLQH
JHRUGQHWH0HQJHQDW UOLFKHU=DKOHQZREHLQGHU$Q]DKOGHU
(LQJDEHYDULDEOHQYRQ:HQWVSULFKW'LH$XVZHUWXQJYRQ:EHL(LQJDEH1LVW
GDQQGXUFKIROJHQGH9HUIDKUHQVYRUVFKULIWGHILQLHUW
) UMHGHVL∈^Q`VHW]HGHQ:HUWGHU9DULDEOHQ[ L DXIQ L
:HUWHGLH$QZHLVXQJVIROJH$DXV
'LH$XVZHUWXQJHLQHU$QZHLVXQJVIROJHD D N ZREHLI UHLQN∈©D D N
$QZHLVXQJHQLVWUHNXUVLYGHILQLHUWGXUFK
)DOOVN OHHUH$QZHLVXQJVIROJHWXHQLFKWV
)DOOVN! :HUWH$QZHLVXQJD DXVXQGZHUWHGDQDFKGLH
$QZHLVXQJVIROJHD D N DXV
) UGLH$XVZHUWXQJHLQHU$QZHLVXQJJLOW
DLVW,QNUHPHQWGHU9DULDEOHQY∈9
6HLFGHU:HUWGHU9DULDEOHQY6HW]HGHQ:HUWYRQYDXIF
DLVW'HNUHPHQWGHU9DULDEOHQY∈9
6HLWH

(LQOHLWXQJ
6HLFGHU:HUWGHU9DULDEOHQY)DOOVF!VHW]HGHQ:HUWYRQYDXIF
DQVRQVWHQWXHQLFKWV
6HLWH

(LQOHLWXQJ
DLVW,QLWLDOLVDWLRQHLQHU9DULDEOHQYHWZDVHWY P
)DOOVPLVW9DULDEOHVRVHW]HGHQ:HUWGHU9DULDEOHQYDXIGHQ:HUWYRQ
P
)DOOVPLVWHLQHQDW UOLFKH=DKOVRVHW]HGHQ:HUWGHU9DULDEOHQYDXIP
DLVW6FKOHLIHHWZD
while v > 0 do
A’
end while
ZREHLY∈9XQG$HLQH$QZHLVXQJVIROJHLVWYHUIDKUHQDFKIROJHQGHU
9RUVFKULIW
L)DOOVGHU:HUWGHU9DULDEOHQYLVWJHKH]XUQlFKVWHQ$QZHLVXQJ
DQVRQVWHQJHKH]X3XQNWLL
LL:HUWHGLH$QZHLVXQJVIROJH$DXVJHKH]X3XQNWL
'HILQLWLRQ
'LH$XVZHUWXQJHLQHV:+,/(3URJUDPPHVWHUPLQLHUWZHQQEHLGHU
$XVZHUWXQJQDFKHQGOLFKYLHOHQ5HFKHQVFKULWWHQDOOH$QZHLVXQJHQ
DXVJHZHUWHWZRUGHQVLQG
'HILQLWLRQ
'LH$XVZHUWXQJHLQHV:+,/(3URJUDPPHVOLHIHUWGHQ:HUWFF∈©ZHQQ
DGLH$XVZHUWXQJWHUPLQLHUW
EQDFK%HHQGLJXQJGHU$XVZHUWXQJKDWGLH$XVJDEHYDULDEOHGHQ:HUWF
Zeigen wir nun, wie mit Hilfe eines WHILE-Programmes Algorithmen zur Addition und
Multiplikation zweier natürlicher Zahlen beschreiben werden kann:
Beispiel 1.2.1:
Gegeben sei das folgende WHILE-Programm:
input (a,b)
while a > 0 do
++b
--a
end while
output b
Die Schleife in obigem Programm terminiert in a Schritten, d.h. der Wert der Variablen b wird
a-mal um 1 erhöht. Demnach hat die Variable b nach Beendigung der Schleife den Wert a+b.
Dies ist auch der Wert der Ausgabe.
6HLWH

(LQOHLWXQJ
Beispiel 1.2.2:
Gegeben sei das folgende WHILE-Programm:
input (a,b)
set (s := 0)
while a > 0 do
set (c := b)
while c > 0 do
++s
--c
end while
--a
end while
output s
Analog zu Beispiel 1.2.1 wird die äußere Schleife genau a-mal durchlaufen. Bei jedem
Durchlauf wird die Variable s, die mit dem Wert 1 initialisiert wird, um den Betrag b erhöht.
Demnach hat s nach Beendigung der äußeren Schleife den Wert a⋅b, der dann der Wert der
Ausgabe ist.
Beispiel 1.2.3:
Wenden wir uns jetzt einem etwas anwendungsbezogenerem Beispiel zu. Dieses Beispiel soll
zweierlei veranschaulichen:
(1) Obwohl die Ausdrucksmöglichkeiten der Sprache sehr rudimentär sind, reichen sie für
bestimmte Anwendungsgebiete aus.
(2) Es kann sehr vom Nutzen sein, die Sprache zu erweitern.
Abbildung 1 : Modell des Roboters aus Beispiel 1.2.3
links
rechts
auf
ab
öffne
schließe
Ein Roboter verfüge über die folgenden Operationen:
links dreht den Roboter um eine Winkeleinheit nach links
rechts dreht den Roboter um eine Winkeleinheit nach rechts
6HLWH

(LQOHLWXQJ
auf bewegt den Arm des Roboters um eine Längeneinheit nach oben
ab bewegt den Arm des Roboters um eine Längeneinheit nach unten
schließe schließt die Greifhand des Roboterarmes
öffne öffnet die Greifhand des Roboterarmes
Die Programmierung des Roboters geschieht in der Sprache WHILE gemäß Definition 1.2.1,
wobei wir als zusätzliche Anweisungen die Schlüsselworte links, rechts, auf, ab, schließe
und öffne zulassen.
Der Roboter erhalte folgende Aufgabe: a Holzklötzchen, die aufgetürmt an der Position (0)
liegen sollen auf die Positionen (1) - (a) verteilt werden, so daß auf jeder Position genau ein
Hölzchen zu liegen kommt. Zu Beginn befinde sich die Hand des Roboters an Position (0) auf
der untersten Ebene. Am Ende der Aufgabe soll die Hand wieder auf dieser Position
angekommen sein. Die Positionen sind alle nur eine Winkeleinheit voneinander entfernt, wobei
Position (0) die rechteste der Positionen ist. Die Höhe der Klötzchen beträgt eine
Längeneinheit.
Dann kann die Aufgabe durch das folgende Programm gelöst werden
input (a)
set (b := a)
set (c := 0)
--b
while a > 0 do
while b > 0 do
auf
--b
++c
end while
++c
schließe
while c > 0 do
links
--c
++b
end while
--b
while b > 0 do
ab
--b
++c
end while
++c
öffne
while c > 0 do
rechts
--c
++b
end while
--b
--b
--a
end while
output a
6HLWH

(LQOHLWXQJ
Auch hier ist die Korrektheit des Algorithmus' sofort einsichtig. Die äußere Schleife wird
genau so oft durchlaufen, wie Klötzchen vorhanden sind, wobei die Variable a bei jedem
Durchlauf um 1 vermindert wird.
Vor jedem Schleifendurchlauf ruht der Arm auf der untersten Ebene von Position (0). Dann
wird der Arm des Roboters um (a-1) Längenelemente nach oben bewegt, und die Hand ergreift
das oberste Element des Stapels. Dann bewegt sich der Arm um a Elemente nach links, um
sich um (a-1) Elemente zu senken, womit wieder die unterste Ebene erreicht wird. Die Hand
öffnet sich und das Element wird auf der Position (a) abgelegt. Dann bewegt sich der Arm a
Winkeleinheiten zum Ausgangspunkt.
1.3 Die Mächtigkeit der Sprache WHILE
'HILQLWLRQ
(LQH)XQNWLRQI© N →©KHL‰W:+,/(EHUHFKHQEDUZHQQHVHLQ:+,/(
3URJUDPP:JLEWVRGD‰I UMHGHV7XSHOQDW UOLFKHU=DKOHQQ Q N JLOW
:HQQIQ Q N ↓GDQQOLHIHUW:EHL(LQJDEHQ Q N GHQ:HUWIQ Q N
XQGZHQQIQ Q N ↑VROLHIHUW:NHLQHQ:HUW
'HILQLWLRQ
6HLIHLQH:+,/(EHUHFKHQEDUHNVWHOOLJH)XQNWLRQ6HL:HLQ:+,/(
3URJUDPPGD‰IEHUHFKQHW:KDEHIROJHQGH*HVWDOW
input (x 1 ,...,x k )
a 1
...
a n
output y
GDEHLVHLHQD D Q I UHLQQ∈©:+,/($QZHLVXQJHQ
'DQQKHL‰WGLH$QZHLVXQJVIROJHGHU*HVWDOW
set (x 1 ← x 1 ’)
set (x 2 ← x 2 ’)
...
set (x k ← x k ’)
a 1
...
a n
set (y’ ← y)
ZREHLGLH9DULDEOHQ[ [ N \QLFKWLQD D Q YRUNRPPHQ0DNURYRQIXQG
ZLUGDEJHN U]WGXUFK\←I[ [ N
6DW]
-HGHSULPLWLYUHNXUVLYH)XQNWLRQILVW:+,/(EHUHFKHQEDU
Beweis:
Wir zeigen durch Induktion über den Aufbau der Menge der primitiv rekursiven
Funktionen, daß jede primitiv rekursive Funktion auch WHILE-berechenbar ist.
(strukturelle Induktion)
Induktionsverankerung:
Konstantenfunktionen, Projektionsfunktionen und die Nachfolgerfunktion
sind WHILE-berechenbar.
6HLWH

(LQOHLWXQJ
1. Konstantenfunktionen:
Seien k und c beliebige natürliche Zahlen. Dann ist die k-stellige Funktion
constc: © k →©definiert durch constc (x1,...,xk) = c für alle natürliche Zahlen
x1,...,xk.
Dann wird constc durch das folgende WHILE-Programm berechnet:
input (x 1 ,..,x k )
set (y ← c)
output y
2. Projektionsfunktionen:
Seien k,i ∈© + mit i≤k. Dann ist die k-stellige Funktion proji: © k →©definiert
durch proji (x1,...,xk) = xi für alle natürliche Zahlen x1,...,xk.
Dann wird proji durch das folgende WHILE-Programm berechnet:
input (x 1 ,..,x k )
set (y ← x i )
output y
3. Nachfolgerfunktion:
Die einstellige Funktion succ: © →© ist definiert durch succ(x) = x + 1 für alle
x∈©. Sie wird durch das folgende WHILE-Programm berechnet:
input (x)
set (y ← x)
++y
output y
Induktionvoraussetzung:
Sei k∈© + und n∈© beliebig. Die primitiv rekursive Funktion g: © k →©,
h1,...,hk: © n →©, c: © k-1 →© und d: © k+1 →© seien WHILE-berechenbar.
Induktionsbehauptung:
1. Verkettung primitiv rekursiver Funktionen
Sei f: © n →© definiert durch f(x1,...,xn) =
g(h1(x1,...,xn),h2(x1,...,xn),...,hk(x1,...,xn)). Dann ist f WHILE-berechenbar.
2. Rekursion primitiv rekursiver Funktionen:
Sei r: © k →© definiert durch
r(x1,...,xk-1,0) = c(x1,...,xk)
r(x1,...,xk-1,i+1) = d(x1,..,xk,i+1,r(x1,..,,xk,i)) für alle i∈©.
Dann ist r WHILE-berechenbar.
Induktionsschluß:
1. Verkettung rekursiver Funktionen
Die Funktionen g und h1,...,hk sind nach Induktionsvoraussetzung WHILEberechenbar,
also können auch Makros von ihnen gebildet werden.
6HLWH

(LQOHLWXQJ
Das WHILE-Programm W sei folgendermaßen deklariert:
input (x 1 ,,...,x n )
z 1 ← h 1 (x 1 ,...,x n )
...
z k ← h k (x 1 ,...,x n )
y ← g(z 1 ,...,z k )
output y
Dabei seien x1,...,xn, z1,...,zk, y Variablen, die in den Programmen für g und
h1,...,hk nicht vorkommen.
Nach Definition 1.3.2 enthalten die Variablen z1,..,zk die Ausgaben der
WHILE-Programme für h1,...,hk für die Eingaben von W. Da die Variablen
z1,..,zk als Eingaben zum Makro von g dienen, wird der Variablen y
tatsächlich der Wert f(x1,..,xn) zugewiesen und als Ausgabe für W verwendet.
Also ist f WHILE-berechenbar.
2. Rekursion primitiv rekursiver Funktionen
Nach Induktionsvoraussetzung sind die Funktionen c und d WHILEberechenbar,
weswegen Makros von ihnen gebildet werden können. Nach
Induktionsverankerung sind die Projektionsfunktionen WHILE-berechenbar,
also können auch von ihnen Makros gebildet werden.
Definiere das WHILE-Programm W folgendermaßen, wobei x1,..,.xk,i,y und z
Variablen sind, die in den Programmen von c und d nicht vorkommen:
input (x 1 ,...,x k ,i)
y ← c(x 1 ,...,x k )
while i>0 do
z ← d(x 1 ,...,x k ,i,y)
y ← proj 1 (z)
--i
end while
output y
Wir wollen nun durch Induktion zeigen, daß W die Funktion r berechnet.
(vollständige Induktion über den Wert der Eingabevariablen i)
Induktionsverankerung für i=0:
Für i=0 wird die Schleife nicht durchlaufen, die Ausgabevariable y erhält
den Wert des Makros von c, d.h. für die Eingabe (x1,..,xk,0) liefert der
Algorithmus den Wert von r(x1,..,xk,0) = c(x1,..,xk).
Induktionsvoraussetzung:
Es sei nun i = m beliebig. Für die Eingabe (x1,..,xk,m) wird die Schleife m-
mal durchlaufen und nach dem letzten Schleifendurchlauf hat y den Wert
r(x1,..,xk,m).
Induktionsbehauptung:
6HLWH

(LQOHLWXQJ
Für die Eingabe (x1,..,xk,m+1) wird die Schleife (m+1)-mal durchlaufen und
y hat nach Beendigung des letzten Schleifendurchlaufs den Wert
r(x1,..,xk,m+1).
Induktionsschluß:
Die Variable i kommt in den Programmen der Funktionen c und d nicht
vor, genausowenig wie im Programm für proj1. Also ist die einzige
Anweisung, die i verändert, die Anweisung --i. Nach genau (m+1)
Schleifendurchläufen erreicht die Variable i damit den Wert 0 und die
Schleife wird verlassen.
Nach m Schleifendurchläufen hat die Variable y gemäß
Induktionsvoraussetzung den Wert r(x1,..,xk,m). Also wird im (m+1)-ten
Schleifendurchlauf der Variablen z der Wert d(x1,...,xk,m, r(x1,..,xk,m)) =
r(x1,..,xk,m+1) zugeordnet. Nach Auswertung der Projektionsfunktion
erhält y im (m+1)-ten Schleifendurchlauf den Wert r(x1,..,xk,m+1), der
dann auch ausgegeben wird, da die Schleife verlassen wird.
Nach Induktion berechnet W die Funktion r, die somit WHILE-berechenbar
ist.
6DW]
-HGHSDUWLHOOUHNXUVLYH)XQNWLRQLVW:+,/(EHUHFKHQEDU
Beweis:
Da wir bereits bewiesen haben, daß jede primitiv rekursive Funktion WHILEberechenbar
ist, genügt es zu zeigen, daß für eine gegebene primitiv rekursive
Funktion g: © k+1 →© (k∈©) auch die (partielle) Funktion f: © k →© WHILEberechenbar
ist, wobei f gegeben durch f(x1,...,xk) = minz (g(x1,..,xk,z)=0).
Dazu geben wir folgendes WHILE-Programm W an:
input (x 1 ,..,x n )
set (y ← 0)
w ← g(x 1 ,..,x k ,y)
while w > 0 do
++y
w ← g(x 1 ,..,x k ,y)
end while
output y
Die Variablen x1,..,xn,y und w kommen dabei im Programm für g nicht vor.
Seinen x1,..,xk jetzt beliebige natürliche Zahlen.
1. Fall: ∃z[g(x1,..,xk,z)=0]
Dann sei m = minz [g(x1,..,xk,z)=0] = f(x1,...,xk).
Für m = 0 ist g(x1,..,xk,0) = 0. Damit hat w vor dem ersten Schleifendurchlauf
den Wert 0 und die Schleife wird nicht betreten und der Wert y = f(x1,...,xk) wird
ausgegeben.
Sei nun m > 0. Dann wird die Schleife mindestens einmal betreten. Wir zeigen
zuerst, daß W mindestens m-1 Schleifendurchläufe benötigt.
6HLWH

(LQOHLWXQJ
Da m das Minimum ist, gilt folglich [z0]. Da y im Programm
von g nicht vorkommt, kann sein Wert auch nur in der Anweisung ++y
verändert werden. Da vor dem ersten Schleifendurchlauf y den Wert 0 hat,
kann y in m-1 Schleifendurchläufen nur den Wert m-1 annehmen. Für
y∈{0,..,m-1} ist aber g(x1,..,xk)>0. Dann erhält w bei jedem Schleifendurchlauf
einen Wert ungleich 0 und die Schleife kann nicht verlassen werden.
Im m-ten Schleifendurchlauf hat y als Engabe zum Makro von g den Wert m.
Da g(x1,...,xk,m) = 0, wird die Schleife mit dem Wert y = m verlassen und der
Wert m = f(x1,..,xk) ausgegeben.
2. Fall: [z[g(x1,..,xk,z)>0]
Dann gilt insbesondere g(x1,..,xk,0)>0, d.h. w hat vor der Schleife einen Wert
ungleich 0 und die Schleife wird betreten. Da w aber nie den Wert 0 erreichen
kann, kann die Schleife auch nicht verlassen werden. Also terminiert W nicht
und gibt deswegen auch keinen Wert aus.
Also berechnet W die Funktion f. Damit sind aber auch alle partiell rekursiven
Funktionen WHILE-berechenbar.
/HPPD
6HLΣHLQ$OSKDEHWXQGV _Σ_6HLFΣ→^V`HLQHELMHNWLYH$EELOGXQJ
'DQQH[LVWLHUWHLQHLQMHNWLYHWRWDOH:+,/(EHUHFKHQEDUH$EELOGXQJFRGHΣ
→©
Beweis:
Es genügt die Angabe einer Kodierungsfunktion. Definiere code durch:
k
c( σ i)
code(σ1...σk) = Π prim(i)
i=1
dabei liefert prim(i) die i-te Primzahl und σ1...σk ein Wort über Σ für ein k∈©.
code ist injektiv und total. Da code außerdem primitiv rekursiv ist, ist code nach
Satz 1.3.1 auch WHILE-berechenbar.
/HPPD
6HLΣHLQHQGOLFKHV$OSKDEHWXQGFRGHΣ→©HLQH.RGLHUXQJVIXQNWLRQ
'DQQLVWGLH)XQNWLRQGHFRGH©ò→ΣGHILQLHUWGXUFKGHFRGHFRGHσ σ N L
σ L I UDOOHσ σ N ∈ΣXQGL∈^N`:+,/(EHUHFKHQEDU
Beweis:
Sei code, prim und c wie im Beweis von Lemma 1.3.1. Definiere decode durch:
decode (n,i) = c -1 ( maxz [prim(i) z | n])
Sei σ1...σk und i∈{1,..,k} gegeben. Dann ist
code(σ1...σk) = Π
j=1
k
c(
prim(j)
σ j ) und
k
c(
prim(j)
decode (code(σ1...σk),i) = decode( Π
j=1
= c -1 (maxz [prim(i) z k
c( σ j
| Π prim(j)
) ])
j=1
= c -1 (max {z | z ≤ c(σi)}) = c -1 (c(σi)) = σi.
σ j ) ,i)
6HLWH

(LQOHLWXQJ
Die Funktion decode ist primitiv rekursiv und damit nach Satz 1.3.1 WHILEberechenbar.
/HPPD
6HLΣHLQ$OSKDEHWXQGFRGHΣ→©HLQH.RGLHUXQJVIXQNWLRQ'DQQLVWGLH
)XQNWLRQFKFRGH©ò×Σ→©GHILQLHUWGXUFKFKFRGHFRGHσ σ L σ L σ L σ N Lσ
FRGHσ σ L σσ L σ N I UDOOHσ σ N ∈ΣXQGL∈^N`:+,/(EHUHFKHQEDU
Beweis:
Sei code, prim und c wie im Beweis von Lemma 1.3.1. Definiere chcode durch:
n
c( σ )
chcode (n,i,σ) =
prim(i)
z
maxz[prim(i)
|n]
prim(i)
Sei σ1...σk,σ und i∈{1,..,k} gegeben. Dann ist
chcode (code(σ1...σk),i,σ) = chcode ( Π
j=1
=
=
=
k
prim(i)
k
Π prim(j)
j=1
prim(i)
Π prim(j)
c( σ )
j=1
k
z c( σj)
max [prim(i) | Π prim(j)
i
c( σ j )
c( σ i )
j=1
prim(i)
j
c( σ )
k
c( σ i )
c( σ )
( Π prim(j) ) prim(i)
j=1
j≠i
= code(σ1...σi-1σσi+1σk)
k
prim(i)
c(
prim(j)
c( σ )
σ j ) ,i,σ)
(nach Lemma 1.3.2)
Da chcode primitiv rekursiv, ist es nach Satz 1.3.1 auch WHILE-berechenbar.
'HILQLWLRQ
6HL[HLQH9DULDEOHXQGNHLQHQDW UOLFKH=DKO'DQQLVWGLHVZLWFK
$QZHLVXQJ
switch x
case 0: A 1
case 1: A 2
...
case k: A k
otherwise A
end switch
ZREHL$ $ N $)ROJHQYRQ:+,/($QZHLVXQJHQIROJHQGHUPD‰HQGHILQLHUW
6HLWH

(LQOHLWXQJ
set (y := x)
set (z := 1)
while y > 0 do // 0
--y
while y > 0 do // 1
--y
while y > 0 do // 2
...
while y > 0 do // k-1
--y
while y > 0 do // k
--z
y ← const 0
A
end while // k
end while // k-1
while z > 0 do // k-1*
--z
A k
end while // k-1*
...
end while // 2
while z > 0 do // 2*
--z
A 2
end while // 2*
end while // 1
while z > 0 do // 1*
--z
A 1
end while // 1*
end while // 0
while z > 0 do // 0*
--z
A 0
end while // 0*
'DEHLVHLHQ\XQG]9DULDEOHQGLHLQ$$ $ N QLFKWYRUNRPPHQ
/HPPD
%HLGHUVZLWFK$QZHLVXQJJHPl‰'HILQLWLRQZLUGJHQDXHLQHGHU
$QZHLVXQJVIROJHQ$ $ N $HLQPDODXVJHI KUWQlPOLFK$ L I U[ L
L∈^N`XQG$I U[!N
Beweis:
Nehmen wir zuerst an, es gelte x > k. In diesem Fall hat y vor der ersten
Schleife den Wert x > 0 und nach k-maligem Ausführen der Anweisung --y gilt
immer noch y > 0. Dann wird die mit k markierte Schleife betreten und die
Anweisungsfolge A gemäß der Behauptung ausgeführt. Da sowohl die Variable
y als auch die Variable z nach Ausführung der Anweisungsfolge A den Wert 0
haben, werden alle Schleifen verlassen und keine weitere Schleife betreten. Es
wird also nur eine Anweisungsfolge ausgeführt, nämlich die Anweisungsfolge A,
und auch diese nur einmal.
6HLWH

(LQOHLWXQJ
Sei nun x = i ≤ k. y hat vor dem ersten Schleifendurchlauf den Wert i und nach i-
maligem Ausführen der Anweisung --y den Wert 0. Somit wird die mit i+1
markierte Schleife nicht betreten. Da die Variable z aber den Wert 1 besitzt,
wird die mit i* markierte Schleife betreten und die Anweisungsfolge Ai
ausgeführt. Da nach Ausführung von Ai die Variablen x und z beide den Wert 0
haben, werden alle Schleifen verlassen und keine weitere Schleife betreten. Es
wird also nur eine einzige Anweisungsfolge ausgeführt, nämlich die
Anweisungsfolge Ai einmal.
'HILQLWLRQ
6HL[HLQH9DULDEOHXQG$XQG%)ROJHQYRQ:+,/($QZHLVXQJHQ'LHLI
$QZHLVXQJ
if x > 0 then
A
else
B
end if
VHLIROJHQGHUPD‰HQGHILQLHUW
switch x
case 0: B
otherwise A
end switch
/HPPD
%HLGHULI$QZHLVXQJJHPl‰'HILQLWLRQZLUGQXUHLQHGHUEHLGHQ
$QZHLVXQJHQ$XQG%DXVJHI KUWXQG]ZDUJHQDXHLQPDO,P)DOOH[!
ZLUGGLH$QZHLVXQJ$DXVJHI KUWLP)DOOH[ ZLUGGLH$QZHLVXQJ%
DXVJHI KUW
Beweis:
folgt direkt aus Lemma 1.3.4.
6DW]
-HGHGXUFKHLQH7XULQJPDVFKLQHEHUHFKHQEDUH)XQNWLRQLVWDXFK:+,/(
EHUHFKHQEDU
Beweis:
Wir führen den Beweis dadurch, daß wir zeigen, daß wir eine Turingmaschine
durch ein WHILE-Programm simulieren können.
6HLWH

(LQOHLWXQJ
Abbildung 2 : Struktur der simulierten Turingmaschine
Schreib-/Leseknopf
Ein-/
Ausgabeband
n Zustände
q 1 ,..,q n
Der Einfachheit halber beschränken wir uns auf eine Turingmaschine mit nur
einem halbseitig unendlichen Band. Am Anfangs der Auswertung stehe auf dem
Band nur die Eingabe, ansonsten sei das Band leer. Am Ende der Auswertung
steht das Ergebnis wieder auf dem Band.
Sei die Turingmaschine gegeben durch T = (Σ,B,b,Q,q0,QA,δ), wobei
Σ ein endliches Alphabet (Bandalphabet),
B ⊂ Σ das Eingabealphabet,
b ∈ Σ \ B das Leerzeichen
Q = {q0,...,qn} für ein n∈© eine endliche Menge von Zuständen.
q0 der Startzustand
QA ⊆ Q die Menge der Endzustände
δ : Q×Σ → Q×Σ×{L,R} eine Übergangsrelation.
Am Anfang stehe der Schreib-/Lesekopf der Turingmaschine auf dem ersten
Zeichen des Bandes und die Turingmaschine befindet sich im Zustand q0. Falls
((q,σ),(q',σ',L))∈δ, wechselt T, sofern die sich im Zustand q befindet und der
Schreib-/Leseknopf auf dem Symbol σ steht, in den Zustand q' über,
überschreibt das Symbol σ durch das Symbol σ' und bewegt den Schreib-
/Lesekopf um ein Zeichen nach links. Entsprechend würde für ((q,σ),(q',σ',R))∈δ
der Schreib-/Lesekopf um ein Zeichen nach rechts gesetzt werden.
Für die Simulation wollen wir das Ein-/Ausgabeband mittels der Funktion code
aus Lemma 1.3.1 in der Variablen x speichern, die als Eingabevariable und als
Ausgabevariable dient. Beim Aufruf des WHILE-Programmes wird der
Variablen x die Kodierung des Bandes mit den Eingabedaten übergeben, beim
Ende des Algorithmus' wird mit x die Kodierung des Bandes mit dem Ergebnis
übergeben. In der Variablen w speichern wir die Position des Bandes.
Zur Auswertung der Übergangsfunktion δ definieren wir die Funktionen nexts,
nextm und nextq folgendermaßen: Falls ((qi,σ),(qj,σ,L))∈δ, so ist nexts(i,c(σ)) =
c(σ), nextm(i,c(σ)) = 0 und nextq(i,c(σ)) = j, und falls ((qi,σ),(qj,σ,R))∈δ, so ist
nexts(i,c(σ)) = c(σ), nextm(i,c(σ)) = 1 und nextq(i,c(σ)) = j. Wenn (qi,σ) nicht Teil
der Relation δ, so soll der Funktionswert bei der Eingabe (i, c(σ)) undefiniert
6HLWH

(LQOHLWXQJ
sein. Da δ eine endliche Relation ist, sind diese Funktionen wohldefiniert, sogar
partiell rekursiv und damit WHILE-berechenbar.
Ebenfalls benötigen wir die Funktionen dc: ©²→© mit dc(x,y) = c(decode(x,y))
und cc: ©³→© mit cc(x,y,z) = chcode(x,y,c -1 (z)). Da diese Funktionen primitiv
rekursiv sind, existieren Makros von ihnen.
Das WHILE-Programm W sei dann folgendermaßen definiert:
input (x)
set (a := 1)
set (q := 0)
set (w := 1)
while a > 0 do
switch q
case 0 : W 0
case 1 : W 1
...
case n : W n
otherwise Fehler!
end switch
end while
output x
Dabei sind W0,...,Wn Anweisungsfolgen.
Sei qi für i∈{1,...,n} ein Zustand der Turingmaschine. Definiere eine
Anweisungsfolge Wi:
1. Fall: qi∈QA
Dann setze Wi auf:
--a
2. Fall: q i ∉Q A :
Dann setze W i auf:
set (s := 0)
set (y := 0)
set (n := 0)
set (m := 0)
s ← dc(x,w)
y ← nexts(q,s)
n ← nextq(q,s)
m ← nextm(q,s)
x ← cc(x,w,y)
if m > 0 then
++w
else
--w
end if
q ← proj 1 (n)
6HLWH

(LQOHLWXQJ
Der Zustand der Turingmaschine wird durch die Variable q repräsentiert.
Gemäß Lemma 1.3.4 wird in jedem Schleifendurchlauf der äußeren Schleife im
Programm W genau eine der Anweisungen W0,..,Wn ausgeführt, nämlich die
Anweisung Wq, denn wenn diese Variable wirklich nur Werte aus dem Intervall
[0,n] annimmt, kann der Fehlerfall im Programm W nicht auftreten Die äußere
Schleife, die in jedem Fall betreten wird, kann nur verlassen werden, wenn die
Variable a den Wert 0 annimmt.
Zu Beginn jeder der Anweisungsfolgen Wi (0≤i≤n) hat a den Wert 1. Der Wert
dieser Variablen wird nur verändert, wenn q die Nummer eines Endzustandes
ist, in diesem Fall erhält a den Wert 0 und das Programm W wird verlassen. Die
Ausgabe ist das kodierte Band.
Falls q nicht Nummer eines akzeptierenden Zustandes ist, wird die Variable a
nicht verändert. In die Variable s wird über das Makro dc der Code des Zeichens
auf der Position des Schreib-/Lesekopfes w auf dem durch die Variable x
kodierten Band gelesen. Falls (qq ,c -1 (s)) Element der Definitionsmenge von δ, so
liefern die Makros nestq, nexts und nextm folgende Werte, sofern ein
Folgezustand existiert: Das Makro nextq liefert die Nummer des nächsten
Zustandes, nexts liefert die Nummer des Zeichens, das auf die Position des
Schreib-/Lesezeigers zu schreiben ist und nextm liefert die Werte 0 oder 1, wobei
der Wert 0 für die Bewegung des Schreib-/Lesezeigers um ein Element nach
links und der Wert 1 für die Bewegung des Schreib-/Lesekopfes um ein Zeichen
nach rechts bedeutet. Die Ergebisse der Makros werden in die Variablen y,n,
und m geschrieben. Falls kein Folgezustand existiert, terminiert die Ausführung
der Makros nicht.
Das Makro cc ändert das Zeichen auf der Position w des Schreib-/Lesekopfes auf
das Zeichen mit dem Code s, also dem zu schreibenden Zeichen. Gemäß Lemma
1.3.5 wird die Variable w inkrementiert, wenn der Schreib-/Lesekopf um ein
Element nach links bewegt werden soll und dekremntiert, wenn der Schreib-
/Lesekopf um ein Element nach rechts bewegt werden soll. Als Wert der
Zustandsvariablen wird schließlich der Wert n übergeben, in dem tatsächlich
die Nummer des nächsten Zustandes gespeichert ist.
Damit ist gezeigt, daß das Programm W die Turingmaschine T simuliert. Falls
T terminiert, so terminiert auch W und liefert dasselbe Ergebnis wie T (für
dieselbe Eingabe). Damit berechnet W dieselbe Funktion, die auch W berechnet.
Da T beliebige Turingmaschine, ist auch jede beliebige auf einer
Turingmaschine berechenbare Funktion WHILE-berechenbar.
1.4 Ausführung von Programmen der Sprache WHILE auf einer
Registermaschine
Es bleibt die Frage, ob es überhaupt eine Maschine gibt, auf der WHILE-Programme ablaufen
können. Sicherlich wird es etwas schwierig (aber nicht unmöglich) sein, die Sprache WHILE
auf einer Turingmaschine zu implementieren. Wir führen statt dessen eine Registermaschine
ein, die den Begebenheiten real existierender Rechner näher kommt.
6HLWH

(LQOHLWXQJ
Abbildung 3 : Eine Registermaschine zur Implementation von WHILE-Programmen
Lesezeiger
Programmspeicher
Registersatz
PC
R0
R1
R2
Eingabeband
Schreibzeiger
Ausgabeband
Die Maschine besteht aus zwei einseitig unendlichen Bändern, das Eingabeband und das
Ausgabeband, auf denen natürliche Zahlen geschrieben werden können, und einer unendlichen
Zahl von Registern, die ebenfalls eine natürliche Zahl aufnehmen können. Eines dieser
Register ist ausgezeichnet, der Program Counter (PC). Außerdem beinhaltet die
Registermaschine einen Programmspeicher, in dem Maschinenbefehle stehen. Die
Maschinenbefehle des Programmspeichers sind durchnumeriert, dabei steht der erste Befehl an
der Adresse 0. Jede Adresse eines Maschinenbefehls im Programmspeicher kann mit einem
Label versehen werden. Jeder Label darf jedoch nur einmal verwendet werden. Der Wert des
Program Counters ist immer die Adresse des nächsten Befehls im Programmspeicher. Am
Anfang hat der PC den Wert 0. Der Lesezeiger steht auf dem ersten Element des
Eingabebandes und der Schreibzeiger steht auf dem ersten Element des Ausgabebandes.
Es sind folgende Befehle erlaubt:
Tabelle 1 : Die Befehle der Registermaschine
Befehl
Semantik
NOP erhöhe den Inhalt des PC um 1
READ r
Schreibe Eintrag vom Eingabeband in Register r, bewege Lesezeiger um
ein Element nach rechts; erhöhe Inhalt des PC um 1
WRITE r
Schreibe Inhalt des Registers r auf das Ausgabeband, bewege Lesezeiger
um ein Element nach rechts; erhöhe Inhalt des PC um 1
HALT
Programmende
INC r Erhöhe den Inhalt des Registers r um 1; erhöhe den Inhalt des PC um 1
DEC r
Falls der Inhalt des Registers r ist größer als 0, so erniedrige den Inhalt
des Registers r um 1; erhöhe den Inhalt des PC um 1
LOAD r,n Schreibe Zahl n in das Register r; erhöhe den Inhalt des PC um 1
LOAD r 1 ,r 2
Schreibe Inhalt des Registers r 2 in das Register r 1 ; erhöhe Inhalt des PC
um 1
JUMP l
Schreibe Adresse des Labels l in den PC
JUMPZ r,l
Falls der Inhalt des Registers r ist 0, so schreibe die Adresse des Labels l
in den PC, sonst erhöhe den Inhalt des PC um 1
6HLWH

(LQOHLWXQJ
6DW]
-HGHV:+,/(3URJUDPPNDQQDXIGHUREHQEHVFKULHEHQHQ5HJLVWHUPDVFKLQH
DXVJHI KUWZHUGHQ
Beweis:
Sei W ein beliebiges WHILE-Programm. Zuerst weisen wir jeder Variablen in W
ein Register der Registermaschine (jedoch nicht den Program Counter) zu. Als
abkürzende Schreibweise wollen wir für jede Variable x des Programmes mit
R(x) das der Variablen zugeordnete Register bezeichnen.
Das Programm im Programmspeicher der Registermaschine wird aus den
folgenden drei Teilen bestehen:
(1) Einlesen der Eingabe vom Eingabeband
(2) Auswertung der Anweisungen
(3) Schreiben der Ausgabe auf das Ausgabeband
Wenden wir uns jetzt den drei Schritten zu. Die angegebenen Maschinenbefehle
sollen der Reihe nach ab Adresse 0 hintereinander in den Programmspeicher
geschrieben werden.
(1) Einlesen der Eingabe von Eingabeband
Seien x1,..,xn für eine natürliche Zahl n die Eingabevariablen des Programmes.
Dann haben die ersten n Maschinenbefehle folgende Gestalt:
(0) READ R(x 1 )
(1) READ R(x 2 )
...
(n-1) READ R(x n )
(2) Auswertung der Anweisungen
Die Anweisungen des WHILE-Programmes werden nun der Reihe nach in
Maschinenbefehle überführt. Sei k die letzte Adresse des Programmspeichers, in
der ein Maschinenbefehl steht und a die als nächste zu übersetzende
Anweisung. Für die Anweisung a gibt es jetzt vier Möglichkeiten:
(i) a ist ein Inkrement
(ii) a ist ein Dekrement
(iii) a ist eine Initialisation
(iv) a ist eine Schleife
(i) a ist ein Inkrement, etwa ++v, wobei v eine Variable ist
Dann trage den Maschinenbefehl
(k+1)
INC R(v)
in die Speicherstelle k+1 ein.
(ii) a ist ein Dekrement, etwa --v, wobei v eine Variable ist
Dann trage den Maschinenbefehl
(k+1)
DEC R(v)
in die Speicherstelle k+1 ein.
6HLWH

(LQOHLWXQJ
(iii) a ist eine Initialisation, etwa
set (v := m)
Dabei ist v eine Variable und m entweder eine zweite Variable oder eine
natürliche Zahl.
Falls m ist eine weitere Variable, trage den folgenden Maschinenbefehl in die
Speicherstelle k+1 ein:
(k+1)
MOVE R(v),R(m)
Im Falle, daß es sich bei m um eine natürliche Zahl handelt, lautet der
entsprechende Maschinenbefehl:
(k+1)
MOVE R(v),m
(iv) a ist eine Schleife
Für eine Variable v und einer Folge von Anweisungen A habe die Schleife die
Gestalt:
while v > 0 do
A
end while
Dann wird diese Schleife folgendermaßen in eine Folge von Maschinenbefehlen
übersetzt: Seien L und M Labels, die im Rest des Maschinenprogrammes nicht
vorkommen. Trage den folgenden Maschinenbefehl in die Speicherstelle k+1 an
und markiere diese Speicherstelle mit dem Label L:
(k+1)
L:JUMPZ R(v),M
Danach übersetze die Anweisungsfolge A und trage die entsprechenden
Maschinenbefehle in die Speicherstellen ab Adresse k+2 ein. Die letzte von der
Anweisungsfolge A in Anspruch genommene Speicherstelle sei l. Trage die
folgende Anweisung in die Speicherstellen (l+1) und (l+2) ein:
(l+1)
(l+2)
JUMP L
M:NOP
(3) Schreiben der Ausgabe auf das Ausgabeband
Die letzte von einer Anweisung belegte Speicherstelle sei r und die
Ausgabevariable sei y. Die letzten Anweisungen des Maschinenprogramms
lauten an den Speicherstellen (r+1) und (r+2):
(r+1)
(r+2)
WRITE R(y)
HALT
Es ist sofort zu sehen, daß das beschriebene Maschinenprogramm völlig analog
dem WHILE-Programm W abläuft. Damit berechnet die Registermaschine aber
dieselbe Funktion wie W. Da W beliebig gewählt wurde, ist die
Registermaschine in der Lage, jedes WHILE-Programm auszuführen und damit
jede WHILE-berechenbare Funktion zu berechnen.
6HLWH

(LQOHLWXQJ
1.5 Übersicht über die weiteren Kapitel
Obwohl wir gezeigt haben, daß WHILE-Programme nach Definition 1.2.1 die Mächtigkeit der
Turingmaschine besitzen, haben wir in Abschnitt 1.2 und Abschnitt 1.3 gesehen, daß
Erweiterungen des Sprachumfanges, wie z.B. weitere Kontrollstrukturen, Makroaufrufe und
prozedurale Aufrufe mit Seiteneffekten, die Ausdrucksfähigkeit der Sprache erhöhen können.
Fügen wir eine weitere Erweiterung hinzu:
'HILQLWLRQ
6HLαHLQEHOLHELJHU0DNRUDXIUXIXQG$HLQHEHOLHELJH$QZHLVXQJVVHTXHQ]
'DQQZLUGGLH$QZHLVXQJ
while α do
A’
end while
DOV$EN U]XQJI UGLH$QZHLVXQJVIROJH
v ← α
while v > 0 do
A’
end while
'DEHLLVWYHLQHEHOLHELJH9DULDEOHGLHLQ$QLFKWYHUZHQGHWZLUGαKHL‰W
GDQQ$XVGUXFNGHU6FKOHLIH
Diese und andere Erweiterungen der Sprache sollte ein Synthesealgorithmus verstehen können,
weswegen die Definition 1.2.1 für Programme vom praktischen Interesse zu eingeschränkt in
der Syntax ist. Hinzu kommt, daß die Definition 1.2.1 viel zu unpräzise für eine
Implementierung einen Compiler der Sprache WHILE ist (die wenigsten Computersysteme
haben ein intuitives Verständnis einer Variablen). Auch die Auswertungen von WHILE-
Programmen nach Definition 1.2.2 lassen sich schwerlich als Eingabe für einen
Synthesealgorithmus nutzen. Wir benötigen also für die Algorithmen auf die Problemstellung
angepaßte Definitionen von Programm und Beispielauswertung.
In Kapitel 2 werden wir eine sehr freizügigen Definition der Sprache WHILE und des Begriffs
eines (WHILE-) Programmes konstruieren, die sich aber als Eingabe für einen Compiler
verwenden läßt. Es wird auf den ersten Blick überraschen, daß in diesem Kapitel nur die
Syntax von Programmen erläutert wird, nicht aber deren Semantik. Dies hat den Grund, daß
sowohl die Erzeugung von Beispielauswertungen als auch die Programmsynthese auf einer
syntaktischen Ebene ablaufen. Es ist daher nicht notwendig, die Bedeutung der verwendeten
Sprachmittel mehr als nötig festzulegen. Soweit dies nötig ist (z.B. Werte von Variablen),
wird eine indirekte Festlegung bei der Definition der Beispielauswertungen gegeben. Durch die
große Freizügigkeit der Syntax der Sprache und die nicht näher definierte Semantik wird dem
Anwender des Werkzeuges die Möglichkeit gegeben die Sprache WHILE auf seine
Bedürfnisse anzupassen.
Kapitel 3 dient zur Einführung in den Begriff der Beispielauswertung. Beispielauswertungen
werden in einer Sprache repräsentiert, die der Sprache WHILE sehr ähnelt, wodurch zum
einen die Lesbarkeit und die Erstellung der Beispielauswertungen und zum anderen auch die
Synthese vereinfacht wird.
6HLWH

(LQOHLWXQJ
In Kapitel 4 wird ein Algorithmus zur automatischen Generierung von Beispielauswertungen
angegeben. Kapitel 5 folgt dann mit der Präsentation eines Algorithmus' zur automatischen
Programmsynthese. Dabei wird die Menge der WHILE-Programme auf eine Teilmenge
reduziert, für die die Synthese besonders leicht zu bewerkstelligen ist, die Klasse-I-
Programme. In Kapitel 6 wird die Bedeutung der Einschränkungen, die durch die
Beschränkung auf Klasse-I-Programme diskutiert entsteht, diskutiert und es werden Ansätze
zur Erweiterung der Lernpotenz angesprochen.
Die Kapitel 7 bis 10 beschäftigen sich mit der Implementierung der vorgestellten Algorithmen
auf verschiedenen Rechnern, wobei insbesondere auf die Spezifikation der Komponenten des
Programmes und die genaue Beschreibung der Benutzerschnittstelle eingegangen wird. Das
entstanden Werkzeug trägt den Namen [VDPSOH Version 2.0.
Das Kapitel 11 zeigt einige Beispiele für WHILE-Programme und Beispielauswertungen, die
als Eingabe für [VDPSOH verwendet wurden und demonstriert an den Ausgaben von [VDPSOH
die Funktionsweise der Algorithmen. Im abschließenden Kapitel 12 werden zusammenfassend
und ausblickend die erzielten Ergebnisse diskutiert.
6HLWH

'LH6SUDFKH:+,/(
2 Die Sprache WHILE
Da die Definition 1.2.1 aus dem vorangegangenem Kapitel für eine dem Problem
entsprechende Repräsentation der Sprache WHILE nicht genügt, wollen wir uns in diesem
Kapitel genauer dem Aufbau von WHILE-Programmen dienen. Die Definition soll sich nur
auf die für die Programmsynthese absolut notwendigen Elemente beschränken. Deswegen
wurde die Syntax sehr allgemein gehalten, wodurch dem Benutzer des Werkzeuges sehr große
Möglichkeiten offenstehen, die Sprache auf sein Problem anzupassen. Aus diesem Grund
wurde auch keine Semantik der Sprache angegeben. Es besteht jedoch immer die Möglichkeit,
die in Kapitel 1 angegebene Semantik zu verwenden, sofern man die Syntax der Sprache
wieder etwas einschränkt.
Der Rest des Kapitels beschäftigt sich mit einer Definition eines WHILE-Programmes. Die
hier verwendeten Definitionen für Variable und Programm mögen überraschen, sie sind aber
für einen rein syntaktischen Ansatz notwendig.
Zeichenvorrat
Das zugrundeliegende Alphabet muß folgende Klassen von Zeichen beinhalten:
w Buchstaben : a b c … A B C …
Kleinbuchstaben und Großbuchstaben werden unterschieden.
w Ziffern : 0 1 …
w Trennzeichen : Leerzeichen, Tabulatorzeichen, Zeilenendezeichen
w Sonderzeichen : + - * / ...
Folgende Zeichen sind sowohl Sonderzeichen als auch werden sie zum Sprachaufbau
benötigt:
+ – ( ) , : = "
w Schlüsselworte : input output while do with end set test skip
2.2 Syntax
Zur Angabe der Syntax der Sprache WHILE wird die Erweiterte Backus-Naur-Form (EBNF)
verwendet. Dabei sind die Terminale durch Unterstreichung oder durch das Einschließen in
Anführungszeichen ("") gekennzeichnet. Die Schreibweise {a} steht für die n-malige
Konkatenation von a, wobei n∈© beliebig, d.h. ε (nichts) oder a oder aa oder aaa usw. Die
Schreibweise [a] steht für die null- oder einmalige Konkatenation von a, d.h. ε oder a.
Tabelle 2 : Die Syntax der Sprache WHILE
3URJUDPPWH[W
(LQJDEHNRQVWUXNW
,QLWLDOLVDWLRQVVHTXHQ]
,QLWLDOLVDWLRQVNRQVWUXNW
%H]HLFKQHU
=DKO
$XVJDEHNRQVWUXNW
$QZHLVXQJVVHTXHQ]
$QZHLVXQJ
(LQIDFK$QZHLVXQJ
6WULQJ
,QNUHPHQW
'HNUHPHQW
ZKLOH.RQVWUXNW
$XVGUXFN
(LQJDEHNRQVWUXNW,QLWLDOLVDWLRQVVHTXHQ]$QZHLVXQJVVHTXHQ]$XVJDEHNRQVWUXNW
"input" "("Ã>%H]HLFKQHU^","%H]HLFKQHU`@")"
^,QLWLDOLVDWLRQVNRQVWUXNW`
"set" "(" %H]HLFKQHU":=" %H]HLFKQHU_=DKO")"
%XFKVWDEH^%XFKVWDEH_=LIIHU`
=LIIHU^=LIIHU`
"output"%H]HLFKQHU
^$QZHLVXQJ`
(LQIDFK$QZHLVXQJ_,QNUHPHQW_'HNUHPHQW_ZKLOH.RQVWUXNW
%H]HLFKQHU_=DKO_6WULQJ_6RQGHU]HLFKHQ
^=LIIHU%XFKVWDEH6RQGHU]HLFKHQ7UHQQ]HLFKHQ`
"++"%H]HLFKQHU
"--"%H]HLFKQHU
"with",QLWLDOLVDWLRQVVHTXHQ]"while"$XVGUXFN"do"
$QZHLVXQJVVHTXHQ]"end while"
^(LQIDFK$QZHLVXQJ`
6HLWH

'LH6SUDFKH:+,/(
Es gelten zusätzlich folgende Regeln:
ì Ein Bezeichner muß verschieden von jedem Schlüsselwort sein.
ì Folgen zwei Bezeichner direkt aufeinander, so muß zwischen ihnen ein Trennzeichen
stehen.
ì Folgen zwei Schlüsselworte direkt aufeinander, so muß zwischen ihnen ein Trennzeichen
stehen.
ì Folgen ein Bezeichner und ein Schlüsselwort direkt aufeinander oder umgekehrt, so muß
zwischen ihnen ein Schlüsselwort stehen.
ì Folgen ein Bezeichner bzw. ein Schlüsselwort und eine Zahl direkt aufeinander, so muß ein
Trennzeichen zwischen ihnen stehen.
ì Sollen einem Bezeichner, der nicht Teil eines Inkrementes oder Dekrementes ist, eine der
Zeichenfolgen "++" oder "--" vorangehen, so muß ein Trennzeichen dazwischen stehen.
ì Trennzeichen dürfen nicht innerhalb von Schlüsselworten, Bezeichnern, Inkrementen und
Dekrementen stehen. Innerhalb der Zeichenkombination := in einem
Initialisationskonstrukt sind Trennzeichen nicht zugelassen.
ì Innerhalb eines Strings sind alle Zeichen des Zeichenvorrats mit Ausnahme des Zeichens "
zugelassen. Sie haben dann keine syntaktische Bedeutung.
ì Ansonsten dürfen Trennzeichen beliebig stehen.
ì Steht innerhalb einer Zeile die Zeichenkombination "//", so werden alle Zeichen
beginnend mit dem ersten Vorkommen der Zeichenkombination "//" in der Zeile bis zum
Ende der Zeile überlesen.
Bezeichnung:
Sei "set (x := y)" ein Initialisationskonstrukt. Dann heißt x linke Seite und y rechte
Seite.
2.3 Programme
'HILQLWLRQ
(LQH=HLFKHQIROJHGHU6SUDFKH:+,/(GLHVLFKQDFKRELJHU*UDPPDWLN]XP
6WDUWV\PEROUHGX]LHUHQOl‰WKHL‰W3URJUDPPWH[W
'HILQLWLRQ
'LH$QZHLVXQJVVHTXHQ]$HLQHV3URJUDPPWH[WHV3DX‰HUKDOEMHGHV
ZKLOH.RQVWUXNWHVKHL‰W+DXSWDQZHLVXQJVVHTXHQ]YRQ3(LQH
$QZHLVXQJLQQHUKDOEYRQ$GLHQLFKW7HLOHLQHVZKLOH.RQVWUXNWHVLVW
KHL‰WORNDOH$QZHLVXQJYRQ3
'LHJU|‰WH$QZHLVXQJVVHTXHQ]%LQQHUKDOEHLQHVZKLOH.RQVWUXNWHV:
GLHDOVRQLFKWLQQHUKDOEHLQHVZHLWHUHQZKLOH.RQVWUXNWHVNOHLQHUDOV:
OLHJWKHL‰W+DXSWDQZHLVXQJVVHTXHQ]YRQ:(LQH$QZHLVXQJLQQHUKDOE
YRQ%GLHQLFKW7HLOHLQHVZHLWHUHQZKLOH.RQVWUXNWHVLVWNOHLQHUDOV:LVW
KHL‰WORNDOH$QZHLVXQJYRQ:
'HILQLWLRQ
(LQ%H]HLFKQHU[KHL‰W(LQJDEHYDULDEOHLQHLQHP3URJUDPPWH[W3ZHQQ[
LP(LQJDEHNRQVWUXNWYRQ3JHQDXHLQPDOYRUNRPPW'LHJHRUGQHWH0HQJH
DOOHU(LQJDEHYDULDEOHQLQGHU5HLKHQIROJHLKUHV$XIWUHWHQVLP
(LQJDEHNRQVWUXNWYRQ3ZLUGDOV(93JHVFKULHEHQ
6HLWH

'LH6SUDFKH:+,/(
'HILQLWLRQ
6HL3HLQ3URJUDPPWH[WXQG.HLQ,QLWLDOLVDWLRQVNRQVWUXNW
.KHL‰WJOREDOHV,QLWLDOLVDWLRQVNRQVWUXNWZHQQ.YRUGHU
+DXSWDQZHLVXQJVVHTXHQ]YRQ3VWHKW
6HL:HLQZKLOH.RQVWUXNWLQ3.KHL‰WORNDOHV,QLWLDOLVDWLRQVNRQVWUXNW
YRQ:IDOOV.LQ:YRUGHU+DXSWDQZHLVXQJVVHTXHQ]YRQ:VWHKW
'HILQLWLRQ
(LQ%H]HLFKQHU[KHL‰WJOREDOH9DULDEOHLQHLQHP3URJUDPPWH[W3ZHQQHV
JHQDXHLQJOREDOHV,QLWLDOLVDWLRQVNRQVWUXNW.JLEWVRGD‰
[NRPPWLQ.YRU
[VWHKWQXUDXIGHUOLQNHQ6HLWHYRQ.
[NRPPWQLFKWLP(LQJDEHNRQVWUXNWYRU
.KHL‰WGDQQ,QLWLDOLVDWLRQVNRQVWUXNWYRQ['LH0HQJHDOOHUJOREDOHQ
9DULDEOHQLQ3ZLUGDOV*93JHVFKULHEHQ
'HILQLWLRQ
6HL:HLQZKLOH.RQVWUXNWLQQHUKDOEHLQHV3URJUDPPWH[WHV3(LQ
%H]HLFKQHU[KHL‰WORNDOH9DULDEOH]X:ZHQQHVJHQDXHLQORNDOHV
,QLWLDOLVDWLRQVNRQVWUXNW.YRQ:JLEWVRGD‰
[NRPPWLQ.YRU
[VWHKWQXUDXIGHUOLQNHQ6HLWHYRQ.
[NRPPWLQ3QLFKWDX‰HUKDOEYRQ:YRU
.KHL‰WGDQQ,QLWLDOLVDWLRQVNRQVWUXNWYRQ['LH0HQJHDOOHUORNDOHQ
9DULDEOHQYRQ:ZLUG/9:JHVFKULHEHQ
'HILQLWLRQ
6HL3HLQ3URJUDPPWH[W(LQ%H]HLFKQHU[KHL‰W3URJUDPPYDULDEOHYRQ3
ZHQQ[HQWZHGHUJOREDOH9DULDEOHYRQ3RGHUORNDOH9DULDEOHHLQHVZKLOH
.RQVWUXNWHVLQQHUKDOEYRQ3LVW
/HPPD
6HL3HLQ3URJUDPPWH[WXQGYHLQH3URJUDPPYDULDEOH'DQQOLHJWGDVHUVWH
9RUNRPPHQYRQYLQLKUHP,QLWLDOLVDWLRQVNRQVWUXNWDXIGHUOLQNHQ6HLWH
Beweis:
Sei v globale Variable. Da nach Definition 2.3.5 nicht im Eingabekonstrukt
vorkommt und es genau ein globales Initialisationskonstrukt gibt, in dem v
vorkommt und dies ihr Initialisationskonstrukt ist, muß dies ihr erstes
Vorkommen sein. v darf nur auf der linken Seite ihres Initialisationskonstruktes
vorkommen.
Sei v lokale Variable zu einem while-Konstrukt W. v darf nach Definition 2.3.6
nicht außerhalb von W vorkommen. Es gibt aber auch nur ein
Inititialisationskonstrukt, in dem v vorkommen kann, nämlich ihr
Initialisationskonstrukt. Also liegt ihr erstes Vorkommen in ihrem
Initialisationskonstrukt und v darf nur auf der linken Seite stehen.
6HLWH

'LH6SUDFKH:+,/(
'HILQLWLRQ
(LQ%H]HLFKQHU[KHL‰W9DULDEOHLQHLQHP3URJUDPPWH[W3ZHQQ[HQWZHGHU
(LQJDEHYDULDEOHRGHU3URJUDPPYDULDEOHLVW(LQ%H]HLFKQHU[KHL‰W
+DXSWYDULDEOHLQHLQHP3URJUDPPWH[W3ZHQQ[HQWZHGHU(LQJDEHYDULDEOH
RGHUJOREDOH9DULDEOHLVW
'HILQLWLRQ
(LQ%H]HLFKQHUGHUQLFKW9DULDEOHLVWKHL‰W:RUW
Beispiel 2.3.1:
Gegeben sei folgender Programmtext P:
input(a,b)
set(x:=a)
set(y:=3)
set(z:=4)
h
y
0
with
while do
x
0
with
set(c:=3)
while do
z
d
0
end while
end while
output y
Das Beispiel hat folgende Bezeichner : a,b,x,y,z,h,c,d.
Davon sind
ì Eingabevariablen: a,b
ì Programmvariablen: x,y,z,c
ì globale Variable zu P: x,y,z
ì lokale Variable zum ersten while-Konstrukt: -
ì lokale Variablen zum zweiten while-Konstrukt: c
ì Worte: d,h
Man beachte hierbei, daß die Variable c außerhalb ihres Initialisationskonstruktes nicht
vorkommt.
Es mag überraschen, daß für die while-Konstrukte kein Ausdruck angegeben ist. Dies ist aber
unserer Grammatik nicht notwendig. Eine mögliche Semantik für ein solches Konstrukt ist
eine Endlosschleife.
6HLWH

'LH6SUDFKH:+,/(
'HILQLWLRQ
6HL3HLQ3URJUDPPWH[W
(LQH=DKOFLQGHU+DXSWDQZHLVXQJVVHTXHQ]YRQ3KHL‰WJOREDOH
.RQVWDQWHZHQQFLQNHLQHPZKLOH.RQVWUXNWOLHJW
6HL:HLQZKLOH.RQVWUXNWLQ3(LQH=DKOFKHL‰WORNDOH.RQVWDQWHYRQ:
ZHQQFLVWORNDOH$QZHLVXQJ
(LQH=DKOFKHL‰W3URJUDPPNRQVWDQWHZHQQFLVWJOREDOHRGHUORNDOH
.RQVWDQWH
(LQH.RQVWDQWHLQQHUKDOEHLQHV,QLWLDOLVDWLRQVNRQVWUXNWHVKHL‰W
,QLWLDOLVDWLRQVNRQVWDQWH
Bemerkung:
a) Im Gegensatz zu Variablen kann eine Zahl in Programmen als lokale Konstante zu
mehreren while-Konstrukten, als globale Konstante und/oder als Initialisationskonstante
auftreten.
b) Punkt 2 verbietet nicht, daß c in einem while-Konstrukt kleiner W vorkommt. Es wird aber
verlangt, daß c mindestens einmal außerhalb eines kleineren while-Konstruktes vorkommt.
Beispiel 2.3.2:
In Beispiel 2.3.1 tritt die Zahl 0 sowohl als globale Konstante, als auch als lokale Konstante
zu beiden while-Konstrukten auf. Die Zahlen 3 und 4 treten als Initialisationskonstanten auf.
'HILQLWLRQ
(LQ3URJUDPPWH[W3KHL‰W3URJUDPPZHQQMHGHU%H]HLFKQHU
LP(LQJDEHNRQVWUXNW
LP$XVJDEHNRQVWUXNW
LQHLQHP,QLWLDOLVDWLRQVNRQVWUXNW
LQHLQHP,QNUHPHQW
LQHLQHP'HNUHPHQW
HLQH9DULDEOHLVW
'HILQLWLRQ
(LQH7HLO]HLFKHQIROJH)DXVGHU$QZHLVXQJVVHTXHQ]HLQHV3URJUDPPHV3
KHL‰W3URJUDPPIUDJPHQWZHQQMHGHVZKLOH.RQVWUXNWGDVWHLOZHLVHLQ)
HQWKDOWHQLVWDXFKYROOVWlQGLJLQ)HQWKDOWHQLVW
Beispiel 2.3.4:
Folgender Programmtext ist ein Programm P:
input (x)
set (y := 3)
++y
z
with
set (w := x)
while do
--w
d
end while
output y
6HLWH

'LH6SUDFKH:+,/(
Folgende Zeichenfolge ist ein Programmfragment von P:
z
with
set (w := x)
while do
--w
d
end while
'HILQLWLRQ
6HL)HLQ3URJUDPPIUDJPHQW'LH6FKDFKWHOXQJVWLHIH')LVWUHNXUVLY
GHILQLHUWGXUFK
(QWKlOW)NHLQZKLOH.RQVWUXNWVRLVW')
$QVRQVWHQVHLGGDV0D[LPXPGHU6FKDFKWHOXQJVWLHIHQ
$QZHLVXQJVVHTXHQ]HQDOOHUZKLOH.RQVWUXNWHLQ)6HW]H') G
'HILQLWLRQ
6HL)HLQ3URJUDPPIUDJPHQW'LH=DKOGHUORNDOHQZKLOH.RQVWUXNWHYRQ)
ZLUGPLW:)EH]HLFKQHW
6HLWH

%HLVSLHODXVZHUWXQJHQ
3 Beispielauswertungen
In diesem Kapitel wird der Begriff der Beispielauswertung eingeführt Dabei ist eine
Beispielauswertung eine Beschreibung des Ablaufs eines Programmes. Das Kapitel
beschäftigt sich weiterhin mit der Definition und Analyse äquivalenter Programme, die sich
nicht in ihren Beispielauswertungen unterscheiden. Diese Definition ist von grundlegender
Bedeutung, da zwei äquivalente Programme nach ihrer Auswertung nicht unterschieden
werden können. Jeder auf Beispielauswertungen basierender Synthesealgorithmus wird in der
Regel nicht in der Lage sein, ein bestimmtes Programm einer Äquivalenzklasse zu
rekonstruieren, sondern nur ein zu diesem äquivalenten Programm. Die in diesem Kapitel
aufgeführten Lemmata werden sich bei der Diskussion des Synthesealgorithmus' als nützlich
erweisen.
3.1 Entfaltungen
'HILQLWLRQ
6HL)HLQEHOLHELJHV3URJUDPPIUDJPHQW(LQH=HLFKHQIROJH( ()KHL‰W
(QWIDOWXQJYRQ)ZHQQJLOW
) U') JLOWDXFK( )
(VVHL)HLQZKLOH.RQVWUXNW:GHU*HVWDOW
with
A
while B do C end while
'DEHLVHL$HLQH)ROJHYRQ,QLWLDOLVDWLRQVNRQVWUXNWHQ%HLQ$XVGUXFNXQG&
HLQH$QZHLVXQJVVHTXHQ]'DQQH[LVWLHUWHLQHQDW UOLFKH=DKOQ!XQG
(QWIDOWXQJHQ& & Q YRQ&VRGD‰(KDWHQWZHGHUGLH)RUP
with
A
test B do C' 1 end test
test B do C' 2 end test
...
test B do C' n end test
RGHUGLH)RUP
with
A
test B do C' 1 end test
test B do C' 2 end test
...
test B do C' n end test
test B skip
(VVHL) *+XQG( *+ZREHL*LVW(QWIDOWXQJYRQ*XQG+LVW
(QWIDOWXQJYRQ+
'HILQLWLRQ
6HL3HLQ3URJUDPP'DQQHQWVWHKWHLQH(QWIDOWXQJYRQ3(3GXUFK
(UVHW]HQGHU+DXSWDQZHLVXQJVVHTXHQ]$YRQ3GXUFK($
6HLWH

%HLVSLHODXVZHUWXQJHQ
Beispiel 3.1.1:
Sei P gegeben durch
input (x,y)
a
with
while b do
c
with
while d do e end while
f
end while
output x
So ist die folgende Zeichenfolge eine Entfaltungen von P
input (x,y)
a
with
test b do
c
with
test d do e end test
test d do e end test
test d do e end test
test d do e end test
test d do e end test
test d skip
f
end test
test b do
c
test d do e end test
test d do e end test
test d skip
f
end test
test b do
c
test d do e end test
test d do e end test
f
end test
test b skip
output x
'HILQLWLRQ
6HL)HLQ3URJUDPPIUDJPHQW(HLQH(QWIDOWXQJYRQ)XQGYHLQH9DULDEOH
YRQ)'DQQZLUGGLH=DKOGHU9RUNRPPHQGHU9DULDEOHQYLQ(PLW9Y(
EH]HLFKQHW
6HLWH

%HLVSLHODXVZHUWXQJHQ
3.2 Strukturäquivalenz
'HILQLWLRQ
6HLHQ)XQG*3URJUDPPIUDJPHQWH)XQG*KHL‰HQVWUXNWXUlTXLYDOHQW
ZHQQ
') XQG'* RGHU
')!'*!:) :*XQGI UMHGHVL∈^:)`VLQGGLH
$QZHLVXQJVVHTXHQ]GHVLWHQZKLOH.RQVWUXNWHVYRQ)XQGGLH
$QZHLVXQJVVHTXHQ]GHVLWHQZKLOH.RQVWUXNWHVYRQ*VWUXNWXUlTXLYDOHQW
'HILQLWLRQ
6HLHQ3XQG43URJUDPPH3XQG4KHL‰HQVWUXNWXUlTXLYDOHQWZHQQLKUH
+DXSWDQZHLVXQJVVHTXHQ]HQVWUXNWXUlTXLYDOHQWVLQG
Beispiel 3.2.1:
Folgende Programme sind strukturäquivalent:
input (x)
set (u := 6)
a
b
with
while c do
x
with
while do
5
end while
f
end while
output u
input (r,s,t)
with
set (x := r)
set (y := s)
while x < y do
with
set (z := 3)
while z do
end while
end while
write "fertig"
output t
6HLWH

%HLVSLHODXVZHUWXQJHQ
'HILQLWLRQ
6HLHQ)XQG*VWUXNWXUlTXLYDOHQWH3URJUDPPIUDJPHQWHXQGVHL' ()XQG
( (*'XQG(KHL‰HQVWUXNWXUlTXLYDOHQWZHQQ
') XQG'*
')!XQG'*!XQGI UMHGHVL∈^:)`JLOW
:HQQGDVLWHZKLOH.RQVWUXNW: L) YRQ)GLH(QWIDOWXQJ
with
A F
test B F do C’ F1 end test
test B F do C’ F2 end test
...
test B F do C’ Fn end test
E]ZGLH(QWIDOWXQJ
with
A F
test B F do C’ F1 end test
test B F do C’ F2 end test
...
test B F do C’ Fn end test
test B F skip
EHVLW]WVREHVLW]WGDVLWHZKLOH.RQVWUXNW: L* GLH(QWIDOWXQJ
with
A G
test B G do C’ G1 end test
test B G do C’ G2 end test
...
test B G do C’ Gn end test
E]ZGLH(QWIDOWXQJ
with
A G
test B G do C’ G1 end test
test B G do C’ G2 end test
...
test B G do C’ Gn end test
test B G skip
GDEHLVLQG$ ) XQG$ * GLHORNDOHQ,QLWLDOLVDWLRQVVHTXHQ]HQYRQ: L) XQG: L* % )
XQG% * GLH$XVGU FNHYRQ: L) XQG: L* XQGI UHLQHQDW UOLFKH=DKOQ
& ) & )Q GLH(QWIDOWXQJHQGHU$QZHLVXQJVVHTXHQ]YRQ: L) LQ'XQG
& * & *Q GLH(QWIDOWXQJHQGHU$QZHLVXQJVVHTXHQ]YRQ: L* LQ(ZREHL
]XVlW]OLFKJLOWGD‰I UMHGHVM∈^Q`& )M XQG& *M VWUXNWXUlTXLYDOHQWVLQG
6HLWH

%HLVSLHODXVZHUWXQJHQ
'HILQLWLRQ
6HLHQ3XQG43URJUDPPHXQGVHLHQ' (3XQG( (4ZREHL'XQG(
GLH(QWIDOWXQJHQGHU+DXSWDQZHLVXQJVVHTXHQ]HQYRQ3XQG4VLQG'DQQ
KHL‰HQ'XQG(VWUXNWXUlTXLYDOHQWZHQQ'XQG(VWUXNWXUlTXLYDOHQW
Beispiel 3.2.2:
Seien P und Q die Programme aus Beispiel 3.2.1. Dann sind folgende Entfaltungen von P und
Q strukturäquivalent:
input (x)
set (u := 6)
a
b
with
test c do
x
with
test do
5
end test
test do
5
end test
test do
5
end test
test skip
f
end test
test c do
x
with
test do
5
end test
test do
5
end test
f
end test
test c skip
output u
input (r,s,t)
with
set (x := r)
set (y := s)
test x < y do
with
set (z := 3)
test z do
end test
test z do
end test
test z do
6HLWH

%HLVSLHODXVZHUWXQJHQ
end test
test z skip
end test
test x < y do
with
set (z := 3)
test z do
end test
test z do
end test
end test
test x < y skip
write "fertig"
output t
/HPPD
6HLHQ)XQG*VWUXNWXUlTXLYDOHQWH3URJUDPPIUDJPHQWH'DQQJLOW')
'*
Beweis:
(vollständige Induktion über D(F))
Induktionsverankerung:
Für D(F) = 0 muß nach Definition auch gelten D(G) = 0.
Induktionsvoraussetzung
Für D(F) = n gilt auch D(G) = n.
Induktionsbehauptung:
Für D(F) = n+1 gilt auch D(G) = n+1.
Induktionsschluß:
Sei A die Hauptanweisungssequenz eines lokalen while-Konstruktes K von F
mit maximaler Tiefe. Dann gilt D(A) = n. Sei j die Nummer von K in der
Reihenfolge der lokalen while-Konstrukte. Da G und F strukturäquivalent,
ist W(G) = W(F) und für jedes i∈{1,...,W(F)} sind die Anweisungssequenzen
des i-ten while-Konstruktes in F und des i-ten while-Konstruktes in G
strukturäquivalent. Insbesondere gilt dies auch für die j-ten while-
Konstrukte. Sei L das j-te while-Konstrukt von G und B seine
Hauptanweisungssequenz. Es sind dann A und B strukturäquivalent. Da
D(A) = n, gilt D(B) = n (Induktionsvoraussetzung). Sei L' ein beliebiges
lokales while-Konstrukt in G und k seine Nummer in der Reihenfolge der
lokalen while-Konstrukte. Sei B' die Hauptanweisungssequenz von L’. Sei K'
das k-te while-Konstrukt in F. Da K ein while-Konstrukt maximaler Tiefe,
muß für die Hauptanweisungssequenz A' von K' gelten D(A') ≤ D(A) = n. Da
A' und B' strukturäquivalent, gilt D(B') ≤ n = D(B). Dann ist L ein lokales
while-Konstrukt maximaler Tiefe. Dann ist D(G) = D(B) + 1 = n+1.
6HLWH

%HLVSLHODXVZHUWXQJHQ
/HPPD
6HLHQ)XQG*VWUXNWXUlTXLYDOHQWH3URJUDPPIUDJPHQWH'DQQH[LVWLHUHQ
(QWIDOWXQJHQ'XQG(PLW' ()XQG( (*XQG'XQG(VLQG
VWUXNWXUlTXLYDOHQW
Beweis:
Sei D eine beliebige Entfaltung von F. Die Behauptung folgt durch vollständige
Induktion über D(F) (= D(G) nach Lemma 3.2.1).
Induktionsverankerung:
Für D(F) = 0 gilt auch D(G) = 0, dann sind D und E strukturäquivalent,
wobei E beliebige Entfaltung von G.
Induktionsvoraussetzung:
Für beliebige strukturäquivalente Programmfragmente F' und G' mit D(F') ≤
n existieren für eine Entfaltungen D’ = E(F’) eine Entfaltung E’ = E(G’), wobei
D’ und E’ strukturäquivalent.
Induktionsbehauptung:
Für D(F) = n+1 existiert zu D = E(F) eine Entfaltung E = E(G), so daß D und
E sind strukturäquivalent.
Induktionsschluß:
Wir erhalten eine Entfaltung von E, indem wir jedes lokale while-Konstrukt
L in E durch eine Entfaltung von L ersetzen. Aus der Strukturäquivalenz
folgt W(F) = W(G). Sei für beliebiges i∈{1,..,W(F)} Ki das i-te lokale while-
Konstrukt in F und Li das i-te while-Konstrukt in G. Sei Mi die Entfaltung
von Ki in D.
1. Fall: Mi hat die Form:
with
A F
test B F do C’ F1 end test
test B F do C’ F2 end test
...
test B F do C’ Fm end test
Dabei sei AF die lokale Initialisationssequenz von Ki, BF der Ausdruck von Ki
und C'F1,...,C'Fm für ein m∈© Entfaltungen der Anweisungssequenz CF von Ki.
Es gilt D(CF) ≤ n. Außerdem sind CF und CG strukturäquivalent (nach
Definition der Strukturäquivalenz). Dann existiert aber nach
Induktionsvoraussetzung für jedes j∈{1,..,m} eine Entfaltung C'Gj von CG,
wobei C'Fj und C'Gj strukturäquivalent. Setze Ni gleich
with
A G
test B G do C’ G1 end test
test B G do C’ G2 end test
...
test B G do C’ Gm end test,
so ist Ni eine Entfaltung von Li.
6HLWH

%HLVSLHODXVZHUWXQJHQ
2. Fall: Mi habe die Form:
with
A F
test B F do C’ F1 end test
test B F do C’ F2 end test
...
test B F do C’ Fn end test
test B F skip
Wiederum sei AF die lokale Initialisationssequenz von Ki, BF der Ausdruck
von Ki und C’F1,...,C’Fm für ein m∈© Entfaltungen der Anweisungssequenz CF
von Ki. Li habe die Gestalt
with
A G
while B G do C G end while
Dabei sei AG die Initialisationssequenz von Li, BG der Ausdruck von Li und CG
die Anweisungssequenz von Li. Analog zum 1. Fall existiert für jedes
j∈{1,..,m}eine Entfaltung C'Gj von CG, wobei C'Fj und C'Gj strukturäquivalent.
Setze Ni gleich
with
A G
test B G do C’ G1 end test
test B G do C’ G2 end test
...
test B G do C’ Gn end test
test B G skip
Es ist wiederum klar, daß Ni eine Entfaltung von Li ist.
E entstehe aus G durch Ersetzen von Li durch Ni für jedes i∈{1,..,W(F)}. Da
jedes while-Konstrukt entfaltet ist und die Entfaltung eines Fragmentes H,
das kein while-Konstrukt enthält, wiederum H ist, gilt E = E(G). Außerdem
folgt nach Konstruktion, daß D und E strukturäquivalent.
/HPPD
6HLHQ3XQG4VWUXNWXUlTXLYDOHQWH3URJUDPPH'DQQH[LVWLHUHQ
(QWIDOWXQJHQ'XQG(PLW' (3XQG( (4XQG'XQG(VLQG
VWUXNWXUlTXLYDOHQW
Beweis:
folgt aus Lemma 3.2.2 für die Hauptanweisungssequenzen von P und Q.
6HLWH

%HLVSLHODXVZHUWXQJHQ
3.3 Werte von Zahlen und Variablen
Bemerkung:
Der Wert einer Zahl n ist diejenige natürliche Zahl, deren Dezimaldarstellung n ist. Wir wollen
deswegen eine Zahl und ihren Wert identifizieren.
'HILQLWLRQ
6HLYHLQH+DXSWYDULDEOH3HLQ3URJUDPP( (3XQG1HLQHJHRUGQHWH
0HQJHQDW UOLFKHU=DKOHQPLWQ _1_ _(93_(LQJDEHPHQJH6HLP
9Y('DQQZLUGGHU:HUWYDOYL(YRQYLQ(EHL(LQJDEH1EHL
9RUNRPPHQLL∈^P`LQGXNWLYGHILQLHUW
) UL JLOW
)DOOYLVW(LQJDEHYDULDEOHXQGNRPPWLP(LQJDEHNRQVWUXNWDOVHWH
9DULDEOHYRUH∈^Q`
'DQQZLUGYDOY( UJHVHW]WZREHLUGDVHWH(OHPHQWYRQ1
LVW
)DOOYLVWNHLQH(LQJDEHYDULDEOHXQG.LVWLKUJOREDOHV
,QLWLDOLVDWLRQVNRQVWUXNW
8QWHUIDOO$XIGHUHQUHFKWHU6HLWHYRQ.VWHKWGLH=DKO]
6HW]HYDOY( ]
8QWHUIDOO$XIGHUHQUHFKWHU6HLWHYRQ.VWHKWGLH9DULDEOHZ
6HLMGLH1XPPHUGHV9RUNRPPHQVYRQZLQ(LP
.RQVWUXNW.6HW]HYDOY( YDOZM(
6HLQXQL!
)DOO,QLKUHPLWHP9RUNRPPHQLQ(OLHJWYLQQHUKDOEHLQHV
,QNUHPHQWHV
'DQQLVWYDOYL( YDOYL(
)DOO,QLKUHPLWHQ9RUNRPPHQOLHJWYLQQHUKDOEHLQHV'HNUHPHQWHV
'DQQLVW
val(v, i, E)
$QVRQVWHQLVWYDOYL( YDOYL(
=
⎧val(v, i - 1, E) - 1, falls val(v, i - 1, E) > 0
⎨
⎩0 sonst
6HL3HLQ3URJUDPPXQG1HLQH(LQJDEHPHQJH6HL( (36HLYHLQH
ORNDOH9DULDEOHHLQHVZKLOH.RQVWUXNWHV:LQ36HL'GLH(QWIDOWXQJYRQ:
LQ(6HLP 9Y''DQQZLUGGHU:HUWYDOYL'YRQYLQ'EHL
9RUNRPPHQLL∈^P`LQGHU(QWIDOWXQJ(YRQ3EHL(LQJDEH1
YHUVFKDFKWHOWLQGXNWLYGHILQLHUW
6HLWH

%HLVSLHODXVZHUWXQJHQ
6HL]XHUVW:HLQORNDOHVZKLOH.RQVWUXNWGHU+DXSWDQZHLVXQJVVHTXHQ]YRQ
3
) UL JLOW
6HL.GDVORNDOH,QLWLDOLVDWLRQVNRQVWUXNWYRQYLQ:
8QWHUIDOO$XIGHUHQUHFKWHU6HLWHYRQ.VWHKWGLH=DKO]
6HW]HYDOY' ]
8QWHUIDOO$XIGHUHQUHFKWHU6HLWHYRQ.VWHKWGLH9DULDEOHZ
GLHVNDQQQXUHLQH(LQJDEHYDULDEOHRGHUHLQHJOREDOH
9DULDEOHVHLQ
6HLMGLH1XPPHUGHV9RUNRPPHQVYRQZLQ.LQGHU
(QWIDOWXQJ(6HW]HYDOY' YDOZM(
6HLQXQL!
)DOO,QLKUHPLWHP9RUNRPPHQLQ'OLHJWYLQQHUKDOEHLQHV
,QNUHPHQWHV
'DQQLVWYDOYL' YDOYL'
)DOO,QLKUHPLWHQ9RUNRPPHQOLHJWYLQQHUKDOEHLQHV'HNUHPHQWHV
'DQQLVW
val(v, i, D)
=
⎧val(v, i - 1, D) - 1, falls val(v, i - 1, D) > 0
⎨
⎩0 sonst
$QVRQVWHQLVWYDOYL' YDOYL'
6HLMHW]W:HLQZKLOH.RQVWUXNWYRQ3ZHOFKHVORNDOHVZKLOH.RQVWUXNWHLQHV
]ZHLWHQZKLOH.RQVWUXNWHV:LVW6HL&GLH(QWIDOWXQJYRQ:LQ(
) UL JLOW
6HL.GDVORNDOH,QLWLDOLVDWLRQVNRQVWUXNWYRQYLQ:
8QWHUIDOO$XIGHUUHFKWHQ6HLWHYRQ.VWHKWGLH=DKO]
6HW]HYDOY' ]
8QWHUIDOO$XIGHUUHFKWHQ6HLWHYRQ.VWHKWGLH+DXSWYDULDEOHZ
6HLMGLH1XPPHUGHV9RUNRPPHQVYRQZ,Q.LQGHU
(QWIDOWXQJ(6HW]HYDOY' YDOZM(
8QWHUIDOO $XIGHUUHFKWHQ6HLWHYRQ.VWHKWGLHORNDOH9DULDEOH
Z
6HLMGLH1XPPHUGHV9RUNRPPHQVYRQZLQ.LQGHU
(QWIDOWXQJ&6HW]HYDOY' YDOZM&
6HLWH

%HLVSLHODXVZHUWXQJHQ
6HLQXQL!
)DOO,QLKUHPLWHP9RUNRPPHQLQ'OLHJWYLQQHUKDOEHLQHV
,QNUHPHQWHV
'DQQLVWYDOYL' YDOYL'
)DOO,QLKUHPLWHQ9RUNRPPHQOLHJWYLQQHUKDOEHLQHV'HNUHPHQWHV
'DQQLVW
val(v, i, D)
$QVRQVWHQLVWYDOYL' YDOYL'
Beispiel 3.3.1:
Sei P gegeben durch
input (x ,y)
++x
--y
++x
x
with
set (z := x)
while do
z++
with
set (w := z)
while do
w++
end while
end while
output x
und sei E gegeben durch
input (x ,y)
++x
--y
++x
x
with
set (z := x)
test do
++z
// Beginn von D
with
set (w := z)
test do
++w
end test
test do
++w
end test
// Ende von D
=
⎧val(v, i - 1, D) - 1, falls val(v, i - 1, D) > 0
⎨
⎩0 sonst
6HLWH

%HLVSLHODXVZHUWXQJHQ
end test
test do
++z
with
set (w := z)
test do
++w
end test
test do
++w
end test
end test
output x
Es sei die Eingabemenge N = (1,2)
So gilt für die Werte der Variablen x in E:
val(x,1,E) = 1
val(x,2,E) = 2
val(x,3,E) = 3
val(x,4,E) = 3
val(x,5,E) = 3
val(x,6,E) = 3
und für die Werte der Variablen w in D:
val(w,1,D) = 4
val(w,2,D) = 5
val(w,3,D) = 6
/HPPD
D6HL3HLQ3URJUDPPXQG(HLQH(QWIDOWXQJYRQ36HLYHLQH
(LQJDEHYDULDEOH'DQQJLOWI UMHGHVL∈^9Y(`LVWYDOYL(GHILQLHUW
E6HL3HLQ3URJUDPPXQG(HLQH(QWIDOWXQJYRQ36HLYHLQHJOREDOH
9DULDEOH'DQQJLOWI UMHGHVL∈^9Y(`LVWYDOYL(GHILQLHUW
F6HL3HLQ3URJUDPPXQG(HLQH(QWIDOWXQJYRQ36HL:HLQZKLOH
.RQVWUXNWYRQ3XQG'GLH(QWIDOWXQJYRQ:LQ(6HLYHLQHORNDOH9DULDEOH
YRQ:'DQQJLOWI UMHGHVL∈^9Y'`LVWYDOYL'GHILQLHUW
Beweis:
a) Sei N die Eingabemenge. Sei v eine Eingabevariable. Wir betrachten jetzt das
erste Auftreten von v.
Da v ist Eingabevariable, liegt das erste Vorkommen von v im
Eingabekonstrukt von E. Dann ist val(v,1,E) über ein Element der
Eingabemenge N definiert.
Für 1 < i ≤ V(v,E) ist val(v,i,E) definiert, wenn val(v,i-1,E) definiert ist. Dann
folgt die Behauptung aber sofort durch Induktion über i.
b) v sei globale Variable. Wir betrachten wiederum das erste Auftreten von v in
E. Nach Lemma 2.3.1 liegt das erste Auftreten von v in P auf der linken Seite
ihres Initialisationskonstruktes K. Da ist dann auch das erste Vorkommen von v
in E.
6HLWH

%HLVSLHODXVZHUWXQJHQ
1. Fall: Auf der rechten Seite von K ist die Zahl z. Dann ist val(v,1,E) = z
definiert.
2. Fall: Auf der linken Seite von K ist die Variable w. Dies kann nur eine
Eingabevariable sein, denn globale Variablen dürfen nur einmal in ihrer
Initialisationssequenz vorkommen, nämlich auf der linken Seite ihres
Initialisationskonstruktes. Für Eingabevariablen ist aber die Relation val
definiert für jedes ihrer Vorkommen in E (nach Beweisteil a). Dann ist auch
val(v,1,E) definiert.
Für 1 < i ≤ V(v,E) ist val(v,i,E) definiert, wenn val(v,i-1,E) definiert ist. Dann
folgt die Behauptung aber sofort durch Induktion über i.
c) Sei v eine lokale Variable von W. Nach Lemma 2.3.1 liegt das erste
Vorkommen von v in W auf der linken Seite ihres Initialisationskonstruktes.
Dann ist auch das erste Vorkommen von v in D auf der linken Seite des
Initialisationskonstruktes K von v.
(vollständige Induktion über die Zahl der while-Konstrukte k, in denen W
enthalten ist)
Induktionsverankerung:
Sei k = 0, dann ist W lokales while-Konstrukt der Hauptanweisungssequenz
von P.
1. Fall: auf der rechten Seite von K steht die Zahl z, dann ist val(v,1,D) = z
definiert.
2. Fall: auf der rechten Seite von K steht eine Variable. Dies kann keine
lokale Variable von W sein, da diese nur einmal in der Initialisationssequenz
vorkommen dürfen, nämlich auf der linken Seite ihres
Initialisationskonstruktes. Also muß es eine Hauptvariable sein. Nach den
Beweisteilen a) und b) ist aber die Relation val für diese Variablen für jedes
Vorkommen in E definiert. Dann ist auch val(v,1,D) definiert.
Induktionsvoraussetzung:
Für jedes while-Konstrukt W', das in maximal k while-Konstrukten enthalten
ist, ist die Relation val für jedes Vorkommen jeder lokalen Variablen von W'
in E(W') definiert.
Induktionsbehauptung:
W sei in k+1 while-Konstrukten enthalten. Dann ist val(v,1,D) definiert.
Induktionsschluß:
W sei lokales while-Konstrukt in dem while-Konstrukt W’.
1. Fall: auf der rechten Seite von K steht die Zahl z, dann ist val(v,1,D) = z
definiert.
2. Fall: auf der rechten Seite von K steht die Hauptvariable w. Nach den
Beweisteilen a) und b) ist die Relation val für w definiert. Dann ist auch
val(v,1,D) definiert.
2. Fall: auf der rechten Seite von K steht die lokale Variable w. Dies kann
aber nur eine lokale Variable von W' oder eines while-Konstruktes, in dem W’
6HLWH

%HLVSLHODXVZHUWXQJHQ
enthalten ist, sein. Nach Induktionsvoraussetzung ist aber der Wert von w in
der Entfaltung an der Stelle K definiert. Dann ist auch val(v,1,D) definiert.
Für 1 < i ≤ V(v1,E) ist val(v1,i,E) definiert, wenn val(v1,i-1,E) definiert ist. Dann
folgt die Behauptung aber sofort durch Induktion über i.
3.4 Konstruktion von Beispielauswertungen
'HILQLWLRQ
6HL3HLQ3URJUDPPXQG1HLQHJHRUGQHWH0HQJHQDW UOLFKHU=DKOHQPLW
_1_ _(93_'DQQHQWVWHKWHLQH%HLVSLHODXVZHUWXQJYDO31YRQ3EHL
(LQJDEH1GXUFKIROJHQGHV9HUIDKUHQ
%LOGXQJHLQHU(QWIDOWXQJ(YRQ3
ì (UVHW]HQYRQYGXUFKYDOYL(I UMHGHV9RUNRPPHQLHLQHU
+DXSWYDULDEOHQYLQ(
ì (UVHW]HQYRQYGXUFKYDOYL'I UMHGHV9RUNRPPHQLHLQHUORNDOHQ
9DULDEOHQHLQHVZKLOH.RQVWUXNWHV:LQGHU(QWIDOWXQJ' (:
LQQHUKDOEYRQ(
ì /|VFKHQDOOHU,QLWLDOLVDWLRQVNRQVWUXNWHLQ(
ì /|VFKHQMHGHV9RUNRPPHQVGHV6FKO VVHOZRUWHVZLWKLQ(
'LH0HQJHDOOHU%HLVSLHODXVZHUWXQJHQYRQ3XQG1ZLUGDOV%$31
EH]HLFKQHW
Beispiel 3.4.1:
Sei P gegeben durch
input (x,y)
set (z:=4)
y
with
set (c:=0)
set (d:=y)
while d>0 do
++c
--d
end while
output z
und sei die Eingabe N gleich (3,6),
dann ist die folgende Zeichenfolge eine Beispielauswertung von P:
6HLWH

%HLVSLHODXVZHUWXQJHQ
input (3,6)
6
test 6 > 0 do
1
5
end test
test 5 > 0 do
2
4
end test
output 4
'HILQLWLRQ
6HL3HLQ3URJUDPP)HLQ)UDJPHQWYRQ3XQG6HLQH%HLVSLHODXVZHUWXQJ
YRQ3(LQH7HLO]HLFKHQIROJH7YRQ6KHL‰W%HLVSLHODXVZHUWXQJVIUDJPHQW]X
)ZHQQ7GLH7HLO]HLFKHQIROJHYRQ6LVWGLHGHU(QWIDOWXQJYRQ)HQWVSULFKW
'HILQLWLRQ
6HL)HLQ3URJUDPPIUDJPHQWXQG7HLQ%HLVSLHODXVZHUWXQJVIUDJPHQW7
KHL‰W%HLVSLHODXVZHUWXQJYRQ)ZHQQHVHLQ3URJUDPP3XQGHLQ
%HLVSLHODXVZHUWXQJ6YRQ3JLEWVRGD‰)LVW3URJUDPPIUDJPHQWYRQ3XQG
7LVW%HLVSLHODXVZHUWXQJVIUDJPHQWYRQ6
3.5 Äquivalente Programme
'HILQLWLRQ
=ZHL3URJUDPPH3XQG4KHL‰HQlTXLYDOHQW3≅4ZHQQ
_(93_ _(94_
I UMHGHJHRUGQHWH0HQJHQDW UOLFKHU=DKOHQ1PLW_1_ _(93_JLOW
%$31 %$41
Beispiel 3.5.1:
Folgende Programme sind äquivalent:
input (a)
with
set (b := a)
set (c := 0)
while b>0 do
--b
++c
--c
++c
end while
output a
input (x)
set (w := 0)
set (u := x)
with
set (y := x)
set (z := w)
set (v := w)
while u>w do
--y
++z
w
++w
end while
output u
6HLWH

%HLVSLHODXVZHUWXQJHQ
/HPPD
'LH5HODWLRQ≅LVWHLQHbTXLYDOHQ]UHODWLRQDXIGHU0HQJHGHUZKLOH
3URJUDPPH
Beweis:
Reflexivität, Symmetrie und Transitivität der Relation ≅ folgen direkt aus den
entsprechenden Eigenschaften der Gleichheit der Mengen der
Beispielauswertungen.
'HILQLWLRQ
6HL3HLQ3URJUDPP9 ^Y Y Q`HLQHJHRUGQHWH0HQJHYRQ9DULDEOHQYRQ3
XQG; ^[ [ Q`HLQHJHRUGQHWH0HQJHYRQ%H]HLFKQHUQGLHQLFKWLQ3
YRUNRPPHQ'DQQHQWVWHKWGLHGDV3URJUDPP3σGXUFKGLH
9DULDEOHQVXEVWLWXWLRQσ >Y [ Y Q [ Q @ZREHLMHGHV9RUNRPPHQVYRQY L
GXUFK[ L HUVHW]WZLUGI UMHGHVL∈^Q`
Bemerkung:
a) Die Elemente der Menge X sind Variablen in Pσ.
b) Es ist möglich, Variablen zu tauschen. Zum Beispiel kann eine Substitution [x/y,y/x] durch
die Verkettung der Substitutionen [x/a,x/b] und [a/y,b/x], wobei a und b neue Bezeichner sind,
gemäß obiger Definition ausgeführt werden.
/HPPD
6HLHQ3XQG43URJUDPPHXQGσHLQH9DULDEOHQVXEVWLWXWLRQVRGD‰4 3σ
'DQQJLOW3≅4
Beweis:
Es sei σ = [v1/x1,...,vn/xn], wobei v1,...,vn Variablen in P und x1,...,xn Variablen in
Q. O.B.d.A. seien die Variablen v1,..,vn und x1,...,xn in der Reihenfolge ihres
ersten Auftretens geordnet. P und Q unterscheiden sich nur in diesen Variablen.
Da das erste Vorkommen einer Hauptvariablen vor dem ersten Vorkommen
einer lokalen Variablen liegt, gibt es ein m∈{0,...,n}, so daß v1,..,vm sind
Hauptvariablen und vm+1,...,vn sind lokale Variablen. Es ist klar, daß P und Q
strukturäquivalent sind. Sei D eine beliebige Entfaltung von P. Nach Lemma
3.2.4 existiert eine Entfaltung E von Q, derart daß D und E sind
strukturäquivalent. Die Entfaltungen E und F von P und Q unterscheiden sich
dann ebenfalls nur in den Variablen v1,..,vn und x1,...,xn, die weiterhin in der
Reihenfolge ihres Auftretens geordnet sind. Für jedes i∈{1,...n} gilt außerdem
V(vi,D) = V(xi,E).
Da bei der Konstruktion einer Beispielauswertung alle Variablen durch ihre
Werte ersetzt werden, genügt es zu zeigen, daß für jedes i∈{1,...m} und jedes
j∈{1,...V(vi,D)}gilt val(xi,j,D) = val(vi,j,E)
und für jedes k∈{m+1,...n} und jedes while-Konstrukt Kk von P, in dem vk lokale
Variable ist (Lk sei das entsprechende while-Konstrukt von Q) und jedes
j∈{1,...,V(vk,Dk)} gilt val(vk,j,Dk) = val(xk,j,Ek), wobei Dk
die Entfaltung von Kk in D und Ek die Entfaltung von Lk in E ist.
6HLWH

%HLVSLHODXVZHUWXQJHQ
Betrachten wir zuerst die Hauptvariablen:
(vollständige Induktion über die ersten r Variablen (r≤m))
Induktionsverankerung:
Es sei r=1,v1 ist erste substituierte Variable in D, x1 ist erste substituierte
Variable in E.
1. Fall: Wenn v1 Eingabevariable, so ist auch x1 Eingabevariable und v1 und
x1 stehen an derselben Position im Eingabekonstrukt. Dann ist val(x1,1,E) =
val(v1,1,D).
2. Fall: Wenn v1 globale Variable, so ist auch x1 globale Variable, und die
Initialisationskonstrukte von x1 und v1 unterscheiden sich nur in x1 bzw. v1.
Sei "set (v1 := µ)" das Initialisationskonstrukt von v1, Dabei ist µ eine
beliebige Variable (außer v1,..,vn,x1,...,xn) oder eine Zahl. Dann ist "set (x1 :=
µ)" das Initialisationskonstrukt von x1, denn x1 und v1 dürfen auf der rechten
Seite ihres Initialisationskonstruktes nicht vorkommen, ebensowenig wie die
Variablen v2,..,vn und x2,...,xn. (da v1 bzw., x1 die erste dieser Variablen). Also
gilt auch hier val(x1,1,E) = val(v1,1,D).
Da jede Änderung des Wertes von x1 in einem Dekrement oder Inkrement
eine ebensolche Änderung des Wertes von v1 bedeutet, muß auch für jedes
Vorkommen j>1 gelten: val(x1,j,E) = val(v1,j,D).
Induktionsvoraussetzung:
Für r>1 beliebig (aber ≤ m) gilt für jedes i∈{1,...r-1} und jedes j∈{1,...V(vi,E)}
val(xi,j,E) = val(vi,j,D).
Induktionsbehauptung:
Für jedes i∈{1,...r} und jedes j∈{1,...V(vi,E)} gilt val(xi,j,E) = val(vi,j,D).
Induktionsschluß:
Da die Behauptung nach Induktionsvoraussetzung für die ersten r-1
Substitutionsvariablen gilt, müssen wir sie nur noch für das Paar vr und xr
zeigen.
1. Fall: Wenn vr Eingabevariable, so ist auch xr Eingabevariable und vr und
xr stehen an derselben Position im Eingabekonstrukt. Dann ist val(xr,1,E) =
val(vr,1,D).
2. Fall: Wenn vr globale Variable, so ist auch xr globale Variable. Sei "set (vr
:= µ)" das Initialisationskonstrukt von vr, und "set (xr := λ)" das
Initialisationskonstrukt von xr.
Wir wissen, daß µ≠vr und λ≠xr.
Unterfall 1: µ sei entweder eine Zahl oder eine Variable, die nicht in {v1,...,vn}
enthalten ist. Dann ist λ=µ und val(xr,1,E) = val(vr,1,D).
6HLWH

%HLVSLHODXVZHUWXQJHQ
Unterfall 2: µ ist eine der Variablen aus der Menge {vr+1,...,vn} (λ ist dann eine
der Variablen aus der Menge {xr+1,...,xn}. Dann würde aber das
erste Vorkommen dieser Variablen vor dem ersten Vorkommen der
Variablen vr liegen im Widerspruch zur Voraussetzung die
Variablen wären nach der Reihenfolge ihres Auftretens geordnet.
Unterfall 3: µ ist vi, wobei i∈{1,...,r-1}. Dann ist λ=xr. Sei j die Nummer des
Vorkommens von vi im Initialisationskonstrukt von vr und von xi im
Initialisationskonstrukt von xr. Nach Induktionsvoraussetzung ist
val(vi, j,D) = val(xi,j,E) und damit auch val(vr,1,D) = val(xr,1,E).
Demnach gilt in jedem möglichen Fall val(vr,1,D) = val(xr,1,E).
Da jede Änderung des Wertes von xr in einem Dekrement oder Inkrement
eine ebensolche Änderung des Wertes von vr bedeutet, muß auch für jedes
Vorkommen j>1 gelten: val(xr,j,E) = val(vr,j,D).
Betrachten wir jetzt die lokalen Variablen:
(vollständige Induktion über die ersten s lokalen Variablen (m1 beliebig gilt für jedes i∈{m+1,...s-1} und jedes j∈{1,...V(vi,Di)}:
val(xi,j,Ei) = val(vi,j,Di), wobei Di die Entfaltung des zu vi gehörigen while-
Konstruktes in D und Ei die entsprechende Entfaltung in E.
Induktionsbehauptung:
Für jedes i∈{m+1,...s} und jedes j∈{1,...V(vi,Di)} gilt val(xi,j,Ei) = val(vi,j,Di).
Induktionsschluß:
Da die Behauptung nach Induktionsvoraussetzung für die ersten s-1 lokalen
Substitutionsvariablen gilt, müssen wir sie nur noch für das Paar vs und xs
zeigen. Sei "set (vs := µ)" das Initialisationskonstrukt von vs, und "set (xs :=
λ)" das Initialisationskonstrukt von xs.
Wir wissen, daß µ≠vs und λ≠xs.
6HLWH

%HLVSLHODXVZHUWXQJHQ
Fall 1: µ sei entweder eine Zahl oder eine Variable, die nicht in {v1,...,vn}
enthalten ist. Dann ist λ=µ und val(xs,1,Es) = val(vs,1,Ds).
Fall 2: µ ist eine der Variablen aus der Menge {vs+1,...,vn} (λ ist dann eine der
Variablen aus der Menge {xm+1,...,xn}. Dann würde aber das erste
Vorkommen dieser Variablen vor dem ersten Vorkommen der Variablen
vs liegen im Widerspruch zur Voraussetzung die Variablen wären nach
der Reihenfolge ihres Auftretens geordnet.
Fall 3: µ ist vi, wobei i∈{m+1,...,s-1}. Dann ist λ=xi. vi ist lokale Variable des
while-Konstruktes W von P, dessen Entfaltung innerhalb von D gleich
D’ ist. Dabei ist K in W enthalten. Entsprechendes gilt für die Variable
xi. Sei j die Nummer des Vorkommens von vi im Initialisationskonstrukt
von vs und von xi im Initialisationskonstrukt von xs. Nach
Induktionsvoraussetzung ist val(vi, j,Di) = val(xi,j,Ei) und damit auch
val(vs,1,Ds) = val(xs,1,Es).
Fall 4: µ ist vi, wobei i∈{1,...,m}. Dann ist λ=xi. Damit sind xi und vi
Hauptvariablen. Sei j die Nummer des Vorkommens von vi im
Initialisationskonstrukt von vs und von xi im Initialisationskonstrukt
von xs. Nach obiger Induktion (für Hauptvariablen) ist val(vi, j,D) =
val(xi,j,E) und damit auch val(vs,1,Ds) = val(xs,1,Es).
Demnach gilt in jedem Fall val(vs,1,Ds) = val(xs,1,Es).
Da jede Änderung des Wertes von xm in einem Dekrement oder Inkrement
eine ebensolche Änderung des Wertes von vm bedeutet, muß auch für jedes
Vorkommen j>1 gelten: val(xs,j,Es) = val(vs,j,Ds).
'HILQLWLRQ
6HL3HLQ3URJUDPP'LHNRQVWDQWHQEHUHLQLJWH)RUPYRQ3ZLUG
IROJHQGHUPD‰HQJHELOGHW
) UMHGH.RQVWDQWHFZlKOHHLQHQ%H]HLFKQHUYGHULP3URJUDPPELVKHU
QLFKWYRUNRPPW(UVHW]HMHGHV9RUNRPPHQYRQFGXUFKYXQGI JHGDV
,QLWLDOLVDWLRQVNRQVWUXNWVHWY FLQGLH+DXSWLQLWLDOLVDWLRQVVHTXHQ]HLQ
Beispiel 3.5.2:
Sei P das folgende Programm:
input ()
set (a := 4)
2
with
while 3 do
4
with
set (x := a)
set (y := 5)
while 6 do
7
end while
end while
output a
6HLWH

%HLVSLHODXVZHUWXQJHQ
Dann ist der folgende Programmtext eine konstantenbereinigte Form von P:
input ()
set (a := 4)
set (b := 2)
set (c := 3)
set (d := 4)
set (e := 5)
set (f := 6)
set (g := 7)
b
with
while c do
d
with
set (x := a)
set (y := e)
while f do
g
end while
end while
output a
/HPPD
6HL3HLQ3URJUDPPXQG4VHLQHNRQVWDQWHQEHUHLQLJWH)RUP'DQQLVW4HLQ
3URJUDPP
Beweis:
Es ist klar, daß Q ein Programmtext ist. Zu zeigen bleibt demnach nach
Definition 2.3.11, daß jeder Bezeichner im Eingabekonstrukt, im
Ausgabekonstrukt, in einem Initialisationskonstrukt, in einem Dekrement und
in einem Inkrement eine Variable ist.
Wir haben weder das Eingabekonstrukt, noch das Ausgabekonstrukt, noch ein
Dekrement oder ein Inkrement verändert. Wir haben lediglich bestehenden
Initialisationskonstrukte verändert und neue Initialisationskonstrukte
eingeführt. Wir müssen zeigen, daß jeder der neu eingeführten Bezeichner eine
Variable ist.
Betrachten wir zuerst die neu eingeführten Initialisationskonstrukte. Sie liegen
alle in der globalen Initialisationssequenz. Sei K ein solches
Initialisationskonstrukt. Aus der linken Seite von K steht ein neu eingeführter
Bezeichner, etwa v, und auf der rechten Seite steht eine Konstante. v kommt in
genau einem globalen Initialisationskonstrukt vor und zwar nur auf dessen
linken Seite. v kommt nicht im Eingabekonstrukt vor. Also ist v eine Variable.
Betrachten wir jetzt die veränderten Initialisationskonstrukte. Jedes der
veränderten Initialisationskonstrukte hat die Form "set (x := y)", wobei x und y
Bezeichner sind. Dabei ist x schon eine Variable in P und y nach obigen
Bemerkungen ebenfalls eine Variable. Also ist Q ein Programm.
/HPPD
6HL3HLQ3URJUDPPXQG4VHLQHNRQVWDQWHQEHUHLQLJWH)RUP'DQQJLOW4≅3
6HLWH

%HLVSLHODXVZHUWXQJHQ
Beweis:
Sei c eine beliebige Konstante in P.
Bei der Bildung von Q wurde c durch eine globale Variable v ersetzt mit
val(v,i,E) = c für 1 ≤ i ≤ V(v,E), für jede Entfaltung E von Q.
Bei der Bildung einer Beispielauswertung wird v dann durch c ersetzt und alle
Initialisationskonstrukte werden entfernt. Da sich P und Q nur in ihren
Initialisationskonstrukten und in dem Ersatz der Konstanten durch Variablen
mit demselben Wert unterscheiden, sind die Mengen der Beispielauswertungen
für P und Q gleich.
Bemerkung:
Die konstantenbereinigte Form eines Programmes kann weiterhin Konstanten enthalten,
nämlich in der globalen Initialisationssequenz.
/HPPD
6HL3HLQ3URJUDPPXQG. . . L . L . L . M . M . M . Q I UHLQQ∈©HLQH
,QLWLDOLVDWLRQVVHTXHQ]YRQ36HL. . . L . M . L . M . L . M . Q 6HL4GHU
3URJUDPPWH[WGDVDXV3HQWVWHKWGXUFK(UVHW]HQYRQ.GXUFK.'DQQJLOW
D4LVWHLQ3URJUDPP
E4≅3
Beweis:
P und Q unterscheiden sich nur in Ki und Kj. Sei v die Variable auf der linken
Seite von Ki und w die Variable auf der linken Seite von Kj.
a) v und w treten jeweils weiterhin nur einmal in K auf und zwar auf der linken
Seite ihres Initialisationskonstruktes. Da sie im weiteren nicht verändert
wurden, bleiben sie Variablen. Gleiche Überlegung gilt auch für eventuelle
Variablen auf den rechten Seiten von Ki und Kj. Also ist Q ein Programm.
b) P und Q sind strukturäquivalent, also existiert für eine beliebige Entfaltung
D von P nach Lemma 3.2.4 eine Entfaltung E von Q, so daß E und D sind
strukturäquivalent.
1. Fall: K ist globales Initialisationskonstrukt:
Da v und w auf der linken Seiten von Ki und Kj nicht vorkommen dürfen, gilt
val(v,1,D) = val(v,1,E) und val(w,1,D) = val(w,1,E). Demnach werden die
Wert der Variablen v und w durch die Transformation nicht verändert
(ebensowenig wie die Werte anderer Variablen). Da Initialisationskonstrukte
in Beispielauswertungen nicht mehr vorkommen, haben P und Q dieselben
Mengen von Beispielauswertungen.
2. Fall: K ist lokales Initialisationskonstrukt eines while-Konstruktes W:
Sei D' eine Entfaltung von W in D und E' eine Entfaltung von W in E. Da v
und w auf der linken Seiten von Ki und Kj nicht vorkommen dürfen, gilt
val(v,1,D') = val(v,1,E') und val(w,1,D') = val(w,1,E'). Demnach werden die
Wert der Variablen v und w durch die Transformation nicht verändert
(ebensowenig wie die Werte anderer Variablen). Da Initialisationskonstrukte
in Beispielauswertungen nicht mehr vorkommen, haben P und Q dieselben
Mengen von Beispielauswertungen.
6HLWH

$XWRPDWLVFKH*HQHULHUXQJYRQ%HLVSLHODXVZHUWXQJHQ
4 Automatische Generierung von Beispielauswertungen
In diesem Kapitel wird ein Algorithmus zu automatischen Generierung von
Beispielauswertungen aus WHILE-Programmen angeben und seine Korrektheit bewiesen. Es
zeigt sich, daß der Zeitbedarf für die Generierung linear mit der Länge des WHILE-
Programmes ansteigt.
4.1 Variablenlisten
Zur Speicherung der Anfangswerte und der aktuellen Werte unserer Variablen des
Programmes benötigen wir Datenstruktur Variable und Variablenliste:
Die Datenstruktur Variable besteht aus einem String 'lexem' und zweier natürlicher Zahlen
'endwert' und 'anfangswert'. Dabei wird in der Komponente 'lexem' der Name der Variablen
gespeichert und in der Komponente 'endwert' wird der aktuelle Wert der Variablen während
der Bildung einer Beispielauswertung gespeichert, während in der Komponente 'anfangswert'
der erste Wert der Variablen gespeichert wird. Die Datenstruktur Variablenliste besteht dann
aus einer Liste von Variablen und Methoden zur Verwaltung dieser Liste. Auf die Korrektheit
dieser Methoden soll hier nicht eingegangen werden.
4.2 Algorithmus
Die Generierung von Beispielauswertungen ist für jedes WHILE-Programm durchführbar. Es
wird davon ausgegangen, daß die Eingabe in einer geparsten und von Trennzeichen und
Kommentaren bereinigten Form vorliegt. Auch die Ausgabe wird in einer solchen Form
vorliegen.
Algorithmus ComputeProgram(P,N,S)
Eingabe: P : Programm
Ausgabe:
N : Eingabemenge N={n 1 ,...,n m } wobei m = |EV(P)|, n i ∈©
S : Beispielauswertung
Funktion: Das berechnete S ist Beispielauswertung von P für die Eingabe N.
Variablen: V : Variablenliste
T : Beispielauswertungsfragment
i : natürliche Zahl (Zählvariable)
c : natürliche Zahl (für den Wert der Ausgabevariablen)
6HLWH

$XWRPDWLVFKH*HQHULHUXQJYRQ%HLVSLHODXVZHUWXQJHQ
Abbildung 4 : Struktur des Algorithmus’ ComputeProgram
Prozeduraufruf
Rekursion
computeProgram(P,N,S)
computeSequence(A,V,T)
Sei P ="input (x 1 ,...,x m ) K 1 ,...,K r A output y", wobei x 1 ,...,x m ,y
Variablen, K 1 ...K r die globalen Initialisationskonstrukte und A eine
Anweisungssequenz ist.
// lösche die Variablenliste und trage Eingabevariablen in V ein
Lösche V
für i = 1 bis m tue
Trage Variable x i mit Anfangs- und Endwert n i am Ende von V ein.
ende für
// Trage die Globalen Variablen in V ein
für i = 1 bis r tue
Sei K i = set (v := α).
wenn α ist Zahl dann
trage Variable v mit Anfangs- und Endwert α am Ende von V ein.
sonst (α ist Eingabevariable)
bestimme Wert c von α aus V
Trage Variable v mit Anfangs- und Endwert c am Ende von V ein.
ende wenn
ende für
// Ermittle Beispielauswertung für die Anweisungssequenz A
Rufe ComputeSequence (A, V, T) auf .
// T ist jetzt das Beispielauswertungsfragment zu A uns V enthält alle Eingabe- und
// globalen Variablen mit ihren Werten am Ende der Ausführung von T
// Bestimme den Wert der Ausgabevariablen
Setze c := Endwert von y in V
// Setze S zusammen
Setze S := "input (n 1 ,...,n m ) T output c"
6HLWH

$XWRPDWLVFKH*HQHULHUXQJYRQ%HLVSLHODXVZHUWXQJHQ
Ende Algorithmus ComputeProgram
Prozedur ComputeSequence(A,V,T)
Eingabe: A : Programmfragment
Ein-/Ausgabe:
V : Variablenliste
Ausgabe: T : Beispielauswertungsfragment
Funktion:
T ist Beispielauswertungsfragment von A mit der Variablenbelegung V
am Anfang der Auswertung von A. V beinhaltet am Ende der Prozedur
die Variablenbelegung am Ende von T
Variablen: a : Anweisung
c,i : Natürliche Zahlen
z : Natürliche Zahl (für die Länge der Variablenliste)
// T ist am Anfang leer
T := ""
// Bestimme Länge der Variablenliste
z := Länge von V
// Lese A sequentiell.
wenn A≠"" tue
Setze Lesezeiger vor das ersten Element in A
solange A noch nicht vollständig gelesen tue (d.h. solange der Lesezeiger steht
nicht hinter dem letzten Element in A)
a := lese nächsten Eintrag in A.
Stelle Lesezeiger einen Eintrag vor.
unterscheide
falls a ist Sonderzeichen, Wort oder String:
Füge a am Ende von T an.
falls a ist Zahl:
Füge a am Ende von T an.
falls a ist Variable x:
Füge c am Ende von T an, wobei c der Endwert von x in V ist.
falls a ist Inkrement ++x:
Füge c+1 am Ende von S an, wobei c der Endwert von x in V ist. Setze
Endwert von x in V auf c+1.
falls a ist Dekrement --x:
Sei c der Endwert von x in V. Falls v = 0, füge 0 am Ende von S an,
ansonsten füge c-1 am Ende von S an und setze den Endwert von x in
V auf c-1 .
falls a ist while-Konstrukt der Form "with K 1 ...K r while C do D
end while", wobei K 1 ,...,K r lokale Initialisationskonstrukte (für ein r∈©),
C ein Ausdruck und D eine Anweisungssequenz ist.
// Trage die lokalen Variablen in V ein
für i = 1 bis r tue
Sei K i = set (v := α).
wenn α ist Zahl, dann
trage Variable v mit Anfangs- und Endwert α am Ende von V ein.
6HLWH

$XWRPDWLVFKH*HQHULHUXQJYRQ%HLVSLHODXVZHUWXQJHQ
sonst (α ist Variable in V) bestimme Wert c von α aus V
Trage Variable v mit Anfangs- und Endwert c am Ende von V ein.
ende wenn
ende für
// V enthält jetzt (in den ersten z Komponenten) die übergebenen
// Variablen und (in den letzten Komponenten) die lokalen Variablen
// des while-Konstruktes
// Berechne Beispielauswertungsfragment von a
Variablen : T1,T2,T3,T4 : Beispielauswertungsfragmente
Rufe ComputeSequence(C, V, T1) auf.
Rufe ComputeSequence (D, V, T2) auf.
Füge "test T1 do T2 end test" am Ende von S an.
Rufe ComputeSequence (C, V, T3) auf.
Rufe ComputeSequence (D, V, T4) auf.
Füge "test T3 do T4 end test" am Ende von S an.
// Entferne die lokalen Variablen aus der Variablenliste V
Lösche Rest der Liste V nach Position z
ende unterscheide
ende solange
ende wenn
Ende Prozedur ComputeSequence
4.3 Korrektheit
/HPPD
6HL$GDV3URJUDPPIUDJPHQWLQGHU3UR]HGXU&RPSXWH6HTXHQFH$KDEHGLH
*HVWDOW$ D D V ZREHLD D V $QZHLVXQJHQVLQGXQGV!(VVHL
VLFKHUJHVWHOOWGD‰DOOHUHNXUVLYHQ3UR]HGXUDXIUXIHWHUPLQLHUHQ'DQQ
WHUPLQLHUWGLHVRODQJH6FKOHLIHLQV6FKOHLIHQGXUFKOlXIHQLQ
&RPSXWH6HTXHQFHXQGGLH9DULDEOHDQLPPWQDFKHLQDQGHUGLH:HUWHD D V
DQ
Beweis:
a) Termination der solange-Schleife
Sei i die Nummer, desjenigen Elementes, vor dem der Lesezeiger steht.
Behauptung: Nach (s-1) Schleifendurchläufen gilt i=s.
Beweis durch vollständige Induktion über t (1≤t1:
Es gelte nach (t-1) Schleifendurchläufen i=t.
Induktionsbehauptung:
6HLWH

$XWRPDWLVFKH*HQHULHUXQJYRQ%HLVSLHODXVZHUWXQJHQ
Nach t Schleifendurchläufen gilt i=t+1.
Induktionsschluß:
Nach Induktionsvoraussetzung gilt nach (t-1) Schleifendurchläufen i=t. Im t-
ten Schleifendurchlauf wird der Lesezeiger um ein Feld vorgestellt, also gilt
i=t+1.
Nach Induktion gilt ∀t∈{1,...,s}[nach (t-1) Schleifendurchläufen gilt i=t].
Da der Lesezeiger nach (s-1) Schleifendurchläufen vor dem letzten Element in A
steht, und der Lesezeiger im s-ten Schleifendurchlauf um eine Position
vorgestellt wird, steht nach dem s-ten Schleifendurchlauf der Zeiger hinter dem
letzten Element von A und die Schleife terminiert nach s Durchläufen.
b) a nimmt nacheinander die Werte a1,...,as an
In Teil a) wurde bewiesen: ∀t∈{1,...,s}[nach (t-1) Schleifendurchläufen gilt i=t].
Da a immer den Wert desjenigen Elementes übernimmt, auf dem der Lesezeiger
steht, der Lesezeiger anfangs vor dem ersten Element steht und bei jedem
Durchlauf um ein Element vorgestellt wird, und die Schleife nach s Durchläufen
terminiert, nimmt a tatsächlich die Werte a1,...,as an.
Bemerkung:
Die zusätzliche Voraussetzung 'Es sei sichergestellt, daß alle rekursiven Prozeduraufrufe
terminieren.' ist notwendig. Während es klar ist, daß jede Aktion außer den rekursiven
Aufrufen im Körper der Schleife nach endlich vielen Schritten terminiert, würde eine solche
Annahme von den rekursiven Aufrufen aber die Gültigkeit des Lemmas voraussetzen.
/HPPD
6HL3HLQ3URJUDPPXQG$HLQ$XVGUXFNLQ3'LH9DULDEOHQOLVWH9EHLQKDOWH
DOOHLQ$DXIWUHWHQGHQ9DULDEOHQPLWLKUHP:HUWDP$QIDQJGHU$XVI KUXQJ
YRQ$'DQQOLHIHUWHLQ$XIUXIGHU3UR]HGXU&RPSXWH6HTXHQFHPLWGHQ
3DUDPHWHUQ$97HLQ%HLVSLHODXVZHUWXQJVIUDJPHQW7YRQ$9ZLUGQLFKW
YHUlQGHUW
Beweis:
Ausdrücke enthalten nur Sonderzeichen, Wörter, Strings, Zahlen und
Variablen. Bei der Bildung von Beispielauswertungen werden hiervon nur
Variablen betroffen, die nämlich durch ihren letzen Wert ersetzt werden.
1. Fall: A="". Dann ist auch T="" ein Beispielauswertungsfragment von A.
2. Fall: A≠"". Sei A="a1,...,as" für s>0.
Sei W das while-Konstrukt von P, dessen Ausdruck A ist und E eine Entfaltung
von W.
Nach Lemma 4.3.1 terminiert die solange-Schleife in s Durchläufen und a
nimmt nacheinander die Werte a1,...,as an. Da bei jedem Schleifendurchlauf T
(das am Anfang leer war) um ein Element ergänzt wird, hat T nach s
Schleifendurchläufen die Form T="b1,...,bs".
Falls für ein i ai ist Sonderzeichen, Wort, String oder Zahl, gilt ai = bi.
Es bleibt zu zeigen, falls für ein i ai ist das j-te Vorkommen der Variablen v in E,
dann ist bi = val(v,j-1,E).
6HLWH

$XWRPDWLVFKH*HQHULHUXQJYRQ%HLVSLHODXVZHUWXQJHQ
Da A weder Inkremente noch Dekremente enthält, ist val(v,j-1,E) aber gleich
dem letzten Wert von ai vor der Auswertung von A. Der ist aber in V
gespeichert. Da bi gleich diesem Wert gesetzt wird, ist das Lemma bewiesen.
V wir in ComputeSequence bei der Bearbeitung von Sonderzeichen, Zahlen,
Strings und Wörtern nicht benutzt, bei der Bearbeitung von Variablen wird nur
lesend auf V zugegriffen. Deswegen wird V bei der Bearbeitung eines Ausdrucks
nicht verändert.
Bemerkung:
Im Beweis von Lemma 4.3.2 wurde keine Aussage über die Entfaltung E gemacht. In der Tat
gibt uns das Führen einer Variablenliste die Möglichkeit, Beispielauswertungen zu berechnen,
ohne die endgültige Struktur der Entfaltung kennen zu müssen.
/HPPD
6HL3HLQ3URJUDPP1HLQH(LQJDEHXQG$HLQH$QZHLVXQJVVHTXHQ]LQ3
'LH9DULDEOHQOLVWH9EHLQKDOWHDOOHLQ$DXIWUHWHQGHQ9DULDEOHQRKQHGLH
ORNDOHQ9DULDEOHQHYHQWXHOOLQ$HQWKDOWHQHQZKLOH.RQVWUXNWHPLWLKUHQ
:HUWHQDP$QIDQJGHU$XVI KUXQJYRQ$LQGHU.RPSRQHQWHHQGZHUW'LH
3UR]HGXU6DPSOH6HTXHQFHZHUGHPLWGHQ3DUDPHWHUQ$97DXIJHUXIHQ
'DQQJLOWQDFKGHP$XIUXI
'LH3UR]HGXUWHUPLQLHUWQDFKHQGOLFKYLHOHQ6FKULWWHQ
7LVWHLQ%HLVSLHODXVZHUWXQJVIUDJPHQWYRQ$
9HQWKlOWDOOHLQ$DXIWUHWHQGHQ9DULDEOHQRKQHORNDOH9DULDEOHQ
HQWKDOWHQHUZKLOH.RQVWUXNWHXQGLKUH:HUWHDP(QGHGHU$XVI KUXQJ
YRQ$LQGHU.RPSRQHQWHHQGZHUW
Beweis:
1. Fall: A="". Dann terminiert die Prozedur sofort, T="" ist ein
Beispielauswertungsfragment von A, und V wurde nicht verändert und enthält
immer noch die letzen Werte der Variablen.
2. Fall: A≠"". Sei A="a1,...,as" für s>0.
(vollständige Induktion über D(A))
Induktionsverankerung für D(A)=0:
1. Die Prozedur terminiert nach endlich vielen Schritten
Nach Lemma 4.3.1 terminiert die solange-Schleife in s Durchläufen und a
nimmt nacheinander die Werte a1,...,as an (man beachte, daß wegen D(A) = 0
keine rekursiven Aufrufe erfolgen). Da bei jedem Schleifendurchlauf T (das
am Anfang leer war) um ein Element ergänzt wird, hat T nach s
Schleifendurchläufen die Form T="b1,...,bs".
2. T ist Beispielauswertungsfragment von A
Es sei D(A)=0, dann enthält A keine while-Konstrukte. Demnach entsteht ein
Beispielauswertungsfragment von A durch Ersetzen der Variablen durch ihre
Werte, wobei Variablen aber auch in Inkrementen und Dekrementen
auftreten dürfen.
6HLWH

$XWRPDWLVFKH*HQHULHUXQJYRQ%HLVSLHODXVZHUWXQJHQ
Sei ai ein beliebiges Element in A für ein i∈{1,...,s}. ai kann Sonderzeichen,
Wort, String, Zahl, Variable, Inkrement oder Dekrement sein.
Falls ai ist Sonderzeichen, Wort, String oder Zahl, dann ist bi = ai.
Andernfalls muß ai ein Vorkommen einer Variablen sein (eventuell in einem
Inkrement oder Dekrement). Sei E eine Entfaltung von P und N. Falls ai ist
Hauptvariable von P, setze E' := E. Ansonsten sei W das while-Konstrukt,
dessen lokale Variable ai ist. Dann sei E' die Entfaltung von W in E.
Es ist zu zeigen, daß bi = val(v,j,E'), wobei aj das j-tes Auftreten der Variablen
v in E' sei (eventuell in einem Inkrement oder Dekrement).
Behauptung: bi = val(v,j,E') und V enthält nach dem i-ten Schleifendurchlauf
den Wert bi für die Variable v.
Sei g die Nummer des ersten Vorkommens von v in A und h die Nummer des
letzten Vorkommens von v in A.
(vollständige Induktion über die Nummer j des Auftretens von v in A (g≤j≤h))
Induktionsverankerung für das erste Auftreten von v in A:
Vor dem ersten Vorkommen j = g von v enthält V den letzten Wert von v
nach Voraussetzung.
1. Fall: ai ist Variable v (außerhalb eines Inkrementes oder Dekrementes)
dann ist bi = val(v,g-1,E') = val(v,g,E'), da val(v,g-1,E') in V
gespeichert ist.
2. Fall: ai ist Inkrement ++v,
dann ist bi = val(v,g-1,E')+1 = val(v,g,E'), da val(v,g-1,E') in V
gespeichert ist.
3. Fall: ai ist Dekrement --v,
⎧val(v, g - 1, V’ ) - 1, wenn val(v, g - 1, V’ ) > 0
dann gilt bi = ⎨
⎩0 sonst
= val(v,g,E')
In jedem dieser Fälle enthält V nach dem i-ten Schleifendurchlauf den
Wert val(v,g,E') der Variablen v.
Induktionsvoraussetzung für das j-te Vorkommen von v in A:
bi val(v,j,E') und V enthält nach dem i-ten Schleifendurchlauf den Wert bi
für die Variable v.
6HLWH

$XWRPDWLVFKH*HQHULHUXQJYRQ%HLVSLHODXVZHUWXQJHQ
Induktionsbehauptung für das (j+1)-te Vorkommen von v in A:
bi = val(v,j+1,E') und V enthält nach dem i-ten Schleifendurchlauf den
Wert bi für die Variable v.
Induktionsschluß:
1. Fall: ai ist Variable v (außerhalb eines Inkrementes oder Dekrementes)
dann ist bi = val(v,j,E') = val(v,j+1,E'), da val(v,j,E') in V
gespeichert ist nach Induktionsvoraussetzung.
2. Fall: ai ist Inkrement ++v,
dann ist bi = val(v,j,E')+1 = val(v,j+1,E'), da val(v,j,E') in V
gespeichert ist nach Induktionsvoraussetzung
3. Fall: ai ist Dekrement --v,
⎧val(v, j, E’ ) - 1, wenn val(v, j, E’ ) > 0
dann gilt bi = ⎨
⎩0 sonst
= val(v,j+1,E')
In jedem dieser Fälle enthält V nach dem ersten Schleifendurchlauf den
Wert val(v,j+1,E') der Variablen v.
Demnach entsteht T aus A durch Ersetzen jedes Vorkommens einer
Variablen (einschließlich Inkremente und Dekremente) durch ihren Wert,
somit ist T Beispielauswertungsfragment zu A.
3. V enthält alle in A auftretenden Variablen (ohne lokale Variablen
enthaltener while-Konstrukte) und ihre Werte am Ende der Ausführung von
A.
Wir haben unter 2. gezeigt, daß für jedes letzte Auftreten h einer Variablen v
von A, val(v,h,E') in V gespeichert wird. Dann enthält V die Werte alle
Variablen von A am Ende von A.
Induktionsvoraussetzung:
Es sei D(A) = d > 0. Dann gelte die Behauptung.
Induktionsbehauptung:
Es sei D(A) = d+1. Dann gelte ebenfalls die Behauptung.
Induktionsschluß:
1. Die Prozedur terminiert nach endlich vielen Schritten
In der Prozedur ComputeSequence kann ein rekursiver Aufruf nur auftreten,
wenn als Programmfragment ein Ausdruck oder eine Anweisungssequenz
eines lokalen while-Konstruktes von A übergeben wird. Für diese
Programmfragmente ist aber die Schachtelungstiefe kleiner gleich d. Nach
Induktionsvoraussetzung ist dann die Termination der Abarbeitung des
6HLWH

$XWRPDWLVFKH*HQHULHUXQJYRQ%HLVSLHODXVZHUWXQJHQ
rekursiven Aufrufs der Prozedur sichergestellt. Dann kann Lemma 4.3.1
angewendet werden. Dies sagt aus, daß die solange-Schleife in s
Durchläufen terminiert und a nacheinander die Werte a1,...,as annimmt. Da
bei jedem Schleifendurchlauf T (das am Anfang leer war) um ein Element
ergänzt wird, hat T nach s Schleifendurchläufen die Form T="b1,...,bs".
2. T ist Beispielauswertungsfragment von A
Wir zeigen: Nach dem i-ten Schleifendurchlauf ist b1,...,bi ein
Beispielauswertungsfragment von a1,...,ai und V enthält die Endwerte aller
Variablen nach Auswertung des Elementes ai (1≤i≤s).
(vollständige Induktion über die Nummer i des Auftretens einer Anweisung
in A (1≤i≤s))
Induktionsverankerung:
a1 kann Sonderzeichen, Wort, String, Zahl, Variable, Inkrement,
Dekrement oder ein while-Konstrukt sein. Dabei werden bei der
Erstellung von Beispielauswertungen nur Variablen, Dekremente,
Inkremente und while-Konstrukte verändert.
Falls a1 ist Sonderzeichen, Wort, String oder Zahl, dann ist b1 = a1.
Sei a1 jetzt eine Variable v (eventuell in einem Inkrement oder
Dekrement).
Sei E eine Entfaltung von P. Falls a1 Hauptvariable, setze E' := E.
Ansonsten sei W dasjenige while-Konstrukt von P, dessen lokale Variable
v ist und E' ist die Entfaltung von W in E. Sei a1 das j-te Auftreten der
Variablen v in E'.
Es ist zu zeigen, daß b1 = val(v,j,E').
v ist nach Voraussetzung in V enthalten, somit ist auch der Wert von v vor
der Bearbeitung der Anweisung (val(v,j-1,E')) bekannt.
1. Fall: a1 ist Variable v (außerhalb eines Inkrementes oder
Dekrementes),
dann ist b1 = val (v,j-1,E') = val(v,j,E').
2. Fall: a1 ist Inkrement ++v,
dann ist b1 = val(v,j-1,E')+1 = val(v,j,E')
3. Fall: a1 ist Dekrement --v,
⎧val(v, j - 1, E’ ) - 1, wenn val(v, j - 1, E’ ) > 0
dann gilt b1 = ⎨
⎩0 sonst
= val(v,j,E')
6HLWH

$XWRPDWLVFKH*HQHULHUXQJYRQ%HLVSLHODXVZHUWXQJHQ
In jedem dieser Fälle enthält V nach dem ersten Schleifendurchlauf den
Wert val(v,j,E') der Variablen v.
Sei a1 jetzt ein while-Konstrukt der Form "with K 1 ,...,K t while C do
D end while", wobei für ein t K1,...,Kt die lokalen
Initialisationskonstrukte von a1 , C der Ausdruck von a1 und D die
Anweisungssequenz von a1. Man beachte, daß V vor dem ersten rekursiven
Aufruf alle in C und D vorkommenden Variablen enthält mit ihren
Anfangswerte bei der Bearbeitung von C.
Es erfolgen vier rekursive Aufrufe:
a) ComputeSequence(C, V, T1)
b) ComputeSequence(D, V, T2)
c) ComputeSequence(C, V, T3)
d) ComputeSequence(D, V, T4)
Nach Lemma 4.3.2 enthält T1 nach der Ausführung von a) ein
Beispielauswertungsfragment von C und V wird nicht verändert. Demnach
enthält V die Wert der Variablen am Anfang der Auswertung von D.
Nach der Induktionsvoraussetzung (äußere Induktion) enthält T2 nach
Ausführung der Anweisung b) ein Beispielauswertungsfragment von D
und V enthält die Werte der in D vorkommenden Variablen am Ende der
Abarbeitung.
Deswegen kann wieder Lemma 4.3.2 für die Anweisung c) verwendet
werden, wonach T3 ein Beispielauswertungsfragment von C für die
Variablenliste V ist. V wird nicht verändert.
V enthält damit die Werte der Variablen vor der Ausführung von D. Nach
Induktionsvoraussetzung erhält T4 nach der Ausführung des Aufrufs d)
ein Beispielauswertungsfragment von D und V enthält die Werte der
Variablen nach der Bearbeitung von D (*).
Bei der Bildung einer Beispielauswertung muß a1 in vier Stufen verändert
werden:
I. Überführen von a1 zu E(a1) als Teil von E
II. Ersetzen jedes Vorkommen einer Variablen in a1 durch ihren Wert.
III. Löschen jeder Initialisationssequenz in a1.
IV. Löschen aller Schlüsselworte "with" in a1.
Beweis der einzelnen Stufen der Bildung der Beispielauswertung:
I. Überführen von W in eine Entfaltung E''.
Nach obigen Ausführungen werden bei der Bearbeitung von a1 zwei
Beispielauswertungsfragmente T2 und T4 der Anweisungssequenz D von
a1 berechnet. Bei der Berechnung dieser Beispielauswertungen müssen
Entfaltungen E1 und E2 von D zugrunde gelegen haben. Dann ist das
folgende Konstrukt E'' eine Entfaltung von a1:
6HLWH

$XWRPDWLVFKH*HQHULHUXQJYRQ%HLVSLHODXVZHUWXQJHQ
with
K 1 ,...,K t
test C do E 1 end test
test C do E 2 end test
Dann hat jede Beispielauswertung von E’’ die Gestalt:
test C* do E* 1 end test
test C* do E* 2 end test
Dabei seien C*, E*1 und E*2 Beispielauswertungsfragmente. Genau dieses
Konstrukt wird aber bei der Bearbeitung von a1 erzeugt. Demnach wird
bei der Konstruktion der Beispielauswertung von a1 tatsächlich eine
Entfaltung E'' von a1 angewendet.
II. Ersetzen jedes Vorkommen einer Variablen in W durch ihren Wert.
T1,T2,T3,T4 sind Beispielauswertungen, enthalten damit keine Variablen,
dann enthält auch
test T1 do T2 end test
test T3 do T4 end test
keine Variablen. Dieses Konstrukt ist aber gerade b1.
III. Löschen jeder Initialisationssequenz in W.
Es wird an keiner Stelle in der Prozedur ComputeSequence ein
Initialisationskonstrukt in das Beispielauswertungsfragment T eingefügt.
IV. Löschen aller Schlüsselworte "with" in W.
Es wird an keiner Stelle in der Prozedur ComputeSequence das
Schlüsselwort "with" in T eingefügt.
Bei der Bearbeitung von a1 wird das Konstrukt
test T1 do T2 end test
test T3 do T4 end test
am Ende von T angefügt. Es handelt sich dabei tatsächlich um eine
Beispielauswertungsfragment von a1.
Es bleibt zu zeigen, daß V die Endwerte aller Variablen in A nach
Auswertung von a1 enthält:
Nach Voraussetzung enthielt V die Endwerte aller Variablen vor der
Auswertung von a1.
Als erstes stellen wir fest, daß V nur in einem der drei folgenden Fälle
verändert wird:
(1) a1 ist Inkrement,
(2) a1 ist Dekrement,
(3) a1 ist while-Konstrukt.
6HLWH

$XWRPDWLVFKH*HQHULHUXQJYRQ%HLVSLHODXVZHUWXQJHQ
In den Fällen (1) und (2) wird aber nur der Wert einer Variablen
überschrieben, und zwar mit dem korrektem neuen Wert dieser Variablen.
Also enthält V die Werte aller Variablen nach der Ausführung von a1.
Den Fall (3) haben wir bereits mit (*) abgehandelt.
Induktionsvoraussetzung:
Die Behauptung gilt für alle Anweisungen a1,..,ai (1≤i≤s).
Induktionsbehauptung:
Die Behauptung gelte für ai+1.
Induktionsschluß:
ai+1 kann Sonderzeichen, Wort, String, Zahl, Variable, Inkrement,
Dekrement oder ein while-Konstrukt sein. Dabei werden bei der
Erstellung von Beispielauswertungen nur Variablen, Dekremente,
Inkremente und while-Konstrukte verändert.
Falls ai+1 ist Sonderzeichen, Wort, String oder Zahl, dann ist bi+1 = ai+1.
Sei ai+1 jetzt eine Variable v (eventuell in einem Inkrement oder
Dekrement).
Wiederum sei E eine Entfaltung von P. Falls ai+1 Hauptvariable, setze E'
:= E. Ansonsten sei W dasjenige while-Konstrukt von P, dessen lokale
Variable v ist und E' ist die Entfaltung von W in E.
Es sei für ein j ai+1 das j-te Auftreten von v in E'. Es ist zu zeigen, daß bi+1
= val(v,j,E').
Hilfsbehauptung:
Beweis:
Nach dem i-tem Schleifendurchlauf enthält V den Wert
val(v,j-1,E') als Endwert für die Variable v.
Nach Induktionsvoraussetzung enthält V den Wert die
aktuellen Werte aller Variablen des Programmes.
Dann enthält V den Wert der Variablen v bei deren
letzem Auftreten, also val(v,j-1,E'). (Hilfsbehauptung)
Diese Hilfsbehauptung ermöglicht uns die folgenden Aussagen:
1. Fall: ai+1 ist Variable v (außerhalb eines Inkrementes oder
Dekrementes),
dann ist bi+1 = val (v,j-1,E') = val(v,j,E').
2. Fall: ai+1 ist Inkrement ++v,
dann ist bi+1 = val(v,j-1,E')+1 = val(v,j,E').
6HLWH

$XWRPDWLVFKH*HQHULHUXQJYRQ%HLVSLHODXVZHUWXQJHQ
3. Fall: ai+1 ist Dekrement --v,
⎧val(v, j - 1, E’ ) - 1, wenn val(v, j - 1, E’ ) > 0
dann gilt bi+1 = ⎨
⎩0 sonst
= val(v,j,E’)
In jedem dieser Fälle enthält V nach dem (i+1)-ten Schleifendurchlauf den
Wert val(v,j,E') der Variablen v.
Sei ai+1 jetzt ein while-Konstrukt der Form "with K 1 ,...,K t while C
do D end while", wobei für ein t K1,...,Kt die lokalen
Initialisationskonstrukte von ai , C der Ausdruck von a1 und D die
Anweisungssequenz von ai+1.
Es erfolgen vier rekursive Aufrufe:
a) ComputeSequence(C, V, T1)
b) ComputeSequence(D, V, T2)
c) ComputeSequence(C, V, T3)
d) ComputeSequence(D, V, T4)
Nach der Induktionsbehauptung der inneren Induktion beinhaltet V die
Werte aller Variablen des Programmes vor der Auswertung von ai+1, somit
auch vor der ersten Ausführung von C. Dann kann Lemma 4.3.2
angewandt werden. und T1 enthält nach der Ausführung von a) ein
Beispielauswertungsfragment von C und V wird nicht verändert. Demnach
enthält V die Wert der Variablen am Anfang der Auswertung von D.
Nach der Induktionsvoraussetzung der äußeren Induktion enthält T2 nach
Ausführung der Anweisung b) ein Beispielauswertungsfragment von D
und V enthält die Werte der in D vorkommenden Variablen am Ende der
Abarbeitung. Damit enthält V auch die Werte der Variablen vor der
zweiten Ausführung von C.
Deswegen kann wieder Lemma 4.3.2 für die Anweisung c) verwendet
werden, wonach T3 ein Beispielauswertungsfragment von C für die
Variablenliste V ist. V wird dabei nicht verändert.
V enthält damit die Werte der Variablen vor der Ausführung von D. Nach
Induktionsvoraussetzung erhält T4 nach der Ausführung des Aufrufs d)
ein Beispielauswertungsfragment von D und V enthält die Werte der
Variablen nach der Bearbeitung von D (*).
Bei der Bildung einer Beispielauswertung muß ai+1 in vier Stufen
verändert werden:
I. Überführen von ai+1 zu E(ai+1) als Teil von E
II. Ersetzen jedes Vorkommen einer Variablen in ai+1 durch ihren Wert.
III. Löschen jeder Initialisationssequenz in ai+1.
IV. Löschen aller Schlüsselworte "with" in ai+1.
6HLWH

$XWRPDWLVFKH*HQHULHUXQJYRQ%HLVSLHODXVZHUWXQJHQ
Der Beweis, daß bi+1 diesen vier Schritte genügt, ist vollkommen analog zu
dem Beweis in der Induktionsverankerung der inneren Induktion.
Demnach ist beweisen, daß bi+1 ein Beispielauswertungsfragment von ai+1
ist.
Wir müssen nun zeigen, daß V die Werte aller Variablen des Programmes
nach der Ausführung von ai+1 enthält. V wird in der Prozedur nur bei der
Abarbeitung eines Inkrementes, eines Dekrementes und eines while-
Konstruktes verändert.
Im Falle eines Inkrementes oder Dekrementes wird jeweils nur der
Endwert einer Variablen verändert. Dieser wird aber auf den neuen Wert
der Variablen gesetzt. Alle anderen Variablen in V werden nicht
verändert. Also enthält die Werte aller Variablen nach der Ausführung
von ai+1.
Für den Fall, daß ai+1 ein while-Konstrukt ist, ist die Behauptung durch (*)
bewiesen.
Nach Induktion folgt die Behauptung: Für alle i (1≤i≤s) ist b1....bi ein
Beispielauswertungsfragment von a1...ai. Damit ist für i = s Schritt 2
bewiesen: T ist Beispielauswertungsfragment für A.
3. V enthält alle in A auftretenden Variablen (ohne lokale Variablen
enthaltener while-Konstrukte) und ihre Werte am Ende der Ausführung von
A.
Mit der inneren Induktion in Schritt 2 haben wir bewiesen, daß für alle i
(1≤i≤s) V nach dem i-ten Schritt die Werte der Variablen nach der
Auswertung von ai enthält. Damit folgt die Behauptung 3 für den Fall i = s.
Damit ist auch die äußere Induktion abgeschlossen und das Lemma bewiesen.
Bemerkung:
Für die Berechnung der Beispielauswertungsfragmente der Anweisungssequenzen eines
Programmes P muß die Entfaltung E = E(P) nicht im voraus bekannt sein, da zur Ermittlung
der Variablenwerte das Führen von Variablenlisten ausreichend ist.
6DW]
6HL3HLQEHOLHELJHV3URJUDPPXQG1HLQHEHOLHELJHJHRUGQHWH0HQJH
QDW UOLFKHU=DKOHQPLW_1_ _(93_'DQQEHUHFKQHWGHU$OJRULWKPXV
&RPSXWH3URJUDPÃEHL(LQJDEHYRQ3XQG1HLQH%HLVSLHODXVZHUWXQJ6YRQ3
Beweis:
Sei P ="input (x 1 ,...,x m ) A output y", wobei x1,...,xm,y Variablen und A
eine Anweisungssequenz ist.
6HLWH

$XWRPDWLVFKH*HQHULHUXQJYRQ%HLVSLHODXVZHUWXQJHQ
Hilfsbehauptung:
Die Variablenliste V enthält beim Aufruf von ComputeSequence alle Variablen
von A, die nicht lokale Variable eines while-Konstruktes sind, mit ihrem letzten
Wert vor der ersten Anweisung von A.
Beweis:
Die Variablen in A, die nicht lokale Variable eines while-Konstruktes sind, sind
die Hauptvariablen von P. Sei v eine solche Hauptvariable.
1. Fall: v ist Eingabevariable. Dann muß v im Eingabekonstrukt vorkommen
und der Anfangswert von v ergibt sich unabhängig von E(P) aus N, und zwar ist
dies der i-te Eintrag in N, wenn v die i-te Variable im Eingabekonstrukt ist
(1≤i≤|EV(P)|) Dieser Wert wird aber zusammen mit v in V eingetragen. Da der
Wert von v sich nicht im globalen Initialisationskonstrukt verändert werden
kann, ist dieser Wert der letzte Wert von v vor der ersten Anweisung von A.
2. Fall: v ist globale Variable. Dann muß v in der globalen
Initialisationssequenz vorkommen. Sei K das Initialisationskonstrukt von v. K
habe die Gestalt "set (v := µ)".
1. Unterfall: µ ist sie Zahl c. Dann ist c der Anfangswert von v für jede
Entfaltung E(P) und wird zusammen mit v in V eingetragen. v kann ihren Wert
in der globalen Initialisationssequenz nicht mehr ändern. Also ist c der Wert
von v vor der ersten Anweisung von A.
2. Unterfall: µ ist die Variable w. w kann keine globale Variable sein, da globale
Variablen nur einmal in der globalen Initialisationssequenz vorkommen dürfen,
nämlich auf der rechten Seite ihres Initialisationskonstruktes. Also kann w nur
eine Eingabevariable sein. Deren Wert steht aber in V. Dann wird auch v mit
ihrem korrekten Anfangswert in V eingetragen. Da dieser sich nicht in der
globalen Initialisationssequenz ändern kann, enthält V auch in diesem Fall den
Wert von v vor der ersten Anweisung von A. (Hilfsbehauptung)
Nach der Hilfsbehauptung kann Lemma 4.3.3 angewendet werden. Danach gilt
für den Aufruf ComputeSequence (A,V,T), daß
1. Die Prozedur terminiert nach endlich vielen Schritten.
2. T ist ein Beispielauswertungsfragment von A.
3. V enthält alle in A auftretenden Variablen (ohne lokale Variablen
enthaltener while-Konstrukte) und ihre Werte am Ende der Ausführung von
A.
Wegen 3. muß auch der letzte Wert c der Variablen y in V enthalten sein. Sei N
= {n1,...,nm}. Damit ist "input (n 1 ,...,n m ) T output c" eine
Beispielauswertung für P.
6HLWH

$XWRPDWLVFKH*HQHULHUXQJYRQ%HLVSLHODXVZHUWXQJHQ
4.4 Komplexität
/HPPD
6HL9HLQH9DULDEOHQOLVWHGHU/lQJHP'DQQEHWUlJWGHUK|FKVWH6FKULWW]DKO
I U
ì GDV(LQI JHQHLQHU9DULDEOHQDP(QGHGHU/LVWH
ì GDV/HVHQHLQHU9DULDEOHQ
ì GDVbQGHUQGHV:HUWHVHLQHU9DULDEOHQ
ì GDV6XFKHQHLQHU9DULDEOHQLQGHU/LVWH
ì GDV/|VFKHQGHU9DULDEOHQOLVWH
MHZHLOV2P
Beweis:
Da eine Variablenliste als lineare Liste implementiert werden kann, folgt die
Behauptung aus den entsprechenden Abschätzungen für die lineare Liste.
/HPPD
6HL3HLQ3URJUDPP6HL$HLQH$QZHLVXQJVVHTXHQ]LQ3XQG9HLQH
9DULDEOHQOLVWHGLHDOOH9DULDEOHQLQ$PLWLKUHP:HUWYRUGHUHUVWHQ
$QZHLVXQJYRQ$HQWKlOWI UHLQH(QWIDOWXQJ(36HLQGLH=DKOGHU
$QZHLVXQJHQYRQ$HLQVFKOLH‰OLFKGHU$QZHLVXQJHQLQGHQ$XVGU FNHQXQG
$QZHLVXQJVVHTXHQ]HQLQ$HQWKDOWHQHUZKLOH.RQVWUXNWHXQGPGLH
*HVDPW]DKOYRQ9DULDEOHQLQ3HLQVFKOLH‰OLFKORNDOHU9DULDEOHQLQ$
HQWKDOWHQHUZKLOH.RQVWUXNWH'DQQWHUPLQLHUWGLH3UR]HGXU
&RPSXWH6HTXHQFHEHLGHP$XIUXI&RPSXWH6HTXHQFH$97QDFKK|FKVWHQV
2PòQ6FKULWWHQ
Beweis:
Sei A = "", so terminiert die Prozedur in konstanter Zeit.
Sei A ≠ "".
Nach Lemma 4.3.1 terminiert die solange-Schleife in s Schleifendurchläufen in
ComputeSequence und die Variable a nimmt nacheinander die Werte a1,...,as an.
(vollständige Induktion über D(A))
Induktionsverankerung:
Für D(A) = 0 erfolgt kein rekursiver Aufruf der Prozedur ComputeSequence.
Demnach ist n = s. Für die Bearbeitung von Variablen, Inkrementen und
Dekrementen ist nach Lemma 4.4.1 eine Komplexität O(m) anzusetzen,
während alle anderen Aktionen in einem Schleifendurchlauf nur konstanten
Zeitbedarf besitzen.
Induktionsvoraussetzung:
Es sei d > 0 und d' < d. Für D(A') = d' terminiere der Aufruf der Prozedur
ComputeSequence nach höchstens O(m'²n') Schritten, wobei A' eine
Anweisungssequenz, n' die Zahl der Anweisungen von A' und m die Zahl der
Variablen von A' ist.
6HLWH

$XWRPDWLVFKH*HQHULHUXQJYRQ%HLVSLHODXVZHUWXQJHQ
Induktionsbehauptung:
Für D(A) = d terminiere der Aufruf der Prozedur ComputeSequence nach
höchstens O(m²n) Schritten.
Induktionsschluß:
Seien W1,...,Wk für ein k∈© die lokalen while-Konstrukte von A und sei p die
Zahl der Variablen in A, die innerhalb von A vorkommen, aber nicht lokale
Variable eines in A enthaltenen while-Konstruktes sind. Sei für i∈{1,..,k} ni
die Zahl der Anweisungen von Wi und mi die Zahl der lokalen Variablen von
Wi.
k
Dann gilt m = p + ∑ m und n = s + n i
∑ i .
i=1
Wir wollen jetzt den Zeitbedarf für einen Schleifendurchlauf in Abhängigkeit
von der Art der im Schleifendurchlauf gelesenen Anweisung angeben.
Sei für ein i∈{1,..,s} ai eine Anweisung:
Sei ai eine Zahl, eine Wort, eine Zeichenkette oder ein Trennzeichen, so
erfolgt der Schleifendurchlauf in konstanter Zeit.
Sei ai eine Variable, eine Inkrement oder ein Dekrement, so ist ein
maximaler Zeitbedarf O(p) notwendig, da Zugriffe auf die Variablenliste
notwendig sind.
Sei ai eine while-Konstrukt, etwa Wj, für ein j∈{1,..,k},so rührt der Zeitbedarf
für den Schleifendurchlauf vor allem aus drei Aktionen:
Das Eintragen der lokalen Variablen in V, den vierfachen rekursiven Aufruf
und das Löschen der lokalen Variablen aus V.
Das Eintragen der lokalen Variablen in die Variablenliste V benötigt eine
maximale Komplexität O(p+mj)², da während des Einfügens der Variablen in
der Liste gesucht werden müssen.
Sei C der Ausdruck von Wj und D die Anweisungssequenz von Wj. Da D(C) =
1 und D(D) < d folgt nach Induktionsvoraussetzung für die rekursiven
Aufrufe ein maximaler Zeitbedarf O((p+mi)²ni).
Das Entfernen der lokalen Variablen aus V kann mit einem Aufwand von
O(p) geschehen.
k
i=1
Dann läßt sich der maximale Zeitbedarf für die Prozedur abschätzen durch:
k
∑
O((s - k)p) + (O(p + m ) + O((p + m ) n ) + O(p))
i=1
i
2
Wir können sehen, daß wir innerhalb der Summe nur den Term O((p+mi)²ni
beibehalten müssen.
Umformung ergibt:
k
∑
O((s - k)p) + O((p + m ) n )
i=1
i
2
i
i
2
i
6HLWH

$XWRPDWLVFKH*HQHULHUXQJYRQ%HLVSLHODXVZHUWXQJHQ
Es gilt nun sicherlich
k
∑
O((s - k)p) + O((p + m ) n ) ≤ O(sp) + O((p + m ) (s + n ))
i=1
i
2
i
und hieraus folgt für den maximalen Zeitbedarf h der Prozedur:
h = O(sp) + O(m²n) = O(m²n).
6DW]
6HL3HLQ3URJUDPPXQG1HLQH(LQJDEHPHQJHPLW_1_ _(93_6HLQGLH
=DKOGHU$QZHLVXQJHQYRQ3HLQVFKOLH‰OLFKGHU$QZHLVXQJHQLQGHQ
$XVGU FNHQXQG$QZHLVXQJVVHTXHQ]HQLQ3HQWKDOWHQHUZKLOH.RQVWUXNWH
XQGPGLH*HVDPW]DKOYRQ9DULDEOHQLQ3HLQVFKOLH‰OLFKORNDOHU9DULDEOHQLQ
3HQWKDOWHQHUZKLOH.RQVWUXNWH'DQQWHUPLQLHUWGHU$OJRULWKPXV
&RPSXWH3URJUDPQDFKK|FKVWHQV2PòQ6FKULWWHQ
Beweis:
Sei p die Zahl der Hauptvariablen von P. Nach Lemma 4.4.1 ist der Zeitbedarf
für den Zugriff auf eine Variablenliste durch O(q) beschränkt, wobei q die Länge
der Variablenliste ist. Der Zeitbedarf für das Eintragen der Eingabevariablen
beträgt höchstens O(p), während der Zeitbedarf für das Eintragen der globalen
Variablen durch O(p²) abgeschätzt werden darf. Nach dem Beweis von Satz
4.3.1 wissen wir, daß in der Variablenliste V die Hauptvariablen mit ihrem
Wert vor der ersten Anweisung von P eingetragen sind. Nach Lemma 4.4.2
terminiert der Aufruf der Prozedur ComputeSequence nach höchstens O(m²n)
Schritten. Für das Finden des Wertes der Ausgabevariablen ist nur ein
Zeitbedarf von maximal O(p) notwendig. Wir sehen also, daß in dem
Algorithmus das Zeitverhalten durch den Prozeduraufruf bestimmt wird. Auch
das vorherige Parsen des Programmes fällt nicht ins Gewicht. Deswegen gilt
auch für den Algorithmus ein maximaler Zeitbedarf O(m²n).
k
∑
i=1
i
2
k
∑
i=1
i
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
5 Automatische Synthese von Klasse-I-Programmen
In diesem Kapitel wird ein Algorithmus zur automatischen Synthese von WHILE-
Programmen aus Beispielauswertungen angegeben und seine Korrektheit bewiesen. Dabei
schränken wir unsere Klasse der zu synthetisierenden Algorithmen ein auf die Klasse-I-
Programme, für die sowohl die Synthese als auch der Korrektheitsbeweis einfach zu
bewerkstelligen sind. Für diese Klasse erhalten wir bemerkenswerte Resultate:
ì
ì
Bei Eingabe einer Beispielauswertung eines Programmes P liefert der Synthesealgorithmus
ein Programm Q, das sich von P nur in den Namen der Variablen und der Reihenfolge der
Initialisierungen unterscheidet.
Die Laufzeit des Synthesealgorithmus ist linear zur Größe der Eingabe.
5.1 Idee
Bei der (automatischen und manuellen) Generierung von Beispielauswertungen werden im
wesentlichen zwei Operationen vorgenommen:
1. Die Ersetzung von Variablen, Inkrementen und Dekrementen durch Zahlen.
2. Die Ersetzung von while-Konstrukten durch Entfaltungen.
Wir haben bereits bei der automatischen Generierung von Beispielauswertungen die
Bedeutung von Variablenlisten kennengelernt. Dabei wurden sie benutzt, um den Wert einer
Variablen ohne genaue Kenntnis der Entfaltungen zu bestimmen. Dabei war der letzte Wert
der Variablen in der Variablenliste gespeichert. Da der Name der Variablen, deren Wert zu
bestimmen war, bekannt ist, kann der gesuchte Wert durch einen lesenden Zugriff auf die
Variablenliste bestimmt werden. In Umkehrung dieses Verfahren wollen wir jetzt aus der
Kenntnis einer Variablenliste und dem aktuellen Wert einer Variablen an einer Position den
Namen einer Variablen bestimmen. Es ist sofort einsichtig, daß diese Aufgabe im allgemeinen
nicht eindeutig lösbar ist. Wir müssen deswegen die Klasse der Programme beschränken auf
eine Teilklasse, bei denen die Aufgabe eindeutig lösbar ist.
Jedes while-Konstrukt wird bei der Entfaltung in eine Folge von mindestens zwei Konstrukten
der Form "test ... do ... end test" (im folgenden test-Konstrukt genannt)
umgewandelt. Wir können deswegen aus dem Vorkommen zweier dieser Konstrukte
hintereinander auf ein while-Konstrukt schließen. Sich anschließende test-Konstrukte können
als Teil der Entfaltung des while-Konstruktes interpretiert werden oder als Beginn einer
Entfaltung eines anderen while-Konstruktes. Auch hierbei sind Einschränkungen in der Klasse
der lernbaren Programme notwendig.
Wir können wieder unsere Variablenliste verwenden, die wir allerdings um eine Komponente
'neues-lexem' erweitern müssen. Neben den Methoden zur Manipulation des Anfangswertes
und des Endwertes benötigen wird eine Methode zur Generierung neuer Variablen. Eine solche
Variable muß aber verschieden sein von allen anderen Variablen des bereits generierten
Programmfragmentes. Eine Möglichkeit dies zu bewerkstelligen besteht darin, jede neue
Variable zu indizieren, wobei der Index bei jeder Generierung um eins erhöht wird.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
5.2 Klasse-I-Programme
'HILQLWLRQ
(LQ:+,/(3URJUDPP3KHL‰W.ODVVH,3URJUDPPZHQQIROJHQGH
%HGLQJXQJHQHUI OOWVLQG
(VG UIHQNHLQH]ZHLZKLOH.RQVWUXNWHGLUHNWDXIHLQDQGHUIROJHQ
(VNRPPHQNHLQHORNDOHQ9DULDEOHQYRU
'DVHUVWH9RUNRPPHQHLQHU9DULDEOHQLQGHU+DXSWDQZHLVXQJVVHTXHQ]
YRQ3GDUIQLFKWLQQHUKDOEHLQHV,QNUHPHQWHVRGHU'HNUHPHQWHVVHLQ
'DVHUVWH9RUNRPPHQHLQHU9DULDEOHQLQHLQHPZKLOH.RQVWUXNWGDUI
QLFKWLQQHUKDOEHLQHV,QNUHPHQWHVRGHU'HNUHPHQWHVVHLQ
) UMH]ZHL9DULDEOHQLQHLQHPZKLOH.RQVWUXNWPX‰GLH'LIIHUHQ]
]ZLVFKHQLKUHQ:HUWHLQGHUHUVWHQ(QWIDOWXQJLQGHU]ZHLWHQ(QWIDOWXQJ
YHUVFKLHGHQVHLQ
'HILQLWLRQ
(LQH%HLVSLHODXVZHUWXQJHLQHV.ODVVH,3URJUDPPHVKHL‰W.ODVVH,
%HLVSLHODXVZHUWXQJZHQQIROJHQGH%HGLQJXQJHQHUI OOWVLQG
'LH9DULDEOHLQHLQHP'HNUHPHQWGDUILQGHU$QZHLVXQJYRUGHP
'HNUHPHQWQLFKWGHQ:HUWKDEHQ
,QMHGHU$QZHLVXQJDX‰HUKDOEHLQHVZKLOH.RQVWUXNWHVPX‰GLH'LIIHUHQ]
GHU:HUWH]ZHLHU9DULDEOHQPLQGHVWHQVEHWUDJHQ
5.3 Algorithmus
Wir schränken die Klasse der zulässigen Beispielauswertungen auf Klasse-I-
Beispielauswertungen ein. Wir gehen davon aus, daß die Eingabe in einer geparsten und von
Trennzeichen und Kommentaren bereinigter Form vorliegt. Auch die Ausgabe wird in dieser
Form vorliegen.
Algorithmus SampleProgram(S,P)
Eingabe: S : Klasse-I-Beispielauswertung
Ausgabe: P : Programm
Funktion:
Der Algorithmus berechnet ein Programm P aus S
Variablen: V : Variablenliste
A : Anweisungssequenz
i,j : natürliche Zahlen (Zählvariablen)
S habe die Form "input(c 1 ,...,c m ) T output d". Dabei sind m,c 1 ,...,c m ,d
natürliche Zahlen und T ein Beispielauswertungsfragment.
// lösche die Variablenliste und generiere die Eingabevariablen
Lösche V
für i = 1 bis m tue
Generiere neue Variable v i
Trage Variable v i mit Anfangs- und Endwert c i in V ein.
ende für
// Ermittle Anweisungssequenz A aus Beispielauswertungsfragment T und
// bestimme globale Variablen in der Variablenliste V
Rufe SampleSequence (T,V,A) auf.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
// Konstruiere globale Initialisationssequenz
für i = m+1 bis Länge(V) tue
Sei v i die i-te Variable in V und c i ihr Anfangswert.
für j = 1 bis m tue
Sei v j die j-te Variable in V und c j ihr Anfangswert
wenn c j = c i dann Setze K i := "set (v i := v j )".
verlasse für
Abbildung 5 : Struktur des Algorithmus’ SampleProgram
Prozeduraufruf
Rekursion
sampleProgram(S,P)
sampleSequence(T,V,A)
sampleWHILE
(C,D,C’,D’,V,G,H)
testWHILE(B,C,G,H,V,result)
sampleWExpression
(C,C’,V,X,G)
testWExpression
(B,G,V,result)
sampleWStatementSequence
(C,H,V,result)
testWStatementSequence
(C,H,V,result)
matchWHILE
(M,M’,N,N’,V,Y,X,result)
ende für
Wenn K i nicht gesetzt, setze K i := "set (v i := c i )".
ende für
// Bestimme Ausgabevariable
Suche erste Variable y in V mit Endwert d.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
wenn gefunden, dann ist
P = "input(v 1 ,...,v m ) K m+1 ... K Länge(V) A output y",
sonst beende Algorithmus mit Fehlermeldung
ende wenn
Ende Algorithmus sampleProgram
Prozedur sampleSequence(T,V,A)
Eingabe: T : Beispielauswertungsfragment
Ein-/Ausgabe:
V : Variablenliste
Ausgaben: A : Anweisungssequenz
Funktion:
A ist eine Anweisungssequenz zu T und V enthält alle Hauptvariablen
am Ende von T mit ihren Anfangs- und Endwerten
Variablen: t : Auswertung einer Anweisung
// A ist am Anfang leer
A := ""
// Lese T sequentiell
wenn T≠"" tue
Setze Lesezeiger vor das ersten Element in T
solange T noch nicht vollständig gelesen tue (d.h. solange der Lesezeiger steht
nicht hinter dem letzten Element in T)
t := lese nächstes Element in T.
Stelle Lesezeiger einen Eintrag vor.
unterscheide
falls t ist String, Wort oder Sonderzeichen:
füge t am Ende von A an.
falls t ist Zahl:
Suche erste Variable v in V mit Endwert t.
wenn gefunden, dann
füge v am Ende von A an.
sonst
Suche erste Variable v in V mit Endwert t - 1.
wenn gefunden, dann
füge ++v am Ende von A an.
Setze Endwert von v in V auf t.
sonst
Suche erste Variable v in V mit Endwert t + 1.
wenn gefunden, dann
füge --v am Ende von A an.
Setze Endwert von v in V auf t.
sonst
Sei v neue Variable. Füge v am Ende von A an. Trage v in V
ein mit Anfangs- und Endwert t.
ende wenn
ende wenn
ende wenn
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
falls t ist test-Konstrukt der Form "test C do D end test", wobei C
und D Beispielauswertungsfragmente:
wenn Lesezeiger steht nicht hinter dem letzten Element von T und
wenn das nächste Element von T ist test-Konstrukt der Form "test C’
do D’ end test", wobei C' und D' Beispielauswertungsfragmente,
dann
Variablen: u,u' : Auswertung einer Anweisung
result : logischer Wert
G : Ausdruck
H : Anweisungssequenz
u := Lese nächstes Element in T.
Setze Lesemarke ein Element vor.
// Generiere while-Konstrukt aus t und u
Rufe SampleWHILE(C,D,C’,D’,V,G,H) auf, wobei G ein Ausdruck
und H eine Anweisungssequenz ist.
// Füge while-Konstrukt am Ende von A an
Füge "with while G do H end while"
// folgen weitere Entfaltungen des while-Konstruktes?
solange Lesezeiger steht nicht hinter dem letzten Element von T
und solange das nächste Element von T ist test-Konstrukt der
Form "test C’’ do D’’ end test", wobei C'' und D''
Beispielauswertungsfragmente, tue
u' := Lese nächstes Element in T.
Setze Lesemarke ein Element vor.
// Test durchführen
Rufe TestWHILE(C’’,D’’,G,H,V,result) auf.
wenn result = FALSCH, dann
beende Algorithmus mit Fehlermeldung.
ende wenn
ende solange
wenn Lesezeiger steht nicht hinter dem letzten Element von T und
wenn das nächste Element von T ist test-Konstrukt der Form
"test C’’ skip’", wobei C'' ein Beispielauswertungsfragment
ist, dann
u' := Lese nächstes Element in T.
Setze Lesemarke ein Element vor.
Rufe TestWExpression(C’’,G,V,result) auf.
wenn result = FALSCH, dann
beende Algorithmus mit Fehlermeldung.
ende wenn
ende wenn
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
sonst
// test-Konstrukt am Ende der Anweisungssequenz
beende Algorithmus mit Fehlermeldung
ende wenn
andernfalls
// es kann kein weiterer Fall auftreten
beende Algorithmus mit Fehlermeldung
ende unterscheide
ende solange
ende wenn
Ende Prozedur sampleSequence
Prozedur SampleWHILE(C,D,C’,D’,V,G,H)
Eingabe: C,C’,D,D’ : Beispielauswertungsfragmente
Ein-/Ausgabe: V : Variablenliste
Ausgaben: G : Ausdruck
H : Anweisungssequenz
Funktion:
werden
am
Variablen:
G und H sind Ausdruck und Anweisungssequenz
eines while-Konstruktes,
dessen Beispielauswertungsfragment die Folge
test C do D end test
test C’ do D’ end test
ist.
V enthält alle Variablen des Programmes mit ihren Endwerten
am Ende der Auswertung von D'. Neu eingeführte Variablen
in V mit ihrem Anfangswert zu Beginn von C und ihrem Endwert
Ende von D' eingetragen.
X : Variablenliste
// die Variablenliste X dient zur Aufnahme aller in der
// Beispielauswertung verwendeten Variablen
// X ist am Anfang leer
Lösche X.
// Generierung von G. In die Variablenliste V werden nur noch nicht
// vorher verwendete Variablen neu eingetragen, die bisherigen Inhalte werden
// nicht verändert. Jede in G benutzte Variable wird in V aufgenommen mit
// Anfangs- und Endwert gleich dem Wert in der Auswertung C'.
Rufe SampleWExpression(C,C',V,X,G) auf.
// Generierung von H. Neue Variablen werden in V mit ihrem Anfangswert
// in C aufgenommen.
// Die Endwerte der Variablen in V entsprechen den Werten am Ende der
// Auswertung C. Jede in G und H vorkommende Variable steht in X mit Anfangs-
// und Endwert in C'.
Rufe SampleWStatementSequence(D,D',V,X,H) auf.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
// Der Anfangswert jeder Variablen in X muß dem Endwert der
// Variablen in V entsprechen
für jedes v in X tue
Sei a der Anfangswert von v in X.
Sei e der Endwert von v in V.
Wenn e ≠ a, dann
beende Algorithmus mit Fehlermeldung
ende wenn
ende für
// Trage die Endwerte der Variablen in X als Endwerte der Variablen in V ein.
für jedes v in X tue
Sei c der Endwert von v in X.
Setze Endwert von v in V auf c.
ende für
Ende Prozedur SampleWHILE
Prozedur SampleWExpression(C,C’,V,X,G)
Eingabe: C,C’ : Beispielauswertungsfragmente
Ein-/Ausgaben: X,V : Variablenliste
Ausgabe: G : Ausdruck
Funktion:
Variablen:
G ist Ausdruck eines while-Konstruktes, dessen
Beispielauswertungsfragmente in der ersten und zweiten Entfaltung
C und C’ sind. Wird eine Variable in G verwendet, die in V noch nicht
vorkommt, so wird sie in V eingetragen mit dem Anfangswert des
ersten Vorkommens in der Auswertung C. Jede in G verwendete
Variable wird in X eingetragen mit Anfangs- und Endwert aus C’.
t,u : Entfaltungen von Anweisungen
// G ist am Anfang leer
G := "".
// Lese C und C’ parallel
wenn C≠"" und wenn C’≠"" dann
Setze Lesezeiger L vor das erste Element in C. Setze Lesezeiger L’ vor das
erste Element in C’.
solange weder C noch C' vollständig gelesen tue (d.h. weder L steht hinter dem
letzen Element in C noch L' steht hinter dem letzten Element in C')
t := lese nächstes Element in C
u := lese nächstes Element in C'
Stelle L einen Eintrag vor. Stelle L' einen Eintrag vor.
unterscheide
falls t ist String, Wort oder Sonderzeichen:
wenn t = u, dann füge t am Ende von G an.
sonst beende Algorithmus mit Fehlermeldung
ende wenn
falls t ist Zahl c:
wenn u ist Zahl, etwa c'. dann
Suche erste Variable v in V und X mit Endwerte c und c'.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
wenn gefunden, dann
// wiederholtes Vorkommen einer Variablen
Füge v am Ende von G an.
sonst
Suche erste Variable v in V mit Endwert c.
wenn gefunden, dann
// erstes Vorkommen einer bereits bekannten Variablen in
// G.
Trage v in X ein mit Anfangs- und Endwert c'.
Füge v am Ende von G an.
ende wenn
sonst
// vorkommende Variable ist nicht in V enthalten
Sei x eine neue Variable.
Trage x mit Anfangs- und Endwert c in V ein.
Trage x mit Anfangs- und Endwert c' in X ein.
Füge x am Ende von G an.
ende wenn
ende wenn
sonst
// t ist Zahl, aber nicht u
beende Algorithmus mit Fehlermeldung
ende wenn
andernfalls
beende Algorithmus mit Fehlermeldung
ende unterscheide
ende solange
wenn entweder C oder C' nicht vollständig gelesen, dann
beende Algorithmus mit Fehlermeldung
ende wenn
ende wenn
Ende Prozedur SampleWExpression
Prozedur SampleWStatementSequence(D,D’,V,X,H)
Eingabe: D,D' : Beispielauswertungsfragmente
Ein-/Ausgabe:V,X : Variablenlisten
Ausgabe: H : Anweisungssequenz
Funktion:
Variablen:
H ist Anweisungssequenz eines while-Konstruktes, deren
Beispielauswertungsfragmente in der ersten und zweiten Entfaltung
D und D' sind.
Noch nicht bisher in V vorkommende Variablen werden mit ihrem
Anfangswert am zur Beginn der Auswertung D eingetragen. Für jede
in H vorkommende Variable enthält V als Endwert den letzten Wert
in D. Jede bisher noch nicht in X vorkommende Variable wird mit
ihrem Anfangswert zu Beginn von D' in X eingetragen. Als Endwert
jeder in H verwendete Variablen wird der letzte Wert von D' in X
eingetragen.
t,u : Entfaltungen von Anweisungen
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
// H ist am Anfang leer
H := "".
// Lese D und D’ parallel
wenn D≠"" und wenn D’≠"" dann
Setze Lesezeiger L vor das erste Element in D.
Setze Lesezeiger L’ vor das erste Element in D’.
solange weder D noch D' vollständig gelesen tue (d.h. weder L steht hinter dem
letzen Element in D noch L' steht hinter dem letzten Element in D')
t := lese nächstes Element in D
u := lese nächstes Element in D'
Stelle L einen Eintrag vor. Stelle L' einen Eintrag vor.
unterscheide
falls t ist String, Wort oder Sonderzeichen:
wenn t = u, dann füge t am Ende von H an.
sonst beende Algorithmus mit Fehlermeldung
ende wenn
falls t ist Zahl c:
wenn u ist Zahl, etwa c'. dann
Suche erste Variable v mit Endwert c in V und Endwert c' in X.
wenn gefunden, dann
Füge v am Ende von H an.
sonst wenn c = 0, dann
Suche erste Variable v mit Endwert c in V und Endwert c'+1 in
X.
wenn gefunden, dann
Füge --v am Ende von H an.
Ändere Endwert von v in X auf c'.
sonst
Suche erste Variable v mit Endwert c - 1 in V und Endwert c'
- 1 in X.
wenn gefunden, dann
Füge ++v am Ende von H an.
Ändere Endwert von v in V auf c und von v in X auf c'.
sonst
Suche erste Variable v mit Endwert c + 1 in V und
Endwert c' +1 in X.
wenn gefunden, dann
Füge --v am Ende von H an.
Ändere Endwert von v in V auf c und von v in X auf c'.
sonst wenn c' = 0, dann
Suche erste Variable v mit Endwert c + 1 in V und
Endwert c' in X.
wenn gefunden, dann
Füge --v am Ende von H an.
Ändere Endwert von v auf c.
sonst
// erstes Vorkommen einer Variablen, nicht in
// Inkrement oder Dekrement erlaubt
Suche erste Variable v mit Endwert c in V.
wenn gefunden, dann
Füge v am Ende von H an.
Trage v in X ein mit Anfangs- und Endwert c'.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
sonst
// ganz neue Variable
Sei v eine neue Variable.
Füge v am Ende von H an.
Trage v mit Anfangs- und Endwert c in V ein.
Trage v mit Anfangs- und Endwert c' in X ein.
ende wenn
ende wenn
ende wenn
ende wenn
ende wenn
ende wenn
sonst
// t ist Zahl, aber nicht u
Beende Algorithmus mit Fehlermeldung.
ende wenn
falls t ist test-Konstrukt der Form "test A 1 do B 1 end test", wobei
A 1 und B 1 Beispielauswertungsfragmente:
wenn u ist test-Konstrukt der Form "test A’ 1 do B’ 1 end
test", wobei A' 1 und B' 1 Beispielauswertungsfragmente, dann
wenn L steht nicht hinter dem letzten Element von D und wenn L'
steht nicht hinter dem letztem Element von D' und wenn das
nächste Element von D ist test-Konstrukt der Form "test A 2 do
B 2 end test", wobei A 2 und D 2 Beispielauswertungsfragmente,
und wenn das nächste Element von D' ist test-Konstrukt der
Form "test A’ 2 do B’ 2 end test", wobei A' 2 und D' 2
Beispielauswertungsfragmente, dann
Variablen: t',u' : Auswertungen von Anweisungen
i : natürliche Zahlen (Laufvariablen)
result : logischer Wert
M,M': Ausdrücke
N,N': Anweisungssequenzen
Y : Variablenliste
t' := Lese nächstes Element in D.
u' := Lese nächstes Element in D'.
Setze Lesemarken L und L' je ein Element vor.
// Generiere while-Konstrukte aus t und t' und u und u'
Lösche Y.
Rufe SampleWHILE(A 1 ,B 1 ,A 2 ,B 2 , V,M,N) auf.
Rufe SampleWHILE(A 1 ',B 1 ',A 2 ',B 2 ',Y,M',N') auf.
// stimmen die generierten while-Konstrukte in D und D'
überein?
// Außerdem müssen die Variablen aus Y in X eingetragen
// werden
Rufe MatchWHILE(M,M',N,N',V,Y,X,result) auf.
// eigentlich sollten die Konstrukte schon passen
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
wenn result = FALSCH, dann
beende Algorithmus mit Fehlermeldung
ende wenn
// Damit steht die Form des while-Konstruktes fest
Füge "with while M do N end while" am Ende von H
an.
// folgen weitere Entfaltungen des while-Konstruktes in D?
solange L steht nicht hinter dem letzten Element von D und
solange das nächste Element von D ist test-Konstrukt der
Form "test A 3 do B 3 end test", wobei A 3 und B 3
Beispielauswertungsfragmente sind, tue
t' := Lese nächstes Element in D.
Setze L ein Element vor.
// Test durchführen
Rufe TestWHILE(A 3 ,B 3 ,M,N,V,result) auf.
wenn result = FALSCH, dann
beende Algorithmus mit Fehlermeldung.
ende wenn
ende solange
wenn L steht nicht hinter dem letzten Element von D und
wenn das nächste Element von D ist test-Konstrukt der
Form "test B 3 skip’", wobei B 3 ein
Beispielauswertungsfragment ist, dann
t' := Lese nächstes Element in D.
Setze Lesemarke L ein Element vor.
Rufe TestWExpression(A 3 ,M,V,result) auf.
wenn result = FALSCH, dann
beende Algorithmus mit Fehlermeldung.
ende wenn
ende wenn
// folgen weitere Entfaltungen des while-Konstruktes in D'
solange L' steht nicht hinter dem letzten Element von D' und
solange das nächste Element von D' ist test-Konstrukt der
Form "test A’ 3 do B’ 3 end test", wobei A' 3 und B' 3
Beispielauswertungsfragmente sind, tue
u' := Lese nächstes Element in D.
Setze L' ein Element vor.
// Test durchführen
Rufe TestWHILE(A' 3 ,B' 3 ,M,N,X,result) auf.
wenn result = FALSCH, dann
beende Algorithmus mit Fehlermeldung.
ende wenn
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
ende solange
wenn L’ steht nicht hinter dem letzten Element von D’ und
wenn das nächste Element von D' ist test-Konstrukt der
Form "test B’ 3 skip’", wobei B' 3 ein
Beispielauswertungsfragment ist, dann
u' := Lese nächstes Element in D'.
Setze Lesemarke L' ein Element vor.
Rufe TestWExpression(A' 3 ,M,X,result) auf.
wenn result = FALSCH, dann
beende Algorithmus mit Fehlermeldung.
ende wenn
ende wenn
sonst
// test-Konstrukt am Ende der Anweisungssequenz
beende Algorithmus mit Fehlermeldung
ende wenn
sonst
// t ist test-Konstrukt, aber nicht u
beende Algorithmus mit Fehlermeldung
ende wenn
andernfalls
// kein weiterer Fall möglich
beende Algorithmus mit Fehlermeldung
ende unterscheide
ende solange
wenn entweder D oder D' nicht vollständig gelesen, dann
beende Algorithmus mit Fehlermeldung
ende wenn
ende wenn
Ende Prozedur SampleWStatementSequence
Prozedur MatchWHILE(M,M’,N,N’,V,Y,X,result)
Eingabe: M,M' : Ausdrücke
N,N' : Anweisungssequenzen
V : Variablenliste (Variablen aus M und N)
Y : Variablenliste (Variablen aus M' und N', keine der Variablen
erhält einen Eintrag 'neues Lexem')
Ein-/Ausgabe:
X : Variablenliste
Ausgabe: result : logischer Wert
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Funktion:
result = WAHR ⇔
M und M’ sowie N und N’ stimmen bis auf die Namen der Variablen
überein.
Für jede Variable y (in Y). die in M' oder N' vorkommt, deren
entsprechende Variable in M und N x ist (in V), wird x mit Anfangs- und
Endwert von y in X eingetragen, wenn x beim Aufruf der Prozedur in X
nicht enthalten ist.
Für jede Variable y (in Y), die in M' oder N' vorkommt, deren
entsprechende Variablen in M und N x ist (in V), wird der Endwert von x
in V auf den Endwert von y in Y gesetzt, sofern beim Aufruf der
Prozedur x in X enthalten ist.
Variablen: i : natürliche Zahl (Schleifenvariable)
t,u : Anweisungen
// optimistisch
result := WAHR
// Überprüfe Ausdrücke
wenn M = "" oder M' = "" tue
wenn M ≠ "" oder M' ≠ "" tue
result := FALSCH
ende wenn
sonst
// beide Ausdrücke sind nicht leer
Setze Lesezeiger L vor das erste Element in M und Lesezeiger L' vor das erste
Element in M'.
solange weder M noch M' zu ende gelesen (d.h. weder L noch L' steht hinter
dem letzten Element von M bzw. M') und solange result = WAHR tue
// lese beide Ausdrücke simultan
t := lese nächste Anweisung in M
u := lese nächste Anweisung in M'
Setze L ein Element vor.
Setze L' ein Element vor.
unterscheide
falls t ist Zeichenkette, Wort oder Sonderzeichen:
wenn t≠u, dann
result := FALSCH
ende wenn
falls t ist Variable, etwa v (kein Inkrement oder Dekrement):
wenn u ist Variable, etwa x dann
wenn neuer Wert von x in Y ist vorhanden, etwa y dann
wenn v≠y, dann
result := FALSCH
ende wenn
sonst wenn v in X enthalten. dann
Sei a der Anfangswert von x in Y.
Sei e der Endwert von v in X.
wenn a = e, dann
Sei e' der Endwert von x in Y.
Trage e' als Endwert von v in X ein.
Trage v als neuen Wert von x in Y ein.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
sonst
Beende Algorithmus mit Fehlermeldung
ende wenn
sonst
Sei a der Anfangswert von x in Y und e der Endwert von x in Y.
Trage v mit Anfangswert a und Endwert e in X ein.
Trage v als neuen Wert von x in Y ein.
ende wenn
sonst
result := FALSCH
ende wenn
andernfalls:
Beende Algorithmus mit Fehlermeldung
ende unterscheide
ende solange
wenn entweder M oder M’ nicht zu ende gelesen tue
result = FALSCH
ende wenn
ende wenn
wenn result = WAHR, dann
// Überprüfe Anweisungssequenzen
wenn N = "" oder N' = "" tue
wenn N ≠ "" oder N' ≠ "" tue
result := FALSCH
ende wenn
sonst
// beide Ausdrücke sind nicht leer
Setze Lesezeiger L vor das erste Element in N und Lesezeiger L' vor das
erste Element in N'.
solange weder N noch N' zu ende gelesen tue (d.h. weder L noch L' steht
hinter dem letzten Element von N bzw. N')
// Lese Anweisungssequenzen simultan
t := lese nächste Anweisung in N
u := lese nächste Anweisung in N'
Setze L ein Element vor.
Setze L' ein Element vor.
unterscheide
falls t ist Zeichenkette, Wort oder Sonderzeichen:
wenn t≠u, dann
result := FALSCH
ende wenn
falls t ist Variable, etwa v (kein Inkrement oder Dekrement):
wenn u ist Variable, etwa x dann
wenn u besitzt neuen Name, etwa y dann
wenn v ≠ y, dann
result := FALSCH
ende wenn
sonst wenn v in X enthalten, dann
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Sei e der Endwert von x in Y. Setze den Endwert von v in X
auf e.
Trage v als neuen Namen von x in Y ein.
sonst
Sei a der Anfangswert von x in Y und e der Endwert von x in Y.
Trage v mit Anfangswert a und Endwert e in X ein.
Trage v als neuen Namen von x in Y ein.
ende wenn
sonst
result := FALSCH
ende wenn
falls t ist Inkrement ++v, wobei v Variable aus V:
// v muß als neuer Name von der entsprechenden Variablen in
// x bekannt sein und in X enthalten sein, da v nicht erstes
Vorkommen
// der Variablen in M und N sein darf
wenn t ist Inkrement, etwa ++x, wobei x Variable aus Y:
wenn nicht neuer Name von x existiert und ist gleich v, dann
result := FALSCH
ende wenn
sonst
result := FALSCH
ende wenn
falls t ist Dekrement --v:
// v muß als neuer Name der entsprechenden Variablen in x bekannt
// sein und in X enthalten sein, da v nicht erstes Vorkommen der
// Variablen in M und N sein darf.
wenn t ist Inkrement, etwa ++x, wobei x Variable aus Y:
wenn nicht neuer Name von x existiert und ist gleich v, dann
result := FALSCH
ende wenn
sonst
result := FALSCH
ende wenn
falls t ist while-Konstrukt:
wenn u ist while-Konstrukt, dann
Variablen: result' : logischer Wert
// Form der while-Konstrukte
t habe die folgende Form: t = "with while B do C end
while"
u habe die folgende Form: u = "with while B’ do C’ end
while".
Dabei seien B und B' Ausdrücke und C und C'
Anweisungssequenzen.
// Stimmen die while-Konstrukte überein ?
Rufe MatchWHILE (B,C,B',C',V,Y,X,result')
wenn result' = FALSCH, dann
result := FALSCH
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
ende wenn
sonst
result := FALSCH
ende wenn
andernfalls:
Beende Algorithmus mit Fehlermeldung
ende unterscheide
ende solange
wenn entweder N oder N’ nicht zu ende gelesen tue
result = FALSCH
ende wenn
ende wenn
Ende Prozedur MatchWHILE
Prozedur TestWHILE (B,C,G,H,V,result)
Eingabe: B : Beispielauswertung eines Ausdrucks
C : Beispielauswertung einer Anweisungssequenz
G : Ausdruck
H : Anweisungssequenz
Ein-/Ausgabe:
V : Variablenliste
Ausgabe: result : logischer Wert
Funktion:
Variable:
result = WAHR ⇔ "test A do B end test" ist Teil eines
Beispielauswertungsfragmentes eines while-Konstruktes, dessen
Ausdruck G und dessen Anweisungssequenz H ist. Die Variablenliste V
enthält vor dem Aufruf alle lokalen Variablen des while-Konstruktes mit
ihren Werten vor der Auswertung von B. Nach Beendigung der
Prozedur enthält X die Werte der lokalen Variablen nach der
Auswertung von C, sofern result = WAHR gilt.
result' : logischer Wert
// optimistisch
result := WAHR
// Ausdruck testen
Rufe TestWExpression (B,G,V,result') auf.
wenn result' = FALSCH dann
result := FALSCH
sonst
// Anweisungssequenz testen
Rufe TestWStatementSequence (C,H,V,result') auf.
result := result'
ende wenn
Ende Prozedur TestWHILE
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Prozedur TestWExpression (B,G,V,result)
Eingabe: B : Beispielauswertung eines Ausdrucks
G : Ausdruck
V : Variablenliste
Ausgabe: result : logischer Wert
Funktion:
result = WAHR ⇔ "test B skip" oder "test B do C end test"
(C Beispielauswertung) ist Teil eines Beispielauswertungsfragmentes
eines while-Konstruktes, dessen Ausdruck G ist. Die Variablenliste V
enthält vor dem Aufruf alle lokalen Variablen des while-Konstruktes mit
ihren Werten vor der Auswertung von B.
Variablen: t : Beispielauswertung einer Anweisung
u : Anweisung
// optimistisch
result := WAHR
// Lese B und G sequentiell
wenn B = "", dann
wenn G ≠ "" dann
result := FALSCH
ende wenn
sonst
wenn G = "", dann
result := FALSCH
sonst
// weder G noch B sind leer
Setze Lesezeiger L vor das erste Element von A. Setze Lesezeiger L' vor das
erste Element von G.
solange weder A noch G zu ende gelesen (d.h. weder L noch L' steht hinter
dem letzen Element in A bzw. G) und solange result = WAHR tue
t := lese nächstes Element in G
u := lese nächstes Element in B
Stelle L ein Element vor
Stelle L' ein Element vor.
unterscheide
falls t ist Zeichenkette, Wort oder Sonderzeichen:
wenn t≠u, dann
result := FALSCH
ende wenn
falls t ist Variable v:
Sei c der Endwert von v in V.
wenn u≠c, dann
result := FALSCH
ende wenn
andernfalls:
Beende Algorithmus mit Fehlermeldung
ende unterscheide
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
ende solange
wenn B oder G nicht zu ende gelesen, tue
result := FALSCH
ende wenn
ende wenn
ende wenn
Ende Prozedur TestWExpression
Prozedur TestWStatementSequence (C,H,V,result)
Eingabe: C : Beispielauswertung eines Anweisungssequenz
H : Anweisungssequenz
Ein-/Ausgabe:
V : Variablenliste
Ausgabe: result : logischer Wert
Funktion: result = WAHR ⇔ "test B do C end test" (B
Beispielauswertungsfragment) ist Teil eines
Beispielauswertungsfragmentes eines while-Konstruktes, dessen
Anweisungssequenz H ist. Die Variablenliste V enthält vor dem Aufruf
alle lokalen Variablen des while-Konstruktes mit ihren Werten vor der
Auswertung der ersten Anweisung von C. Für den Fall result = WAHR
enthält V am Ende der Prozedur die Endwerte der Variablen nach der
Auswertung von C.
Variablen: t : Beispielauswertung einer Anweisung
u : Anweisung
// optimistisch
result := WAHR
// Lese C und H sequentiell
wenn C = "", dann
wenn H ≠ "", dann
result := FALSCH
ende wenn
sonst
wenn H = "", dann
result := FALSCH
sonst
// weder C noch H sind leer
Setze Lesezeiger L vor das erste Element von C.
Setze Lesezeiger L' vor das erste Element von H.
solange weder C noch H zu ende gelesen (d.h. weder L noch L' steht hinter
dem letzen Element in C bzw. H) und solange result = WAHR tue
t := lese nächstes Element in H
u := lese nächstes Element in C
Stelle L ein Element vor.
Stelle L' ein Element vor.
unterscheide
falls t ist Zeichenkette, Wort oder Sonderzeichen:
wenn t≠u, dann
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
result := FALSCH
ende wenn
falls t ist Variable v:
Sei c der Endwert von v in V.
wenn u≠c, dann
result := FALSCH
ende wenn
falls t ist Inkrement ++v:
Sei c der Endwert von v in V.
wenn u ist Zahl c+1, dann
setze Endwert von v in V auf c+1.
sonst
result := FALSCH
ende wenn
falls t ist Dekrement --v:
Sei c der Endwert von v in V.
wenn c > 0 oder u > 0, dann
wenn u ist Zahl c-1, dann
Setze Endwert von v in V auf c-1.
sonst
result := FALSCH
ende wenn
ende wenn
falls t ist while-Konstrukt der Form "with while D do E end
while", wobei D ein Ausdruck und E eine Anweisungssequenz ist:
Variablen: i : natürliche Zahl (Schleifenvariable)
result' : logischer Wert
u' : Beispielauswertungsfragment einer Anweisung
// u muß test-Konstrukt sein und zwar Teil des
// Beispielauswertungsfragmentes von t
wenn u ist test-Konstrukt der Form "test B’ do C’ end test",
wobei B' Beispielauswertungsfragment eines Ausdrucks und C'
Beispielauswertungsfragment einer Anweisungssequenz ist, dann
Rufe TestWHILE (A',B',D,E,V,result') auf.
wenn result' = FALSCH, dann
result := FALSCH
sonst
// es muß mindestens noch eine weitere Entfaltung von t
// kommen
wenn C zu ende gelesen (d.h. L' steht hinter dem letzen
Element von C), dann
result := FALSCH
sonst
u' := lese nächstes Element in C.
Setze L' ein Element vor.
wenn u' ist test-Konstrukt der Form "test B’’ do C’’
end test", wobei B'' Beispielauswertungsfragment eines
Ausdrucks und C'' Beispielauswertungsfragment einer
Anweisungssequenz ist, dann
Rufe TestWHILE (B'',C'',D,E,V,result') auf.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
wenn result’ = FALSCH, dann
result := FALSCH
sonst
// es können nun noch weitere Entfaltungen von t
// folgen
solange C nicht zu ende gelesen und solange
nächstes Element in C ist test-Konstrukt der Form
"test B’’’ do C’’’ end test", wobei B'''
Beispielauswertungsfragment eines Ausdrucks und
C''' Beispielauswertungsfragment einer Anweisung,
tue
u' := Lese nächstes Element in C.
Setze L' ein Element vor.
Rufe TestWHILE (B''',C''',D,E,V,result') auf.
wenn result' = FALSCH, dann
result := FALSCH
ende wenn
wenn C nicht zu ende gelesen und wenn nächstes
Element in C ist test-Konstrukt der Form "test B’’’
skip", wobei B''' Beispielauswertungsfragment, dann
u' := Lese nächstes Element in C.
Setze L' ein Element vor.
Rufe TestWExpression (B''',D,V,result') auf.
wenn result' = FALSCH, dann
result := FALSCH
ende wenn
ende wenn
ende wenn // result' = FALSCH
sonst
// u' ist nicht test-Konstrukt
result' = FALSCH
ende wenn
ende wenn // C zu ende gelesen
ende wenn
sonst
// u ist nicht test-Konstrukt
result := FALSCH
ende wenn
andernfalls:
Beende Algorithmus mit Fehlermeldung
ende unterscheide
ende solange
wenn C oder H nicht zu ende gelesen, tue
result := FALSCH
ende wenn
ende wenn
ende wenn
Ende Prozedur TestWStatementSequence
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
5.4 Korrektheit
Das erste Lemma gilt der Prozedur TestWExpression.
/HPPD
6HL3HLQ3URJUDPPXQG:HLQZKLOH.RQVWUXNWLQ3:HQWKDOWHNHLQH
=DKONRQVWDQWH6HL6HLQH%HLVSLHODXVZHUWXQJYRQ3XQG7GDV
%HLVSLHODXVZHUWXQJVIUDJPHQWYRQ:LQ66HL*GHU$XVGUXFNYRQ:XQG%
HLQ%HLVSLHODXVZHUWXQJVIUDJPHQWYRQ*LQQHUKDOEYRQ7'LH9DULDEOHQOLVWH
9HQWKDOWHPLQGHVWHQVDOOH9DULDEOHQYRQ*PLWLKUHQ:HUWHQDP$QIDQJ
GHU$XVZHUWXQJ%'DQQJLOWI UGLH3UR]HGXU7HVW:([SUHVVLRQDXIJHUXIHQ
PLWGHQ3DUDPHWHUQ%*9UZREHLUHLQHORJLVFKH9DULDEOHLVWLQGLHGLH
$XVJDEHGHU3UR]HGXUJHVFKULHEHQZLUG
'LH3UR]HGXUWHUPLQLHUWQDFKHQGOLFKYLHOHQ6FKULWWHQ
1DFK%HHQGLJXQJGHU3UR]HGXUJLOWU :$+5.
Beweis:
1. Termination
Die Prozedur enthält keine eigenen (expliziten) Prozeduraufrufe und nur eine
einzige Schleife. Die Schleife kann nur betreten werden, wenn beide Lesezeiger
vor dem ersten Element von B bzw. G stehen und wird (spätestens) verlassen,
sobald einer der beiden Lesezeiger hinter dem letzen Element von A bzw. G
steht. Bei jedem Schleifendurchlauf werden aber beide Lesezeiger um ein
Element vorgestellt. Dann muß jeder der Lesezeiger nach endlich vielen
Schleifendurchläufen hinter dem letzem Element von A bzw. G stehen, es sei
denn, die Schleife wird vor diesem Stand beendet. Also wird die Schleife in
jedem Fall nach endlich vielen Rechenschritten verlassen und die Prozedur
terminiert im Endlichen.
2. am Ende der Prozedur hat r den Wert WAHR
r erhält am Ende der Prozedur den Wert der Ausgabevariablen result der
Prozedur. Dieser Variable wird an einer Stelle (nämlich am Anfang der
Prozedur) der Wert WAHR und an fünf Stellen der Wert FALSCH zugewiesen,
nämlich
a) wenn B = "" und G ≠ "",
b) wenn B ≠ "" und G = "",
c) wenn in einem Schleifendurchlauf t Zeichenkette, Wort oder Sonderzeichen
ist und u ≠ t gilt.
d) wenn in einem Schleifendurchlauf t eine Variable v ist und t ungleich dem
Endwert von v in V ist.
e) nach dem Ende der solange-Schleife einer der Lesezeiger nicht hinter dem
letzten Element von A bzw. G steht.
Sonst erfolgt kein schreibender Zugriff auf result. Da result am Anfang der
Prozedur den Wert WAHR erhält, kann ein Wert ungleich WAHR für result nur
eintreten, wenn einer der Fälle a) bis e) auftritt. Wir müssen demnach diese
Fälle widerlegen.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
ÃAbbildung 6 : Struktur des Beweises von Satz 5.4.1
SampleProgram
Satz 5.4.1
SampleSequence
Lemma 5.4.15
benötigt für
Lemma 3.5.1
Lemma 3.5.2
Lemma 3.5.3
TestWHILE
Lemma 5.4.4
TestWExpression
Lemma 5.4.1
SampleWHILE
Lemma 5.4.14
Lemma 3.5.4
TestWSequence
Lemma 5.4.3
SampleWSequence
Lemma 5.4.13
SampleWExpression
Lemma 5.4.7
MatchWHILE
Lemma 5.4.2 Lemma 5.4.5
Lemma 5.4.12
Lemma 5.4.6
Lemma 5.4.11
Lemma 5.4.10
Lemma 5.4.9
Lemma 5.4.8
.
G ist ein Ausdruck. Nach Voraussetzung enthält G keine Zahlkonstanten. Also
kann G nur Zeichenketten, Sonderzeichen, Wörter und Variablen (außerhalb
eines Inkrementes und Dekrementes) enthalten. Zeichenketten, Sonderzeichen
und Wörter werden bei der Bildung von Beispielauswertungen nicht verändert,
Variablen werden durch Zahlen ersetzt. Also wird jedes Element eines
Ausdruckes durch ein Element des Beispielauswertungsfragmentes dieses
Ausdrucks ersetzt. Also muß gelten Länge(B) = Länge(G). Dies schließt die Fälle
a) und b) sofort aus.
Es sei A = "a1...aLänge(G)" und G = "g1...gLänge(G)". Dann gilt für i∈{1,...,Länge(G)}: gi
wird bei der Bildung der Beispielauswertung in genau ein Element von A
umgewandelt, nämlich in ai. Sei j∈{1,...,Länge(G)} beliebig. Beim j-ten
Schleifendurchlauf wird genau ein Element t von G und u von A gelesen. Aus
obiger Überlegung folgt, daß t = gj und u = aj.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Falls t ist Zeichenkette, Wort und Sonderzeichen, so muß gelten t = u nach
Konstruktion der Beispielauswertungen. Damit ist Fall c) widerlegt.
Verbleibt der Fall, daß t eine Variable ist, etwa die Variable v. Nach
Voraussetzung enthält die Variablenliste V die Werte der Variablen, die im
Ausdruck vorkommen. Da V innerhalb der Prozedur nicht verändert wird,
enthält V den Wert von v an jeder Stelle des Ausdrucks. Nach Konstruktion der
Beispielauswertung muß u gleich diesem Wert sein. Damit ist Fall d) widerlegt.
Sei jetzt m die Nummer des letzten Schleifendurchlaufs. Da nach obigen
Überlegungen innerhalb der Schleife immer result = WAHR gilt, muß gelten m
= Länge(A) = Länge(G). Damit ist auch der Fall e) ausgeschlossen.
Als nächstes wenden wir uns den Prozeduren TestWStatementSequence und TestWHILE. Die
Analyse dieser Prozeduren wird erheblich erschwert dadurch, daß die beiden Prozeduren sich
gegenseitig aufrufen. Damit sind beide Prozeduren indirekt rekursiv. Beginnen wir mit der
Prozedur TestWStatementSequence für den Fall, daß keine indirekte Rekursion auftritt.
/HPPD
6HL3HLQ3URJUDPPXQG:HLQZKLOH.RQVWUXNWLQ3:HQWKDOWHNHLQH
=DKONRQVWDQWHQXQGNHLQHORNDOHQZKLOH.RQVWUXNWH6HL6HLQH
%HLVSLHODXVZHUWXQJYRQ3XQG7GDV%HLVSLHODXVZHUWXQJVIUDJPHQWYRQ:LQ
66HL+GLH$QZHLVXQJVVHTXHQ]YRQ:XQG&HLQ
%HLVSLHODXVZHUWXQJVIUDJPHQWYRQ+LQQHUKDOEYRQ7'LH9DULDEOHQOLVWH9
HQWKDOWHPLQGHVWHQVDOOH9DULDEOHQYRQ+PLWLKUHQ:HUWHQDP$QIDQJYRQ
&'DQQJLOWI UGLH3UR]HGXU7HVW:6WDWHPHQW6HTXHQFHDXIJHUXIHQPLWGHQ
3DUDPHWHUQ&+9UZREHLUHLQHORJLVFKH9DULDEOHLVWLQGLHGLH$XVJDEH
GHU3UR]HGXUJHVFKULHEHQZLUG
'LH3UR]HGXUWHUPLQLHUWQDFKHQGOLFKYLHOHQ6FKULWWHQ
1DFK%HHQGLJXQJGHU3UR]HGXUJLOWU :$+5
9HQWKlOWPLQGHVWHQVDOOH9DULDEOHQGLHLQ+YRUNRPPHQPLWLKUHQ
:HUWHQDP(QGHYRQ&
Beweis:
1. Termination
Da nach Voraussetzung W keine lokalen while-Konstrukte enthält, gilt dies
auch für H. Explizite Prozeduraufrufe treten in der Prozedur aber nur auf, wenn
H mindestens ein while-Konstrukt enthält, was aber nicht der Fall ist. Es wird
dann auch nur eine einzige Schleife durchlaufen, nämlich die äußere solange-
Schleife. Diese kann nur betreten werden, wenn beide Lesezeiger vor dem
ersten Element von C bzw. H stehen (C und H sind nicht leer) und wird
(spätestens) verlassen, sobald einer der beiden Lesezeiger hinter dem letzten
Element von C bzw. H steht. Da der Fall "t ist while-Konstrukt" nicht auftreten
kann, ist sichergestellt, daß beide Lesezeiger bei jedem Schleifendurchlauf um
genau ein Element vorgestellt werden. Dann muß jeder der Lesezeiger nach
endlich vielen Schleifendurchläufen hinter dem letzem Element von C bzw. H
stehen, es sei denn, die Schleife wird vor diesem Stand beendet. Also wird die
Schleife in jedem Fall nach endlich vielen Rechenschritten verlassen und die
Prozedur terminiert.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
2. am Ende der Prozedur hat r den Wert WAHR
r erhält am Ende der Prozedur den Wert der Ausgabevariablen result der
Prozedur. Dieser Variable wird an einer Stelle (nämlich am Anfang der
Prozedur) der Wert WAHR und an sieben Stellen der Wert FALSCH zugewiesen
(man beachte, daß der Fall "t ist while-Konstrukt" nicht auftreten kann),
nämlich
a) wenn C = "" und H ≠ "",
b) wenn C ≠ "" und H = "",
c) wenn in einem Schleifendurchlauf t Zeichenkette, Wort oder Sonderzeichen
ist und u ≠ t gilt.
d) wenn in einem Schleifendurchlauf t eine Variable v ist und u ungleich dem
Endwert von v in V ist.
e) wenn in einem Schleifendurchlauf t ein Inkrement ++v ist und u ungleich
dem Wert c + 1, wobei c der Endwert von v in V ist.
f) wenn in einem Schleifendurchlauf t ein Dekrement --v ist, wobei für den
Endwert c von v in V gilt c > 0, und u ist ungleich der Zahl c - 1.
g) nach dem Ende der solange-Schleife einer der Lesezeiger nicht hinter dem
letzten Element von C bzw. H steht.
Sonst erfolgt kein schreibender Zugriff auf result, da der Fall "t ist while-
Konstrukt" niemals eintreten kann. Demnach kann ein Wert ungleich WAHR
für result nur eintreten, wenn einer der Fälle a) bis g) auftritt. Wir müssen
demnach diese Fälle widerlegen.
Nach Voraussetzung enthält H keine Zahlkonstanten und keine while-
Konstrukte sondern nur Zeichenketten, Sonderzeichen, Wörter, Variablen,
Inkremente und Dekremente. Zeichenketten, Sonderzeichen und Wörter werden
bei der Bildung von Beispielauswertungen nicht verändert, Variablen,
Inkremente und Dekremente werden durch Zahlen ersetzt. Also wird bei der
Bildung der Beispielauswertung jedes Element von H durch genau ein Element
des Beispielauswertungsfragmentes von H ersetzt. Insbesondere folgt daraus:
Länge(C) = Länge(H). Dies schließt die Fälle a) und b) sofort aus.
Wir wollen nun zuerst zeigen, daß vor dem ersten Schleifendurchlauf und nach
jedem Schleifendurchlauf die Variablenliste V die aktuellen Werte aller
Variablen von H an der Position des Lesezeigers in C enthält (sofern die Schleife
nicht vorzeitig verlassen wurde).
Beweis durch vollständige Induktion über die Zahl der Schleifendurchläufe
Induktionsverankerung (0 Schleifendurchläufe):
Vor dem ersten Schleifendurchlauf gilt obige Behauptung nach
Voraussetzung.
Induktionsvoraussetzung:
Sei j∈{0,..,Länge(H)-1}, Nach dem j-ten Schleifendurchlauf enthält V die
Endwerte aller Variablen von H an der Position des Lesezeigers.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Induktionsbehauptung:
V enthält auch nach dem (j+1)-ten Schleifendurchlauf die Endwerte aller
Variablen von H an der Position des Lesezeigers.
Induktionsschluß:
Es wird pro Schleifendurchlauf ein Element von H gelesen und zwar
sequentiell. Demnach wird im (j+1)-ten Schleifendurchlauf das (j+1)-te
Element von H gelesen. Sei t dieses Element.
1. Fall: t ist Zeichenkette, Wort, Sonderzeichen oder Variable. Dann ist der
Wert jeder Variablen nach dem (j+1)-ten Schleifendurchlauf gleich ihrem
Wert nach dem j-ten Schleifendurchlauf. Nach Induktionsvoraussetzung ist
dieser Wert aber bereits in V enthalten.
2. Fall: t ist Inkrement ++v, wobei v eine Variable ist. Nach
Induktionsvoraussetzung enthält V den Wert von v nach dem j-ten
Schleifendurchlauf c. Der Endwert von v in V wird auf den Wert c+1 gesetzt,
welcher in der Tat der Wert der Variablen v nach Ausführung des
Inkrementes ist. Da der Endwert aller Variablen ungleich v nicht verändert
wurde, enthält V ihre Endwerte nach Induktionsvoraussetzung.
3. Fall: t ist Dekrement --v, wobei v eine Variable ist, und v hat im j-ten
Schleifendurchlauf den Wert 0. Nach Induktionsvoraussetzung enthält V den
Wert von v nach dem j-ten Schleifendurchlauf, nämlich 0. V wird nicht
verändert. Damit enthält V den Wert von v nach dem (j+1)-ten
Schleifendurchlauf, ebenfalls 0. Es wurde keine Variable ungleich v
verändert, deshalb enthält V die Endwerte dieser lokalen Variablen nach
Induktionsvoraussetzung.
4. Fall: t ist Dekrement --v, wobei v eine lokale Variable ist, und v hat im j-
ten Schleifendurchlauf den Wert c > 0. Nach Induktionsvoraussetzung
enthält V den Endwert c von v. Der Endwert von v in V wird dann auf den
Wert c-1 erniedrigt, was der Wert von v nach dem (j+1)-ten
Schleifendurchlauf entspricht. Es wird der Wert keiner Variablen außer v
verändert. Also enthält V nach Induktionsvoraussetzung die Endwerte dieser
Variable nach j+1 Schleifendurchläufen.
Es können keine weiteren Fälle auftreten.
Sei jetzt C = "c1...cLänge(H)" und H = "h1...hLänge(H)". Dann gilt für i∈{1,...,Länge(H)}
hi wird bei der Bildung der Beispielauswertung in genau ein Element von C
umgewandelt, nämlich in ci. Sei j∈{1,...,Länge(H)} beliebig. Beim j-ten
Schleifendurchlauf wird genau ein Element t von H und u von C gelesen. Aus
obiger Überlegung folgt, daß t = hj und u = cj.
Falls t ist Zeichenkette, Wort und Sonderzeichen, so muß gelten t = u nach
Konstruktion der Beispielauswertungen. Damit ist Fall c) widerlegt.
Falls t ist Variable, etwa v, so wird v bei der Bildung der Beispielauswertung
durch den Wert von v ersetzt. Nach obiger Induktion enthält V den Wert c von v
nach dem j-ten Schleifendurchlauf, welcher mit dem Wert nach dem (j+1)-ten
Schleifendurchlauf übereinstimmt. Es muß also gelten: u = c. Damit ist Fall d)
widerlegt.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Sei nun t da Inkrement ++v, wobei v eine Variable ist. Nach obiger Induktion
enthält V den Wert von v nach dem j-ten Schleifendurchlauf c. Der Wert von v
nach dem (j+1)-ten Schleifendurchlauf ist folglich c+1. Also muß gelten u = c+1.
Dies widerlegt Fall e).
Es gelte jetzt t ist Dekrement --v, wobei für den Wert c von v nach dem j-ten
Schleifendurchlauf gilt: c > 0. Nach obiger Induktion enthält V den Wert c als
Endwert von v. Nach Konstruktion der Beispielauswertung ist der neue Wert
von v (nach dem (j+1)-ten Schleifendurchlauf) gleich c - 1. Also muß gelten u = c
-1. Dies widerlegt den Fall f).
Sei jetzt m die Nummer des letzten Schleifendurchlaufes. Da nach obigen
Überlegungen innerhalb der Schleife immer result = WAHR gilt, muß gelten m
= Länge(V) = Länge(H). Damit ist auch der Fall g) ausgeschlossen.
3. V enthält nach Beendigung der Prozedur (mindestens) alle Variablen von H
mit ihren Werten am Ende von C.
V enthält (mindestens) alle Variablen von H nach Voraussetzung. Weiterhin
wurde bewiesen, daß V die Werte alle auftretenden Variablen vor dem ersten
Schleifendurchlauf und am Ende jedes Schleifendurchlaufs enthält. Also enthält
V auch die Endwerte nach dem letzten Schleifendurchlauf. Da der Lesezeiger
am Ende der Prozedur hinter dem letzten Element von C steht (da die Schleife
nicht vorzeitig verlassen wird), enthält V die Endwerte der Variablen am Ende
von C.
Wir wollen jetzt die Korrektheit der Prozedur TestWStatementSequence für den Fall einer
Schachtelungstiefe d > 0 zeigen. Dazu müssen wir aber die Korrektheit der Prozedur
TestWHILE voraussetzen. Der Clou liegt dabei darin, daß wir die Korrektheit der Prozedur
TestWHILE nur für Anweisungssequenzen mit einer Schachtelungstiefe kleiner d fordern.
/HPPD
6HL3HLQ3URJUDPPXQG:HLQZKLOH.RQVWUXNWLQ3:HQWKDOWHNHLQH
=DKONRQVWDQWHQ6HL6HLQH%HLVSLHODXVZHUWXQJYRQ3XQG7GDV
%HLVSLHODXVZHUWXQJVIUDJPHQWYRQ:LQ66HL+GLH$QZHLVXQJVVHTXHQ]YRQ
:XQG&HLQ%HLVSLHODXVZHUWXQJVIUDJPHQWYRQ+LQQHUKDOEYRQ76HLG
'+!(VJHOWHQIROJHQGH9RUDXVVHW]XQJI UGLH3UR]HGXU7HVW:+,/(
6HL:HLQZKLOH.RQVWUXNWLQ3GDVNHLQH=DKONRQVWDQWHQHQWKlOWXQG7GDV
%HLVSLHODXVZHUWXQJVIUDJPHQWYRQ:LQ66HL*GHU$XVGUXFNYRQ:XQG+
GLH$QZHLVXQJVVHTXHQ]YRQ:ZREHL'+G6HLtest B’ do C’ end
testHLQWHVW.RQVWUXNWLQ7ZHOFKHVGXUFK(QWIDOWXQJYRQ:HQWVWDQGHQ
LVW'LH9DULDEOHQOLVWH9HQWKDOWHGLH:HUWHDOOHU9DULDEOHQYRQ:PLWLKUHQ
(QGZHUWHQYRU*'DQQJLOWI UGLH3UR]HGXUWHVW:+,/(EHLP$XIUXI
%&*+9UHVXOW
'LH$XVI KUXQJGHU3UR]HGXUWHUPLQLHUWQDFKHQGOLFKYLHOHQ6FKULWWHQ
1DFK%HHQGLJXQJGHU3UR]HGXUJLOWI UGHQ$XVJDEHSDUDPHWHUUHVXOW
:$+5
9HQWKlOWQDFK%HHQGLJXQJGHU3UR]HGXUGLH(QGZHUWHDOOHUORNDOHQ
9DULDEOHQYRQ:DP(QGHYRQ&
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
:HLWHUKLQJLOW'LH9DULDEOHQOLVWH9HQWKDOWHPLQGHVWHQVDOOH9DULDEOHQYRQ
+PLWLKUHQ:HUWHQDP$QIDQJYRQ&'DQQJLOWI UGLH3UR]HGXU
7HVW:6WDWHPHQW6HTXHQFHDXIJHUXIHQPLWGHQ3DUDPHWHUQ&+9UZREHLU
HLQHORJLVFKH9DULDEOHLVWLQGLHGLH$XVJDEHGHU3UR]HGXUJHVFKULHEHQZLUG
, 'LH3UR]HGXUWHUPLQLHUWQDFKHQGOLFKYLHOHQ6FKULWWHQ
,, 1DFK%HHQGLJXQJGHU3UR]HGXUJLOWU :$+5
,,,9HQWKlOWPLQGHVWHQVDOOH9DULDEOHQGLHLQ+YRUNRPPHQPLWLKUHQ
:HUWHQDP(QGHYRQ&
Beweis:
1. Termination
Hilfsbehauptung 1: Sei m = Länge (H). Dann wird die äußere solange-Schleife
maximal m-mal durchlaufen.
Beweis:
Wegen D(H) > 0 folgt m > 0. Wir nehmen an, die Schleife werde mindestens
einmal betreten (wird die Schleife nicht betreten, ist Hilfsbehauptung 1 sofort
bewiesen, da die Schleife nullmal durchlaufen wird). Des weiteren nehmen wir
an, jeder der ersten m Schleifendurchläufe terminiere (falls der i-te
Schleifendurchlauf (1≤i≤m) nicht terminiert, kann der (i+1)-te
Schleifendurchlauf nicht betreten werden), sofern die Schleife nicht vorzeitig
beendet wird.
Die äußere solange-Schleife wird verlassen, wenn eine der folgenden
Bedingungen nach einem Schleifendurchlauf wahr wird:
- result = FALSCH
- L steht hinter dem letzten Element von C.
- L' steht hinter dem letzten Element von H.
Es genügt zu zeigen: Falls die Schleife nicht vorzeitig terminiert, steht L' nach
m Schleifendurchläufen hinter dem letzten Element von H.
Vor dem ersten Schleifendurchlauf steht L' vor dem ersten Element von H. Da
bei jedem Schleifendurchlauf L' um genau ein Element vorgestellt wird, folgt die
Hilfsbehauptung nach Induktion. (Hilfsbehauptung 1)
Hilfsbehauptung 2: Sei j∈{0,..,m}. Die Schleife werde nicht vor dem j-ten
Schleifendurchlauf beendet, noch terminiere einer der ersten j
Schleifendurchläufe nicht. V enthalte vor dem j-ten Schleifendurchlauf die
Werte aller Variablen an der Position des Lesezeigers L in C'. Im j-ten
Schleifendurchlauf wird t als while-Konstrukt "with while D do E end
while" gelesen, wobei D ein Ausdruck und E eine Anweisungssequenz ist (man
beachte, daß Klasse-I-Programme keine lokalen Variablen besitzen). Der
Lesezeiger L stehe vor dem Anfang einer Folge F von test-Konstrukten, die das
Beispielauswertungsfragment von t sind. Dann gilt:
(i) Der Schleifendurchlauf ist nach endlich vielen Rechenschritten beendet.
(ii) L steht am Ende hinter dem letztem Element der Folge F.
(iii)
V enthält die Werte aller Variablen nach der Auswertung der letzten
Anweisung von F.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Beweis:
Das erste gelesene Element der Folge F habe die Form u = "test B’ do C’
end test", wobei B’ ein Beispielauswertungsfragment von D und C’ ein
Beispielauswertungsfragment von E ist. Man beachte, daß V die Werte aller
Variablen von u am Anfang von B' enthält und D(C') < d ist. Dann gilt nach den
Voraussetzungen des Lemma für den Aufruf der Prozedur TestWHILE:
I. Die Ausführung der Prozedur terminiert nach endlich vielen Schritten.
II. Nach Beendigung der Prozedur gilt für den Ausgabeparameter result' =
WAHR.
III. V enthält nach Beendigung der Prozedur die Endwerte aller Variablen von
u am Ende von C'.
Der Lesezeiger L steht jetzt vor dem zweiten Element der Liste F. Dieses habe
die Form u = "test B’’ do C’’ end test", wobei B'' ein
Beispielauswertungsfragment von D und C'' ein Beispielauswertungsfragment
von E ist. Wiederum gelten für den Aufruf der Prozedur TestWHILE die
Voraussetzungen des Lemma und es gilt für den Aufruf:
I. Die Ausführung der Prozedur terminiert nach endlich vielen Schritten.
II. Nach Beendigung der Prozedur gilt für den Ausgabeparameter result' =
WAHR.
III. V enthält nach Beendigung der Prozedur die Endwerte aller Variablen von
u am Ende von C''.
Der Lesezeiger L steht wieder hinter dem test-Konstrukt u'.
Dieselbe Argumentation läßt sich anwenden, wenn weitere test-Konstrukte
innerhalb der Folge F anstehen. Falls das letzte Element der Folge der test-
Konstrukte ein test-Konstrukt der Form = "test B’’’ skip", wobei B''' ein
Beispielauswertungsfragment von D ist, so liefert das Lemma 5.4.1 das
gewünschte Ergebnis. (Hilfsbehauptung 2)
Hilfsbehauptung 3: Sei j∈{0,..,m}. Die Schleife werde nicht vor dem j-ten
Schleifendurchlauf beendet, noch terminiere einer der ersten j
Schleifendurchläufe nicht. Dann wird im j-ten Schleifendurchlauf genau ein
Element von H gelesen.
Beweis:
Die Anweisungssequenz H und der Lesezeiger L' werden bei keinem
Prozeduraufruf übergeben. Also kann kein Element von H während eines
Prozeduraufrufs gelesen werden. Außerhalb von Prozeduraufrufen wird der
Lesezeiger nur einmal während eines Schleifendurchlaufs vorgestellt. Also kann
pro Schleifendurchlauf nur ein Element der Anweisungssequenz H gelesen
werden. (Hilfsbehauptung 3)
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Hilfsbehauptung 4: Sei j∈{0,..,m}. Die Schleife werde nicht vor dem j-ten
Schleifendurchlauf beendet, noch terminiere einer der ersten j
Schleifendurchläufe nicht. Dann ist der j-te Schleifendurchlauf nach endlich
vielen Schritten beendet, der Lesezeiger L' steht hinter dem j-ten Element von
H, und der Lesezeiger L steht hinter dem Beispielauswertungsfragment des j-
ten Elementes von C. Außerdem enthält V nach dem j-ten Schleifendurchlauf
die Endwerte aller vorkommenden Variablen an der Position des Lesezeigers L
in C (für j=0 enthält V die Werte vor dem ersten Schleifendurchlauf, d.h. vor der
Ausführung von C).
Beweis durch vollständige Induktion über die Zahl der Schleifendurchläufe:
Induktionsverankerung (0 Schleifendurchläufe):
Vor dem ersten Schleifendurchlauf gilt obige Behauptung nach
Voraussetzung.
Induktionsvoraussetzung:
Sei j∈{0,..,Länge(H)-1}. Der j-te Schleifendurchlauf terminiert, der Lesezeiger
L' steht hinter dem j-ten Element von H, und der Lesezeiger L (in C) stehe
hinter dem Beispielauswertungsfragment des j-ten Elementes von H. Nach
dem j-ten Schleifendurchlauf enthält V die Endwerte aller Variablen von H
an der Position des Lesezeigers.
Induktionsbehauptung:
Der (j+1)-te Schleifendurchlauf ist nach endlich vielen Schritten beendet, der
Lesezeiger L' steht hinter dem (j+1)-ten Element, der Lesezeiger L' steht
hinter dem Beispielauswertungsfragment des (j+1)-ten Elementes von H, und
V enthält auch nach dem (j+1)-ten Schleifendurchlauf die Endwerte aller
Variablen von H an der Position des Lesezeigers.
Induktionsschluß:
Nach Hilfsbehauptung 3 wird pro Schleifendurchlauf ein Element von H
gelesen und zwar sequentiell. Demnach wird im (j+1)-ten Schleifendurchlauf
das (j+1)-te Element von H gelesen. Sei t dieses Element.
Wir müssen vier Behauptungen zeigen:
a) der (j+1)-te Schleifendurchlauf terminiert.
b) nach dem Schleifendurchlauf steht der Lesezeiger L' hinter t.
c) nach dem Schleifendurchlauf steht der Lesezeiger L hinter dem
Beispielauswertungsfragment von t in C.
d) die Variablenliste V enthält (mindestens) die Werte aller vorkommenden
Variablen an der Position des Lesezeigers L.
Falls t ein while-Konstrukt ist, liefert und die Induktionsvoraussetzung die
Voraussetzung für die Anwendung der Hilfsbehauptung 2. Demnach gilt:
(i) Der Schleifendurchlauf ist nach endlich vielen Rechenschritten beendet.
(ii) L steht am Ende hinter dem letztem Element des
Beispielauswertungsfragmentes von t.
(iii)
V enthält die Werte aller Variablen nach der Auswertung des
Beispielauswertungsfragmentes von t.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Wenden wird uns jetzt den vier Behauptungen der Hilfsbehauptung 4 zu:
a) der (j+1)-te Schleifendurchlauf terminiert.
Falls t kein while-Konstrukt ist, ist diese Behauptung sofort einsichtig, und
für den Fall, daß t ein while-Konstrukt ist, liefert uns die Aussage (i) von
Hilfsbehauptung 2 das gewünschte Ergebnis.
b) nach dem Schleifendurchlauf steht der Lesezeiger L' hinter t.
Dies folgt direkt aus Hilfsbehauptung 3.
c) nach dem Schleifendurchlauf steht der Lesezeiger L hinter dem
Beispielauswertungsfragment von t in C.
Für den Fall, daß t kein while-Konstrukt ist, wird nur ein Element von C
gelesen, nämlich das Beispielauswertungsfragment von t (dies muß gelten, da
nach Induktionsvoraussetzung der Lesezeiger hinter dem
Beispielauswertungsfragment des j-ten Elementes von H gestanden hat). Das
Beispielauswertungsfragment besteht nur aus einem Element. Da der
Lesezeiger L auch nur um ein Element vorgestellt wird, steht er folglich
hinter dem Beispielauswertungsfragment.
d) die Variablenliste V enthält (mindestens) die Werte aller vorkommenden
Variablen an der Position des Lesezeigers L.
1. Fall: t ist Zeichenkette, Wort, Sonderzeichen oder Variable. Dann ist der
Wert jeder Variablen nach dem (j+1)-ten Schleifendurchlauf gleich ihrem
Wert nach dem j-ten Schleifendurchlauf. Nach Induktionsvoraussetzung ist
dieser Wert aber bereits in V enthalten.
2. Fall: t ist Inkrement ++v, wobei v eine lokale Variable ist. Nach
Induktionsvoraussetzung enthält V den Wert von v nach dem j-ten
Schleifendurchlauf c. Der Endwert von v in V wird auf den Wert c+1 gesetzt,
welcher in der Tat der Wert der Variablen v nach Ausführung des
Inkrementes ist. Da der Endwert aller Variablen ungleich v nicht verändert
wurde, enthält V ihre Endwerte nach Induktionsvoraussetzung.
3. Fall: t ist Dekrement --v, wobei v eine Variable ist, und v hat im j-ten
Schleifendurchlauf den Wert 0. Nach Induktionsvoraussetzung enthält V den
Wert von v nach dem j-ten Schleifendurchlauf, nämlich 0. V wird nicht
verändert. Damit enthält V den Wert von v nach dem (j+1)-ten
Schleifendurchlauf, ebenfalls 0. Es wurde keine Variable ungleich v
verändert, deshalb enthält V die Endwerte dieser Variablen nach
Induktionsvoraussetzung.
4. Fall: t ist Dekrement --v, wobei v eine Variable ist, und v hat im j-ten
Schleifendurchlauf den Wert c > 0. Nach Induktionsvoraussetzung enthält V
den Endwert c von v. Der Endwert von v in V wird dann auf den Wert c-1
erniedrigt, was der Wert von v nach dem (j+1)-ten Schleifendurchlauf
entspricht. Es wird der Wert keiner Variablen außer v verändert. Also
enthält V nach Induktionsvoraussetzung die Endwerte dieser Variable nach
j+1 Schleifendurchläufen.
5. Fall: t ist while-Konstrukt.
Dann folgt die Behauptung aus Aussage (iii) der Hilfsbehauptung 2.
Weitere Fälle können nicht auftreten. (Hilfsbehauptung 4)
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Durch Induktion folgt aus Hilfsbehauptung 4: Für jedes j∈{1,..,m} terminiert der
j-te Schleifendurchlauf, sofern die Schleife nicht vorzeitig abgebrochen wird.
Nach Hilfsbehauptung 1 werden aber maximal m Schleifendurchläufe
ausgeführt. Also muß die Schleife nach endlicher Zeit verlassen werden.
2. am Ende der Prozedur hat r den Wert WAHR
r erhält am Ende der Prozedur den Wert der Ausgabevariablen result der
Prozedur. Dieser Variable wird an einer Stelle (nämlich am Anfang der
Prozedur) der Wert WAHR und an zwölf Stellen der Wert FALSCH zugewiesen,
nämlich
a) wenn C = "" und H ≠ "",
b) wenn C ≠ "" und H = "",
c) wenn in einem Schleifendurchlauf t Zeichenkette, Wort oder Sonderzeichen
ist und u ≠ t gilt.
d) wenn in einem Schleifendurchlauf t eine Variable v ist und u ungleich dem
Endwert von v in V ist.
e) wenn in einem Schleifendurchlauf t ein Inkrement ++v ist und u ungleich
dem Wert c + 1, wobei c der Endwert von v in V ist.
f) wenn in einem Schleifendurchlauf t ein Dekrement --v ist, wobei für den
Endwert c von v in V gilt c > 0, und u ist ungleich der Zahl c - 1.
g) wenn nach einem Aufruf von TestWHILE der Wert result' = FALSCH
zurückgeliefert wird.
h) wenn nach einem Aufruf von TestWExpression der Wert result' = FALSCH
zurückgeliefert wird.
i) wenn bei der Behandlung eines while-Konstruktes für u ein anderes Element
als ein test-Konstrukt gelesen wird.
j) wenn bei der Behandlung eines while-Konstruktes für u' ein anderes Element
als ein test-Konstrukt gelesen wird.
k) wenn bei der Behandlung eines while-Konstruktes nach dem Einlesen des
ersten test-Konstruktes des Beispielauswertungsfragmentes von t das Ende
von C erreicht wird.
l) nach dem Ende der solange-Schleife einer der Lesezeiger nicht hinter dem
letzten Element von C bzw. H steht.
Demnach kann ein Wert ungleich WAHR für result nur eintreten, wenn einer
der Fälle a) bis l) auftritt. Wir müssen demnach diese Fälle widerlegen.
Die Anweisungssequenz einer leeren Anweisungsfolge ist wieder ein leeres
Beispielauswertungsfragment. Demnach kann der Fall a) nie eintreten. Falls
aber C ≠ "", d.h. C enthält eine Anweisung a, so muß H ein
Beispielauswertungsfragment von a enthalten, dann kann aber nicht gelten H =
"", womit auch der Fall b) nicht eintreten kann.
Für den Fall C = "" und H = "" wird r als WAHR zurückgegeben, also können wir
annehmen, daß die Schleife betreten wird. Sei t die im j-ten Schleifendurchlauf
(j beliebig) gelesene Anweisung. Da in H keine Zahlkonstanten vorkommen,
kann t nur Wort, Zeichenkette, Sonderzeichen, Variable, Inkrement, Dekrement
oder while-Konstrukt sein.
Nach Hilfsbehauptung 4 des ersten Teils des Beweises steht der Lesezeiger L
vor dem Beispielauswertungsfragment von t in C. Im Falle, daß t Zeichenkette,
Wort oder Sonderzeichen ist, muß für das gelesene Element u gelten: t = u, was
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
den Fall c) verbietet. Falls t ist Variable, Inkrement oder Dekrement, so muß
das gelesene Element u eine Zahl sein, nämlich den Wert von v. Der letzte Wert
von v ist in der Variablenliste V gespeichert (nach Hilfsbehauptung 4 vom
ersten Teil des Beweises). Sei c dieser Wert. Dann ist der Wert von v nach dem
Schleifendurchlauf im Fall, daß t eine Variable ist, gleich c, im Fall, daß t ein
Inkrement ist, gleich c+1, und im Fall, daß t ein Dekrement ist, gleich c-1,
sofern c>0 gilt. Damit sind auch die Fälle d), e) und f) widerlegt.
Wenden wir uns jetzt den Fall g) bis k) zu. Die Prozedur TestWHILE wird
innerhalb der Prozedur TestWStatementSequence an genau drei Stellen
aufgerufen, und zwar nur im Fall, daß t ein while-Konstrukt ist. Sei also t ein
while-Konstrukt, etwa "with while D do E end while", wobei D ein
Ausdruck und E eine Anweisungssequenz ist (man beachte, daß Klasse-I-
Programme keine lokalen Initialisationen besitzen). Nach Hilfsbehauptung 4
des ersten Teile des Beweises steht der Lesezeiger L in C vor dem
Beispielauswertungsfragment von t. Dieses habe für ein k∈© (k>1) die Form
test F 1 do G 1 end test
test F 2 do G 2 end test
...
test F k do G k end test
oder die Form
test F 1 do G 1 end test
test F 2 do G 2 end test
...
test F k do G k end test
test F k+1 skip
Dabei sind F1,..,Fk+1 Beispielauswertungsfragmente von D und G1,..,Gk
Beispielauswertungsfragmente von E. Da k > 1 müssen zum
Beispielauswertungsfragment von t mindestens zwei test-Konstrukte gehören.
Dann kann aber die Liste C nicht nach dem Einlesen des ersten test-
Konstruktes zu Ende sein. Also kann der Fall k) nicht eintreten.
Das erste bei der Bearbeitung des while-Konstruktes von C gelesene Element
(u) ist also auf jedem Fall
test F 1 do G 1 end test
also ein test-Konstrukt, weswegen der Fall i) nicht eintreten kann.
Für den anschließenden Aufruf der Prozedur testWHILE gilt aber:
ì u ist Teil des Beispielauswertungsfragment von t, wobei D(D) < d.
ì V enthält (mindestens) alle Variablen von t mit ihren Anfangswerten zu
Beginn der Auswertung u, da keine lokalen Variablen auftreten können.
Somit gilt für den Rückgabewert result' der Prozedur testWHILE nach
Voraussetzung (Punkt II): result' = WAHR.
Das zweite gelesene Element von C (u') ist
test F 2 do G 2 end test
wiederum ein test-Konstrukt, womit auch der Fall j) widerlegt ist
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Für den zweiten Aufruf der Prozedur testWHILE gilt wieder:
ì u' ist Teil des Beispielauswertungsfragment von t, und D(D) < d.
ì V enthält (mindestens) alle Variablen von t mit ihren Anfangswerten zu
Beginn von u' (nach Punkt III) der Voraussetzung).
Dann kann wieder aus Punkt II der Voraussetzung für die Prozedur TestWHILE
geschlossen werden: der Ergebniswert result' = WAHR.
Die analoge Beweisführung läßt sich auch auf die restlichen k-2 test-Konstrukte
des Beispielauswertungsfragmentes von t anwenden, womit wir zu den Schluß
kommen:
ì
ì
Nach dem Einlesen des k-ten test-Konstruktes des
Beispielauswertungsfragmentes von t steht der Lesezeiger L hinter diesem
Element.
Nach dem Einlesen des k-ten test-Konstruktes des
Beispielauswertungsfragmentes von t enthält die Variablenliste V
(mindestens) alle vorkommenden Variablen mit ihren Werten am Ende der
Auswertung des k-ten test-Konstruktes.
ì Jeder der Aufrufe der Prozedur TestWHILE liefert das Ergebnis result' =
WAHR (womit der Fall g) widerlegt ist).
Falls kein (k+1)-tes test-Konstrukt folgt, wird die Prozedur TestWExpression
nicht aufgerufen, und der Fall h) kann nicht eintreten. Nehmen wir deswegen
an, an der Position des Lesezeigers stehe ein (k+1)-tes test-Konstrukt, nämlich
test F k+1 skip
Somit wird die Prozedur SampleWExpression aufgerufen. Wir können aber das
Lemma 5.4.1 benutzen, wonach allerdings nach dem Aufruf der Wert result' =
WAHR ist, weswegen auch der Fall h) widerlegt ist.
Da innerhalb der äußeren solange-Schleife immer result = WAHR gilt, kann die
Schleife nur verlassen werden, wenn entweder C oder H zu ende gelesen.
Nach Hilfsbehauptung 4 des ersten Teils des Beweises wissen wir, daß am Ende
der Schleife, in der eine Anweisung t aus H gelesen wurde, der Lesezeiger in der
Liste C hinter dem Beispielauswertungsfragment zu t steht. Nehmen wir jetzt
an, H wäre nicht zu ende gelesen, aber die Schleife terminiere. Also muß C zu
ende gelesen sein. Dann existiert aber eine Anweisung a von H, dessen
Beispielauswertungsfragment nicht in C enthalten ist. Also ist C kein
Beispielauswertungsfragment von H im Widerspruch zur Voraussetzung des
Lemmas.
Nehmen wir umgekehrt an, H wäre zu ende gelesen, aber nicht C, beim
Terminieren der Schleife. Dann enthält C aber Elemente, die nicht
Beispielauswertungsfragment einer Anweisung aus H sein können, womit C
selbst kein Beispielauswertungsfragment von H sein kann, wiederum im
Widerspruch zur Voraussetzung.
Also muß nach Beendigung der Schleife gelten, daß sowohl H als auch C zu ende
gelesen sind, womit der Fall k) ausgeschlossen ist.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Damit ist beweisen, daß am Ende der Prozedur, die Ausgabevariable result den
Wert WAHR besitzt.
3. V enthält (mindestens) alle Variablen, die in H vorkommen mit ihren Werten
am Ende von C.
Diese Aussage folgt durch Induktion aus der Hilfsbehauptung 4 des ersten Teils
des Beweises.
Wir wollen jetzt die Korrektheit der Prozedur TestWHILE beweisen. Das Problem dabei liegt,
daß wir dazu das Lemma 5.4.3 benutzen müssen, zu dessen Beweis aber Aussagen über die
Korrektheit von TestWHILE gemacht wurden.
/HPPD
6HL3HLQ3URJUDPPXQG:HLQZKLOH.RQVWUXNWLQ3:HQWKDOWHNHLQH
=DKONRQVWDQWHQ6HL6HLQH%HLVSLHODXVZHUWXQJYRQ3XQG7GDV
%HLVSLHODXVZHUWXQJVIUDJPHQWYRQ:LQ6:KDEHGLH*HVWDOWwith while
G do H end whileXQG7KDEHGLH*HVWDOWtest B do C end test'LH
9DULDEOHQOLVWH9HQWKDOWHPLQGHVWHQVDOOH9DULDEOHQYRQ:PLWLKUHQ
:HUWHQDP$QIDQJYRQ7'DQQJLOWI UGLH3UR]HGXU7HVW:+,/(DXIJHUXIHQ
PLWGHQ3DUDPHWHUQ%&*+9UZREHLUHLQHORJLVFKH9DULDEOHLVWLQGLH
GLH$XVJDEHGHU3UR]HGXUJHVFKULHEHQZLUG
'LH3UR]HGXUWHUPLQLHUWQDFKHQGOLFKYLHOHQ6FKULWWHQ
1DFK%HHQGLJXQJGHU3UR]HGXUJLOWU :$+5
9HQWKlOWPLQGHVWHQVDOOH9DULDEOHQGLHLQ:YRUNRPPHQPLWLKUHQ
:HUWHQDP(QGHYRQ7
Beweis:
(vollständige Induktion über die Schachtelungstiefe D(W))
Induktionsverankerung für D(W) = 1:
Für den Aufruf der Prozedur TestWExpression kann das Lemma 5.4.1
angewendet werden, wonach die Prozedur nach endlicher Zeit terminiert und
der Rückgabewert result' = WAHR zurückgegeben wird. Da die Prozedur
TestWExpression die Variablenliste V nicht verändert, enthält V die Werte
aller Variablen von W zu Beginn der Auswertung H.
Da result' = WAHR wird die Prozedur TestWStatementSequence aufgerufen.
Wegen D(W) = 1 gilt D(H) = 0, somit enthält H weder Zahlkonstanten noch
lokale while-Konstrukte. Somit kann das Lemma 5.4.2 angewendet werden,
wonach für den Aufruf gilt:
1. Die Prozedur terminiert nach endlich vielen Schritten.
2. Nach Beendigung der Prozedur gilt für den Rückgabewert result' = WAHR.
3. V enthält (mindestens) nach Beendigung der Prozedur alle Variablen, die
in H vorkommen mit ihren Werten am Ende der Auswertung von C.
Da der Ausgabeparameter r den Wert von result' erhält, sind alle
Behauptungen des Lemma beweisen.
Induktionsvoraussetzung:
Sei d∈© + beliebig. Die Behauptungen des Lemma gelten für alle W mit D(W)
≤ d.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Induktionsbehauptung:
Die Behauptungen des Lemma gelten für alle W mit D(W) = d+1.
Induktionsschluß:
Für den Aufruf der Prozedur TestWExpression kann das Lemma 5.4.1
angewendet werden, wonach die Prozedur nach endlicher Zeit terminiert und
der Rückgabewert result' = WAHR zurückgegeben wird. Da die Prozedur
TestWExpression die Variablenliste V nicht verändert, enthält V die Werte
aller Variablen von W zu Beginn der Auswertung H.
Da result' = WAHR, wird die Prozedur TestWStatementSequence aufgerufen.
Für diesen Aufruf kann aber das Lemma 5.4.3 angewendet werden, da die
darin gemachten Aussagen über die Prozedur TestWHILE für while-
Konstrukte mit Schachtelungstiefe d' ≤ d nach der Induktionsvoraussetzung
gelten. Somit gilt:
1. Die Prozedur TestWStatementSequence terminiert nach endlich vielen
Schritten.
2. Nach Beendigung der Prozedur gilt result' = WAHR.
2. V enthält (mindestens) alle Variablen, die in H vorkommen mit ihren
Werten am Ende von C.
Da die Ausgabevariable r den Wert von result' erhält, sind alle
Behauptungen des Lemmas erfüllt.
Das nächste Lemma analysiert das Verhalten der Prozedur MatchWHILE:
/HPPD
6HL3HLQ.ODVVH,3URJUDPPGDVNHLQH=DKONRQVWDQWHQHQWKlOW6HLHQ:XQG
:]ZHLZKLOH.RQVWUXNWHPLW: with while M do N end whileXQG
: with while M’ do N’ end while'DEHLVHLQHQ0XQG0
$XVGU FNHXQG1XQG1$QZHLVXQJVVHTXHQ]HQ'LH9DULDEOHQYRQ:VWHKHQ
LQGHU9DULDEOHQOLVWH9GLH9DULDEOHQYRQ:VWHKHQLQGHU9DULDEOHQOLVWHQ<
'HU(LQWUDJQHXHU:HUWMHGHU9DULDEOHQDXV

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Beweis:
Zeigen wir zuerst zwei Hilfsbehauptungen:
Hilfsbehauptung 1:
Die erste solange-Schleife wird maximal |M| = |M’| Mal durchlaufen.
Beweis:
Es ist klar, daß |M| = |M'|, da sich M und M' nur in den Namen der
vorkommenden Variablen unterscheiden. Der Lesezeiger L, der über M läuft
steht am Anfang der ersten solange-Schleife (sofern diese überhaupt betreten
wird) vor dem ersten Element von M und wird bei jedem Schleifendurchlauf um
genau ein Element vorgestellt. Dann steht L (sofern die Schleife nicht vorher
beendet wird) nach |M| Schleifendurchläufen hinter dem letztem Element von
M und die Schleife wird beendet. (Hilfsbehauptung 1)
Hilfsbehauptung 2:
Die zweite solange-Schleife wird maximal |N| = |N'| Mal durchlaufen.
Beweis:
Es ist wiederum klar, daß |N| = |N'|. Der Lesezeiger L steht vor dem ersten
Schleifendurchlauf der zweiten solange-Schleife (sofern die Schleife überhaupt
betreten wird) vor dem ersten Element von N und wird bei jedem
Schleifendurchlauf um ein Element vorgestellt. Deshalb steht L nach genau
|M| Schleifendurchläufen hinter dem letzten Element von M, falls jeder
Schleifendurchlauf terminiert und die Schleife nicht vorher beendet wird.
(Hilfsbehauptung 2)
Wenden wir uns jetzt dem Beweis des Lemmas zu:
(vollständige Induktion über die Schachtelungstiefe D(W) = D(W'))
Induktionsverankerung für D(W) = D(W') = 1:
1. Die Prozedur terminiert nach endlich vielen Schritten.
Wegen D(W) = D(W’) = 1 ist D(N) = D(N’) = 0 und die W und W’ enthalten
keine lokalen while-Konstrukte, also kann der Fall, daß ein while-Konstrukt
als Anweisung gefunden worden ist, nicht auftreten und es finden keine
rekursiven Aufrufe statt. Damit ist klar, daß jeder Schleifendurchlauf nach
einer endlichen Anzahl von Schritten beendet wird. Da nach Hilfsbehauptung
1 und 2 nur endlich viele Schleifendurchläufe auftreten können, ist die
Termination der Prozedur MatchWHILE gesichert.
2. Nach dem Aufruf der Prozedur MatchWHILE hat result den Wert WAHR.
result erhält zu Anfang der Auswertung den Wert WAHR und es existieren
14 Stellen innerhalb der Prozedur, an denen die Variable result den Wert
FALSCH zugewiesen bekommt:
a) falls |M| ≠ |M‘|
b) falls in einem Schleifendurchlauf der ersten solange-Schleife für die
eingelesenen Anweisungen t und u gilt: t ist Zeichenkette, Wort oder
Sonderzeichen und t ≠ u.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
c) falls in einem Schleifendurchlauf der ersten solange-Schleife für die
eingelesenen Anweisungen t und u gilt: t ist Variable und u ist keine
Variable
d) falls in einem Schleifendurchlauf der ersten solange-Schleife für die
eingelesenen Anweisungen t und u gilt: t und u sind Variablen, t ∈ X
und neuer Name von u in Y ist nicht t.
e) falls |N| ≠ |N'|
f) falls in einem Schleifendurchlauf der zweiten solange-Schleife für die
eingelesenen Anweisungen t und u gilt: t ist Zeichenkette, Wort oder
Sonderzeichen und t ≠ u.
g) falls in einem Schleifendurchlauf der zweiten solange-Schleife für die
eingelesenen Anweisungen t und u gilt: t ist Variable und u ist keine
Variable
h) falls in einem Schleifendurchlauf der zweiten solange-Schleife für die
eingelesenen Anweisungen t und u gilt: t und u sind Variablen, neuer
Wert von u ist vorhanden und neuer Name von u in Y ist nicht t.
i) falls in einem Schleifendurchlauf der zweiten solange-Schleife für die
eingelesenen Anweisungen t und u gilt: t ist Inkrement, aber nicht u.
j) falls in einem Schleifendurchlauf der zweiten solange-Schleife für die
eingelesenen Anweisungen t und u gilt: t ist Inkrement einer Variablen
v und u ist Inkrement einer Variablen x und der neue Name von x in Y
ist nicht v.
k) falls in einem Schleifendurchlauf der zweiten solange-Schleife für die
eingelesenen Anweisungen t und u gilt: t ist Dekrement, aber nicht u.
l) falls in einem Schleifendurchlauf der zweiten solange-Schleife für die
eingelesenen Anweisungen t und u gilt: t ist Dekrement einer Variablen
v und u ist Dekrement einer Variablen x und der neue Name von x in Y
ist nicht v.
m)falls in einem Schleifendurchlauf der zweiten solange-Schleife für die
eingelesenen Anweisungen t und u gilt: t ist while-Konstrukt, aber
nicht u.
n) falls in einem Schleifendurchlauf der zweiten solange-Schleife für die
eingelesenen Anweisungen t und u gilt: t und u sind while-Konstrukte
und der rekursive Aufruf der Prozedur MatchWHILE liefert als
Ergebnis result' = FALSCH.
Ansonsten wird die Variable result nicht verändert. Wir müssen also jeden
der Fälle a) bis n) widerlegen, um zu beweisen, daß am Ende der Prozedur
die Variable result den Wert WAHR besitzt.
Der Beweis der Hilfsbehauptungen 1 und 2 schließt die Fällt a) und e) aus.
Ebenso können die Fälle m) und n) nicht auftreten, da D(N) = 0.
Widerlegen wir jetzt die Fälle b), c) und d) und formulieren dies als
Hilfsbehauptung.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Hilfsbehauptung 3:
Die Fälle b), c) und d) können nicht eintreten.
Beweis:
Falls M = M' = "" wird die erste solange-Schleife nicht betreten, und keiner
der Fälle b), c) oder d) kann eintreten. Nehmen wir deswegen an, weder M
noch M' seien leer und die Schleife wird betreten.
Da in P keine Zahlkonstanten vorkommen, kann eine Anweisung in M (oder
M') nur eine Zeichenkette, ein Wort, ein Sonderzeichen oder eine Variable
(außerhalb eines Dekrementes oder Inkrementes) sein. Außerdem wissen wir,
daß sich M und M' nur in den Namen der Variablen unterscheiden. Dann
muß auch die i-te Anweisung in M der i-ten Anweisung in M' bis auf die
Namen von Variablen entsprechen (i∈{1,...,|M|}). Da aber in jedem
Schleifendurchlauf genau ein Element t von M und genau ein Element u von
M' gelesen wird, ist klar, daß es ein i gibt, so daß t ist das i-te Element von M
und u ist das i-te Element von M'. Also müssen sich t und u bis aus den
Namen von Variablen entsprechen. Falls also u keine Variable ist, d.h. u ist
Zeichenkette, Wort oder Sonderzeichen, muß gelten t = u, womit der Fall b)
widerlegt ist.
Sei nun t eine Variable, etwa v, so muß auch u eine Variable sein, etwa x (in
Widerspruch zu Fall c)). Es kann aber sein v ≠ x. Dennoch muß für jedes
Vorkommen der Variablen v in M dieselbe Variable x in M' gegenüberstehen.
1. Fall: die Variable v tritt zum ersten Mal in M auf.
Dann gelten die folgenden drei Aussagen:
(1) x hat keinen neuen Wert in Y nach Voraussetzung.
(2) x tritt in M' zum ersten Mal auf.
(3) in jedem bisherigem Vorkommen stand die Variable v der Variablen x
gegenüber.
Folglich stimmen t und u bis auf den Namen der Variablen überein. Man
beachte, daß das Lexem v als neuer Name von x in die Variablenliste Y
eingetragen wird und die Variable v mit dem Anfangs- und Endwert der
Variablen x aus Y in die Variablenliste X eingetragen wird, sofern v nicht in
X enthalten ist. Falls v in X enthalten ist, wird der Endwert von v in X
überschrieben durch den Endwert von x in Y.
2. Fall: die Variable v tritt nicht zum ersten Mal in M auf:
Nach dem 1. Fall muß gelten: x hat in Y einen neuen Namen, etwa v'. Es
muß demnach gelten v' = v und der Fall d) kann nie eintreten.
(Hilfsbehauptung 3)
Wir wissen damit, daß nach Beendigung der ersten solange-Schleife gilt:
result = WAHR. Zu widerlegen bleiben die Fälle f), g), h), i), j), k) und l).
Falls N = "" und damit N' = "", kann keiner dieser Fälle auftreten. Deswegen
nehmen wird an: N ≠ "" und N' ≠ "" und die zweite solange-Schleife wird
betreten.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Da in N und N’ weder Zahlkonstanten noch while-Konstrukte vorkommen,
sind als Anweisungen nur Zeichenketten, Wörter, Sonderzeichen, Variablen,
Inkremente und Dekremente erlaubt. Sei jetzt für einen Schleifendurchlauf t
eine Anweisung aus N und u die Anweisung aus N'. u muß jetzt bis auf den
Namen von Variablen mit t übereinstimmen.
Falls t Zeichenkette, Wort oder Sonderzeichen, so muß gelten t = u, denn
dann enthalten weder u noch t Variablen, wodurch der Fall f) widerlegt ist.
Falls t eine Variable ist, so muß auch u eine Variable sein, in Widerlegung zu
Fall g). Sei etwa t = v und u = x, wobei v ∈V und x ∈Y.
1. Fall: die Variable v kommt nicht in M vor und tritt zum ersten Mal in N
auf.
Dann gelten die folgenden drei Aussagen:
(1) x hat in Y keinen neuen Namen.
(2) x tritt nicht in M' auf und tritt in N' zum ersten Mal auf.
(3) in jedem bisherigem Vorkommen in den while-Konstrukten stand die
Variable v der Variablen x gegenüber.
Folglich stimmen t und u bis auf den Namen der Variablen überein. Man
beachte, daß das Lexem v als neuer Name von x in die Variablenliste Y
eingetragen wird und die Variable v mit dem Anfangs- und Endwert der
Variablen x aus Y in die Variablenliste X eingetragen wird, falls v ∉ X. Falls
v ∈ X, so wird der Endwert von v in X auf den Endwert von x in Y gesetzt.
2. Fall: die Variable v tritt nicht zum ersten Mal in N oder M auf:
Nach dem 1. Fall muß gelten, daß x in Y einen neuen Namen hat, etwa v'. Es
muß demnach gelten v' = v und der Fall h) kann nie eintreten.
Sei nun t ein Inkrement, etwa ++v. Dann muß auch u ein Inkrement sein,
etwa ++x. Dies widerlegt den Fall i). Da in Klasse-I-Programmen das erste
Vorkommen einer Variablen in einem while-Konstrukt innerhalb eines
Inkrementes nicht erlaubt ist, muß die Variable v in M oder N bereits
außerhalb eines Inkrementes oder Dekrementes vorgekommen sein. Dann ist
v in X enthalten und der neue Name von x in Y ist v, womit der Fall j)
widerlegt ist.
Falls t ein Dekrement ist, etwa --v, muß u ebenfalls ein Dekrement sein, etwa
--x. Deswegen kann der Fall k) nicht eintreten. Da in Klasse-I-Programmen
das erste Vorkommen einer Variablen in einem while-Konstrukt innerhalb
eines Dekrementes nicht erlaubt ist, muß die Variable v in M oder N bereits
außerhalb eines Inkrementes oder Dekrementes vorgekommen sein. Also ist
v ∈ X und v ist der neue Name von x in Y in Widerspruch zum Auftreten des
Falles l).
Dadurch ist bewiesen, daß in keinem Fall die Ausgabevariable result den
Wert FALSCH zugewiesen werden kann. Also hat am Ende der Prozedur
result den Wert WAHR.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
3. Jede Variable aus W, die nicht beim Aufruf der Prozedur in X enthalten
ist, wird in X angefügt mit Anfangs- und Endwert der entsprechenden
Variablen aus Y.
Im Beweis von Punkt 2 haben wir gezeigt, daß für jedes erste Vorkommen
einer Variablen v in W, v mit Anfangs- und Endwert der entsprechenden
Variablen x aus Y in die Variablenliste X eingetragen wird, sofern v nicht
bereits in X enthalten gewesen ist. V wird aber nur beim ersten Vorkommen
einer Variablen in W verändert, und zwar wird nur deren Eintrag verändert.
Also wird die Variable v nur eingetragen, wenn v am Anfang der Prozedur
nicht in X enthalten war. Da außerdem jede Variable aus W zum ersten Mal
in W vorkommt, folgt die Behauptung.
4. Der Endwert in X jeder Variable aus W, die in X enthalten ist, wird mit
dem Endwert der entsprechenden Variablen in Y überschrieben.
Unter Punkt 2 sahen wir, daß falls eine Variable v bei ihrem ersten
Vorkommen in W in X bereits enthalten gewesen ist, ihr Endwert mit dem
Endwert der entsprechenden Variablen aus x (in der Variablenliste Y)
überschrieben wird. Außerhalb des Vorkommens der Variablen v wird die
Variable v in V nicht verändert. da jede Variable in W einmal zum ersten Mal
in W vorkommen muß, folgt die Behauptung.
Induktionsvoraussetzung:
Sei nun d ∈© + beliebig und es gelte für den Aufruf der Prozedur
MatchWHILE, wobei D(W) ≤ d:
1. Die Prozedur terminiert nach endlich vielen Schritten.
2. Nach dem Aufruf hat result den Wert WAHR.
3. Jede Variable aus W, die nicht beim Aufruf der Prozedur in X enthalten
ist, wird in X angefügt mit Anfangs- und Endwert der entsprechenden
Variablen aus Y.
4. Der Endwert in X jeder Variable aus W, die in X enthalten ist, wird mit
dem Endwert der entsprechenden Variablen in Y überschrieben, sofern die
Endwerte nicht bereits übereinstimmen.
Induktionsbehauptung:
Die Behauptungen gelten auch für D(W) = d+1.
Induktionsschluß:
1. Die Prozedur terminiert nach endlich vielen Schritten.
Betrachten wird zunächst die erste solange-Schleife. Wir stellen als erstes
fest, daß jeder Schleifendurchlauf terminiert. Nach Hilfsbehauptung 1 ist die
Zahl der Schleifendurchläufe durch die Länge von M beschränkt. Also
terminiert die Schleife nach endlicher Schrittzahl, sofern sie überhaupt
betreten wird.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
In der zweiten Schleife ist der endliche Schleifendurchlauf garantiert, falls
die gelesenen Anweisungen Worte, Sonderzeichen, Zeichenketten, Variablen,
Inkremente oder Dekremente sind, da dann kein Prozeduraufruf erfolgt.
Falls die gelesenen Anweisungen t und u while-Konstrukte sind, stellen wir
fest, daß D(t) = D(u) ≤ d. Also kann für den rekursiven Aufruf der Prozedur
matchWHILE die Induktionsvoraussetzung angewandt werde, womit auch in
diesem Fall die Termination des Schleifendurchlaufs gesichert ist. Nach
Hilfsbehauptung 2 werden für die zweite solange-Schleife nur endlich viele
Schleifendurchläufe benötigt, falls die Schleife überhaupt betreten wird, so
daß die Prozedur in jedem Fall nach endlich vielen Schritten beendet ist.
2. Nach dem Aufruf der Prozedur MatchWHILE hat result den Wert WAHR.
result erhält zu Anfang der Auswertung den Wert WAHR und es existieren
14 Stellen innerhalb der Prozedur, an denen die Variable result den Wert
FALSCH zugewiesen bekommt:
a) falls |M| ≠ |M‘|
b) falls in einem Schleifendurchlauf der ersten solange-Schleife für die
eingelesenen Anweisungen t und u gilt: t ist Zeichenkette, Wort oder
Sonderzeichen und t ≠ u.
c) falls in einem Schleifendurchlauf der ersten solange-Schleife für die
eingelesenen Anweisungen t und u gilt: t ist Variable und u ist keine
Variable
d) falls in einem Schleifendurchlauf der ersten solange-Schleife für die
eingelesenen Anweisungen t und u gilt: t und u sind Variablen, t ∈ X
und neuer Name von u in Y ist nicht t.
e) falls |N| ≠ |N'|
f) falls in einem Schleifendurchlauf der zweiten solange-Schleife für die
eingelesenen Anweisungen t und u gilt: t ist Zeichenkette, Wort oder
Sonderzeichen und t ≠ u.
g) falls in einem Schleifendurchlauf der zweiten solange-Schleife für die
eingelesenen Anweisungen t und u gilt: t ist Variable und u ist keine
Variable
h) falls in einem Schleifendurchlauf der zweiten solange-Schleife für die
eingelesenen Anweisungen t und u gilt: t und u sind Variablen, neuer
Wert von u ist vorhanden und neuer Name von u in Y ist nicht t.
i) falls in einem Schleifendurchlauf der zweiten solange-Schleife für die
eingelesenen Anweisungen t und u gilt: t ist Inkrement, aber nicht u.
j) falls in einem Schleifendurchlauf der zweiten solange-Schleife für die
eingelesenen Anweisungen t und u gilt: t ist Inkrement einer Variablen
v und u ist Inkrement einer Variablen x und der neue Name von x in Y
ist nicht v.
k) falls in einem Schleifendurchlauf der zweiten solange-Schleife für die
eingelesenen Anweisungen t und u gilt: t ist Dekrement, aber nicht u.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
l) falls in einem Schleifendurchlauf der zweiten solange-Schleife für die
eingelesenen Anweisungen t und u gilt: t ist Dekrement einer Variablen
v und u ist Dekrement einer Variablen x und der neue Name von x in Y
ist nicht v.
m)falls in einem Schleifendurchlauf der zweiten solange-Schleife für die
eingelesenen Anweisungen t und u gilt: t ist while-Konstrukt, aber
nicht u.
n) falls in einem Schleifendurchlauf der zweiten solange-Schleife für die
eingelesenen Anweisungen t und u gilt: t und u sind while-Konstrukte
und der rekursive Aufruf der Prozedur MatchWHILE liefert als
Ergebnis result' = FALSCH.
Ansonsten wird die Variable result nicht verändert. Wir müssen also jeden
der Fälle a) bis n) widerlegen, um zu beweisen, daß am Ende der Prozedur
die Variable result den Wert WAHR besitzt.
Den Fall a) haben wir bereits im Beweis der Hilfsbehauptung 1
ausgeschlossen. Die Fälle b), c) und d) widerlegen wir mit Hilfsbehauptung 3
(der Beweis ist vollkommen analog), und die Widerlegung von Fall e) folgt
aus dem Beweis der Hilfsbehauptung 2.
Wir wissen damit, daß nach Beendigung der ersten solange-Schleife gilt:
result = WAHR. Zu widerlegen bleiben die Fälle f), g), h), i), j), k) und l).
Falls N = "" und damit N' = "", kann keiner dieser Fälle auftreten. Deswegen
nehmen wird an: N ≠ "" und N' ≠ "" und die zweite solange-Schleife wird
betreten. Da in N und N' keine Zahlkonstanten vorkommen, sind als
Anweisungen nur Zeichenketten, Wörter, Sonderzeichen, Variablen,
Inkremente, Dekremente und while-Konstrukte erlaubt.
Sei jetzt für einen Schleifendurchlauf t eine Anweisung aus N und u die
Anweisung aus N'. u muß jetzt bis auf den Name von Variablen mit t
übereinstimmen.
Falls t Zeichenkette, Wort oder Sonderzeichen, so muß gelten t = u, denn
dann enthalten weder u noch t Variablen, wodurch der Fall f) widerlegt ist.
Falls t eine Variable ist, so muß auch u eine Variable sein, in Widerlegung zu
Fall g). Sei etwa t = v und u = x, wobei v ∈V und x ∈Y.
1. Fall: die Variable v kommt nicht in M vor und tritt zum ersten Mal in N
auf.
Dann gelten die folgenden Aussagen:
(1) x hat in Y keinen neuen Namen.
(2) x tritt nicht in M' auf und tritt in N' zum ersten Mal auf.
Diese Aussagen sind jetzt nicht trivial, müssen also bewiesen werden:
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Beweis der Aussage 2:
Annahme: x wäre bereits einmal vorgekommen, etwa in der Anweisung a'.
Dann muß es eine Anweisung a in W geben, die sich von a' nur in dem
Namen der Variablen unterscheidet. Der Name der Variablen kann aber
nicht v sein, da v in der Anweisung t zum ersten Mal vorkommt. Sei also
etwa w die Variable in a. Also sind x und w bis auf den Namen dieselbe
Variable, da u = x ist, müßte demnach t = w sein. Also kann x nicht bereits
vorgekommen sein. (Aussage 1)
Beweis der Aussage 1:
Man beachte bitte, daß bei einem rekursiven Aufruf der Prozedur
MatchWHILE die Variablenliste Y als Eingabeparameter übergeben wird. Y
kann also bei einem rekursiven Aufruf nicht verändert werden. Y wird also
nur an einer Stelle im Programm verändert, nämlich, wenn bei der
Bearbeitung einer Variable y, und zwar wenn ein neuer Name der Variablen
y eingetragen wird. Da aber die Variable v zum ersten Mal in W auftritt,
muß auch die Variable x zum ersten Mal in W' auftreten (nach Aussage 2).
Dann kann kein neuer Name für x eingetragen worden sein. (Aussage 1)
Folglich stimmen t und u bis auf den Namen der Variablen überein. Man
beachte, daß das Lexem v als neuer Name von x in die Variablenliste Y
eingetragen wird und die Variable v mit dem Anfangs- und Endwert der
Variablen x aus Y in die Variablenliste X eingetragen wird, falls v ∉ X. Falls
v ∈ X, so wird der Endwert von v in X auf den Endwert von x in Y gesetzt.
2. Fall: die Variable v tritt nicht zum ersten Mal in N oder M auf:
Dann müssen wir wieder drei Fälle unterscheiden:
(i) die Variable v tritt zum ersten Mal in M auf.
(ii) die Variable v tritt zum ersten Mal in M auf, jedoch nicht innerhalb eines
lokalen while-Konstruktes.
(iii) die Variable v tritt zum ersten Mal in M innerhalb eines lokalen while-
Konstruktes auf.
Im Unterfall (i) haben wir bereits bewiesen, daß die x zugeordnete Variable
in V als neue Name von x in die Variablenliste Y eingetragen ist. Außerdem
wird v in X eingetragen mit Anfangs- und Endwert von x aus Y. Die x
zugeordnete Variable ist aber v, sonst stimmen t und u nicht bis auf den
Namen der Variablen überein. Also kann der Fall h) nicht eintreten.
Für den Unterfall (ii) haben wir im 1. Fall gesehen, daß dann die x
zugeordnete Variable als neuer Name in Y eingetragen wurde. Da v die x
zugeordnete Variable ist, muß v der neue Name von x in Y sein, wodurch der
Fall h) widerlegt ist. Außerdem ist v mit Anfangs- und Endwert von x in Y in
X eingetragen.
Im Unterfall (iii) wissen wir aus der Induktionsvoraussetzung (da
Schachtelungstiefe einer lokalen while-Konstruktes kleiner als D(W) sein
muß, daß die x zugeordnete Variable als neuer Name von x in Y eingetragen
wurde und diese zugeordnete Variable mit Anfangs- und Endwert von x in X
eingefügt wurde. Die x zugeordnete Variable ist aber v, also kann der Fall h)
auch in diesem Unterfall nicht eintreten.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Sei nun t ein Inkrement, etwa ++v. Dann muß auch u ein Inkrement sein,
etwa ++x. Dies widerlegt den Fall i). Da in Klasse-I-Programmen das erste
Vorkommen einer Variablen in einem while-Konstrukt innerhalb eines
Inkrementes nicht erlaubt ist, muß die Variable v in M oder N bereits
außerhalb eines Inkrementes oder Dekrementes vorgekommen sein. Analog
zum 2. Fall bei der Behandlung einer Variablen kann man sich vergewissern,
daß v in X enthalten ist (mit Anfangs- und Endwert von x in Y) und der neue
Name von x in Y v ist, womit der Fall j) widerlegt ist. Dieselbe
Argumentation widerlegt die Fälle k) und l) beim Auftreten von
Dekrementen.
Verbleibt die Möglichkeit, daß t ein while-Konstrukt ist. Dann muß auch u
ein while-Konstrukt sein, denn sonst könnten u und v nicht übereinstimmen.
Also ist der Fall m) ausgeschlossen. Es gelte jetzt für die while-Konstrukte t
und u:
t = with while B do C end while
u = with while B’ do C’ end while
Dabei beachte man, daß Klasse-I-Programme keine lokalen Variablen
besitzen. B und B' sind Ausdrücke und C und C' sind Anweisungssequenzen.
Man beachte, daß D(C) = D(C') < d. Folglich gilt nach
Induktionsvoraussetzung für den rekursiven Aufruf der Prozedur
MatchWHILE.: Die Ausgabevariable result' hat nach Beendigung des
rekursiven Aufrufs dem Wert WAHR, womit auch der Fall n) widerlegt ist.
Dadurch ist bewiesen, daß in keinem Fall die Ausgabevariable result den
Wert FALSCH zugewiesen werden kann. Also hat am Ende der Prozedur
result den Wert WAHR.
3. Jede Variable aus W, die nicht beim Aufruf der Prozedur in X enthalten
ist, wird in X angefügt mit Anfangs- und Endwert der entsprechenden
Variablen aus Y.
Nach Induktionsvoraussetzung wird jede Variable aus einem lokalen while-
Konstrukt von W mit Anfangs- und Endwert der entsprechenden Variablen
aus Y in die Variablenliste X aufgenommen, sofern diese nicht bereits beim
rekursiven Prozeduraufruf in X enthalten gewesen ist. Unter Punkt 2 haben
wir gesehen, daß beim Auftritt einer Variablen v in W außerhalb eines
lokalen while-Konstruktes diese mit Anfangs- und Endwert der
entsprechenden Variablen x aus Y in die Variablenliste Y eingetragen wird,
sofern für die Variable x in Y kein neuer Name eingetragen ist. Dies ist aber
genau beim ersten Vorkommen einer Variablen in W bzw. W' der Fall. Also
wird beim ersten Vorkommen einer Variablen in W, die nicht bereits in V
enthalten ist, diese in die Variablenliste V aufgenommen. Da jede
vorkommende Variable zum ersten Mal vorkommt, ist die Behauptung
bewiesen.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
4. Der Endwert in X jeder Variable aus W, die in X enthalten ist, wird mit
dem Endwert der entsprechenden Variablen in Y überschrieben, sofern die
Endwerte nicht bereits übereinstimmen.
Auch diese Behauptung folgt für den Fall des ersten Vorkommens der
Variablen innerhalb eines lokalen while-Konstruktes von W aus der
Induktionsvoraussetzung. Im Beweis der Behauptung 2 haben wird gesehen,
daß der Endwert einer bereits in X enthalten Variablen v auf den Endwert
der entsprechenden Variablen x aus Y gesetzt wird, wenn für die Variable x
aus Y kein neuer Wert angegeben ist. Dies ist aber dann der Fall, wenn die
Variablen v und x in W und W' erstmalig vorkommen. Da jede vorkommen
Variable einmal zum ersten Mal vorkommen muß, wird der Endwert jeder
beim Aufruf der Prozedur in X enthalte Variable aus W mit dem Endwert der
entsprechenden Variablen in W' überschrieben. Dabei kann es
selbstverständlich vorkommen, daß der Endwert einer Variablen aus X mit
demselben Endwert überschrieben wird, was aber kein Widerspruch zur
Behauptung ist. Auch diese Behauptung ist jetzt bewiesen.
Nach Induktion folgt jetzt die Gültigkeit des Lemmas.
Als nächstes beweisen wir die Korrektheit der Prozedur SampleSequence.
/HPPD
6HL3HLQ.ODVVH,3URJUDPPGDVNHLQH=DKONRQVWDQWHQHQWKlOWXQG6HLQH
%HLVSLHODXVZHUWXQJYRQ66HL:HLQZKLOH.RQVWUXNWLQ:XQG7HLQ
%HLVSLHODXVZHUWXQJVIUDJPHQWYRQ:LQ6'LHHUVWHQEHLGHQWHVW.RQVWUXNWH
YRQ7VHLHQ
WHVWÃ&ÃGRÃ'ÃHQGÃWHVW
WHVWÃ&ÃGRÃ'ÃHQGÃWHVW
'DEHLVHLHQ&XQG&%HLVSLHODXVZHUWXQJVIUDJPHQWHGHV$XVGUXFNHVYRQ:
XQG'XQG'%HLVSLHODXVZHUWXQJVIUDJPHQWHGHU$QZHLVXQJVVHTXHQ]YRQ:
6HLHQ9XQG;9DULDEOHQOLVWHQZREHL;OHHULVW'DQQJLOWI UGHQ$XIUXIGHU
3UR]HGXU6DPSOH:([SUHVVLRQPLWGHQ3DUDPHWHUQ&&9;*
'LH3UR]HGXUWHUPLQLHUWQDFKHQGOLFKYLHOHQ6FKULWWHQ
&XQG&VLQG%HLVSLHODXVZHUWXQJHQYRQ*
-HGH9DULDEOHLQ*GLHEHLP$XIUXIGHU3UR]HGXUQLFKWLQ9HQWKDOWHQLVW
ZLUGLQ9HLQJHWUDJHQ,KU$QIDQJVZHUWLVWGHU:HUWLKUHVHUVWHQ
$XIWUHWHQVLQ&
$P(QGHGHU3UR]HGXULVWMHGH9DULDEOHYRQ*LQ9HLQJHWUDJHQ,KU
(QGZHUWLVWGHU:HUWLKUHV$XIWUHWHQVLQ&
-HGH9DULDEOHLQ*ZLUGLQ;HLQJHWUDJHQ,KU$QIDQJVZHUWXQGLKU
(QGZHUWLVWGHU:HUWLKUHV$XIWUHWHQVLQ&
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Beweis:
1. Die Prozedur terminiert nach endlich vielen Schritten.
Klar ist, daß |C| = |C'|. Falls C = "", wird die Prozedur sofort beendet. Nehmen
wir also an m = |C| = |C'| > 0. In diesem Fall wird die solange-Schleife
betreten und spätestens dann verlassen, wenn die Lesezeiger am Ende von C
und C' stehen. Da vor dem ersten Schleifendurchlauf diese vor der ersten
Anweisung des Ausdrucks stehen und beide Lesezeiger um je ein Element
vorgezogen werden, terminiert die Schleife nach m Schleifendurchläufen. Da
außerdem jeder Schleifendurchlauf in endlicher Zeit beendet ist, ist auch die
Prozedur nach endlich vielen Schritten beendet.
2. C und C' sind Beispielauswertungen von G
C und C' dürfen nur Zeichenketten, Wörter, Sonderzeichen und Zahlen
enthalten. Unter Punkt 1 haben wir gesehen, daß in der solange-Schleife in
jedem Schleifendurchlauf je ein Element von C und C' gelesen wird, und zwar
vom ersten Element bis zum letzten Element. Außerdem ist sofort zu sehen, daß
in jedem Schleifendurchlauf G um ein Element ergänzt wird. Da G vor dem
ersten Schleifendurchlauf kein Element enthält, wissen wir, daß |G| = |C| =
|C'|, sofern die Prozedur nicht infolge eines Fehlers verlassen wird. Deswegen
wollen wir als nächstes zeigen, daß der Fehlerfall nicht auftreten kann.
Es gibt in der Prozedur SampleWExpression vier Stellen, an denen der
Algorithmus abgebrochen werden kann.
a) wenn in einem Schleifendurchlauf das von C eingelesene Element t ein Wort,
eine Zeichenkette oder ein Sonderzeichen ist und ungleich dem von C'
eingelesenem Element u.
b) wenn in einem Schleifendurchlauf das von C eingelesene Element t eine Zahl
ist und das von C' eingelesen Element u nicht.
c) wenn C ein Element ungleich einem Sonderzeichen, einer Zeichenkette,
einem Wort oder einer Zahl enthält.
d) wenn |C| ≠ |C'|.
Nach unseren Vorbemerkungen können wir die Fälle c) und d) sofort
ausschließen. Sei jetzt ai für ein i ∈ {1,..,|C|} die i-te Anweisung im Ausdruck
von W. Dann werden im i-ten Schleifendurchlauf die
Beispielauswertungsfragmente t und u von ai gelesen. ai kann jetzt
Sonderzeichen, Zeichenkette, Wort oder Variable sein, da P keine
Zahlkonstanten enthält. Falls ai ist Sonderzeichen, Zeichenkette oder Wort,
muß gelten t = ai und u = ai. Also ist der Fall a) widerlegt. Falls ai eine Variable,
so müssen sowohl t als auch u Zahlen sein, womit auch der Fall b) nicht
zutreffen kann.
G enthält nur Zeichenketten, Sonderzeichen, Wörter und Variablen. Wir müssen
nun zeigen, daß für jedes i ∈ {1,..,|G|} die i-ten Elemente ci und ci' von C und C'
Beispielauswertungsfragmente des i-ten Elementes von G sind.
Sei also i beliebig und gi ist Sonderzeichen, Wort oder Zeichenkette. Dann muß
gelten: ci = ci' = gi. Aus obigen Überlegungen wissen wir bereits daß ci und ci' im
i-ten Schleifendurchlauf gelesen werden, und daß gilt ci = ci'. Dann wird aber ci
als i-tes Element von G angefügt. Also gilt gi = ci = ci'.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Falls gi ist eine Variable, so müssen ci und ci' Zahlen sein, und es muß gelten ci =
val(gi,j,E) und ci' = val(gi,k,E). Dabei sei E eine Entfaltung und j und k die
Nummern des Auftretens von gi an der Stelle ci und ci'. Da P keine
Zahlkonstanten enthält, müssen aber ci und ci' Werte einer Variablen von P
sein, etwa der Variablen x. Als i-tes Element von G wird aber gerade eine
Variable angefügt, deren Wert gerade dem von x entspricht. Also sind ci und ci'
Beispielauswertungsfragmente von gi.
Sei P jetzt das Programm, dessen Hauptanweisungsteil G ist und in dessen
Hauptinitialisationssequenz die Variablen von G mit ihren Anfangswerten zu
Beginn der Auswertung von G initialisiert werden. Die Ein- und Ausgaben von
P sind unerheblich. Es ist klar, daß G ein Programmfragment von P ist und daß
C ein Beispielauswertungsfragment einer Auswertung von P ist. Also ist C eine
Beispielauswertung von G. Die analoge Argumentation gilt auch für C'.
3. Jede Variable in G, die beim Aufruf der Prozedur nicht in V enthalten ist,
wird in V eingetragen. Ihr Anfangswert ist der Wert ihres ersten Auftretens
in C.
Sei v eine Variable in G und i die Nummer des ersten Vorkommens von v in G.
Also wurde v im i-ten Schleifendurchlauf an G angefügt. Sei c ihr Wert in C.
Das i-te Element von C muß also c sein. Falls v beim Aufruf der Prozedur in V
enthalten ist, so muß eine Variable in V existieren mit Endwert c, nämlich v.
Falls also keine solche Variable existiert, so kann v nicht in V enthalten sein. In
diesem Fall wird aber v in V eingetragen. Ihr Anfangswert ist der Wert c.
4. Am Ende der Prozedur ist jede Variable von G in V eingetragen. Ihr Endwert
ist der Wert ihres Auftretens in C.
Im Punkt 3 haben wir gezeigt, daß jede Variable v ∈ G, die zu Beginn der
Prozedur nicht in V eingetragen ist, in V eingetragen wird. Bei diesem Eintrag
wird der Wert von v in der Auswertung C als Endwert eingetragen. Sei nun v ∈
G, wobei v bereits zu Beginn der Prozedur in V enthalten ist. In diesem Fall
muß aber der Endwert von v in v mit dem Wert von v in C übereinstimmen, da
dieser sich innerhalb eines Ausdrucks nicht ändern kann.
5. Jede Variable in G wird in X eingetragen. Ihr Anfangswert und ihr Endwert
ist der Wert ihres Auftretens in C'.
Sei v eine Variable in G. Da X am Anfang der Prozedur leer, gilt zu Beginn der
Prozedur: v ∉ X. Sei i die Nummer des ersten Vorkommens von v in G. Dann
wurde v im i-ten Schleifendurchlauf an G angefügt. Sei c der Wert von v in C
und c' der Wert von v in C', so ist das i-te Element von C gleich c und das i-te
Element von C' gleich c'.
1. Fall: v ist zu Beginn der Prozedur in V enthalten.
Da v ∉ X (v wurde nicht in den ersten (i-1) Programmläufen in X eingetragen),
wird jetzt v mit Anfangs- und Endwert c' in X eingetragen.
2. Fall: v ist zu Beginn der Prozedur nicht in V enthalten.
Auch in diesem Fall wird v mit Anfangs- und Endwert c' in X eingetragen.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
/HPPD
6HL3HLQ.ODVVH,3URJUDPPGDVNHLQH=DKONRQVWDQWHQHQWKlOWXQG6HLQH
%HLVSLHODXVZHUWXQJYRQ36HL:HLQZKLOH.RQVWUXNWHLQ3GHU)RUP
ZLWKÃZKLOHÃ$ÃGRÃ%ÃHQGÃZKLOHÃ$$XVGUXFNXQG%$QZHLVXQJVVHTXHQ]
XQGVHL7HLQ%HLVSLHODXVZHUWXQJVIUDJPHQWYRQ:LQ6'LHHUVWHQEHLGHQ
WHVW.RQVWUXNWHYRQ7VHLHQ
WHVWÃ&ÃGRÃ'ÃHQGÃWHVW
WHVWÃ&ÃGRÃ'ÃHQGÃWHVW
'DEHLVLQG&XQG&%HLVSLHODXVZHUWXQJVIUDJPHQWHYRQ$XQG'XQG'
%HLVSLHODXVZHUWXQJVIUDJPHQWHYRQ%'LH9DULDEOHQOLVWH9HQWKDOWHDOOHLQ3
YRUGHU$XVZHUWXQJ7DXIJHWUHWHQHQ9DULDEOHQPLWLKUHQ$QIDQJVXQG
(QGZHUWHQYRUGHU$XVZHUWXQJGHVHUVWHQ(OHPHQWHVYRQ&'LH
9DULDEOHQOLVWH;VHLOHHU'HU$XIUXIGHU3UR]HGXUVDPSOH:([SUHVVLRQPLW
GHQ3DUDPHWHUQ&&9;*WHUPLQLHUHQDFKHQGOLFKYLHOHQ6FKULWWHQXQG
OLHIHUHDOV$XVJDEHHLQHQ$XVGUXFN*'DQQH[LVWLHUWHLQH
9DULDEOHQXPEHQHQQXQJσVRGD‰$ *σ
Beweis:
Nach Lemma 5.4.6 wissen wir, daß der Aufruf der Prozedur sampleWExpression
nach endlich vielen Schritten terminiert und einen Ausdruck G liefert. Dabei
sind C und C' Beispielauswertungsfragmente von A und von G. Weder A noch G
enthalten Zahlkonstanten, somit können beide nur Sonderzeichen, Wörter,
Zeichenketten oder Variable enthalten. Es ist klar, daß |G| = |A|. Sei für ein i
∈ {1,..,|A|} gi das i-te Element von G, ai das i-te Element von A ci das i-te
Element von C und c'i das i-te Element von C'. Falls gi Zeichenkette,
Sonderzeichen oder Wort, muß gelten ci = c'i = gi. Somit muß auch gelten ai = gi,
sonst könnten ci und c'i nicht Beispielauswertungsfragmente von ai sein
(dieselbe Überlegung gilt auch umgekehrt). Sei also gi eine Variable, so muß
auch ai eine Variable sein. Sei j die Position des ersten Auftretens von gi in G
und k die Position des ersten Auftretens von ai in A. Wir müssen als erstes
zeigen, daß k = j.
Sei c der Wert von gi in C und c' der Wert von gi in C'. Sei e der Wert von ai in C
und e' der Wert von ai in C'. Es ist klar, daß c = e = ci und c' = e' = c'i. Es gilt
demnach cj = c = e = ck. Sei aj die Variable an der j-ten Position von A und gk die
Variable an der k-ten Position von G. Dann wissen wir, daß aj, gk, ai und gi in C
den Wert c = e und in C' den Wert c' = e' haben. Da in Klasse-I-Programmen in
einem while-Konstrukt keine zwei verschiedenen Variablen vorkommen dürfen,
deren Wert in den ersten beiden Entfaltungen identisch ist, muß gelten aj = ai.
Da k die Position des ersten Vorkommens von ai in A ist, muß gelten j ≥ k.
Nehmen wir jetzt an, es gelte j > k. Dann gilt gk ≠ gi, denn das erste Vorkommen
von gi ist an der Position j. Wir wissen, daß in der Prozedur sampleWExpression
nach dem k-ten Schleifendurchlauf die Variable gk in V und X eingetragen ist
mit den Endwerten c und c'. Dann wird aber im j-ten Schleifendurchlauf eine
Variable in V mit dem Wert c = ci und in X mit dem Wert c' = c'i gefunden,
nämlich die Variable gk und wird als j-tes Element von G angefügt. Also kann gi
nicht j-tes Element von G sein im Widerspruch zur Annahme, daß j die Position
des ersten Vorkommens der Variablen gi sei. Also muß die Annahme j > k falsch
sein und es ist bewiesen, daß j = k.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Dann ist das j-te Element von C gleich c und das j-te Element von C’ gleich c’.
Falls gi zu Beginn der Prozedur in V enthalten ist, gilt gi = ai, da V alle in P
vorkommenden Variablen vor der Stelle der Auswertung T enthält. Sei also gi
eine Variable, die zu Beginn der Prozedur nicht in V enthalten ist. Dann gilt im
allgemeinen gi ≠ ai, allerdings stimmen die Werte der Variablen in C und C'
überein. Sei nun m eine weitere Position eines Vorkommens von gi in G. Dann
muß das m-te Element von C der Wert c sein und das i-te Element von C' der
Wert c' sein. Da in Klasse-I-Programmen keine zwei Variablen in einem
Ausdruck erlaubt sind, die in den ersten beiden Entfaltungen in ihren Werten
übereinstimmen, muß ai das m-te Element von A sein. Umgekehrt, falls n die
Position eines weiteren Vorkommens von ai in A ist, wissen wir, daß die n-ten
Elemente in C und C' gerade c und c' sind. Es ist aber eine Variable in den
Variablenlisten V und X zu Beginn des n-ten Schleifendurchlaufs in der
Prozedur enthalten, nämlich die Variable gi. Also wird gi das m-te Element von
G. Damit wissen wir, daß für jedes n∈ {1,..,|A|} gilt: Das n-te Element von A ist
die Variable ai genau dann, wenn das n-te Element von g ist die Variable gi für
jede Variable in A und G.
Definieren wir nun σ so, daß jede Variable gi zu der zugehörigen Variablen ai
zugeordnet wird, folgt die Behauptung.
Wenden wir uns nun der Prozedur SampleWSequence zu. Zunächst betrachten wir den
vereinfachten Fall, daß die Anweisungssequenz keine lokalen while-Konstrukte enthält.
/HPPD
6HL3HLQ.ODVVH,3URJUDPPGDVNHLQH=DKONRQVWDQWHQHQWKlOWXQG6HLQH
%HLVSLHODXVZHUWXQJYRQ66HL:HLQZKLOH.RQVWUXNWLQ:PLWG: XQG
7HLQ%HLVSLHODXVZHUWXQJVIUDJPHQWYRQ:LQ6'LHHUVWHQEHLGHQWHVW
.RQVWUXNWHYRQ7VHLHQ
test C do D end test
test C’ do D’ end test
'DEHLVHLHQ&XQG&%HLVSLHODXVZHUWXQJVIUDJPHQWHGHV$XVGUXFNHVYRQ:
XQG'XQG'%HLVSLHODXVZHUWXQJVIUDJPHQWHGHU$QZHLVXQJVVHTXHQ]YRQ:
6HLHQ9XQG;9DULDEOHQOLVWHQ) UMHGH9DULDEOHYLP$XVGUXFNYRQ:
H[LVWLHUWHLQH9DULDEOH[LQ9XQG;VRGD‰GHU(QGZHUWYRQ[LQ9LVWGHU
:HUWYRQYLQ&XQGGHU(QGZHUWYRQ[LQ;LVWGHU:HUWYRQYLQ&'DQQ
JLOWI UGHQ$XIUXIGHU3UR]HGXU6DPSOH:6WDWHPHQW6HTXHQFHPLWGHQ
3DUDPHWHUQ''9;+
'LH3UR]HGXUWHUPLQLHUWQDFKHQGOLFKYLHOHQ6FKULWWHQ
'XQG'VLQG%HLVSLHODXVZHUWXQJHQYRQ+
-HGH9DULDEOHLQ+GLHEHLP$XIUXIGHU3UR]HGXUQLFKWLQ9HQWKDOWHQLVW
ZLUGLQ9HLQJHWUDJHQ,KU$QIDQJVZHUWLVWGHU:HUWLKUHVHUVWHQ
$XIWUHWHQVLQ'
$P(QGHGHU3UR]HGXULVWMHGH9DULDEOHYRQ+LQ9HLQJHWUDJHQ,KU
(QGZHUWLVWGHU:HUWLKUHVOHW]WHQ$XIWUHWHQVLQ'
-HGH9DULDEOHLQ+GLHEHLP$XIUXIGHU3UR]HGXUQLFKWLQ;HQWKDOWHQLVW
ZLUGLQ;HLQJHWUDJHQ,KU$QIDQJVZHUWLVWGHU:HUWLKUHVHUVWHQ
$XIWUHWHQVLQ'
$P(QGHGHU3UR]HGXULVWMHGH9DULDEOHYRQ+LQ;HLQJHWUDJHQ,KU
(QGZHUWLVWGHU:HUWLKUHVOHW]WHQ$XIWUHWHQVLQ'
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Beweis:
1. Die Prozedur terminiert nach endlich vielen Schritten.
W enthält keine lokalen while-Konstrukte. Daraus folgt, daß |D| = |D'|, da
jede Anweisung der Anweisungssequenz in genau eine Anweisung des
Beispielauswertungsfragmentes überführt wird. Falls D = "", wird die Prozedur
sofort beendet. Nehmen wir also an m = |D| = |D'| > 0. In diesem Fall wird die
solange-Schleife betreten und spätestens dann verlassen, wenn die Lesezeiger
am Ende von D und D' stehen. Da vor dem ersten Schleifendurchlauf diese vor
der ersten Anweisung der Anweisungssequenz stehen und beide Lesezeiger um
je ein Element vorgezogen werden, terminiert die Schleife nach m
Schleifendurchläufen. Da außerdem jeder Schleifendurchlauf in endlicher Zeit
beendet ist, ist auch die Prozedur nach endlich vielen Schritten beendet.
2. D und D' sind Beispielauswertungen von H.
D und D' dürfen nur Zeichenketten, Wörter, Sonderzeichen und Zahlen
enthalten. Unter Punkt 1 haben wir gesehen, daß in der solange-Schleife in
jedem Schleifendurchlauf je ein Element von D und D' gelesen wird, und zwar
vom ersten Element bis zum letzten Element. Außerdem ist sofort zu sehen, daß
in jedem Schleifendurchlauf H um genau ein Element ergänzt wird. Da H vor
dem ersten Schleifendurchlauf kein Element enthält, wissen wir, daß |H| =
|D| = |D'|, sofern die Prozedur nicht infolge eines Fehlers verlassen wird.
Deswegen wollen wir als nächstes zeigen, daß der Fehlerfall nicht auftreten
kann.
Es gibt in der Prozedur SampleWExpression vier Stellen, an denen der
Algorithmus abgebrochen werden kann.
a) wenn in einem Schleifendurchlauf das von D eingelesene Element t ein Wort,
eine Zeichenkette oder ein Sonderzeichen ist und ungleich dem von D'
eingelesenem Element u.
b) wenn in einem Schleifendurchlauf das von D eingelesene Element t eine Zahl
ist und das von D' eingelesen Element u nicht.
c) wenn D ein Element ungleich einem Sonderzeichen, einer Zeichenkette,
einem Wort oder einer Zahl enthält.
d) wenn |D| ≠ |D'|.
Nach unseren Vorbemerkungen können wir die Fälle c) und d) sofort
ausschließen. Sei jetzt ai für ein i ∈ {1,..,|D|} die i-te Anweisung im Ausdruck
von W. Dann werden im i-ten Schleifendurchlauf die
Beispielauswertungsfragmente t und u von ai gelesen. ai kann jetzt
Sonderzeichen, Zeichenkette, Wort oder Variable sein, da P keine
Zahlkonstanten enthält. Falls ai ist Sonderzeichen, Zeichenkette oder Wort,
muß gelten t = ai und u = ai. Also ist der Fall a) widerlegt. Falls ai eine Variable,
so müssen sowohl t als auch u Zahlen sein, womit auch der Fall b) nicht
zutreffen kann.
H enthält nur Zeichenketten, Sonderzeichen, Wörter, Variablen, Inkremente
und Dekremente. Wir müssen nun zeigen, daß für jedes i ∈ {1,..,|H|} die i-ten
Elemente di und di' von D und D' Beispielauswertungsfragmente des i-ten
Elementes hi von H sind. Sei also i beliebig.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
1. Fall: hi ist Sonderzeichen, Wort oder Zeichenfolge:
Aus obigen Überlegungen wissen wir bereits daß di und di' im i-ten
Schleifendurchlauf gelesen werden, und daß gilt di = di'. Dann wird aber di als i-
tes Element von H angefügt. Also gilt hi = di = di'. Also sind di und d'i
Beispielauswertungsfragmente von hi.
2. Fall: hi ist Variable:
Da im i-ten Schritt eine Variable in H angefügt worden ist, müssen sowohl di als
auch d'i Zahlen sein. Da P keine Zahlkonstanten enthält, müssen aber di und di'
Werte einer Variablen von P sein, etwa der Variablen x, die aber auch in einem
Inkrement oder einem Dekrement vorkommen kann. Schauen wir uns diese
Möglichkeiten an:
a) x steht nicht innerhalb eines Inkrementes oder Dekrementes und x kommt
nicht zum erstenmal in W vor.
b) x steht nicht innerhalb eines Inkrementes oder Dekrementes und x kommt
zum erstenmal in W vor.
c) x steht innerhalb eines Inkrementes (dann muß x schon einmal in W
vorgekommen sein)
d) x steht innerhalb eines Dekrementes (dann muß x schon einmal in W
vorgekommen sein)
Wenden wir uns zuerst dem Punkt b) zu. In diesem Fall kann es keine Variable
v∈V, v∈X geben, so daß der Endwert von v in V im i-ten Schleifendurchlauf
entspricht di und der Endwert von v in X entspricht di'.
Beweis: (indirekt)
Annahme, es gebe eine solche Variable v in den Variablenlisten. Dann muß es
aber eine Variable y in W geben, deren Beispielauswertungen an einer Stelle in
C/C' oder D/D' gleich di oder di' sind, denn sonst würden die Werte di und di'
nicht als Endwerte einer Variablen in V und X aufgenommen . Es kann aber
keine zwei Variablen in einem Klasse-I-Programm geben, deren Differenz der
Werte in zwei Entfaltungen desselben while-Konstruktes gleich sind. Also muß
gelten y = x im Widerspruch zur Annahme, x käme an der Stelle i zum
erstenmal in W vor.
Die analoge Argumentation verbietet auch das Vorkommen einer Variablen
v∈V, v∈X geben, so daß der Endwert von v in V im i-ten Schleifendurchlauf
entspricht di-1 und der Endwert von v in X entspricht di'-1, bzw. der Endwert
von v in V im i-ten Schleifendurchlauf entspricht di+1 und der Endwert von v in
X entspricht di'+1.
Es kann jetzt sein, daß eine Variable v in V existiert, deren Endwert di ist. Dann
wird die Variable v auch in X eingetragen mit Anfangs- und Endwert v.
Ansonsten wird eine neue Variable generiert (etwa v) und mit Anfangs- und
Endwert di und di' in V und X eingetragen. Es gilt dann hi = v. Damit sind aber
di und di' Beispielauswertungsfragmente von hi (falls V und X tatsächlich die
Werte der Variablen in H repräsentieren).
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Damit die Fälle a), c) oder d) auftreten können, muß x wie in Fall b) in W
vorgekommen sein. Annahme: Das erste Vorkommen von x geschieht im
Ausdruck von W. Dann wissen wir nach Voraussetzung des Lemmas, daß in den
Variablenlisten V und X eine Variable, etwa v, enthalten ist, deren Wert im
Ausdruck dem Wert von x entspricht. Wenn aber das erste Vorkommen von x in
der Anweisungssequenz von W liegt, wissen wir aus der Behandlung von b), daß
es eine Variable, etwa v, in V und X gibt, deren Wert an der Stelle des ersten
Vorkommens von x mit dem Wert von x übereinstimmt.
Wir zeigen jetzt induktiv, daß der Wert von v auch an den Stellen des weiteren
Vorkommens der Variablen x übereinstimmt.
Annahme: Die Endwerte der Variablen v in V und X beim m-ten Vorkommen
der Variablen x in W entsprechen den Werten der Variablen x bei ihrem m-ten
Vorkommen in den Auswertungen D und D'.
Betrachten wir jetzt das (m+1)-te Vorkommen der Variablen x. Es ist klar, daß
zwischen zwei Vorkommen die Endwerte der Variablen v in V und X nicht
verändert werden konnten. Falls dies geschehen wäre, müßte es eine Variable y
≠ x geben, deren Differenz der Werte in D und D' gleich der Differenz der Werte
von x in D und D' entspricht, was aber in Klasse-I-Programmen nicht der Fall
ist.
Das (m+1)-te Vorkommen von x sei (wie in Fall a) außerhalb eines Inkrementes
oder Dekrementes. Dann wird der Wert von v (ebenso wie der Wert von x) nicht
verändert.
Wenn das (m+1)-te Vorkommen von x innerhalb eines Inkrementes liegt, so
wird der Wert von x um 1 erhöht. Sei e der Wert von x in D und e' der Wert von
x in D'. Wir wissen, es existiert eine Variable v in V und X mit den Endwerten e-
1 und e'-1. Gleichzeitig wissen wir, daß es keine Variable in V und X mit den
Endwerten e und e' gibt, denn wenn dies der Fall wäre, müßte es eine Variablen
in W ungleich x geben, Differenz der Werte in D und D' gleich der Differenz der
Werte von x ist. Dies ist aber in P nicht möglich. Also wird gi gesetzt auf ++v
und der Wert von v wird in V und X auf e und e' gesetzt.
Die letzte Möglichkeit ist das Vorkommen von x in einem Dekrement. Seien e
und e' die Werte von x in D und D' vor dem Dekrement und f und f' die Werte
von c in D und D' beim Auftreten des Dekrementes. Dann wissen wir, daß in
Klasse-I-Programmen immer gilt: f < e und f' < e'. Gleichzeitig wissen wir aus
der Induktionsvoraussetzung, daß die Variablen v in V und X die Werte e und e'
besitzt. Es kann keine zweite Variable in W vorkommen, deren Differenz ihres
Wertes in D und D' gleich der Differenz des Wertes von x sein kann. Also wissen
wir auch, daß V und X keine Variable enthalten mit den Werten f und f', sowie f-
1 und f'-1. Also wird in H das Dekrement --v eingetragen und die Werte von v in
V und X auf f und f' erniedrigt.
Aus obiger Überlegung sehen wir, daß für den Fall a) hi = v ist, wobei der Wert
von v in V gleich di und der Wert von v in X gleich di' ist. Somit sind di und di'
Beispielauswertungsfragmente von hi.
Die Fälle c) und d) können nicht eintreten, da dann der Wert von v nicht mit
dem Wert von x übereinstimmt.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
3. Fall : hi ist Inkrement:
Dann müssen di und d'i Zahlen sein, nämlich die Werte einer Variablen
(eventuell in einem Dekrement oder Inkrement). Sei x diese Variable. Dann
liefert uns die Überlegungen aus dem 2. Fall die Aussage, daß eine Variable
(etwa v) in V und X existiert, deren Wert an der Stelle i gleich dem Wert von x
an der Stelle i ist, also ist der Wert von v in D gleich di und in D' gleich di'. Also
sind di und di' Beispielauswertungsfragmente von hi. Da v in einen Inkrement
vorkommt, muß auch x in einem Inkrement vorkommen.
4. Fall: hi ist Dekrement:
Dann müssen di und d'i Zahlen sein, nämlich die Werte einer Variablen
(eventuell in einem Dekrement oder Inkrement). Sei x diese Variable. Dann
liefert uns die Überlegungen aus dem 2. Fall die Aussage, daß eine Variable
(etwa v) in V und X existiert, deren Wert an der Stelle i gleich dem Wert von x
an der Stelle i ist, also ist der Wert von v in D gleich di und in D' gleich di'. Also
sind di und di' Beispielauswertungsfragmente von hi. Da v in einem Dekrement
vorkommt, muß auch x in einem Dekrement vorkommen.
Wir haben jetzt gezeigt, daß in jedem Fall di und di'
Beispielauswertungsfragmente von hi sind. Sei P jetzt das Programm, dessen
Hauptanweisungsteil H ist und in dessen Hauptinitialisationssequenz die
Variablen von H mit ihren Anfangswerten zu Beginn der Auswertung von H
initialisiert werden. Die Ein- und Ausgaben von P sind unerheblich. Es ist klar,
daß H ein Programmfragment von P ist und daß D ein
Beispielauswertungsfragment einer Auswertung von P ist. Also ist D eine
Beispielauswertung von H. Die analoge Argumentation gilt auch für D'.
3. Jede Variable in H, die beim Aufruf der Prozedur nicht in V enthalten ist,
wird in V eingetragen. Ihr Anfangswert ist der Wert ihres ersten Auftretens
in D.
Sei v eine Variable in H und i die Nummer des ersten Vorkommens von v in H.
Dieses erste Vorkommen darf nicht innerhalb eines Inkrementes oder
Dekrementes sein. v wurde im i-ten Schleifendurchlauf an H angefügt. Sei d ihr
Wert in D. Das i-te Element von D muß also d sein. Falls v beim Aufruf der
Prozedur in V enthalten ist, so muß eine Variable in V existieren mit Endwert d,
nämlich v. Falls also keine solche Variable existiert, so kann v nicht in V
enthalten sein. In diesem Fall wird aber v in V eingetragen. Ihr Anfangswert ist
der Wert d.
4. Am Ende der Prozedur ist jede Variable von H in V eingetragen. Ihr Endwert
ist der Wert ihres letzten Auftretens in D.
Im Punkt 3 haben wir gezeigt, daß jede Variable v ∈ H, die zu Beginn der
Prozedur nicht in V eingetragen ist, in V eingetragen wird. Bei diesem Eintrag
wird der Wert von v in der Auswertung D als Endwert eingetragen. Es ist damit
klar, daß am Ende der Prozedur jede Variablen von H in V eingetragen ist.
Wir zeigen jetzt, daß der Wert von v in der Auswertung D mit dem Endwert von
v in der Variablenliste V übereinstimmt. Der Wert von v bei der Auswertung
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
kann nur aus zwei Gründen geändert werden: a) v kommt in einem Inkrement
vor. b) v kommt in einem Dekrement vor. Immer aber, wenn ++v oder --v in h
eingetragen wird, wird der Wert von v in V auf den neuen Wert der Variablen
gesetzt. Da der Wert von v in V ansonsten nicht verändert wird, gilt die
Behauptung auch für den letzten Wert von v in D.
5. Jede Variable in H, die beim Aufruf der Prozedur nicht in X enthalten ist,
wird in X eingetragen. Ihr Anfangswert ist der Wert ihres ersten Auftretens
in D'.
und
6. Am Ende der Prozedur ist jede Variable von H in X eingetragen. Ihr Endwert
ist der Wert ihres letzten Auftretens in D'.
Der Beweis dieser Aussagen verläuft vollkommen analog zum Beweis der
Punkte 3 und 4.
/HPPD
6HL3HLQ.ODVVH,3URJUDPPGDVNHLQH=DKONRQVWDQWHQHQWKlOWXQG6HLQH
%HLVSLHODXVZHUWXQJYRQ36HL:HLQZKLOH.RQVWUXNWHLQ3GHU)RUP
with while A do B end while ($$XVGUXFNXQG%
$QZHLVXQJVVHTXHQ]
'DEHLHQWKDOWH%NHLQHORNDOHQZKLOH.RQVWUXNWH
(VVHL7HLQ%HLVSLHODXVZHUWXQJVIUDJPHQWYRQ:LQ6'LHHUVWHQEHLGHQWHVW
.RQVWUXNWHYRQ7VHLHQ
test C do D end test
test C’ do D’ end test
'DEHLVLQG&XQG&%HLVSLHODXVZHUWXQJVIUDJPHQWHYRQ$XQG'XQG'
%HLVSLHODXVZHUWXQJVIUDJPHQWHYRQ%'LH9DULDEOHQOLVWH9HQWKDOWHDOOHLQ3
YRUGHU$XVZHUWXQJ7DXIJHWUHWHQHQ9DULDEOHQPLWLKUHQ$QIDQJVXQG
(QGZHUWHQYRUGHU$XVZHUWXQJGHVHUVWHQ(OHPHQWHVYRQ') UMHGH
9DULDEOHYLP$XVGUXFNYRQ:H[LVWLHUWHLQH9DULDEOH[LQ9XQG;VRGD‰
GHU(QGZHUWYRQ[LQ9LVWGHU:HUWYRQYLQ&XQGGHU(QGZHUWYRQ[LQ;LVW
GHU:HUWYRQYLQ&'HU$XIUXIGHU3UR]HGXUVDPSOH:6WDWHPHQW6HTXHQFH
PLWGHQ3DUDPHWHUQ''9;+WHUPLQLHUHQDFKHQGOLFKYLHOHQ6FKULWWHQ
XQGOLHIHUHDOV$XVJDEHHLQHQ$XVGUXFN+'DQQH[LVWLHUWHLQH
9DULDEOHQXPEHQHQQXQJσVRGD‰% +σ
Beweis:
Nach Lemma 5.4.8 wissen wir, daß der Aufruf der Prozedur
sampleWStatementSequence nach endlich vielen Schritten terminiert und eine
Anweisungssequenz H liefert. Dabei sind D und D'
Beispielauswertungsfragmente von B und von H.
Klar ist, daß |B| = |H| und daß weder B noch H while-Konstrukte und
Zahlkonstanten enthalten können. Sei für ein beliebiges i∈{1,..,|B|} bi die i-te
Anweisung von B und hi die i-te Anweisung von H. Falls bi ist Sonderzeichen,
Wort oder Zeichenkette, so gilt bi = hi. Es sind also nur die Fälle interessant, daß
bi Variable, Inkrement oder Dekrement ist.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
In Teil 2 des Beweises von Lemma 5.4.9 haben wir gezeigt, daß es für jede in B
vorkommende Variable v eine in H vorkommende Variable x gibt, deren
Endwert in der Variablenliste V an der Stelle des Vorkommens eines
Beispielauswertungsfragmentes der Variablen v in D gleich dem Wert von v ist,
und deren Endwert in der Variablenliste X an der Stelle des Vorkommens eines
Beispielauswertungsfragmentes der Variablen v in D' gleich dem Wert von v ist.
Bei der Bildung von H wurde aber gerade jedes Vorkommen von v in B durch x
ersetzt. Zur Vervollständigung des Beweises müssen wir nun noch zeigen, daß
es kein Vorkommen von x in H gibt, so daß (für ein i) x ist in hi enthalten, und v
ist nicht in bi enthalten.
Nehmen wir an, ein solches i existiere. Sei x die in hi vorkommende Variable. Es
ist klar, daß bi nur eine Variable, ein Inkrement oder ein Dekrement sein kann,
denn sonst wäre bi = hi und hi könnte eine Variable enthalten. Sei w die in bi
vorkommende Variable. Wir wissen nun, daß es ein in H vorkommendes y gibt,
so daß beim Übergang von B nach H jedes Vorkommen von w durch y ersetzt
wurde. Also muß gelten x = y. Dann gilt aber auch v = w.
/HPPD
6HL3HLQ.ODVVH,3URJUDPPGDVNHLQH=DKONRQVWDQWHQHQWKlOWXQG6HLQH
%HLVSLHODXVZHUWXQJYRQ36HL:HLQZKLOH.RQVWUXNWHLQ3GHU)RUP
with while A do B end while $$XVGUXFNXQG%
$QZHLVXQJVVHTXHQ]
'DEHLHQWKDOWH%NHLQHORNDOHQZKLOH.RQVWUXNWH
(VVHL7HLQ%HLVSLHODXVZHUWXQJVIUDJPHQWYRQ:LQ6'LHHUVWHQEHLGHQWHVW
.RQVWUXNWHYRQ7VHLHQ
test C do D end test
test C’ do D’ end test
'DEHLVLQG&XQG&%HLVSLHODXVZHUWXQJVIUDJPHQWHYRQ$XQG'XQG'
%HLVSLHODXVZHUWXQJVIUDJPHQWHYRQ%'LH9DULDEOHQOLVWH9HQWKDOWHDOOHLQ3
YRUGHU$XVZHUWXQJ7DXIJHWUHWHQHQ9DULDEOHQPLWLKUHQ$QIDQJVXQG
(QGZHUWHQYRUGHU$XVZHUWXQJGHVHUVWHQ(OHPHQWHVYRQ') UMHGH
9DULDEOHYLP$XVGUXFNYRQ:H[LVWLHUWHLQH9DULDEOH[LQ9XQG;VRGD‰
GHU(QGZHUWYRQ[LQ9LVWGHU:HUWYRQYLQ&XQGGHU(QGZHUWYRQ[LQ;LVW
GHU:HUWYRQYLQ&'LH3UR]HGXUVDPSOH:6WDWHPHQW6HTXHQFHZHUGHPLW
GHQ3DUDPHWHUQ''9;+DXIJHUXIHQ6HLσGLH9DULDEOHQXPEHQHQQXQJ
DXV/HPPD4HQWVWHKHDXV3GXUFKHUVHW]HQYRQ%GXUFK+σ'DQQ
VWLPPHQGLH:HUWHEHLGHU$XVZHUWXQJYRQ3QDFKMHGHU$XVZHUWXQJYRQ%
PLWGHQ:HUWHQGHU$XVZHUWXQJYRQ4QDFKMHGHU$XVZHUWXQJYRQ+σ
EHUHLQ
Beweis:
Nach Lemma 5.4.9 ist P = Q. Damit stimmen die Auswertungen von P und Q
überein.
Wir wollen nun die Prozedur SampleWSequence untersuchen für den Fall, daß die
Anweisungssequenz lokale while-Konstrukte enthalten dürfen. Dazu müssen wir wieder
Aussagen über die Korrektheit der Prozedur SampleWHILE machen.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
/HPPD
6HL3HLQ.ODVVH,3URJUDPPGDVNHLQH=DKONRQVWDQWHQHQWKlOWXQG6HLQH
%HLVSLHODXVZHUWXQJYRQ3
6HL:HLQZKLOH.RQVWUXNWLQ3PLW': G∈©XQG7HLQ
%HLVSLHODXVZHUWXQJVIUDJPHQWYRQ:LQ6
) UGLH3UR]HGXU6DPSOH:+,/(JHOWHQGLHIROJHQGHQ9RUDXVVHW]XQJHQ
6HL:HLQZKLOH.RQVWUXNWYRQ3PLW':G:KDEHGLHIROJHQGH)RUP
with while A’ do B’ end while
'DEHLVHL$HLQ$XVGUXFNXQG%HLQH$QZHLVXQJVVHTXHQ]6HL7HLQ
%HLVSLHODXVZHUWXQJVIUDJPHQWYRQ6'LHHUVWHQEHLGHQWHVW.RQVWUXNWHYRQ7
ODXWHQ
test E do F end test
test E’ do F’ end test
'DEHLVHLHQ(XQG(%HLVSLHODXVZHUWXQJVIUDJPHQWHYRQ$XQG'XQG'
%HLVSLHODXVZHUWXQJVIUDJPHQWHYRQ%6HL9HLQH9DULDEOHQOLVWH'DQQJLOW
I UGHQ$XIUXIGHU3UR]HGXU6DPSOH:+,/(PLWGHQ3DUDPHWHUQ()()9*
XQG+ZREHLGLH$XVJDEHYDULDEOH*HLQ$XVGUXFNXQGGLH$XVJDEHYDULDEOH
+HLQH$QZHLVXQJVVHTXHQ]LVW
, 'LH3UR]HGXUWHUPLQLHUWQDFKHQGOLFKYLHOHQ6FKULWWHQ
,, 6HL8 with while G’ do H’ end while 'DQQLVW7HLQH
%HLVSLHODXVZHUWXQJYRQ8
,,,(VJLEWHLQH9DULDEOHQXPEHQHQQXQJσVRGD‰*σ $XQG+σ %
,9:LUGLQ*RGHU+HLQH9DULDEOHYHUZHQGHWGLHQLFKWEHUHLWVEHLP$XIUXI
GHU3UR]HGXULQ9HQWKDOWHQLVWVRZLUGVLHPLWLKUHP$QIDQJVZHUWLQ9
HLQJHWUDJHQ
9 9HQWKlOWDP(QGHGHU3UR]HGXUGLH:HUWHDOOHULQ*XQG+
YRUNRPPHQGHQ9DULDEOHQDP(QGHGHU$XVZHUWXQJ)
'LHHUVWHQEHLGHQWHVW.RQVWUXNWHYRQ7VHLHQ
test C do D end test
test C’ do D’ end test
'DEHLVHLHQ&XQG&%HLVSLHODXVZHUWXQJVIUDJPHQWHGHV$XVGUXFNHVYRQ:
XQG'XQG'%HLVSLHODXVZHUWXQJVIUDJPHQWHGHU$QZHLVXQJVVHTXHQ]YRQ:
6HLHQ9XQG;9DULDEOHQOLVWHQ) UMHGH9DULDEOHYLP$XVGUXFNYRQ:
H[LVWLHUWHLQH9DULDEOH[LQ9XQG;VRGD‰GHU(QGZHUWYRQ[LQ9LVWGHU
:HUWYRQYLQ&XQGGHU(QGZHUWYRQ[LQ;LVWGHU:HUWYRQYLQ&;
HQWKlOWVRQVWNHLQH9DULDEOH'DQQJLOWI UGHQ$XIUXIGHU3UR]HGXU
6DPSOH:6WDWHPHQW6HTXHQFHPLWGHQ3DUDPHWHUQ''9;+
'LH3UR]HGXUWHUPLQLHUWQDFKHQGOLFKYLHOHQ6FKULWWHQ
'XQG'VLQG%HLVSLHODXVZHUWXQJHQYRQ+
-HGH9DULDEOHLQ+GLHEHLP$XIUXIGHU3UR]HGXUQLFKWLQ9HQWKDOWHQLVW
ZLUGLQ9HLQJHWUDJHQ,KU$QIDQJVZHUWLVWGHU:HUWLKUHVHUVWHQ
$XIWUHWHQVLQ'
P(QGHGHU3UR]HGXULVWMHGH9DULDEOHYRQ+LQ9HLQJHWUDJHQ,KU
(QGZHUWLVWGHU:HUWLKUHVOHW]WHQ$XIWUHWHQVLQ'
-HGH9DULDEOHLQ+GLHEHLP$XIUXIGHU3UR]HGXUQLFKWLQ;HQWKDOWHQLVW
ZLUGLQ;HLQJHWUDJHQ,KU$QIDQJVZHUWLVWGHU:HUWLKUHVHUVWHQ
$XIWUHWHQVLQ'
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
$P(QGHGHU3UR]HGXULVWMHGH9DULDEOHYRQ+LQ;HLQJHWUDJHQ,KU
(QGZHUWLVWGHU:HUWLKUHVOHW]WHQ$XIWUHWHQVLQ'
Beweis:
1. Die Prozedur terminiert nach endlich vielen Schritten.
Falls die äußere solange-Schleife nicht betreten wird, ist die Termination der
Prozedur gesichert. Nehmen wir also an, die Schleife werde mindestens einmal
durchlaufen.
Man beachte, daß bei jedem Schleifendurchlauf der äußeren solange-Schleife
mindestens ein Element t von D und mindestens ein Element u von D‘ gelesen
wird. Dann werden die Lesezeiger beider Sequenzen um (mindestens) ein
Element vorgestellt. Da vor dem ersten Schleifendurchlauf beide Zeiger am
Anfang der Sequenzen stehen, ist sichergestellt, daß nach maximal
min(|D|,|D'|) Schleifendurchläufen einer der Zeiger hinter dem letzten
Element seiner Sequenz steht, sofern die Schleife nicht vorzeitig beendet wird.
Wir zeigen nun, daß jeder Schleifendurchlauf der äußeren solange-Schleife
terminiert. In einem beliebigen Schleifendurchlauf werde das Element t von D
gelesen. Falls t ist Wort, Sonderzeichen, Zeichenkette oder Zahl ist der
Schleifendurchlauf in endlicher Zeit abgearbeitet. Sei nun t ein test-Konstrukt.
Falls auch das von D' gelesene Element u ein test-Konstrukt ist, erfolgen bis zu
fünf Prozeduraufrufe und es können zwei solange-Schleifen betreten werden.
Bei den ersten beiden Prozeduraufrufen wird die Prozedur SampleWHILE
aufgerufen. Für diesen Aufruf gilt aber die Voraussetzung, wonach die Prozedur
nach endlicher Zeit terminiert. Die Termination des dritten Aufrufs, in dem die
Prozedur MatchWHILE benötigt wird, folgt aus Lemma 5.4.5. Die Termination
der Aufrufe der Prozedur TestWExpression folgt nach Lemma 5.4.1. Die
folgenden solange-Schleifen werden beendet, wenn ein Lesezeiger hinter de
letzten Element seiner Sequenz steht. Da dieser Zeiger aber in der inneren
solange-Schleife um ein Element vorgestellt wird, ist die Termination gesichert.
In den inneren solange-Schleifen wird die Prozedur TestWHILE aufgerufen,
deren Termination nach endlich vielen Schritten aber bereits in Lemma 5.4.4
bewiesen worden ist. Dann terminiert auch in diesem Fall der
Schleifendurchlauf der äußeren solange-Schleife, und die Termination der
Prozedur SampleWSequence ist gesichert.
2. D und D' sind Beispielauswertungen von H.
Sei B die Anweisungssequenz von W. Wir beweisen den folgenden Hilfssatz
durch Induktion über die Länge eines Anfangsstückes von B.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Hilfssatz:
a) Für jedes i ∈ {0,..,|B|} wird die äußere solange-Schleife mindestens i-mal
durchlaufen.
b) H hat nach dem Ende des i-ten Schleifendurchlaufs genau i Elemente.
c) Die Lesezeiger in D und D' stehen hinter der Auswertung des i-ten Elementes
von B.
d) Die Anfangsstücke von D und D', die durch Auswertung der ersten i Elemente
von B entstehen, sind Beispielauswertungen von H nach dem i-ten
Schleifendurchlauf.
e) Die Variablenliste V enthält (mindestens) alle in den ersten i
Schleifendurchläufe in H verwendeten Variablen mit ihrem Endwerten an der
Stelle des i-ten Schleifendurchlaufs in D.
f) Die Variablenliste X enthält (mindestens) alle in den ersten i
Schleifendurchläufen in H verwendeten Variablen mit ihren Endwerten an der
Stelle des i-ten Schleifendurchlaufs in D'.
g) Zu jeder im Anfangsstück von B vorkommenden Variablen x existiert eine
Variable v in H, deren Werte in D und D' mit den Werten von x
übereinstimmen.
Beweis des Hilfssatzes:
Die Induktionsverankerung gilt trivialerweise. Die Behauptung gelte jetzt für
alle i ≤ n ∈ © (n < |B|).
Sei b das (n+1)-te Element von B. b kann keine Zahlkonstante sein. Nach
Induktionsvoraussetzung wird die Schleife n-mal durchlaufen. Die Lesezeiger
stehen hinter der Auswertung des n-ten Element von B. Dies kann nicht hinter
dem letzten Element von D und D' sein, da ansonsten D und D' keine
Auswertung von b enthielten. Also wird die Schleife wiederum betreten (es muß
allerdings bewiesen werden, daß der Schleifendurchlauf nicht vorzeitig beendet
wird).
Sei t das von D gelesene Element und u das von D' gelesene Element. Man
beachte, daß beide Lesezeiger um ein Element vorgestellt werden. Wir
unterscheiden jetzt nach b:
1. Fall: b ist Sonderzeichen, Wort oder Zeichenfolge:
In diesem Fall gilt t = u = b, da t und u Beispielauswertungen von b sind. Das
(n+1)-te Element von H ist aber dann ebenfalls b. Nach
Induktionsvoraussetzung sind die Anfangsstücke von D und D', die durch
Auswertung der ersten n Elemente von b entstanden sind,
Beispielauswertungen für die ersten n Elemente von H. Dann sind aber die
Anfangsstücke von D und D' bis einschließlich der Elemente t und u
Beispielauswertungen der ersten n+1 Elementen von H. Da die Auswertung von
b nur aus einem Element besteht, stehen die Lesezeiger hinter der Auswertung
des (n+1)-ten Elementes von B. Die Aussagen über V und X gelten nach wie vor
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
nach Induktionsvoraussetzung, da weder V noch X, noch der Wert einer
Variablen verändert wurde.
2. Fall: b ist Variable, etwa x, und x kommt in den ersten n Anweisungen von B
und in A nicht vor:
Sei d der Wert von b in D und d' der Wert von b in D' (jeweils an der Stelle n+1).
Es kann nun keine Variable in V und X existieren, deren Differenz ihrer Werte
in V und X gleich d' - d ist.
Beweis (indirekt):
Annahme, eine solche Variable existiere, sie heiße w. Nehmen wir zuerst an, die
Variable wäre bereits beim Aufruf der Prozedur in den Variablenlisten
enthalten. Da w in X vorkommt, muß es nach Voraussetzung ein Variable y in A
geben, deren Werte in den Auswertungen C und C' mit den Endwerten von w in
V und X übereinstimmen. Also stimmen der Differenzen der Werte in der ersten
und zweiten Entfaltung überein. Dies ist aber in Klasse-I-Programmen nur
zulässig, wenn x = y. Dies steht aber im Widerspruch zur Aussage, x käme nicht
in A vor.
w sei jetzt beim Aufruf der Prozedur nicht in V und X enthalten. Also muß w in
den ersten n Schleifendurchläufen in V und X eingetragen worden sein, etwa im
j-ten Schleifendurchlauf. w könnte bei einem Aufruf der Prozedur
SampleWHILE aufgenommen worden sein. Nach den Voraussetzungen über
diese Prozedur müßte dann aber w auch in G' oder H' vorkommen. A' und G',
bzw. B' und H' unterscheiden sich aber nur in den Namen der Variablen. D.h. es
muß eine Variable in A' oder B' vorkommen, deren Werte mit w
übereinstimmen. Sei etwa y diese Variable. Dann stimmt aber die Differenz der
Werte von y in der ersten und zweiten Entfaltung von W mit den Werten in der
ersten und zweiten Entfaltung von x überein. Dann muß aber gelten x = y im
Widerspruch zur Voraussetzung, in der (n+1)-ten Anweisung von B käme x
erstmalig vor.
Die letzte Möglichkeit für den Eintrag von w ist, daß w im j-ten
Schleifendurchlauf eingetragen worden ist, in dem aber kein while-Konstrukt
gelesen wurde. Dazu müssen aber die im j-ten Schleifendurchlauf von D und D'
eingelesenen Beispielauswertungen, etwa e und e' Zahlen sein. Da in P
Zahlkonstanten nicht vorkommen, müssen e und e' Werte einer Variablen im
Anfangsstück von B sein, etwa Werte der Variablen y. Also stimmen die
Differenzen der Werte der Variablen x und y in ihrer ersten und zweiten
Entfaltung überein. Dies ist aber nur erlaubt, wenn x = y. Dies widerspricht der
Voraussetzung, x trete im i-ten Schleifendurchlauf erstmalig auf.
Dann wird aber im i-ten Schleifendurchlauf eine Variable, etwa v, in H
angefügt, deren Wert aber mit dem Wert von x übereinstimmt. Diese Variable
ist dann in V und X enthalten. Die Beispielauswertungen von v sind aber gerade
d und d'. Nach Induktionsvoraussetzung sind die Anfangsstücke von D und D'
für die ersten n Anweisungen von B aber Beispielauswertungen der ersten n
Anweisungen von H. Nun gilt dies auch für die Beispielauswertungen des (n+1)-
ten Elementes von B. Also gilt die Teilaussage d) des Hilfssatzes.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Die Schleife wird beendet, also mindestens (n+1)-mal durchlaufen (Teilaussage
a)). Die Beispielauswertungen von b bestehen nur aus einem Element,
deswegen stehen die Lesezeiger bereits hinter den Beispielauswertungen von b
(Teilaussage b)). H wurde um ein Element ergänzt, hat also n+1 Elemente, da
es vor dem Schleifendurchlauf nach Induktionsvoraussetzung n Elemente hatte
(Teilaussage c)). Die Variablenlisten V und X wurden nur dahingehend
verändert, daß eine neue Variable aufgenommen wurde. Die Werte der anderen
Variablen wurden nicht verändert. Ebenso wurden in den i-ten Anweisungen
von B und H die Werte irgendwelcher Variablen verändert. Der Wert der in H
eingetragenen Variablen ist als Endwert in V und X aufgenommen, womit die
Teilbehauptungen e) und f) bestätigt sind. Die Teilaussage g) folgt direkt aus
der Induktionsvoraussetzung für alle im Anfangsstück von B vorkommenden
Variablen außer x. Daß die Bedingung für x gilt, haben wir aber oben gezeigt.
3. Fall: b ist Variable, etwa x, und x kommt in den ersten n Anweisungen von B
oder in A vor:
Sei d der Wert von b in D und d' der Wert von b in D' (jeweils an der Stelle n+1).
Nach Induktionvoraussetzung wissen wir, daß es eine Variable, etwa v, im
Anfangsstück von H (die ersten n Anweisungen) gibt, deren Werte bei der
Auswertung von H mit den Werten von x bei der Auswertung von B
übereinstimmen. Die Werte am Ende der Auswertung der n-ten Anweisung von
H sind in den Variablenlisten V und X gespeichert. Also muß der Endwert von v
in V gleich d sein, und der Endwert von v in X muß gleich d' sein. Es kann nun
keine zweite Variable in V und X geben, deren Differenz der Endwerte gleich d' -
d ist. Denn dann müßte es eine zweite Variable in A oder im Anfangsstück von
B geben, deren Differenz der Werte in der ersten und zweiten Entfaltung gleich
d' - d ist. Das (n+1)-te Element von H kann damit nur die Variable v sein. d und
d' sind damit Beispielauswertungen von v. Nach Induktionsvoraussetzung sind
die Anfangsstücke von D und D' für die ersten n Anweisungen von B aber
Beispielauswertungen der ersten n Anweisungen von H. Nun gilt dies auch für
die Beispielauswertungen des (n+1)-ten Elementes von B. Also gilt die
Teilaussage d) des Hilfssatzes.
Die Schleife wird beendet, also mindestens (n+1)-mal durchlaufen (Teilaussage
a)). Die Beispielauswertungen von b bestehen nur aus einem Element,
deswegen stehen die Lesezeiger bereits hinter den Beispielauswertungen von b
(Teilaussage b)). H wurde um ein Element ergänzt, hat also n+1 Elemente, da
es vor dem Schleifendurchlauf nach Induktionsvoraussetzung n Elemente hatte
(Teilaussage c)).
V und X werden nicht verändert, also gelten die Teilaussagen e) und f) nach
Induktionsvoraussetzung. Die Gültigkeit der Teilbehauptung g) folgt für die
ersten n Element von H aus der Induktionsvoraussetzung. Sie gilt aber
ebenfalls für das (n+1)-te Element von H. Denn v hat im (n+1)-ten
Schleifendurchlauf gerade bei der Auswertung von H gerade die Werte d und d'.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
4. Fall : b ist Inkrement:
Sei d der Wert von b in D und d’ der Wert von b in D’ (jeweils an der Stelle n+1).
Sei x die Variable in b, d.h. b = "++x". x muß bereits in A oder in den ersten n
Anweisungen von B vorgekommen sein. Nach Induktionvoraussetzung wissen
wir, daß es eine Variable, etwa v, im Anfangsstück von H (die ersten n
Anweisungen) gibt, deren Werte bei der Auswertung von H mit den Werten von
x bei der Auswertung von B übereinstimmen. Die Werte am Ende der
Auswertung der n-ten Anweisung von H sind in den Variablenlisten V und X
gespeichert. Also muß der Endwert von v in V gleich d-1 sein, und der Endwert
von v in X muß gleich d'-1 sein. Es kann nun keine zweite Variable in V und X
geben, deren Differenz der Endwerte gleich d' - d ist (selbe Argumentation wie
im 3. Fall). Insbesondere enthalten V und X keine Variable mit den Endwerten
d und d'. Dann muß das (n+1)-te Element von H das Inkrement der Variablen v
sein.
d und d' sind damit Beispielauswertungen des (n+1)-ten Elementes von H. Nach
Induktionsvoraussetzung sind die Anfangsstücke von D und D' für die ersten n
Anweisungen von B aber Beispielauswertungen der ersten n Anweisungen von
H. Damit gilt die Teilaussage d) des Hilfssatzes.
Die Schleife wird beendet, also mindestens (n+1)-mal durchlaufen (Teilaussage
a)). Die Beispielauswertungen von b bestehen nur aus einem Element,
deswegen stehen die Lesezeiger bereits hinter den Beispielauswertungen von b
(Teilaussage b)). H wurde um ein Element ergänzt, hat also n+1 Elemente, da
es vor dem Schleifendurchlauf nach Induktionsvoraussetzung n Elemente hatte
(Teilaussage c)).
Die Variablenlisten V und X werden dahingehend verändert, daß für die
Endwerte der Variablen v die Werte d und d' eingetragen werden. Diese Werte
stimmen aber tatsächlich mit den Werten von v nach Auswertung der (n+1)-ten
Anweisung überein. Nach Induktionsvoraussetzung stimmen die Einträge der
übrigen bisher in H vorgekommenen Variablen mit ihren Werten nach
Auswertung der n-ten Anweisung überein. Dann stimmen sie aber auch mit den
Werten nach Auswertung der (n+1)-ten Anweisung überein. Damit sind die
Teilbehauptungen e) und f) bewiesen. Die Gültigkeit der Teilbehauptung g) folgt
für die ersten n Element von H aus der Induktionsvoraussetzung. Sie gilt aber
ebenfalls für das (n+1)-te Element von H, denn der Wert der Variablen v stimmt
mit dem Wert der Variablen v überein.
5. Fall: b ist Dekrement:
Sei d der Wert von b in D und d' der Wert von b in D' (jeweils an der Stelle n+1).
Sei x die Variable in b, d.h. b = "--x". x muß bereits in A oder in den ersten n
Anweisungen von B vorgekommen sein. Man beachte, daß in Klasse-I-
Beispielauswertungen keine Variable dekrementiert werden darf, die bereits
den Wert 0 hat. Nach Induktionvoraussetzung wissen wir, daß es eine Variable,
etwa v, im Anfangsstück von H (die ersten n Anweisungen) gibt, deren Werte
bei der Auswertung von H mit den Werten von x bei der Auswertung von B
übereinstimmen. Die Werte am Ende der Auswertung der n-ten Anweisung von
H sind in den Variablenlisten V und X gespeichert. Also muß der Endwert von v
in V gleich d+1 sein, und der Endwert von v in X muß gleich d'+1 sein, wobei wir
auch an dieser Stelle verwenden, daß der Wert einer zu dekrementierenden
Variablen größer Null sein muß. Es kann nun keine zweite Variable in V und X
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
geben, deren Differenz der Endwerte gleich d’ - d ist (selbe Argumentation wie
im 3. Fall). Insbesondere enthalten V und X keine Variable mit den Endwerten
d und d' und auch keine Variable mit den Endwerten d-1 und d'-1. Dann muß
das (n+1)-te Element von H das Dekrement der Variablen v sein.
Vollkommen analog wie im 4. Fall kann man die Gültigkeit des Hilfssatzes
zeigen.
6. Fall: b ist while-Konstrukt:
b habe die Form
with while A’ do B’ end while
Dabei sei A' ein Ausdruck und B' eine Anweisungssequenz. Dann existieren
natürliche Zahlen m, m' > 1, do daß d die Form
test C 1 do D 1 end test
test C 2 do D 2 end test
...
test C m do D m end test
oder die Form
test C 1 do D 1 end test
test C 2 do D 2 end test
...
test C m do D m end test
test C m+1 skip
hat. Entsprechend hat d' die Form
test C’ 1 do D’ 1 end test
test C’ 2 do D’ 2 end test
...
test C’ m’ do D’ m end test
oder die Form
test C’ 1 do D’ 1 end test
test C’ 2 do D’ 2 end test
...
test C’ m’ do D’ m’ end test
test C’ m+1 skip
hat. Dabei sind C1,..,Cm,Cm+1,C'1,...,C'm,C'm+1 Beispielauswertungsfragmente von
A' und D1,..,Dm,D'1,..,D'm Beispielauswertungsfragmente von B'.
Dann ist das von D eingelesene Fragment t das test-Konstrukt
test C 1 do D 1 end test
und das von D' eingelesene Fragment u ist das test-Konstrukt
test C’ 1 do D’ 1 end test
Der Lesezeiger L in D steht jetzt vor dem zweiten test-Konstrukt von d und der
Lesezeiger L' in D' steht vor dem zweiten test-Konstrukt von d'. Folglich gilt für
die beiden jetzt eingelesenen Fragmente t' und u':
t' hat die Form
test C 2 do D 2 end test
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
und u’ hat die Form
test C’ 2 do D’ 2 end test
Der Lesezeiger L steht nun hinter dem zweiten test-Konstrukt von d und der
Lesezeiger L’ in D’ steht hinter dem zweiten test-Konstrukt von d’. Man beachte,
daß hinter der Position von L und L' weitere test-Konstrukte von d und d' folgen
können.
Im (n+1)-ten Schleifendurchlauf wird jetzt die Prozedur SampleWHILE zweimal
und die Prozedur MatchWHILE einmal aufgerufen.
Für die Aufrufe der Prozedur SampleWHILE dürfen wir die Voraussetzungen
für unser Lemma verwenden, da D(b) < D(W). Dann gilt nach dem ersten Aufruf
der Prozedur SampleWHILE mit den Parametern (C1,D1,C2,D2,V,M,N)
aufgerufen, dabei sind der Ausdruck M und die Anweisungssequenz N
Ausgabeparameter. Nach Voraussetzung gilt nach dem Aufruf:
I. Die Prozedur terminiert nach endlich vielen Schritten.
II. Sei U = " with while M do N end while ". Dann ist d eine
Beispielauswertung von U.
III.Es gibt eine Variablenumbenennung σ, so daß Mσ = A' und Nσ = B'.
IV.Wird in M oder N eine Variable verwendet, die nicht bereits beim Aufruf der
Prozedur in V enthalten ist, so wird sie mit ihrem Anfangswert in V
eingetragen.
V. V enthält am Ende der Prozedur die Werte aller in Mund N vorkommenden
Variablen am Ende der Auswertung D2.
Für den zweiten Aufruf der Prozedur SampleWHILE mit den Parametern
(C'1,D'1,C'2,D'2',Y,M',N'), wobei Y eine beim Aufruf leere Variablenliste, M' ein
Ausdruck und N' eine Anweisungssequenz ist, gilt entsprechend:
I.‘ Die Prozedur terminiert nach endlich vielen Schritten.
II.‘ Sei U' = " with while M’ do N’ end while ". Dann ist d' eine
Beispielauswertung von U.
III.‘ Es gibt eine Variablenumbenennung τ, so daß M'τ = A' und N'τ = B'.
IV.‘ Jede in M' oder N' verwendete Variablen wird mit ihrem Anfangswert in Y
eingetragen.
V.‘ Y enthält am Ende der Prozedur die Werte aller in M' und N'
vorkommenden Variablen am Ende der Auswertung D'2.
Anschließend wird die Prozedur MatchWHILE mit den Parametern
(M,M',N,N',V,Y,X,result) aufgerufen, wobei result eine Ausgabevariable ist.
Nach Lemma 5.4.5 gilt dann:
1. Die Prozedur terminiert nach endlich vielen Schritten.
2. Nach dem Aufruf hat result den Wert WAHR.
3. Jede Variable aus M und N, die nicht beim Aufruf der Prozedur in X
enthalten ist, wird in X angefügt mit Anfangs- und Endwert der
entsprechenden Variablen aus Y.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
4. Der Endwert in X jeder Variable aus M und N, die in X enthalten ist, wird
mit dem Endwert der entsprechenden Variablen in Y überschrieben, sofern
die Endwerte nicht bereits übereinstimmen.
Nach II. ist d eine Beispielauswertung von U unter Berücksichtigung der
Variablenliste V. Wir wollen nun zeigen, daß d' ebenfalls eine
Beispielauswertung von U ist, nämlich für die Variablenliste X.
Nach II' ist d' eine Beispielauswertung von U' (mit Variablenliste Y). Es gilt
ebenfalls U'τ = b = Uσ. U und U' unterscheiden sich also nur in den Namen der
Variablen. Da d' Beispielauswertung von U', gibt es ein Programm P' und eine
Beispielauswertung S' von P', so daß d' ist eine Beispielauswertungsfragment
von S' und U' ist ein Programmfragment von P'. Das Programm Q sei jetzt
definiert als Q = Pστ -1 . Dann ist U Programmfragment von Q. Nach Lemma
3.5.2 sind P' und Q ähnlich. Dann ist aber S' Beispielauswertung von Q und d'
Beispielauswertung von U. Da result den Wert FALSCH besitzt, wird U an H
angefügt. H wird im (n+1)-ten Schleifendurchlauf nicht mehr verändert. Nach
Induktionsvoraussetzung hat H vor dem (n+1)-ten Schleifendurchlauf n
Element, somit hat H nach dem Anfügen von U n+1 Elemente. Somit ist die
Teilaussage b) es Hilfssatzes bewiesen. Nach Induktionsvoraussetzung sind die
Anfangsstücke von D und D', die durch Auswertung der ersten n Elemente von
B entstehen, Beispielauswertungen der ersten n Anweisungen von H. da auch
die Auswertung des (n+1)-ten Elementes von B Beispielauwertungen des (n+1)-
ten Elementes von h sind, gilt auch die Teilbehauptung d).
Der Lesezeiger L in D steht nun vor m-2 weiteren test-Konstrukten der Form
test C i do D i end test
wobei i ∈{3,..,m}, Dann wird die erste innere solange-Schleife m-2 mal
durchlaufen (sofern der Algorithmus nicht vorzeitig abgebrochen wird). Für
jeden Aufruf der Prozedur TestWHILE gilt Lemma 5.4.4, denn jeder dieser test-
Konstrukte ist eine Beispielauswertung von b und damit auch von U, und wir
wissen
1. Die Prozedur terminiert nach endlich vielen Schritten.
2. Nach Beendigung der Prozedur gilt für die Ausgabevariable result = WAHR.
3. V enthält alle Variablen, die in U vorkommen mit ihren Werten am Ende von
des gelesenen test-Konstruktes.
Daraus folgt, daß die Schleife tatsächlich m-2 mal durchlaufen wird. L steht
dann hinter dem m-ten test-Konstrukt von d und V enthält alle Variablen aus U
mit ihren Werten am Ende von Dm.
Es kann nun noch ein test-Konstrukt von d folgen. Falls kein weiteres test-
Konstrukt folgt, steht der Lesezeiger L hinter der Beispielauswertung von b und
die Variablenliste V enthält (mindestens) alle in den ersten n+1
Schleifendurchläufe in H verwendeten Variablen mit ihrem Endwerten nach
dem (n+1)-ten Schleifendurchlauf.
Nehmen wir jetzt an, es folge ein weiteres test-Konstrukt. Dieses muß dann die
Form haben
test C m+1 skip
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Für den folgenden Aufruf der Prozedur TestWExpression gelten die Aussagen
des Lemma 5.4.1:
1. Die Prozedur terminiert nach endlich vielen Schritten.
2. Nach Beendigung der Prozedur gilt für die Rückgabevariable result = WAHR.
Die Variablenliste V wird nicht verändert, sie enthält damit alle in den ersten
n+1 Schleifendurchläufe in H verwendeten Variablen mit ihrem Endwerten
nach dem (n+1)-ten Schleifendurchlauf. Damit ist auf jedem Fall die
Teilaussage e) bewiesen. Der Lesezeiger L steht hinter dem letzten Element der
Beispielauswertung von b.
Vor der zweiten inneren solange-Schleife enthält die Variablenliste X alle in den
ersten n+1 Anweisungen von H vorkommenden Variablen mit ihren Endwerten
nach Auswertung der zweiten Entfaltung von U in der Beispielauswertung D',
d.h. sie besitzen die Werte der Variablen am Ende von D'2’ (denn X enthält alle
Variablen von V mit den Endwerten der entsprechenden Variablen von Y (aus
der Variablenumbenennung) am Ende von D'2).
Der Lesezeiger L' in D' steht nun vor dem 3. test-Konstrukt von d', es folgen also
mindestens m'-2 weitere test-Konstrukte. Analog wie bei der Behandlung der
test-Konstrukte von d, wird die zweite innere solange Schleife genau m'-2 mal
durchlaufen und die Variablenliste X enthält die Endwerte der Variablen am
Ende der Auswertung D'm’. Der Lesezeiger L' steht dann hinter dem m'-ten
Element von d'. Falls ein (m'+1)-tes Element von d‘ folgt, so hat dies die Form
test C’ m’+1 skip
und es kann analog wie bei der Behandlung des entsprechenden Elementes von
d die Prozedur TestWExpression verwendet werden. Auf jedem Fall beinhaltet
die Variablenliste X (mindestens) alle in den ersten n+1 Schleifendurchläufen in
H verwendeten Variablen mit ihren Endwerten an der Stelle des (n+1)-ten
Schleifendurchlaufs in D' (Teilaussage f)). Beide Lesezeiger stehen hinter der
Auswertung des (n+1)-ten Elementes von B (Teilbehauptung c)). Da die Schleife
nach Induktionsvoraussetzung mindestens n mal durchlaufen wird, und der
(n+1)-te Schleifendurchlauf beendet wird, wird die äußere solange-Schleife also
mindestens (n+1)-mal durchlaufen (Teilbehauptung a)).
Verbleibt zu zeigen die Teilbehauptung g). Nach Induktionsvoraussetzung
wissen wir, daß es für jede der im Anfangsstück von B vorkommenden
Variablen, etwa x, eine Variable v in H gibt, deren Werte in D und D' mit den
Werten von x übereinstimmen.
Nehmen wir hierzu an, die Teilbehauptung gelte nicht. Sei x eine in den ersten
n+1 Anweisungen von B vorkommende Variable, zu der es keinen Variable in
den ersten n+1 Anweisungen von H gibt, deren Werte in D und D' mit den
Werten von x übereinstimmen. Wegen der Induktionsvoraussetzung kann die
Nichtübereinstimmung nicht in den ersten n Anweisungen der beiden
Anweisungssequenzen auftreten. Also muß die Nichtübereinstimmung zwischen
b und U auftreten. b und U unterscheiden sich aber nur in den Namen der
Variablen. Sei a eine Anweisung, in der x vorkommt. Dann muß es eine
entsprechende Anweisung a' in U geben, die sich von a nur im Namen der
Variablen unterscheidet. Sei v die in a' vorkommende Variable. x und v haben
jetzt an der Stelle der Anweisungen a und a' bei der Auswertung verschiedene
Werte, dann sind aber ihre Auswertungen verschieden, d.h. die
Beispielauswertungen von b und U unterscheiden sich an mindestens einer
Stelle. Dies steht aber im Widerspruch zu Punkt II. unserer Voraussetzung für
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
die Korrektheit der Prozedur SampleWHILE. Also kann es keine im
Anfangsstück von B vorkommende Variable geben, zu der es keine
entsprechende Variable im Anfangsstück von H gibt, die in ihren Werten bei der
Auswertung übereinstimmen.
Damit ist der Hilfssatz nach Induktion bewiesen. (Hilfssatz)
Die 2. Aussage des Lemmas folgt direkt aus Teilaussage d) des Hilfssatzes für
den Fall n = |B|.
3. Jede Variable in H, die beim Aufruf der Prozedur nicht in V enthalten ist,
wird in V eingetragen. Ihr Anfangswert ist der Wert ihres ersten Auftretens in
D.
Nach Punkt e) des Hilfssatzes im Beweis der 2. Aussage, wissen wir, daß jede in
H vorkommende Variable, in V enthalten ist. Dann muß aber eine Variable, die
vorher nicht in V enthalten ist, in V eingetragen worden sein. Es stellt sich nun
die Frage, was der Anfangswert einer solchen Variablen ist. Betrachten wir
dazu das erste Vorkommen der Variablen. Falls das erste Vorkommen der
Variablen innerhalb eines lokalen while-Konstruktes von H liegt, so wissen wir
nach unseren Voraussetzungen für die Korrektheit der Prozedur
SampleWHILE, daß ihr der entsprechende Anfangswert in V eingetragen
worden ist. Da der Anfangswert einer Variablen, die bereits in V enthalten ist,
niemals verändert wird, so mu gilt die Aussage.
Falls das erste Vorkommen der Variablen, etwa v, nicht in einem lokalen while-
Konstrukt liegt, so muß es eine Anweisung h in H geben, so daß h gerade die
Variable v ist. Es gibt also ein Schleifendurchlauf, in dem eine Variable in H
aufgenommen wurde, die an dieser Stelle noch nicht in V enthalten ist. Dann
kann V keine Variable enthalten, deren Werte mit denen von v übereinstimmen,
da in Klasse-I-Programmen keine zwei Variablen in einem while-Konstrukt
erlaubt sind, die in der Differenz ihrer Werte bei der Auswertung der ersten und
zweiten Entfaltung übereinstimmen. Dann wird aber in diesem
Schleifendurchlauf v mit ihrem Wert bei der Auswertung D als Anfangswert in
V eingetragen.
4. Am Ende der Prozedur ist jede Variable von H in V eingetragen. Ihr Endwert
ist der Wert ihres letzten Auftretens in D.
Folgt direkt aus Teilaussage e) des Hilfssatzes im Beweis der 2. Aussage.
5. Jede Variable in H, die beim Aufruf der Prozedur nicht in X enthalten ist,
wird in X eingetragen. Ihr Anfangswert ist der Wert ihres ersten Auftretens in
D'.
Nach Punkt f) des Hilfssatzes im Beweis der 2. Aussage, wissen wir, daß jede in
H vorkommende Variable in X enthalten ist. Dann muß aber eine Variable, die
vorher nicht in X enthalten ist, in X eingetragen worden sein. Es stellt sich nun
die Frage, was der Anfangswert einer solchen Variablen ist. Betrachten wir
dazu das erste Vorkommen der Variablen.
Falls das erste Vorkommen der Variablen, etwa v, innerhalb eines lokalen
while-Konstruktes von H liegt, so wissen nach unseren Voraussetzungen für die
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Prozedur SampleWHILE, daß diese Variable mit ihrem Anfangswert bei der
Auswertung D in die Variablenliste V eingetragen worden ist. Die Variablenliste
Y enthält dann eine Variable, etwa y, die in ihren Werten mit den Werten von v
bei der Auswertung D' übereinstimmt. Der Anfangswert von y in Y ist dann
gleich dem ersten Wert von v bei der Auswertung D'. Nach Lemma 5.4.5 wird
dann aber beim Aufruf der Prozedur MatchWHILE die Variable v in X
eingetragen. Ihr Anfangswert wird auf den Anfangswert der Variablen y in Y
gesetzt.
Falls das erste Vorkommen der Variablen, etwa v, nicht in einem lokalen while-
Konstrukt liegt, so muß es eine Anweisung h in H geben, so daß h gerade die
Variable v ist. Es gibt also ein Schleifendurchlauf, in dem eine Variable in H
aufgenommen wurde, die an dieser Stelle noch nicht in X enthalten ist. Dann
kann X keine Variable enthalten, deren Werte mit denen von v übereinstimmen,
da in Klasse-I-Programmen keine zwei Variablen in einem while-Konstrukt
erlaubt sind, die in der Differenz ihrer Werte bei der Auswertung der ersten und
zweiten Entfaltung übereinstimmen. Dann wird aber in diesem
Schleifendurchlauf v mit ihrem Wert bei der Auswertung D' als Anfangswert in
X eingetragen.
6. Am Ende der Prozedur ist jede Variable von H in X eingetragen. Ihr Endwert
ist der Wert ihres letzten Auftretens in D'.
Folgt direkt aus Teilaussage f) des Hilfssatzes im Beweis der 2. Aussage.
/HPPD
6HL3HLQ.ODVVH,3URJUDPPGDVNHLQH=DKONRQVWDQWHQHQWKlOWXQG6HLQH
%HLVSLHODXVZHUWXQJYRQ3
6HL:HLQZKLOH.RQVWUXNWLQ3PLW': G∈©XQG7HLQ
%HLVSLHODXVZHUWXQJVIUDJPHQWYRQ:LQ6
) UGLH3UR]HGXU6DPSOH:+,/(JHOWHQGLHIROJHQGHQ9RUDXVVHW]XQJHQ
6HL:HLQZKLOH.RQVWUXNWYRQ3PLW':G:KDEHGLHIROJHQGH)RUP
with while A’ do B’ end while
'DEHLVHL$HLQ$XVGUXFNXQG%HLQH$QZHLVXQJVVHTXHQ]6HL7HLQ
%HLVSLHODXVZHUWXQJVIUDJPHQWYRQ6'LHHUVWHQEHLGHQWHVW.RQVWUXNWHYRQ7
ODXWHQ
test E do F end test
test E’ do F’ end test
'DEHLVHLHQ(XQG(%HLVSLHODXVZHUWXQJVIUDJPHQWHYRQ$XQG'XQG'
%HLVSLHODXVZHUWXQJVIUDJPHQWHYRQ%6HL9HLQH9DULDEOHQOLVWH'DQQJLOW
I UGHQ$XIUXIGHU3UR]HGXU6DPSOH:+,/(PLWGHQ3DUDPHWHUQ()()9*
XQG+ZREHLGLH$XVJDEHYDULDEOH*HLQ$XVGUXFNXQGGLH$XVJDEHYDULDEOH
+HLQH$QZHLVXQJVVHTXHQ]LVW
, 'LH3UR]HGXUWHUPLQLHUWQDFKHQGOLFKYLHOHQ6FKULWWHQ
,, 6HL8 Ãwith while G’ do H’ end while'DQQLVW7HLQH
%HLVSLHODXVZHUWXQJYRQ8
,,,(VJLEWHLQH9DULDEOHQXPEHQHQQXQJσVRGD‰*σ $XQG+σ %
,9:LUGLQ*RGHU+HLQH9DULDEOHYHUZHQGHWGLHQLFKWEHUHLWVEHLP$XIUXI
GHU3UR]HGXULQ9HQWKDOWHQLVWVRZLUGVLHPLWLKUHP$QIDQJVZHUWLQ9
HLQJHWUDJHQ
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
9 9HQWKlOWDP(QGHGHU3UR]HGXUGLH:HUWHDOOHULQ*XQG+
YRUNRPPHQGHQ9DULDEOHQDP(QGHGHU$XVZHUWXQJ)
:KDEHGLH)RUP
with while A do B end whileÃ$$XVGUXFNXQG%
$QZHLVXQJVVHTXHQ]
(VVHL7HLQ%HLVSLHODXVZHUWXQJVIUDJPHQWYRQ:LQ6'LHHUVWHQEHLGHQWHVW
.RQVWUXNWHYRQ7VHLHQ
test C do D end test
test C’ do D’ end test
'DEHLVLQG&XQG&%HLVSLHODXVZHUWXQJVIUDJPHQWHYRQ$XQG'XQG'
%HLVSLHODXVZHUWXQJVIUDJPHQWHYRQ%'LH9DULDEOHQOLVWH9HQWKDOWHDOOHLQ3
YRUGHU$XVZHUWXQJ7DXIJHWUHWHQHQ9DULDEOHQPLWLKUHQ$QIDQJVXQG
(QGZHUWHQYRUGHU$XVZHUWXQJGHVHUVWHQ(OHPHQWHVYRQ') UMHGH
9DULDEOHYLP$XVGUXFNYRQ:H[LVWLHUWHLQH9DULDEOH[LQ9XQG;VRGD‰
GHU(QGZHUWYRQ[LQ9LVWGHU:HUWYRQYLQ&XQGGHU(QGZHUWYRQ[LQ;LVW
GHU:HUWYRQYLQ&'HU$XIUXIGHU3UR]HGXUVDPSOH:6WDWHPHQW6HTXHQFH
PLWGHQ3DUDPHWHUQ''9;+WHUPLQLHUHQDFKHQGOLFKYLHOHQ6FKULWWHQ
XQGOLHIHUHDOV$XVJDEHHLQHQ$XVGUXFN+'DQQH[LVWLHUWHLQH
9DULDEOHQXPEHQHQQXQJσVRGD‰% +σ
Beweis:
Nach Lemma 5.4.11 wissen wir, daß der Aufruf der Prozedur
sampleWStatementSequence nach endlich vielen Schritten terminiert und eine
Anweisungssequenz H liefert. Dabei sind D und D'
Beispielauswertungsfragmente von B und von H.
Wir haben im Beweis der 2. Aussage des Lemma 5.4.11 folgende Aussage
bewiesen:
Zu jeder in B vorkommenden Variablen x existiert eine Variable v in H, deren
Werte in D und D' mit den Werten von x übereinstimmen.
Die Variablenumbenennung σ entstehe jetzt dadurch, daß jede Variable v in H
durch die entsprechende Variable x in B ersetzt wird. Wir müssen nun zeigen,
daß B = Hσ.
Wir wissen, daß |B| = |H| = |Hσ|. Wenn also B ≠ Hσ, so muß es ein
i∈{1,..,|B|} geben, so daß die i-te Anweisung von B ungleich der i-ten
Anweisung von Hσ ist. Sei nun b die entsprechende Anweisung in B und h die
entsprechende Anweisung in H, sei s die entsprechende Anweisung in Hσ. Wir
unterscheiden jetzt nach b, wobei wir wissen, daß b keine Zahlkonstante sein
kann.
1. Fall: b ist Wort, Sonderzeichen oder Zeichenkette:
Dann muß gelten, b = h = s, denn sonst könnte D nicht Beispielauswertung für
B und für H sein.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
2. Fall: b ist Variable, Inkrement oder Dekrement:
Es ist klar, daß sowohl h als auch s ebenfalls Variable, Inkrement oder
Dekrement sind. Sei x die in b vorkommende Variable und y die in s
vorkommende Variable. Es existiert nun eine Variable v in H, deren Werte mit
den Werten von x übereinstimmen.
Nehmen wir jetzt an, x ≠ y. Da die bei der Bildung von Hσ aus H jedes
Vorkommen von v durch x ersetzt wurde, kann v nicht die in h vorkommende
Variable sein. Sei nun w die in h vorkommende Variable. Die Differenz der
Werte von w und v bei den Auswertungen in der ersten und zweiten Entfaltung
des umgebenen while-Konstruktes müssen sich unterscheiden. Dann können D
und D' aber nicht zugleich Beispielauswertungen von H und von B sein.
Also muß gelten x = y. Wir wissen, daß sowohl vor und nach der Auswertung
von b und h die Werte von x und v übereinstimmen. Also müssen auch die
Werte von x vor und nach der Auswertung von b und s übereinstimmen. Also
muß gelten b = s.
3. Fall: b ist while-Konstrukt:
Es ist klar, daß sowohl h als auch s while-Konstrukte sein müssen. Für die
Bildung von h wurde aber die Prozedur SampleWHILE verwendet, für deren
Aufruf die Voraussetzungen für ihre Korrektheit gelten. Demnach gibt es eine
Variablenumbenennung σ', so daß b = hσ'. Verbleibt zu zeigen, daß hσ' = s = hσ.
Annahme hσ' ≠ s. Bei der Bildung von s wurde aber jede Variable v in h durch
die entsprechende Variable x in b ersetzt, mit deren Werten sie übereinstimmt.
Also muß es eine Variable v in h geben, so daß σ'(v) ≠ x. Dann kann aber nicht
gelten b = hσ', denn es gibt eine Variable, die in b enthalten ist, aber nicht in
hσ'. Also muß gelten hσ' = s. Damit gilt auch b = s.
/HPPD
6HL3HLQ.ODVVH,3URJUDPPGDVNHLQH=DKONRQVWDQWHQHQWKlOWXQG6HLQH
%HLVSLHODXVZHUWXQJYRQ3
6HL:HLQZKLOH.RQVWUXNWLQ3PLW': G∈©XQG7HLQ
%HLVSLHODXVZHUWXQJVIUDJPHQWYRQ:LQ6
) UGLH3UR]HGXU6DPSOH:+,/(JHOWHQGLHIROJHQGHQ9RUDXVVHW]XQJHQ
6HL:HLQZKLOH.RQVWUXNWYRQ3PLW':G:KDEHGLHIROJHQGH)RUP
with while A’ do B’ end while
'DEHLVHL$HLQ$XVGUXFNXQG%HLQH$QZHLVXQJVVHTXHQ]6HL7HLQ
%HLVSLHODXVZHUWXQJVIUDJPHQWYRQ6'LHHUVWHQEHLGHQWHVW.RQVWUXNWHYRQ7
ODXWHQ
test E do F end test
test E’ do F’ end test
'DEHLVHLHQ(XQG(%HLVSLHODXVZHUWXQJVIUDJPHQWHYRQ$XQG'XQG'
%HLVSLHODXVZHUWXQJVIUDJPHQWHYRQ%6HL9HLQH9DULDEOHQOLVWH'DQQJLOW
I UGHQ$XIUXIGHU3UR]HGXU6DPSOH:+,/(PLWGHQ3DUDPHWHUQ()()9*
XQG+ZREHLGLH$XVJDEHYDULDEOH*HLQ$XVGUXFNXQGGLH$XVJDEHYDULDEOH
+HLQH$QZHLVXQJVVHTXHQ]LVW
, 'LH3UR]HGXUWHUPLQLHUWQDFKHQGOLFKYLHOHQ6FKULWWHQ
,, 6HL8 Ãwith while G’ do H’ end while'DQQLVW7HLQH
%HLVSLHODXVZHUWXQJYRQ8
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
,,,(VJLEWHLQH9DULDEOHQXPEHQHQQXQJσVRGD‰*σ $XQG+σ %
,9:LUGLQ*RGHU+HLQH9DULDEOHYHUZHQGHWGLHQLFKWEHUHLWVEHLP$XIUXI
GHU3UR]HGXULQ9HQWKDOWHQLVWVRZLUGVLHPLWLKUHP$QIDQJVZHUWLQ9
HLQJHWUDJHQ
9 9HQWKlOWDP(QGHGHU3UR]HGXUGLH:HUWHDOOHULQ*XQG+
YRUNRPPHQGHQ9DULDEOHQDP(QGHGHU$XVZHUWXQJ)
:KDEHGLH)RUP
with while A do B end while ($$XVGUXFNXQG%
$QZHLVXQJVVHTXHQ]
(VVHL7HLQ%HLVSLHODXVZHUWXQJVIUDJPHQWYRQ:LQ6'LHHUVWHQEHLGHQWHVW
.RQVWUXNWHYRQ7VHLHQ
test C do D end test
test C’ do D’ end test
'DEHLVLQG&XQG&%HLVSLHODXVZHUWXQJVIUDJPHQWHYRQ$XQG'XQG'
%HLVSLHODXVZHUWXQJVIUDJPHQWHYRQ%'LH9DULDEOHQOLVWH9HQWKDOWHDOOHLQ3
YRUGHU$XVZHUWXQJ7DXIJHWUHWHQHQ9DULDEOHQPLWLKUHQ$QIDQJVXQG
(QGZHUWHQYRUGHU$XVZHUWXQJGHVHUVWHQ(OHPHQWHVYRQ') UMHGH
9DULDEOHYLP$XVGUXFNYRQ:H[LVWLHUWHLQH9DULDEOH[LQ9XQG;VRGD‰
GHU(QGZHUWYRQ[LQ9LVWGHU:HUWYRQYLQ&XQGGHU(QGZHUWYRQ[LQ;LVW
GHU:HUWYRQYLQ&'LH3UR]HGXUVDPSOH:6WDWHPHQW6HTXHQFHZHUGHPLW
GHQ3DUDPHWHUQ''9;+DXIJHUXIHQ6HLσGLH9DULDEOHQXPEHQHQQXQJ
DXV/HPPD4HQWVWHKHDXV3GXUFKHUVHW]HQYRQ%GXUFK+σ'DQQ
VWLPPHQGLH:HUWHEHLGHU$XVZHUWXQJYRQ3QDFKMHGHU$XVZHUWXQJYRQ%
PLWGHQ:HUWHQGHU$XVZHUWXQJYRQ4QDFKMHGHU$XVZHUWXQJYRQ+σ
EHUHLQ
Beweis:
Nach Lemma 5.4.12 ist P = Q. Damit stimmen die Auswertungen von P und Q
überein.
Als nächstes müssen wir die Korrektheit der Prozedur SampleWHILE beweisen. Dabei
müssen wir darauf achten, daß wir bei der Benutzung der Lemmata 5.4.11, 5.4.12 und 5.4.13
die Voraussetzungen für SampleWHILE erfüllen.
/HPPD
6HL3HLQ.ODVVH,3URJUDPPGDVNHLQH=DKONRQVWDQWHQHQWKlOWXQG6HLQH
%HLVSLHODXVZHUWXQJYRQ3
6HL:HLQZKLOH.RQVWUXNWLQ3XQG7HLQ%HLVSLHODXVZHUWXQJVIUDJPHQWYRQ
:LQ6:KDEHGLHIROJHQGH)RUP
with while A do B end while
'DEHLVHL$HLQ$XVGUXFNXQG%HLQH$QZHLVXQJVVHTXHQ]6HL7HLQ
%HLVSLHODXVZHUWXQJVIUDJPHQWYRQ:LQ6'LHHUVWHQEHLGHQWHVW.RQVWUXNWH
YRQ7ODXWHQ
test C do D end test
test C’ do D’ end test
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
'DEHLVHLHQ&XQG&%HLVSLHODXVZHUWXQJVIUDJPHQWHYRQ$XQG'XQG'
%HLVSLHODXVZHUWXQJVIUDJPHQWHYRQ%6HL9HLQH9DULDEOHQOLVWH'DQQJLOWI U
GHQ$XIUXIGHU3UR]HGXU6DPSOH:+,/(PLWGHQ3DUDPHWHUQ&'&'9*
XQG+ZREHLGLH$XVJDEHYDULDEOH*HLQ$XVGUXFNXQGGLH$XVJDEHYDULDEOH
+HLQH$QZHLVXQJVVHTXHQ]LVW
, 'LH3UR]HGXUWHUPLQLHUWQDFKHQGOLFKYLHOHQ6FKULWWHQ
,, 6HL8 Ãwith while G do H end while'DQQLVW7HLQH
%HLVSLHODXVZHUWXQJYRQ8
,,,(VJLEWHLQH9DULDEOHQXPEHQHQQXQJσVRGD‰*σ $XQG+σ %
,9:LUGLQ*RGHU+HLQH9DULDEOHYHUZHQGHWGLHQLFKWEHUHLWVEHLP$XIUXI
GHU3UR]HGXULQ9HQWKDOWHQLVWVRZLUGVLHPLWLKUHP$QIDQJVZHUWLQ9
HLQJHWUDJHQ
9 9HQWKlOWDP(QGHGHU3UR]HGXUGLH:HUWHDOOHULQ*XQG+
YRUNRPPHQGHQ9DULDEOHQDP(QGHGHU$XVZHUWXQJ'
Beweis:
Wir führen den Beweis durch vollständige Induktion nach der
Schachtelungstiefe D(W).
Induktionsverankerung für D(W) = 0:
I. Die Prozedur terminiert nach endlich vielen Schritten
Die einzigen Prozeduraufrufe in SampleWHILE sind Aufrufe der Prozeduren
SampleWStatementSequence und SampleWExpression. Der Aufruf der
Prozedur SampleWExpression terminiert nach endlich vielen Schritten, wie
wir in Lemma 5.4.6 gezeigt haben. Für den Aufruf der Prozedur
SampleWStatementSequence können wir das Lemma 5.4.8 anwenden,
wodurch ebenfalls die Termination im Endlichen gewährleistet ist. Da die
beiden für-Schleifen innerhalb von SampleWHILE sicher terminieren, ist
auch die Termination nach endlich vielen Schritten der Prozedur
SampleWHILE gewährleistet.
II. Sei U = " with while G do H end while ". Dann ist T eine
Beispielauswertung von U.
Wir wollen zuerst zeigen, daß die Prozedur nicht mit Fehlermeldung
abgebrochen wird. Da dies innerhalb eines Prozeduraufrufes nicht geschehen
kann, kann der Abbruch nur auftreten, wenn innerhalb der ersten für-
Schleife in der Prozedur SampleWHILE für eine Variable v der Endwert in V
und der Anfangswert in X nicht übereinstimmen.
Nach Lemma 5.4.6 gilt aber:
Jede Variable in G wird in X eingetragen. Ihr Anfangswert und ihr
Endwert ist der Wert ihres Auftretens in C'.
Am Ende der Prozedur ist jede Variable von G in V eingetragen. Ihr
Endwert ist der Wert ihres Auftretens in C.
Nach Lemma 5.4.8 gilt:
Am Ende der Prozedur ist jede Variable von H in V eingetragen. Ihr
Endwert ist der Wert ihres letzten Auftretens in D.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Jede Variable in H, die beim Aufruf der Prozedur nicht in X enthalten ist,
wird in X eingetragen. Ihr Anfangswert ist der Wert ihres ersten
Auftretens in D’.
Am Ende der Prozedur ist jede Variable von H in X eingetragen. Ihr
Endwert ist der Wert ihres letzten Auftretens in D’.
Hieraus läßt sich folgern:
Jede Variable in U ist in sowohl in V als auch in X enthalten. Endwert jeder
Variablen aus U in V ist der Wert ihres letzten Auftretens in der Auswertung
der ersten Entfaltung von U. Anfangswert jeder Variablen aus U in X ist der
Wert ihres ersten Auftretens in der Auswertung der zweiten Entfaltung von
U. Das erste Auftreten einer Variablen in einem while-Konstrukt eines
Klasse-I-Programmes darf nicht innerhalb eines Inkrementes oder eines
Dekrementes sein. Also muß der erste Wert einer Variablen in der zweiten
Entfaltung eines while-Konstruktes mit dem letzten Wert in der ersten
Entfaltung übereinstimmen. Also muß auch der Anfangswert einer Variablen
in X mit dem Endwert derselben Variablen in V übereinstimmen.
Der Ausdruck G ist Ausgabe der Prozedur SampleWExpression. Nach Lemma
5.4.6 gilt aber dann:
C und C' sind Beispielauswertungen von G (für die Variablenlisten V und
X).
Analog kann für die Prozedur SampleWStatementSequence nach Lemma
5.4.8 ausgesagt werden:
D und D' sind Beispielauswertungen von H (für die Variablenlisten V und
X)
Dann ist vollkommen klar, daß das Beispielauswertungsfragment
test C do D end test
test C’ do D’ end test
Beispielauswertung von U ist. Verbleibt die Frage, ob T Beispielauswertung
von U ist. Die Auswertung jeder weiteren Entfaltung von W unterscheidet
sich aber nur in den Werten der in U vorkommenden Variablen. Nach Punkt
III (noch zu beweisen) unterscheiden sich U und W aber nur durch eine
Variablenumbenennung. Wir zeigen jetzt, daß es zu jeder Variablen x in W
eine Variable v in U gibt, so daß der Wert von x und der Wert von v sich
entsprechen für jede Anweisung der Beispielauswertung für W und U.
Als erstes stellen wir fest, daß die Bedingung am Ende jedes weiteren test-
Konstruktes der Beispielauswertungen von U und W erfüllt ist (wir nehmen
an, die Beispielauswertung bestehe aus genügend vielen Entfaltungen). Dies
folgt direkt aus Lemma 5.4.10. Sei x eine beliebige Variable in W und v die
entsprechende Variable in U. Da die Werte von x und v zu Beginn und am
Ende der i-ten Auswertung (i > 2) von U und W übereinstimmen, muß es ein
Vorkommen der Variablen in der i-ten Auswertung von W und U geben, in
denen sich die Werte unterscheiden, wenn das i-te test-Konstrukt von T
keine Beispielauswertung von U ist. Dann können sich die beiden
Anweisungen aber nicht nur in den Namen der Variablen unterscheiden.
Dann können sich aber auch W und U nicht nur in den Namen der Variablen
unterscheiden.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Also können sich die Auswertungen der i-ten Entfaltung von W und der i-ten
Entfaltung von U nicht unterscheiden für jedes i > 0. Dann ist aber T eine
Beispielauswertung von U (man erhöhe einfach die Zahl der Entfaltungen
von U auf die Zahl der test-Konstrukte in T).
III. Es gibt eine Variablenumbenennung σ, so daß Gσ = A und Hσ = B.
Nach Lemma 5.4.7 gibt es eine Variablenumbenennung σ1, so daß A = Gσ1,
nach Lemma 5.4.9 gibt es eine Variablenumbenennung σ2, so daß B = Hσ2.
Die Variablenumbenennung σ entsteht dann einfach durch
Zusammenfassung von σ1 und σ2.
IV.Wird in G oder H eine Variable verwendet, die nicht bereits beim Aufruf
der Prozedur in V enthalten ist, so wird sie mit ihrem Anfangswert in V
eingetragen.
Diese Aussage folgt direkt aus Lemma 5.4.6 und Lemma 5.4.8.
V.V enthält am Ende der Prozedur die Werte aller in G und H
vorkommenden Variablen am Ende der Auswertung D'.
Nach dem Aufruf der Prozedur SampleWExpression in der Prozedur
SampleWHILE gilt nach Lemma 5.4.6:
Am Ende der Prozedur ist jede Variable von G in V eingetragen. Ihr
Endwert ist der Wert ihres Auftretens in C.
Jede Variable in G wird in X eingetragen. Ihr Anfangswert und ihr
Endwert ist der Wert ihres Auftretens in C'.
Nach dem Aufruf der Prozedur SampleWStatementSequence in der Prozedur
SampleWHILE gilt nach Lemma 5.4.8:
Am Ende der Prozedur ist jede Variable von H in V eingetragen. Ihr
Endwert ist der Wert ihres letzten Auftretens in D.
Am Ende der Prozedur ist jede Variable von H in X eingetragen. Ihr
Endwert ist der Wert ihres letzten Auftretens in D'.
Dann enthält die Variablenliste X die Werte aller in G und H vorkommenden
Variablen am Ende der Auswertung D'. Da in der zweiten für-Schleife der
Prozedur SampleWHILE der Endwert jeder Variablen von V, die auch in X
enthalten ist (damit in U vorkommt), auf den Endwert derselben Variablen in
der Variablenliste X gesetzt wird, enthält V damit die Endwerte jeder in G
und H vorkommenden Variablen am Ende der Auswertung D'.
Induktionsvoraussetzung:
Sei n∈© beliebig. Für while-Konstrukte aus P mit D(W) ≤ n gelte für den
Aufruf der Prozedur SampleWHILE:
I. Die Prozedur terminiert nach endlich vielen Schritten.
II. Sei U = " with while G do H end while ". Dann ist T eine
Beispielauswertung von U.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
III.Es gibt eine Variablenumbenennung σ, so daß Gσ = A und Hσ = B.
IV.Wird in G oder H eine Variable verwendet, die nicht bereits beim Aufruf
der Prozedur in V enthalten ist, so wird sie mit ihrem Anfangswert in V
eingetragen.
V. V enthält am Ende der Prozedur die Werte aller in G und H
vorkommenden Variablen am Ende der Auswertung D'.
Induktionsbehauptung:
W sei ein while-Konstrukt mit D(W) = n+1. Dann gilt für den Aufruf der
Prozedur SampleWHILE:
I. Die Prozedur terminiert nach endlich vielen Schritten.
II. Sei U = " with while G do H end while ". Dann ist T eine
Beispielauswertung von U.
III.Es gibt eine Variablenumbenennung σ, so daß Gσ = A und Hσ = B.
IV.Wird in G oder H eine Variable verwendet, die nicht bereits beim Aufruf
der Prozedur in V enthalten ist, so wird sie mit ihrem Anfangswert in V
eingetragen.
V. V enthält am Ende der Prozedur die Werte aller in G und H
vorkommenden Variablen am Ende der Auswertung D'.
Induktionsschluß:
Die Induktionsvoraussetzung erfüllt genau die Voraussetzungen für die
Korrektheit der Prozedur SampleWHILE, die in den Lemmata 5.4.11, 5.4.12
und 5.4.13 verlangt wurde. Der Induktionsschluß ist dann vollkommen
analog wie die Induktionsverankerung zu beweisen, wobei anstelle der
Lemmata 5.4.8, 5.4.9 und 5.4.10 die Lemmata 5.4.11, 5.4.12 und 5.4.13
treten.
Wenden wir uns jetzt der nicht-rekursiven Prozedur SampleSequence zu:
/HPPD
6HL3HLQ.ODVVH,3URJUDPPGDVNHLQH=DKONRQVWDQWHQHQWKlOWXQG6HLQH
%HLVSLHODXVZHUWXQJYRQ36HL7GLH%HLVSLHODXVZHUWXQJGHU
+DXSWDQZHLVXQJVVHTXHQ]YRQ3'LH9DULDEOHQOLVWH9HQWKDOWHDOOH
(LQJDEHYDULDEOHQYRQ3PLWLKUHQ:HUWHQLP(LQJDEHNRQVWUXNWYRQ3'DQQ
JLOWI UGHQ$XIUXIGHU3UR]HGXU6DPSOH6HTXHQFHPLWGHQ3DUDPHWHUQ
79$ZREHLGHU$XVJDEHSDUDPHWHUHLQH$QZHLVXQJVVHTXHQ]LVW
, 'LH3UR]HGXUWHUPLQLHUWQDFKHQGOLFKYLHOHQ6FKULWWHQ
,, 7LVWHLQH%HLVSLHODXVZHUWXQJYRQ$
,,,(VJLEWHLQH9DULDEOHQXPEHQHQQXQJσVRGD‰$σ %ZREHL%GLH
+DXSWDQZHLVXQJVVHTXHQ]YRQ3LVW
,9:LUGLQ$HLQH9DULDEOHYHUZHQGHWGLHQLFKWEHUHLWVEHLP$XIUXIGHU
3UR]HGXULQ9HQWKDOWHQLVWVRZLUGVLHPLWLKUHP$QIDQJVZHUWLQ9
HLQJHWUDJHQ
9 9HQWKlOWDP(QGHGHU3UR]HGXUGLH:HUWHDOOHULQ$YRUNRPPHQGHQ
9DULDEOHQDP(QGHGHU$XVZHUWXQJ7
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Beweis:
I. Die Prozedur terminiert nach endlich vielen Schritten.
Wenn T = "", wird die Prozedur sofort abgebrochen. Gehen wir also davon aus,
daß T ≠ "" und die äußere solange-Schleife wird betreten. Zeigen wir zuerst, daß
die äußere solange-Schleife maximal |T| mal durchlaufen wird. Die äußere
solange-Schleife wird spätestens verlassen, wenn der Lesezeiger in T hinter dem
letzten Element von T steht. Da der Lesezeiger vor dem ersten
Schleifendurchlauf vor dem ersten Element von T steht und bei jedem
Schleifendurchlauf um wenigstens ein Element vorgestellt wird, terminiert die
äußere solange-Schleife nach höchstens |T| Durchläufen, falls jeder
Schleifendurchlauf in endlicher Zeit beendet wird.
Prüfen wir jetzt dies nach. Falls das von T gelesene Element t ungleich einem
test-Konstrukt ist, ist die Termination des Schleifendurchlaufs gewährleistet.
Nehmen wir deswegen an, t wäre ein test-Konstrukt.
Der Aufruf der Prozedur SampleWHILE terminiert nach Lemma 5.4.14, ebenso
die innere solange-Schleife, da die Prozedur TestWHILE nach Lemma 5.4.4
terminiert, und die Schleife nur endlich oft durchlaufen wird. Denn die innere
solange-Schleife wird abgebrochen, wenn der Lesezeiger L nicht vor einem
weiteren test-Konstrukt steht, und der Lesezeiger L wird in der Schleife um ein
Element vorgestellt. Da T nur endlich viele test-Konstrukte enthalten kann, ist
die Termination der inneren solange-Schleife garantiert. Da der Aufruf der
Prozedur TestWExpression gemäß Lemma 5.4.1 terminiert, ist die Laufzeit für
jeden Schleifendurchlauf der äußeren solange-Schleife endlich.
II. T ist eine Beispielauswertung von A.
Wir zeigen zuerst, daß die Prozedur nicht mit einem Fehler abbricht. Es gibt in
der Prozedur genau fünf Stellen, an denen die Prozedur abgebrochen wird (sie
wird nicht in einem der aufgerufenen Prozeduren abgebrochen):
a) wenn die Prozedur TestWHILE den Wert result = FALSCH zurückliefert.
b) wenn die Prozedur TestWExpression den Wert result = FALSCH
zurückliefert.
c) wenn das von T gelesene Element t ein test-Konstrukt ist, und der Lesezeiger
in T hinter dem letzten Element von T steht.
d) wenn das von T gelesene Element t ein test-Konstrukt ist, das auf t folgende
Element aber nicht.
e) wenn T ein Element ungleich einem Wort, einer Zeichenkette, einem
Sonderzeichen, einer Zahl oder einem test-Konstrukt ist.
Fall e) können wir sofort ausschließen. Die Fälle a) und b) werden durch die
Lemmata 5.4.1 und 5.4.4 widerlegt.
Als nächstes beobachten wir, daß sobald mit t ein test-Konstrukt eingelesen
wird, in diesem Schleifendurchlauf der Lesezeiger soweit vorgestellt wird, daß er
hinter dem letzten Element von T steht, oder vor einem Element von T ungleich
einem test-Konstrukt steht. D.h. falls T eine Folge von test-Konstrukten
enthält, so wird nur das erste test-Konstrukt in t eingelesen. Da jedes
Beispielauswertungsfragment eines while-Konstruktes aus mindestens zwei
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
test-Konstrukten besteht, muß t ein weiteres test-Konstrukt folgen. Dies
schließt die Fälle c) und d) aus.
In jedem Schleifendurchlauf wird A um ein Element ergänzt. Die äußere
Schleife wird also |A| mal durchlaufen. Sei B die Hauptanweisungssequenz von
P. Wir zeigen nun den folgenden Hilfssatz:
Hilfssatz:
1) Für jedes i∈{0,..,|A|} ist das Anfangsstück der
Beispielauswertungsfragmente der ersten i Anweisungen von B
Beispielauswertung der ersten i Anweisungen von A.
2) Die Variablenliste V enthält nach i Schleifendurchläufen die Wert aller in den
ersten i Anweisungen von A vorgekommenen Variablen am Ende nach der i-ten
Anweisung von A.
3) Der Lesezeiger L steht nach dem i-ten Schleifendurchlauf hinter der
Beispielauswertung der i-ten Anweisung von B.
Beweis (induktiv):
Für i = 0 ist der Hilfssatz trivial. Wir nehmen nun an, die Behauptung gelte für
alle i ≤ n und zeigen den Hilfssatz für i = n+1.
Nach Induktionsvoraussetzung steht der Lesezeiger L vor dem
Beispielauswertung des (n+1)-ten Elementes von B. Das erste Element dieser
Beispielauswertung wird in t eingelesen und der Lesezeiger um ein Element
vorgestellt. Sei a das (n+1)-te Element von A. Wir unterscheiden nach t:
1. Fall: t ist Sonderzeichen, Wort oder Zeichenkette:
Dann ist t = a eine Beispielauswertung von a. Nach Induktionsvoraussetzung
ist das Anfangsstück der Auswertungen der ersten n Elemente von B eine
Beispielauswertung der ersten n Elemente von A. Somit ist das Anfangsstück
von T für die ersten n+1 Elemente von B eine Beispielauswertung der ersten
n+1 Elemente von A und die Teilaussage 1) ist bewiesen. Da weder V noch eine
Variable in A verändert wurde, gilt Teilaussage 2) nach
Induktionsvoraussetzung. Da die Beispielauswertung des (n+1)-ten Elementes
von B nur ein Element in T ist, gilt auch die Teilaussage 3).
2. Fall: t ist Zahl, etwa c:
t muß Wert einer Variablen sein, da in P keine Zahlkonstanten vorkommen. Da
wir nicht innerhalb eines while-Konstruktes sind, darf es in Klasse-I-
Programmen genau eine Variable geben, deren Wert zwischen c-1 und c+1 liegt
Nach Induktionsvoraussetzung enthält V die Werte aller Variablen in A nach
Auswertung des n-ten Elementes.
1. Unterfall: es gibt eine Variable v in V mit Endwert c.
Es gibt keine andere Variable in A, deren Wert c ist. Dann ist a gerade die
Variable v und t ist Beispielauswertung von a. An dieser Stelle ist auch wichtig,
daß das Dekrement von Variablen mit Wert 0 in Klasse-I-Programmen nicht
erlaubt ist.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
2. Unterfall: es gibt eine Variable v in V mit Endwert c - 1:
Dann gibt es keine andere Variable in A, deren Wert c sein kann. Dann ist a
gleich ++v und t ist Beispielauswertung von a.
3. Unterfall: es gibt eine Variable v in V mit Endwert c + 1:
Dann gibt es keine andere Variable in A, deren Wert c sein kann. Dann ist a
gleich --v und t ist Beispielauswertung von a.
4. Unterfall: es gibt keine Variable in V, für deren Endwert d gilt: c-1 ≤ d ≤ c+1:
Dann muß c der Wert einer Variablen, etwa v, sein, die noch nicht
vorgekommen ist, da nach Induktionsvoraussetzung V die Werte aller
vorgekommenen Variablen beinhaltet. Das erste Vorkommen einer Variablen
darf aber nicht in einem Inkrement oder Dekrement erfolgen, also ist a nur die
Variable v. Die Variable hat dann den Anfangswert c, der als Anfangs- und als
Endwert zusammen mit v in V eingetragen wird. c ist dann Beispielauswertung
von v.
Mithilfe der Induktionsvoaussetzung sieht man nun, daß das Anfangsstück von
T der Auswertungen der ersten n+1 Anweisungen von B eine
Beispielauswertung der ersten n+1 Elemente von A ist, womit wir Teilaussage
1) bewiesen haben. Ebenfalls wissen wir, daß das Beispielauswertungsfragment
des (n+1)-ten Elementes von b nur aus t besteht. Da nach
Induktionsvoraussetzung der Lesezeiger vor dem (n+1)-ten Schleifendurchlauf
hinter dem Beispielauswertungsfragment der n-ten Anweisung von B steht,
wissen wir, daß der Lesezeiger jetzt hinter dem Beispielauswertungsfragment
der (n+1)-ten Anweisung on B steht (Teilaussage 3)).
Falls a kein Inkrement oder Dekrement ist, ändert sich weder der Wert einer
Variablen im Anfangsstück von B noch der Wert einer Variablen in V. Falls a
ein Inkrement ist, etwa der Variablen v, so wird der Wert der Variablen v
sowohl bei der Auswertung von A als auch in V um 1 erhöht. Falls a eine
Dekrement ist, etwa der Variablen v (dann ist der Wert von v nicht 0), so wird
sowohl der Wert von v bei der Auswertung T als auch in der Variablenliste V
um 1 erniedrigt. Die Werte aller Variablen ungleich v werden nicht berührt. V
beinhaltet nach Induktionsvoraussetzung die Werte aller Variablen des
Anfangsstückes der ersten n Anweisungen von A nach der Auswertung der n-
ten Anweisung. Nach dem (n+1)-ten Schleifendurchlauf beinhaltet V die Werte
aller im Anfangsstück der ersten n+1 Anweisungen von A nach der Auswertung
von a, womit wir Teilaussage 2) bewiesen haben.
3. Fall: t ist test-Konstrukt:
Wir wissen, daß der Lesezeiger vor einem weiteren test-Konstrukt stehen muß.
Dieses zweite test-Konstrukt wird als u gelesen, und der Lesezeiger wird um ein
Element vorgestellt.
t und u sind jetzt die Auswertung der ersten und zweiten Entfaltung eines
while-Konstruktes. D.h. t hat die Form
test C do D end test
und u hat die Form
test C’ do D’ end test
Dabei sind C und C' Beispielauswertungsfragmente eines Ausdrucks und D und
D' Beispielauswertungsfragmente einer Anweisungssequenz.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Für den Aufruf der Prozedur SampleWHILE mit den Parametern
(C,D,C',D',V,G,H), wobei der Ausdruck G und die Anweisungssequenz H
Ausgabeparameter sind, wissen wir dann nach Lemma 5.4.14, daß die
Beispielauswertung der (n+1)-ten Anweisung von B eine Beispielauswertung für
a ist. Zusammen mit der Induktionsvoraussetzung wissen wir dann aber, daß
das Anfangsstück von T der ersten n+1 Anweisungen von B eine
Beispielauswertung der ersten n+1 Anweisungen von A ist (Teilaussage 1)).
Außerdem sagt uns Lemma 5.4.14, daß jede in der in a erstmalig
vorgekommenen mit ihrem Anfangswert in V eingetragen worden ist. Ebenso
besagt das Lemma, daß die Endwerte jeder Variablen im Anfangsstück von A
mit den Endwerten in der Variablenliste V nach dem Aufruf übereinstimmen.
Dann beinhaltet die Variablenliste V die Werte aller bereits vorgekommen
Variablen nach Auswertung von u.
Wir wissen bereits, daß am Ende des (n+1)-ten Schleifendurchlaufs der
Lesezeiger L hinter der Auswertung des (n+1)-ten Elementes von B steht
(Teilaussage 3)). Lemma 5.4.4 sagt uns, daß nach jedem Aufruf der Prozedur
TestWHILE für eines weiteres test-Konstrukt der Beispielauswertung des (n+1)-
ten Elementes von B die Werte von V die Werte der Variablen von a am Ende
dieses test-Konstruktes sind. Falls nach Beendigung der inneren solange-
Schleife die Prozedur SampleWExpresion aufgerufen wird, so folgt nach Lemma
5.4.1, daß die Werte der Variablen am Ende der Auswertung des letzten test-
Konstruktes die Endwerte dieser Variablen in V sind. Dann wissen wir, daß die
Variablenliste V die Endwerte aller Variablen am Ende der Auswertung von a
(wie in T) beinhaltet (Teilaussage 2)).
Damit ist der Hilfssatz bewiesen. (Hilfssatz)
Die 2. Behauptung des Lemmas folgt aus der 1. Teilaussage des Hilfssatzes.
III. Es gibt eine Variablenumbenennung σ, so daß Aσ = B, wobei B die
Hauptanweisungssequenz von P ist.
Wir wissen aus dem Beweis von II, daß T Beispielauswertung sowohl für A als
auch für B ist. Daraus folgt, daß |A| = |B|. Wir zeigen, daß sich A und B nur
im Namen der Variablen unterscheiden. Sei i ∈ {1,..,|A|} beliebig. Sei ai die i-te
Anweisung von A und bi die i-te Anweisung von B.
1. Fall: bi ist Sonderzeichen, Zahl oder Zeichenkette.
Dann muß gelten ai = bi, denn sonst könnten T nicht Beispielauswertung von A
und von B sein.
2. Fall: bi ist while-Konstrukt:
ai ist dann ebenfalls while-Konstrukt und wurde durch die Prozedur
SampleWHILE gebildet. Für diese Prozedur gilt das Lemma 5.4.14, nach dem ai
und bi bis auf die Namen der Variablen übereinstimmen. Man beachte, daß für
jede erstmalig in bi auftretende Variable, eine neue Variable in ai eingeführt
wurde, die denselben Wert wie die ursprüngliche Variable besitzt.
3. Fall: bi ist Variable x, die erstmalig in B auftaucht.
Sei c der Wert von x an der Stelle der Auswertung von bi. V kann keine Variable
mit einem Wert zwischen c-1 und c+1 enthalten, denn sonst müßte es eine
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
zweite Variable in B geben, deren Wert sich vom Wert von x um weniger als 2
unterscheidet. Also wird a gleich einer neuen Variablen, etwa v, gesetzt, deren
Wert mit dem von x übereinstimmt.
4. Fall: bi ist Variable x, die nicht erstmalig in B auftaucht.
x muß erstmalig im 2. Fall oder im 3. Fall vorgekommen sein. Dann gibt es eine
Variable v in A, deren Wert mit dem Wert von x übereinstimmt. Nach dem
Hilfssatz im Beweis des 2. Teils des Lemmas ist der Wert der Variablen v in V
enthalten. Dann wird aber ai auf die Variable gesetzt. ai und bi unterscheiden
sich nur im Namen der Variablen.
5. Fall: bi ist Inkrement einer Variablen, etwa der Variablen x.
x kann nicht erstmalig in bi vorkommen, sondern muß gemäß dem 2. Fall oder
dem 3. Fall eingeführt worden sein. Auf jeden Fall gibt es eine Variable v in A
und V, deren Wert mit dem Wert von x übereinstimmt. Sei c der Wert von x vor
dem Inkrement. Dann beinhaltet V eine Variable mit dem Wert c-1, aber keine
Variablen mit dem Wert c, also wird ai auf das Inkrement der Variablen v
gesetzt und der Endwert von v in v um eins erhöht. ai und bi stimmen wieder
nur im Namen der Variablen überein.
6. Fall: bi ist Inkrement einer Variablen, etwa der Variablen x.
Die Argumentation verläuft völlig analog zum 5. Fall.
Wie sehen also, daß A und B sich nur in den Namen der Variablen
unterscheiden. Für jede Variable x in B existiert eine Variable v in A, deren
Werte mit den Werten von x übereinstimmen. Die Variablenumbenennung σ
entsteht dann einfach durch Ersetzen jeder Variablen v durch die entsprechende
Variablen x.
Wird in A eine Variable verwendet, die nicht bereits beim Aufruf der Prozedur
in V enthalten ist, so wird sie mit ihrem Anfangswert in V eingetragen.
Haben wir bereits im Beweis des Hilfssatzes im Beweis des 2. Teil des Lemmas
gesehen.
V enthält am Ende der Prozedur die Werte aller in A vorkommenden Variablen
am Ende der Auswertung T.
Folgt direkt aus der 2. Teilaussage des Hilfssatzes im Beweis des 2. Teils des
Lemmas.
Endlich können wir unseren Satz formulieren:
6DW]
6HL3HLQ.ODVVH,3URJUDPPXQG6HLQH.ODVVH,%HLVSLHODXVZHUWXQJYRQ3
'DQQJLOWI UGHQ$XIUXIGHV$OJRULWKPXV6DPSOH3URJUDPPLWGHQ
3DUDPHWHUQ65ZREHLGHU$XVJDEHSDUDPHWHU5HLQ3URJUDPPLVW
'HU$OJRULWKPXVWHUPLQLHUWQDFKHQGOLFKYLHOHQ5HFKHQVFKULWWHQ
3≅5
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Beweis:
1. Der Algorithmus terminiert nach endlich vielen Rechenschritten.
Die einzige Prozedur, die aufgerufen wird, ist die Prozedur SampleSequence.
Deren Termination wird aber in Lemma 5.4.15 bestätigt. Die für-Schleifen im
Algorithmus SampleProgram werden nach endlicher Zeit verlassen. Dann
benötigt der Algorithmus insgesamt nur endliche Rechenzeit.
2. P ≅ R.
Sei Q die konstantenbereinigte Form von P. In der ersten für-Schleife des
Algorithmus' wird für jede Eingabevariable von Q eine Variable mit Anfangsund
Endwert des Wertes der Eingabevariablen im Eingabekonstrukt in die
Variablenliste V eingetragen, die anfänglich leer war. Für den folgenden Aufruf
der Prozedur SampleSequence mit den Parametern (T,V,A), wobei T die
Beispielauswertung der Hauptanweisungssequenz von Q und der
Ausgabeparameter A eine Anweisungssequenz ist, gilt das Lemma 5.4.15:
I. Die Prozedur terminiert nach endlich vielen Schritten.
II. T ist eine Beispielauswertung von A.
III.Es gibt eine Variablenumbenennung σ, so daß Aσ = B, wobei B die
Hauptanweisungssequenz von P ist.
IV.Wird in A eine Variable verwendet, die nicht bereits beim Aufruf der
Prozedur in V enthalten ist, so wird sie mit ihrem Anfangswert in V
eingetragen.
V. V enthält am Ende der Prozedur die Werte aller in A vorkommenden
Variablen am Ende der Auswertung T.
Man beachte, daß es nur eine Variable in V geben kann, etwa y, deren Wert mit
dem Wert der Ausgabevariablen in Q übereinstimmt. R erhält den Wert
input (v 1 ,..,v m ) K m+1 ... K Länge(V) A output y
Dabei v1,...,vm die Variablen, die den Eingabevariablen von Q entsprechen und
Km+1,...,KLänge(V) die Hauptinitialisationssequenz (man beachte, daß V die Werte
des ersten Vorkommens aller Variablen von A enthält, diese Werte müssen mit
den Initialisationswerten übereinstimmen).
R' entstehe durch R durch Ersetzen der Variablen von R durch die
entsprechenden Variablen in Q. Nach Lemma 3.5.2 gilt R' ≅ R.
R' und Q unterscheiden sich jetzt nur noch in der Reihenfolge der Initialisation
in der Hauptinitialisationssequenz. Nach Lemma 3.5.4 gilt dennoch Q ≅ R' ≅ R.
Nach Lemma 3.5.1 gilt dann Q ≅ R. Nach Lemma 3.5.3 gilt P ≅ Q ≅ R. Dann
folgt wieder mit Lemma 3.5.1: P ≅ R.
Satz 5.4.1 verschenkt aber einiges der Aussage der Lemmata.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
6DW]
6HL3HLQ.ODVVH,3URJUDPPGDVNHLQH=DKONRQVWDQWHQHQWKlOWXQG6HLQH
.ODVVH,%HLVSLHODXVZHUWXQJYRQ3'DQQJLOWI UGHQ$XIUXIGHV$OJRULWKPXV
6DPSOH3URJUDPPLWGHQ3DUDPHWHUQ65ZREHLGHU$XVJDEHSDUDPHWHU5
HLQ3URJUDPPLVW
'HU$OJRULWKPXVWHUPLQLHUWQDFKHQGOLFKYLHOHQ5HFKHQVFKULWWHQ
3XQWHUVFKHLGHWVLFKYRQ5QXULQGHQ1DPHQGHU9DULDEOHQXQGLQGHU
5HLKHQIROJHGHU,QLWLDOLVLHUXQJHQLP+DXSWLQLWLDOLVDWLRQVNRQVWXNW
Beweis:
folgt direkt aus dem Beweis des Lemma 5.4.1.
5.5 Komplexität
Wie wollen hier einen Ausdruck für eine obere Schranke der Rechenzeit des Algorithmus im
schlechtesten Fall herleiten. Dabei wollen annehmen, daß wir für jede Operation nur eine
Zeiteinheit benötigen.
Wir beginnen unsere Komplexitätsanalyse mit der Aufwandsberechnung für die Prozedur
TestWExpression.
/HPPD
'LH3UR]HGXU7HVW:([SUHVVLRQZHUGHPLWGHQ3DUDPHWHU%*9UHVXOW
DXIJHUXIHQZREHL*HLQH$XVGUXFN%HLQH%HLVSLHODXVZHUWXQJYRQ*9HLQH
9DULDEOHQOLVWHXQGUHVXOWHLQHORJLVFKH$XVJDEHYDULDEOHLVW'DQQEHQ|WLJW
GLH3UR]HGXULPVFKOHFKWHVWHQ)DOO2_%__9_6FKULWWH
Beweis:
In Lemma 5.4.1 haben wir gezeigt, daß die äußere solange-Schleife in der
Prozedur |B| = |G| mal durchlaufen wird. Jedes Element von G kann
entweder Zeichenkette, Wort, Sonderzeichen oder Variable sein. In den ersten
drei Fällen kann der Schleifendurchlauf sofort (in konstanter Zeit)
abgeschlossen werden. Fall das vom Ausdruck G gelesene Element aber eine
Variable ist, so muß der Wert der Variablen in der Variablenliste V ermittelt
werden Dazu sind maximal |V| Vergleiche notwendig. Damit ergibt sich der
Zeitbedarf im schlechtesten Fall zu O(|B||V|).
Für die Berechnung der Komplexität der Prozedur TestWStatementSequence benötigen wir
eine Voraussetzung für die Komplexität der Prozedur TestWHILE. Deswegen betrachten wir
zunächst die Komplexität für den Fall, daß die Prozedur TestWHILE nicht aufgerufen wird.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Abbildung 7 : Struktur des Beweises von Satz 5.5.1
benötigt für
SampleProgram
Satz 5.5.1
SampleSequence
Lemma 5.5.10
Lemma 5.4.15
TestWHILE
SampleWHILE
Lemma 5.5.4
Lemma 5.5.9
SampleWSequence
Lemma 5.4.3
TestWSequence
Lemma 5.5.3
Lemma 5.5.8
Lemma 5.4.11
Lemma 5.4.2
Lemma 5.5.2
Lemma 5.5.7
Lemma 5.4.8
TestWExpression
SampleWExpression
Lemma 5.4.1
Lemma 5.5.1
Lemma 5.5.6
Lemma 5.4.6
MatchWHILE
Lemma 5.4.5
Lemma 5.5.5
/HPPD
'LH3UR]HGXU7HVW:6WDWHPHQW6HTXHQFHZHUGHPLWGHQ3DUDPHWHU
&+9UHVXOWDXIJHUXIHQZREHL+HLQH$QZHLVXQJVVHTXHQ]LVW&HLQH
%HLVSLHODXVZHUWXQJYRQ+9HLQH9DULDEOHQOLVWHXQGUHVXOWHLQHORJLVFKH
$XVJDEHYDULDEOHLVW(VJHOWH'+ 'DQQEHQ|WLJWGLH3UR]HGXULP
VFKOHFKWHVWHQ)DOO2_&__9_6FKULWWH
Beweis:
In Lemma 5.4.2 haben wir gezeigt, daß die äußere solange-Schleife in der
Prozedur |C| = |H| mal durchlaufen wird. Jedes Element von H muß entweder
Zeichenkette, Wort, Sonderzeichen, Variablen, Dekrement oder Inkrement sein.
Im Falle einer Zeichenkette, eines Sonderzeichens oder eines Wortes wird der
Schleifendurchlauf nach konstanter Zeit beendet. Falls aber die gelesene
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Anweisung eine Variable, ein Inkrement oder ein Dekrement ist, so muß zuerst
der Wert dieser Variablen (und die Speicherstelle dieses Wertes) aus der
Variablenliste V entnommen werden. Hierzu sind im schlechtesten Fall |V|
Operationen notwendig. Der Gesamtzeitbedarf im schlechtesten Fall für die
Prozedur ist also von der Größenordnung O(|C||V|).
/HPPD
'LH3UR]HGXU7HVW:6WDWHPHQW6HTXHQFHZHUGHPLWGHQ3DUDPHWHU
&+9UHVXOWDXIJHUXIHQZREHL+HLQH$QZHLVXQJVVHTXHQ]LVW&HLQH
%HLVSLHODXVZHUWXQJYRQ+9HLQH9DULDEOHQOLVWHXQGUHVXOWHLQHORJLVFKH
$XVJDEHYDULDEOHLVW(VVHLG '+
) UGLH3UR]HGXU7HVW:+,/(JHOWHGLHIROJHQGH9RUDXVVHW]XQJ
'LH3UR]HGXU7HVW:+,/(ZHUGHPLWGHQ3DUDPHWHUQ%&*+9UHVXOW
DXIJHUXIHQZREHL*HLQ$XVGUXFN+HLQH$QZHLVXQJVVHTXHQ]%HLQH
%HLVSLHODXVZHUWXQJYRQ*XQG&HLQH%HLVSLHODXVZHUWXQJYRQ+LVWUHVXOW
VHLHLQHORJLVFKH$XVJDEHYDULDEOHXQG9HLQH9DULDEOHQOLVWH(VJHOWH'+
G(VVHLQGLH6XPPHGHU=DKOGHU=HLFKHQLQ%XQG&XQGP _9_'DQQ
LVWGLH.RPSOH[LWlWLPVFKOHFKWHVWHQ)DOOJHJHEHQGXUFK2QP
(VVHLQGLH=DKOGHU=HLFKHQLQ&XQGP _9_'DQQEHQ|WLJWGLH3UR]HGXU
7HVW:6WDWHPHQW6HTXHQFHLPVFKOHFKWHVWHQ)DOO2QP5HFKHQVFKULWWH
Beweis:
Wir wissen nach Lemma 5.4.3, daß die äußere solange-Schleife |H| mal
durchlaufen wird. Man beachte, daß im allgemeinen |H| ≠ |C|. Sei Ri für
i∈{1,..,|H|} die Rechenzeit im i-ten Schleifendurchlauf. Dann wird die
Gesamtrechenzeit der Prozedur im wesentlichen bestimmt durch
der Zeitbedarf für alle übrigen Operationen ist konstant.
|H|
∑ R i
i=1
, denn
Berechnen wir zuerst die Rechenzeit im Fall, daß das von H eingelesene
Element t ein while-Konstrukt sein. Sei j die Nummer des Schleifendurchlaufs,
in dem t eingelesen wird. Sei G' der Ausdruck von t und H' die
Anweisungssequenz von t. Sei T die Beispielauswertung von t in C. T sei ist
dann entweder eine Folge:
test B1 do C1 end test
test B 2 do C 2 end test
...
test B r do C r end test
oder eine Folge
test B 1 do C 1 end test
test B 2 do C 2 end test
...
test B r do C r end test
test B r+1 skip
für ein r > 1. Dabei sind B1,..,Br+1 Beispielauswertungen von G' und C1,..,Cr
Beispielauswertungen von H'. Die Rechenzeit Rj ist damit im wesentlichen
durch die Aufrufe der Prozedur TestWHILE mit den Parametern
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
(B1,C1,G,H,V,result)
(B2,C2,G,H,V,result)
...
(Br,Cr,G,H,V,result)
bestimmt, sowie durch den eventuell folgenden Aufruf der Prozedur
TestWExpression. Für jeden der Aufrufe der Prozedur TestWHILE gilt die
Voraussetzung in unserem Lemma. Sei ni die Summe der Zahl der Zeichen in Bi
und Ci. Dann ist die Komplexität im schlechtesten Fall für das i-te test-
Konstrukt gegeben durch O(nim).
Die Komplexität für den eventuellen Aufruf der Prozedur TestWExpression mit
den Parametern (Br+1, G,V,result) ist nach Lemma 5.5.1 aber gerade
O(|Br+1|m). Da jede Anweisung aus mindestens einem Zeichen besteht, läßt
sich die Komplexität für den Aufruf der Prozedur TestWExpression abgrenzen
durch O(nr+1m), wobei nr+1 die Zahl der Zeichen von Br+1 ist.
Dann läßt sich die Komplexität im schlechtesten Fall für den j-ten
Schleifendurchlauf begrenzen durch O(nTm), wobei nT die Zahl der Zeichen von
T ist.
Falls das von H eingelesene Element t eine Variable, ein Inkrement oder ein
Dekrement ist, so ist die Länge der Beispielauswertung von t gleich 1. Die
Rechenzeit ist hier vor allem abhängig von der Zeit für das Suchen des Wertes
und des Speicherplatzes für die Änderung desselben einer Variablen in V. D.h.
Rj = O(1 m). Falls das von H eingelesene Element t eine Zeichenkette, ein
Sonderzeichen oder ein Wort ist, so ist die Länge der Beispielauswertung von t
gleich der Länge von t. Die Rechenzeit ist in diesem Fall konstant.
Bezeichne nCi die Länge der Beispielauswertung der i-ten Anweisung von H, so
gilt für die Gesamtrechenzeit der Prozedur:
R = R =
ges
|H|
∑
i=1
i
|H|
∑
i=1
Im schlimmsten Fall gilt also Rges = O(nm).
⎧O(1)
falls i - te Anweisung ist Sonderzeichen,
⎪
Wort oder Zeichenkette
⎪
⎨O(nCim) falls i - te Anweisung ist Variable,
⎪
Inkrement oder Dekrement
⎪
⎩⎪
O(nCim) sonst
Nun zur Prozedur TestWHILE. Die im Lemma 5.5.3 benutzte Voraussetzung über die
Komplexität der Prozedur TestWHILE wird sich jetzt durch die Induktionsvoraussetzung
ergeben.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
/HPPD
'LH3UR]HGXU7HVW:+,/(ZHUGHPLWGHQ3DUDPHWHUQ%&*+9UHVXOW
DXIJHUXIHQZREHL*HLQ$XVGUXFN+HLQH$QZHLVXQJVVHTXHQ]%HLQH
%HLVSLHODXVZHUWXQJYRQ*XQG&HLQH%HLVSLHODXVZHUWXQJYRQ+LVWUHVXOWVHL
HLQHORJLVFKH$XVJDEHYDULDEOHXQG9HLQH9DULDEOHQOLVWH(VVHLQGLH6XPPH
GHU=DKOGHU=HLFKHQLQ%XQG&XQGP _9_'DQQLVWGLH.RPSOH[LWlWLP
VFKOHFKWHVWHQ)DOOJHJHEHQGXUFK2QP
Beweis:
Sofort einsichtig ist, daß die Rechenzeit für die Prozedur TestWHILE im
wesentlichen gleich der Summe der Rechenzeiten der beiden Prozeduraufrufen
ist. Sei nB die Zahl der Zeichen in B und nC die Zahl der Zeichen in C.
(vollständige Induktion)
Induktionsverankerung für D(H) = 0:
Die Rechenzeit für die Prozedur TestWExpression ist O(|B||V|) ≤ O(nBm)
nach Lemma 5.5.1. Die Rechenzeit für die Prozedur TestWStatementSequence
ist gegeben durch O(nCm) nach Lemma 5.5.2. Also ergibt sich die
Gesamtrechenzeit für die Prozedur zu O(nm).
Induktionsvoraussetzung:
Sei d∈©. Für D(H) ≤ d sei die Komplexität der Prozedur TestWHILE gleich
O(nm).
Induktionsbehauptung:
Für D(H) = d+1 sei die Komplexität der Prozedur TestWHILE gleich O(nm).
Induktionsschluß:
Nach Lemma 5.5.1 ist die Komplexität der Prozedur TestWExpression gleich
O(|B||V|) ≤ O(nBm). Nach Induktionsvoraussetzung können wir für den
Aufruf der Prozedur TestWStatementSequence da Lemma 5.5.3 verwenden,
wonach sich die Komplexität im schlechtesten Fall ergibt zu O(nCm). Folglich
wird die Gesamtkomplexität beschrieben durch O(nm).
Als nächstes analysieren wir das Zeitverhalten der Prozedur MatchWHILE.
/HPPD
'LH3UR]HGXU0DWFK:+,/(ZHUGHPLWGHQ3DUDPHWHUQ
00119

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Wir berechnen zuerst die Rechenzeit für den ersten Teil der Prozedur, in dem
die Ausdrücke M und M' miteinander verglichen werden.
Die erste solange-Schleife wird nach dem Beweis von Lemma 5.4.5 |M|-mal
durchlaufen. Falls das von M gelesene Element eine Zeichenkette, ein Wort oder
ein Sonderzeichen ist, so ist der Zeitbedarf für einen Schleifendurchlauf
konstante, falls das gelesene Element eine Variable, ein Inkrement oder ein
Dekrement ist, so ergibt sich der Aufwand im wesentlichen durch das Auffinden
der Endwerte der Variablen in den Variablenlisten V und Y und das Eintragen
einer Variablen in die Variablenliste X. Dieser Aufwand kann also durch
O(|V|)+O(|X|)+O(|Y|) = O(m) beschrieben werden. Für die erste solange-
Schleife läßt sich dann ein Gesamtaufwand von O(|M|m) ≤ O(nMm) angeben.
Der zweite Teil der Prozedur MatchWHILE, in dem die Anweisungssequenzen
miteinander verglichen werden, ist rekursiv, wir benötigen also zum Beweis des
Lemmas vollständige Induktion.
Induktionsverankerung für D(N) = 0:
In diesem Fall ist die Ausführung der Prozedur nicht rekursiv. Nach Lemma
5.4.5 wird die zweite äußere solange-Schleife |N|-mal durchlaufen. Die
einzigen Elemente, die N und N' enthalten können sind (nach dem Beweis
von Lemma 5.4.5) Sonderzeichen, Zeichenketten, Worte, Variablen,
Inkremente und Dekremente.
Im Falle eines Wortes, eines Sonderzeichens oder einer Zeichenkette wird der
Schleifendurchlauf in konstanter Zeit abgeschlossen. Der Zeitbedarf für die
Behandlung eines Inkrementes, eines Dekrementes oder einer Variablen wird
im wesentlichen durch den Zeitbedarf zum Auffinden der Werte in den
Variablenlisten V,X und Y, und zum Eintragen von Variablen in die
Variablenliste X bestimmt, weswegen als Komplexität wieder O(m) angesetzt
werden darf. Die Komplexität im schlechtesten Fall für die zweite äußere
solange-Schleife ist damit O(nNm).
Die Gesamtkomplexität für die Prozedur ergibt sich damit zu O(nm).
Induktionsvoraussetzung:
Sei d∈©. Für D(H) ≤ d sei die Komplexität der Prozedur MatchWHILE gleich
O(nm).
Induktionsbehauptung:
Für D(H) = d+1 sei die Komplexität der Prozedur MatchWHILE gleich O(nm).
Induktionsschluß:
Wiederum sagt uns der Beweis von Lemma 5.4.5, daß die zweite äußere
solange-Schleife |N| mal durchlaufen wird. Wir haben bereits in der
Induktionsverankerung gesehen, daß wir die Rechenzeit für einen
Schleifendurchlauf im Fall, daß die von M eingelesene Anweisung ein
Sonderzeichen, eine Wort oder eine Zeichenkette ist, als konstant ansehen
dürfen, und im Fall, daß die von M eingelesene Anweisung eine Variable,
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
eine Inkrement oder ein Dekrement ist, mit O(m) abschätzen dürfen. Nach
Lemma 5.4.5 kann aber die eingelesene Anweisung ansonsten nur noch ein
while-Konstrukt sein. Der Zeitbedarf in diesem Fall resultiert aber
wesentlich nur vom rekursiven Aufruf der Prozedur MatchWHILE.
Sei B der Ausdruck des gelesenen while-Konstruktes und C die
Anweisungssequenz. Da für den rekursiven Aufruf die
Induktionsvoraussetzung gültig ist, können wird die Rechenzeit für den
Schleifendurchlauf im schlechten Fall abschätzen durch O(n'm). Dabei sei n'
die Summe der Zahl der Zeichen in B und C.
Die Komplexität der zweiten solange-Schleife ergibt sich jetzt durch
Summation der Rechenzeiten für die einzelnen Schleifendurchläufen und wir
erhalten:
|N|
∑
R = R =
i=1
i
|N|
∑
i=1
⎧O(1)
⎪
⎪
⎨O(m)
⎪
⎪
⎩⎪
O(n im)
falls i - te Anweisung ist Sonderzeichen,
Wort oder Zeichenkette
falls i - te Anweisung ist Variable,
Inkrement oder Dekrement
sonst
Dabei sei Ri die Rechenzeit im i-ten Schleifendurchlauf und ni die Zahl der
Zeichen in der i-ten Anweisung von M. R kann nun abgeschätzt werden zu
O(nNm). Die Gesamtrechenzeit für die Prozedur ergibt sich damit zu O(nm).
Als nächstes wollen wir die Komplexität der Prozedur SampleWExpression untersuchen.
/HPPD
'LH3UR]HGXU6DPSOH:([SUHVVLRQZHUGHPLWGHQ3DUDPHWHUQ&&9;*
DXIJHUXIHQ'DEHLVHLHQ&XQG&%HLVSLHODXVZHUWXQJVIUDJPHQWH9XQG;
9DULDEOHQOLVWHQXQG*HLQ$XVGUXFN'DQQZLUGGLH5HFKHQ]HLWGHU3UR]HGXU
LPVFKOHFKWHVWHQ)DOOGXUFK2_&_PòEHVFKULHEHQZREHLP
PD[_9__;_
Beweis:
Im Beweis des Lemma 5.4.6 haben wir gesehen, daß |C| = |C'| gilt. Demnach
wird die solange-Schleife |C|-mal durchlaufen. Jedes von C gelesene Element
kann entweder eine Zahl, eine Zeichenkette, eine Sonderzeichen oder ein Wort
sein. Falls das gelesene Element ein Sonderzeichen, ein Wort oder ein Zahl ist,
so wird der Schleifendurchlauf in konstanter Zeit beendet. Falls das gelesene
Element eine Zahl ist, so hängt der Aufwand für den Schleifendurchlauf vom
Aufwand des Suchen in den Variablenlisten V und X ab. Diesen Aufwand
können wir für den schlechtesten Fall mit O(|V||X|) ≤ O(m²) abschätzen. Also
kann der Gesamtaufwand für die Prozedur durch O(|C|m²) abgeschätzt
werden.
Wenden wir uns jetzt der Prozedur SampleWSequence zu.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
/HPPD
'LH3UR]HGXU6DPSOH:6HTXHQFHZHUGHPLWGHQ3DUDPHWHUQ''9;+
DXIJHUXIHQ'DEHLVHLHQ'XQG'%HLVSLHODXVZHUWXQJVIUDJPHQWHHLQHU
$QZHLVXQJVVHTXHQ]9XQG;9DULDEOHQOLVWHQXQG+HLQH
$QZHLVXQJVVHTXHQ]:HGHU'QRFK'HQWKDOWHQWHVW.RQVWUXNWH'DQQZLUG
GLH5HFKHQ]HLWGHU3UR]HGXULPVFKOHFKWHVWHQ)DOOGXUFK2_'_Pò
EHVFKULHEHQZREHLP PD[_9__;_
Beweis:
Der Aufwand für die Prozedur ist wesentlich nur von der solange-Schleife
abhängig. Im Beweis des Lemma 5.4.8 wurde gezeigt, daß |D| = |D'| = |H|
und die äußere solange-Schleife |D|-mal durchlaufen wird. Jedes Element von
D und D' kann nur eine Zeichenkette, ein Wort, ein Sonderzeichen oder eine
Zahl sein. Im Falle einer Zeichenkette, eines Wortes oder eines Sonderzeichens,
wird der Schleifendurchlauf in konstanter Zeit beendet. Im Falle einer Zahl
hängt die Komplexität des Schleifendurchlaufs vom Suchen von Werten und
Speicherplätzen in den Variablenlisten V und X ab. Wir können diesen Aufwand
im schlechtesten Fall durch O(|V||X|) ≤ O(m²) abschätzen. Der
Gesamtaufwand für die Prozedur ergibt sich dann zu O(|D|m²).
/HPPD
'LH3UR]HGXU6DPSOH:6HTXHQFHZHUGHPLWGHQ3DUDPHWHUQ''9;+
DXIJHUXIHQ'DEHLVHLHQ'XQG'%HLVSLHODXVZHUWXQJVIUDJPHQWHHLQHU
$QZHLVXQJVVHTXHQ]GHU6FKDFKWHOXQJVWLHIHG9XQG;9DULDEOHQOLVWHQXQG
+HLQH$QZHLVXQJVVHTXHQ]
) UGLH3UR]HGXU6DPSOH:+,/(JHOWHGLHIROJHQGH9RUDXVVHW]XQJ
%HLP$XIUXIGHU3UR]HGXU6DPSOH:+,/(PLWGHQ3DUDPHWHUQ
$$%%9*+ZREHL$XQG$%HLVSLHODXVZHUWXQJHQHLQHV$XVGUXFNV%
XQG%%HLVSLHODXVZHUWXQJHQHLQHU$QZHLVXQJVVHTXHQ]HLQHU
6FKDFKWHOXQJVWLHIHNOHLQHUG9HLQH9DULDEOHQOLVWH*HLQH$XVGUXFNXQG+
HLQH$QZHLVXQJVVHTXHQ]KDWGLH3UR]HGXUHLQH.RPSOH[LWlWLP
VFKOHFKWHVWHQ)DOOYRQ2QPò'DEHLVHLQGLH6XPPHGHU=DKOGHU=HLFKHQ
LQ$$%XQG%XQGP _9_
'DQQZLUGGLH5HFKHQ]HLWGHU3UR]HGXULPVFKOHFKWHVWHQ)DOOGXUFK2QPò
EHVFKULHEHQZREHLQJOHLFKGHU6XPPHGHU=DKOGHU=HLFKHQLQ'XQG'
XQGP PD[_9__;_
Beweis:
Auch hier hängt der Aufwand ausschlaggebend von der solange-Schleife ab.
Nach dem Beweis des Lemma 5.4.11 wird die äußere solange-Schleife |H|-mal
durchlaufen. Ihr Zeitaufwand läßt sich als Summe der Rechenzeiten der
einzelnen Schleifendurchläufen berechnen. Bezeichne Ri die Rechenzeit für den
i-ten Schleifendurchlauf (i∈{1,...,|H|}). Jedes Element von D und D' kann
entweder eine Zeichenkette, ein Wort, ein Sonderzeichen, eine Zahl oder ein
test-Konstrukt sein.
Falls das im i-ten Schleifendurchlauf eingelesene Element eine Zeichenkette, ein
Wort oder ein Sonderzeichen ist, so wird der Schleifendurchlauf in konstanter
Zeit abgeschlossen. Falls das eingelesene Element eine Zahl ist, so wird die
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Komplexität des Schleifendurchlaufs durch die Zugriffe auf die Variablenlisten
V und X bestimmt. Im schlechtesten Fall kann Ri angegeben werden durch
O(|V||X|) ≤ O(m²).
Falls das im i-ten Schleifendurchlauf von D eingelesene Element t ein test-
Konstrukt sein, so muß es das erste einer Folge von test-Konstrukten sein,
nämlich entweder
test A 1 do B 1 end test
test A 2 do B 2 end test
...
test A r do B r end test
oder eine Folge
test A 1 do B 1 end test
test A 2 do B 2 end test
...
test A r do B r end test
test A r+1 skip
Entsprechend muß das von D' eingelesene Element u ein test-Konstrukt sein
und es muß das erste einer Folge
test A’ 1 do B’ 1 end test
test A’ 2 do B’ 2 end test
...
test A’ s do B’ s end test
oder einer Folge
test A’ 1 do B’ 1 end test
test A’ 2 do B’ 2 end test
...
test A’ s do B’ s end test
test A’ s+1 skip
sein. Dabei sind s,r > 1, A1,...,Ar+1,A'1,...,A's+1 Beispielauswertungen eines
Ausdrucks und B1,...,Br,A'1,...,A's Beispielauswertungen einer
Anweisungssequenz, deren Schachtelungstiefe kleiner d sein muß.
Also können wir die Voraussetzungen unseres Lemma für die Prozedur
SampleWHILE verwenden. Für den ersten Aufruf der Prozedur SampleWHILE
im i-ten Schleifendurchlauf werden die Parameter (A1,B1,A2,B2,V,M,N)
übergeben, wobei M ein Ausdruck und N eine Anweisungssequenz. Nach
Voraussetzung ist der Aufwand hierfür im schlechtesten Fall O(n1/2 |V|²), wobei
n1/2 die Summe der Zeichen in den Fragmenten A1,B1, A2 und B2 bedeutet.
Entsprechend liegt der Aufwand für den zweiten Aufruf der Prozedur
SampleWHILE mit den Parametern (A'1,B'1,A'2,B'2,Y,M',N') bei O(n'1/2 |Y|²).
Dabei sei M' eine Ausdruck und N' eine Anweisungssequenz. n'1/2 bedeutet die
Summe der Zeichenzahlen der Fragmente A'1, B'1, A'2 und B'2. Wichtig ist an
dieser Stelle noch, daß es für jede in Y enthaltene Variable eine in X enthaltene
Variable gibt, es gilt also |V| ≥ |X|.
Der Aufwand für den anschließenden Aufruf der Prozedur MatchWHILE mit
den Parametern (M,M',N,N',V,Y,X) liegt nach Lemma 5.5.5 im schlechtesten
Fall bei O(n*,m*), wobei n* die Summe der Zeichenzahlen von M und N und m*
= max (|V|,|X|,|Y|) ist.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Die anschließende solange-Schleife wird gemäß dem Beweis von Lemma 5.4.11
(r-2)-mal durchlaufen, wobei in jedem Schleifendurchlauf ein weiteres test-
Konstrukt von D gelesen wird. In jedem Schleifendurchlauf wird die Prozedur
TestWHILE aufgerufen. Nach Lemma 5.5.4 gilt für diesen Aufruf die
Aufwandsabschätzung O(nj |V|). Dabei bedeutet nj die Summe der Zahl der
Zeichen in Aj und Bj, falls das j-te test-Konstrukt behandelt wird. Der Aufwand
für die erste solange-Schleife berechnet sich demnach durch
r
∑
j=3
O(n |V|)
j
Da wir den schlechtesten Fall betrachten, müssen wir davon ausgehen, daß die
Prozedur TestWExpression im Anschluß an die erste innere solange-Schleife
aufgerufen wird. Nach Lemma 5.5.1 liegt der Aufwand hierfür bei O(|Ar+1|
|V|).
Der Aufwand für die zweite innere solange-Schleife berechnet sich vollkommen
analog zum Aufwand der ersten inneren solange-Schleife zu
s
∑
j=3
O(n’ |X|)
j
n'j bedeute die Summe der Zahl der Zeichen in A'j und B'j, falls das j-te test-
Konstrukt im Schleifendurchlauf gelesen wird.
Wiederum müssen wir davon ausgehen, daß die Prozedur TestWExpression ein
zweites Mal aufgerufen wird. Der Aufwand hierfür berechnet sich nach Lemma
5.5.1 zu O(|Bs+1| |X|).
Dann erhalten wir folgenden Ausdruck für die Rechenzeit:
O(n1/2 |V|²) + O(n'1/2 |Y|²) + O(n*m*) +
s
∑
j=3
O(n’ |X|)
j
+ O(|Bs+1| |X|).
r
∑ O(n j |V|) + O(|Ar+1| |V|) +
j=3
Benutzen wir jetzt die Beziehung m = max (|V|,|X|) ≥ |V| ≥ |Y|, so erhalten
wir einen vereinfachten Ausdruck:
r
O(n1/2 m²) + O(n'1/2 m²) + O(n*m) + ∑ O(n
jm)
+ O(|Ar+1| m) + ∑ O(n’
j
m) +
j=3
O(|Bs+1| m).
Wir führen jetzt die Bezeichnungen n1, n2, n'1, n'2 für die Summe der Zahl der
Zeichen in A1 und B1, A'1 und B'1, A2 und B2, sowie A'2 und B'2 ein. Die
Bezeichnungen nr+1 und n's+1 stehen für die Zahl der Zeichen in Ar+1 und A's+1.
Außerdem sehen wir, daß der Term O(n*m) nicht ins Gewicht fällt, weswegen
wir ihn weglassen können. Unser Ausdruck für die Komplexität vereinfacht sich
jetzt nach Abschätzung nach oben zu:
r+1
2
2
∑ O(n j m ) + ∑ O(n’
j
m )
j=1
s+1
j=1
s
j=3
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Dies können wir wieder großzügig abschätzen und wir erhalten:
Ri = O(Nm²)
Dabei sei Ni die Summe der im i-ten Schleifendurchlauf von D und D' gelesenen
Zeichen. Dann können wir die Gesamtrechenzeit für die Prozedur
SampleSequence angeben durch
|H|
∑
Rges = O(N m ) = O(nm²).
i=1
i
2
Berechnen wir jetzt die Komplexität der Prozedur SampleWHILE.
/HPPD
%HLP$XIUXIGHU3UR]HGXU6DPSOH:+,/(PLWGHQ3DUDPHWHUQ
$$%%9*+ZREHL$XQG$%HLVSLHODXVZHUWXQJHQHLQHV$XVGUXFNV%
XQG%%HLVSLHODXVZHUWXQJHQHLQHU$QZHLVXQJVVHTXHQ]9HLQH
9DULDEOHQOLVWH*HLQH$XVGUXFNXQG+HLQH$QZHLVXQJVVHTXHQ]KDWGLH
3UR]HGXUHLQH.RPSOH[LWlWLPVFKOHFKWHVWHQ)DOOYRQ2QPò'DEHLVHLQGLH
6XPPHGHU=DKOGHU=HLFKHQLQ$$%XQG%XQGP _9_
Beweis:
Die Rechenzeit der Prozedur SampleWHILE berechnet sich folgendermaßen:
Rges = Rexp + Rseq + Rtest + Rew
Dabei bedeuten:
Rges : Rechenzeit für die Prozedur
Rexp : Rechenzeit für den Aufruf der Prozedur SampleWExpression
Rseq : Rechenzeit für den Aufruf der Prozedur SampleWSequence
Rtest : Rechenzeit für die erste für-Schleife (Vergleich der Anfangswerte der
Variablen in X mit den Endwerten der Variablen in X.
Rew : Rechenzeit für das Eintragen der Endwerte der Variablen in X in die
Variablenliste V.
(vollständige Induktion)
Induktionsverankerung:
B und B' enthalten jetzt keine test-Konstrukte.
Nach Lemma 5.5.6 ist der Aufwand für den Aufruf der Prozedur
SampleWExpression abzuschätzen durch
Rexp = O(|A| (max(|V|,|X)²)|.
Für den Aufruf der Prozedur SampleWStatementSequence kann das Lemma
5.5.7 verwendet werden, und es gilt
Rseq = O(|B| (max(|V|,|X|)²)
Die erste für-Schleife wird |X|-mal durchlaufen. Der Aufwand für einen
Schleifendurchlauf resultiert vor allem aus dem Suchen in der Variablenliste
V. Deswegen kann der Aufwand abgeschätzt werden durch O(|V|). Dann gilt
für Rtest:
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Rtest = O(|V| |X|)
Vollkommen analog gilt für die zweite für-Schleife:
Rew = O(|V| |X|)
Wir benötigen die Feststellung, daß es für jede Variablen in X eine Variable
in V gibt. Dann gilt |V| ≥ |X|. Damit vereinfacht sich der Ausdruck für Rges:
Rges = O(|A| m²) + O(|B| m²) + O(m²) + O(m²) = O((|A|+|B|)m²)
Es gilt |A| + |B| ≤ |A| + |B| + |A'| + |B'| = n. Somit ist auch O(nm²) eine
obere Schranke für die Rechenzeit der Prozedur SampleWHILE.
Induktionsvoraussetzung:
B und B' seien Beispielauswertungen einer Anweisungssequenz mit einer
Schachtelungstiefe kleiner gleich d∈©. Dann beträgt der Aufwand für die
Prozedur SampleWHILE O(nm²).
Induktionsbehauptung:
B und B' seien Beispielauswertungen einer Anweisungssequenz der
Schachtelungstiefe d+1. Dann beträgt der Aufwand für die Prozedur
SampleWHILE O(nm²).
Induktionsschritt:
Analog zur Induktionsverankerung erhalten wir:
Rexp = O(|A| (max(|V|,|X)²)|.
Rtest = O(|V| |X|)
Rew = O(|V| |X|)
Für die Berechnung der Rechenzeit der Prozedur
SampleWStatementSequence können wir das Lemma 5.5.8 verwenden, denn
die Voraussetzungen, die in diesem Lemma für die Prozedur SampleWHILE
verlangt werden, werden bereits durch die Induktionsvoraussetzung erfüllt.
Dann erhalten wir die Abschätzung
Rseq = O(nB (max(|V|,|X|)²)),
wobei nB die Summe der Zahl der Zeichen in B und B' ist. Unter Benutzung
der Beziehung |V| ≥ |X| erhalten wir folgenden Ausdruck für Rges:
Rges = O(|A| m²) + O(nB m²) + O(m²) + O(m²) = O((|A|+nB)m²)
Dies können wir wieder durch O(nm²) abschätzen.
Als nächstes schauen wir die Rechenzeit für die Prozedur SampleSequence an.
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
/HPPD
'LH3UR]HGXU6DPSOH6HTXHQFHZHUGHDXIJHUXIHQPLWGHQ3DUDPHWHUQ
79$ZREHL7HLQ%HLVSLHODXVZHUWXQJVIUDJPHQW9HLQH9DULDEOHQOLVWHXQG
GLH$XVJDEHJU|‰H$HLQH$QZHLVXQJVVHTXHQ]LVW
6HLQGLH=DKOGHU=HLFKHQLQ$XQGP _9_VRNDQQGLH.RPSOH[LWlWGHU
3UR]HGXULPVFKOHFKWHVWHQ)DOOEHVFKULHEHQZHUGHQGXUFK2QPò
Beweis:
Die Rechenzeit für die Prozedur SampleSequence hängt maßgeblich von der
Rechenzeit zur Abarbeitung der äußeren solange-Schleife ab. Gemäß des
Beweises von Lemma 5.4.15 wird die äußere solange-Schleife in |A| Schritten
abgearbeitet. Sei Ri für i∈{1,..,|A|} die Rechenzeit im i-ten Schleifendurchlauf.
Dann läßt sich die Komplexität für die Prozedur durch den folgenden Ausdruck
abschätzen:
Rges =
|A|
∑ R i
i=1
Betrachten wir also die Rechenzeit für den i-ten Schleifendurchlauf.
Falls das im i-ten Schleifendurchlauf gelesene Element t eine Zeichenkette, ein
Wort oder ein Sonderzeichen ist, so wird der Schleifendurchlauf sofort beendet.
Falls das im i-ten Schleifendurchlauf gelesene Element t eine Variable, ein
Inkrement oder ein Dekrement ist, so ist der Aufwand für den i-ten
Schleifendurchlauf im wesentlichen durch den Zugriff auf die Variablenliste V
bestimmt. Deswegen kann man als Komplexität O(m) angeben.
Falls t ein test-Konstrukt ist, so ist es das erste einer Folge von test-
Konstrukten der Auswertung eines while-Konstruktes, etwa
test C 1 do D 1 end test
test C 2 do D 2 end test
...
test C r do D r end test
oder der Folge
test C 1 do D 1 end test
test C 2 do D 2 end test
...
test C r do D r end test
test C r+1 skip
Dabei sei r > 2 und C1,..,Cr+1 Beispielauswertungen des Ausdrucks des while-
Konstruktes und D1,..,Dr Beispielauswertungen der Anweisungssequenz des
Ausdrucks. t ist folglich das erste while-Konstrukt und die darauf gelesene
Element u das zweite while-Konstrukt der Folge. Für den Aufruf der Prozedur
SampleWHILE gilt nach Lemma 5.5.9 die Aufwandsabschätzung O(n1/2m²),
wobei n1/2 die Summe der Zahl der Zeichen in C1, C2, D1 und D2 ist.
Nach Lemma 5.4.15 wird die innere solange-Schleife (r-2)-mal durchlaufen,
wobei in jedem Schleifendurchlauf ein weiteres test-Konstrukt von T gelesen
wird und die Prozedur TestWHILE aufgerufen wird. Falls im Schleifendurchlauf
das j-te test-Konstrukt gelesen wird, so gilt nach Lemma 5.5.4 für die
Komplexität des Schleifendurchlaufs im schlechtesten Fall O(njm), falls nj die
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Summe der Zahl der Zeichen in Cj und Dj bedeutet. Dann liegt die Komplexität
der inneren solange-Schleife bei
r
∑
j=3
O(n m)
i
Der Aufwand für den anschließenden Aufruf der Prozedur TestWExpression, von
dem wir bei der Betrachtung des schlechtesten Falles ausgehen müssen, liegt
gemäß Lemma 5.5.1 bei O(|Cr+1| m).
Die Gesamtkomplexität des Schleifendurchlaufs wird dann durch den folgenden
Ausdruck beschrieben:
r
∑
O(n1/2m²) + O(n m) + O(|Cr+1| m).
j=3
i
Schätzen wir diesen Ausdruck nach oben ab und führen wir die Bezeichnungen
n1 für die Summe der Zahl der Zeichen in C1 und D1, sowie n2 für die Summe der
Zahl der Zeichen in C2 und D2 ein, so erhalten wir die gewünschte Beziehung für
Ri
r
∑
2
Ri = O(n m ) = O(n'm²),
j=1
i
wobei n' die Summe der Zahl der Zeichen in der Folge der test-Konstrukte.
Dann können wir für die Gesamtkomplexität der Prozedur den Ausdruck
Rges =
|A|
R i
i=1
∑ = O(nm²)
im schlechtesten Fall angeben.
Nun können wir die Komplexität des Algorithmus SampleProgram bestimmen.
6DW]
'HU$OJRULWKPXV6DPSOH3URJUDPZHUGHDXIJHUXIHQPLWGHQ3DUDPHWHUQ
63ZREHL6HLQH%HLVSLHODXVZHUWXQJXQG3HLQ3URJUDPPLVW6HLQGLH
=DKOGHU=HLFKHQLQ3XQGPGLH=DKODOOHULQ3YRUNRPPHQGHQ9DULDEOHQ
'DQQOLHJWGLH.RPSOH[LWlWI UGHQ$OJRULWKPXVLPVFKOHFKWHVWHQ)DOOEHL
2QPò
Beweis:
Sei Rges die Komplexität des Algorithmus SampleProgram. Dann berechnet sie
sich folgendermaßen:
Rges = REV + Rseq + RGV + RAV
Dabei bedeuten
REV : Zeitbedarf für das Eintragen der Eingabevariablen
Rseq : Zeitbedarf für den Aufruf der Prozedur SampleSequence
RGV : Zeitbedarf für die Generierung der Hauptinitialisationssequenz
RAV : Zeitbedarf für das Suchen der Ausgabevariablen
6HLWH

$XWRPDWLVFKH6\QWKHVHYRQ.ODVVH,3URJUDPPHQ
Wir wissen, daß alle in P vorkommenden Variablen, in der Variablenliste V
enthalten sind. Für REV ist deshalb sicherlich O(m) eine obere Schranke, ebenso
für RAV. Für RGV können wir die Abschätzung O(m²) ansetzen.
Nach Lemma 5.5.10 gilt Rseq = O(n'm²), wobei n' die Zahl der Zeichen in der
Beispielauswertung der Hauptanweisungssequenz von S ist. Dann ist auch
O(nm²) eine obere Schranke für die Laufzeit im schlechtesten Fall. Dies ist dann
auch die Gesamtkomplexität Rges.
6DW]
'HU$OJRULWKPXV6DPSOH3URJUDPHQWVWHKHDXVGHP$OJRULWKPXV
6DPSOH3URJUDPLQGHPMHW]WI UGLH9HUZDOWXQJGHU9DULDEOHQOLVWHQDQVWDWW
OLQHDUHU/LVWHQDXVEDODQFLHUWH6XFKElXPHHLQJHVHW]WZHUGHQ'HU
$OJRULWKPXV6DPSOH3URJUDPZHUGHDXIJHUXIHQPLWGHQ3DUDPHWHUQ63
ZREHL6HLQH%HLVSLHODXVZHUWXQJXQG3HLQ3URJUDPPLVW6HLQGLH=DKOGHU
=HLFKHQLQ3XQGPGLH=DKODOOHULQ3YRUNRPPHQGHQ9DULDEOHQ'DQQOLHJW
GLH.RPSOH[LWlWI UGHQ$OJRULWKPXVLPVFKOHFKWHVWHQ)DOOEHL2QOGPò
Beweis:
Aus dem Beweis von Lemma 5.5.1 ist ersichtlich, daß der Faktor m im Ausdruck
für die Komplexität durch das Suchen in Variablenlisten herrührt. Durch den
Ersatz der linearen Listen durch ausbalancierte Suchbäume verbessert sich der
Aufwand für das Auffinden einer Variablen von O(m) zu O(ld m).
Bemerkung:
Es stellt sich die Frage, ob die Rechenzeit im schlechtesten Fall noch weiter gesenkt werden
kann, zumal unsere Abschätzungen im Beweis von Satz 5.5.1 recht grob waren.
Zum einem haben wir als Länge der Variablenliste V immer dieselbe Zahl angenommen,
nämlich die Gesamtzahl aller Variablen im Programm, obwohl die Variablenliste V während
des Programmlaufs wächst. Für eine worst-case-Betrachtung müssen wir aber davon
ausgehen, daß V maximale Länge hat, d.h. die Länge der Variablenliste ist gleich der Zahl der
Variablen im Programm.
Zum zweiten stellt sich die Frage, warum wir unsere Abschätzungen (fast) immer mit der Zahl
der Zeichen vorgenommen haben, während die Operationen in den Prozeduren, nach denen wir
ja unsere Rechenzeit messen, sich auf die Elemente in den Beispielauswertungsfragmenten,
Ausdrücken und Anweisungssequenzen beziehen. Im schlechtesten Fall fallen beide
Betrachtungsweisen zusammen, da man davon ausgehen kann, daß die Elemente minimale
Länge haben. Außerdem dürfen wir nicht vergessen, daß wir jedes Zeichen der Eingabe
mindestens einmal lesen müssen.
Bemerkung:
Im besten Fall kann die Rechenzeit unseres Algorithmus' mit O(n) abgeschätzt werden (nur
eine Variable im Programm). Eine weitere Reduzierung ist nicht möglich, da jedes Element der
Eingabe gelesen werden muß.
Die durchschnittliche Rechenzeit muß leider wieder mit O(nm²) bzw. O(n(ld m)²) abgeschätzt
werden, für eine genauere Abschätzung wäre eine Statistik über den Aufbau von while-
Programmen notwendig.
Es stellt sich die Frage nach einem Vergleich mit einem laufzeitoptimalem
Synthesealgorithmus. Sicherlich muß ein solcher Algorithmus jedes Element der Eingabe
lesen, wozu O(n) Operationen nötig sind. Sicherlich muß eine Variablenliste geführt werden.
Es ist eine Vermutung, daß hierfür ein Aufwand von O((ld m)²) Operationen im schlechtesten
Fall notwendig ist. Damit läge die Komplexität eines optimalen Algorithmus' bei O(n(ld m)²).
6HLWH

:HLWHUH3URJUDPPNODVVHQ
6 Weitere Programmklassen
In diesem Kapitel wollen wir diskutieren, inwiefern die Beschränkung der Eingabemenge für
den Synthesealgorithmus auf Klasse-I-Beispielauwertungen eine Einschränkung der Menge
der lernbaren Funktionen darstellt. Ausgehend von dieser Analyse wollen wir Lösungsansätze
angeben, wie der Synthesealgorithmus abgeändert werden kann, so daß die Einschränkungen
aufgehoben werden können und somit die Lernpotenz des Synthesealgorithmus' vergrößert
wird.
6.1 Einschränkungen für Klasse-I-Programme
Fassen wir noch einmal zusammen, welche Bedingungen für Klasse-I-Programme und Klasse-
I-Beispielauswertungen gelten (nach Definition 5.2.1 und Definition 5.2.2):
$(VG UIHQNHLQH]ZHLZKLOH.RQVWUXNWHGLUHNWDXIHLQDQGHUIROJHQ
% (VNRPPHQNHLQHORNDOHQ9DULDEOHQYRU
&'DVHUVWH9RUNRPPHQHLQHU9DULDEOHQLQGHU+DXSWDQZHLVXQJVVHTXHQ]
GHV3URJUDPPHVGDUIQLFKWLQQHUKDOEHLQHV,QNUHPHQWHVRGHU
'HNUHPHQWHVVHLQ
''DVHUVWH9RUNRPPHQHLQHU9DULDEOHQLQHLQHPZKLOH.RQVWUXNWGDUI
QLFKWLQQHUKDOEHLQHV,QNUHPHQWHVRGHU'HNUHPHQWHVVHLQ
( ) UMH]ZHL9DULDEOHQLQHLQHPZKLOH.RQVWUXNWPX‰GLH'LIIHUHQ]
]ZLVFKHQLKUHQ:HUWHLQGHUHUVWHQ(QWIDOWXQJLQGHU]ZHLWHQ(QWIDOWXQJ
YHUVFKLHGHQVHLQ
) 'LH9DULDEOHLQHLQHP'HNUHPHQWGDUILQGHU$QZHLVXQJYRUGHP
'HNUHPHQWQLFKWGHQ:HUWKDEHQ
*,QMHGHU$QZHLVXQJDX‰HUKDOEHLQHVZKLOH.RQVWUXNWHVPX‰GLH'LIIHUHQ]
GHU:HUWH]ZHLHU9DULDEOHQPLQGHVWHQVEHWUDJHQ
A) Es dürfen keine zwei while-Konstrukte direkt aufeinanderfolgen.
Dies ist keine Einschränkung der Lernpotenz, es erinnert an eine ähnliche Regelung in
Sprachen wie Pascal. Der Grund für diese Regel ist, daß wir dann immer wissen, daß zwei
aufeinanderfallende test-Konstrukte zur Auswertung desselben while-Konstruktes gehören. Es
mag jetzt verwundern, warum wir diese Regel eingeführt haben, wo wir doch eine Prozedur
(TestWHILE) haben, deren Zweck es ist, zu erkennen, ob ein test-Konstrukt
Beispielauswertung eines while-Konstruktes ist oder nicht. Betrachten wir dazu die folgende
Beispielauswertung:
input (1)
test 3 < 4 do 5 6 4 end test
test 4 < 6 do 7 8 5 end test
test 5 < 8 do 9 10 6 end test
test 6 < 10 do 11 12 7 end test
output 1
6HLWH

:HLWHUH3URJUDPPNODVVHQ
So kann kein Synthesealgorithmus unterscheiden, ob diese Zeichenfolge durch Auswertung
des folgenden Programmes
input (x)
set (y := 3)
set (z := 4)
with while y < z do ++z ++z ++y end while
output x
oder dieses Programmes
input (x)
set (y := 3)
set (z := 4)
with while y < z do ++z ++z ++y end while
with while y < z do ++z ++z ++y end while
output x
gebildet wurde.
B) Es kommen keine lokalen Variablen vor
Dies ist eine starke Einschränkung der Ausdrucksfähigkeit unsere Sprache. Wegen dieser
Einschränkung kann das folgende Programm nicht vom Synthesealgorithmus generiert werden:
input (a,b)
set (s := 0)
with
while a > 0 do
with
set (c := b)
while c > 0 do
--c
++s
end while
--a
end while
output s
Eine Methode zur Aufhebung dieser Einschränkung wird in Kapitel 6.2 diskutiert.
C) Das erste Vorkommen einer Variablen in der Hauptanweisungssequenz des Programmes
darf nicht innerhalb eines Inkrementes oder Dekrementes sein.
Dies stellt keine Einschränkung der Menge der lernbaren Funktionen dar. Ohne diese
Forderungen sind die folgenden beiden Programme als Eingabe erlaubt, können aber anhand
ihrer Beispielauswertung nicht unterscheiden werden. Sie sind allerdings ähnlich.
6HLWH

:HLWHUH3URJUDPPNODVVHQ
input (x)
set (z := 1)
z
output z
und
input(x)
set (z := 0)
++z
output z
D) Das erste Vorkommen einer Variablen in einem while-Konstrukt des Programmes darf
nicht innerhalb eines Inkrementes oder Dekrementes sein.
Auch diese Forderung stellt keine Einschränkung in der Menge der lernbaren Funktionen dar.
Sie kann außerdem leicht umgangen werden. Dazu ist nur eine leichte Modifikation im
Synthesealgorithmus notwendig. Betrachten wir zuerst ein Beispiel:
input (x)
set (z := 10)
with
while z > 0 do
++x
--z
end while
output x
Dieses Programm kann jederzeit durch das folgende Klasse-I-Programm ersetzt werden:
input (x)
set (z := 10)
set (y := 0)
with
while z > y do
x
++x
--z
end while
output x
6HLWH

:HLWHUH3URJUDPPNODVVHQ
Betrachten wir jetzt eine Beispielauswertung des ersten Programmes:
input (17)
test 10 > 0 do
18
9
end test
test 9 > 0 do
19
8
end test
test 8 > 0 do
20
7
end test
output 20
Die Prozedur SampleWHILE wird aber das folgende while-Konstrukt generieren:
with
while v0 > v1 do
v2
--v0
end while
Der Inhalt der Variablenliste V ist dann:
v0 Anfangswert 10 Endwert 9
v1 Anfangswert 0 Endwert 0
v2 Anfangswert 18 Endwert 18
Der Inhalt der Variablenliste X ist dann:
v0 Anfangswert 9 Endwert 8
v1 Anfangswert 0 Endwert 0
v2 Anfangswert 19 Endwert 19
Die Prozedur SampleWHILE wird dann beim Vergleich der Variablenlisten eine Fehler
melden, da der Anfangswert der Variablen v2 in X nicht mit dem Endwert der Variablen v2 in
V übereinstimmt. An dieser Stelle könnte der Synthesealgorithmus verbessert werden. Eine
Abweichung des Wertes einer Variablen zwischen zwei Entfaltungen eines while-Konstruktes
um den Wert 1 kann nur bedeuten, daß der Wert der Variablen bei ihrem ersten Vorkommen
in um den Wert 1 erhöht worden ist. Also muß an der Position des ersten Vorkommens der
Variablen ein Inkrement stehen (entsprechend muß an der Position des ersten Vorkommens der
Variablen ein Dekrement stehen, wenn der Wert der Variablen zwischen zwei Durchläufen um
den Wert 1 vermindert worden wäre). Der verbesserte Synthesealgorithmus' muß jetzt an der
Position des ersten Vorkommen der Variable v2 im bereits fertig generierten while-Konstrukt
die Anweisung v2 durch die Anweisung ++v2 ersetzen. Damit erhält die Prozedur das richtige
while-Konstrukt
6HLWH

:HLWHUH3URJUDPPNODVVHQ
with
while v0 > v1 do
++v2
--v0
end while
für die gegebene Beispielauswertung. Entsprechend muß der Anfangswert der Variable v2 in
der Variablenliste V um den Wert 1 erniedrigt werden. Der neue Anfangswert ist also 17, was
auch dem Anfangswert der Variablen x bei der Bildung der Beispielauswertung entspricht.
Es stellt sich die Frage, warum diese Verbesserung nicht in den Synthesealgorithmus
eingebracht wurde. Der eine Grund ist der, daß der Verzicht auf die Erweiterung zur
Einschränkung D) geführt hat, die aber die eigentliche Lernpotenz des Algorithmus' nicht
schmälert. Der zweite Grund ist, daß wir bei dem Beweis des Korrektheitssatzes 5.4.1 immer
indirekt eine Konsistenzbedingung vorausgesetzt haben: Nach dem Lesen der ersten n Zeichen
der Eingabebeispielauswertung ist das Anfangsfragment der ersten n Zeichen ein
Beispielauswertungsfragment des bis hierhin konstruierten Anfangsfragment des Programmes.
Das heißt, der Synthesealgorithmus macht keine Fehler. Wenn ein Teil des Programmes
fertiggestellt ist, so ist es korrekt. Im Falle des verbesserten Synthesealgorithmus müssen wir
die Konsistenzbedingung fallenlassen: Das generierte while-Konstrukt kann richtig sein oder
falsch. Dann läßt sich die Korrektheit des Algorithmus' mit den im vorigen Kapitel
angewandten Methoden nicht zeigen.
E) Für zwei verschiedene Variablen in einem while-Konstrukt muß die Differenz zwischen
ihren Werten in der ersten Entfaltung und in der zweiten Entfaltung verschieden sein.
Diese Einschränkung ist sicher etwas streng, sie vereinfacht jedoch die Wirkungsweise des
Synthesealgorithmus'. Es ist klar, daß diese Bedingung die Lernpotenz einschränkt, denn sie
verbietet Programme wie das folgende:
input (x)
set (z := 10)
with
while z > 0 do
--z
x
--x
end while
output x
Der Grund für diese Bedingung ist es, daß in der Auswertung eines while-Konstruktes zwei
verschiedene Variablen als verschieden erkannt werden. Diese Forderung ist einer der
Hauptgründe warum ein solch positives Resultat wie der Satz 5.4.2 zustande kommen. Aus
der folgenden Beispielauswertung wird der Synthesealgorithmus das ursprüngliche Programm
wieder erzeigen können:
6HLWH

:HLWHUH3URJUDPPNODVVHQ
input (100)
test 10 > 0 do
9
100
99
end test
test 9 > 0 do
8
99
98
end test
output 98
Jedoch dürften die meisten Synthesealgorithmen bei der folgenden Beispielauswertung
scheitern:
input (10)
test 10 > 0 do
9
10
9
end test
test 9 > 0 do
8
9
8
end test
output 8
Der Grund für diese Schwierigkeit ist, daß die zweite Beispielauswertung auch
Beispielauswertung des folgenden Programmes ist:
input (x)
with
while x > 0 do
--x
++x
--x
end while
Die beiden Programme sind nicht ähnlich, das heißt ein Synthesealgorithmus, der beide
Programme generieren muß, kann nicht korrekt arbeiten, da er aus einer korrekten
Beispielauswertung nicht unterscheiden kann, zu welcher Äquivalenzklasse von Algorithmen
diese Auswertung gehört.
Ein Ausweg wäre sicherlich, eine Bedingung zu finden, die Beispielauswertungen ausschließt,
die zu unlösbaren Problemen führen. Eine solche Bedingung dürfte aber die Lernpotenz des
Synthesealgorithmus nicht mehr einschränken, als sie durch die Bedingung E) eingeschränkt
wird. Eine solche Bedingung für die Menge der zugelassenen Beispielauswertungen zu finden,
ist dem Autor dieser Arbeit bisher nicht gelungen.
6HLWH

:HLWHUH3URJUDPPNODVVHQ
F) Die Variable in einem Dekrement darf in der Anweisung davor nicht den Wert 0 haben.
Dies ist im Zusammenhang mit der Bedingung E) zu sehen. Die Bedingung stellt keine
Einschränkung in der Lernpotenz dar, denn das Dekrement einer Variable, die bereits den
Wert 0 hat, macht keinen Sinn. Der Algorithmus berücksichtigt die Möglichkeit des
Dekrementes einer Variablen mit dem Wert 0, sofern dies erkannt werden kann. Dies ist im
Fall des folgenden Programmes
input (x)
set (y := 3)
with
while y > 0 do
x
--x
--x
--y
end while
output x
möglich für die Eingabe
input (20)
test 3 > 0 do
20
19
18
2
end test
test 2 > 0 do
18
17
16
1
end test
test 1 > 0 do
16
15
14
0
end test
test 0 > 0 do
14
13
12
0
end test
output 12
Bei diesem Beispiel kann das vierte test-Konstrukt als Teil der Entfaltung des while-
Konstruktes interpretiert werden, da bekannt ist, daß die Variable y am Ende der dritten
Entfaltung den Wert 0 hat. Betrachten wir jetzt zum selbigen Programm eine andere
Beispielauswertung:
6HLWH

:HLWHUH3URJUDPPNODVVHQ
input (0)
test 3 > 0 do
0
0
0
2
end test
test 2 > 0 do
0
0
0
1
end test
Die Nullen in der Auswertung der Anweisungssequenz des while-Konstruktes sind nicht als
Ergebnisse eines Dekrementes zu erkennen.
G) In jeder Anweisung außerhalb eines while-Konstruktes muß die Differenz der Werte zweier
Variablen mindestens 3 betragen.
Diese Bedingung dient zum Identifizieren von Variablen in einer Beispielauswertung und ist
für die Gültigkeit des Satzes 5.4.2 erforderlich. Wir können außerhalb der Auswertung eines
while-Konstruktes eine Variablen nicht an der Differenz ihrer Werte zwischen zwei
Entfaltungen erkennen. Betrachten wir jetzt einen Wert in einer Beispielauswertung außerhalb
jedes test-Konstruktes. Sei c dieser Wert. Der Wert c kann jetzt der Wert einer Variablen mit
dem Wert c vor der Auswertung der Anweisung sein, der Wert einer Variablen mit dem Wert
c+1 vor der Auswertung eines Dekrementes oder der Wert einer Variablen mit dem Wert c-1
vor der Auswertung eines Inkrementes sein. Um den Wert also eindeutig einer Variablen
zuzuordnen, darf also keine zweite Variable existieren, deren Wert sich um weniger als 3 vom
Wert der ersten Variablen unterscheidet. Betrachten wir dazu das folgende Beispiel: Gegeben
sei das Klasse-I-Programm
input (x)
set (a := 2)
set (b := 5)
a
x
++x
b
output b
Dann ist die folgende Beispielauswertung des Programmes als Eingabe nicht erlaubt:
input (3)
2
3
4
5
output 5
6HLWH

:HLWHUH3URJUDPPNODVVHQ
Schauen wir uns ein nicht so leicht einsichtiges Beispiel an. Betrachten wir das folgende
Programm:
input (x)
set (a := 1)
with
while a do
++a
end while;
with
while x do
--x
end while
--x
output x
Auch für dieses Programm gibt es eine Beispielauswertung, die zu Problemen führt:
input (7)
test 1 do 2 end test
test 2 do 3 end test;
test 7 do 6 end test
test 6 do 5 end test
4
output 4
Kein Synthesealgorithmus kann unterscheiden, ob die Zahl 4 zur Anweisung --x oder zur
Anweisung ++a gehört.
Die Bedingung G) führt leider zu einer Einschränkung der Lernpotenz.
6.2 Lokale Variablen
Die Zulassung lokaler Variablen in einem while-Konstrukt wäre eine große Verbesserung der
Lernpotenz des Synthesealgorithmus. Prüfen wir zuerst, wie der Verzicht auf die Verwendung
der Bedingung B) für Klasse-I-Programme sich auf die Korrektheit des Synthesealgorithmus'
auswirkt. Wir definieren dazu eine Klasse von Algorithmen, die dieselben Einschränkungen
wie die Klasse-I besitzt, in der jedoch lokale Variablen zugelassen sind.
'HILQLWLRQ
3KHL‰W.ODVVH,,3URJUDPPZHQQIROJHQGH%HGLQJXQJHQHUI OOWVLQG
(VG UIHQNHLQH]ZHLZKLOH.RQVWUXNWHGLUHNWDXIHLQDQGHUIROJHQ
'DVHUVWH9RUNRPPHQHLQHU9DULDEOHQLQGHU+DXSWDQZHLVXQJVVHTXHQ]
YRQ3GDUIQLFKWLQQHUKDOEHLQHV,QNUHPHQWHVRGHU'HNUHPHQWHVVHLQ
'DVHUVWH9RUNRPPHQHLQHU9DULDEOHQLQHLQHPZKLOH.RQVWUXNWGDUI
QLFKWLQQHUKDOEHLQHV,QNUHPHQWHVRGHU'HNUHPHQWHVVHLQ
) UMH]ZHL9DULDEOHQLQHLQHPZKLOH.RQVWUXNWPX‰GLH'LIIHUHQ]
]ZLVFKHQLKUHQ:HUWHLQGHUHUVWHQ(QWIDOWXQJLQGHU]ZHLWHQ(QWIDOWXQJ
YHUVFKLHGHQVHLQ
6HLWH

:HLWHUH3URJUDPPNODVVHQ
'HILQLWLRQ
(LQH%HLVSLHODXVZHUWXQJHLQHV.ODVVH,,3URJUDPPHVKHL‰W.ODVVH,,
%HLVSLHODXVZHUWXQJZHQQIROJHQGH%HGLQJXQJHQHUI OOWVLQG
'LH9DULDEOHLQHLQHP'HNUHPHQWGDUILQGHU$QZHLVXQJYRUGHP
'HNUHPHQWQLFKWGHQ:HUWKDEHQ
,QMHGHU$QZHLVXQJDX‰HUKDOEHLQHVZKLOH.RQVWUXNWHVPX‰GLH'LIIHUHQ]
GHU:HUWH]ZHLHU9DULDEOHQPLQGHVWHQVEHWUDJHQ
Resultat 1:
Sei P ein Klasse-II-Programm und S eine Klasse-II-Beispielauswertung von P. Jedes while-
Konstrukt in P, das eine lokale Initialisationssequenz enthält, ist lokale Anweisung der
Hauptanweisungssequenz von P. Dann liefert der Algorithmus' SampleProgram ein
Programm Q und es gilt P ≅ Q. (d.h. der Satz 5.4.1 hat Gültigkeit).
Der Grund für dieses Resultat ist klar: Verschiebt man die Deklaration der lokalen Variablen
in P in die Hauptinitialisationssequenz, so erhält man ein zu P ähnliches Programm R. Das
Programm R ist aber dann ein Klasse-I-Programm, und S ist eine Klasse-I-Beispielauswertung
von R. Nach Satz 5.4.1 liefert der Algorithmus SampleProgram dann ein zu R ähnliches
Programm Q, und es gilt nach Lemma 3.5.1 auch P ≅ Q.
Was passiert aber, wenn lokale Variablen in einem while-Konstrukt initialisiert werden, das
nicht Anweisung in der Hauptanweisungssequenz ist. Betrachten wir dazu das Beispiel des
folgenden Klasse-II-Programmes P und das Klasse-I-Programm P':
input (x)
set (y := 10)
with
while y > 0 do
with
set (z := y)
while z > 0 do
x
++x
--z
end while
--y
end while
output x
input (x)
set (y := 10)
with
while y > 0 do
with
while y > 0 do
x
++x
--y
end while
++y
end while
output x
Dann ist jedem einsichtig, daß P und P' nicht ähnlich sind. Betrachten wir jetzt die
Beispielauswertungen A und S' von P und P':
6HLWH

:HLWHUH3URJUDPPNODVVHQ
input (1)
test 10 > 0 do
test 10 > 0 do
1
2
9
end test
test 9 > 0 do
2
3
8
end test
9
end test
test 9 > 0 do
test 10 > 0 do
3
4
9
end test
test 9 > 0 do
4
5
8
end test
8
end test
output 5
0 do
1
2
9
end test
test 9 > 0 do
2
3
8
end test
9
end test
test 9 > 0 do
test 9 > 0 do
3
4
8
end test
test 8 > 0 do
4
5
7
end test
8
end test
output 5

:HLWHUH3URJUDPPNODVVHQ
Dies ist eine richtige Lösung für eine konstantenbereinigte Form von P'. Die inneren
Entfaltungen der zweiten äußeren Entfaltung unterscheiden sich zwischen S und S'. Hier
könnte der Synthesealgorithmus erkennen, daß die Variable im Ausdruck des inneren while-
Konstruktes nicht die Variable im Ausdruck des äußeren while-Konstruktes ist, da die Werte
nicht übereinstimmen, wenn der Prozedur SampleWSequence, die aus den ersten beiden
inneren Entfaltungen ein while-Konstrukt generieren soll, eine vollständige Variablenliste
übergeben werden könnte, was aber nicht geht, da die Werte der Variablen nicht bekannt sind.
Deshalb liefert die Prozedur die folgende Lösung für beide Eingaben:
with
while y0 < y1 do
y2
++y2
--y0
end while
Die Variablenliste Y hat für die Eingabe S den Inhalt:
y0 Anfangswert 10 Endwert 8
y1 Anfangswert 0 Endwert 0
y2 Anfangswert 3 Endwert 5
Für die Eingabe S' hat die Variablenliste Y den folgenden Inhalt:
y0 Anfangswert 9 Endwert 7
y1 Anfangswert 0 Endwert 0
y2 Anfangswert 3 Endwert 5
Wir sehen, daß unser Synthesealgorithmus wiederum nur für die Eingabe S' eine richtige
Lösung generiert. Beachten wir jetzt noch die Variablenliste X, die die Werte aller Variablen
im Ausdruck der zweiten Entfaltung enthält (für beide Eingaben):
v0 Anfangswert 8 Endwert 9
v1 Anfangswert 0 Endwert 0
Für die Eingabe S' liefert der Synthesealgorithmus als korrekte Lösung ein zu P' ähnliches
Programm. Für die Eingabe S bricht die Prozedur MatchWHILE den Algorithmus mit
Fehlermeldung ab, denn die Variable v0 entspricht der Variablen y0 im Ausdruck der while-
Konstruktes. Der letzte Wert der Variablen v0 vor der Auswertung des inneren while-
Konstruktes in der zweiten äußeren Entfaltung ist aber 9, der erste Wert von y0 in der
Auswertung des inneren while-Konstruktes ist aber 10. Damit erkennt die Prozedur
MatchWHILE zurecht, daß die Eingabe S keine Klasse-I-Beispielauswertung ist.
Es stellt sich jetzt die Frage, ob die Prozedur MatchWHILE das Auftreten einer lokalen
Variablen immer entdecken kann. Wir können uns dabei auf lokale Variablen von while-
Konstrukten beschränken, die selbst in einem Anweisung in einem while-Konstrukt sind, da
lokale while-Konstrukte der Hauptanweisungssequenz gemäß Resultat 1 keine Problem
bereiten. Der Anfangswert einer lokalen Variablen wird vor dem ersten Schleifendurchlauf in
allen Entfaltungen des umgebenen while-Konstruktes immer gleich sein. Also kann eine lokale
Variable von einer zu einem while-Konstrukt globalen Variablen unterschieden werden, wenn
der Wert der Variablen sich ändert, denn dann ist der Wert der nicht-lokalen Variablen
verschieden in den verschiedenen Auswertungen. Ist dies nicht der Fall, so kann aber auch in
6HLWH

:HLWHUH3URJUDPPNODVVHQ
den Beispielauswertungen nicht zwischen der lokalen und der globalen Variablen
unterschieden werden, und die sich ergebenden Programme sind ähnlich.
In unserem Beispiel erkennen wir, daß die erste Variable im inneren while-Konstrukt eine
lokale Variable dieses while-Konstruktes sein muß. Wir können nun den Synthesealgorithmus
verbessern, indem wir folgende Änderungen einführen:
ì In Prozeduren werden lokalen Variablen der while-Konstrukte erlaubt.
ì Wird in der Prozedur MatchWHILE eine lokale Variable entdeckt, deren Anfangswert mit
dem Wert der Variablen v übereinstimmt, so erzeuge eine neue Variable, etwa w, ersetze
jedes Vorkommen von v im while-Konstrukt durch w, und führe w als globale Variable mit
Anfangswert v ein. Setze danach die Prozedur MatchWHILE fort.
Resultat 2 (Behauptung ohne Beweis):
Sei P eine Klasse-II-Programm, für das die folgende Bedingungen gelten: Wenn die Variable v
ist Anfangswert der lokalen Variablen w, so kommt v nicht im lokalen while-Konstrukt von w
vor. Außerdem kommt die Variable v im while-Konstrukt, in dem das lokale while-Konstrukt
lokal ist, vor Sei S eine Klasse-II-Beispielauswertung von P. Dann liefert der nach obiger
Anleitung verbesserte Algorithmus SampleProgram ein Programm zu P ähnliches Programm
Q.
Die Frage bleibt, warum diese Verbesserung nicht in den Algorithmus eingegangen ist:
1. Der verbesserte Algorithmus arbeitet nicht konsistent, man kann nicht entscheiden, ob die
bisher fertiggestellte Lösung korrekt ist oder noch nachträglich korrigiert werden muß.
Damit ist die in Kapitel 5.4 vorgestellte Beweisidee nicht anwendbar. Die Gültigkeit des
Satzes 5.4.1 ist damit offen.
2. Satz 5.4.2 gilt nicht.
3. Eine lokale Variable darf nicht gleichzeitig mit einer globalen Variablen verwendet werden,
die ihren Anfangswert bestimmt.
4. Jede Variable, die Anfangswert für eine lokale Variable ist, muß vor der Initialisation im
umgebenen while-Konstrukt vorkommen.
5. Die Komplexität verschlechtert sich auf.
Gehen wir auf diese Punkte genauer ein:
1. Der verbesserte Algorithmus arbeitet nicht konsistent.
Man kann nicht entscheiden, ob die bisher fertiggestellte Lösung korrekt ist oder noch
nachträglich korrigiert werden muß. Damit ist die in Kapitel 5.4 vorgestellte Beweisidee nicht
anwendbar. Die Gültigkeit des Satzes 5.4.1 ist damit offen.
2. Satz 5.4.2 gilt nicht.
Gegeben sei die folgende Eingabe:
input (7)
test do 7 end test
test do 7 end test
output 7
So kann der Synthesealgorithmus nicht zwischen zwei möglichen erzeugenden Programmen
unterscheiden:
6HLWH

:HLWHUH3URJUDPPNODVVHQ
input (x)
with
while do x end while
output x
input (x)
with
set (y := x)
while do y end while
output x
3. Eine lokale Variable darf nicht gleichzeitig mit einer globalen Variablen verwendet werden,
die ihren Anfangswert bestimmt.
In diesem Fall würde auch jedes Vorkommen der lokalen Variablen fälschlicherweise
abgeändert.
4. Jede Variable, die Anfangswert für eine lokale Variable ist, muß vor der Initialisation im
umgebenen while-Konstrukt vorkommen.
Gegeben sei das folgende Klasse-II-Programm:
input (x)
set (y := 1)
with
while do
with
set (z := x)
while x

:HLWHUH3URJUDPPNODVVHQ
Für dieses Programm existiert die folgende Beispielauswertung:
input (7)
test do
test 1

:HLWHUH3URJUDPPNODVVHQ
mit der Variablenliste V:
x0 Anfangswert 1 Endwert 3
x1 Anfangswert 7 Endwert 11
mit der Variablenliste Y:
y0 Anfangswert 3 Endwert 5
y1 Anfangswert 8 Endwert 12.
Beim Aufruf der Prozedur MatchWHILE ist die Variablenliste V leer. Es wird kein Fehler
erkannt. Die Variablenliste V erhält nach dem Aufruf die folgenden Werte:
v0 Anfangswert 3 Endwert 5
v1 Anfangswert 8 Endwert 12
Es wird also keine lokale Variable entdeckt. Die Prozedur SampleWHILE wird feststellen, daß
der Anfangswert der Variablen v1 in X nicht mit dem Endwert der Variablen v1 in V
übereinstimmt und den Algorithmus mit einer Fehlermeldung verlassen.
5. Die Komplexität verschlechtert sich.
Für das ersetzten jedes Vorkommens einer Variablen durch eine andere, muß ein Teil des
bereits erzeugten Programmes nochmals gelesen werden. Hierzu ist im schlechtesten Fall ein
Aufwand O(n) notwendig, wobei n die Länge der Eingabe ist. Dann hängt die Aufwand für die
Synthese aber nicht mehr linear, sondern quadratisch von der Größe der Eingabe ab.
6.3 IF-Konstrukte
Wir wollen jetzt die Syntax der Programme erweitern, indem wir eine if-Konstrukt einführen.
Dazu erweitern wir zuerst den Sprachumfang um die Schlüsselworte if und then und führen
folgende Syntax ein:
6HLWH

:HLWHUH3URJUDPPNODVVHQ
Tabelle 3 : Erweiterte Syntax der Sprache WHILE
3URJUDPPWH[W
(LQJDEH.RQVWUXNW
,QLWLDOLVDWLRQVVHTXHQ]
,QLWLDOLVDWLRQVNRQVWUXNW
%H]HLFKQHU
=DKO
$XVJDEH.RQVWUXNW
$QZHLVXQJVVHTXHQ]
$QZHLVXQJ
(LQIDFK$QZHLVXQJ
6WULQJ
,QNUHPHQW
'HNUHPHQW
ZKLOH.RQVWUXNW
$XVGUXFN
LI.RQVWUXNW
(LQJDEHNRQVWUXNW,QLWLDOLVDWLRQVVHTXHQ]$QZHLVXQJVVHTXHQ]
$XVJDEHNRQVWUXNW
"input" "("Ã>%H]HLFKQHU^","%H]HLFKQHU`@")"
^,QLWLDOLVDWLRQVNRQVWUXNW`
"set" "(" %H]HLFKQHU":=" %H]HLFKQHU_=DKO")"
%XFKVWDEH^%XFKVWDEH_=LIIHU`
=LIIHU^=LIIHU`
"output"%H]HLFKQHU
^$QZHLVXQJ`
(LQIDFK$QZHLVXQJ_,QNUHPHQW_'HNUHPHQW_ZKLOH.RQVWUXNW_LI.RQVWUXNW
%H]HLFKQHU_=DKO_6WULQJ_6RQGHU]HLFKHQ
^=LIIHU%XFKVWDEH6RQGHU]HLFKHQ7UHQQ]HLFKHQ`
"++"%H]HLFKQHU
"--"%H]HLFKQHU
"with",QLWLDOLVDWLRQVVHTXHQ]"while"$XVGUXFN"do"
$QZHLVXQJVVHTXHQ]"end while"
^(LQIDFK$QZHLVXQJ`
if$XVGUXFN"then"$QZHLVXQJVVHTXHQ]"end if"
Die Definitionen im Kapitel 2 gelten sinngemäß nach obiger Definition. Wir müssen nun die
Beispielauswertung eines if-Konstruktes definieren. Dazu erweitern wir Definition 3.1.1:
Die Entfaltung eines if-Konstruktes der Form
if A then B end if
wobei A ein Ausdruck und B eine Anweiungssequenz ist, ist entweder von der Form
test A do B end test (positive Form)
oder von der Form
test A skip (negative Form)
Die Definitionen über Werte von Programmen und Beispielauswertungen sind dann einfach
um die Entfaltung eines if-Konstruktes zu ergänzen. Solche Beispielauswertungen können
selbstverständlich auch automatisch erzeugt werden.
Wie wollen uns lieber mit der Frage beschäftigen, wie Programme mit if-Anweisungen
automatisch aus Beispielauswertungen synthetisiert werden können. Definieren wir dafür
einfach eine neue Programmklasse:
6HLWH

:HLWHUH3URJUDPPNODVVHQ
'HILQLWLRQ
(LQ:+,/(3URJUDPPGHUHUZHLWHUWHQ6\QWD[3KHL‰W.ODVVH,,,3URJUDPP
ZHQQIROJHQGH%HGLQJXQJHQHUI OOWVLQG
(VG UIHQNHLQH]ZHLZKLOH.RQVWUXNWHGLUHNWDXIHLQDQGHUIROJHQ
(VNRPPHQNHLQHORNDOHQ9DULDEOHQYRU
'DVHUVWH9RUNRPPHQHLQHU9DULDEOHQLQGHU+DXSWDQZHLVXQJVVHTXHQ]
YRQ3GDUIQLFKWLQQHUKDOEHLQHV,QNUHPHQWHVRGHU'HNUHPHQWHVVHLQ
'DVHUVWH9RUNRPPHQHLQHU9DULDEOHQLQHLQHPZKLOH.RQVWUXNWGDUI
QLFKWLQQHUKDOEHLQHV,QNUHPHQWHVRGHU'HNUHPHQWHVVHLQ
) UMH]ZHL9DULDEOHQLQHLQHPZKLOH.RQVWUXNWPX‰GLH'LIIHUHQ]
]ZLVFKHQLKUHQ:HUWHLQGHUHUVWHQ(QWIDOWXQJLQGHU]ZHLWHQ(QWIDOWXQJ
YHUVFKLHGHQVHLQ
(VG UIHQNHLQH]ZHLLI.RQVWUXNWHDXIHLQDQGHUIROJHQ
(VGDUINHLQZKLOH.RQVWUXNWDXIHLQLI.RQVWUXNWIROJHQ
(VGDUINHLQLI.RQVWUXNWDXIHLQZKLOH.RQVWUXNWIROJHQ
'HILQLWLRQ
(LQH%HLVSLHODXVZHUWXQJHLQHV.ODVVH,,,3URJUDPPHVKHL‰W.ODVVH,,,
%HLVSLHODXVZHUWXQJZHQQIROJHQGH%HGLQJXQJHQHUI OOWVLQG
'LH9DULDEOHLQHLQHP'HNUHPHQWGDUILQGHU$QZHLVXQJYRUGHP
'HNUHPHQWQLFKWGHQ:HUWKDEHQ
,QMHGHU$QZHLVXQJDX‰HUKDOEHLQHVZKLOH.RQVWUXNWHVPX‰GLH'LIIHUHQ]
GHU:HUWH]ZHLHU9DULDEOHQPLQGHVWHQVEHWUDJHQ
(LQLI.RQVWUXNWZHOFKHVQLFKWLQHLQHPZKLOH.RQVWUXNWHQWKDOWHQLVW
GDUIQXULQGHUSRVLWLYHQ)RUPHQWIDOWHWZHUGHQ
(LQLI.RQVWUXNWZHOFKHVORNDOH$QZHLVXQJHLQHVZKLOH.RQVWUXNWHVLVW
PX‰LQGHQHUVWHQEHLGHQ(QWIDOWXQJHQGHVZKLOH.RQVWUXNWHVSRVLWLY
HQWIDOWHWVHLQ
Die Entfaltung eines while-Konstruktes besteht aus mindestens zwei aufeinanderfolgenden
test-Konstrukten, während die Entfaltung eines if-Konstruktes nur aus einem isoliertem test-
Konstrukt bestehen darf (nach Punkten 6 -8 der Definition 6.3.1). Wir können damit die
Beispielauswertung eines test-Konstruktes exakt von der Beispielauswertung eines while-
Konstruktes unterscheiden. Betrachten wir zuerst den Fall, daß das if-Konstrukt lokale
Anweisung der Hauptanweisungssequenz des Programmes ist. Dann muß das if-Konstrukt
positiv entfaltet sein, etwa
test A do B end test
dabei ist A eine Beispielauswertung eines Ausdrucks und B eine Beispielauswertung einer
Anweisung. Man beachte, daß if-Konstrukte keine lokale Initialisationssequenz besitzen. Also
kann die Prozedur SampleSequence zur Analyse herangezogen werden.
Falls das if-Konstrukt lokale Anweisung eines while-Konstruktes ist, so wissen wir, daß es in
den ersten zwei Entfaltungen des while-Konstruktes positiv entfaltet ist. Es werden also in der
Prozedur SampleWSequence diese Entfaltungen des if-Konstruktes gelesen (man beachte, daß
sie als Entfaltungen eines if-Konstruktes identifiziert werden können):
test A 1 do B 1 end test
und
6HLWH

:HLWHUH3URJUDPPNODVVHQ
test A 2 do B 2 end test
Dabei sind A 1 und A 2 Beispielauswertungen des Ausdrucks des if-Konstruktes und B 1 und B 2
Beispielauswertungen der Anweisungssequenz des if-Konstruktes. Die Prozeduren
SampleWExpression und SampleWSequence können nun einfach zur Synthese des Ausdrucks
und der Anweisungssequenz des if-Konstruktes benutzt werden. Es muß dabei keine neue
Variablenliste angelegt werden. Auf diese Weise kann ein if-Konstrukt gewonnen werden, so
daß obige Fragmente Beispielauswertungen sind. Weitere Beispielauswertungsfragmente des
if-Konstruktes in anderen Entfaltungen des while-Konstruktes können nun von der Prozedur
TestWHILE erkannt werden. Wenn eine solche Beispielauswertung aus einer negativen
Entfaltung besteht, wird einfach nur die Auswertung des Ausdrucks beachtet.
Wie wollen nun hinterfragen, ob die zusätzlichen Bedingungen für Klasse-III-Programme und
Klasse-III-Beispielauswertungen sinnvoll sind, oder die Klasse der möglichen Programme (mit
if-Konstrukten) zu sehr einschränken. Die Bedingungen 6-8 der Definition 6.3.1 sind
sicherlich nicht beschränkend, sie entsprechen Regeln wie in Sprachen wie Pascal.
Leider beschränken die Regeln 3 und 4 der Definition 6.3.2 die Menge der Eingaben stark. Die
Bedingung, ein if-Konstrukt immer positiv oder in den ersten zwei Vorkommen positiv
auszuwerten gleicht der Bedingung, daß der Ausdruck einer if-Anweisung immer wahr ist.
Dies führt aber den Sinn einer if-Anweisung ad absurdum. Die Klasse III ist damit nicht
geeignet als vernünftige Sprachklasse zur Synthese von Programmen.
Versuchen wir jetzt, alternative Ansätze zur Programmsynthese zu finden Wir müssen jedes
if-Konstrukt mindestens einmal positiv auswerten, denn sonst haben wir keine Chance, die
Anweiungssequenz synthetisieren zu können. Deswegen können wir auf die Bedingung 3 nicht
verzichten. Es stellt sich jetzt die Frage, ob eine positive Auswertung des if-Konstruktes in den
Entfaltungen des while-Konstruktes nicht genügt, um eine if-Konstrukt zu generieren. Es sind
aber mindestens zwei Entfaltungen notwendig, um die Zuordnung von Zahlen in einer
Beispielauswertung auf die beteiligten Variablen zu treffen. Wenn wir also nur eine positive
Entfaltung des if-Konstruktes fordern, so müssen wir das Vorkommen von Variablen im if-
Konstrukt ausschließen, was sicherlich unbefriedigend ist.
Wir benötigen also mindestens zwei positive Entfaltungen des if-Konstruktes. Wenn das if-
Konstrukt aber nicht in den ersten beiden Entfaltungen des while-Konstruktes positiv
ausgewertet worden ist, kann im allgemeinen von der Prozedur SampleWHILE nach dem
Lesen der ersten beiden Entfaltungen das while-Konstrukt nicht generiert werden. Nicht nur,
daß das if-Konstrukt in der Anweisungssequenz des while-Konstruktes fehlt (dies könnte ja
später von der Prozedur TestWHILE ergänzt werden), dadurch das wir nicht wissen, welche
Variablen im if-Konstrukt verwendet wurden und welche Werte verändert wurden, konnte
auch der Rest der Anweisungssequenz nicht fehlerfrei synthetisiert werden. Damit kann aber
unser Synthesealgorithmus if-Konstrukte nur auf der Basis der Klasse-III-Programme
bearbeiten.
Aufgrund der oben ausgeführten Problem erübrigt sich die Frage, warum wir das if-Konstrukt
nicht um einen else-Zweig ergänzt haben.
6.4 weitergehende Erweiterungen
In Kapitel 1 haben wir gesehen, daß wir durch Einführung weiterer Konstrukte die
Ausdrucksfähigkeit unserer Sprache erhöhen konnten. Leider ist es nicht möglich, z.B. einen
switch-Konstrukt einzuführen. Denn wie sollten wir jeden Zweig des switch-Konstruktes
zweimal auswerten, und das noch in den ersten beiden Entfaltungen eines while-Konstruktes?
Versuchen wir lieber eine grundlegender Erweiterung in unsere Sprache einzuführen, nämlich
Makros. Dazu gibt es zwei Möglichkeiten: Wir lassen die Makroaufrufe bei der Bildung der
6HLWH

:HLWHUH3URJUDPPNODVVHQ
Beispielauswertungen bestehen oder wir lassen sie bei der Bildung der Auswertung unter den
Tisch fallen.
Betrachten wir zuerst die erste Möglichkeit. Ein solches Programm wäre etwa:
input (x)
double (x)
output x
mit der Beispielauswertung:
input (8)
double (8)
output 16
Wenn dem Synthesealgorithmus jetzt bekannt ist, das das Makro double den Wert der
Variablen in seinem Argument verdoppelt, so weiß er, daß die Variable, die vor dem Aufruf
den Wert 8 innehatte, danach den Wert 16 besitzt. Also kann das obige Programm
synthetisiert werden. Es bleibt aber die Frage, wie dieses "Wissen" an den
Synthesealgorithmus überreicht werden kann.
Falls die Bedeutung des Makros double nicht bekannt ist, so dürfte es schwerfallen, die
Semantik des Makros zu erkennen. Unlösbar wird die Aufgabe, wenn die Beispielauswertung
den Makroaufruf nicht mehr enthält. Die Beispielauswertung des obigen Programms sähe
dann so aus:
input (8)
output 16
Geben wir zum Abschluß noch ein krasseres Beispiel an. Gegeben sei die folgende Eingabe:
input (1)
4
19
11
22
14
output 16
Obige Eingabe dürfte die meisten Synthesealgorithmen überfordern. Die Lösung ist
selbstverständlich das folgende Programm:
input (x)
add3 (x)
add15 (x)
sub8 (x)
double (x)
sub8 (x)
output x
6HLWH

(QWZXUIVHQWVFKHLGXQJHQ
7 Entwurfsentscheidungen
Der Entwurf richtet sich nach folgenden Grundlagen:
1. Das Werkzeug wird den Namen ’[VDPSOH’ tragen. Seine Versionsnummer soll 2.0 lauten.
2. Es wird objektorientierte Programmierung verwendet. Als Programmiersprache wird C++
verwendet. Es wird der Gnu-C++-Compiler verwendet.
3. Das Werkzeug soll unter einer UNIX-Umgebung laufen.
4. Das Programm wird in Komponenten und Unterkomponenten aufgeteilt, die einzeln
spezifiziert, kodiert und getestet werden können.
5. Es werden die GNU-C++-Libraries verwendet.
6. Es werden X11 und OSF/Motif verwendet.
7. Die Steuerung des Programmes geschieht wahlweise über eine interaktive graphische
Benutzeroberfläche oder über Kommandozeilenargumente im Batch-Betrieb.
8. Das Werkzeug enthält einen Texteditor zur Erzeugen der Eingaben. Weiterhin soll
Datenverkehr zu einem Speichermedium unterstützt werden.
9. Die Bedienung des neuen Programmes soll der Bedienung der Version 1.0 des Werkzeugs
ähneln. Des weiteren sollen die Datenformate der neuen Version nach Möglichkeit mit den
alten Datenformaten übereinstimmen.
10. Im Sinne der Wiederverwertung soll vor jeder neuen Spezifikation geprüft werden, ob nicht
eine Komponente der Version 1.0 des Werkzeugs ganz oder teilweise verwendet werden
kann.
11. Das Werkzeug soll auf mehreren Plattformen laufen.
12. Das Werkzeug soll für eine Erweiterung um weitere Programmklassen vorbereitet sein.
13. Natürliche Zahlen werden generell durch den Datentyp unsigned int dargestellt. Ihre obere
Schranke richtet sich nach der internen Darstellung dieses Datentyps und dürfte im
Regelfall 32 Bit betragen.
6HLWH

'HU$XIEDXYRQ[VDPSOH9HUVLRQ
8 Der Aufbau von [VDPSOH Version 2.0
Zur besseren Darstellung der Komponenten des Programmes und ihrer Beziehungen
zueinander wurde eine graphische Darstellung gewählt (siehe Abb. 1) Die Pfeile starten dabei
an der exportierenden Komponente und enden an der importierenden Komponente. Es werden
fünf Arten der Beziehungen zwischen Komponenten unterschieden:
ì
ì
ì
ì
ì
ì
Bei der Vererbung benutzt die importierende Komponente eine Klasse der exportierenden
Komponente als Basisdatentyp einer eigenen Klasse. Die importierende Klasse kann dabei
auf private Komponenten und Methoden der übertragenen Klasse nicht zugreifen.
Bei der Bereitstellung eines Datentyps für die importierende Komponente durch die
exportierende Komponente wird der übertragene Datentyp als Typ von Variablen und
Komponenten benötigt. Bei einer Klasse kann dabei nur auf öffentliche Komponenten und
Methoden zurückgegriffen werden.
Die Fehlerbehandlung beinhaltet die Bereitstellung eines Datentyps mit den Namen der
Kodierung der Fehlermeldung und die Bereitstellung einer Funktion zum Aufruf des
Fehlers.
Die Bereitstellung von Funktionen ermöglicht der importierenden Komponente den Aufruf
von Funktionen der exportierenden Komponente.
Bei der Bereitstellung von Callbackroutinen durch die exportierende Komponente werden
diese Routinen von der importierenden Komponente an Aktionen von X-Applikationen
gebunden. Die Callbackroutinen werden nicht von der importierenden Komponente
aufgerufen, sondern von Ereignissen der X-Applikation.
Bei der Bereitstellung von Event-Handlern werden Event-Handler zur Bearbeitung von
Events von der exportierenden Komponente an die importierende Komponente übergeben,
um sie an vom Benutzer des System auflösbare Events zu Binden. Event-Handler werden
von Ereignissen der X-Applikation aufgerufen.
6HLWH

'HU$XIEDXYRQ[VDPSOH9HUVLRQ
Ein Überblick über die Komponenten des Programmes und ihrer Beziehungen zueinander
bietet Abb. 5.
Abbildung 8 : Struktur von [VDPSOH 2.0
Zeichenerklärung:
Bereitstellung von Datentypen
Bereitstellung von Funktionen
Vererbung
Fehlerbehandlung
Interface
Text
SampleText
ProgramText
Computer
Synthesizer
Parser
Der Benutzer erhält dabei nur Kontakt zur Komponente Interface. Diese Komponente enthält
die Funktion main, die als erste Funktion beim Start des Werkzeugs vom Betriebssystem
aufgerufen wird. Nach Auswertung der Kommandozeilenoptionen wird, sofern dies gewünscht
6HLWH

'HU$XIEDXYRQ[VDPSOH9HUVLRQ
wird, die interaktive Benutzerschnittstelle aufgebaut (siehe Kapitel 9). Die Komponente stellt
Funktionen zum Aufbau des Hauptfensters und aller untergeordneten Fenster bereit, sowie die
Callbackroutinen zur Reaktion auf die Events, die vom Benutzer ausgelöst werden. Inbegriffen
ist damit auch das Hilfe- und das Fehlermeldesystem.
Die Komponente Text stellt den Datentyp Text bereit. Dieser beinhaltet Methoden und Daten
zur Verwaltung eines beliebig langen ASCII-Textes, einschließlich Datenverkehrsoperationen.
Die Komponenten SampleText und ProgramText erweitern diese Klasse um Methoden zur
Bildung der Beispielauswertung aus einem WHILE-Programm oder zur Generierung eines
Programmes aus einer Beispielauswertung. Die von diesen Komponenten zur Verfügung
gestellten Klassen SampleText und ComputableText werden von der Komponente Interface
verwendet.
Die Komponente Parser beinhaltet die interne Darstellung von Programmen und
Beispielauswertungen. Zu diesem Zweck stellt sie die Klassen Program und
SampleComputation. Die Komponenten Computer und Synthesizer erweitern diese Klassen
um Methoden zur automatischen Programmsynthese und Auswertungsgenerierung.
8.1 Namenskonventionen
Bei der Kodierung des Werkzeuges wurde bei allen vom Autor frei gewählten Bezeichnern
folgende Namenskoventionen eingehalten:
Tabelle 4 : Namenskoventionen
Art des Bezeichners Namenskonvention Beispiele
Datentypen
Klein- und Großbuchstaben,
Wörter zusammengeschrieben,
jedes Wort beginnt mit einem
Großbuchstaben
Funktionen und Methoden
Variablen
Konstanten
Klein- und Großbuchstaben,
Wörter zusammengeschrieben,
jedes Wort mit Ausnahme des ersten
beginnt mit einem Großbuchstaben
Kleinbuchstaben,
Wörter durch "_" getrennt
Großbuchstaben,
Wörter durch "_" getrennt.
CommandType
Program
LeftSideType
checkCommandLine
compute
getText
number_of_elements
counter
E_NUMBER,
MODE_BATCH
6HLWH

'HU$XIEDXYRQ[VDPSOH9HUVLRQ
8.2 Die Komponente Interface
Abbildung 9 : Struktur der Komponente Interface
Zeichenerklärung:
Bereitstellung von Datentypen
Bereitstellung von Funktionen
Bereitstellung von Callbackroutinen
Bereitstellung von Event-Handlern
Fehlerbehandlung
Vererbung
Betriebssystem
Main
CommandLine
Graphical
UserInterface
Extended
Operations
EventHandler
Callback
Operations
Help
Messages
HelpErrorText
Error
HelpError
Connection
Text Parser
Synthezizer
ProgramText
SampleText
6HLWH

'HU$XIEDXYRQ[VDPSOH9HUVLRQ
8.2.1 Die Unterkomponente Main
Quellcodedateien:
Import von Datentypen:
Import von Funktionen:
Export von Datentypen
Export von Funktionen
xsample.h
xsample.cxx
AlgorithmType, LogType, ModeType,
CommandType von Unterkomponente
CommandLine
FormData von Unterkomponente Operations
checkCommandLine von Unterkomponente
CommandLine
startInterface von Unterkomponente
GraphicalUserInterface
errorInit und logInit von Unterkomponente Error
keine
main
Die Unterkomponente Main stellt die Funktion main zur Verfügung, die beim Start des
Werkzeugs aufgerufen wird. Der Funktion main werden auch die Kommandozeilenargumente
des Aufrufs übergeben. In der Funktion main wird die Kommandozeile ausgewertet und eine
Instanz des zentralen Datentyps FormData konstruiert. Falls die interaktive Benutzerführung
angewählt wurde, wird die graphische Benutzeroberfläche gestartet, falls der Batch-Modus
angewählt wurde, wird der Programmablauf von der Funktion main selbst durchgeführt.
8.2.2 Die Unterkomponente CommandLine
Quellcodedateien:
Import von Datentypen:
Import von Funktionen:
Export von Datentypen
Export von Funktionen
commandline.h
commandline.cxx
AlgorithmType von Unterkomponente Connection
standardAlgorithm, setAlgorithm und
listAlgorithm von Unterkomponente Connection
ModeType, AlgorithmType, LogType,
CommandType
checkCommandLine
Zweck der Unterkomponente CommandLine ist die Auswertung der Kommandozeile mittels
der bereitgestellten Funktion checkCommandLine. Eine nähere Beschreibung der
Kommandozeilenargumente erfolgt in Kapitel 9. Rückgabewert der Funktion ist eine Struktur
des Typs CommandType, in der die das Ergebnis der Komandozeilenanalyse festgehalten
wird.
8.2.3 Die Unterkomponente GraphicalUserInterface
Quellcodedateien:
Import von Datentypen:
Import von Funktionen:
Export von Datentypen
Export von Funktionen
gui.h
gui.cxx
FormData, WidgetName, Triple und ButtonName
von Unterkomponente Operations
AlgorithmType von Unterkomponente Connection
errorInit von Unterkomponente Error
helpInit von Unterkomponente Help
Callbackroutinen von Unterkomponente Callback
Eventhandler von Unterkomponente EventHandler
keine
startInterface
6HLWH

'HU$XIEDXYRQ[VDPSOH9HUVLRQ
Die von der Unterkomponente zur Verfügung gestellte Funktion startInterface konstruiert das
Hauptfenster des Formulars, verbindet von den Widgets des Hauptformulars ausgelöste
Events mit den Callbackroutinen und den Eventhandlern und fügt das Programm als X-
Anwendung in die Haupteventschleife des X-Servers ein.
8.2.4 Die Unterkomponente Messages
Quellcodedateien:
Import von Datentypen:
Import von Funktionen:
Export von Datentypen
Export von Funktionen
messages.h
messages.cxx
ExtendedFormData von Unterkomponente
ExtendedOperations
Callbackroutinen von Unterkomponente Callback
WarningType
createWarning, createQuestion, fileSelect und
createInfoBox
Die Unterkomponente stellt Funktionen zur Erzeugung von
Warnungsboxen vor versehentlichem Löschen nicht gesicherter Änderungen im Text der
Beispielauswertung oder im Text des Programmes,
Dialogboxen für Sicherheitsabfragen,
Dateiauswahlboxen,
sowie für die Informationsbox, die einen Text über den Autor des Programmes ausgibt.
Callbackroutinen zur Behandlung der von den Dialogfenstern erzeugten Events werden von
der Unterkomponente Callback zur Verfügung gestellt.
8.2.5 Die Unterkomponente Callback
Quellcodedateien:
Import von Datentypen:
Import von Funktionen:
Export von Datentypen
Export von Funktionen
callback.h
callback.cxx
ExtendedFormData und OperationType von
Unterkomponente ExtendedOperations
WarningType von Unterkomponente Messages
HelpType von Unterkomponente Help
createWarning, createQuestion, fileSelect und
createInfoBox von Unterkomponente Messages
createHelpDialog von Unterkomponente Help
WarningType
Callbackroutinen
In dieser Unterkomponente werden Callbackroutinen für die Behandlung der Events des
Hauptformulars und der Dialogfenster zur Verfügung gestellt. Die Unterkomponente steuert
ebenfalls den Aufbau der Dialogfenster.
8.2.6 Die Unterkomponente EventHandler
Quellcodedateien:
Import von Datentypen:
Import von Funktionen:
Export von Datentypen
Export von Funktionen
eventhandler.h
eventhandler.cxx
keine
keine
keine
Eventhandler
Die Unterkomponente stellt Eventhandler für die Unterkomponente GraphicalUserInterface
bereit.
6HLWH

'HU$XIEDXYRQ[VDPSOH9HUVLRQ
8.2.7 Die Unterkomponente Help
Quellcodedateien:
Import von Datentypen:
Import von Funktionen:
Export von Datentypen
Export von Funktionen
help.h
help.cxx
HelpErrorText von Unterkomponente
HelpErrorText
displayMessage von Unterkomponente HelpError
HelpType
helpInit, createHelpDialog
Die Unterkomponente stellt die Hilfefunktion von [VDPSOH 2.0 zur Verfügung. Zur
Kodierung der Hilfstexte stellt die Unterkomponente den Datentyp HelpType zur Verfügung.
Zum Lesen der Hilfstexte wird die Klasse HelpErrorText von der Unterkomponente
HelpErrorText importiert, zur Darstellung der Hilfstexte in der Hilfebox wird die Funktion
displayMessage der Unterkomponente HelpError verwendet. Die Hilfetexte werden
standardmäßig in der Datei "sample.help" gesucht, über die Umgebungsvariable
"XSAMPLEHELPFILE" kann eine andere Datei angewählt werden.
8.2.8 Die Unterkomponente Error
Quellcodedateien:
Import von Datentypen:
Import von Funktionen:
Export von Datentypen
Export von Funktionen
error.h
error.cxx
HelpErrorText von Unterkomponente
HelpErrorTex
LogType von Unterkomponente CommandLine
displayMessage und displayLog von
Unterkomponente HelpError
ErrorType
errorInit, logInit und error
In dieser Unterkomponente werden die Fehlermeldungen des Werkzeugs erzeugt. Der
Datentyp ErrorType beinhaltet eine Kodierung der Fehlermeldungen. Die Texte der
Fehlermlungen werden über die Klasse HelpErrorType der Unterkomponente
HelpErrorType. Die Ausgabe der Fehlermeldungen erfolgt im interaktiven Modus über eine
Hilfebox mittels der Funktion displayMessage, die von der Unterkomponente HelpError
geliefert wird. Im Batch-Modus erfolgt die Ausgabe der Fehlermeldungen über die
Standardfehlerausgabe. Standardmäßig stehen die Fehlermeldungen in der Datei
"sample.error", jedoch kann über die Umgebungsvariable "XSAMLEERRORFILE" eine
andere Datei für die Fehlermeldungen bestimmt werden. Optional kann beim Aufruf der
Funktion error auch einen Fehlerprotokoll angegeben werden. Das Fehlerprotokoll wird in die
Datei "error.log" (oder über eine andere bei der Initialisation angegebene Datei) gespeichert,
sofern diese Funktionalität nicht abgeschaltet wird. Im interaktiven Modus wird das
Fehlerprotokoll mittels der Funktion displayLog in einem Fenster angezeigt.
8.2.9 Die Unterkomponente HelpErrorText
Quellcodedateien:
Import von Datentypen:
Import von Funktionen:
Export von Datentypen
Export von Funktionen
helperrortext.h
helperrortext.cxx
keine
keine
ErrorTypeText
keine
6HLWH

'HU$XIEDXYRQ[VDPSOH9HUVLRQ
Die Komponente stellt den Datentyp HelpErrorText zur Verfügung. Über ihn können sowohl
Hilfetexte als auch Fehlermeldungen von Datei gelesen werden.
8.2.10 Die Unterkomponente HelpError
Quellcodedateien:
Import von Datentypen:
Import von Funktionen:
Export von Datentypen
Export von Funktionen
helperror.h
helperror.cxx
keine
Callbackroutinen von Unterkomponente Callback.
keine
displayMessage, displayLog
Die Unterkomponente HelpError kreiert eine Mitteilungsbox zur Darstellung der Hilfetexte
und der Fehlermeldungen mit der exportierten Funktion displayMessage. Die Funktion
displayLog dient zur Ausgabe des Fehlerprotokolls in einem Fenster.
8.2.11 Die Unterkomponente Operations
Quellcodedateien:
Import von Datentypen:
Import von Funktionen:
Export von Datentypen
Export von Funktionen
operations.h
operations.cxx
AlgorithmType, SampleText, ProgramText von
Unterkomponente Connection
keine
FormData, ButtonName, ButtonType,
WidgetName, Triple
keine
Die Unterkomponente stellt den zentralen Datentype FormData zur Verfügung. In diesem
Datentyp werden alle Informationen, die zur Steurung des Werkzeugs notwendig sind
gespeichert. Außerdem werden weitere Datentypen exportiert, die zur Zugriff und zur
effizienten Speicherung der verschiedenen Widgets in der Klasse FormData notwendig sind.
8.2.12 Die Unterkomponente ExtendedOperations
Quellcodedateien:
Import von Datentypen:
Import von Funktionen:
Export von Datentypen
Export von Funktionen
xoperations.h
xoperations.cxx
FormData von Unterkomponente Operations
AlgorithmType von Unterkomponente Connection
standardAlgorithm von Unterkomponente
Connection
OperationType
ExtendedFormData
keine
Die Unterkomponente erweitert den von Operations zur Verfügung gestellten Datentyp
FormData und stellt die Methoden für die Manipulation der Datenstruktur zur Verfügung.
Der Datentyp OperationType dient zur Kodierung der Art der Operation, wenn diese in
ExtendedFormData gespeichert werden soll.
6HLWH

'HU$XIEDXYRQ[VDPSOH9HUVLRQ
8.2.13 Die Unterkomponente Connection
Quellcodedateien:
Import von Datentypen:
Import von Funktionen:
Export von Datentypen
Export von Funktionen
connetion.h
connetion.cxx
SampleText von Komponente SampleText
ProgramText von Komponente ProgramText
keine
AlgorithmType, SampleText und ProgramText
standardAlgorithm, setAlgorithm und
listAlgorithm
Diese Unterkomponenten stellt das Bindeglied dar zwischen der Komponente Interface und
den funktionalen Komponenten. Demnach muß bei Änderungen in den funktionalen
Komponenten (z.B. der Hinzunahme weiterer Programmklassen) in der Komponente Interface
nur die Unterkomponente Connection angepaßt werden. Sollen weitere Algorithmen über die
graphische Benutzeroberfläche angewählt werden können, so sind auch Änderungen in den
Unterkomponenten GraphicalUserInterface und Callback notwendig.
8.3 Die Komponente Text
Quellcodedateien:
Import von Datentypen:
Import von Funktionen:
Export von Datentypen
Export von Funktionen
text.h
text.cxx
keine
keine
Text
keine
In der Komponente Text wird der Datentyp Text bereitgestellt, der die Verwaltung einer
beliebig langen Zeichenkette beinhaltet, einschließlich Operationen des Datenverkehrs mit
einem Speichermedium.
8.4 Die Komponente SampleText
Quellcodedateien:
sampletext.h
sampletext.cxx
Import von Datentypen:
AlgorithmType von Komponente Interface
Unterkomponente Connection
Text von Komponente Text
SynthesizableSample von Komponente
Synthesizer
Import von Funktionen:
keine
Export von Datentypen
SampleText
Export von Funktionen
keine
Die Komponente erweitert den Datentyp Text zum Datentyp SampleText durch Hinzunahme
von Operationen zur Programmsynthese. Der Datentyp SampleText wird dann als Klasse der
ASCII-Texte der Beispielauswertungen verwendet. Die ASCII-Darstellung wird für die
Ausgabe auf dem Bildschirm und für die Speicherung auf einem Speichermedium verwendet,
da sie für den Menschen lesbar ist und von jedem Texteditor verarbeitet werden kann. Diese
Darstellung der Beispielauswertungen wurde auch in dieser Arbeit verwendet.
6HLWH

'HU$XIEDXYRQ[VDPSOH9HUVLRQ
8.5 Die Komponente ProgramText
Quellcodedateien:
Import von Datentypen:
Import von Funktionen:
Export von Datentypen
Export von Funktionen
programtext.h
programtext.cxx
AlgorithmType von Komponente Interface
Unterkomponente Connection
Text von Komponente Text
ComputableProgram von Komponente Computer
keine
ProgramText
keine
Die Komponente erweitert den Datentyp Text zum Datentyp ProgramText durch
Hinzunahme von Operationen zur Auswertung von Programmen. Der Datentyp ProgramText
wird dann als Klasse der ASCII-Texte der WHILE-Programme verwendet. Die ASCII-
Darstellung wird für die Ausgabe auf dem Bildschirm und für die Speicherung auf einem
Speichermedium verwendet, da sie für den Menschen lesbar ist und von jedem Texteditor
verarbeitet werden kann. Diese Darstellung der WHILE-Programme wurde auch in dieser
Arbeit verwendet.
8.6 Die Komponente Computer
Quellcodedateien:
computer.h
computer.cxx
Import von Datentypen:
Program, Construct, WhileConstruct,
Sequence, ProgramSequence, Statement,
StatementType und InitialType von Komponente
Parser Unterkomponente Program
SampleComputation, SampleSequence und
TestConstruct von Komponente Parser
Unterkomponente SampleComputation
Import von Funktionen:
keine
Export von Datentypen
ComputableProgram
Export von Funktionen
keine
Die Komponente erweitert den von der Komponente Parser übernommene Klasse Program
zur Klasse ComputableProgram. Wichtigste Erweiterung ist die Methode
ComputableProgram::compute, die eine Auswertung des Programmes berechnet und als
ASCII-Text zurückliefert.
6HLWH

'HU$XIEDXYRQ[VDPSOH9HUVLRQ
8.7 Die Komponente Synthesizer
Quellcodedateien:
Import von Datentypen:
Import von Funktionen:
Export von Datentypen
Export von Funktionen
computer.h
computer.cxx
Program, Construct, WhileConstruct,
Sequence, ProgramSequence, Statement,
StatementType und InitialType von Komponente
Parser Unterkomponente Program
SampleComputation, SampleSequence und
TestConstruct von Komponente Parser
Unterkomponente SampleComputation
ErrorType von Komponente Interface
Unterkomponente Error
error von Komponente Interface
Unterkomponente Error
SynthesizableSample
keine
Die Komponente erweitert den von der Komponente Parser übernommene Klasse
SampleComputation zur Klasse SynthesizableSample. Wichtigste Erweiterung ist die
Methode SynthesizableSample::synthesize, die eine Auswertung des Programmes berechnet
und als ASCII-Text zurückliefert.
6HLWH

'HU$XIEDXYRQ[VDPSOH9HUVLRQ
8.8 Die Komponente Parser
Abbildung 10 : Struktur der Komponente Parser
Zeichenerklärung:
Bereitstellung von Datentypen
Bereitstellung von Funktionen
Vererbung
Fehlerbehandlung
Variable
Basic
Interface
ProgramText
Program
Sample
Computation
Interface
SampleText
Interface
Scanner
6HLWH

'HU$XIEDXYRQ[VDPSOH9HUVLRQ
8.8.1 Die Unterkomponente Scanner
Quellcodedateien:
Import von Datentypen:
Import von Funktionen:
Export von Datentypen
Export von Funktionen
scanner.h
scanner.cxx
ErrorType von Komponente Interface
Unterkomponente Error
error von Komponente Interface
Unterkomponente Error
WhiteSpacesMode, ScanText
keine
Die Unterkomponente Scanner stellt die wichtigsten Methoden zur syntaktische Analyse eines
Textes zur Verfügung. Mit dem von der Unterkomponente exportierten Datentyp ScanText
können Worte, Zahlen, Zeichenketten und Sonderzeichen aus dem Text gelesen werden. Dabei
können Trennzeichen und Kommentare überlesen werden.
8.8.2 Die Unterkomponente Variable
Quellcodedateien:
Import von Datentypen:
Import von Funktionen:
Export von Datentypen
Export von Funktionen
variable.h
variable.cxx
keine
keine
Variable, VariableList
keine
In der Unterkomponente Variable werden die Datentypen Variable und VariableList
bereitgestellt zusammen mit Methoden zur Verwaltung von Variablen und Variablenlisten.
8.8.3 Die Unterkomponente Basic
Quellcodedateien:
Import von Datentypen:
Import von Funktionen:
Export von Datentypen
Export von Funktionen
basic.h
basic.cxx
Variable und VariableList von Unterkomponente
Variable
ScanText von Unterkomponente Scanner
keine
OutputState, SkipState, InitialType, Statement,
StatementType, Sequence, Construct und
BasicProgram
keine
Die Unterkomponente Basic stellt Basisdatentypen für die interne Darstellung von
Programmen und Beispielauswertungen zur Verfügung.
6HLWH

'HU$XIEDXYRQ[VDPSOH9HUVLRQ
8.8.4 Die Unterkomponente Program
Quellcodedateien:
Import von Datentypen:
Import von Funktionen:
Export von Datentypen
Export von Funktionen
program.h
program.cxx
Variable und VariableList von Unterkomponente
Variable
ScanText und WhiteSpacesMode von
Unterkomponente Scanner
ErrorType von Komponente Interface
Unterkomponente Error
OutputState, SkipState, InitialType, Statement,
StatementType, Sequence, Construct und
BasicProgram von Unterkomponente Basic
error von Komponente Interface
Unterkomponente Error
WhileConstruct, ProgramSequence, Program
keine
Die Datentypen WhileConstruct, ProgramSequence und Program, die von der
Unterkomponente Program exportiert werden, implementieren die interne Darstellung von
while-Konstrukten, Anweisungssequenzen (und Ausdrücken) und Programmen. Die
Unterkomponente stellt Methoden dar zum Parsen eines ASCII-Textes eines Programmes in
die interne Darstellung mittels des importierten Datentyps ScanText, sowie zur
Rückumwandlung der internen Darstellung eines Programmes in einen ASCII-Text.
8.8.5 Die Unterkomponente SampleComputation
Quellcodedateien:
Import von Datentypen:
Import von Funktionen:
Export von Datentypen
Export von Funktionen
samplecomputation.h
samplecomputation.cxx
Variable und VariableList von Unterkomponente
Variable
ScanText und WhiteSpacesMode von
Unterkomponente Scanner
ErrorType von Komponente Interface
Unterkomponente Error
OutputState, SkipState, InitialType, Statement,
StatementType, Sequence, Construct und
BasicProgram von Unterkomponente Basic
error von Komponente Interface
Unterkomponente Error
TestConstruct, SampleSequence,
SampleComputation
keine
Die Datentypen TestConstruct, SampleSequence und SampleComputation, die von der
Unterkomponente SampleComputation exportiert werden, implementieren die interne
Darstellung von test-Konstrukten, Auswertungsfragmenten und Beispielauswertungen. Die
Unterkomponente stellt Methoden dar zum Parsen eines ASCII-Textes einer
Besipielauswertung in die interne Darstellung mittels des importierten Datentyps ScanText,
sowie zur Rückumwandlung der internen Darstellung einer Beispielauswertung in einen
ASCII-Text.
6HLWH

'HU$XIEDXYRQ[VDPSOH9HUVLRQ
8.9 Erweiterungen
8.9.1 Hinzunahme weiterer Algorithmen
Soll ein weiterer Algorithmus in die Funktionalität des Werkzeugs hinzu genommen werden,
so ist dieser Algorithmus in den Datentyp AlgorithmType in der Unterkomponente
Connection aufzunehmen. Damit dieser Algorithmus über die Kommandozeilenoption -a
angewählt werden kann, sind Änderungen in den Funktionen, die von der Unterkomponente
Connection bereitgestellt werden, notwendig. Zur Aufnahme des Algorithmus' in das
Algorithmenmenü des Hauptformulars der graphischen Benutzeroberfläche muß dieser neue
Menüpunkt in der Unterkomponente GraphicalUserInterface hinzugefügt werden. Die
Beschriftung des Menüpunktes ist in das Resourcenfile aufzunehmen. Des weiteren ist eine
neue Callbackroutine einzuführen und in der Unterkomponente Callback zu definieren.
Auf jedem Fall müssen die Methoden ProgramText::compute und SampleText::synthesize
in den Komponenten Programtext und SampleText angepaßt werden. Dazu muß die neue
Synthesefunktion und/oder die neue Auswertefunktion importiert werden. Falls der neue
Algorithmus angewählt worden ist, sind dann statt der Standardalgorithmen die neuen
Algorithmen aufzurufen.
8.9.2 Hinzunahme weiterer Fehlermeldungen
Zuerst muß eine Kodierung der neuen Fehlermeldung in den Datentyp ErrorType der
Unterkomponente Error aufgenommen werden (und zwar als letztes Element des Datentyps).
Diese Kodierung muß beim Aufruf der Funktion error benutzt werden, wenn die neu
aufzunehmende Fehlermeldung aufgerufen werden soll. Die neue Fehlermeldung muß dann in
die Fehlermeldungsdatei aufgenommen werden, ebenfalls als letztes Element.
8.9.3 Hinzunahme weiterer Hilfstexte
Hierzu muß die Kodierung des neuen Hilfstextes als letztes Element in den Datentyp
HelpType aufgenommen werden. Diese Kodierung ist beim Aufruf der Hilfefunktion mit
createHelpDialog zu verwenden. Der Hilfetext muß als letztes Element in die Hilfetextdatei
angefügt werden.
8.9.4 Hinzunahme weiterer Operationen im Hauptformular
Hierzu sind Änderungen in der Komponente GraphicalUserInterface und in der
Resourcendatei notwendig. Operationen über den Texteditor sollten als Menüeinträge in das
Edit-Menü eingefügt werden. Andere Operationen können in einer gesonderten Menüleiste
eingeführt werden. Benötigte Eventhandler sind in der Unterkomponente EventHandler
aufzunehmen, benötigte Callbacks sind in die Unterkomponente Callback einzufügen.
6HLWH

%HQXW]HUVFKQLWWVWHOOH
9 Benutzerschnittstelle
9.1 Dateien
Das Werkzeug [VDPSOH in der Version 2.0 besteht bei der Installation aus den folgenden
Dateien:
xsample
Sample
sample.help
sample.error
xsample.bm
xsample.icon.bm
xsample.1
Das Programm ist in einer Binärdatei namens
xsample
enthalten.
Zum Start der graphischen Benutzeroberfläche ist ein Resourcenfile namens
Sample
notwendig. Diese Datei muß sich in dem mit der Umgebungsvariable APPLRESDIR
spezifiziertem Verzeichnis oder im Homeverzeichnis des Benutzers befinden, falls die Variable
nicht definiert ist (oder im 'app-default'- Verzeichnis des Systems). Selbstverständlich können
die Resourcen auch auf andere Weise (z.B. .Xdefaults, xrdb) zur Verfügung gestellt werden
Des weiteren muß eine Datei vorhanden sein, in der die Hilfetexte gespeichert sind. Dies ist
standardmäßig die Datei
sample.help
und steht im selben Verzeichnis wie xsample. Mit der Umgebungsvariablen
XSAMPLEHELPFILE kann eine andere Datei und ein anderer Pfad gewählt werden.
Analog muß eine Datei vorhanden sein, in der die Fehlermeldungen gespeichert sind. Diese
Datei heißt
sample.error,
und steht in demselben Verzeichnis wie xsample, sofern nicht mit der Umgebungsvariablen
XSAMPLEERRORFILE eine andere Datei und ein anderer Pfad festgelegt worden ist.
Die Datei
xsample.bm
enthält das Bitmap der Applikation, wie für die Infobox benötigt wird. Die Datei
xsample.icon.bm
enthält die Bitmap für das Icon des Programmes.
Die 'man-page' zum Programm ist in der Datei
xsample.1
enthalten.
6HLWH

%HQXW]HUVFKQLWWVWHOOH
Folgende Konvention sollte bei der Wahl der Dateinamen für die Beispielauswertung und die
Programmtexte eingehalten werden:
Die Dateinamen für Programme enden auf .pr, Dateinamen für Beispielauswertungen enden
auf .sc.
9.2 Kommandozeilenoptionen
Kommandozeilenoptionen werden dem Werkzeug beim Start des Programmes übergeben.
Normalerweise gibt man sie beim Aufruf des Programmes aus der Kommandozeile hinter dem
Namen xsample an. Es können mehrere Kommanozeilenoptionen gleichzeitig angegeben
werden, jedoch sind bestimmte Kombinationen ausgeschlossen.
Ein gültiger Aufruf des Werkzeugs ist der folgende:
xsample -sf test.sc -fn fixed -logfilename test.log
Es ist aber nicht möglich, sowohl ein Programm als auch eine Beispielauswertung gleichzeitig
aus der Standardeingabe zu lesen, weswegen der folgende Aufruf abgewiesen wird:
xsample -s -c
Die nachfolgende Tabelle liefert einen Überblick über die möglichen
Kommandozeilenoptionen, die von der Unterkomponente CommandLine oder von der
Application-Shell erkannt werden:
Tabelle 5 : Kommandozeilenoptionen
Option Beispiel Bedeutung
-a Algorithmus -a class-I Auswahl eines Algorithmus' für
Programmauswertung und -synthese. Fehlt diese
Option, so wird beim Start des Programmes der
Standardalgorithmus class-I verwendet. Diese
Option macht nur bei einer Erweiterung des
Werkzeugs um mehrere Algorithmen Sinn.
-b -b Verhindert den Start der graphischen
Benutzeroberfläche (Batch-Mode). Diese Option
kann nur zusammen mit genau einer der Optionen
-s, -sf, -c oder -cf verwendet werden. Die
Wirkung einer vorangegangenen Option -i wird
aufgehoben.
-background Color -background orange Setzt die Hintergrundfarbe.
-bg Color
-bg seashell
-bordercolor Color -bordercolor Setzt die Farbe des Fensterrahmens.
-bd Color
lightskyblue
-borderwidth Zahl -borderwidth 4 Setzt die Breite des Fensterrahmens in Pixel.
-bw Zahl
-bw 10
-c -c Einlesen eines Programs von der
Standardeingabe. Diese Option darf nicht
zusammen mit der Option -s oder der Option -cf
verwendet werden.
-cf Dateiname -cf test.pr Einlesen eines Programs von der Datei mit dem
angegebenen Dateinamen. Diese Option darf nicht
zusammen mit der Option -c verwendet werden.
-display Display -display Bestimmt den für die Ausgabe der graphischen
6HLWH

%HQXW]HUVFKQLWWVWHOOH
x8.rhrk.uni-kl.de:0.0 Benutzeroberfläche zu verwendenden X-Server.
-foreground Color -foreground #3232cc Setzt die Vordergrundfarbe.
-fg Color
-fg orchid
-font Font
-font 9x15bold Setzt den zu verwendenden Zeichensatz.
-fn Font
-fn 6x10
-geometry Geometry -geometry
200x200+0+0
Legt die Größe des Hauptformulars und seine
Lage auf dem Bildschirm fest.
-help -help Ausgabe eines Hilfetextes über die
Kommandozeilenoptionen auf der
Standardausgabe.
-i -i Bewirkt den Start der graphischen
Benutzeroberfläche (Standardvorgabe). Die
Wirkung einer vorangegangen Option -b wird
aufgehoben.
-iconic -iconic nur Icon anzeigen
-lista -lista Gibt eine Liste der zur Verfügung stehenden
Algorithmen auf der Standardausgabe aus.
-log -log Bewirkt das Anlegen einer Fehlerprotokolldatei
(Standardvorgabe). Die Wirkung einer
vorangegangenen Option -nolog wird aufgehoben.
-logfilename
Dateiname
-logfilename
protokoll.dat
Auswahl des Namens der Fehlerprotokolldatei.
Die Standardvorgabe für die Protokolldatei ist
"error.log". Die Option beeinflußt nicht die
Entscheidung, ob eine Fehlerprotokolldatei
angelegt wird oder nicht.
-name Dateiname -name My_Sample Festlegen der Resourcendatei
-nolog -nolog Verhindert das Anlegen einer
Fehlerprotokolldatei. Setzt die Wirkung einer
vorangegangen Option -log außer Kraft.
-pcolumns Zahl -pcolumns 80 Setzt die Zahl der gleichzeitig angezeigten Spalten
des Programs.
-preadonly -preadonly Verhindert den schreibenden Zugriff auf das
angezeigte Program.
-prows Zahl -prows 30 Setzt die Zahl der gleichzeitig angezeigten Zeilen
des Programs.
-reverse
-rv
Vertauscht Vorder- und Hintergrundfarbe.
-rv
+rv +rv Hebt die Wirkung eines vorangegangenen -rv oder
-reverse wieder auf.
-s -s Einlesen einer Beispielauswertung von der
Standardeingabe. Diese Option darf nicht
zusammen mit der Option -c oder der Option -sf
verwendet werden.
-scolumns Zahl -scolumns 80 Setzt die Zahl der gleichzeitig angezeigten Spalten
der Sample Computation.
-selectionTimeout
Zahl
-selectionTimeout
100
Setzt die Zeitspanne im Millisekunden, in der
zwei miteinander kommunizierende X-
Anwendungen reagieren müssen.
-sf Dateiname -sf test.sc Einlesen einer Beispielauswertung von der Datei
mit dem angegebenen Dateinamen. Diese Option
darf nicht zusammen mit der Option -s verwendet
6HLWH

%HQXW]HUVFKQLWWVWHOOH
werden.
-sreadonly -sreadonly Verhindert den schreibenden Zugriff auf die
angezeigte Sample Computation.
-srows Zahl -srows 30 Setzt die Zahl der gleichzeitig angezeigten Zeilen
der Sample Computation.
-synchronous -synchronous Schaltet die Pufferung der Weitergabe der
Requests an den X-Server aus. Diese Option
sollte vom Benutzer nicht verwendet werden.
+synchronous +synchronous Hebt die Wirkung von -synchronous auf.
-title Name -title ysample Legt den Titel des Hauptfensters fest.
-xnllanguage Locale -xnllanguage german Setzt die landessprachlichen Optionen für das
Werkzeug. Die Standardeinstellung ist auf den
meisten Systemen US-american.
-xrm
Resourcenstring
-xrm "*foreground:
black"
Setzen von Resourcen.
Eine Option kann mehrmals in derselben Kommandozeile auftauchen. Beinhaltet die Option
ein Argument, so ist das Argument beim letzten Vorkommen der Option in der
Kommandozeile maßgeblich.
9.3 Batch-Mode
Im Batch-Mode wird keine graphische Benutzeroberfläche aufgebaut. Nach Starten des
Werkzeugs hat der Benutzer keine Möglichkeit mehr zur Kommunikation. Deswegen müssen
alle Benutzerkommandos über die Kommandozeile übergeben werden. Zum Start von
[VDPSOH im Batch-Mode muß die Kommandozeilenoption -b angegeben werden. Dem
Benutzer stehen zwei Betriebsarten zur Verfügung: Die Synthese eines Programmes aus einer
Beispielauswertung und die Generierung einer Beispielauswertung aus einem Programm. In
jeder Betriebsart wird die Eingabe entweder von der Standardeingabe oder von Datei gelesen.
Die Ausgabe erfolgt immer auf der Standardausgabe. Im Fehlerfall erfolgt eine Fehlermeldung
auf der Standardfehlerausgabe. Standardmäßig wird zusätzlich eine Fehlerprotokolldatei
angelegt. Man beachte bei den folgenden Beispielen, daß selbstverständlich auch weitere
Kommandozeilenoptionen angegeben werden dürfen.
1. Synthese eines Programmes:
In dieser Betriebsart muß zusätzlich zur Option -b eine der Optionen -s oder -sf angegeben
werden. Der Aufruf
xsample -b -s
liest eine Beispielauswertung von der Standardeingabe, synthetisiert ein Programm und gibt
dieses (sofern die Synthese erfolgreich war) auf der Standardausgabe aus. Der Aufruf
xsample -b -sf eingabe.sc
liest eine Beispielauswertung von der Datei mit dem Dateinamen "eingabe.sc" ein, synthetisiert
ein Programm und gibt dieses bei Erfolg auf der Standardausgabe aus. Man beachte, daß der
angegebene Dateiname ein Pfad zu einer ASCII-Datei sein muß, die eine gültige
Beispielauswertung enthält.
2. Generierung einer Beispielauswertung:
Hier muß neben der Option -b eine der Optionen -c oder -cf angegeben werden. Der Aufruf
xsample -b -c
6HLWH

%HQXW]HUVFKQLWWVWHOOH
liest ein Programm von der Standardeingabe ein, wertet dieses Programm aus und gibt die
erzeugte Beispielauswertung auf der Standardausgabe aus, sofern kein Fehler bei der
Auswertung auftritt. Der Aufruf
xsample -b -cf eingabe.pr
liest ein Programm von der Datei mit dem Dateinamen "eingabe.pr" ein, wertet es aus und gibt
die Beispielauswertung bei Erfolg auf der Standardausgabe aus. Man beachte, daß der
angegebene Dateiname ein Pfad zu einer ASCII-Datei sein muß, die ein gültiges WHILE-
Programm enthält.
Es gibt drei Hauptanwendungen für die Benutzung des Batch-Mode anstelle der interaktiven
Benutzerführung:
(1) Zur Zeitersparnis
Wenn der Benutzer eine vorgegebene Datei synthetisieren oder auswerten will, so ist die
Benutzung des Werkzeugs im Batch-Mode schneller zu bewerkstelligen. Die Eingabe eines
Komamndozeilenbefehls wie etwa der folgende
xsample -b -sf ~/examples/beispiel1.sc > ausgabe.pr
ist für den geübten Benutzer einfacher als den Start der Benutzeroberfläche, die Selektion
des Dateinamens der zu ladenden Beispielauswertung, die Auswahl des Synthesebuttons
und die Auswahl des Dateinamens, unter dem das Ergebnis gespeichert werden soll.
(2) Bei der Verwendung in Shell-Scripten.
(3) Im Zusammenspiel mit anderen Programmen.
In einer UNIX-Umgebung wird die folgende Kommandozeile Sinn machen:
cut -f 2 listing | xsample -c -b -nolog | tee ausgabe.dat | lpr -Plaser
9.4 Das Hauptformular
Das Hauptformular von [VDPSOH 2.0 ist dasjenige Fenster, daß beim Start des Programmes
im interaktiven Modus aufgebaut wird. Im Rahmen der Möglichkeiten des gewählten
Windowmanagers kann das Fenster auf dem Bildschirm bewegt und in seinen Abmessungen
verändert werden, es kann von anderen Fenstern überlagert werden oder selbst andere Fenster
überlagern, auf volle Bildschirmgröße gebracht werden oder zu einem Icon verkleinert werden.
Neben dem Hauptformular beinhaltet das Werkzeug noch weitere dem Hauptformular
untergeordnete Fenster, die Dialogfenster. Diese sind jedoch meistens nicht sichtbar.
Das Hauptformular besteht aus drei Bereichen, die durch eine Separatorline getrennt sind:
ì
ì
ì
Menüzeile
Aktionsfenster
Pushbuttonzeile
6HLWH

%HQXW]HUVFKQLWWVWHOOH
Abbildung 11 : Das Hauptformular von [VDPSOH 2.0
Menüzeile
Beispielauswertung ist
gesichert und keine Auswertung
des angezeigten Programmes
Anzeige eines nicht
geicherten Inhaltes des
Programmtextes
Dateiname der
Beispielauswertung
Aktionsfenster
Textfenster der
Beispielauswertung
Dateiname des
Programmes
(kein
Dateiname
angegeben)
Angezeigtes
Programm ist durch
Synthese der
Beispielauswertung
entstanden
Textfenster
des
Programmes
horizontale
Scrollbar
vertikale
Scrollbar
Pushbuttonzeile
9.4.1 Die Menüzeile
Die Menüzeile befindet sich direkt unterhalb des Fenstertitels und ist (auf Farbbildschirmen)
farblich hervorgehoben. Sie enthält die folgenden Menüs:
ì
ì
ì
ì
ì
File
Edit
Generate
Algorithm
Help
Bei der Bedienung mit der Maus bewegt man den Mauscursor auf den Eintrag des
gewünschten Menüs in der Menüzeile, drückt die linke Maustaste nieder und fährt bei
gehaltener Maustaste am nun aufgeklappten Pulldownmenü herab bis zum gewünschten
Menüeintrag. Beinhaltet dieser Menüeintrag am Ende das Zeichen ➮, wird klappt bei Anwahl
dieses Menüpunktes ein Untermenü auf. Um einen Menüpunkt aus diesem Untermenü
anzuwählen, bewegt man den Mauscursor (bei weiterhin gehaltener linken Maustaste) zum
dem gewünschten Menüeintrag des Untermenüs. Bewegt man den Mauscursor im Hauptmenü
weiter, so verschwindet das Untermenü.
6HLWH

%HQXW]HUVFKQLWWVWHOOH
Ein Menüeintrag wird aktiviert, sobald die linke Maustaste auf diesem Menüeintrag
losgelassen wird. Um keinen Menüpunkt anzuwählen, muß sich der Mauscursor sich beim
Loslassen der linken Maustaste außerhalb jedes Menüeintrags befinden.
Die Menüeinträge können auch mit den Pfeiltasten der Tastatur aufgerufen werden. Dazu
betätigt man die Funktionstaste [F3], während der Tastaturfocus auf dem Hauptformular liegt.
Der Eintrag File in der Menüzeile wird jetzt hervorgehoben gezeichnet. Mit den Tasten [Ç]
und [È] kann jetzt ein Menü angewählt werden. Bei jeder Betätigung der Pfeiltasten wird ein
anderes Menü hervorgehoben. Drückt man die Taste [Ê], während ein Menü hervorgehoben
wird, so klappt an angewählte Menü auf. Mit den Tasten [Ê] und [É] wird ein Menüpunkt
angewählt. Bei Wahl eines durch ➮ gekennzeichneten Menüpunktes klappt ein Untermenü auf.
Um einen Eintrag aus diesem Untermenü zu wählen, bewegt man die Markierung mit der
Taste [È] in das Untermenü hinein und wählt mit den Tasten [Ç] und [È] einen Menüpunkt
aus. Durch Betätigen der Taste [RETURN] wird der in diesem Moment markierte Menüpunkt
aktiviert. Mit der Taste [ESC] kann die Menüauswahl abgebrochen werden.
Des weiteren kann jeder Menüpunkt mit der [ALT]-Taste auf der Tastatur aufgerufen werden.
Das Betätigen der Taste [ALT] zusammen mit dem in einem in der Menüzeile unterstrichenem
Buchstaben öffnet ein Menü. Es gilt (standardmäßig):
[ALT]-F öffnet das File-Menü
[ALT]-E öffnet das Edit-Menü
[ALT]-G öffnet das Generate-Menü
[ALT]-A öffnet das Algorithm-Menü
[ALT]-H öffnet das Hilfemenü
Um einen Menüpunkt in dem geöffneten Menü anzuwählen, drückt man die Taste des
unterstrichenen Buchstabens in dem gewünschten Menüpunkt. Falls ein Untermenü aufklappt,
muß zur Anwahl eines Menüpunktes des Untermenüs die Taste des unterstrichenen
Buchstabens eingegeben werden. Die Menüauswahl kann wieder mit [ESC] abgebrochen
werden.
Einige der wählbaren Operationen sind durch eine weitere Tastenkombination anwählbar, die
dann aber im entsprechenden Menüeintrag angegeben ist.
9.4.2 Das Aktionsfenster
Das Aktionsfenster nimmt den größten Teil des Hauptformulars in Anspruch. Es besteht aus
zwei Fenstern, die durch einen vertikalen Separator getrennt sind. Das linke Fenster ist das
Samplefenster, da in ihm die Beispielauswertung (Sample Computation) angezeigt wird, das
rechte Fenster ist das Programfenster, da in ihm das Programm (Program) angezeigt wird.
Der Schwerpunkt jedes der Teilfensters bildet das Textfenster für die Beispielauswertung oder
das Programm. In ihm wird die momentan bearbeitetet Beispielauswertung bzw. das
momentan bearbeitete Programm angezeigt und kann auch erstellt oder bearbeitet werden. Bei
Auswertung eines Programmes wird die gewonnene Beispielauswertung im Textfenster des
Samplefensters angezeigt, bei der Synthese aus einer Bespielauswertung wird das
synthetisierte Programm im Textfenster des Programfensters angezeigt. Beide Textfenster sind
mit horizontalen und vertikalen Scrollbars versehen.
Über dem Textfenster befindet sich je ein Label, der "Sample Computation" (im
Samplefenster) oder mit "Program" (im Programfenster) beschriftet ist. In der Zeile unterhalb
dieses Labels wird der zuletzt gewählte Dateiname für die Beispielauswertung bzw. für das
Programm angezeigt.
6HLWH

%HQXW]HUVFKQLWWVWHOOH
Des weiteren können neben dem Titellabel die folgenden Hinweise eingeblendet werden (beim
Start des Programmes werden sie nicht angezeigt):
[unsaved] : Der angezeigte Text im entsprechenden Fenster enthält
nicht gesicherte Änderungen.
[computed] : die angezeigte Beispielauswertung ist eine Auswertung des
angezeigten Programmes.
[synthesized] : das angezeigte Programm wurde aus der angezeigten
Beispielauswertung synthetisiert.
Sowohl im Samplefenster als auch im Programfenster kann durch Niederdrücken und Halten
der rechten Maustaste ein Popupmenü aufgeklappt werden. Zum Auswahl eines Menüeintrags
bewegt man den Mauscursor bei gehaltener rechten Maustaste auf den gewünschten
Menüeintrag. Läßt man die Maustaste auf dem gewünschten Menüeintrag los, so wird die
gewählte Operation aktiviert. Zum Abbruch der Menüauswahl läßt man die linke Maustaste
los, während kein Menüpunkt angewählt wird.
Das Popupmenü kann auch durch Betätigen der Taste [F4] im Samplefenster oder durch
Betätigen der Taste [F5] im Programfenster angezeigt werden. Dazu muß der Tastaturfocus
sich auf dem Hauptformular befinden, was standardmäßig der Fall ist, wenn sich der
Mauscursor innerhalb des Fensters des Hauptformulars befindet. Ein Menüpunkt kann dann
mit durch Anklicken mit der linken Maustaste aktiviert werden. Ebenfalls wird mit der Taste
[RETURN] der momentan hervorgehobene Menüpunkt aktiviert. Mit den Pfeiltasten kann ein
anderer Menüpunkt angewählt werden. Man beachte, daß während ein Popupmenü
aufgeklappt ist, eine Aktivierung eines Menüeintrags oder ein Abbruch erfolgen muß. Zum
Abbruch der Menüauswahl kann die Taste [ESC] benutzt werden.
9.4.3 Die Pushbuttonzeile
Als weitere Alternative zum Wahl einer Operation sind in der Pushbuttonzeile vier
Pushbuttons angebracht:
Tabelle 6 : Die Pushbuttonezeile
Pushbutton
Synthesize
Compute
Quit
Help
Operation
Die angezeigte Beispielauswertung wird zu einem Programm
synthetisiert. Das synthetisierte Programm wird im Programfenster
angezeigt.
Das angezeigte Programm wird zu einer Beispielauswertung
ausgewertet, und die gewonnene Beispielauswertung wird im
Samplefenster angezeigt.
[VDPSOH wird beendet.
Ein Hilfefenster wird geöffnet und ein Hilfetext wird angezeigt.
Zum Aktivieren eines Pushbuttons klickt man den betreffenden Button mit der linken
Maustaste an.
9.4.4 Verfügbarkeit der Menüeinträge und Pushbuttons
Nicht immer sind alle Menüeinträge und Pushbuttons verfügbar. Zum Beispiel hat es wenig
Sinn, die angezeigte Beispielauswertung in eine Datei zu sichern, wenn gar keine
6HLWH

%HQXW]HUVFKQLWWVWHOOH
Beispielauswertung angezeigt ist, da das entsprechende Fenster leer ist. Inaktive Menüeinträge
und Pushbuttons sind nicht anwählbar (auch nicht über Tastatur). Wenn ein Buttons nicht
anwählbar ist, wird es schwächer gezeichnet dargestellt, die Aufschrift erscheint in Grau statt
in Schwarz.
9.5 Die Menüs
In diesem Abschnitt wollen wir auf die einzelnen anwählbaren Menüeinträge eingehen.
9.5.1 Pulldownmenüs
Die Menüzeile enthält insgesamt fünf Pulldownmenüs, über die alle wesentlichen
Benutzerkommandos aktiviert werden können.
Im File-Menü sind die Operationen, die den Datenverkehr zur Festplatte betreffen, enthalten.
Es enthält die folgenden Menüeinträge:
Tabelle 7 : Das File-Menü
Menüeintrag
im
Hauptmenü
New
Menüeintrag
im
Untermenü
Operation
Beide Textfenster werden gelöscht.
Load Sample Beispielauswertung von Datei laden, Dateiname
auswählen. Eine eventuell angezeigte
Beispielauswertung wird überschrieben.
Load Program Programm von Datei laden, Dateiname auswählen.
Ein eventuell angezeigtes Programm wird
überschrieben.
Reload Sample Beispielauswertung von Datei laden, zuletzt
benutzten Dateiname einer Beispielauswertung
verwenden. Eine eventuell angezeigte
Beispielauswertung wird überschrieben.
Reload Program Programm von Datei laden, zuletzt benutzten
Dateinamen eines Programmes verwenden. Ein
eventuell angezeigtes Programm wird
überschrieben.
Save As Sample Angezeigte Beispielauswertung in Datei sichern,
Dateiname auswählen. Wenn die gewählte Datei
bereits existiert, wird ihr Inhalt überschrieben.
Save As Program Angezeigtes Programm in Datei sichern, Dateiname
auswählen. Wenn die gewählte Datei bereits
existiert, wird ihr Inhalt überschrieben.
Save Sample Angezeigte Beispielauswertung in Datei sichern,
zuletzt verwendeten Dateinamen einer
Beispielauswertung verwenden. Der vorherige Inhalt
dieser Datei wird überschrieben.
Save Program Angezeigtes Programm in Datei sichern, zuletzt
verwendeten Dateinamen eines Programmes
verwenden. Der vorherige Inhalt dieser Datei wird
6HLWH

%HQXW]HUVFKQLWWVWHOOH
Quit
überschrieben.
[VDPSOH wird beendet.
Das Edit-Menü enthält Operationen für die Textfenster. In der derzeitigen Version von
[VDPSOH sind hier nur vier Operationen pro Textfenster enthalten:
Tabelle 8 : Das Edit-Menü
Menüeintrag
im
Hauptmenü
Menüeintrag
im
Untermenü
Operation
Cut Sample Selektierter Text im Textfenster der
Beispielauswertung in das Clipboard kopieren und
aus dem Text der Beispielauswertung ausschneiden.
Cut Program Selektierter Text im Textfenster des Programms in
das Clipboard kopieren und aus dem Text des
Programms ausschneiden.
Copy Sample Selektierter Text im Textfenster der
Beispielauswertung in das Clipboard kopieren.
Copy Program Selektierter Text im Textfenster des Programms in
das Clipboard kopieren.
Paste Sample Inhalt des Clipboards in den Text der
Beispielauswertung an der Position des Textcursors
einfügen.
Paste Program Inhalt des Clipboards in den Text des Programmes
an der Position des Textcursors einfügen.
Clear Sample Selektion im Textfenster der Beispielauswertung
aufheben.
Clear Program Selektion im Textfenster des Programmes aufheben.
Das Generate-Menü enthält nur die beiden Einträge Synthesize und Compute. Mit der
Aktivierung von Synthesize wird aus der angezeigten Beispielauswertung ein Programm
synthetisiert und dieses angezeigt. Der vorherige Inhalt des Programmfensters wird
überschrieben. Mit Aktivierung von Compute wird aus dem angezeigten Programm eine
Beispielauswertung generiert und diese wird angezeigt. Der vorherige Inhalt des
Samplefensters wird überschrieben.
Im Algorithm-Menü kann ein Algorithmus ausgewählt werden, der für Synthese und
Auswertung verwendet werden kann. Es kann immer nur genau ein Algorithmus ausgewählt
sein. Der ausgewählte Algorithmus wird durch eine Markierung vor dem Menüpunkt
gekennzeichnet. Da im momentanen Entwicklungszustand des Werkzeugs nur ein Algorithmus
zur Verfügung steht, macht die Benutzung des Algorithm-Menüs (noch) keinen Sinn.
Das Help-Menü dient zum Aufruf der Hilfsfunktion und zur Anzeige eines
Informationsfensters.
6HLWH

%HQXW]HUVFKQLWWVWHOOH
Tabelle 9 : Das Help-Menü
Menüeintrag
im Hauptmenü
Help General
Help On Windows
Help On Menues
Help On Buttons
Help On Keys
Info
Operation
allgemeine Hilfe anzeigen
Hilfe über Aufbau des Hauptformulars anzeigen
Hilfe über die Menüeinträge anzeigen
Hilfe über die Pushbuttonzeile anzeigen
Hilfe über Tastaturbindungen anzeigen
Informationen über den Autor des Programmes anzeigen
9.5.2 Popupmenüs
Das Popupmenü des Samplefenster enthält die folgenden Einträge:
Tabelle 10 : Das Popupmenü des Samplefensters
Menüeintrag
Load
Reload
Save As
Save
Synthesize
Operation
Beispielauswertung von Datei laden, Dateiname auswählen.
Eine eventuell angezeigte Beispielauswertung wird
überschrieben.
Beispielauswertung von Datei laden, zuletzt benutzten
Dateiname einer Beispielauswertung verwenden. Eine eventuell
angezeigte Beispielauswertung wird überschrieben.
Angezeigte Beispielauswertung in Datei sichern, Dateiname
auswählen. Wenn die gewählte Datei bereits existiert, wird ihr
Inhalt überschrieben.
Angezeigte Beispielauswertung in Datei sichern, zuletzt
verwendeten Dateinamen einer Beispielauswertung verwenden.
Der vorherige Inhalt dieser Datei wird überschrieben.
Aus angezeigter Beispielauswertung Programm generieren.
Gewonnenes Programm anzeigen. Der bisherige Inhalt des
Programfensters wird überschrieben.
Der Aufbau des Popupmenüs des Programfensters ist ähnlich:
6HLWH

%HQXW]HUVFKQLWWVWHOOH
Tabelle 11 : Das Popupmenü des Programmfensters
Menüeintrag
Load
Reload
Save As
Save
Compute
Operation
Programm von Datei laden, Dateiname auswählen. Ein eventuell
angezeigtes Programm wird überschrieben.
Programm von Datei laden, zuletzt benutzten Dateinamen eines
Programmes verwenden. Ein eventuell angezeigtes Programm
wird überschrieben.
Angezeigtes Programm in Datei sichern, Dateiname auswählen.
Wenn die gewählte Datei bereits existiert, wird ihr Inhalt
überschrieben.
Angezeigtes Programm in Datei sichern, zuletzt verwendeten
Dateinamen eines Programmes verwenden. Der vorherige Inhalt
dieser Datei wird überschrieben.
Aus angezeigtem Programm Beispielauswertung generieren.
Die gewonnene Beispielauswertung wird angezeigt. Der
bisherige Inhalt des Samplefensters wird dabei überschrieben.
9.5.3 Tear-Off-Menüs
Für häufig verwendete Befehle mag es lästig sein, immer ein Menü zuerst aufklappen zu
müssen, bevor man einen Menüeintrag aktivieren kann. Auch das Lernen der entsprechenden
Tastenkombinationen mag nicht jedem Benutzer gefallen. Deswegen gibt es die Möglichkeit,
jedes Menü in einem eigenem Fenster darzustellen. Dazu wählt man mit der Maus oder mit
den Pfeiltasten die gestrichelte Linie über jedem Menü aus und aktiviert diese Linie durch
Loslassen der entsprechenden Maustaste oder durch Betätigen von [RETURN]. In diesem Fall
wird ein neues Fenster geöffnet, daß nur das angewählte Menü enthält, ein sogenanntes Tear-
Off-Menü. Dieses kann beliebig auf dem Bildschirm plaziert werden. Die Anwesenheit eines
Tear-Off-Menüs beeinträchtigt nicht die Funktionsweise der anderen Menüs.
Zum Anwählen eines Menüeintrags aus einem Tear-Off-Menü genügt es den Eintrag mit der
linken Maustaste anzuwählen. Wird hierdurch ein Untermenü aufgeklappt, so kann ein
Menüeintrag angewählt werden durch Ziehen der Maus bei gehaltener linken Maustaste auf
den gewünschten Menüeintrag des Untermenüs und Loslassen der Maustaste auf dem Eintrag.
Zum Schließen des Tear-Off-Menüs betätigt man die Taste [ESC], während der Mauscursor
sich innerhalb des Fensters des Tear-Off-Menüs befindet.
6HLWH

%HQXW]HUVFKQLWWVWHOOH
Abbildung 12 : Tear-Off-Menüs
9.5.4 Zusammenstellung der Menübefehle
Alle Operationen, die durch die Menüs ausgelöst werden können, sind in der folgenden Tabelle
zusammengefaßt. Dabei bedeutet eine Anweisung für einen Menüeintrag wie File-Load-
Sample, daß im File-Menü der Menüpunkt Load und dann in dem nun aufgeklappten
Untermenü der Menüpunkt Sample anzuwählen ist. Die Tastatureingabe [CTRL]-L bedeutet,
daß die Taste L bei gehaltener [CTRL]-Taste zu betätigen ist. Dabei spielt es keine Rolle, ob
die [SHIFT]-Taste gedrückt wurde (großes L) oder nicht (kleines l).
Tabelle 12 : Zusammenstellung der Menübefehle
Operation
Sample Computation
von Datei laden
Program von Datei
laden
zuletzt geladene oder
gesicherte Sample
Computation laden
zuletzt geladenes oder
gesichertes Program
Bedienung in
Menüzeile
File - Load -
Sample wählen
File - Load -
Program wählen
File - Reload -
Sample wählen
File - Reload -
Program wählen
Bedienung in
Popupmenü
Load wählen
(im Samplefenster)
Load wählen
(im Programfenster)
Reload wählen
(im Samplefenster)
Reload wählen
(im Programfenster)
Bedienung mit
Tastatur
[CTRL]-L
oder [ALT]-F L S
[CTRL]-O
oder [ALT]-F L P
[ALT]-F R S
[ALT]-F R P
6HLWH

%HQXW]HUVFKQLWWVWHOOH
laden
Sample Computation in
Datei speichern, zuletzt
gewählter Dateiname
verwenden
Program in Datei
speichern, zuletzt
gewählter Dateiname
verwenden
Sample Computation in
Datei speichern, neuer
Dateiname wählen
Program in Datei
speichern, neuer
Dateiname wählen
gewählte Selektion im
Samplefenster in
Clipboard kopieren
gewählte Selektion im
Programfenster in
Clipboard kopieren
gewählte Selection im
Samplefenster
ausschneiden und in
Clipboard kopieren
gewählte Selection im
Programfenster
ausschneiden und in
Clipboard kopieren
Inhalt des Clipboard an
Position des
Textcursores im
Samplefenster
einfügen
Inhalt des Clipboard an
Position des
Textcursores im
Programfenster
einfügen
Selektion im
Samplefenster
aufheben
Selektion im
Programfenster
aufheben
Sample Computation
synthetisieren
(auch über Pushbutton
möglich)
Program auswerten
(auch über Pushbutton
möglich)
File - Save -
Sample wählen
File - Save -
Program wählen
File - SaveAs -
Sample wählen
File - SaveAs -
Program wählen
Edit - Copy -
Sample wählen
Edit - Copy -
Program wählen
Edit - Cut - Sample
wählen
Edit - Cut - Program
wählen
Edit - Paste -
Sample wählen
Edit - Paste -
Program wählen
Edit - Clear -
Sampe wählen
Edit - Clear -
Program wählen
Generate -
Synthesize wählen
Generate -
Compute wählen
Save wählen
(im Samplefenster)
Save wählen
(im Programfenster)
SaveAs wählen
(im Samplefenster)
SaveAs wählen
(im Programfenster)
Copy wählen
(im Samplefenster)
Copy wählen
(im Programfenster)
Cut wählen
(im Samplefenster)
Cut wählen
(im Programfenster)
Paste wählen
(im Samplefester)
Paste wählen
(im Programfester)
Clear wählen
(im Samplefenster)
Clear wählen
(im Programfenster)
Synthesize wählen
(im Samplefenster)
Compute wählen
(im Programfenster)
[CTRL]-S
oder [ALT]-F S S
[CTRL]-A
oder [ALT]-F S P
[ALT]-F A S
[ALT]-F A P
[F7]
oder [ALT]-E C S
[F9]
oder [ALT]-E C P
[SHIFT]-[F7]
oder [ALT]-E T S
[SHIFT]-[F9]
oder [ALT]-E T P
[F8]
oder [ALT]-E P S
[F10]
oder [ALT]-E P P
[SELECT]
(im
Samplefenster)
[SELECT]
(im
Programfenster)
[CTRL]-Y
oder [ALT]-G S
[CTRL]-C
oder [ALT]-G C
6HLWH

%HQXW]HUVFKQLWWVWHOOH
Sample Computation
und Program löschen
[VDPSOH beenden
(auch über Pushbotton
möglich)
Standardalgorithmus
wählen
Allgemeine Hilfe
anzeigen
(auch über Pushbutton
möglich)
Hilfe zum
Hauptformular
anzeigen
Hilfe zu Menues
anzeigen
Hilfe zur
Tastaturbelegung
anzeigen
Hilfe zu Pushbuttons
anzeigen
File - New wählen nicht möglich [CTRL]-N
oder [ALT]-F N
File - Quit wählen nicht möglich [CTRL]-Q
oder [ALT]-F Q
Algorithm-Standard
wählen
Help-General
wählen
Help-Windows
wählen
nicht möglich
nicht möglich
nicht möglich
[ALT]-A S
[F1]
oder [ALT]-H G
[ALT]-H W
Help-Menu wählen nicht möglich [ALT]-H M
Help-Keys wählen nicht möglich [ALT]-H K
Help-Buttons
wählen
nicht möglich
[ALT]-H B
9.6 Textbearbeitung
Mit der graphischen Benutzeroberfläche von [VDPSOH 2.0 können eine Beispielauswertung
und ein WHILE-Programm nicht nur gleichzeitig angezeigt, sondern auch erstellt oder
bearbeitet werden. Hierzu muß der Tastaturfocus auf den entsprechenden Fenster sein. Das
heißt, wenn die Beispielauswertung bearbeitet werden soll, muß der Tastaturfocus auf dem
linken Textfenster stehen, soll das Programm bearbeitet werden, muß der Tastaturfocus auf
dem rechten Textfenster stehen. Standardmäßig erhält das Fenster den Tastaturfocus, in dem
sich der Mauscursor befindet.
Überschreitet die Zahl der Zeilen des Textes die Zahl der angezeigten Zeilen, so wird das
Textfenster nicht vergrößert, statt dessen wird immer nur ein Teilstück des Textes angezeigt.
Der Balken innerhalb der vertikale Scrollbar an der Seite des Textfensters zeigt die
angezeigten Zeilen im Bezug zu dem gesamten Text. Bewegt man den Balken mit der Maus
bei gehaltener mittleren Maustaste nach oben oder nach unten, so verschiebt man damit
gleichzeitig auch den angezeigten Ausschnitt des Textes gegen den Anfang oder dem Ende des
Gesamttextes zu. Klickt man mit der mittleren Maustaste auf eine beliebige Position der
Scrollbar, so wir der angezeigte Text so gewählt, daß der Balken sich an der Position der
Maus befindet. Klickt man mit der linken Maustaste auf die Scrollbar oberhalb des Balkens,
so scrollt der angezeigte Text um eine Bildschirmseite (das heißt um so viele Zeilen, wie
gleichzeitig angezeigt werden) nach oben oder an den Anfang des Textes, falls dies nicht
möglich ist. Klickt man mit der linken Maustaste auf der Scrollbar unterhalb des Balkens, so
scrollt der angezeigte Text eine Seite nach unten (oder zum Ende des Textes). Dasselbe gilt
analog bei Überschreitung der Zahl der angezeigten Spalten und der horizontalen Scrollbar.
Die Textfenster von [VDPSOH 2.0 eignen sich keineswegs zur Textverarbeitung, da es keine
einfache Möglichkeit zur Eingabe und Darstellung von Textformaten gibt, insbesondere
unterstützt das Werkzeug kein WYSIWYG. Auch fehlen den Textfenstern (noch) viele
Funktionen der gebräuchlichen Texteditoren.
6HLWH

%HQXW]HUVFKQLWWVWHOOH
Die Einfügeposition in einem Textfenster ist immer die Position des Textcursors. Der
Textcursor ist als 'I' dargestellt und wird auch angezeigt, wenn das Textfenster keinen
Tastaturfocus besitzt. Erhält das Fenster aber den Focus, so wird der Textcursor stärker
gezeichnet und blinkt (sofern dies nicht mit der Resource "xsample*blinkRate"
verhindert wird).
Zum Einfügen eines Zeichens an der Position des Textcursors drückt man einfach die
entsprechende Taste auf der Tastatur. Es erfolgt kein automatischer Zeilenumbruch. Zum
Einfügen eines Zeilenumbruchs ist am Ende der Zeile, hinter der der Umbruch eingefügt
werden soll, die Taste [RETURN] (Eingabetaste) zu betätigen. Mit der Taste [TAB]
(Tabulatortaste) wird ein Tabulatorzeichen in den Text eingefügt. Das Tabulatorzeichen wird
als eine Folge von Leerzeichen dargestellt.
Zum Löschen des Textes existieren die folgenden Tastenkombinationen:
Tabelle 13 : Tastenkombination zum Löschen von Text
Zeichen links der Position des Textcursors löschen
Zeichen rechts der Position des Textcursors
löschen
[BACKSPACE]
[DELETE]
Zum Positionieren des Textcursors mit der Maus innerhalb des angezeigten Textabschnittes
klickt man mit der linken Maustaste auf die gewünschte neue Position des Textcursors. Soll
eine etwaige Selektion nicht verändert werden, so muß beim Drücken der linken Maustaste
gleichzeitig die [CTRL]-Taste betätigt werden. Zum Positionieren des Textcursors mittels der
Tastatur existieren die folgenden Möglichkeiten:
Tabelle 14 : Tastenkombinationen zum Bewegen des Textcursors
Textcursor ein Zeichen nach links bewegen
Textcursor ein Wort nach links bewegen
Textcursor eine Bildschirmseite nach links
bewegen
Textcursor an den Anfangs der Zeile bewegen
Textcursor ein Zeichen nach rechts bewegen
Textcursor ein Wort nach rechts bewegen
Textcursor eine Bildschirmseite nach rechts
bewegen
Textcursor an das Ende der Zeile bewegen
Textcursor eine Zeile nach oben bewegen
Textcursor an den Anfang des Absatzes bewegen
Textcursor eine Bildschirmseite nach oben
bewegen
Textcursor an den Anfang des Textes bewegen
Textcursor eine Zeile nach unten bewegen
Textcursor an das Ende des Absatzes bewegen
Textcursor ein Bildschirmseite nach unten
bewegen
Textcursor an das Ende des Textes bewegen
[←]
[CTRL]-[←]
[CTRL]-[PAGE UP]
[ALT]-[←]
[→]
[CTRL]-[→]
[CTRL]-[PAGE DOWN]
[ALT]-[→]
[↑]
[CTRL]-[↑]
[PAGE UP]
[CTRL]-[ALT]-[←]
[↓]
[CTRL]- [↓]
[PAGE DOWN]
[CTRL]-[ALT]-[→]
Dabei müssen Absätze durch eine Leerzeile getrennt sein.
6HLWH

%HQXW]HUVFKQLWWVWHOOH
Um mehr als ein Zeichen auf einmal einfügen, löschen, kopieren oder bewegen zu können,
muß mit Selektionen gearbeitet werden. Zum Erstellen einer Selektion bewegt man den
Mauscursor zum Anfang des zu selektierenden Bereiches und zieht die Maus bei gehaltener
linken Maustaste zum Ende des zu selektierenden Bereiches. Überschreitet der Mauscursor
dabei die Fenstergrenzen, so wir der Text automatisch weitergescrollt in die Richtung, in der
der Mauscursor das Fenster verlassen hat. Beim Loslassen der linken Maustaste wird die
Selektion invers dargestellt. Ist die linke Maustaste losgelassen, so führt ein weiterer Klick mit
der linken Maustaste in das Textfenster, ohne daß eine weitere Taste gleichzeitig betätigt wird,
die Aufhebung der Selektion. Denselben Effekt hat auch die Wahl des Menüeintrages Clear im
Edit-Menü oder im Popupmenü des bearbeiteten Textfensters. Soll die Selektion erweitert
werden, so ist gleichzeitig zur linken Maustaste die [SHIFT]-Taste zu betätigen. Dann wird
die Selektion zur Position des Mauszeigers ausgedehnt.
Es gibt drei abkürzende Operationen zum Anlegen einer Selektion mit der Maus:
ì Ein Doppelklick mit der linken Maustaste selektiert das Wort, in dem sich der Mauszeiger
befindet.
ì
Ein Dreifachklick markiert die Zeile, in der sich der Mauscursor befindet.
ì Ein Vierfachklick markiert den vollständigen Text (nicht nur den angezeigten Ausschnitt).
Mit der Tastatur kann eine Selektion mit denselben Tastenkombinationen wir zum Bewegen
des Textcursors erstellt und erweitert werden, wenn zusätzlich die Taste [SHIFT] gehalten
wird. Zum Aufheben der Selektion dient die Taste [SELECT]. Um den vollständigen Text zu
selektieren, kann man die Tastenkombination [CTRL]-/ verwenden. Um die Selektion des
ganzen Textes wieder aufzuheben, verwendet man [CTRL]-\.
Ein selektierter Text kann mit der Tastenkombination [CTRL]-[DELETE] mit Leerzeichen
überschrieben werden. Um die Selektion zu löschen, gibt man einfach ein beliebiges Zeichen
ein, solange sich der Textcursor noch innerhalb der Selektion befindet. In diesem Fall wird die
Selektion aus dem Text durch das eingegebene Zeichen überschrieben. Diese Einstellung kann
mit der Resource "xsample*sampleText.pendingDelete" bzw.
"xsample*programText.pendingDelete" abgeschaltet werden.
Um den selektierten Text zu einer anderen Stelle zu kopieren, bewegt man die Maus an die
Stelle, an der der neue Text eingefügt werden soll, und klickt mit der mittleren Maustaste.
Dann wird der Text an der neuen Stelle eingefügt. Die Markierung der Selektion verschwindet.
Trotzdem bleibt die Selektion gespeichert und kann weiterhin an anderen Stellen eingefügt
werden, bis die Selektion aufgehoben wird, oder ein neuer Text selektiert wird. Soll der Text
von einer Stelle zur anderen verschoben werden, so ist gleichzeitig mit dem Klicken der
mittleren Maustaste die [SHIFT]-Taste zu halten. In diesem Fall wird der selektierte Text an
der neuen Stelle eingefügt und an der alten Position gelöscht. Es ist nicht möglich, selektierten
Text an eine Position innerhalb des selektierten Textes zu kopieren oder zu verschieben.
Es ist nicht nur möglich selektierten Text innerhalb eines Textfensters zu kopieren oder zu
verschieben, es ist auch möglich, den Text zwischen den beiden Textfenstern von [VDPSOH
2.0 auszutauschen. Es ist sogar möglich, Text zwischen verschiedenen X-Anwendungen
auszutauschen. Damit kann eine Selektion eines Textes innerhalb eines Textfensters von
[VDPSOH in das Fenster einer anderen X-Anwendung eingefügt werden, bzw. eine Selektion,
die in einem Fenster eines anderen Programmes angelegt worden ist, in das Textfenster von
[VDPSOH zu schreiben. Ob ein solcher Datenaustausch tatsächlich so einfach realisierbar ist,
hängt von der betroffenen Anwendung ab.
Wird der Austausch über die Selektion nicht unterstützt, oder soll ein Text über die
Lebensspanne der Selektion hinaus aufgehoben werden, so bietet sich die Speicherung im
6HLWH

%HQXW]HUVFKQLWWVWHOOH
Clipboard an. Das Clipboard ist ein universeller Zwischenspeicher, der von allen X-
Anwendungen gelesen und beschrieben werden kann.
Um eine Selektion in das Clipboard zu kopieren, wählt man im Edit-Menü oder im
Popupmenü des Textfensters den Menüpunkt Copy an. Will man die Selektion ins Clipboard
kopieren, gleichzeitig die Selektion löschen, so wählt man statt dessen den Menüpunkt Cut an.
Alternativ kann man eine Selektion kopieren über die Taste [F7] für das Samplefenster bzw.
der Taste [F9] für das Programfenster. Um die Selektion auszuschneiden und ins Clipboard zu
kopieren kann man die Tastenkombinationen [SHIFT]-[F7] bzw. [SHIFT]-[F9] verwenden.
Der Inhalt des Clipboard (der selbstverständlich auch von einer anderen X-Anwendung
beschrieben worden sein kann) läßt sich mittels des Menüpunktes Paste des Edit-Menüs oder
des Popupmenüs des entsprechenden Fensters einfügen. Über die Tastatur ist das Einfügen mit
[F8] für das Samplefenster bzw. [F10] für das Programfenster möglich.
9.7 Dialogfenster
Sinn und Zweck des Hauptformulars ist die Bereitstellung von Kommandoelementen zur
Steuerung des Programmes und die Anzeige und Bearbeitung der Texte für das Programm und
die Beispielauswertung. Ist darüber hinaus eine Kommunikation mit dem Benutzer notwendig,
so werden weitere Fenster geöffnet, sogenannte Dialogfenster. Diese Fenster sind dem
Hauptformular untergeordnet. Das heißt, daß diese Fenster beim Schließen oder beim
Iconifizieren des Hauptformulars verschwinden. Sie lassen sich in der Regel (abhängig vom
verwendeten Windowmanager) nicht iconifizieren oder in ihrer Größe verändern, jedoch kann
man sie auf dem Bildschirm verschieben. Die Dialogfenster von [VDPSOH sind normalerweise
nicht sichtbar. Sie werden nur angezeigt, wenn sie einen bestimmten Zweck zu erfüllen haben,
eine Mitteilung an den Benutzer oder die Auswahl eines Dateinamens. Haben sie ihren Zweck
erfüllt, verschwinden sie wieder von Bildschirm.
Alle Dialogfenster von [VDPSOH 2.0 sind modeless. Das heißt, es wird keine sofortige
Reaktion des Benutzers auf das Dialogfenster erwartet, weder [VDPSOH noch ein anderes
gleichzeitig ablaufendes Programm werden in ihren Eingaben gesperrt. Inwieweit das
Ignorieren des Dialogfensters zum Beispiel im Falle einer Fehlermeldung sinnvoll ist, bleibt
dem Benutzer überlassen.
9.7.1 Sicherheitsabfragen
Bei bestimmten Operation, wie dem Verlassen des Programmes oder dem Laden einer neuen
Datei wird eine Abfragebox geöffnet mit der Bitte um Bestätigung der gewählten Operation.
Die Abfragebox besteht nur aus einem Label mit der Mitteilung und dreier Pushbutton:
Durch Betätigen des linken Pushbuttons mit der linken Maustaste wird die gewählte Operation
fortgesetzt, durch Betätigen des mittleren Pushbuttons wird die Operation abgebrochen. In
beiden Fällen verschwindet die Abfragebox sofort wieder von der Anzeigefläche. Zur
Bestätigung der gewählten Operation kann auch die Taste [RETURN] verwendet werden, zum
Abbruch die Taste [ESC]. Dies gilt allerdings nur, wenn das Dialogfenster den Tastaturfocus
besitzt. Normalerweise muß dazu der Mauscursor sich innerhalb der Abfragebox befinden.
Die Sicherheitsabfrage erscheint immer über der Position des Mauscursors.
6HLWH

%HQXW]HUVFKQLWWVWHOOH
Abbildung 13 : Das Dialogfenster der Sicherheitsabfrage
Text der
Sicherheitsabfrage
Button zum Bestätigen der Operation
Hilfebutton
Button zum Abbruch der
Operation
9.7.2 Warnungen
Abbildung 14 : Die Warnungsbox
Text der Warnung
Button zum Bestätigen
der Operation
Button zum Abbruch der
Operation
Hilfebutton
Warnungen werden ausgegeben, wenn eine Operation angewählt wurde, durch die nicht
gespeicherte Änderungen im Inhalt eines der Textfenster oder in beiden Textfenstern gelöscht
werden. Man kann eine Warnung als zweite Sicherheitsabfrage auffassen. Die Warnungsbox
gleicht der Abfragebox. Wiederum sind unter dem Label mit dem Text der Warnung drei
Buttons angebracht. Zum Bestätigen der Operation und damit Überschreiben der nicht
gespeicherten Änderungen klickt man mit der linken Maustaste auf den linken Pushbutton.
Zum Abbruch der gewählten Operation klickt man auf den mittleren Pushbutton. Durch einen
Klick mit der linken Maustaste auf den Pushbutton wird ein weiteres Fenster mit einem
Hilfetext geöffnet. Befindet sich der Tastaturfocus auf dem Dialogfenster, so genügt auch das
Betätigen der Taste [RETURN] zur Bestätigung der gewählten Operation und das Betätigen
der Taste [ESC] zum Abbruch.
Die Warnungsbox verschwindet vom Bildschirm, sobald die gewählte Operation bestätigt oder
abgebrochen wird. Dialogbox erscheint über der Position des Mauscursors.
9.7.3 Die Dateiauswahlbox
Zur Auswahl eines Dateinamens dient die Dateiauswahlbox. Das Fenster der
Dateiauswahlbox besteht aus vier Teilen:
ì
ì
ì
dem Fenster des Dateifilters
der Verzeichnis- und der Dateiliste
dem Fenster des Dateinamens
6HLWH

%HQXW]HUVFKQLWWVWHOOH
ì vier Pushbuttons
Standardmäßig wird zuerst versucht, eine Datei in dem Verzeichnis zu suchen, von dem aus
[VDPSOH gestartet wurde. Deswegen zeigt das Verzeichnisfenster alle Unterverzeichnisse
(inklusive . und ..) in diesem Verzeichnis an und das Dateifenster die restlichen Dateien an,
sofern sie dem gewählten Filter entsprechen (auch versteckte Dateien, aber die entsprechen
selten dem Filter.
Abbildung 15 : Die Dateiauswahlbox
Fenster des Dateifilters
Verzeichnisliste
Dateiliste
Vertikale Scrollbar
Horizontale Scrollbar
Fenster des Dateinamens
Auswahl akzeptieren
Dateiliste und Verzeichnisliste
neu einlesen
gewählte Operation
abbrechen
Hilfebox
Der gewählte Filter wird im Fenster des Dateifilters angezeigt. Der Eintrag besteht
normalerweise aus dem aktuellem Verzeichnis und dem Filter *.sc, wenn eine
Beispielauswertung angewählt werden soll und *.pr, wenn ein Programm angewählt werden
soll. Diese Vorgaben können über Resourcen geändert werden. Aber auch in einer geöffneten
Dateiauswahlbox kann der Dateifilter verändert werden. Zum Beispiel sollte man den Eintrage
nach dem Verzeichnispfad auf * verkürzen, um alle Dateien angezeigt zu bekommen. Um die
Änderung auszuführen, muß die Taste [RETURN] gedrückt werden, während sich der
Tastaturfocus im Fenster des Dateifilters befindet, oder der zweite Pushbutton (apply) mit der
linken Maustaste angeklickt werden.
Im Fenster des Dateinamens steht der gewählte Dateiname (oder nur ein Verzeichnis, falls
noch kein Dateiname ausgewählt worden ist). Es ist möglich, in dieses Fenster direkt den
Dateinamen hineinzuschreiben. Dies muß immer getan werden, wenn der Name einer bisher
nicht vorhandenen Datei ausgewählt werden soll. Dazu bewegt man den Mauscursor in das
Fenster des Dateinamens hinein, so daß das Fenster den Tastaturfocus erhält.
Als Alternative im Fall, daß der Name einer bereits existierenden Datei angewählt werden soll,
kann der Dateiname in der Dateiliste mit der linken Maustaste angeklickt werden.
Überschreitet die Zahl der Dateien die Zahl der Zeilen in der Dateiliste, so kann die seitliche
Scrollbar wie die Scrollbar in einem Textfenster verwendet werden, um die Anzeige zu
6HLWH

%HQXW]HUVFKQLWWVWHOOH
verschieben. Die Dateien in der Auswahlliste können auch mit der [RETURN]-Taste
angewählt werden, sofern die betreffende Datei invers dargestellt wird. Über die Pfeiltasten
besteht eine weitere Möglichkeit der Auswahl einer Datei.
Der gewählte Dateiname kann jederzeit geändert werden, bis die Dateiauswahl abgeschlossen
wird. Die Dateiauswahl wird abgeschlossen wenn:
ì
ì
ì
ì
Die Taste [RETURN] gedrückt wird, während der Tastaturfocus im Fenster des
Dateinamens steht und in diesem Fenster ein Dateiname steht.
Die Taste [RETURN] gedrückt wird, während der Tastaturfocus im Dateifenster steht und
ein Dateiname markiert ist. Dann wird der markierte Dateiname angewählt.
Ein Dateiname im Dateifenster mit der linken Maustaste doppeltgeklickt wird. In diesem
Fall wird auch dieser Dateiname gewählt.
Der linke Pushbutton (ok) mit der linken Maustaste gedrückt wird, und im Fenster des
Dateinamens ein Dateiname steht.
Nach erfolgter Auswahl, wird die gewählte Operation (sichern oder laden) fortgesetzt und die
Dateiauswahlbox geschlossen.
Zum Wechsel eines Verzeichnisses kann der Pfad des Verzeichnisses im Fenster des
Dateinamens angegeben werden oder ein Verzeichnisfenster ein Verzeichnis angewählt
werden. Dies geschieht analog wie bei der Auswahl eines Dateinamens, jedoch wird die
gewählte Operation nicht fortgesetzt und die Dateiauswahlbox nicht geschlossen sondern das
Verzeichnis im Fenster des Dateinamens und im Fenster des Dateifilters auf das gewählte
Verzeichnis geändert. Das Verzeichnisfenster und das Dateifenster zeigen jetzt den Inhalt des
neuen Verzeichnissen an.
Mit einem Klick mit der linken Maustaste auf den zweiten Pushbutton (apply) wird das
Verzeichnis nochmals gelesen (z.B. wenn sich der Inhalt geändert hat, während das
Dateiauswahlfenster geöffnet ist).
Ein Klick auf den dritten Pushbutton (cancel) bricht die gewählte Operation ab und schließt
die Dateiauswahlbox. Denselben Effekt hat auch die Taste [ESC], während sich der
Tastaturfocus innerhalb der Dateiauswahlbox befindet. Über den rechten Pushbutton kann ein
Fenster mit einem Hilfetext aufgerufen werden.
Eine Dateiauswahlbox erscheint immer an der Position des Mauszeigers.
9.7.4 Hilfetexte
Eine Hilfebox erscheint aus einem der folgenden Gründe:
ì
ì
ì
ì
Die Taste [F1] wurde betätigt.
Eine der Menüpunkte im Hilfemenü wurde angewählt.
Der Hilfebutton in der Kommandozeile wurde angeklickt.
In einem Dialogfenster wurde der rechte Pushbutton (help) angeklickt.
Das Hilfefenster erscheint immer in der Mitte des Hauptformulars (um kein anderes
Dialogfenster zu überdecken). Neben dem Label mit dem (hoffentlich erhellenden) Hilfetext
enthält die Hilfebox zwei Pushbuttons. Ein Mausklick (mit der linken Maustaste) auf den
linken Pushbutton (ok) schließt das Fenster, während ein Klick auf den rechten Pushbutton ein
weiteres Hilfefenster erscheinen läßt. Wenn der Tastaturfocus auf dem Dialogfenster liegt,
kann das Fenster auch mit der [RETURN]-Taste geschlossen werden.
6HLWH

%HQXW]HUVFKQLWWVWHOOH
Abbildung 16 : Die Hilfebox
Hilfetext
Hilfefenster
schließen
Hilfetext
anzeigen
9.7.5 Fehlermeldungen
Bei der interaktiven Benutzerführung werden Fehlermeldungen ebenfalls in einem
Dialogfenster ausgegeben. Die Dialogbox erscheint in der Mitte des Hauptformulars. Neben
dem Text der Fehlermeldung enthält das Fenster zwei Pushbuttons. Ein Klick mit der linken
Maustaste auf den linken Pushbutton (ok) schließt das Fenster, ebenso das Betätigen der Taste
[RETURN]. Durch einen Klick auf den rechten Pushbutton (help) öffnet sich eine Hilfebox.
9.7.6 Die Fehlerprotokollbox
Bei einigen Fehlermeldungen wird zusätzlich ein Fehlerprotokoll angezeigt. Das
Fehlerprotokoll wird in einem eigenen Fenster angezeigt, welches unterhalb des Fenster mit
der Fehlermeldung aufgebaut wird.
Neben der Anzeige des Fehlerprotokolls enthält die Dialogbox zwei Pushbuttons. Ein Klick
mit der linken Maustaste auf den linken der Buttons (oder das Betätigen der Taste [RETURN]
schließt das Dialogfenster. Ein Klick auf den rechten Pushbutton öffnet ein Fenster mit einem
Hilfetext.
Überschreitet das Fehlerprotokoll die Größe des Fensters, so wird nur ein Teil des
Fehlerprotokolls angezeigt. Gleichzeitig erscheinen Scrollbars an den Seiten des angezeigten
Textes, mit denen (analog wie beim Textfenster) der Ausschnitt des angezeigten Protokolls
verschoben werden kann.
6HLWH

%HQXW]HUVFKQLWWVWHOOH
Abbildung 17 : Das Fehlermeldedialogfenster und das Fehlerprotokollfenster
Fehlerprotokoll
vertikale
Scrollbar
Fehlermeldung
Hilfebutton
Fenster
schließen
9.7.7 Die Infobox
Die Infobox dient nur zur Anzeige einer Information über das Werkzeug und seinen Autor. Sie
wird über dem Mauscursor sichtbar. Die Infobox besitzt nur einen einzigen Pushbutton. Klickt
man diesen Button mit der linken Maustaste an, so wird die Infobox geschlossen.
9.8 Die Syntax der Hilfetexte und Fehlermeldungen
Den Dateien der Hilfetexten und Fehlermeldungen liegt dasselbe Format zugrunde. Sie werden
in einer gewöhnlichen ASCII-Datei gespeichert, wobei alle Hilfetexte in einer Datei stehen
müssen, und alle Fehlermeldungen in einer Datei stehen müssen. Die Einträge stehen dabei
hintereinander, wobei die Reihenfolge der Einträge wichtig ist.
Jeder Eintrag eines Hilfetextes bzw. einer Fehlermeldung beginnt mit einer Kopfzeile, deren
erstes Zeichen ein "@" sein muß. Alle Zeilen zwischen zwei Kopfzeilen (außer
Kommentarzeilen) bzw. zwischen der letzten Kopfzeile und dem Dateiende werden zu einem
Eintrag gezählt. Kommentarzeilen werden immer überlesen. Erstes Zeichen einer
Kommentarzeile muß das Zeichen "!" sein. Ebenso werden alle Zeilen vor der ersten
Kopfzeile überlesen. Es versteht sich, daß keine Zeile eines Hilfetextes oder einer
Fehlermeldung mit "@" oder mit "!" beginnen darf.
6HLWH

3RUWLHUXQJHQ
10 Portierungen
Das Werkzeug wurde erfolgreich auf folgenden Systemen implementiert und getestet:
u SUN-SPARC-Cluster der AG Wiehagen unter
w SunOs 5.5
w Gnu C++ 2.7.2
w X11R6
w Motif 1.2
u AIX-Cluster des RHRK (IBM RS6000) unter
w Aix 3.2.5
w Gnu C++ 2.7.2
w X11R6
w Motif 1.2
u Ausbildungscluster des IRZ Kaiserslautern (SUN) unter
w SunOs 4.1.2
w Gnu C++ 2.7.2
w X11R5
w Motif 1.2
u Intel DX2/66 - PC unter
w Linux 2.0.10
w Gnu C++ 2.7.2
w X11R6
w Motif 2.0
6HLWH

%HLVSLHOHYRQ3URJUDPPOlXIHQ
11 Beispiele von Programmläufen
12 Programmläufe im Batch-Modus
Bei der Benutzung des Werkzeuges zur Auswertung eines WHILE-Programmes im Batch-
Modus kann das Programm entweder in einer ASCII-Text vorliegen oder von der
Standardeingabe eingelesen werden. Wenn es von der Standardeingabe eingelesen wird, so
wird die Eingabe für [VDPSOH von einem anderen UNIX-Programm geliefert. Es ist
selbstverständlich möglich, den Text des WHILE-Programmes direkt über die Tastatur
einzugeben. Der folgende Programmlauf wurde aus einem mit 'script' erstellten Shell-Protokoll
ausgeschnitten:
Script started on Fri Apr 25 13:51:56 1997
christof@nafteta[~/sample] % xsample -b -c
input (a,b,c)
set (d := 50)
with while a > 0 do
with set (e := 40) while b > 0 do
e ++e ++e --b
end while
--a --a ++c
end while
output c
input (10, 20, 30)
test
10 > 0
do
test
20 > 0
do
40 41 42 19
end test
test
19 > 0
do
42 43 44 18
end test
9 8 31
end test
test
8 > 0
do
test
18 > 0
do
40 41 42 17
end test
6HLWH

%HLVSLHOHYRQ3URJUDPPOlXIHQ
test
17 > 0
do
42 43 44 16
end test
7 6 32
end test
output 32
christof@nafteta[~/sample] % exit
script done on Fri Apr 25 13:55:43 1997
Bei der Benutzung des Werkzeugs zur Generierung einer Beispielauswertung ist es
schwieriger, den Text der Beispielauswertung direkt einzugeben, aber dennoch möglich. Auch
hier wird üblicherweise die Eingabe von Datei oder über eine Pipe gelesen.
Script started on Fri Apr 25 16:12:26 1997
christof@nafteta[~/sample] % xsample -b -s
input (10,20,30)
test 10 < 20 do
11 12 13 19
test 30 > 0 do
writeln (29);
next_value = 29
end test
test 29 > 0 do
writeln (28);
next_value = 28
end test
test 28 > 0 do
writeln (27);
next_value = 27
end test
test 27 > 0 skip
end test
test 13 < 19 do
14 15 16 18
test 27 > 0 do
writeln (26);
next_value = 26
end test
test 26 > 0 do
writeln (25);
next_value = 25
end test
end test
output 25
input (x0, x1, x2)
set (x3 := 0)
with
6HLWH

%HLVSLHOHYRQ3URJUDPPOlXIHQ
while
x0 x3
do
writeln ( --x2 );next_value =x2
end while
end while
output x2
christof@nafteta[~/sample] % exit
script done on Fri Apr 25 16:17:47 1997
13 Programmläufe mit der graphischen Benutzeroberfläche
Es ist für die meisten Anwender einfacher, das Werkzeug über die graphische
Benutzeroberfläche zu bedienen. Um die Funktionalität des Werkzeugs einschätzen zu können,
haben wir bei den hier eingefügten Testläufen immer nur ein WHILE-Programm vorgegeben,
dieses ausgewertet und aus der generierten Beispielauswertung wieder eine WHILE-
Programm zu synthetisieren. Auf diese Weise können wir die Güte des Programmes
einschätzen, das ursprüngliche Programm zurückzugewinnen.
6HLWH

%HLVSLHOHYRQ3URJUDPPOlXIHQ
14 Beispiel 1
Abbildung 18 : Beispiel 1 - Programmauswertung
Abbildung 18 zeigt einen einfachen Programmlauf über die graphische Benutzeroberfläche.
Jedes while-Konstrukte wird genau zweimal entfaltet. Dies ist die zur Synthese notwendige
Mindestzahl. Als Werte für die Eingabevariable werden Vielfache der Zahl 10 verwendet
(diese Festlegung ist willkürlich). Man beachte, daß der Kommentar und die Variable w in der
Auswertung nicht auftauchen.
Betrachten wir nun das aus der Auswertung zurücksynthetisierte Programm in der Abbildung
19:
Die nicht verwendete Variable w taucht hier nicht auf, ebensowenig wie der Kommentar.
Ansonsten stimmen aber das eingegebene und das synthetisierte Programm überein.
6HLWH

%HLVSLHOHYRQ3URJUDPPOlXIHQ
Abbildung 19 : Beispiel 1 - Programmsynthese
6HLWH

%HLVSLHOHYRQ3URJUDPPOlXIHQ
15 Beispiel 2
Abbildung 20 : Beispiel 2 - Programmauswertung
Auch im zweiten Beispiel (Abbildung 20) taucht der Kommentar in der Auswertung nicht
mehr auf. Bei der Betrachtung der Synthese (Abbildung 22) fällt auf, daß sowohl die lokale
Variable d als auch die Zahlkonstante 100 im synthetisierten Programm durch globale
Variablen ersetzt wurden.
6HLWH

%HLVSLHOHYRQ3URJUDPPOlXIHQ
Abbildung 21 : Beispiel 2 - Programmsynthese
6HLWH

%HLVSLHOHYRQ3URJUDPPOlXIHQ
16 Beispiel 3
Abbildung 22 : Beispiel 3 - Programmauswertung
Abbildung 22 zeigt ein weiteres Beispiel für die automatische Auswertung eines Programmes.
Bei der Synthese (Abbildung 23) fällt wieder auf, daß die Konstante 200 durch eine weitere
globale Variable ersetzt wurde.
6HLWH

%HLVSLHOHYRQ3URJUDPPOlXIHQ
Abbildung 23 : Beispiel 3 - Programmsynthese
6HLWH

%HLVSLHOHYRQ3URJUDPPOlXIHQ
17 Beispiel 4
Das nächste Beispiel soll die Grenzen des Synthesealgorithmus' aufzeigen:
Abbildung 24 : Beispiel 4
A
B
C
Auch in diesem Beispiel (Abbildung 24) wird die Auswertung des eingegebenen Programmes
automatisch berechnet. Die Synthese jedoch scheitert. An der Stelle A kann der
Synthesealgorithmus' nicht entscheiden, ob die Zahl 9 der Wert der bereits bekannten globalen
Variablen, hier c, oder einer neuen lokalen Variablen (d) mit dem Anfangswert c ist (kein
konsistent arbeitender Algorithmus ist dazu in der Lage). Der Synthesealgorithmus entscheidet
sich immer für die globale Variable. Deswegen muß er annehmen, daß die globale Variable c
an der Stelle B den Wert 7 besitzt. Der Wert 9 an der Stelle C in der zweiten Entfaltung des
äußeren while-Konstruktes muß unbedingt ein Wert der globalen Variablen c sein. Da die
Variable aber nicht am Ende der ersten Entfaltung eines while-Konstruktes den Wert 9, und zu
Beginn der zweiten Entfaltung den Wert 7 besitzen kann, wird der Synthesealgorithmus eine
fehlerhafte Eingabe melden.
6HLWH

=XVDPPHQIDVVXQJXQG6FKOX‰EHPHUNXQJHQ
18 Zusammenfassung und Schlußbemerkungen
Ziel dieser Arbeit war es, eine Methode anzugeben, mit der Algorithmen durch einen Rechner
automatisch generiert werden durch Eingabe von Beispielauswertungen. Dies ist ein
Spezialfall einer sehr verbreiteten Lernsituation, nämlich dem Lernen durch gute Beispiele.
Die Lernsituation ist dabei sehr extrem. Der Rechner (der Lernende) erhält nur ein einziges
Beispiel für das zu lösende Problem als Eingabe und muß sofort eine Lösung des Problem
ausgeben.
Die Sprache zur Formulierung des Problems und seiner Lösungen wurde bewußt sehr einfach
gehalten. Trotzdem zeigt Kapitel 1, daß die Mächtigkeit der Sprache WHILE an die
Mächtigkeit der Turingmaschine heranreicht und daß ihre Ausdrucksfähigkeit auch für
Probleme des (technischen) Alltags ausreicht.
Die in den Kapiteln 4 und 5 vorgestellten Algorithmen zur automatischen Generierung der
Beispielauswertungen und der Synthese der WHILE-Programme erfüllen die gestellte
Forderungen. Die gefundenen Abschätzungen für die Rechenzeit sind als gut zu bezeichnen,
da der Aufwand sowohl für die Auswertung als auch für die Synthese nur linear von der
Länge der Eingabe abhängt. Kapitel 6 zeigt die Grenzen unserer Methode. Die Menge der
lernbaren Algorithmen ist eingeschränkt, und diese Einschränkung läßt sich nicht mit
einfachen Mitteln beheben.
In den abschließenden Kapiteln wurde das Werkzeug [VDPSOH2.0 vorgestellt, mit dem die
Algorithmen auch auf mehreren heutigen Rechnersystemen getestet werden können. Das
Werkzeug [VDPSOH stellt auch eine Basis für künftige Entwicklungen auf dem Gebiet dar.
Die Forschung auf dem Gebiet der automatisierten Programmsynthese ist nicht abgeschlossen
und wird es wohl nie sein. Auch diese Arbeit hat einig Fragen offen gelassen:
w Kann die automatisierte Programmsynthese auf Sprachen mit einer höheren
Ausdrucksfähigkeit erfolgen? Es wäre wünschenswert, Sprachen wie Pascal oder C als
Ausgangssprachen verwenden zu können.
w Welche anderen Formen der Eingabe für die Synthese können neben Beispielauswertungen
verwendet werden?
w Wie können die Algorithmen verbessert werden, hinsichtlich der Effizienz und hinsichtlich
der Menge der lernbaren Klassen von Programmen? Gibt es eine Klasse von Programmen,
die von den Algorithmen gelernt werden kann, und eine Obermenge zur Klasse-I darstellt?
Gibt es alternative Ansätze zur Programmsynthese, durch die Menge der lernbaren
Algorithmen erhöht werden kann.
w Welche anderen Synthesealgorithmen können gefunden werden? Das Werkzeug [VDPSOH
ist für die Verwendung verschiedener Algorithmen für Auswertung und Synthese
vorgesehen. Auch wenn keine Obermenge zur Klasse-I gefunden werden kann, so kann
durch die Verwendung mehrerer Algorithmen die Lernpotenz dennoch erhöht werden. Auch
eine Spezialisierung der Algorithmen auf bestimmte Algorithmenklassen kann sinnvoll sein.
6HLWH

$QKDQJ$'LH:LGJHWVWUXNWXUYRQ[VDPSOH
Anhang A Die Widgetstruktur von [VDPSOH 2.0
Abbildung 25 : Die Widgetstruktur des Hauptformulars von [VDPSOH 2.0
ApplicationShell
xsample
Form ???
MenuBar
CascadeButton
menu
fileMenu
PulldownMenu
filePane
PushButton
new
Separator
blank
CascadeButton
load
PulldownMenu
loadPane
PushButton
loadSample
PushButton
loadProgram
CascadeButton
reload
PulldownMenu
reloadPane
PushButton
reloadSample
PushButton
reloadProgram
6HLWH

$QKDQJ$'LH:LGJHWVWUXNWXUYRQ[VDPSOH
Abbildung 26 : Die Widgetstruktur des Hauptformulars von [VDPSOH2.0 (Fortsetzung)
CascadeButton
saveAs
PulldownMenu
saveAsPane
PushButton
PushButton
saveAsSample
saveAsProgram
CascadeButton
save
PulldownMenu
PushButton
PushButton
Separator
savePane
saveSample
saveProgram
blank
PushButton
quit
CascadeButton
edit
PulldownMenu
editPane
CascadeButton
cut
PulldownMenu
cutPane
PushButton
cutSample
PushButton
cutProgram
6HLWH

$QKDQJ$'LH:LGJHWVWUXNWXUYRQ[VDPSOH
Abbildung 27 : Die Widetstruktur des Hauptformulars von [VDPSOH2.0 (Fortsetzung)
CascadeButton
copy
PulldownMenu
copyPane
PushButton
copySample
PushButton
copyProgram
CascadeButton
paste
PulldownMenu
pastePane
PushButton
pasteSample
PushButton
pasteProgram
CascadeButton
clear
PulldownMenu
clearPane
PushButton
clearSample
PushButton
clearProgram
CascadeButton
generateMenu
PulldownMenu
generatePane
PushButton
synthesize
PushButton
compute
6HLWH

$QKDQJ$'LH:LGJHWVWUXNWXUYRQ[VDPSOH
Abbildung 28 : Die Widgetstruktur des Hauptformulars von [VDPSOH 2.0 (Fortsetzung)
CascadeButton
algorithmMenu
PulldownMenu
algorithmPane
ToggleButton
standardAlgorithm
CascadeButton
help
PulldownMenu
helpPane
PushButton
helpGeneral
PushButton
helpOnWindows
PushButton
helpOnMenues
Pushbutton
helpOnButtons
PushButton
helpOnKeys
Separator
blank
Pushbutton
Form
info
actionForm
Form
sampleForm
Label
sampleTitle
6HLWH

$QKDQJ$'LH:LGJHWVWUXNWXUYRQ[VDPSOH
Abbildung 29 : Die Widgetstruktur des Hauptformulars von [VDPSOH2.0 (Fortsetzung)
Label
sampleUnsavedLabel
Label
sampleComputedLabel
Label
sampleFilename
Text
sampleText
popupMenu
samplePopup
Label
label
Separator
blank
PushButton
loadSample
Pushbutton
reloadSample
PushButton
saveAsSample
PushButton
saveSample
PushButton
Separator
synthesize
textsep
Form
programForm
Label
programTitle
6HLWH

$QKDQJ$'LH:LGJHWVWUXNWXUYRQ[VDPSOH
Abbildung 30 : Die Widgetstruktur des Hauptformulars von [VDPSOH 2.0 (Fortsetzung)
Label
Label
programUnsavedLab
el
programSynthesizedLabel
Label
programFilename
Text
programText
popupMenu
programPopup
Label
label
Separator
blank
PushButton
loadProgram
Pushbutton
reloadProgram
PushButton
saveAsProgram
PushButton
saveProgram
PushButton
compute
RowColumn
commandLine
PushButton
synthesizeButton
PushButton
computeButton
PushButton
quitButton
PushButton
helpButton
6HLWH

$QKDQJ%5HVRXUFHQ
Anhang B Resourcen
Resourcen ermöglichen die Anpassung des Werkzeuges an die persönlichen Bedürfnisse des
Benutzers, ohne dazu bei jedem Aufruf mehrere Kommandozeilenoptionen setzen zu müssen.
Die Resourcen können sowohl in einer ASCII-Datei angegeben werden, aber auch durch die
Komandozeilenoptionen gesetzt werden. Oftmals wird der Wert einer Resource aber vom
Programm unveränderlich festgelegt.
Auf der Suche nach den Resourcen für das Werkzeug wird beim Aufruf von [VDPSOH
folgendermaßen vorgegangen:
ì Es wird die Datei "Sample" im Standard-Application-Default-Verzeichnis des System
gelesen, sofern die Datei in diesem Verzeichnis enthalten ist.
ì
ì
ì
Es wird die Datei "Sample" in dem durch die Umgebungsvariable APPLRESDIR
angegeben Verzeichnis gelesen. Falls diese Datei nicht existiert, wird die Datei "Sample"
im Homeverzeichnis des Benutzers gesucht, und, falls sie gefunden wird, gelesen.
Es werden die Resourcen des X-Servers gelesen. Resourcen können mit der Anweisung
xrdb in den Server geladen werden.
Es wird die Kommandozeilenoption -xrm in der Kommandozeile ausgewertet.
ì Es werden die übrigen Kommandozeilenoptionen ausgewertet, sofern diese den Wert der
Resourcen verändern.
Auf die genauerer Vorgehensweise beim Aufruf des Programmes soll hier nicht eingegangen
sein. Für den Benutzer wichtig ist die Datei Sample, die die für den Benutzer am relevantesten
Resourcen enthält. Zu ihrer Benutzung empfiehlt sich das Setzen der Umgebungsvariablen
APPLRESDIR oder das Setzen eines gleichnamigen Links vom Homeverzeichnis aus auf die
Datei Sample.
Das Programm [VDPSOHbesitzt sehr viele Resourcen, die anhand einschlägiger Fachliteratur
aus der in Anhang A angegebenen Widgetstruktur ermittelt werden kann. Die meisten der
Resourcen sind jedoch vom Programm aus mit festen Werten belegt, oder ihre Festlegung ist
nicht sinnvoll. Die wenigsten Benutzer haben z.B. ein Interesse daran, die genauen
Koordinaten der Position eines Pushbuttons auf dem Bildschirm anzugeben. Deswegen wollen
wir hier nicht alle Resourcen erläutern, sondern nur diejenigen Resourcen, die auch in der
Standard-Resourcendatei Sample enthalten sind.
Mit der Resource
xsample*title
wird der Titel des Fensters des Hauptformulars gesetzt. Wert dieser Resource kann eine
beliebige Zeichenfolge sein. Die Standardvorgabe in dieser Resource ist "xsample 2.0". Der
Titel des Icons kann mit der Resource
xsample*iconName
gesetzt werden. Auch hier ist standardmäßig der Wert "xsample 2.0" eingetragen.
Die Resource
xsample*keyboardFocusPolicy
enthält normalerweise den Wert "POINTER". Dann enthält dasjenige Fenster den
Tastaturfocus, in dem sich der Mauscursor befindet. Wird hier der Wert EXPLICIT
eingetragen, muß jede Applikation, die den Tastaturfocus haben soll, mit der Maus angeklickt
werden. Das Fenster behält dann aber den Focus, auch wenn der Mauscursor sich nicht
innerhalb der Fenstergrenezen befindet.
6HLWH

$QKDQJ%5HVRXUFHQ
Über die Resource
xsample*blinkRate
regelt man die Frequenz, in der der Textcursor blinkt. Dabei bedeutet der Standardwert 300,
daß der Textcursor alle 300 Millisekunden aufblinkt. Um das Blinken des Cursor
abzuschalten, trägt man in die Resource den Wert 0 ein.
Die Abstände zwischen den einzelnen Widgets innerhalb des Formulars werden mit den
Resourcen
xsample*horizontalSpacing und
xsample*verticalSpacing
festgesetzt. Die angegebenen Werte bezeichnet die horizontalen und vertikalen Abstände in
Pixeln.
Um die Tear-Off-Menüs abzuschalten, kann man als Wert der Resourcen
xsample*tearOffModel
die Konstante TEAR_OFF_DISABLED eintragen.
Mit der Resource
xsample*defaultVirtualBindings
können einige logische Keys existierenden Tasten auf der Tastatur zugeordnet werden. Der
Standardwert dieser Resource ist
osfAddMode:
Insert \n\
osfBackSpace: BackSpace \n\
osfBeginLine: Mod1Left \n\
osfClear:
CtrlDelete \n\
osfDelete:
Delete \n\
osfDown:
Down \n\
osfEndLine:
Mod1Right \n\
osfLeft:
Left \n\
osfPageDown:
Next \n\
osfPageUp:
Prior \n\
osfPrimaryPaste: F6 \n\
osfSelect:
Select \n\
osfRight:
Right \n\
osfUp:
Up
Der Benutzer mag diese Belegung an seine eigenen Wünsche und den Gegebenheiten seiner
Tastatur anpassen wollen. Um zum Beispiel die Taste [HOME] für den logischen Key
osfBeginLine zu verwenden, ändert man die entsprechende Zeile um in:
osfBeginLine: Home \n\
Die Form der verwendeten Separatoren zum Abtrennen des Aktionsfensters von der
Pushbuttoonzeile und von der Menüzeile und zum Abtrennen des Samplefensters vom
Programfenster werden in den Resourecen
xsample*uppersep.separatorType,
xsample*lowersep.separatorType und
xsample*textsep.separatorType
festgelegt. Die Resourcen können die folgenden Werte annehmen:
NO_LINE, SINGLE_LINE, DOUBLE_LINE, SINGLE_DASHED_LINE,
DOUBLE_DASHED_LINE, SHADOW_ETCHED_IN, sowie
SHADOW_ETCHED_OUT.
6HLWH

$QKDQJ%5HVRXUFHQ
Mit der Resource
xsample*menu*menuAccelerator
kann diejenige Taste festgelegt werden, mit der auf die Menüzeile mit den Cursortasten
zugegriffen werden kann. Der Standardwert dieser Resource ist F3.
Die Beschriftungen der einzelnen Menüs in der Menüzeile werden über die Resourcen
xsample*menu*fileMenu.labelString,
xsample*menu*editMenu.labelString,
xsample*menu*generateMenu.labelString,
xsample*menu*algorithmMenu.labelString und
xsample*menu*helpMenu.labelString
festgelegt. Mit den Resourcen
xsample*menu*fileMenu.mnemonic,
xsample*menu*editMenu.mnemonic,
xsample*menu*generateMenu.mnemonic,
xsample*menu*algorithmMenu.mnemonic und
xsample*menu*helpMenu.mnemonic
wird derjenige Buchstabe festgelegt, über dessen Taste zusammen mit der [ALT]-Taste das
Menü aufgeklappt wird. Diese Buchstabe wird in der Beschriftung des Menüs unterstrichen.
Die Beschriftung der einzelnen Menüeinträge (auch die Einträge der Untermenüs) werden über
die folgenden Resourcen festgelegt:
xsample*menu*new.labelString
xsample*menu*load.labelString
xsample*menu*loadSample.labelString
xsample*menu*loadProgram.labelString
xsample*menu*reload.labelString
xsample*menu*reloadSample.labelString
xsample*menu*reloadProgram.labelString
xsample*menu*saveAs.labelString
xsample*menu*saveAsSample.labelString
xsample*menu*saveAsProgram.labelString
xsample*menu*save.labelString
xsample*menu*saveSample.labelString
xsample*menu*saveProgram.labelString
xsample*menu*quit.labelString
xsample*menu*cut.labelString
xsample*menu*cutSample.labelString
xsample*menu*cutProgram.labelString
xsample*menu*copy.labelString
xsample*menu*copySample.labelString
xsample*menu*copyProgram.labelString
xsample*menu*paste.labelString:
xsample*menu*pasteSample.labelString
xsample*menu*pasteProgram.labelString
xsample*menu*clear.labelString
xsample*menu*clearSample.labelString
xsample*menu*clearProgram.labelString
xsample*menu*synthesize.labelString
xsample*menu*compute.labelString
xsample*menu*algorithmMenu.labelString
xsample*menu*standardAlgorithm.labelString
xsample*menu*helpGeneral.labelString
xsample*menu*helpOnWindows.labelString
6HLWH

$QKDQJ%5HVRXUFHQ
xsample*menu*helpOnMenues.labelString
xsample*menu*helpOnButtons.labelString
xsample*menu*helpOnKeys.labelString
xsample*menu*info.labelString
Die entsprechenden Resourcen zur Wahl der Buchstabens zur Menüauswahl über die Tastatur
unterscheiden sich von den Resourcen zur Wahl des Eintrags nur dadurch, daß die
Zeichenfolge "labelString" durch "mnemonic" ersetzt wird.
Es können nun noch weitere Tastenkombinationen gewählt werden, mit denen ein Menüeintrag
aufgerufen werden kann. Um die dafür notwendige Resource zu erhalten ersetzt man die
Zeichenkette "labelString" durch die Zeichenkette "accelerator". In der Datei Sample sind die
folgenden "Accelerators" definiert:
xsample*menu*new.accelerator:
CtrlN
xsample*menu*loadSample.accelerator: CtrlL
xsample*menu*loadProgram.accelerator: CtrlO
xsample*menu*saveSample.accelerator: CtrlS
xsample*menu*saveProgram.accelerator: CtrlA
xsample*menu*quit.accelerator:
CtrlQ
xsample*menu*synthesize.accelerator: CtrlY
xsample*menu*compute.accelerator: CtrlC
xsample*menu*cutSample.accelerator: ShiftF7
xsample*menu*cutProgram.accelerator: ShiftF9
xsample*menu*copySample.accelerator: F7
xsample*menu*copyProgram.accelerator: F9
xsample*menu*pasteSample.accelerator: F8
xsample*menu*pasteProgram.accelerator: F10
xsample*menu*helpGeneral.accelerator: F1
Es steht dem Benutzer frei, diese Tastenkombinationen umzubelegen oder zu ergänzen.
Diese Shortcuts sollten auch im Menü angezeigt werden. Über weitere Resourcen kann ein
beliebiger Text hinter den "labelString" in einen Menüeintrag eingetragen werden. Für die
oben definierten Shortcuts gelten normalerweise die folgenden Einträge:
xsample*menu*new.acceleratorText:
Ctrl-N
xsample*menu*loadSample.acceleratorText: Ctrl-L
xsample*menu*loadProgram.acceleratorText: Ctrl-O
xsample*menu*saveSample.acceleratorText: Ctrl-S
xsample*menu*saveProgram.acceleratorText: Ctrl-A
xsample*menu*quit.acceleratorText: Ctrl-Q
xsample*menu*synthesize.acceleratorText: Ctrl-Y
xsample*menu*compute.acceleratorText: Ctrl-C
xsample*menu*cutSample.acceleratorText: Shift-F7
xsample*menu*cutProgram.acceleratorText: Shift-F9
xsample*menu*copySample.acceleratorText: F7
xsample*menu*copyProgram.acceleratorText: F9
xsample*menu*pasteSample.acceleratorText: F8
xsample*menu*pasteProgram.acceleratorText:F10
xsample*menu*helpGeneral.acceleratorText: F1
Kommen wir nun zur Pushbuttonleiste. Die Aufschriften auf den vier Pushbuttons werden in
den Resourcen
xsample*synthesizeButton.labelString,
xsample*computeButton.labelString,
xsample*quitButton.labelString und
xsample*helpButton.labelString
eingegeben.
6HLWH

$QKDQJ%5HVRXUFHQ
Über die Resourcen
xsample*sampleTitle.labelString und
xsample*programTitle.labelString
stellt man die Beschriftung der Überschriftlabel des Samplefensters und des Programfensters
ein. Standardmäßig sind beide Fenster mit einem Rahmen versehen. Zur Angabe der Breite der
Rahmens dienen die Resourcen
xsample*sampleTitle.highlightThickness und
xsample*programTitle.highlightThickness
Die Standardbreite beträgt 2 Pixel. Die Breite der Randline wird mit den Resourcen
xsample*sampleTitle.borderWidth und
xsample*programTitle.borderWidth
eingegeben. Ihr Wert wird in der Datei Sample mit 1 Pixel angegeben.
Im Samplefenster können zwei Flags angezeigt werden. Das este Flag zeigt an, daß der Inhalt
des Textfensters nicht gesichert ist, das zweite Flag zeigt an, daß die angezeigte
Beispielauswertung aus der Auswertung des angezeigten Programmes hervorgegangen ist.
Diese Flags werden über die folgenden Resourcen festgelegt:
xsample*sampleUnsavedLabel.labelString und
xsample*sampleComputedLabel.labelString.
Entsprechend können im Programfenster ebenfalls zwei Flags eingeblendet werden. Das erste
Flag zeigt an, daß der Inhalt des Textfensters nicht gesichert ist, das zweite Flag zeigt an, daß
das angezeigte Programm aus der Synthese der angezeigten Beispielauswertung
hervorgegangen ist. Die beiden Flags werden mit den Resourcen
xsample*programUnsavedLabel.labelString und
xsample*programSynthesizedLabel.labelString
beschriftet.
Der angezeigte Dateiname kann nur während der Laufzeit von [VDPSOH festgelegt werden. Es
ist aber möglich, anzugeben, welcher Text an der Stelle des Dateinamens stehen soll, wenn
kein Dateiname angegeben ist. Die Datei Sample enthält die folgenden Festlegungen:
xsample*sampleFilename.labelString: -
xsample*programFilename.labelString: -
Standardmäßig kann in den Textfenstern eine angezeigte Beispielauswertung oder ein
angezeigtes Programm verändert werden. Soll eine Beispielauswertung oder ein Programm vor
versehentlichem Überschreiben geschützt werden, bietet [VDPSOH die beiden
Kommandozeilenoprionen -sreadonly und -preadonly an. Es ist aber trotzdem möglich, den
Schreibschutz für alle Aufrufe von zu [VDPSOH aktivieren. Dazu kann man die Resourcen
xsample*sampleText.editable und
xsample*programText.editable
benutzen. Falls für die Resourcen der Wert 'False' eingetragen wird, so wird jeder Versuch, ein
Zeichen in das entsprechende Textfenster einzufügen oder ein Zeichen vom entsprechenden
Textfenster zu löschen, abgewehrt. Es wird nur ein Piepston ausgegeben, aber der angezeigte
Text nicht verändert.
Die Zahl der Zeilen und Spalten in jedem Textfenster kann über die Resourcen
xsample*sampleText.rows,
xsample*sampleText.columns,
xsample*programText.rows und
6HLWH

$QKDQJ%5HVRXUFHQ
xsample*programText.columns
bestimmt werden. Standardmäßig enthalten beide Fenster 30 Zeilen und 50 Spalten. Die
Größe der Textfenster kann aber auch über die Kommandozeile oder auch zur Laufzeit des
Programmes durch Verändern der Größe des Fensters des Hauptformulars angepaßt werden.
Über die Resourcen
xsample*sampleText.pendingDelete und
xsample*programText.pendingDelete
kann entschieden werden, ob eine Selektion durch Eingabe eines Zeichens überschrieben wird.
Der Standardwert für beide Resourcen ist 'True', womit diese Funktionalität aktiviert wird.
Der Benutzer mag den Wert auf 'False' abändern, wenn er nicht wünscht, daß seine
Selektionen überschrieben werden können.
Mit den beiden Resourcen
xsample*sampleForm*menuPost und
xsample*programForm*menuPost
wird angegeben, mit welcher Maustaste die Popupmenüs erschenen soll. Die Standardvorgabe
hierfür ist . Dann wird das entsprechende Popupmenü aufgeklappt, solange
innerhalb des Samplefenster oder innerhalb des Programfensters die rechte Maustaste
gedrückt ist. Da die beiden anderen Maustasten für das Arbeiten mit Selektionen benötigt
werden, bietet es sich nicht an, diese Maustasten für das Popupmenü zu verwenden. Aber ein
Wert wie Shift wäre denkbar. in diesem Fall klappt das Popupmenü auf, wenn
gleichzeitig die rechte Maustaste und die [SHIFT]-Taste gedrückt sind.
Zusätzlich können zwei Tastenkombinationen festgelegt werden, mit denen die Popupmenüs
angezeigt werden können, ohne die Maus zu benutzen. Hierfür stehen die folgenden Reosurcen
bereit:
xsample*sampleForm*menuAccelerator und
xsample*programForm*menuAccelerator.
Zur Festlegung der Überschrift über die Popupmenüs werden die Resourcen
xsample*samplePopup*label.labelString und
xsample*programPopup*label.labelSring
verwendet. Die Standardvorgaben für diese Resourcen sind "Sample" und "Program".
Für die Beschriftung der Menüpunkte im Popupmenü des Samplefensters enthält die Datei
Sample die folgenden Vereinbarungen:
xsample*samplePopup*loadSample.labelString: Load
xsample*samplePopup*reloadSample.labelString: Reload
xsample*samplePopup*saveAsSample.labelString: SaveAs
xsample*samplePopup*saveSample.labelString: Save
xsample*samplePopup*synthesize.labelString: Synthesize
Entsprechend gilt für die Beschriftung der Einträge im Popupmenp des Programfensters:
xsample*programPopup*loadProgram.labelString: Load
xsample*programPopup*reloadProgram.labelString: Reload
xsample*programPopup*saveAsProgram.labelString: SaveAs
xsample*programPopup*saveProgram.labelString: Save
xsample*programPopup*compute.labelString: Compute
Wenden wir uns nun den Dialogfenstern zu. Der Text der Infobox wird im Quellcode von
[VDPSOH festgelegt und kann vom Benutzer nicht verändert werden. Wohl aber kann das
angezeigte Icon ausgetauscht werden über den Wert der Resource
6HLWH

$QKDQJ%5HVRXUFHQ
xsample*infoBox.symbolPixmap.
Der Wert dieser Resource muß eine Datei sein, die ein Bitmap enthält. Die Standardvorgabe
für diese Datei ist xsample.bm.
Der Fenstertitel für die Infobox wird in der Resource
xsample*infoBox.dialogTitle
angegeben.
Die Infobox besitzt nur einen einzigen Pushbutton. Seine Aufschrift steht in der Resource
xsample*infoBox.okLabelString.
Es gibt insgesamt drei verschiedene Warnungsboxen, die den Benutzer daran erinnern, daß er
im Begriff ist, den nicht gespeicherten Inhalt seiner Textfenster zu überschreiben. Die drei
Warnungsboxen unterscheiden sich dahin, daß die Warnung sich auf das Samplefenster, das
Programfenster oder auf beide Fenster beziehen kann. Zur Festlegung des Textes der drei
Warnungsboxen stehen die folgenden Resourcen zur Verfügung:
xsample*warningSample.messageString,
xsample*warningProgram.messageString, sowie
xsample*warningBoth.messageString.
Zur Festlegung der Überschriften der drei Fenster werden die Resourcen
xsample*warningSample.dialogTitle,
xsample*warningProgram.dialogTitle und
xsample*warningBoth.dialogTitle
verwendet.
Die Warnungsbox besitzt drei Pushbuttons. Über den linken Pushbutton wird die gewählte
Operation fortgesetzt. Ihre Aufschrift steht in den Resourcen
xsample*warningSample.okLabelString,
xsample*warningProgram.okLabelString und
xsample*warningBoth.okLabelString.
Der mittlere Pushbutton bewirkt den Abruch der gewählten Operation. Zur Festlegung seiner
Aufschrift werden die Resourcen
xsample*warningSample.cancelLabelString,
xsample*warningProgram.cancelLabelString und
xsample*warningBoth.cancelLabelString
zur Verfügung gestellt.
Der rechte Pushbutton dient zum Aufruf der Hilfefunktion mit der Anforderung für Hilfe für
die Warnungsbox. Die Aufschrift über diesen Pushbutton wird in den Resourcen
xsample*warningSample.helpLabelString,
xsample*warningProgram.helpLabelString und
xsample*warningBoth.helpLabelString
festgelegt.
Für die Sicherheitsabfrage werden insgesamt sechs Dialogboxen verwendet, da es sechs
Operationen gibt, die bestätigt werden müssen. Es sind dies New, Load Sample, Load
Program, Reload Sample, Reload Program und Quit. Zur Bestimmung des Textes der
Sicherheitsabfragen werden die folgenden Resourcen zur Verfügung gestellt:
xsample*questionNew.messageString,
6HLWH

$QKDQJ%5HVRXUFHQ
xsample*questionLoadSample.messageString,
xsample*questionLoadProgram.messageString,
xsample*questionReloadSample.messageString,
xsample*questionReloadProgram.messageString und
xsample*questionExit.messageString.
Vollkommen analog zu den Warnungsboxen kann auch der Fenstertitel, sowie die Aufschrift
auf den drei Pushbuttons festgelegt werden. Um die dazu notwendigen Resourcen zu erhalten,
ersetzt man die Zeichenkette "messageString" durch "dialogTitle", "okLabelString",
"cancelLabelString" oder "helpLabelString".
Betrachten wir nun die Dateiauswahlbox. Es gibt zwei verschiedene Dateiauswahlboxen, je
eine zu Auswahl eines Programmes und eine zur Auswahl einer Beispielauswertung. Die
Fensterüberschriften werden durch die Resourcen
xsample*sampleFileSelectionBox.dialogTitle und
xsample*programFileSelectionBox.dialogTitle
gesetzt. Für die Festlegung der Überschrift über dem Fenster des Dateifilters stehen die
Resourcen
xsample*sampleFileSelectionBox.filterLabelString und
xsample*programFileSelectionBox.filterLabelString
zur Verfügung.
Der verwendete Dateifilter wird durch die folgenden Resourcen gesetzt:
xsample*sampleFileSelectionBox.dirMask und
xsample*programFileSelectionBox.dirMask.
Die Standardwerte für die Resourcen sind '*.sc' für die Dateiauswahlbox der
Beispielauswertungen und '*.pr' für die Dateiauswahlbox der Programme.
Mit den Resourcen
xsample*sampleFileSelectionBox.dirListLabelString und
xsample*programFileSelectionBox.dirListLabelString
bestimmt man die Überschrift über das Verzeichnisfenster. Analog kann man mit den
Resourcen
xsample*sampleFileSelectionBox.fileListLabelString und
xsample*programFileSelectionBox.fileListLabelString
die Überschrift über das Dateifenster und mit den Resourcen
xsample*sampleFileSelectionBox.selectionLabelString und
xsample*programFileSelectionBox.selectionLabelString
die Überschrift über das Fenster des Dateinamens festlegen.
Die Dateiauswahlboxen verfügen über vier Pushbuttons. Mit dem linken Button wird die
Dateiauswahl abgeschlossen. Für die Festlegung der Aufschrift auf diesen Pushbutton dienen
die Resourcen
xsample*sampleFileSelectionBox.okLabelString und
xsample*programFileSelectionBox.okLabelString.
Die Aufschrift auf den zweiten Pushbutton, mit dem das aktuelle Verzeichnis erneut
eingelesen werden kann, wird mit den Resourcen
xsample*sampleFileSelectionBox.applyLabelString und
xsample*programFileSelectionBox.applyLabelString
6HLWH

$QKDQJ%5HVRXUFHQ
festgelegt. Mit dem dritten Pushbutton kann die gewählte Operation abgebrochen werden. Die
Aufschrift auf diesen Button steht in den Resourcen
xsample*sampleFileSelectionBox.cancelLabelString, sowie
xsample*programFileSelectionBox.cancelLabelString.
Der rechte Pushbutton dient zum Aufruf eines Hilfefensters mit einem Hilfetext über die
Dateiauswahlbox. Ihre Aufschrift ist in den Resourcen
xsample*sampleFileSelectionBox.helpLabelString und
xsample*programFileSelectionBox.helpLabelString
enthalten.
Kommen wir nun zur Hilfebox. Neben der Darstellung der Hilfetexte werden in der Hilfebox
auch Fehlermeldungen wiedergegeben. Es können beliebig viele Hilfeboxen gleichzeitig am
Bildschirm angezeigt werden. In beiden Fällen wird die dargebotene Meldung nicht aus den
Resourcen, sondern aus getrennten Datei bestimmt. Für die Festlegung des Fenstertitels steht
die Resource
xsample*helpBox.dialogTitle
zur Verfügung.
Die Hilfebox verfügt nur über zwei Pushbuttons. Mit dem linken Button wird die Box
geschlossen, während mit dem rechten Button eine weitere Hilfebox mit einer weiteren
Fehlermeldung geöffnet wird. Für die Festlegung der Aufschriften auf die beiden Button,
können die Resourcen
xsample*helpBox.okLabelString und
xsample*helpBox.helpLabelString
verwendet werden.
Auch der Inhalt der Fehlerprotokollbox wird von [VDPSOH zur Laufzeit festgelegt. Es können
beliebig viele Fehlerprotokollboxen gleichzeitig angezeigt werden. Der Fenstertitel kann über
die Resource
xsample*logBox.dialogTitle
bestimmt werden.
Wie die Hilfebox, so hat auch die Fehlerprotokollbox zwei Buttons, mit denen die Box
geschlossen werden kann oder eine Hilfetext angefordert werden kann. Für die Aufschriften
auf diesen Pushbuttons stehen die Resourcen
xsample*logBox.okLabelString und
xsample*logBox.helpLabelString
bereit.
Da die Größe der Fehlerprotokolldatei unbeschränkt ist und damit auch die Größe des
Bildschirms überschreiten kann, ist es notwendig, die Größe der Fehlerprotokollbox
festzusetzen. Höhe und Breite der Anzeigefläche werden durch die Resourcen
xsample*logBox*scrolledLog.width und
xsample*logBox*scrolledLog.height
vorgegeben. Die Standardwerte dieser Resourcen sind 400 Pixel und 250 Pixel.
Über die Resource
xsample*logBox*scrolledLog.scrollBarDisplayPolicy
6HLWH

$QKDQJ%5HVRXUFHQ
kann bestimmt werden, ob die Scrollbars innerhalb der Fehlerprotokollbox immer angezeigt
werden sollen, oder nur dann, wenn das Fehlerprotokoll die festgelegten Dimensionen der
Anzeigefläche überschreitet. Der Standardwert für diese Resource ist AS_NEEDED. Dann
wird die Scrollbar nur bei Bedarf angezeigt. Soll die Scrollbar dagegen immer angezeigt
werden, so ist für diese Resource der Wert STATIC einzusetzen.
Die Farben für den Vordergrund und den Hintergrund des Hauptformulars werden durch die
Resourcen
xsample*background und
xsample*foreground
bestimmt.
Die Farbe der Menüleiste wird mit der Resource
xsample*menu*background
geregelt. Da keine Vordergrundfarbe gesetzt wird, wird die Vordergrundfarbe des
Hauptformulars verwendet.
Die Vorder- und Hintergrundfarbe des Überschriftslabel des Samplefenster, sowie die Farbe
des Randes kann mit den Resourcen
xsample*sampleTitle*background,
xsample*sampleTitle*foreground und
xsample*sampleTitle*borderColor
festgelegt werden. Analog gibt es für das Überschriftslabel des Programfensters die Resourcen
xsample*programTitle*background,
xsample*programTitle*foreground und
xsample*programTitle*borderColor.
Die Hintergrundfarbe der Textfenster wird mit den Resourcen
xsample*sampleText*background und
xsample*programText*background
bestimmt. Entsprechend werden die Vordergrundfarben der beiden Textfenster durch die
folgenden Resourcen gegeben:
xsample*sampleText*foreground und
xsample*programText*foreground.
Zur Bestimmung der Farbe des Randes der Textfenster benutzt man die Resourcen
xsample*sampleText*borderColor und
xsample*programText*borderColor.
Über die Resourcen
xsample*sampleText*borderWidth und
xsample*programText*borderWidth
kann die Breite des Randes des Randes der Textfenster gesetzt werden.
Zum Setzen der Vorder- und Hintergrundfarbe der Pushbuttons in der Pushbuttonzeile können
dir folgenden Resourcen verwendet werden:
xsample*synthesizeButton*background,
xsample*computeButton*background,
xsample*quitButton*background,
xsample*helpButton*background,
6HLWH

$QKDQJ%5HVRXUFHQ
xsample*synthesizeButton*foreground,
xsample*computeButton*foreground,
xsample*quitButton*foreground und
xsample*helpButton*foreground.
Mit den Resourcen
xsample*warningSample*background,
xsample*warningSample*foreground,
xsample*warningSample*bordercolor,
xsample*warningProgram*background,
xsample*warningProgram*foreground,
xsample*warningProgram*bordercolor,
xsample*warningBoth*background,
xsample*warningBoth*foreground und
xsample*warningBoth*bordercolor
legt man Vordergrund-, Hintergrund- und Randfarbe für die Warnungsbox fest.
Analog exitieren für die Abfragebox die Resourcen:
xsample*questionNew*background,
xsample*questionNew*foreground,
xsample*questionNew*bordercolor,
xsample*questionLoadSample*background,
xsample*questionLoadSample*foreground,
xsample*questionLoadSample*bordercolor,
xsample*questionLoadProgram*background,
xsample*questionLoadProgram*foreground,
xsample*questionLoadProgram*bordercolor,
xsample*questionReloadSample*background,
xsample*questionReloadSample*foreground,
xsample*questionReloadSample*bordercolor,
xsample*questionReloadProgram*background,
xsample*questionReloadProgram*foreground,
xsample*questionReloadProgram*bordercolor,
xsample*questionExit*background,
xsample*questionExit*foreground und
xsample*questionExit*bordercolor.
Der Hintergrund der Dateiauswahlbox wird durch die Resourcen
xsample*sampleFileSelectionBox.background und
xsample*programFileSelectionBox.background
bestimmt.
Die Farben der Hilfebox sind in den Resourcen
xsample*helpBox*background,
xsample*helpBox*foreground und
xsample*helpBox*bordercolor
abgelegt. Entsprechend sind für die Farben der Fehlerprotokollbox die Resourcen
xsample*logBox*background,
xsample*logBox*foreground,
xsample*logBox*bordercolor und
6HLWH

$QKDQJ%5HVRXUFHQ
xsample*logBox*logLabel.background
bestimmt.
6HLWH

$QKDQJ&4XHOOWH[W
Anhang C Quelltext
Das Werkzeug ist in der Programmiersprache C++ geschrieben. Der Quelltext des
Programmes einschließlich der Spezifikationen der einzelnen Klassen und Funktionen liegt auf
dem SUN-SPARC-Cluster der AG Wiehagen und kann auf Wunsch eingesehen werden. Eine
Verwendung des Quelltextes gleich welcher Art ist jedoch nur mit Einwilligung des Autors
gestattet. Der Quelltext für das Werkzeug besteht aus den folgenden Dateien:
Tabelle 15 : Die Dateien des Quellcodes
Komponente/Unterkomponente Datei Lines of Code
Interface/Main
xsample.h
xsample.cxx
89
146
Interface/CommandLine commandline.h
commandline.cxx
156
331
Interface/
GraphicalUserInterface
gui.h
gui.cxx
134
1263
Interface/Callback
callback.h
callback.cxx
517
1854
Interface/Messages
messages.h
messages.cxx
143
442
Interface/EventHandler eventhandler.h
eventhandler.cxx
77
59
Interface/Error
error.h
error.cxx
378
227
Interface/Help
help.h
help.cxx
106
111
Interface/HelpError
helperror.h
helperror.cxx
95
146
Interface/HelpErrorText helperrortext.h
helperrortext.cxx
118
168
Înterface/Operations operations.h
operations.cxx
368
556
Interface/ExtendedOperations xoperations.h
xoperations.cxx
506
868
Interface/Connection connection.h
connection.cxx
116
74
Text
text.h
text.cxx
280
222
SampleText
sampletext.h
sampletext.cxx
245
154
ProgramText
programtext.h
programtext.cxx
234
153
Synthesizer
synthesizer.h
synthesizer.cxx
131
1852
Computer
computer.h
computer.cxx
133
254
Parser/SampleComputation samplecomputation.h
samplecomputation.cxx
386
1170
Parser/Program program.h 545
6HLWH

$QKDQJ&4XHOOWH[W
Parser/Basic
Parser/Scanner
Parser/Variable
program.cxx 1865
basic.h
398
basic.cxx
88
scanner.h
293
scanner.cxx
535
variable.h
354
variable.cxx
526
18866
6HLWH

$QKDQJ'9HU]HLFKQLVGHUYHUZHQGHWHQ/LWHUDWXU
Anhang D Verzeichnis der verwendeten Literatur
[1] Stroustrup Bjarne: Die C++-Programmiersprache, 2. Auflage: Bonn, München,
Paris: Addison-Wesley 1992
[2] Gottheil K. et. al.: X und Motif: Einführung in die Programmierung des Motif-
Toolkits und des X-Windows-Systems: Berlin et. al.: Springer 1992
[3] Nye Adrian: Xlib Programming Manual, 3. Auflage: Sebastopol: O'Reilly &
Associates 1992
[4] Nye Adrian: Xlib Reference Manual, 3. Auflage: Sebastopol: O'Reilly & Associates
1992
[5] Nye Adrian, O'Reilly Tim: X Toolkit Intrinsics Programming Manual, Motif
Edition, 3. Auflage: Sebastopol: O'Reilly & Associates 1993
[6] Flanagan David: X Toolkit Intrinsics Reference Manual, 3. Auflage: Sebastopol:
O'Reilly & Associates 1992
[7] Heller Dan, Fergusan Paula: Motif Programming Manual, 2. Auflage: Sebastopol:
O'Reilly & Associates 1994
[8] Ferguson, Paula M., Motif Reference Manual: Sebastopol : O'Reilly & Associates
1993
[9] Aho, Alfred et al.: Compilerbau: Bonn et. al.: Addison-Wesley 1988
[10] Kopp Herbert, Compilerbau, Grundlagen, Methoden, Werkzeuge: München, Wien:
Hanser 1988
[11] Louden Keneth C., Programming Languages: principles and practice: Boston: PWS-
Kent 1993
[12] Kowalk Wolfgang P., Korrekte Software: Semanik, Spezifikation, Verifikation und
Testen von Programmen: Mannheim et. al.: BI-Wissenschaftsverlag 1993
[13] Hopcroft John E., Ullman Jeffrey D.: Einführung in die Automatentheorie, formale
Sprachen und Komplexitätstheorie, 2. Auflage: Reading et. al.: Addison-Wesley
1990
[14] Kinber E. B.: „Inductive Synthesis of Programs for Recursive Functions from
Sample Computations“. Inform. Process. Cybern. EIK 25 (1989) 8/9, S. 435-456
6HLWH

,QGH[
Index
A
Aktionsfenster 225
Algorithmus 7
Alphabet 39
Anweisung 17, 39
Anweisungssequenz 39
Äquivalenz 59
Äquivalenzrelation 60
Ausdruck 39
Ausgabevariable 17
Auswertung 18
B
Batch-Mode 222
Beispielauswertung 58, 67, 85
Beispielauswertungsfragment 59
Benutzeroberfläche 222, 233
Benutzerschnittstelle 205
Bezeichner 39
Clipboard 236
Dateiauswahl 237
Datenverkehr 227
Dekrement 18, 39
Dialogfenster 236
C
D
E
Eingabekonstrukt 39
Eingabemenge 53
Eingabevariable 17, 40
Entfaltung 45
Fehlermeldungen 240
Fehlerprotokoll 240
F
if-Konstrukt 196
Initialisation 18
Initialisationskonstante 43
Initialisationskonstrukt 39, 41
Initialisationssequenz 39
Inkrement 18, 39
I
K
Klasse-I-Beispielauswertung 86, 181
Klasse-II-Beispielauswertung 190
Klasse-III-Beispielauswertung 198
Klasse-III-Programm 198
Klasse-II-Programm 189
Klasse-I-Programm 86, 181
Kodierungsfunktion 26
Kommandozeile 207
Kommandozeilenoptionen 220
Konstante 43
konstantenbereinigte Form 63
Makro 199
Menü 224, 227
Menüzeile 224, 227
M
P
partiell rekursive Funktion 25
Popupmenü 226, 229
primitiv rekursive Funktion 22
Programm 43
Programmfragment 43
Programmkonstante 43
Programmtext 39
Programmvariable 41
Pushbuttonzeile 226
Registermaschine 32
Resourcen 263
R
H
Hauptanweisungssequenz 40
Hauptformular 223
Hauptvariable 42
Hilfe 239
6HLWH

,QGH[
S
Schachtelungstiefe 44
Schleife 18
Schlüsselworte 39
Selektion 235
Sicherheitsabfrage 236
String 39
Strukturäquivalenz 47
Synthese 85
T
Tear-Off-Menü 230
Textfenster 225, 233
Trennzeichen 39
Turingmaschine 17, 29
V
Variable 17, 41, 42, 189
Variablenliste 67
Variablensubstitution 60
Vererbung 203
Vorkommen 46
W
Warnungen 237
WHILE 7, 39
WHILE-berechenbar 22
while-Konstrukt 39, 181
WHILE-Programm 17, 18, 85
WHILE-Programme 39
Wort 42
Z
Zeichenvorrat 39
6HLWH