update

Writerside/in.tree

@@ -142,6 +142,7 @@
                 <toc-element topic="ti_hausaufgabe5.md"/>
                 <toc-element topic="ti_hausaufgabe6.md"/>
                 <toc-element topic="ti_hausaufgabe7.md"/>
+                <toc-element topic="ti_hausaufgabe8.md"/>
 
             </toc-element>
             <toc-element topic="01Einleitung.md"/>

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.
+![image_923.png](image_923.png)
+
+- $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:
+![image_924.png](image_924.png)
+
+### 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^+)$
+