rename testgame to adam
This commit is contained in:
Alexander Bentkamp
@@ -0,0 +1,60 @@
|
||||
import TestGame.Metadata
|
||||
import Std.Tactic.RCases
|
||||
import Mathlib.Tactic.LeftRight
|
||||
import Mathlib.Tactic.Contrapose
|
||||
import Mathlib.Tactic.Use
|
||||
import Mathlib.Tactic.Ring
|
||||
|
||||
import TestGame.ToBePorted
|
||||
|
||||
Game "TestGame"
|
||||
World "Contradiction"
|
||||
Level 1
|
||||
|
||||
Title "Have"
|
||||
|
||||
Introduction
|
||||
"
|
||||
**Oddeus**: Willkommen Reisende! Ich muss eingestehen ich bin in Gedanken noch
|
||||
an etwas, könnt ihr mir bei diesem widersprüchlichen Problem helfen?
|
||||
"
|
||||
|
||||
-- Manchmal, wollen wir nicht am aktuellen Goal arbeiten, sondern zuerst ein
|
||||
-- Zwischenresultat beweisen, welches wir dann benützen können.
|
||||
|
||||
-- Mit `have [Name] : [Aussage]` kann man ein Zwischenresultat erstellen,
|
||||
-- dass man anschliessen beweisen muss.
|
||||
|
||||
-- Wenn du zum Beispiel die Annahmen `(h : A → ¬ B)` und `(ha : A)` hast, kannst
|
||||
-- du mit
|
||||
-- ```
|
||||
-- have g : ¬ B
|
||||
-- apply h
|
||||
-- assumption
|
||||
-- ```
|
||||
-- eine neue Annahme `(g : ¬ B)` erstellen. Danach beweist du zuerst diese Annahme,
|
||||
-- bevor du dann mit dem Beweis forfährst.
|
||||
|
||||
Statement (A B : Prop) (h : A → ¬ B) (k : A ∧ B) : False := by
|
||||
Hint "**Du**: Also als erstes Teile ich wohl mal das Und (`∧`) auf."
|
||||
rcases k with ⟨h₁, h₂⟩
|
||||
Hint "**Du**: Aber jetzt…
|
||||
|
||||
**Robo**: Du könntest dir ein passendes Zwischenresultat zurechtlegen, das dir hilft:
|
||||
Mach mal `have g : ¬ B`!"
|
||||
have g : ¬ B
|
||||
· Hint "**Du**: Was und jetzt hab ich einfach angenommen das sei richtig?
|
||||
|
||||
**Robo**: Ne, jetzt musst du das zuerst beweisen bevor du es dann benützen kannst."
|
||||
Hint (hidden := true) "**Robo**: `apply` scheint passend zu sein."
|
||||
apply h
|
||||
assumption
|
||||
· Hint (hidden := true) "**Du**: Und wie war das nochmals wenn zwei Annahmen sich widersprechen?
|
||||
|
||||
**Robo**: `contradiction`."
|
||||
contradiction
|
||||
|
||||
NewTactic «have»
|
||||
DisabledTactic «suffices»
|
||||
|
||||
Conclusion "*Oddeus*: Das stimmt wohl."
|
||||
@@ -0,0 +1,63 @@
|
||||
import TestGame.Metadata
|
||||
import Std.Tactic.RCases
|
||||
import Mathlib.Tactic.LeftRight
|
||||
import Mathlib.Tactic.Contrapose
|
||||
import Mathlib.Tactic.Use
|
||||
import Mathlib.Tactic.Ring
|
||||
|
||||
import TestGame.ToBePorted
|
||||
|
||||
Game "TestGame"
|
||||
World "Contradiction"
|
||||
Level 2
|
||||
|
||||
Title "Suffices"
|
||||
|
||||
Introduction
|
||||
"
|
||||
*Oddeus*' Partner meldet sich.
|
||||
|
||||
**Partner**: Ich habe letzthin was änliches gesehen, aber irgendwie verdreht.
|
||||
"
|
||||
|
||||
-- Die Taktik `suffices` funktioniert genau gleich wie `have`,
|
||||
-- vertauscht aber die beiden Beweisblöcke:
|
||||
|
||||
-- ```
|
||||
-- suffices h : [Aussage]
|
||||
-- [Beweis des Goals (mithilfe von h)]
|
||||
-- [Beweis der Aussage h]
|
||||
-- ```
|
||||
-- Auf Deutsch entspricht `suffices g : [Aussage]` dem Ausdruck
|
||||
-- \"Es genügt zu zeigen, dass `[Aussage]` wahr ist.\"
|
||||
|
||||
-- Man kann `have` und `suffices` nach belieben vertauschen. Bevorzugt, wählt man es so,
|
||||
-- dass der erste Beweisblock der kürzere ist. Zum Beispiel wäre bei der vorigen Aufgabe
|
||||
-- `suffices` schöner gewesen:
|
||||
|
||||
Statement
|
||||
"Angenommen, man hat eine Implikation $A \\Rightarrow \\neg B$ und weiss, dass
|
||||
$A \\land B$ wahr ist. Zeige, dass dies zu einem Widerspruch führt."
|
||||
(A B : Prop) (h : A → ¬ B) (k₁ : A) (k₂ : B) : False := by
|
||||
Hint "**Robo**: Ich weiss was er meint! Anstatt `have` kannst du auch `suffices`
|
||||
brauchen. Das funktioniert genau gleich, aussert dass dann die beiden Goals vertauscht sind.
|
||||
|
||||
**Du**: Also nach `suffices g : ¬B` muss ich dann zuerst zeigen, wie man mit `g` den Beweis
|
||||
abschliesst bevor ich `g` beweise?
|
||||
|
||||
**Robo**: Genau! Verwendende `have` und `suffices` einfach nach gutdünken."
|
||||
suffices g : ¬ B
|
||||
Hint "**Robo**: Also hier beendest du den Beweis angenommen {g} sei wahr."
|
||||
contradiction
|
||||
Hint "**Robo**: Und hier beweist du das Zwischenresultat."
|
||||
apply h
|
||||
assumption
|
||||
|
||||
NewTactic «suffices»
|
||||
DisabledTactic «have»
|
||||
|
||||
Conclusion "*Oddeus* nimmt den Brief, schaut ihn an und, rollt ihn zusammen.
|
||||
|
||||
**Oddeus**: Ich verstehe meine Schwester nie. Kommt, vielleicht könnt ihr mir helfen.
|
||||
|
||||
Und er führt euch durch seinen Rosengarten."
|
||||
@@ -0,0 +1,65 @@
|
||||
import TestGame.Metadata
|
||||
import Std.Tactic.RCases
|
||||
import Mathlib.Tactic.LeftRight
|
||||
import Mathlib.Tactic.Contrapose
|
||||
import Mathlib.Tactic.Use
|
||||
import Mathlib.Tactic.Ring
|
||||
import Mathlib
|
||||
|
||||
import TestGame.ToBePorted
|
||||
|
||||
Game "TestGame"
|
||||
World "Contradiction"
|
||||
Level 3
|
||||
|
||||
Title "Per Widerspruch"
|
||||
|
||||
Introduction
|
||||
"**Oddeus**: Ich verstehe *Evenine* einfach nicht. Ich will euch auch gleich zeigen,
|
||||
was sie mir letzthin geschrieben hat, aber zuerst schaut einmal unseren
|
||||
wunderschönen Absurda-Tempel an!
|
||||
|
||||
Damit kommt ihr vor einen sehr hohen Turm, der ausschliesslich aus Dornenranken gewachsen
|
||||
scheint.
|
||||
|
||||
**Oddeus**: Versteht ihr, was hier über dem Eingang steht?
|
||||
"
|
||||
|
||||
-- Eine sehr nützliche Beweismethode ist per Widerspruch.
|
||||
|
||||
-- Wir habe schon gesehen, dass `contradiction` einen Widerspruch in den Annahmen
|
||||
-- sucht, und damit jegliches beweisen kann.
|
||||
|
||||
-- Um dorthin zu kommen, können wir `by_contra h` brauchen, welches das aktuelle
|
||||
-- Goal auf `False` setzt und die Negierung des Goals als Annahme hinzufügt.
|
||||
|
||||
-- Insbesondere braucht man `by_contra h` meistens, wenn im Goal eine Negierung
|
||||
-- steht:
|
||||
|
||||
Statement (A B : Prop) (g : A → B) (b : ¬ B) : ¬ A := by
|
||||
Hint "**Robo**: Ein `¬` im Goal heisst häufig, dass du einen Widerspruchsbeweis führen
|
||||
möchtest.
|
||||
|
||||
**Du**: Und wie mach ich das? Mit `contradiction`?
|
||||
|
||||
**Robo**: Mit `by_contra h` fängst du einen an. Mit `contradiction` schliesst du ihn dann
|
||||
später ab."
|
||||
by_contra h
|
||||
Hint "**Robo**: Jetzt hast du also eine Annahme `{h} : ¬ {A}`, und damit musst du einen
|
||||
Widerspruch herbeileiten.
|
||||
|
||||
Ein Methode ist, dass du jetzt mit `suffices` sagts, zu was du denn gerne den Widerspruch
|
||||
haben möchtest, zum Beispiel `suffices k : B`
|
||||
"
|
||||
suffices k : B
|
||||
Hint "**Du**: Ah und jetzt kann ich einfach sagen dass sich die Anahmen `{B}` und `¬{B}`
|
||||
widersprechen."
|
||||
contradiction
|
||||
Hint "**Robo**: Und jetzt kannst du noch das Ergebnis zeigen, das zu einem Widerspruch
|
||||
geführt hat."
|
||||
apply g
|
||||
assumption
|
||||
|
||||
NewTactic by_contra
|
||||
|
||||
Conclusion "**Oddeus**: Sehr gut, kommt mit hinein!"
|
||||
@@ -0,0 +1,51 @@
|
||||
import TestGame.Metadata
|
||||
import Std.Tactic.RCases
|
||||
import Mathlib.Tactic.LeftRight
|
||||
import Mathlib.Tactic.Contrapose
|
||||
import Mathlib.Tactic.Use
|
||||
import Mathlib.Tactic.Ring
|
||||
import Mathlib
|
||||
|
||||
import TestGame.ToBePorted
|
||||
|
||||
Game "TestGame"
|
||||
World "Contradiction"
|
||||
Level 4
|
||||
|
||||
Title "Per Widerspruch"
|
||||
|
||||
Introduction
|
||||
"
|
||||
*Oddeus* Geht zu einem Regal mit vielen Dokumenten und beginnt zu suchen.
|
||||
|
||||
**Oddeus**: Ich hab's gleich. Hier ist eine Notiz meiner Gelehrter, die mir
|
||||
mit solchen kryptischen Nachrichten helfen wollten.
|
||||
|
||||
Auf dem Pergament steht das ein Lemma mit dem Namen `not_imp_not`:
|
||||
"
|
||||
|
||||
Statement not_imp_not (A B : Prop) : A → B ↔ (¬ B → ¬ A) := by
|
||||
Hint "**Du**: Ich glaube, dafür kenn ich das meiste schon."
|
||||
Hint (hidden := true) "**Robo**: Fang doch mal mit `constructor` an."
|
||||
constructor
|
||||
intro h b
|
||||
by_contra a
|
||||
Hint "**Robo**: Zur Erinnerung, hier würde ich mit `suffices g : B` einen Widerspruch
|
||||
herbeiführen."
|
||||
suffices b : B
|
||||
contradiction
|
||||
apply h
|
||||
assumption
|
||||
intro h a
|
||||
Hint "**Robo**: Hier würde ich ebenfalls einen Widerspruch anfangen."
|
||||
by_contra b
|
||||
Hint (hidden := true) "**Robo**: `suffices g : ¬ A` sieht nach einer guten Option aus."
|
||||
suffices g : ¬ A
|
||||
contradiction
|
||||
apply h
|
||||
assumption
|
||||
|
||||
DisabledTactic rw
|
||||
DisabledLemma not_not
|
||||
|
||||
Conclusion "**Du**: Und wie hilft uns das jetzt, was steht denn in dem Brief?"
|
||||
@@ -0,0 +1,70 @@
|
||||
import TestGame.Metadata
|
||||
import Std.Tactic.RCases
|
||||
import Mathlib.Tactic.Contrapose
|
||||
import Mathlib.Tactic.Use
|
||||
import Mathlib.Tactic.Ring
|
||||
|
||||
import TestGame.ToBePorted
|
||||
|
||||
Game "TestGame"
|
||||
World "Contradiction"
|
||||
Level 5
|
||||
|
||||
Title "Kontraposition"
|
||||
|
||||
Introduction
|
||||
"
|
||||
*Oddeus* reicht euch das Papier.
|
||||
|
||||
**Du**: Da steht etwas über `contrapose` hier…
|
||||
|
||||
**Oddeus**: Das ist doch klar eine Aggression uns gegenüber!
|
||||
|
||||
**Robo**: Wartet mal, vielleicht wollte euch eure Schwester einfach von ihren neuen
|
||||
Endeckungen zeigen. Schaut, darunter ist eine Aufgabe.
|
||||
"
|
||||
|
||||
-- Ein Beweis durch Kontraposition benützt im Grunde das eben bewiesene Lemma
|
||||
|
||||
-- ```
|
||||
-- lemma not_imp_not (A B : Prop) : (A → B) ↔ (¬ B → ¬ A) := by
|
||||
-- [...]
|
||||
-- ```
|
||||
|
||||
-- Dazu gibt es die Taktik `contrapose`, welche eine Implikation im Goal
|
||||
-- entsprechend umdreht.
|
||||
|
||||
-- Wir erinnern hier an die Taktik `revert h`, die aus der Annahme `h` eine Implikation
|
||||
-- im Goal erstellt.
|
||||
|
||||
-- Im Gegensatz dazu kann man auch einen Beweis durch Kontraposition führen.
|
||||
-- Das ist kein Widerspruch, sondern benützt dass `A → B` und `(¬ B) → (¬ A)`
|
||||
-- logisch equivalent sind.
|
||||
|
||||
-- Wenn das Goal eine Implikation ist, kann man `contrapose` anwenden.
|
||||
open Nat
|
||||
|
||||
Statement (n : ℕ) (h : Odd (n ^ 2)): Odd n := by
|
||||
Hint "**Oddeus**: Wie soll das den gehen?
|
||||
|
||||
**Robo**: `contrapose` benutzt das Lemma eurer Gelehrter, `not_imp_not`. Also es wandelt
|
||||
ein Goal `A → B` zu `¬B → ¬A ` um.
|
||||
|
||||
**Du**: Aber das Goal ist doch gar keine Implikation?
|
||||
|
||||
**Robo**: Mit `revert {h}` kannst du die Annahme `{h}` als Implikationsannahme ins Goal
|
||||
schieben."
|
||||
revert h
|
||||
Hint "*Oddeus*: Ob man jetzt wohl dieses `contrapose` benutzen kann?"
|
||||
contrapose
|
||||
Hint (hidden := true) "**Du**: Warte mal, jetzt kann man wohl `even_iff_not_odd` verwenden…"
|
||||
rw [← even_iff_not_odd]
|
||||
rw [← even_iff_not_odd]
|
||||
Hint "**Robo**: Und den Rest hast du bei *Evenine* als Lemma gezeigt!"
|
||||
apply even_square
|
||||
|
||||
NewTactic contrapose
|
||||
DisabledTactic by_contra
|
||||
|
||||
Conclusion "**Oddeus**: Ah ich sehe, die Aussage ist, dass wir das nur zusammen lösen konnten.
|
||||
Ich danke euch, darauf wäre ich nie gekommen."
|
||||
@@ -0,0 +1,56 @@
|
||||
import TestGame.Metadata
|
||||
import Std.Tactic.RCases
|
||||
import Mathlib.Tactic.Contrapose
|
||||
import Mathlib.Tactic.Use
|
||||
import Mathlib.Tactic.Ring
|
||||
|
||||
import TestGame.ToBePorted
|
||||
|
||||
Game "TestGame"
|
||||
World "Contradiction"
|
||||
Level 6
|
||||
|
||||
Title "Contradiction"
|
||||
|
||||
Introduction
|
||||
"
|
||||
**Du**: Sag mal Robo, das hätte ich aber auch als Widerspruch anstatt Kontraposition
|
||||
beweisen können?
|
||||
|
||||
**Robo**: Klar. `contrapose` ist eine Kontraposition, `by_contra` ein Widerspruchsbeweis.
|
||||
Probiers doch einfach!
|
||||
In diesem Kapitel hast du also folgende Taktiken kennengelernt:
|
||||
|
||||
|
||||
Als Vergleich zwischen Beweisen \"per Widerspruch\"
|
||||
und \"per Kontraposition\", beweise die Gleiche Aufgabe indem
|
||||
du mit `by_contra` einen Widerspruch suchst.
|
||||
"
|
||||
|
||||
open Nat
|
||||
|
||||
Statement (n : ℕ) (h : Odd (n ^ 2)) : Odd n := by
|
||||
Hint "**Robo**: Fang diesmal mit `by_contra g` an!"
|
||||
by_contra g
|
||||
Hint "**Robo**: Jetzt würde ich einen Widerspruch zu `Odd (n ^ 2)` führen."
|
||||
Hint "**Robo**: Also `suffices g : ¬ Odd (n ^ 2)`."
|
||||
suffices d : ¬ Odd (n ^ 2)
|
||||
contradiction
|
||||
rw [←even_iff_not_odd] at *
|
||||
apply even_square
|
||||
assumption
|
||||
|
||||
DisabledTactic contrapose revert
|
||||
|
||||
Conclusion "**Robo**: Bravo! Hier nochmals ein Überblick, was wir jetzt alles auf diesem
|
||||
Mond gelernt haben:
|
||||
|
||||
| | Taktik | Beispiel |
|
||||
|:------|:----------------|:-------------------------------------------------------|
|
||||
| 177 | `have` | Zwischenresultat annehmen. |
|
||||
| 18 | `suffices` | Zwischenresultat annehmen. |
|
||||
| 19 | `by_contra` | Widerspruch. (startet einen Widerspruch) |
|
||||
| *3* | `contradiction` | *(Schliesst einen Widerspruchsbeweis)* |
|
||||
| 20 | `contrapose` | Kontraposition. |
|
||||
| *9* | `revert` | Nützlich um danach `contrapose` anzuwenden. |
|
||||
"
|
||||
Reference in New Issue
Block a user