update

Writerside/in.tree

@@ -93,6 +93,8 @@
 
         <toc-element toc-title="Projektmanagement">
             <toc-element topic="00_EinführungPM.md"/>
+            <toc-element topic="01_Projektinitiierung.md"/>
+
         </toc-element>
 
         <toc-element toc-title="Rechnernetze">
@@ -101,12 +103,13 @@
             <toc-element topic="00_RNIntroduction.md"/>
             <toc-element topic="01_Internetworking.md"/>
             <toc-element topic="02_HW-BausteineUndVerkabelung.md"/>
+            <toc-element topic="03_GrundlagenNetzwerke_Ethernet.md"/>
 
         </toc-element>
         <toc-element toc-title="Software Engineering">
             <toc-element topic="00_Introduction.md"/>
             <toc-element topic="01_ImplementingForMaintainability.md"/>
-            <toc-element topic="99_Praktikum1Vorbereitung.md"/>
+            <toc-element topic="02_TestingForContinuousQuality.md"/>
         </toc-element>
         <toc-element toc-title="Theoretische Informatik">
             <toc-element toc-title="Übungen">
@@ -115,11 +118,13 @@
             <toc-element toc-title="Hausaufgaben">
                 <toc-element topic="ti_hausaufgabe1.md"/>
                 <toc-element topic="ti_hausaufgabe2.md"/>
+                <toc-element topic="ti_hausufgabe3.md"/>
 
             </toc-element>
             <toc-element topic="01Einleitung.md"/>
             <toc-element topic="02_GrundlagenFormaleSprachen.md"/>
             <toc-element topic="03_GrundlagenEndlicherAutomaten.md"/>
+            <toc-element topic="04_GrenzenGroesseEA.md"/>
         </toc-element>
 
     </toc-element>
@@ -145,5 +150,4 @@
             <toc-element topic="10_IntergrierteInformationsverarbeitung.md"/>
         </toc-element>
     </toc-element>
-    <toc-element topic="01_Projektinitiierung.md"/>
 </instance-profile>

Writerside/topics/04/Rechnernetze/02_HW-BausteineUndVerkabelung.md

@@ -76,8 +76,54 @@
 > Wird verwendet, um Kollisionen zu handhaben. Wenn eine Kollision erkannt wird, stoppen die sendenden
 > Geräte, warten eine zufällige Zeitspanne und versuchen dann erneut, ihre Daten zu senden.
 
+> Mehrfachzugang mit Trägerprüfung und Kollisionserkennung
+
 ![image_754.png](image_754.png)
 
+#### Grundprinzipien
+##### Carrier Sense (Trägererkennung)
+- Ethernetgerät prüft, ob Übertragungsmedium frei ist, bevor es sendet
+  - für hinreichend lange Zeit (Round-Trip-Delay) keine Übertragung
+
+##### Multiple Access (Mehrfachzugriff)
+- Mehrere Ethernet-Geräte haben gleichzeitig und konkurrierend Zugriff auf das gleiche Übertragungsmedium
+  - können senden, wenn es frei ist
+
+##### Collision Detection (Kollisionserkennung)
+- Während Übertragung weiterhin Medium abhören, um mögl. Kollision festzustellen
+  - wenn erkannt:
+    - spezielles Kollisionserkennungssignal, um alle Geräte im Netzwerk zu informieren
+- **NUR der Sender kann die Kollision NUR während des Sendevorgangs erkennen!**
+
+##### Jam Signal (Störsignal)
+- wenn Kollision erkannt:
+  - spezielles Störsignal, um alle Geräte im Netzwerk zu informieren
+
+##### Backoff-Algorithmus
+- **Verzögerung vor erneutem Versuch**
+  - alle Geräte warten eine zufällige Zeit vor erneutem Übertragungsversuch
+  - Wartezeit wird in Slot-Times berechnet
+    - typ. Slot-Time: `51,2 Mikrosekunden`
+- **Exponentieller Backoff**
+  - Wartezeit wird nach jeder Kollision erhöht, um Wahrscheinlichkeit weiterer Kollisionen zu verringern
+
+#### Ergänzung: Eine sendewillige Ethernetstation…
+![image_791.png](image_791.png)
+- hört Kanal vor Übertragung auf Senderaktivität ab 
+- beginnt frühestens 9,6μs nach Freiwerden des Kanals mit dem Senden
+  - Inter Frame Gap (IFG) 
+    - ermöglicht es anderen Ethernet-Stationen, das Senderecht zu erlangen
+      - verhindert Monopolisierung der Übertragung
+    - gibt Ethernet-Station, die gerade empfangen hat, Zeit, um in Empfangsmodus zurückzuschalten
+    - wird verwendet, um minimale Pause zu gewährleisten
+    - ermöglicht es Netzwerkgeräten, Zeit für die Verarbeitung der Frames und für die Erkennung von Kollisionen zu haben
+      - besonders wichtig in älteren Ethernet-Varianten (10BASE-T)
+- Überwacht den Kanal auch während des Sendens
+- Bricht Übertragung bei Entdeckung einer Kollision sofort ab
+  - und sendet Störsignal
+- Bleibt für die zufällige BEB-Zeit (Backoff) inaktiv
+  - Versucht Übertragung danach erneut, wenn Kanal laut CS frei ist
+
 ## Beispielaufgabe Klausur Broadcast-/Kollisionsdomänen
 - Netzwerkplan gegeben
 - Alle Broadcast- und Kollisionsdomänen einzeichnen

