phc
/
lean4game
6
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update world 1

Browse Source
pull/54/head
Jon Eugster 2 years ago
parent 27532a7688
commit 7c2b1b0482
15 changed files with 177 additions and 183 deletions
Show Stats Download Patch File Download Diff File

19
server/testgame/TestGame/Levels/Proposition/L00_Tauto.lean
Unescape Escape View File

@ -21,25 +21,20 @@ Du siehst Robo hilflos an.
Statement "" Statement ""
(A B C : Prop) : (A B C : Prop) :
¬((¬B ∨ ¬ C) ∨ (A → B)) → (¬A ∨ B) ∧ ¬ (B ∧ C) := by ¬((¬B ∨ ¬ C) ∨ (A → B)) → (¬A ∨ B) ∧ ¬ (B ∧ C) := by
Hint "Hello? {A}" Hint "**Robo** Das ist ganz einfach. Mit `{A} {B} {C} : Prop` meint er:
tauto
Hint (A B C : Prop) :
¬((¬B ∨ ¬ C) ∨ (A → B)) → (¬A ∨ B) ∧ ¬ (B ∧ C) =>
"**Robo** Das ist ganz einfach. Mit `{A} {B} {C} : Prop` meint er:
`{A}`, `{B}` und `{C}` sind irgendwelche Aussagen (*propositions*). `{A}`, `{B}` und `{C}` sind irgendwelche Aussagen (*propositions*).
Und mit `→` meint sie ⇒, also “impliziert”. Die anderen Symbole kennst Du, oder? Und mit `→` meint sie ⇒, also “impliziert”. Die anderen Symbole kennst Du, oder?
**Du** Ehhm, ja. Aber da muss ich jetzt trotzdem erst einmal überlegen. **Du** Ehhm, ja. Aber da muss ich jetzt trotzdem erst einmal überlegen.
**Robo** (flüsternd) Behaupte doch einfach, dass sei eine Tautologie. **Robo** (flüsternd) Behaupte doch einfach, dass sei eine Tautologie.
**Du** Ernsthaft? **Du** Ernsthaft?
**Robo** Ja. Schreib einfach `tauto`. **Robo** Ja. Schreib einfach `tauto`.
**Robo** Mach schon … **Robo** Mach schon …"
" tauto
Conclusion Conclusion
" "

7
server/testgame/TestGame/Levels/Proposition/L01_Rfl.lean
Unescape Escape View File

@ -19,13 +19,10 @@ Er schreibt es Dir wieder auf.
Statement "" : Statement "" :
42 = 42 := by 42 = 42 := by
Hint " **Robo** Ist doch klar. Du musst ihn einfach daran erinnern,
dass Gleichheit *reflexiv* ist. Probier mal `rfl`."
rfl rfl
Hint : 42 = 42 => "
**Robo** Ist doch klar. Du musst ihn einfach daran erinnern, dass Gleichheit *reflexiv* ist.
Probier mal `rfl`.
"
Conclusion Conclusion
" "
**Untertan** Ah, richtig. Ja, Sie haben ja so recht. Das vergesse ich immer. Rfl, rfl, rfl … **Untertan** Ah, richtig. Ja, Sie haben ja so recht. Das vergesse ich immer. Rfl, rfl, rfl …

8
server/testgame/TestGame/Levels/Proposition/L02_Assumption.lean
Unescape Escape View File

