# Übungsblatt 3
> Wenzel Schwan (1125033), Paul Kneidl (1125219), David Schirrmeister (1125746), Michelle Klein (1126422)

## Übung 1
Betrachten Sie den nichtdeterministischen Automaten $N$ aus Abbildung 1 über dem
Alphabet $Σ = \{ 0, 1 \}^*$.

![Abbildung 1](image_784.png)
Automat $N$ für Worte aus $\{ 0, 1 \}^*$, deren drittletztes Zeichen eine `0` ist.

### 1(a)
Wie viele Berechnungspfade gibt $e$, die das Wort `1111` lesen? Wie viele Berechnungsschritte (Verarbeitungen eines Zeichens) sind insgesamt notwendig, um all diese
Berechnungspfade (deterministisch) zu simulieren? Begründen Sie nachvollziehbar,
wie Sie auf Ihre Antworten gekommen sind.

**Antwort:**

Da wir bei jedem Übergang in `a` bleiben, gibt es nur einen möglichen Berechnungspfad für das Wort `1111`

Die Anzahl der deterministischen Berechnungsschritte liegt bei 4, da der Pfad 4 Eingaben verarbeitet.

### 1(b)
Konstruieren Sie den Potenzautomaten $A_N$ zu $N$. Geben Sie bei der Konstruktion
die Übergangsfunktion $δ$ des Automaten $A_N$ in tabellarischer Form an. Machen Sie
nach dem Abarbeiten einer Zeile deutlich, welche neuen Metazustände Sie gefunden
haben.

| Zustand               | δ(.,0)          | δ(.,1)        |
|-----------------------|-----------------|---------------|
| a                     | **{a,b}**       | a             |
| {a,b}                 | **{a,b,c}**     | **{a,c}**     |
| {a,b,c}               | **{a,b,c,d}**   | **{a,c,d}**   |
| {a,c}                 | **{a,b,d}**     | **{a,d}**     |
| {a,b,c,d} [$∈ Q_A$]   | **{a,b,c,d,ε}** | **{a,c,d,ε}** |
| {a,c,d}  [$∈ Q_A$]    | **{a,b,d,ε}**   | **{a,d,ε}**   |
| {a,b,d} [$∈ Q_A$]     | **{a,b,c,ε}**   | **{a,c,ε}**   |
| {a,d}  [$∈ Q_A$]      | **{a,b,ε}**     | **{a,ε}**     |
| {a,b,c,d,ε} [$∈ Q_A$] | {a,b,c,d,ε}     | {a,c,d,ε}     |
| {a,c,d,ε} [$∈ Q_A$]   | {a,b,d,ε}       | {a,d,ε}       |
| {a,b,d,ε} [$∈ Q_A$]   | {a,b,c,ε}       | {a,c,ε}       |
| {a,d,ε}  [$∈ Q_A$]    | {a,b,ε}         | {a,ε}         |
| {a,b,c,ε}             | {a,b,c,d,ε}     | {a,c,d,ε}     |
| {a,c,ε}               | {a,b,d,ε}       | {a,d,ε}       |
| {a,b,ε}               | {a,b,c,ε}       | {a,c,ε}       |
| {a,ε}                 | {a,b,ε}         | {a,ε}         |
| b                     | c               | c             |
| c                     | d               | d             |
| d [$∈ Q_A$]           | ε               | **ε**         |
| ε                     | ε               | ε             |


```plantuml
@startuml
scale 0.3

top to bottom direction
skinparam dpi 150

skinparam state {
    BackgroundColor #FFFACD
    BorderColor black
    FontName Helvetica
    RoundCorner 30
    Shadowing false
    LineThickness 0
}

state "d" as d##[bold]
state "a" as a
state "{a,b}" as ab
state "{a,b,c}" as abc
state "{a,c}" as ac
state "{a,b,c,d}" as abcd##[bold]
state "{a,c,d}" as acd##[bold]
state "{a,b,d}" as abd##[bold]
state "{a,d}" as ad##[bold]
state "{a,b,c,d,ε}" as abcde##[bold]
state "{a,c,d,ε}" as acde##[bold]
state "{a,b,d,ε}" as abde##[bold]
state "{a,d,ε}" as ade##[bold]
state "{a,b,c,ε}" as abce
state "{a,c,ε}" as ace
state "{a,b,ε}" as abe
state "{a,ε}" as ae
state "b" as b
state "c" as c
state "ε" as e



[*] --> a

' Übergänge von a
a --> a : 1
a --> ab : 0

' Übergänge von {a,b}
ab --> abc : 0
ab --> ac : 1

' Übergänge von {a,b,c}
abc --> abcd : 0
abc --> acd : 1

' Übergänge von {a,c}
ac --> abd : 0
ac --> ad : 1

' Übergänge von {a,b,c,d}
abcd --> abcde : 0
abcd --> acde : 1

' Übergänge von {a,c,d}
acd --> abde : 0
acd --> ade : 1

' Übergänge von {a,b,d}
abd --> abce : 0
abd --> ace : 1

' Übergänge von {a,d}
ad --> abe : 0
ad --> ae : 1

' Übergänge von {a,b,c,d,ε}
abcde --> abcde : 0
abcde --> acde : 1

' Übergänge von {a,c,d,ε}
acde --> abde : 0
acde --> ade : 1

' Übergänge von {a,b,d,ε}
abde --> abce : 0
abde --> ace : 1

' Übergänge von {a,d,ε}
ade --> abe : 0
ade --> ae : 1

' Übergänge von {a,b,c,ε}
abce --> abcde : 0
abce --> acde : 1

' Übergänge von {a,c,ε}
ace --> abde : 0
ace --> ade : 1

' Übergänge von {a,b,ε}
abe --> abce : 0
abe --> ace : 1

' Übergänge von {a,ε}
ae --> abe : 0
ae --> ae : 1

' Übergänge von b
b --> c : 0
b --> c : 1

' Übergänge von c
c --> d : 0
c --> d : 1

' Übergänge von d (Endzustand Q_A)
d --> e : 0
d --> e : 1

' Schleife auf ε
e --> e : 0
e --> e : 1
@enduml
```

