Automatisierte Logik und Programmierung

Automatisierte Logik und Programmierung 

1994/95 

Christoph Kreitz 

FG Intellektik, TH Darmstadt, Telephon 16-2863 

kreitz@intellektik.informatik.th-darmstadt.de

Probleme der Kommerziellen Softwareproduktion 

KONVENTIONELLE SOFTWAREPRODUKTION 

Anforderung 

KUNDE 

Spezifikation 

exakte 

Beschreibung 

Programm 

COMPUTER 

Sumpf der Unklarheit 

Wildnis der Lösungs− wege 

• “von Hand”, direkt in Programmiersprache, schnell 

• Software-Krise 

– Hohe Kosten für Erstellung und Wartung 

– Modifikationen und Erweiterungen schwierig 

– Mangelnde Zuverlässigkeit mit fatalen Folgen 

Automatisierte Logik und Programmierung 1 Einführung

Maximale Segmentsumme 

• Gegeben eine Folge a 1 , a 2 , . . . , a n ganzer Zahlen 

Bestimme die Summe Σ q i=p a i eines Segmentes, die maximal 

im Bezug auf alle möglichen Summen von Segmenten ist 

M n ≡ max({Σ q i=p a i | 1≤p≤q≤n}) 

• Direkte Lösung leicht zu finden, aber ineffizient 

• Induktive Betrachtung liefert 

M 1 = a 1 

, M n+1 = max(M n ,L n+1 ) 

wobei L n ≡ max({Σ n i=p a i | 1≤p≤n}) 

L 1 = a 1 , L n+1 = max(L n +a n+1 ,a n+1 ) ) 

→ eleganterer und effizienterer Algorithmus 


Maximale Segmentsumme – direkte Lösung 

maxseg:INTEGER is 

local p, q, i, sum :INTEGER 

do 

from p := lower 

-- variiere untere Grenze p 

Result := item(lower); -- Initialwert zum Vergleich 

until p >= upper 

loop 

from q := p 

-- variiere obere Grenze q 

until q > upper 

loop 

from i := p ; -- Berechne ∑ q 

i=p a i 

sum := item(i) -- Initialwert der Summe 

until i = q 

loop 

i := i+1; sum := sum+item(i) 

end -- sum = ∑ q 

end 

end 

if sum > Result 

q := q+1 

end; 

p := p+1 

i=p a i 

then Result := sum end 


Maximale Segmentsumme: systematische Lösung 

maxseg:INTEGER 

is 

local n, L n :INTEGER 

do 

from n := lower; 

Result := item(n); 

L n := item(n) 

until n >= upper 

invariant -- Result = M n ∧ L n = L n 

variant 

upper - n 

end 

loop 

if L n > 0 

then L n := L n + item(n) 

else L n := item(n) 

end; -- L n = L n+1 

if L n > Result 

then Result := L n 

end; -- Result = M n+1 

n := n+1 

end 


Softwareentwicklung ist .. 

logischer Schlußfolgerungsprozeß 

+ Kreativität 

+ Verarbeitung von Wissen verschiedenster Art (Erfahrung) 

+ fehlerfreie Codierung (Disziplin) 

⇒ Kooperation zwischen Mensch und Maschine sinnvoll 

– Steuerung des Entwicklungsprozesses durch Menschen 

– Korrektheitsgarantie für erzeugte Software durch Computer 

CASE Tools sind nicht genug 


Wissensbasiertes Software Engineering 

= Erzeugung formaler Spezifikationen aus Anforderungen 

+ Synthese von Programmen aus formalen Spezifikationen 

• Formalisierung von Wissen (Kalküle) 

– Formale Sprache 

– Inferenzregeln, welche logsiches Schließen simulieren 

• Strategien 

– Automatisierung des Schließens mit Kalkülen 

– Beweisführung + Programmerzeugung 


Kalküle 

• Mathematik und Programmierung formalisieren 

Axiomatische Mengentheorie ist unkonstruktiv 

⇒ Konstruktive Kalküle (Intuitionistische Typentheorie) 

formalisieren Logik, Berechnung und Standard-Datentypen 

• Beweise interaktiv mit Hilfe von Computern führen 

denn interessante Mathematik ist unentscheidbar 

⇒ Proof-Checker/Beweiseditoren (NuPRL Proof Development System) 

• Möglichkeit der automatischen Unterstützung 

Taktik-Mechanismus: programmierte Beweissuche 


Strategien 

• Entscheidungsprozeduren für eingeschränkte Arithmetik 

und andere entscheidbare Teiltheorien 

• Theorembeweiser für eingeschränkte Anwendungsbereiche 

– Prädikatenlogik, Gleichheit, Induktion + Spezialanwendungen 

• Verfahren zur automatischen Erzeugung korrekter 

Programme 

– KIDS nahe an Routineprogrammierung 

– Implementierung losgelöst von formalen Kalkülen 



Lektion 2 

Formale Kalküle 

1. Kalküle – wozu? 

2. Syntax und Semantik formaler Sprachen 

3. Klassische vs. intuitionistische Mathematik 

4. Objekt- und Metasprache 

5. Definitorische Erweiterung formaler Sprachen 

6. Inferenzsysteme und formale Beweise 

– Natürliche Deduktion – Sequenzenkalküle

Kalküle 

Simulation mathematisch-semantischer Argumentation 

durch Regeln zur Symbolmanipulation 

• Anwendung formaler Vorschriften ohne Nachdenken 

– umgeht Mehrdeutigkeiten der natürlichen Sprache 

– schematische Lösung mathematischer Probleme 

• Kernbestandteile: 

– Formale Sprache (Syntax + Semantik) 

– Ableitungssystem (Regeln + Axiome) 

• Wichtige Eigenschaften: 

– korrekt + vollständig bzgl. Semantik 

– leicht zu verstehen 

– leicht zu verarbeiten (automatisierbar) 

Automatisierte Logik und Programmierung 10 Kalküle

Formale Sprachen 

• Syntax 

– Formale Struktur der Sprache 

– Notation, textliche Erscheinungsform 

– Beschreibbar durch 

– Mathematische Definitionsgleichungen 

– Formale Grammatik 

• Semantik 

– Zuordnung von Bedeutung an syntaktisch korrekte Ausdrücke 

Abbildung von formaler Quellsprache in informale Zielsprache 

– Zielsprache meist Mengentheorie 

– Beschreibbar durch Interpretationsfunktion 


Syntax der Prädikatenlogik (informal) 

• Vordefiniert: Alphabete 

– Variablen-, Funktions- und Prädikatensymbole 

• Terme: Formalisierung mathematischer Objekte 

– Variablen x 

– Funktionsanwendung: f(t 1 , . . . , t n ) 

• Formeln: Formalisierung mathematischer Aussagen 

– atomare Formel: P (t 1 , . . . , t n ) 

– zusammengesetzte Formel: 

¬A, A ∧ B, A ∨ B, A ⇒ B, ∀x.A, ∃x.A, (A) 

• Prioritäten + Konventionen zur Abkürzung 


Semantik der Prädikatenlogik (informal) 

• Interpretationsfunktion weist Variablen-, Funktions- und 

Prädikatensymbolen ein mengentheoretisches Objekt zu 

– Funktions- und Prädikatssymbole haben keine feste Bedeutung 

• Fortsetzung auf Terme und atomare Formeln 

– Zusammensetzung der Einzelinterpretationen zu Objekten / Aussagen 

• Fortsetzung auf zusammengesetzte Formeln: 

Negation ¬A wahr, wenn A falsch 

Konjunktion A ∧ B wahr, wenn A und B wahr 

Disjunktion A ∨ B wahr, wenn A oder B wahr 

Implikation A ⇒ B wahr, wenn B wahr ist, wann immer A wahr ist 

Universelle Quantifizierung ∀x.A wahr, wenn A für jedes x wahr 

Existentielle Quantifizierung ∃x.A wahr, wenn A für ein x wahr 


Intuitionistische vs. klassische Mathematik 

• Begriffe “oder”, “wann immer”, “es gibt” nicht eindeutig: 

– Gilt A ∨ B, wenn nicht A und B falsch sind? 

– Gilt ∃x.A, wenn A nicht für alle x falsch ist? 

• Gesetz vom ausgeschlossenen Dritten: A ∨ ¬A 

“Eine Aussage ist wahr oder ihr Gegenteil ist wahr” 

Nicht: “Eine Aussage ist wahr oder falsch”! 

⇒ “klassische” Mathematik 

• intuitionistische Mathematik 

– lehnt das Gesetz vom ausgeschlossenen Dritten ab 

– versteht alle mathematischen Aussagen konstruktiv 

– für Schließen über Algorithmen naheliegender 

– Beweise werden z.T. komplizierter 

• Formaler Unterschied sehr gering (nur eine Regel) 


Objekt- und Metasprache 

• Objektsprache: 

– Sprache des Kalküls, in dem formalisiert wird 

– formale Sprache 

• Metasprache: 

– Sprache, um Aussagen über den Kalkül zu machen 

– natürliche Sprache 

+ Objektsprache 

+ syntaktische Metavariablen 


Definitorische Erweiterung 

• Erweiterung durch definitorische Abkürzung 

(“konservative” Erweiterung) 

⇒ Kleiner Grundformalismus möglich 

– einfache Syntax und Semantik 

– einfacher Kalkül 

– Eigenschaften leicht beweisbar 

Gleichzeitig Flexibilität 

– umfangreiche formale Sprache 

– freiere Syntax 

• Beispiel: Äquivalenz in der Prädikatenlogik 

A ⇔ B ≡ (A ⇒ B) ∧ (B ⇒ A) 


Ableitungssysteme 

• Syntaktische Manipulation formaler Ausdrücke unter 

Berücksichtigung der Semantik 

• Konversion: 

– Umformung in semantisch äquivalente Ausdrücke 

– erhält den Wert eines Ausdrucks 

4+5 → 9 

A ∧ (A ∨ B) → A 

d/dx(u + v) → du/dx + dv/dx 

• Inferenz: 

– Erzeugung von logischen Konsequenzen 

– erhält Gültigkeit einer Aussage 

aus A und A ⇒ B folgt B: 

– Abschwächung möglich 

– Vielseitiger für logisches Schließen 

A, A ⇒ B 

B 


• Regelschemata: 