@ -13,9 +13,7 @@ Während der erste Untertan noch rfl, rfl, rfl murmelt, tritt schon der nächste
Statement "" Statement ""
(n : ℕ) (h₁ : 10 > n) (h₂ : 1 < n) (h₃ : n ≠ 5) : 1 < n := by (n : ℕ) (h₁ : 10 > n) (h₂ : 1 < n) (h₃ : n ≠ 5) : 1 < n := by
assumption Hint "
Hint (n : ℕ) (h₁ : 10 > n) (h₂ : 1 < n) (h₃ : n ≠ 5) : 1 < n => "
**Robo** `{n} : ℕ` bedeutet, `{n}` ist eine natürliche Zahl. **Robo** `{n} : ℕ` bedeutet, `{n}` ist eine natürliche Zahl.
**Du** Warum schreibt er dann nicht `{n} ∈ ℕ`?? **Du** Warum schreibt er dann nicht `{n} ∈ ℕ`??
@ -32,8 +30,8 @@ für die Annahme `n < 10`, `1 < n` und `n ≠ 5`. Beweisen sollen wir: `1 < n`.
**Du** ??? **Du** ???
**Robo** Du musst ihm das halt explizit sagen. Probiers mal mit `assumption`. **Robo** Du musst ihm das halt explizit sagen. Probiers mal mit `assumption`."
" assumption
Conclusion Conclusion
" "

10
server/testgame/TestGame/Levels/Proposition/L03_Assumption.lean
Unescape Escape View File

@ -14,9 +14,7 @@ Ein dritter Untertan kommt mit folgendem Problem.
Statement "" Statement ""
(A : Prop) (hA : A) : A := by (A : Prop) (hA : A) : A := by
assumption Hint "
Hint (A : Prop) (hA : A) : A => "
**Robo** Hier bedeutet `{A} : Prop` wieder, dass `{A}` irgendeine Aussage ist. **Robo** Hier bedeutet `{A} : Prop` wieder, dass `{A}` irgendeine Aussage ist.
Und `{hA}` ist eine Name für die Annahme, dass `{A}` wahr ist. Und `{hA}` ist eine Name für die Annahme, dass `{A}` wahr ist.
@ -24,10 +22,10 @@ Hint (A : Prop) (hA : A) : A => "
**Robo** Ja. Da kommst Du jetzt selbst drauf, wie das geht, oder? **Robo** Ja. Da kommst Du jetzt selbst drauf, wie das geht, oder?
" "
Hint (hidden := true) "Ist doch genau wie eben:
HiddenHint (A : Prop) (hA : A) : A => die Aussage, die zu beweisen ist, gehört selbst zu den Annahmen.
"Ist doch genau wie eben: die Aussage, die zu beweisen ist, gehört selbst zu den Annahmen.
Also wird `asumption` auch wieder funktionieren." Also wird `asumption` auch wieder funktionieren."
assumption
Conclusion Conclusion
" "

8
server/testgame/TestGame/Levels/Proposition/L04_True.lean
Unescape Escape View File

@ -11,11 +11,8 @@ Introduction
Der nächste Untertan in der Reihe ist ein Schelm. Der nächste Untertan in der Reihe ist ein Schelm.
" "
Statement "" : Statement "" : True := by
True := by Hint "
trivial
Hint : True => "
**Robo** Dieses `True` ist eine spezielle Aussage, nämlich die Aussage, die immer und **Robo** Dieses `True` ist eine spezielle Aussage, nämlich die Aussage, die immer und
bedingungslos wahr ist. bedingungslos wahr ist.
@ -23,6 +20,7 @@ bedingungslos wahr ist.
**Robo** Ich glaube, nichts. Ich glaube, Du kannst einfach `trivial` schreiben. **Robo** Ich glaube, nichts. Ich glaube, Du kannst einfach `trivial` schreiben.
" "
trivial
Conclusion Conclusion
" "

21
server/testgame/TestGame/Levels/Proposition/L05_Not.lean
Unescape Escape View File

