diff --git a/server/adam/Adam/Levels/Implication.lean b/server/adam/Adam/Levels/Implication.lean
index 6b77705..b3c2887 100644
--- a/server/adam/Adam/Levels/Implication.lean
+++ b/server/adam/Adam/Levels/Implication.lean
@@ -18,17 +18,20 @@ Title "Aussagenlogik 2"
 
 Introduction
 "
-Zurück im Raumschiff macht ihr euch auf den Weg zum einem der beiden Monde, die ebenfalls
-beide bewohnt zu sein scheinen.
+Zurück im Raumschiff macht ihr euch auf den Weg zu einem der beiden Monde, die ebenfalls
+bewohnt zu sein scheinen.
 
-**Du**: Sag mal Robo, Königin *Logisindes* hat under anderem von Implikationen gesprochen,
-aber niemand von den Einwohnern wusste was davon...
+**Du**: Ich habe immer noch das Gefühl, dass ich die Aufgabe von Königin *Logisinde* ohne `tauto` nicht hätte lösen können.
+Kamen in der Aufgabe nicht auch Implikationen vor? 
 
-**Robo**: Auf dem Mond *Implis* den wir gerade ansteuern können sie uns vielleicht mehr
-erzählen…
+**Robo**: Vielleicht haben wir ja auf dem Mond *Implis*, den wir gerade ansteuern, Gelegenheit, noch etwas dazuzulernen.  Festhalten bitte …
 
-Und damit leitet Robo den Landeanflug ein. Implis scheint ein riesiger Tagbau zu sein auf
-dem nach allem möglichen gegraben wird. Überall seht ihr Förderbänder kreuz und quer.
+Und damit leitet Robo den Landeanflug ein. 
+
+Implis scheint ein riesiger Tagebau zu sein.
+Überall verlaufen Förderbänder, kreuz und quer, aber die meisten stehen still.
+Ein schüchterner Operationsleiter erwartet Euch bereits.
+
+**Operationsleiter**:  Ihr kommt mir gerade recht!  Ich habe schon gehört.  Echte Mathematiker!  Wisst Ihr, wir fördern hier Wahrheitswerte.  Und dabei muss man höllisch aufpassen.  Ein Fehler, und alles bricht zusammen.  Aber ich bin sehr vorsichtig.  Ich sage immer:  Lieber Stillstand als Untergang!
 
-Das Operationsteam begrüsst euch freundlich und lädt zum Essen im Kommandoturm.
 "
diff --git a/server/adam/Adam/Levels/Implication/L01_Intro.lean b/server/adam/Adam/Levels/Implication/L01_Intro.lean
index 97fef55..5bac3e2 100644
--- a/server/adam/Adam/Levels/Implication/L01_Intro.lean
+++ b/server/adam/Adam/Levels/Implication/L01_Intro.lean
@@ -11,24 +11,39 @@ Title "Intro"
 
 Introduction
 "
-**Operationsleiter**: Sagt mal, könnt ihr mir hier weiterhelfen?
+**Operationsleiter**: Hier, zum Beispiel:
 "
 
 Statement (A B : Prop) (hb : B) : A → (A ∧ B) := by
-  Hint "**Du**: Einen Moment, das ist eine Implikation (`\\to`),
-  also `A` impliziert `A und B`, soweit so gut, also eine Tautologie.
+  Hint "
+  **Operationsleiter:**  Die Arbeiten meinen, das wäre so richtig und wir würden das dringend brauchen.  Aber keiner kann es mir beweisen.  
 
-  **Robo**: Du hast recht, eigentlich könnte man `tauto` sagen,
-  aber das scheinen die hier tauto nicht zu verstehen.
-  Implikationen kannst du aber mit `intro h` angehen."
+  **Du**: Einen Moment.  Das ist ja gerade so eine Implikation (`\\to`).  Wir nehmen an, dass `{B}` gilt, und wollen zeigen, dass dann gilt `{A}` impliziert `{A} und {B}`. Ja, klar! Natürlich stimmt das.
+
+  Der Operationsleiter sieht Dich erwartungsvoll an. 
+
+  **Du** *(leise zu Robo)*:  Soll ich ihm `tauto` aufschreiben?
+
+  **Robo** *(leise zurück)*:  So wie der aussieht, fürchte ich, das wird er auch nicht verstehen.
+    Schreib den Beweis lieber aus.
+
+  *Du**: Aber wie denn?  Ich glaube, ich würde als erstes gern so etwas sagen wie 'Nehmen wir also an, `{A}` gilt …'
+
+  **Robo**: Ja, gute Idee.  Wähle dazu für Deine Annahme einfach einen Namen, zum Beispiel `{h}`, und schreib `intro {h}`."
   intro hA
-  Hint "**Du**: Jetzt habe ich also angenommen, dass `A` wahr ist und muss `A ∧ B` zeigen,
-  das kennen wir ja schon."
+  Hint "**Du**: OK.  Jetzt habe ich also sowohl `{A}` als auch `{B}` in meinen Annahmen und muss `{A} ∧ {B}` zeigen.
+
+  **Robo**:  Genau.  Und wie das geht, weißt Du ja schon."
   constructor
   assumption
   assumption
 
