rename testgame to adam

2023-03-23 17:10:13 +01:00
parent a262cff63b
commit 5c73d3bddb
166 changed files with 0 additions and 0 deletions
@@ -0,0 +1,41 @@
+import TestGame.Metadata
+
+import Mathlib
+
+set_option tactic.hygienic false
+
+Game "TestGame"
+World "Lean"
+Level 1
+
+Title "Typen"
+
+Introduction
+"
+**Du**: Also, wieso schreib ich denn sowohl `(n : ℕ)` für eine natürliche Zahl wie
+auch `(h : A ∧ ¬ B)` für eine Aussage?
+
+**Robo**: Alles in Lean sind Objekte von einem *Typen*, man nennt das auch
+\"dependent type theory\". Rechts vom `:` steht immer der Typ der dieses Objekt hat.
+
+**Du**: Verstehe, dann war `ℕ` der Typ der natürlichen Zahlen, `Prop` der Typ
+aller logischen Aussagen, und so weiter. Un wenn `R` einfach irgendein Typ ist, dann…
+
+**Robot: …würdest du das als `(R : Type)` schreiben.
+
+**Du**: Also sind Typen ein bisschen jene Grundlage, die in meinem Studium die
+Mengen eingenommen haben?
+
+**Robo**: Genau. Ein Ring ist dann zum Beispiel als `(R : Type) [Ring R]` definiert,
+also als Typen, auf dem eine Ringstruktur besteht.
+
+**Robo**: Hier ein Beispiel. Die Taktik `ring` funktioniert in jedem Typen, der
+genügend Struktur definiert hat, zum Beispiel in einem kommutativen Ring:
+"
+
+Statement (R : Type) [CommRing R] (a b : R) : a + b = b + a := by
+  ring
+
+Conclusion "**Robo**: `[CommRing R]` nennt man übrigens eine Instanz und die
+eckigen Klammern sagen Lean, dass es automatisch suchen soll, ob es so eine Instanz
+findet, wenn man ein Lemma anwenden will."
@@ -0,0 +1,44 @@
+import TestGame.Metadata
+
+import Mathlib
+
+set_option tactic.hygienic false
+
+Game "TestGame"
+World "Lean"
+Level 2
+
+Title "Universen"
+
+Introduction
+"**Du**: Aber wenn alles Typen sind, welcher Typ hat dann `Type`?
+
+**Robo**: `Type 1` und dieser hat Typ `Type 2`, etc.
+
+**Robo**: Die Zahl nennt man *Universum*. Manchmal führt man Universen explizit
+mit `universum u` ein, öfter siehst du `(R : Type _)`, was einfach ein Platzhalter
+für irgend ein Universum ist.
+
+**Du**: Das klingt ein bisschen nach Mengentheoretische Probleme, die man normalerweise
+ignoriert.
+
+**Robo**: Genau! Deshalb schreibt man eigentlich immer einfach `Type _` und ist glücklich.
+Spezifischer muss man erst werden wenn man sowas wie Kategorientheorie anschaut, wo
+man die Universen tatsächlich kontrollieren muss.
+
+**Du**: Oke, hier rein, da raus. Aber hast du mir noch eine Aufgabe?
+"
+
+universe u
+
+Statement
+    (R : Type u) [CommRing R] (a b : R) : a + b = b + a := by
+  Hint "**Robo**: Naja, Aufgaben zu Universen sind nicht so natürlich,
+  aber vorige Aufgabe würde man eigentlich besser so schreiben, da
+  kannst du mindestens das Uniersum beobachten."
+  ring
+
+Conclusion "**Du**: Na dann. Aber gut dass ich's mal gesehen hab."
+
+-- Hint (R : Type) (h : CommRing R) (a : R) (b : R) : a + b = b + a =>
+-- ""
@@ -0,0 +1,71 @@
+import TestGame.Metadata
+
+import Mathlib
+import TestGame.ToBePorted
+
+set_option tactic.hygienic false
+
+Game "TestGame"
+World "Lean"
+Level 3
+
+Title "Implizite Argumente"
+
+Introduction
+"
+**Du**: Was mich aber mehr beschäftigt, ist, dass Lemmas manchmal viel mehr Argumente
+haben als ich hinschreiben muss.
+
+**Robo**: Lean kann manche Argumente aus dem Kontext erschliessen. Hast du zum Beispiel
+ein Lemma von vorhin
+
+```
+lemma Fin.sum_univ_castSucc {β : Type _} [AddCommMonoid β] {n : ℕ} (f : Fin (n + 1) → β) :
+    ∑ i : Fin (n + 1), f i = ∑ i : Fin n, f (↑Fin.castSucc.toEmbedding i) + f (Fin.last n) := by
+  sorry
+```
+
+dann reicht es ja Lean `f` zu geben und daraus kann es herausfinden, was die anderen
+(`β`, `n`) sein müssen.
+
+**Robo**: Solche *implizite Argumente* markiert man dann mit `{_ : _}` während
+*explizite Arumente* mit `(_ : _)` markiert werden.
+
+**Du**: Dann könnte ich also einfach `Fin.sum_univ_castSucc f` schreiben?
+
+**Robo**: Genau!
+
+**Du**: Und was war dann das `(n := m + 1)` vorhin genau?
+
+**Robo**: Damit kann man im Aussnahmefall die impliziten Argumente doch angeben. Hier haben wir
+gesagt, es soll für das Argument `n` den Term `m + 1` einsetzen. Hier mach das doch noch einmal
+unter weniger Stress:
+"
+
+open BigOperators
+
+Statement (m : ℕ) : ∑ i : Fin (m + 1), (i : ℕ) + (m + 1) = ∑ i : Fin (Nat.succ m + 1), ↑i := by
+  Branch
+    rw [Fin.sum_univ_castSucc]
+    Hint "**Robo**: Siehst du, ohne die Hilfe macht es das Falsche. Deshalb muss man hier
+    explizit mit `Fin.sum_univ_castSucc (n := m + 1)` nachhelfen."
+    rw [Fin.sum_univ_castSucc]
+    Hint "**Robo**: Na klar, in dem Beispiel kannst du einfach weiter umschreiben bis es
+    nicht mehr geht, aber das war nicht der Punkt…"
+    rw [Fin.sum_univ_castSucc]
+    Hint "**Robo**: Na klar, in dem Beispiel kannst du einfach weiter umschreiben bis es
+    nicht mehr geht, aber das war nicht der Punkt…"
+    rfl
+  rw [Fin.sum_univ_castSucc (n := m + 1)]
+  rfl
+
+OnlyTactic rw rfl
+
+Conclusion "**Du**: Gibt es auch noch ander Methoden implizite Argumente anzugeben.
+
+**Robo** `@Fin.sum_univ_castSucc` würde *alle* Argumente explizit machen,
+aber das ist unparktischer, weil man dann irgendwie
+`@Fin.sum_univ_castSucc _ _ (m + 1)` schreiben müsste.
+
+**Du**: Ah und ich sehe der `_` ist überall in Lean ein Platzhalter, der automatisch
+gefüllt wird."
@@ -0,0 +1,57 @@
+import TestGame.Metadata
+
+import Mathlib
+import TestGame.ToBePorted
+
+set_option tactic.hygienic false
+
+Game "TestGame"
+World "Lean"
+Level 4
+
+Title "Instanz-Argumente"
+
+Introduction
+"**Du**: Also nochmals als Zusammenfassung, dann gibt es 3 Arten von Argumenten,
+explizite mit `()`, implizite mit `{}` und Instanzen mit `[]`?
+
+**Robo**: Korrekt. Instanzen sind damit auch Implizite Argumente. Der Unterschied
+zwischen `{}` und `[]` ist also *wie* Lean diese füllt.
+
+**Du**: Verstehe, bei den ersten sucht es logisch nach einer richtigen Möglichkeit,
+beim zweiten geht's durch alle Instanzen, die es kennt.
+
+
+**Robo**: Funktioniert hier bei mir nicht, aber wenn du ausserhalb eines Beweises
+`#synth Ring ℤ` in ein Dokument schreibt, zeigt dir Lean, ob es eine Instanz finden kann.
+
+**Du**: Ich glaube das macht alles Sinn.
+
+**Robo**: Hier, mach nochmals das Gleiche wie vorhin aber mit @-Syntax um das zu
+verinnerlichen:
+"
+
+open BigOperators
+
+Statement (m : ℕ) :
+      ∑ i : Fin (m + 1), (i : ℕ) + (m + 1) = ∑ i : Fin (Nat.succ m + 1), ↑i := by
+  Hint "*Robo*: Schreibe `rw [@Fin.sum_univ_castSucc _ _ (m + 1)]`
+  anstatt `rw [Fin.sum_univ_castSucc (n := m + 1)]`!"
+  rw [@Fin.sum_univ_castSucc _ _ (m + 1)]
+  rfl
+
+OnlyTactic rw rfl
+
+Conclusion "
+**Du**: Danke Robo!
+
+Um zwei weitere Ecken und plötzlich steht ihr wieder vor dem Golem, dem ihr schon begegnet seit.
+Dieser lädt euch zum Abendmahl ein. Ihr erfährt, dass er ganz gerne liest und er zeigt euch
+sein neustes Buch, das er leider nicht lesen kann. Nich tnur ist es der zweite Band einer Serie
+(der Erste hat offensichtlich was mit \"Urbildern\" zu tun), sondern ist es auch in einem
+Dialekt geschrieben, der anscheinend nur auf einem Nachbarsmond gesprochen wird.
+
+Ihr beschliesst dem herzlichen Golem zu helfen und beiden Monden einen Besuch abzustatten,
+sowohl um den Dialekt zu lernen, wie auch in der Bibliothek auf dem anderen Mond nach dem
+ersten Band zu suchen.
+"