### 1(c)
Gibt es einen deterministischen endlichen Automaten mit weniger Zuständen als
$A_N$, der $L(N)$ akzeptiert? Begründen Sie Ihre Antwort.

**Antwort:**

Um $A_N$ zu minimieren, könnte man nicht erreichbare Zustände, in diesem Fall
{{b},{c},{d},{ε}}, entfernen.
Ansonsten ist der Automat bereits in minimaler Form, da die Zustände sich alle in ihrer 
Erreichbarkeit und/oder ihrem Umgang mit Eingaben unterscheiden.




## Übung 2
Betrachten Sie den nichtdeterministischen Automaten N aus Abbildung 2 über dem
Alphabet $Σ = \{ x, y, z \}^*$. Weiterhin seien die Zeichenketten $s_1 = zzx$, $s_2 = xxyz$,
$s_3 = yyy$, $s_4 = xxz$ und $s_5 = xxzxxzxxzxxz$ definiert.

![Abbildung 2](image_792.png)

### 2(a)
Geben Sie für jedes $s_i (i ∈ \{ 1, 2, . . . , 5 \})$ an, ob es eine Berechnung (Bearbeitungspfad) für den Automaten N gibt, welche die Zeichenkette si vollständig liest (also
alle Zeichen abarbeitet bevor entschieden wird, ob $s_i$ akzeptiert wird oder nicht.)

**Antwort:**

- $s_1$: ja
- $s_2$: nein
- $s_3$: ja
- $s_4$: ja
- $s_5$: ja


### 2(b)
Geben Sie für jedes $s_i (i ∈ \{ 1, 2, . . . , 5 \})$ die Menge aller Zustände an, die $N$ durch
die Zeichenkette si erreichen kann

**Antwort:**

- $s_1$: {a,b}
- $s_2$: {}
- $s_3$: {$e$}
- $s_4$: {a,d}
- $s_5$: {a,d}

### 2(c)
Wie viele Berechnungspfade gibt es, die das Wort $s_5$ vollständig lesen? Begründen
Sie nachvollziehbar, wie Sie auf Ihre Antwort gekommen sind.

**Antwort:**

- $s_5 = xxzxxzxxzxxz = (xxz)^4$
- Anzahl Pfade:
  - 4x (xxz) in `a` → nicht akzeptierend
  - 3x (xxz) in `a` → akzeptierend
  - 2x (xxz) in `a` → akzeptierend
  - 1x (xxz) in `a` → akzeptierend
  - 0x (xxz) in `a` → akzeptierend
- **5 Berechnungspfade**



### 2(d)
Beschreiben Sie die Sprache $L(N)$ aller Worte, die der Automat $N$ akzeptiert
(formal oder informal, Ihre Wahl). Welche der Zeichenketten $s_i (i ∈ \{ 1, 2, . . . , 5 \})$
gehören zu $L(N )$, welche nicht?

**Antwort:**

- Automat $N$ für Worte aus $\{x,y,z\}^*$, die kein $y$ enthalten und die Zeichenkette $xxy$ beinhalten
- $L(N):=\{w ∈ Σ^* \space | \space w = a^n*b*c^n, n ∈ \mathbb{N}, a,c ∈ Σ\backslash\{y\}, b = xxz\}, Σ = \{c,y,z\}$

### 2(e)
Beschreiben Sie die Sprache aller Worte, welche der Automat $N$ nicht vollständig
bearbeiten kann, unabhängig davon ob $N$ die Worte akzeptiert oder nicht (formal
oder informal, Ihre Wahl). Also die Worte, für die kein Berechnungspfad existiert
der alle Zeichen liest

**Antwort:**
- Informell: Alle Worte, welche nach einem `y` ein `x` oder `z` beinhalten.
- Formell: $L(\not N) := \{w ∈ Σ^* \space | \space w = a^n*b^m*c^m*d^n, n ∈ \mathbb{N}, m ∈ \mathbb{N}_0, a,c ∈ \{x,z\}, b ∈ \{y\}, d ∈ Σ\}$