-Conclusion "Der Operationsleiter nickt bedacht."
+Conclusion "**Operationsleiter:** Perfekt!  Danke schön!
+
+Er geht zu einer Schalttafel und ein paar Knöpfe.  Irgendwo setzt sich lautstark ein Förderband in Bewegung.
+
+**Operationsleiter:** Habt Ihr vielleicht noch ein paar Minuten?  
+"
 
 NewTactic intro
 DisabledTactic tauto
diff --git a/server/adam/Adam/Levels/Implication/L02_Revert.lean b/server/adam/Adam/Levels/Implication/L02_Revert.lean
index 5345c60..563cb7e 100644
--- a/server/adam/Adam/Levels/Implication/L02_Revert.lean
+++ b/server/adam/Adam/Levels/Implication/L02_Revert.lean
@@ -9,22 +9,27 @@ Level 2
 Title "Revert"
 
 Introduction
-"Jemand aus der Gruppe gibt dir ein Blatt Papier mit einer Zeile Text:"
+"Der Operationsleiter holt aus einem Container einen Stapel Papier hervor.  
+
+**Operationsleiter:** Hier hat sich echt einiges angesammelt.  Wäre echt super, wenn Ihr mir noch ein bisschen helfen könntet. 
+
+Er übergibt Euch das oberste Blatt."
 
 Statement (A B : Prop) (ha : A) (h : A → B) : B := by
-  Hint "**Robo**: Mit `revert {ha}` kann man die Annahme `ha` als
-  Implikationsprämisse vorne ans Goal anhängen, dann ist das Goal `{A} → {B}`.
+  Hint "**Operationsleiter:** Das ist von einem Kollegen.
+
+  **Robo**:  Oh, das hab ich schon einmal irgendwo gelesen.  Warte mal … Richtig!  Das war damals, als ich Wikipedia gecrawlt habe: `Der Modus ponens ist eine schon in der antiken Logik geläufige Schlussfigur, die in vielen logischen …`
 
-  **Du**: Das wirkt etwas unnatürlich.
+  **Du**:  Robo!  Gefragt ist ein Beweis und kein historischer Aufsatz!   Oder komme ich hier etwa mit `mopo` oder so etwas weiter?
 
-  **Robo**: Schon, ja. Aber als Tool kann das manchmal nützlich sein."
+  **Robo**:  Ok, nein, sorry.  `mopo` gibt es nicht.  Probier lieber `revert {ha}`."
   revert ha
-  assumption
+  Hint "**Du**:  Aha.  `revert` ist qausi `intro` rückwärts.  
 
-Conclusion "**Du**: Aber das müsste doch auch anders gehen, ich hätte jetzt intuitiv
-die Implikation $A \\Rightarrow B$ angewendet und behauptet, dass es genügt $A$ zu zeigen…
+  **Robo:** Genau.  `intro` nimmt die Prämisse aus einer Implikation `{A} \\to {B}` im Beweisziel und macht daraus eine Annahme.  `revert` nimmt umgekehrt eine Annahme und setzt sie als Implikationsprämisse vor das Beweisziel.  Aber nun mach schon fertig."
+  assumption
 
-Daraufhin lächelt der Fragende nur vorahnend."
+Conclusion "Der Operationsleiter nimmt erfreut Eure Lösung entgegen, und greift zum Telefon."
 
 NewTactic revert
 DisabledTactic tauto
diff --git a/server/adam/Adam/Levels/Implication/L03_Apply.lean b/server/adam/Adam/Levels/Implication/L03_Apply.lean
index 30eb21f..e1f348f 100644
--- a/server/adam/Adam/Levels/Implication/L03_Apply.lean
+++ b/server/adam/Adam/Levels/Implication/L03_Apply.lean
@@ -9,21 +9,20 @@ Title "Apply"
 
 Introduction
 "
-Sein Kollege zieht eine Linie unter deinen Beweis, schreibt ein durchgestrichenes ~`revert`~
-hin und gibt dir das Blatt wieder.
+Leider läuft das Telefonat nicht so gut.  Er legt wieder auf und schüttelt mit dem Kopf.
+
+**Operationsleiter**: Der Kollege auf der anderen Seite des Mondes versteht kein `revert`. Oder er tut zumindest so.  Habt Ihr noch eine andere Idee? 
+
+Er zieht eine Linie unter Euren Beweis, ergänzt ein durchgestrichenes ~`revert`~, und legt Euch das Blatt ein zweites Mal vor.
 "
 
 Statement (A B : Prop) (hA : A) (h : A → B) : B := by
-  Hint "**Robo**: Da hat er natürlich recht, normalerweise ist es viel schöner mit
-  `apply {h}` die Implikation anzuwenden."
+  Hint "**Robo**:  Vielleicht wäre es ohnehin eleganter gewesen, mit Implikation mit `apply {h}` anzuwenden."
   apply h
