Automatisierte Logik und Programmierung

Automatisierte Logik und Programmierung
Einheit 5
Der λ-Kalkül
1. Syntax
2. Operationale Semantik
3. Schließen über Berechnung
4. Ausdruckskraft
Auswertung von Termen
• Prädikatenlogik und Evidenzen verwenden Termsprache
– Prädikatenlogik: uninterpretierte Variablen- und Funktionssymbole
– Evidenz: Terme der Prädikatenlogik und Konstrukte mit Bedeutung
λx.b, f (a), (a, b), x.1, x.2, inl(a), inr(b), case x of ...
• Verschiedene Terme können die gleiche Bedeutung haben
– Für f = λx.b ist f (a) = b[a/x] und λx.f (x) ist dasselbe wie f
– (a, b).1 = a, (a, b).2 = b und das Paar (x.1, x.2) ist dasselbe wie x
– case inl(a) of inl(y) → s | inr(z) → t ist dasselbe wie s[a/y]
– Terme auf rechter und linker Seite haben jeweils denselben Wert
• Termauswertung kann als Kalkül beschrieben werden
– Berechnungskalkül interpretiert Terme als Programmiersprache und
kalkuliert Wert schrittweise durch Termersetzung (Rewriting)
– Beweiskalkül beschreibt Effekte der Berechnungsschritte als Gleichheiten
in einer Berechnungslogik
– Die Grundform beider Kalküle ist der λ-Kalkül
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
1
λ-Kalkül
Der λ-Kalkül
Logisches Schließen über den Wert von Termen
• Einfacher mathematischer Mechanismus
– Funktionen werden definiert und angewandt
– Beschreibung des Funktionsverhaltens wird zum Namen der Funktion
– Funktionswerte werden ausgerechnet durch Einsetzen von Werten
• Leicht zu verstehende Basiskonzepte
1. Definition einer Funktion:
f =
ˆ λx. 2*x+3
λ-Abstraktion
Name der Funktion irrelevant für Beschreibung des Verhaltens
2. Anwendung der Funktion (ohne Auswertung):
f(4) =
ˆ (λx. 2*x+3)(4)
Applikation
3. Auswertung einer Funktionsanwendung (tatsächliches Ausrechnen):
β
∗
(λx. 2*x+3)(4) −→ 2*4+3 −→ 11
Reduktion
• Alle anderen Konstrukte können simuliert werden
– Turingmächtige funktionale Programmiersprache
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
2
7→ Lisp, ML, Haskell, . . .
λ-Kalkül
λ-Kalkül – Syntax
• Einfache Programmiersprache: λ-Terme
– Variablen x, y, z, x0, y0,, . . .
– λx.t, wobei x Variable und t λ-Term
Vorkommen von x in t werden gebunden
– f t, wobei t und f λ-Terme
– (t), wobei t λ-Term
λ-Abstraktion
Applikation
• Prioritätskonventionen sparen Klammern
– Applikation bindet stärker als λ-Abstraktion
– Applikation ist links-assoziativ:
• Beispiele für λ-Terme
(mit impliziten und ‘kosmetischen’ Klammern)
–x
– λf.(λx.(f(x)))
– λf.(λg.(λx.(((f g) (g x)))))
– x(x)
– (λx.x(x)) (λx.x(x))
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
λx.f t =
ˆ λx.(f t)
f t1 t2 =
ˆ (f t1 ) t2
Symbole sind immer Variablen
Anwendung einer Funktion
Funktionen höherer Ordnung
Selbstanwendung
Fixpunkt
3
λ-Kalkül
λ-Kalkül – Semantik
• Interpretation in Zielsprache ist zu kompliziert
– Abbildung auf Funktionen in einfachem Universum nicht möglich
– Modellierung benötigt Theorie vollständiger Halbordnungen (CPOs)
• Semantik von Termen wird operational erklärt
– Entspricht Methodik beim Rechnen auf Zahlen: 4∗(3+2) = 4∗5 = 20
– λ-Terme werden ausgewertet bis irreduzibler Term erreicht ist
– Irreduzible Terme werden als Werte angesehen
• Berechnung ist rein syntaktischer Mechanismus
– Auswertung ersetzt Funktionsparameter durch Funktionsargumente
β
– Formales Konzept: Reduktion (λx.t)(b) −→ t[b/x]
Ersetzen der freien Vorkommen der λ-Variablen x durch den λ-Term b
– Benötigt Erweiterung des Substitutionskonzepts auf λ-Terme
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
4
λ-Kalkül
Vorkommen von Variablen in λ-Termen
• Vorkommen der Variablen x im Term t, informal
– Gebunden: x erscheint im Bindungsbereich einer λ-Abstraktion λx
– Frei: x kommt in t vor, ohne gebunden zu sein
– t heißt geschlossen falls t keine freien Variablen enthält
– t[x1, .., xn]: Term t hat mögliche freie Vorkommen von x1, .., xn
• Präzise, induktive Definition
die Variable x kommt frei vor; y6=x kommt nicht vor
x
λx.t: beliebige Vorkommen von x in t werden gebunden
Vorkommen von y6=x in t bleiben unverändert
f t freie Vorkommen von x in t bleiben frei
(t)
gebundene Vorkommen von x bleiben gebunden
x gebunden
z
}|
{
λf.λx.(λz.
f{zx z) x}
|
x frei
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
5
λ-Kalkül
Substitution u[t/x] formal
• Anwendung einer endlichen Abbildung σ = [t/x]
⌊x⌋[t/x]
=t
⌊λx.u⌋[t/x] = λx.u
∗
⌊λx.u⌋[t/y] = ⌊λz.u[z/x]⌋[t/y]
⌊f u⌋σ
= f σ uσ
∗
⌊x⌋[t/y]
=x
⌊λx.u⌋[t/y]
= λx.⌊u[t/y]⌋ ∗∗
= (uσ)
⌊(u)⌋σ
(y6=x)
: y6=x, y frei in u, x frei in t, z neue Variable
: y6=x, y nicht frei in u oder x nicht frei in t
∗∗
• Substitution und Reduktion am Beispiel
(λn.λf.λx. n f (f x)) (λf.λx.x)
= (λn.(λf.(λx.((n f)(f x))))) (λf.(λx.x)) (Reduktion ersetzt n)
−→ λf.(λx.((λf.(λx.x)) f)(f x))
(8 Substitutionsschritte)
−→ λf.(λx.((λx.x)(f x)))
−→ λf.λx. f x
⇓
3
(λn.λf.λx. n f (f x)) (λf.λx.x) −→ λf.λx. f x
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
6
λ-Kalkül
Reduktion als Formalismus – wichtige Begriffe
• α-Konversion:
– Umbenennung gebundener Variablen in Termen (erhält Bedeutung)
– Ersetze Teilterms der Gestalt λx.u durch λz.u[z/x]
(z neue Variable)
• Kongruenz t ∼
= u (“t und u sind α-konvertibel”)
– u entsteht aus t durch α-Konversion
β
• Reduktion (λx.u) s −→ u[s/x]:
– Ersetze Teilterm der Gestalt (λx.u)
| {z s} durch u[s/x]
| {z }
Redex
Kontraktum
∗
• Reduzierbarkeit t −→ u:
– u entsteht aus t durch endlich viele Reduktionen und α-Konversionen
• Normalform:
– Term u, der nicht weiter reduzierbar (irreduzibel) ist
∗
– Wert von t: Normalform u mit t −→ u
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
7
λ-Kalkül
Regeln für Konversion und Reduktion
• α-Konversion: λx.u ∼
= λz.u[z/x]
(z neu)
– µ-Konversion: f t ∼
= f u, falls t ∼
= u
– ν-Konversion: f t ∼
= g t, falls f ∼
= g
– ξ-Konversion: λx.t ∼
= λx.u, falls t ∼
=u
– ρ -Konversion: t ∼
=t
– σ-Konversion: t ∼
= u, falls u ∼
=t
– τ -Konversion: t ∼
= u, falls t ∼
= s und s ∼
=u
• β-Reduktion: (λx.u) s −→ u[s/x]
µ–Reduktion: f t −→ f u, falls t −→ u
ν–Reduktion: f t −→ g t, falls f −→ g
ξ–Reduktion: λx.t −→ λx.u, falls t −→ u
τ –Reduktion: t −→ u, falls t −→ s und s ∼
= u oder t ∼
= s und s −→ u
∗
n
• Reduzierbarkeit: t −→ u, falls t −→ u für ein n ∈ N
0
– t −→ u, falls t ∼
=u
n+1
n
– t −→ u, falls t −→ s und s −→ u
–
–
–
–
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
8
λ-Kalkül
Reduktion ist nicht deterministisch
Naheliegende Reduktionsreihenfolge
(λf.λx. f x (f f)) (λx.λy. y)
−→ λx. (λx.λy. y) x ((λx.λy. y) (λx.λy. y))
−→ λx. (λy. y) ((λx.λy. y) (λx.λy. y))
−→ λx. ((λx.λy. y) (λx.λy. y)
−→ λx. λy. y
Alternative Reduktionsreihenfolgen sind möglich
(λf.λx. f x (f f)) (λx.λy. y)
−→ λx. (λx.λy. y) x ((λx.λy. y) (λx.λy. y))
−→ λx. (λx.λy. y) x (λy. y)
−→ λx. (λy. y) (λy. y)
−→ λx. λy. y
Bekommt man immer das gleiche Ergebnis?
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
9
λ-Kalkül
Semantik von λ-Termen präzisiert
• Bedeutung von λ-Termen ist ihr Wert
– Normalform: Term ohne keine Redizes als Teilterme
∗
– u Normalform von t: u in Normalform und t −→ u
– t normalisierbar: es gibt eine Normalform u von t
• Hat jeder λ-Term eine Normalform?
Nein: (λx. x x) (λx. x x) ist nicht normalisierbar
– Terminierung von λ-Programmen ist nicht garantiert
• Haben normalisierbare λ-Terme eindeutige Werte?
Notwendig für Einsatz des λ-Kalküls als Programmiersprache
– Führt jede Reduktionsfolge zu einer Normalform?
Wenn nein, kann man eine Normalform systematisch finden?
– Ist die Normalform eines λ-Terms eindeutig?
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
10
λ-Kalkül
Reduktion normalisierbarer λ-Terme
• Führt jede Reduktionsfolge zu einer Normalform?
Nein: Reduktionsfolgen normalisierbarer Terme müssen nicht terminieren
(λx.λy.y) ((λx. x x x) (λx. x x x)) (λx. x)
−→ (λy.y) (λx. x)
−→ λx. x
Eine “innermost” Strategie führt bei diesem Term nicht zur Normalform
(λx.λy.y) ((λx.x x x) (λx.x x x)) (λx.x)
∗
−→ (λx.λy.y) ((λx.x x x) (λx.x x x) (λx.x x x)) (λx.x)
∗
−→ (λx.λy.y) ((λx.x x x)(λx.x x x)(λx.x x x) (λx.x x x)) (λx.x)
..
..
• Kann man eine Normalform immer finden?
– Ja: Reduktion des äußersten Redex (“leftmost reduction”) führt zur
Normalform, wenn es eine gibt
Beweis: Curry & Feys 1958, p142
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
11
λ-Kalkül
Eindeutigkeit von Normalformen
• Was heißt “eindeutig”?
– Müssen Normalformen textlich identisch sein (wie 4 = 4)?
– Oder sollen sie “nur” den gleichen Wert haben (wie λx.x und λy.y)?
– Gleichwertigkeit zu fordern ist semantisch sinnvoller
• Semantische Gleichheit von λ-Termen ist extensional
∗
∗
– t = u: es gibt v mit t −→ v und u −→ v (t und u sind konvertierbar)
– Auch Terme, die nicht normalisierbar sind, können gleich sein
• Ist die Normalform eines λ-Terms eindeutig?
– Ja: Reduktion ist konfluent
∗
Beweis: Barendregt 1981 §3.2
∗
Gilt t −→ u und t −→ v, so folgt u = v
(Church-Rosser Theorem)
– Alle Normalformen eines λ-Terms sind kongruent und können
(durch Konversionen) auf denselben Term reduziert werden
– Semantisch gleiche Terme haben dieselben Normalformen oder keine
– Normalformen, die nicht kongruent sind, sind nicht semantisch gleich
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
12
λ-Kalkül
Semantische Gleichheit
• Ausdrucksstärker als Reduzierbarkeit
– Benötigt keine Normalform für den Vergleich von Termen
Es reicht, mit Reduktionen/Konversionen den gleichen Term zu erreichen
– Auch Terme, die nicht normalisierbar sind, können verglichen werden
• Grundlage des logischen Schließens über Berechnungen
– Im (allgemeinen) λ-Kalkül kann automatische Normalisierung zu nichtterminierenden Reduktionsfolgen führen
Für typisierbare λ-Termen gibt es immer eine terminierende Reduktionsstrategie
– Schließen über semantische Gleichheit braucht terminierende Reduktion
– Beweisregeln müssen einzelne Reduktionsschritte widerspiegeln
• Der λ-Kalkül ist unabhängig von der Prädikatenlogik
– Schließen über semantische Gleichheit benötigt keine logischen Regeln
– Beweissysteme können separat beschrieben und dann integriert werden
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
13
λ-Kalkül
Regeln zum Schließen über Gleichheit
• β-Reduktion
– Gleichheit mit einem Redex entspricht Gleichheit mit Kontraktum
H ⊢ (λx.u) s = t
H ⊢ u[s/x] = t reduction
• Kongruenzregeln
– Applikationen sind gleich, wenn Funktionen und Argumente gleich sind
– Funktionen sind gleich, wenn sie auf allen Argumenten gleich sind
H ⊢f t=gu
H ⊢f =g
H ⊢ t = u applyEq
H ⊢ λx.t = λy.u
H, x′:U ⊢ t[x′/x] = u[x′/y] lambdaEq
x′ ist neue Variable, die in H nicht frei vorkommt
• Reflexivität, Symmetrie, Transitivität, Substitution
H ⊢t=t
H ⊢t=u
H ⊢u=t
reflexivity H ⊢ t = u
H ⊢t=s
H ⊢s=u
symmetry
transitivity s
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
14
H ⊢ E[t/x]
H ⊢t=u
H ⊢ E[u/x]
subst t = u
λ-Kalkül
Sequenzenbeweis für eine Reduktion
• Beweis einer einfachen Reduktion
⊢ (λf.λx.f x(f f ))(λx.λy.y) = λx.λy.y
1. ⊢ λx. (λx.λy.y)x((λx.λy.y)(λx.λy.y)) = λx.λy.y
1.1. x:U ⊢ (λx.λy.y)x((λx.λy.y)(λx.λy.y)) = λy.y
1.1.1. x:U ⊢ (λy.y) ((λx.λy.y)(λx.λy.y)) = λy.y
1.1.1.1. x:U ⊢ (λx.λy.y)(λx.λy.y) = λy.y
1.1.1.1.1. x:U ⊢ λy.y = λy.y
BY
BY
BY
BY
BY
BY
reduction
lambdaEq
reduction
reduction
reduction
reflexivity
BY
BY
BY
BY
BY
BY
reduction
reduction
symmetry
reduction
lambdaEq
reflexivity
• Beweis einer semantischen Gleichheit
⊢ (λf.λx.f x)(λy.y) = (λx.λy.y)(λz.z)
1. ⊢ λx.(λy.y) x = (λx.λy.y)(λz.z)
1.1. ⊢ λx.x = (λx.λy.y)(λz.z)
1.1.1. ⊢ (λx.λy.y)(λz.z) = λx.x
1.1.1.1. ⊢ λy.y = λx.x
1.1.1.1.1. x′:U ⊢ x′ = x′
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
15
λ-Kalkül
Eigenschaften des Beweiskalküls
• Korrektheit
– Wenn ⊢ u=v im erweiterten Sequenzenkalkül bewiesen werden kann,
dann sind u und v semantisch gleich (u = v)
– Die neuen Regeln sind korrekt in Bezug auf semantische Gleichheit
• Vollständigkeit gilt nur in eingeschränktem Sinne
∗
∗
Jede (konkrete) Reduktionsfolge t −→ v und u −→ v kann in eine Folge
von Beweisschritten für ⊢ u=v übertragen werden
– β-Reduktion wird von reduction abgedeckt
– α- und ξ-Konversionen und -Reduktionen werden von lambdaEq erfaßt
– µ- und ν-Konversionen und -Reduktionen werden von applyEq erfaßt
– reflexivity, symmetry, transitivity, subst decken den Rest ab
Achtung! Es folgt nicht: “Gilt u = v, so ist ⊢ u=v beweisbar” (siehe Folie 29)
• Kalkül kann auch definitorische Gleichheit verarbeiten
– Sind Konzepte durch definitorische Abkürzung erklärt, so ersetzt
die Regel unfold die linke Seite der Definition durch die rechte
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
16
λ-Kalkül
Vom λ-Kalkül zu echten Programmen
• λ-Kalkül ist der Basismechanismus
– Die Assemblersprache funktionaler Programme
– Nur die elemtarsten Konstrukte sind vordefiniert
• Programm- und Datenstrukturen werden codiert
– Berechnung auf λ-Ausdrücken muß Effekte auf Struktur simulieren
(Analog zu konventionellen Computern, in denen alles als Bitmuster codiert wird)
• Alle wichtigen Strukturen sind leicht codierbar
– Boolesche Operationen: T, F, if b then s else t
– Tupel / Projektionen: hs,ti, p.1, p.2
– Injektion / Analyse: inl(a), inr(b), case x of inl(a)→s | inr(b)→t
– Zahlen und arithmetische Operationen
– Iteration oder Rekursion von Funktionen
Der λ-Kalkül kann alle berechenbaren Funktionen repräsentieren
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
17
λ-Kalkül
Darstellung Boolescher Operatoren im λ-Kalkül
Wir brauchen zwei verschiedene Objekte und einen Test
T
≡ λx.λy.x
Term für “true”
F
≡ λx.λy.y
Term für “false”
if b then s else t ≡ b s t
Term für Konditional
Beweis: Die Konditional(-darstellung) ist invers zu T und F
⊢
⊢
⊢
⊢
⊢
if T then s else t = s
Tst = s
(λx.λy.x) s t = s
(λy.s) t = s
s = s
AUTOMATISIERTE L OGIK
UND
⊢
unfold T/F ⊢
reduction
⊢
reduction
⊢
reflexivity ⊢
BY unfold cond
BY
BY
BY
BY
P ROGRAMMIERUNG
18
if F then s else t = t
Fst = t
(λx.λy.y s t = t
(λy.y) t = t
t = t
λ-Kalkül
“Beweis” für F 6= T
Beweis zeigt “nur” die Absurdität von F = T
– Es ist nicht möglich, F 6= T zu beweisen, aber wenn F = T wäre,
dann sind alle λ-Terme gleich
⊢ F = T ⇒ ∀s,t:U. s = t
1. F = T, s:U, t:U ⊢ s = t
1.1. F = T,... ⊢ s = if F then s else t
1.1.1. F = T,... ⊢ if F then s else t = s
1.1.1.1. F = T,... ⊢ F = T
1.1.1.2. F = T,... ⊢ if T then s else t = s
1.1.1.2.1. F = T,... ⊢ (λx.λy.x) s t = s
1.1.1.2.1.1... ⊢ s = s
1.2. F = T,... ⊢ if F then s else t = t
1.2.1. F = T,... ⊢(λx.λy.y) s t = t
1.2.1.1. F = T,... ⊢ t = t
BY
BY
BY
BY
BY
BY
BY
BY
BY
BY
BY
impliesR THEN allR THEN allR
transitivity if F then s else t
symmetry
subst F = T
axiom
unfold THEN unfold
reduction THEN reduction
reflexivity
unfold THEN unfold
reduction THEN reduction
reflexivity
– Beweis auch ohne Verwendung der subst Regel möglich, aber länger
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
19
λ-Kalkül
Bildung und Analyse von Paaren
hu,vi
≡ λp. p u v
pair.1
≡ pair (λx.λy.x)
pair.2
≡ pair (λx.λy.y)
match pair with hx,yi 7→ t ≡ pair (λx.λy.t)
(uniformer Analyseoperator, oft eleganter in Anwendung)
Der Analyseoperator ist invers zur Paarbildung
≡
≡
−→
−→
−→
match hu,vi with hx,yi 7→ t
hu,vi(λx.λy.t)
(λp. p u v)(λx.λy.t)
(λx.λy.t) u v
(λy.t[u/x]) v
t[u, v/x, y]
(kurz für t[u/x][v/y])
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
20
λ-Kalkül
Injektionen und Fallanalyse
Verallgemeinerung boolescher Operatoren
inl(a)
≡ λx.λy.x a
inr(b)
≡ λx.λy.y b
case z of inl(x) → s | inr(y) → t ≡ z (λx.s) (λy.t)
Fallanalyse ist invers zu Injektionen
≡
≡
−→
−→
−→
case inl(a) of inl(x) → s | inr(y) → t
(inl(a)) (λx.s) (λy.t)
(λx.λy.x a) (λx.s) (λy.t)
(λy.(λx.s) a) (λy.t)
(λx.s) a)
s[a/x]
∗
Analog: case inr(b) of inl(x) → s | inr(y) → t −→ t[b/x]
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
21
λ-Kalkül
Simulation von Zahlen und Arithmetik
• Darstellung natürlicher Zahlen durch iterierte Terme
– Semantisch: wiederholte Anwendung von Funktionen
– Repräsentiere die Zahl n durch den λ-Term λf.λx. f
| (f..(f
{z x)..)}
n-mal
– Notation: n ≡ λf.λx. fn x
(Markierung n hilft, eine Verwechselung von Zahlen und zugehörigen λ-Termen zu vermeiden)
– Bezeichnung: Church Numerals
• f :Nn→N λ-berechenbar:
– Es gibt einen λ-Term t mit der Eigenschaft
f (x1, .., xn) = m ⇔ t x1..xn = m
• Operationen müssen “Termvielfachheit” berechnen
– Simulation einer Funktion auf Darstellung von Zahlen
muß Darstellung des Funktionsergebnisses liefern
– z.B. muß add m n als Wert immer den Term m+n liefern
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
22
λ-Kalkül
Arithmetische Operationen im λ-Kalkül
• Nachfolgerfunktion:
s ≡ λn.λf.λx. f (n f x)
– Der Wert von s n ist der Term n+1
s n
≡
−→
−→
−→
−→
(λn.λf.λx. f (n f x)) (λf.λx. fn x)
λf.λx. f ((λf.λx. fn x) f x)
λf.λx. f ((λx. fn x) x)
λf.λx. f (fn x)
λf.λx. fn+1 x
≡ n+1
• Addition:
add ≡ λm.λn.λf.λx. m f (n f x)
• Multiplikation:
mul ≡ λm.λn.λf.λx. m (n f) x
• Test auf Null:
zero ≡ λn. n (λn.F) T
• Vorgängerfunktion:
p ≡ λn. (n (λf x. hs, match f x with hf,xi 7→ f xi) hλz.0, 0i).2
• Einfache Rekursion:
PRs[b,h] ≡ λn. n h b
– Für f ≡ PRs[b,h] gilt: f 0 = b und f (s n) = h (f n)
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
23
λ-Kalkül
Korrektheit der Additionsfunktion
Beweise: add m n = m+n
⊢
⊢
⊢
⊢
⊢
⊢
⊢
⊢
⊢
⊢
⊢
⊢
add m n = m+n
(λm.λn.λf.λx. m f (n f x)) m n = m+n
(λn.λf.λx. m f (n f x)) n = m+n
λf.λx. m f (n f x) = m+n
λf.λx. (λf.λx. fm x) f (n f x) = m+n
λf.λx. (λx. fm x) (n f x) = m+n
λf.λx. fm (n f x) = m+n
λf.λx. fm ((λf.λx. fn x) f x) = m+n
λf.λx. fm ((λx. fn x) x) = m+n
λf.λx. fm (fn x) = m+n
λf.λx. fm+n x = m+n
λf.λx. fm+n x = λf.λx. fm+n x
BY
BY
BY
BY
BY
BY
BY
BY
BY
BY
BY
BY
unfold
reduction
reduction
unfold
reduction
reduction
unfold
reduction
reduction
reduction
unfold
reflexivity
Keine Angabe der Unterzieladresse im Beweisbaum, da Beweis linear ist
Beweis ist “generisch”. Konkreter Beweis nur mit konkreter Instanz für m und n
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
24
λ-Kalkül
Darstellung von Listen
• Erweiterung des Konzepts natürlicher Zahlen
– Wiederholte Anwendung einer Funktion auf Listenelemente
– Repräsentiere a1..an durch den Term λf.λx. f a1 (f..(f an x)..)
• Grundkonzepte: Leere Liste, Anhängen, Rekursion
[]
≡ λf.λx.x
t::list
≡ λf.λx. f t (list f x)
list ind[b,h] ≡ λlist. list h b
• Rekursionsgleichungen für f ≡ list ind[b,h]
⊢
⊢
⊢
⊢
f [] = b
(λlist. list h b) [] = b
[] h b = b
(λf.λx.x) h b = b
⊢
⊢
⊢
⊢
⊢
f (t::list) = h t (f list)
t::list h b = h t (f list)
(λf.λx. f t (list f x)) h b = h t (f list)
h t (list h b) = h t (f list)
h t ((λlist. list h b) list) = h t (list h b)
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
BY
BY
BY
BY
unfold
reduce
unfold
reduce THEN reduce THEN symmetry
25
BY
BY
BY
BY
BY
unfold THEN reduce
unfold
reduce THEN reduce
symmetry THEN unfold
reduce THEN reflexivity
λ-Kalkül
Programmierung rekursiver Funktionen
• Funktion, die durch Gleichung f (x)=t[f, x] definiert ist
– d.h. im Programmkörper t darf f sich selbst und x aufrufen
• Darstellung: Anwendung eines Fixpunktkombinators auf t
– Fixpunktkombinator: λ-Term R mit Eigenschaft R t = t (R t) für alle t
– Rekursive Funktion f ist implementierbar durch f ≡ R (λf .λx.t),
∗
denn es gilt f x = (R (λf .λx.t)) x = (λf .λx.t) f x −→ t[f, x]
– Programmiernotation für R(λf .λx.t) ist “function f (x) = t”
Notation “function f (x, y) = t” steht für R(λf .λx.λy.t)
• Bekanntester Fixpunktkombinator ist der Y-Kombinator
– Y ≡ λf. (λx. f (x x)) (λx. f (x x))
⊢
⊢
⊢
⊢
⊢
⊢
⊢
Y t = t (Y t)
BY
(λx. t (x x)) (λx. t (x x)) = t (Y t)
BY
t (λx. t (x x)) (λx. t (x x)) = t (Y t)
BY
t (Y t) = t (λx. t (x x)) (λx. t (x x))
BY
t = t
BY
Y t = (λx. t (x x)) (λx. t (x x))
BY
(λx. t (x x)) (λx. t (x x)) = (λx. t (x x)) (λx. t
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
26
unfold THEN reduction
reduction
symmetry
applyEq
reflexivity
unfold THEN reduction
(x x)) BY reflexivity
λ-Kalkül
Beispiele rekursiv programmierter Funktionen
• Fakultätsfunktion: Es ist 0! = 1 und n! = n ∗ (n−1)! für n>0
– fak ≡ function fak(n) = if zero(n) then 1 else mul n (fak(p n))
≡ Y ( λfak.λn. if zero(n) then 1 else mul n (fak(p n)) )
• Subtraktion: n−m = n, falls m=0, sonst (n−(m−1))−1
– sub ≡ function sub(n,m) = if zero(m) then n else p(sub n (p m))
• Test n<m: Es ist n<m genau dann, wenn n+1−m = 0
– less ≡ λn.λm. zero(sub (s n) m)
• Division: Suche das erste z mit n<(z+1) ∗ m). Starte Suche bei 0
– div ≡ λn.λm.(function search(z) =
if less n (mul z m) then p z else search(s z)) 0
• Ackermannfunktion:
– A ≡ function A(n,x) =
if zero(x) then 1
else if zero(n) then if zero(p x) then 2 else add x 2
else A (p n) (A n (p x))
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
27
λ-Kalkül
Ausdruckskraft des λ-Kalküls
Alle µ-rekursiven Funktionen sind λ-berechenbar
• Nachfolgerfunktion s:
s ≡ λn.λf.λx. n f (f x)
n:
• Projektionsfunktionen prm
prnm ≡ λx1..λxn. xm
• Konstantenfunktion cn
m:
cnm ≡ λx1..λxn. m
• Komposition f ◦ (g1, .., gn):
◦
≡ λf.λg1..λgn. λx. f (g1 x)..(gn x)
• Primitive Rekursion P r[f, g]:
PR ≡ λf.λg. function h(x) = λy.if zero y then f x else g x (p y) (h x (p y))
• Minimierung µ[f ]:
Mu ≡ λf.λx. (function min(y) = if zero(f x y) then y else min (s y)) 0
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
28
λ-Kalkül
Konsequenzen der großen Ausdruckskraft
Ergebnisse der Berechenbarkeitstheorie übertragen sich
• Keine nichttriviale extensionale Eigenschaft von
λ-Termen kann automatisch geprüft werden (Satz von Rice)
– Terminiert die Berechnung einer Funktion f bei Eingabe x?
– Ist die durch einen λ-Term f beschriebene Funktion total
– Gehört ein Wert y zum Wertebereich einer Funktion f ?
– Berechnet die Funktion f bei Eingabe von x den Wert y
– Verhalten sich zwei λ-berechenbare Funktionen gleich?
Man kann nicht einmal für alle gleichen λ-Terme einen Gleichheitsbeweis finden
Das Hauptproblem ist dabei die Gleichheit nichtterminierender λ-Terme
• Beweis kann direkt im λ-Kalkül geführt werden
– Umweg über Berechenbarkeitstheorie mit Church’scher These,
Gödelnummern, utm- oder smn-Theorem ist nicht erforderlich
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
29
λ-Kalkül
Das Halteproblem
Terminierung von λ-Termen ist unentscheidbar
• Beweis stützt sich auf wenige Erkenntnisse
– λx.x terminiert mit Normalform λx.x
– ⊥ = Y(λx.x) terminiert nicht, da Y(λx.x) = (λx. x x) (λx. x x)
– Die Boole’schen Wahrheitswerte sind verschieden: T 6= F
• Einfacher Widerspruchsbeweis
– Wir nehmen an, Terminierung von λ-Termen
sei entscheidbar
(
T falls t terminiert
d.h. es gibt einen λ-Term h mit h(t) =
F sonst
– Definiere d = λx. if h(x) then ⊥ else λx.x.
– Dann h(Yd) = (
h(d(Y d)) = h(if h(Y d) then ⊥ else λx.x)
h(⊥) = F, falls h(Yd) = T
also h(Y d) =
h(λx.x) = T, falls h(Yd) = F
– Dies ist ein Widerspruch, also ist das Halteproblem nicht entscheidbar
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
30
λ-Kalkül
λ-Kalkül – Grenzen
• Vielseitige, ausdrucksstarke Sprache
– Klares Berechenbarkeitsmodell
– Wenige Vorgaben für formales Schließen
– Mengentheoretische Semantik extrem kompliziert (domain theory)
• Kein Schließen über Datentypen möglich
– Wann gehört ein Objekt zu einem bestimmten Datentyp?
– Welche Struktur hat der Datentyp eines Objekts?
– Welche Eigenschaften hat ein Programm?
• Erweiterung von Semantik / Inferenzsystem nötig
– Beschränke Freiheit der λ-Terme durch Präzisierung ihrer Eigenschaften
– Wähle Datentypen als Beschreibung von Programmeigenschaften
⇓
Typentheorie
AUTOMATISIERTE L OGIK
UND
P ROGRAMMIERUNG
31
λ-Kalkül