@ -11,22 +11,19 @@ Introduction
Der Schelm hat noch eine Schwester dabei. Der Schelm hat noch eine Schwester dabei.
" "
Statement "" : Statement "" : ¬False := by
¬False := by Hint "
trivial **Robo** Dieses Zeichen `¬` bedeutet Negation. Also wenn eine Aussage `(A : Prop)`
wahr ist, dann ist `¬A` falsch, und umgekehrt.
Hint : ¬False => "
**Robo** Dieses Zeichen `¬` bedeutet Negation. Also wenn eine Aussage `(A : Prop)`
wahr ist, dann ist `¬A` falsch, und umgekehrt.
**Du** Und `False` ist wahrscheinlich die Aussage, die immer falsch ist? **Du** Und `False` ist wahrscheinlich die Aussage, die immer falsch ist?
**Robo** Ja, richtig. **Robo** Ja, richtig.
**Du** Ist das jetzt nicht doch wieder trivial? **Du** Ist das jetzt nicht doch wieder trivial?
**Robo** Probier mal! **Robo** Probier mal!"
" trivial
Conclusion Conclusion
" "

12
server/testgame/TestGame/Levels/Proposition/L06_False.lean
Unescape Escape View File

@ -15,12 +15,8 @@ Als nächstes kommen drei Querulanten. Der erste hat folgendes Problem:
Statement "" Statement ""
(A : Prop) (h : False) : A := by (A : Prop) (h : False) : A := by
contradiction Hint "**Du** Wenn ich das jetzt richtig lese, ist `{A}` eine Aussage,
und wir haben außerdem eine Annahme names `{h}`, die besagt …
Hint (A : Prop) (h : False) : A =>
"
**Du** Wenn ich das jetzt richtig lese, ist `{A}` eine Aussage, und wir haben außerdem eine
Annahme names `{h}`, die besagt …
**Robo** … die besagt, dass `False` gilt. **Robo** … die besagt, dass `False` gilt.
@ -33,8 +29,8 @@ Insbesondere die gesuchte Aussage `{A}`.
**Du** Und wie erkläre ich das jetzt diesem Formalosophen? **Du** Und wie erkläre ich das jetzt diesem Formalosophen?
**Robo** Ich glaube, Du musst ihn darauf hinweisen, dass zwischen der allgemeingültigen **Robo** Ich glaube, Du musst ihn darauf hinweisen, dass zwischen der allgemeingültigen
Annahme `True` und seiner Annahme `False` ein Widerspruch besteht. Probier mal `contradiction`. Annahme `True` und seiner Annahme `False` ein Widerspruch besteht. Probier mal `contradiction`."
" contradiction
Conclusion Conclusion
"Der erste Querulant ist offenbar zufrieden. "Der erste Querulant ist offenbar zufrieden.

10
server/testgame/TestGame/Levels/Proposition/L07_ContraNotEq.lean
Unescape Escape View File

@ -17,14 +17,10 @@ Auftritt zweiter Querulant.
Statement "" Statement ""
(n : ℕ) (h : n ≠ n) : n = 37 := by (n : ℕ) (h : n ≠ n) : n = 37 := by
contradiction Hint "**Du** Ist `{n} ≠ {n}` nicht auch ein Widerspruch?
Hint (n : ℕ) (h : n ≠ n) : n = 37 =>
"
**Du** Ist `{n} ≠ {n}` nicht auch ein Widerspruch?
**Robo** Probiers mal! **Robo** Probiers mal!"
" contradiction
Conclusion Conclusion
" "

8
server/testgame/TestGame/Levels/Proposition/L08_Contra.lean
Unescape Escape View File

@ -17,14 +17,12 @@ Auftritt dritter Querulant.
Statement "" Statement ""
(n : ℕ) (h : n = 10) (g : n ≠ 10) : n = 42 := by (n : ℕ) (h : n = 10) (g : n ≠ 10) : n = 42 := by
Hint "**Du** Wieder ein Widerspruch in den Annahmen?
**Robo** Ich sehe, du hast langsam den Dreh raus."
contradiction contradiction
Hint (n : ℕ) (h : n = 10) (g : n ≠ 10) : n = 42 =>
"
**Du** Wieder ein Widerspruch in den Annahmen?
**Robo** Ich sehe, du hast langsam den Dreh raus.
"
Conclusion Conclusion
" "