-  Hint "**Du**: Und jetzt genügt es also `A` zu zeigen."
+  Hint "**Du**: Ja, das kommt mir jetzt auch natürlich vor."
   assumption
 
-Conclusion "**Robo** Übrigens mit `apply LEMMA` kannst auch jedes Lemma anwenden, dessen
-Aussage mit dem Goal übereinstimmt.
-
-Die beiden Fragenden schauen das Blatt an und murmeln zustimmend."
+Conclusion "Diesmal scheint das Telefont erfolgreich zu verlaufen."
 
 NewTactic apply
 DisabledTactic revert tauto
diff --git a/server/adam/Adam/Levels/Implication/L04_Apply.lean b/server/adam/Adam/Levels/Implication/L04_Apply.lean
index bef022c..5181ff7 100644
--- a/server/adam/Adam/Levels/Implication/L04_Apply.lean
+++ b/server/adam/Adam/Levels/Implication/L04_Apply.lean
@@ -10,14 +10,7 @@ Title "Implikation"
 
 Introduction
 "
-**Du** *(zu Robo)*: Testen die uns eigentlich hier?
-
-Ein älteres Gruppenmitglied schiebt ein Tablet über den Tisch und beginnt in leiser
-Stimme zu erklären.
-
-**Mitarbeiterin**: Eines unserer Kontrollelemente ist kaputt und ist verwirrt, wo Sachen hinkommen.
-Gesteuert werden diese über Panels, und hier hab ich das Übungspanel, mit dem wir neue
-Ingeneure ausbilden:
+**Operationsleiter**:  Das hier ist jetzt weider ein lokales Problem.
 "
 
 Statement (A B C : Prop) (f : A → B) (g : B → C) : A → C := by
@@ -31,8 +24,6 @@ Statement (A B C : Prop) (f : A → B) (g : B → C) : A → C := by
   apply f
   assumption
 
-Conclusion "**Du**: Ich hab das Konzept verstanden.
-
-Die Mitarbeiterin ist zufrieden und wünscht euch Glück auf der Mission."
+Conclusion "**Operationsleiter**:  Ihr seid echt super!"
 
 DisabledTactic tauto
diff --git a/server/adam/Adam/Levels/Implication/L05_Apply.lean b/server/adam/Adam/Levels/Implication/L05_Apply.lean
index ef92b93..d4747a9 100644
--- a/server/adam/Adam/Levels/Implication/L05_Apply.lean
+++ b/server/adam/Adam/Levels/Implication/L05_Apply.lean
@@ -8,45 +8,41 @@ Title "Implikation"
 
 Introduction
 "
-Selbstsicher folgt ihr den Anweisungen und geht nach draußen zum
-defekten Kontrollelement. Dieses zeigt ein kompliziertes Diagram:
-$$
-\\begin{CD}
-  A  @>{f}>> B       @<{g}<< C       \\\\
-  @. @V{h}VV @V{m}VV \\\\
-  D  @>{i}>> E       @>{k}>> F       \\\\
-  @A{m}AA @A{n}AA @V{p}VV \\\\
-  G  @<{q}<< H       @>{r}>> I
-\\end{CD}
-$$
+Die nächste Seite sieht ein bisschen komplizierter aus.  Damit Ihr nicht die Übersicht verliert, fasst Robo sofort die verschiedenen Implikationen in einem Diagramm zusammen.
+  $$
+  \\begin{CD}
+    A  @>{f}>> B       @<{g}<< C       \\\\
+    @. @V{h}VV @V{m}VV \\\\
+    D  @>{i}>> E       @>{k}>> F       \\\\
+    @A{m}AA @A{n}AA @V{p}VV \\\\
+    G  @<{q}<< H       @>{r}>> I
+  \\end{CD}
+  $$
 "
-
 Statement
     (A B C D E F G H I : Prop)
     (f : A → B) (g : C → B) (h : B → E) (i : D → E) (k : E → F) (m : G → D)
     (n : H → E) (p : F → I) (q : H → G) (r : H → I) : A → I := by
   Hint "**Du**: Also ich muss einen Pfad von Implikationen $A \\Rightarrow I$ finden.
 
-  **Robo**: Und dann fängst du am besten wieder mit `intro` an."
+  **Robo**: Dann fängst du am besten wieder mit `intro` an."
+
   intro ha
   Branch
     apply r
-    Hint "**Robo**: Das sieht nach einer Sackgasse aus…"
+    Hint "**Robo**: Das sieht nach einer Sackgasse aus …"
   Hint (hidden := true) "**Robo**: Na wieder `apply`, was sonst."
   apply p
   apply k
   apply h
   Branch
     apply g
-    Hint "**Robo**: Nah, da stimmt doch was nicht…"
+    Hint "**Robo**: Nah, da stimmt doch was nicht …"
   apply f
   assumption
 
 Conclusion
-"Mit einem lauten Ratteln springen die Förderbänder wieder an.
-
-**Operationsleiter**: Vielen Dank euch! Kommt ich geb euch eine Führung und stell euch den
-Technikern hier vor."
+"Der Operationsleiter bedankt sich wieder artig.  Er drückt wieder auf ein paar Knöpfe, und mit einem lauten Ratteln springen mehrere Förderbänder gleichzeitig wieder an."
 
 DisabledTactic tauto
 
