reorganise world Implication
This commit is contained in:
Jon Eugster
@@ -0,0 +1,40 @@
|
||||
import TestGame.Metadata
|
||||
|
||||
set_option tactic.hygienic false
|
||||
|
||||
Game "TestGame"
|
||||
World "Implication"
|
||||
Level 1
|
||||
|
||||
Title "Intro"
|
||||
|
||||
Introduction
|
||||
"
|
||||
## Implikationen
|
||||
|
||||
In diesem Kapitel lernst du Implikation ($\\Rightarrow$) und Genau-dann-wenn
|
||||
($\\Leftrightarrow$) kennen.
|
||||
Dazu lernst du, wie man bereits bewiesene Sätze verwendet.
|
||||
|
||||
Seien `(A B : Prop)` zwei logische Aussagen. Eine Implikation $A \\Rightarrow B$ schreibt
|
||||
man in Lean als `A → B` (`\\to`).
|
||||
|
||||
Wenn das Goal eine Implikation $A \\Rightarrow B$ ist, kann man mit
|
||||
`intro ha` annehmen, dass $A$ wahr ist. Dann muss man $B$ beweisen.
|
||||
"
|
||||
|
||||
Statement
|
||||
"Wenn $B$ wahr ist, dann ist die Implikation $A \\Rightarrow (A ∧ B)$ wahr."
|
||||
(A B : Prop) (hb : B) : A → (A ∧ B) := by
|
||||
intro hA
|
||||
constructor
|
||||
assumption
|
||||
assumption
|
||||
|
||||
Hint (A : Prop) (B : Prop) (hb : B) : A → (A ∧ B) =>
|
||||
"Mit `intro ha` kann man annehmen, dass $A$ wahr ist. danach muss man $A \\land B$ zeigen."
|
||||
|
||||
Message (A : Prop) (B : Prop) (ha : A) (hb : B) : (A ∧ B) =>
|
||||
"Jetzt kannst du die Taktiken aus dem letzten Kapitel verwenden."
|
||||
|
||||
Tactics intro constructor assumption
|
||||
@@ -0,0 +1,42 @@
|
||||
import TestGame.Metadata
|
||||
|
||||
set_option tactic.hygienic false
|
||||
|
||||
Game "TestGame"
|
||||
World "Implication"
|
||||
Level 2
|
||||
|
||||
Title "Revert"
|
||||
|
||||
Introduction
|
||||
"
|
||||
Mit `intro` kann man also eine Implikation aus dem Goal entfernen, indem man
|
||||
die Implikationsprämisse zu den *Annahmen* hinzufügt:
|
||||
|
||||
```
|
||||
example : A → B :=
|
||||
[Beweis]
|
||||
```
|
||||
|
||||
wird zu
|
||||
|
||||
```
|
||||
example (ha : A) : B :=
|
||||
[Beweis]
|
||||
```
|
||||
|
||||
Seltener kann auch die andere Richtung nützlich sein. Mit `revert ha` kann man die Annahme
|
||||
`ha` entfernen und als Implikationsprämisse vor's Goal hängen.
|
||||
"
|
||||
|
||||
Statement
|
||||
"Angenommen $A$ ist eine wahre Aussage und man hat eine Implikation $A \\Rightarrow B$, zeige
|
||||
dass $B$ wahr ist."
|
||||
(A B : Prop) (ha : A) (h : A → B) : B := by
|
||||
revert ha
|
||||
assumption
|
||||
|
||||
Hint (A : Prop) (B : Prop) (ha : A) (h : A → B): B =>
|
||||
"Mit `revert ha` kann man die Annahme `ha` als Implikationsprämisse vorne ans Goal anhängen."
|
||||
|
||||
Tactics revert assumption
|
||||
@@ -0,0 +1,41 @@
|
||||
import TestGame.Metadata
|
||||
import Mathlib
|
||||
|
||||
Game "TestGame"
|
||||
World "Implication"
|
||||
Level 3
|
||||
|
||||
Title "Apply"
|
||||
|
||||
Introduction
|
||||
"
|
||||
`revert` ist aber nur selten der richtige Weg.
|
||||
|
||||
Im vorigen Beispiel würde man besser die Implikation $A \\Rightarrow B$ *anwenden*, also
|
||||
sagen \"Es genügt $A$ zu zeigen, denn $A \\Rightarrow B$\" und danach $A$ beweisen.
|
||||
|
||||
Wenn man eine Implikation `(g : A → B)` in den Annahmen hat, bei welcher die Konsequenz
|
||||
(also $B$) mit dem Goal übereinstimmt, kann man `apply g` genau dies machen.
|
||||
"
|
||||
|
||||
Statement
|
||||
"Seien $A, B$ logische Aussagen, wobei $A$ wahr ist und $A \\Rightarrow B$.
|
||||
Zeige, dass $B$ wahr ist."
|
||||
(A B : Prop) (hA : A) (g : A → B) : B := by
|
||||
apply g
|
||||
assumption
|
||||
|
||||
Hint (A : Prop) (B : Prop) (hA : A) (g : A → B) : B =>
|
||||
"Mit `apply g` kannst du die Implikation `g` anwenden."
|
||||
|
||||
Hint (A : Prop) (B : Prop) (hA : A) (g : A → B) : A =>
|
||||
"Nachdem du die Implikation `A → B` angewendet hast, musst du nur noch $A$ zeigen,
|
||||
dafür hast du bereits einen Beweis in den Annahmen."
|
||||
|
||||
Tactics apply assumption
|
||||
|
||||
-- Katex notes
|
||||
-- `\\( \\)` or `$ $` for inline
|
||||
-- and `$$ $$` block.
|
||||
-- align block:
|
||||
-- $$\\begin{aligned} 2x - 4 &= 6 \\\\ 2x &= 10 \\\\ x &= 5 \\end{aligned}$$
|
||||
@@ -0,0 +1,35 @@
|
||||
import TestGame.Metadata
|
||||
|
||||
set_option tactic.hygienic false
|
||||
|
||||
Game "TestGame"
|
||||
World "Implication"
|
||||
Level 4
|
||||
|
||||
Title "Implikation"
|
||||
|
||||
Introduction
|
||||
"
|
||||
Hier eine Übung zu Implikationen.
|
||||
Fast immer ist es der richtige Weg, wenn du mit `intro` anfängst.
|
||||
"
|
||||
|
||||
Statement
|
||||
"Angenommen man weiss $A \\Rightarrow B \\Rightarrow C$, zeige dass $A \\Rightarrow C$."
|
||||
(A B C : Prop) (f : A → B) (g : B → C) : A → C := by
|
||||
intro hA
|
||||
apply g
|
||||
apply f
|
||||
assumption
|
||||
|
||||
Hint (A : Prop) (B : Prop) (C : Prop) (f : A → B) (g : B → C) : A → C =>
|
||||
"Mit `intro hA` kann man annehmen, dass $A$ wahr ist. danach muss man $B$ zeigen."
|
||||
|
||||
Message (A : Prop) (B : Prop) (C : Prop) (hA : A) (f : A → B) (g : B → C) : C =>
|
||||
"Jetzt ist es ein altbekanntes Spiel von `apply`-Anwendungen."
|
||||
|
||||
Hint (A : Prop) (B : Prop) (C : Prop) (hA : A) (f : A → B) (g : B → C) : C =>
|
||||
"Du willst $C$ beweisen. Suche also nach einer Implikation $\\ldots \\Rightarrow C$ und wende
|
||||
diese mit `apply` an."
|
||||
|
||||
Tactics intro apply assumption revert
|
||||
@@ -0,0 +1,53 @@
|
||||
import TestGame.Metadata
|
||||
|
||||
Game "TestGame"
|
||||
World "Implication"
|
||||
Level 5
|
||||
|
||||
Title "Implikation"
|
||||
|
||||
Introduction
|
||||
"
|
||||
Noch eine Übung: Angenommen man hat folgende Implikationen:
|
||||
$$
|
||||
\\begin{CD}
|
||||
A @>{f}>> B @<{g}<< C \\\\
|
||||
@. @V{h}VV @V{m}VV \\\\
|
||||
D @>{i}>> E @>{k}>> F
|
||||
\\end{CD}
|
||||
$$
|
||||
"
|
||||
|
||||
Statement
|
||||
"Beweise $A \\Rightarrow F$."
|
||||
(A B C D E F : Prop) (f : A → B) (g : C → B) (h : B → E)
|
||||
(i : D → E) (k : E → F) (m : C → F) : A → F := by
|
||||
intro ha
|
||||
apply k
|
||||
apply h
|
||||
apply f
|
||||
assumption
|
||||
|
||||
Hint (A : Prop) (B : Prop) (C : Prop) (D : Prop) (E : Prop) (F : Prop)
|
||||
(f : A → B) (g : C → B) (h : B → E)
|
||||
(i : D → E) (k : E → F) (m : C → F) : A → F =>
|
||||
"Wieder ist es schlau, mit `intro` anzufangen."
|
||||
|
||||
Hint (A : Prop) (B : Prop) (C : Prop) (D : Prop) (E : Prop) (F : Prop)
|
||||
(hA : A) (f : A → B) (g : C → B) (h : B → E)
|
||||
(i : D → E) (k : E → F) (m : C → F) : F =>
|
||||
"Versuch mit `apply` den richtigen Weg zu finden."
|
||||
|
||||
Message (A : Prop) (B : Prop) (C : Prop) (D : Prop) (E : Prop) (F : Prop)
|
||||
(hA : A) (f : A → B) (g : C → B) (h : B → E)
|
||||
(i : D → E) (k : E → F) (m : C → F) : C =>
|
||||
"Sackgasse. Probier doch einen anderen Weg."
|
||||
|
||||
Message (A : Prop) (B : Prop) (C : Prop) (D : Prop) (E : Prop) (F : Prop)
|
||||
(hA : A) (f : A → B) (g : C → B) (h : B → E)
|
||||
(i : D → E) (k : E → F) (m : C → F) : D =>
|
||||
"Sackgasse. Probier doch einen anderen Weg."
|
||||
|
||||
Tactics apply assumption revert intro
|
||||
|
||||
-- https://www.jmilne.org/not/Mamscd.pdf
|
||||
@@ -0,0 +1,43 @@
|
||||
import TestGame.Metadata
|
||||
|
||||
Game "TestGame"
|
||||
World "Implication"
|
||||
Level 6
|
||||
|
||||
Title "Genau dann wenn"
|
||||
|
||||
Introduction
|
||||
"
|
||||
Genau-dann-wenn, $A \\Leftrightarrow B$, wird als `A ↔ B` (`\\iff`) geschrieben.
|
||||
`A ↔ B` ist eine Struktur (ähnlich wie das logische UND), die aus zwei Teilen besteht:
|
||||
|
||||
- `mp`: die Implikation $A \\Rightarrow B$.
|
||||
- `mpr`: die Implikation $B \\Rightarrow A$.
|
||||
|
||||
Hat man ein $\\Leftrightarrow$ im Goal, nimmt man dieses ebenfalls mit der Taktik
|
||||
`constructor` auseinander und zeigt dann beide Richtungen einzeln.
|
||||
"
|
||||
|
||||
Statement
|
||||
"Zeige dass `B ↔ C`."
|
||||
(A B : Prop) (mp : A → B) (mpr : B → A) : A ↔ B := by
|
||||
constructor
|
||||
assumption
|
||||
assumption
|
||||
|
||||
Hint (A : Prop) (B : Prop) : A ↔ B =>
|
||||
"Eine Struktur wie `A ↔ B` kann man mit `constructor` zerlegen."
|
||||
|
||||
Hint (A : Prop) (B : Prop) (h : A → B) : A → B =>
|
||||
"Such mal in den Annahmen."
|
||||
|
||||
Conclusion
|
||||
"
|
||||
Die Taktik `constructor` heisst so, weil `↔` als \"Struktur\" definiert ist, die
|
||||
aus mehreren Einzelteilen besteht: `⟨A → B, B → A⟩`. Man sagt also Lean, es soll versuchen,
|
||||
ob das Goal aus solchen Einzelteilen \"konstruiert\" werden kann.
|
||||
"
|
||||
|
||||
Tactics constructor assumption
|
||||
|
||||
-- TODO : `case mpr =>` ist mathematisch noch sinnvoll.
|
||||
@@ -0,0 +1,74 @@
|
||||
import TestGame.Metadata
|
||||
|
||||
import Init.Data.ToString
|
||||
-- #check List UInt8
|
||||
|
||||
Game "TestGame"
|
||||
World "Implication"
|
||||
Level 7
|
||||
|
||||
Title "Genau dann wenn"
|
||||
|
||||
Introduction
|
||||
"
|
||||
Hat man ein `(h : A ↔ B)` in den Annahmen, hat man die gleichen beiden Optionen wie beim
|
||||
logischen UND plus noch eine neue:
|
||||
|
||||
1. Mit `h.mp` und `h.mpr` (oder `h.1` und `h.2`) kann man die einzelnen Implikationen
|
||||
direkt auswählen.
|
||||
2. Mit `rcases h with ⟨h₁, h₂⟩` könnte man die Struktur `h` zerlegen und man erhält zwei
|
||||
separate Annahmen `(h₁ : A → B)` und `(h₂ : B → A)`
|
||||
3. **Mit** `rw [h]` **kann man im Goal `A` durch `B` ersetzen.**
|
||||
|
||||
Wir widmen uns zuerst `rw`. Dies steht für \"rewrite\". Da $A$ und $B$ logisch äquivalent
|
||||
sind, kann man beliebig das eine mit dem anderen vertauschen.
|
||||
`rw [h]` ersetzt $A$ durch $B$.
|
||||
Dabei gibt es noch einige Tricks:
|
||||
|
||||
- `rw [← h]` ersetzt umgekehrt $B$ durch $A$ (`\\l`, kleines L).
|
||||
- `rw [h, g]` ist das gleiche wie `rw [h]` gefolgt von `rw [g]`.
|
||||
"
|
||||
|
||||
Statement
|
||||
"Zeige dass `B ↔ C`."
|
||||
(A B C D : Prop) (h₁ : C ↔ D) (h₂ : A ↔ B) (h₃ : A ↔ D) : B ↔ C := by
|
||||
rw [h₁]
|
||||
rw [←h₂]
|
||||
assumption
|
||||
|
||||
Hint (A : Prop) (B : Prop) (C : Prop) (D : Prop) (h₁ : C ↔ D) (h₂ : A ↔ B) (h₃ : A ↔ D) : B ↔ C =>
|
||||
"Im Goal kommt `C` vor und `h₁` sagt `C ↔ D`.
|
||||
Probiers doch mit `rw [h₁]`."
|
||||
|
||||
Hint (A : Prop) (B : Prop) (C : Prop) (D : Prop) (h₁ : C ↔ D) (h₂ : A ↔ B) (h₃ : A ↔ D) : A ↔ C =>
|
||||
"Im Goal kommt `C` vor und `h₁` sagt `C ↔ D`.
|
||||
Probiers doch mit `rw [h₁]`."
|
||||
|
||||
Message (A : Prop) (B : Prop) (C : Prop) (D : Prop) (h₁ : C ↔ D) (h₂ : A ↔ B) (h₃ : A ↔ D) : B ↔ D =>
|
||||
"Man kann auch rückwärts umschreiben:
|
||||
`rw [←h₂]` ersetzt man im Goal `B` durch `a` (`\\l`, also ein kleines L)"
|
||||
|
||||
Hint (A : Prop) (B : Prop) (h : A ↔ B) : A ↔ B =>
|
||||
"Schau mal durch die Annahmen durch."
|
||||
|
||||
|
||||
-- These should not be necessary if they don't use `rw [] at`.
|
||||
Hint (A : Prop) (B : Prop) (C : Prop) (D : Prop) (h₁ : C ↔ D) (h₂ : A ↔ B) (h₃ : A ↔ C) : B ↔ C =>
|
||||
"Auch eine Möglichkeit... Kannst du das Goal so umschreiben,
|
||||
dass es mit einer Annahme übereinstimmt?"
|
||||
|
||||
Hint (A : Prop) (B : Prop) (C : Prop) (D : Prop) (h₁ : C ↔ D) (h₂ : A ↔ B) (h₃ : B ↔ D) : B ↔ C =>
|
||||
"Auch eine Möglichkeit.. Kannst du das Goal so umschreiben, dass es mit einer Annahme übereinstimmt?"
|
||||
|
||||
Message (A : Prop) (B : Prop) (h : B ↔ A) : A ↔ B =>
|
||||
"Naja auch Umwege führen ans Ziel... Wenn du das Goal zu `A ↔ A` umschreibst, kann man es mit
|
||||
`rfl` beweisen (rsp. das passiert automatisch.)"
|
||||
|
||||
Message (A : Prop) (B : Prop) (C : Prop) (D : Prop) (h₁ : C ↔ D) (h₂ : D ↔ B) (h₃ : D ↔ A) : B ↔ C =>
|
||||
"Das ist nicht der optimale Weg..."
|
||||
|
||||
Message (A : Prop) (B : Prop) (C : Prop) (D : Prop) (h₁ : C ↔ D) (h₂ : D ↔ B) (h₃ : A ↔ D) : B ↔ C =>
|
||||
"Das ist nicht der optimale Weg..."
|
||||
|
||||
|
||||
Tactics rw assumption
|
||||
@@ -0,0 +1,44 @@
|
||||
import TestGame.Metadata
|
||||
|
||||
set_option tactic.hygienic false
|
||||
|
||||
Game "TestGame"
|
||||
World "Implication"
|
||||
Level 8
|
||||
|
||||
Title "Genau dann wenn"
|
||||
|
||||
Introduction
|
||||
"
|
||||
Nun schauen wir uns Option 1) an, die du schon von UND kennst:
|
||||
|
||||
1. Mit `h.mp` und `h.mpr` (oder `h.1` und `h.2`) kann man die einzelnen Implikationen
|
||||
direkt auswählen.
|
||||
|
||||
`h.mp` und `h.mpr` (oder `h.1` und `h.2`) sind die einzelnen Implikationen, und du kannst
|
||||
mit denen ensprechend arbeiten. Insbesondere kannst du mit `apply h.mp` die Implikation
|
||||
$A \\Rightarrow B$ anwenden, wenn das Goal $B$ ist.
|
||||
|
||||
*(PS: das `.mp` kommt von \"Modus Ponens\", ein Ausdruck as der Logik.)*
|
||||
"
|
||||
|
||||
Statement
|
||||
"Angenommen man hat $A \\iff B$ und $B \\Rightarrow C$, zeige $A \\Rightarrow C$."
|
||||
(A B C : Prop) (h : A ↔ B) (g : B → C) : A → C := by
|
||||
intro hA
|
||||
apply g
|
||||
apply h.mp
|
||||
assumption
|
||||
|
||||
Hint (A : Prop) (B : Prop) (C : Prop) (h : A ↔ B) (g : B → C) : A → C =>
|
||||
"Fange wie immer mit `intro` an."
|
||||
|
||||
Hint (A : Prop) (B : Prop) (C : Prop) (h : A ↔ B) (g : B → C) (hA : A) : C =>
|
||||
"Wie im Implikationen-Level kannst du nun `apply` verwenden."
|
||||
|
||||
Message (A : Prop) (B : Prop) (C : Prop) (h : A ↔ B) (g : B → C) (hA : A) : B =>
|
||||
"Mit `apply h.mp` kannst du nun die Implikation `A → B` anwenden."
|
||||
|
||||
Conclusion "Im nächsten Level findest du die zweite Option."
|
||||
|
||||
Tactics apply assumption
|
||||
@@ -0,0 +1,51 @@
|
||||
import TestGame.Metadata
|
||||
import Std.Tactic.RCases
|
||||
import Mathlib.Tactic.Cases
|
||||
|
||||
Game "TestGame"
|
||||
World "Implication"
|
||||
Level 9
|
||||
|
||||
Title "Genau dann wenn"
|
||||
|
||||
Introduction
|
||||
"
|
||||
Und noch die letzte Option:
|
||||
|
||||
2. Mit `rcases h with ⟨h₁, h₂⟩` könnte man die Struktur `h` zerlegen und man erhält zwei
|
||||
separate Annahmen `(h₁ : A → B)` und `(h₂ : B → A)`
|
||||
|
||||
Als letzte Option kannst du `rcases h with ⟨h₁, h₂⟩` auch auf eine Annahme `(h : A ↔ B)`
|
||||
anwenden, genau wie du dies bei einer Annahme `(h' : A ∧ B)` gemacht hast.
|
||||
"
|
||||
Statement
|
||||
"Angenommen man hat $A \\iff B$ und $B \\Rightarrow C$, zeige $A \\Rightarrow C$."
|
||||
(A B : Prop) : (A ↔ B) → (A → B) := by
|
||||
intro h
|
||||
rcases h
|
||||
assumption
|
||||
|
||||
Hint (A : Prop) (B : Prop) : (A ↔ B) → A → B =>
|
||||
"Angefangen mit `intro h` kannst du annehmen, dass `(h : A ↔ B)` wahr ist."
|
||||
|
||||
Hint (A : Prop) (B : Prop) (h : A ↔ B) : A → B =>
|
||||
"Mit `rcases h with ⟨h₁, h₂⟩` kannst du jetzt die Annahme `(h : A ↔ B)` zerlegen."
|
||||
|
||||
|
||||
Conclusion
|
||||
"
|
||||
"
|
||||
|
||||
Tactics intro apply rcases assumption
|
||||
|
||||
-- -- TODO: The new `cases` works differntly. There is also `cases'`
|
||||
-- example (A B : Prop) : (A ↔ B) → (A → B) := by
|
||||
-- intro h
|
||||
-- cases h with
|
||||
-- | intro a b =>
|
||||
-- assumption
|
||||
|
||||
-- example (A B : Prop) : (A ↔ B) → (A → B) := by
|
||||
-- intro h
|
||||
-- cases' h with a b
|
||||
-- assumption
|
||||
@@ -0,0 +1,55 @@
|
||||
import TestGame.Metadata
|
||||
import Std.Tactic.RCases
|
||||
import Mathlib.Tactic.Cases
|
||||
import Mathlib
|
||||
|
||||
Game "TestGame"
|
||||
World "Implication"
|
||||
Level 10
|
||||
|
||||
Title "Lemmas"
|
||||
|
||||
Introduction
|
||||
"
|
||||
Bewiesene Resultate möchte man in späteren Aufgaben als Sätze wieder verwenden.
|
||||
|
||||
In Lean sind das Lemmas und Theoreme (wobei es keinen Unterschied zwischen `lemma` und `theorem`
|
||||
gibt).
|
||||
|
||||
Links in der Bibliothek findest du bekannte Lemmas. Wenn das Goal mit der Aussage des Lemmas
|
||||
übereinstimmt, kannst du es mit `apply [Lemma-Name]` anwenden, wie du das mit Implikationen auch
|
||||
machst.
|
||||
|
||||
Zum Beispiel gibt es ein Lemma, das sagt, dass wenn
|
||||
$A \\Rightarrow B$ dann $(\\neg A \\lor B)$:
|
||||
|
||||
```
|
||||
lemma not_or_of_imp : (A B : Prop) (h : A → B) :
|
||||
¬A ∨ B := by
|
||||
...
|
||||
```
|
||||
|
||||
Wenn also dein Goal `¬A ∨ B` ist, kannst du mit `apply not_or_of_imp` dieses
|
||||
Lemma anwenden. Danach musst du noch alle Annahmen zeigen.
|
||||
"
|
||||
|
||||
Statement
|
||||
"Benutze `not_or_of_imp` um zu zeigen, dass $\\neg A \\lor A$ wahr ist."
|
||||
(A : Prop) : ¬A ∨ A := by
|
||||
apply not_or_of_imp
|
||||
intro
|
||||
assumption
|
||||
|
||||
Hint (A : Prop) : ¬A ∨ A =>
|
||||
"Das Lemma wendest du mit `apply not_or_of_imp` an."
|
||||
|
||||
Hint (A : Prop) : A → A =>
|
||||
"Wie immer, `intro` ist dein Freund."
|
||||
|
||||
Conclusion
|
||||
"
|
||||
"
|
||||
|
||||
Tactics apply left right assumption
|
||||
|
||||
Lemmas not_or_of_imp
|
||||
@@ -0,0 +1,39 @@
|
||||
import TestGame.Metadata
|
||||
import Std.Tactic.RCases
|
||||
import Mathlib.Tactic.Cases
|
||||
import Mathlib.Logic.Basic
|
||||
|
||||
Game "TestGame"
|
||||
World "Implication"
|
||||
Level 11
|
||||
|
||||
Title "Lemmas"
|
||||
|
||||
Introduction
|
||||
"
|
||||
Wenn die Aussage eines Lemmas eine Äquivalenz ist, kann man dieses auch mit `rw` brauchen,
|
||||
wie du es von Äquivalenzen kennst.
|
||||
|
||||
Ein wichtiges Lemma ist dass $\\neg(\\neg A))$ und $A$ äquivalent sind:
|
||||
|
||||
```
|
||||
lemma not_not (A : Prop) : ¬¬A ↔ A := by
|
||||
...
|
||||
```
|
||||
|
||||
Mit `rw [not_not]` sucht Lean also im Goal ein Term `¬¬(·)` und entfernt dort das `¬¬`.
|
||||
"
|
||||
|
||||
Statement
|
||||
"Zeige, dass $A ∨ (¬¬B) ∧ C$ und $A ∨ B ∧ C$ äquivalent sind."
|
||||
(A B C : Prop) : A ∨ (¬¬B) ∧ C ↔ A ∨ B ∧ C := by
|
||||
rw [not_not]
|
||||
|
||||
Conclusion
|
||||
"
|
||||
`rw` hat automatisch `rfl` ausgeführt und dadurch den Beweis beendet.
|
||||
"
|
||||
|
||||
Tactics rw
|
||||
|
||||
Lemmas not_not not_or_of_imp
|
||||
@@ -0,0 +1,81 @@
|
||||
import TestGame.Metadata
|
||||
import Std.Tactic.RCases
|
||||
import Mathlib.Tactic.LeftRight
|
||||
import Mathlib
|
||||
|
||||
set_option tactic.hygienic false
|
||||
|
||||
Game "TestGame"
|
||||
World "Implication"
|
||||
Level 12
|
||||
|
||||
Title "Zusammenfassung"
|
||||
|
||||
Introduction
|
||||
"
|
||||
Damit bist du am Ende der zweiten Lektion angekommen.
|
||||
Hier ein Überblick über alles was in diesem Kapitel eingeführt wurde und eine
|
||||
Abschlussaufgabe.
|
||||
|
||||
## Notationen / Begriffe
|
||||
|
||||
| | Beschreibung |
|
||||
|:--------------|:---------------------------------------------------------|
|
||||
| → | Eine Implikation. |
|
||||
| ↔ | Genau-dann-wenn / Äquivalenz. |
|
||||
| `lemma` | Ein Resultat mit einem Namen. |
|
||||
| `theorem` | Das gleiche wie ein Lemma. |
|
||||
| `example` | Wie ein Lemma aber ohne Namen (nicht weiter verwendbar.) |
|
||||
|
||||
## Taktiken
|
||||
|
||||
| | Taktik | Beispiel |
|
||||
|:----|:--------------------------|:-------------------------------------------------------|
|
||||
| 8 | `intro` | Für eine Implikation im Goal. |
|
||||
| 9 | `revert` | Umkehrung von `intro`. |
|
||||
| 10 | `apply` | Wendet eine Implikation auf das Goal an. |
|
||||
| 10ᵇ | `apply` | Wendet ein Lemma an. |
|
||||
| 11 | `rw` | Umschreiben zweier äquivalenter Aussagen. |
|
||||
| 11ᵇ | `rw` | Benutzt ein Lemma, dessen Aussage eine Äquivalenz ist. |
|
||||
|
||||
|
||||
Als Abschlussübung kannst du folgende Äquivalenz zeigen:
|
||||
"
|
||||
|
||||
Statement imp_iff_not_or
|
||||
"$A \\Rightarrow B$ ist äquivalent zu $\\neg A \\lor B$."
|
||||
(A B : Prop) : (A → B) ↔ ¬ A ∨ B := by
|
||||
constructor
|
||||
apply not_or_of_imp
|
||||
intro h ha
|
||||
rcases h with h | h
|
||||
contradiction
|
||||
assumption
|
||||
|
||||
Hint (A : Prop) (B: Prop) : (A → B) ↔ ¬ A ∨ B =>
|
||||
"Eine Äquivalenz im Goal geht man immer mit `constructor` an."
|
||||
|
||||
Hint (A : Prop) (B: Prop) : (A → B) → ¬ A ∨ B =>
|
||||
"Diese Aussage hast du vorhin bereits als Lemma kennengelernt und angewendet."
|
||||
|
||||
Hint (A : Prop) (B: Prop) (h : A → B) : ¬ A ∨ B =>
|
||||
"Diese Aussage hast du vorhin bereits als Lemma kennengelernt und angewendet."
|
||||
|
||||
Hint (A : Prop) (B: Prop) : ¬ A ∨ B → (A → B) =>
|
||||
"Eine Implikation geht man fast immer mit `intro h` an."
|
||||
|
||||
Hint (A : Prop) (B: Prop) (h : ¬ A ∨ B) : (A → B) =>
|
||||
"Nochmals `intro`."
|
||||
|
||||
Hint (A : Prop) (B: Prop) (h : ¬ A ∨ B) : (A → B) =>
|
||||
"Das ODER in den Annahmen kannst du mit `rcases h with h | h` aufteilen."
|
||||
|
||||
Hint (A : Prop) (B: Prop) (h : ¬ A ∨ B) (ha : A) : B =>
|
||||
"Das ODER in den Annahmen kannst du mit `rcases h with h | h` aufteilen."
|
||||
|
||||
Hint (A : Prop) (B: Prop) (ha : A) (ha' : ¬A) : B =>
|
||||
"Findest du einen Widerspruch?"
|
||||
|
||||
Tactics rfl assumption trivial left right constructor rcases
|
||||
|
||||
Lemmas not_not not_or_of_imp
|
||||
Reference in New Issue
Block a user