34
server/testgame/TestGame/Levels/Proposition/L09_And.lean
Unescape Escape View File

@ -15,34 +15,46 @@ Der nächste Formalosoph in der Reihe hat seine Frage bereìts mitgebracht.
Er legt sie uns vor, setzt sich hin, und häkelt. Er legt sie uns vor, setzt sich hin, und häkelt.
" "
Statement "" (A B : Prop) (hA : A) (hB : B) : A ∧ B := by Statement "" (A B : Prop) (hA : A) (hB : B) : A ∧ B := by
constructor Hint
assumption
assumption
Hint (A B : Prop) (hA : A) (hB : B) : A ∧ B =>
" "
**Du**: Also, wir haben zwei Annahmen: `{A}` gilt, und `{B}` gilt. Auch. Und beweisen sollen wir **Du**: Also, wir haben zwei Annahmen: `{A}` gilt, und `{B}` gilt. Auch. Und beweisen sollen wir
dass `{A} und {B}` gilt. Ich glaube, diese Formalospinner treiben mich noch zur Verzweiflung. dass `{A} und {B}` gilt. Ich glaube, diese Formalospinner treiben mich noch zur Verzweiflung.
Kann ich nicht wieder `trivial` sagen? Kann ich nicht wieder `trivial` sagen?
**Robo** Nee, diesmal wird das nicht funktionieren. **Robo**: Nee, diesmal wird das nicht funktionieren.
Du musst das Beweisziel einfach in zwei Teile zerlegen. Probier mal `constructor`. Du musst das Beweisziel einfach in zwei Teile zerlegen. Probier mal `constructor`.
**Du** Du meinst, `destructor`?? **Du**: Du meinst, `destructor`??
**Robo** Nein, `constructor`. Ich weiß das ist verwirrend, **Robo**: Nein, `constructor`. Ich weiß das ist verwirrend,
aber die nennen das hier so weil man die Aussage aus mehreren Teilen aber die nennen das hier so weil man die Aussage aus mehreren Teilen
konstruieren kann. konstruieren kann.
" "
constructor
HiddenHint (A : Prop) (hA : A) : A => -- TODO: (BUG) Hier werden beide der folgenden Hints angezeigt.
-- Das logiste Verhalten wäre, wenn jeder nur am richtigen Ort
-- angezeigt würde.
-- Ein cooles Feature wäre, wenn man nur diesen ersten Hint schreiben könnte
-- und dieser dann automatisch auch beim zweiten Goal angezeigt wird, aber dann mit `B` statt `A`.
Hint (hidden := true)
" "
**Robo** Schau mal, das ist Zauberpapier. **Robo**: Schau mal, das ist Zauberpapier.
Jetzt haben wir auf einmal zwei Beweisziele. Jetzt haben wir auf einmal zwei Beweisziele.
Hier ist dast Ziel `{A}`. Hier ist dast Ziel `{A}`.
Ich glaube, Du weißt schon, wie man die jeweils erreicht. Ich glaube, Du weißt schon, wie man die jeweils erreicht.
Die Ziele stehen ja jeweils in den *Annahmen*. Die Ziele stehen ja jeweils in den *Annahmen*.
" "
assumption
Hint (hidden := true)
"
**Robo**: Schau mal, das ist Zauberpapier.
Jetzt haben wir auf einmal zwei Beweisziele.
Hier ist dast Ziel `{B}`.
Ich glaube, Du weißt schon, wie man die jeweils erreicht.
Die Ziele stehen ja jeweils in den *Annahmen*.
"
assumption
Conclusion Conclusion
" "

21
server/testgame/TestGame/Levels/Proposition/L10_And.lean
Unescape Escape View File