## Übung 3
### 3(a)
Gegeben sei ein beliebiger deterministischer endlicher Automat $A = (Σ, Q, q_s, Q_a, δ)$.
Konstruieren Sie einen deterministischen endlichen Automaten $A$ in formaler Tupel-
Darstellung, der genau die Worte akzeptiert die $A$ nicht akzeptiert. Beweisen Sie
die Korrektheit Ihrer Konstruktion.

**Antwort:**
- $A' = (Σ,Q,q_s,Q'_a,δ)$
  - $Q'_a=Q\backslash Q_a$
- Beweis:
  - wenn $w ∈ Σ^*$ ein beliebiges Wort ist
    - $δ(q_s, w) = q$
    - Falls $q ∈ Q_a$
      - $A$ akzeptiert das Wort
      - da $q \not ∈ Q'_a$, akzeptiert $A'$ nicht
    - Falls $q \not ∈ Q_a$
      - $A$ akzeptiert das Wort nicht
      - da $q ∈ Q'_a$, akzeptiert $A'$
    - Es gilt also
      - $w ∈ L(A') ↔ w \not ∈ L(A)$

### 3(b)
Gegeben sei ein beliebiger nichtdeterministischer endlicher Automat $N = (Σ, Q, q_s, Q_a, δ)$.
Können Sie hier auf ähnliche Weise wie in [Punkt (a)](#3-a) einen nichtdeterministischen
endlichen Automaten $N$ konstruieren, der genau die Worte akzeptiert, die $N$ nicht
akzeptiert? Falls ja, beweisen Sie die Korrektheit der Konstruktion. Falls nein,
geben Sie ein Beispiel für das die Konstruktion scheitert.

**Antwort:**
- Nein, kann nicht konstruiert werden
  - in einem NEA gibt es _mindestens_ einen Pfad, der in einen akzeptierenden Zustand führt, damit das Wort akzeptiert wird
  - durch einfaches Subtrahieren der Mengen ändert sich nicht automatisch die Gesamtaussage über (Nicht-)Akzeptanz aller Pfade
- Beispiel
  - $Σ = \{a\}$
  - $Q = \{q_0, q_1\}$
  - $q_s = q_0$
  - δ
    - |       | (.,a)         |
      |-------|---------------|
      | $q_0$ | $\{q_0,q_1\}$ |
      | $q_1$ |               |
  - Verhalten von A
    - für $w=a$
      - $q_0 \xrightarrow[a] q_0$ → nicht akzeptierend
      - $q_0 \xrightarrow[a] q_1$ → akzeptierend
    - es existiert ein akzeptierender Pfad → a wird akzeptiert
  - $Q'_a=\{q_0\}$
    - für $w=a$
      - $q_0 \xrightarrow[a] q_0$ → akzeptierend
      - $q_0 \xrightarrow[a] q_1$ → nicht akzeptierend
    - es existiert ein akzeptierender Pfad → a wird wieder akzeptiert
      


## Übung 4
Betrachten Sie die beiden deterministischen endlichen Automaten $A_1$ und $A_2$ aus Abbildung 3
![Abbildung 3](image_786.png)

### 4(a)
Beschreiben Sie den Aufbau von Worten $w$ aus der Sprache $L(A_1) ∪ L(A_2)$ (formal
oder informal, Ihre Wahl)

- informal: alle Worte, die genau drei `1` enthalten oder keine zwei `1` aufeinanderfolgend beinhalten


### 4(b)
Konstruieren Sie einen nichtdeterministischen endlichen Automaten $N_∪$, der die
Sprache $L(A_1) ∪ L(A_2)$ 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
}




[*] --> S
S --> a0 : ε
S --> b0 : ε

' --- Automat A1 ---
  a0 --> a0 : 0
  a0 --> a1 : 1
  a1 --> a1 : 0
  a1 --> a2 : 1
  a2 --> a2 : 0
  a2 --> a3 : 1
  a3 --> a3 : 0
  state a3##[bold]


' --- Automat A2 ---
  b0 --> b0 : 0
  b0 --> b1 : 1
  b1 --> b0 : 0
  b1 --> b2 : 1
  state b0##[bold]
  state b1##[bold]



@enduml
```

### 4(c)
Beschreiben Sie den Aufbau von Worten $w$ aus der Sprache $L(A_1) ∩ L(A_2)$ (formal
oder informal, Ihre Wahl)

- Alle Wörter, die aus genau drei `1` bestehen und niemals 2x hintereinander eine `1` haben

### 4(d)
Konstruieren Sie einen nichtdeterministischen endlichen Automaten $N_∩$, der die
Sprache $L(A_1) ∩ L(A_2)$ 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
}

[*] --> a

' a: noch keine 1 gelesen
state a {
}

a --> a : 0
a --> b : 1

' b: eine 1 gelesen, darf nur 0 folgen
b --> b : 0
b --> c : 0

' c: bereit für zweite 1
c --> d : 1

' d: zwei 1 gelesen, darf nur 0 folgen
d --> d : 0
d --> e : 0

' e: bereit für dritte 1
e --> f : 1

' f: drei 1 gelesen – akzeptierend
state f##[bold]
f --> f : 0
@enduml

```