14 files changed, 101 insertions, 68 deletions

diff --git a/conclusion.tex b/conclusion.tex
new file mode 100644
index 0000000..c604841
--- /dev/null
+++ b/conclusion.tex
@@ -0,0 +1,4 @@
+Unsere konkrete Implementierung hat, wie in Abschnitt \ref{performance} besprochen, Performance-Charakteristik, die sie für den tatsächlichen Einsatz untauglich macht.
+Aufgrund der Struktur unserer Implementierung lässt sich jedoch eine der unterliegenden Ideen, das Komplement der edit-lens als Binärbaum von Wirkungen darzustellen und durch effizientes Austauschen von Baumfragmenten die gewünschte Laufzeit-Charakteristik zu erreichen, in Zukunft recht einfach auf andere Parser anwenden.
+
+Zusammenfassend haben wir eine neue und non-triviale Anwendung von edit-lenses vorgestellt.
diff --git a/edit-lens/src/Control/DFST.lhs b/edit-lens/src/Control/DFST.lhs
index 271a13e..eb838ae 100644
--- a/edit-lens/src/Control/DFST.lhs
+++ b/edit-lens/src/Control/DFST.lhs
@@ -39,7 +39,7 @@ import Text.Dot
 \end{comment}
 
 \begin{defn}[deterministic finite state transducer]
-  Wir nennen einen FST \emph{deterministic}, wenn jedes Paar aus Ausgabezustand und Eingabesymbol maximal eine Transition zulässt, $\epsilon$-Transitionen keine Schleifen bilden und die Menge von initialen Zustände einelementig ist.
+  Wir nennen einen FST \emph{deterministic}, wenn jedes Paar aus Ausgabezustand und Eingabesymbol maximal eine Transition zulässt, $\epsilon$-Transitionen keine Schleifen bilden und die Menge von initialen Zuständen einelementig ist.
 
   Zusätzlich ändern wir die Darstellung indem wir $\epsilon$-Transitionen kontrahieren.
   Wir erweitern hierfür die Ausgabe pro Transition von einem einzelnen Zeichen zu einem Wort beliebiger Länge und fügen, bei jeder Kontraktion einer $\epsilon$-Transition $A \rightarrow B$, die Ausgabe der Transition vorne an die Ausgabe aller Transitionen $B \rightarrow \ast$ von $B$ an.
