rename message to hint

2023-01-24 16:37:18 +01:00
parent ecc9a488a2
commit 8c4b995a32
44 changed files with 187 additions and 527 deletions
@@ -29,7 +29,7 @@ Statement
    (x y : ℕ) : (x + y) ^ 2 = x ^ 2 + 2 * x * y + y ^ 2 := by
  ring

-Hint (x : ℕ) (y : ℕ) : (x + y) ^ 2 = x ^ 2 + 2 * x * y + y ^ 2 =>
+HiddenHint (x : ℕ) (y : ℕ) : (x + y) ^ 2 = x ^ 2 + 2 * x * y + y ^ 2 =>
 "`ring` übernimmt den ganzen Spaß."

 Conclusion
@@ -28,39 +28,39 @@ Zeige dass $b = c$."
  rw [←h₂]
  assumption

-Hint (a : ℕ) (b : ℕ) (c : ℕ) (d : ℕ) (h₁ : c = d) (h₂ : a = b) (h₃ : a = d) : b = c =>
+HiddenHint (a : ℕ) (b : ℕ) (c : ℕ) (d : ℕ) (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 : ℕ) (b : ℕ) (c : ℕ) (d : ℕ) (h₁ : c = d) (h₂ : a = b) (h₃ : a = d) : a = c =>
+HiddenHint (a : ℕ) (b : ℕ) (c : ℕ) (d : ℕ) (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₁]`."

-Hint (a : ℕ) (b : ℕ) (c : ℕ) (d : ℕ) (h₁ : c = d) (h₂ : a = b) (h₃ : a = d) : b = d =>
+HiddenHint (a : ℕ) (b : ℕ) (c : ℕ) (d : ℕ) (h₁ : c = d) (h₂ : a = b) (h₃ : a = d) : b = d =>
 " Man kann auch rückwärts umschreiben: `h₂` sagt `a = b` mit
 `rw [←h₂]` ersetzt man im Goal `b` durch `a` (`\\l`, also ein kleines L)"

-Hint (a : ℕ) (b : ℕ) (h : a = b) : a = b =>
+HiddenHint (a : ℕ) (b : ℕ) (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 : ℕ) (b : ℕ) (c : ℕ) (d : ℕ) (h₁ : c = d) (h₂ : a = b) (h₃ : a = c) : b = c =>
+HiddenHint (a : ℕ) (b : ℕ) (c : ℕ) (d : ℕ) (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 : ℕ) (b : ℕ) (c : ℕ) (d : ℕ) (h₁ : c = d) (h₂ : a = b) (h₃ : b = d) : b = c =>
+HiddenHint (a : ℕ) (b : ℕ) (c : ℕ) (d : ℕ) (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 : ℕ) (b : ℕ) (h : b = a) : a = b =>
+Hint (a : ℕ) (b : ℕ) (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 : ℕ) (b : ℕ) (c : ℕ) (d : ℕ) (h₁ : c = d) (h₂ : d = b) (h₃ : d = a) : b = c =>
+Hint (a : ℕ) (b : ℕ) (c : ℕ) (d : ℕ) (h₁ : c = d) (h₂ : d = b) (h₃ : d = a) : b = c =>
 "das ist nicht der optimale Weg..."

-Message (a : ℕ) (b : ℕ) (c : ℕ) (d : ℕ) (h₁ : c = d) (h₂ : d = b) (h₃ : a = d) : b = c =>
+Hint (a : ℕ) (b : ℕ) (c : ℕ) (d : ℕ) (h₁ : c = d) (h₂ : d = b) (h₃ : a = d) : b = c =>
 "das ist nicht der optimale Weg..."


@@ -28,10 +28,10 @@ Zeige dass $b + b ^ 2 = b + 1$."
  rw [h] at g
  assumption

-Message (a : ℕ) (b : ℕ) (h : a = b) (g : a + a ^ 2 = b + 1) : b + b ^ 2 = b + 1 =>
+Hint (a : ℕ) (b : ℕ) (h : a = b) (g : a + a ^ 2 = b + 1) : b + b ^ 2 = b + 1 =>
 "`rw [ ... ] at g` schreibt die Annahme `g` um."

-Message (a : ℕ) (b : ℕ) (h : a = b) (g : a + a ^ 2 = b + 1) : a + a ^ 2 = a + 1 =>
+Hint (a : ℕ) (b : ℕ) (h : a = b) (g : a + a ^ 2 = b + 1) : a + a ^ 2 = a + 1 =>
 "Sackgasse. probiers doch mit `rw [h] at g` stattdessen."

 Conclusion "Übrigens, mit `rw [h] at *` kann man im weiteren `h` in **allen** Annahmen und
@@ -22,10 +22,10 @@ Statement
  rw [h]
  ring

-Message (x : ℕ) (y : ℕ) (h : x = 2 * y + 1) : x ^ 2 = 4 * y ^ 2 + 3 * y + 1 + y =>
+Hint (x : ℕ) (y : ℕ) (h : x = 2 * y + 1) : x ^ 2 = 4 * y ^ 2 + 3 * y + 1 + y =>
  "Die Annahme `h` kannst du mit `rw [h]` benützen."

-Message (y : ℕ) : (2 * y + 1) ^ 2 = 4 * y ^ 2 + 3 * y + 1 + y =>
+Hint (y : ℕ) : (2 * y + 1) ^ 2 = 4 * y ^ 2 + 3 * y + 1 + y =>
  "Jetzt kann `ring` übernehmen."

 Conclusion ""
@@ -42,29 +42,29 @@ Statement even_square
  rw [hx]
  ring

-Message (n : ℕ) (h : Even n) : Even (n ^ 2) =>
+Hint (n : ℕ) (h : Even n) : Even (n ^ 2) =>
 "Wenn du die Definition von `even` nicht kennst, kannst du diese mit `unfold even` oder
 `unfold even at *` ersetzen.
 Note: Der Befehl macht erst mal nichts in Lean sondern nur in der Anzeige. Der Beweis funktioniert
 genau gleich, wenn du das `unfold` rauslöscht."

-Message (n : ℕ) (h : ∃ r, n = 2 * r) : ∃ r, n ^ 2 = 2 * r =>
+Hint (n : ℕ) (h : ∃ r, n = 2 * r) : ∃ r, n ^ 2 = 2 * r =>
 "Ein `∃ x, ..` in den Annahmen kann man wieder mit `rcases h with ⟨x, hx⟩` aufteilen, und
 ein `x` erhalten, dass die Aussage erfüllt."

-Message (n : ℕ) (x : ℕ) (hx : n = x + x) : ∃ r, n ^ 2 = 2 * r =>
+Hint (n : ℕ) (x : ℕ) (hx : n = x + x) : ∃ r, n ^ 2 = 2 * r =>
 "Bei einem `∃ x, ..` im Goal hingegen, muss man mit `use y` das Element angeben, dass
 die Aussage erfüllen soll."

-Message (n : ℕ) (x : ℕ) (hx : n = x + x) : ∃ r, (x + x) ^ 2 = r + r =>
+Hint (n : ℕ) (x : ℕ) (hx : n = x + x) : ∃ r, (x + x) ^ 2 = r + r =>
 "Bei einem `∃ x, ..` im Goal hingegen, muss man mit `use y` das Element angeben, dass
 die Aussage erfüllen soll."

-Message (n : ℕ) (x : ℕ) (hx : n = x + x) : n ^ 2 = 2 * x ^ 2 + 2 * x ^ 2 =>
+Hint (n : ℕ) (x : ℕ) (hx : n = x + x) : n ^ 2 = 2 * x ^ 2 + 2 * x ^ 2 =>
 "Prinzipiell löst `ring` simple Gleichungen wie diese. Allerdings musst du zuerst `n` zu
 `x + x` umschreiben..."

-Message (n : ℕ) (x : ℕ) (hx : n = x + x) : (x + x) ^ 2 = 2 * x ^ 2 + 2 * x ^ 2 =>
+Hint (n : ℕ) (x : ℕ) (hx : n = x + x) : (x + x) ^ 2 = 2 * x ^ 2 + 2 * x ^ 2 =>
 "Die Taktik `ring` löst solche Gleichungen."

 Tactics unfold rcases use rw ring
@@ -43,7 +43,7 @@ Statement
  rw [hy]
  ring

-Message (n : ℕ) (hn : Odd n) (h : ∀ (x : ℕ), (Odd x) → Even (x + 1)) : Even (n + 1) =>
+Hint (n : ℕ) (hn : Odd n) (h : ∀ (x : ℕ), (Odd x) → Even (x + 1)) : Even (n + 1) =>
 "`∀ (x : ℕ), (odd x) → even (x + 1)` ist eigentlich das gleiche wie
 `(x : ℕ) → `"

@@ -35,30 +35,30 @@ Statement
  unfold Even
  use n

-Message : ¬ ∃ (n : ℕ), ∀ (k : ℕ) , Odd (n + k) =>
+Hint : ¬ ∃ (n : ℕ), ∀ (k : ℕ) , Odd (n + k) =>
 "`push_neg` schiebt die Negierung an den Quantoren vorbei."


-Message (n : ℕ) : (∃ k, ¬Odd (n + k)) =>
+Hint (n : ℕ) : (∃ k, ¬Odd (n + k)) =>
 "An dieser Stelle musst du nun ein `k` angeben, sodass `n + k` gerade ist... Benutze `use`
 mit der richtigen Zahl."


-Hint (n : ℕ) : ¬Odd (n + n) =>
+HiddenHint (n : ℕ) : ¬Odd (n + n) =>
 "Du kennst ein Lemma um mit `¬odd` umzugehen."

-- Hint (n : ℕ) (k : ℕ) : ¬odd (n + k) =>
+-- HiddenHint (n : ℕ) (k : ℕ) : ¬odd (n + k) =>
 -- "Du kennst ein Lemma um mit `¬odd` umzugehen."

-Hint (n : ℕ) : Even (n + n) =>
+HiddenHint (n : ℕ) : Even (n + n) =>
 "`unfold even` hilft, anzuschauen, was hinter `even` steckt.

 Danach musst du wieder mit `use r` ein `(r : ℕ)` angeben, dass du benützen möchtest."

-- Hint (n : ℕ) (k : ℕ) : even (n + k) =>
+-- HiddenHint (n : ℕ) (k : ℕ) : even (n + k) =>
 -- "`unfold even` hilft hier weiter."

-Message (n : ℕ) : n + n = 2 * n => "Recap: `ring` löst Gleichungen in `ℕ`."
+Hint (n : ℕ) : n + n = 2 * n => "Recap: `ring` löst Gleichungen in `ℕ`."

 Conclusion ""