diff --git a/server/adam/Adam/Levels/Implication/L06_Iff.lean b/server/adam/Adam/Levels/Implication/L06_Iff.lean
index 3941d32..ca0ad39 100644
--- a/server/adam/Adam/Levels/Implication/L06_Iff.lean
+++ b/server/adam/Adam/Levels/Implication/L06_Iff.lean
@@ -4,42 +4,36 @@ Game "Adam"
 World "Implication"
 Level 6
 
-Title "Genau dann wenn"
+Title "Genau dann, wenn"
 
 Introduction
 "
-Als erstes kommt ihr in einen kleinen Raum mit ganz vielen Bildschirmen.
-
-Ein junges Wesen dreht sich auf dem Stuhl um, und sagt:
-
-**Mitarbeiter**: Oh hallo! Schaut euch mal das hier an!
+**Operationsleiter:** Wir hatten auch mal ein paar Förderbänder, die in beide Richtungen laufen konnten.  Die hatte ich vorsichtshalber alle abgestellt, weil in den neusten Handbüchern von solchen Doppelbändern abgeraten wird.  Aber vielleicht sind sie ja unter bestimmten Voraussetzungen doch sicher?  Was meint Ihr zu diesem Fall?
 "
 
 Statement (A B : Prop) (mp : A → B) (mpr : B → A) : A ↔ B := by
-  Hint "**Robo**: Das ist ein genau-dann-wenn Pfeil: `\\iff`. Er besteht aus zwei Teilen:
-  `A ↔ B` ist als `⟨A → B, B → A⟩` definiert.
+  Hint "**Robo**: `→` ist natürlich Leansch für `$\iff$`.  
+  Die Aussage `A ↔ B` besteht also aus zwei Teilen; sie ist als `⟨A → B, B → A⟩` definiert.
 
   **Du**: Also ganz ähnlich wie das UND, `A ∧ B`?
 
-  **Robo**: Genau. Entsprechend kannst du hier auch mit `constructor` anfangen."
+  **Robo**: Genau. Entsprechend kannst Du auch hier mit `constructor` anfangen."
   constructor
-  Hint "**Du**: Ah und die beiden hab ich schon in den Annahmen."
+  Hint "**Du**: Ah, und die beiden Teile habe ich schon in den Annahmen."
   assumption
   assumption
 
 Conclusion
 "
-**Robo**: Übrigens, bei `(h : A ∧ B)` haben die beiden Teile `h.left` und `h.right` geheissen,
-hier bei `(h : A ↔ B)` heissen sie `h.mp` und `h.mpr`.
+**Operationsleiter**: Ok, das leuchtet mir ein.  
 
-**Du**: Also `h.mp` ist `A → B`? Wieso `mp`?
+**Robo** *(zu Dir)*: Übrigens, so wie bei `(h : A ∧ B)` die beiden Teile `h.left` und `h.right` heißen,
+heißen bei `(h : A ↔ B)` die beiden Teile `h.mp` und `h.mpr`.
 
-**Operationsleiter**: \"Modulo Ponens\" ist ein lokaler Begriff hier,
-aber das ist doch nicht wichtig.
+**Du**: Also `h.mp` ist `A → B`? Wieso `mp`?
 
