diff --git a/formulas/Block 2.md b/formulas/Block 2.md
new file mode 100644
index 0000000..50a92d5
--- /dev/null
+++ b/formulas/Block 2.md	
@@ -0,0 +1,22 @@
+Kleinere Aufgaben zur Programmierung mit Numpy und Pandas; Zuordnungen, Wahr/Falsch,
+Codeanpassungen.
+
+Data-Wrangling: Importieren, Bereinigen und Transformieren von Daten am Beispiel von Phyton, Plots
+
+Vertiefung Numpy und Pandas Beispielanwendungen: Umgang mit realistischen Datensätzen, Zeitreihen, Ausblick MLVerfahren
+
+Arten und Anwendungsbereiche verschiedener NoSQLDatenbanken, CAP-Theorem, Skalierung von NoSQLDatenbanken, Sharding, Übungen
+
+## CAP-Theorem
+- • **Konsistenz (Consistency):** Alle Knoten zeigen zur gleichen Zeit die gleichen Daten an.
+- **Verfügbarkeit (Availability):** Jeder Anfrage wird garantiert eine Antwort geliefert – auch wenn sie nicht den aktuellsten Stand widerspiegelt.
+- **Partitionstoleranz (Partition Tolerance):** Das System funktioniert weiter, auch wenn Teile des Netzwerks ausfallen oder nicht miteinander kommunizieren können.
+- **CA (Konsistenz + Verfügbarkeit):**  
+    Funktioniert nur ohne Netzwerkausfall.  
+    Beispiel: Einzelner MySQL-Server.
+- **CP (Konsistenz + Partitionstoleranz):**  
+    Bleibt bei Ausfall konsistent, aber nicht immer erreichbar.  
+    Beispiel: HBase, MongoDB (strikte Konsistenz).
+- **AP (Verfügbarkeit + Partitionstoleranz):**  
+    Immer erreichbar, aber Daten können kurz inkonsistent sein.  
+    Beispiel: Cassandra, DynamoDB.
\ No newline at end of file
diff --git a/formulas/Block 3.md b/formulas/Block 3.md
new file mode 100644
index 0000000..712efd7
--- /dev/null
+++ b/formulas/Block 3.md	
@@ -0,0 +1,133 @@
+## Reguläre Ausdrücke (Regex)
+
+Regex sind Suchmuster für Text. Ein Zeichen steht für sich selbst, außer Sonderzeichen (`*+?{}[]\|()`), die mit einem Backslash `\` "escaped" werden müssen. Wichtige Platzhalter sind `.` für ein beliebiges Zeichen, `\d` für eine Ziffer, `\w` für ein alphanumerisches Zeichen und `\s` für Leerraum (Whitespace); die jeweiligen Großbuchstaben wie `\D` negieren die Auswahl. Eine Zeichenauswahl erfolgt mit `[...]`, auch als Bereich `[a-z]` oder als Negation `[^a-z]`. Wiederholungen steuern `*` (0 oder mehr), `+` (1 oder mehr), `?` (optional) und `{n,m}` (genaue Anzahl); ein angehängtes `?` (z.B. `*?`) macht die Suche "non-greedy". Runde Klammern `()` fassen Ausdrücke zu Gruppen zusammen, `|` trennt Alternativen. Die Position wird mit `^` (Anfang) und `$` (Ende) einer Zeile oder `\b` (Wortgrenze) verankert.
+
+### Detaillierte Regex-Beispiele
+
+| Syntax | Beschreibung | Beispiel |
+| :--- | :--- | :--- |
+| **Platzhalter** | | |
+| `.` | Jedes beliebige Zeichen (außer Zeilenwechsel) | `a.c` |
+| `\d` | Dezimalziffer (`[0-9]`) | `\d{3}` |
+| `\D` | Jedes Zeichen außer einer Ziffer | `\D+` |
+| `\w` | Jedes alphanumerische Zeichen (`[A-Za-z0-9_]`) | `\w+` |
+| `\W` | Jedes nicht-alphanumerische Zeichen | `\W` |
+| `\s` | Jede Art von Leerzeichen (Whitespace) | `hello\sworld` |
+| `\S` | Jedes Zeichen außer Whitespace | `\S+` |
+| **Zeichenauswahl** | | |
+| `[abc]` | Genau eines der Zeichen a, b oder c | `gr[ae]y` |
+| `[^abc]` | Jedes Zeichen außer a, b oder c | `[^0-9]` |
+| `[a-z]` | Ein Zeichen im Bereich von a bis z | `[A-Z]` |
+| **Wiederholungen** | | |
+| `*` | 0 oder mehr Wiederholungen | `\d*` |
+| `+` | 1 oder mehr Wiederholungen | `\w+` |
+| `?` | 0 oder 1 Wiederholung (optional) | `colou?r` |
+| `{n}` | Genau n Wiederholungen | `\d{4}` |
+| `{n,}` | Mindestens n Wiederholungen | `\d{2,}` |
+| `{n,m}` | Zwischen n und m Wiederholungen | `\d{2,4}` |
+| **Gruppen & Alternativen** | | |
+| `(...)` | Gruppiert Ausdrücke und fängt das Ergebnis | `(https?://)` |
+| `(?P<N>...)`| Benannte Gruppe | `(?P<year>\d{4})` |
+| `\|` | Logisches ODER | `GET\|POST` |
+| `\1`, `\2` | Rückverweis auf Gruppe 1, 2 etc. | `(\w+)\s\1` |
+| **Position (Anchors)** | | |
+| `^` | Anfang der Zeile | `^From:` |
+| `$` | Ende der Zeile | `11$` |
+| `\A` | Anfang der gesamten Zeichenkette | `\A-----BEGIN` |
+| `\Z` | Ende der gesamten Zeichenkette | `\n\Z` |
+| `\b` | Wortgrenze | `\bWort\b` |
+| `\B` | Keine Wortgrenze | `\B-\B` |
+
+## XPath & JSONPath
+XPath navigiert durch XML-Dokumente mit `/` (direktes Kind), `//` (beliebiger Nachfahre), `.` (aktueller Knoten) und `..` (Elternknoten). Filter (Prädikate) in eckigen Klammern `[]` wählen nach Position `[1]`, Attribut `[@type="x"]` oder Inhalt `[tag="wert"]` aus. Werte liest man mit `@attribut` oder der Funktion `text()` aus. JSONPath fragt JSON-Daten ab, beginnend beim Wurzelelement `$`. Auf Kindelemente wird mit `.` oder `['name']` zugegriffen. `..` sucht auf allen Ebenen (rekursiv) und `[*]` wählt alle Array-Elemente. Mit `[?(@...)]` werden Filter angewendet, wobei `@` das aktuelle Element ist.
+### Detaillierte XPath-Beispiele
+
+| Syntax | Beschreibung | Beispiel |
+| :--- | :--- | :--- |
+| `tag` | Wählt alle Knoten mit diesem Tagnamen | `lecturer` |
+| `*` | Wählt alle Kindknoten aus | `lecturer/*` |
+| `//tag` | Wählt passende Nachfahrenknoten auf allen Tiefen | `//name` |
+| `.` / `..` | Aktueller Knoten / Elternknoten | `//name/..` |
+| `[n]` | Wählt den n-ten Knoten (Zählung startet bei 1) | `lecturer[1]` |
+| `[@attrib]` | Wählt Knoten, wo das Attribut gesetzt ist | `lecturer[@type]` |
+| `[@a="v"]` | Wählt Knoten, wo Attribut `a` den Wert `v` hat | `lecturer[@type="external"]` |
+| `[tag]` | Wählt Knoten, die einen Kindknoten `tag` haben | `lecturer[name]` |
+| `[t="v"]` | Wählt Knoten mit Kindknoten `t` mit Inhalt `v` | `lecturer[email="a@b.ch"]` |
+| `@attrib` | Gibt den Wert des Attributs aus | `./lecturer/@type` |
+| `text()` | Gibt den Text des Knotens aus | `./lecturer/name/text()` |
+| `count()` | Gibt die Anzahl der Knoten aus | `count(./lecturer)` |
+| `sum()` | Bildet die Summe der Knoten (müssen Zahlen sein) | `sum(./lecturer/units)` |
+
+### Detaillierte JSONPath-Beispiele
+
+| Syntax | Beschreibung | Beispiel |
+| :--- | :--- | :--- |
+| `$` | Das Wurzelobjekt | `$` |
+| `.prop` | Kindobjekt mit dem Namen `prop` | `$.movies` |
+| `['prop']` | Alternative zum Punkt | `$['movies']` |
+| `..prop` | Nachfahren auf allen Ebenen (rekursiv) | `$..year` |
+| `[n]` | n-tes Objekt in einem Array (Zählung startet bei 0) | `$.movies[0]` |
+| `[*]` | Alle Einträge eines Objekts oder Arrays | `$.movies[*]` |
+| `[n:m]` | Bereich eines Arrays (Slice) | `$.movies[3:5]` |
+| `[?(filter)]` | Filtert Elemente basierend auf einem Ausdruck | `$.movies[?(@.year > 1995)]` |
+| `@` | Das aktuelle Element in einem Filter | `[?(@.title =~ 'Kill.*')]` |
+
+## HTTP-APIs & Web Crawling
+
+HTTP-APIs nutzen URLs, die aus Schema, Host, Pfad und optionalen Query-Parametern (`?key=val`) bestehen, um Daten via REST-Prinzipien auszutauschen (Methoden: GET, POST, PUT, DELETE). Authentifizierung erfolgt oft über API-Keys. Web Scraping extrahiert Daten aus dem HTML von Webseiten. Die Auswahl der Daten erfolgt mit CSS-Selektoren. Web Crawling folgt Hyperlinks, um weitere Seiten zu verarbeiten. Dabei sollte man die `robots.txt` respektieren. Die `sitemap.xml` kann helfen, alle Unterseiten zu finden.
+
+### Detaillierte CSS-Selektor-Beispiele
+
+| Syntax | Beschreibung | Beispiel |
+| :--- | :--- | :--- |
+| `*` | Wählt alle Elemente aus | `*` |
+| `tag` | Wählt alle Elemente mit diesem Tagnamen | `h1` |
+| `.class` | Wählt Elemente mit dieser Klasse | `.intro` |
+| `#id` | Wählt das Element mit dieser ID | `#register` |
+| `[attr=val]` | Wählt Elemente, deren Attribut `attr` den Wert `val` hat | `[type="text"]` |
+| `:first-child` | Wählt das erste Kind seines Elternelements | `p:first-child` |
+| `:nth-child(n)`| Wählt das n-te Kind (auch `2n`, `odd`, `even`) | `tr:nth-child(odd)` |
+| `A B` | Wählt alle B, die Nachfahren von A sind (Descendant) | `div p` |
+| `A > B` | Wählt alle B, die direkte Kinder von A sind (Child) | `ul > li` |
+| `A + B` | Wählt B, das direkt auf A auf derselben Ebene folgt | `h1 + p` |
+| `A ~ B` | Wählt alle B, die auf A auf derselben Ebene folgen | `h1 ~ p` |
+
+---
+
+## Komplexe Anwendungsbeispiele
+
+### Regex-Vorlage
+```python
+^(?P<timestamp>\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2})\s\[(?P<level>INFO|WARN|ERROR)\]\s\(user:\s'(?P<user>[\w\.-]+@[\w\.-]+)'\)\s"(?P<message>.*?)"$
+```
+
+
+### XPath-Vorlage
+```python
+//course[@id='cds104']/lecturer[@type='external' and units > 5]/name/text()
+```
+
+### JSONPath-Vorlage
+```python
+$.movies[?(@.year > 1999 && @.title =~ /^Matrix.*/)].actors[*].name
+```
+
+### CSS-Selector-Vorlage (für Web Scraping)
+
+```css
+main#content article.published:not(.featured) h2 + div.meta a[href*="author"]
+```
+
+
+## GRAPHQL
+```python
+{
+  table1 {
+    property1
+    property2
+    othertable {
+      prop_from_other_table
+    }
+  }
+}
+```
diff --git a/formulas/Block1.md b/formulas/Block1.md
new file mode 100644
index 0000000..727e376
--- /dev/null
+++ b/formulas/Block1.md
@@ -0,0 +1,140 @@
+
+## ER Modell
+>**Chen** Notation: 
+>- Rechteck = Entity; Beziehung = Diamant; Kardinalität = {0, 1, N, M, 0..1} über der Verbindungslinie; Entities = Ovale (Unterstrichen = Primary-Key; )
+
+- **How Foreign Keys Appear in Chen Notation** 
+- **Entities** are drawn as rectangles.
+- **Relationships** are drawn as diamonds.
+- **Attributes** are ovals connected to their entity or relationship.
+- **Primary keys** are underlined in the entity’s attribute list.
+- **Foreign keys** are not shown as a separate symbol. Instead, they are implied by the relationship between entities.
+
+## SQL
+```plsql
+INSERT INTO a VALUES (1, 'A'), (2, 'B'), (3, 'C'), (40, 'D'), (50, 'E');
+CREATE TABLE a ( id INTEGER PRIMARY KEY, comment CHARACTER VARYING NOT NULL );
+```
+
+
+```plsql
+-- [Operators]
+-- Comparison: =, <>, !=, <, >, <=, >=
+-- Arithmetic: +, -, *, /, %, ^
+-- Logical: AND, OR, NOT
+-- Pattern Matching: LIKE, ILIKE, SIMILAR TO
+-- Regular Expressions: ~ (case-sensitive), ~* (case-insensitive), !~ (not match), !~* (not match)
+-- Range: <@ (contains), @> (is contained by), && (overlaps)
+-- JSON/JSONB: ->, ->>, #>, #>>
+-- Arrays: @>, <@, &&, ||
+
+-- [Date/Time Literals and Functions]
+-- Date literals: 'YYYY-MM-DD', 'YYYY-MM-DD HH:MI:SS'
+-- Typed literals: DATE 'YYYY-MM-DD', TIMESTAMP 'YYYY-MM-DD HH:MI:SS'
+-- to_date('DD.MM.YYYY', 'DD.MM.YYYY')
+-- INTERVAL '1 day', '2 hours'
+-- NOW(), CURRENT_DATE, CURRENT_TIMESTAMP, EXTRACT(field FROM source), AGE(source, reference)
+
+-- [Aggregate Functions]
+-- COUNT(expr), SUM(expr), AVG(expr), MIN(expr), MAX(expr)
+-- STDDEV(expr), VARIANCE(expr)
+-- STRING_AGG(expr, delimiter), ARRAY_AGG(expr), JSON_AGG(expr)
+-- BOOL_AND(expr), BOOL_OR(expr), EVERY(expr)
+
+
+-- 1. Haupt-Query
+SELECT
+  -- OPTIONAL: UNIQUE / DISTINCT / DISTINCT ON
+  /* DISTINCT */                  -- Einmalige Werte
+  /* DISTINCT ON (spalte1, spalte2) */
+
+  t.spalte1,                       -- einfache Spalte
+  t.spalte2 AS alias2,             -- aliasierte Spalte
+
+FROM 
+  schema.tabelle1 AS t
+  -- OPTIONAL: Tabelle sampeln
+  /* TABLESAMPLE SYSTEM (10) */
+
+  -- Verschiedene JOIN-Typen
+  INNER JOIN schema.tabelle2 AS t2
+    ON t.fk = t2.id               -- INNER JOIN
+  LEFT OUTER JOIN schema.tabelle3 AS t3
+    USING (gemeinsame_spalte)     -- USING
+  RIGHT JOIN schema.tabelle4 AS t4
+  NATURAL LEFT JOIN schema.tabelle5 AS t5
+  CROSS JOIN schema.tabelle6       -- CROSS JOIN
+  FULL JOIN LATERAL (
+    SELECT ...
+  ) AS sub ON true
+
+-- 2. Filter
+WHERE
+    t.spalte1 = 'Wert'            -- Gleichheit
+  AND t.spalte2 LIKE '%muster%'   -- Pattern-Matching
+  AND t.spalte3 IN (1,2,3)        -- IN-Liste
+  AND t.spalte4 BETWEEN 10 AND 20 -- Bereich
+  AND (t.spalte5 IS NULL OR t.spalte6 IS NOT NULL)
+  AND t.datum >= DATE '2025-01-01'
+  AND t.beschreibung ~* 'regex'   -- Regex-Operator (case-insensitive)
+
+-- 3. Gruppierung für Aggregate
+GROUP BY
+  t.spalte1,
+  t.spalte2
+
+-- 4. Filter auf Gruppenebene
+HAVING
+  COUNT(*) > 1
+
+-- 6. Kombinieren mehrerer Queries
+/* UNION [ALL] SELECT ... */
+/* INTERSECT [ALL] SELECT ... */
+/* EXCEPT [ALL] SELECT ... */
+
+-- 7. Sortierung
+ORDER BY
+  t.spalte1 DESC,                -- auf- oder absteigend
+  alias2 ASC
+-- OPTIONAL: NULLS FIRST/LAST
+/* t.spalte2 NULLS LAST */
+
+-- 8. Paging
+LIMIT 10
+OFFSET 20
+/* FETCH FIRST 10 ROWS ONLY */
+;
+
+```
+
+## Normalformen
+Vorherige Normalformen sind immer Vorraussetzung
+### 1NF Normalform - Zeilen und Spalten erweitern
+> - Alle Attribute atomar sind, d.h. jedes Feld enthält nur einen Wert. Mehrere Attribute in einer Spalte werden zu neuen spalten. Mehrere Datensätze vom gleichen Attribut in der Zelle werden zu einer Neuen Zeile.
+
+### 2NF 
+>Nicht-Schlüsselattribute (Spalten), die eigentlich einen anderen Primärschlüssel haben (sofern der in der Tabelle auch vorhanden), sollte dieser mitsamt diesem in eine eigene Tabelle verlegt werden.
+
+## 3NF
+>Gleiches Vorgehen wie bei der 2NF, einziger Unterschied ist, dass der Primärschlüssel ein bereits bestehender Foreign-Key ist.
+
+
+## Integrität (Constraints)
+- Nur erlaubte werte (hauptsächlich eine Zahlen Range) `CREATE TABLE ... price numeric CHECK (price > 0)` oder `... NOT NULL`
+- Keine Doppelten Primary-Keys/Zeilen (i.e. Unique ) `CREATE TABLE ... id serial UNIQUE`
+- Keine Null-Pointer auf Primary-Keys (Referentielle Integrität) 
+- **CASCADE** = Alles mit löschen, das darauf referenziert; **RESTRICT** = Nicht Löschen, wenn darauf referenziert.
+  `CREATE TABLE ... FOREIGN KEY (bestellung_id) REFERENCES <<table_name>> (<<id_column>>) ON UPDATE CASCADE ON DELETE <<CASCADE or RESTRICT>>`
+## Konsistenz: 
+```plsql
+BEGIN; <-- Anfang von Transaktion
+...
+COMMIT; <-- Abschluss von Transaktion
+ROLLBACK; <- Abbruch von Transaktion 
+```
+>1. **Atomarität:** Eine Transaktion wird entweder komplett durchgeführt, oder sie hinterlässt keine Spuren ihrer Wirkung auf die Datenbank.
+>2. **Konsistenz:** Während der Transaktion können einzelne Konsistenzbedingungen zeitweise verletzt sein, bei Transaktionsende müssen jedoch alle wieder erfüllt sein.
+>3. **Isolation:** Das Prinzip der Isolation verlangt, dass gleichzeitig ablaufende Transaktionen dieselben Resultate wie im Falle einer Einbenutzerumgebung erzeugen müssen.
+>4. **Dauerhaftigkeit:** Datenbankzustände müssen so lange gültig sein und erhalten bleiben, bis sie von Transaktionen verändert werden.
+
+
diff --git a/formulas/Block3_short.md b/formulas/Block3_short.md
new file mode 100644
index 0000000..dddc252
--- /dev/null
+++ b/formulas/Block3_short.md
@@ -0,0 +1,27 @@
+## Reguläre Ausdrücke (Regex)
+Sonderzeichen (`*+?{}[]\|()`) mit `\` escapen.
+* **Platzhalter:** `.` (Zeichen), `\d` (Ziffer), `\w` (Buchstabe/Ziffer), `\s` (Whitespace). Großbuchstaben (`\D`, `\W`, `\S`) negieren die Auswahl.
+* **Auswahl:** `[...]` (Zeichenmenge), `[^...]` (negierte Menge), `[a-z]` (Bereich).
+* **Wiederholung:** `*` (0+), `+` (1+), `?` (0-1), `{n,m}` (Anzahl). `*?` für non-greedy.
+* **Logik & Gruppen:** `()` (Gruppe), `(?P<n>...)` (benannte Gruppe), `|` (ODER).
+* **Position:** `^` (Anfang), `$` (Ende), `\b` (Wortgrenze).
+**Beispiel**:
+```python
+^(?P<timestamp>\d{4}-\d{2}-\d{2}\s\d{2}:\d{2}:\d{2})\s\[(?P<level>INFO|WARN|ERROR)\]\s\(user:\s'(?P<user>[\w\.-]+@[\w\.-]+)'\)\s"(?P<message>.*?)"$
+````
+## XPath & JSONPath
+* **XPath (XML):** Navigation mit `/` (Kind), `//` (Nachfahre), `.` (aktuell), `..` (Eltern). Filtern mit `[...]`, z.B. `[@id='x']` (Attribut) oder `[1]` (Position). Werte mit `@attribut` oder `text()`.
+* **JSONPath (JSON):** Start mit `$`. Navigation mit `.` oder `['key']`. `..` (rekursiv), `[*]` (alle Array-Elemente). Filtern mit `[?(@...)]`, wobei `@` das aktuelle Element ist.
+**Beispiel**:
+```python
+//course[@id='cds104']/lecturer[@type='external' and units > 5]/name/text()
+```
+```json
+$.movies[?(@.year > 1999 && @.title =~ /^Matrix.*/)].actors[*].name
+```
+## HTTP-APIs & Web Crawling
+* **HTTP-APIs:** Datenaustausch über URLs via REST (Methoden: GET, POST, etc.), oft mit API-Key zur Authentifizierung.
+* **Web Scraping/Crawling:** Extrahiert Daten aus HTML. Auswahl mit CSS-Selektoren (z.B. `tag`, `.klasse`, `#id`). Crawler folgen Links (`<a>`). Beachte `robots.txt` und nutze `sitemap.xml`.
+```css
+main#content article.published:not(.featured) h2 + div.meta a[href*="author"]
+```