update

Writerside/in.tree

@@ -118,9 +118,7 @@
             <toc-element topic="06_ipRoutingIPQoS.md"/>
             </toc-element>
             <toc-element toc-title="Teil-2">
-                <toc-element topic="12_EndeZuEnde_UDP_TCP.md"/>
                 <toc-element topic="13_TCP-Ende-zuEnde.md"/>
-                <toc-element topic="14_TCP-Fallstudien.md"/>
 
             </toc-element>
 
@@ -147,6 +145,8 @@
                 <toc-element topic="ti_hausaufgabe6.md"/>
                 <toc-element topic="ti_hausaufgabe7.md"/>
                 <toc-element topic="ti_hausaufgabe8.md"/>
+                <toc-element topic="ti_hausaufgabe9.md"/>
+                <toc-element topic="ti_hausaufgabe10.md"/>
 
             </toc-element>
             <toc-element topic="01Einleitung.md"/>
@@ -155,6 +155,7 @@
             <toc-element topic="04_GrenzenGroesseEA.md"/>
             <toc-element topic="05_GrundlagenGrammatiken.md"/>
             <toc-element topic="06_ReguläreSprachen.md"/>
+            <toc-element topic="07_kontextfreieSprachen.md"/>
 
         </toc-element>
 

Writerside/topics/04/Rechnernetze/Teil-2/13_TCP-Ende-zuEnde.md

@@ -9,13 +9,182 @@
 | Paket-Sortier-Mechanismus                                                              | keiner                            |
 | ACKs                                                                                   | keine ACKs                        |
 | Erweitertes Error-Checking                                                             | nur Checksumme                    |
