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
@@ -31,10 +31,10 @@ Statement
  assumption
  assumption

-Hint (A : Prop) (B : Prop) (hb : B) : A → (A ∧ B) =>
+HiddenHint (A : Prop) (B : Prop) (hb : B) : A → (A ∧ B) =>
 "Mit `intro ha` kann man annehmen, dass $A$ wahr ist. danach muss man $A \\land B$ zeigen."

-Message (A : Prop) (B : Prop) (ha : A) (hb : B) : (A ∧ B) =>
+Hint (A : Prop) (B : Prop) (ha : A) (hb : B) : (A ∧ B) =>
 "Jetzt kannst du die Taktiken aus dem letzten Kapitel verwenden."

 Tactics intro constructor assumption
@@ -36,7 +36,7 @@ dass $B$ wahr ist."
  revert ha
  assumption

-Hint (A : Prop) (B : Prop) (ha : A) (h : A → B): B =>
+HiddenHint (A : Prop) (B : Prop) (ha : A) (h : A → B): B =>
 "Mit `revert ha` kann man die Annahme `ha` als Implikationsprämisse vorne ans Goal anhängen."

 Tactics revert assumption
@@ -25,10 +25,10 @@ Statement
  apply g
  assumption

-Hint (A : Prop) (B : Prop) (hA : A) (g : A → B) : B =>
+HiddenHint (A : Prop) (B : Prop) (hA : A) (g : A → B) : B =>
 "Mit `apply g` kannst du die Implikation `g` anwenden."

-Hint (A : Prop) (B : Prop) (hA : A) (g : A → B) : A =>
+HiddenHint (A : Prop) (B : Prop) (hA : A) (g : A → B) : A =>
 "Nachdem du die Implikation `A → B` angewendet hast, musst du nur noch $A$ zeigen,
 dafür hast du bereits einen Beweis in den Annahmen."

@@ -22,13 +22,13 @@ Statement
  apply f
  assumption

-Hint (A : Prop) (B : Prop) (C : Prop) (f : A → B) (g : B → C) : A → C =>
+HiddenHint (A : Prop) (B : Prop) (C : Prop) (f : A → B) (g : B → C) : A → C =>
 "Mit `intro hA` kann man annehmen, dass $A$ wahr ist. danach muss man $B$ zeigen."

-Message (A : Prop) (B : Prop) (C : Prop) (hA : A) (f : A → B) (g : B → C) : C =>
+Hint (A : Prop) (B : Prop) (C : Prop) (hA : A) (f : A → B) (g : B → C) : C =>
 "Jetzt ist es ein altbekanntes Spiel von `apply`-Anwendungen."

-Hint (A : Prop) (B : Prop) (C : Prop) (hA : A) (f : A → B) (g : B → C) : C =>
+HiddenHint (A : Prop) (B : Prop) (C : Prop) (hA : A) (f : A → B) (g : B → C) : C =>
 "Du willst $C$ beweisen. Suche also nach einer Implikation $\\ldots \\Rightarrow C$ und wende
 diese mit `apply` an."

@@ -28,22 +28,22 @@ Statement
  apply f
  assumption

-Hint (A : Prop) (B : Prop) (C : Prop) (D : Prop) (E : Prop) (F : Prop)
+HiddenHint (A : Prop) (B : Prop) (C : Prop) (D : Prop) (E : Prop) (F : Prop)
    (f : A → B) (g : C → B) (h : B → E)
    (i : D → E) (k : E → F) (m : C → F) : A → F =>
 "Wieder ist es schlau, mit `intro` anzufangen."

-Hint (A : Prop) (B : Prop) (C : Prop) (D : Prop) (E : Prop) (F : Prop)
+HiddenHint (A : Prop) (B : Prop) (C : Prop) (D : Prop) (E : Prop) (F : Prop)
    (hA : A) (f : A → B) (g : C → B) (h : B → E)
    (i : D → E) (k : E → F) (m : C → F) : F =>
 "Versuch mit `apply` den richtigen Weg zu finden."

-Message (A : Prop) (B : Prop) (C : Prop) (D : Prop) (E : Prop) (F : Prop)
+Hint (A : Prop) (B : Prop) (C : Prop) (D : Prop) (E : Prop) (F : Prop)
    (hA : A) (f : A → B) (g : C → B) (h : B → E)
    (i : D → E) (k : E → F) (m : C → F) : C =>
 "Sackgasse. Probier doch einen anderen Weg."