@ -16,10 +16,7 @@ Langsam wird die Schlange kürzer. Die nächste Formalosophin hat folgendes Anli
Statement "" Statement ""
(A B C : Prop) (h : A ∧ (B ∧ C)) : B := by (A B C : Prop) (h : A ∧ (B ∧ C)) : B := by
rcases h with ⟨_, ⟨g , _⟩⟩ Hint "
assumption
Hint (A B C : Prop) (h : A ∧ (B ∧ C)) : B => "
**Du** Jetzt müssen wir wohl die Annahme de-konstruieren. **Du** Jetzt müssen wir wohl die Annahme de-konstruieren.
**Robo** Ja, genau. Das geht am einfachsten mit `rcases {h} with ⟨h₁, h₂⟩`. **Robo** Ja, genau. Das geht am einfachsten mit `rcases {h} with ⟨h₁, h₂⟩`.
@ -30,16 +27,12 @@ Hint (A B C : Prop) (h : A ∧ (B ∧ C)) : B => "
Und h₁ schreibst Du einfach als `h\\1`. Aber Du kannst Dir auch einfach andere Namen Und h₁ schreibst Du einfach als `h\\1`. Aber Du kannst Dir auch einfach andere Namen
für `h₁` und `h₂`, zum Beispiel `rcases {h} with ⟨hA, hBC⟩` für `h₁` und `h₂`, zum Beispiel `rcases {h} with ⟨hA, hBC⟩`
" "
Branch
Hint (A B C : Prop) (hA : A) (hAB : B ∧ C) : B => rcases h with ⟨h₁, h₂⟩
" Hint "**Robo** Das sieht doch schon besser aus! Gleich nochmal!"
**Robo** Das sieht doch schon besser aus! Gleich nochmal! rcases h with ⟨_, ⟨g , _⟩⟩
" Hint (hidden := true) "**Robo** Du hast einen Beweis dafür in den *Annahmen*."
assumption
HiddenHint (A : Prop) (hA : A) : A =>
"
**Robo** Du hast einen Beweis dafür in den *Annahmen*.
"
Conclusion Conclusion
" "

20
server/testgame/TestGame/Levels/Proposition/L11_Or.lean
Unescape Escape View File

@ -18,12 +18,7 @@ Der nächste bitte …
Statement Statement
"" ""
(A B : Prop) (hA : A) : A ∨ (¬ B) := by (A B : Prop) (hA : A) : A ∨ (¬ B) := by
left Hint "**Du** Muss ich jetzt wieder das Beweisziel de-konstruieren?
assumption
Hint (A B : Prop) (hA : A) : A ∨ (¬ B) =>
"
**Du** Muss ich jetzt wieder das Beweisziel de-konstruieren?
**Robo** Nein, viel einfacher. Wenn Du eine Oder-Aussage beweisen sollst, musst Du Dich **Robo** Nein, viel einfacher. Wenn Du eine Oder-Aussage beweisen sollst, musst Du Dich
einfach entscheiden, ob Du die linke oder rechte Seite beweisen willst. einfach entscheiden, ob Du die linke oder rechte Seite beweisen willst.
@ -31,13 +26,12 @@ einfach entscheiden, ob Du die linke oder rechte Seite beweisen willst.
**Du** Und wie erkläre ich meinem Formalosophen, welche Seite ich gern beweisen würde? **Du** Und wie erkläre ich meinem Formalosophen, welche Seite ich gern beweisen würde?
Ich will natürlich `{A}` beweisen! Ich will natürlich `{A}` beweisen!
**Robo** Mit `left` bzw. `right`. Ist doch logisch, oder? **Robo** Mit `left` bzw. `right`. Ist doch logisch, oder?"
" Branch
right
Hint (A B : Prop) (hA : A) : ¬ B => Hint "**Robo** Wusste gar nicht, dass Du eine Links-Rechts-Schwäche hast. Probier's nochmal."
" left
**Robo** Wusste gar nicht, dass Du eine Links-Rechts-Schwäche hast. Probier's nochmal. assumption
"
Conclusion Conclusion
" "

47
server/testgame/TestGame/Levels/Proposition/L12_Or.lean
Unescape Escape View File

