Weitere KIV-Regeln: Induktion

• Theoretisches zu Induktion später

• In KIV gibt es pro Datentyp meist eine strukturelle Induktionsregel

• Nat. Zahlen: Wenn für eine Formel ϕ(n)⋆ ϕ(0) gilt⋆ für jedes n: aus Ind.hyp. ϕ(n) folgt: ϕ(n+1)

dann gilt für ∀ n. ϕ(n)

• Im Sequenzenkalkül: ϕ ist jetzt die Sequenz Γ ⊢ ∆für Induktionsformel in Formel umwandeln!

⊢ ϕ(0) ϕ(n) ⊢ ϕ(n+1)

Γ ⊢ ∆

ϕ = ∀ y.∧

Γ →∨

∆, y = free(Γ → ∆) \ {n}

71

Induktion für Listen

• Jede Liste ist entweder die leere Liste []oder durch Addition von a vorne an x a+ x gebildet

• Achtung: append von zwei Listen wird auch x+ y geschrieben

• Es gilt ebenfalls strukturelle Induktion:Wenn für eine Formel ϕ(x)⋆ ϕ([]) gilt⋆ für jede Liste x: aus Ind.hyp. ϕ(x) folgt für jedes a: ϕ(a+ x)

dann gilt für ∀ x. ϕ(x)

⊢ ϕ([]) ϕ(x) ⊢ ϕ(a+ x)

Γ ⊢ ∆

ϕ = ∀ y.∧

Γ →∨

∆, y = free(Γ → ∆) \ {x}

Hinweis: Ind.hyp weglassen = Fallunterscheidung, ob Liste = [] oder = a+ x

72

Pragmatik zur Listeninduktion

• Viele Definitionen sind rekursivappend: [] + y = y, (a+ x) + y = a+ (x+ y)size: #([]) = 0, #(a+ x) = 1 + # xisprefix: isprefix([],y), ¬ isprefix(a+ x,[]),

isprefix(a+ x, b+ y) ↔ a = b ∧ isprefix(x, y)sorted: sorted([]), sorted(a + []),