-**Robo**: Und das \"r\" in `mpr` stünde für \"reverse\" weil's die Rückrichtung ist.
+**Robo**: `mp` steht für Modus Ponens`.  Der Modus ponens ist eine schon in der antiken Logik geläufige Schlussfigur, die in vielen logischen Systemen …  Ach nee, das wolltest Du ja nicht hören.  Das \"r\" in `mpr` steht für \"reverse\", weil's die Rückrichtung ist.
 "
-
 NewTactic constructor
 DisabledTactic tauto rw
 
diff --git a/server/adam/Adam/Levels/Implication/L07_Rw.lean b/server/adam/Adam/Levels/Implication/L07_Rw.lean
index dc1fa5d..ad12542 100644
--- a/server/adam/Adam/Levels/Implication/L07_Rw.lean
+++ b/server/adam/Adam/Levels/Implication/L07_Rw.lean
@@ -9,19 +9,17 @@ Game "Adam"
 World "Implication"
 Level 7
 
-Title "Genau dann wenn"
+Title "Genau dann, wenn"
 
 Introduction
 "
-Als nächstes begenet ihr jemandem im Flur.
-
-Dieser hat schon von euch gehört und will sofort wissen, ob ihr ihm helfen könnt:
+**Operationsleiter**: Hier ist noch so etwas.
 "
 
 Statement (A B C D : Prop) (h₁ : C ↔ D) (h₂ : A ↔ B) (h₃ : A ↔ D) : B ↔ C := by
   Hint "**Du**: $B \\iff A \\iff D \\iff C$, die sind doch alle äquivalent…
 
-  **Robo**: Ja aber du musst ihm helfen umzuschreiben. Mit `rw [h₁]` kannst du `C` durch `D`
+  **Robo**: Ja, aber du musst ihm helfen, die Äquivalenzen umzuschreiben. Mit `rw [h₁]` kannst du `C` durch `D`
   ersetzen."
   rw [h₁]
   Hint "**Du** Und wenn ich in die andere Richtung umschreiben möchte?
@@ -29,18 +27,18 @@ Statement (A B C D : Prop) (h₁ : C ↔ D) (h₂ : A ↔ B) (h₃ : A ↔ D) :
   **Robo**: Dann schreibst du ein `←` vor den Namen, also `rw [← hₓ]`."
   Branch
     rw [← h₃]
-    Hint "**Du**: Ehm, das ist verkehrt.
+    Hint "**Du**: Ehm, das war verkehrt.
 
-    **Robo**: Andersrum wär's besser gewesen, aber wenn du jetzt einfach weitermachst bis du
-    sowas wie `A ↔ A` kriegst, kann `rfl` das beweisen.
+    **Robo**: Ja, anders herum wär's besser gewesen.  Aber wenn du jetzt einfach weitermachst, bis Du
+    sowas wie `A ↔ A` erhältst, kann `rfl` das beweisen.
 
-    **Robo: Da fällt mir ein, `rw` versucht automatisch `rfl` am Ende. Das heisst, du musst
-    das nicht einmal mehr schreiben."
+    **Robo: Da fällt mir ein, `rw` wendet ohnehin auch versuchsweise `rfl` an. 
+  Das heißt, Du musst `rfl` nicht einmal ausschreiben."
     rw [h₂]
   rw [←h₂]
   assumption
 
-Conclusion "Ihr geht weiter und der Operationsleiter zeigt euch die Küche."
+Conclusion "**Operationsleiter**:  Wenn Ihr so weitermacht, dann kommen wir ja durch den ganzen Packen durch!"
 
 NewTactic rw assumption
 DisabledTactic tauto
diff --git a/server/adam/Adam/Levels/Implication/L08_Iff.lean b/server/adam/Adam/Levels/Implication/L08_Iff.lean
index 0cd443d..19820b5 100644
--- a/server/adam/Adam/Levels/Implication/L08_Iff.lean
+++ b/server/adam/Adam/Levels/Implication/L08_Iff.lean
@@ -10,35 +10,35 @@ Title "Genau dann wenn"
 
 Introduction
 "
-Der Koch kommt erfreut hinter einem grossen Topf hervor.
-
-**Koch**: Sagt mal, gestern hat mir jemand was erzählt und es will einfach nicht aus
-meinem Kopf…
+  **Operationsleiter**: Das hier ist wieder für meinen beschränkten Kollegen.  Ich glaube, `rw` mag der auch nicht.  Geht das trotzdem?
 "
 
 Statement (A B C : Prop) (h : A ↔ B) (g : B → C) : A → C := by
   Hint "**Du**: Naja ich kann wohl immerhin mal mit `intro` anfangen und annehmen,
-  dass `{A}` wahr sei…
+  dass `{A}` wahr sei …
 
-  **Robo**: und dann schauen wir weiter!"
+  **Robo**: … und dann schauen wir weiter!"
   intro hA
-  Hint "**Robo**: Also eine Implikation wendet man mit apply an…
+  Hint "**Robo**: Also eine Implikation wendet man mit `apply` an …
 
-  **Du**: Weiss ich ja!"
+  **Du**: Weiß ich doch!"
   apply g
-  Hint "**Robo**: …und du kannst die Implikation `{A} → {B}` genau gleich mit
+  Hint "**Robo**: … und Du kannst die Implikation `{A} → {B}` genau gleich mit
   `apply {h}.mp` anwenden.
 
-  **Du**: Aber ich könnte hier auch `rw [← h]` sagen, oder?
+  **Du**: Aber normalerweise könnte ich hier auch `rw [← h]` sagen, oder?
 
-  **Robo**: Klar, aber offenbar versteht der Koch das `rw` nicht.
+  **Robo**: Ja ja, nur nicht auf der anderen Seite des Mondes.
   "
   apply h.mp
   assumption
 
-Conclusion "**Koch**: Danke vielmals! Jetzt muss ich aber schauen dass die Suppe nicht verkocht!
+Conclusion "**Operationsleiter**:  Ok, super.  Das müsste passen.
+
+Er telefoniert wieder.
 
-Und er eilt davon."
+**Operationsleiter**: Bingo!
+"
 
 NewTactic apply assumption
 DisabledTactic tauto rw
diff --git a/server/adam/Adam/Levels/Implication/L09_Iff.lean b/server/adam/Adam/Levels/Implication/L09_Iff.lean
index 60835df..d225eae 100644
--- a/server/adam/Adam/Levels/Implication/L09_Iff.lean
+++ b/server/adam/Adam/Levels/Implication/L09_Iff.lean
@@ -10,32 +10,32 @@ Title "Genau dann wenn"
 
 Introduction
 "
-Noch während der Koch wieder zu seiner Suppe geht, kommt sein erster Gehilfe hervor.
+**Operationsleiter**:  Ah, die nächste Seite ist auch von diesem Kollegen. Aber da ist noch eine Notiz bei.  Wir hatten hierfür schon einmal einen Beweis, aber den mochte er nicht.  Er wollte einen Beweis, der weder `rw` noch `apply` verwendet!! 
 
-**Gehilfe**: Ich hab gestern noch was anderes gehört, könnt ihr mir da auch helfen?
-Aber ich versteh nicht ganz was ihr meinem Chef erklärt habt.
+Er holt tief Luft und seuft.  
+
+**Operationsleiter**:  Ich glaube, der stellt sich immer viel dümmer, als er ist.  Aber meint Ihr, Ihr schafft das?
 "
 
 Statement (A B : Prop) : (A ↔ B) → (A → B) := by
   Hint "**Du**: Hmm, mindestens mit der Implikation kann ich anfangen."
   Hint (hidden := true) "**Robo**: Genau, das war `intro`."
   intro h
-  Hint "**Du**: Also ich kenn `rw [h]` und `apply h.mp`, aber das will er wohl nicht hören.
+  Hint "**Du**: Also, ich kenne `rw [h]` und `apply h.mp`, aber das wollten wir ja diesmal vermeiden.
 
-  **Robo**: Was du machen könntest ist mit `rcases h with ⟨mp, mpr⟩` die Annahme in zwei
+  **Robo**: Was Du machen könntest, ist, mit `rcases h with ⟨mp, mpr⟩` die Annahme in zwei
   Teile aufteilen."
   Branch
     intro a
-    Hint "**Robo**: Hier müsstest du jetzt `rw [←h]` oder `apply h.mp` benützen, aber der
-    Gehilfe will, dass du zwingend eine dritte Variante benützt. Geh doch einen
-    Schritt zurück so dass das Goal `A → B` ist."
+    Hint "**Robo**: Hier müsstest Du jetzt `rw [←h]` oder `apply h.mp` benutzen.
+    Geh lieber einen Schritt zurück, sodass das Goal `A → B` ist."
   rcases h with ⟨mp, mpr⟩
-  Hint (hidden := true) "**Du**: Ah und jetzt ist das Resultat in den Annahmen."
+  Hint (hidden := true) "**Du**: Ah, und jetzt ist das Beweisziel in den Annahmen."
   assumption
 
 Conclusion
 "
-**Gehilfe**: Ah danke! Und jetzt versteh ich auch die Zusammenhänge!
+**Operationsleiter**: Perfekt, das sollte reichen!
 "
 OnlyTactic intro rcases assumption
 DisabledTactic rw apply tauto
diff --git a/server/adam/Adam/Levels/Implication/L10_Apply.lean b/server/adam/Adam/Levels/Implication/L10_Apply.lean
index 5e47099..d67c961 100644
--- a/server/adam/Adam/Levels/Implication/L10_Apply.lean
+++ b/server/adam/Adam/Levels/Implication/L10_Apply.lean
@@ -11,38 +11,39 @@ Title "Lemmas"
 
 Introduction
 "
-Ihr setzt euch hin und der Gehilfe bringt euch allen Suppe. Neben euch sitzt eine Mechanikerin
-über ihre Suppe geneigt.
+Beim nächsten Problem stutzt der Operationsleiter.
 
-**Mechanikerin**: Sagt mal, ich hab unten über folgendes tiefgründiges Problem nachgedacht:
+**Operationsleiter**:  Ehrlich gesagt weiß ich gar nicht, wo dieses Blatt herkommt.  Das ist gar nicht von mir.  Sieht aber irgendwie interessant aus.
 "
 
 Statement (A : Prop) : ¬A ∨ A := by
-  Hint "**Du**: Das scheint ziemlich offensichtlich.
+  Hint "**Du**: Das scheint wieder ziemlich offensichtlich.
 
-  **Robo**: Ich glaube, sie will eine detailierte Antwort. Ich kenne ein Lemma
-  `not_or_of_imp`, was sagt `(A → B) → ¬ A ∨ B`. Da das Resultat des Lemmas mit
-  deinem Goal übreinstimmt, kannst du es mit `apply not_or_of_imp` anwenden."
-  Branch
+  **Robo**:  Nee, offensichtlich ist das nicht.  Aber ich glaube, es gibt ein wohlbekanntens Lemma, das hier weiterhilft:
+  `not_or_of_imp` besagt `(A → B) → ¬ A ∨ B`.  Da die rechte Seite der Implikation mit Deinem Beweisziel übereinstimmt, 
+  kannst Du es mit `apply not_or_of_imp` anwenden.
+
+  **Du**:  `Wohlbekannt` auf Implis?
+
+  **Robo**:  Werden wir sehen. Probiers aus!"
+  Branch     
     right
     Hint "**Du**: Und jetzt?
 
-    **Robo**: `right/left` funktioniert hier nicht, da du nicht weisst ob `A` wahr oder falsch
-    ist."
+    **Robo**: `right/left` funktioniert hier nicht, da Du nicht weißt, ob `A` wahr oder falsch ist."
   Branch
     left
     Hint "**Du**: Und jetzt?
 
-    **Robo**: `right/left` funktioniert hier nicht, da du nicht weisst ob `A` wahr oder falsch
-    ist."
+    **Robo**: `right/left` funktioniert hier nicht, da Du nicht weißt, ob `A` wahr oder falsch ist."
   apply not_or_of_imp
-  Hint (hidden := true) "**Robo**: Ich würd wieder mit `intro` weitermachen."
+  Hint (hidden := true) "**Robo**: Ich würde wieder mit `intro` weitermachen."
   intro
   assumption
 
 Conclusion
 "
-**Mechanikerin**: Danke vielmals, jetzt bin ich schon viel ruhiger.
+Der Operationsleiter nickt zustimmend.  Offenbar war ihm `not_or_of_imp` tatsächlich bekannt.
 "
 
 NewLemma not_or_of_imp
diff --git a/server/adam/Adam/Levels/Implication/L11_ByCases.lean b/server/adam/Adam/Levels/Implication/L11_ByCases.lean
index d5048b4..7d749e0 100644
--- a/server/adam/Adam/Levels/Implication/L11_ByCases.lean
+++ b/server/adam/Adam/Levels/Implication/L11_ByCases.lean
@@ -11,19 +11,20 @@ Title "by_cases"
 
 Introduction
 "
-**Du**: Sagt mal, hätte ich da nicht auch einfach zwei Fälle anschauen können:
-Wenn `A` wahr ist, beweis ich die rechte Seite, sonst die Linke.
+**Du**: Sag mal, hätten wir nicht auch einfach zwei Fälle anschauen können? 
+Wenn `A` wahr ist, beweisen wir die rechte Seite, sonst die Linke.
 
 **Robo**: Tatsächlich, `by_cases h : A` würde genau das machen!
+
+**Du** (zum Operationsleiter): Können wir das Blatt bitte noch einmal haben?
 "
 
 Statement (A : Prop) : ¬A ∨ A := by
-  Hint (hidden := true) "**Du**: Wie?
+  Hint (hidden := true) "**Du**: Wie noch einmal?
 
   **Robo**: Also `by_cases h : A` erstellt zwei Goals. Im ersten hast Du `(h : A)` zur
   Verfügung, im zweiten `(h : ¬ A)`."
   by_cases h : A
-  Hint "**Du**: "
   right
   assumption
   left
@@ -31,7 +32,7 @@ Statement (A : Prop) : ¬A ∨ A := by
 
 Conclusion
 "
-**Du**: Das kann noch ganz nützlich sein.
+**Du**: So gefällt mir der Beweis viel besser!
 "
 
 NewTactic by_cases
diff --git a/server/adam/Adam/Levels/Implication/L12_Rw.lean b/server/adam/Adam/Levels/Implication/L12_Rw.lean
index 5685c3a..61a637e 100644
--- a/server/adam/Adam/Levels/Implication/L12_Rw.lean
+++ b/server/adam/Adam/Levels/Implication/L12_Rw.lean
@@ -11,19 +11,12 @@ Title "Lemmas"
 
 Introduction
 "
-Der Arbeitskollegin der Mechanikerin, der die ganze Zeit gespannt zugehört hat, dreht sich zu
-euch.
-
-Er ist offensichtlich interessiert and existierenden Resultaten zu sein, aber offenbar
-kann er nicht viel mit `apply` anfangen.
-
-Er hat aber folgendes Resultat bereit:
-
+**Operationsleiter**:  Wieder etwas für den Kollegen ….  Und er wollte wieder einen Beweise ohne `apply`.  Ich sehe hier auch, dass ich mir schon einmal etwas hierzu notiert hatte.  Richtig, es gibt da dieses Lemma:
 ```
 lemma not_not (A : Prop) : ¬¬A ↔ A
 ```
 
-und stellt euch folgende Frage:
+**Operationsleiter**:  Schafft Ihr das damit?
 "
 
 Statement (A B C : Prop) : (A ∧ (¬¬C)) ∨ (¬¬B) ∧ C ↔ (A ∧ C) ∨ B ∧ (¬¬C) := by
@@ -33,17 +26,16 @@ Statement (A B C : Prop) : (A ∧ (¬¬C)) ∨ (¬¬B) ∧ C ↔ (A ∧ C) ∨ B
   Hint "**Du**: Häh, wieso hat das jetzt 2 von 3 der `¬¬` umgeschrieben?
 
   **Robo**: `rw` schreibt nur das erste um, das es findet, also `¬¬C`. Aber weil dieses
-  mehrmals vorkommt, werden die alle ersetzt…
+  mehrmals vorkommt, werden die alle ersetzt …
 
-  **Du**: Ah, und `¬¬B` ist was anderes, also brauch ich das Lemma nochmals."
+  **Du**: Ah, und `¬¬B` ist etwas anderes, also brauche ich das Lemma nochmals."
   rw [not_not]
 
 Conclusion
 "
-**Du**: Ah und wir sind fertig…?
+**Du**: Wir sind schon fertig …?
 
-**Robo**: Ja, `rw` versucht immer anschliessend `rfl` aufzurufen, und das hat hier
-funktioniert.
+**Robo**: Ja, `rw` versucht immer anschließend `rfl` aufzurufen, und das hat hier funktioniert.
 "
 
 DisabledTactic tauto apply
diff --git a/server/adam/Adam/Levels/Implication/L13_Summary.lean b/server/adam/Adam/Levels/Implication/L13_Summary.lean
index 0e86aad..d801b44 100644
--- a/server/adam/Adam/Levels/Implication/L13_Summary.lean
+++ b/server/adam/Adam/Levels/Implication/L13_Summary.lean
@@ -13,14 +13,11 @@ Title "Zusammenfassung"
 
 Introduction
 "
-**Operationsleiter**: Damit endet unsere Führung langsam. Bevor ihr weitergeht
-habe ich noch ein Problem, an dem ich mir die Zähne ausbeisse. Wir haben die
-Herleitung eines unserer Programme `imp_iff_not_or` verloren, und wissen nicht mehr
-ob es einwandfrei funktioniert.
+**Operationsleiter**: Ihr habt mir wirklich so geholfen!  Hier ist das letzte Problem.  Das habe ich von meinem Vorgänger geerbt.  Er hat behauptet, wenn wir das lösen können, dann läuft hier wieder alles.  Aber es sah mir immer viel zu schwierig aus, um es überhaupt zu versuchen. Wollt Ihr es einmal probieren?
 
-**Du**: Nah gut, mal sehen. Robo, was hab ich denn alles hier gelernt?
+**Du**: Klar, zeig her!  Robo, kannst Du mir vielleicht auch noch einmal so eine nette Zusammenfassung anzeigen, was ich theoretisch in den letzten fünf Minuten gelernt habe?
 
-**Robo**: Hier ist die Übersicht:
+**Robo**: Hier ist die Übersicht:     
 
 ## Notationen / Begriffe
 
@@ -44,34 +41,35 @@ ob es einwandfrei funktioniert.
 
 Statement imp_iff_not_or (A B : Prop) : (A → B) ↔ ¬ A ∨ B := by
   constructor
-  Hint "**Du**: Das sieht kompliziert aus…
+  Hint "**Du** *(flüsternd)*: Ist das nicht die Definition von `→`? 
 
-  **Robo** *(flüsternd)*: Ja, aber die Richtung kennst du ja schon also Lemma,
-  wend doch einfach das an."
+  **Robo** *(flüsternd)*: Könnte man so sehen.  Aber auf Leansch ist das bloß eine Äquivalenz.  
+  So oder so kennst du ja eine Richtung schon als Lemma. 
+  Also wende das doch einfach an."
   apply not_or_of_imp
   Hint "**Du**: Gibt es für die Gegenrichtung auch ein Lemma?
 
-  **Robo**: Leider nicht. Da musst du manuell ran."
-  Hint (hidden := true) "**Robo**: Na Implikationen fangst du immer mit `intro` an."
+  **Robo**: Leider nicht. Da musst Du manuell ran."
+  Hint (hidden := true) "**Robo**: Na Implikationen gehst Du immer mit `intro` an."
   intro h
   intro ha
-  Hint (hidden := true) "**Robo**: Ich wür mal die Annahme `h` mit `rcases` aufteilen."
+  Hint (hidden := true) "**Robo**: Ich würde mal die Annahme `h` mit `rcases` aufteilen."
   rcases h with h | h
   contradiction
   assumption
 
 DisabledTactic tauto
 
-Conclusion "**Operationsleiter**: Damit gehen unsere Wege auseinander. Da fällt mir ein, seit
-ihr auf dem Weg zu unserem Schwestermond?
+Conclusion "**Operationsleiter**: Das ist ja fantastisch!  Tausend Dank!  Dann will ich Euch auch gar nicht länger aufhalten.
+Ihr wollt bestimmt weiter zu Quantus, unserem Schestermond, oder?
 
-**Du**: Könnten wir sein…
+**Du**: Ehm, vielleicht …
 
-**Operationsleiter**: Ich hab hier einen Brief für *Evenine*, könntet ihr diesen mit euch führen?
+**Operationsleiter**: Dann habe ich noch eine letzte Bitte. Ich habe hier noch einen Brief für die Königin von Quantus!  Auch schon von meinem Vorgänger geerbt. Die Post will ihn nicht annehmen, weil ich die Adresse nicht weiß.  Könntet Ihr ihn vielleicht zu ihr mitnehmen?
 
-**Du**: Klar! Robo, halt den mal.
+**Du**: Klar! Robo, halt mal.
 
-Robo nimmt den Brief und lässt ihn irgendwo in seinem Innern verschwinden. Dabei bemerkt er
-den besorgten Blick des Operationsleiters.
+Robo nimmt den Brief und lässt ihn irgendwo in seinem Innern verschwinden. 
+Der Operationsleiter sieht ihn entgeistert an.
 
 **Robo**: Keine Angst, ich verdaue nichts!"