DavidS/zusammenfassungen
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update

Browse Source
This commit is contained in:
David Schirrmeister
2025-05-12 22:45:01 +02:00
parent b015a74b43
commit a13909a556
17 changed files with 342 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

430
Writerside/topics/04/Theoretische Informatik/Hausaufgaben/ti_hausaufgabe3.md Normal file
View File

@ -0,0 +1,430 @@
# Ü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
```