diff --git a/Writerside/images/image_923.png b/Writerside/images/image_923.png
new file mode 100644
index 0000000..c69b25f
Binary files /dev/null and b/Writerside/images/image_923.png differ
diff --git a/Writerside/images/image_924.png b/Writerside/images/image_924.png
new file mode 100644
index 0000000..58f254a
Binary files /dev/null and b/Writerside/images/image_924.png differ
diff --git a/Writerside/in.tree b/Writerside/in.tree
index 66eb1d8..939b38d 100644
--- a/Writerside/in.tree
+++ b/Writerside/in.tree
@@ -142,6 +142,7 @@
+
diff --git a/Writerside/topics/04/Theoretische Informatik/Hausaufgaben/ti_hausaufgabe8.md b/Writerside/topics/04/Theoretische Informatik/Hausaufgaben/ti_hausaufgabe8.md
new file mode 100644
index 0000000..d4e946d
--- /dev/null
+++ b/Writerside/topics/04/Theoretische Informatik/Hausaufgaben/ti_hausaufgabe8.md
@@ -0,0 +1,389 @@
+# Übungsblatt 8
+> Wenzel Schwan (1125033), Paul Kneidl (1125219), David Schirrmeister (1125746), Michelle Klein (1126422)
+
+## Übung 1
+
+### 1(a)
+Beschreiben Sie für jeden der folgenden regulären Ausdrücke $\alpha_i$ die entsprechende Sprache $L(\alpha_i)$ (formal oder informal, Ihre Wahl):
+
+- (i) $\alpha_1 = (00 \mid 1)^* (11 \mid 0)$
+ - Alle Wörter, welche mit beliebig vielen Aneinanderreihungen von `00` und `1` beginnen und dann mit `11` oder `0` enden
+- (ii) $\alpha_2 = (1 \mid 01 \mid 001)^* (1 \mid 111)$
+ - Alle Wörter, welche mit beliebig vielen Aneinanderreihungen von `1`, `01` und `001` beginnen und dann mit `1` oder `111` enden
+
+
+### 1(b)
+Bestimmen Sie für jeden der folgenden regulären Ausdrücke $\beta_i$ einen endlichen Automaten (deterministisch oder nichtdeterministisch, Ihre Wahl), der die Sprache $L(\beta_i)$ akzeptiert:
+
+- (i) $\beta_1 = \emptyset$
+ - ```plantuml
+ @startuml
+ scale 0.50
+
+ left to right direction
+ skinparam dpi 150
+
+ skinparam state {
+ BackgroundColor #FFFACD
+ BorderColor black
+ FontName Helvetica
+ RoundCorner 30
+ Shadowing false
+ LineThickness 0
+ }
+
+ state S##[bold]
+ [*]-->S
+ @enduml
+ ```
+- (ii) $\beta_2 = ((0 \mid 1)^* 1)^*$
+ - ```plantuml
+ @startuml
+ scale 0.50
+
+ left to right direction
+ skinparam dpi 150
+
+ skinparam state {
+ BackgroundColor #FFFACD
+ BorderColor black
+ FontName Helvetica
+ RoundCorner 30
+ Shadowing false
+ LineThickness 0
+ }
+
+ state S##[bold]
+ state U##[bold]
+
+ [*]-->S
+ S --> T: 0,1
+ T --> U: 1
+ T --> T: 0,1
+ S --> U: 1
+ U --> T: 0,1
+
+ @enduml
+ ```
+
+### 1(c)
+Betrachten Sie die endlichen Automaten $N_1$ und $N_2$ aus Abbildung 1. Bestimmen Sie für jede der drei Sprachen $L(N_1)$, $L(N_2)$ und $L(N_1) \setminus L(N_2)$ einen regulären Ausdruck, der die jeweilige Sprache beschreibt.
+
+
+- $L(N_1)$
+ - $1(0|1)^*1$
+- $L(N_2)$
+ - $(0|1)^*11(0|1)^*$
+- $L(N_1) \backslash L(N_2)$
+ - $10(0|10)^*1$
+
+
+### 1(d)
+Bestimmen Sie einen regulären Ausdruck, der die Sprache aller Binärstrings beschreibt, die **nicht auf 11 enden**.
+
+$(0|1)^*(00|01|10)$
+
+## Übung 2
+
+Betrachten Sie folgende reguläre Grammatik über dem Alphabet $\Sigma = \{x, y, z\}$:
+
+$$
+G: \quad
+S \Rightarrow xS \mid xA \mid zB \\
+A \Rightarrow yA \mid B \\
+B \Rightarrow zB \mid \varepsilon
+$$
+
+### 2(a)
+Erarbeiten Sie sich den Begriff eines nichtdeterministischen endlichen Automaten mit $\varepsilon$-Übergängen mit Hilfe des Skriptes (Seiten 137–139).
+Überlegen Sie sich, wie sich ein zur Grammatik $G$ passender, nichtdeterministischer endlicher Automat mit $\varepsilon$-Übergängen konstruieren lässt, der die Sprache $L(G)$ akzeptiert.
+Geben Sie den Automaten dazu in **Graphdarstellung** an.
+
+```plantuml
+ @startuml
+ scale 0.50
+
+ left to right direction
+ skinparam dpi 150
+
+ skinparam state {
+ BackgroundColor #FFFACD
+ BorderColor black
+ FontName Helvetica
+ RoundCorner 30
+ Shadowing false
+ LineThickness 0
+ }
+
+ state B##[bold]
+
+ [*]-->S
+ S --> S: x
+ S --> A: x
+ S --> B: z
+ A --> A: y
+ A --> B: ε
+ B --> B: z
+
+ @enduml
+```
+
+### 2(b)
+Nutzen Sie das Kochrezept aus den Folien (Kapitel 6), um die Grammatik zu normalisieren.
+(Schritte 1 und 2 des Kochrezepts sind hier nicht notwendig, da es keine Regeln der entsprechenden Form gibt.)
+
+- $S → xS | xA | zB$
+- $A → yA | zB | ε$
+- $B → zB | ε$
+
+
+### 2(c)
+Nutzen Sie den zweiten Teil des Kochrezepts zur Umwandlung einer regulären Grammatik $G$ in einen NEA (Kapitel 6), um für die **normalisierte Grammatik** einen NEA zu konstruieren, der die von der Grammatik erzeugte Sprache akzeptiert.
+
+```plantuml
+ @startuml
+ scale 0.50
+
+ left to right direction
+ skinparam dpi 150
+
+ skinparam state {
+ BackgroundColor #FFFACD
+ BorderColor black
+ FontName Helvetica
+ RoundCorner 30
+ Shadowing false
+ LineThickness 0
+ }
+
+ state B##[bold]
+ state A##[bold]
+
+ [*]-->S
+ S --> S: x
+ S --> A: x
+ S --> B: z
+ A --> A: y
+ A --> B: z
+ B --> B: z
+
+ @enduml
+```
+
+## Übung 3
+### 3(a)
+Entwerfen Sie eine reguläre Grammatik $G_{\text{date}}$, um Datumsangaben bestehend aus Tag (T), Monat (M) und Jahr (Y) in der Form `YYYY-MM-TT` über einem geeigneten Alphabet zu erzeugen.
+- Σ = {0,...,9,-}
+- $S = S$
+- $V=\{S,Y,M,D,Y_1,Y_2,Y_3,A,B,M_1,M_2,C\}$
+- $R$
+ - $S→YMD$
+ - $Y → AY_1$
+ - $Y_1 → AY_2$
+ - $Y_2 → AY_3$
+ - $Y_3 → AB$
+ - $A→0|1|2|3|4|5|6|7|8|9$
+ - $B→-$
+ - $M→0M_1|1M_2$
+ - $M_1→1B|2B|3B|4B|5B|6B|7B|8B|9B$
+ - $M_2→0B|1B$
+ - $D→0A|1A|2A|3C$
+ - $C→0|1$
+
+### 3(b)
+Entwerfen Sie eine reguläre Grammatik $G_{\text{time}}$, um Uhrzeiten bestehend aus Stunde (H) und Minute (M) in der Form `HH:MM` über einem geeigneten Alphabet zu erzeugen.
+
+- Σ = {0,...,9,:}
+- $S = S$
+- $V=\{S,H,M,A,H_1}$
+- $R$
+ - $S→HM$
+ - $H→0H_1|1H_1|2H_1|3H_1|4H_1|5H_1$
+ - $H_1→A:$
+ - $A→0|1|2|3|4|5|6|7|8|9$
+ - $M→0A|1A|2A|3A|4A|5A$
+
+
+
+
+### 3(c)
+Kombinieren Sie die Grammatiken $G_{\text{date}}$ und $G_{\text{time}}$ zu drei neuen Grammatiken, welche jeweils die Sprache
+$L(G_{\text{date}}) \cup L(G_{\text{time}})$,
+$L(G_{\text{date}}) \circ L(G_{\text{time}})$ und
+$L(G_{\text{date}})^*$ erzeugen.
+
+
+
+**(i) $L(G_{\text{date}}) \cup L(G_{\text{time}})$**
+
+Um die Vereinigungsgrammatik zu erzeugen, fügt man eine neue Startregel hinzu, die entweder in das Datum oder in die Uhrzeit verzweigt. Es wird also eine neue Startvariable $S'$ eingeführt und die bisherigen Startsymbole $S_{\text{date}}$ und $S_{\text{time}}$ ersetzt:
+
+- Neue Startregel:
+ - $S' \rightarrow S_{\text{date}} \mid S_{\text{time}}$
+- Dabei ist $S_{\text{date}}$ die bisherige Startvariable der Datumsgrammatik, $S_{\text{time}}$ die der Uhrzeitgrammatik.
+- Alle Regeln aus beiden Grammatiken werden übernommen und $S$ wird jeweils durch $S_{\text{date}}$ bzw. $S_{\text{time}}$ ersetzt, um Namenskonflikte zu vermeiden.
+
+---
+
+**(ii) $L(G_{\text{date}}) \circ L(G_{\text{time}})$**
+
+Für die Konkatenation fügt man eine neue Startregel ein, die zuerst die Erzeugung eines Datums, danach die einer Uhrzeit erlaubt. Auch hier müssen die Startvariablen unterschieden werden:
+
+- Neue Startregel:
+ - $S' \rightarrow S_{\text{date}} S_{\text{time}}$
+- Wieder werden alle bisherigen Regeln beibehalten, aber die Startvariablen entsprechend umbenannt.
+- Die Sprache besteht dann aus Zeichenketten der Form `YYYY-MM-DDHH:MM`.
+
+---
+
+**(iii) $L(G_{\text{date}})^*$**
+
+Um beliebig viele Datumsangaben zu erzeugen, wird ein neuer Startzustand $S'$ eingeführt, der entweder ein Datum erzeugt, gefolgt von einer rekursiven Wiederholung, oder auf $\varepsilon$ endet:
+
+- Neue Startregeln:
+ - $S' \rightarrow S_{\text{date}} S' \mid \varepsilon$
+- Die übrige Grammatik bleibt unverändert.
+- Es können also beliebig viele aufeinanderfolgende Datumsangaben erzeugt werden, z.B. `2025-06-152025-07-01...`
+
+
+Bei allen drei Fällen ist es notwendig, **Namenskonflikte** zwischen den Nichtterminalen der beiden Grammatiken (Datum vs. Uhrzeit) zu vermeiden. Das kann man entweder durch Präfixe (z.B. $A_{\text{date}}$, $A_{\text{time}}$) oder durch getrennte Mengen von Nichtterminalen und Startsymbolen lösen.
+
+
+## Übung 4
+
+Betrachten Sie den nichtdeterministischen endlichen Automaten $N$. Bestimmen Sie systematisch einen regulären Ausdruck, der die Sprache $L(N)$ beschreibt, indem Sie wie folgt vorgehen:
+
+
+### 4(a)
+Wandeln Sie $N$ in einen äquivalenten nichtdeterministischen Automaten $N_\varepsilon$ mit $\varepsilon$-Übergängen um, der **genau einen akzeptierenden Zustand** hat.
+
+```plantuml
+ @startuml
+ scale 0.50
+
+ left to right direction
+ skinparam dpi 150
+
+ skinparam state {
+ BackgroundColor #FFFACD
+ BorderColor black
+ FontName Helvetica
+ RoundCorner 30
+ Shadowing false
+ LineThickness 0
+ }
+
+ state Z##[bold]
+
+ [*]-->A
+ A --> A: a
+ A --> B: a
+ A --> D: a
+ D --> E: a
+ E --> Z: ε
+ B --> C: a
+ C --> F: a
+ F --> F: b
+ F --> Z: ε
+ F --> G: c
+ A --> G: c
+ G --> G: c
+ G --> Z: ε
+
+ @enduml
+```
+
+
+
+### 4(b)
+Als nächstes erlauben wir anstatt einfachen Symbolen an den Kanten auch **reguläre Ausdrücke**.
+Ein regulärer Ausdruck $\alpha$ an einer Kante von Zustand $q \in Q$ nach $q' \in Q$ (wir schreiben $q \xrightarrow{\alpha} q'$) bedeutet dabei, dass der Automat durch Lesen eines Wortes der Sprache $L(\alpha)$ von Zustand $q$ in Zustand $q'$ wechseln kann.
+
+Mit diesem neuen Mittel ausgerüstet, können wir z.B. den Zustand $B$ aus dem Automaten $N_\varepsilon$ entfernen, indem wir die Kanten $A \xrightarrow{a} B$ und $B \xrightarrow{a} C$ entfernen und stattdessen die neue Kante $A \xrightarrow{aa} C$ einfügen.
+
+**Entfernen Sie auf diese Weise nacheinander die Zustände $B$, $C$, $D$ und $E$ aus $N_\varepsilon$ und zeichnen Sie den entstehenden Automaten.**
+
+```plantuml
+ @startuml
+ scale 0.50
+
+ left to right direction
+ skinparam dpi 150
+
+ skinparam state {
+ BackgroundColor #FFFACD
+ BorderColor black
+ FontName Helvetica
+ RoundCorner 30
+ Shadowing false
+ LineThickness 0
+ }
+
+ state Z##[bold]
+
+ [*]-->A
+ A --> A: a
+ A --> F: aaa
+ A --> Z: aa
+ F --> F: b
+ F --> Z: ε
+ F --> G: c
+ A --> G: c
+ G --> G: c
+ G --> Z: ε
+
+ @enduml
+```
+
+
+### 4(c)
+Als nächstes entfernen wir den Zustand $F$.
+Betrachten Sie dazu jedes Paar $q, q' \in Q \setminus \{F\}$ mit Kanten $q \xrightarrow{\alpha} F$ und $F \xrightarrow{\beta} q'$.
+Fügen Sie als Ersatz für diese Kanten eine Kante $q \xrightarrow{\gamma} q'$ für einen geeignet gewählten regulären Ausdruck $\gamma$ ein (beachten Sie die Schleife $F \xrightarrow{b} F$ in $F$!).
+Nach Bearbeitung aller solcher Paare kann der Zustand $F$ gelöscht werden (**warum?**).
+
+**Entfernen Sie auf diese Weise neben Zustand $F$ auch den Zustand $G$ und zeichnen Sie den entstehenden Automaten.**
+
+```plantuml
+ @startuml
+ scale 0.50
+
+ left to right direction
+ skinparam dpi 150
+
+ skinparam state {
+ BackgroundColor #FFFACD
+ BorderColor black
+ FontName Helvetica
+ RoundCorner 30
+ Shadowing false
+ LineThickness 0
+ }
+
+ state Z##[bold]
+
+ [*]-->A
+ A --> A: a
+ A --> Z: aa | aaa | aaa(b)* | aaa(c)+ | (c)+
+
+ @enduml
+```
+
+### 4(d)
+Sie sollten nun einen Automaten mit noch zwei Zuständen (Startzustand und Endzustand) haben.
+Leiten Sie von diesem Automaten den regulären Ausdruck für die Sprache $L(N)$ ab.
+(**Beachten Sie die Schleife in Zustand $A$!**)
+
+$(a)^*(aa|aaa|aaa(b)^*|aaa(c^+)|(c)^+)$
+
+### 4(e)
+Der erhaltene reguläre Ausdruck ist vermutlich recht lang.
+**Versuchen Sie ihn (durch „scharfes Hinsehen“) soweit wie möglich zu vereinfachen.**
+
+$a^*(aa|aaa(b^*|c^*)|c^+)$
+
+
+ODER
+
+$a^*(aa(a(b^*|c^*))^?|c^+)$
+