@ -20,14 +20,7 @@ Der nächste bitte …
Statement "" Statement ""
(A B : Prop) (h : (A ∧ B) ∨ A) : A := by (A B : Prop) (h : (A ∧ B) ∨ A) : A := by
rcases h with h | h Hint "**Robo** Schau mal, wenn du mit dem Finger eine Annahme berührst, zeigt es dir,
rcases h with ⟨h₁, h₂⟩
assumption
assumption
Hint (A B : Prop) (h :(A ∧ B) ∨ A) : A =>
"
**Robo** Schau mal, wenn du mit dem Finger eine Annahme berührst, zeigt es dir,
wie die Klammern gesetzt sind. Irre… wie die Klammern gesetzt sind. Irre…
**Du** Ah ich sehe, also `({A} ∧ {B}) ∨ {A}`! **Du** Ah ich sehe, also `({A} ∧ {B}) ∨ {A}`!
@ -41,34 +34,24 @@ Wir sind ja gleich hier fertig, und können zu einem interessanteren Planeten we
**Du** Also, wieder `rcases …`? **Du** Also, wieder `rcases …`?
**Robo** Ja, aber diesmal nicht `rcases {h} with ⟨h₁, h₂⟩`, sondern `rcases {h} with h | h`. **Robo** Ja, aber diesmal nicht `rcases {h} with ⟨h₁, h₂⟩`, sondern `rcases {h} with h | h`."
" rcases h with h | h
Hint "**Robo**
-- -- TODO: This also triggers later under the assumptions
-- -- `(A : Prop) (B : Prop) (h₁ : A) (h₂ : B) : A`
-- -- Could we do something about that?
-- Hint (A : Prop) (B : Prop) (h : A) : A =>
-- "
-- **Robo** Jetzt musst Du Dein Ziel zweimal beweisen:
-- Einmal unter Annahme der linken Seite `{A}`,
-- und einmal unter Annahme der rechten Seite `{A} ∨ {B}`. Hier haben nehmen wir an, die linke Seite
-- sei wahr.
-- "
Hint (A : Prop) (B : Prop) (h : A ∧ B) : A =>
"
**Robo**
Jetzt musst Du Dein Ziel zweimal beweisen: Jetzt musst Du Dein Ziel zweimal beweisen:
Einmal unter Annahme der linken Seite `{A} ∨ {B}`, Einmal unter Annahme der linken Seite `{A} ∨ {B}`,
und einmal unter Annahme der rechten Seite `{A}`. und einmal unter Annahme der rechten Seite `{A}`.
Hier haben nehmen wir an, die linke Seite Hier haben nehmen wir an, die linke Seite
sei wahr. sei wahr."
" Hint (hidden := true) " **Robo** Wie man mit einem Und in den Annahmen umgeht,
HiddenHint (A : Prop) (B : Prop) (h : A ∧ B) : A => weißt Du doch schon:
" `rcases h with ⟨h₁, h₂⟩`. Zur Erinnerung: Für die Klammern schreibst Du `\\<>`."
**Robo** Wie man mit einem Und in den Annahmen umgeht, weißt Du doch schon: rcases h with ⟨h₁, h₂⟩
`rcases h with ⟨h₁, h₂⟩`. Zur Erinnerung: Für die Klammern schreibst Du `\\<>`. Hint "**Robo** Jetzt musst Du Dein Ziel zweimal beweisen:
" Einmal unter Annahme der linken Seite `{A}`,
und einmal unter Annahme der rechten Seite `{A} ∨ {B}`. Hier haben nehmen wir an, die linke Seite
sei wahr."
assumption
assumption
Conclusion Conclusion
"**Du** Ok, das scheint ihn zufriedenzustellen. Nur noch eine Seele… "**Du** Ok, das scheint ihn zufriedenzustellen. Nur noch eine Seele…

83
server/testgame/TestGame/Levels/Proposition/L13_Summary.lean
Unescape Escape View File