sorted((a+ (b+ x)) ↔ a < b ∧ sorted(b+ x)

• Induktion, wann immer möglich, über Variable am rekursiven Argument.Also: erstes Argument bei append und isprefix

• Wenn dort keine Variable, oft Generalisierung des Arguments zuVariable notwendig

• Anschliessend rekursive Definition anwenden (oft mit Simplifier!),dann Induktionshypothese

• Bei sorted geht Rekursion über 2 Stufen: Induktion für FU!

73

KIV-Kalkül: Elimination für Selektoren

• Listen haben (Postfix-)Selektoren⋆ .first (erstes Element)⋆ .rest (Rest der Liste)

• Trick: Selektoren loswerden mit Hilfe von insert elim lemma

• Benötigt wird Lemma ⊢ x 6= [] → (a = x.first ∧ y = x.rest ↔ x = a+ y)

• Eliminationsregel sucht einen Term t.first oder t.rest

• Wenn t 6= [] gilt, wird t = a+ y ersetzt (neue Variablen a, y)

• Damit wird aus t.first bzw. t.rest jetzt a bzw. y

t = a+ y,Γ(a, y, a + y) ⊢ ∆(a, y, a+ y)

t 6= [],Γ(t.first, t.rest, t) ⊢ ∆(t.first, t.rest, t)

74

KIV-Kalkül: Elimination für andere Funktionen

• Manchmal geht Elimination auch für andere “unbeliebte” Funktionen

• Beliebte Beispiele: Minus und Division

• Lemma für Minus: n ≤ m ⊢ n0 = m − n↔ m = n0 + n

• Vorteil: Man kann auf Simplifierregeln für − verzichten!

• Nachteil: Neue Variable n0 wird eingeführt (manchmal unintuitiv)

Γ(n0 + n, n, n0) ⊢ ∆(n0 + n, n, n0)

n ≤ m,Γ(m,n,m− n) ⊢ ∆(m,n,m− n)

75

Spezifikation von Listen (1)

list-basic =enrich nat withsorts elem; list; constants [] : list;functions. + . : elem × list → list prio 9;. + . : list × list → list prio 9;. .first : list → elem ;. .rest : list → list ;# : list → nat ;

predicates. < . : elem × elem;. ∈ . : elem × list;

variables c, b, a: elem; z2, y2, x2, z1, y1, x1, z0, y0, x0, z, y, x: list;induction list generated by [], + :: elem × list;

76

Spezifikation von Listen (2)

axiomsirreflexivity : ⊢ ¬ a < a; used for : s,ls;transitivity : ⊢ a < b ∧ b < c→ a < c; used for : f,lf;totality : ⊢ a < b ∨ a = b ∨ b < a;

constructors : ⊢[] 6= a+ x; used for : s,ls;first : ⊢ (a+ x).first = a; used for : s,ls;rest : ⊢ (a+ x).rest = x; used for : s,ls;

append-base : ⊢[] + x = x; used for : s,ls;append-rec : ⊢ (a+ x) + y = a+ x+ y; used for : s,ls;

size-base : ⊢ #([]) = 0; used for : s,ls;size-rec : ⊢ #(a+ x) = #(x) + 1; used for : s,ls;

In : ⊢ a ∈ x↔ (∃ y, z. x = y + a+ z);end enrich

77

Beispiel (1)

zu zeigen: ⊢ # (x+ y) = # x + # y

Beweis durch strukturelle Induktion über x:Induktions Anfang x = []# ( [] + y ) = # y = 0 + # y = # x + # yInduktions Schritt x⇒ a+ x

# ( (a+ x) + y) = # (a+ x+ y) = # (x+ y) + 1= # x + # y + 1 = # x+ 1 + # y = # (a+ x)+ # y

78

Herleitung (1)

79

Herleitung (2)

80

Noch ein Beispiel

z. z.: x+ a = y + z ∧ ¬ a ∈ z → z = []Strukturelle Induktion über x:

• x = []: [] + a = a + [] = y + z

z = [] �⇒ y = [] ⇒ a + [] = z ⇒ a ∈ z �

• x = b+ x′: Ind.Hyp: ∀ a, y, z. x′ + a = y + z ∧ ¬ a ∈ z → z = []z. z.: (b+ x′) + a = y + z ∧ ¬ a ∈ z → z = [](b+ x′) + a = b+ (x′ + a) = y + z

1. y 6= [] ⇒ b = y.first ∧ x′ + a = y.rest + z ⇒ (Ind.-Hyp) �2. y = [] ⇒ b+ (x′ + a) = z ⇒ a ∈ b+ (x′ + a) �

81

Automatisierung in KIV: Heuristiken

• Flexible Automatisierung ist zentral, um bei grossen Fallstudien nichtimmer wieder die gleichen Beweisschritte wiederholen zu müssen

• Deshalb in KIV: Automatisierung durch zuschaltbare Heuristiken

• Speziell: der Simplifier ist eine Heuristik⇒ sollte man (fast) immer benutzen

• Für jedes Beweisziel werden alle Heuristiken der Reihen nachausprobiert

• Gewählte Heuristiken jederzeit änderbar

Sehr wichtig für das Verständnis von KIV:Welche Heuristik hat welchen Effekt?

82

Wichtige Heuristiken für PL in KIV (1)

• Simplifier⋆ Wendet die Simplifier-Regel an

• pl case distinction⋆ Wendet Regel case distinction an⋆ Für einfache bis mittelschwere Beweise⋆ Gefahr, unnötige Fallunterscheidungen zu machen

• if-then-else-split⋆ if-then-else-Operator:

(ϕ ⊃ σ; τ ) bezeichnet σ, falls ϕ wahr ist, sonst τ⋆ Wendet cut Regel mit ϕ an⋆ Häufig einsetzbar, um sinnvolle Fallunterscheidungen zu erzwingen⋆ Beispiel: Fallunterscheidung nach Anwendung von Rewrite-Regel

abs(i) = (i ≥ 0 ⊃ i; − i)

83

Wichtige Heuristiken für PL in KIV (2)

• Quantifier closing⋆ Sucht Instanzen, mit denen eine Prämisse direkt geschlossen

werden kann⋆ Immer verwenden⋆ Einziges Problem: Bei sehr vielen Quantoren braucht die Heuristik

viel unnötige Zeit⋆ Deshalb Spezifikationsmethodik:

Prädikat (+ Simplfierregeln) definieren statt grosseQuantorenformeln zu verwenden

• Quantifier:⋆ Sucht „sinnvolle“ Instanzen für Quantoren⋆ Kann Endlosschleifen verursachen!⋆ Nur bei einfachen Quantorenbeweisen einsetzbar

84

Wichtige Heuristiken für PL in KIV (3)

• structural induction:⋆ Macht strukturelle Induktion über “sinnvolle” Terme⋆ Idee für “sinnvoll”: Variablen an rekursiven Positionen:n ist sinnvoll in m+ n, da + rekursiv über das zweite Argumentdefiniert: m+ 0 = m, m+ (n+1) = (m+ n) +1

⋆ Klappt meistens, aber nicht immer⋆ Heuristik wendet ausserdem einmal die Induktionshypothese an

• module specific:⋆ Eigentlich eine Meta-Heuristik: Erlaubt heuristische Anwendung von

Regeln durch Patterns⋆ Pattern: Gibt Formeln (oder Schemas für Formeln) an, die in der

Sequenz vorkommen müssen bzw. nicht vorkommen dürfen + Regeldie angewandt werden soll

⋆ Alle Patterns stehen in der Datei module-specific

85

Wichtige Heuristiken für PL in KIV (4)

elimination:

• Heuristik gesteuert durch Eliminationsregeln(analog zu: Simplifier durch Simplifierregeln)

• KIV-Eingabe analog : used for: e; etc.

• Beispiel: n ≤ m ⊢ n0 = m − n↔ m = n0 + n

• Vorbedingung im Antezedent: n ≤ m muss beweisbar sein(analog zu Simplifierregeln)

86

KIV-Kalkül: Heuristiksätze

• in KIV: 3 vordefinierte Heuristiksätze:⋆ PL Heuristics: minimale Menge sinnvoller Heuristiken⋆ PL Heuristics + Case Splitting: Keine Induktion, FU automatisch⋆ PL Heuristics + Struct. Ind.:

Versucht Ziel induktiv zu beweisen undFallunterscheidungen (FU) automatisch zu machen

• Für grössere Projekte definiert man häufig seinen eigenenStandardsatz⇒ Datei default-heuristics

• Weitere Heuristiken für Programme (DL). Dort noch wichtiger, daProgramme mehr Struktur haben (später)

87

Formale SpezifikationundInduktion

88

Was ist ein SW-System mathematisch?

1. Sicht: Operational

Ein SW-System ist ein Automat

• mit Zustand,

• Zustandsübergängen und

• mit Abläufen.

2. Sicht: Algebraisch

Ein SW-System ist eine Algebra = Datenstruktur, d. h. ein System vonDaten und Operationen.

89

Was ist spezieller?

Einen Automaten kann man als spezielle Algebra auffassen:

• Zustand = Element einer Datenstruktur ⇒ Algebra!

• Sorten = State, Input, Output mit Operationen⋆ Anfangszustände:

isinitial: State → Bool⋆ Zustandsübergangsfunktion (oder auch Relation):

exec: Input × State → State × Output (→ Bool)

• Z. B. Zustand eines Programms:Programm + Programmzähler + Speicherbelegung

• Theoretisch: Algebraische Sicht genügt

• Praktisch: Automatensicht hat viele Spezialeigenschaften(u .a. ist eine Idee von „Zeit“ damit verbunden).Deshalb Codierung oft nicht die beste Idee.

90

SW-Beschreibungsformalismen

SW-System ist Datentyp:

• Modellorientierte Spezifikation (Z, VDM):Alle Datentypen sind mit Mengenlehre gebildet(Tupel und Mengen z. B. für UML-Klassendiagramme)

• Algebraische Spezifikation

SW-System ist Menge von Abläufen:

• Algorithmische Spezifikation, z. B. Programmiersprachen

• Programme über algebraischen/modellorientierten Datentypen

• Automaten, Harel/UML Statecharts, Abstract State Machines (ASMs)

Eignung hängt von den Zielen ab (Was will ich beschreiben? Wasbeweisen?)

91

Spezifikation

Ziel: Ein bestimmter Datentyp (Algebra) soll spezifiziert werden.

Fragen:1. Was für Operationen brauche ich?

2. Welche Axiome brauche ich?

3. Welche Datentypen kann ich überhaupt spezifizieren?

4. Kann ich alle wahren Aussagen über dem Datentyp auch beweisen?

Zunächst: Fragen 3 + 4 speziell für die natürlichen Zahlen

92

Natürliche Zahlen: Die Peano-Axiome

• Es gibt eine ausgezeichnete Zahl 0 ∈ IN.

• Jede Zahl n ∈ IN hat einen Nachfolger succ(n) ∈ IN.

• Zu zwei Zahlen gibt es Summe m+ n und Produkt m ∗ n

• Axiom 1: 0 ist kein Nachfolger.

• Axiom 2: Die Nachfolgerfunktion ist injektiv.

• Axiom 3: m+ 0 = m, m + succ(n) = succ(m+ n)

• Axiom 4: m ∗ 0 = 0, m ∗ succ(n) = m ∗ n+ n

• Axiom 5: IN ist die kleinste Menge M mit:0 ∈ M und wenn n ∈ M, dann succ(n) ∈ M

Aus dem letzten Axiom folgt das Induktionsprinzip:Wenn ϕ(0) gilt, und sich ϕ von n auf n+1 vererbt, dann ist ϕ für alle n wahr

Begründung: M := {n : ϕ(n)} ist mindestens so groß wie IN.93

Natürliche Zahlen: Mit PL nicht spezifizierbar!

Satz (Charakterisierung der natürlichen Zahlen)Die Peano-Axiome charakterisieren ein Modell (eben die natürlichenZahlen) bis auf Isomorphie (= Umbenennung).

Aber:

Satz von SkolemEs gibt keine Menge Ax-Nat von prädikatenlogischen Formeln, die alseinziges Modell (modulo Umbenennung) nur die natürlichen Zahlen hat.

Beweis mit Endlichkeitssatz: M erfüllbar ⇔ jedes endl. M’ ⊆ M erfüllbar.Betrachte Ax-Nat ∪ {c 6= 0, c 6= succ(0), . . . }

Intuition: Prädikatenlogische Axiome können nicht ausdrücken, dass esneben den „echten“ natürlichen Zahlen keine weiteren Zahlen gibt.

94

Natürliche Zahlen: Ein schwächeres Ziel

Wir wissen schon: Jede Axiomenmenge hat auch andere Modelle als IN mitzusätzlichen Elementen.

Wir versuchen es schwächer: Suche Axiomenmenge, mit der alle über INwahren Formeln bewiesen werden können(dass sie auch über anderen Modellen gelten, könnte uns ja egal sein).

Die Axiomenmenge sollte entscheidbar sein, d. h. es gibt Programm,das immer terminiert und sagt: “ja, ist Axiom” oder “nein, ist kein Axiom”.

Problem beim Finden der Axiomenmenge ist Peano-Axiom 5:IN ist kleinste Menge mit 0 ∈ M und n ∈ M ⇒ succ(n) ∈ M

Versuchen wir Mengen M durch Formeln zu beschreiben:Die Formel ϕ(n) mit freier Variable n beschreibt {n : ϕ(n)}

95

Natürliche Zahlen: Versuch der Spezifikation

specification peano-axsorts nat;constants 0 : nat;functions . +1 : nat → nat;

. + . : nat × nat → nat;

. ∗ . : nat × nat → nat;axioms0 6= n +1;m 6= n → m +1 6= n +1;m + 0 = m; m + (n +1) = (m + n) +1;m ∗ 0 = 0; m ∗ (n +1) = m ∗ n + m;

ϕ0n ∧ (∀ n. ϕ→ ϕn +1

n ) → ∀ n. ϕ; (: für jedes ϕ ∈ For(Σ,X) :)end specification

Unendlich viele Axiome, aber entscheidbar!96

Natürliche Zahlen: Unvollständigkeit

Problem: Alle Formeln (abzählbar viele) beschreiben nicht alle Mengen(überabzählbar viele)!

Es gilt leider:

Gödelscher UnvollständigkeitssatzEs gibt keine entscheidbare Menge von Formeln über (0, succ, +, ∗), die dieersten 4 Peano-Axiome und n 6= 0 → ∃ n. n = succ(m) enthält oderimpliziert, mit der sich alle in IN wahren Aussagen ableiten lassen(insbesondere ist peano-ax auch unvollständig).

Der Trick zum Beweis ist das Lügnerparadoxon: Es gibt eine Formel, diesagt: „Ich bin nicht beweisbar“

97

Natürliche Zahlen: Unvollständigkeit

Intuition:

• Leider findet man auch keine „gute“ Axiomenmenge, mit der die wahrenAussagen herleitbar sind

• Alle wahren Aussagen könnte man als Axiome trivialerweise nehmen.

• Die Menge der wahren Aussagen ist also nicht entscheidbar.

• Wahre Aussagen für die natürlichen Zahlen zu beweisen, ist kreativ.

• Verursachte ziemlich viel Wirbel in den 30er Jahren:Die Idee, Mathematik auf ganz einfachen Grundlagen aufzubauen(Hilbert’sches Programm) zu definieren, war gescheitert

• Heute: Komplizierte Mengenlehre (Zermelo-Fränkel, Gödel-Bernays)als Grundlage für Mathematik.

98

Natürliche Zahlen ohne Multiplikation

SatzFür Aussagen über natürlichen Zahlen mit 0, +, −, <, ≤ (aber keineMultiplikation) lässt sich mit dem Entscheidungsverfahren von Nelson undOppen automatisch entscheiden, ob sie wahr oder falsch sind. Der Aufwandist allerdings doppelt exponentiell.

Intuition:

• Mal was positives: Solange man kein ∗ hat, ist keine Kreativität, nur vielRechenpower erforderlich.

• Entscheidungsprozeduren gibt es auch für andere „einfache“Datentypen (und Aussagenlogik!); werden auch verwendet(z. B. SAL, automatische Beweiser, abstrakte Interpretation)

• Kombination mehrerer Entscheidungsprozeduren und mit zus.Funktionen schwierig (wann was versuchen?)

99

Problem: Prädikatenlogik reicht nicht

Problem: Prädikatenlogik kann nicht ausdrücken, dass es ausser denZahlen 0, 1, 2 (= die aus 0 und +1 gebildeten Terme 0, 0 +1, 0 +1 +1, . . .) keineweiteren Elemente gibt.

Dasselbe Problem gibt es auch für andere Datentypen:

• Alle ganzen Zahlen sind mit 0, +1, −1 gebildet

• Alle Listen sind die aus [] und + gebildeten Terme:[], a + [], a + b + [], . . .⋆ Bei Listen: Terme dürfen Elementvariablen enthalten

• Alle (endlichen) Graphen bekommt man aus dem leeren ∅, durchAddieren von Knoten addnode und Kanten addedge

• Alle Arrays bekommt man durch:⋆ mkarray(n) (erzeugt Array der Grösse n)⋆ put(a, i, d) (schreibt an Position i das Datum d)

100

Generiertheitsklauseln: Syntax

Deshalb Idee: Wir definieren ein “Spezialaxiom”, genanntGeneriertheitsklausel, das aussagt: Die Daten eines Datentyps sind genaudie mit bestimmten Konstruktoren gebildeten Terme.

Syntaxs generated by C ist Termerzeugtheitsklausel (∈ Gen(Σ)) ⇔

• s ∈ S, C = {f1, . . . , fn} ⊆ OP ,

• die Konstruktoren fi haben die Ergebnissorte s (Konstanten sind alsKonstruktoren erlaubt)

• für wenigstens ein fi sind alle Argumentsorten ungleich s(sonst gibt es keine Konstruktorterme!)

Ein Konstruktorterm t hat die Sorte s, ist mit Konstruktoren gebildet undenthält nur Variablen anderer Sorten, ist also aus Ts((S,C),X \Xs).

101

Generiertheitsklauseln: Semantik

Idee: Jedes Element der generierten Sorte ist der Wert einesKonstruktorterms, wenn man die (Parameter)-Variablen geeignet belegt.

Semantik

A |= s generated by C :⇔für jedes a ∈ As gibt es ein v und t ∈ Ts((S,C),X \Xs) mit a = [[t]]A,v.

Beispiel: Zur Liste [2,5] gibt es den Konstruktorterm a+ b+ [].

Mit einer Belegung v der Variablen a, b als v(a) = 2 und v(b) = 5 gilt:

[[a+ b+ []]]A,v = [2,5].

102

Elementare Spezifikation

Elementare SpezifikationEine Spezifikation SP = (Σ, Ax , Gen) ist ein Tripel mit:

• Σ = (S, OP )

• Ax ⊆ For(Σ, X) endlich

• Gen ⊆ Gen(Σ) endlich

ModellA ist Modell von SP (A |= SP , A ∈ Mod(SP ))

A |= SP :⇔ A ∈ Alg(Σ), A |= Gen und A |= Ax .

GültigkeitSP |= ϕ :⇔ für alle A in Mod(SP ): A |= ϕ

103

Konsistenz und Monomorphie

Definition Eine Spezifikation ist konsistent:⇔ Axiome nicht widersprüchlich⇔ Kein Beweis von false möglich⇔ Es gibt ein Modell A der Spezifikation

⇒ Das muss sein!

Definition Eine Spezifikation ist monomorph:⇔ Axiome legen Verhalten eindeutig fest⇔ Je zwei Modelle sind bis auf Umbenennung (Isomorphie) gleich

⇒ Sollte für Datentypen wie natürliche Zahlen etc. so sein(die Axiome sollten ja nicht versehentlich auch reelle Zahlen erlauben).

⇒ Für Systembeschreibungen oft nicht erforderlich bzw. wünschenswert.Man will ja gerade Details offenlassen.

104

Minimale Spez. der natürlichen Zahlen in KIV

specificationsorts nat;constants 0 : nat;functions . +1 : nat → nat;induction nat generated by 0, +1;variables m, n : nat;axioms0 6= n +1;m 6= n → m +1 6= n +1;

end specification

ist konsistent und mononorph

105

Spez. der natürlichen Zahlen mit Add. und Mult.

specificationsorts nat;constants 0 : nat;functions . +1 : nat → nat;

. + . : nat × nat → nat;

. ∗ . : nat × nat → nat;induction nat generated by 0, +1;variables m, n : nat;axioms0 6= n +1;m 6= n → m +1 6= n +1;m + 0 = m; m + n +1 = (m + n) +1;m ∗ 0 = 0; m ∗ n +1 = m * n + m;

end specification

ist konsistent und mononorph106

Minimale Spez. der Listen in KIV

specificationsorts elem; list;constants [] : list;functions . + . : elem × list → list;induction list generated by [], +;variables a, b : elem;

x, y : list;axioms[] 6= a + x;a 6= b ∨ x 6= y → a + x 6= b + y;

end specification

ist konsistent und mononorph

107

Kalkül mit struktureller Induktion

Strukturelle Induktion

Sorte s erzeugt von Konstruktoren c, f ⇒ Jedes Element der Trägermengeist darstellbar als Konstruktorterm f(f(. . . f(c)))

Induktionsformeln: ϕ(c) ∧ (∀ x. ϕ(x) → ϕ(f(x))) → ∀ x. ϕ(x)

Induktionsregel:⊢ ϕ(c) ϕ(x) ⊢ ϕ(f(x))

Γ ⊢ ∆

ϕ = ∀ y.∧

Γ →∨

∆, y = free(Γ → ∆) \ {x}

AbleitungWenn man aus der Spezifikation SP durch Anwendung vonSequenzenkalkül + Induktions-Regel die Formel ϕ ableiten kann, dannschreibt man SP ⊢IND ϕ.

108

Kalkül mit struktureller Induktion:Korrektheit und Unvollständigkeit

Satz (Korrektheit)Es gilt SP ⊢IND ϕ ⇒ SP |= ϕ

Satz (Unvollständigkeit)Es gibt Spezifikationen und Theoreme mit SP |= ϕ, die aber mit Induktionnicht beweisbar sind (SP 6⊢IND ϕ).

109

Ein Beispiel für Unvollständigkeit (1)

x from a = die Liste ab dem erstem Vorkommen des Elements a (exklusiv).Falls das Element nicht vorkommt, die leere Liste.

specificationsorts elem; list;constants [] : list;functions . + . : elem × list → list;

. from . : list × elem → list;induction list generated by [], +;variables a, b : elem; x, y : list;axioms[] 6= a + x; a 6= b ∨ x 6= y → a + x 6= b + y;

[] from a = [];(a + x) from a = x;a 6= b → (b + x) from a = x from a;

end specification110

Ein Beispiel für Unvollständigkeit (2)

• Die Spezifikation ist monomorph: Sie hat Listen als einziges Modell A.

• Für die Funktion from gilt das Theorem ϕ (x) :=x 6= [] → x from a 6= x

• Es lässt sich ϕ ([]), ϕ (b+ []), . . . beweisen:[] 6= [] → [] from a 6= []b+ [] 6= [] → (b+ []) from a 6= []b+ c+ [] 6= [] → (b+ c+ []) from a 6= []b+ c+ d+ [] 6= [] → (b+ c+ d+ []) from a 6= []. . .

• Induktionsschluss klappt nicht: x from a 6= x→ (b+ x) from a 6= b+ x

• Man muss die Aussage für Induktion verallgemeinern:x 6= [] → x from a < x

x 6= [] → # (x from a) < # x

• Aber: Das braucht ein neues Prädikat < (ist Endstück) oder # (Länge).

• Beide können rekursiv definiert werden.111

Wie schlimm ist Unvollständigkeit?

• Der Kalkül mit der Induktions-Regel ist „fast vollständig“:Wenn SP |= ϕ, dann gibt es eine Erweiterung SP ′ von SP um neuerekursiv definierte Funktionen, so dass SP ′ ⊢IND ϕ gilt.

• Praktisch gesehen: Mit den zusätzlichen Symbolen in SP ′ wird einepassend (verallgemeinerte) Induktionshypothesefür den Beweis von ϕ ausdrückbar.

• Die Induktionsregel wird auf neue Formeln anwendbar.

• SP ′ ist je nach ϕ verschieden (kein uniformes SP ′).

• In jedem SP ′ gibt es neue Formeln ψ, die wahr aber nicht ableitbar sind.

• Kreativitität also für Verallgemeinerung und passende Hilfsfunktionen.

112