|
|
|
|
@ -1,6 +1,7 @@
|
|
|
|
|
import TestGame.Metadata
|
|
|
|
|
|
|
|
|
|
import Mathlib
|
|
|
|
|
import TestGame.Options.BigOperators
|
|
|
|
|
|
|
|
|
|
set_option tactic.hygienic false
|
|
|
|
|
|
|
|
|
|
@ -20,38 +21,43 @@ schreibt man mit runden Klammern `()`, **impliziete Argumente** mit geschweiften
|
|
|
|
|
Als implizit werden alle Argumente markiert, die Lean selbständig aus dem Kontext
|
|
|
|
|
erschliessen und einfüllen kann.
|
|
|
|
|
|
|
|
|
|
Als Beispiel hier zweimal das gleiche Lemma, einmal ohne impliziten Argumenten und einmal mit
|
|
|
|
|
Als Beispiel schauen wir uns ein bekanntes Lemma an:
|
|
|
|
|
```
|
|
|
|
|
lemma not_or_of_imp' (A B : Prop) (h : A → B) : ¬A ∨ B := sorry
|
|
|
|
|
|
|
|
|
|
lemma not_or_of_imp {A B : Prop} (h : A → B) : ¬A ∨ B := sorry
|
|
|
|
|
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
|
|
|
|
|
```
|
|
|
|
|
|
|
|
|
|
Hat man nun `g : C → D` dann braucht man diese Lemmas mit
|
|
|
|
|
`have := not_or_of_imp g` oder `have := not_or_of_imp' C D g`.
|
|
|
|
|
|
|
|
|
|
Wie man sieht erschliesst Lean die impliziten Argumente automatisch und es wäre deshalb
|
|
|
|
|
unnötig, diese jedes Mal explizit angeben zu müssen.
|
|
|
|
|
|
|
|
|
|
TODO
|
|
|
|
|
(Trick mit `@not_or_of_imp` kann man sagen, dass man **alle** Argumente angeben möchte und mir
|
|
|
|
|
`not_or_of_imp g (B := D)` könnte man ein spezifisches implizites Argument spezifizieren.
|
|
|
|
|
Wenn man diese Tricks braucht, heisst das aber meistens, das etwas nicht optimal definiert
|
|
|
|
|
ist.)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Nebenbemerkung: Es gibt auch noch implizite **Klassen-Elemente** mit eckigen Klammern `[]`
|
|
|
|
|
wie zum Beispiel `[CommRing R]` im vorigen Beispiel. Diese werden später behandelt,
|
|
|
|
|
und sagen Lean, dass es für dieses Argument eine **Instanz** suchen gehen soll. Diese
|
|
|
|
|
Instanzen werden mehrheitlich dafür verwendet, mathematische Strukturen auf Typen zu
|
|
|
|
|
definieren, aber das kommt alles später.
|
|
|
|
|
Hier ist unter anderem `n` als implizites Argument angegeben, da Lean aus `f` herauslesen kann,
|
|
|
|
|
was `n` sein muss. Falls man trotzdem einmal das implizites Argument angeben muss
|
|
|
|
|
(z.B. um `rw` zu helfen, wenn es mehrere Möglichkeiten gibt),
|
|
|
|
|
kann man dies mit `Fin.sum_univ_castSucc (n := m + 1)` machen.
|
|
|
|
|
"
|
|
|
|
|
|
|
|
|
|
Statement
|
|
|
|
|
"TODO"
|
|
|
|
|
(R S : Type _) [CommRing R] (a b : R) : a + b = b + a := by
|
|
|
|
|
ring
|
|
|
|
|
open BigOperators
|
|
|
|
|
|
|
|
|
|
Hint (R : Type _) (h : CommRing R) (a : R) (b : R) : a + b = b + a =>
|
|
|
|
|
"Die Taktik `ring` funktioniert in jedem Typen,
|
|
|
|
|
der mindestens eine Instanz `[Ring R]` hat."
|
|
|
|
|
Statement
|
|
|
|
|
"Zeige $(\\sum_{i=0}^{m} i) + (m + 1) = \\sum_{i=0}^{m + 1} i$."
|
|
|
|
|
(m : ℕ) :
|
|
|
|
|
∑ i : Fin (m + 1), (i : ℕ) + (m + 1) = ∑ i : Fin (Nat.succ m + 1), ↑i := by
|
|
|
|
|
rw [Fin.sum_univ_castSucc (n := m + 1)]
|
|
|
|
|
rfl
|
|
|
|
|
|
|
|
|
|
OnlyTactics rw rfl
|
|
|
|
|
|
|
|
|
|
NewLemmas Fin.sum_univ_castSucc
|
|
|
|
|
|
|
|
|
|
HiddenHint (m : ℕ) :
|
|
|
|
|
∑ i : Fin (m + 1), (i : ℕ) + (m + 1) = ∑ i : Fin (Nat.succ m + 1), ↑i =>
|
|
|
|
|
"Das Lemma `Fin.sum_univ_castSucc` hilft."
|
|
|
|
|
|
|
|
|
|
Hint (m : ℕ) :
|
|
|
|
|
∑ i : Fin m, (Fin.castSucc.toEmbedding i : ℕ) + ↑(Fin.last m) + (m + 1) =
|
|
|
|
|
∑ i : Fin (Nat.succ m + 1), ↑i =>
|
|
|
|
|
"Hier hat `rw` die falsche der beiden Summen umgeschrieben. Hilf ihm mit
|
|
|
|
|
`rw [Fin.sum_univ_castSucc (n := m + 1)]`."
|
|
|
|
|
|
|
|
|
|
Hint (m : ℕ) :
|
|
|
|
|
∑ i : Fin (m + 1), (i : ℕ) + (m + 1) =
|
|
|
|
|
∑ i : Fin (m + 1), ↑i + (m + 1) =>
|
|
|
|
|
"Jetzt sind beide Seiten gleich und das Goal kann mit `rfl` geschlossen werden."
|
|
|
|
|
|
Jon Eugster
3 years ago