“aus A 1 und . . . und A n 

} {{ } 

Prämissen 

(Inferenz)kalküle 

A 1 , . . . , A n 

C 

folgt 

}{{} C ” 

Konklusion 

Axiom: Regel ohne Prämissen 

• Γ ⊢ rs C: Konkrete Anwendung der Regel rs 

• Theorem: Ausdruck, der sich durch Anwendung von 

endlich vielen Regeln ableiten läßt 

• Korrektheit eines Kalküls: Alle Theoreme sind gültig 

Regeln: Gültigkeit der Konklusion folgt aus Gültigkeit der Prämissen 

• Vollständigkeit eines Kalküls: 

alle gültigen Aussagen sind Theoreme 


Kalkülarten 

synthetisch/bottom-up: Schlüsse von den Axiomen zur Aussage 

analytisch/top-down: von der Zielaussage zu den Voraussetzungen 

• Frege–Hilbert–Kalküle: 

– viele Axiome, kaum echte Regeln; sehr mächtig; 

– synthetisch, Beweissuche aufwendig 

• Gentzens natürliches Schließen (NK / NJ) 

– synthetisch, nahe am natürlichen mathematischen Schließen, 

– kaum Axiome, 2 Regeln für jedes logische Zeichen, Verwaltung von Annahmen nötig 

• Sequenzenkalküle (LK / LJ) 

– Modifikation von NK/NJ: Schließen über Urteile statt Aussagen 

– lokale Sicht, keine Verwaltung von Annahmen, gut für interaktive Beweiser 

– synthetisch oder analytisch formulierbar 

• Resolutions- und Konnektionskalküle 

– analytisch, maschinennah, gut für automatisches Beweisen, kaum lesbar 


Natürliche Deduktion (intuitionistisch) 

[A] 

Λ-E 

Λ 

A 

¬-I 

Λ 

¬A 

¬-E 

¬A A 

Λ 

∧ -I 

A B 

A ∧ B 

∧ -E 

A ∧ B 

A 

A ∧ B 

B 

∨ -I 

A 

A ∨ B 

B 

A ∨ B 

∨ -E 

A ∨ B 

[A] 

C 

C 

[B] 

C 

[A] 

⇒ -I 

B 

A ⇒ B 

⇒ -E 

A A ⇒ B 

B 

Einführungsregel –I: unter welchen Voraussetzungen ist eine Formel gültig? 

Eliminationsregel (–E): was folgt aus einer gegebenen Formel? 


((A ⇒ B) ∧ (B ⇒ C)) ⇒ (A ⇒ C) 

mathematischer Beweis 

1. Wir nehmen an (A ⇒ B) ∧ (B ⇒ C) sei erfüllt 

2. Wir nehmen weiter an, daß A gilt. 

3. Aus der ersten Annahme folgt (A ⇒ B) 

4. und mit der zweiten dann auch B. 

5. Aus der ersten Annahme folgt auch, daß (B ⇒ C) gilt 

6. und mit der vierten dann auch C. 

7. Es ergibt sich, daß C unter der Annahme A gilt. Also folgt A ⇒ C 

8. Insgesamt folgt A ⇒ C unter der Annahme (A ⇒ B) ∧ (B ⇒ C). 

Damit gilt die Behauptung: ((A ⇒ B) ∧ (B ⇒ C)) ⇒ (A ⇒ C) 


((A ⇒ B) ∧ (B ⇒ C)) ⇒ (A ⇒ C) 

Beweis in NK 

(1) (A ⇒ B) ∧ (B ⇒ C) Annahme 

(2) A Annahme 

(3) (A ⇒ B) ∧ -E mit (1) 

(4) B ⇒ -E mit (2) und (3) 

(5) (B ⇒ C) ∧ -E mit (1) 

(6) C ⇒ -E mit (4) und (5) 

(7) (A ⇒ C) ⇒ -I mit (2) und (6) — (2) entfällt 

(8) (A ⇒ B) ∧ (B ⇒ C) ⇒ (A ⇒ C) ⇒ -I mit (1) und (7) — (1) entfällt 


Sequenzenkalküle 

• Sequenz: 

A 1 , . . . , A n ⊢ C 

“Formel C folgt aus den Annahmen A 1 ,. . . ,A n ” (Urteil) 

• Regeln manipulieren Sequenzen statt Formeln 

• Eliminationsregeln = Einführungsregeln für Annahmen 

A ∧ B 

A 

→ 

Γ,A ⊢ C 

Γ,A ∧ B ⊢ C 

• analytische Version = Umkehrung + Kontrollparameter 

Γ,A ∧ B ⊢ C 

Γ,A,B ⊢ C 

and elim 


Sequenzenkalkül für Aussagenlogik 

Axiom Γ,A ⊢ A 

Schnitt 

Γ ⊢ A ∆,A ⊢ C 

Γ,∆ ⊢ C 

Λ-E 

Γ, Λ ⊢ A 

¬-I 

Γ, A ⊢ Λ 

Γ, ⊢ ¬A 

¬-E 

Γ ⊢ A 

Γ,¬A ⊢ Λ 

∧ -I 

Γ⊢A Γ⊢B 

Γ ⊢ A ∧ B 

∧ -E 

Γ,A ⊢ C 

Γ,A ∧ B ⊢ C 

Γ,B ⊢ C 

Γ,A ∧ B ⊢ C 

∨ -I 

Γ ⊢ A 

Γ ⊢ A ∨ B 

Γ ⊢ B 

Γ ⊢ A ∨ B 

∨ -E 

Γ,A ⊢ C Γ,B ⊢ C 

Γ,A ∨ B ⊢ C 

⇒ -I 

Γ, A ⊢ B 

Γ ⊢ A ⇒ B 

⇒ -E 

Γ ⊢ A ∆,B ⊢ C 

Γ,∆,A ⇒ B ⊢ C 


((A ⇒ B) ∧ (B ⇒ C)) ⇒ (A ⇒ C) 

Sequenzenbeweis 

(1) A ⊢ A Axiom 

(2) B ⊢ B Axiom 

(3) A, A ⇒ B ⊢ B ⇒ -E mit (1), (2) 

(4) C ⊢ C Axiom 

(5) A, A ⇒ B, B ⇒ C ⊢ C ⇒ -E mit (3), (4) 

(6) A, (A ⇒ B) ∧ (B ⇒ C) ⊢ C ∧ -E 

(6’) (A ⇒ B) ∧ (B ⇒ C), A ⊢ C – Vertauschung – 

(7) (A ⇒ B) ∧ (B ⇒ C) ⊢ A ⇒ C ⇒ -I 

(8) ⊢ (A ⇒ B) ∧ (B ⇒ C) ⇒ (A ⇒ C) ⇒ -I 



Lektion 3 

Prädikatenlogik 

1. Syntax 

2. Semantik 

3. Analytische Sequenzenbeweise 

– strukturelle Regeln 

– aussagenlogische Regeln 

– Quantoren 

– Gleichheit 

– Eigenschaften des Beweiskalküls 

4. Beweismethodik

Prädikatenlogik erster Stufe – Terme 

V: Alphabet von Variablen(-symbolen) 

F i : Alphabet von i-stelligen Funktionssymbolen 

F = ⋃ ∞ 

i=0 

F i 

• x Term, falls x ∈ V 

• f Term (Konstante), falls f ∈ F 0 

• f(t 1 ,. . .,t n ) Term, falls t 1 , .., t n Terme und f ∈ F n 

Automatisierte Logik und Programmierung 27 Prädikatenlogik

Prädikatenlogik erster Stufe (mit Sorten) – Formeln 

P i : Alphabet von i-stelligen Prädikatssymbolen 

P = ⋃ ∞ 

i=0 

P i 

T : Alphabet von Bereichssymbolen (Typen) 

• Λ (atomare) Formel. 

• P atomare Formel (Aussagenvariable), falls P ∈ P 0 

• t 1 = t 2 atomare Formel, falls t 1 und t 2 Terme 

• P (t 1 ,. . .,t n ) atomare Formel, falls t 1 , .., t n Terme, P ∈ P n 

• ¬A, A ∧ B, A ∨ B, A ⇒ B, ∀x:T .A, ∃x:T .A, (A) 

Formeln, falls A, B Formeln, x ∈ V und T ∈ T 


Prädikatenlogik erster Stufe – Semantik I 

• Interpretation: Universum U + Interpretationsfunktion ι 

– ι(x) Objekt aus U (x ∈ V) 

– ι(f) n-stellige Funktion φ : U n →U (f ∈ F n ) 

– ι(T ) Teilmenge von U (T ∈ T ) 

– ι(P ) Funktion Π : U n ↛{wahr, falsch} (P ∈ P n ) 

• ι(f(t 1 ,. . .,t n )) = ι(f)( ι(t 1 ), . . . , ι(t n ) ). 

• ι(Λ) = falsch 

{ 

• ι(t 1 = t 2 ) = 

wahr 

falsch sonst 

falls ι(t 1 ) und ι(t 2 ) in U gleich 

• ι(P (t 1 ,. . .,t n )) = ι(P )( ι(t 1 ), . . . , ι(t n ) ). 


Prädikatenlogik erster Stufe – Semantik II 

{ 

ι(¬A) 

wahr falls ι(A) = falsch 

= 

falsch sonst 

{ 

ι(A ∧ B) 

wahr falls ι(A) = wahr und ι(B) = wahr 

= 

falsch sonst 

{ 

ι(A ∨ B) 

wahr falls ι(A) = wahr oder ι(B) = wahr 

= 

falsch sonst 

{ 

wahr falls aus ι(A) = wahr immer ι(B) = wahr folgt 

ι(A ⇒ B) = 

falsch sonst 

{ 

wahr falls ι 

u 

ι(∀x:T .A) = 

x 

(A) = wahr für alle u ∈ ι(T ) 

falsch sonst (ι u x (x) = u, sonst ιu x 

{ 

= ι) 

ι(∃x:T .A) = 

wahr falls ι u x (A) = wahr für ein u ∈ ι(T ) 

falsch sonst 

ι((A)) = ι(A) 


Prädikatenlogik – klassische Semantik 

ι(A ∨ B) = 

ι(A ⇒ B) = 

ι(∃x:T .A) = 

{ 

{ 

{ 

falsch falls ι(A) = falsch und ι(B) = falsch 

wahr sonst 

falsch falls ι(A) = wahr und ι(B) = falsch 

wahr sonst 

falsch falls ι u x (A) = falsch für alle u ∈ ι(T ) 

wahr sonst 


Modelle und Gültigkeit 

• Modell von A: Interpretation (ι,U) mit ι(A) = wahr 

• A erfüllbar, wenn es ein Modell für A gibt, 

• A widerlegbar, wenn es ein Modell für ¬A gibt, 

• A widersprüchlich, wenn es für A kein Modell gibt, 

• A gültig, wenn jede Interpretation Modell für A ist. 


Sequenzenbeweise 

• Deklaration x:T (x ∈ V, T ∈ T ) 

• Sequenz Γ ⊢ C 

– Γ Hypothesenliste von Formeln oder Deklarationen 

– C Formel (Konklusion) 

• Inferenzregel: Abbildung von Beweisziel in Teilziele 

– Sequenz in endliche Liste von Sequenzen 

• Beweis: Baum mit Sequenz+Regel als Knoten 

– Nachfolger eines Knotens sind Teilziele der Regelanwendung auf Sequenz 

unvollständiger Beweis: manche Blätter ohne Regel 

vollständiger Beweis: Regeln der Blätter ohne Teilziele 

• C Theorem: es gibt vollständigen Beweis für ‘ ⊢ C’ 


Interpretation von Sequenzen 

ι(x:T ) = wahr für jede Deklaration 

⎧ 

wahr falls aus ι(A 1 ) = wahr 

⎪⎨ 

und . . . ι(A n ) = wahr 

ι(A 1 ,...,A n ⊢ C) = 

immer ι(C) = wahr folgt 

⎪⎩ 

falsch sonst 


Sequenzenkalkül – Strukturelle Regeln 

Γ,C,∆ ⊢ C 

by hypothesis i 

Γ,∆ ⊢ C by cut i A 

Γ,∆ ⊢ A 

Γ,A,∆ ⊢ C 

Γ,A,∆ ⊢ C 

Γ,∆ ⊢ C 

by thin i 


Sequenzenkalkül – Aussagenlogische Regeln 

Γ ⊢ A ∧ B by and i 

Γ ⊢ A 

Γ ⊢ B 

Γ ⊢ A ∨ B by or i1 

Γ ⊢ A 

Γ ⊢ A ∨ B by or i2 

Γ ⊢ B 

Γ ⊢ A ⇒ B by imp i 

Γ,A ⊢ B 

Γ ⊢ ¬A by not i 

Γ,A ⊢ Λ 

Γ ⊢ C by classical contradiction 

Γ, ¬C ⊢ Λ 

Γ,A ∧ B,∆ ⊢ C by and e i 

Γ,A,B,∆ ⊢ C 

Γ,A ∨ B,∆ ⊢ C by or e i 

Γ,A,∆ ⊢ C 

Γ,B,∆ ⊢ C 

Γ,A ⇒ B ⊢ C by imp e i 

Γ,A ⇒ B,∆ ⊢ A 

Γ,∆,B ⊢ C 

Γ,¬A,∆ ⊢ C by not e i 

Γ,¬A,∆ ⊢ A 

Γ,∆,Λ ⊢ C 

Γ,Λ,∆ ⊢ C by false e i 


Freies und gebundenes Vorkommen von Variablen 

• x: die Variable x kommt frei vor; y ≠ x kommt nicht vor. 

• f(t 1 , ..., t n ): freie Vorkommen von x in t i bleiben frei, gebundene Vorkommen 

von x bleiben gebunden. 

• Λ: x kommt nicht vor 

• t 1 =t 2 freie Vorkommen von x in t i bleiben frei, gebundene Vorkommen von x 

bleiben gebunden. 

• P (t 1 , ..., t n ) freie Vorkommen von x in t i bleiben frei, gebundene Vorkommen 

von x bleiben gebunden. 

• ¬A, A ∧ B, A ∨ B, A ⇒ B, (A): freie Vorkommen von x in A, B bleiben 

frei, gebundene Vorkommen von x bleiben gebunden. 

• ∀x:T .A, ∃x:T .A: freie und gebundene Vorkommen von x in A werden 

gebunden; freie Vorkommen von y ≠ x in A bleiben frei, gebundene 

Vorkommen von y bleiben gebunden. 


Substitution 

endliche Abbildung σ von Variablen in Terme 

σ = [t 1 , . . . , t n /x 1 , . . . , x n ] ˆ= σ(x 1 )=t 1 , . . . , σ(x n )=t n 

P A[t/x]: Anwendung von σ=[t/x] auf Ausdruck P A 

x[t/x] = t x[t/y] = x (y ≠ x) 

f(t 1 , .., t n )[t/x] = f(t 1 [t/x], .., t n [t/x]) 

Λ[t/x] = Λ t 1 =t 2 [t/x] = t 1 [t/x]=t 2 [t/x]. 

P (t 1 , .., t n )[t/x] = P (t 1 [t/x], .., t n [t/x]) 

¬A[t/x] = ¬A[t/x], A ∧ B[t/x] = A[t/x] ∧ B[t/x], 

A ∨ B[t/x] = A[t/x] ∨ B[t/x], A ⇒ B[t/x] = A[t/x] ⇒ B[t/x], 

(A)[t/x] = (A[t/x]) 

∀x:T .A[t/x] = ∀x:T .A ∃x:T .A[t/x] = ∃x:T .A 

∀x:T .A[t/y] = (∀z:T .A[z/x])[t/y] ∃x:T .A[t/y] = (∃z:T .A[z/x])[t/y] 

y ≠ x, y frei in A, x frei in t, z neue Variable. 

∀x:T .A[t/y] = ∀x:T .A[t/y] ∃x:T .A[t/y] = ∃x:T .A[t/y], 

y ≠ x, y nicht frei in A oder x nicht frei in t 


Sequenzenkalkül – Quantorregeln + Gleichheit 

Γ ⊢ ∀x:T .A by all i ∗ 

Γ,x ′ :T ⊢ A[x ′ /x] 

Γ,∀x:T .A,∆ ⊢ C by all e i t 

Γ,∀x:T .A,∆,A[t/x] ⊢ C 

Γ ⊢ ∃x:T .A 

Γ ⊢ A[t/x] 

by ex i t 

Γ,∃x:T .A,∆ ⊢ C by ex e i ∗∗ 

Γ,x ′ :T ,A[x ′ /x],∆ ⊢ C 

Γ ⊢ t=t by reflexivity Γ ⊢ t 1 =t 2 by symmetry 

Γ ⊢ t 2 =t 1 

Γ ⊢ A[t 1 /x] by substitution t 1 =t 2 

Γ ⊢ t 1 =t 2 by transitivity u 

Γ ⊢ u=t 2 Γ ⊢ A[t 2 /x] 

Γ ⊢ t 1 =u 

Γ ⊢ t 1 =t 2 

∗ : Die Umbenennung [x ′ /x] erfolgt, wenn x in Γ frei vorkommt 

∗∗ : Die Umbenennung [x ′ /x] erfolgt, wenn x in C frei vorkommt. 



Lektion 4 

λ-Kalkül 

1. Syntax 

2. Operationale Semantik 

3. Standard-Erweiterungen 

4. Ein Kalkül zum Schließen über Berechnung 

5. Ausdruckskraft des λ-Kalküls 

6. Eigenschaften des λ-Kalküls

λ-Terme – Syntax 

V: Alphabet von Variablen(-symbolen) 

• x 

λ-Term, falls x ∈ V 

• λx.t 

λ-Term, falls x ∈ V und t λ-Term λ-Abstraktion 

• f t λ-Term, falls t und f λ-Terme 

Applikation 

• (t) 

λ-Term, falls t λ-Term 

Automatisierte Logik und Programmierung 41 λ-Kalkül



• λx.t: freie und gebundene Vorkommen von x in t werden 

gebunden; freie Vorkommen von y ≠ x in t bleiben frei, 

gebundene Vorkommen von y bleiben gebunden. 

• f t: freie Vorkommen von x in f und t bleiben frei, gebundene 

Vorkommen von x bleiben gebunden. 

• (t): freie Vorkommen von x in t bleiben frei, gebundene 

Vorkommen von x bleiben gebunden. 

t[x 1 , . . . , x n ]: x 1 , . . . , x n kommen frei in t vor 

t geschlossen, falls t keine freien Variablen enthält 


Substitution in λ-Termen 

x[t/x] = t x[t/y] = x (y ≠ x) 

λx.u[t/x] = 

λx.u[t/y] = 

λx.u 

λx.u[t/y] 

y ≠ x, y nicht frei in t oder x nicht frei in t 

λx.u[t/y] = (λz.u[z/x])[t/y] 

y ≠ x, y frei in t, x frei in t, z neue Variable. 

f u[t/x] = f[t/x] u[t/x] 

(u)[t/x] = (u[t/x]) 


Konversion und Reduktion – informal 

• Umbenennung gebundener Variablen in t (α-Konversion): 

Ersetzung eines Teilterms der Gestalt λx.u durch den 

Term λz.u[z/x], (z neue Variable) 

• t und u kongruent (α-konvertibel): u ergibt sich aus t 

durch endlich viele Umbenennungen gebundener 

Variablen 

• Reduktion von t: Ersetzung eines Teiltermes der Gestalt 

• t 

(λx.u)(s) (Redex) durch u[s/x] (Kontraktum) 

∗ 

−→ u (t reduzierbar auf u): u ergibt sich aus t durch 

endlich viele Reduktionen und α-Konversionen 


Konversion ∼ = – formal 

• λx.u ∼ = λz.u[z/x], (z neue Variable) 

• f t ∼ = f u, falls t ∼ = u 

• f t ∼ = g t, falls f ∼ = g 

• λx.t ∼ = λx.u, falls t ∼ = u 

• t ∼ = t 

• t ∼ = u, falls u ∼ = t 

• t ∼ = u, falls t ∼ = s und s ∼ = u 

α-Konversion 

µ-Konversion 

ν-Konversion 

ξ-Konversion 

ρ-Konversion 

σ-Konversion 

τ -Konversion 


Reduktion −→ – formal 

• (λx.u) s −→ u[s/x] 

β-Reduktion 

• f t −→ f u, falls t −→ u 

• f t −→ g t, falls f 

−→ g 

• λx.t −→ λx.u, falls t −→ u 

• t −→ u, falls t −→ s und s ∼ = u 

oder t ∼ = s und s −→ u 

t 

– t 

∗ 

−→ u, falls t 

0 

−→ u, falls t ∼ =u, 

n 

– t n+1 

−→ u, falls t −→ s und s 

−→ u für ein n ∈ N. 

1 

t −→ u, falls t −→ u 

−→ n 

u 


Boolesche Operatoren / Operatoren auf Paaren 

T ≡ ≡ λx.λy.x 

F ≡ ≡ λx.λy.y 

if b then s else t ≡ cond(b;s;t) ≡ b s t 

〈s,t〉 ≡ pair(s,t) ≡ λp. p s t 

pair.1 ≡ pi1(pair) ≡ pair (λx.λy.x) 

pair.2 ≡ pi2(pair) ≡ pair (λx.λy.y) 

let 〈x,y〉 = pair in t ≡ spread(pair; x,y.t) ≡ pair (λx.λy.t) 


Zahlen (Church Numerals) und Listen 

n ≡ λf.λx. f n x ≡ λf.λx. f (f ...(f x) ...) 

} {{ } 

n-mal 

s ≡ λn.λf.λx. n f (f x) 

add ≡ λm.λn.λf.λx. m f (n f x) 

mul 

exp 

zero 

≡ λm.λn.λf.λx. m (n f) x 

≡ λm.λn.λf.λx. n m f x 

≡ λn. n (λn.F) T 

p ≡ λn. (n (λfx. 〈s, let 〈f,x〉 = fx in f x〉) 〈λz.0, 0〉).2 

PRs[b,h] 

≡ λn. n h b 

[] ≡ λf.λx.x 

cons(t,list) ≡ λf.λx. f t (list f x) 

t.list 

≡ cons(t,list) 

list ind[b,h] ≡ λlist. list h b 


Rekursion im λ-Kalkül 

• Fixpunktkombinator (Rekursor): λ-Term R mit der 

Eigenschaft, daß für beliebige t gilt: 

R(t) = t( R(t) ) 

• Y ≡ λf. (λx. f (x x)) (λx. f (x x)) ist ein 

Fixpunktkombinator 

• letrec f(x) = t ≡ Y(λf.λx.t) 


Kalkül zum Schließen über Berechnungen 

t=u: es gibt v mit t 

∗ 

−→ v und u 

∗ −→ v. 

(t und u semantisch gleich / konvertierbar) 

Γ ⊢ f t = g u 

Γ ⊢ f = g 

Γ ⊢ t = u 

by apply eq 

Γ ⊢ λx.t = λy.u by lambda eq ∗ 

Γ, x ′ :U ⊢ t[x ′ /x] = u[x ′ /y] 

Γ ⊢ (λx.u) s = t 

u[s/x] = t 

by reduction 

Γ ⊢ t=t by reflexivity Γ ⊢ t 1 =t 2 by symmetry 

Γ ⊢ t 1 =t 2 by transitivity u 

Γ ⊢ t 1 =u 

Γ ⊢ t 2 =t 1 

Γ ⊢ u=t 2 

∗ : Die Umbenennung [x ′ /x] erfolgt, wenn x in Γ frei vorkommt. 


µ-rekursive Funktionen 

1. Konstanten 0, 1, 2, . . . – (nullstellige Funktionen) 

2. Nullfunktion z mit z(n) = 0 für alle n ∈ N 

3. Nachfolgerfunktion s mit s(n) = n + 1 für alle n ∈ N 

4. Projektionsfunktionen pr n m mit prn m (x 1, ..., x n ) = x m 

5. Komposition Cn[f, g 1 ...g n ] der Funktionen f, g 1 ...g n : 

h = Cn[f, g 1 ...g n ], wenn h(⃗x) = f( g 1 (⃗x), ..., g n (⃗x) ) 

6. primitive Rekursion P r[f, g] zweier Funktionen f und g: 

h = P r[f, g], wenn 

h(⃗x, 0) = f(⃗x) , h(⃗x, y + 1) = g(⃗x, y, h(⃗x, y)) 

7. Minimierung 

⎧ 

Mn[f] einer Funktion f: h = Mn[f], wenn 

⎪⎨ min{y | f(⃗x, y) = 0} falls dies existiert und 

h(⃗x) = 

alle f(⃗x, i), i < y definiert 

⎪⎩ undefiniert 

sonst 


Ausdruckskraft des λ-Kalküls 

• f:N n →N λ-berechenbar, wenn es einen λ-Term t gibt mit: 

f(x 1 , ..., x n ) = m ⇔ t x 1 ...x n = m 

⇒ Die Klasse der λ-berechenbaren Funktionen ist identisch mit der Klasse 

der µ-rekursiven Funktionen. 

1. Konstanten 0, 1, 2, . . . ∈ N: Church-Numerals 0,1,2,. . . 

2. Nullfunktion z: λn.0 

3. Nachfolgerfunktion s: s 

4. Projektionsfunktionen prm n : λx ....λx 1 n.x m 

5. Komposition Cn[f, g 1 , .., g n ]: 

Cn ≡ λf.λg 1 

....λg n 

. λ⃗x. f (g 1 

⃗x) ...(g n 

⃗x) 

6. Primitive Rekursion P r[f, g]: 

Pr ≡ λf.λg. Y (λh.λ⃗x.λy. if zero y then f⃗x else g ⃗x (p y) (h⃗x (p y)) ) 

7. Minimierung Mn[f]: 

Mn ≡ λf.λ⃗x. ( Y (λmin.λy. if zero(f⃗x y) then y else min (s y) ) ) 0 


Normalform 

• t in Normalform, wenn t keine Redizes enthält 

• t normalisierbar, wenn t auf einen λ-Term in 

Normalform reduziert werden kann 

• t Normalform von s, wenn t in Normalform und 

s −→ ∗ t 


Eigenschaften des λ-Kalküls 

• Es gibt λ-Terme ohne Normalform 

– (λx. x x) (λx. x x) 

• Es gibt normalisierbare λ-Terme, bei denen nicht jede 

Reduktionsfolge zu einer Normalform führt 

– (λx.λy.y) ((λx. x x x) (λx. x x x)) (λx. x) 

• Ist ein λ-Term normalisierbar, so kann man die Normalform 

durch Reduktion des jeweils äußersten Redex bestimmen. 

• Die Normalform eines λ-Terms ist eindeutig 

Church-Rosser Theorem: Gilt t −→ u und t −→ v, 

so gibt es einen λ-Term s mit u −→ ∗ 

s und v −→ ∗ 

s. 

• Satz von Rice: Alle nichttrivialen extensionalen 

Eigenschaften von λ-Termen sind unentscheidbar. 

∗ 

Automatisierte Logik und Programmierung 54 λ-Kalkül 

∗


Lektion 5 

Die einfache Typentheorie I 

1. Syntax, Semantik und Typzugehörigkeit 

2. Formales Schließen über Typzugehörigkeit 

3. Ein Typechecking Algorithmus

Typentheorie – Syntax 

Typ-Ausdrücke: 

• T (atomarer) Typ, wenn T ∈ T (Alphabet von Bereichssymbolen) 

• S→T 

Typ, falls S und T Typen 

• (T ) Typ, falls T Typ 

→ ist rechtsassoziativ 

Objekt-Ausdrücke sind λ-Terme 

• x λ-Term, falls x ∈ V (Alphabet von Variablen) 

• λx.t λ-Term, falls x ∈ V und t λ-Term 

• f t λ-Term, falls t und f λ-Terme 

• (t) λ-Term, falls t λ-Term 

Automatisierte Logik und Programmierung 56 Einfache Typentheorie

Typzugehörigkeit 

Typzugehörigkeitsrelation t ∈ T : 

• x ∈ T , falls x ∈ V und T ein Typ 

• λx.t ∈ S→T , falls t ∈ T aus x ∈ S folgt 

• f t ∈ T , falls f ∈ S→T und t ∈ S für einen Typ S. 

• (t) ∈ T , falls t ∈ T 

• t ∈ (T ), falls t ∈ T 

t typisierbar, falls es einen Typ T gibt mit t ∈ T . 

prinzipielles Typschema von t: kleinster Typ T mit t ∈ T 

Sind t und t ′ semantisch gleich, so gilt t ∈ T ⇔ t ′ ∈ T 


Kalkül zum Schließen über Typzugehörigkeit 

Γ ⊢ λx.t ∈ S→T by lambda i ∗ 

Γ, x ′ :S ⊢ t[x ′ /x] ∈ T 

Γ ⊢ S ∈ U 

Γ ⊢ f t ∈ T by apply i S 

Γ ⊢ f ∈ S→T 

Γ ⊢ t ∈ S 

Γ ⊢ S→T ∈ U 

Γ ⊢ S ∈ U 

Γ ⊢ T ∈ U 

by function i 

Γ, x:T , ∆ ⊢ x ∈ T by declaration i 

∗ : Umbenennung [x ′ /x], wenn x in Γ frei vorkommt 


Deklaration, Typisierungen, Sequenzen 

• Festes Symbol U (Universum aller Typen) 

• Deklaration 

x:X (Variablendeklaration) oder T :U (Typdeklaration) 

• Typisierung: t ∈ T oder T ∈ U 

• Sequenz Γ ⊢ C 

– Γ Hypothesenliste von Deklarationen 

– C Typisierung (Konklusion) 

• Γ rein: jeder Bezeichner genau einmal deklariert, Bezeichner T , 

der rechts in Deklaration erscheint, zuvor deklariert durch T :U 

• Initialsequenz: Sequenz Γ ⊢ t ∈ T , Γ rein, Γ deklariert alle in T 

vorkommenden Bezeichner und sonst keine 

• Inferenzregel, Beweis etc. wie zuvor 


Sequenzenbeweis für (λf.λx. f x)(λz.z) ∈ 

T→T 

T:U ⊢ (λf.λx. f x)(λz.z) ∈ T→T by apply i T→T 

|\ 

| T:U ⊢ λf.λx. f x ∈ (T→T) → (T→T) by lambda i 

| |\ 

| | T:U, f:T→T ⊢ λx. f x ∈ T→T by lambda i 

| | |\ 

| | | T:U, f:T→T, x:T ⊢ f x ∈ T by apply i T 

| | | |\ 

| | | | T:U, f:T→T, x:T ⊢ f ∈ T→T by declaration 2 

| | | \ 

| | | T:U, f:T→T, x:T ⊢ x ∈ T by declaration 3 

| | \ 

| | T:U, f:T→T ⊢ T ∈ U by declaration 1 

| \ 

| T:U ⊢ T→T ∈ U by function i 

| |\ 

| | T:U ⊢ T ∈ U by declaration 1 

| \ 

| T:U ⊢ T ∈ U by declaration 1 

\ 

T:U ⊢ λz.z ∈ T→T by lambda i 

|\ 

| T:U, z:T ⊢ z ∈ T by declaration 2 

\ 

T:U ⊢ T ∈ U by declaration 1 


Hindley-Milner Typechecking Algorithmus 

Eingabe: geschlossener λ-Term t 

Ausgabe: prinzipielles Typschema von t oder Fehlermeldung 

Start: σ:=[]; TYPE-OF([], t) 

Algorithmus TYPE-OF(Env,t) : 

Falls t=x ∈ V: suche Deklaration x:T in Env und gebe T aus 

Falls t=f u: 

S 1 :=TYPE-OF(Env,f); S 2 :=TYPE-OF(Env,u) 

Wähle neues X i+1 und unifiziere σ(S 1 ) mit S 2 →X i+1 . 

Falls Unifikation fehlschlägt, breche mit Fehlermeldung ab. 

Sonst σ := σ ′ ◦σ (σ ′ Unifikationsergebnis) Ausgabe σ(X i+1 ) 

Falls t=λx.u: 

{ 

Wähle neues X i+1 

TYPE-OF(Env·[x:X i+1 ],u) falls x nicht in Env 

S 1 := 

TYPE-OF(Env·[x ′ :X i+1 ],u[x ′ /x]) sonst (x ′ ∈ V neu) 

Ausgabe σ(X i+1 )→S 1 


Typisierung von λf.λx. f(f(f x)) 

Env Aktueller Term t σ UNIFY Typ 

λf.λx. f(f(f x)) 

f:X 0 

λx. f(f(f x)) 

f:X 0 

, x:X 1 

f(f(f x)) 

f:X 0 

, x:X 1 

f X 0 

f:X 0 

, x:X 1 

f(f x) 

f:X 0 

, x:X 1 

f X 0 

f:X 0 

, x:X 1 

f x 

f:X 0 

, x:X 1 

f X 0 

f:X 0 

, x:X 1 

x X 1 

f:X 0 

, x:X 1 

f x X 0 

= X 1 

→X 2 

X 2 

f:X 0 

, x:X 1 

f(f x) [X 1 

→X 2 

/X 0 

] X 1 

→X 2 

= X 2 

→X 3 

X 3 

f:X 0 

, x:X 1 

f(f(f x)) [X 3 

,X 3 

,X 3 

→X 3 

/ X 2 

,X 1 

,X 0 

] X 3 

→X 3 

= X 3 

→X 4 X 4 

f:X 0 

λx. f(f(f x)) [X 4 ,X 4 ,X 4 ,X 4 →X 4 / X 3 

,X 2 

,X 1 

,X 0 

] X 4 →X 4 

λf.λx. f(f(f x)) [X 4 ,X 4 ,X 4 ,X 4 →X 4 / X 3 

,X 2 

,X 1 

,X 0 

] (X 4 →X 4 ) → X 4 →X 4 



Lektion 6 

Die einfache Typentheorie II 

1. Eigenschaften typisierbarer λ-Terme 

– Schwache Normalisierbarkeit 

– Starke Normalisierbarkeit 

– Konfluenz 

– Entscheidbarkeit 

2. Schließen über den Wert getypter λ-Terme 

3. Die Curry-Howard Isomorphie 

4. Die Ausdruckskraft typisierbarer λ-Terme

Eigenschaften typisierbarer Terme 

• Schwache Normalisierbarkeit 

– jeder Term hat Normalform 

– alle Funktionen total 

• Starke Normalisierbarkeit 

– jede Reduktionsfolge terminiert 

• Konfluenz / Church-Rosser Theorem 

– Reduktionsfolgen wieder zusammenführbar 

– jede Normalform ist eindeutig 

• Entscheidungsprozeduren 

– Typisierbarkeit 

– Gleichheit 

– Korrektheit und Äquivalenz von Programmen 


Schwache Normalisierbarkeit 

• Tiefe d(T ) eines Typausdrucks T 

– d(T ) = 0, falls T ∈ T , d(S→T ) = 1 + max(d(S), d(T )) 

Tiefe von (λx.t) u: Tiefe des Typs von λx.t. 

Tiefe von t: maximale Tiefe der Redizes von t 

• Lemma: Reduziert man in t das am weitesten rechts 

stehende Redex maximaler Tiefe, so verringert sich die 

Anzahl der Redizes maximaler Tiefe. 

• Satz: Die Rightmost-Maxdepth-Strategie terminiert 

auf allen typisierbaren λ-Termen 

• Korollar: Jeder typisierbare λ-Term ist normalisierbar 


Starke Normalisierbarkeit – Begriffe 

• t stark normalisierbar: 

jede in t beginnende Reduktionsfolge terminiert. 

• Berechenbare typisierte Terme: 

– t ∈ T (T atomar) berechenbar, falls t stark normalisierbar 

– t ∈ S→T berechenbar, falls t s berechenbar für alle 

berechenbare s ∈ S 

• t neutral, falls t nicht die Gestalt λx.u hat. 


Starke Normalisierbarkeit – Ergebnisse 

• T Typausdruck; t und t ′ Terme vom Typ T 

1. t berechenbar ⇒ t stark normalisierbar 

β 

2. t berechenbar, t −→ t ′ ⇒ t ′ berechenbar 

3. t neutral, jede β-Reduktion führt zu berechenbaren t ′ 

⇒ 

t berechenbar 

4. t neutral und in Normalform ⇒ t berechenbar. 

• t[s/x] berechenbar für alle berechenbaren s ⇒ λx.t berechenbar 

• x 1 . . . x n freie Variablen von t, b i berechenbare Terme vom Typ der x i . 

Dann ist t[b 1 . . . b n / x 1 . . . x n ] berechenbar 

• Alle typisierbaren λ-Terme sind berechenbar 

• Alle typisierbaren λ-Terme sind stark normalisierbar 


Konfluenz ( 

r 

−→ Reduktionsrelation) 

• t 

t 

n 

−→ s: s ergibt sich aus t durch n Reduktionsschritte 

– t 

0 

−→ s, falls t=s 

– t n+1 

−→ s, falls es u gibt mit t 

∗ 

−→ s: es gibt ein n ∈ N mit t 

t + −→ s: es gibt ein n>0 mit t 

• t↑s: es gibt u mit u 

• t↓s: es gibt u mit t 

r 

−→ u und u 

n −→ s 

n −→ s 

∗ −→ t und u 

∗ 

−→ u und s 

n 

−→ s 

∗ −→ s 

∗ −→ u 

• r −→ konfluent: aus t↑s folgt immer t↓s 

• r −→ lokal konfluent: aus u 

r −→ t, u 

r −→ s folgt t↓s 


Konfluenz / Church-Rosser Theorem 

r 

• Lemma: −→ stark normalisierbar, lokal konfluent, 

dann 

r 

−→ konfluent 

• Lemma: Die β-Reduktion 

• Satz: In der Typentheorie ist 

• Korollar: 

β −→ ist lokal konfluent 

β 

−→ konfluent 

Typisierbare λ-Terme haben eindeutige Normalformen 


Integration des Berechnungskalküls 

Konzept: Gleichheit von Termen innerhalb eines Typs 

s=t + t ∈ T ↦→ s = t ∈ T 

Modifizierte Regeln 

Γ ⊢ f t = g u ∈ T by applyEq S 

Γ ⊢ f = g ∈ S→T 

Γ ⊢ t = u ∈ S 

Γ ⊢ λx.t = λy.u ∈ S→T by lambdaEq 

Γ, x ′ :S ⊢ t[x ′ /x] = u[x ′ /y] ∈ T 

Γ ⊢ S ∈ U 

Γ ⊢ (λx.u) s = t ∈ T 

u[s/x] = t ∈ T 

by reduction 


Curry-Howard Isomorphie 

Integration der Logik 

Γ ⊢ λx.t ∈ S→T by lambda i 

Γ, x ′ :S ⊢ t[x ′ /x] ∈ T 

Γ ⊢ S ∈ U 

Γ ⊢ A ⇒ B by imp i 

Γ,A ⊢ B 

Γ ⊢ f t ∈ T by apply i S 

Γ ⊢ f ∈ S→T 

Γ ⊢ t ∈ S 

Γ ⊢ B by modus ponens A 

Γ ⊢ A ⇒ B 

Γ ⊢ A 

Typ 

Formel 

Variable vom Typ S 

Annahme der Formel S 

Term vom Typ T (freie Variablen aus S i ) Beweis von T (Annahmen S i ) 

Typechecking 

Beweisführung 

(Regel der) λ-Abstraktion 

⇒ -Einführung 

(Regel der) Applikation 

⇒ -Elimination 


Schließen über Programmierung 

• Prädikatenlogik: Analyse der logischen Struktur 

– Bedeutung von Konzepten unwichtig 

• λ-Kalkül: Wert von Ausdrücken 

– sehr ausdrucksstark, kaum kontrollierbar 

• Einfache Typentheorie: Eigenschaften von Programmen 

– bisher zu ausdrucksschwach, da zu einfach 

⇒ Integriere Logik und λ-Kalkül und erweitere Typsystem 

↦→ Intuitionistische Typentheorie 

– komplexer, ausdrucksstärker, aufwendigere Semantik 



Lektion 7 

Intuitionistische Typentheorie: Systematik, Syntax & Semantik 

1. Anforderungen an einen universell verwendbaren Kalkül 

– Konstruktive mathematische Grundlagentheorie 

– Ausdruckskraft 

– Eigenschaften von Berechnungsmechanismen und Beweiskalkül 

2. Systematik der Syntax formaler Ausdrücke 

3. Semantik: Werte und Eigenschaften formaler Ausdrücke 

– Der Wert eines Ausdrucks 

– Urteile und hypothetische Urteile

Intuitionistische Typentheorie 

Universell verwendbarer Kalkül 

• Anforderungen und Gestaltungsziele 

• Systematik 

– Aufbau von Syntax, Semantik, Inferenzsystem 

– elementare Datentypen (Funktionenraum, Produktraum, disjunkte Vereinigung) 

• Einbettung von Logik 

– Curry-Howard Isomorphie (intuitionistische Logik) / Leerer Datentyp 

– Gödelsche Übersetzung (klassische Logik) 

• Programmierung in der Typentheorie 

– Beweise als Programme 

– Zahlen, Listen, Teilmengen, Restklassen 

• Rekursion 

– induktive Typen, (partiell-)rekursive Funktionen, unendliche Objekte 

Automatisierte Logik und Programmierung 74 Intuitionistische Typentheorie

Typentheorie – grundlegende Konstrukte 

• Funktionenraum S→T — λx.t, f t 

• Produktraum S×T — 〈s,t〉, let 〈x,y〉 = pair in u 

• Summe (disjunkte Vereinigung) S+T 

— inl(s), inr(t), case e of inl(x) ↦→ u | inr(y) ↦→ v 

• Natürliche Zahlen (N) oder ganze Zahlen (Z) 

— 0,1,-1,2,-2,..., +,-,*,/, Induktion 

• Listen (Folgen) S list — [], t.list, Induktion 

• Teilmengen {x:T |P (x)} — Restriktion der Elemente 

• Restklassen (Quotiententypen) — andere Gleichheit 

• Textketten (strings) 

• rekursive Datentypen, partiell-rekursive Funktionen 

• abhängige Datentypen x:S→T , x:S×T 

• Logik eingebettet durch Curry-Howard Isomorphie 


Typentheorie – Anforderungen 

• Mathematische Grundlagentheorie 

– konstruktive (formale) Mengentheorie 

– universelle Sprache zur Simulation aller Konzepte 

– Abstützung der Semantik “in sich selbst”, widerspruchsfrei 

• Terminierenden Berechnungen 

– Starke Normalisierbarkeit nicht erforderlich 

– feste Reduktionsstrategie 

• Konfluenz 

– Konsistenz zwischen Beweisführung und Berechnung 

• Typisierbarkeit? 

– problematisch wegen abhängiger Datentypen 

– Prüfung im Beweiskalkül 

• Beweis-/Programm-konstruktion (statt -überprüfung) 


Systematik des Theorieaufbaus 

Konstruktive semantische Theorie 

Syntax: Ausdrücke (Terme), bindende Vorkommen von Variablen 

Semantik: 

Werte von Termen 

– Unterteile in kanonische und nichtkanonische Terme 

– Wertbestimmung durch Reduktion auf kanonischen Term 

Urteile: Eigenschaften, Beziehungen zwischen Termen 

– Gleichheit, Typzugehörigkeit, Typ-Sein 

– Explizite (rekursive) Definition für kanonischen Terme, sonst zunächst Reduktion 

hypothetische Urteile: Argumentieren unter Annahmen 

Inferenzsystem: 

Repräsentation von (hypothetischen) Urteilen durch Sequenzen 

– Inferenzregeln spiegeln Semantikdefinition (unvollständig) wieder 

– Hinzunahme von Typuniversen und Gleichheitstyp in Syntax 

Automatisierte Logik und Programmierung 77 Typentheorie – Systematik

Ausdrücke – unsystematisch 

• x Ausdruck, falls x ∈ V 

• (t) Ausdruck, falls t Ausdruck 

• λx.t Ausdruck, falls x ∈ V und t Ausdruck 

• f t Ausdruck, falls t und f Ausdrücke 

• x:S→T und S→T Ausdrücke, falls x ∈ V, S und T Ausdrücke 

• 〈s,t〉 Ausdruck, falls s und t Ausdrücke 

• let 〈x,y〉 = e in u Ausdruck, falls x, y ∈ V sowie e und u Ausdrücke 

• x:S×T und S×T Ausdrücke, falls x ∈ V, S und T Ausdrücke 

• inl(s) und inr(t) Ausdrücke, falls s und t Ausdrücke 

• case e of inl(x) ↦→ u | inr(y) ↦→ v 

Ausdruck, falls x, y ∈ V und e, u, v Ausdrücke 

• S+T Ausdruck, falls S und T Ausdrücke 


Freies/gebundenes Vorkommen von Variablen – 

unsystematisch 


• (t): freie Vorkommen von x in t bleiben frei, gebundene Vorkommen bleiben gebunden. 

• λx.t: freie Vorkommen von x in t werden gebunden; freie Vorkommen von y ≠ x in t bleiben frei, 

gebundene Vorkommen bleiben gebunden. 

• f t: freie Vorkommen von x in f und t bleiben frei, gebundene Vorkommen bleiben gebunden. 

• x:S→T : freie Vorkommen von x in T werden gebunden; freie Vorkommen von y ≠ x in T bleiben frei, 


S→T : freie Vorkommen von x in S oder T bleiben frei, gebundene Vorkommen bleiben gebunden. 

• 〈s,t〉: freie Vorkommen von x in s und t bleiben frei, gebundene Vorkommen bleiben gebunden. 

• let 〈x,y〉 = e in u: freie Vorkommen von x und y in u werden gebunden; freie Vorkommen von x und y 

in e bleiben frei; freie Vorkommen von z ≠ x/y bleiben frei, gebundene Vorkommen bleiben gebunden. 

• x:S×T : freie Vorkommen von x in T werden gebunden; freie Vorkommen von y ≠ x in T bleiben frei, 


S×T : freie Vorkommen von x in S oder T bleiben frei, gebundene Vorkommen bleiben gebunden. 

• inl(s), inr(t): freie Vorkommen von x in s bzw. t bleiben frei, gebundene Vorkommen bleiben gebunden. 

• case e of inl(x) ↦→ u | inr(y) ↦→ v : freie Vorkommen von x in u bzw. von y in v werden gebunden; 

freie Vorkommen von z ≠ x/y in u bzw. v bleiben frei, gebundene Vorkommen bleiben gebunden. 

• S+T : freie Vorkommen von x in S oder T bleiben frei, gebundene Vorkommen bleiben gebunden. 


Terme – einheitliche Definition 

Abstraktionsform opid{P 1 , . . . , P n }(b 1 ; . . . ; b n ) und Darstellungsform 

von Termen werden getrennt behandelt aber simultan betrachtet 

• I: Menge von Indexfamilien 

→ Indexfamilientabelle 

muß Famile variable enthalten 

p:F Parameter, falls F ∈ I und p zulässiges Element von F 

F Parametertyp, p Parameterwert 

• opid{P 1 , . . . , P n } Operator, falls opid Operatorname, P i Parameter 

→ Operatorentabelle 

muß Operator var enthalten 

• V: Menge von Variablen (Elemente von variable) 

– x 1 , . . . , x m .t gebundener Term, falls t Term, x i ∈ V 

– op(b 1 ;. . .;b n ) Term, falls op Operator, b i gebundene Terme 


Indexfamilientabelle der Typentheorie von NuPRL 

variable : Variablennamen 

Zulässige Elemente: Zeichenketten aus [a−z A−Z 0−9 - %] + 

natural : Natürliche Zahlen 

Zulässige Elemente: Zeichenketten aus 0 + [1 − 9][0 − 9] ∗ . 

token : Zeichenketten (für Namen) 

Zulässige Elemente: alle Strings des NuPRL Zeichensatzes 

(keine Kontrollsymbole) 

string : Zeichenketten (für Texte) 

Zulässige Elemente: alle Strings des NuPRL Zeichensatzes 

(keine Kontrollsymbole) 

level-expression : Ausdrücke für Level von Typuniversen 

Zulässige Elemente: eingeschränkte arithmetische Ausdrücke 


Operatorentabelle (Funktionen, Produkt, Summe) 

Operator und Termstruktur Display Form 

var{x:v}() 

x 

fun{}(S; x.T ) 

x:S→T 

lam{}(x.t) 

λx.t 

apply{}(f;t) 

f t 

prod{}(S; x.T ) 

x:S×T 

pair{}(s;t) 

〈s,t〉 

spread{}(e; x,y.u) let 〈x,y〉 = e in u 

union{}(S;T ) 

S+T 

inl{}(s), inr{}(t) inl(s), inr(t) 

decide{}(e; x.u; y.v) case e of inl(x) ↦→ u | inr(y) ↦→ v 



• var{x:v}: x ∈ V kommt frei vor; y ≠ x kommt nicht vor. 

• op(b 1 ;. . .;b n ): freie Vorkommen von x in den b i bleiben frei, 


• x 1 , . . . , x m .t: freie und gebundene Vorkommen der x i in t werden 

gebunden; freie Vorkommen von y ≠ x i bleiben frei, gebundene 

Vorkommen von y bleiben gebunden. 

t[x 1 , . . . , x n ]: x 1 , . . . , x n kommen frei in t vor 

t geschlossen, falls t keine freien Variablen enthält 


Substitution in Termen 

var{x:v}()[t/x] 

= t 

var{x:v}()[t/y] = var{x:v}(), (y ≠ x) 

(op(b 1 ;. . .;b n ))[t/x] 

= op(b 1 [t/x];. . .;b n [t/x]) 

(x 1 ,...,x n .u)[t/x] = x 1 ,...,x n .u, 

x ist eines der x i 

(x 1 ,...,x n .u)[t/x] = x 1 ,...,x n .u[t/x] 

x verschieden von allen x i , x nicht frei in u oder 

keines der x i frei in t 

(x 1 ,..,x j ,..,x n .u)[t/x] = (x 1 ,..,z,..,x n .u[z/x j ])[t/x] 

x verschieden von allen x i , x frei in u, x j frei 

in t, z neue Variable. 


Auswertung von Ausdrücken 

Die Semantik der Typentheorie basiert auf Lazy Evaluation 

• t = opid{P 1 , . . . , P n }(b 1 , . . . , b n ) kanonisch, 

falls opid in Operatorentabelle als kanonisch gekennzeichnet. 

Wert: geschlossener kanonischer Term 

• prinzipiellen Argumente von t (Hauptargumente von t): 

in Operatorentabelle gekennzeichnete Teilterme von t 

• t Redex: t nichtkanonisch, prinzipielle Argumente in 

kanonischer Form + Eintrag in 

→ Redex–Kontrakta Tabelle 

Kontraktum von t: zugehöriger Eintrag in Redex–Kontrakta Tabelle 

• t reduzierbar auf u (t 

• u Wert eines geschlossenen Terms t (t 

β 

−→ u), falls u Kontraktum von t 

l 

−→ u): 

u Ergebnis der Anwendung der Auswertungsprozedur EVAL auf t. 


Algorithmus EVAL(t) 

• Falls t in kanonischer Form: Ausgabe t 

• Falls t nichtkanonisch: 

Bestimme s 1 :=EVAL(t 1 ), . . . , s n :=EVAL(t n ), wobei die 

t i die Hauptargumente von t sind. 

Ersetze in t die t i durch ihre Werte s i ; 

nenne das Result s 

– Falls s ein Redex ist und u das zugehörige 

Kontraktum, so gebe EVAL(u) als Wert aus. 

– Andernfalls stoppe die Reduktion ohne Ergebnis: 

t besitzt keinen Wert. 


Vollständige Operatorentabelle (Funktionen, 

Produkt, Summe) 

kanonisch 

nichtkanonisch 

(Typen) 

(Elemente) 

var{x:v}() 

x 

fun{}(S; x.T ) lam{}(x.t) apply{}( f ;t) 

x:S→T λx.t f t 

prod{}(S; x.T ) pair{}(s;t) spread{}( e ; x,y.u) 

x:S×T 〈s,t〉 let 〈x,y〉 = e in u 

union{}(S;T ) inl{}(s), inr{}(t) decide{}( e ; x.u; y.v) 

S+T inl(s), inr(t) case e of inl(x) ↦→ u | inr(y) ↦→ v 

Hauptargumente umrandet, Trennung von Typen und Elementen nur informativ 


Redex–Kontrakta Tabelle (Funktionen, Produkt, 

Summe) 

Redex 

(λx.u) t 

let 〈x,y〉 = 〈s,t〉 in u 

case inl(s) of inl(x) ↦→ u | inr(y) ↦→ v 

case inr(t) of inl(x) ↦→ u | inr(y) ↦→ v 

β 

−→ 

β 

Kontraktum 

u[t/x] 

−→ u[s, t / x, y] 

β 

−→ 

β 

−→ 

u[s/x] 

v[t/y] 


Urteile in der Typentheorie 

Semantische Grundbausteine zur 

Formulierung der Eigenschaften von Termen 

• T Typ: T ist ein Ausdruck für einen Typ (Menge). 

(Typ-Sein) 

• S=T : S und T beschreiben denselben Typ. 

(Typgleichheit) 

• t ∈ T : t beschreibt ein Element des Typs T 

(Typzugehörigkeit) 

• s=t ∈ T : s und t beschreiben dasselbe Element des 

Typs T 

(Elementgleichheit) 

Semantische Gleichheit ist stärker als Identität von Werten 


Semantik von Urteilen 

• T Typ, falls T =T 

• S=T , falls es kanonische Terme S ′ und T ′ gibt mit 

l 

S −→ S ′ l 

, T −→ T ′ und S ′ =T ′ folgt aus 

→ Typsemantiktabelle 

• t ∈ T , falls t=t ∈ T 

• s=t ∈ T , falls es kanonische Terme s ′ , t ′ und T ′ gibt 

l 

mit s −→ s ′ l 

, t −→ t ′ , T =T ′ und s ′ =t ′ ∈ T ′ folgt aus 

→ Elementsemantiktabelle 


Semantiktabellen für Funktionen, Produkt, Summe 

Typsemantik 

x 1 :S 1 →T 1 = x 2 :S 2 →T 2 ≡ S 1 =S 2 und T 1 [s 1 /x 1 ]=T 2 [s 2 /x 2 ] für alle Terme s 1 , s 2 mit 

s 1 =s 2 ∈ S 1 . 

T = S 2 →T 2 ≡ T = x 2 :S 2 →T 2 für ein beliebiges x 2 ∈ V. 

S 1 →T 1 = T ≡ x 1 :S 1 →T 1 = T für ein beliebiges x 1 ∈ V. 

x 1 :S 1 ×T 1 = x 2 :S 2 ×T 2 ≡ S 1 =S 2 und T 1 [s 1 /x 1 ]=T 2 [s 2 /x 2 ] für alle Terme s 1 , s 2 mit 

s 1 =s 2 ∈ S 1 . 

T = S 2 ×T 2 ≡ T = x 2 :S 2 ×T 2 für ein beliebiges x 2 ∈ V. 

S 1 ×T 1 = T ≡ x 1 :S 1 ×T 1 = T für ein beliebiges x 1 ∈ V. 

S 1 +T 1 = S 2 +T 2 ≡ S 1 =S 2 und T 1 =T 2 . 

Elementsemantik 

λx 1 .t 1 = λx 2 .t 2 ∈ x:S→T ≡ x:S→T Typ und t 1 [s 1 /x 1 ] = t 2 [s 2 /x 2 ] ∈ T [s 1 /x] für 

alle Terme s 1 , s 2 mit s 1 =s 2 ∈ S. 

〈s 1 ,t 1 〉 = 〈s 2 ,t 2 〉 ∈ x:S×T ≡ x:S×T Typ und s 1 =s 2 ∈ S und t 1 =t 2 ∈ T [s 1 /x]. 

inl(s 1 ) = inl(s 2 ) ∈ S+T ≡ S+T Typ und s 1 =s 2 ∈ S. 

inr(t 1 ) = inr(t 2 ) ∈ S+T ≡ S+T Typ und t 1 =t 2 ∈ T . 


Eigenschaften der semantischen Urteile 

• Typgleichheit S=T ist transitiv und symmetrisch (aber nicht reflexiv) 

• S=T gilt genau dann, wenn es S ′ gibt mit S 

l 

−→ S ′ und S ′ =T . 

• Elementgleichheit s=t ∈ T ist transitiv und symmetrisch (aber nicht 

reflexiv) in s und t. 

• s=t ∈ T gilt genau dann, wenn es s ′ gibt mit s 

• Aus s=t ∈ T folgt, daß T ein Typ (T =T ) ist. 

• Aus s=t ∈ T und S=T folgt, daß s=t ∈ S gilt. 

l 

−→ s ′ und s ′ =t ∈ T . 


Hypothetische Urteile 

Urteile unter gegebenen Hypothesen 

x 1 :T 1 ,. . . ,x n :T n ⊢ J 

Unter der Annahme, daß x i Variablen vom Typ T i sind, gilt das Urteil J 

• Semantisches Gegenstück zur Sequenz 

• Funktionalität: J[t i /x i ] gilt für alle kanonischen Elemente 

t i ∈ T i 

• Extensionalität: falls t i =t ′ i ∈ T i , dann gilt J[t i /x i ] genau 

dann, wenn J[t ′ i /x i] gilt (t i und t ′ i 

auch nichtkanonisch) 

• Formale Definition aufwendig 



Lektion 8 

Intuitionistische Typentheorie: Inferenzsystem 

1. Universen: 

– syntaktische Repräsentation der Typ-Eigenschaft 

2. Gleichheit als Proposition 

3. Entwicklung von Beweisen statt Überprüfung 

4. Sequenzen, Regeln und formale Beweise 

5. Das Regelsystem im Detail 

6. Grundprinzipien des systematischen Aufbaus

Syntaktische Repräsentation von Urteilen 

• Sequenzen x 1 :T 1 ,...,x n :T n ⊢ C als Grundstruktur 

• Universen: Repräsentation der Typ-Eigenschaft 

– ‘T Typ’ → ‘T ∈ U’, ‘S=T ’ → ‘S=T ∈ U 

– Universen müssen selbst (Typ-)ausdrücke sein 

– Jede Theorie mit x:S→T und U ∈ U ist inkonsistent. 

⇒ kumulative Hierarchie von Universen U=U 1 

∈ 

⊂ U 2 

∈ 

⊂ U 3 

∈ 

⊂ . . . 

• Gleichheit als Typ 

– ermöglicht Schließen über Gleichheiten in Hypothesen 

– Propositionen als Datentypen – Elemente entsprechen Beweisen 

(syntaktische Darstellung – nicht konzeptuelle Gleichsetzung) 

• Implizite Darstellung von Elementen in Urteilen: T ⌊p⌋ 

– p Extrakt-Term von T 

– ermöglicht Konstruktion von Beweisen und Programmen 

– Überprüfung von Urteilen durch Verwendung des Gleichheitstyps 

Automatisierte Logik und Programmierung 95 Intuitionistische Typentheorie – Inferenzsystem

Universen und Gleichheit – Syntax 

kanonisch 


(Typen) 

U{j:l}() 

(Elemente) 

(alle kanonischen Typen) 

U j 

equal{}(s;t;T ) Axiom{}() 

s = t ∈ T 

Axiom 


Universen und Gleichheit – Semantik 

Typsemantik 

s 1 = t 1 ∈ T 1 = s 2 = t 2 ∈ T 2 ≡ T 1 =T 2 und s 1 =s 2 ∈ T 1 und t 1 =t 2 ∈ T 1 

U j1 

= U j2 

≡ j 1 =j 2 (als natürliche Zahl) 


Axiom = Axiom ∈ s = t ∈ T ≡ s=t ∈ T 

x 1 :S 1 →T 1 = x 2 :S 2 →T 2 ∈ U j ≡ S 1 =S 2 ∈ U j und T 1 [s 1 /x 1 ]=T 2 [s 2 /x 2 ] ∈ U j für alle 

Terme s 1 , s 2 mit s 1 =s 2 ∈ S 1 

T = S 2 →T 2 ∈ U j ≡ T = x 2 :S 2 →T 2 ∈ U j für ein beliebiges x 2 ∈ V 

S 1 →T 1 = T ∈ U j ≡ x 1 :S 1 →T 1 = T ∈ U j für ein beliebiges x 1 ∈ V 

x 1 :S 1 ×T 1 = x 2 :S 2 ×T 2 ∈ U j ≡ S 1 =S 2 ∈ U j und T 1 [s 1 /x 1 ]=T 2 [s 2 /x 2 ] ∈ U j für alle 

Terme s 1 , s 2 mit s 1 =s 2 ∈ S 1 

T = S 2 ×T 2 ∈ U j ≡ T = x 2 :S 2 ×T 2 ∈ U j für ein beliebiges x 2 ∈ V 

S 1 ×T 1 = T ∈ U j ≡ x 1 :S 1 ×T 1 = T ∈ U j für ein beliebiges x 1 ∈ V 

S 1 +T 1 = S 2 +T 2 ∈ U j ≡ S 1 =S 2 ∈ U j und T 1 =T 2 ∈ U j 

s 1 = t 1 ∈ T 1 = s 2 = t 2 ∈ T 2 ∈ U j ≡ T 1 =T 2 ∈ U j und s 1 =s 2 ∈ T 1 und t 1 =t 2 ∈ T 1 

U j1 

= U j2 

∈ U j ≡ j 1 =j 2

Formales Schließen in der Typentheorie 

• Explizit – Überprüfung eines Urteils: 

– Typ-Sein “T Typ”: beweise ⊢ T = T ∈ U j 

(Zeige Existenz eines Terms p und eines Levels j mit p ∈ T = T ∈ U j ) 

– Typgleichheit “S=T ”: beweise ⊢ S = T ∈ U j 

– Typzugehörigkeit “t ∈ T ”: beweise ⊢ t = t ∈ T 

– Elementgleichheit “s=t ∈ T ”: beweise ⊢ s = t ∈ T 

• Implizit – Konstruktion von Termen, die Urteil erfüllen: 

– Konstruktion von Datentypen: beweise ⊢ U j 

– Konstruktion von Elementen eines Typs: beweise ⊢ T 

(Zeige Existenz eines Terms t mit t ∈ T ) 


Sequenzen x 1 :T 1 ,. . . ,x n :T n ⊢ C 

• Deklaration x:T — x Variable, T Term 

• Hypothesenliste Γ = x 1 :T 1 ,..., x n :T n — x i :T i Deklarationen. 

• Konklusion C — C Term 

• Sequenz (Beweisziel) 

Γ ⊢ C — Γ Hypothesenliste, C Konklusion 

• x 1 :T 1 ,...,x n :T n ⊢ C geschlossen, falls jede in C oder T i frei 

vorkommende Variable x zuvor durch x:T j deklariert wurde 

• Z = Γ ⊢ C rein, wenn Z geschlossen, jede Variable nur einmal 

deklariert 

• Γ ⊢ C gültig, falls es einen Term t gibt, für den Γ ⊢ t ∈ C ein 

hypothetisches Urteil ist. 

Notation: Γ ⊢ C ⌊t⌋, falls t bekannt 


Regeln 

Dekomposition von Zielen 

+ 

Aufbau von Evidenzen (Validierung) 

• Dekomposition: Beweisziel 

↦→ endliche Liste von Sequenzen (Teilziele) 

• Validierung: Liste von Sequenzen und Termen 

↦→ Term 

• Inferenzregel (dec,val) — dec Dekomposition, val Validierung 

• r = (dec,val) korrekt, falls für jede reine Sequenz Z = Γ ⊢ C 

– Alle Teilziele Z 1 = Γ 1 ⊢ C 1 , . . . , Z n = Γ n ⊢ C n sind rein 

– Aus der Gültigkeit aller Z i folgt die Gültigkeit von Z 

– Gilt Γ i ⊢ C ⌊t i ⌋ für alle Z i , so folgt Γ ⊢ C ⌊t⌋, 

wobei t = val([(Z 1 ,t 1 ),. . . ,(Z n t n )]) 


Beweise und Extrakt-Terme 

• Jede Sequenz Z ist ein unvollständiger Beweis mit Wurzel Z 

(Z, r, [π 1 ,. . . ,π n ]) Beweis mit Wurzel Z, falls 

– Z = Γ ⊢ C Sequenz, 

– r = (dec,val) korrekte Inferenzregel, 

– π 1 ,. . . ,π n Beweise, deren Wurzeln die Teilziele von Z sind 

• π vollständig, wenn π keine unvollständigen Teilbeweise enthält 

• Extrakt-Term EXT(π): 

– EXT(Z, (dec,val), [π 1 ,...,π n ]) 

= val([ (Z 1 ,EXT(π 1 )),. . . , (Z n ,EXT(π n )) ]) (Z i Wurzel von π i ) 

• Initialsequenz: geschlossene Sequenz ⊢ C 

• Theorem: vollständiger Beweis mit Initialsequenz als Wurzel 


Regelarten 

• Formationsregeln: 

– wie ist ein Typ zusammengesetzt? (typEq) Γ ⊢ S = T ∈ U j 

• Kanonische Regeln: 

– wann sind kanonische Elemente gleich? (elementEq) Γ ⊢ s = t ∈ T 

– wie sind Elemente zusammengesetzt? (elementI) Γ ⊢ T ⌊t⌋ 

• Nichtkanonische Regeln: 

– wann gehört ein Ausdruck zu einem Typ? (nichtkanonischEq) Γ ⊢ s = t ∈ T 

– wie kann eine Variable benutzt werden? (typE) Γ, x:S, ∆ ⊢ T ⌊t⌋ 

• Berechnungsregeln: 

– Reduktion von Redizes in Gleichheit (nichtkanonischRed) Γ ⊢ redex = t ∈ T 

+ spezielle Regeln 


Parameter zur Steuerung von Regeln 

• Position i einer zu elimierenden Variablen 

functionE i s 

• Term s als einzusetzender Wert 

functionE i s 

• Level j des Universums, das innerhalb eines Unterziels 

benötigt wird 

lambdaEq j 

• Typ T eines Teilterms des Beweiszieles, welcher in 

einem Unterziel isoliert auftritt. applyEq x:S→T 

• Abhängigkeit eines (instantiierten) Terms C von einer 

Variablen z 

spreadEq z C x:S×T 


¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

Regeln für Funktionenraum 

Γ ⊢ x 1 :S 1 →T 1 = x 2 :S 2 →T 2 ∈ U j 

Ax 

by functionEq 

Γ ⊢ S 1 = S 2 ∈ U j 

Ax 

Γ, x:S 1 ⊢ T 1 [x/x 1 ] = T 2 [x/x 2 ] ∈ U j 

Ax 

Γ ⊢ λx 1 .t 1 = λx 2 .t 2 ∈ x:S→T Ax 

by lambdaEq j 

Γ, x ′ :S ⊢ t 1 [x ′ /x 1 ] = t 2 [x ′ /x 2 ] ∈ T [x ′ /x] 

Γ ⊢ S ∈ U j 

Ax 

Γ ⊢ f 1 t 1 = f 2 t 2 ∈ T [t 1 /x] 

by applyEq x:S→T 

Γ ⊢ f 1 = f 2 ∈ x:S→T 

Γ ⊢ t 1 = t 2 ∈ S Ax 

Ax 

Ax 

Ax 

Γ ⊢ x:S→T ⌊λx ′ .t⌋ 

by lambdaI j 

Γ, x ′ :S ⊢ T [x ′ /x] ⌊t⌋ 

Γ ⊢ S ∈ U j 

Ax 

Γ, f: x:S→T , ∆ ⊢ C ⌊t[f s, Axiom/y, z]⌋ 

by functionE i s 

Γ, f: x:S→T , ∆ ⊢ s ∈ S Ax 

Γ, f: x:S→T , y:T [s/x], 

z: y = f s ∈ T [s/x], ∆ ⊢ C ⌊t⌋ 

Γ ⊢ (λx.t) s = t 2 

by applyRed 

Γ ⊢ t[s/x] = t 2 

∈ T 

∈ T 

Ax 

Ax 

Γ ⊢ f 1 = f 2 ∈ x:S→T ⌊t⌋ 

by functionExt j x 1 :S 1 →T 1 x 2 :S 2 →T 2 

Γ, x ′ :S ⊢ f 1 x ′ = f 2 x ′ ∈ T [x ′ /x] ⌊t⌋ 

Γ ⊢ S ∈ U j 

Ax 

Γ ⊢ f 1 ∈ x 1 :S 1 →T 1 Ax 

Γ ⊢ f 2 ∈ x 2 :S 2 →T 2 Ax 


¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

Regeln für Produktraum 

Γ ⊢ x 1 :S 1 ×T 1 = x 2 :S 2 ×T 2 ∈ U j 

Ax 

by productEq 

Γ ⊢ S 1 = S 2 ∈ U j 

Ax 

Γ, x ′ :S 1 ⊢ T 1 [x ′ /x 1 ] = T 2 [x ′ /x 2 ] ∈ U j 

Ax 

Γ ⊢ 〈s 1 ,t 1 〉 = 〈s 2 ,t 2 〉 ∈ x:S×T 

by pairEq j 

Γ ⊢ s 1 = s 2 ∈ S Ax 

Γ ⊢ t 1 = t 2 ∈ T [s 1 /x] Ax 

Γ, x ′ :S ⊢ T [x ′ /x] ∈ U j 

Ax 

Ax 

Γ ⊢ x:S×T ⌊〈s,t〉⌋ 

by pairI j s 

Γ ⊢ s ∈ S Ax 

Γ ⊢ T [s/x] ⌊t⌋ 

Γ, x ′ :S ⊢ T [x ′ /x] ∈ U j 

Ax 

Γ ⊢ let 〈x 1 ,y 1 〉 = e 1 in t 1 

= let 〈x 2 ,y 2 〉 = e 2 in t 2 ∈ C[e 1 /z] Ax 

by spreadEq z C x:S×T 

Γ ⊢ e 1 = e 2 ∈ x:S×T Ax 

Γ, s:S, t:T [s/x], y: e 1 =〈s,t〉 ∈ x:S×T 

⊢ t 1 [s, t/x 1 , y 1 ] = t 2 [s, t/x 2 , y 2 ] ∈ C[〈s,t〉/z] 

Ax 

Γ, z: x:S×T , ∆ ⊢ C ⌊let 〈s,t〉 = z in u⌋ 

by productE i 

Γ, z: x:S×T , s:S, t:T [s/x] ∆[〈s,t〉/z] 

⊢ C[〈s,t〉/z] ⌊u⌋ 

Γ ⊢ let 〈x,y〉 = 〈s,t〉 in u = t 2 

by spreadRed 

Γ ⊢ u[s, t/x, y] = t 2 ∈ T 

Ax 

∈ T 

Ax 


¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

Regeln für disjunkte Vereinigung 

Γ ⊢ S 1 +T 1 = S 2 +T 2 ∈ U j 

Ax 

by unionEq 

Γ ⊢ S 1 = S 2 ∈ U j 

Ax 

Γ ⊢ T 1 = T 2 ∈ U j 

Ax 

Γ ⊢ inl(s 1 ) = inl(s 2 ) ∈ S+T 

by inlEq j 

Γ ⊢ s 1 = s 2 ∈ S Ax 

Γ ⊢ T ∈ U j 

Ax 

Γ ⊢ inr(t 1 ) = inr(t 2 ) ∈ S+T 

by inrEq j 

Γ ⊢ t 1 = t 2 ∈ T Ax 

Γ ⊢ S ∈ U j 

Ax 

Ax 

Ax 

Γ ⊢ S+T ⌊inl(s)⌋ 

by inlI j 

Γ ⊢ S ⌊s⌋ 

Γ ⊢ T ∈ U j 

Ax 

Γ ⊢ S+T ⌊inr(t)⌋ 

by inrI j 

Γ ⊢ T ⌊t⌋ 

Γ ⊢ S ∈ U j 

Ax 


¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

Γ ⊢ case e 1 of inl(x 1 ) ↦→ u 1 | inr(y 1 ) ↦→ v 1 

= case e 2 of inl(x 2 ) ↦→ u 2 | inr(y 2 ) ↦→ v 2 

∈ C[e 1 /z] Ax 

by decideEq z C S+T 

Γ ⊢ e 1 = e 2 ∈ S+T Ax 

Γ, s:S, y: e 1 =inl(s) ∈ S+T 

⊢ u 1 [s/x 1 ] = u 2 [s/x 2 ] ∈ C[inl(s)/z] Ax 

Γ, t:T , y: e 1 =inr(t) ∈ S+T 

⊢ v 1 [t/y 1 ] = v 2 [t/y 2 ] ∈ C[inr(t)/z] Ax 

Γ, z:S+T , ∆ ⊢ C 

⌊case z of inl(x) ↦→ u | inr(y) ↦→ v ⌋ 

by unionE i 

Γ, z:S+T , x:S, ∆[inl(x)/z] 

⊢ C[inl(x)/z] ⌊u⌋ 

Γ, z:S+T , y:T , ∆[inr(y)/z] 

⊢ C[inr(y)/z] ⌊v⌋ 

Γ ⊢ case inl(s) of inl(x) ↦→ u | inr(y) ↦→ v 

= t 2 ∈ T Ax 

by decideRedL 

Γ ⊢ u[s/x] = t 2 ∈ T Ax 

Γ ⊢ case inr(t) of inl(x) ↦→ u | inr(y) ↦→ v 

= t 2 ∈ T Ax 

by decideRedR 

Γ ⊢ v[t/y] = t 2 ∈ T Ax 


¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

Regeln für Universen und Gleichheit 

Γ ⊢ U j 

∈ U k 

Ax 

by univEq ∗ 

∗ : nur , wenn j < k 

Γ ⊢ s 1 = t 1 ∈ T 1 = s 2 = t 2 ∈ T 2 ∈ U j 

Ax 

by equalityEq 

Γ ⊢ T 1 = T 2 ∈ U j 

Ax 

Γ ⊢ s 1 = s 2 ∈ T 1 Ax 

Γ ⊢ t 1 = t 2 ∈ T 1 Ax 

Γ ⊢ T ∈ U k 

Ax 

by cumulativity j ∗ 

Γ ⊢ T ∈ U j 

Ax 

Γ ⊢ Axiom ∈ s = t ∈ T 

by axiomEq 

Γ ⊢ s = t ∈ T Ax 

Ax 

Γ, z: s = t ∈ T , ∆ ⊢ C ⌊u⌋ 

by equalityElim i 

Γ, z: s = t ∈ T , ∆[Axiom/z] 

⊢ C[Axiom/z] ⌊u⌋ 

Γ, x:T , ∆ ⊢ x ∈ T 

by hypEq i 

Ax 

Γ ⊢ s = t ∈ T 

by symmetry 

Γ ⊢ t = s ∈ T 

Ax 

Ax 

Γ ⊢ s = t ∈ T Ax 

by transitivity t ′ 

Γ ⊢ s = t ′ ∈ T Ax 

Γ ⊢ t ′ = t ∈ T Ax 

Γ ⊢ C[s/x] ⌊u⌋ 

by subst j s = t ∈ T x C 

Γ ⊢ s = t ∈ T Ax 

Γ ⊢ C[t/x] ⌊u⌋ 

Γ, x:T ⊢ C ∈ U j 

Ax 


¡ 

Strukturelle Regeln 

Γ, x:T , ∆ ⊢ T ⌊x⌋ 

by hypothesis i 

Γ,∆ ⊢ C ⌊(λx.t) s⌋ 

by cut i T 

Γ,∆ ⊢ T ⌊s⌋ 

Γ,x:T ,∆ ⊢ C ⌊t⌋ 

Γ ⊢ T ⌊t⌋ 

by intro t 

Γ ⊢ t ∈ T Ax 

Γ, x:T , ∆ ⊢ C ⌊t⌋ 

by thin i 

Γ,∆ ⊢ C ⌊t⌋ 


Hinzunahme neuer Typkonstrukte 

• Syntax und Darstellungsform in Operatortabelle eintragen 

• Kanonische und nichtkanonische Terme trennen 

Redex-Kontrakta Tabelle erweitern 

• Semantik fixieren durch Einträge in Typbzw. 

Elementsemantiktabelle 

Auf Widersprüchlichkeiten achten !! 

• Inferenzregeln aufstellen 

Semantik wiederspiegeln 

Alternativ: konservative Erweiterung durch Definition 



Lektion 9 

Logik in der Typentheorie 

1. Die Curry-Howard Isomorphie 

2. Der leere Datentyp void 

3. Konstruktive Logik 

4. Klassische Logik

Curry-Howard Isomorphie 

Typ 

Formel 

Deklaration x:S 

Annahme der Formel S 

‘Urteil’ T [x i ]⌊t⌋ (Variablen x i ∈ S i ) Beweis t von T (Annahmen S i ) 

Produkt A×B 

Konjunktion A ∧ B 

pairI indep 

∧ -Einführung 

productE 

∧ -Elimination 

Disjunkte Vereinigung A+B Disjunktion A ∨ B 

inlI, inrI 

∨ -Einführung 

unionE 

∨ -Elimination 

Funktioneraum A→B 

Implikation A ⇒ B 

lambdaI 

⇒ -Einführung 

functionE indep 

⇒ -Elimination 

Leerer Datentyp void 

Falschheit Λ 

Funktioneraum A→void Negation ¬A 

Funktionenraum x:T →A Universelle Quantifizierung ∀x:T .A 

lambdaI 

∀-Einführung 

functionE 

∀-Elimination 

Produkt x:T ×A Existentielle Quantifizierung ∃x:T .A 

pairI 

∃-Einführung 

productE 

∃-Elimination 

Automatisierte Logik und Programmierung 112 Logik in der Typentheorie

Der leere Datentyp void 

• Gegenstück zur leeren Menge und zur logischen Falscheit 

• Simulierbar durch X:U 1 → X = X→X ∈ U 1 

– aber ohne nichtkanonische Elemente 

• Ergänzungen der Operatorentabelle 

kanonisch 


(Typen) 

(Elemente) 

void{}() 

void 

any{}(e) 

any(e) 

• Probleme 

(gelten schon für Gleichheitstyp) 

– unsinnige Hypothesen nach x:void möglich 

– Starke Normalisierbarkeit nur für extrahierte Terme 


¡ 

¡ 

¡ 

Semantik und Inferenzregeln für void 

Typsemantik 

void = void 


s = t ∈ void gilt niemals ! 

void = void ∈ U j falls j≤1 (als natürliche Zahl) 

Γ ⊢ void = void ∈ 

by voidEq 

U j 

Ax 

Γ ⊢ any(s) = any(t) ∈ 

by anyEq 

Γ ⊢ s = t ∈ void Ax 

T 

Ax 

Γ, z: void, ∆ ⊢ C ⌊any(z)⌋ 

by voidE i 


Konservative Erweiterung: (Konstruktive) Logik 

A ∧ B ≡ and{}(A;B) ≡ A×B 

A ∨ B ≡ or{}(A;B) ≡ A+B 

A ⇒ B ≡ implies{}(A;B) ≡ A→B 

¬A ≡ not{}(A) ≡ A→void 

Λ ≡ false{}() ≡ void 

∀x:T .A ≡ all{}(T ; x.A) ≡ x:T →A 

∃x:T .A ≡ exists{}(T ; x.A) ≡ x:T ×A 

IP i ≡ prop{i:l}() ≡ U i 


Konsequenzen der Curry-Howard Isomorphie 

• Das Prinzip “Propositionen als Datentypen” definiert 

die intuitionistische Prädikatenlogik (J ). 

• Schnitteliminationssatz: Ist Γ ⊢ C in LJ beweisbar, 

dann gibt es einen Beweis ohne Schnittregel. 

– Beweis durch Normalisierung der Extraktterme 

• Satz: LJ ist konsistent. 

– andernfalls gäbe es einen schnittfreien Beweis für ‘⊢ Λ’ 

• Funktionenkalküle höherer Ordnung und 

Prädikatenlogik beliebiger Stufe sind simulierbar 


Konservative Erweiterung: Klassische Logik 

Λ ≡ false{}() ≡ void 

¬A ≡ not{}(A) ≡ A→void 

A ∧ B ≡ and{}(A;B) ≡ A×B 

∀x:T .A ≡ all{}(T ; x.A) ≡ x:T →A 

A ∨ c B ≡ orc{}(A;B) ≡ ¬(¬A ∧ ¬B) 

A ⇒ c B ≡ impc{}(A;B) ≡ ¬A ∨ c B 

∃ c x:T .A ≡ exc{}(T ; x.A) ≡ ¬(∀x:T .¬A) 



Lektion 10 

Programmierung in der Typentheorie 

1. Beweise als Programme 

2. Zahlen und Induktion 

– Die primitiv rekursive Arithmetik 

– Der NuPRL-Typ der ganzen Zahlen 

– Listen 

3. Teilmengen 

4. Quotienten (Restklassen)

Interpretationen der typentheoretischen Urteile 

T ∈ U j t ∈ T T ⌊t⌋ 

T ist eine Menge t ist Element von T T ist nicht leer (inhabited) 

T ist Proposition t ist Beweis für T T ist wahr (beweisbar) 

T ist Intention t ist Methode, T zu erfüllen T ist erfüllbar (realisierbar) 

T ist Problem t ist Methode, T zu lösen T ist lösbar 

Automatisierte Logik und Programmierung 119 Programmierung in der Typentheorie

Beweise als Programme 

• t ∈ T : ‘t ist Programm, das die Spezifikation T löst’ 

‘⊢ T ⌊t⌋’: Aufgabe, ein Programm zu konstruieren 

• Konstruktives Auswahlaxiom: 

Für alle Universen U j kann man beweisen 

⊢ ∀T:U j .∀S:U j .∀spec: T×S→IP j . 

(∀x:T. ∃y:S. spec 〈x,y〉) 

⇒ ∃f:T→S.∀x:T. spec 〈x,f x〉 

⇒ Programmentwicklung ist dasselbe wie Beweisführung 


Primitiv rekursive Arithmetik 

• Natürliche Zahlen – minimale Ausgestaltung: 

– kanonisch: N 0, s:N→N 

– nichtkanonisch: ind(n; base; m,f m .t) 

• Reduktion 

ind(0; base; m,f m .t) 

ind(s(n); base; m,f m .t) 

β 

−→ base 

β 

−→ t[n, ind(n; base; m,f m .t) / m, f m ] 

⇒ Induktive Beweisführung ≡ Rekursives Programm 

• Regelsystem zu einfach für praktisches Arbeiten. 


¡ 

¡ 

¡ 

¡ 

Natürliche Zahlen – Regeln 

Γ ⊢ N ∈ 

by natEq 

U j 

Ax 

Γ ⊢ 0 ∈ N 

by zeroEq 

Ax 

Γ ⊢ N ⌊0⌋ 

by zeroI 

Γ ⊢ s(t 1 ) = s(t 2 ) ∈ 

by sucEq 

Γ, ⊢ t 1 = t 2 ∈ N 

N 

Ax 

Ax 

Γ ⊢ N ⌊s(t)⌋ 

by sucI 

Γ ⊢ N ⌊t⌋ 


¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

Natürliche Zahlen – Regeln II 

Γ ⊢ ind(n 1 ; b 1 

; m 1 ,f m1 .t 1 ) 

= ind(n 2 ; b 2 

; m 2 ,f m2 .t 2 ) 

∈ T [n 1 /z] Ax 

by indEq z T 

Γ ⊢ n 1 = n 2 ∈ N Ax 

Γ ⊢ b 1 

= b 2 

∈ T [0/z] Ax 

Γ, m:N, f m :T [m/z] 

⊢ t 1 [m, f m / m 1 , f m1 ] 

= t 2 [m, f m / m 2 , f m2 ] 

∈ T [s(m)/z] Ax 

Γ, n:N, ∆ ⊢ C 

⌊ind(n; b; m,f m .t)⌋ 

by natE i 

Γ, n:N, ∆ ⊢ C[0/n] ⌊b⌋ 

Γ, n:N, ∆, m:N, f m :C[m/n] 

⊢ C[s(m)/n] ⌊t⌋ 

Γ ⊢ ind(0; b; m,f m .t) = t 2 ∈ T 

by indRedBase 

Γ ⊢ b = t 2 ∈ T Ax 

Ax 

Γ ⊢ ind(s(n); b; m,f m .t) = t 2 ∈ T 

by indRedUp 

Γ ⊢ t[n, ind(n; b; m,f m .t) / m, f m ] 

= t 2 ∈ T Ax 

Ax 


Der NuPRL-Typ Z 

‘konservative’ Erweiterung der 

primitiv rekursiven Arithmetik 

• Ganze Zahlen als Grundlage der Arithmetik 

– 0, 1, -1, 2, -2, ... 

• Elementare arithmetische Operationen vordefiniert 

– +, -, *, ÷, rem ,

Ganze Zahlen – Syntax 

(Typen) 

kanonisch 

(Elemente) 


int{}() natnum{n:n}() ind{}( u ; x,f x .s; base; y,f y .t) 

minus{}(natnum{n:n}()) minus{}( u ), add{}( u ; v ), 

sub{}( u ; v ), mul{}( u ; v ), 

div{}( u ; v ), rem{}( u ; v ) 

int eq( u ; v ; s; t), less( u ; v ; s; t) 

Z n ind( u ; x,f x .s; base; y,f y .t) 

−n - u , u + v , 

u - v , u * v , 

u ÷ v , u rem v 

if u = v then s else t, if u < v then s else t 

lt{}(u;v) Axiom{}() 

u

Ganze Zahlen – Reduktion 

Redex 

ind(0; x,f x .s; base; y,f y .t) 

ind(n; x,f x .s; base; y,f y .t) 

ind(-n; x,f x .s; base; y,f y .t) 

-i 

i+j 

i-j 

i*j 

i÷j 

i rem j 

if i=j then s else t 

if i 0) 

β 

−→ s[-n,ind(-n+1; x,f x .s; base; y,f y .t) /x, f x ], (n > 0) 

β 

−→ 

β 

−→ 

β 

−→ 

β 

−→ 

β 

−→ 

β 

−→ 

β 

−→ 

β 

−→ 

Die Negation von i (als Zahl) 

Die Summe von i und j 

Die Differenz von i und j 

Das Produkt von i und j 

0, falls j=0; ansonsten die Integer-Division von i und j 

0, falls j=0; ansonsten der Rest der Division von i und j 

s, falls i = j; ansonsten t 

s, falls i < j; ansonsten t 


Listen 

• Analog zur primitiv rekursiven Arithmetik 

– kanonisch: T list , [], t.l, 

– nichtkanonisch: list ind(L; base; x,l,f l .t) 

• Reduktion 

list ind([]; b; x,l,f xl .t) 

list ind(s.u; b; x,l,f xl .t) 

β 

−→ b 

β 

−→ t[s, u,list ind(u; b; x,l,f xl .t) /x, l, f xl ] 

⇒ Induktive Beweisführung ≡ Rekursives Programm 

– fortsetzbar auf komplexere Datenstrukturen 


Maximale Segmentsumme – formale Definitionen 

max(i,j) 

≡ if i

⊢ ∀a:Z list .∀a 1 

:Z.∃L:Z.∃M:Z. L = maxbeg(a 1 

.a) ∧ M = maxseq(a 1 

.a) 

by all i THEN listE 1 THEN all i (Induktion auf a) 

|\ 

| a:Z list , a 1 

:Z ⊢ ∃L:Z.∃M:Z. L = maxbeg(a 1 

.[]) ∧ M = maxseq(a 1 

.[]) 

| by ex i a 1 

THEN ex i a 1 

THEN and i 

| |\ 

| | a:Z list , a 1 

:Z ⊢ a 1 

= maxbeg(a 1 

.[]) 

| | by ... Anwendung arithmetischer Lemmata ... 

| \ 

| a:Z list , a 1 

:Z ⊢ a 1 

= maxseq(a 1 

.[]) 

| by ... Anwendung arithmetischer Lemmata ... 

\ 

a:Z list , x:Z, l:Z list , v: ∀a 1 

:Z.∃L:Z.∃M:Z. L = maxbeg(a 1 

.l) ∧ M = maxseq(a 1 

.l), a 1 

:Z 

⊢ ∃L:Z.∃M:Z. L = maxbeg(a 1 

.(x.l)) ∧ M = maxseq(a 1 

.(x.l)) 

by all e 4 x THEN thin 4 

\ 

a:Z list , x:Z, l:Z list , a 1 

:Z, v 1 

: ∃L:Z.∃M:Z. L = maxbeg(x.l) ∧ M = maxseq(x.l) 



.(x.l)) 

by ex e 5 THEN ex e 6 THEN and e 7 

\ 


:Z, L:Z, M:Z, v 2 

: L = maxbeg(x.l), v 3 

: M = maxseq(x.l) 



.(x.l)) 

by ex i max(L+a 1 

,a 1 

) THEN ex i max(M, max(L+a 1 

,a 1 

)) THEN and i 

|\ 

| a:Z list , x:Z, l:Z list , a 1 

:Z, L:Z, M:Z, v 2 



| ⊢ max(L+a 1 

,a 1 

) = maxbeg(a 1 

.(x.l)) 

| by ... Anwendung arithmetischer Lemmata ... 

\ 


:Z, L:Z, M:Z, v 2 



⊢ max(M, max(L+a 1 

,a 1 

)) = maxseq(a 1 

.(x.l)) 

by ... Anwendung arithmetischer Lemmata ... 


Teilmengenkonstrukt {x:S | P [x] } 

• Steigerung der “praktischen” Ausdruckskraft 

– Vermeidung überflüssiger Informationen in Extrakt-Termen 

– Natürliche Repräsentation von Teilmengen eines Typs 

• Simulation durch Produkttyp x:S×P [x] nicht sinnvoll 

– Beweis für P [x] bleibt Bestandteil eines Elements 

• Handhabung impliziten Wissens nötig 

– Beweisterm für P [x] nicht konstruktiv verwendbar 

– Wissen P [x] verwendbar in nichtkonstruktiven Teilbeweisen 

• Versteckte Hypothesen in Beweisen 

– Erzeugung durch setE (auch quotient eqE) 

– Freigabe in Teilzielen von Regeln, die Axiom generieren 

• Unabhängiges Teilmengenkonstrukt {S | P } 


Teilmengen – Semantik 

Typsemantik 

{x 1 :S 1 | T 1 } = {x 2 :S 2 | T 2 } falls S 1 =S 2 und es gibt eine Variable x, die weder in T 1 

noch in T 2 vorkommt, und zwei Terme p 1 und p 2 mit 

der Eigenschaft 

p 1 ∈ ∀x:S 1 . T 1 [x/x 1 ] ⇒ T 2 [x/x 2 ] und 

p 2 ∈ ∀x:S 1 . T 2 [x/x 2 ] ⇒ T 1 [x/x 1 ]. 

T = {S 2 | T 2 } falls T = {x 2 :S 2 | T 2 } für ein beliebiges x 2 ∈ V. 

{S 1 | T 1 } = T falls {x 1 :S 1 | T 1 } = T für ein beliebiges x 1 ∈ V. 

s = t ∈ {x:S | T } 


falls {x:S | T } Typ und s = t ∈ S und es gibt einen 

Term p mit der Eigenschaft p ∈ T [s/x] 


¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

Teilmengen – Inferenzregeln 

Γ ⊢ {x 1 :S 1 | T 1 } = {x 2 :S 2 | T 2 } ∈ U j 

Ax 

by setEq 

Γ ⊢ S 1 = S 2 ∈ U j 

Ax 

Γ, x:S 1 ⊢ T 1 [x/x 1 ] = T 2 [x/x 2 ] ∈ U j 

Ax 

Γ ⊢ s = t ∈ {x:S | T } Ax 

by elementEq j 

Γ ⊢ s = t ∈ S Ax 

Γ ⊢ T [s/x] Ax 

Γ, x ′ :S ⊢ T [x ′ /x] ∈ U j 

Ax 

Γ ⊢ {x:S | T } ⌊s⌋ 

by elementI j s 

Γ ⊢ s ∈ S Ax 

Γ ⊢ T [s/x] Ax 

Γ, x ′ :S ⊢ T [x ′ /x] ∈ U j 

Ax 

Γ, z: {x:S | T }, ∆ ⊢ C ⌊(λy.t) z⌋ 

by setE i 

Γ, z: {x:S | T }, y:S, [⌊v⌋]:T [y/x], 

∆[y/z] ⊢ C[y/z] ⌊t⌋ 


Quotiententypen x,y : T //E 

• Benutzerdefinierte Modifikation der Gleichheit auf T 

– E[s, t / x, y] bestimmt Gleichheit von s und t 

– Restklassen modulo E: E muß Typ einer Äquivalenzrelation sein 

• Gleichheit E[s, t / x, y] ist implizites Wissen von s und t 

• Type-Squashing für benutzerdefinierte Prädikate 

– |P | ≡ {0 ∈ Z | P } 

– reduziert Typ P auf “Wahrheitstyp” 

– erforderlich um Überstrukturierung auf x,y : T //E zu umgehen 


Quotiententypen – Semantik 

Typsemantik 

x 1 ,y 1 : T 1 //E 1 

= x 2 ,y 2 : T 2 //E 2 

falls T 1 = T 2 und es gibt (verschiedene) Variablen x, y, z, die weder in 

E 1 noch in E 2 vorkommen, und Terme p 1 , p 2 , r,s und t mit der 

Eigenschaft 

p 1 ∈ ∀x:T 1 .∀y:T 1 . E 1 [x, y/x 1 , y 1 ] ⇒ E 2 [x, y/x 2 , y 2 ] und 

p 2 ∈ ∀x:T 1 .∀y:T 1 . E 2 [x, y/x 2 , y 2 ] ⇒ E 1 [x, y/x 1 , y 1 ] und 

r ∈ ∀x:T 1 .E 1 [x, x/x 1 , y 1 ] und 

s ∈ ∀x:T 1 .∀y:T 1 . E 1 [x, y/x 1 , y 1 ] ⇒ E 1 [y, x/x 1 , y 1 ] und 

t ∈ ∀x:T 1 .∀y:T 1 .∀z:T 1 . 

E 1 [x, y/x 1 , y 1 ] ⇒ E 1 [y, z/x 1 , y 1 ] ⇒ E 1 [x, z/x 1 , y 1 ] 


s = t ∈ x,y : T //E falls x,y : T //E Typ und s ∈ T und t ∈ T und es gibt einen Term 

p mit der Eigenschaft p ∈ E[s, t/x, y] 


¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

Quotiententyp – Inferenzregeln 

Γ ⊢ x 1 ,y 1 : T 1 //E 1 

= x 2 ,y 2 : T 2 //E 2 

∈ U j 

Ax 

by quotientEq 

Γ ⊢ x 1 ,y 1 : T 1 //E 1 

∈ U j 

Ax 

Γ ⊢ x 2 ,y 2 : T 2 //E 2 

∈ U j 

Ax 

Γ ⊢ T 1 = T 2 ∈ U j 

Ax 

Γ, v: T 1 = T 2 ∈ U j , x:T 1 , y:T 1 

⊢ E 1 [x, y/x 1 , y 1 ] ⇒ E 2 [x, y/x 2 , y 2 ] Ax 

Γ, v: T 1 = T 2 ∈ U j , x:T 1 , y:T 1 

⊢ E 2 [x, y/x 2 , y 2 ] ⇒ E 1 [x, y/x 1 , y 1 ] Ax 

Γ ⊢ s = t ∈ x,y : T //E Ax 

by memberEq j 

Γ ⊢ x,y : T //E ∈ U j 

Ax 

Γ ⊢ s ∈ T Ax 

Γ ⊢ t ∈ T Ax 

Γ ⊢ E[s, t/x, y] Ax 

Γ, v: s = t ∈ x,y : T //E , ∆ ⊢ C ⌊u⌋ 

by quotient eqE i j 

Γ, v: s = t ∈ x,y : T //E , [⌊v ′ ⌋]:E[s, t/x, y], ∆ 

⊢ C ⌊u⌋ 

Γ, v: s = t ∈ x,y : T //E , ∆, x ′ :T , y ′ :T 

⊢ E[x ′ , y ′ /x, y] ∈ U j 

Ax 

Γ ⊢ x,y : T //E ⌊t⌋ 

by memberI j 

Γ ⊢ x,y : T //E ∈ U j 

Ax 

Γ ⊢ T ⌊t⌋ 

Γ, z: x,y : T //E , ∆ ⊢ s = t ∈ S Ax 

by quotientE i j 

Γ, z: x,y : T //E , ∆, x ′ :T , y ′ :T 

⊢ E[x ′ , y ′ /x, y] ∈ U j 

Ax 

Γ, z: x,y : T //E , ∆ ⊢ S ∈ U j 

Ax 

Γ, z: x,y : T //E , ∆, x ′ :T , y ′ :T , 

v: E[x ′ , y ′ /x, y] 

⊢ s[x ′ /z] = t[y ′ /z] ∈ S[x ′ /z] Ax 



Lektion 11 

Rekursion in der Typentheorie 

1. Induktive Typen 

2. (Partiell) Rekursive Funktionen 

3. Unendliche Objekte 

4. Ergänzungen zugunsten der praktischen Anwendbarkeit

Rekursive Definition 

+ Effizientere und elegantere Algorithmen und Datentypen 

– Nichtterminierender Reduktionsketten möglich 

– Unentscheidbarkeiten 

⇒ Einbettung in terminierendes Beweiskonzept schwierig 

• Induktive Typkonstruktoren 

– Wohlfundierte, rekursiv definierte Datentypen und ihre Elemente 

• Partiell Rekursive Funktionen 

– Totale Funktionen auf eingeschränktem Definitionsbereich 

– (fast exakter) Definitionsbereich aus Algorithmus ableitbar 

• Lässige Typkonstruktoren 

– Schließen über unendliche Objekte 

Automatisierte Logik und Programmierung 137 Rekursion

Induktive Typen X = T [X] 

Repräsentation fast aller rekursiv definierten Konzepte 

• Semantik: Kleinster Fixpunkt der rechten Seite 

Formale Notation: rectype X = T X 

• T X muß “Induktionsanfang” ohne X enthalten 

T X darf X nur positiv in → Konstrukten enthalten 

• Kanonische Elemente gemäß Konstruktoren in T X 

Nichtkanonisches Element: let ∗ f(x) = t in f(e) 

– immer terminierende rekursive Funktionsauswertung auf e 

• Allgemeinste Form: parametrisierte simultane Rekursion 

– rectype X 1 (x 1 ) = T X1 and ... and X n (x n ) = T Xn select X i (a i ) 


Induktive Typen – Syntax und Semantik 

kanonisch 


(Typen) 

(Elemente) 

rec{}(X.T X ) 

rec ind{}( e ; f,x.t) 

rectype X = T X let ∗ f(x) = t in f( e ) 

Redex 

let ∗ f(x) = t in f(e) 

Kontraktum 

β 

−→ t[λy.let ∗ f(x) = t in f(y), e / f, x] 

rectype X 1 = T X1 = rectype X 2 = T X2 

s = t ∈ rectype X = T X 

Typsemantik 

falls T X1 [X/X 1 ] = T X2 [X/X 2 ] für alle Typen X 


falls rectype X = T X Typ und 

s = t ∈ T X [rectype X = T X / X] 

rectype X 1 = T X1 = rectype X 2 = T X2 ∈ U j falls T X1 [X/X 1 ]=T X2 [X/X 2 ] ∈ U j 

für alle Terme X mit X ∈ U j 


¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

Induktive Typen – Inferenzregeln I 

Γ ⊢ rectype X 1 = T X1 = rectype X 2 = T X2 ∈ U j 

Ax 

by recEq 

Γ, X:U j ⊢ T X1 [X/X 1 ] = T X2 [X/X 2 ] ∈ U j 

Ax 

Γ ⊢ s = t ∈ rectype X = T X Ax 

by rec memEq j 

Γ ⊢ s = t ∈ T X [rectype X = T X / X] 

Γ ⊢ rectype X = T X ∈ U j 

Ax 

Ax 

Γ ⊢ rectype X = T X ⌊t⌋ 

by rec memI j 

Γ ⊢ T X [rectype X = T X / X] ⌊t⌋ 


Ax 

Γ, z: rectype X = T X , ∆ ⊢ C ⌊t[z/x]⌋ 

by recE unroll i 

Γ, z: rectype X = T X , ∆, 

x: T X [rectype X = T X / X], 

v: z = x ∈ T X [rectype X = T X / X] 

⊢ C[x/z] ⌊t⌋ 


¡ 

¡ 

¡ 

¡ 

¡ 

Induktive Typen – Inferenzregeln II 

Γ ⊢ let ∗ f 1 (x 1 ) = t 1 in f 1 (e 1 ) 

= let ∗ f 2 (x 2 ) = t 2 in f 2 (e 2 ) ∈ T [e 1 /z] 

by rec indEq z T rectype X = T X j 

Γ ⊢ e 1 = e 2 ∈ rectype X = T X Ax 


Ax 

Γ, P : (rectype X = T X )→IP j , 

f: (y:{x:rectype X = T X | P (x) } → T [y/z]), 

x: T X [{x:rectype X = T X | P (x) } / X] 

⊢ t 1 [f, x / f 1 , x 1 ] = t 2 [f, x / f 2 , x 2 ] ∈ T [x/z] 

Ax 

Ax 

Γ, z: rectype X = T X , ∆ ⊢ C 

⌊let ∗ f(x) = t[λy.Λ / P ] in f(z)⌋ 

by recE i j 

Γ, z: rectype X = T X , ∆ 

⊢ rectype X = T X ∈ U j 

Ax 

Γ, z: rectype X = T X , ∆ 

P : (rectype X = T X )→IP j , 

f: (y:{x:rectype X = T X | P (x) } → C[y/z]), 

x: T X [{x:rectype X = T X | P (x) } / X] 

⊢ C[x/z] ⌊t⌋ 


Rekursive Funktionen f(x) = t[f, x] 

• Semantik: Kleinster Fixpunkt der rechten Seite 

Formale Notation: letrec f(x) = t 

• Analog zu let ∗ f(x) = t in f(e), aber 

– rekursive Struktur der Eingaben nicht vorgegeben 

⇒ kein Extraktterm einer Eliminationsregel 

⇒ flexiblerer Einsatz in Programmierung (“reale” Programme) 

⇒ induktive Struktur des Definitionsbereiches muß berechnet werden 

• S↛T : totale Funktionen auf Teilmenge von S 

– f ∈ S↛T simuliert durch f ∈ {x:S | dom(f)(x) } → T 

– dom(f)(x) reduziert zu rekursivem Datentyp, auf dem f terminiert 

– Exakte Beschreibung des Definitionsbreiches nicht immer möglich 


– letrec f 1 (x 1 ) = t 1 and ... and f n (x n ) = t n select f i 


Partiell rekursive Funktionen – Syntax und Semantik 

(Typen) 

kanonisch 

(Elemente) 


pfun{}(S; T ) fix{}(f,x.t) dom{}( f ), apply p{}( f ;t) 

S↛T letrec f(x) = t dom( f ), f (t) 

Redex 

(letrec f(x) = t) (u) 

dom(letrec f(x) = t) 

β 

Kontraktum 

−→ t[letrec f(x) = t, u / f, x] 

β 

−→ λx.rectype F = E[[t]] 

Typsemantik 

S 1 ↛T 1 = S 2 ↛T 2 falls S 1 = S 2 und T 1 = T 2 


letrec f 1 (x 1 ) = t 1 = letrec f 2 (x 2 ) = t 2 ∈ S↛T falls S↛T Typ und für alle s 1 , s 2 mit s 1 =s 2 ∈ S 

{x:S | dom(letrec f 1 (x 1 ) = t 1 )(x) } 

= {x:S | dom(letrec f 2 (x 2 ) = t 2 )(x) } und 

t 1 [letrec f 1 (x 1 ) = t 1 , s 1 / f 1 , x 1 ] 

= t 2 [letrec f 2 (x 2 ) = t 2 , s 2 / f 2 , x 2 ] ∈ T 

S 1 ↛T 1 = S 2 ↛T 2 ∈ U j falls S 1 = S 2 ∈ U j und T 1 = T 2 ∈ U j 


¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

Partiell rekursive Funktionen – Inferenzregeln I 

Γ ⊢ S 1 ↛T 1 = S 2 ↛T 2 ∈ U j 

Ax 

by pfunEq 

Γ ⊢ S 1 = S 2 ∈ U j 

Ax 

Γ ⊢ T 1 = T 2 ∈ U j 

Ax 

Γ ⊢ (letrec f 1 (x 1 ) = t 1 ) 

= (letrec f 2 (x 2 ) = t 2 ) ∈ S↛T Ax 

by fixEq j 

Γ ⊢ letrec f 1 (x 1 ) = t 1 ∈ S↛T Ax 

Γ ⊢ letrec f 2 (x 2 ) = t 2 ∈ S↛T Ax 

Γ ⊢ {x:S | dom(letrec f 1 (x 1 ) = t 1 )(x) } 

= {x:S | dom(letrec f 2 (x 2 ) = t 2 )(x) } ∈ U j 

Ax 

Γ, y: {x:S | dom(letrec f 1 (x 1 ) = t 1 )(x) } 

⊢ (letrec f 1 (x 1 ) = t 1 ) (y) 

= (letrec f 2 (x 2 ) = t 2 ) (y) ∈ T Ax 

Γ ⊢ letrec f(x) = t ∈ S↛T Ax 

by fixMem j 

Γ ⊢ S↛T ∈ U j 

Ax 

Γ, f ′ :S↛T , x ′ :S ⊢ E [ t[f ′ , x ′ /f, x] ] ∈ U j 

Ax 

Γ, f ′ :S↛T , x ′ :S, E [ t[f ′ , x ′ / f, x] ] 

⊢ t[f ′ , x ′ / f, x] ∈ T Ax 


¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

¡ 

Partiell rekursive Funktionen – Inferenzregeln II 

Γ ⊢ f 1 (t 1 ) = f 2 (t 2 ) ∈ T Ax 

by apply pEq S↛T 

Γ ⊢ f 1 = f 2 ∈ S↛T Ax 

Γ ⊢ t 1 = t 2 ∈ {x:S | dom(f 1 )(x) } 

Ax 

Γ, f: S↛T , ∆ ⊢ C ⌊t[f (s),Axiom / y, v]⌋ 

by pfunE i s 

Γ, f: S↛T , ∆ 

⊢ s ∈ {x:S | dom(f 1 )(x) } Ax 

Γ, f: S↛T , ∆, y:T , v: y = f (s) ∈ T 

⊢ C ⌊t⌋ 

Γ ⊢ dom(f 1 ) = dom(f 2 ) ∈ S→IP j 

Ax 

by domEq S↛T 

Γ ⊢ f 1 = f 2 ∈ S↛T Ax 

Γ ⊢ S↛T ∈ U j 

Ax 

Γ ⊢ (letrec f(x) = t) (u) = t 2 ∈ T Ax 

by apply pRed 

Γ ⊢ t[letrec f(x) = t, u / f, x] = t 2 ∈ T 

Ax 


Lässige Typen X = T [X] 

Repräsentation unendlicher Konstrukte 

• Semantik: Größter Fixpunkt der rechten Seite 

Formale Notation: inftype X = T X 

• T X braucht keinen “Induktionsanfang” 

T X darf X nur positiv in → Konstrukten enthalten 

• Kanonische Elemente gemäß Konstruktoren in T X 

Nichtkanonisches Element: let ∞ f(x) = t in f(e) 


Noch kein fester Bestandteil der Typentheorie 


¡ 

Inferenzregeln zum praktischen Arbeiten 

Γ ⊢ C ⌊t⌋ 

by compute tagC 

Γ ⊢ C↓ tagC ⌊t⌋ 

Γ, z: T , ∆ ⊢ C ⌊t⌋ 

by computeHyp i tagT 

Γ, z: T ↓ tagT , ∆ ⊢ C ⌊t⌋ 

Γ ⊢ C ⌊t⌋ 

by unfold def-name 

Γ ⊢ C ↓ ⌊t⌋ 

Γ, z: T , ∆ ⊢ C ⌊t⌋ 

by unfoldHyp def-name i 

Γ, z: T ↓ , ∆ ⊢ C ⌊t⌋ 

Γ ⊢ C ⌊t⌋ 

by rev compute tagC 

Γ, ⊢ C↑ tagC ⌊t⌋ 

Γ, z: T , ∆ ⊢ C ⌊t⌋ 

by rev computeHyp i tagT 

Γ, z: T ↑ tagT , ∆ ⊢ C ⌊t⌋ 

Γ ⊢ C ↓ ⌊t⌋ 

by fold def-name 

Γ ⊢ C ⌊t⌋ 

Γ, z: T ↓ , ∆ ⊢ C ⌊t⌋ 

by foldHyp def-name i 

Γ, z: T , ∆ ⊢ C ⌊t⌋ 

Γ, z: T , ∆ ⊢ C ⌊t⌋ 

by replaceHyp i S j 

Γ, z: S, ∆ ⊢ C ⌊t⌋ 

Γ, z: T , ∆ ⊢ T = S ∈ U j 

Ax 

Automatisierte Logik und Programmierung 147 Resümee

¡ 

¡ 

¡ 

¡ 

Inferenzregeln zum praktischen Arbeiten II 

Γ, z: T , ∆ ⊢ C ⌊t⌋ 

by replaceHyp i S j 

Γ, z: S, ∆ ⊢ C ⌊t⌋ 

Γ, z: T , ∆ ⊢ T = S ∈ U j 

Ax 

Γ ⊢ C ⌊t⌋ 

by lemma theorem-name 

Γ ⊢ C ⌊t[σ]⌋ 

by instantiate Γ ′ C ′ σ 

Γ ′ ⊢ C ′ ⌊t⌋ 

Γ ⊢ t ∈ T Ax 

by extract theorem-name 

Γ ⊢ C ⌊t[y/x]⌋ 

by rename y x 

Γ ⊢ C[x/y] ⌊t⌋ 

Γ ⊢ s = t ∈ 

by equality 

T 

Ax 

Γ ⊢ C ⌊t⌋ 

by arith j 

Γ ⊢ s 1 ∈ Z 

. 

Ax 


Typentheorie im Rückblick 

• Inferenzsystem für Mathematik und Programmierung 

– Formalisierung “natürlicher” Gesetze der zentralen Konzepte 

– Direkte Darstellung (keine Simulation) der zentralen Konzepte 

⇒ Umfangreiche Theorie 

– mathematische Grundkonstrukte, Logik, 

– Grundkonstrukte der Programmierung, Rekursion 

• Praktische Probleme 

– Beweise erfordern viel Schreibarbeit 

→ interaktive Beweissysteme 

– Beweise sind unübersichtlich (viele Regelanwendungen) 

– Beweise sind schwerzu finden (viele Regeln und Parameter) 

→ Automatisierung der Beweisführung 



Lektion 12 

Interaktive Beweissysteme 

1. ML als formale Beschreibungssprache 

2. Implementierung der Objektsprache 

– Terme 

– Regeln und Beweise 

3. Systemkomponenten 

– Bibliothekskonzepte, Kommandoebene, Text- und Termeditor 

– Beweiseditor, Definitionsmechanismus 

4. Zur Korrektheit der Implementierung

Automatisierung von Beweisführung 

• Proof Checking: Überprüfung formaler Beweise durch Computer 

– leicht zu programmieren 

– mühsam in Anwendung (minimale Automatisierung) 

• Proof Editing: Interaktive Entwicklung formaler Beweise 

– leicht verständlich, einfach zu programmieren 

– Idee/Regel durch Benutzer – Ausführung durch Computer 

• Theorem Proving: vollautomatische Suche nach Beweisen 

– Maschinennahe Beweisformulierung, aufwendige Programmierung 

– schwer verständlich, kaum anwendbar für reichhaltige Theorien 

• Entscheidungsprozeduren 

– vollautomatische Entscheidung für Probleme kleiner Teiltheorien 

– Einbettung in interaktive Beweiseditoren möglich 

• Taktiken: programmierte Steuerung von Regelanwendungen 

– flexibel, leistungsfähig, sicher 

Automatisierte Logik und Programmierung 151 Interaktive Beweiser

Beweisentwicklungssysteme – Komponenten 

Verständliche Beweis-/Programmentwicklung 

• Repräsentation objektsprachlicher Konzepte 

• Interaktiver Beweiseditor mit Extraktionsmechanismus 

• Definitionsmechanismus 

• Programmevaluator 

• Bibliothek 

• Kommandoebene 

• Text- und Termeditor 


ML – Grundeigenschaften 

Systemimplementierung durch Formalisierung der Metasprache 

• Funktionale Programmiersprache höherer Stufe 

– Programmieren = Definition + Anwendung von Funktionen 

– Abstraktion über lokale Variablen in komplexen Ausdrücken 

(Werte für Variablen durch Matching bestimmbar) 

• Erweiterbare polymorphe Typdisziplin 

– Grundkonstrukte: int, bool, tok, string, unit, 

A->B, A#B, A+B, A list 

– anwenderdefinierbare abstrakte und rekursive Datentypen 

– Typechecking mit Hindley/Milner-Algorithmus 

• Kontrollierte Behandlung von Ausnahmen 


Abstrakte Datentypen in ML 

abstype time = int # int 

with maketime(hrs,mins) = if hrs

Implementierung von Termen 

Informale Definitionen 

↦→ (abstrakte) Datentypen 

abstype var = tok 

with mkvar t = abs var t 

and dvar v = rep var v 

;; 

abstype level exp = tok + int 

with . 

abstype parm = int + tok + string + var + level exp + bool 

with . 

absrectype term = (tok # parm list) # bterm list 

and bterm = var list # term 

with mk term (opid,parms) bterms = abs term((opid,parms),bterms) 

and dest term t = rep term t 

and mk bterm vars t = abs bterm(vars,t) 

and dest bterm bt = rep bterm bt 

;; 

Konkrete Objektsprache in Tabellen und Bibliotheksobjekten 


Implementierung von Regeln und Beweisen 

• Abstrakte Definition der Typen rule and proof 

– keine unzulässige Manipulation von Beweisen möglich 

– Sicherheit des Beweissystems leicht zu garantieren 

• Regel = Dekomposition + Validierungsfunktion 

– Repräsentation durch Regelschemata 

– Aufbau des Beweisbaums nur durch Validierung 

– Anwendung durch Konversion in Taktik mit refine 

⇒ leichte Komposition von Regeln 

Konkrete Inferenzregeln in Bibliotheksobjekten 

• Korrektheit des Systems leicht verifizierbar 

– Überprüfe korrekte Repräsentation von Regeln (Text) 

– Verifiziere refine 


Regeln und Beweise – konkrete Datentypen 

abstype declaration = var # term 

with mk assumption v t = abs declaration(v,t) 

and 

;; 

dest assumption d = rep declaration d 

lettype sequent = declaration list # term;; 

abstype rule = ..... 

absrectype proof = (declaration list # term) # rule # proof list 

with mk proof goal decs t = abs proof((decs,t), ⋄,[]) 

and refine r p = let children = deduce children r p 

and validation= deduce validation r p 

in children, validation 

and hypotheses p = fst (fst (rep proof p)) 

and conclusion p = snd (fst (rep proof p)) 

and refinement p = fst (snd (rep proof p)) 

and 

;; 

children p = snd (snd (rep proof p)) 

lettype validation = proof list -> proof;; 

lettype tactic = proof -> (proof list # validation);; 


Bibliothek 

Formalisiertes mathematisches Textbuch 

• Objekte 

– Inhalt: Definitionen, Sätze+Beweise, Methoden, Anmerkungen 

– Verwaltungsinformation: Name, Art, Status, Position 

• Unterstrukturierung in Theorien 

• Grundoperationen zur Verwaltung 

– Erzeugen, Löschen, Editieren, Überprüfen 

– Verschieben, Laden von Datei, Ablegen 

• Zusätzliche Regeln: lemma, extract 


Kommandoebene 

Interface Beweisentwicklungssystem ←→ Benutzer 

• Kontrolle der Bibliothek 

• Aufruf von Editoren 

• Experimente mit Termen der Objektsprache 

• Experimente mit ML-Programmen (Interpreter) 

• Laden externer Dateien 

. 


Termeditor 

Verständliche Notation in formalen Sprachen 

• Unterstützung interaktiver Beweisentwicklung 

– Darstellung mathematischer Notation auf dem Bildschirm 

– Kontextfreie Sprachen unakzeptabel 

⇒ Parser zu unflexibel 

• Termeingabe durch Struktureditor 

– Erzeugung des Termbaus durch Ausfüllen von Slots 

⇒ Effizienz: keine Dekodierung von Text nötig 

⇒ Flexibilität: freie Syntax und Mehrdeutigkeiten zulässig 

⇒ Eleganz: Kenntnis der genauen Syntax nicht erforderlich 

– Umdenken nötig: keine lineare Eingabe von Text 


Beweiseditor 

• Sichtbare Entwicklung von Beweisen 

– Baumeditor 

– Kontrolliertes Interface zu refine und mk proof goal 

• Lokale Sicht auf Beweise 

– Arbeiten im einzelnen Beweisknoten 

– Bewegung im Baum mit Maus und Sondertasten 

• Extraktionsmechanismus 

– Komposition der Extraktterme bei vollständigem Beweis 

Beweisplanung durch Anwender nötig 


Typischer Beweisknoten 

Name des Theorems 

EDIT THM intsqrt 

Status, Position relativ zur Wurzel # top 1 

Erste Hypothese des Beweisziels 1. x:N 

Konklusion ⊢ ∃y:N. y 2 ≤x ∧ x

Definitionsmechanismus 

• Essentiell für konservative Erweiterungen 

– einfache, verständliche und vertraute Notation 

• Textmakros hilfreich aber zu einfach 

• Abstraktionsmechanismus 

– Auffalten von Definitionen nur explizit 

– Metavariablen und Substitution 2. Stufe nötig 

• Displaymechanismus 

– elegante, leicht lesbare Textdarstellung 

(Formatierung, Klammerung, Abkürzung) 

– Hypertext-Technik erforderlich 



Lektion 13 

Taktiken – programmierte Beweisführung 

1. Grundkonzepte des taktischen Beweisens 

– Verfeinerungstaktiken 

– Transformationstaktiken 

2. Programmierung von Taktiken 

3. Korrektheit taktisch geführter Beweise 

4. Erfahrungen im praktischen Umgang

Taktiken 

Benutzerdefinierte Erweiterung des Inferenzsystems 

• Programmierte Anwendung von Beweisregeln 

– Vorausplanung von Beweisen 

– Strategische Suche nach Beweisen 

– Modifikation von Beweisen 

– Strukturierung von Beweisen / Unterdrücken von Details 

– Integration von Beweis-/Syntheseverfahren in interaktive Systeme 

• Freiheit zum Experimentieren mit Beweisstrategien 

+ 

Sicherheit gegenüber Fehlern beim Beweisen 

Satz: Das Resultat einer Taktik-Anwendung ist immer ein gültiger Beweis 

des zugrundeliegenden logischen Kalküls. 

• Kombination mit Definitionen und Lemmata sehr effizient 

Automatisierte Logik und Programmierung 165 Taktiken

Verfeinerungstaktiken 

Abgeleitete (programmierte) Inferenzregeln 

• Anwendung: wie gewöhnlichen Kalkülregel 

• Sichtbar: Taktikname + ungelöste Teilziele 

• Interne Verarbeitung: 

1. prlgoal ←− aktuelle Beweissequenz 

Teilbaum unterhalb der Sequenz wird ignoriert 

2. Anwendung der Taktik auf prlgoal liefert Teilziele + Validierung 

3. Anwendung der Validierung auf Teilziele erzeugt Beweisbaum 

4. Aktuelle Beweisregel ←− Taktikname + Beweisbaum (intern) 

Aktuelle Teilziele ←− generierte Teilziele 

5. Fehlermeldung, falls Taktik nicht anwendbar 


Transformationstaktiken 

Modifikation existierender Beweise 

(Kopieren, Expandieren, Komprimieren, Analogie, . . . ) 

• Anwendung: spezieller Befehl 

• Sichtbar: gesamter erzeugter Beweisbaum (Regeln + Teilziele) 

• Interne Verarbeitung: 

1. prlgoal ←− gesamter aktueller Teilbeweis 

2. Anwendung der Taktik auf prlgoal liefert Teilziele + Validierung 

3. Anwendung der Validierung auf Teilziele erzeugt Beweisbaum 

4. Aktueller Beweisbaum ←− generierter Beweisbaum 

Taktikname wird nicht gespeichert 

5. Keine Änderung, falls Taktik nicht anwendbar 


Programmierung von Taktiken 

• Umwandlung von Regeln in Taktiken mittels refine 

• Zusammensetzung von Taktiken durch Tacticals 

– t 1 THEN t 2 : “Wende t 2 auf alle von t 1 erzeugten Teilziele an” 

– t THENL [t 1 ; t 2 ; ..t n ]: “Wende t i auf das i-te von t erzeugte Teilziel an” 

– t 1 ORELSE t 2 : “Wende t 1 an. Falls dies fehlschlägt, wende t 2 an”. 

– Repeat t: “Wiederhole die Taktik t bis sie fehlschlägt” 

– Complete t: “Wende t nur an, wenn der Beweis vollständig wird” 

– Progress t: “Wende t nur an, wenn ein Fortschritt erzielt wird” 

– Try t: “Wende t an; falls dies fehlschlägt, lasse das Ziel unverändert” 

. 

• ML-Programme zur Steuerung von Taktikanwendungen 

– Ausführliche Analyse der Sequenzen zur Parameterbestimmung 


Implementierung von Tacticals 

ml curried infix ‘THENL‘ ;; 

ml curried infix ‘ORELSE‘ ;; 

let $THENL (tac: tactic) (tac list : tactic list) (pf:proof) = 

let subgoals, val = tac pf 

in 

if not length tac list = length subgoals 

then fail 

else let subgoalLists, valList = map apply tac list subgoals 

in 

(flatten subgoalLists), 

\proofs. val ( (mapshape (map length subgoalLists) valList) proofs) 

;; 

let $ORELSE (t1:tactic) (t2:tactic) pf = t1 pf ? t2 pf ;; 

let Complete (tac:tactic) (pf:proof) = let subgoals, val = tac pf 

in 

if null subgoals 

then subgoals, val 

else fail 

;; 


ML-Programme als Taktiken 

Anwendung von hypothesis auf alle Hypothesen des Beweises 

let hypcheck (pf:proof) = 

let n = length (hypotheses pf) 

in 

;; 

letrec TryHyp pos = 

if pos

Programmierung der Taktik simple prover 

let hypcheck = TryAllHyps hypothesis ;; 

let contradiction = TryAllHyps false e ;; 

let conjunctionE = TryAllHyps and e ;; 

let existentialE = TryAllHyps ex e ;; 

let disjunctionE = TryAllHyps or e ;; 

let impChain = Chain impE hypcheck ;; 

let notChain = TryAllHyps not e THEN impChain ;; 

let nondangerousI pf 

let simple prover 

= let termkind = opid (conclusion pf) 

in 

if member termkind [‘all‘; ‘not‘; ‘implies‘; 

‘rev implies‘; ‘iff‘; ‘and‘] 

then Run (termkind ˆ ‘ i‘) pf 

else fail 

;; 

= Repeat 

( hypcheck 

ORELSE contradiction 

ORELSE conjunctionE 

ORELSE existentialE 

ORELSE nondangerousI 

ORELSE disjunctionE 

ORELSE notChain 

ORELSE impChain 

);; 


Programmierung von Transformationstaktiken 

Markieren und Kopieren von Beweisen 

let Mark name pf = add saved proof name pf; Id pf ;; 

letrec copy pattern pattern pf = 

if is refined pattern 

then Try ( refine (refinement pattern) 

THENL (map copy pattern (children pattern)) 

) pf 

else Id pf 

;; 

let Copy name = copy pattern (get saved proof name) 

saved proofs: globale Variable vom Typ (tok#proof) list 



Lektion 14 

Entscheidungsprozeduren – automatische Beweisführung 

1. Einsatzbereiche 

2. Entscheidungsprozedur für elementare Arithmetik 

3. Schließen über Gleichheit 

4. Grenzen der Anwendungsmöglichkeiten 

AUSBLICK

Entscheidungsprozeduren 

Fest eingebaute algorithmische Inferenzregeln 

• Sinnvoll, wenn nur “Wahrheit” gefragt 

– Variation bekannter mathematischer Erkenntnisse 

– Beweisdetails / Extraktterm ohne Bedeutung 

– formaler Beweis mit Taktiken zu aufwendig 

• Möglich, wenn Problem algorithmisch entscheidbar 

– schneller Test für Anwendbarkeit überhaupt 

– maschinennahe Charakterisierung für Gültigkeit 

– maschinennahes Entscheidungsverfahren 

• Erforderlich: Verifikation der Prozedur 

– Konsistenz mit dem Rest der Theorie (Typkonzept!) 

– Korrektheit und Vollständigkeit der Entscheidungsalgorithmen 

Automatisierte Logik und Programmierung 174 Entscheidungsprozeduren

Arithmetische Entscheidungsprozeduren 

• Praktische Beweisführung braucht arithmetische 

Entscheidungsprozedur 

– arithmetisches Schließen taucht fast überall auf 

– arithmetische Schlüsse liefern keine neuen Erkenntnisse 

– arithmetische Aussagen tauschen in vielen Erscheinungsformen auf 

– formale Beweise simpler arithmetischer Aussagen sind nicht leicht 

• Allgemeine Arithmetik ist unentscheidbar 

– glechmächtig mit Theorie der berechenbaren Funktionen 

⇒ Entscheidungsprozedur für eingeschränkte Arithmetik 

– Konstanten, Grundoperationen, Grundvergleiche – keine Induktion 


A – Theorie der elementaren Arithmetik 

Formale Sprache: elementar-arithmetische Formeln 

– Terme aufgebaut aus ganzzahligen Konstanten, Variablen und +, -, * 

– Atomare Formeln t 1 ρ t 2 : t i Terme, ρ ∈ {=,≠,,≤,≥} 

– Formeln aufgebaut aus atomaren Formen mit ¬, ∧ , ∨ und ⇒ 

Semantik: axiomatisch charakterisiert durch 

– Gleichheitsaxiome mit eingeschränkter Substitutivität 

– Axiome der Konstantenarithmetik 

– Ringaxiome der ganzen Zahlen 

– Axiome der diskreten linearen Ordnung 

– Definitionsaxiome für Ordnungsrelationen und Ungleichheiten 

– Monotonieaxiome 


arith – wichtige Voraussetzungen 

• Zu jeder elementar-arithmetischen Formel F gibt es eine äquivalente 

elementar-arithmetische Formel G in konjunktiver Normalform 

• Γ ⊢ G 1 ∨ ... ∨ G n gültig gdw. Γ, ¬G 1 ,...,¬G n 

(falls G 1 , . . . , G n entscheidbar) 

⊢ Λ gültig 

• Eine Menge F 1 [e 1 , .., e k / u 1 , .., u k ], . . . , F n [e 1 , .., e k / u 1 , .., u k ] von 

elementar-arithmetischen Formeln ist genau dann widersprüchlich, 

wenn F 1 , . . . , F n widersprüchlich ist. 

(e 1 , . . . , e k elementar-arithmetische Terme; u 1 , . . . , u k Variablen) 

• Γ = v 1 ≥ u 1 + c 1 , . . . , v n ≥ u n + c n ist genau dann widersprüchlich, 

wenn der Ordnungsgraph G von Γ einen positiven Zyklus besitzt. 

(v i /u i Variablen oder 0; c i nichtnegative Konstanten) 


arith angewandt auf Γ ⊢ G 1 ∨ . . . ∨ G n 

1. Führe Monotonieschritte aus (erzeugt neue Hypothese) 

2. Transformiere in die Gestalt Γ, ¬G 1 ,...,¬G n ⊢ Λ. 

3. Zerlege Konjunktionen entsprechend der Regel and e 

4. Transformiere Ungleichungen x≠y in Disjunktion x≥y+1 ∨ y≥x+1 

5. Zerlege Disjunktionen (wie mit or e); betrachte Beweisziele separat. 

6. Entferne Hypothesen ohne atomare elementar-arithmetische Formeln 

7. Ersetze nicht elementar-arithmetische Teilterme durch Variablen. 

8. Transformiere Komparanden in Standardpolynome. 

9. Transformiere Komparanden in monadische lineare Polynome c + u i 

10. Konvertiere Hypothesen in Ungleichungen der Gestalt t 1 ≥t 2 

(t 1 Variable oder 0; t 2 ein monadisches lineares Polynom) 

11. Erzeuge den Ordnungsgraphen der Formelmenge: 

Knoten für jede Variablen/ Konstante; Kante u i 

c 

−→ u j 

für u i 

≥u j 

+c. 

12. Teste, ob der Ordnungsgraph einen positiven Zyklus hat. 

Generiere Wohlgeformtheitsziele oder Fehlermeldung. 


Gleichheitsschließen 

Folgt eine Gleichheit aus anderen Gleichheiten? 

• Gleichheitsschließen wichtig für praktische 

Beweisführung 

– Reflexivität, Symmetrie, Transitivität und Substitution 

• Elementare Gleichheit ist entscheidbar 

– Hypothesen und Konklusion sind Gleichheiten 

– Semantik: Axiome der Reflexivität, Symmetrie, Transitivität und Substitution 

• Effiziente Verfahren verfügbar: 

– transitive Hülle einer Äquivalenzrelation berechnen 

– technisch durch Betrachtung des Relationsgraphen 


Equality: graphentheoretische Voraussetzungen 

1. G = (V, E) gerichteter Graph 

– l(v): Markierung des Knoten v in G 

– δ(v): Anzahl der von v ausgehenden Kanten 

– v[i]: i-ter Nachfolgerknoten von v 

– u Vorgänger von v, wenn v = u[i] für ein i 

2. R Relation auf V . 

• u und v kongruent unter R, wenn l(u) = l(v), δ(u) = δ(v) und 

(u[i], v[i]) ∈ R für alle i 

• R abgeschlossen unter Kongruenzen, wenn aus u und v 

kongruent unter R folgt, daß (u, v) ∈ R gilt 

• Der Kongruenzabschluß R ∗ von R ist die eindeutige minimale 

Erweiterung von R, die abgeschlossen unter Kongruenzen und 

eine Äquivalenzrelation ist. 


MERGE(R,u,v) – Algorithmus 

Berechne Kongruenzabschluß von R ∪ {(u, v)} 

Eingabe: G = (V, E) gerichteter Graph; R Äquivalenzrelation 

(abgeschlossen unter Kongruenzen); u, v ∈ V . 

1. Sind u und v in der gleichen Äquivalenzklasse von R , dann lasse 

R unverändert und beende die Berechnung. 

2. Andernfalls sei P u bzw. P v die Menge der Vorgänger von Knoten 

aus der Äquivalenzklasse von u bzw. v 

3. Modifiziere R: verschmelze Äquivalenzklassen von u und v. 

4. Wiederhole für alle x ∈ P u und y ∈ P v 

Falls die Äquivalenzklassen von x und y verschieden sind, aber 

x und y kongruent sind, so modifiziere R durch Aufruf von 

MERGE(R,x,y). Andernfalls lasse R unverändert. 

Ausgabe: modifizierte Relation R. 


Entscheidungsprozedur für Gleichheit 

Quantorenfreies Schließen über Gleichheiten mit 

uninterpretierten Funktionssymbolen und Variablen 

Eingabe: Hypothesen s 1 =t 1 ,...,s n =t n ; Konklusion s=t 

1. Konstruiere Graphen G der Baumdarstellungen von 

s, s 1 , . . . , s n , t, t 1 , . . . , t n 

Setze R als Identitätsrelation auf den Knoten von G 

2. Wende schrittweise MERGE(R,τ (s i ),τ (t i )) für 1 ≤ i ≤ n an. 

3. Wenn τ (s) in der gleichen Äquivalenzklasse wie τ (t) liegt, dann 

sind s und t gleich. 

Andernfalls folgt s=t nicht aus s 1 =t 1 ,...,s n =t n 

τ (u): Wurzelknoten der Baumdarstellung von u in G. 

In NuPRL wegen Typbedingungen nur eingeschränkt einsetzbar 



• Ausdruckstarke Theorien sind unentscheidbar 

⇒ vollautomatische Beweissysteme nicht sinnvoll 

⇒ Beweissysteme interaktiv steuern 

– ergänzt durch Taktiken und Entscheidungsprozeduren 

• NuPRL: flexibles universelles Basissystem 

– Schließen über alle Bereiche von Mathematik und Programmierung 

– Ausbau zu leistungsfähigen Inferenzsystem für beliebige Anwendungsgebiete 

durch Benutzer möglich 

• Forschungsrichtungen 

– Verbesserung der in das System integrierten Mechanismen 

– Strukturierung der mathematischen Bibliothek 

– Meta-Schließen, Reflektion, Analogie 

– praktische Anwendungen 

Kooperation zwischen Mensch und Computer verbessern 



Lektion 15 

Programmsynthese 

1. Wissensbasiertes Softwareentwicklung 

2. Formale Grundkonzepte 

3. Leitbeispiel: Costas-Arrays

Wissensbasiertes Software-Engineering 

Automatisierung des Schrittes von der Spezifikation 

zum korrekten, ausführbaren Programm 

und Dokumentation getroffener Entscheidungen 

• Strategien zur Synthese von Algorithmen 

aus formalen Spezifikationen 

• Verfahren zum Erwerb von “Synthesewissen” 

• Hilfe beim Entwurf formaler Spezifikationen 

• Hilfsmittel zur 

– algorithmischen Optimierung, 

– Implementierung abstrakter Datentypen 

– sprachabhängigen Compilierung / Optimierung 

. 

Automatisierte Logik und Programmierung 185 Programmsynthese

Programmsynthese 

• Grundkonzepte 

– Phasen einer Synthese 

– Formale Grundbegriffe 

– Syntheseparadigmen 

• Beweise als Programme 

– Induktionsstrategien, Rippling, .... 

• Synthese durch Transformationen 

– LOPS 

• Synthese mit Algorithmenschemata 

– KIDS: Globalsuche, Divide & Conquer, Lokalsuche .... 

• Nachträgliche Optimierungen 


Phasen einer formalen Entwicklung von Software 

1. Erstellen der nötigen “Objekttheorie”: 

– Formalisierung vorkommender Begriffe 

– Aufstellen mathematischer Gesetze 

2. Erstellen der formalen Spezifikation 

3. Entwurf eines läuffähigen, korrekten Algorithmus 

4. Verifizierte algorithmische Optimierung 

5. Implementierung abstrakter Datentypen 

6. Compilierung und sprachabhängige Optimierung 


Programmsynthese: Formale Grundbegriffe 

• Spezifikation: Tupel spec = (D,R,I,O) 

Notation: FUNCTION f(x:D):R WHERE I(x) RETURNS y SUCH THAT O(x,y) 

– D (Domain) und R (Range): Datentypen 

– I (Input-Bedingung an zulässige Eingaben): Prädikat über D 

– O (Output-Bedingung an mögliche Ausgaben): Prädikat über D×R 

D,R,I,O in Spezifikationssprache zu beschreiben 

• Programm: Tupel p = ( D,R,I,O, body ) 

FUNCTION f(x:D):R WHERE I(x) RETURNS y SUCH THAT O(x,y) = body(x) 

– (D,R,I,O): Spezifikation 

– body:D↛R (Programmkörper): berechenbare Funktion 

body in Programmiersprache zu beschreiben (f darf vorkommen) 

• Programm p korrekt, falls gilt: ∀x:D. I(x) ⇒ O(x,body(x)) 

• Spezifikation spec erfüllbar (synthetisierbar), falls eine Funktion 

body:D↛R existiert, so daß p=(spec,body) korrekt ist 


Erweiterte formale Sprache – wichtigste 

Bestandteile 


B, true, false Data type of boolean expressions, explicit truth values 

¬, ∧ , ∨ , ⇒ , ⇐ , ⇔ Boolean connectives 

∀x ∈ S.p, ∃x ∈ S.p 

Limited boolean quantifiers (on finite sets and sequences) 

if p then a else b 

Conditional 

Seq(α) 

Data type of finite sequences over members of α 

null?, ∈ , ⊑ 

Decision procedures: emptiness, membership, prefix 

[], [a], [i..j], [a 1 

...a n 

] Empty/ singleton sequence, subrange, literal sequence former 

a.L, L·a 

prepend a, append a to L 

[f(x)|x ∈ L ∧ p(x)], |L|, L[i] General sequence former, length of L, i-th element, 

domain(L), range(L) 

The sets {1..|L|} and {L[i]|i ∈ domain(L)} 

nodups(L) 

Decision procedure: all the L[i] are distinct (no duplicates) 

Set(α) 

Data type of finite sets over members of α 

empty?, ∈ , ⊆ 

Decision procedures: emptiness, membership, subset 

∅, {a}, {i..j}, {a 1 

...a n 

} Empty set, singleton set, integer subset, literal set former 

S+a, S-a 

{f(x)|x ∈ S ∧ p(x)}, |S| 

S∪T, 

⋃ 

S∩T, S\T 

⋂ 

FAMILY, FAMILY 

element addition, element deletion 

General set former, cardinality 

Union, intersection, set difference 

Union, intersection of a family of sets 


Costas-Arrays: Problemstellung 

Costas Array der Größe n: 

Permutation von {1..n} ohne doppelte Elemente in den Zeilen der Differenzentafel 

2 4 1 6 5 3 

-2 3 -5 1 2 

1 -2 -4 3 

-4 -1 -2 

-3 1 

-1 

Costas Array der Ordnung 6 und seine Differenzentafel 

Ziel: Berechnung aller Costas Arrays der Größe n 

Programmsynthese 191 DEMO: Costas Arrays Synthese

Costas-Arrays (1): Objekttheorie 

• Formalisierung vorkommender Begriffe: 

dtrow(L,j) ≡ [L[i]-L[i+j] | i ∈ [1..|L|-j] ] 

perm(L,S) ≡ nodups(L) ∧ range(L)=S 

• Aufstellen mathematischer Gesetze: 

∀L,L’:Seq(Z).∀i:Z.∀j:N. 

1. dtrow([],j) = [] 

2. j≤|L| ⇒ dtrow(i.L,j) = (i-L[j]).dtrow(L,j) 

3. j≠0 ⇒ dtrow([i],j) = [] 

4. L⊑L’ ⇒ dtrow(L,j) ⊑ dtrow(L’,j) 

5. j≥|L| ⇒ dtrow(L,j) = [] 

6. j≤|L| ⇒ dtrow(L·i,j) = dtrow(L,j)·(L[ |L|+1-j ]-i) 


Costas-Arrays (2): formale Spezifikation 

FUNCTION Costas (n:Z):Set(Seq(Z)) WHERE n≥1 

RETURNS All-p 

SUCH THAT All-p = 

{p:Seq(Z)| perm(p,{1..n}) 

∧ ∀j ∈ domain(p).nodups(dtrow(p,j))} 

Kurzschreibweise 

FUNCTION Costas (n:Z) WHERE n≥1 

RETURNS {p:Seq(Z)| perm(p,{1..n}) 

∧ ∀j ∈ domain(p).nodups(dtrow(p,j))} 


Costas-Arrays (3): lauffähiger Algorithmus 


RETURNS {p:Seq(Z)| perm(p,{1..n}) ∧ ∀j ∈ domain(p).nodups(dtrow(p,j))} 

= if nodups([]) ∧ ∀j ∈ domain([]).nodups(dtrow([],j)) 

then Costas aux (n,[]) else ∅ 

FUNCTION Costas aux (n:Z,V:Seq(Z)) 

WHERE n≥1 ∧ range(V)⊆{1..n} ∧ nodups(V) ∧ ∀j ∈ domain(V).nodups(dtrow(V,j)) 

RETURNS {p:Seq(Z)| perm(p,{1..n}) ∧ V⊑p ∧ ∀j ∈ domain(p).nodups(dtrow(p,j))} 

= {p | p ∈ {V} ∧ perm(p,{1..n}) ∧ ∀j ∈ domain(p).nodups(dtrow(p,j))} 

∪ ⋃ { Costas aux (n,W) | W ∈ {V·i|i ∈ {1..n}} ∧ nodups(W) 

∧ ∀j ∈ domain(W).nodups(dtrow(W,j)) } 


COSTAS-ARRAYS (4a): CI-Simplifikationen 


RETURNS {p:Seq(Z)| perm(p,{1..n}) ∧ 

= Costas aux (n,[]) 

∀j ∈ domain(p).nodups(dtrow(p,j))} 



RETURNS {p:Seq(Z)| perm(p,{1..n}) ∧ V⊑p ∧ ∀j ∈ domain(p).nodups(dtrow(p,j)) } 

= (if perm(V,{1..n}) ∧ ∀j ∈ domain(V).nodups(dtrow(V,j)) then {V} else ∅) 

∪ ⋃ { Costas aux (n,V·i) |i ∈ {1..n} ∧ nodups(V·i) 

∧ ∀j ∈ domain(V·i).nodups(dtrow(V·i,j))} 


Costas-Arrays (4b): CD-Simplifikationen 








= (if {1..n}⊆range(V) then {V} else ∅) 

∪ ⋃ { Costas aux (n,V·i) |i ∈ {1..n} ∧ i ∉ V 

∧ ∀j ∈ domain(V). (V[|V|+1-j]-i) ∉ dtrow(V,j) } 


Costas-Arrays (4c): Finite Differencing 



= Costas aux1 (n,[],{1..n}) 


FUNCTION Costas aux1 (n:Z,V:Seq(Z),Pool:Set(Z)) 


∧ Pool = {1..n}\range(V) 


= (if empty?(Pool) then {V} else ∅) 

∪ ⋃ { Costas aux1 (n,V·i,Pool−i) |i ∈ Pool 



Costas-Arrays (4d): Case Analysis 



= Costas aux2 (n,[],{1..n},1) 


FUNCTION Costas aux2 (n:Z,V:Seq(Z), Pool:Set(Z),Vsize:Z) 


∧ Pool = {1..n}\range(V) ∧ Vsize = |V|+1 


= if empty?(Pool) 

then {V} 

else ⋃ { Costas aux2 (n,V·i,Pool−i,Vsize+1) |i ∈ Pool 

∧ ∀j ∈ domain(V). (V[Vsize-j]-i) ∉ dtrow(V,j) } 


Datentypverfeinerung 

Ersetze abstrakte Definitionen von Datentypen 

durch effiziente konkrete Implementierungen 

• Endliche Mengen 

– Listen: Standardimplementierung 

– Bitvektor: Mengen über endlichem Domain 

– charakteristische Funktion (effiziente Elementrelation) 

• Folgen 

– verkettete Liste: Standardimplementierung 

– umgekehrte Liste (gut für append-Operation ·) 

• System stellt Auswahl von Implementierungen bereit 

Benutzer legt Nichtstandard-Implementierung fest 

– separate für jede einzelne Variable 



Lektion 16 

Syntheseparadigmen 

1. Beweise als Programme 

2. Synthese durch Transformationen 

3. Algorithmenschemata

Syntheseparadigmen 

• Unterscheidungsmerkmale 

– Interne Aufgabenstellung (Darstellung des Problems) 

– Interne Lösungsmethode (Art der Inferenzen) 

– Konstruktionsmethode für Algorithmus (aus interner Lösung) 

• Beweise als Programme 

– Extraktion aus konstruktivem Beweis eines Theorems 

• Synthese durch Transformationen 

– Äquivalenzumformungen in ausführbare (rekursive) Form 

• Verwendung von Algorithmenschemata 

– Verfeinerung von Standardlösungen für bekannte algorithmische Grundstrukturen 

Automatisierte Logik und Programmierung 200 Syntheseparadigmen

Syntheseparadigmen: Beweise als Programme 

Gegeben sei die Spezifikation: 

FUNCTION f(x:D):R WHERE I(x) RETURNS y SUCH THAT O(x,y) 

1. Wandle um in Spezifikationstheorem: 

– ∀x:D.∃y:R. I(x) ⇒ O(x,y) 

2. Suche formalen Beweis in konstruktivem logischen Kalkül. 

3. Extrahiere aus Beweis eine Methode, y aus x zu berechnen 

Forschung: 

– Ausdrucksstarke Kalküle 

– Effiziente Beweisstrategien und Beweisplaner (Induktion) 

– Effiziente Extraktionsmechanismen 


Syntheseparadigmen: Synthese durch Transformation 



1. Definiere neues Prädikat F über D×R durch: 

– ∀x:D.∀y:R. I(x) ⇒ (F(x,y) ⇔ O(x,y)). 

2. Transformiere in äquivalente Formel der Gestalt: 

– ∀x:D.∀y:R. I(x) ⇒ (F(x,y) ⇔ O f (x,y)) 

O f (x,y) darf nur aus erfüllbaren Prädikaten und Vorkommen von F bestehen 

3. Extrahiere aus der rekursiven Formel ein Programm. 

– Alternativ: Interpretation als Logik-Programm 

Forschung: 

– Leistungsfähige Transformationsregeln 

– effiziente Rewrite Techniken und Heuristiken 


Syntheseparadigmen: Algorithmenschemata 

Erzeuge Algorithmus in einem Schritt 



1. Wähle algorithmischen Klasse und (partielles) Schema 

2. Verfeinere Schema auf das Problem 

Vervollständige unbesetzte Parameter 

3. Instantiiere Algorithmenschema 

Forschung: 

– Analyse der Struktur einer Klasse von Algorithmen 

– Komponenten und Axiome für Korrektheit 

– Techniken zur Verfeinerung von Standardlösungen 



Lektion 17 

Synthese–Strategien 

1. Übersicht 

2. Beweise als Programme: OYSTER/CLAM, PRECOMAS 

3. Synthese durch Transformationen

Synthese–Strategien 

Konkrete Verfahren zur 

Synthese von Algorithmen aus Spezifikationen 

• Steuern die Anwendung eines logischen Formalismus 

• Strukturieren den Lösungsweg durch interne Teilziele 

• Verarbeiten Programmierwissen 

• Lösen Teilziele durch heuristisch kontrollierte Suche 

• Hängen ab von Rückfragen an den Benutzer 

Automatisierte Logik und Programmierung 205 Synthese–Strategien

Synthesestrategien: Historisch relevante Verfahren 

• Informale Methoden 

– Polya, Dijkstra, Gries, . . . 

• Beweiser mit Skolemisierung und Resolution 

– Green, 1969 (Stanford/Kestrel Institute) 

– Manna/Waldinger, 1971,75 (SRI International) 

Transformations- und Formationsregeln 

– Manna/Waldinger, 1972–1980 

Beweiskalkül gekoppelt mit Transformationen 

– Manna/Waldinger, 1980– 

• Fold/Unfold Techniken 

– Burstall/Darlington (Edinburgh) 1975–81 

• Modifizierte Knuth-Bendix Vervollständigung 

– Dershowitz (Illinois) 1985– 

• Synthese von Logikprogrammen 

– Clark, Hogger (London) 1980 – 

Automatisierte Logik und Programmierung 206 Synthese–Strategien

Beweise als Programme:OYSTER/CLAM Beweisplaner 

• Planer simuliert Kalkül — Beweiser führt Beweisplan aus 

– Verzögerung von Entscheidungen durch Skolemvariablen und Unifikation 

• Induktionsbeweise 

– Induktionsschema ⇐ Analyse der Rekursionsstruktur + globales Schema 

– Rippling: Verschiebe Unterschiede zwischen Induktionshypothese und -schluß 

bis Funktion der Hypothese entsteht 

Literatur: 

– A. Bundy, A. Smaill, G. Wiggins. The synthesis of logic programs from inductive proofs. 

Computer Logic Proceedings, Brussels. Springer Verlag, 1990. 

– A. Bundy, F. van Harmelen, J. Hesketh, A. Smaill. Experiments with proof plans for induction. 

JAR 7:303–324, 1991. 

– A. Bundy. The use of explicit plans to guide inductive proofs. Proc. CADE-9, Springer LNCS 310, 

111–120, 1988. 

– A. Bundy. Automatic guidance of program synthesis proofs. Workshop on Automating Software 

Design, IJCAI-89, 57–59, 1989. 

– A. Bundy, F. van Harmelen, A. Smaill, A. Ireland. Extensions to the rippling-out tactic for 

guiding inductive proofs. Proc. CADE-10, Springer LNCS 449, 132–146, 1990. 

Automatisierte Logik und Programmierung 207 Beweise als Programme

Beweise als Programme: PRECOMAS: Constructive Matching 

Synthese durch induktives Theorembeweisen 

• Start mit 

∀x:D. ∃y:R.O(x,y). 

• Zerlege O(x,y) syntaktisch in atomare Prädikate 

P 1 

(t 1 

(x,y),...t n 

(x,y)) ∧ ... ∧ P m 

(t 1 

(x,y),...t n 

(x,y)) 

• Für jedes atomare Prädikat wähle festen Term t i 

; 

ersetze die anderen durch freie Parameter ξ j . 

• Entfalte Definitionen bis ξ j gegen t j 

(x,y) matchen 

– Im Basisfall verwende Definitionen der Theorie 

– Im Induktionsfall verwende zusätzlich ∀x’:R. x’

Beweise als Programme: Eigenschaften 

• Korrektheit des Programms ist garantiert 

• Verschiedene Kalküle sind theoretisch äquivalent 

– große praktische Unterschiede 

– Sequenzenkalküle für Mensch und Maschine geeignet 

• Verschiedene Extraktionsverfahren 

– beeinflussen Effizienz erzeugter Programme 

• Beweisschritte zu atomar (Assemblerniveau) 

– Beweise interaktiv kaum durchführbar 

– Automatisierung schwierig: 

Analyse der Formel, Unifikation, Suche nach geeigneten Induktionen 

↦→ praktisch nur sinnvoll in Kombination mit Definitionen und Spezialtaktiken 

Automatisierte Logik und Programmierung 209 Beweise als Programme

Synthese durch Transformation 

• Historisch: Optimierung von Programmen 

– Erzeuge abstraktes, verifiziertes Prototyp-Programm 

– Transformiere in äquivalentes effizienteres Programm 

• Synthese: Optimierung “nichtausführbarer” Programme 

– Spezifikation ≡ nichtausführbares Programm 

– Transformiere in äquivalente, ausführbare Formel 

Individuelle Formalismen variieren sehr stark 

• Forschung: 

– effiziente Rewrite-Techniken 

– Heuristiken zur Steuerung von Vorwärtsinferenzen 

Literatur: 

– R. M. Burstall, J. Darlington: A Transformation System for Developing Recursive Programs, 

JACM 24:44-67, 1977. 

– C. J. Hogger: Derivation of Logic Programs, JACM 28:372–392, 1981. 

– Z. Manna, R. J. Waldinger: Synthesis: Dreams ⇒ Programs, IEEE.SE SE-5 (4):294–328, 1979. 

Automatisierte Logik und Programmierung 210 Synthese durch Transformationen

Transformationen 

• Anwendung bedingter Ersetzungsregeln der Form 

∀z:T. P(z) ⇒ ( Q(z) ⇔ Q’(z) ) 

“Ersetze Vorkommen von Q(z) durch Q’(z), falls Bedingung P(z) erfüllt” 

Äquivalenzen oder Verfeinerungen (Implikationen) 

• Regeln ergeben sich aus 

– Lemmata der Wissensbasis 

– Dynamisch erzeugte Definitionen 

– Elementare Tautologien und Abstraktionen 

– Dynamisch erzeugte Kombinationen 

• Kalkül nicht zielgerichtet 

⇒ heuristische Steuerung notwendig 


Transformationen: Maximale Segmentsumme (1) 

Bestimme maximale Summe Σ p+q 

i=p 

L[i] der Teilfolgen einer Liste L 

1. Definiere neues Prädikat maxseg: 

∀L:Seq(Z).∀m:Z. L≠[] ⇒ 

maxseg(L,m) ⇔ m = MAX( ⋃ { {Σ q i=p L[i] |p ∈ {1..q}} | q ∈ {1..|L|} }) 

2. Generalisiere: Einführung eines Prädikats max aux: 

∀L:Seq(Z).∀m:Z. L≠[] ⇒ 

maxseg(L,m) ⇔ ∃l:Z. max aux(L,m,l) 

∀L:Seq(Z).∀m:Z. L≠[] ⇒ 

max aux(L,m,l) ⇔ m = MAX( ⋃ { {Σ q i=p L[i] |p ∈ {1..q}} | q ∈ {1..|L|} }) 

∧ l = MAX({Σ q i=1 L[i] |q ∈ {1..|L|} }) 

3. Transformation durch Anwendung von Lemmata 

∀L:Seq(Z).∀m:Z. L≠[] ⇒ max aux(L,m,l) 

⇔ |L|=1 ∧ m=L[1] ∧ l=L[1] 

∨ |L|>1 ∧ ∃m’,l’:Z. l’ = MAX({Σ q i=2 L[i] | q ∈ {2..|L|}} 

∧ m’ = MAX( ⋃ { {Σ q i=p L[i] |p ∈ {2..q}} | q ∈ {2..|L|} }) 

∧ l=max(L[1],l’+L[1]) ∧ m=max(l,m’) 


Transformationen: Maximale Segmentsumme (2) 

4. Umschreiben der Indizes relativ zu rest(L) 


⇔ |L|=1 ∧ m=L[1] ∧ l=L[1] 

∨ rest(L)≠[] 

∧ ∃m’,l’:Z. l’ = MAX({Σ q i=1 rest(L)[i] | q ∈ {1..|rest(L)|}}) 

∧ m’= MAX( ⋃ { {Σ q i=p rest(L)[i] |p ∈ {1..q}} | q ∈ {1..|rest(L)|} }) 


5. Einsetzen der Definition von max aux: 


⇔ |L|=1 ∧ m=L[1] ∧ l=L[1] 

∨ rest(L)≠[] ∧ ∃m’,l’:Z. max aux(rest(L),m’,l’) 

6. PROLOG-artiges Programm 


maxseg(L,m) :- max aux(L,l,m). 

max aux([a],a,a). 

max aux(a.L’,l,m):- max aux(L,m’,l’), max(a,l’+a,l), max(l,m’,m). 


Transformationen:Erzeugung funktionaler Programme 

• Disjunktion 

↦−→ Fallunterscheidung 

– Sind (D,R,I,O,body) und (D,R,I’,O’,body’) korrekt, dann auch 

FUNCTION f(x:D):R WHERE I(x) ∨ I’(x) RETURNS y SUCH THAT O(x,y) ∨ O’(x,y) 

= if I(x) then body(x) else body’(x) 

• Konjunktion 

• Existenzquantor 

↦−→ Einschränkung legaler Eingaben 

↦−→ Generalisierung 

– Sind (D,R,I,O,body) und (R,R’,J,O’,body’) korrekt, dann auch 

FUNCTION f(x:D):R’ WHERE I(x) ∧ J(body(x)) 

RETURNS z SUCH THAT ∃y:R. O(x,y) ∧ O’(y,z) 

= body’(body(x)) 

• Rekursive Formel ↦−→ Rekursion (Terminierungsbeweis nötig!) 

– f d :D↛D wohlfundierte ‘Reduktionsfunktion’ (keine absteigenden Ketten) und 

1. ∀x:D. I(x) ⇒ I(f d (x)) 

2. ∀x:D.∀y:R. I(x) ⇒ O(x,y) ⇔ ∃y r :R. O(f d (x),y r ) ∧ O C (x,f d (x),y r ,y) 

3. FUNCTION f C (x,x r ,y r :D×D×R):R WHERE I(x) RETURNS y SUCH THAT O C (x,x r ,y r ,y) 

= body(x,x r ,y r ) ist korrekt 

dann ist das folgende rekursive Programm korrekt 

FUNCTION f(x:D):R WHERE I(x) RETURNS y SUCH THAT O(x,y) = body(x, f d (x), f(f d (x))) 


Programmerzeugung: Maximale Segmentsumme 

Resultat der Transformationen 

∀L:Seq(Z).∀m:Z. L≠[] ⇒ 

maxseg(L,m) ⇔ ∃l:Z. max aux(L,m,l) 


⇔ |L|=1 ∧ m=L[1] ∧ l=L[1] 

∨ rest(L)≠[] ∧ ∃m’,l’:Z. max aux(rest(L),m’,l’) 

Erzeugtes funktionales Programm 


FUNCTION Maxseg(L:Seq(Z)):Z 

= snd( Max aux(L) ) 

WHERE L≠[] RETURNS m SUCH THAT maxseg(L,m) 

FUNCTION Max aux(L:Seq(Z)):Z×Z WHERE L≠[] 

RETURNS m,l SUCH THAT max aux(L,m,l) 

= if |L|=1 then (L[1],L[1]) 

else let (m’,l’) = Max aux(rest(L)) in 

let l=max(L[1],l’+L[1]) in 

( max(l,m’), l) 



Lektion 18 

LOPS 

1. Übersicht 

2. GUESS/DOMAIN 

3. GET-REC 

4. Sonstige Strategien

LOPS – LOgische ProgrammSynthese 

• Syntaktische Transformationen logischer Formeln 

kontrolliert durch semantische Informationen 

• Kombination einer kleinen Menge von Teilstrategien 

– GUESS/DOMAIN: Raten einer Teillösung 

– GET-REC: Rekursionseinführung 

– Vereinfachung 

– Erzeugung von Unterproblemen 

– Test auf Auswertbarkeit von Teilformeln 

– . 

• Algorithmenkonstruktion: 

– Umformung rekursiver Formeln in logische/funktionale Programme 

Literatur: 

– Wolfgang Bibel: Syntax–directed, Semantics–supported Program Synthesis AIJ 14:243–261, 1980 

Automatisierte Logik und Programmierung 217 LOPS

LOPS: Maximum-Synthese (1) 

Bestimme das Maximum m einer nichtleeren Menge S:Set(Z) 

0. Definiere neues Prädikat max durch 

∀S:Set(Z).∀m:Z. S≠∅ ⇒ max(S,m) ⇔ (m ∈ S ∧ ∀x ∈ S. x≤m) 

Markiere S als Input-Variable und m als Output-Variable. 

1. Die Formel ist nicht auswertbar 

2. GUESS/DOMAIN: 

– Rate eine Zahl g. Beschränke Auswahlmöglichkeiten auf Werte g ∈ S 

– Geratene Zahl ist direkte Lösung oder Grundlage für Problemreduktion 

und Einführung von Rekursion 

Transformiere Ausgangsformel in 

∀S:Set(Z).∀m:Z. S≠∅ ⇒ 

max(S,m) ⇔ ∃g:Z. g ∈ S ∧ (m ∈ S ∧ ∀x ∈ S.x≤m ∧ g≠m ∨ g=m) 


LOPS: Strategie GUESS/DOMAIN 

Gezieltes Raten liefert verwertbare Information 

Transformiere: 

∀x:D.∀y:R. I(x) ⇒ P(x,y) ⇔ O(x,y) 

in die Form 

∀x:D.∀y:R. I(x) ⇒ P(x,y) 

⇔ ∃g:G. DC(x,g) ∧ (O(x,y) ∧ t(g,y) ∨ ¬t(g,y)) 

Parameter der GUESS-Transformation 

• G: Datentyp der “Guess-Variable” g. 

In einfachen Fällen identisch mit R 

• t: Tautologie-Relation zwischen y und g. 

In einfachen Fällen die Gleichheit, sonst “g ist Teil von y” 

• Bedingung an Lösungen, von denen Teile geraten werden können 

Prädikat displayable(y) ˆ= ∃g:G.t(g,y) 

• DC: Bedingung an sinnvolle Ratewerte (Domain von g) 

Automatisierte Logik und Programmierung 219 LOPS 

↦→ Wissensbank 



↦→ Heuristik DOMAIN

LOPS: Heuristik DOMAIN 

Beschränke Ratemöglichkeiten auf leicht zu bestimmende Werte 

und versuche, die Möglichkeit falscher Rateschritte klein zu halten 

• Spezifikation (D,G,I,DC) muß erfüllbar sein. 

• Darstellbare Anteile von Lösungen müssen erreichbar sein 

{g:G | ∃y:R. O(x,y) ∧ t(g,y)} ⊆ {g:G | DC(x,g)} 

Formal: DC notwendig für darstellbare Anteile von Lösungen 

∀x:D.∀g:G. I(x) ⇒ (∃y:R. O(x,y) ∧ t(g,y)) ⇒ DC(x,g) 

Im einfachen Fall: DC “Echte Teilformel” von O 

• Menge ungeeigneter Werte ({g:G | DC(x,g) ∧ ¬t(g,y)}) soll klein sein 

• Effizienter Algorithmus zur Lösung von (D,G,I,DC) soll existieren 

⇒ Benutzerhilfe nötig für letzte beiden Kriterien 


LOPS: Zerlegung in Teilprobleme 

Zerlege Resultat von GUESS/DOMAIN in drei Teilprobleme 

∀x:D.∀y:R. I(x) ⇒ P(x,y) ⇔ ∃g:G. DC(x,g) ∧ (O 1 

(x,g,y) ∨ O 2 

(x,g,y)) 

∀x:D.∀g:G.∀y:R. I(x) ∧ DC(x,g) ⇒ 

∀x:D.∀g:G.∀y:R. I(x) ∧ DC(x,g) ⇒ 

O 1 

(x,g,y) ⇔ O(x,y) ∧ t(g,y) 

O 2 

(x,g,y) ⇔ O(x,y) ∧ ¬t(g,y) 

⇒ Lösung der Unterprobleme bestimmt Gesamtlösung, wenn DC erfüllbar 


3....S≠∅ ⇒ max(S,m) ⇔ ∃g:Z. g ∈ S ∧ (m ∈ S ∧ ∀x ∈ S.x≤m ∧ , g≠m ∨ g=m) wird zerlegt in 

∀S:Set(Z).∀m:Z. S≠∅ ⇒ 

max(S,m) ⇔ ∃g:Z. g ∈ S ∧ 

(max1(S,g,m) ∨ max2(S,g,m)) 

∀S:Set(Z).∀g,m:Z. S≠∅ ∧ g ∈ S ⇒ 

max1(S,g,m) ⇔ m ∈ S ∧ ∀x ∈ S. x≤m ∧ g≠m 

∀S:Set(Z).∀g,m:Z. S≠∅ ∧ g ∈ S ⇒ 

max2(S,g,m) ⇔ m ∈ S ∧ ∀x ∈ S. x≤m ∧ g=m 

DC(g,S) ˆ= g ∈ S ist erfüllbar, 

Lösung des dritten Teilproblems steht fest 



4. GET-REC: Transformiere in rekursive Variante der Ausgangsformel 

– Instantiiere Rekursionsschema für endliche Mengen 

“Versuche, P(S) durch P(S-g) auszudrücken” 

– Wende Lemmata der Wissensbank an 

1. S≠∅ ⇔ S={g} ∨ S-g ≠ ∅ 

2. g ∈ S ⇒ g≠m ∧ m ∈ S ⇔ g≠m ∧ m ∈ S-g 

3. g ∈ S ⇒ ∀x ∈ S. x≤m ⇔ g≤m ∧ ∀x ∈ S-g. x≤m 

– Zerlege Vorbedingung in Basis- & Rekursionsfall 

Resultat der Transformation 

∀S:Set(Z).∀g,m:Z. S={g} ∧ g ∈ S ⇒ 

max1(S,g,m) ⇔ m ∈ S ∧ ∀x ∈ S. x≤m ∧ g≠m 

↦→ Terminierung garantiert 

∀S:Set(Z).∀g,m:Z. S-g ≠ ∅ ∧ g ∈ S ⇒ 

max1(S,g,m) ⇔ m ∈ S-g ∧ ∀x ∈ S-g. x≤m ∧ g≠m ∧ g≤m 


LOPS: Strategie GET-REC 

Goal-oriented Equivalence Transformation 

• Ziel: Rekursive Form 

– Disjunktion in der Input-Bedingung 

– Konjunktionen in der Output-Bedingung 

– Außer O nur erfüllbare Prädikate 

• Methode: Suche nach geeigneten Lemmata 

– Beziehung zwischen reduzierter und nichtreduzierter Form der Prädikate 

• Hilfsmittel: 

– Wohlfundiertes Rekursionsschema ↦→ Wissensbank 

– Suchheuristik 



5. Simplifikation durch gerichtete Lemmata 

∀S:Set(Z).∀m:Z. S≠∅ ⇒ 

max(S,m) ⇔ ∃g:Z. g ∈ S ∧ 

∀S:Set(Z).∀g,m:Z. S={g} ⇒ 

max1(S,g,m) ⇔ false 

∀S:Set(Z).∀g,m:Z. S-g ≠ ∅ ∧ g ∈ S ⇒ 

max1(S,g,m) ⇔ max(S-g,m) ∧ g

LOPS: Konstruktion logischer Programme 

• ∀ entfällt im Programmkopf 

• ∃ entfällt im Programmkörper 

• Disjunktionen werden ersetzt durch einen Aufruf. 

– Der zugehörige Programmkopf wird entsprechend umbenannt 

• Vorbedingungen entfallen 

• Unerfüllbare Teile entfallen 

• Gleichheit wird verschoben in den Programmkopf 

• Funktionsaufrufe werden ersetzt durch prädikative 

Programme mit neuer Ausgabevariable 


LOPS:Integration in allgemeines Konzept – simple Variante 

Ist (D,R,↘) ein wohlfundiertes Rekursionsschema und gilt 

∀x:D.∀g:R. I(x) 

⇔ I base (x,g) ∨ I(x↘g) 

∀x:D.∀g,y,y r :R. DC(x,g) ∧ ¬O(x,g) ∧ g≠y ⇒ 

O(x,y) ⇔ O(x↘g,y r ) ∧ O rec (x,g,y r ,y) 

und sind die folgenden Programme korrekt 

FUNCTION f DC (x:D):R WHERE I(x) RETURNS g SUCH THAT DC(x,g) = f dc (x) 

FUNCTION f BASE (x,g:D×R):R WHERE I base (x) ∧ DC(x,g) ∧ ¬O(x,g) 

RETURNS y SUCH THAT O(x,y) ∧ g≠y = f base (x,g) 

FUNCTION f REC (x,g,y r :D×R×R):R WHERE I(x↘g) ∧ DC(x,g) ∧ ¬O(x,g) ∧ O(x↘g,y r ) 

RETURNS y SUCH THAT g≠y ∧ O rec (x,g,y r ,y) = f rec (x,g,y r ) 

dann ist das folgende rekursive Programm korrekt 


= let g=f dc (x) in if O(x,g) then g 

else if I base (x,g) then f base (x,g) 

else f rec (x,g,f(x↘g)) 

Erweiterung: allgemeines GUESS, komplexere Rekursion, mengenwertige Funktionen 

↦→ Einbettung von LOPS durch Theoreme 

↦→ Strategien = Bestimmung der notwendigen Parameter 


LOPS: Sonstige Strategien 

• Allgemeine Techniken 

– Normalisierung und Simplifikation (gerichtete Lemmata) 

– Unterproblem-Erzeugung (für komplexere Ausdrücke) 

• Unterstützung von GUESS/DOMAIN 

– Preprocessing (Abspaltung von Outputs ohne darstellbare Anteile) 

– GET-RNV: Reduziere die Zahl der Ausgabevariablen 

– GET-SOC: Spalte Ausgabebedingungen 

– CHVAR: Wähle bestgeeigneteste Ausgabevariable 

– DEPEND: Bestimme Abhängigkeiten zwischen den Ausgabevariablen 

• Unterstützung von GET-REC 

– GET-EP: Ersetzung durch auswertbare Prädikate 


LOPS: Preprocessing für GUESS 

• Abspaltung von Eingaben, die kein GUESS erlauben 

– Ausgabewerte ohne darstellbare Anteile (d.h. ¬∃g:G.t(g,y)) 

– zugehörige Eingaben haben einfache Lösungen (aus {y:R | ¬displayable(y)}) 

• Bestimme Prädikat prim mit 

∀x:D. (∃y:R. I(x) ∧ O(x,y) ∧ ¬displayable(y)) ⇒ prim(x) 

∀x:D. I(x) ∧ prim(x) ⇒ ∃y:R. O(x,y) 

Herleitung: Vereinfachung von ∃y:R. I(x) ∧ O(x,y) ∧ ¬displayable(y) 

• Transformation: Zerlege 

∀x:D.∀y:R. I(x) ⇒ P(x,y) ⇔ O(x,y) in 

∀x:D.∀y:R. I(x) ∧ prim(x) ⇒ P(x,y) ⇔ O(x,y) 

∀x:D.∀y:R. I(x) ∧ ¬prim(x) ⇒ P(x,y) ⇔ O(x,y) 


GET-RNV — Reduce Number of Output Variables 

• Anwendbar bei Programmen mit mehreren Ausgabewerten 

• Ziel: Veringere Anzahl der Ausgabevariablen 

– Suche unmittelbare Abhängigkeiten zwischen Variablen 

– Beschreibe Variable als Funktion der anderen 

• ∀x:D.∀(y,y’):R×R’. I(x) ⇒ P(x,(y,y’)) ⇔ O(x,(y,y’)) 

wird transformiert in 

∀x:D.∀(y,y’):R×R’. I(x) ⇒ P(x,(y,y’)) ⇔ P’(x,y) ∧ y’=f(x,y) 

∀x:D.∀y:R. I(x) ⇒ P’(x,y) ⇔ O(x,y,f(x,y)) 

Beispiel: Bestimme das i-t-größte Element einer Menge S 

∀S,i.∀S1,a,S2. i ∈ {1..|S|} ⇒ FIND((S,i),(S1,a,S2)) 

⇔ S=S1∪{a}∪S2 ∧ ∀x ∈ S1.x

GET-SOC — Separate Output Conditions 


– wenn GET-RNV nicht zum Ziel führt 

• Zerlege Output Bedingungen in unabhängige Teile 

∀x:D.∀(y,y’):R×R’. I(x) ⇒ P(x,(y,y’)) ⇔ O(x,(y,y’)) 

wird transformiert in 

∀x:D.∀(y,y’):R×R’. I(x) ⇒ P(x,(y,y’)) ⇔ P 1 

(x,y) ∧ 

∀x:D.∀(y,y’):R×R’. I(x) ⇒ P 1 

(x,y) ⇔ O 1 

(x,y) 

∀x:D.∀(y,y’):R×R’. I(x) ⇒ P 2 

(x,y) ⇔ O 2 

(x,y) 

• Zerlegung geschieht auf rein syntaktischer Basis 

– Aufsammeln von Konjunktionsgliedern, in denen nur y bzw. y’ vorkommt 

P 2 

(x,y’) 


CHVAR — Choose Output-Variable 


– ∀x:D.∀y,y’:R×R’. I(x) ⇒ P(x,(y,y’)) ⇔ O(x,(y,y’)) 

– wenn GET-RNV und GET-SOC nicht zum Ziel führen 

• Versuche hierarchische Lösung: 

– Berechnung des zweiten Ausgabewertes wird Teilproblem bei Berechnung des ersten 

– Guessing zunächst auf ‘äußerer’ Variable 

– Guessing auf ‘innerer’ Variable während Synthese der entstandenen Teilprobleme 

• Lege heuristisch fest, welche Variable zuerst verwendet wird 

– Wähle Guess-Schema für einzelne Ausgabevariablen und führe DOMAIN aus 

– Vergleiche | {y:R | ∃g:G.DC(x,g) ∧ t(g,y)} | 

mit | {y’:R’ | ∃g’:G’.DC’(x,g’) ∧ t’(g’,y’)} | 

– Wähle Variable mit kleinerer Anzahl von Ratemöglichkeiten 


DEPEND — Bestimme Abhängigkeiten der Ausgaben 

• Anwendbar nach CHVAR 

– Bestimme Abhängigkeit der Ausgabevariablen von äußerster Guess-Variable (y) 

– ähnlich wie GET-RNV aber erheblich aufwendiger 

• Nach GUESS auf y suche maximale Bedingung O’(x,g,y,y’), 

die in beiden Teilproblemen lösbar ist 

– Heuristik: größte Menge von Konjunktionsgliedern, in denen y’ vorkommt 

• Synthetisiere separat (mit Eingabevariablen x,g,y!) 

∀x:D.∀g:G.∀y:R.∀y’:R’. 

I(x) ∧ DC(x,g) ⇒ P’(x,g,y,y’) ⇔ O’(x,y,y’) 

• Ersetze im ursprünglichen Problem y’ durch f’(x,g,y) 


GET-EP — Rewrite into Evaluable Predicates 

• Simplifikation: ersetze Konjunktionsglieder der Ausgabeformel 

– suche Konjunktionsglieder, die nicht unmittelbar auswertbar sind 

– ersetze durch äquivalente auswertbare Prädikate 

• Ziel: vereinfachte Erzeugung von (Logik-)Programmen 

– vereinfachter Test auf Auswertbarkeit 

– effizientere Anordnung von Prädikaten im Programm 

• Hilfreich, aber nicht unbedingt notwendig 

Beispiel: Maximum-Simplifikation 

∀S:Set(Z).∀g,m:Z. S≠∅ ∧ g ∈ S ⇒ 

max2(S,g,m) ⇔ m ∈ S ∧ ∀x ∈ S. x≤m ∧ g=m 

Ohne g=m ist ∀x ∈ S. x≤m nicht auswertbar. Ersetze durch ∀x ∈ S. x≤g 

∀S:Set(Z).∀g,m:Z. S≠∅ ∧ g ∈ S ⇒ 

max2(S,g,m) ⇔ ∀x ∈ S. x≤g ∧ g=m 


LOPS: Gesamtstrategie (1) 

Gegeben x:D, y:R, I(x) und O(x,y) 

1. Definiere Prädikat P durch ∀x:D.∀y:R. I(x) ⇒ P(x,y) ⇔ O(x,y) 

– Markiere x als Eingabevariable 

2. GUESS-Phase: 

– Bei mehreren Ausgabevariablen versuche Problemreduktion mit GET-RNV, 

GET-SOC oder CHVAR/DEPEND 

(a) Wähle GUESS-Schema (R, G, displayable, t) aus der Wissensbank 

(b) Enthält R nichtdarstellbare Ausgaben, so spalte diese ab. 

(c) Bestimme DC mit der Heuristik DOMAIN 

(d) Transformiere die Ausgangsformel durch Hinzufügen der geratenen Information. 

(e) Spalte Problem in Teilprobleme und behandle diese einzeln. 

Markiere g als Eingabevariable der neuen Hilfsprädikate. 


LOPS: Gesamtstrategie (2) 

3. Teste Auswertbarkeit und Widersprüchlichkeit heuristisch 

– Heuristik: in wenigen Schritten nachweisbar 

– einfaches Guessing ↦→ trivial lösbare Teilprobleme 

– induktive Datenstrukturen ↦→ widersprüchliche Teilprobleme 

4. GET-REC-Phase 

(a) Wähle Rekursionsschema (D,R,↘) aus der Wissensbank. 

(b) Schreibe Formel um in rekursive Variante der Ausgangsformel: 

∀x:D.∀y:R.∀g:G. I base (x,g) ∨ I(x↘g) ⇒ 

P’(x,g,y) ⇔ ∃y r .O(x↘g,y r ) ∧ O rec (x,g,y r ,y) 

(c) Spalte nichtrekursiven Lösungen (I base ) ab. 

Ersetze Konjunktionsglieder aus O durch P. 

5. Vereinfache Formeln soweit wie möglich und teste Auswertbarkeit 

– Starte LOPS erneut, wenn Formel nicht auswertbar 

6. Extrahiere aus der rekursiven Formel ein Programm 


LOPS Strategie: Sortieralgorithmus 

FUNCTION sort(L:Seq(Z)):Seq(Z) RETURNS S 

SUCH THAT rearranges(L,S) ∧ ordered(S) 

1. Definiere: ∀L,S:Seq(Z). true ⇒ SORT(L,S) ⇔ rearranges(L,S) ∧ ordered(S) 

2.(a) Wähle GUESS-Schema G ≡ Z, displayable(S) ≡ S≠[], t(g,S) ≡ g=first(S) 

(b) ∃S:Seq(Z). SORT(L,S) ∧ ¬(S≠[]) ⇒ L=[] ≡ prim(L) 

(c) ∃S:Seq(Z). L≠[] ∧ SORT(L,S) ∧ g=first(S) ⇒ g ∈ L ∧ ∀x ∈ L.x≥g 

Lösungsfunktion für DC(L,g): λL. min(L) 

(d) Teilprobleme: 

Automatisierte Logik und Programmierung 236 LOPS 

B.2.26.1 

B.2: 9.3/26.3/26.12/ordered 

g ∈ L ∧ ∀x ∈ L.x≥g ⇒ SORT 1 

(L,g,S) ⇔ rearranges(L,S) ∧ ordered(S) ∧ g=first(S) 

g ∈ L ∧ ∀x ∈ L.x≥g ⇒ SORT 2 

(L,g,S) ⇔ rearranges(L,S) ∧ ordered(S) ∧ g≠first(S) 

3. Teilproblem SORT 2 

ist unerfüllbar 

4.(a) Rekursionsschema für Seq(Z)×Z: L↘g ≡ L-g 

(b) g ∈ L ∧ ∀x ∈ L.x≥g ⇒ SORT 1 

(L,g,S) ⇔ ∃S’:Seq(Z).SORT(L-g,S’) ∧ S=g.S’ 

Funktion für Rekursionsanpassung: λL,g,S’. g.S’ 

B.2: 26.15/3.2/2.3/25.2/fold SORT 

5. L = [] ⇒ SORT(L,S) ⇔ S=[] auswertbar 

L≠[] ⇒ SORT(L,S) ⇔ ∃g:Z. g ∈ L ∧ ∀x ∈ L.x≥g ∧ SORT 1 

(L,g,S) auswertbar 

g ∈ L ∧ ∀x ∈ L.x≥g ⇒ SORT 1 

(L,g,S) ⇔ ∃S’:Seq(Z).SORT(L-g,S’) ∧ S=g.S’ auswertbar 

6. Funktionale Lösung 

FUNCTION sort(L:Seq(Z)):Seq(Z) RETURNS S SUCH THAT rearranges(L,S) ∧ ordered(S) 

= if L=[] then [] else let g=min(L) in g.sort(L-g)


Lektion 19 

Algorithmentheorien 

1. Übersicht 

2. Grundkonzepte 

3. Allgemeines Verfahren

Synthese mit Algorithmenschemata 

• Historisch: High-Level Transformation 

– Erzeuge lauffähigen Algorithmus in einem Schritt – Optimiere nachträglich 

• Vorarbeiten: Strukturanalyse für algorithmische Klasse 

– Identifizierung von Komponenten und Axiomen 

– Korrektheitsbeweis für abstraktes Algorithmenschema 

– Erstellung von konkreten (partiellen) Standardlösungsstrukturen 

+ Techniken zur Verfeinerung von Standardlösungen 

• Syntheseprozeß: 

– Bestimmung der fehlenden Komponenten 

– Nachweis der Axiome 

– Instantiierung des Algorithmenschemas 

• Forschung: Formalisierung als algebraische Theorien 

– 3 Ebenen: Allgemeines Konzept — algorithmische Theorien — konkrete Probleme 

– Entwurf spezialisierter Strategien für jede Algorithmenklasse 

Automatisierte Logik und Programmierung 238 Algorithmentheorien

Algorithmenschemata: Literatur 

Douglas R. Smith and Michael R. Lowry 

Algorithm Theories and Design Tactics, 

Science of Computer Programming 14:305–321 

Douglas R. Smith 

KIDS — A Knowledge-Based Software Development system, 

in: Michael R. Lowry and Robert D. McCartney, ed. 

Automating Software Design, AAAI Press, 1991, p.483–514. 


Top-Down Synthesis of Divide-and-Conquer Algorithms, AIJ 27:43–96, 1985 


Structure and Design of Global Search Algorithms 

Structure and Design of Problem Reduction Generators 

Structure and Design of Dynamic Programming Algorithms 

Technical Report, Kestrel Institute 

Michael R. Lowry 

Structure and Design of Local Search Algorithms 

Proceedings, AAAI Workshop on Software Design, p.88–94 


Algebraische Theorien – Grundbegriffe 

• Formale Theorie: Tripel T = (S, Ω, Ax) 

– S: Menge von Sortennamen (Namen für Datentypen) 

– Ω: Familie von Operationsnamen (zusammen mit Typisierung) 

– Ax: Menge von Axiomen für Datentypen und Operationen 

• Struktur für T : 

– Menge von Datentypen und Operationen, typisiert gemäß Ω 

• Modell für T : 

– Struktur T , die alle Axiome aus T erfüllt 

• Theorie T 1 erweitert T 2 : 

– Sortennamen, Operationsnamen und Axiome von T 2 existieren auch in T 1 

Struktur T 1 erweitert T 2 : 

– Datentypen und Operationen von T 2 existieren auch in T 1 

(gleiche Typisierung bezüglich T 2 !) 


Algorithmenschemata als algebraische Theorien 

• T SPEC : algebraische Theorie der Spezifikationen 

– ({D,R}, {I:D→B, O:D×R→B}, ∅) 

P Problemtheorie: 

– P erweitert T SPEC (P enthält Programmspezifikation) 

• T PROG : algebraische Theorie der Programme 

– ( {D,R}, {I: D→B, O: D×R→B, body: D↛R}, { ∀x:D. I(x) ⇒ O(x,body(x)) } ) 

P Programmtheorie: 

– P erweitert T PROG 

• A Algorithmentheorie: 

– Problemtheorie mit kanonischer Erweiterung zu Programmtheorie 

– Es gibt abstraktes Programmschema BODY mit der Eigenschaft 

(spec A ,BODY(A)) korrekt für jedes Modell A von A 

“Für jedes Modell A existiert Standardlösung der Spezifikation spec A ” 


Algorithmenschemata: Syntheseverfahren 

Satz: Spezifikation spec = (D,R,I,O) ist erfüllbar, wenn es eine Algorithmentheorie A 

und ein Modell A für A gibt, welches die Struktur Tspec = ({D,R}, {I,O}) erweitert 

Methode: 

– Wähle Algorithmentheorie A, 

– erweitere Tspec zu Modell A von A 

– Instantiiere BODY(A) und extrahiere Programmkomponenten 

Theorie-Erweiterung: 

Komponenten+Axiome 

✟ ✟✟✟✟✟✟✟✟✟✟✟✯ 

T SPEC 

✟✟ 

✟ ✟✟ 

✟✟ 

✟✟ 

Tspec 

Spezifikation 

A 

A 

Modell 

Erweiterung: 

Komponentensuche 

Kanonische Theorie-Erweiterung: BODY + Korrektheitsaxiom 

Erweiterung mit BODY(A) 

Synthese 

T PROG 

✲ 

✲ 

✟ ✟✟✟✟✟✟✟✟✟✟✟✯ 

✲ 

✟✙ 

✟ 

✟✟ 

✟✟ 

✟✟ 

✟✟ 

Tprog 

Programm 

P 

P 

Programmkonstruktion: 

Extraktion relevanter Komponenten 


Algorithmenschemata: Verfeinertes Syntheseverfahren 

spec reduzierbar auf spec ′ : 

– Eingabebedingung (nach Transformation) stärker, Ausgabebedingung schwächer 

– ∀x:D. I(x) ⇒ ∃x’:D’. I’(x) ∧ ∀y’:R’. O(x’,y’) ⇒ ∃y:R.O(x,y) 

Satz: spec = (D,R,I,O) ist erfüllbar, wenn es eine Algorithmentheorie 

A und ein Modell A für A gibt, so daß spec reduzierbar auf spec A 

⇓ 

Methode: “Operator match” 

– Wähle Algorithmentheorie A und allgemeines Modell A von A 

– Zeige: spec reduzierbar auf spec A ↦−→ Substitutionen σ und θ 

– Spezialisiere body(A) zu λx. σ(x,body(A)(θ(x))) 


Verfeinertes Syntheseverfahren für mengenwertige Probleme 

spec ′ generalisiert spec: 

– Eingabebedingung (nach Transformation) und Ausgabebedingung schwächer 

– ∀x:D. I(x) ⇒ ∃x’:D’. I’(x) ∧ ∀y:R. O(x,y) ⇒ O’(x’,y) 

Satz: 

FUNCTION F(x:D):Set(R) WHERE I(x) RETURNS { z | O(x,z)} 

ist erfüllbar, wenn es eine Algorithmentheorie A und ein Modell 

A für A gibt, so daß gilt: spec A generalisiert (D,R,I,O) 

Methode: 

⇓ 

– Wähle Algorithmentheorie A und allgemeines Modell A von A 

– Zeige: spec A generalisiert (D,R,I,O) ↦−→ Substitution θ:D→D A 

– Spezialisiere body(A) zu λx. { y | y ∈ body(A)(θ(x)) ∧ O(x,y) } 

(Optimierte Verfahren für spezielle Algorithmentheorien möglich) 


Algorithmenschemata: Vorteile für Syntheseverfahren 

1. Effizientes Syntheseverfahren 

– Theoretische Untersuchungen entlasten Syntheseprozeß zur Laufzeit 

↦→ Beweislast verlagert in Entwurf und Beweis der Algorithmentheorien 

– Verfeinerung vorgefertigter Teillösungen (Modelle) möglich 

↦→ zielgerichtetes Vorgehen, Verifikation der Axiome entfällt 

– Echte Kooperation zwischen Mensch und Computer 

Mensch: Entwurfsentscheidungen — Computer: formale Details 

2. Erzeugung effizienter Algorithmen 

– Vorgabe einer effizienten Grundstruktur durch Theoreme 

– Individuelle Optimierung nachträglich 

3. Wissensbasiertes Vorgehen 

– Erkenntnisse über Algorithmen als Theoreme verwendbar 

4. Formales theoretisches Fundament ↦→ leicht integrierbar 



Lektion 20 

Globalsuchalgorithmen 

1. Grundform 

2. Filter 

3. Synthesestrategie 

4. Integration in formales Konzept

Globalsuch-Algorithmen: Suche alle Lösungen eines Problems 

Grundstruktur: Manipulation von Kandidatenmengen 


= if Φ(x,s 0 

(x)) then F gs (x,s 0 

(x)) else ∅ 

FUNCTION F gs (x,s:D×S):Set(R) WHERE I(x) ∧ J(x,s) ∧ Φ(x,s) 

RETURNS { z | O(x,z) ∧ sat(z,s)} 

= { z | z ∈ ext(s) ∧ O(x,z) } ∪ ⋃ { F gs (x,t) | t ∈ split(x,s) ∧ Φ(x,t) } 

• Deskriptoren s ∈ S für Kandidatenmengen 

J(x,s) : s sinnvoll für x — sat(z,s) : z gehört zur “Menge” s 

• Initialdeskriptor s 0 

(x) ∈ S – umfaßt alle Lösungen 

• Direkte Extraktion ext(s) ∈ Set(R) von Lösungskandidaten 

• Suche: rekursive Aufspaltung split(x,s) ∈ Set(S) von Deskriptoren 

• notwendige Filter Φ(x,s) – Elimination unnötiger Deskriptoren 

↦→ Verallgemeinerung von Binärsuche, Backtracking, . . . 

Vollständig: jede berechenbare Funktion beschreibbar 

Automatisierte Logik und Programmierung 247 Globalsuchalgorithmen

Globalsuch-Algorithmen (Grundform): Korrektheit 

FUNCTION F(x:D):Set(R) WHERE I(x) RETURNS { z | O(x,z)} = F gs (x,s 0 

(x)) 

FUNCTION F gs (x,s:D×S):Set(R) WHERE I(x) ∧ J(x,s) RETURNS { z | O(x,z) ∧ sat(z,s)} 

= { z | z ∈ ext(s) ∧ O(x,z) } ∪ ⋃ { F gs (x,t) | t ∈ split(x,s) } 

ist korrekt, wenn 5 Axiome erfüllt sind 

1. Initialdeskriptor ist sinnvoll 

– I(x) ⇒ J(x,s 0 

(x)) 

2. Splitting sinnvoller Deskriptoren liefert sinnvolle Deskriptoren 

– I(x) ∧ J(x,s) ⇒ ∀t ∈ split(x,s). J(x,t) 

3. Initialdeskriptor enthält alle Lösungen 

– I(x) ∧ O(x,z) ⇒ sat(z,s 0 

(x)) 

4. Alle Lösungen in endlich vielen Schritten extrahierbar 

– I(x) ∧ J(x,s) ∧ O(x,z) ⇒ sat(z,s) ⇔ ∃k:N.∃t ∈ split k (x,s). z ∈ ext(t) 

5. Splitting nur endlich oft durchführbar (Wohlfundiertheit) 

– I(x) ∧ J(x,s) ⇒ ∃k:N. split k (x,s) = ∅ 

G=((D,R,I,O), S,J,s 0 

,sat,split,ext) wohlfundierte Globalsuchtheorie 


Globalsuch-Algorithmen (Grundform): Korrektheitsbeweis 

FUNCTION F(x:D):Set(R) WHERE I(x) RETURNS { z | O(x,z)} = F gs (x,s 0 

(x)) 

FUNCTION F gs (x,s:D×S):Set(R) WHERE I(x) ∧ J(x,s) RETURNS { z | O(x,z) ∧ sat(z,s)} 

= { z | z ∈ ext(s) ∧ O(x,z) } ∪ ⋃ { F gs (x,t) | t ∈ split(x,s) } 

• Korrektheit von F folgt aus Korrektheit von F gs mit Axiom 3 (& 1): 

I(x) ∧ J(x,s 0 

(x)) ⇒ { z | O(x,z) ∧ sat(z,s 0 

(x))} = { z | O(x,z) } 

• Partielle Korrektheit von F gs folgt aus Axiom 4 (& 2): 

Def.: split k (x,s) ≡ if k=0 then {s} else ⋃ {split k−1 (x,t) | t ∈ split(x,s)} 

Satz: Hält F gs (x,s) nach i Schritten an (split i (x,s) = ∅), so ist das Resultat 

⋃ 

{ {z | z ∈ ext(t) ∧ O(x,z)} | t ∈ 

⋃ 

{split j (x,s) | j ∈ {0..i-1} } } 

(Lösungen, die extrahierbar sind aus Deskriptoren, die zu einem split j (x,s) mit j

Synthese von Globalsuch-Algorithmen: Hilfsmittel 

• Globalsuchtheorie G: allgemeine Suchstruktur für R 

– G=((D,R,I,O), S,J,s 0 

,sat,split,ext) erfüllt Axiome 1-4 

• Filter Φ: verfeinert split-Operation 

– split Φ (x,s) ≡ {t | t ∈split(x,s) ∧Φ(x,t)} 

vorgefertigt in Wissensbank 

Wohlfundiertheit: split Φ terminiert ( ˆ= Axiom 5) 

vorgefertigt in Wissensbank 

Notwendig: keine Lösung wird eliminiert (↦→ Axiom 4) 

– Φ(x,s) ⇐ ∃z:R. sat(z,s) ∧O(x,z) zur Laufzeit prüfen, heuristisch ergänzen 

Effizienzsteigerung durch starke notwendige Filter möglich 

• Spezialisierungsmechanismus für G und Φ 

– Wähle G passend zum Ausgabebereich der Spezifikation spec = (D,R,I,O) 

– Zeige: G generalisiert spec ↦−→ Substitution θ:D→D G 

– modifiziere G und Φ mit θ zu wohlfundierter Globalsuchtheorie für spec 


GS-theorie: Folgen L von Elementen einer endlichen Menge S⊆α 

Suche ˆ= Aufzählung der Präfixe einer Folge 

• Deskriptormengen: Folgen mit gemeinsamem Präfix V 

• Splitting: Verlängern der Präfixsequenz 

• Extraktion: Gesamte Präfixsequenz 

gs seq set(α) ≡ D ↦→ Set(α) 

R ↦→ Seq(α) 

I ↦→ λS. true 

O ↦→ λS, L. range(L)⊆S 

S ↦→ Seq(α) 

J ↦→ λS, V. range(V)⊆S 

s 0 

↦→ λS. [] 

sat ↦→ λL, V. V⊑L 

split ↦→ λS, V. {V·i|i ∈ S} 

ext ↦→ λV. {V} 

✁ . . . . 

x 1 

x 1 

... x 2 

x 1 

... x 3 

x 1 

... x 4 x 1 

... 

❅ ❆ 

❅❆ 

❅ ❆ 

❅ 

❅ ❆ 

❅ 

❅ ❆ 

❅ 

✁ . . . 

❅❆ 

✁✁ 

❅❆ 

✁✁ 

❅❆ 

✁✁ 

❅❆ 

✁ 

x 1 

x 2 

x 3 

x 4 x 5 ... 

❳ ❳❳❳❳ ❍ 

❳ 

❍ ❳❳❳ ❍ 

❍ 

❍❳ 

✟✘✘ ✟✟✟✟ ✘ ✘✘✘ ✘ 

[] 


Wohlfundiertheitsfilter für gs seq set(α) 

• Φ 1 (S,V) = |V|≤k 

– Längenbegrenzung absolut 

– Test einfach, Terminierung nach k Schritten, Baumgröße |S| k 

• Φ 2 (S,V) = |V|≤k*|S| 

– Längenbegrenzung relativ zur Größe von S 

– Test einfach, Terminierung nach k*|S| Schritten, Baumgröße |S| k∗|S| 

• Φ 3 (S,V) = nodups(V) 

– Folgen ohne doppelte Elemente 

– Test aufwendiger, Terminierung nach |S| Schritten, Baumgröße |S| ! 


Spezialisierung von gs seq set(Z) und Φ 3 

Spezialisiere gs seq set(Z) und Φ 3 auf das Costas-Arrays Problem 

FUNCTION Costas (n:Z):Set(Seq(Z)) WHERE n≥1 

RETURNS {p | perm(p,{1..n}) ∧ ∀j ∈ domain(p).nodups(dtrow(p,j))} 

1. Ausgabebereich R stimmt mit R G =Seq(Z) überein 

2. Eingabebereiche D=Z und D G =Set(Z) sind anzupassen 

3. Keine Eingabebedingung zu prüfen, da I G (S)=true. 

4. Zeige ∀n:Z. n≥1 ⇒ ∃S:Set(Z). ∀p:Seq(Z). O(n,p) ⇒ range(p)⊆S 

– Heuristik: Suche Folgerungen von O(n,p), in denen range(p) vorkommt 

– Auffalten von perm liefert: perm(p,{1..n}) ⇒ range(p)⊆ {1..n} 

– Wähle S:={1..n} 

5. Modifiziere gs seq set(Z) und Φ 3 mit θ:=λn.{1..n} und (D,R,I,O) 

G θ 

= ((D,R,I,O), 

Seq(Z),λn,V.range(V)⊆{1..n},λn.[], sat,λn,V.{V·i|i ∈ {1..n}},ext) 

Φ 3,θ (n,V) = Φ 3 ({1..n},V) = nodups(V) notwendig für G θ ! 


Globalsuchalgorithmen: allgemeine Synthesesestrategie 

Gegeben eine Problemspezifikation 

FUNCTION F(x:D):Set(R) WHERE I(x) RETURNS {y:R | O(x,y)} 

1. Wähle Globalsuchtheorie G mit Ausgabetyp R (Wissensbank) 

2. Beweise ‘G generalisiert (D,R,I,O)’ 

Extrahiere Substitution θ aus dem Beweis und berechne G θ 

3. Wähle wf-Filter Φ für G (Wissensbank) 

Beweise ‘Φ θ notwendig für G θ ’ 

4. Bestimme zusätzlichen notwendigen Filter Ψ für G θ 

– Eigenschaften von x und s, die leicht aus sat(z,s) ∧ O(x,z) ableitbar sind 

5. Instantiiere schematischen Globalsuchalgorithmus für G Φ,θ,Ψ 


= if Φ(θ(x),s 0 

(θ(x))) ∧ Ψ(x,s 0 

(θ(x))) then F gs (x,s 0 

(θ(x))) else ∅ 

FUNCTION F gs (x,s:D×S):Set(R) WHERE I(x) ∧ J(x,s) ∧ Φ(θ(x),s) ∧ Ψ(x,s) 

RETURNS { z | O(x,z) ∧ sat(z,s)} 

= {z | z ∈ ext(s) ∧ O(x,z)} ∪ ⋃ {F gs (x,t) | t ∈ split(θ(x),s) ∧ Φ(θ(x),t) ∧ Ψ(x,t)} 


Globalsuchalgorithmen: Costas Arrays Synthese 

FUNCTION Costas (n:Z):Set( Seq(Z) ) WHERE n≥1 


1. Wähle die Globalsuchtheorie G = gs seq set(Z) 

2. Beweis für ‘G generalisiert (D,R,I,O)’ liefert θ(n) := {1..n} 

3. Wähle wf-Filter Φ so, daß ‘Φ θ notwendig für G θ ’ beweisbar 

perm(p,{1..n}) ∧ ∀j ∈ domain(p).nodups(dtrow(p,j)) ∧ V⊑ p ⇒ Φ({1..n},V) 

Leicht beweisbar nur für Φ 3 (S,V) := nodups(V) 

4. Aus perm(p,{1..n}) ∧ ∀j ∈ domain(p).nodups(dtrow(p,j)) ∧ V⊑p 

leite ab Ψ(n,V) := ∀i ∈ domain(V).nodups(dtrow(V,j)) 

5. Instantiiere den Standard-Globalsuchalgorithmus 



= if nodups([]) ∧ ∀j ∈ domain([]).nodups(dtrow([],j)) then Costas gs (n,[]) else ∅ 

FUNCTION Costas gs (n:Z,V:Seq(Z)):Set( Seq(Z) ) 


RETURNS {p | perm(p,{1..n}) ∧ V⊑p ∧ ∀j ∈ domain(p).nodups(dtrow(p,j))} 


∪ ⋃ { Costas gs (n,W) | W ∈ {V·i|i ∈ {1..n}} ∧ nodups(W) ∧ ∀j ∈ domain(W).nodups(dtrow(W,j))} 


Globalsuch-Strategie: Integration in formales Konzept 

• Formalisiere Grundkonzepte als Definitionen 

– Globalsuchtheorie: Datenstruktur + Axiome 

– Generalisierungseigenschaft 

– Filter: Datenstruktur, Wohlfundiertheit, Notwendigkeit 

– Verfeinerung und Spezialisierung 

• Formalisiere vorgefertigte Objekte als Lemmata 

– konkrete Globalsuchtheorien (mit Nachweis der Axiome) 

– Wohlfundiertheitsfilter für existierende Globalsuchtheorien (mit Nachweis) 

• Beweise Theorem über Globalsuchalgorithmen 

– Erfüllbarkeit folgt aus Existenz von G, θ, Φ und Ψ sowie Axiomen 

• Schreibe Taktik zur Anwendung des Theorems 

– Matching, Instantiierung, Suche in der Wissensbank 


Globalsuch-Strategie: Formalisierung der Grundkonzepte 

GS ≡ spec:SPEC × S:TYPES × D×S→B × ... 

split k ≡ natind(k; λx,s.{s}; n,sp n 

. λx,s. ⋃ {sp n 

(x,t)|t ∈ split(x,s)}) 

G is a GS-theory 

≡ let ((D,R,I,O), S, J, s 0 

, sat, split, ext) = G in 

∀x:D. I(x) ⇒ s 0 

(x) hält ∧ J(x,s 0 

(x)) 

∧ ∀x:D.∀s:S. I(x) ∧ J(x,s) ⇒ ∀t ∈ split(x,s).J(x,t) 

∧ ∀x:D.∀z:R. I(x) ∧ O(x,z) ⇒ sat(z,s 0 

(x)) 

∧ ∀x:D.∀s:S. I(x) ∧ J(x,s) ⇒ ∀z:R.O(x,z) ⇒ 

sat(z,s) ⇔ ∃k:N.∃t ∈ split k (x,s). z ∈ ext(t) 

Filters(G) ≡ let..=G in D×S→B 

split Φ ≡ λx,s. { t | t ∈ split(x,s) ∧ Φ(x,t) } 

Φ necessary for G 

≡ let..=G in ∀x:D.∀s:S. ∃z:R. sat(z,s) ∧ O(x,z) ⇒ Φ(x,s) 

Φ wf-filter for G 

≡ let..=G in ∀x:D.∀s:S. I(x) ∧ J(x,s) ⇒ ∃k:N. split k Φ (x,s) = ∅ 

G generalizes spec with θ 

≡ let..=G and (D’,R’,I’,O’)=spec in 

R’⊂R ∧ ∀x:D’. I’(x) ⇒ I(θ(x)) ∧ ∀z:R’. O’(x,z) ⇒ O(θ(x),z) 

Φ θ ≡ λx,s.Φ(θ(x),s) 

G θ (spec) 

≡ let..=G in ( spec, S, λx,s.J(θ(x),s), λx.s 0 

(θ(x)), sat, λx,s.split(θ(x),s), ext ) 


Globalsuch-Strategie: Formalisierung als Theorem 

∀spec=(D,R,I,O):SPEC. 

FUNCTION F(x:D):Set(R) WHERE I(x) RETURNS {z | O(x,z)} ist erfüllbar 

⇐ ∃G:GS. G is a GS-Theory 

∧ ∃θ:D↛D G . G generalizes spec with θ 

∧ ∃Φ:Filters(G). Φ wf-filter for G ∧ Φ θ necessary for G θ (spec) 

∧ ∃Ψ:Filters(G θ (spec)). Ψ necessary for G θ (spec) 

Beweis: 

Gegeben: G = ((D’,R’,I’,O’), S, J, s 0 

, sat, split, ext), θ, Φ, und Ψ. 

Lösungsprogramm: Instantiierung des Standard-Globalsuchalgorithmus 

letrec f gs (x,s) = { z | z ∈ ext(s) ∧ O(x,z) } 

∪ ⋃ { f gs (x,t) | t ∈ split(θ(x),s) ∧ Φ(θ(x),t) ∧ Ψ(x,t) } 

in 

if Φ(θ(x),s0 (θ(x))) ∧ Ψ(x,s 0 

(θ(x))) then f gs (x,s 0 

(θ(x))) else ∅ 

Korrektheit: Formalisierung des informalen Beweises mit NuPRL 


Globalsuch-Strategie: Synthese ˆ= Anwendung des Theorems 

1. Formuliere Syntheseproblem als Beweisziel 

⊢ FUNCTION F(x: D ):Set( R ) WHERE I(x) RETURNS {z | O(x,z) } 

ist erfüllbar 

2. Wende Synthesetheorem an wie eine Inferenzregel 

3. Als Unterziel bestimme G, θ, Φ und Ψ. 

(a) Wähle GS-theorie G aus Wissensbank (enthält 6-10 GS-theorien) 

mit Bildbereich R oder einer Obermenge davon 

(b) Bestimme Substitution θ 

Direkt oder Extraktion aus konstruktivem Beweis der Generalisierung 

(c) Wähle wf-filter Φ für G aus Wissensbank 

(3-4 Möglichkeiten) 

Zeige: Φ θ notwendig für G θ (spec) 

(d) Bestimme zusätzlichen Filter Ψ heuristisch 

Eigenschaften von x und s, die leicht aus sat(z,s) ∧ O(x,z) ableitbar sind 

⇒ ENDE: System extrahiert Instanz des Standard-Globalsuchalgorithmus 


Formale Costas Arrays Synthese: Zentraler Schritt 

# top 

⊢ FUNCTION Costas(n:Z):Set( Seq(Z) ) WHERE n≥1 

RETURNS {p | perm(p,{1..n}) ∧ ∀j ∈ dom(p).nodups(dtrow(p,j))} 

ist erfüllbar 

BY call ‘GS-theorem‘ 

1. ⊢ ∃G. G is a GS-Theory 

∧ ∃θ. G generalizes spec with θ 

∧ ∃Φ. Φ wf-filter for G ∧ Φ θ necessary for G θ (spec) 

∧ ∃Ψ. Ψ necessary for G θ (spec) 

where spec = ( Z, Seq(Z), λn. n≥1, 

λn,p. perm(p,{1..n}) ∧ ∀j ∈ dom(p).nodups(dtrow(p,j)) ) 

Typinformation zugunsten der Lesbarkeit unterdrückt (Display-Mechanismus) 

Restliche Aufgabe: Bestimmung von G, θ, Φ und Ψ. 

– Extraktion des Algorithmus automatisch nach Lösung dieses Ziels 


Formale Costas Arrays Synthese: Wahl der GS-Theorie 

# top 1 

⊢ ∃G. G is a GS-Theory 

∧ ∃θ. G generalizes spec with θ 

∧ ∃Φ. Φ wf-filter for G ∧ Φ θ necessary for G θ (spec) 

∧ ∃Ψ. Ψ necessary for G θ (spec) 


λn,p. perm(p,{1..n}) ∧ ∀j ∈ dom(p).nodups(dtrow(p,j)) ) 

BY ex i gs seq set(Z) THEN unfold ‘perm‘ 

1. ⊢ gs seq set(Z) is a GS-Theory 

2. ⊢ ∃θ. gs seq set(Z) generalizes spec with θ 

∧ ∃Φ. Φ wf-filter for gs seq set(Z) 

∧ Φ θ necessary for gs seq set(Z) θ (spec) 

∧ ∃Ψ. Ψ necessary for gs seq set(Z) θ (spec) 


λn,p. nodups(p) ∧ range(p)={1..n} ∧ ∀j ∈ dom(p).nodups(dtrow(p,j)) ) 

Teilziel 1 ˆ= Lemma der Wissensbank 


# top 1 2 

Formale Costas Arrays Synthese: Substitution θ 

⊢ ∃θ. gs seq set(Z) generalizes spec with θ 

∧ ∃Φ. Φ wf-filter for gs seq set(Z) 

∧ Φ θ necessary for gs seq set(Z) θ (spec) 

∧ ∃Ψ. Ψ necessary for gs seq set(Z) θ (spec) 



BY ex i 

λn.{1..n} 

1. ⊢ gs seq set(Z) generalizes spec with λn.{1..n} 

where spec = ...... 

2. ⊢ ∃Φ. Φ wf-filter for gs seq set(Z) 

∧ Φ θ necessary for gs seq set(Z) λn.{1..n} (spec) 

∧ ∃Ψ. Ψ necessary for gs seq set(Z) λn.{1..n} (spec) 


Teilziel 1 lösbar durch einfachen Beweiser 


Formale Costas Arrays Synthese: Filter Φ 

# top 1 2 2 

⊢ ∃Φ. Φ wf-filter for gs seq set(Z) 

∧ Φ θ necessary for gs seq set(Z) λn.{1..n} (spec) 

∧ ∃Ψ. Ψ necessary for gs seq set(Z) λn.{1..n} (spec) 



BY ex i λS,V.nodups(V) 

1. ⊢ λS,V.nodups(V) wf-filter for gs seq set(Z) 

2. ⊢ λn,V.nodups(V) necessary for gs seq set(Z) λn.{1..n} (spec) 


3. ⊢ ∃Ψ. Ψ necessary for gs seq set(Z) λn.{1..n} (spec) 


Teilziel 1 ˆ= Lemma der Wissensbank 


Formale Costas Arrays Synthese:Φ θ notwendig/Wahl von Ψ 

# top 1 2 2 2 

⊢ λn,V.nodups(V) necessary for gs seq set(Z) λn.{1..n} (spec) 



BY undo abstractions THEN unfold ‘specialize‘ THEN unfold ‘necessary‘ 

1. ⊢ ∀n.∀V. ∃p. nodups(p) ∧ range(p)={1..n} ∧ ∀j ∈ dom(p).nodups(dtrow(p,j)) ∧ V⊑p 

⇒ nodups(V) 

* BY Prover 

# top 1 2 2 3 

⊢ ∃Ψ. Ψ necessary for gs seq set(Z) λn.{1..n} (spec) 


(Prover zerlegt logisch und konsultiert dabei Fakten der Wissensbank) 

BY undo abstractions THEN unfold ‘specialize‘ THEN unfold ‘necessary‘ 

1. ⊢ ∃Ψ.∀n.∀V. ∃p. nodups(p) ∧ range(p)={1..n} ∧ ∀j ∈ dom(p).nodups(dtrow(p,j)) ∧ V⊑p 

⇒ Ψ(n,V) 

* BY ex i λn,V. ∀j ∈ dom(V).nodups(dtrow(V,j) THEN Prover 


Costas Arrays: generiertes ausführbares Programm 

FUNCTION Costas(n:Z):Set( Seq(Z) ) WHERE n≥1 


is 

letrec Costas gs (n,V) = 

{ p | p ∈ {V} ∧ perm(p,{1..n}) ∧ ∀j ∈ dom(p).nodups(dtrow(p,j))} 

∪ ⋃ { Costas gs (n,W) | W ∈ {V·i|i ∈ {1..n}} ∧ nodups(W) 

in 

if nodups([]) ∧ ∀j ∈ dom([]).nodups(dtrow([],j)) 

then Costas gs (n,[]) else ∅ 

∧ ∀j ∈ dom(W).nodups(dtrow(W,j)) } 

Nach elementaren Optimierungen 

(weitere sind möglich) 

FUNCTION Costas(n:Z):Set( Seq(Z) ) WHERE n≥1 


is 

letrec Costasgs (n,V) = 

(if perm(V,{1..n}) ∧ ∀j ∈ dom(V).nodups(dtrow(V,j)) then {V} else ∅) 

∪ ⋃ { Costas gs (n,V·i) | i ∈ {1..n} ∧ nodups(V·i) ∧ ∀j ∈ dom(V·i).nodups(dtrow(V·i,j)) } 

in 

Costas gs (n,[]) 



Lektion 21 

Weitere Designstrategien 

1. Divide & Conquer Algorithmen 

2. Lokalsuch-Algorithmen 

3. Algorithmentaxonomie

Divide & Conquer Algorithmen 

Grundstruktur: Problemreduktion durch Dekomposition 

FUNCTION F(x:D):R WHERE I(x) RETURNS y SUCH THAT O(x,y) 

= if primitive(x) then Directly-solve(x) 

else (Compose ◦ G×F ◦ Decompose) (x) 

• Dekomposition Decompose(x) von Eingaben in Teilprobleme 

• Rekursiver Aufruf F(y) — Hilfsfunktion G(y’) 

– Zusammengesetzt zu G×F ≡ λy’,y.(G(y’),F(y)) 

• Bottom-up Komposition Compose(z,z’) von Teillösungen 

– Notation: f◦g ≡ λx. f(g(x)) 

• Direkte Lösung Directly-solve(x) für ‘primitive’ Teilprobleme 

• Kontrollprädikat primitive(x) 

Automatisierte Logik und Programmierung 267 Divide & Conquer Algorithmen

Divide & Conquer Algorithmen: Korrektheit 





1. Direkte Lösung Directly-solve(x) erfüllt O für primitive Eingaben 

– FUNCTION F p (x:D):R WHERE I(x) ∧ primitive(x) RETURNS y SUCH THAT O(x,y) 

2. ‘Strong Problem Reduction Principle’: 

– Ausgabebedingung O rekursiv zerlegbar in O D , O’ und O C 

O D (x,y’,y) ∧ O(y,z) ∧ O’(y’,z’) ∧ O C (z,z’,t) ⇒ O(x,t) 

3. Dekomposition Decompose(x) erfüllt O D und ‘verkleinert’ Problem 

– FUNCTION F d (x:D):D’×D WHERE I(x) ∧ ¬primitive(x) 

RETURNS y’,y SUCH THAT I’(y’) ∧ I(y) ∧ x≻y ∧ O D (x,y’,y) 

4. Komposition Compose(z,z’) erfüllt O C 

– FUNCTION F c (z,z’:R×R’):R RETURNS t SUCH THAT O C (z,z’,t) 

5. Hilfsfunktion G(y’) erfüllt O’ 

– FUNCTION F G (y’:D’):R’ WHERE I’(y’) RETURNS z’ SUCH THAT O’(y’,z’) 

6. Verkleinerungsrelation ≻ ist wohlfundierte Ordnung auf D 


Divide & Conquer Algorithmen: Korrektheitsbeweis 




• Partielle Korrektheit: strukturelle Induktion über (D,≻) 

– Primitive Eingaben: 

– F(x) = Directly-solve(x) — Korrektheit folgt aus Axiom 1 

– Nichtprimitive Eingaben: 

– F(x) = (Compose ◦ G×F ◦ Decompose) (x) 

– Decompose(x) liefert y’,y mit O D (x,y’,y) und x≻y Axiom 3 

– G(y’) liefert z’ mit O’(y’,z’) Axiom 5 

– F(y) liefert z mit O(y,z) Induktionsannahme 

– Compose(z,z’) liefert t mit O C (z,z’,t) Axiom 4 

– Für t gilt O(x,t) und es ist t=F(x) Axiom 2 

• Terminierung: Wohlfundiertheit von ≻ (Axiom 6) 


Divide & Conquer Algorithmen: Synthesestrategie 

Zerlege Problem in Spezifikationen für Teilprobleme 

Gegeben: 


1. Wähle ≻ und Decompose aus Wissensbank ↦→ O D ,D’, Axiom 6 

2. Konstruiere Hilfsfunktion G: ↦→ O’,I’, Axiom 5 

– Heuristik: G:=F, falls D’=D, sonst G=Id 

3. Verifiziere Decompose, generiere Vorbedingung: ↦→ primitive, Axiom 3 

– Heuristik: abgeleitete zusätzliche Vorbedingung für O D ist ¬primitive(x) 

4. Konstruiere Compose ↦→ O C , Axiom 4,2 

– Heuristik: Erzeuge O C mit Axiom 2; synthetisiere Compose gemäß Axiom 4 

5. Konstruiere Directly-solve ↦→ Axiom 1 

– Heuristik: Suche nach vorgefertigten Lösungen, sonst neue Synthese 

– Falls dies nicht möglich ist, konstruiere eingeschränkte Vorbedingung I 

6. Instantiiere das Divide & Conquer Schema 

Alternativen: 

– Wähle Compose, konstruiere sukzessive G, ≻, Decompose und Directly-solve 

– Wähle Decompose und ≻, konstruiere sukzessive Compose, G und Directly-solve 


Divide & Conquer Strategie: Sortieralgorithmus 

FUNCTION sort(L:Seq(Z)):Seq(Z) RETURNS S 

SUCH THAT rearranges(L,S) ∧ ordered(S) 

1. L≻L’ : ≡ |L|>|L’| 

Decompose : ≡ ListSplit ≡ λL. ( [ L[i]|i ∈ [1..|L|÷2] ], [ L[i]|i ∈ [1+|L|÷2..|L|] ] ) 

2. G : ≡ sort 

3. FUNCTION F d (L:Seq(Z):Seq(Z)×Seq(Z) WHERE ¬primitive(x) 

RETURNS L 1 

,L 2 

SUCH THAT L≻L 1 

∧ L≻L 2 

∧ L 1 

◦L 2 

=L ∧ |L 1 

|=|L|÷2 ∧ |L 2 

|=(1+|L|)÷2 

= ListSplit(L) 

hat als Vorbedingung für Korrektheit primitive(L) : ≡ L=[] 

4. L 1 

◦L 2 

=L ∧ ... ∧ SORT(L 1 

,S 1 

) ∧ SORT(L 2 

,S 2 

) ∧ O C (S 1 

,S 2 

,S) ⇒ SORT(L,S) 

liefert als Spezifikation und Lösung für Decompose 

FUNCTION F c (S 1 

,S 2 

:Seq(Z)×Seq(Z)):Seq(Z) WHERE ordered(S 1 

) ∧ ordered(S 2 

) 

RETURNS S SUCH THAT ordered(S) ∧ range(S)=range(S 1 

)∪range(S 2 

) 

= merge(S 1 

,S 2 

) 

5. Direkte Lösung für primitive Eingaben: 

FUNCTION F p (L:Seq(Z)):Seq(Z) WHERE |L|=[] RETURNS S 

6. Instantiierter Divide & Conquer Algorithmus 

SUCH THAT SORT(L,S) = L 

FUNCTION sort(L:Seq(Z)):Seq(Z) RETURNS S SUCH THAT rearranges(L,S) ∧ ordered(S) 

= if |L|=[] then L else let L 1 

,L 2 

= ListSplit(L) in merge(sort(L 1 

),sort(L 2 

)) 


Lokalsuch-Algorithmen: Lösung von Optimierungsproblemen 

Grundstruktur: Suche lokales Optimum 

– Hillclimbing: Transformiere Initiallösung in benachbarte, verbesserte Lösung 

FUNCTION F opt (x:D):R WHERE I(x) RETURNS y 

SUCH THAT O(x,y) ∧ ∀t:R. O(x,t) ⇒ cost(x,y)≤cost(x,t) 

= F LS (x,F(x)) 

FUNCTION F LS (x:D,z:R):R WHERE I(x) ∧ O(x,y) RETURNS y 

SUCH THAT O(x,y) ∧ ∀t ∈ N(x,y). O(x,t) ⇒ cost(x,y)≤cost(x,t) 

= if ∀t ∈ N(x,z). O(x,t) ⇒ cost(x,z)≤cost(x,t) 

then z 

else F LS (x, arb({t | t ∈ N(x,z) ∧ O(x,t) ∧ cost(x,z)>cost(x,t)}) ) 

• Initiallösung F(x) 

• Nachbarschaftsstruktur N :D×R →Set(R) 

• Kostenfunktion cost auf Raum R mit Ordnung ≤ 

Automatisierte Logik und Programmierung 272 Lokalsuch-Algorithmen

Lokalsuch-Algorithmen: Korrektheit 

FUNCTION F opt (x:D):R WHERE I(x) RETURNS y 

SUCH THAT O(x,y) ∧ ∀t:R. O(x,t) ⇒ cost(x,y)≤cost(x,t) 

= F LS (x,F(x)) 

FUNCTION F LS (x:D,z:R):R WHERE I(x) ∧ O(x,y) RETURNS y 

SUCH THAT O(x,y) ∧ ∀t ∈ N(x,y). O(x,t) ⇒ cost(x,y)≤cost(x,t) 

= if ∀t ∈ N(x,z). O(x,t) ⇒ cost(x,z)≤cost(x,t) 

then z else F LS (x, arb({t | t ∈ N(x,z) ∧ O(x,t) ∧ cost(x,z)>cost(x,t)}) ) 


1. F(x) berechnet gültige Initiallösung für O 

– FUNCTION f(x:D):R WHERE I(x) RETURNS y SUCH THAT O(x,y) 

2. Reflexivität der Nachbarschaftsstruktur 

– ∀x:D.∀y:R. I(x) ∧ O(x,y) ⇒ y ∈ N(x,y) 

3. Exaktheit lokaler Optima 

– ∀x:D.∀y:R. I(x) ∧ O(x,y) ⇒ ∀t ∈ N(x,y). O(x,t) ⇒ cost(x,y)≤cost(x,t) 

⇒ ∀t:R. O(x,t) ⇒ cost(x,y)≤cost(x,t) 

4. Erreichbarkeit gültiger Lösungen 

– ∀x:D.∀y,t:R. I(x) ∧ O(x,y) ∧ O(x,t) ⇒ ∃k:N.t ∈ N k O (x,y) 

N k O (x,y) ≡ if k=0 then {y} else ⋃ { N k−1 (x,t) | t ∈ N(x,y) ∧ O(x,t) } 

Automatisierte Logik und Programmierung 273 Lokalsuch-Algorithmen

Komplementierung 

Siebe 

statisch 

Problemreduktion 

(Operator Match) 

Hierarchie algorithmischer Theorien 

Allgemeine Problemstruktur 

Generate & Test 

 

 

 

 

 

Reduktionsstruktur 

✏ ✏✏✏✏✏✏✏✏✏✏✏✏✏✏✏ 

 

✘✘ ✘✘✘ ✘ ✘✘✘ ✘ ✘✘✘ ✘ ✘✘✘ ✘ ✘✘✘ ✘ 

✁ 

✁ 

✁ 

✁ 

✁ 

∧ -Reduktion 

rekursiv 

❅ Divide & Conquer 

❅ 

❅ 

❅ 

❅ 

❅ 

❅ 

❅ 

❅ 

❅ 

❅ 

❳ ❳❳ ❳ ❳❳❳ ❳ ❳❳❳ ❳ ❳❳❳❳ ❳ ❳❳❳ ❳❳ 

∨ -Reduktion 

 

 

statisch 

Bedingungen 

Fallanalyse 

✟ 

✟ 

✟ 

✟ 

✟ 

✟ 

✟ 

✟ 

✟ 

✟ 

✟ 

✟ 

✟ 

✟ 

✟ 

✟ 

✟ ∧ - ∨ -Reduktion 

Dynamische Programmierung 

Branch & Bound (AO ∗ ) 

Spielbaum-Suche 

Lokale Struktur 

Lokalsuche 

Simulated Annealing 

rekursiv 

✟ 

✟ 

✟ 

✟ 

Globalsuche 

Binärsuche 

Backtracking 

Branch & Bound (A ∗ ) 



Lektion 22 

Optimierungstechniken 

1. Simplifikationen 

2. Partielle Auswertung 

3. Endliche Differenzierung 

4. Fallanalyse 

5. Datentyp-Verfeinerung

Optimierungstechniken 

• Simplifikationen 

– unabhängig (nur Teilausdruck betrachtet) 

– mit Kontextberücksichtigung 

• Partielle Auswertung 

– Auswertung von Funktionen mit konstanten Argumenten 

• Endliche Differenzierung 

– Inkrementelle Berechnung von Teilausdrücken 

• Fallanalyse 

• Datentyp-Verfeinerung 

– Auswahl konkrete Implementierungen für abstrakte Konstrukte 

• Complierung 

– Übersetzung in konkrete Zielsprache + sprachabhängige Optimierung 

Automatisierte Logik und Programmierung 276 Optimierungstechniken

Simplifikationen 

Logische Vereinfachung von Teilausdrücken 

Anwendung gerichteter Gleichungen (Lemmata) 

• CI-Simplifikation: (kontextunabhängig) 

– Anwendung von Gleichungen ohne Vorbedingungen 

– Ausführung, solange anwendbare Gleichungen vorhanden 

• CD-Simplifikation: (kontextabhängig) 

– Anwendung bedingter Gleichungen 

– Kontext wird über Syntaxbaum bestimmt (Programmcode und Vorbedingung) 

– Hauptanwendung: Elimination redundanter Teilausdrücke 

Benutzer wählt konkreten Teilausdruck und Art der 

Vereinfachung 


Costas-Arrays Optimierung: erster Algorithmus 



= if nodups([]) ∧ ∀j ∈ domain([]).nodups(dtrow([],j)) 

then Costas aux (n,[]) else ∅ 

FUNCTION Costas aux (n:Z,V:Seq(Z)):Set( Seq(Z) ) 


RETURNS {p | perm(p,{1..n}) ∧ V⊑p ∧ ∀j ∈ domain(p).nodups(dtrow(p,j))} 


∪ ⋃ { Costas aux (n,W) | W ∈ {V·i|i ∈ {1..n}} ∧ nodups(W) 

∧ ∀j ∈ domain(W).nodups(dtrow(W,j)) } 


Costas-Arrays Optimierung: CI-Simplifikationen 






RETURNS {p | perm(p,{1..n}) ∧ V⊑p ∧ ∀j ∈ domain(p).nodups(dtrow(p,j)) } 

= (if perm(V,{1..n}) ∧ ∀j ∈ domain(V).nodups(dtrow(V,j)) then {V} else ∅) 

∪ ⋃ { Costas aux (n,V·i) |i ∈ {1..n} ∧ nodups(V·i) 

∧ ∀j ∈ domain(V·i).nodups(dtrow(V·i,j)) } 


Costas-Arrays Optimierung: CD-Simplifikationen 







= (if {1..n}⊆range(V) then {V} else ∅) 

∪ ⋃ { Costas aux (n,V·i) | i ∈ {1..n} ∧ i ∉ V 



Partielle Auswertung 

Auswertung von Funktionen mit konstantem Argument 

• Formal: Auffalten von Definitionen + Simplifikation 

– solange ein konstanter Teilausdruck vorhanden 

Beispiel: 

|[4;5] ◦ V| unfold concatenation 

= |4. ([5] ◦ V)| unfold concatenation 

= |4. (5. ([] ◦ V))| unfold concatenation 

= |4. (5. V)| unfold length 

= 1 + |5. V| unfold length 

= 1 + 1 + |V| simplify 

= 2 + |V| 

• Benutzer wählt auszuwertenden Teilausdruck 


Endliche Differenzierung 

Inkrementelle Berechnung wiederkehrender Teilausdrücke 

• Ersetze Teilausdrücke in rekursiven Aufrufen durch 

Variablen und bestimme differentielle Veränderungen 

Formal: Abstraktion über Teilausdruck E(x) 

+ Simplifikation mit zusätzlicher Gleichung 

• Abstraktion über E(x) in f(x): 

– Bestimme neues f’, so daß f(x) = f’(x,E(x)) 

– Ersetze alle Aufrufe der Art f( g(x) ) durch f’( g(x) x, E(g(x)) ) 

• Simplifikation mit zusätzlicher Gleichung ‘E(x) = new’ 

– Simplifiziere Ausdrücke der Form E(g(x)) in die Form g’(E(x)) 

– Ersetze alle Vorkommen von E(x) durch new 

• Benutzer wählt konkreten Teilausdruck E(x) 


Costas-Arrays Optimierung: Endliche Differenzierung 



= Costas aux1 (n,[],{1..n}) 

FUNCTION Costas aux1 (n:Z,V:Seq(Z),Pool:Set(Z)):Set( Seq(Z) ) 


∧ Pool = {1..n}\range(V) 


= (if empty?(Pool) then {V} else ∅) 

∪ ⋃ { Costas aux1 (n,V·i,Pool−i) |i ∈ Pool 

∧ ∀j ∈ domain(V). (V[ |V|+1 -j]-i) ∉ dtrow(V,j) } 


Costas-Arrays Optimierung: Fallanalyse 



= Costas aux2 (n,[],{1..n},1) 

FUNCTION Costas aux2 (n:Z,V:Seq(Z), Pool:Set(Z),Vsize:Z):Set( Seq(Z) ) 


∧ Pool = {1..n}\range(V) ∧ Vsize = |V|+1 


= if empty?(Pool) 

then {V} 

else ⋃ { Costas aux2 (n,V·i,Pool−i,Vsize+1) |i ∈ Pool 

∧ ∀j ∈ domain(V). (V[Vsize-j]-i) ∉ dtrow(V,j) } 


Datentypverfeinerung 

Ersetze abstrakte Definitionen von Datentypen 

durch effiziente konkrete Implementierungen 

• Endliche Mengen 

– Listen: Standardimplementierung 

– Bitvektor: Mengen über endlichem Domain 

– charakteristische Funktion (effiziente Elementrelation) 

• Folgen 

– verkettete Liste: Standardimplementierung 

– umgekehrte Liste (gut für append-Operation ·) 

• System stellt Auswahl von Implementierungen bereit 

Benutzer legt Nichtstandard-Implementierung fest 

– separat für jede einzelne Variable 



Lektion 23 

Ausblick

Programmsynthese: 

Ausblick 

• Notwendig für die Praxis der Programmierung 

• Marktreife noch in weiter Zukunft 

• Zukunftsträchtiges Forschungsgebiet 

• Bedingungen an konkrete Systeme 

– interne Verarbeitung formal korrekt 

– externe Präsentation möglichst wenig formal 

– graphische Unterstützung für Kontrolle einer Synthese 

– große Wissensbanken mit effizienter Verwaltung 

• Voraussetzungen für die Entwicklung von Systemen 

– Theoretische Grundlagen und praktische Programmierarbeiten 

– Formale Denkweise, Kenntnis logischer Kalküle, Abstraktionsvermögen 

– Kreativität, Experimentierfreudigkeit, Ausdauer 

Automatisierte Logik und Programmierung 287 Ausblick

Aktuelle Forschungsthemen 

• Aufbau und Strukturierung der Wissensbank 

– Formalisierung und Computerrealisierung verschiedener Anwendungsbereiche 

– Anwendung von Lemmata als Rewrite-Regeln (Teilterm-matching 2. Stufe) 

– Effizienter Zugriff auf anwendbare Lemmata (Strukturierungsmethoden) 

• Integration von Beweisverfahren 

– Aussagenlogik – Entscheidungsprozeduren (Davis-Putnam Verfahren?) 

– Prädikatenlogik – Konnektionsmethode (↦→ S.Schmitt / J.Otten / D.Korn) 

– Induktionstechniken (Rippling,...) 

– Anwendungsspezifische Verfahren 

• Integration von Syntheseverfahren 

– Computerrealisierung von Algorithmetheorien als Theoreme 

– Spezialisierte Entwurfstaktiken mit Theoremeinbindung 

– Optimierungstechniken 

• Benutzerinterface & Dokumentation 

↦→ Studien- & Diplomarbeiten 

Automatisierte Logik und Programmierung 288 Ausblick

Automatisierte Logik und Programmierung

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?