-| [Flow Control](12_EndeZuEnde_UDP_TCP.md#tcp-flusskontrolle)                            | keine                             |
+| [Flow Control](#tcp-flusskontrolle)                                                    | keine                             |
-| [SlowStart & CongestionAvoidance](12_EndeZuEnde_UDP_TCP.md#tcp-berlastungskontrolle)   | keine                             |
+| [SlowStart & CongestionAvoidance](#tcp-berlastungskontrolle)                           | keine                             |
 | 20-Byte Header                                                                         | 8-Byte Header                     |
-| [3-Wege-Handshake](12_EndeZuEnde_UDP_TCP.md#tcp-verbindungsaufbau)<br/>SYN SYN-ACK ACK | keiner                            |
+| [3-Wege-Handshake](#tcp-verbindungsaufbau)<br/>SYN SYN-ACK ACK                         | keiner                            |
 | Genutzt von kritischen Anwendungen                                                     | genutzt von Real-Time Anwendungen |
 | HTTP, HTTPS, FTP, DNS, SMTP, Telnet                                                    | DHCP, DNS, VoIP, RIP, TFTP        |
 
+## TCP 
+> Zuverlässiger Byte-Strom mit integrierter Flusskontrolle
+
+
+### Ausgangslage für eine (virtuelle) TCP-Verbindung
+![image_866.png](image_866.png)
+
+- MSS (Maximum Segment Size)
+  - maximale Größe eines TCP-Segments (NUR Daten, ohne Header)
+  - wird bei Verbindungsaufbau ausgehandelt
+  - abhängig von der MTU (Maximum Transmission Unit) des darunterliegenden Netzwerks
+- Retransmission Timer (Timeout = RTO)
+  - Nach Ablauf des Timers werden unbestätigte Datenpakete erneut gesendet
+## TCP Sequenznummern
+- Sequenznummer eines TCP-Segments
+  - Bytestromnummer des ersten Bytes im Segment
+  - wird bei Verbindungsaufbau ausgehandelt
+
+## TCP Bestätigungsnummern
+- Bestätigungsnummer eines TCP-Segments
+  - Bytestromnummer des nächsten erwarteten Bytes
+  - Als Quittungsnummer wird gesetzt:
+    - ACK-Nummer (von Host B) = fehlerfrei empfangene Squenznummer + Größe der Nutzdaten in Byte
+- i.d.R poitiv
+  - stellen Summenquittungen dar
+    - d.h. alle Bytes bis zur ACK-Nummer wurden fehlerfrei empfangen
+- werden zusammen mit den restlichen Daten die von B nach A gesendet werden, in einem TCP-Segment übertragen
+  - "Huckepack"
+
+### TCP Telnet Fallstudie
+![image_867.png](image_867.png)
+
+#### Neuübertragung aufgrund einer verlorenen ACK
+![image_868.png](image_868.png)
+
+#### keine Neuübertragung, weil Bestätigung vor Timeout ankommt
+![image_869.png](image_869.png)
+
+#### Keine Neuübertragung, weil kumulative Bestätigung ankommt (Summenquittung)
+![image_870.png](image_870.png)
+
+## TCP Verbindungsaufbau
+> TCP-Verbindung ist Full-Duplex
+>
+> Beide Verbindungen (Hin und Rück) müssen separat aufgebaut werden
+>
+> SYN-Flag = 1 dient zum Aufbau (Synchronisation)
+>
+> ACK-Flag = 1 dient zur Bestätigung (Quittung)
+>
+> Sequenz- und Quittungsnummern beziehen sich auf Bytes
+
+- TCP-Verbindung wird mit einem 3-Wege-Handshake aufgebaut
+  - **Verbindungsanfrage (SYN) von A an B**
+    - SYN = 1
+    - SEQ = x (Startsequenznummer)
+  - **Verbindungsbestätigung (SYN, ACK) von B an A**
+    - SYN = 1
+    - ACK = x + 1 (Bestätigungsnummer)
+    - SEQ = y (Startsequenznummer von B)
+  - **Bestätigung (ACK) von A an B**
+    - SYN = 0
+    - ACK = y + 1 (Bestätigungsnummer)
+    - SEQ = x + 1 (Fortsetzung der Sequenznummer von A)
+- ![image_871.png](image_871.png)
+
+### Verbindungsaufbau Übung
+![image_872.png](image_872.png)
+
+## TCP Verbindungsabbau
+> TCP-Verbindung ist Full-Duplex → Jede Richtung muss separat abgebaut werden
+>
+> Falls nur eine Verbindung abgebaut wird (und die andere noch aktiv ist), dann wird die Verbindung in den Zustand "Half-Close" versetzt.
+> bspw. Wenn der Client nur noch empfangen möchte, aber nicht mehr senden.
+
+- Schematisch
+  - Schließung TCP-Verbindung mit anschließender Wartezeit von 30 Sekunden
+  - ![image_873.png](image_873.png)
+
+### Verbindungsabbau Übung
+![image_874.png](image_874.png)
+
+## TCP Verbindungsmanagement
+![image_875.png](image_875.png)
+- TCP-Verbindungen werden in einem Verbindungsmanagement verwaltet
+- Zustände:
+  - CLOSED: Verbindung ist geschlossen
+  - LISTEN: Verbindung wartet auf Verbindungsanfrage
+  - SYN-SENT: Verbindungsanfrage wurde gesendet, aber noch keine Antwort erhalten
+  - SYN-RECEIVED: Verbindungsanfrage wurde empfangen, aber noch keine Bestätigung gesendet
+  - **ESTABLISHED**: Verbindung ist aufgebaut und kann Daten übertragen
+  - FIN-WAIT-1: Die Anwendung möchte Übertragung beenden
+  - FIN-WAIT-2: Andere Seite ist einverstanden die Verbindung zu beenden
+  - TIME-WAIT: Verbindung ist geschlossen, aber wartet auf mögliche ausstehende Pakete
+  - CLOSING: Beide Seiten haben gleichzeitig versucht, die Verbindung zu schließen
+  - CLOSE-WAIT: Gegenseite hat Verbindungsfreigabe eingeleitet
+  - LAST-ACK: Warten, bis keine TCP-Segmente mehr kommen
+
+### TCP Client Lifecycle
+![image_876.png](image_876.png)
+
+### TCP Server Lifecycle
+![image_877.png](image_877.png)
+
+## TCP Zuverlässigkeit sicherstellen
+- Quittungen
+  - positive ACKs
+  - kumulative Summenquittungen
+- Zeitüberwachung
+  - Retransmission Timer
+  - Timeout (RTO)
+- Sequenznummern
+
+## TCP Pipelining, Sliding Window
+### Pipelining
+- TCP-Sender kann mehrere Segmente senden, ohne auf die Bestätigung des Empfängers zu warten
+- Erlaubt eine höhere Auslastung der Verbindung
+- Sender sendet mehrere Segmente in einem Rutsch
+  - z.B. 3 Segmente mit jeweils 1000 Bytes
+- **Konsequenzen**:
+  - Sender und Empfänger benötigen einen Puffer für mehrere Segmente
+    - Minimum: Sender muss alle gesendeten, aber noch nicht bestätigten Segmente puffern
+  - Bereich der Sequenz- und Bestätigungsnummern wird größer
+
+### Sliding Window
+![image_881.png](image_881.png)
+- Sliding Window ist eine Erweiterung des Pipelining
+- Gewährleistet:
+  - Zuverlässige Übertragung in einem Bytestrom
+  - Übertragung der Daten in richtiger Reihenfolge
+  - Flusskontrolle zwischen Sender und Empfänger
+- Integrierte Flusskontrolle
+  - keine feste Sliding Window Größe
+    - wird Sender vom Empfänger mitgeteilt ("Advertised Window")
+      - auf Grundlage des Speicherplatzes, der der Verbindung zugewiesen ist
+
+#### Sliding Window Beispiel
+![image_882.png](image_882.png)
+- **Senderseite** (a)
+  - LastByteAcked ≤ LastByteSent
+  - LastByteSent ≤ LastByteWritten
+  - Bytes zwischen LastByteAcked und LastByteSent puffern
+- **Empfängerseite** (b)
+  - LastByteRead ≤ LastByteExpected
+  - LastByteExpected ≤ LastByteReceived + 1
+  - Bytes zwischen LastByteRead und LastByteReceived puffern
+
+
+## TCP Fehlerbehandlung
+- Erfolgt durch Go-Back-N
+  - Sender sendet Datenpakete, bis er eine Bestätigung erhält
+  - Bei Verlust eines Pakets wird es erneut gesendet
+- Arbeitet mit positiven ACKs
+  - Empfänger sendet ACKs für empfangene Pakete (ggf. kumulative ACKs)
+  - Ab dem ersten, nicht quittierten Paket, werden alle folgenden Pakete erneut gesendet
+
+
+## TCP Überlastungskontrolle
+- Funktion der Netzwerkschicht zur Regelung des Datenflusses
+- Begrenzung der Übertragungsrate
+- Lösungsansatz:
+  - **TCP-Slow-Start**
+    - Startet mit einer niedrigen Übertragungsrate
+    - Erhöht die Rate (cwnd) exponentiell, bis ein Paket verloren geht
+      - maximal Windowsize
+  - **TCP-Überlastungskontrolle**
+    - Reduziert die Übertragungsrate, wenn Pakete verloren gehen
+
+
 ## Silly Window
 > Sender/Empfänger senden/empfangen nur sehr kleine Datenmengen → Fragmentierung in viele Segmente, welche aber immer 
 > noch den TCP/IP-Header haben und damit Netzwerknutzung ineffizient wird
@@ -159,4 +328,87 @@
     - kleine, verzögerte Pakete leiden
     - → sofortiges Senden kleiner Pakete
   - Delayed ACKs abschalten/reduzieren
-  
+
+## TCP Flusskontrolle
+### Senden
+- TCP-Sender sendet Daten, solange der Sendepuffer nicht voll ist
+  - enthält die gesendeten, aber noch nicht bestätigten Daten
+- ![image_878.png](image_878.png)
+- Sendefenster wird dazu benutzt, um die Anzahl von Bytes anzugeben, die der Empfänger bereit ist anzunehmen
+  - bildet absolute obere Grenze, die vom Sender nicht überschritten werden darf
+
+### Empfangen
+- TCP-Empfänger sendet ACKs, solange der Empfangspuffer nicht voll ist
+- ![image_879.png](image_879.png)
+
+- Empfangsfenster ist dynamisch
+  - wird vom Empfänger in jedem ACK aktualisiert
+    - **rwnd = rcvBuffer - (LastByteRcvd - LastByteRead)**
+  - gibt an, wie viele Bytes der Empfänger noch aufnehmen kann
+    - wenn rwnd = 0, warten auf WindowUpdate und keine Daten mehr senden
+
+### Flusskontrolle Beispiel
+![image_880.png](image_880.png)
+
+
+### Datenfluss: Fehlerfreie Übertragung
+![image_883.png](image_883.png)
+
+### Datenfluss: Fehlerhafte Übertragung
+![image_884.png](image_884.png)
+
+
+## TCP Timeout und RTO-Berechnung
+- nach jeder RTT Messung, um zuverlässig aber nicht zu früh neu zu senden
+
+1. Startwert: RTO = 1 Sekunde
+2. Initialisierung nach erster RTT Messung
+   - SRTT (Smoothed RTT) = RTT_neu
+   - RTTVAR (RTT Varianz) = RTT_neu / 2
+   - RTO = SRTT + max(G, 4 x RTTVAR
+3. Aktualisierung
+   - SRTT = (1- 1/8) x SRTT + (1/8) x RTT_neu
+   - RTTVAR = (1- 1/4) x RTTVAR + (1/4) x |SRTT - RTT_neu|
+   - RTO = SRTT + max(G, 4 x RTTVAR)
+4. Sicherheitsmechanismen
+   - RTO ≥ 1 Sekunde
+   - Exponentielles Backoff
+     - RTO = 2x vorheriges RTO
+     - RTT wird nur für Original-Segmente gemessen
+       - _nicht bei Retransmissions_
+
+
+## TCP Fast Retransmit und Fast Recovery
+### Fast Retransmit
+- Ziel: Frühzeitige Erkennung von Paketverlusten
+  - Schnelle Wiederherstellung Übertragung
+  - Reduktion unnötiger Timeouts
+- Ablauf
+  - Segment geht verloren, nachfolgende kommen an
+  - Empfänger bestätigt nur letztes empfangenes Byte
+    - Duplicate ACKs
+  - Sobald Sender 3 DupACKs für gleiches Segment empfängt → Verlust
+  - Segment direkt neu senden (KEIN RTO)
+> 3x gemeldet → sofort gesendet!
+
+![image_959.png](image_959.png)
+
+### Fast Recovery
+- Greift direkt nach Fast Retransmit
+- Ziel: TCP soll nicht in Slow-Start-Phase zurückfallen
+- Sender reduziert cwnd nur moderat
+
+## TCP Tahoe
+- Implementierung von Staukontrolle
+  - SlowStart, Congestion Avoidance, Fast Retransmit
+
+> TCP Tahoe startet neu mit dem SlowStart bei jedem Verlust - Sicherheit geht vor Geschwindigkeit
+
+
+## TCP Reno
+- Weiterentwicklung von TCP Tahoe
+  - Fast Retransmit UND Fast Recovery
+
+> TCP Reno erkennt Verluste früh, sendet schnell neu und erholt sich klug
+
+![image_960.png](image_960.png)

Writerside/topics/04/Theoretische Informatik/06_ReguläreSprachen.md

@@ -114,4 +114,6 @@ Nachteile:
   - $(a)^?$: ggf. 1x a
   - $[acfw]$: $a | c | f | w$ =  a oder c oder f oder w
   - $[^acfw]$: nicht eins von denen
-  - $[1-4]$: [1234]
+  - $[1-4]$: [1234]
+
+> Sprachen sind von einem regulären Ausdruck beschreibbar, wenn Nerode-Index endlich ist

Writerside/topics/04/Theoretische Informatik/07_kontextfreieSprachen.md

@@ -0,0 +1,17 @@
+# Kontextfreie Sprachen
+## Chomsky Normalform
+- Eine Grammatik ist in der CNF, wenn
+  - α ∈ V
+  - β in Σ ODER β = X*Y mit X,Y ∈ V
+  - S nicht auf der rechten Seite
+
+### Umwandlung kontextfreier Grammatiken in CNF
+1. Falls `S` irgendwo auf der rechten Seite ist
+   - Altes `S` in `S'` umbenennen
+   - Neue Variable `S → S'` hinzufügen
+2. Alle epsilon Regeln entfernen (außer `S → ε`)
+3. Alle Regeln der Form `A→B` entfernen
+4. Alle Regleln der Form `A→β` mit |β| > 2 umwandeln
+   - $A → X_1X_2...X_n$ in A → $X_1Y_1$, $Y_1 → X_2Y_2$, ..., $Y_{n-1} → X_n$
+   - 
+   - 

Writerside/topics/04/Theoretische Informatik/Hausaufgaben/ti_hausaufgabe10.md

@@ -0,0 +1,138 @@
+# Übungsblatt 10
+> Wenzel Schwan (1125033), Paul Kneidl (1125219), David Schirrmeister (1125746), Michelle Klein (1126422)
+
+## Aufgabe 1
+
+### 1a)
+Gegeben sei folgende CNF-Grammatik $G_1$:
+
+```
+G_1:  
+S → AB | CD  
+C → AB  
+D → BA  
+A → 0  
+B → 1
+```
+
+Nutzen Sie den CYK-Algorithmus, um zu entscheiden, ob das Wort $w = 0110$ zur Sprache $L(G_1)$ gehört.  
+Legen Sie dazu eine Tabelle analog zu dem Beispiel aus der Vorlesung (Kapitel 7, Folie 16) an und füllen Sie diese entsprechend aus.
+
+| $Var(w)_{[i,j]}(G_1)$ | 1       | 2       | 3  | 4       |
+|-----------------------|---------|---------|----|---------|
+| 1                     | $\{A\}$ | {S,C}   | {} | $\{S\}$ |
+| 2                     | -       | $\{B\}$ | {} | {}      |
+| 3                     | -       | -       |    | $\{D\}$ |
+| 4                     | -       | -       | -  | $\{A\}$ |
+
+→ $w ∈ L(G_1)$
+
+### 1b)
+Gegeben sei folgende CNF-Grammatik $G_2$:
+
+```
+G_2:  
+S → AB  
+A → AA | AC | a  
+B → BC | b  
+C → CC | a | c
+```
+
+Nutzen Sie analog zu Aufgabe 1a den CYK-Algorithmus, um zu entscheiden, ob das Wort $w = acb$ zur Sprache $L(G_2)$ gehört.
+
+| $Var(w)_{[i,j]}(G_2)$ | 1         | 2         | 3       |
+|-----------------------|-----------|-----------|---------|
+| 1                     | $\{A,C\}$ | $\{A,C\}$ | $\{S\}$ |
+| 2                     | -         | $\{C\}$   | {}      |
+| 3                     | -         | -         | $\{B\}$ |
+
+→ $w ∈ L(G_1)$
+
+## Aufgabe 2
+
+Gegeben sei folgende CNF-Grammatik $G$:
+
+```
+G:  
+S → AB  
+A → AA | AC | a  
+B → BC | b  
+C → CC | a | c
+```
+
+### 2a)
+Zeichnen Sie zwei verschiedene Syntaxbäume für das Wort $w = acacaaabaca \in L(G)$.
+
+![image_961.png](image_961.png)
+
+### 2b)
+Finden Sie ein Wort $w \in L(G)$, zu dem ein Ableitungsbaum mit möglichst wenig Knoten existiert, und zeichnen Sie den zugehörigen Ableitungsbaum.
+
+$w = ab$
+
+![image_962.png](image_962.png)
+
+## Aufgabe 3
+
+Betrachten Sie die folgenden Grammatiken $G_1$ und $G_2$. Gibt es zu der jeweiligen Grammatik $G_i$ ($i \in \{1, 2\}$) ein Wort $w \in L(G_i)$ mit mehr als einem Syntaxbaum? Begründen Sie Ihre Antwort.
+
+### 3a)
+
+```
+G_1:  
+S → 0 1 | 0 S 1
+```
+
+Nein, es gibt kein Wort mit mehreren Syntaxbäumen, da die Regeln jeden Schritt genau vorgeben, da
+wir nur eine Regel mit Rekursion haben, ist keine Mehrdeutigkeit möglich.
+
+### 3b)
+
+```
+G_2:  
+S → 0 B | 1 A  
+A → 0 | 0 S | 1 A A  
+B → 1 | 1 S | 0 B B
+```
+
+Nein, es gibt keine Möglichkeit mehrere Syntaxbäume zu bilden, da zwar eine Rekursion möglich ist durch
+$B → 0BB$ und $A→1AA$, jedoch durch die 1 und 0 vor den Variablen kein alternativer Pfad gebildet werden kann.
+
+## Aufgabe 4
+
+Für eine Sprache $L$ über einem Alphabet $\Sigma$ definieren wir
+
+$$
+L^R := \{ w^R \mid w \in L \}
+$$
+
+Dabei gilt $w^R = w_n w_{n-1} \dots w_1$ für $w = w_1 w_2 \dots w_n \in L$ mit $w_i \in \Sigma$.
+
+Beschreiben Sie ein algorithmisches Verfahren, das aus einer kontextfreien Grammatik $G$ eine kontextfreie Grammatik $G^R$ erzeugt, so dass $L(G^R) = L(G)^R$ gilt. Begründen Sie die Korrektheit Ihres Verfahrens.
+
+Gegeben: $G=(Σ, V, S, R)$
+- S, V und Σ bleiben gleich
+- Für jede Regel $A → X_1X_2...X_n$
+  - Regel $A → X_n, X_{n-1}, ..., X_1$ hinzufügen
+
+Da kontextfreie Grammatiken keine Einschränkungen hinsichtlich der Position von (Nicht-)Terminalen in Regeln haben,
+bleibt die resultierende Grammatik $G^R$ kontextfrei.
+Die Korrektheit folgt daraus, dass jede Regel in $G$ eine Regel in $G^R$ erzeugt, die das gleiche Wort in umgekehrter Reihenfolge generiert.
+
+## Aufgabe 5
+
+Für eine Sprache $L$ über dem Alphabet $\Sigma = \{ 0, 1 \}$ definieren wir
+
+$$
+L^{\text{prfx}} := \{ x \in \Sigma^\ast \mid \exists y \in \Sigma^\ast : x \cdot y \in L \}
+$$
+
+Beschreiben Sie ein algorithmisches Verfahren, das aus einer regulären Grammatik $G$ eine reguläre Grammatik $G_{\text{prfx}}$ erzeugt, so dass $L(G_{\text{prfx}}) = L(G)_{\text{prfx}}$ gilt. Begründen Sie die Korrektheit Ihres Verfahrens.
+
+Gegeben: $G=(Σ, V, S, R)$
+- Wandle G in einen NEA N um
+- Markiere alle Zustände als akzeptierend → $N_{prfx}$
+  - Präfix kann beliebig lang sein und muss kein nachfolgendes Symbol haben
+- Wandle $N_{prfx}$ in eine rechtslineare Grammatik $G_{prfx}$ um
+
+- Oder für jede Nichtterminale die Regel $A → ε$ hinzufügen

Writerside/topics/04/Theoretische Informatik/Hausaufgaben/ti_hausaufgabe9.md

@@ -0,0 +1,147 @@
+# Übungsblatt 9
+> Wenzel Schwan (1125033), Paul Kneidl (1125219), David Schirrmeister (1125746), Michelle Klein (1126422)
+
+## Aufgabe 1
+Geben Sie für die folgende Sprachen über dem Alphabet $\Sigma = \{ a, b, c \}$ eine kontextfreie Grammatik $G_1$ an, so dass $L(G_1) = L_1$ gilt:
+
+**$L_1 = \{ a^m b^c n \mid n, m \in \mathbb{N}, m < n + 1 \}$**
+
+```
+S → aXc
+X → aXc | Xc | b
+```
+
+$L_2 = \{ a^m b^c n \mid n, m \in \mathbb{N}, m > n + 1 \}$
+
+```
+S → aaaXc 
+X → aXc | aX | b
+```
+
+$L_3 = \{ a^m b^c n \mid n, m \in \mathbb{N}, m \neq n + 1 \}$
+
+```
+S → aXc | aaaYc
+X → aXc | Xc | b
+Y → aYc | aY | b
+```
+
+## Aufgabe 2
+
+### 2a)
+Geben Sie eine kontextfreie Grammatik $G_{arithm}$ an, welche die Sprache der vollständig geklammerten arithmetischen Ausdrücke über dem Alphabet $\Sigma = \{ 0, 1, \dots, 9, +, -, \cdot, /, (, ) \}$ erzeugt.  
+Beispiel: $((23 - 42)/21) \in L(G_{arithm})$
+
+```
+S → (SOS) | Z
+O → + | - | * | /
+Z → OZ | O
+O → 0 | 1 | ... | 9
+```
+
+### 2b)
+Geben Sie eine kontextfreie Grammatik $G_{reg}$ an, welche die Sprache der vollständig geklammerten regulären Ausdrücke für reguläre Sprachen über dem Alphabet $\{ 0, 1, \dots, 9 \}$ erzeugt.
+
+```
+S → (S|S) | (S*S) | (S*) | O 
+O → OZ | Z
+Z → 0 | 1 | ... | 9
+```
+
+## Aufgabe 3
+
+### 3a)
+Gegeben sei die folgende kontextfreie Grammatik $G$ über dem Alphabet $\Sigma = \{ x, y, z \}$:
+
+```
+S → y S y | H  
+H → x H | x | H'  
+H' → H | z
+```
+
+Geben Sie eine CNF-Grammatik $G'$ an, so dass $L(G') = L(G)$ gilt. Geben Sie geeignete Zwischenschritte an und erläutern Sie Ihr Vorgehen.
+
+```
+G'(0):
+S → S'
+S' → yS'y | H
+H → xH | x | H'
+H' → H | z
+
+G'(1):
+S → S'
+S' → yS'y | H
+H → xH | x | H'
+H' → H | z
+
+G'(2):
+S → yS'y | xH | x | z
+S' → yS'y | xH | x |z
+H → xH | x | z
+
+G'(3):
+S → XS'' | XH | x | z
+S'' → S'Y
+S' → YS'' | XH | x | z
+H → XH | x | z
+Y → y
+X → x
+```
+
+
+### 3b)
+Geben Sie für die Sprache $L = \{ v \cdot a^n b^n \mid v \in \{ a, b, c \}^\ast, n \in \mathbb{N} \}$ eine CNF-Grammatik $G$ an, so dass $L(G) = L$ gilt.
+
+$$S → VX | V_aX_1 | V_aV_b$$
+$$V → V_aV | V_bV | V_cV | a | b | c$$
+$$X → V_aX_1 | V_aV_b$$
+$$X_1 → XV_b$$
+$$V_a → a$$
+$$V_b → b$$
+$$V_c → c$$
+
+
+
+## Aufgabe 4
+
+Gegeben sei die folgende CNF-Grammatik $G$:
+
+```
+S → A B | N H | N E  
+A → N H | N E  
+B → E B | 1  
+H → A E  
+N → 0  
+E → 1
+```
+
+### 4a)
+Beschreiben Sie die Sprache $L(G)$ in formaler Mengenschreibweise.
+
+$$L(G) := \{0^n1^m|n,m ∈ N, n ≤ m\}$$
+
+### 4b)
+Leiten Sie fünf selbstgewählte Wörter $w \in \{ 0, 1 \}^\ast$ unterschiedlicher Länge mit Hilfe der Grammatik $G$ ab (Folge von 1-Schritt-Ableitungen).
+
+$$01: S → NE → 0E → 01$$
+
+$$011: S → AB → NEB → 0EB → 01B → 011$$
+
+$$00111: S → AB → NHB → NAEB → NNEEB → 0NEEB → 00EEB → 001EB → 0011B → 00111$$
+
+$$0111: S→ AB→ NEB → 0EB → 01B → 01EB → 011B → 0111$$
+
+$$001111: S → AB → NHB → NAEB → NNEEB → 0NEEB → 00EEB → 001EB → 001EEB → 0011EB → 00111B → 001111$$
+
+### 4c)
+Wie viele Ableitungsschritte wurden jeweils in 4b benötigt? Geben Sie möglichst exakt an, wie viele Ableitungsschritte (in Abhängigkeit von $n$) nötig sind, um ein Wort $w \in L(G)$ der Länge $n \in \mathbb{N}$ abzuleiten.
+
+2 → 3; 3 → 5; 5 → 9; 4 → 7; 6 → 11
+
+→ $2n - 1$
+
+### 4d)
+Lässt sich Ihre Erkenntnis aus 4c auf andere CNF-Grammatiken übertragen? Begründen Sie Ihre Antwort.
+
+Ja, da die CNF eine binäre Struktur erzwingt, was stets zu $2n-1$ Ableitungsschritten führt.
+→ Jede Regel ist entweder vom Typ `A→BC` oder `A→a`, was zu einem binären Baum führt.