@ -14,7 +14,9 @@ Introduction
" "
Der letzte Untertan tritt vor. Ihr Anliegen ist etwas komplizierter als die vorherigen. Der letzte Untertan tritt vor. Ihr Anliegen ist etwas komplizierter als die vorherigen.
**Robo** Wirf einfach alles drauf, was Du gelernt hast. Hier, ich bin sogar so nett und zeig Dir noch einmal die vier wichtigsten Taktiken für diese Situation an. **Robo** Wirf einfach alles drauf, was Du gelernt hast.
Hier, ich bin sogar so nett und zeig Dir noch einmal die vier
wichtigsten Taktiken für diese Situation an.
| (Übersicht) | Und (`∧`) | Oder (`∨`) | | (Übersicht) | Und (`∧`) | Oder (`∨`) |
|-------------|:-------------------------|:------------------------| |-------------|:-------------------------|:------------------------|
@ -26,46 +28,83 @@ Der letzte Untertan tritt vor. Ihr Anliegen ist etwas komplizierter als die vor
Statement "" Statement ""
(A B C : Prop) (h : A ∨ (B ∧ C)) : (A ∨ B) ∧ (A ∨ C) := by (A B C : Prop) (h : A ∨ (B ∧ C)) : (A ∨ B) ∧ (A ∨ C) := by
Hint (hidden := true)
"**Robo**: Ich würd zuerst die Annahme {h} mit `rcases {h}` aufteilen."
Branch
constructor constructor
rcases h with h | h · rcases h with h' | h'
left · left
assumption
· rcases h' with ⟨h₁, h₂⟩
right
assumption
· rcases h with h' | h'
· left
assumption
· rcases h' with ⟨h₁, h₂⟩
right
assumption
rcases h
Hint (hidden := true) "**Robo**: Jetzt kannst Du das `∧` im Goal mit `constructor` angehen."
· constructor
· left
assumption
· left
assumption
· Hint (hidden := true)
"**Robo**: Hier würde ich die Annahme {h} nochmals mit `rcases` aufteilen."
Branch
constructor
· Hint "**Robo**: Der Nachteil an der Reihenfolge ist, dass du jetzt in jedem Untergoal
`rcases h` aufrufen musst."
Branch
right
rcases h with ⟨h₁, h₂⟩
assumption assumption
rcases h with ⟨h₁, h₂⟩ rcases h with ⟨h₁, h₂⟩
right right
assumption assumption
rcases h with h | h · Branch
left right
rcases h with ⟨h₁, h₂⟩
assumption assumption
rcases h with ⟨h₁, h₂⟩ rcases h with ⟨h₁, h₂⟩
right right
assumption assumption
rcases h with ⟨h₁, h₂⟩
constructor
· right
assumption
· right
assumption
HiddenHint (A : Prop) (B : Prop) (C : Prop) (h : B ∧ C) : (A ∨ B) ∧ (A ∨ C) => -- HiddenHint (A : Prop) (B : Prop) (C : Prop) (h : B ∧ C) : (A ∨ B) ∧ (A ∨ C) =>
"**Robo** Das `∧` in der Annahme kannst Du mit `rcases {h} with ⟨h₁, h₂⟩` zerlegen." -- "**Robo** Das `∧` in der Annahme kannst Du mit `rcases {h} with ⟨h₁, h₂⟩` zerlegen."
HiddenHint (A : Prop) (B : Prop) (C : Prop) : (A ∨ B) ∧ (A ∨ C) => -- HiddenHint (A : Prop) (B : Prop) (C : Prop) : (A ∨ B) ∧ (A ∨ C) =>
"**Robo** Das `∧` im Goal kannst Du mit `constructor` zerlegen." -- "**Robo** Das `∧` im Goal kannst Du mit `constructor` zerlegen."
HiddenHint (A : Prop) (B : Prop) (C : Prop) (h : A ∨ (B ∧ C)) : (A ∨ B) ∧ (A ∨ C) => -- HiddenHint (A : Prop) (B : Prop) (C : Prop) (h : A ∨ (B ∧ C)) : (A ∨ B) ∧ (A ∨ C) =>
"**Robo** Das `∨` in der Annahme kannst Du mit `rcases h with h | h` zerlegen." -- "**Robo** Das `∨` in der Annahme kannst Du mit `rcases h with h | h` zerlegen."
HiddenHint (A : Prop) (B : Prop) (C : Prop) (h : A ∨ (B ∧ C)) : (A ∨ B) => -- HiddenHint (A : Prop) (B : Prop) (C : Prop) (h : A ∨ (B ∧ C)) : (A ∨ B) =>
"**Robo** Das `∨` in der Annahme kannst Du mit `rcases h with h | h` zerlegen." -- "**Robo** Das `∨` in der Annahme kannst Du mit `rcases h with h | h` zerlegen."
HiddenHint (A : Prop) (B : Prop) (C : Prop) (h : A ∨ (B ∧ C)) : (A ∨ C) => -- HiddenHint (A : Prop) (B : Prop) (C : Prop) (h : A ∨ (B ∧ C)) : (A ∨ C) =>
"**Robo** Das `∨` in der Annahme kannst Du mit `rcases h with h | h` zerlegen." -- "**Robo** Das `∨` in der Annahme kannst Du mit `rcases h with h | h` zerlegen."
HiddenHint (A : Prop) (B : Prop) (C : Prop) (h : B ∧ C) : (A ∨ B) => -- HiddenHint (A : Prop) (B : Prop) (C : Prop) (h : B ∧ C) : (A ∨ B) =>
"**Robo** Das `∧` in der Annahme kannst Du mit `rcases h with ⟨h₁, h₂⟩` zerlegen." -- "**Robo** Das `∧` in der Annahme kannst Du mit `rcases h with ⟨h₁, h₂⟩` zerlegen."
HiddenHint (A : Prop) (B : Prop) (C : Prop) (h : B ∧ C) : (A ∨ C) => -- HiddenHint (A : Prop) (B : Prop) (C : Prop) (h : B ∧ C) : (A ∨ C) =>
"**Robo** Das `∧` in der Annahme kannst Du mit `rcases {h} with ⟨h₁, h₂⟩` zerlegen." -- "**Robo** Das `∧` in der Annahme kannst Du mit `rcases {h} with ⟨h₁, h₂⟩` zerlegen."
-- TODO: Hint nur Anhand der Annahmen? -- -- TODO: Hint nur Anhand der Annahmen?
HiddenHint (A : Prop) (B : Prop) : A ∨ B => -- HiddenHint (A : Prop) (B : Prop) : A ∨ B =>
"**Robo** `left` oder `right`?" -- "**Robo** `left` oder `right`?"
Conclusion Conclusion
" "

10
server/testgame/TestGame/Levels/SetTheory/L03_Subset.lean
Unescape Escape View File

@ -28,16 +28,16 @@ namespace MySet
open Set open Set
theorem mem_univ {A : Type _} (x : A) : x ∈ (univ : Set A) := by -- theorem mem_univ {A : Type _} (x : A) : x ∈ (univ : Set A) := by
trivial -- trivial
theorem not_mem_empty {A : Type _} (x : A) : x ∉ (∅ : Set A) := by -- theorem not_mem_empty {A : Type _} (x : A) : x ∉ (∅ : Set A) := by
tauto -- tauto
Statement subset_empty_iff Statement subset_empty_iff
"." (A : Set ℕ) : A ⊆ univ := by "." (A : Set ℕ) : A ⊆ univ := by
intro h hA intro h hA
apply mem_univ -- or `trivial`. trivial --apply mem_univ -- or `trivial`.
NewTactic intro trivial apply NewTactic intro trivial apply
-- blocked: tauto simp -- blocked: tauto simp

Write Preview
Loading…
Cancel
Save