Writerside/topics/04/Rechnernetze/03_GrundlagenNetzwerke_Ethernet.md

@@ -0,0 +1,87 @@
+# Ethernet(IEEE 802.3) mit [CSMA/CD](02_HW-BausteineUndVerkabelung.md#csma-cd-protokoll)
+## Vollduplex vs Halbduplex
+![image_787.png](image_787.png)
+
+### Vollduplex
+- von einem Switch zu einem ausgewählten Host
+- von einem Switch zu einem anderen Switch
+- von einem Host zu einem anderen Host (über ein Crossover Kabel)
+
+
+## Ethernet Vergleich
+
+|                                         | Klassisches Ethernet                                                                                                         | Fast Ethernet                                                                                                                     | Gigabit-Ethernet                                                                                                                              |
+|-----------------------------------------|------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------|
+| Übertragungsgeschwindigkeit             | 10 Mbit/s                                                                                                                    | 100 Mbit/s                                                                                                                        | 1000 Mbit/s (1Gbit/s)                                                                                                                         |
+| Übertragungsmedium                      | Koaxialkabel, (später) Twisted-Pair, Glasfaser                                                                               | Twisted-Pair, Glasfaser                                                                                                           | Twisted-Pair(IEEE 802.3ab, längere Distanzen), Glasfaser (kurze Distanzen), 1000BASE-CX(sehr kurze Distanzen)                                 |
+| Topologie                               | Bus-Topologie (Koaxialkabel), Stern-Topologie (Geräte über Kabel mit zentralem Hub/Switch verbunden, heute Managed Switches) |                                                                                                                                   |                                                                                                                                               |
+| CSMA/CD                                 | wird genutzt                                                                                                                 | Unterstützung, Veränderungen: Notwendigkeit reduziert(Einführung Switches, Full-Duplex-Verbindungen)                              |                                                                                                                                               |
+| Adressierung und Rahmenstruktur (Frame) | MAC-Adressen (Identifizierung im LAN-Netzwerk)                                                                               |                                                                                                                                   |                                                                                                                                               |
+| Rahmenstruktur (Frame)                  | Präambel und StartFrame-Delimiter, Ziel-/Quelladressen, Typ-/Längenfeld, Nutzdaten, Prüfsumme                                |                                                                                                                                   | standardmäßiges Ethernet-Rahmenformat → Rückwärtskompatibilität                                                                               |
+| Codierung                               |                                                                                                                              |                                                                                                                                   | PAM5 (Pulse Amplitude Modulation mit 5 Levels) für Twisted-Pair                                                                               |
+| Maximale Kabellänge                     | ~100 Meter, wegen Signalabschwächung und Anforderungen von CSMA/CD                                                           |                                                                                                                                   |                                                                                                                                               |
+| Benutzerfreundlichkeit                  | Einfachheit in der Implementierung und Wartung                                                                               |                                                                                                                                   |                                                                                                                                               |
+| Übertragungsmodi                        |                                                                                                                              | Voll-Duplex (gleichzeitig, bidirektional, ohne Kollisionen), Halb-Duplex (mit CSMA/CD), Auto-Negotiation zwischen den beiden Modi | Full-Duplex (CSMA/CD überflüssig, wird meistens genutzt), Auto-Negotiation (ermöglicht beste verfügbare Geschwindigkeit, bester Duplex-Modus) |
+| Anwendungsbereiche                      |                                                                                                                              | Unternehmensnetzwerke (Backbone, Bereiche mit hohen Bandbreiten), Heimnetzwerke (verbreitet, aber wird durch Gigabit ersetzt)     | Unternehmens-/Heimnetzwerke/Serverfarmen (dort, wo hohe Übertragungsraten benötigt werden), Rechenzentren (Standard)                          |
+
+
+## Broadcast-Domänen verkleinern
+> Zur Verbesserung der Netzwerk-Performance und Erhöhung der Sicherheit
+
+### Einsatz von Virtual Local Area Networks (VLANs)
+- **Segmentierung des Netzwerks**
+  - VLANs ermöglichen Aufteilung in logische Netzwerke
+    - jedes VLAN bildet eine eigene Broadcast-Domäne
+    - Verkehrt wird innerhalb kleinerer Netzwerke gehalten → Begrenzung
+- **Verbesserte Sicherheit**
+  - Durch Trennung von Netzwerksegmenten
+  - Broadcasts werden nicht über gesamtes Netzwerk verbreitet
+- **VLAN tag**
+  - ![image_788.png](image_788.png)
+
+### Verwendung von Layer-3-Switches oder Routern
+- **Routing zwischen VLANs**
+  - können Datenverkehr zwischen VLANs steuern
+- **Kontrolle und Sicherheit**
+  - bieten zusätzliche Funktionen/Möglichkeiten
+    - _bspw. Zugangskontrolllisten (ACL)_
+
+### Einsatz von Subnetting auf der IP-Schicht
+- **Aufteilung in kleinere IP-Netzwerke**
+  - Jedes IP-Subnetz hat eigene Broadcast-Domäne
+    - reduziert Broadcast-Verkehr
+
+### Einsatz von Managed Switches
+- **Konfigurierbare L2-Switche**
+  - bieten erweiterte Funktionen an
+    - VLAN-Konfiguration, Port-Sicherheit, Zugriffskontrollen
+    - → Reduzierung von Broadcast-Domänen
+    - → Erhöhung der Netzwerksicherheit
+
+
+## QoS bei Ethernet-Netzwerken
+> nicht von Beginn an vorhanden
+> 
+> könnte Perfomance und Sicherheit erhöhen
+> 
+> → Für **Echtzeit-Anwendungen** wie VoIP und Streaming sollten spezielle QoS-Regeln erstellt werden 
+> um Latenz oder Paketverlust zu minimieren
+
+### Implementation QoS bei Ethernet-Netzwerken
+#### Einsatz von Managed Layer-2-Switches
+- **Erweiterte QoS-Funktionen**
+  - ermöglichen, Datenverkehr basierend auf verschiedenen Kriterien zu priorisieren
+    - _bspw. Portnummer, VLAN-ID, spezifische Anwendung_
+
+#### Priorisierung des Datenverkehrs durch 802.1Q Tagging
+- **802.1Q Tagging**
+  - Tagging von Ethernet-Frames mit einer Priorität
+  - wird von Routern und Switches genutzt um best. Datenverkehr zu bevorzugen
+
+#### [Einsatz von VLANs](#einsatz-von-virtual-local-area-networks-vlans)
+
+#### Einsatz von Layer-3-QoS-Konfigurationen mit DSCP
+- **Einsatz von DSCP auf IP-Schicht** (_Differentiated Services Code Point_) 
+  - Markierung von IP-Paketen mit spez. Prioritätsstufen
+    - Router, Switches können anhand der Markierungen priorisieren/verwalten
+