-Message (A : Prop) (B : Prop) (C : Prop) (D : Prop) (E : Prop) (F : Prop)
+Hint (A : Prop) (B : Prop) (C : Prop) (D : Prop) (E : Prop) (F : Prop)
    (hA : A) (f : A → B) (g : C → B) (h : B → E)
    (i : D → E) (k : E → F) (m : C → F) : D =>
 "Sackgasse. Probier doch einen anderen Weg."
@@ -25,10 +25,10 @@ Statement
  assumption
  assumption

-Hint (A : Prop) (B : Prop) : A ↔ B =>
+HiddenHint (A : Prop) (B : Prop) : A ↔ B =>
 "Eine Struktur wie `A ↔ B` kann man mit `constructor` zerlegen."

-Hint (A : Prop) (B : Prop) (h : A → B) : A → B =>
+HiddenHint (A : Prop) (B : Prop) (h : A → B) : A → B =>
 "Such mal in den Annahmen."

 Conclusion
@@ -36,38 +36,38 @@ Statement
  rw [←h₂]
  assumption

-Hint (A : Prop) (B : Prop) (C : Prop) (D : Prop) (h₁ : C ↔ D) (h₂ : A ↔ B) (h₃ : A ↔ D) : B ↔ C =>
+HiddenHint (A : Prop) (B : Prop) (C : Prop) (D : Prop) (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 : Prop) (B : Prop) (C : Prop) (D : Prop) (h₁ : C ↔ D) (h₂ : A ↔ B) (h₃ : A ↔ D) : A ↔ C =>
+HiddenHint (A : Prop) (B : Prop) (C : Prop) (D : Prop) (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₁]`."

-Message (A : Prop) (B : Prop) (C : Prop) (D : Prop) (h₁ : C ↔ D) (h₂ : A ↔ B) (h₃ : A ↔ D) : B ↔ D =>
+Hint (A : Prop) (B : Prop) (C : Prop) (D : Prop) (h₁ : C ↔ D) (h₂ : A ↔ B) (h₃ : A ↔ D) : B ↔ D =>
 "Man kann auch rückwärts umschreiben:
 `rw [←h₂]` ersetzt man im Goal `B` durch `a` (`\\l`, also ein kleines L)"

-Hint (A : Prop) (B : Prop) (h : A ↔ B) : A ↔ B =>
+HiddenHint (A : Prop) (B : Prop) (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 : Prop) (B : Prop) (C : Prop) (D : Prop) (h₁ : C ↔ D) (h₂ : A ↔ B) (h₃ : A ↔ C) : B ↔ C =>
+HiddenHint (A : Prop) (B : Prop) (C : Prop) (D : Prop) (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 : Prop) (B : Prop) (C : Prop) (D : Prop) (h₁ : C ↔ D) (h₂ : A ↔ B) (h₃ : B ↔ D) : B ↔ C =>
+HiddenHint (A : Prop) (B : Prop) (C : Prop) (D : Prop) (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 : Prop) (B : Prop) (h : B ↔ A) : A ↔ B =>
+Hint (A : Prop) (B : Prop) (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 : Prop) (B : Prop) (C : Prop) (D : Prop) (h₁ : C ↔ D) (h₂ : D ↔ B) (h₃ : D ↔ A) : B ↔ C =>
+Hint (A : Prop) (B : Prop) (C : Prop) (D : Prop) (h₁ : C ↔ D) (h₂ : D ↔ B) (h₃ : D ↔ A) : B ↔ C =>
 "Das ist nicht der optimale Weg..."

-Message (A : Prop) (B : Prop) (C : Prop) (D : Prop) (h₁ : C ↔ D) (h₂ : D ↔ B) (h₃ : A ↔ D) : B ↔ C =>
+Hint (A : Prop) (B : Prop) (C : Prop) (D : Prop) (h₁ : C ↔ D) (h₂ : D ↔ B) (h₃ : A ↔ D) : B ↔ C =>
 "Das ist nicht der optimale Weg..."


@@ -30,13 +30,13 @@ Statement
  apply h.mp
  assumption

-Hint (A : Prop) (B : Prop) (C : Prop) (h : A ↔ B) (g : B → C) : A → C =>
+HiddenHint (A : Prop) (B : Prop) (C : Prop) (h : A ↔ B) (g : B → C) : A → C =>
 "Fange wie immer mit `intro` an."

-Hint (A : Prop) (B : Prop) (C : Prop) (h : A ↔ B) (g : B → C) (hA : A) : C =>
+HiddenHint (A : Prop) (B : Prop) (C : Prop) (h : A ↔ B) (g : B → C) (hA : A) : C =>
 "Wie im Implikationen-Level kannst du nun `apply` verwenden."

-Message (A : Prop) (B : Prop) (C : Prop) (h : A ↔ B) (g : B → C) (hA : A) : B =>
+Hint (A : Prop) (B : Prop) (C : Prop) (h : A ↔ B) (g : B → C) (hA : A) : B =>
 "Mit `apply h.mp` kannst du nun die Implikation `A → B` anwenden."

 Conclusion "Im nächsten Level findest du die zweite Option."
@@ -25,10 +25,10 @@ Statement
  rcases h
  assumption

-Hint (A : Prop) (B : Prop) : (A ↔ B) → A → B =>
+HiddenHint (A : Prop) (B : Prop) : (A ↔ B) → A → B =>
 "Angefangen mit `intro h` kannst du annehmen, dass `(h : A ↔ B)` wahr ist."

-Hint (A : Prop) (B : Prop) (h : A ↔ B) : A → B =>
+HiddenHint (A : Prop) (B : Prop) (h : A ↔ B) : A → B =>
 "Mit `rcases h with ⟨h₁, h₂⟩` kannst du jetzt die Annahme `(h : A ↔ B)` zerlegen."


@@ -40,10 +40,10 @@ Statement
  intro
  assumption

-Hint (A : Prop) :  ¬A ∨ A =>
+HiddenHint (A : Prop) :  ¬A ∨ A =>
 "Das Lemma wendest du mit `apply not_or_of_imp` an."

-Hint (A : Prop) : A → A =>
+HiddenHint (A : Prop) : A → A =>
 "Wie immer, `intro` ist dein Freund."

 Conclusion
@@ -52,28 +52,28 @@ Statement imp_iff_not_or
  contradiction
  assumption

-Hint (A : Prop) (B: Prop) : (A → B) ↔ ¬ A ∨ B =>
+HiddenHint (A : Prop) (B: Prop) : (A → B) ↔ ¬ A ∨ B =>
 "Eine Äquivalenz im Goal geht man immer mit `constructor` an."

-Hint (A : Prop) (B: Prop) : (A → B) → ¬ A ∨ B =>
+HiddenHint (A : Prop) (B: Prop) : (A → B) → ¬ A ∨ B =>
 "Diese Aussage hast du vorhin bereits als Lemma kennengelernt und angewendet."

-Hint (A : Prop) (B: Prop) (h : A → B) : ¬ A ∨ B =>
+HiddenHint (A : Prop) (B: Prop) (h : A → B) : ¬ A ∨ B =>
 "Diese Aussage hast du vorhin bereits als Lemma kennengelernt und angewendet."

-Hint (A : Prop) (B: Prop) : ¬ A ∨ B → (A → B) =>
+HiddenHint (A : Prop) (B: Prop) : ¬ A ∨ B → (A → B) =>
 "Eine Implikation geht man fast immer mit `intro h` an."

-Hint (A : Prop) (B: Prop) (h : ¬ A ∨ B) : (A → B) =>
+HiddenHint (A : Prop) (B: Prop) (h : ¬ A ∨ B) : (A → B) =>
 "Nochmals `intro`."

-Hint (A : Prop) (B: Prop) (h : ¬ A ∨ B) : (A → B) =>
+HiddenHint (A : Prop) (B: Prop) (h : ¬ A ∨ B) : (A → B) =>
 "Das ODER in den Annahmen kannst du mit `rcases h with h | h` aufteilen."

-Hint (A : Prop) (B: Prop) (h : ¬ A ∨ B) (ha : A) : B =>
+HiddenHint (A : Prop) (B: Prop) (h : ¬ A ∨ B) (ha : A) : B =>
 "Das ODER in den Annahmen kannst du mit `rcases h with h | h` aufteilen."

-Hint (A : Prop) (B: Prop) (ha : A) (ha' : ¬A) : B =>
+HiddenHint (A : Prop) (B: Prop) (ha : A) (ha' : ¬A) : B =>
 "Findest du einen Widerspruch?"

 Tactics rfl assumption trivial left right constructor rcases