diff --git a/edit-lens/src/Control/DFST/Lens.lhs b/edit-lens/src/Control/DFST/Lens.lhs
index 8222db2..ec81113 100644
--- a/edit-lens/src/Control/DFST/Lens.lhs
+++ b/edit-lens/src/Control/DFST/Lens.lhs
@@ -138,12 +138,12 @@ Wir bedienen uns hierbei einer bestehenden Programmbibliothek \cite{composition-
   Auf $s$ wechselt der DFST seinen Zustand, auf $p$ produziert er, abhängig vom aktuellen Zustand, genau ein Zeichen.
 
   Wir stellen die Wirkung des DFST auf den Eingabe-String $spp$ grafisch analog zur Baumstruktur von \texttt{Compositions} dar.
-  Wir bedienen uns hier der Darstellung von Automaten-Wirkungen als \emph{Schaltboxen} aus \cite{hofmann2011automatentheorie}, angepasst für DFSTs indem wir die Ausgabe des Automaten an den Pfaden innerhalb der Schaltbox annotieren.
+  Wir bedienen uns hier der Darstellung von Automaten-Wirkungen als \emph{Schaltboxen} aus \cite{hofmann2011automatentheorie}, angepasst für DFSTs indem wir die Ausgabe des transducers an den Pfaden innerhalb der Schaltbox annotieren.
   
   \begin{figure}[H]
     \centering
     \pinclude{presentation/comptree.tex}
-    \caption{Die Wirkung der Eingabe $spp$ auf den Automaten aus Abbildung \ref{fig:switchdfst}}
+    \caption{Die Wirkung der Eingabe $spp$ auf den einfachen transducer aus Abbildung \ref{fig:switchdfst}}
   \end{figure}
 \end{eg}
 
@@ -160,7 +160,7 @@ dfstaProduces = fmap fst . runDFSTAction'
 \end{code}
 \end{comment}
 
-Für $\Rrightarrow$ können wir die alte DFST-Wirkung zunächst anhand des Intervalls indem der input-String von allen gegebenen edits betroffen ist (\texttt{affected}) in einen unveränderten Prefix und einen womöglich betroffenen Suffix unterteilen.
+Für $\Rrightarrow$ können wir die alte DFST-Wirkung zunächst anhand des Intervalls in dem der input-String von allen gegebenen edits betroffen ist (\texttt{affected}) in einen unveränderten Prefix und einen womöglich betroffenen Suffix unterteilen.
 
 Da wir wissen welche Stelle im input-String vom ersten gegebenen edit betroffen ist können wir, anhand der Wirkung des Teilstücks bis zu jener Stelle, den betroffenen Suffix wiederum teilen.
 Die Wirkung ab der betroffenen Stelle im input-String können wir als Komposition der Wirkung der durch den edit betroffenen Stelle und derer aller Zeichen danach bestimmen.
@@ -170,12 +170,12 @@ Für die asymmetrische edit-lens entgegen der DFST-Richtung $\Lleftarrow$ verwen
 
 Wir unterteilen zunächst das Komplement an den Grenzen des betroffenen Intervalls im output-String in drei Teile (durch Akkumulation der Elemente des Komplements bis die gewünschte Länge erreicht ist).
 
-Wir transformieren dann den DFST in einen FST, dessen Ausgabe wir mit \texttt{restrictOutput} auf das gewünschte Fragment einschränken, setzen als initialen Zustand des FST den Zustand am linken Rand des von den edits betroffenen Intervalls und akzeptieren jene Zustände, von denen aus das Komplement-Fragment ab dem rechten Rand des betroffenen Intervalls zu einem im ursprünglichen DFST akzeptierten Zustand führt.
+Wir transformieren dann den DFST in einen FST, dessen Ausgabe wir mit \texttt{restrictOutput} auf das gewünschte Fragment einschränken, setzen als initialen Zustand des FST den Zustand am linken Rand des von den edits betroffenen Intervalls und akzeptieren jene Zustände, von denen aus das Komplement-Fragment ab dem rechten Rand des betroffenen Intervalls zu einem im ursprünglichen DFST akzeptierenden Zustand führt.
 
-Wir verwenden dann gewöhnliche Breitensuche über die Zustände und Transitionen des soeben konstruierten FSTs um einen Lauf-Fragment zu bestimmen, dass wir in das betroffene Intervall einsetzen können.
-Hierbei sind sämtliche Randbedingungen (korrekte Ausgabe, Übereinstimmung an den Intervallgrenzen) bereits in den FST kodiert sodass wir nur noch prüfen müssen, dass der gefunde Lauf in einem akzeptierten Zustand endet.
+Wir verwenden dann gewöhnliche Breitensuche über die Zustände und Transitionen des soeben konstruierten FSTs um einen Lauffragment zu bestimmen, dass wir in das betroffene Intervall einsetzen können.
+Hierbei sind sämtliche Randbedingungen (korrekte Ausgabe, Übereinstimmung an den Intervallgrenzen) bereits in den FST kodiert sodass wir nur noch prüfen müssen, dass der gefunde Lauf in einem akzeptierenden Zustand endet.
 
-Die input-edits können nun wiederum, unter Beachtung der Verschiebung der indices um die Länge der Eingabe vor der linken Intervallgrenze, mit dem Unix Standard-Diff-Algorithmus berechnet werden.
+Die input-edits können nun wiederum, unter Beachtung der Verschiebung der Indices um die Länge der Eingabe vor der linken Intervallgrenze, mit dem Unix Standard-Diff-Algorithmus berechnet werden.
 
 \begin{comment}
 \begin{code}
@@ -299,7 +299,8 @@ bfs outgoing predicate
     n & \mapsto ( \text{\tt \textbackslash n}, 0 ) \\
     & \\
     \text{act}_\text{L} & \colon Q \to \Delta^\star \times \{ \bot \} \cup Q \\
-    n & \mapsto (0\, 1\, \ldots\, 80, 80) \\
     \text{other} & \mapsto (\epsilon, \bot)
   \end{align*}
+
+  % TODO
 \end{eg}
diff --git a/edit-lens/src/Control/Edit.lhs b/edit-lens/src/Control/Edit.lhs
index ba4b8e6..80c143a 100644
--- a/edit-lens/src/Control/Edit.lhs
+++ b/edit-lens/src/Control/Edit.lhs
@@ -6,10 +6,10 @@ module Control.Edit
 \end{code}
 \end{comment}
 
-Um das Intuitive Verhalten von Änderungen auf Texten\footnote{Im folgenden \emph{edits}} und ihre interne algebraische Struktur zu fassen formalisieren wir sie als \emph{Moduln}:
+Um das intuitive Verhalten von Änderungen auf Texten\footnote{Im folgenden \emph{edits}} und ihre interne algebraische Struktur zu fassen formalisieren wir sie als \emph{Moduln}:
 
 \begin{defn}[Moduln]
-Ein Modul $M$ ist eine \emph{partielle Monoidwirkung} zusammen mit einem schwach-initialen Element\footnote{Gemeint ist hier die übliche Definition von \emph{schwach-initial} aus der Kategorientheorie—ein Modul $M$ bildet eine Kategorie mit Objekten aus $\Dom M$ und Morphismen von $x$ nach $y$ den Monoidelementen $\partial x \in \partial M$ sodass $x \cdot \partial x = y$} (bzgl. der Monoidwirkung) auf dem Träger, d.h. $M = (\Dom M, \partial M, \init_M)$ ist ein Tupel aus einer Trägermenge $\Dom M$, einem Monoid $\partial M$ zusammen mit mit einer partiellen Funktion $\cdot \colon \Dom M \times \partial M \to \Dom$, die \emph{kompatibel} ist mit der Monoid-Struktur:
+Ein \emph{Modul} $M$ ist eine partielle Monoidwirkung zusammen mit einem schwach-initialen Element\footnote{Gemeint ist hier die übliche Definition von \emph{schwach-initial} aus der Kategorientheorie—ein Modul $M$ bildet eine Kategorie mit Objekten aus $\Dom M$ und Morphismen von $x$ nach $y$ den Monoidelementen $\partial x \in \partial M$ sodass $x \cdot \partial x = y$} (bzgl. der Monoidwirkung) auf dem Träger, d.h. $M = (\Dom M, \partial M, \init_M)$ ist ein Tupel aus einer Trägermenge $\Dom M$, einem Monoid $\partial M$ zusammen mit mit einer partiellen Funktion $\cdot \colon \Dom M \times \partial M \to \Dom$, die \emph{kompatibel} ist mit der Monoid-Struktur:
 
 \begin{itemize}
   \item $\forall m \in \Dom M \colon m \cdot 1_{\partial M} = m$
@@ -22,7 +22,7 @@ $$\forall m \in \Dom M \ \exists \partial m \in \partial M \colon m = \init_M \c
 
 Wir führen außerdem eine Abbildung $(\init_M \cdot)^{-1} \colon \Dom M \to \partial m$ ein, die ein $m$ auf ein arbiträr gewähltes $\partial m$ abbildet für das $\init_M \cdot \partial m = m$ gilt.
 
-In Haskell charakterisieren wir Moduln über ihren Monoid, d.h. die Wahl des Monoiden \texttt{m} legt den Träger \texttt{Domain m}, die Wirkung \texttt{apply}, das initiale Element \texttt{init} und $(\init_M \cdot)^{-1}$ eindeutig fest\footnote{Betrachten wir mehrere Moduln über dem selben Träger (oder mit verschiedenen Wirkungen) führen wir neue, isomorphe, Typen ein (\texttt{newtype}-Wrappern)}.
+In Haskell charakterisieren wir Moduln über ihren Monoid, d.h. die Wahl des Monoiden \texttt{m} legt den Träger \texttt{Domain m}, die Wirkung \texttt{apply}, das initiale Element \texttt{init} und $(\init_M \cdot)^{-1}$ eindeutig fest\footnote{Betrachten wir mehrere Moduln über dem selben Träger (oder mit verschiedenen Wirkungen) führen wir neue, isomorphe Typen ein (\texttt{newtype}-Wrapper)}.
 Eine Repräsentierung als Typklasse bietet sich an:
 
 \begin{code}
diff --git a/edit-lens/src/Control/FST.lhs b/edit-lens/src/Control/FST.lhs
index 9739adc..9cc7524 100644
--- a/edit-lens/src/Control/FST.lhs
+++ b/edit-lens/src/Control/FST.lhs
@@ -46,8 +46,8 @@ import Text.Dot
 \end{code}
 \end{comment}
 
-\begin{defn}[Finite state transducers]
-Unter einem finite state transducer verstehen wir ein 6-Tupel $(\Sigma, \Delta, Q, I, F, E)$ mit $\Sigma$ dem endlichen Eingabe-Alphabet, $\Delta$ dem endlichen Ausgabe-Alphabet, $Q$ einer endlichen Menge an Zuständen, $I \subset Q$ der Menge von initialen Zuständen, $F \subset Q$ der Menge von akzeptierenden Endzuständen, und $E \subset Q \times (\Sigma \cup \{ \epsilon \}) \times (\Delta \cup \{ \epsilon \}) \times Q$ der Transitionsrelation.
+\begin{defn}[Finite State Transducers]
+Unter einem \emph{finite state transducer} verstehen wir ein 6-Tupel $(\Sigma, \Delta, Q, I, F, E)$ mit $\Sigma$ dem endlichen Eingabe-Alphabet, $\Delta$ dem endlichen Ausgabe-Alphabet, $Q$ einer endlichen Menge an Zuständen, $I \subset Q$ der Menge von initialen Zuständen, $F \subset Q$ der Menge von akzeptierenden Endzuständen, und $E \subset Q \times (\Sigma \cup \{ \epsilon \}) \times (\Delta \cup \{ \epsilon \}) \times Q$ der Transitionsrelation.
 
 Semantisch ist ein finite state transducer ein endlicher Automat erweitert um die Fähigkeit bei Zustandsübergängen ein Symbol aus seinem Ausgabe-Alphabet an ein Ausgabe-Wort anzuhängen.
 
@@ -64,7 +64,7 @@ data FST state input output = FST
 \end{defn}
 
 \begin{eg} \label{eg:linebreak}
-  Als wiederkehrendes Beispiel betrachten wir einen Transducer $L_{80} = (\Sigma, \Delta, Q, I, F, E)$, der für ein beliebiges Alphabet $\Sigma \supseteq \{ \text{\tt ' '}, \text{\tt \textbackslash n} \}$ durch Umwandlung zwischen Leerzeichen und Zeilenumbrüchen sicherstellt, dass jede Zeile des Ausgabetextes mindestens 80 Zeichen enthält, jedoch nur an Wortgrenzen umbricht:
+  Als wiederkehrendes Beispiel betrachten wir einen Transducer $L_{80} = (\Sigma, \Delta, Q, I, F, E)$, der für ein beliebiges Alphabet $\Sigma \supseteq \{ \text{\tt ' '}, \text{\tt \textbackslash n} \}$ durch Umwandlung zwischen Leerzeichen und Zeilenumbrüchen sicherstellt, dass jede Zeile des Ausgabetextes möglichst wenige aber mindestens 80 Zeichen enthält, und nur an Wortgrenzen umbricht:
 
   \begin{align*}
     \Delta & = \Sigma \\
@@ -132,7 +132,7 @@ instance (Show state, Show input, Show output, Ord state, Ord input, Ord output)
 \end{comment}
 
 \begin{defn}[Auswertung von FSTs]
-Wir definieren die Auswertung von finite state transducers induktiv indem wir zunächst angeben wie ein einzelner Auswertungs-Schritt erfolgt.
+Wir definieren die \emph{Auswertung} von finite state transducers induktiv indem wir zunächst angeben wie ein einzelner Auswertungs-Schritt erfolgt.
 
 Hierzu kommentieren wir die Haskell-Implementierung eines Auswertungs-Schritts.
 Notwendigerweise ist die Auswertung eines FSTs nicht deterministisch, wir produzieren daher eine Liste von möglichen Resultaten in keiner besonderen Reihenfolge.
@@ -223,7 +223,7 @@ Hierfür berechnen wir das Graphen-Produkt der FSTs:
 \begin{defn}[FST-Produkt]
   Gegeben zwei finite state transducer $T = (\Sigma, \Delta, Q, I, F, E)$ und $T^\prime = (\Sigma^\prime, \Delta^\prime, Q^\prime, I^\prime, F^\prime, E^\prime)$ nennen wir $T^\times = (\Sigma^\times, \Delta^\times, Q^\times, I^\times, F^\times, E^\times)$ das Produkt $T^\times = T \times T^\prime$ von $T$ und $T^\prime$.
 
-  $T^\times$ bestimmt sich als das Graphenprodukt der beiden, die FSTs unterliegenden Graphen, wobei wir die Zustandsübergänge als Kanten mit Gewichten aus dem Boolschen Semiring auffassen:
+  $T^\times$ bestimmt sich als das Graphenprodukt der beiden, die FSTs unterliegenden, Graphen wobei wir die Zustandsübergänge als Kanten mit Gewichten aus dem Boolschen Semiring auffassen:
 
   \begin{align*}
     \Sigma^\times & = \Sigma \cap \Sigma^\prime \\
@@ -270,7 +270,7 @@ productFST fst1 fst2 = FST
 
 Es ist später erforderlich einen FST derart einzuschränken, dass er eine gegebene Ausgabe produziert.
 
-Hierzu nehmen wir das FST-Produkt mit einem FST, der, ungeachtet der Eingabe, immer die gegebene Ausgabe produziert.
+Hierzu nehmen wir das FST-Produkt mit einem FST, der, ungeachtet der Eingabe, immer die gewünschte Ausgabe produziert.
 Da die Ausgaben der beiden FSTs übereinstimmen müssen produziert das Produkt mit einem derartigen FST (solange dessen Ausgabe in keinem Sinne von der Eingabe abhängt) die gewünschte Ausgabe.
 
 Zur Konstruktion eines derartigen \emph{Wort-FST}s nehmen wir Indizes im Ausgabe-Wort (natürliche Zahlen) als Zustände.
@@ -374,12 +374,12 @@ restrictOutput :: forall state input output. (Ord state, Ord input, Ord output)
             (rest2) edge node {$(98, 98)$} (99);
     \end{tikzpicture}
 
-    \caption{\label{fig:l80timesw100} Die Einschränkung des Automaten aus Abbildung \ref{fig:linebreak} auf das Wort aus Abbildung \ref{fig:w100}}
+    \caption{\label{fig:l80timesw100} Die Einschränkung des Automaten aus Abbildung \ref{fig:linebreak} (Zeilenumbrüche $\leftrightarrow$ Leerzeichen) auf das Wort aus Abbildung \ref{fig:w100} ($1 \ldots 80 \text{\texttt{\textbackslash n}} 81 \ldots 98$)}
   \end{figure}
 \end{eg}
 
 \begin{rem}
-  Es ist bemerkenswert, dass in Beispiel \ref{eg:l80timesw100} die Zirkuläre Struktur von $L_{80}$ durch Produkt mit einem Wort verloren geht.
+  Es ist bemerkenswert, dass in Beispiel \ref{eg:l80timesw100} die zirkuläre Struktur von $L_{80}$ durch das Produkt mit einem Wort verloren geht.
 
   I.\@A.\@ ist das Produkt eines beliebigen FST mit einem Wort-FST zwar nicht azyklisch, erbt jedoch die lineare Struktur des Wort-FST in dem Sinne, dass Fortschritt in Richtung der akzeptierenden Zustände nur möglich ist indem der $(i, \sigma, w_i, i + 1)$-Klasse von Transitionen des Wort-FSTs gefolgt wird.
 \end{rem}
diff --git a/edit-lens/src/Control/FST/Lens.tex b/edit-lens/src/Control/FST/Lens.tex
index dc44e10..31af317 100644
--- a/edit-lens/src/Control/FST/Lens.tex
+++ b/edit-lens/src/Control/FST/Lens.tex
@@ -15,7 +15,7 @@ $\Lleftarrow$ basiert fundamental darauf im Komplement anhand der erzeugten outp
 Um sicher zu stellen, dass jene Suche immer terminiert, müsste die Aufzählung der i.A. unendlich vielen zulässigen output-Strings in \texttt{FSTAction} geschickt gewählt sein.
 Quellen von Serien unendlich vieler output-Strings sind notwendigerweise Zykel im betrachteten FST.
 Wir könnten nun für jeden Zykel im betrachteten FST eine Kante arbiträr wählen und dem Folgen jener Kante Kosten zuweisen.
-Wenn wir nun sicherstellen, dass output-Strings in Reihenfolge aufsteigender Kosten aufgezählt werden, lässt sich jeder endliche output-String in endlicher Zeit finden.
+Wenn wir nun sicherstellen, dass output-Strings in Reihenfolge aufsteigender Kosten aufgezählt werden, lässt sich zu jedem endlichen output-String eine Eingabe in endlicher Zeit finden.
 
 Das obig beschriebene Verfahren weißt eine Asymmetrie auf, die im unterliegenden FST nicht vorhanden ist (sowohl Eingabe- als auch Ausgabe-Symbole sind Annotationen vom gleichen Typ an die Transitionen des FST).
 Diese Asymmetrie ergibt sich ausschließlich aus der Wahl des Komplements.
diff --git a/edit-lens/src/Control/Lens/Edit.lhs b/edit-lens/src/Control/Lens/Edit.lhs
index 6561528..5cf8662 100644
--- a/edit-lens/src/Control/Lens/Edit.lhs
+++ b/edit-lens/src/Control/Lens/Edit.lhs
@@ -12,7 +12,7 @@ import Control.Edit
 \end{comment}
 
 \begin{defn}[Zustandsbehaftete Monoidhomomorphismen]
-Gegeben eine Menge $C$ von \emph{Komplementen} und zwei Monoiden $M$ und $N$ nennen wir eine partielle Funktion $\psi \colon C \times M \to C \times N$ einen zustandsbehafteten Monoidhomomorphismus wenn sie den folgenden Ansprüchen genügt:
+Gegeben eine Menge $C$ von \emph{Komplementen} und zwei Monoiden $M$ und $N$ nennen wir eine partielle Funktion $\psi \colon C \times M \to C \times N$ einen \emph{zustandsbehafteten Monoidhomomorphismus} wenn sie den folgenden Ansprüchen genügt:
 
 \begin{itemize}
    \item $\forall c \in C \colon \psi(1_M, c) = (1_N, c)$
@@ -28,7 +28,7 @@ type StateMonoidHom s m n = (s, m) -> (s, n)
 \end{defn}
 
 \begin{defn}[edit-lenses]
-Für Moduln $M$ und $N$ besteht eine symmetrische edit-lens zwischen $M$ und $N$ aus zwei zustandsbehafteten Monoidhomomorphismen $\Rrightarrow \colon C \times \partial M \to C \times \partial N$ und $\Lleftarrow \colon C \times \partial N \to C \times \partial M$, mit kompatiblem Komplement $C$, einem ausgezeichneten Element $\ground_C \in C$ und einer \emph{Konsistenzrelation} $K \subset \Dom M \times C \times \Dom N$ sodass gilt:
+Für Moduln $M$ und $N$ besteht eine \emph{symmetrische edit-lens} zwischen $M$ und $N$ aus zwei zustandsbehafteten Monoidhomomorphismen $\Rrightarrow \colon C \times \partial M \to C \times \partial N$ und $\Lleftarrow \colon C \times \partial N \to C \times \partial M$, mit kompatiblem Komplement $C$, einem ausgezeichneten Element $\ground_C \in C$ und einer \emph{Konsistenzrelation} $K \subset \Dom M \times C \times \Dom N$ sodass gilt:
 
 \begin{itemize}
   \item $(\init_M, \ground_C, \init_N) \in K$
@@ -69,14 +69,14 @@ instance (Module m, Module n) => HasEditLens (EditLens c m n) m n where
 
 \subsection{Kompatibilität mit bestehenden lens frameworks}
 
-Das einschlägige bestehende lens framework \cite{lens} konstruiert seine Linsen alá \citeauthor{laarhoven} wie folgt:
+Das einschlägige bestehende lens framework \cite{lens} konstruiert seine Linsen à la \citeauthor{laarhoven} wie folgt:
 
-\begin{defn}[lenses alá laarhoven]
+\begin{defn}[lenses à la Laarhoven]
 Für Typen $n$ und $m$ ist eine \emph{lens} $\ell$ von $n$ in $m$ eine Abbildung\footnote{Gdw. die betrachtete Linse einen Isomorphismus kodiert wird auch über den verwendeten Profunktor anstatt $\to$ quantifiziert} folgender Struktur:
 
 $$ \forall f \, \text{Funktor} \colon \left ( \ell \colon \left ( m \to f(m) \right ) \to \left ( n \to f(n) \right ) \right )$$
 
-Durch geschickte Wahl des Funktors\footnote{\texttt{Const} bzw. \texttt{Identity}} $f$ können dann $\searrow \colon m \to n$ und $\nearrow \colon (m \to m) \to (n \to n)$ oder verwandte Strukturen (folds, traversals, …) konstruiert werden.
+Durch geschickte Wahl des Funktors\footnote{\texttt{Const m} bzw. \texttt{Identity}} $f$ können dann $\searrow \colon n \to m$ und $\nearrow \colon (m \to m) \to (n \to n)$ oder verwandte Strukturen (folds, traversals, …) konstruiert werden.
 \end{defn}
 
 Es liegt nun nahe $\nearrow \colon (m \to m) \to (n \to n)$ mit $\Rrightarrow \colon \partial m \to \partial n$ zu identifizieren.
diff --git a/edit-lens/src/Control/Lens/Edit/ActionTree.lhs b/edit-lens/src/Control/Lens/Edit/ActionTree.lhs
index 6632dce..0cfaf24 100644
--- a/edit-lens/src/Control/Lens/Edit/ActionTree.lhs
+++ b/edit-lens/src/Control/Lens/Edit/ActionTree.lhs
@@ -42,15 +42,12 @@ import System.IO.Unsafe
 \end{code}
 \end{comment}
 
-Das beschrieben Verfahren wurde prinzipiell agnostisch in Bezug auf die konkret gewählte Parser-Konstruktion gewählt.
+Das beschrieben Verfahren wurde prinzipiell agnostisch in Bezug auf die konkret gewählte Parser-Konstruktion implementiert.
 
 Hierfür wurden die benötigten Operationen auf der DFST-Wirkung und das in $\Lleftarrow$ verwendete Suchschema abstrakt als Typklasse angegeben:
 
 \begin{code}
 class Monoid action => Action action input output | action -> input, action -> output where
-\end{code}
-\begin{comment}
-\begin{code}
   -- | Most operations of `Action` permit access to some underlying description of the parser (i.e. an automaton)
   type ActionParam action = param | param -> action
 
@@ -84,7 +81,6 @@ class Monoid action => Action action input output | action -> input, action -> o
                  -> Compositions action -- ^ Suffix
                  -> Maybe (Seq input)
 \end{code}
-\end{comment}
 
 Das Verfahren kann nun auf andere Sorten von Parser angewendet werden, indem nur die oben aufgeführte \texttt{Action}-Typklasse implementiert wird:
 
diff --git a/implementation.tex b/implementation.tex
index f5e5e58..3a68e04 100644
--- a/implementation.tex
+++ b/implementation.tex
@@ -22,7 +22,7 @@ Die Module innerhalb von \texttt{edit-lens} entsprechen im wesentlichen den Sekt
 \item[Control.DFST]
   Datentyp, schrittweise-, und vollständige Auswertung sowie Umwandlung zu einem FST für deterministische finite state transducer
 \item[Control.Lens.Edit.ActionTree]
-  Das beschriebene Verfahren zur Darstellung eines beliebigen DFST als edit-lens für jene edit-Sprache
+  Das beschriebene Verfahren zur Darstellung eines beliebigen DFST als edit-lens für die edit-Sprache aus \textbf{Control.Edit.String}
 
   Es ist hierbei jedoch der konkrete Typ der Wirkung und das Suchschema für $\Lleftarrow$ als Typklasse abstrahiert
 \item[Control.DFST.Lens]
@@ -53,13 +53,15 @@ Die Module innerhalb von \texttt{edit-lens} entsprechen im wesentlichen den Sekt
 Der interaktive editor kann von der Befehlseingabe gestartet werden wie folgt:
 \begin{lstlisting}[language=bash]
   $ stack build
-  $ stack exec interact <dfst
+  $ stack exec interact <dfst>
 \end{lstlisting}
 Hierbei ist \texttt{<dfst>} einer der in \texttt{Main} implementierten DFSTs:
 
 \begin{description}
 \item[linebreak]
-  Wandelt Zeilenumbrüche und Leerzeichen ineinander um, sodass alle Zeilen mindestens 80 Zeichen enthalten
+  Wandelt Zeilenumbrüche und Leerzeichen ineinander um, sodass alle Zeilen mindestens 80 Zeichen enthalten (Beispiel \ref{eg:linebreak})
+\item[switch]
+  Der einfache DFST aus Abbildung \ref{fig:switchdfst}
 \item[json-newl]
   Normalisiert Whitespace in einem JSON\footnote{\url{https://de.wikipedia.org/wiki/JSON}}-String.
   JSON ist nicht regulär; Es lassen sich Klammern nicht prüfen und Einrückung nicht in Abhängigkeit der Verschachtelung implementieren
@@ -85,5 +87,5 @@ Nach Auswahl wird der Inhalt der Datei am Cursor eingefügt.
 \subsubsection{Performance}
 
 Bei der Implementierung wurde nicht auf Performance geachtet.
-Es ist daher die Laufzeit des interaktiven Editors bereits bei kleinen Eingabe inakzeptabel lang (mehrere Sekunden für ein Kilobyte JSON).
+Es ist daher die Laufzeit des interaktiven Editors bereits bei kleinen Eingaben inakzeptabel lang (mehrere Sekunden für ein Kilobyte JSON).
 Es lässt sich allerdings der Speedup beim Propagieren kleiner edits gut beobachten; die Propagation eines ein-Buchstaben-edits nach rechts ist ca. einen Faktor 200 schneller als das komplett neue Parsen einer Datei (ca. ein Kilobyte JSON).
diff --git a/interactive-edit-lens/src/Main.hs b/interactive-edit-lens/src/Main.hs
index c816515..21db685 100644
--- a/interactive-edit-lens/src/Main.hs
+++ b/interactive-edit-lens/src/Main.hs
@@ -92,6 +92,12 @@ instance Universe LineBreakState where
 instance Finite LineBreakState
 instance NFData LineBreakState
 
+data SwitchState = SwitchA | SwitchB
+  deriving (Eq, Ord, Enum, Bounded, Show, Read, Generic)
+instance Universe SwitchState
+instance Finite SwitchState
+instance NFData SwitchState
+
 dfstMap :: String -> Maybe SomeDFST
 dfstMap "double" = Just . SomeDFST $ DFST
   { stInitial = ()
@@ -228,6 +234,16 @@ dfstMap "linebreak" = Just . SomeDFST $ DFST
     ]
   , stAccept = Set.fromList universeF
   }
+dfstMap "switch" = Just . SomeDFST $ DFST
+  { stInitial = SwitchA
+  , stTransition = Map.fromList
+    [ ((SwitchA, 's'), (SwitchB, Seq.empty))
+    , ((SwitchB, 's'), (SwitchA, Seq.empty))
+    , ((SwitchA, 'p'), (SwitchA, Seq.singleton 'a'))
+    , ((SwitchB, 'p'), (SwitchB, Seq.singleton 'b'))
+    ]
+  , stAccept = Set.fromList [SwitchA, SwitchB]
+  }
 dfstMap _ = Nothing
 
 main :: IO ()
diff --git a/intro.tex b/intro.tex
index 539a0a6..43d909d 100644
--- a/intro.tex
+++ b/intro.tex
@@ -2,18 +2,19 @@
 
 Unter einem inkrementellen Parser \cite{ghezzi1979incremental} verstehen wir ein Programm, das, nach einem initialen Parsevorgang, gegeben eine Spezifikation einer Änderung der textuellen Eingabe i.A. schneller ein neues Ergebnis erzeugt als es ohne zusätzlichen Kontext möglich wäre (gewöhnlicherweise in logarithmischer Zeit in der Länge der Eingabe).
 
-Es ist nun prinzipiell wünschenswert die algebraische Struktur derartiger Klassen von Programmen zu untersuchen, mit dem Ziel neue Parser mit generischen Mitteln aus bereits bekannten konstruieren zu können.
+Es ist nun prinzipiell wünschenswert die algebraische Struktur derartiger Klassen von Programmen zu untersuchen, mit dem Ziel neue Parser mit generischen Mitteln aus bereits Bekannten konstruieren zu können.
 
-In dieser Arbeit versuchen wir, anhand von Finite State Transducern als Spezialfall, inkrementelle Parser und die unterliegenden edits mit neuerer algebraischer Struktur, edit-lenses \cite{hofmann2012edit}, zu versehen um Komponierbarkeit zu vereinfachen.
+In dieser Arbeit versuchen wir, anhand von finite state transducern als Spezialfall, inkrementelle Parser und die unterliegenden edits mit neuerer algebraischer Struktur, edit-lenses \cite{hofmann2012edit}, zu versehen um Komponierbarkeit zu vereinfachen.
 Vor allem versuchen wir somit zu demonstrieren, dass sich bekannte Klassen von Programmen, unter Erhalt ihrer vollen Struktur, als edit-lenses auffassen lassen, auch wenn die Darstellung als konventionelle funktionale Linse unzufriedenstellend wäre.
 
 \subsubsection{Inhalt}
 
 Wir stellen in Abschnitt \ref{edit-lenses} die Definitionen und Konstruktion von edit-lenses aus \cite{hofmann2012edit} vor und diskutieren kurz die Kompatibilität unserer Implementierung und edit-lenses im Allgemeinen mit etablierten frameworks für funktionale Linsen in Haskell.
-In Abschnitt \ref{finite-state-transducers} präsentieren wir eine etablierte Version von Finite State Transducern, für die folgenden Teile relevante Konstruktionen darauf, und einige assoziierte Beispiele.
-Abschnitt \ref{edit-lenses-fuxfcr-deterministic-finite-state-transducers} beschreibt eine Methode beliebige deterministische Finite State Transducers als edit-lenses aufzufassen und stellt somit eine non-triviale Anwendung der Methoden und Konzepte aus \cite{hofmann2012edit} dar.
-In Abschnitt \ref{ausblick-edit-lenses-fuxfcr-non-determinische-finite-state-transducers} stellen wir kurz einen Ansatz dar unsere Konstruktion aus \ref{edit-lenses-fuxfcr-deterministic-finite-state-transducers} auch auf non-deterministische Finite State Transducer zu erweitern.
-In Abschnitt \ref{implementierung} kommentieren wir den Implementierungs-Prozess der Arbeit und die Schlüsse, die wir aus der Implementierung als solche ziehen konnten.
+In Abschnitt \ref{finite-state-transducers} präsentieren wir eine etablierte Version von finite state transducern, für die folgenden Teile relevante Konstruktionen darauf und einige assoziierte Beispiele.
+Abschnitt \ref{edit-lenses-fuxfcr-deterministic-finite-state-transducers} beschreibt eine Methode beliebige deterministische finite state transducers als edit-lenses aufzufassen und stellt somit eine non-triviale Anwendung der Methoden und Konzepte aus \cite{hofmann2012edit} dar.
+In Abschnitt \ref{ausblick-edit-lenses-fuxfcr-non-determinische-finite-state-transducers} stellen wir kurz einen Ansatz dar unsere Konstruktion aus \ref{edit-lenses-fuxfcr-deterministic-finite-state-transducers} auch auf non-deterministische finite state transducer zu erweitern.
+In Abschnitt \ref{implementierung} kommentieren wir den Implementierungsprozess der Arbeit und die Schlüsse, die wir aus der Implementierung als solcher ziehen konnten.
+Abschnitt \ref{ausblick-anwendbarkeit-der-implementierung-auf-andere-parser} beschreibt kurz wie sich das dargestellte Verfahren auf andere Sorten von Parsern anwenden ließe.
 
 \subsection{Historischer Ãœberblick}
 
@@ -41,7 +42,7 @@ Bidirektionale, inkrementelle, und kombinierbare Parser und ihre Analyse sind ei
 % [ ] ~~universal updates for symmetric lenses~~
 
 \begin{description} % TODO: more
-  \item[1979] \cite{ghezzi1979incremental} präsentieren, in einer der ersten Arbeiten zu dem Thema, einen Ansatz zum inkrementellen Parsen von deterministischen und Kontext-freien Sprachen basierend auf dem $LR$-Ansatz.
+  \item[1979] \cite{ghezzi1979incremental} präsentieren, in einer der ersten Arbeiten zu dem Thema, einen Ansatz zum inkrementellen Parsen von deterministischen und kontextfreien Sprachen basierend auf dem $LR$-Ansatz.
   \item[1992] \cite{hedin1992incremental} präsentieren einen Formalismus zur inkrementellen \emph{semantischen} Analyse (d.h. das Versehen des Syntax-Baums eines Programms mit Attributen wie z.B. Typen) basierend auf (modifizierten) Attribut-Grammatiken.
   \item[1997] \cite{wagner1997general} stellen einen Algorithmus zur inkrementellen lexikalischen Analyse (tokenizing) der auf den selben Spezifikationen arbeiten kann wie die UNIX-Tools \texttt{lex} und \texttt{flex}.
   \item[1998] \cite{wagner1998efficient} stellen neue, Laufzeit- und Speicher-optimale, Methoden zur Konstruktion inkrementeller Parser auf Basis beliebiger $LR(k)$-Grammatiken vor.
@@ -49,16 +50,16 @@ Bidirektionale, inkrementelle, und kombinierbare Parser und ihre Analyse sind ei
   \item[2004] \cite{hu2004programmable} spezifizieren eine algebraisch strukturierte Sprache für bidirektionale Baum-Transformationen unter einer programmierbaren Konsistenzrelation mit Blick auf direkte Anwendung im Editieren von bestehenden Baum-Dokumenten
   \item[2007] \cite{foster2007combinators} präsentieren sowohl eine Sprache bidirektionaler Baum-Transformationen als konventionelle funktionale Linsen im Speziellen, als auch mathematische Resultate für funktionale Linsen und Sammlungen davon im Allgemeinen.
     Auch enthalten ist eine nützliche Klassifikation und ein historischer Überblick diverser bidirektionalen Programmiertechniken.
-  \item[2008] Analog zur Sprache bidirektionaler Baum-Transformation aus \cite{foster2007combinators} stellen \cite{bohannon2008boomerang} eine Sprache für semi-Strukturierten Text (als Serie von vertauschbaren Schlüssel-Wert-Assoziationen) vor.
-  \item[2009] \cite{bernardy2009lazy} implementieren, im Rahmen der Arbeit am Text-Editor Yi, eine Kombinator-basierte Programmbibliothek zum inkrementellen Parsen basierend auf lazy evaluation und aggressivem Caching in Haskell.
+  \item[2008] Analog zur Sprache bidirektionaler Baum-Transformation aus \cite{foster2007combinators} stellen \cite{bohannon2008boomerang} eine Sprache für semi-strukturierten Text (als Serie von vertauschbaren Schlüssel-Wert-Assoziationen) vor
+  \item[2009] \cite{bernardy2009lazy} implementieren, im Rahmen der Arbeit am Text-Editor Yi, eine Kombinator-basierte Programmbibliothek zum inkrementellen Parsen basierend auf lazy evaluation und aggressivem Caching in Haskell
   \item[2011] \cite{hofmann2011symmetric} definieren symmetrische \emph{set-based}-lenses (funktionale Linsen im konventionellen Sinn), d.h. ohne strukturierte edits.
     Es wird auch die umfangreiche algebraische Struktur symmetrischer Linsen besprochen.
     Vieles hiervon vererbt sich direkt auf edit-lenses als Spezialfall symmetrischer Linsen.
   \item[2012] \cite{hofmann2012edit} definieren edit-lenses.
     In Abgrenzung zu bestehenden Formalismen symmetrischer funktionaler Linsen arbeiten edit-lenses ausschließlich auf algebraisch strukturierten edit-Sprachen, was sie besonders attraktiv macht.
-  \item[2013] \cite{hofmann2013edit} stellen eine generelle edit-Sprache (zur Verwendung mit und basierend auf edit-lenses) für eine weite Klasse von container-Datentypen (Listen, Bäume, Graphen, ...) vor.
-  \item[2014] \cite{zaytsev2014parsing} geben einen nützlichen Überblick über die, historisch inkonsistente, Terminologie und Konzepte im Zusammenhang mit Parsing.
-  \item[2016] \cite{johnson2016unifying} betrachten Zusammenhänge von diversen Klassen funktionaler Linsen (inkl. edit-lenses) und geben dabei einen umfangreichen Überblick über die bestehende Forschung an funktionalen Linsen.
+  \item[2013] \cite{hofmann2013edit} stellen eine generelle edit-Sprache (zur Verwendung mit und basierend auf edit-lenses) für eine weite Klasse von container-Datentypen (Listen, Bäume, Graphen, ...) vor
+  \item[2014] \cite{zaytsev2014parsing} geben einen nützlichen Überblick über die, historisch inkonsistente, Terminologie und Konzepte im Zusammenhang mit Parsing
+  \item[2016] \cite{johnson2016unifying} betrachten Zusammenhänge diverser Klassen funktionaler Linsen (inkl. edit-lenses) und geben dabei einen umfangreichen Überblick über die bestehende Forschung.
     Ein relevantes Resultat ist hierbei ein Begriff von asymmetrischen edit-lenses kompatibel mit dem symmetrischen Fall.
 \end{description}
 
@@ -68,14 +69,15 @@ Obwohl wir detailliertere Definitionen der folgenden Konzepte im Laufe der Arbei
 
 \begin{description}
   \item[FST] \emph{Finite-State-Transducer} sind endliche Automaten, die bei jedem Zustandsübergang die Möglichkeit haben ein Zeichen an eine sich akkumulierende Ausgabe anzuhängen
-  \item[DFST] \emph{Deterministic finite-state-transducer} sind FSTs bei denen für jeden Zustand jedes gelesene Zeichen maximal einen Zustandsübergang zulässt
+  \item[DFST] \emph{Deterministic Finite-State-Transducer} sind FSTs bei denen für jeden Zustand jedes gelesene Zeichen maximal einen Zustandsübergang zulässt
   \item[Monoid] \emph{Monoiden} sind algebraisch zwischen Halbgruppen und Gruppen angesiedelt.
     Wir sagen eine Menge hat Monoidstruktur bzgl. einer zweistelligen Verknüpfung auf jener Menge, wenn sie ein neutrales Element enthält und die Verknüpfung assoziativ ist.
   \item[Moduln & edits] \emph{Moduln} verknüpfen eine Trägermenge mit einer Menge von \emph{edits} (mit monoidaler Struktur) auf jener Menge.
     Edits beschreiben jeweils eine partielle Abbildung innerhalb der Trägermenge.
-  \item[Funktionale Linsen] Eine \emph{Funktionale Linse} von $s$ in $a$ in der üblichen Definition ist ein paar von Abbildungen $\searrow \colon s \to a$ und $\nearrow \colon (a \to a) \to (s \to s)$ mit umfangreicher algebraischer Struktur, die die Komposition komplexer Linsen aus einfacheren ermöglicht.
+  \item[Funktionale Linsen] Eine \emph{Funktionale Linse} von $s$ in $a$ in der üblichen Definition (\emph{set-based}) ist ein Paar von Abbildungen $\searrow \colon s \to a$ und $\nearrow \colon (a \to a) \to (s \to s)$ mit umfangreicher algebraischer Struktur, die die Komposition komplexer Linsen aus Einfacheren ermöglicht.
     Wir finden es hilfreich von einer Projektion ($\searrow$) und einem \emph{edit-Propagator} ($\nearrow$) zu sprechen.
   \item[Van-Laarhoven Linsen] In \cite{laarhoven} wurde eine Darstellung als eine (über einen Funktor parametrisierte) Funktion dargelegt, die unter anderem auch die soeben beschriebenen funktionalen Linsen einbetten kann
-  \item[edit-lenses] \emph{edit-lenses} verknüpfen zwei Moduln-Trägermengen indem sie edits des einen Modul in die des anderen übersetzen.
+  \item[edit-lenses] \emph{edit-lenses} verknüpfen zwei Moduln-Trägermengen indem sie edits des einen Modul in die des Anderen übersetzen.
     Hierbei wird ein, mit den jeweiligen Elementen der Trägermengen konsistenter, unterliegender Zustand, das \emph{Komplement} der edit-lens, gewahrt.
+    Intuitiv speichert das Komplement genau jene Information, die nicht in beiden Darstellungen vorkommt.
 \end{description}
diff --git a/org.tex b/org.tex
new file mode 100644
index 0000000..d0c6ed4
--- /dev/null
+++ b/org.tex
@@ -0,0 +1,23 @@
+\pagebreak
+
+Diese Arbeit ist entstanden unter Betreuung durch Stephan Barth.
+
+Verantwortliche Hochschullehrer sind \textdagger Prof. Martin Hoffmann PhD und Dr. Steffen Jost.
+
+\vfill
+
+\noindent Ich erkläre hiermit, dass ich die vorliegende Arbeit
+selbstständig angefertigt, alle Zitate als solche kenntlich gemacht
+sowie alle benutzten Quellen und Hilfsmittel angegeben habe.
+
+\bigskip
+
+\makebox[.5\linewidth][r]{}{\xleaders\hbox to .2em{\d{}}\hfill\d{}}\smallskip \\
+\hspace*{.5\linewidth}Gregor Kleen \\
+\hspace*{.5\linewidth}München, \today
+
+%% \bigskip\noindent München, \today
+
+%% \vspace{4ex}\noindent\makebox[7cm]{\dotfill}
+
+\pagebreak
diff --git a/thesis.meta.yml.gup b/thesis.meta.yml.gup
index 27ce8cb..b13ea3a 100644
--- a/thesis.meta.yml.gup
+++ b/thesis.meta.yml.gup
@@ -21,7 +21,7 @@ lang: de-de
 link-citations: true
 bibliography: literature.bibtex
 author: Gregor Kleen
-date: \formatdate{01}{03}{2019}
+date: \formatdate{30}{05}{2019}
 numbersections: true
 ...
 EOF
diff --git a/thesis.tex b/thesis.tex
index 2f0346b..e24e544 100644
--- a/thesis.tex
+++ b/thesis.tex
@@ -1,26 +1,11 @@
-\vfill
-
-\noindent Ich erkläre hiermit, dass ich die vorliegende Arbeit
-selbstständig angefertigt, alle Zitate als solche kenntlich gemacht
-sowie alle benutzten Quellen und Hilfsmittel angegeben habe.
-
-\bigskip
-
-\makebox[.5\linewidth][r]{}{\xleaders\hbox to .2em{\d{}}\hfill\d{}}\smallskip \\
-\hspace*{.5\linewidth}Gregor Kleen \\
-\hspace*{.5\linewidth}München, \today
-
-%% \bigskip\noindent München, \today
-
-%% \vspace{4ex}\noindent\makebox[7cm]{\dotfill}
-
+\input{./org.tex}
 
 \section{Einführung}
 \input{./intro.tex}
 
 \section{Edit-lenses}
 
-Ziel ist es zunächst edit-lenses alá \cite{hofmann2012edit} in Haskell zur Verfügung zu stellen.
+Ziel ist es zunächst edit-lenses à la \cite{hofmann2012edit} in Haskell zur Verfügung zu stellen.
 Dabei werden wir die Definitionen aus \cite{hofmann2012edit} sowohl in natürlicher Sprache als auch in lauffähigem Haskell vorstellen.
 
 \input{./edit-lens/src/Control/Edit.lhs.tex}
@@ -50,3 +35,7 @@ Dabei werden wir die Definitionen aus \cite{hofmann2012edit} sowohl in natürlic
 \subsection{Ausblick: Anwendbarkeit der Implementierung auf andere Parser}
 
 \input{./edit-lens/src/Control/Lens/Edit/ActionTree.lhs.tex}
+
+\section{Fazit}
+
+\input{conclusion.tex}