Writerside/topics/04/Software Engineering/01_ImplementingForMaintainability.md

@@ -35,21 +35,7 @@
 > Black-/White-Box-Testing sind Konzepte, die auf verschiedene Test-Typen angewendet werden können
 
 
-## Testing Quadrants Matrix
-![image_556.png](image_556.png)
-
-### Quadrant 1: Technologie-fokussierte Tests, die das Development leiten
-- Developer Tests:
-  - Unit tests
-    - Verifizieren Funktionalität eines kleinen Subsets des Systems
-    - Unit Tests sind die essenzielle Basis einer guten Test-Suite
-      - Verglichen mit anderen, sind sie einfach zu erstellen und warten
-      - Viele Unit-Tests :) 
-  - Component-/Integration Tests:
-    - Verifizieren Verhalten eines größeren Teils
-
-- Tests sind nicht für den Kunden
-
+## [](02_TestingForContinuousQuality.md)
 
 
 ## Goals of Testing during Implementation
@@ -616,4 +602,30 @@
   - P = Nummer der verbundenen Komponenten (für eine OO Funktion ist P = 1)
 - Beispiel:
   - $$C = 9-8+ (2*1) = 3$$
-- ![image_668.png](image_668.png)
+- ![image_668.png](image_668.png)
+
+
+## Übung Test Cases, Dependencies and more
+![image_778.png](image_778.png)
+![image_779.png](image_779.png)
+
+3. :
+   - BriefSystem - Controller
+   - BriefErstellung - Domain
+   - Empfaenger - trivialer Code
+   - EmpfaengerInterface - Domain Model
+   - EmpfaengerCsvLeser - trivialer Code
+   - Brief - trivialer Code
+
+
+4. : alle
+5. :
+  - wurdeEmpfängerHinzugefügt
+    - Empfänger über Interface hinzufügen
+    - Brief erstellen und schauen ob Empfänger hinzufügbar ist
+      - EmpfängerListe kann sonst nicht abgefragt werden
+
+6. :
+
+
+ 

Writerside/topics/04/Software Engineering/02_TestingForContinuousQuality.md

@@ -0,0 +1,182 @@
+# Testing for continuous Quality
+![image_556.png](image_556.png)
+
+## Quadrant 1: Technologie-fokussierte Tests, die das Development leiten
+- Developer Tests:
+    - Unit tests
+        - Verifizieren Funktionalität eines kleinen Subsets des Systems
+        - Unit Tests sind die essenzielle Basis einer guten Test-Suite
+            - Verglichen mit anderen, sind sie einfach zu erstellen und warten
+            - Viele Unit-Tests :)
+    - Component-/Integration Tests:
+        - Verifizieren Verhalten eines größeren Teils
+- Tests sind nicht für den Kunden
+- [**Implementierung**](01_ImplementingForMaintainability.md)
+
+## Quadrant 2: Business-fokussierte Tests, die das Development leiten
+- definiert Qualität/Features, die der Kunde möchte
+- Funktionale Tests, die von [User-Storys](RequirementsAnalysis.md#user-stories) abgeleitet werden
+    - bspw. _GUI-Tests, Integration-Tests_
+    - (_Mock-Up-Tests, Simulationen_) → wird nicht behandelt
+        - GUI-Designs mit User validieren, nicht automatisiert
+- Sollten zum Großteil automatisiert als Teil der CI/CD-Pipeline laufen
+  - am besten auf Production-Code
+- **Implementierung**
+  - Direkte Kommunikation zwischen Kunden/Developer
+  - TDD umsetzen
+    - Erst simplen Happy-Path-Test implementieren
+    - Dann Code
+    - Dann mehr Tests
+    - mehr Code
+  - Sobald ein Test ein erstes Mal erfolgreich ist, sollte er nicht mehr fehlschlagen
+    - Es sei denn: Anforderungen haben sich geändert
+
+### Q2: Service Testing
+- Production Code durch externe Schnittstellen testen
+  - bspw: _Extern sichtbare Interfaces(Klassen/Funktionen, aufgebaut nach Facade Pattern), API, Event-Gesteuerte Interfaces (Kafka, MQTT)_
+- Vorteile:
+  - weniger fragil als UI-Tests
+  - sehr günstig zu warten
+- Tests bieten eine "lebende Dokumentation", wie das System sich verhält
+
+#### Implementierung Service Tests
+- API-level Test-Frameworks unterstützen
+  - ![image_794.png](image_794.png)
+    - Test-Framework
+      - unterstützt restliche Teile bei Test-Definition und -Ausführung
+    - SystemUnderTest
+      - Zeigt auf die Komponente, die durch das Interface gezeigt wird
+    - Tests/Beispiele
+      - Test-Szenarien, technologie-unabhängig
+    - Test-Methode
+
+#### Beispiel Service Testing
+![image_793.png](image_793.png)
+- Tests adressieren Endpunkte der drei Komponenten
+- sollten alle automatisch ausgeführt werden
+
+- ![image_795.png](image_795.png)
+  - 2 Tests: 
+    - happy-path
+    - invalid username
+  - Input wird der Test-Methode `TestLogin` gegeben
+  - Dann weiter als Variable in den Production-Code
+  - Erwartetes Ergebnis wird mit dem tatsächlichen Ergebnis verglichen
+  - _Wie Daten hin und zurück kommen, müssen Tester und Coder besprechen_
+
+### Q2: User Interface Testing
+- Production-Code durch UI testen
+- Simulieren Nutzer-Verhalten
+  - ist dennoch möglich zu automatisieren
+
+#### Beispiel UI-Testing (mit Selenium)
+- Selenium ist ein Framework für automatisierte UI-Tests
+  - ![image_796.png](image_796.png)
+  - ![image_797.png](image_797.png)
+- Tests sind sehr fragil
+  - Vor allem, die Teile, bei denen Elemente auf der Webseite ausgewählt werden
+  
+
+## Quadrant 3: Business-fokussierte Tests, die das Projekt kritisieren/evaluieren
+- manchmal sind Anforderungen nicht gut genug, um gewünschtes Produkt zu designen
+    - Tests evaluieren, ob Software Erwartungen genügt
+        - Emulation von User-Interaktionen
+- Manuelles Testen, das nur ein Mensch ausführen kann
+- Typen:
+  - User Acceptance Testing (UAT)
+    - neue Features austesten lassen
+  - Usability Testing
+    - Fokus-Gruppen werden studiert und interviewt, während sie die Anwendung nutzen
+    - Wissen, wie die Nutzer Systeme nutzen, ist ein Vorteil, wenn man die Nutzbarkeit testet
+  - Exploratory testing
+    - Tester denken sich selbst neue Tests aus, die sie dann auch durchführen
+      - benötigt viel Kreativität und Intuition
+    - wird von einer Strategie geleitet und durch Guidelines eingegrenzt
+    
+
+## Quadrant 4: Technologie-fokussierte Tests, die das Projekt kritisieren/evaluieren
+- Tests, die Charakteristiken wie Performance, Robustheit, Sicherheit sicherstellen
+- Sollten in jedem Schritt des SDLC beachtet werden
+
+### Q4: Security Testing
+- Technologie fokussierte Tests von einem wichtigen, [nicht-funktionalen Aspekt](IntroductionOOAD.md#requirements-in-software-engineering)
+- Sicherheits-Bugs sind sehr kostenintensiv, wenn sie erst spät im SDLC gefunden werden
+- Security-Testing: Denken wie ein Hacker
+
+#### Tools und Techniken für Security Testing in verschiedenen Stages
+- Static Application Security Testing (SAST)
+  - _bspw. nicht-verschlüsselte Passwörter_ darstellen
+- Software Composition Analysis (SCA)
+  - Identifiziert Schwachstellen in 3rd-Party-Abhängigkeiten
+  - kann in CI/CD integriert werden
+- Image Scanning
+  - Scannt Container-Images
+  - kann in CI/CD integriert werden
+- Dynamic Application Security Testing (DAST)
+  - Analysiert, wie die Anwendung auf spezifisch angepasste Anfragen reagiert
+  - kann in CI/CD integriert werden
+    - brauchen teilweise länger in der Ausführung
+- Manual exploratory testing
+- Penetration (pen) -Testing
+  - beinhaltet einen professionellen Security-Tester
+  - sollte nah am Ende des Auslieferungs-Kreislaufs geschehen
+- Runtime Application Self Protection (RASP)
+  - Anwendung durchgängig auf mögliche Attacken beobachten und diese verhindern
+  - _bspw. durch automatische Beendung von Prozessen_
+
+### Q4: Performance Testing
+- **Performance** kann anhand **verschiedener Faktoren gemessen** werden
+  - Antwort-Zeit
+    - _WebApplikationen bspw. sollten max. 3 Sekunden für eine Antwort brauchen_
+  - Durchsatz/Parallelität
+    - Anzahl an Anfragen, die innerhalb einer Zeitspanne unterstützt werden können
+  - Verfügbarkeit
+- **Faktoren, die Performance beeinflussen**:
+  - Architektur-Design
+    - bspw. _Caching-Mechanismen_
+  - Wahl des Tech-Stacks
+    - Technologien sind unterschiedlich schnell
+  - Code-Komplexität
+  - Datenbank-Wahl und -Design
+  - Netzwerk-Latenz
+    - Alle Komponenten kommunizieren darüber
+    - Falls schlechtes Netz → langsame Anwendung
+  - Physischer Ort der Nutzer
+    - Distanz spielt eine Rolle
+  - Infrastruktur
+    - CPU, RAM, etc. 
+  - 3rd Party Integrationen
+    - Sind meistens außerhalb der Kontrolle
+    - Sollten auch anhand von Performance-Werten ausgewählt werden
+
+#### Typen von Performance Tests
+- Load/Volume Tests
+  - Verifizieren, dass das System den benötigten Durchsatz liefert
+  - werden meist mehrfach durchgeführt → Durchschnitt
+- Stress Tests
+  - Womit kommt die Anwendung noch klar?
+    - bspw. viele User
+  - Exakte Messungen werden benötigt, um die Infrastruktur anhand der Ergebnisse zu planen
+- Soak Tests
+  - Wird die Performance über Zeit schlechter?
+  - Hält die Anwendung durchgängig unter einem konstanten Workload
+
+
+## Testing Automation Pyramide
+![image_798.png](image_798.png)
+![image_799.png](image_799.png)
+
+- Unit Tests
+  - Verifizierung von einem kleinen Subset des Systems
+- Integration Tests
+  - Testen einer Gruppe von Klassen
+- Contract Tests
+  - API-Tests für Module, die gerade entwickelt werden
+- Service Tests
+  - API-Tests, die individuelle Module testen
+- UI-Tests
+  - Simulieren Nutzer-Verhalten für bestimmte Features
+- End-to-end-Tests
+  - Simulieren Nutzer-Verhalten für eine komplette Interaktion (inkl. externe Systeme)
+
+**Achtung: Nicht-Funktionale Tests werden hier nicht beachtet!**

Writerside/topics/04/Software Engineering/99_Praktikum1Vorbereitung.md

@@ -7,19 +7,19 @@ Docker is a platform designed to help developers build, share, and run applicati
 Kubernetes, also known as K8s, is an open-source system for automating deployment, scaling, and management of containerized applications. It groups containers that make up an application into logical units for easy management and discovery. Kubernetes is designed to scale without increasing your operations team, and it can run anywhere, giving you the freedom to take advantage of on-premises, hybrid, or public cloud infrastructure.
 ## FastAPI
 
-FastAPI is a modern, high-performance web framework for building APIs with Python 3.6+ based on standard Python type hints. It is designed to be easy to use, fast to code, and ready for production. FastAPI automatically generates interactive API documentation using Swagger UI and ReDoc, and it uses Pydantic for data validation and serialization. This framework is ideal for building robust and scalable applications quickly. ​
+FastAPI is a modern, high-performance web framework for building APIs with Python 3.6+ based on standard Python type hints. It is designed to be easy to use, fast to code, and ready for production. FastAPI automatically generates interactive API documentation using Swagger UI and ReDoc, and it uses Pydantic for data validation and serialization. This framework is ideal for building robust and scalable applications quickly. 
 Medium+1Docker Hub+1
 ## SQLAlchemy
 
 SQLAlchemy is the Python SQL toolkit and Object Relational Mapper (ORM) that gives application developers the full power and flexibility of SQL. It provides a full suite of well-known enterprise-level persistence patterns, designed for efficient and high-performing database access, adapted into a simple and Pythonic domain language. SQLAlchemy offers both a high-level ORM and a low-level Core for constructing SQL expressions and schema management.
 ## FastAPI with SQLAlchemy
 
-Combining FastAPI with SQLAlchemy allows developers to build high-performance APIs with robust database interactions. FastAPI's asynchronous capabilities can be leveraged alongside SQLAlchemy's ORM features to create efficient and scalable applications. This integration supports features like automatic data validation, serialization, and interactive API documentation, streamlining the development process. ​
+Combining FastAPI with SQLAlchemy allows developers to build high-performance APIs with robust database interactions. FastAPI's asynchronous capabilities can be leveraged alongside SQLAlchemy's ORM features to create efficient and scalable applications. This integration supports features like automatic data validation, serialization, and interactive API documentation, streamlining the development process. 
 Medium+1Docker Hub+1
 ## Alembic
 
-Alembic is a lightweight database migration tool for usage with the SQLAlchemy Database Toolkit for Python. It provides a system for managing database schema changes, allowing for version control of database structures. Alembic is particularly useful for applications that require continuous database evolution without losing data. It integrates seamlessly with SQLAlchemy, making it a preferred choice for managing migrations in Python applications. ​
+Alembic is a lightweight database migration tool for usage with the SQLAlchemy Database Toolkit for Python. It provides a system for managing database schema changes, allowing for version control of database structures. Alembic is particularly useful for applications that require continuous database evolution without losing data. It integrates seamlessly with SQLAlchemy, making it a preferred choice for managing migrations in Python applications.
 testdriven.io
 ## Swagger UI
 
-Swagger UI is a tool that automatically generates interactive API documentation from OpenAPI specifications. It allows developers and users to visualize and interact with the API's resources without having any of the implementation logic in place. Swagger UI is automatically integrated with FastAPI, providing a user-friendly interface to test and understand API endpoints. This enhances the developer experience and facilitates easier API consumption. ​
+Swagger UI is a tool that automatically generates interactive API documentation from OpenAPI specifications. It allows developers and users to visualize and interact with the API's resources without having any of the implementation logic in place. Swagger UI is automatically integrated with FastAPI, providing a user-friendly interface to test and understand API endpoints. This enhances the developer experience and facilitates easier API consumption. 

Writerside/topics/04/Theoretische Informatik/04_GrenzenGroesseEA.md

@@ -0,0 +1,78 @@
+# Grenzen & Größen endlicher Automaten
+## Nerode-Index einer Sprache
+- Sei $L=\{w ∈ \{x,y,z\}^*\}\space | \space \#_z(w) ∈ \{2,3\}\}$
+- betrachte die Wörter aus $\{x, y, z\}^*$
+  - Gruppiere sie hinsichtlich des "Grad der Zugehörigkeit" zu $L$
+    - ![image_780.png](image_780.png)
+- Beobachtung:
+  - zwei Worte $u ∈ L$ und $v \not\in L$ sind sicherlich nicht sehr ähnlich
+  - zwei Worte $u,v ∈ L$ _können_ ähnlich sein 
+    - ähnlich: $zz$ und $yzxxzy$
+    - nicht ähnlich: $zz$ und $zzz$
+  - zwei Worte $u,v \not\in L$ _können_ ähnlich sein
+    - ähnlich: $ ε$ und $xxy$
+    - nicht ähnlich: $ ε$ und $yzxxxy$
+
+- **$u,v ∈ Σ^*$ sind ähnlich bezüglich $L$, wenn:**
+  - durch anhängigen des gleichen, beliebigen Wortes
+    - in beiden Fällen ein Wort aus $L$ entsteht
+    - in beiden Fällen ein Wort aus $Σ \backslash L$ entsteht
+
+### Rechtsäquivalenz
+- gegebene Sprache $L$ über Alphabet Σ
+- $u,v ∈ Σ^*$ heißen rechtsäquivalent bezüglich L, wenn
+  - $∀s ∈ Σ^*: u*s ∈ L ↔ v*s ∈ L$
+- wir schreiben auch: $(u,v) ∈ R_L$ oder $u \space R_L \space v$
+
+### Nerode-Klassen und -Index
+- gegebene Sprache $L$ über Alphabet Σ und Wort $u ∈ Σ^*$
+- **Nerode-Klasse $N(u)$**: Menge der zu $u$ rechtsäquivalenten Wörter:
+  - $N(u) := \{v ∈ Σ^* \space | \space (u,v) ∈ R_L\}$
+- **Nerode-Index** von L: Anzahl Nerode-Klassen
+
+### Beispiel
+- ist $v ∈ N(u)$ so gilt $N(v)=N(u)$
+- beliebiges $u ∈ N$ heißt _Repräsentant_ der Nerode-Klasse $N$
+
+- Wie lauten die Nerode-Klassen von der Sprache $L_1 = \{w ∈ \{x,y,z\}^* \space | \space \#_Z(w) ∈ \{2,3\}\}$?
+  - ![image_781.png](image_781.png)
+- Wie viele Nerode-Klassen hat $L_2=\{0^n*1^n \space | \space n ∈ N_0\}$
+  - ∞
+  - bspw. $N_i=N(0^i)$ für $i ∈ N_0$
+
+## Eigenschaften von Nerode-Klassen
+### Nützliche Eigenschaften
+#### Alles-oder-nichts
+> Sei $L$ eine Sprache und $N$ eine Nerode Klasse von $L$.
+> Dann gilt entweder $N ⊆ L$ oder $N \not ⊆ L := Σ^* \backslash L$
+
+**Beweis:**
+- wähle beliebiges, festes $u ∈ N$
+- für jedes $v ∈ N$ gilt: $u$ und $v$ sind rechtsäquivalent
+- insbesondere: $u = u * ε ∈ L ↔ v * ε = v ∈ L$
+- also entweder sind _alle_ solche Wörter $v$ aus $L$ (wenn $u ∈ L$)
+- oder es sind alle solche Wörter $v$ nicht aus $L$ (wenn $u \not ∈ L$)
+
+#### Mitgegangen-Mitgefangen
+> Sei $L$ eine Sprache und $u,v ∈ Σ^*$ Wörter aus der gleichen Nerode-Klasse. 
+> Dann gilt für alle $s ∈ Σ^*$: $N(u*s)=N(v*s)$
+
+**Beweis:**
+- zu zeigen: $(u*s, v*s) ∈ R_{L(A)}$ 
+  - d.h. $u*s$ und $v*s$ sind [rechtsäquivalent](#rechts-quivalenz)
+- sei dazu $w ∈ Σ^*$ beliebig, dann gilt:
+  - ![image_782.png](image_782.png)
+
+
+#### Gemeinsame Reise
+> Sei $A = (Σ, Q, q_s, Q_A, δ)$ ein DEA.
+> Betrachte zwei Worte $u,v ∈ Σ^*$ die $A$ in den gleichen Zustand überführen.
+> Dann sind $u$ und $v$ rechtsäquivalent bzgl. $L(A)$
+
+![image_783.png](image_783.png)
+
+
+
+## Der Satz von Myhill-Nerode
+## Reaping the Fruits!
+## Minimierungsalgorithmus

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

@@ -1,4 +1,6 @@
 # Übungsblatt 2
+> Wenzel Schwan (1125033), Paul Kneidl (1125219), David Schirrmeister (1125746), Michelle Klein (1126422)
+
 ## Übung 1
 Betrachten Sie den Automaten A aus Abbildung 1:
 ![image_766.png](image_766.png)
@@ -16,7 +18,7 @@ Betrachten Sie den Automaten A aus Abbildung 1:
       | a       | b      |        |
       | b       | c      | b      |
       | c       | d      | b      |
-      | d       | d      | b      |
+      | d       |        | b      |
 
 ### (b) Beschreiben Sie wie der Automat die Eingabe $xyyxyx$ verarbeitet.
 1. Start in Zustand $a$
@@ -36,9 +38,9 @@ Betrachten Sie den Automaten A aus Abbildung 1:
 
 ### (c) Nennen Sie zwei verschiedene kürzeste Wörter, die von A akzeptiert werden und die jeweils jeden Übergang (Kante) aus Abbildung 1 mindestens einmal benutzen.
 
-$w_1 ∈ Σ^* := xyxyxxyxxx$
+$w_1 ∈ Σ^* := xyxxyxyxx$
 
-$w_2 ∈ Σ^* := xxyyxxyxxx$
+$w_2 ∈ Σ^* := xxyxxyyxx$
 
 ### (d) Beschreiben Sie die von A akzeptierte Sprache sowohl informal (in Worten) als auch formal (als Teilmenge von $\{x,y\}^*$). 
 #### Informal:
@@ -51,6 +53,8 @@ $L_A:= \{w \space | \space w = x*a*xx, a ∈ \{x,y\}^*\}$
 
 ```plantuml
 @startuml
+scale 0.5
+
 left to right direction
 skinparam dpi 150
 
@@ -83,8 +87,12 @@ Betrachten Sie die Sprache $ L = \{s ∈ Σ^* \space | \space s \space hat \spac
 über dem Alphabet $ Σ=\{0,1,...,9\}$.
 
 ### (a) Beschreiben Sie einen vollständigen endlichen Automaten in Graphdarstellung der die Sprache L akzeptiert.
+> Annahme, dass das Wort `423` von L nicht akzeptiert wird, da `42` der Präfix ist und das Wort gleichzeitig auf `23` endet.
+
 ```plantuml
 @startuml
+scale 0.5
+
 left to right direction
 skinparam dpi 150
 
@@ -108,7 +116,8 @@ f --> f : {0,...,9}
 b --> d: {2}
 c --> c : {0,...,9}\{2}
 c --> d : {2}
-d --> c : {0,...,9}\{3}
+d --> c : {0,...,9}\{2,3}
+d --> d : {2}
 d --> e : {3}
 e --> c : {0,...,9}\{2}
 e --> d : {2}
@@ -116,9 +125,9 @@ e --> d : {2}
 ```
 
 ### (b) Beschreiben Sie einen vollständigen endlichen Automaten in Graphdarstellung der genau die nicht-leeren Zeichenketten über dem Alphabet $Σ$ akzeptiert, die keine Wörter der Sprache L sind.
-
 ```plantuml
 @startuml
+scale 0.5
 left to right direction
 skinparam dpi 150
 
@@ -143,20 +152,24 @@ f --> f : {0,...,9}
 b --> d: {2}
 c --> c : {0,...,9}\{2}
 c --> d : {2}
-d --> c : {0,...,9}\{3}
+d --> c : {0,...,9}\{2,3}
+d --> d : {2}
 d --> e : {3}
 e --> c : {0,...,9}\{2}
 e --> d : {2}
 @enduml
 ```
 
+
+
+
 ## Übung 3
 Beschreiben Sie für jede der nachfolgend definierten Sprachen jeweils einen endlichen
 deterministischen Automaten, der die Sprache akzeptiert. Geben Sie die Automaten
 dabei sowohl in der formalen Tupel- als auch in der Graphdarstellung an. Begründen1
 Sie jeweils die Korrektheit Ihrer Konstruktion.
 
-### (a) Die Sprache $L1$ aller geraden natürlichen Zahlen in Dezimaldarstellung ohne führende Null (d. h. $\{ 0, 2, 8, 42 \} ⊆ L1$ aber $\{ 02, 23 \} ∩ L1 = ∅$). 
+### (a) Die Sprache $L1$ aller geraden natürlichen Zahlen in Dezimaldarstellung ohne führende Null  (d.h. $\{0, 2, 8, 42 \} ⊆ L1$, aber $\{02, 23 \} ∩ L1 = ∅$). 
 #### Tupeldarstellung (a)
 - $A=(Σ,Q,q_s,Q_a, δ)$
     - $Σ = \{0,...,9\}$
@@ -164,14 +177,14 @@ Sie jeweils die Korrektheit Ihrer Konstruktion.
     - $q_s = \{a\}$
     - $Q_a = \{b,d\}$
     - $δ:$
-- | Zustand | δ(.,0) | δ(.,1) | δ(.,2) | δ(.,3) | δ(.,4) | δ(.,5) | δ(.,6) | δ(.,7) | δ(.,8) | δ(.,9) |
-  |---------|--------|--------|--------|--------|--------|--------|--------|--------|--------|--------|
-  | a       | b      | e      | d      | e      | d      | e      | d      | e      | d      | e      |
-  | **b**   | c      | c      | c      | c      | c      | c      | c      | c      | c      | c      |
-  | c       | c      | c      | c      | c      | c      | c      | c      | c      | c      | c      |
-  | **d**   | d      | e      | d      | e      | d      | e      | d      | e      | d      | e      |
-  | e       | d      | e      | d      | e      | d      | e      | d      | e      | d      | e      |
 
+| Zustand | δ(.,0) | δ(.,1) | δ(.,2) | δ(.,3) | δ(.,4) | δ(.,5) | δ(.,6) | δ(.,7) | δ(.,8) | δ(.,9) |
+|---------|--------|--------|--------|--------|--------|--------|--------|--------|--------|--------|
+| a       | b      | e      | d      | e      | d      | e      | d      | e      | d      | e      |
+| **b**   | c      | c      | c      | c      | c      | c      | c      | c      | c      | c      |
+| c       | c      | c      | c      | c      | c      | c      | c      | c      | c      | c      |
+| **d**   | d      | e      | d      | e      | d      | e      | d      | e      | d      | e      |
+| e       | d      | e      | d      | e      | d      | e      | d      | e      | d      | e      |
 
 
 
@@ -179,6 +192,8 @@ Sie jeweils die Korrektheit Ihrer Konstruktion.
 #### Graphdarstellung (a)
 ```plantuml
 @startuml
+scale 0.5
+
 left to right direction
 skinparam dpi 150
 
@@ -216,26 +231,26 @@ e --> e : {1,3,5,7,9}
 ### (b) Die Sprache $L2 = \{ w ∈ \{ 0, 7 \}^* \space|\space w\space enthält\space 007\space genau\space einmal\space als\space Teilwort \}$.
 #### Tupeldarstellung (b)
 - $A=(Σ,Q,q_s,Q_a, δ)$
-    - $Σ = \{0,...,9\}$
+    - $Σ = \{0,7\}$
     - $Q = \{a,b,c,d,e,f,g\}$
     - $q_s = \{a\}$
-    - $Q_a = \{d\}$
+    - $Q_a = \{d,e,f\}$
     - $δ:$
-      - | Zustand | δ(.,0) | δ(.,1) | δ(.,2) | δ(.,3) | δ(.,4) | δ(.,5) | δ(.,6) | δ(.,7) | δ(.,8) | δ(.,9) |
-        |---------|--------|--------|--------|--------|--------|--------|--------|--------|--------|--------|
-        | a       | b      | a      | a      | a      | a      | a      | a      | a      | a      | a      |
-        | b       | c      | a      | a      | a      | a      | a      | a      | a      | a      | a      |
-        | c       | a      | a      | a      | a      | a      | a      | a      | d      | a      | a      |
-        | **d**   | d      | d      | d      | d      | d      | d      | d      | e      | d      | d      |
-        | e       | d      | d      | d      | d      | d      | d      | d      | f      | d      | d      |
-        | f       | d      | d      | d      | d      | d      | d      | d      | g      | d      | d      |
-        | g       | g      | g      | g      | g      | g      | g      | g      | g      | g      | g      |
-
+        - | Zustand | δ(.,0) | δ(.,7) |
+          |---------|--------|--------|
+          | a       | b      | a      |
+          | b       | c      | a      |
+          | c       | d      | c      |
+          | **d**   | e      | d      |
+          | **e**   | f      | d      |
+          | **f**   | g      | f      |
+          | g       | g      | g      |
 
 
 #### Graphdarstellung (b)
 ```plantuml
 @startuml
+scale 0.5
 skinparam dpi 150
 
 skinparam state {
@@ -248,23 +263,25 @@ skinparam state {
 }
 
 state d##[bold]
+state e##[bold]
+state f##[bold]
 
 
 [*] -right-> a
 a -right-> b : {0}
 b -right-> c : {0}
-c -right-> d : {7}
+c --> d : {7}
 d -right-> e : {0}
 e -right-> f : {0}
-f -right-> g : {7}
+f --> g : {7}
 
-b --> a : {0,...,9}\{0}
-a --> a : {0,...,9}\{0}
-c --> a : {0,...,9}\{7}
-d --> d : {0,...,9}\{0}
-e --> d : {0,...,9}\{0}
-f --> d : {0,...,9}\{7}
-g --> g : {0,...,9}
+b --> a : {7}
+a --> a : {7}
+c --> c : {0}
+d --> d : {7}
+e --> d : {7}
+f --> f : {0}
+g --> g : {0,7}
 @enduml
 ```
 
@@ -289,8 +306,10 @@ g --> g : {0,...,9}
       | q2      | q0     | q1     |
 
 #### Graphdarstellung (c)
+
 ```plantuml
 @startuml
+scale 0.5
 left to right direction
 skinparam dpi 150
 
@@ -318,4 +337,40 @@ q2 --> q1 : b
 
 #### Begründung (c)
 - q0 wird genau dann erreicht, wenn $\#_a ≡ \#_b mod 3$
-- Übergänge sind konsistent
+- Übergänge sind konsistent
+
+## Übung 4
+Betrachten Sie die Sprache $L = \{ w ∈ \{ 0, 1 \}^* \space|\space \#_1(w) = 3 \}$. Beschreiben Sie einen
+Automaten in der Graphdarstellung, der die Sprache $L$ akzeptiert, und beweisen Sie die
+Korrektheit Ihrer Konstruktion.
+
+```plantuml
+@startuml
+scale 0.5
+left to right direction
+skinparam dpi 150
+
+skinparam state {
+    BackgroundColor #FFFACD
+    BorderColor black
+    FontName Helvetica
+    RoundCorner 30
+    Shadowing false
+    LineThickness 0
+} 
+
+state q3##[bold]
+
+
+[*] --> q0
+q0 --> q1 : 1
+q0 --> q0 : 0
+q1 --> q2 : 1
+q1 --> q1 : 0
+q2 --> q3 : 1
+q2 --> q2 : 0
+q3 --> q3 : 0
+q3 --> q4 : 1
+q4 --> q4 : 0,1
+@enduml
+```

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

@@ -0,0 +1,434 @@
+# Ü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 --> A1 : ε
+S --> A2 : ε
+
+' --- Automat A1 ---
+state "A" as A1 {
+  [*] --> a0
+  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 ---
+state "B" as A2 {
+  [*] --> b0
+  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
+
+```