added complex komonent list

.gitea/workflows/build-script.yaml

@@ -7,16 +7,13 @@ on:
   pull_request:
     branches: [ "**" ]
 
-env:
-  TYPST_SOURCE_DIR: src
-  BUILD_DIR: build
-
 jobs:
   build-typst:
     runs-on: ubuntu-latest
 
     # Run the whole job inside a Docker container that has Typst installed
     steps:
+      - uses: typst-community/setup-typst@v4
       - name: Checkout repository
         uses: actions/checkout@v4
         with:
@@ -27,38 +24,38 @@ jobs:
       - name: Debug Ls
         run: ls -la "$PWD" && echo "$PWD && echo ${{ github.workspace }}"
 
-      - name: Build Typst builder image
+      - name: Make build directory
-        uses: docker/build-push-action@v2
+        run: mkdir -p build
-        with:
-          tags: typst-builder-image:latest
-          push: false
 
-      - name: Compile all .typ files
+      - name: Compile Analysis1
-        uses: addnab/docker-run-action@v3
+        continue-on-error: true
-        env:
+        run: typst compile --root src src/cheatsheets/Analysis1.typ "build/sem1-Analysis_1.pdf"
-          TYPST_SOURCE_DIR: ${{ env.TYPST_SOURCE_DIR }}
+
-          BUILD_DIR: ${{ env.BUILD_DIR }}
+      - name: Compile Schaltungstheorie
-        with:
+        continue-on-error: true
-          image: typst-builder-image:latest
+        run: typst compile --root src src/cheatsheets/Schaltungstheorie.typ "build/sem1-Schaltungstheorie.pdf"
-          options: --volumes-from=${{ env.JOB_CONTAINER_NAME }}
+
-          cwd: ${{ github.workspace }}
+      - name: Compile LinAlg
-          run: "cd ${{ github.workspace }} && TYPST_SOURCE_DIR=${{ env.TYPST_SOURCE_DIR }} BUILD_DIR=${{ env.BUILD_DIR }} bash -c ./compile-all.bash"
+        continue-on-error: true
+        run: typst compile --root src src/cheatsheets/LinearAlgebra.typ "build/sem1-Lineare-algebra.pdf"
+
+      - name: Compile Digtaltechnik
+        continue-on-error: true
+        run: typst compile --root src src/cheatsheets/Digitaltechnik.typ "build/sem1-Digitaltechnik.pdf"
+
+      - name: Compile CT
+        continue-on-error: true
+        run: typst compile --root src src/cheatsheets/CT.typ "build/sem1-Computertechnik.pdf"
 
-      - name: Upload PDFs
-        if: always()
-        uses: actions/upload-artifact@v3
-        with:
-          name: typst-pdfs
-          path: ${{ env.BUILD_DIR }}/*.pdf
-          if-no-files-found: warn
 
       - name: Create Gitea Release
-        uses: softprops/action-gh-release@v1
+        continue-on-error: true
+        uses: akkuman/gitea-release-action@v1
         with:
-          tag_name: ${{ steps.tag.outputs.tag }}
+          name: "Formelsammlungen PDFs"
-          name: Typst PDFs ${{ steps.tag.outputs.tag }}
+          tag_name: "latest"
-          body: |
+          files: build/*.pdf
-            Automated release of Typst-generated PDFs.
 
-            Commit: ${{ github.sha }}
+      - name: Trigger 
-          files: ${{ env.BUILD_DIR }}/*.pdf
+        continue-on-error: true
+        run: curl -u trigger:${{ secrets.TRIGGER_PASSWORD }} -X POST https://trigger.typst4ei.de/trigger/all

.gitignore

@@ -1 +1,9 @@
-venv
+.venv
+out
+node_modules
+__pycache__/
+
+package-lock.json
+package.json
+
+*.pdf

.vscode/tasks.json

@@ -1,17 +0,0 @@
-{
-    "tasks": [
-        {
-            "label": "Compile All",
-            "type": "shell",
-            "command": "TYPST_SOURCE_DIR=src BUILD_DIR=output ./compile-all.bash",
-            "group": {
-                "kind": "build",
-                "isDefault": true
-            },
-            "problemMatcher": [],
-            "options": {
-                "cwd": "${workspaceFolder}"
-            }
-        }
-    ]
-}

compile-all.bash

@@ -1,31 +0,0 @@
-#!/usr/bin/env bash
-
-set -euo pipefail
-SRC_DIR="${TYPST_SOURCE_DIR}"
-OUT_DIR="${BUILD_DIR}"
-
-if [[ ! -d "$SRC_DIR" ]]; then
-    echo "Source directory '$SRC_DIR' does not exist."
-    exit 1
-fi
-
-mkdir -p "$OUT_DIR"
-
-
-# Find all .typ files under $SRC_DIR (excluding hidden dirs)
-mapfile -d '' files < <(printf '%s\0' "$SRC_DIR"/*.typ 2>/dev/null)
-
-if [[ ${#files[@]} -eq 0 ]]; then
-    echo "No .typ files found in '$SRC_DIR'."
-    exit 0
-fi
-
-for f in "${files[@]}"; do
-    # Trim leading ./ if present
-    rel="${f#./}"
-    # Destination path: build/<same-subdirs>/<filename>.pdf
-    dest_pdf="${OUT_DIR}/$(basename "${rel%.typ}").pdf"
-
-    echo "Compiling: $f  ->  $dest_pdf"
-    typst compile "$f" "$dest_pdf"
-done

reihen_plot.py

@@ -1,17 +0,0 @@
-from matplotlib import pyplot as plt
-
-f = lambda x_prev: 1/4 * (x - 3)
-x = 0
-
-reihe = [x]
-
-for i in range(100):
-    x = f(x)
-    reihe.append(x)
-
-plt.plot(reihe, marker='o', linestyle='-')
-plt.title("Reihen Plot")
-plt.xlabel("n")
-plt.ylabel("x_n")
-plt.grid()
-plt.savefig("reihen_plot.png", dpi=500)

src/Analysis1.typ

@@ -1,259 +0,0 @@
-#import "@preview/biceps:0.0.1": *
-#import "@preview/cetz:0.4.2"
-
-#import "lib/styles.typ": *
-#import "lib/common.typ": *
-
-#show: stdTemplate
-
-#place(
-  top+left,
-  stdBlock([
-    == #hlHeading([Trig Identitäten])
-    $sin(x+y) = cos(x)sin(y) + sin(x)cos(y)$ \
-    $cos(x+y) = cos(x)cos(y) - sin(x)sin(y)$ \
-
-    $cos(2x) = cos^2(x) - sin^2(x)$ \
-    $sin(2x) = 2sin(x)cos(x)$
-
-    #grid(
-      gutter: 5mm,
-      columns: (auto, auto),
-      [$cos^2(x) = (1 + cos(2x))/2$],
-      [$sin^2(x) = (1 - cos(2x))/2$]
-    )
-
-    $cos^2(x) + sin^2(x) = 1$
-    
-    #grid(
-      gutter: 5mm,
-      columns: (auto, auto),
-      [$cos(-x) = cos(x)$],
-      [$sin(-x) = -sin(x)$],
-    )
-
-    Subsitution mit Hilfsvariable
-
-    #grid(
-      gutter: 5mm,
-      row-gutter: 3mm,
-      columns: (auto, auto),
-      [$tan(x)=sin(x)/cos(x)$],
-      [$cot(x)=cos(x)/sin(x)$],
-      [$tan(x)=-cot(x + pi/2)$],
-      [$cot(x)=-tan(x + pi/2)$],
-      [$cos(x - pi/2) = sin(x)$],
-      [$sin(x + pi/2) = cos(x)$],
-    )
-    $sin(x)cos(y) = 1/2sin(x - y) + 1/2sin(x + y)$
-
-    Für $x in [-1, 1]$ \
-    $arcsin(x) = -arccos(x) - pi/2 in [-pi/2, pi/2]$ \
-    $arccos(x) = -arcsin(x) + pi/2 in [0, pi]$
-  ])
-)
-#place(
-  top + left,
-  dx: 6.5cm,
-  sinTable
-)
-
-#place(
-  top+left,
-  dx: 0cm,
-  dy: 8cm,
-  stdBlock([
-    #grid(
-      columns:(auto, auto), 
-      gutter: 1mm,
-      [
-        == #hlHeading([Folgen])
-        $ lim_(x->infinity) a_n $
-        - *Beschränkt*: $exists k in RR$ so dass $abs(a_n) <= k$
-          - $epsilon$-Interval: $x in (a - epsilon, a + epsilon) <=> abs(x - a) < epsilon$
-          - *Beweiß:* Induktion
-          - Hat min. eine konvergent Teilfolge
-
-        - *Monoton: steigen/fallend* $a_(n+1) gt.eq.lt a_n$
-          - *Beweisen:* Induktion mit \ $a_(n+1) gt.eq.lt a_n$ oder $a_(n+1) / a_(n) gt.lt 1 $  oder Umformung
-
-        - *Konvergent*:
-          - Es gibt $forall epsilon > 0$ eine Index $n_epsilon in NN$ sodass \ $abs(a_n - a) < epsilon space forall n > n_epsilon$
-          - Divergent $-> infinity$, wenn $forall k in RR : exists space  a_n > k$
-          - Divergent $-> -infinity$, wenn $forall k in RR : exists space  a_n < k$
-          - Genzwert is eindeutig
-
-        - *Konvergenz $a_n -> a$ $<=>$ beschränkt UND monoton*
-          - $<=>$ Alle Teilefolgen konvergent zu $a$
-          - Wenn Häufungspunk $eq.not$ $=>$ divergent
-          - Sandwitch-Theorem
-
-        - *Cauchyfolge*
-          Ein folge die diese Eigenschaft hat: \
-          $forall epsilon > 0 space exists N_epsilon in NN space forall m,n > N_epsilon : abs(a_n - a_m) < epsilon$ \
-          Cauchyfolge $<=>$ Konvergenz
-      ], 
-      grid.vline(stroke: 0.1mm + black, position: start),
-      pad([
-        === Grenzwert Finden:
-        - "Bottom up" von Bekannten Ausdrücken
-        - Fixpunk Gleösenichung l $a = f(a)$  für $f(a_n)$
-        - Bernoulli-Ungleichung für $(a_n)^n$ \
-          $(1 + a)^n >= 1 + n a$ für $a >= -1$
-        - #MathAlignLeft($1 + u <= 1/(1-u), u < 1$)
-          
-        Für Konvergent Folgen:
-        #grid(
-          columns: (auto, auto),
-          align: bottom,
-          gutter: 2mm,
-          [$ lim_(n->infinity) (a_n + b_n) = a + b $],
-          grid.cell(
-            rowspan:  2,
-            [$ lim_(n->infinity) (a_n / b_n) = a / b $],
-          ),
-          MathAlignLeft($ lim_(n->infinity) (a_n dot b_n) = a dot b $),
-          MathAlignLeft($ lim_(n->infinity) sqrt(a_n) = sqrt(a) $),
-          MathAlignLeft($ lim_(n->infinity) abs(a_n) = abs(a) $),
-          MathAlignLeft($ lim_(n->infinity) c dot a_n = c dot lim_(n->infinity) a_n $),
-        )
-
-        == Spezifische Folgen
-        #grid(
-          columns: (auto, auto, auto),
-          column-gutter: 4mm,
-          row-gutter: 2mm,
-          align: bottom,
-          MathAlignLeft($ lim_(n->infinity) 1/n = 0 $),
-          MathAlignLeft($ lim_(n->infinity) q^n = 0 $),
-          MathAlignLeft($ lim_(n->infinity) q^n = 0 $),
-          grid.cell(colspan: 2, MathAlignLeft($ lim_(n->infinity) sqrt(n) = + infinity $)), [],
-          grid.cell(colspan: 2, MathAlignLeft($ lim_(n->infinity) k = k, k in RR $)), [],
-          grid.cell(colspan: 2, MathAlignLeft($ exp(x) =  e^x = lim_(n->infinity) (1 + x/n)^n $))
-        )
-
-        == Teilfolgen
-        - Indizies müssen immer streng monoton \
-          wachsend sein. (z.B. is $a_1, a_1, a_2, a_2$ KEIN\
-          Teilfolge von $a_n$)
-        - Beschränkte $a_n$ $=>$ *min eine* \
-          konvergent Teilfolge
-        - Konvergent $a_n$ $=>$ *genau ein* Häufungspunkt
-        
-
-      ], left: 1mm)
-    )
-  ])
-)
-
-#place(
-  top+left,
-  dx: 13cm,
-  dy: 0cm,
-  stdBlock([
-    == #hlHeading([Reihen])
-
-    Wenn $sum_(n=1)^infinity a_n$ konverigiert $=>$ $a_n$ Nullfolge \
-    Wenn $a_n$ keine Nullfolge $=>$ $sum_(n=1)^infinity$ divergent
-
-    === Absolute Konvergenz
-    Bedeuted $sum_(n=1)^infinity abs(a_n) = a ==> sum_(n=1)^infinity a_n$ konvergent 
-    
-    $sum_(n=1)^infinity abs(a_n)$ beschränkt + (monoto steigended) $= sum_(n=1)^infinity abs(a_n)$
-
-    === Partialsummen
-    Sind die Partialsummen von $sum_(k=1)^infinity abs(a)$ beschränkt\
-    $==>$ _Absolute Konvergent_
-
-    === Cauchy-Kriterium
-    konvergent wenn $forall epsilon$ existiert ein $n_epsilon in NN$ \
-    sodass $abs(s_n - s_m) = abs(sum_(k=m+1)^(n)) < epsilon space$ \
-    $forall n_epsilon < m < n $
-
-    === Leibnitzkriterium
-    Wenn monton fallend, $a_n >= 0$, Null folge dann
-
-    $sum_(n=1)^infinity (-1)^n dot a_n$ konvergent
-
-    === Majorandenkriterium
-    Seien $a_n, b_n$ mit $abs(a_n) <= b_n space (forall n > N, N in NN)$
-    1. $sum_(n=0)^infinity b_n$ konvergent $==> sum_(n=0)^infinity abs(a_n)$ konvergent \
-      Suche $b_n$ für Konvergenz
-    2. $sum_(n=0)^infinity abs(a_n)$ divergent $==> sum_(n=0)^infinity b_n$ divergent \
-      Suche $abs(a_n)$ für Divergenz
-
-    Nützlich:
-    - Dreiecksungleichung
-    - $forall space n in NN$ \
-      $exists space k,q in RR$ \
-      für $q > 1$: $n^k <= q^n$ ab einem bestimmten.
-
-    === Quotientenkriterium und Wurzelkriterium
-    1. $rho = lim_(n -> infinity) abs((a_(n+1))/(a_n)) $
-    2. $rho = lim_(n -> infinity) root(n, abs(a_(n+1))) $ \
-      (Stärker, am besten für $(...)^n$)
-
-    divergent: $rho > 1$, keine Aussage $rho = 1$, konvergent $rho < 1$
-    === Spezifische Reihen
-      Geometrische Reihe: $sum_(n=0)^infinity q^n$
-      - konvergent $abs(q) < 1$, divergent  $abs(q) >= 1$
-      - Grenzwert: (Muss $n=0$) $=1/(1-q)$
-      Harmonische Reihe: $sum_(n=0)^infinity 1/n = +infinity$
-
-      1. $e^x = sum_(n=0)^infinity (x^n)/(n!)$
-      2. $ln(x) = sum_(n=0)^infinity (-1)^n x^(n+1)$
-  ])
-)
-
-#place(
-  top+left,
-  dx: 0cm,
-  dy: 20cm,
-  stdBlock([
-    == Kriterien Übersich für Reihen $sum_(n=0)^infinity a_n$
-    #line()
-
-    #grid(
-      columns: (auto, auto),
-      gutter: 3mm,
-      [
-        *Notwendinge Kriterien*\
-        ($not$ Bedingung $=>$ div.)
-        - Cauchy-Kriterium
-        - #MathAlignLeft($ lim_(n->infinity)a_n = 0 $)
-        - Konvergenz der Partialsummen
-        - Beschränktheit der Partialsummen
-      ],
-      [
-        *Hinreichende Kriterien* \
-        (Bedingung $=>$ konv.)
-        - Absolute Konvergenz
-        - Leibnitz-Kroterium
-        - Beschränktheit der Partialsummen
-        - Quotienten-/Wurzel-kriterium
-        - Majorandenkriterium
-      ]
-    )
-  ])
-)
-
-#pagebreak()
-#place(
-  left+top,
-  dx: 0cm,
-  dy: 0cm,
-  stdBlock([
-    == #hlHeading([Funktionen])
-    === Stetigkeit
-    Stetig an der stelle $x_0$ wenn: $ lim_(x->x_0+) f(x) = lim_(x->x_0-) f(x) =f(x_0) $
-    $f(x)$ muss nicht definiert sein an $x_0$
-    === Differenzierbar
-    An der stelle $x_0$ wenn
-    #MathAlignLeft($ 
-      lim_(h -> 0) (f(x_0 + h)-f(x_0))/h =\
-      lim_(h -> 0) (f(x_0 - h)-f(x_0))/h = f'(x)
-    $)
-    definiert ist
-
-  ])
-)

src/Analysis_rewrite.typ

@@ -1,519 +0,0 @@
-#import "lib/common_rewrite.typ" : *
-
-#set page(
-  paper: "a4", 
-  margin: (
-    bottom: 10mm,
-    top: 5mm,
-    left: 5mm,
-    right: 5mm
-  ),
-  flipped:true,
-  numbering: "— 1 —",
-  number-align: center
-)
-
-#set text(
-  size: 8pt,
-)
-
-#place(top+center, scope: "parent", float: true, heading(
-  [Analysis 1 (IE)]
-))
-
-#let SeperatorLine = line(length: 100%, stroke: (paint: black, thickness: 0.3mm))
-#let MathAlignLeft(e) = {
-  align(left, block(e))
-}
-
-#let colorAllgemein = color.hsl(105.13deg, 92.13%, 75.1%)
-#let colorFolgen = color.hsl(202.05deg, 92.13%, 75.1%)
-#let colorReihen = color.hsl(280deg, 92.13%, 75.1%)
-#let colorAbleitung = color.hsl(356.92deg, 92.13%, 75.1%)
-#let colorIntegral = color.hsl(34.87deg, 92.13%, 75.1%)
-
-
-#columns(4, gutter: 2mm)[
-  #bgBlock(fill: colorAllgemein)[
-    #subHeading(fill: colorAllgemein)[Allgemeins]
-    #grid(
-      columns: (auto, auto),
-      row-gutter: 2mm,
-      column-gutter: 3mm,
-      [Dreiecksungleichung], [
-        $abs(x + y) <= abs(x) + abs(y)$ \
-        $abs(abs(x) - abs(y)) <=  abs(x - y)$
-      ],
-      [Cauchy-Schwarz-Ungleichung], [
-        $abs(x dot y) <= abs(abs(x) dot abs(y))$
-      ],
-      [Geometrische Summenformel], [
-        #MathAlignLeft($ limits(sum)_(k=1)^(n) k = (n(n+1))/2 $)
-      ],
-      [Bernoulli-Ungleichung ], [
-        $(1 + a)^n x in RR >= 1 + n a$
-      ],
-      [Binomialkoeffizient], [
-        $binom(n, k) = (n!)/(k!(n-k)!)$
-      ],
-      [Binomische Formel], [
-        #MathAlignLeft($ (a + b)^n = sum^(n)_(k=0) binom(n,k) a^(n-k) b^k $)
-      ],
-      [Fakultäten], [$ 0! = 1! = 1 $],
-
-      [Gausklammer], [
-        $floor(x) = text("floor")(x)$ \
-        $ceil(x) = text("ceil")(x)$
-      ],
-      [Bekannte Werte], [
-        $e approx  2.71828$ ($2 < e < 3$) \
-        $pi approx 3.14159$ ($3 < pi < 4$)
-      ]
-    )
-  ]
-
-  #bgBlock(fill: colorAllgemein)[
-    #subHeading(fill: colorAllgemein)[Trigonometrie]
-  ]
-
-    #bgBlock(fill: colorAllgemein)[
-    #table(
-      inset: 1.5mm,
-      stroke: (thickness: 0.2mm),
-      columns: 4,
-      table.header(
-        [x], [deg], [cos(x)], [sin(x)]
-      ),
-      [$0$], [$0°$], [$1$], [$0$],
-      [$pi/6$], [$30°$], [$sqrt(3)/2$], [$1/2$],
-      [$pi/4$], [$45°$], [$sqrt(2)/2$], [$sqrt(2)/2$],
-      [$pi/3$], [$60°$], [$1/2$], [$sqrt(3)/2$],
-      [$pi/2$], [$90°$], [$0$], [$1$],
-      [$2/3pi$], [$120°$], [$-1/2$], [$sqrt(3)/2$],
-      [$3/4pi$], [$135°$], [$-sqrt(2)/2$], [$sqrt(2)/2$],
-      [$5/6pi$], [$150°$], [$-sqrt(3)/2$], [$1/2$],
-      [$pi$], [$180°$], [$-1$], [$0$],
-      [$3/2pi$], [$270°$], [$0$], [$-1$],
-      [$2pi$], [$360°$], [$1$], [$0$]
-    )
-  ]
-
-  #bgBlock(fill: colorAllgemein)[
-    #subHeading(fill: colorAllgemein)[Complexe Zahlen]
-    $z = r dot e^(phi i) = r (cos(phi) + i sin(phi))$
-
-    $z^n = r^n dot e^(phi i dot n) = r^n (cos(n phi) + i sin(n phi))$
-
-    #grid(
-      columns: (1fr, 1fr),
-      [$ sin(x) = (e^(i x) - e^(-i x))/(2i) $],
-      [$ cos(x) = (e^(i x) + e^(-i x))/(2) $]
-    )
-    #subHeading(fill: colorAllgemein)[Trigonmetrie]
-    $sin(x+y) = cos(x)sin(y) + sin(x)cos(y)$ \
-    $cos(x+y) = cos(x)cos(y) - sin(x)sin(y)$ \
-
-    $cos(2x) = cos^2(x) - sin^2(x)$ \
-    $sin(2x) = 2sin(x)cos(x)$
-
-    #grid(
-      gutter: 5mm,
-      columns: (auto, auto),
-      [$cos^2(x) = (1 + cos(2x))/2$],
-      [$sin^2(x) = (1 - cos(2x))/2$]
-    )
-
-    $cos^2(x) + sin^2(x) = 1$
-    git config pull.rebase falsegit config pull.rebase false
-    #grid(
-      gutter: 5mm,
-      columns: (auto, auto),
-      [$cos(-x) = cos(x)$],
-      [$sin(-x) = -sin(x)$],
-    )
-
-    Subsitution mit Hilfsvariable
-
-    #grid(
-      gutter: 5mm,
-      row-gutter: 3mm,
-      columns: (auto, auto),
-      [$tan(x)=sin(x)/cos(x)$],
-      [$cot(x)=cos(x)/sin(x)$],
-      [$tan(x)=-cot(x + pi/2)$],
-      [$cot(x)=-tan(x + pi/2)$],
-      [$cos(x - pi/2) = sin(x)$],
-      [$sin(x + pi/2) = cos(x)$],
-    )
-    $sin(x)cos(y) = 1/2sin(x - y) + 1/2sin(x + y)$
-
-    Für $x in [-1, 1]$ \
-    $arcsin(x) = -arccos(x) - pi/2 in [-pi/2, pi/2]$ \
-    $arccos(x) = -arcsin(x) + pi/2 in [0, pi]$
-  ]
-
-  #bgBlock(fill: colorFolgen)[
-    #subHeading(fill: colorFolgen)[Folgen]
-    $ lim_(x -> infinity) a_n $
-
-    *Beschränkt:* $exists k in RR$ sodass $abs(a_n) <= k$
-    - Beweiße: durch Induktion
-    - Beweiße: Hat min. ein konvergent Teilefolge
-    - (Beweiße: Ungleichung $abs(a_n) <= k$)
-
-    *Monoton fallend/steigended*
-    - Beweise: Induktion
-    #grid(columns: (1fr, 1fr),
-      gutter: 1mm,
-      row-gutter: 2mm,
-      align(top+center, [*Fallend*]), align(top+center, [*Steigend*]),
-      [$ a_(n+1) <= a_(n) $],
-      [$ a_(n+1) >= a_(n) $],
-      [$ a_(n+1)/a_(n) < 1 $],
-      [$ a_(n+1)/a_(n) > 1 $],
-    )
-
-    *Konvergentz Allgemein*
-    $ lim_(n -> infinity) a_n = a $
-
-    $forall epsilon > 0 space exists n_epsilon in NN$ sodass \
-    - Konvergent $-> a$: $a_n in [a - epsilon, a + epsilon] $
-    - Divergent $-> infinity$: $a_n in [epsilon, infinity) $
-    - Divergent $-> infinity$: $a_n in (-infinity, epsilon) $
-
-    $space forall n > n_epsilon$
-
-    *Konvergentz Häufungspunkte*
-    - $a_n -> a <=>$ Alle Teilfolgen $-> a$
-
-    *Konvergenz Beweißen*
-    - Monoton UND Beschränkt $=>$ Konvergenz
-      NICHT Umgekehert
-    - (Cauchyfolge \
-      $forall epsilon > 0 space exists n_epsilon in NN space$ sodass \
-      $forall m,n >= n_epsilon : abs(a_n - a_m) < epsilon$ \
-      Cauchyfolge $=>$ Konvergenz)
-    - $a_n$ unbeschränkt $=>$ divergenz
-
-    *Konvergent Grenzwert finden*
-    - Von Bekannten Ausdrücken aufbauen
-    - Fixpunk Gleichung: $a = f(a)$ \
-      für rekusive $a_(n+1) = f(a_n)$ (Zu erst machen!)
-    - Bernoulli-Ungleichung Folgen der Art $(a_n)^n$: \
-      $(1 + a)^n >= 1 + n a$
-    - Sandwitchtheorem:\
-      $b_n -> x$: $a_n <= b_n <= c_n$, wenn $a_n -> x$ und $c_n -> x$ \
-      $b_n -> -infinity$: $b_n <= c_n$, wenn $c_n -> -infinity$ \
-      $b_n -> +infinity$: $c_n <= b_n $, wenn $a_n -> +infinity$
-    - Zwerlegen in Konvergente Teil folgen \
-      (Vorallem bei $(-1)^n dot a_n$)
-  ]
-
-  #bgBlock(fill: colorFolgen)[
-    #subHeading(fill: colorFolgen)[Konvergent Folge Regeln]
-    #grid(
-      columns: (auto, auto),
-      align: bottom,
-      gutter: 2mm,
-      [$ lim_(n->infinity) (a_n + b_n) = a + b $],
-      grid.cell(
-        rowspan:  2,
-        [$ lim_(n->infinity) (a_n / b_n) = a / b $ für ($b != 0$)],
-      ),
-      MathAlignLeft($ lim_(n->infinity) (a_n dot b_n) = a dot b $),
-      MathAlignLeft($ lim_(n->infinity) sqrt(a_n) = sqrt(a) $),
-      MathAlignLeft($ lim_(n->infinity) abs(a_n) = abs(a) $),
-      MathAlignLeft($ lim_(n->infinity) c dot a_n = c dot lim_(n->infinity) a_n $),
-    )
-  ]
-
-  #bgBlock(fill: colorFolgen)[
-    #subHeading(fill: colorFolgen)[Bekannte Folgen]
-    #grid(
-      columns: (auto, auto, auto),
-      column-gutter: 4mm,
-      row-gutter: 2mm,
-      align: bottom,
-      MathAlignLeft($ lim_(n->infinity) 1/n = 0 $),
-      [],
-      MathAlignLeft($ lim_(n->infinity) k = k, k in RR $),
-      grid.cell(colspan: 2, MathAlignLeft($ exp(x) =  e^x = lim_(n->infinity) (1 + x/n)^n $)), 
-      MathAlignLeft($ lim_(n->infinity) sqrt(n) = + infinity $),
-      grid.cell(colspan: 2, MathAlignLeft($ lim_(n->infinity) q^n = cases(
-        0 &abs(q),
-        1 &q = 1,
-        plus.minus infinity &q < -1,
-        plus infinity #h(5mm) &q > 1
-      ) $)), []
-    )
-  ]
-
-  #bgBlock(fill: colorFolgen)[
-    #subHeading(fill: colorFolgen)[Teilfolgen]
-    $ a_k subset a_n space (text("z.B") k= 2n + 1) $
-    - Index muss streng monoton steigen!
-    - Beschränkte $a_n => text("min eine konvergente") a_k$
-    - Konvergenz-Werte von $a_k$ sind Häufungspunkte
-    - Wenn alle $a_k$ gegen #underline([genau eine]) Häufungspunk konverigiert $<=> a_n$ konvergent 
-  ]
-
-  #bgBlock(fill: colorReihen)[
-    #subHeading(fill: colorReihen)[Reihen]
-    $limits(lim)_(n->infinity) a_n != 0 => limits(sum)_(n=1)^infinity a_n$ konverigiert NICHT \
-
-    - *Absolute Konvergenz* \
-      $limits(sum)_(n=1)^infinity abs(a_n) = a => limits(sum)_(n=1)^infinity a_n$ konvergent 
-    
-
-
-    - *Partialsummen* \
-      ALLE Partialsummen von $limits(sum)_(k=1)^infinity abs(a)$ beschränkt\
-      $=>$ _Absolute Konvergent_
-
-    - *(Cauchy-Kriterium)*\
-      konvergent wenn $forall epsilon > 0 space exists n_epsilon in NN$ \
-      sodass $abs(s_n - s_m) = abs(limits(sum)_(k=m+1)^(n)) < epsilon space$ \
-      $forall n_epsilon < m < n $
-
-    - *Leibnitzkriterium* \
-      Alternierend + Nullfolge \
-      $=> limits(sum)_(n=1)^infinity (-1)^n dot a_n$ konvergent
-
-    - *Vergleichskriterium* \
-      $a_n, b_n : abs(a_n) <= b_n space forall n in NN > N_0, N_0 in NN$
-      1. $limits(sum)_(n=0)^infinity b_n$ konvergent $=> limits(sum)_(n=0)^infinity abs(a_n)$ konvergent \
-        Suche $b_n$ für Konvergenz
-      2. $limits(sum)_(n=0)^infinity abs(a_n)$ divergent $=> limits(sum)_(n=0)^infinity b_n$ divergent \
-        Suche $abs(a_n)$ für Divergenz
-
-      Nützlich:
-      - Dreiecksungleichung
-      - $forall space n > N_0 in NN space exists k,q in RR$ \
-        sodass $q > 1$: $n^k <= q^n$ (Potenz stärker Polynom)
-
-    - *Quotientenkriterium und Wurzelkriterium*
-      1. $rho = lim_(n -> infinity) abs((a_(n+1))/(a_n)) $
-      2. $rho = lim_(n -> infinity) root(n, abs(a_(n+1))) $ \
-      
-      divergent: $rho > 1$, keine Aussage $rho = 1$, konvergent $rho < 1$
-
-    - *Geometrische Reihe* 
-      $limits(sum)_(n=0)^infinity q^n$
-      - konvergent $abs(q) < 1$, divergent  $abs(q) >= 1$
-      - Grenzwert: (Muss $n=0$) $=1/(1-q)$
-    - *Harmonische Reihe* $limits(sum)_(n=0)^infinity 1/n = +infinity$
-
-    - *Reihendarstellungen*
-      1. $e^x = limits(sum)_(n=0)^infinity (x^n)/(n!)$
-      2. $ln(x) = limits(sum)_(n=0)^infinity (-1)^n x^(n+1)$
-      3. $sin(x) = limits(sum)_(n=0)^infinity $
-      4. $cos(x) = limits(sum)_(n=0)^infinity $
-
-  ]
-
-  #bgBlock(fill: colorReihen)[
-    #subHeading(fill: colorReihen)[Potenzreihen]
-  ]
-
-  #bgBlock(fill: colorReihen)[
-    #subHeading(fill: colorReihen)[Bekannte Reihen]
-    *Geometrische Reihe:* $sum_(n=0)^infinity q^n$
-    - konvergent $abs(q) < 1$, divergent  $abs(q) >= 1$
-    - Grenzwert: (Muss $n=0$) $=1/(1-q)$
-
-    *Harmonische Reihe:* $sum_(n=0)^infinity 1/n = +infinity$
-    
-    *Andere*
-    - $e^x = limits(sum)_(n=0)^infinity (x^n)/(n!)$
-    - $ln(x) = limits(sum)_(n=0)^infinity (-1)^n x^(n+1)$
-  ]
-
-  #colbreak()
-
-  #bgBlock(fill: colorAbleitung)[
-    #subHeading(fill: colorAbleitung)[Funktionen]
-    Sei $f : [a,b] -> RR$, stetig auf $x in [a,b]$
-    - *Zwischenwertsatz* \
-      $=> forall y in [f(a), f(b)] exists text("min. ein") x in [a,b] : f(x) = y$ \
-      _Beweiß für mindest. n Nst_
-    - *Satze von Rolle* \
-      diffbar $x in (a,b)$\
-      $f(a) = f(b) => exists text("min. ein") x_0 in (a,b) : f'(x_0) = 0$
-      _Beweiß für max. n Nst, durchWiederspruchsbweiß mit $f(a)=f(b)=0$ und Wiederholte Ableitung_
-
-    - *Mittelwertsatz*
-      diffbar $x in (a,b)$ \
-      $=> exists x_0 : f'(x_0)=(f(b) - f(a))/(a-b)$
-
-    - *Monotonie* \
-      $x in I : f'(x) < 0$: Streng monoton steigended \
-      $x_0,x_1 in I,  x_0 < x_1 => f(x_0) < f(x_1)$ \
-      (Analog bei (streng ) steigned/fallended)
-  ]
-
-  #bgBlock(fill: colorAbleitung)[
-    #subHeading(fill: colorAbleitung)[Stetigkeit]
-    *Allgemein*
-    
-    $f(x)$ ist stetig wenn: \
-    $ limits(lim)_(x->x_0-) f(x) = limits(lim)_(x->x_0+) f(x) = f(x_0) $ \
-    $x in DD$ Beachten! Definitionslücken $!=$ unstätig \
-    Definition gilt auch für $I subset RR$
-
-    *Regeln*
-
-    $f(x),g(x)$ seinen stetig dann sind auch Stetig:
-
-    #grid(columns: (auto, auto, auto, auto, auto),
-      column-gutter: 4mm,
-      row-gutter: 2mm, 
-      $f(x) + g(x)$, $f circle.small g$, $alpha dot f(x)$,
-      $f(x)/g(x)$, $f(x) dot g(x)$
-    )
-
-    *Bekannte Funktion*
-    #table(
-      columns: (1fr, 1fr),
-      table.header(
-        [*Stetig*], [*Nicht Stetig*]
-      ),
-      stroke: (x, y) => (x: 0mm, y: 0.2mm),
-      [
-        - Polynome, gebrochen Rationale Fn
-        - $floor(x),ceil(x)$ für $x in RR without ZZ$
-        - Betrags Funktion
-        - $sin, cos, tan$
-      ],
-      [
-        - Stufenfunktion
-        - Fall Unterscheidungen
-        - $floor(x),ceil(x)$ für $x in RR$
-      ]
-    )
-  ]
-
-  #bgBlock(fill: colorAbleitung)[
-    #subHeading(fill: colorAbleitung)[Ableitung]
-    *Differenzierbarkeit*
-    - $f(x)$ ist an der Stelle $x_0 in DD$ diffbar wenn \
-      #MathAlignLeft($ f'(x_0) = lim_(x->x_0 plus.minus) (f(x_0 + h - f(x_0))/h) $)
-    - $f(x)$ diffbar $=>$ $f(x)$ stetig
-    - Tangente an $x_0$: $f(x_0) + f'(x_0)(x - x_0)$
-      - Beste #underline([linear]) Annäherung
-      - Tangente $t(x)$ von $f(x)$ an der Stelle $x_0$: $ lim_(x->0) (f(x) - f(x_0))/(x-x_0) -f'(x_0) =0 $
-
-    *Ableitung Regeln*
-
-    #grid(
-      row-gutter: 3mm,
-      columns: (1fr, 1fr),
-      grid.cell(
-        colspan: 2,
-        [$f(x) + g(x) : f'(x) + g'(x) $]
-      ),
-      grid.cell(
-        colspan: 2,
-        [$f(x) dot g(x) : f'(x)g(x) + f(x)g'(x) $]
-      ),
-      grid.cell(
-        colspan: 2,
-        [#MathAlignLeft($ f(x)/g(x) : (f'(x)g(x) - f(x)g'(x))/(g(x)^2) $)]
-      ),
-      [$f(x) = c : f'(x) = 0$],
-      [$c dot f(x) : c dot f'(x)$],
-      [$(x^(-n)) n in NN : n x^(n-1)$],
-      [$e^(x) : e^(x)$],
-    )
-    - Kettenregel: $f(g(x)) : f'(g(x)) dot g'(x)$
-  ],
-
-  #block([
-    #set text(size: 10pt)
-    #table(
-      align: horizon, 
-      columns: (1fr, 1fr, 1fr),
-      table.header([*$F(x)$*], [*$f(x)$*], [*$f'(x)$*]),
-      row-gutter: 1mm,
-      fill: (x, y) => if x == 0 { color.hsl(180deg, 89.47%, 88.82%) }
-        else if x == 1 { color.hsl(180deg, 100%, 93.14%) } else 
-          { color.hsl(180deg, 81.82%, 95.69%) },
-      [$1/(q + x) x^(q+1)$], [$x^q$], [$q x^(q-1)$],
-      [$ln abs(x)$], [$1/x$], [$-1/x^2$],
-      [$x ln(a x) - x$], [$ln(a x)$], [$1 / x$],
-      [$2/3 sqrt(a x^3)$], [$sqrt(a x)$], [$a/(2 sqrt(a x))$],
-      [$e^x$], [$e^x$], [$e^x$],
-      [$a^x/ln(a)$], [$a^x$], [$a^x ln(a)$],
-
-      [$x arcsin(x) + sqrt(1 - x^2)$],
-      [$arcsin(x)$], [$1/sqrt(1 - x^2)$],
-
-      [$x arccos(x) - sqrt(1 - x^2)$],
-      [$arccos(x)$], [$-1/sqrt(1 - x^2)$],
-
-      [$x arctan(x) - 1/2 ln abs(1 + x^2)$],
-      [$arctan(x)$], [$1/(1 + x^2)$],
-
-      [$x op("arccot")(x) + \ 1/2 ln abs(1 + x^2)$],
-      [$op("arccot")(x)$], [$-1/(1 + x^2)$],
-
-      [$x op("arsinH")(x) + \ sqrt(1 + x^2)$],
-      [$op("arsinH")(x)$], [$1/sqrt(1 + x^2)$],
-
-      [$x op("arcosH")(x) + \ sqrt(1 + x^2)$],
-      [$op("arcosH")(x)$], [$1/sqrt(x^2-1)$],
-
-      [$x op("artanH")(x) + \ 1/2 ln(1 - x^2)$],
-      [$op("artanH")(x)$], [$1/(1 - x^2)$],
-    )
-  ])
-
-  #colbreak()
-]
-
-#pagebreak()
-
-== Folgen in $CC$
-
-$z_n in C: lim z_n  <=> lim abs(z_n -> infinity) = 0$
-
-Alle folgen regelen gelten
-
-Complexe Folge kann man in Realteil und Imag zerlegen
-
-z.B.
-
-$z_n = z^n z in CC$
-
-$z = abs(z) dot e^(i phi) = abs(z)^n$
-
-== Reihen in $CC$
-
-Fast alles gilt auch.
-
-Bis auf Leibnitzkriterium weil es keine Monotonie gibt
-
-Geometrische Reihe gilt.
-
-Exponential funktion
-
-#MathAlignLeft($ e^z = lim_(n -> infinity) (1 + z/n)^n = sum_(n=0)^infinity (z^n)/(n!) space z in CC $)
-
-Vorsicht: $(b^a)^n = b^(a dot c)$
-
-Potenzreihen: Eine Fn der form:
-
-#MathAlignLeft($ P(z) = sum^(infinity)_(n=0) a_n dot (z - z_0)^n space z, z_0 in CC $)
-
-=== Satz
-
-Konvergenz Radius $R = [0, infinity)$$$
-
-1. $R = 0$ Konvergiet nur bei $z = 0$
-
-2. $R in R : cases(
-  z in CC &abs(z - z_0) < R &: "abs Konvergent",
-  z in CC &abs(z - z_0) = R &: "keine Ahnung",
-  z in CC &abs(z - z_0) > R &: "Divergent"
-)$
-
-$ R = limsup_(n -> infinity) $

src/LinearAlgebra.typ

@@ -1,177 +0,0 @@
-#import "@preview/biceps:0.0.1" : *
-#import "@preview/mannot:0.3.1"
-#import "lib/styles.typ" : *
-#import "lib/common_rewrite.typ" : *
-
-#set page(
-  paper: "a4", 
-  margin: (
-    bottom: 10mm,
-    top: 5mm,
-    left: 5mm,
-    right: 5mm
-  ),
-  flipped:true,
-  numbering: "— 1 —",
-  number-align: center
-)
-
-#place(top+center, scope: "parent", float: true, heading(
-  [Linear Algebra EI]
-))
-
-#let colorAllgemein = color.hsl(105.13deg, 92.13%, 75.1%)
-#let colorFolgen = color.hsl(202.05deg, 92.13%, 75.1%)
-#let colorReihen = color.hsl(280deg, 92.13%, 75.1%)
-#let colorAbbildungen = color.hsl(356.92deg, 92.13%, 75.1%)
-#let colorGruppen = color.hsl(34.87deg, 92.13%, 75.1%)
-
-
-#let SeperatorLine = line(length: 100%, stroke: (paint: black, thickness: 0.3mm))
-#let MathAlignLeft(e) = {
-  align(left, block(e))
-}
-#columns(4, gutter: 2mm)[
-    #bgBlock(fill: colorAllgemein)[
-        #subHeading(fill: colorAllgemein)[Notation]
-        
-
-    ]
-
-    #bgBlock(fill: colorGruppen)[
-         #subHeading(fill: colorGruppen)[Gruppen]
-
-        *Halbgruppe:* $(M, compose): M times M arrow M$
-        - Assoziativgesetz: $a dot (b dot c) = (a dot b) dot c$
-        *Monoid* Halbgruppe $M$ mit:
-        - Identitätselment: $e in M : a e = e a = a$
-        *Kommutativ/abelsch:* Halbgruppe/Monoid mit
-        - Kommutativgesetz; $a dot b = b dot a$
-
-        #SeperatorLine
-
-        *Gruppe:* Monoid mit
-        - Inverse: $forall a in G : exists space a a^(-1) = a^(-1)a = e$
-        - Eindeutig Lösung für Gleichungen 
-        Zusatz:
-        - Inverseregel: $(a dot b)^(-1) = b^(-1) dot a^(-1)$
-        *Untergruppe:*
-        - Gruppe: $(G, dot)$, $U subset G$
-        - $a,b in U <=> a dot b in U$
-        - $a in U <=> a^(-1) in U$
-        - $e in U$ (Neutrales Element)
-
-        *Direktes Produkt:*\
-        $(G_1,dot_1) times (G_2,dot_2) times ... $ \
-        $(a_1,b_1,...)(a_2,b_2,...)= (a_1 dot_1 b_1, a_2 dot_2 b_2, ...)$
-
-
-        #SeperatorLine
-
-        *Ring:* (auch Schiefkörper) Menge $R$ mit:
-        - $(R, +)$ kommutativ Gruppe
-        - $(R, dot)$ Halbgruppe
-        - $(a + b) dot c = (a dot c) + (a dot b) space$ (Distributiv Gesetz)
-
-        #colbreak()
-
-        *Körper:* Menge $K$ mit:
-        - $(K, +), (K without {0} , dot)$ kommutativ Gruppe \
-            ($0$ ist Neutrales Element von $+$)
-        - $(a + b) dot c = (a dot c) + (a dot b) space$ (Distributiv Gesetz)
-        _Beweiß durch Überprüfung der Eigneschaften_
-    ]
-
-    #bgBlock(fill: colorReihen)[
-        #subHeading(fill: colorReihen)[Vektorräume (VR)]
-        $(V, plus.o, dot.o)$ ist ein über Körper $K$
-        - $+: V times V -> V, (v,w) -> v + w$
-        - $dot: K times V -> V, (lambda,v) -> lambda v$
-        Es gilt: $lambda,mu in K, space v,w in V$ 
-        - $(lambda mu)v = lambda (mu v)$
-        - $lambda(v + w) = lambda v + lambda w$\
-            $(lambda + mu)v = lambda v + lambda mu$
-        - $1v = v$, $arrow(0) in V$
-        Bsp: $KK^n$ ($RR^n, CC^n$)
-
-        *Untervektorraum:* $U subset V$ \
-        $v,w in U, lambda in K$ \
-        $ <=> v + w in U$, $arrow(0) in U$ UND $lambda v in U$
-        - $(U inter W) subset V$
-    ]
-
-    #bgBlock(fill: colorReihen)[
-        #subHeading(fill: colorReihen)[Basis und Dim]
-        *Linear Abbildung:* $Phi: V -> V$ 
-        - $Phi(0) = 0$
-        - $Phi(lambda v + w) = lambda Phi(v) + Phi(w)$
-        - Menge aller linearen Abbildung: $L(V,W)$
-
-        *Basis:*\
-        linear unabhänige Menge $B$ an $v in V$, sodass $op("spann")(v_1, ..., v_n) = op("spann")(V)$
-        - $B$ ist Erzeugerssystem von $V$
-        - Endliche Erzeugerssystem: $abs(B_1)=abs(B_2)...$
-
-        *Linear unabhänige:*
-        Linearkombintation in welcher $lambda_0 = 0, ..., lambda_n = 0$ die EINZIEGE Lösung für $lambda_0 v_0 + ... + lambda_1 v_1 = 0$
-
-        *Basisergänzungssatz:* \
-        Sei ${v_1, ... v_n}$ lin. unabhänig und $M$ kein Basis. Dann $exists v_(n+1)$ sodass ${v_1, ... v_n, v_(n+1)}$ lin unabhänig (aber evt. eine Basis ist)
-
-        *Dimension:* $dim V = \#$Vektoren der Basis
-        - $dim V = infinity$, wenn $V$ nicht endlich erzeugt ist
-    ]
-
-    #bgBlock(fill: colorAbbildungen)[
-        #subHeading([Abbildungen], fill: colorAbbildungen)
-        
-        $f(x)=y, f: A -> B$
-
-        *Injectiv (Monomorphismus):*\
-        _one to one_ \
-        $f(x) = f(y) <=> x = y$
-
-        *Surjectiv (Epimorhismis):* \
-        _Output space coverered_ \
-        - Zeigen das $f(f^(-1)(x)) = x$ für $x in DD$
-        - $forall x in B: exists x in A : f(x) = y$
-        NICHT surjektiv wenn $abs(a) < abs(b)$
-
-        *Bijektiv (Isomorphismus):* \
-        _Injectiv und Surjectiv_ \
-        - In einer Gruppe ist $f(x) = x c$ für $c,x in G$ bijektiv
-        - isomorph: $V,W$ VRs, $f$ bijektiv $f(V) = W => V tilde.equiv W$
-
-        Beweiß durch Wiederspruch \
-        für Gegenbeweiß
-
-        *Endomorphismus:* $A -> B$ mit $A, B subset.eq C$ 
-
-        *Automorphismus:* Endomorphismus und Bijektiv (Isomorphismus)
-        
-        *Vektorraum-Homomorphismus:* linear Abbildung zwischen VR
-    ]
-
-    #bgBlock(fill: colorAbbildungen)[
-        #subHeading(fill: colorAbbildungen)[Spann und Bild]
-        *Spann:* 
-        - Vektorraum $V : op("spann")(V) = limits(inter)_(M subset V) U$
-        - $B : op("spann")(U) = {lambda_0 v_0 + ... + lambda_n v_n, lambda_0, ... lambda_n in K}$
-        - $op("spann")(Phi(M)) = Phi(op("spann")(M))$
-
-        *Urbild:* $f^(-1)(I subset B) subset.eq A$
-
-        *Bild:* Wertemenge $WW$ 
-        - $f(I subset A) = B$ (Oft $I = A$)
-        - Basis $B : op("spann")(B)$
-        - $op("Bild") Phi := {Phi in W | v in V}$
-
-        *Nullraum/Kern:* \
-        $op("Kern") Phi := {v in V | Phi(v) = 0}$
-
-        *Rang*
-        $op("Rang") f := dim op("Bild") f$
-    ]
-
-]
-

src/cheatsheets/Analysis1.typ

@@ -0,0 +1,760 @@
+#import "@preview/mannot:0.3.1"
+
+#import "../lib/common_rewrite.typ" : *
+#import "../lib/mathExpressions.typ" : *
+
+#set text(7.5pt)
+
+#set page(
+  paper: "a4", 
+  margin: (
+    bottom: 10mm,
+    top: 5mm,
+    left: 5mm,
+    right: 5mm
+  ),
+  flipped:true,
+  footer: context [
+    #grid(
+      align: center,
+      columns: (1fr, 1fr, 1fr),
+      [#align(left, datetime.today().display("[day].[month].[year]"))], 
+      [#align(center, counter(page).display("- 1 -"))], 
+      [#align(right, image("../images/cc0.png", height: 5mm,))]
+    )
+  ],
+)
+
+#place(top+center, scope: "parent", float: true, heading(
+  [Analysis 1 (IE)]
+))
+
+#let SeperatorLine = line(length: 100%, stroke: (paint: black, thickness: 0.3mm))
+#let MathAlignLeft(e) = {
+  align(left, block(e))
+}
+
+#let colorAllgemein = color.hsl(105.13deg, 92.13%, 75.1%)
+#let colorFolgen = color.hsl(202.05deg, 92.13%, 75.1%)
+#let colorReihen = color.hsl(280deg, 92.13%, 75.1%)
+#let colorAbleitung = color.hsl(356.92deg, 92.13%, 75.1%)
+#let colorIntegral = color.hsl(34.87deg, 92.13%, 75.1%)
+
+
+#columns(5, gutter: 2mm)[
+
+  // Allgemeiner Shit
+  #bgBlock(fill: colorAllgemein)[
+    #subHeading(fill: colorAllgemein)[Allgemeins]
+
+    #grid(
+      columns: (1fr, 1fr),
+      inset: 0mm,
+      gutter: 2mm,
+      [
+        *Dreiecksungleichung* \
+        $abs(x + y) <= abs(x) + abs(y)$ \
+        $abs(abs(x) - abs(y)) <=  abs(x - y)$ \
+      ],
+      [
+        *Cauchy-Schwarz-Ungleichung*\
+        $abs(x dot y) <= abs(abs(x) dot abs(y))$ \
+      ],
+      [
+        *Geometrische Summenformel*\
+        $sum_(k=1)^(n) k = (n(n+1))/2$ \
+      ],
+      [
+        *Bernoulli-Ungleichung* \
+        $(1 + a)^n x in RR >= 1 + n a$ \
+      ],
+      [
+        *Binomialkoeffizient* $binom(n, k) = (n!)/(k!(n-k)!)$
+      ],
+      [
+        *Binomische Formel*\
+        $(a + b)^n = sum^(n)_(k=0) binom(n,k) a^(n-k) b^k $ \
+      ],
+      [
+        *Bekannte Werte* \
+          $e approx  2.71828$ ($2 < e < 3$) \
+          $pi approx 3.14159$ ($3 < pi < 4$)
+      ],
+      [
+        *Gaußklammer*: \
+          $floor(x) = text("floor")(x)$ \
+          $ceil(x) = text("ceil")(x)$ \
+      ],
+      [
+        *Fakultäten* $0! = 1! = 1$ \
+      ],
+      [
+        *Mitternachtsformel*
+        $x_(1,2) =  (-b plus.minus sqrt(b^2 + 4a c))/(2a)$
+      ],
+      [
+        *Binomische Formel*\
+        $(a + b)^2 = a^2 + 2a b + b^2$\
+        $(a - b)^2 = a^2 - 2a b + b^2$\
+        $(a + b)(a - b) = a^2 - b^2$\
+      ]
+    )
+  ]
+
+  // Complex Zahlen
+  #bgBlock(fill: colorAllgemein)[
+    #subHeading(fill: colorAllgemein)[Complexe Zahlen]
+
+    #ComplexNumbersSection()
+
+    #grid(
+      columns: (1fr, 1fr),
+      row-gutter: 2mm,
+      [$ sin(x) = (e^(i x) - e^(-i x))/(2i) $],
+      [$ cos(x) = (e^(i x) + e^(-i x))/(2) $],
+      grid.cell(
+        colspan: 1,
+        align: center,
+        $ tan(x) = 1/2i ln((1+i x)/(1-i x)) $
+      ),
+      grid.cell(
+        colspan: 1,
+        align: center,
+        $ arctan(x) = 1/2i ln((1+i x)/(1-i x)) $
+      )
+        
+    )
+    #subHeading(fill: colorAllgemein)[Trigonmetrie]
+    *Additionstheorem* \
+    $sin(x+y) = cos(x)sin(y) + sin(x)cos(y)$ \
+    $cos(x+y) = cos(x)cos(y) - sin(x)sin(y)$ \
+    $tan(x +y) = (tan(a) + tan(b))/(1 - tan(a) tan(b))$ \
+    $arctan(x) + arctan(y) = arctan((x+y)/(1 - x y))$ \
+    $arctan(1/x) + arctan(x) = cases(
+      x > 0 : pi/2,
+      x < 0 : -pi/2
+    )$
+
+    *Doppelwinkel Formel* \
+    $cos(2x) = cos^2(x) - sin^2(x)$ \
+    $sin(2x) = 2sin(x)cos(x)$
+
+    #grid(
+      gutter: 2mm,
+      columns: (auto, auto, auto),
+      $cos^2(x) = (1 + cos(2x))/2$,
+      $sin^2(x) = (1 - cos(2x))/2$,
+      $cos(-x) = cos(x)$,
+      $sin(-x) = -sin(x)$,
+      grid.cell(colspan: 2, $cos^2(x) + sin^2(x) = 1$)
+    )
+
+    Subsitution mit Hilfsvariable
+
+    #grid(
+      gutter: 5mm,
+      row-gutter: 3mm,
+      columns: (auto, auto),
+      [$tan(x)=sin(x)/cos(x)$],
+      [$cot(x)=cos(x)/sin(x)$],
+      [$tan(x)=-cot(x + pi/2)$],
+      [$cot(x)=-tan(x + pi/2)$],
+      [$cos(x - pi/2) = sin(x)$],
+      [$sin(x + pi/2) = cos(x)$],    
+    
+    )
+    $sin(x)cos(y) = 1/2sin(x - y) + 1/2sin(x + y)$
+
+    Für $x in [-1, 1]$ \
+    $arcsin(x) = -arccos(x) - pi/2 in [-pi/2, pi/2]$ \
+    $arccos(x) = -arcsin(x) + pi/2 in [0, pi]$
+  ]
+
+  // Folgen Allgemein
+  #bgBlock(fill: colorFolgen)[
+    #subHeading(fill: colorFolgen)[Folgen]
+
+    *Beschränkt:* $exists k in RR$ sodass $abs(a_n) <= k$
+    - Beweiße: durch Induktion
+    - Beweiße: Hat min. ein konvergent Teilefolge
+    - (Beweiße: Ungleichung $abs(a_n) <= k$)
+
+    *Monoton fallend/steigended*
+    - Beweise: Induktion
+    #grid(columns: (1fr, 1fr),
+      inset: 0.2mm,
+      align(top+center, [*Fallend*]), align(top+center, [*Steigend*]),
+      [$ a_(n+1) <= a_(n), quad a_(n+1) >= a_(n) $],
+      [$ a_(n+1)/a_(n) < 1, quad a_(n+1)/a_(n) > 1 $],
+    )
+
+    *Konvergentz Allgemein*
+    $lim_(n -> infinity) a_n = a$
+
+    $forall epsilon > 0 space exists n_epsilon in NN$ sodass \
+    - Konvergent $-> a$: $a_n in [a - epsilon, a + epsilon] $
+    - Divergent $-> infinity$: $a_n in [epsilon, infinity) $
+    - Divergent $-> infinity$: $a_n in (-infinity, epsilon) $
+
+    $space forall n > n_epsilon$
+
+    *Konvergentz Häufungspunkte*
+    - $a_n -> a <=>$ Alle Teilfolgen $-> a$
+
+    *Folgen in $CC$* (Alle Regeln von $RR$ gelten)\
+    - $z_n in CC : lim z_n <=> lim abs(z_n) = 0$
+    - Zerlegen in $a + b i$ oder $abs(z) dot e^(i phi)$
+  ]
+
+  // Folgen Strat
+  #bgBlock(fill: colorFolgen)[
+    #subHeading(fill: colorFolgen)[Folgen Konvergenz Strategien]
+    - Von Bekannten Ausdrücken aufbauen
+    - *Monoton UND Beschränkt $=>$ Konvergenz*
+    - Fixpunk Gleichung: $a = f(a)$ \
+      für rekusive $a_(n+1) = f(a_n)$ (Zu erst machen!)
+    - Bernoulli-Ungleichung Folgen der Art $(a_n)^n$: \
+      $(1 + a)^n >= 1 + n a$
+    - Sandwitchtheorem:\
+      $b_n -> x$: $a_n <= b_n <= c_n$, wenn $a_n -> x$ und $c_n -> x$ \
+    - Zwerlegen in Konvergente Teil folgen \
+      (Vorallem bei $(-1)^n dot a_n$)
+    - (Cauchyfolge \
+      $forall epsilon > 0 space exists n_epsilon in NN space$ sodass \
+      $forall m,n >= n_epsilon : abs(a_n - a_m) < epsilon$ \
+      Cauchyfolge $=>$ Konvergenz)
+
+
+    *Divergenz*
+    - $a_n$ unbeschränkt $=>$ divergenz
+    - Vergleichskriterium: \
+      $b_n -> -infinity$: $b_n <= c_n$, wenn $c_n -> -infinity$ \
+      $b_n -> +infinity$: $c_n <= b_n $, wenn $a_n -> +infinity$
+  ]
+
+  // L'Hospital
+  #bgBlock(fill: colorFolgen)[
+    #subHeading(fill: colorFolgen)[L'Hospital]
+    $x in (a,b): limits(lim)_(x->b)f(x)/g(x)$
+
+    (Konvergenz gegen $b$, beliebiges $a$)
+
+    Bendingungen:
+    1. $limits(lim)_(x->b)f(x) = limits(lim)_(x->b)g(x)= 0 "oder" infinity$
+    2. $g'(x) != 0, x in (a,b)$
+    3. $limits(lim)_(x->b) (f'(x))/(g'(x))$ konveriert
+
+    $=> limits(lim)_(x->b) (f'(x))/(g'(x)) = limits(lim)_(x->b) (f(x))/(g(x))$
+
+    Kann auch Reksuive angewendet werden!
+
+    Bei "$infinity dot 0$" mit $f(x)g(x) = f(x)/(1/g(x))$
+  ]
+
+  // Bekannte Folgen
+  #bgBlock(fill: colorFolgen)[
+    #subHeading(fill: colorFolgen)[Bekannte Folgen]
+    #grid(
+      columns: (auto, auto),
+      align: bottom,
+      gutter: 2mm,
+      [$ lim_(n->infinity) (a_n + b_n) = a + b $],
+      grid.cell(
+        rowspan:  2,
+        [$ lim_(n->infinity) (a_n / b_n) = a / b $ für ($b != 0$)],
+      ),
+      MathAlignLeft($ lim_(n->infinity) (a_n dot b_n) = a dot b $),
+      MathAlignLeft($ lim_(n->infinity) sqrt(a_n) = sqrt(a) $),
+      MathAlignLeft($ lim_(n->infinity) abs(a_n) = abs(a) $),
+      MathAlignLeft($ lim_(n->infinity) c dot a_n = c dot lim_(n->infinity) a_n $),
+    )
+    
+    #grid(
+      columns: (auto, auto),
+      column-gutter: 4mm,
+      row-gutter: 2mm,
+      align: bottom,
+      MathAlignLeft($ lim_(n->infinity) 1/n = 0 $),
+      MathAlignLeft($ lim_(n->infinity) sqrt(n) = + infinity $),
+      MathAlignLeft($ lim_(n->infinity) k = k, k in RR $), 
+      MathAlignLeft($ e^x = lim_(n->infinity) (1 + x/n)^n $),
+      grid.cell(colspan: 2, MathAlignLeft($ lim_(n->infinity) q^n = cases(
+        0 &abs(q),
+        1 &q = 1,
+        plus.minus infinity &q < -1,
+        plus infinity #h(5mm) &q > 1
+      ) $)), []
+    )
+  ]
+
+  // Teilfolgen
+  #bgBlock(fill: colorFolgen)[
+    #subHeading(fill: colorFolgen)[Teilfolgen]
+    $ a_k subset a_n space (text("z.B") k= 2n + 1) $
+    - Index muss streng monoton steigen!
+    - Beschränkte $a_n => text("min eine konvergente") a_k$
+    - Konvergenz-Werte von $a_k$ sind Häufungspunkte
+    - Wenn alle $a_k$ gegen #underline([genau eine]) Häufungspunk konverigiert $<=> a_n$ konvergent 
+  ]
+
+  // Reihen
+  #bgBlock(fill: colorReihen)[
+    #subHeading(fill: colorReihen)[Reihen]
+    $limits(lim)_(n->infinity) a_n != 0 => limits(sum)_(n=1)^infinity a_n$ konverigiert NICHT \
+
+    - *Absolute Konvergenz* \
+      $limits(sum)_(n=1)^infinity abs(a_n) = a => limits(sum)_(n=1)^infinity a_n$ konvergent 
+    
+    - *Partialsummen* \
+      ALLE Partialsummen von $limits(sum)_(k=1)^infinity abs(a)$ beschränkt\
+      $=>$ _Absolute Konvergent_
+
+    - *(Cauchy-Kriterium)*\
+      konvergent wenn $forall epsilon > 0 space exists n_epsilon in NN$ \
+      sodass $abs(s_n - s_m) = abs(limits(sum)_(k=m+1)^(n)) < epsilon space$ \
+      $forall n_epsilon < m < n $
+
+    - *Leibnitzkriterium* \
+      Alternierend + Nullfolge \
+      $=> limits(sum)_(n=1)^infinity (-1)^n dot a_n$ konvergent
+
+    - *Vergleichskriterium* \
+      $a_n, b_n : abs(a_n) <= b_n space forall n in NN > N_0, N_0 in NN$
+      1. $limits(sum)_(n=0)^infinity b_n$ konvergent $=> limits(sum)_(n=0)^infinity abs(a_n)$ konvergent \
+        Suche $b_n$ für Konvergenz
+      2. $limits(sum)_(n=0)^infinity abs(a_n)$ divergent $=> limits(sum)_(n=0)^infinity b_n$ divergent \
+        Suche $abs(a_n)$ für Divergenz
+
+      Nützlich:
+      - Dreiecksungleichung
+      - $forall space n > N_0 in NN space exists k,q in RR$ \
+        sodass $q > 1$: $n^k <= q^n$ (Potenz stärker Polynom)
+
+    - *Quotientenkriterium und Wurzelkriterium*
+      1. $rho = lim_(n -> infinity) abs((a_(n+1))/(a_n)) $
+      2. $rho = lim_(n -> infinity) root(n, abs(a_(n+1))) $ \
+      
+      divergent: $rho > 1$, keine Aussage $rho = 1$, konvergent $rho < 1$
+
+    *Reihen in $CC$*
+    - Alles 
+  ]
+
+  // Potenzreihen
+  #bgBlock(fill: colorReihen)[
+    #subHeading(fill: colorReihen)[Potenzreihen]
+    $P(z) = sum_(n=0)^infinity a_n dot (z- z_0)^n quad z,z_0 in CC$
+
+    #grid(
+      columns: (auto, auto),
+      column-gutter: 5mm,
+      row-gutter: 1.5mm,
+    
+      [*Konvergenzradius*], [$|z - z_0| < R : $ absolute Konvergenz],
+      [], [$|z - z_0| = R : $ Keine Aussage],
+      [], [$|z - z_0| > R : $ Divergent]
+    )
+
+    #grid(
+      columns: (1fr, 1fr),
+      $R = lim_(n->infinity) abs(a_n/(a_(n+1))) = 1/(lim_(n->infinity) root(n, abs(a_n)))$,
+      $R = limits(liminf)_(n->infinity) abs(a_n/(a_(n+1))) = 1/(limits(limsup)_(n->infinity) root(n, abs(a_n)))$
+    )
+
+  ]
+
+  // Bekannte Reihen
+  #bgBlock(fill: colorReihen)[
+    #subHeading(fill: colorReihen)[Bekannte Reihen]
+    *Geometrische Reihe:* $sum_(n=0)^infinity q^n$
+    - konvergent $abs(q) < 1$, divergent  $abs(q) >= 1$
+    - Grenzwert: (Muss $n=0$) $=1/(1-q)$
+
+    *Harmonische Reihe:* $sum_(n=0)^infinity 1/n = +infinity$
+
+    *Binomische Reihe:* 
+    
+    *Reihendarstellungen*
+    #grid(
+      columns: (1fr, 1fr),
+      gutter: 3mm,
+      row-gutter: 3mm,
+      $e^x = limits(sum)_(n=0)^infinity (x^n)/(n!)$,
+      $ln(x) = limits(sum)_(n=0)^infinity (-1)^n x^(n+1)$,
+      $sin(x) = limits(sum)_(n=0)^infinity (-1)^n (z^(2n+1))/((2n + 1)!)$,
+      $cos(x) = limits(sum)_(n=0)^infinity (-1)^n (z^(2n))/((2n)!)$
+    )
+  ]
+
+  // Ableitung
+  #bgBlock(fill: colorAbleitung)[
+    #subHeading(fill: colorAbleitung)[Funktionen]
+
+    $f(x) = y, f : A -> B$
+
+    *Injectiv (Monomorphismus):* one to one\ 
+    $f(x) = f(y) <=> x = y quad$
+    
+    *Surjectiv (Epimorhismis):* Output space coverered \
+    - $forall x in B : exists x in A : f(x) = y$
+
+    *Bijektiv*
+
+    injektiv UND Surjectiv $<=>$ Umkehrbar
+  ]
+
+  // Funktions Sätze
+  #bgBlock(fill: colorAbleitung)[
+    #subHeading(fill: colorAbleitung)[Funktionen Sätze]
+    $f(x)$ diff'bar $=> f(x)$ stetig
+
+    $f(x)$ stetig diff'bar $=> f(x)$ diff'bar, stetig UND $f'(x)$ stetig
+
+    #line(length: 100%, stroke: 0.3mm)
+
+    Sei $f : I =[a,b] -> RR$, stetig auf $x in I$
+
+
+    - *Zwischenwertsatz* \
+      $=> forall y in ["min", "max"] space exists text("min. ein") x in [a,b] : f(x) = y$ \
+      _Beweiß für mindest. n Nst_
+
+    - *Mittelwertsatz der Diff'rechnung* \
+      diff'bar $x in (a,b)$ \
+      $=> exists x_0 : f'(x_0)=(f(b) - f(a))/(a-b)$
+
+    - *Mittelwertsatz der Integralrechnung*\
+      $g -> RR "integrierbar," g(x)>= 0 forall x in [a,b]$\
+      $exists xi in [a,b] : integral_a^b  f(x)g(x) d x = f(xi) integral_a^b g(x) d x$
+
+    - *Satze von Rolle* \
+      diffbar $x in (a,b)$\
+      $f(a) = f(b) => exists text("min. ein") x_0 in (a,b) : f'(x_0) = 0$\
+      _Beweiß für max. n Nst, durchWiederspruchsbweiß mit $f(a)=f(b)=0$ und Wiederholte Ableitung_
+
+    - *Hauptsatz der Integralrechung*
+      Sei $f: [a,b] -> RR$ stetig
+
+      $F(x) = integral_a^x f(t) d t, x in [a,b]$\
+      $=> F'(x) = f(x) forall x in [a,b]$
+  ]
+
+  // Stetigkeit
+  #bgBlock(fill: colorAbleitung)[
+    #subHeading(fill: colorAbleitung)[Stetigkeit]
+    *Allgemein*
+    
+    $f(x)$ ist stetig wenn: \
+    $ limits(lim)_(x->x_0-) f(x) = limits(lim)_(x->x_0+) f(x) = f(x_0) $ \
+    $x in DD$ Beachten! Definitionslücken $!=$ unstätig \
+    Definition gilt auch für $I subset RR$
+
+    *Regeln*
+
+    $f(x),g(x)$ seinen stetig dann sind auch Stetig:
+
+    #grid(columns: (auto, auto, auto, auto, auto),
+      column-gutter: 4mm,
+      row-gutter: 2mm, 
+      $f(x) + g(x)$, $f circle.small g$, $alpha dot f(x)$,
+      $f(x)/g(x)$, $f(x) dot g(x)$
+    )
+
+    *Bekannte Funktion*
+    #table(
+      columns: (1fr, 1fr),
+      table.header(
+        [*Stetig*], [*Nicht Stetig*]
+      ),
+      stroke: (x, y) => (x: 0mm, y: 0.2mm),
+      [
+        - Polynome, gebrochen Rationale Fn
+        - $floor(x),ceil(x)$ für $x in RR without ZZ$
+        - Betrags Funktion
+        - $sin, cos, tan$
+      ],
+      [
+        - Stufenfunktion
+        - Fall Unterscheidungen
+        - $floor(x),ceil(x)$ für $x in RR$
+      ]
+    )
+  ]
+
+  // Ableitung
+  #bgBlock(fill: colorAbleitung)[
+    #subHeading(fill: colorAbleitung)[Ableitung]
+    *Differenzierbarkeit*
+    - $f(x)$ ist an der Stelle $x_0 in DD$ diffbar wenn \
+      #MathAlignLeft($ f'(x_0) = lim_(x->x_0 plus.minus) (f(x_0 + h - f(x_0))/h) $)
+    - Tangente an $x_0$: $f(x_0) + f'(x_0)(x - x_0)$
+      - Beste #underline([linear]) Annäherung
+      - Tangente $t(x)$ von $f(x)$ an der Stelle $x_0$: $ lim_(x->0) (f(x) - f(x_0))/(x-x_0) -f'(x_0) =0 $
+
+    *Ableitung Regeln*
+
+    #grid(
+      row-gutter: 3mm,
+      columns: (1fr, 1fr),
+      grid.cell(
+        colspan: 2,
+        [$f(x) + g(x) : f'(x) + g'(x) $]
+      ),
+      grid.cell(
+        colspan: 2,
+        [$f(x) dot g(x) : f'(x)g(x) + f(x)g'(x) $]
+      ),
+      grid.cell(
+        colspan: 2,
+        [#MathAlignLeft($ f(x)/g(x) : (f'(x)g(x) - f(x)g'(x))/(g(x)^2) $)]
+      ),
+      [$f(x) = c : f'(x) = 0$],
+      [$c dot f(x) : c dot f'(x)$],
+      [$(x^(-n)) n in NN : n x^(n-1)$],
+      [$e^(x) : e^(x)$],
+    )
+    - Kettenregel: $f(g(x)) : f'(g(x)) dot g'(x)$
+  ],
+
+  // Ableitungstabelle
+  #block([
+    #set text(size: 7pt)
+    #table(
+      align: horizon, 
+      columns: (auto, auto, auto),
+      table.header([*$F(x)$*], [*$f(x)$*], [*$f'(x)$*]),
+      row-gutter: 1mm,
+      inset: 1.4mm,
+      fill: (x, y) => if calc.rem(x, 3) == 0 { color.hsl(180deg, 89.47%, 88.82%) }
+        else if calc.rem(x, 3) == 1 { color.hsl(180deg, 100%, 93.14%) } else 
+          { color.hsl(180deg, 81.82%, 95.69%) },
+      [$1/(q + x) x^(q+1)$], [$x^q$], [$q x^(q-1)$],
+      [$ln abs(x)$], [$1/x$], [$-1/x^2$],
+      [$x ln(a x) - x$], [$ln(a x)$], [$a / x$],
+      [$2/3 sqrt(a x^3)$], [$sqrt(a x)$], [$a/(2 sqrt(a x))$],
+      [$e^x$], [$e^x$], [$e^x$],
+      [$a^x/ln(a)$], [$a^x$], [$a^x ln(a)$],
+      $-cos(x)$, $sin(x)$, $cos(x)$,
+      $sin(x)$, $cos(x)$, $-sin(x)$,
+      $-ln abs(cos(x))$, $tan(x)$, $1/(cos(x)^2)$,
+      $ln abs(sin(x))$, $cot(x)$, $-1/(sin(x)^2)$,
+
+      [$x arcsin(x) + sqrt(1 - x^2)$],
+      [$arcsin(x)$], [$1/sqrt(1 - x^2)$],
+
+      [$x arccos(x) - sqrt(1 - x^2)$],
+      [$arccos(x)$], [$-1/sqrt(1 - x^2)$],
+
+      [$x arctan(x) - 1/2 ln abs(1 + x^2)$],
+      [$arctan(x)$], [$1/(1 + x^2)$],
+
+      [$x op("arccot")(x) + 1/2 ln abs(1 + x^2)$],
+      [$op("arccot")(x)$], [$-1/(1 + x^2)$],
+
+      [$x op("arsinH")(x) + sqrt(1 + x^2)$],
+      [$op("arsinH")(x)$], [$1/sqrt(1 + x^2)$],
+
+      [$x op("arcosH")(x) + sqrt(1 + x^2)$],
+      [$op("arcosH")(x)$], [$1/sqrt(x^2-1)$],
+
+      [$x op("artanH")(x) + 1/2 ln(1 - x^2)$],
+      [$op("artanH")(x)$], [$1/(1 - x^2)$],
+    )
+  ])
+
+  // Extremstellen, Krümmung, Monotonie
+  #bgBlock(fill: colorAbleitung)[
+    #subHeading(fill: colorAbleitung)[Extremstellen, Krümmung, Monotonie]
+
+    *Monotonie* $forall x_0,x_1 in I, x_0 < x_1 <=> f(x_0) <= f(x_1)$
+
+    Hinreichende: $f'(x) >= 0$ \
+    Konstante Funktion bei $f'(x) = 0$ 
+
+    *Streng Monoton*
+    $forall x_0,x_1 in I, x_0 < x_1 <=> f(x_0) < f(x_1)$ \
+    
+    Notwendig: $f'(x) >= 0$ (Aber nicht hinreichend)
+
+    *Extremstellen Kandiaten*
+    1. $f'(x) = 0$
+    2. Definitionslücken
+    3. Randstellen von $DD$
+
+    #grid(columns: (1fr, 1fr),
+      gutter: 2mm,
+      [
+        *Minima*\
+        $x_0,x in I : f(x_0) < f(x)$ \
+        $f''(x) > 0 $ \
+        $f'(x) : - space 0 space +$ 
+      ],
+      [
+        *Maxima*\
+        $x_0,x in I : f(x_0) > f(x)$ \
+        $f''(x) < 0$ \
+        $f'(x) : + space 0 space -$
+      ],
+      [
+        *Wendepunkt*\
+        $f''(x) = 0$ \
+        $f'(x) : plus.minus space ? space plus.minus$
+      ],
+      [
+        *Stattelpunkt/Terrasenpunkt* \
+        $f'''(x) != 0$
+        $f''(x) = 0$ UND $f'(x) = 0$ \
+        $f'(x) : plus.minus space 0 space plus.minus$ \
+      ],
+      [
+        *Extremstelle* \
+        $f'(x) = 0$
+      ]
+    )
+
+    #grid(columns: (1fr, 1fr),
+      gutter: 2mm,
+      [
+        *konkav* $f''(x) <= 0$ \ rechtsgekrümmt \
+        Sekante liegt unter $f(x)$ \
+        (eingebäult, von $y= -infinity$ aus)
+      ],
+      [
+        *konvex* $f''(x) >= 0$ \ linksgekrümmt \
+        Sekante liegt über $f(x)$ \
+        (ausgebaucht, von $y= -infinity$ aus)
+      ]
+    )
+
+    *Strange Konkav/Konvex* \
+    Notwendig $f''(x) lt.gt 0$
+  ]
+
+  // Integral
+  #bgBlock(fill: colorIntegral, [
+    #subHeading(fill: colorIntegral, [Integral])
+
+    Wenn $f(x)$ stetig und monoton $=>$ integrierbar
+
+    Summen: $integral f(x) + g(x) d x = integral f(x) d x + integral g(x)$
+
+    Vorfaktoren: $integral lambda f(x) d x = lambda f(x) d x$
+
+    *Ungleichung:* \
+    $f(x) <= q(x) forall x in [a,b] => integral_a^b f(x) d x <= integral_a^b g(x) d x$ \
+    $abs(integral_a^b f(x) d x) <= integral_a^b abs(f(x)) d x$
+
+    *Partial Integration*
+    
+    $integral u(x) dot v'(x) d x = u(x)v(x) - integral u'(x) dot v(x)$
+
+    $integral_a^b u(x) dot v'(x) d x = [u(x)v(x)]_a^b - integral_a^b u'(x) dot v(x)$
+
+    *Subsitution*
+
+    $integral_(x_0)^(x_1) f\(underbrace(g(x), "t")\) dot g'(x) d x$
+    
+    1. Ersetzung: $t := g(x)$
+    2. Umformen:
+      $(d y)/(d x) = g'(x)$
+    3. $x$-kürzen sich weg
+  ])
+
+  #bgBlock(fill: colorIntegral, [
+    #subHeading(fill: colorIntegral, [Integral])
+
+    *Riemann Integral*\
+    $limits(sum)_(x=a)^(b) f(i)(x_())$
+
+    Summen: $integral f(x) + g(x) d x = integral f(x) d x + integral g(x)$
+
+    Vorfaktoren: $integral lambda f(x) d x = lambda f(x) d x$
+
+    *Integral Type*\
+    - Eigentliches Int.: $integral_a^b f(x) d x$ 
+    - Uneigentliches Int.: \ 
+      $limits(lim)_(epsilon -> 0) integral_a^(b + epsilon) f(x) d x$ \
+      $limits(lim)_(epsilon -> plus.minus infinity) integral_a^(epsilon) f(x) d x$
+    - Unbestimmtes Int.: $integral f(x) d x = F(x) + c, c in RR$- Uneigentliches Int.: 
+    
+    *Cauchy-Hauptwert*
+
+    $integral_(-infinity)^(+infinity) f(x)$ \
+    NUR konvergent wenn: \
+    $limits(lim)_(R -> -infinity) integral_(R)^(a) f(x) d x$ und $limits(lim)_(R -> infinity) integral_(a)^(R) f(x) d x$ konvergent für $a in RR$
+
+    $integral_(-infinity)^(infinity) f(x) d x$ existiert \
+    $=> lim_(M -> infinity) integral_(-M)^(M) f(x) d x = integral_(-infinity)^(infinity) f(x) d x$ 
+
+    *Partial Integration*
+    
+    $integral u(x) dot v'(x) d x = u(x)v(x) - integral u'(x) dot v(x)$
+
+    *Subsitution*
+
+    $integral_(x_0)^(x_1) f\(underbrace(g(x), "t")\) dot 1/(g'(x)) d x$
+    
+    1. Ersetzung: $ d x := d t dot g'(x)$ und $t := g(x)$
+    2. Grenzen: $t_0 = g(x_0)$, $t_1 = g(x_1)$
+    3. $x$-kürzen sich weg
+
+    *Absolute "Konvergenz"* \
+    Wenn $g(x)$ konvergent, 
+    $abs(f(x)) <= g(x) => $ $f(x)$ konvergent
+  ])
+
+  #bgBlock(fill: colorIntegral, [
+    #subHeading(fill: colorIntegral)[Partial-Bruch-Zerlegung]
+    Form: $integral "Zähler Polynom"/"Nenner Polynom"$,
+    $deg("Nenner") < deg("Zähler")$
+    1. $deg("Zähler") >= deg("Nenner") ->$ *Polynomdivision*
+    2. *Faktorisieren des Nenners (Nst finden)*, \
+      Polynomdivision, Raten, Binomische Formel \
+      Resulat: $N = (x - x_0)^(n_0+)(x - x_1)^(n_1)... (x^2+b x + c)^(m_1)$
+    3. *Ansatz:* $A$\
+      $(x-x_0)^n -> A/((x - x_0)^n) + B/((x - x_0)^(n-1)) ... + C/(x - x_0)$\
+      $(x^2 + b x + c)^n -> (A x + B)/((x^2 + b x + c)^n) ... + (C x + D)/((x^2 + b x + c)^1) $
+
+    4. *Durchmul.* $"Ansatz" dot 1/("Fakt. Nenner") = "Zähler"$
+    5. $A,B,...$ :
+      Nst einsetzen, dann Koeffizientenvergleich
+    6. *Intergral wiederzusammen setzen $+c$*
+    7. Summen teile Integrieren
+
+    $delta = 4a - b^2$
+    #grid(columns: (auto, auto),
+      row-gutter: 2mm,
+      column-gutter: 2mm,
+      $integral 1/(x - x_0)$, $ln abs(x - x_0)$,
+      $integral 1/((x - x_0)^n)$, $-1/((n-1)(x-x_0)^(n-1))$,
+      $integral 1/(x^2 + b x + c)$, $2/sqrt(delta) arctan((2x + b)/sqrt(delta))$,
+      $integral 1/((x^2 + b x + c)^n)$, $(2x + b)/((n-1)(sigma)(x^2+b x +c)^(n-1)) + \
+        (2(2n-3))/((n-1)(delta)) + (C )
+      $,
+    )
+
+
+
+  ])
+
+  #bgBlock(fill: colorAllgemein, [
+    #subHeading(fill: colorAllgemein, [Sin-Table])
+    #sinTable
+  ])
+
+  #bgBlock(fill: colorAllgemein, [
+    #subHeading(fill: colorAllgemein)[Notwending und Hinreiched]
+
+    #grid(columns: (1fr, 1fr),
+      gutter: 2mm,
+      inset: (left: 2mm, right: 2mm),
+      $not "not." => not "Satz"$,
+      $"hin." => "Satz"$,
+      $"Satz" => forall "not." $,
+      $not "Satz" => forall not "hin." $,
+
+      $"not." arrow.r.double.not "Satz"$,
+      $not "hin." arrow.r.double.not "Satz"$,
+    )
+  ])
+]

src/cheatsheets/CT.typ

@@ -0,0 +1,154 @@
+#import "../lib/styles.typ" : *
+#import "../lib/common_rewrite.typ" : *
+#import "@preview/cetz:0.4.2"
+
+#set page(
+  paper: "a4", 
+  margin: (
+    bottom: 10mm,
+    top: 5mm,
+    left: 5mm,
+    right: 5mm
+  ),
+  flipped:true,
+  numbering: "— 1 —",
+  number-align: center
+)
+
+#set text(size: 8pt)
+
+#place(top+center, scope: "parent", float: true, heading(
+  [Computer Technik/Programmierpraktikum EI]
+))
+
+#let Allgemein = color.hsl(105.13deg, 92.13%, 75.1%)
+#let colorProgramming = color.hsl(330.19deg, 100%, 68.43%)
+#let colorNumberSystems = color.hsl(202.05deg, 92.13%, 75.1%)
+// #let colorVR = color.hsl(280deg, 92.13%, 75.1%)
+// #let colorAbbildungen = color.hsl(356.92deg, 92.13%, 75.1%)
+// #let colorGruppen = color.hsl(34.87deg, 92.13%, 75.1%)
+
+
+#let SeperatorLine = line(length: 100%, stroke: (paint: black, thickness: 0.3mm))
+#let MathAlignLeft(e) = {
+  align(left, block(e))
+}
+#columns(2, gutter: 2mm)[
+  #bgBlock(fill: colorNumberSystems)[
+    #subHeading(fill: colorNumberSystems)[ASCII Ranges]
+
+    #table(
+      columns: (1fr, 1fr, 1fr),
+      [Range], [Hex], [Bits],
+      [Upper Case], raw("0x41-0x5A"), [#raw("010XXXXX") (bit 6)],
+      [Lower Case], raw("0x61-0x7A"), [#raw("011XXXXX") (bit 6)],
+      [Numbers (0-9)], raw("0x30-0x39"), [#raw("0011XXXX")],
+      [Ganz ASCII], raw("0x00-0x7F"), [#raw("0XXXXXXX")],
+    )
+  ]
+
+  #bgBlock(fill: colorNumberSystems)[
+    #subHeading(fill: colorNumberSystems)[Einer-Kompilment, Zweier-Kompliment, Float (IEEE 754)]
+
+    *Float (IEEE 754)*
+
+    #cetz.canvas({
+      import cetz.draw : *
+      let cell_size = 0.3;
+      
+      let manntise_stop = 22;
+      let exponent_start = 23;
+      let exponent_stop = 30;
+      let sign_bit = 31;
+      let total_bits = sign_bit + 1;
+
+
+      for i in range(total_bits) {
+        let bit = 31 - i;
+
+        rect((i*cell_size, 0), (i*cell_size+cell_size, 0.5),
+          fill: if bit == sign_bit { rgb("#8fff57") } else { 
+            if ( bit >= exponent_start and bit <= exponent_stop) { rgb("#ffe057") } else { if (bit <= manntise_stop) {rgb("#57a5ff")} else { white } }
+          },
+          stroke: (thickness: 0.2mm)
+        )
+  
+        content((i*cell_size + 0.5*cell_size, 0.25), raw(str(0)))
+      }
+
+      content((cell_size, 0.7), [sign], anchor: "east")
+      content((5*cell_size, 0.7), [Exponent (#str(exponent_stop - exponent_start + 1) bit)])
+      content((20*cell_size, 0.7), [Mantisse/Wert (#str(manntise_stop+1) bit)])
+
+      rect((0,0), (32*cell_size, 0.5))
+
+      content((cell_size*(total_bits - sign_bit), -0.2), anchor: "south", raw(str(sign_bit)), angle: 90deg)
+
+      content((cell_size*(total_bits - exponent_stop), -0.2), anchor: "south", raw(str(exponent_stop)), angle: 90deg)
+
+      content((cell_size*(total_bits - exponent_start), -0.2), anchor: "south", raw(str(exponent_start)), angle: 90deg)
+
+      content((cell_size*(total_bits - manntise_stop), -0.2), anchor: "south", raw(str(manntise_stop)), angle: 90deg)
+
+      content((cell_size*(total_bits), -0.2), anchor: "south", raw(str(0)), angle: 90deg)
+    })
+
+    #cetz.canvas({
+      import cetz.draw : *
+      let cell_size = 0.21;
+      
+      let manntise_stop = 51;
+      let exponent_start = 52;
+      let exponent_stop = 62;
+      let sign_bit = 63;
+      let total_bits = sign_bit + 1;
+
+
+      for i in range(total_bits) {
+        let bit = sign_bit - i;
+
+        rect((i*cell_size, 0), (i*cell_size+cell_size, 0.5),
+          fill: if bit == sign_bit { rgb("#8fff57") } else { 
+            if ( bit >= exponent_start and bit <= exponent_stop) { rgb("#ffe057") } else { if (bit <= manntise_stop) {rgb("#57a5ff")} else { white } }
+          },
+          stroke: (thickness: 0.2mm)
+        )
+  
+        content((i*cell_size + 0.5*cell_size, 0.25), raw(str(0)))
+      }
+
+      content((cell_size, 0.7), [sign], anchor: "east")
+      content((7*cell_size, 0.7), [Exponent (#str(exponent_stop - exponent_start + 1) bit)])
+      content((20*cell_size, 0.7), [Mantisse/Wert (#str(manntise_stop+1) bit)])
+
+      rect((0,0), (total_bits*cell_size, 0.5))
+
+      content((cell_size*(total_bits - sign_bit), -0.2), anchor: "south", raw(str(sign_bit)), angle: 90deg)
+
+      content((cell_size*(total_bits - exponent_stop), -0.2), anchor: "south", raw(str(exponent_stop)), angle: 90deg)
+
+      content((cell_size*(total_bits - exponent_start), -0.2), anchor: "south", raw(str(exponent_start)), angle: 90deg)
+
+      content((cell_size*(total_bits - manntise_stop), -0.2), anchor: "south", raw(str(manntise_stop)), angle: 90deg)
+
+      content((cell_size*(total_bits), -0.2), anchor: "south", raw(str(0)), angle: 90deg)
+    })
+  ]
+
+  #bgBlock(fill: colorProgramming)[
+    #subHeading(fill: colorProgramming)[C]
+
+    #table(
+      columns: (auto, 1fr),
+      fill: white,
+      raw("restrict", lang: "c"), [
+        Funktions Argument modifier
+
+        Gibt compiler den hint, das eine Pointer nur in der Funktion verwedent wird. Kann besser optimiert werden
+      ],
+      raw("volatile", lang: "c"), [
+        Zwingt Compiler den Funktion/Variable nicht wegzuoptimieren
+      ]
+    )
+  ]
+]

src/cheatsheets/Digitaltechnik.typ

@@ -0,0 +1,625 @@
+#import "@preview/mannot:0.3.1"
+#import "@preview/cetz:0.4.2"
+#import "@preview/zap:0.5.0"
+
+#import "../lib/common_rewrite.typ" : *
+#import "../lib/truthtable.typ" : *
+#import "../lib/fetModel.typ" : *
+
+#show math.integral: it => math.limits(math.integral)
+#show math.sum: it => math.limits(math.sum)
+
+#set page(
+  paper: "a4", 
+  margin: (
+    bottom: 10mm,
+    top: 5mm,
+    left: 5mm,
+    right: 5mm
+  ),
+  flipped:true,
+  footer: context [
+    #grid(
+      align: center,
+      columns: (1fr, 1fr, 1fr),
+      [#align(left, datetime.today().display("[day].[month].[year]"))], 
+      [#align(center, counter(page).display("- 1 -"))], 
+      [Thanks to Daniel for the circuit Symbols],
+      [#align(right, image("../images/cc0.png", height: 5mm,))]
+    )
+  ],
+)
+
+#let pTypeFill = rgb("#dd5959").lighten(10%);
+#let nTypeFill = rgb("#5997dd").lighten(10%);
+
+#place(top+center, scope: "parent", float: true, heading(
+  [Digitaltechnik]
+))
+
+#let SeperatorLine = line(length: 100%, stroke: (paint: black, thickness: 0.3mm))
+#let MathAlignLeft(e) = {
+  align(left, block(e))
+}
+
+#let colorBoolscheLogic = color.hsl(105.13deg, 92.13%, 75.1%)
+#let colorOptimierung = color.hsl(202.05deg, 92.13%, 75.1%)
+#let colorRealsierung = color.hsl(280deg, 92.13%, 75.1%)
+#let colorState = color.hsl(356.92deg, 92.13%, 75.1%)
+//#let colorIntegral = color.hsl(34.87deg, 92.13%, 75.1%)
+
+#let LNot(x) = math.op($overline(#x)$)
+
+#columns(4, gutter: 2mm)[
+  #bgBlock(fill: colorBoolscheLogic)[
+    #subHeading(fill: colorBoolscheLogic)[Allgemein]
+    *Moorsches Gesetz:* 2x der Anzahl der Transistoren pro Fläche (in 2 Jahren)
+
+    Flächenskalierung eines Transistors: $1/sqrt(2)$
+
+    *Kombinatorisch:* Kein Gedächtnis
+
+    *(Synchrone) sequenentielle:* Mit Gedächtnis
+
+    *Fan-In:* Anzahl der Inputs eines Gatters
+
+    *Fan-Out:* Anzahl der Output Verbindungen eines Gatters
+  ]
+
+  #bgBlock(fill: colorBoolscheLogic)[
+    #subHeading(fill: colorBoolscheLogic)[Boolsche Algebra]
+
+    *Dualität*
+    $LNot(0) = 1$, $LNot(1) = 0$
+
+    *Äquivalenz* $LNot((LNot(A)))=A$\
+    $A dot A = A$, $A + 0 = A$ \
+
+    *Konstanz*
+    $A dot 1 = A$ $A + 1 = 1$
+
+    *Komplementärgesetz* \
+    $A dot LNot(A) = 0$, $A + LNot(A) = 1$
+
+    *Kommutativgesetz* \
+    $A dot B = B dot A$, $A + B = B + A$
+
+    *Assoziativgesetz*\
+    $A dot (B dot C) = (A dot B) dot C$\
+    $A + (B + C) = (A + B) + C$
+
+    *Distributivgesetz*\
+    $A dot (B + C) = A dot B + A dot C$ \
+    $A + (B dot C) = (A + B) dot (A + C)$
+
+    *De Morgan*\
+    $LNot((A + B)) = LNot(A) dot LNot(B)$\
+    $LNot((A dot B)) = LNot(A) + LNot(B)$
+
+    *Absorptionsgesetz*\
+    $A + (A dot B) = A$\
+    $A dot (A + B) = A$
+
+    *Resolutionsgesetz (allgemein)*\
+    $X dot A + LNot(X) + B = X dot A + LNot(X) dot B + bold(A dot B)$
+
+    *Resolutionsgesetz (speziell)*\
+    $X dot A + LNot(X) dot A = A$\
+    $(X + A) dot (LNot(X) + A) = A$
+  ]
+
+  #bgBlock(fill: colorBoolscheLogic)[
+    #subHeading(fill: colorBoolscheLogic)[Boolsche Funktionen]
+
+    $f: {0,1}^n -> {0,1}$
+
+    Variablenmenge: ${x_0, x_1, ..., x_n}$\
+    Literalmenge: ${x_0, ..., x_n, LNot(x_0), ... LNot(x_n)}$ \
+    Einsmenge: $F = {underline(v) in {0,1}^n | f(underline(v)) = 1}$
+    Nullmenge: $overline(F) = {underline(v) in {0,1}^n | f(underline(v)) = 0}$
+    Don't-Care-Set: ${underline(v) in {0,1}^n | f(underline(v)) = *}$
+
+    Funktionsbündel: $underline(y)  = underline(f)(underline(x))$ \
+    $underline(f): {0,1}^n -> {0,1}^m$
+
+    *Kofaktoren* aka Bit $n$ fixen\ 
+    $x_i : f_x_i = f(x_1, ..., 1, ..., x_n)$\
+    $overline(x)_i : f_overline(x)_i = f(x_1, ..., 0, ..., x_n)$
+  
+    *Substitutionsregel*
+
+    $x_i dot f = x_i dot f_x_i$
+
+    $overline(x)_i dot f = overline(x)_i dot f_overline(x)_i$
+
+    $x_i + f = x_i + f_overline(x)_i$
+
+    $overline(x)_i + f = overline(x)_i + f_x_i$
+
+    *Boolsche Expansion*\
+    $f(underline(x)) = x_i dot f_x_i + overline(x)_i dot f_overline(x)_i$
+
+    $f(underline(x)) = (x_i + f_overline(x)_i) dot (overline(x)_i + f_x_i)$
+
+    $overline(f(underline(x))) = overline(x)_i dot overline(f_overline(x)_i) + x_i dot overline(f_x_i)$
+
+    $overline(f(underline(x))) = (overline(x)_i + overline(f_x_i)) dot (x_i + overline(f_overline(x)_i)) $
+
+    *Eigentschaften:*
+
+    tautologisch: $f(underline(x)) = 1, forall underline(x) in {0,1}^n$\
+    kontradiktorisch: $f(underline(x)) = 0, forall underline(x) in {0,1}^n$\
+    unabhängig von $x_i <=> f_x_i  = f_overline(x)_i$\
+    abhängig von $x_i <=> f_x_i  != f_overline(x)_i$\
+  ]
+
+  #bgBlock(fill: colorOptimierung)[
+    #subHeading(fill: colorOptimierung)[Hauptsatz der Schaltalgebra]
+    Jede $f(x_0, ...,x_n)$ kann als...
+    - *Minterme $m$:* $ = LNot(x)_0 dot x_1 dot ...$\
+      VerODERungen von VerUNDungen\
+      $f(underline(x)) = m_0 + m_1 + ... + m_n$
+
+    - *Maxterme $M$:* $ = LNot(x)_0 + x_1 ü ...$\
+      VerUNDungen von VerODERungen\
+      $f(underline(x)) = m_0 dot m_1 dot ... dot m_n$
+
+    ... dargestellt werden
+
+    *DNF:* Disjunktive Normalform, *Minterme*
+    - Term $tilde.equiv$ $1$-Zeile
+    - $LNot(x)_0 dot x_1 + x_0 dot x_1 +...$\
+    - $1 tilde.equiv x_0$, $0 tilde.equiv overline(x_0)$
+  
+    *KNF:* Konjunktive Normalform, *Maxterme*
+    - Term $tilde.equiv$ $0$-Zeile
+    - $(LNot(x)_0 + LNot(x)_1) dot (x_0 + x_1) dot...$\
+    - $1 tilde.equiv overline(x_0)$, $0 tilde.equiv x_0$
+  
+    Kanonische: In jedem Term müssen alle enthalten sein.
+
+    *KDNF:* Kanonische DNF\
+    *KKNF:* Kanonische KNF
+
+    *DMF:* Disjunktive #underline("Minimal")-Form: \ 
+    $ --> LNot(x_0)x_1 + LNot(x_1)$\
+
+    *KMF:* Konjunktive #underline("Minimal")-Form: \
+    $ --> (LNot(x_0) + x_1) dot LNot(x_1)$
+
+    $f(underline(x)) -->$ *KKNF* / *KDNF* mit Boolsche Expansion
+
+  ]
+
+  // Dotierung
+  #bgBlock(fill: colorRealsierung)[
+    #table(
+      columns: (auto, 1fr),
+      [N-Type],
+      [
+        - Dotierung: Phosphor (V)
+        - Negative Ladgunsträger ($e^-$)
+        - mehr Elektron als Si
+      ],
+      [P-Type],
+      [
+        - Dotierung:  Bor (III)
+        - Postive Landsträger (Löcher)
+        - mehr Löcher als Si
+      ]
+    )
+
+
+    #zap.circuit({
+      import cetz.draw : *
+      import zap : *
+
+      diode("A", (0,1.7), (3,1.7), fill: black, i: (content: $i_d$, anchor: "south"))
+
+
+      rect((0,0),(1,1), fill: pTypeFill, stroke: none)
+      rect((2,0),(3,1), fill: nTypeFill, stroke: none)
+      rect((1,0), (1.5,1), fill: color.lighten(pTypeFill, 50%), stroke: none)
+      rect((1.5,0), (2,1), fill: color.lighten(nTypeFill, 50%), stroke: none)
+      line((2, 0), (2, 1), stroke: (dash: "dotted"))
+      line((1, 0), (1, 1), stroke: (dash: "dotted"))
+      line((1.5, 0), (1.5, 1), stroke: (dash: "densely-dotted"))
+
+      cetz.decorations.brace((2,-0.1),(1,-0.1))
+      content((1.5, -0.6), "RLZ")
+      content((2.5, 0.5), "N")
+      content((0.5, 0.5), "P")
+      content((1.25, 0.5), "-")
+      content((1.75, 0.5), "+")
+    })
+
+    #grid(
+      columns: (1fr, 1fr),
+      column-gutter: 6mm,
+      align: center,
+      [#align(center)[*NMOS*]], [#align(center)[*PMOS*]],
+      grid.cell(inset: 2mm,
+        align(center, 
+          zap.circuit({
+            import "../lib/circuit.typ" : *
+
+            registerAllCustom();
+            fet("T", (0,0), type: "N", scale: 150%);
+          })
+        )
+      ),
+      grid.cell(inset: 2mm,
+        align(center, 
+          zap.circuit({
+            import "../lib/circuit.typ" : *
+
+            registerAllCustom();
+            fet("T", (0,0), type: "P", scale: 150%);
+          }),
+        )
+      ),
+      scale(
+        x: 75%, y: 75%,
+        zap.circuit({
+          import cetz.draw : *
+          import zap : *
+          rect((1.5,0),(4-1.5, 0.1), fill: rgb("#535353"), stroke: none)
+          rect((0,0),(4,-1), fill: pTypeFill, stroke: none)
+          rect((0.5,-0),(1.5, -0.5), fill: nTypeFill, stroke: none)
+          rect((4 - 1.5,-0),(4-0.5, -0.5), fill: nTypeFill, stroke: none)
+          rect((1.5,-0),(2.5, -0.5), fill: none, stroke: (paint: black, dash: "dotted", thickness: 0.06))
+
+          line((3, 0.3), (3, 0))
+          line((1, 0.3), (1, 0))
+          line((2, 0.3), (2, 0.1))
+
+          cetz.decorations.brace((2.5,-0.6),(1.5,-0.6))
+          content((2, -1.3), "Channel")
+          content((3, -0.25), $"n"^+$)
+          content((1, -0.25), $"n"^+$)
+          content((0.5, -0.75), "p")
+
+          content((3, 0.5), "S")
+          content((1, 0.5), "D")
+          content((2, 0.5), "G")
+        })
+      ),
+      scale(
+        x: 75%, y: 75%,
+        zap.circuit({
+          import cetz.draw : *
+          import zap : *
+          rect((1.5,0),(4-1.5, 0.1), fill: rgb("#535353"), stroke: none)
+          rect((0,0),(4,-1), fill: nTypeFill, stroke: none)
+          rect((0.5,-0),(1.5, -0.5), fill: pTypeFill, stroke: none)
+          rect((4 - 1.5,-0),(4-0.5, -0.5), fill: pTypeFill, stroke: none)
+          rect((1.5,-0),(2.5, -0.5), fill: none, stroke: (paint: black, dash: "dotted", thickness: 0.06))
+
+          line((3, 0.3), (3, 0))
+          line((1, 0.3), (1, 0))
+          line((2, 0.3), (2, 0.1))
+
+          cetz.decorations.brace((2.5,-0.6),(1.5,-0.6))
+          content((2, -1.3), "Channel")
+          content((3, -0.25), $"p"^+$)
+          content((1, -0.25), $"p"^+$)
+          content((0.5, -0.75), "n")
+
+          content((3, 0.5), "S")
+          content((1, 0.5), "D")
+          content((2, 0.5), "G")
+        })
+      ),
+    )
+
+    *Drain Strom:*
+
+    NMOS: $I_"Dn" = cases(
+        gap: #0.6em,
+        0 & 0 < U_"GS" < U_t,
+        beta_n (U_"GS" - U_t - U_"DS" / 2) U_"DS" quad & cases(delim: #none, U_"GS" >= U_t, 0 < U_"DS" < U_"GS" - U_t),
+        beta_n/2 (U_"GS" - U_"th")^2 & cases(delim: #none, U_"GS" >= U_t, U_"DS" > U_"GS" - U_t)
+      )$
+
+    PMOS: $I_"Dp" = cases(
+        gap: #0.6em,
+        0 & 0 > U_"GS" > U_t,
+        beta_p (U_"GS" - U_t - U_"DS" / 2) U_"DS" quad & cases(delim: #none, U_"GS" <= U_t, 0 > U_"DS" > U_"GS" - U_t),
+        beta_p/2 (U_"GS" - U_"th")^2 & cases(delim: #none, U_"GS" <= U_t, U_"DS" < U_"GS" - U_t)
+      )
+    $
+  ]
+
+  // Quine McCluskey
+  #bgBlock(fill: colorOptimierung)[
+    #subHeading(fill: colorOptimierung)[Quine McCluskey]
+  ]
+
+  // NMOS/PMOS
+  #bgBlock(fill: colorRealsierung)[
+    #subHeading(fill: colorRealsierung)[CMOS]
+    $hat(=)$ Complemntary MOS
+
+    #table(
+      columns: (1fr, 1fr),
+      zap.circuit({
+        import zap : *
+        import cetz.draw : content
+        import "../lib/circuit.typ" : *
+
+        set-style(wire: (stroke: (thickness: 0.025)))
+
+        registerAllCustom();
+        fet("N0", (0,0), type: "N", angle: 90deg);
+        fet("P0", (0,1), type: "P", angle: 90deg);
+        wire("N0.G", (rel: (-0.1, 0)), (horizontal: (), vertical: "P0.G"), "P0.G")
+
+        node("outNode", (0,0.5))
+        node("inNode", (-0.6,0.5))
+        wire((-1, 0.5), "inNode")
+        wire((0.2, 0.5), "outNode")
+
+        node("N2", (0,-0.5))
+        node("N2", (0,1.5))
+
+        wire((-1, -0.5), (0.5, -0.5))
+        wire((-1, 1.5), (0.5, 1.5))
+
+        content((-1, 0.5), scale($"X"$, 60%), anchor: "east")
+        content((0.45, 0.5), scale($overline("X")$, 60%), anchor: "east")
+        content((-0.9, 1.5), scale($"U"_"DD"$, 60%), anchor: "east")
+        content((-0.9, -0.5), scale($"GND"$, 60%), anchor: "east")
+      }),
+
+      [
+        *Inverter*
+        
+        $overline(X)$
+      ],
+
+      zap.circuit({
+        import zap : *
+        import cetz.draw : content
+        import "../lib/circuit.typ" : *
+
+        set-style(wire: (stroke: (thickness: 0.025)))
+
+        registerAllCustom();
+        fet("P0", (0.5,0.25), type: "P", angle: 90deg);
+        fet("P1", (0.5,1.25), type: "P", angle: 90deg);
+        fet("N0", (0,-1), type: "N", angle: 90deg);
+        fet("N1", (1,-1), type: "N", angle: 90deg);
+
+        content((-0.7, 1.75), scale($"V"_"DD"$, 60%), anchor: "east")
+        content((-0.7, -1.5), scale($"GND"$, 60%), anchor: "east")
+
+        content("N0.G", scale($"B"$, 60%), anchor: "east")
+        content("P0.G", scale($"B"$, 60%), anchor: "east")
+        content("N1.G", scale($"A"$, 60%), anchor: "east")
+        content("P1.G", scale($"A"$, 60%), anchor: "east")
+
+        wire((-0.75, -1.5), (1.5, -1.5))
+        wire((-0.75, 1.75), (1.5, 1.75))
+
+        wire("N0.S", "N1.S")
+        node("N2", "P0.D")
+        wire("N2", (horizontal: (), vertical: "N0.S"))
+        node("N3", "N0.D")
+        node("N4", "N1.D")
+        node("N5", "P1.S")
+        node("N6", (horizontal: (), vertical: "N0.S"))
+
+        wire("N2", (horizontal: (rel: (0.5, 0)), vertical: "N2"))
+        
+        content((horizontal: (rel: (0.65, 0)), vertical: "N2"), scale($"Y"$, 60%))
+      }),
+
+      [
+        *NOR*
+
+        $overline(A +B) = Y$
+      ],
+
+      zap.circuit({
+        import zap : *
+        import cetz.draw : content
+        import "../lib/circuit.typ" : *
+
+        set-style(wire: (stroke: (thickness: 0.025)))
+
+        registerAllCustom();
+        content((-0.7,  0.5), scale($"V"_"DD"$, 60%), anchor: "east")
+        content((-0.7, -2.75), scale($"GND"$, 60%), anchor: "east")
+
+        fet("P0", (0, 0), type: "P", angle: 90deg);
+        fet("P1", (1, 0), type: "P", angle: 90deg);
+        fet("N0", (0.5,-1.25), type: "N", angle: 90deg);
+        fet("N1", (0.5,-2.25), type: "N", angle: 90deg);
+
+        wire((-0.75, 0.5), (1.5, 0.5))
+        wire((-0.75, -2.75), (1.5, -2.75))
+        wire("P0.D", "P1.D")
+
+        node("N2", (horizontal: "N1.D", vertical: "P0.D"))
+        node("N3", "N0.S")
+        wire("N2", "N3")
+        wire("N3", (rel: (0.5, 0)))
+
+        content((horizontal: (rel: (0.65, 0)), vertical: "N3"), scale($"Z"$, 60%))
+        node("4", "P0.S")
+        node("4", "P1.S")
+        node("4", "N1.D")
+
+        content("N0.G", scale($"B"$, 60%), anchor: "east")
+        content("P0.G", scale($"B"$, 60%), anchor: "east")
+        content("N1.G", scale($"A"$, 60%), anchor: "east")
+        content("P1.G", scale($"A"$, 60%), anchor: "east")
+      }),
+
+      [
+        *NAND*
+
+        $overline(A dot B) = Z$
+      ],
+    )
+  ]
+
+  // CMOS
+  #bgBlock(fill: colorRealsierung)[
+    #subHeading(fill: colorRealsierung)[CMOS Verzögerung]
+
+    *Inverter*\
+    $t_("p"/"nLH") ~ (C_"L" t_"ox" L_"p/n")/(W_"p/n" mu_"p/n" epsilon(V_"DD" - abs(V_"Tpn"))) $
+
+    #grid(
+      columns: (1fr, 1fr),
+      [
+        *Steigend mit*
+        - Last $C_L$
+        - Oxyddicke $T_"ox"$
+        - Kandlalänge $L_"p/n"$
+        - Schwellspannung $V_"Tp/n"$ 
+      ],
+      [
+        *Sinkend mit*
+        - Kanalweite
+        - Landsträger Veweglichkeit $mu_"p/n"$
+      ],
+
+    )
+
+    $t_p ~ C_L/(beta(V_"DD" - abs(V_"T")))$
+
+    $t_p ~ C_L/(W(V_"DD" - abs(V_"T")))$
+  ]
+
+  #bgBlock(fill: colorState)[
+    #subHeading(fill: colorState)[Latches, Flipflops und Register]
+  ]
+
+  #bgBlock(fill: colorState)[
+    #subHeading(fill: colorState)[Timing]
+
+    *Register Bedinungen*
+
+    #cetz.canvas(length: 0.5mm, {
+      import cetz.draw: *
+
+
+      let cycle_time = 38
+      let cycle_start = cycle_time*0.8
+      let cycle_end = cycle_time*4
+      let signal_hight = 10
+      let switch_offset = cycle_time/13
+      let signal_storke = (paint: rgb("#2e2e2e"), thickness: 0.3mm)
+
+      let t_c2q = 0.6
+      let t_setup = 0.6
+      let t_hold = 0.4
+
+      // clk1
+      line((1*cycle_time + switch_offset/2, signal_hight + 1), (1*cycle_time + switch_offset/2, -40), stroke: (paint: rgb("#0004ff"), thickness: 0.4mm, dash: "densely-dashed"))
+
+      // q change
+      line((cycle_time*(t_c2q + 1) + switch_offset/2, -15 + signal_hight + 1), (cycle_time*(t_c2q + 1) + switch_offset/2, -40), stroke: (paint: rgb("#0004ff"), thickness: 0.4mm, dash: "densely-dashed"))
+
+      // d change
+      line((cycle_time*(t_setup + 2) + switch_offset/2, -30 + signal_hight + 1), (cycle_time*(t_setup + 2) + switch_offset/2, -40), stroke: (paint: rgb("#0004ff"), thickness: 0.4mm, dash: "densely-dashed"))
+
+      // clk
+      line((cycle_time*3 + switch_offset/2, signal_hight + 1), (cycle_time*3 + switch_offset/2, -40), stroke: (paint: rgb("#0004ff"), thickness: 0.4mm, dash: "densely-dashed"))
+
+      // hold time
+      line((cycle_time*(3+t_hold) + switch_offset/2, -30 + signal_hight + 1), (cycle_time*(3+t_hold) + switch_offset/2, -40), stroke: (paint: rgb("#0004ff"), thickness: 0.4mm, dash: "densely-dashed"))
+
+
+      content(( cycle_start -7, 5), "clk")
+
+      line((cycle_start,0), (cycle_time,0), (cycle_time + switch_offset,signal_hight), (cycle_time*2, signal_hight), (cycle_time*2 + switch_offset, 0), (cycle_time*3, 0), (cycle_time*3 + switch_offset, 10), (cycle_end, signal_hight), stroke: signal_storke)
+
+      translate((0, -15))
+      content((cycle_start -7, 5), "Q")
+
+      line(
+        (cycle_start,0), (cycle_time*(t_c2q + 1), 0), 
+        (cycle_time*(t_c2q + 1) + switch_offset, signal_hight), 
+        (cycle_time*(t_c2q + 3),signal_hight), (cycle_time*(t_c2q + 3) + switch_offset, 0), 
+        (cycle_end + switch_offset, 0),
+        stroke: signal_storke
+      )
+      line(
+        (cycle_start,signal_hight), (cycle_time*(t_c2q + 1), signal_hight), 
+        (cycle_time*(t_c2q + 1) + switch_offset, 0), 
+        (cycle_time*(t_c2q + 3),0), (cycle_time*(t_c2q + 3) + switch_offset, signal_hight),
+        (cycle_end + switch_offset, signal_hight),
+        stroke: signal_storke
+      )
+
+      translate((0, -15))
+      content((cycle_start -7, 5), "D")
+
+      line(
+        (cycle_start,0), (cycle_time*(t_setup + 2), 0), 
+        (cycle_time*(t_setup + 2) + switch_offset, signal_hight), (cycle_end + switch_offset, signal_hight), stroke: signal_storke
+        
+      )
+      line(
+        (cycle_start,signal_hight), (cycle_time*(t_setup + 2), signal_hight), 
+        (cycle_time*(t_setup + 2) + switch_offset, 0), (cycle_end + switch_offset, 0), stroke: signal_storke
+      )
+    })
+  ]
+
+
+
+  #bgBlock(fill: colorState)[
+    #subHeading(fill: colorState)[Pipeline/Parallele Verarbeitungseinheiten]
+  ]
+
+  #bgBlock(fill: colorState)[
+    #subHeading(fill: colorState)[Zustandsautomaten]
+  ]
+
+  #colbreak()
+  #bgBlock(fill: colorRealsierung)[
+    #subHeading(fill: colorRealsierung)[Verlustleistung/Verzögerung]
+    
+    $t_p ~ C_L / (V_"DD" - V_"Tn")$
+
+    $P_"stat" ~ e^(-V_T)$
+
+    $P_"dyn"~ V_"DD"^2$
+
+    *Dynamisch:* Bei Schlaten \
+    - Quer/Kurzschluss Strom $i_q$ \
+      $P_"short" = a_01 f beta_n tau (V_"DD" - 2 V_"Tn")^3$ \
+      $tau$: Kurzschluss/Schaltzeit
+    - Lade Strome des $C_L$ $i_c$
+      $P_"cap" = alpha_01 f C_L V_"DD"^2$
+    *Statisch:* Konstant
+    - Leckstom (weil Diode)
+    - Gatestrom 
+
+    *Schaltrate*
+
+    $alpha_"clk" = 100%$
+
+    $alpha_"logic" = 50%$
+
+  ]
+]
+
+#place(bottom,
+  truth-table(
+    outputs: (
+      ("NAND", (1, 1, 1, 0)),
+      ("NOR",  (1, 0, 0, 0)),
+      ("XNOR", (1, 0, 0, 1)),
+      ("XOR",  (0, 1, 1, 0)),
+      ("AND",  (0, 0, 0, 1)),
+      ("OR",   (0, 1, 1, 1)),
+    ),
+    inputs: ("A", "B")
+  ),
+  float: true
+)

src/cheatsheets/LinearAlgebra.typ

@@ -0,0 +1,430 @@
+#import "@preview/biceps:0.0.1" : *
+#import "@preview/mannot:0.3.1"
+#import "@preview/fletcher:0.5.8"
+#import "@preview/cetz:0.4.2"
+
+#import "../lib/styles.typ" : *
+#import "../lib/common_rewrite.typ" : *
+#import "../lib/mathExpressions.typ" : *
+
+#set page(
+  paper: "a4", 
+  margin: (
+    bottom: 10mm,
+    top: 5mm,
+    left: 5mm,
+    right: 5mm
+  ),
+  flipped:true,
+  numbering: "— 1 —",
+  number-align: center
+)
+
+#set text(size: 8pt)
+
+#place(top+center, scope: "parent", float: true, heading(
+  [Linear Algebra EI]
+))
+
+#let colorAllgemein = color.hsl(105.13deg, 92.13%, 75.1%)
+#let colorMatrixVerfahren = color.hsl(330.19deg, 100%, 68.43%)
+#let colorMatrix = color.hsl(202.05deg, 92.13%, 75.1%)
+#let colorVR = color.hsl(280deg, 92.13%, 75.1%)
+#let colorAbbildungen = color.hsl(356.92deg, 92.13%, 75.1%)
+#let colorGruppen = color.hsl(34.87deg, 92.13%, 75.1%)
+
+
+#let SeperatorLine = line(length: 100%, stroke: (paint: black, thickness: 0.3mm))
+#let MathAlignLeft(e) = {
+  align(left, block(e))
+}
+#columns(4, gutter: 2mm)[
+    #bgBlock(fill: colorAllgemein)[
+        #subHeading(fill: colorAllgemein)[Komplexe Zahlen]
+        
+        #ComplexNumbersSection()
+        
+        #sinTable
+    ]
+
+    #bgBlock(fill: colorGruppen)[
+         #subHeading(fill: colorGruppen)[Gruppen]
+
+        *Halbgruppe:* $(M, compose): M times M arrow M$
+        - Assoziativgesetz: $a dot (b dot c) = (a dot b) dot c$
+        *Monoid* Halbgruppe $M$ mit:
+        - Identitätselment: $e in M : a e = e a = a$
+        *Kommutativ/abelsch:* Halbgruppe/Monoid mit
+        - Kommutativgesetz; $a dot b = b dot a$
+
+        #SeperatorLine
+
+        *Gruppe:* Monoid mit
+        - Inverse: $forall a in G : exists space a a^(-1) = a^(-1)a = e$
+        - Eindeutig Lösung für Gleichungen 
+        Zusatz:
+        - Inverseregel: $(a dot b)^(-1) = b^(-1) dot a^(-1)$
+        *Untergruppe:*
+        - Gruppe: $(G, dot)$, $U subset G$
+        - $a,b in U <=> a dot b in U$
+        - $a in U <=> a^(-1) in U$
+        - $e in U$ (Neutrales Element)
+
+        *Direktes Produkt:*\
+        $(G_1,dot_1) times (G_2,dot_2) times ... $ \
+        $(a_1,b_1,...)(a_2,b_2,...)= (a_1 dot_1 b_1, a_2 dot_2 b_2, ...)$
+
+
+        #SeperatorLine
+
+        *Ring:* (auch Schiefkörper) Menge $R$ mit:
+        - $(R, +)$ kommutativ Gruppe
+        - $(R, dot)$ Halbgruppe
+        - $(a + b) dot c = (a dot c) + (a dot b) space$ (Distributiv Gesetz)
+
+        *Körper:* Menge $K$ mit:
+        - $(K, +), (K without {0} , dot)$ kommutativ Gruppe \
+            ($0$ ist Neutrales Element von $+$)
+        - $(a + b) dot c = (a dot c) + (a dot b) space$ (Distributiv Gesetz)
+        _Beweiß durch Überprüfung der Eigneschaften_
+    ]
+
+    #bgBlock(fill: colorVR)[
+        #subHeading(fill: colorVR)[Vektorräume (VR)]
+        $(V, plus.o, dot.o)$ ist ein über Körper $K$
+        - $+: V times V -> V, (v,w) -> v + w$
+        - $dot: K times V -> V, (lambda,v) -> lambda v$
+        Es gilt: $lambda,mu in K, space v,w in V$ 
+        - $(lambda mu)v = lambda (mu v)$
+        - $lambda(v + w) = lambda v + lambda w$\
+            $(lambda + mu)v = lambda v + lambda mu$
+        - $1v = v$, $arrow(0) in V$
+        Bsp: $KK^n$ ($RR^n, CC^n$)
+
+        *Untervektorraum:* $U subset V$ \
+        $v,w in U, lambda in K$ \
+        $ <=> v + w in U$, $arrow(0) in U$ UND $lambda v in U$
+        - $(U inter W) subset V$
+    ]
+
+    #bgBlock(fill: colorVR)[
+        #subHeading(fill: colorVR)[Basis und Dim]
+        *Linear Abbildung:* $Phi: V -> V$ 
+        - $Phi(0) = 0$
+        - $Phi(lambda v + w) = lambda Phi(v) + Phi(w)$
+        - Menge aller linearen Abbildung: $L(V,W)$
+
+        *Basis:*\
+        linear unabhänige Menge $B$ an $v in V$, sodass $op("spann")(v_1, ..., v_n) = op("spann")(V)$
+        - $B$ ist Erzeugerssystem von $V$
+        - Endliche Erzeugerssystem: $abs(B_1)=abs(B_2)...$
+
+        *Linear unabhänige:*
+        Linearkombintation in welcher $lambda_0 = 0, ..., lambda_n = 0$ die EINZIEGE Lösung für $lambda_0 v_0 + ... + lambda_1 v_1 = 0$
+
+        *Basisergänzungssatz:* \
+        Sei ${v_1, ... v_n}$ lin. unabhänig und $M$ kein Basis. Dann $exists v_(n+1)$ sodass ${v_1, ... v_n, v_(n+1)}$ lin unabhänig (aber evt. eine Basis ist)
+
+        *Dimension:* $dim V = \#$Vektoren der Basis
+        - $dim V = infinity$, wenn $V$ nicht endlich erzeugt ist
+    ]
+
+    #bgBlock(fill: colorAbbildungen)[
+        #subHeading([Abbildungen], fill: colorAbbildungen)
+        
+        $f(x)=y, f: A -> B$
+
+        *Injectiv (Monomorphismus):*\
+        _one to one_ \
+        $f(x) = f(y) <=> x = y$
+
+        *Surjectiv (Epimorhismis):* \
+        _Output space coverered_ \
+        - Zeigen das $f(f^(-1)(x)) = x$ für $x in DD$
+        - $forall x in B: exists x in A : f(x) = y$
+        NICHT surjektiv wenn $abs(a) < abs(b)$
+
+        *Bijektiv (Isomorphismus):* \
+        _Injectiv und Surjectiv_ \
+        - In einer Gruppe ist $f(x) = x c$ für $c,x in G$ bijektiv
+        - isomorph: $V,W$ VRs, $f$ bijektiv $f(V) = W => V tilde.equiv W$
+
+        Beweiß durch Wiederspruch \
+        für Gegenbeweiß
+
+        *Endomorphismus:* $A -> B$ mit $A, B subset.eq C$ 
+
+        *Automorphismus:* Endomorphismus und Bijektiv (Isomorphismus)
+        
+        *Vektorraum-Homomorphismus:* linear Abbildung zwischen VR
+    ]
+
+    // Spann und Bild, Kern
+    #bgBlock(fill: colorAbbildungen)[
+        #subHeading(fill: colorAbbildungen)[Spann und Bild]
+        *Spann:* 
+        - Vektorraum $V : op("spann")(V) = limits(inter)_(M subset V) U$
+        - $B : op("spann")(U) = {lambda_0 v_0 + ... + lambda_n v_n, lambda_0, ... lambda_n in K}$
+        - $op("spann")(Phi(M)) = Phi(op("spann")(M))$
+
+        *Urbild:* $f^(-1)(I subset B) subset.eq A$
+
+        *Bild:* Wertemenge $WW$ 
+        - $f(I subset A) = B$ (Oft $I = A$)
+        - Basis $B : op("spann")(B)$
+        - $op("Bild") Phi := {Phi in W | v in V}$
+
+        *Nullraum/Kern:* \
+        $op("Kern") Phi := {v in V | Phi(v) = 0}$
+
+        *Rang*
+        $op("Rang") f := dim op("Bild") f$
+
+        *Dimensionssatz:* Sei $A$ lineare Abbildung \
+        $dim(V) = dim(kern(A)) + dim(Bild(A))$ \
+        $dim(V) = dim(kern(A)) + Rang(A)$ \
+
+        $dim(V) = dim(Bild(A)) "oder" dim(kern(A)) = 0 \ <=> A "bijektiv" <=> "invertierbar"$
+    ]
+
+    #bgBlock(fill: colorAbbildungen)[
+        #subHeading(fill: colorAbbildungen)[Determinate und Bilinearform]
+    ]
+
+    #bgBlock(fill: colorVR)[
+        #subHeading(fill: colorVR)[Eukldische Vektorräume]
+    ]
+
+    #bgBlock(fill: colorVR)[
+        #subHeading(fill: colorVR)[Unitair Vektorräume ]
+    ]
+
+
+    // Matrix Typem
+    #bgBlock(fill: colorMatrix)[
+        #let colred(x) = text(fill: red, $#x$)
+        #let colblue(x) = text(fill: blue, $#x$)
+
+        #subHeading(fill: colorMatrix)[Matrix Typen]
+        #align(center, scale($colred(m "Zeilen") colblue(n "Splate")\ A in KK^(colred(m) times colblue(n))$, 120%)) #grid(columns: (1fr, 1fr),
+        $quad mat(
+                a_11, a_12, ..., a_(1n);
+                a_21, a_22, ..., a_(2n);
+                dots.v, dots.v, dots.down, dots.v;
+                a_(m 1), a_(m 2), ..., a_(m n)
+            )
+        $,
+            
+            cetz.canvas({
+                    import cetz.draw : *
+
+                    rect((0, 0), (1, 1), fill: rgb("#9292926b"))
+
+                    set-style(mark: (end: (symbol: "straight")))
+                    line((0, -0.2), (1, -0.2), stroke: (paint: blue, thickness: 0.3mm))
+                    line((-0.2, 1), (-0.2, 0), stroke: (paint: red, thickness: 0.3mm))
+
+                    content((-0.45, 0.5), $colred(bold(m))$)
+                    content((0.5, -0.35), $colblue(bold(n))$)
+                    content((0.5, 0.5), $A$)
+                })
+        )
+
+        #table(
+            columns: (auto, 1fr),
+            inset: 2mm,
+            fill: (x, y) => if (calc.rem(y, 2) == 0) { tableFillLow } else { tableFillHigh },
+            [*Einheits Matrix*\ $I,E$], [],
+            [*Diagonalmatrix* \ $Sigma,D$], [
+                Nur Einträger auf Hauptdiagonalen \
+                $det(D) = d_00 dot d_11 dot d_22 dot ...$
+            ],
+            [*Symetrisch*\ $S$], [
+                $S = S^T$, $S in KK^(n times n)$\
+                $A A^T$, $A^T A$ ist symetrisch \
+                $S$ immer diagonaliserbar \
+                EW immer $in RR$, EV orthogonal
+            ],
+            [*Invertierbar*], [
+                $exists A^(-1) : A A^(-1) = A^(-1) A = E$ \
+
+                *Invertierbar wenn:* \
+                $A$ bijektiv, $det(A) = 0$ \
+                $"Spalten Vekoren lin. unabhänig"$ \
+                $det(A) = 0$ \                
+
+                *Nicht Invertierbar wenn:*\
+                $exists$ EW $!= 0 => not "invertierbar"$
+                Keine Qudratische Matrix
+            ],
+            [*Orthogonal*\ $O$], [
+                $O^T = O^(-1)$ \
+                $ip(O v, O w) = ip(v, w)$
+            ],
+            [*Unitair*], [
+                $V^* )$
+            ],
+            [*Diagonaliserbar*], [
+                $exists A = B D B^(-1)$, $D$ diagonal,
+
+                $B$: Splaten sind EV von $A$
+
+                - Selbst-Adujunkte diagonalisierbar
+                - Symetrisch Matrix
+                - $A in KK^(n times n) "AND" alg(lambda) = geo(lambda)$
+            ],
+            [*postiv-semi-definit*], [
+                $forall$ EW $>= 0$
+            ],
+        )
+    ]
+
+    #bgBlock(fill: colorMatrixVerfahren)[
+
+        #subHeading(fill: colorMatrixVerfahren)[Eigenwert und Eigenvektoren ]
+
+        $A in CC^(n times n):$ $n$ Complexe Eigenwerte \
+        $A in RR^(n times n)$
+
+        *1. Eigentwete bestimmen*
+        
+        $A v = lambda v => det(A-E lambda) = 0$
+
+        $0 = det mat(#mannot.markhl($x_11 - lambda_1$, color: red), x_12, ..., x_(1n);
+            x_21, #mannot.markhl($x_22 - lambda_2$, color: red), ..., x_(2n);
+            dots.v, dots.v, dots.down,  dots.v;
+            x_(n 1), x_(n 2), ..., #mannot.markhl($x_(n n) -lambda_n$, color: red)
+        )$
+
+        $--> chi_A = (lambda_0 - lambda)^(n_0) dot (lambda_1 - lambda)^(n_1) ... $
+
+
+        $lambda_0, lambda_1, ... = $ Nst von $chi_A$
+
+
+        *2. Eigenvektor bestimmen*
+        
+        $Eig(lambda_k) = kern(A - lambda_k E)$
+        
+        $mat(#mannot.markhl($x_11 - lambda_k$, color: red), x_12, ..., x_(1n);
+            x_21, #mannot.markhl($x_22 - lambda_k$, color: red), ..., x_(2n);
+            dots.v, dots.v, dots.down,  dots.v;
+            x_(n 1), x_(n 2), ..., #mannot.markhl($x_(n n) -lambda_k$, color: red)
+        ) vec(v_1, v_2, dots.v, v_n) = vec(0, 0, dots.v, 0)$
+
+
+
+        *Algebrasche Vielfacheit:* $alg(lambda) = n_0 + n_1 + ...$ \
+        *Geometrische Vielfacheit:* $geo(lambda) = dim("Eig"_A (lambda))$ \
+
+        $1 <= geo(lambda) <= alg(lambda)$
+
+    ]
+
+    #bgBlock(fill: colorMatrixVerfahren)[
+        #subHeading(fill: colorMatrixVerfahren)[Gram-Schmit ONB]
+
+
+
+    ]
+
+    #bgBlock(fill: colorMatrixVerfahren)[
+        #subHeading(fill: colorMatrixVerfahren)[Diagonalisierung]
+        $A = R D R^(-1)$
+
+        *Rezept Diagonalisierung*
+
+        1. EW bestimmen: $det(A - lambda I) = 0$  \
+            $=> chi_A = (lambda_1 - lambda)^(m 1) (lambda_2 - lambda)^(m 2) ...$ 
+        2. EV bestimmen: $spann(kern(A - lambda_i I))$: $r_0, r_1, ...$
+        3. \
+            #grid(columns: (1fr, 1fr),
+            [
+                Diagnoalmatrix: $D$
+                $mat(
+                        lambda_1, 0, 0,...;
+                        0, lambda_1, 0, ...;
+                        0, 0, lambda_2, ...;
+                        dots.v, dots.v, dots.v, dots.down
+                    )
+                $
+            ],
+            [
+                Basiswechselmatrix: $R$
+                $mat(
+                    |, | , ..., |;
+                    r_0, r_1, ..., r_n;
+                    |, |, ..., |
+                )$
+            ]
+        )
+     ]
+
+
+    #bgBlock(fill: colorMatrixVerfahren)[
+        #subHeading(fill: colorMatrixVerfahren)[Schur-Zerlegung]
+        immer anwendbar; 
+    ]
+
+    #bgBlock(fill: colorMatrixVerfahren)[
+        #subHeading(fill: colorMatrixVerfahren)[SVD]
+
+        $A in RR^(m times n)$ zerlegbar in $A = L S R^T$ \
+
+
+        $L in RR^(m times m)$ Orthogonal \
+        $S in RR^(m times n)$ Diagonal \
+        $R in RR^(n times n)$ Orthogonal
+
+
+        1. $A A^T$ berechnen $A A^T in RR^(m times m)$
+
+        2. $A A^T$ diagonalisieren in $R$, $D$
+
+        3. Singulärwere berechen: $sigma_i = sqrt(lambda_i) $
+        
+        4. $l_i = 1/sigma_i A v_(lambda i) quad quad L = mat( |, |, ..., |; l_0, l_1, ..., l_m; |, |, ..., |)$ \
+            (Evt. zu ONB ergenze mit Gram-Schmit/Kreuzprodukt)
+
+        5. $S in RR^(n times m)$ (wie $A$): \
+            $S = mat(sigma_0, 0; 0, sigma_1; dots.v, dots.v; 0, 0) quad quad quad S = mat(sigma_0, 0, dots, 0; 0, sigma_1, ..., 0)$
+    ]
+
+    #bgBlock(fill: colorMatrix)[
+        #subHeading(fill: colorMatrix)[Matrix Normen]
+
+        $|| dot ||_M$ Matrix Norm, $|| dot ||_V$ Vektornorm
+
+        Generisch Vektor Norm: $|| v ||_p = root(p, sum_(k=1)^n (x_k)^p)$
+
+        - submultiplikativ: $||A B||_"M" <= ||A||||B||$
+        - verträglich mit einer Vektornorm: $||A v||_"V" <= ||A||_"M" ||v||_"V"$
+
+        *Frobenius-Norm* $||A||_"M" = sqrt(sum_(i=1)^m sum_(j=1)^n a_(m n)^2)$
+
+        *Induzierte Norm* $||A||_"M" = sup_(v in V without {0}) (||A v||_V)/(||v||_V)$\
+        $ = sup_(||v|| = 1) (||A v||_V)/(||v||_V)$
+            - submultiplikativ
+            - verträglich mit einer Vektornorm $||dot||_V$
+
+        *maximale Spaltensumme* $||A||_r = max_(1<= i <= n) sum_(j=1)^n |a_(j)|$
+    ]
+
+    #bgBlock(fill: colorMatrix)[
+        #subHeading(fill: colorMatrix)[Rekursive Folgen]
+
+        E.g: $a_1 x_(n-1) + a_2 x_(n) = x_(n+1)$
+
+        1. Als Matrix Schreiben $F: vec(x_(n-1), x_(n)) = vec(x_n, x_(n+1))$ \
+            $F s_(n-1) = s_(n)$
+
+        2. Diagonaliseren: $F = R D R^(-1) $ \
+        3. Wiederholte Anwendung: $F^n = R D^n R^(-1)$
+
+    ]
+
+    #bgBlock(fill: colorMatrix)[
+        #subHeading(fill: colorMatrix)[Differenzialgleichungen]
+    ]
+]
+

src/lib/circuit.typ

@@ -0,0 +1,156 @@
+#import "@preview/cetz:0.4.2" as cetz
+#import "@preview/zap:0.5.0" as zap
+#import zap: interface
+
+#let registerAllCustom() = {
+  cetz.draw.set-ctx(ctx => {
+    ctx.zap.style.insert("zweiTor", (
+      scale: auto,
+      fill: none,
+      height: 10mm,
+      width: 10mm,
+    ))
+
+    ctx.zap.style.insert("einTor", (
+      scale: auto,
+      fill: none,
+      height: 3mm,
+      width: 6mm,
+    ))
+
+    ctx.zap.style.insert("fet", (
+      scale: auto,
+      fill: none,
+      height: 5mm,
+      width: 10mm,
+    ))
+
+
+    for it in ("lnot", "land", "lnand", "lor", "lnor", "lxor", "lxnor") {
+        ctx.zap.style.insert(it, (
+          width: 0.7,
+          min-height: 0.9,
+          spacing: 0.4,
+          padding: 0.25,
+          fill: white,
+          stroke: auto,
+        )
+      )
+    }
+
+    ctx
+  })
+
+
+
+}
+
+#let einTor(name, node, flip: false, ..params) = {
+  import cetz.draw: rect
+  import zap: component
+
+
+  // Drawing function
+  let draw(ctx, position, style) = {
+    rect(
+      (-style.width/2, -style.height/2),
+      (style.width/2, style.height/2),
+      fill: style.fill
+    )
+
+    if(flip) {
+      rect(
+        ((style.width*0.7)/2, -(style.height)/2),
+        (style.width/2, style.height/2),
+        fill: black
+      )
+    } else {
+      rect(
+        (-(style.width)/2, -style.height/2),
+        (-(style.width*0.6)/2, style.height/2),
+        fill: black
+      )
+    }
+
+    interface((-style.width / 2, -style.height / 2), (style.width / 2, style.height / 2), io: position.len() < 2)
+  }
+
+  // Component call
+  component("einTor", name, node, draw: draw, ..params)
+}
+
+#let zweiTor(name, node, label, ..params) = {
+  import cetz.draw: rect, anchor, content
+  import zap: component
+
+
+  // Drawing function
+  let draw(ctx, position, style) = {
+    rect(
+      (-style.width/2, -style.height/2),
+      (style.width/2, style.height/2),
+      fill: style.fill
+    )
+
+    content((0,0), label)
+
+    anchor("in0", (-style.width/2, -style.height*0.5/2))
+    anchor("in1", (-style.width/2, style.height*0.5/2))
+    anchor("out0", (style.width/2, -style.height*0.5/2))
+    anchor("out1", (style.width/2, style.height*0.5/2))
+
+    interface((-style.width / 2, -style.height / 2), (style.width / 2, style.height / 2), io: false)
+  }
+
+  // Component call
+  component("zweiTor", name, node, draw: draw, ..params)
+}
+
+#let fet(name, node, type: "N", scale: 1, angle: 0, thickness: 0.5pt, ..params) = {
+  import cetz.draw: line, circle, anchor, rotate
+  import zap: component
+  
+  // Drawing function
+  let draw(ctx, position, style) = {
+    let zap-style = ctx.zap.style
+
+    let height = style.height * scale;
+    let width = style.width * scale;
+
+    let wireThink = ctx.zap.style.wire.stroke.thickness;
+
+    rotate(angle);
+
+    if(type == "N") {
+      line((0, height), (0, height*(1-0.45)), stroke: (thickness: wireThink))
+    } else { 
+      line((0, height), (0, height*(1-0.2)), stroke: (thickness: wireThink))
+      circle((0, height*(1-0.3) - thickness/2), radius: (height/2)*0.2, stroke: (thickness: wireThink))
+    }
+
+    line(
+      (width/2, 0), 
+      (width*0.4/2, 0),
+      (width*0.4/2, 0), 
+      (width*0.4/2, height*(1-0.6)),
+      (-width*0.4/2, height*(1-0.6)),
+      (-width*0.4/2, 0),
+      (-width/2, 0), stroke: (thickness: wireThink)
+    )
+
+    line(
+      (width*0.42/2, height*(1-0.45)),
+      (-width*0.42/2, height*(1-0.45)),
+      stroke: (thickness: wireThink)
+    )
+
+    anchor("G", (0, height))
+    anchor("D", (-width/2, 0))
+    anchor("S", (width/2, 0))
+
+    interface((-width / 2, -height / 2), (width / 2, height / 2), io: true)
+  }
+
+  // Component call
+  component("fet", name, node, draw: draw, ..params)
+}

src/lib/common_rewrite.typ

@@ -1,4 +1,4 @@
-#let bgBlock(body, fill: color) = block(body, fill:fill.lighten(80%), width: 100%, inset: (bottom: 2mm))
+#let bgBlock(body, fill: color, width: 100%) = block(body, fill:fill.lighten(80%), width: width, inset: (bottom: 2mm, left: 2mm, right: 2mm,))
 
 #let SeperatorLine = line(length: 100%, stroke: (paint: black, thickness: 0.3mm))
 #let MathAlignLeft(e) = {
@@ -6,23 +6,68 @@
 }
 
 #let subHeading(body, fill: color) = {
-  box(
+  move(dx: -2mm, dy: 0mm, box(
     align(
       top+center,
       text(
         body,
-        size: 10pt,
+        size: 8pt,
-        weight: "regular",
+        weight: "bold",
         style: "italic",
       )
     ),
     fill: fill,
-    width: 100%,
+    width: 100% + 4mm,
     inset: 1mm,
     height: auto
-  )
+  ))
 }
 
 #let MathAlignLeft(e) = {
   align(left, block(e))
-}
+}
+
+#let tableFillHigh = white
+#let tableFillLow = color.lighten(gray, 50%)
+
+#let sinTable = [
+  #let data = json("../sintable.json")
+  #table(
+    columns: data.len(),
+    rows: data.keys().len(),
+    stroke: none,
+    table.hline(stroke: (thickness: 0.3mm)),
+    fill: (x, y) => if (calc.rem(y, 2) == 0) { tableFillLow } else { tableFillHigh },
+
+    table.vline(),
+    ..for (i, label) in data.keys().enumerate() {
+      ([*#eval(label, mode: "math")*], if i > 0 { table.vline() } else { table.vline(stroke: none) })
+    },
+
+    table.hline(stroke: (thickness: 0.3mm)),
+  
+    ..for (i, v) in data.at("x").enumerate() {
+    for (col) in data.keys() {
+        (eval(data.at(col).at(i), mode: "math"),)
+      }
+    },
+    table.hline(stroke: (thickness: 0.3mm)),
+  )
+]
+
+#let ComplexNumbersSection(i: $i$) = [
+  $1/#i = #i^(-1) = -#i quad quad #i^2=-1 quad quad sqrt(#i) = 1/sqrt(2) + 1/sqrt(2)#i$
+
+  $z in CC = a + b #i quad quad quad z = r dot e^(#i phi)$ \
+  $z_0 + z_1 = (a_0 + a_1) + (b_0 + b_1) #i$\
+  $z_0 dot z_1 = (a_1 a_2 - b_1 b_2) + #i (a_1b_2 + a_2 b_1) = r_0 r_1 e^(#i (phi_0 + phi_1))$\
+  $z^x = r^x dot e^(phi #i dot x) quad x in RR$ \
+  $z_0/z_1 = r_0/r_1 e^(#i (phi_0 - phi_1)) quad quad quad$ 
+
+  $z^* = a - #i b = r e^(-#i phi)$
+
+  $r = abs(z) quad phi = cases(
+    + arccos(a/r) space : space a >= 0,
+    - arccos(a/r) space : space a < 0,
+  )$
+]

src/lib/fetModel.typ

@@ -0,0 +1,290 @@
+#import "@preview/zap:0.5.0"
+#import "@preview/cetz-plot:0.1.3"
+
+
+#set page(width: auto, height: auto)
+
+#let FetModelSubstrate = zap.circuit({
+  import zap: *
+  import cetz.draw: *
+
+  rect(
+    (0, 0),
+    (12, 4),
+    fill: rgb("#ffb1b1"),
+    name: "p",
+  )
+  rect((0, -0.05), (12, -0.05), stroke: 3pt, name: "substrate")
+  earth("g1", (11.5, 0))
+
+  content("substrate", [Bulk], anchor: "north", padding: 0.2)
+})
+
+#let FetModel1 = zap.circuit({
+  import zap: *
+  import cetz.draw: *
+
+  rect(
+    (0, 0),
+    (12, 4),
+    fill: rgb("#ffb1b1"),
+    name: "p",
+  )
+  rect((0, -0.05), (12, -0.05), stroke: 3pt, name: "substrate")
+  earth("g1", (11.5, 0))
+
+  rect((2.75, 3), (5.25, 4), fill: rgb("#61ff9f"), name: "kanal1", radius: (
+    south: 0.2,
+  ))
+  rect((6.75, 3), (9.25, 4), fill: rgb("#61ff9f"), name: "kanal2", radius: (
+    south: 0.2,
+  ))
+
+  content("kanal1", [n+], anchor: "center", padding: 0.2)
+  content("kanal2", [n+], anchor: "center", padding: 0.2)
+  content("substrate", [Bulk], anchor: "north", padding: 0.2)
+})
+
+#let FetModel2 = zap.circuit({
+  import zap: *
+  import cetz.draw: *
+
+  rect(
+    (0, 0),
+    (12, 4),
+    fill: rgb("#ffb1b1"),
+    name: "p",
+  )
+  rect((0, -0.05), (12, -0.05), stroke: 3pt, name: "substrate")
+  earth("g1", (11.5, 0))
+
+  rect((2.75, 3), (5.25, 4), fill: rgb("#61ff9f"), name: "kanal1", radius: (
+    south: 0.2,
+  ))
+  rect((6.75, 3), (9.25, 4), fill: rgb("#61ff9f"), name: "kanal2", radius: (
+    south: 0.2,
+  ))
+
+  content("kanal1", [n+], anchor: "center", padding: 0.2)
+  content("kanal2", [n+], anchor: "center", padding: 0.2)
+  content("substrate", [Bulk], anchor: "north", padding: 0.2)
+
+
+  rect((0, 4), (12, 4.5), fill: rgb("#fffc61"), name: "isolator")
+  content("isolator.west", [Isolator ($"SiO"_2$)], anchor: "west", padding: .2)
+})
+
+#let FetModel3 = zap.circuit({
+  import zap: *
+  import cetz.draw: *
+
+  rect(
+    (0, 0),
+    (12, 4),
+    fill: rgb("#ffb1b1"),
+    name: "p",
+  )
+  rect((0, -0.05), (12, -0.05), stroke: 3pt, name: "substrate")
+  earth("g1", (11.5, 0))
+
+  rect((2.75, 3), (5.25, 4), fill: rgb("#61ff9f"), name: "kanal1", radius: (
+    south: 0.2,
+  ))
+  rect((6.75, 3), (9.25, 4), fill: rgb("#61ff9f"), name: "kanal2", radius: (
+    south: 0.2,
+  ))
+
+  content("kanal1", [n+], anchor: "center", padding: 0.2)
+  content("kanal2", [n+], anchor: "center", padding: 0.2)
+  content("substrate", [Bulk], anchor: "north", padding: 0.2)
+
+
+  rect((0, 4), (3, 4.5), fill: rgb("#fffc61"), name: "isolator2")
+  rect((5, 4), (7, 4.5), fill: rgb("#fffc61"))
+  rect((9, 4), (12, 4.5), fill: rgb("#fffc61"), name: "isolator")
+
+  rect((3, 4), (5, 4.25), fill: gray)
+  rect((7, 4), (9, 4.25), fill: gray)
+  rect((5.1, 4.5), (6.9, 4.75), fill: gray)
+
+  content("isolator", [$"SiO"_2$])
+  content("isolator2", [Isolator])
+})
+
+#let FetModel(type: "N", s: 100%) = zap.circuit({
+  import zap: *
+  import cetz.draw: rect, content
+
+  cetz.draw.scale(s)
+
+  let pTypeFill = rgb("#ffb1b1");
+  let pTypeFill = rgb("#ffb1b1");
+  let nTypeFill = rgb("#61ff9f")
+
+  rect(
+    (0, 0),
+    (12, 4),
+    fill: if(type == "N") { pTypeFill } else { nTypeFill },
+    name: "p",
+  )
+  rect((0, -0.05), (12, -0.05), stroke: 3pt, name: "substrate")
+  earth("g1", (11.5, 0))
+
+  wire((13, 5.5), (13, 0), mark: (end: ">"))
+  node("n-r1", (13, 5.75))
+
+  wire((6, 4.5), (6, 5.75))
+  node("n-g1", (6, 5.75))
+  wire("n-g1", "n-r1")
+
+  node("n-s1", (4, 5))
+  wire("n-s1", (4, 4.25))
+
+  node("n-d1", (8, 5))
+  wire("n-d1", (8, 4.25))
+
+  rect((0, 4), (3, 4.5), fill: rgb("#fffc61"), name: "isolator2")
+  rect((5, 4), (7, 4.5), fill: rgb("#fffc61"))
+  rect((9, 4), (12, 4.5), fill: rgb("#fffc61"), name: "isolator")
+
+  rect((3, 4), (5, 4.25), fill: gray)
+  rect((7, 4), (9, 4.25), fill: gray)
+  rect((5.1, 4.5), (6.9, 4.75), fill: gray)
+
+  content("n-g1", [*G*\ate], anchor: "south", padding: 0.2, auto-scale: true)
+  content("n-s1", [*S*\ource], anchor: "south", padding: 0.2)
+  content("n-d1", [*D*\rain], anchor: "south", padding: 0.2, auto-scale: true)
+  content("substrate", [Bulk], anchor: "north", padding: 0.2, auto-scale: true)
+  content("p", if type == "N" [p] else [n], auto-scale: true)
+  content("isolator", [$"SiO"_2$], auto-scale: true)
+
+  content("isolator2", [Isolator], auto-scale: true)
+
+  rect((2.75, 3), (5.25, 4), fill: if(type == "N") { nTypeFill }  else { pTypeFill }, name: "kanal1", radius: (
+    south: 0.2,
+  ))
+  rect((6.75, 3), (9.25, 4), fill: if(type == "N") { nTypeFill } else { pTypeFill }, name: "kanal2", radius: (
+    south: 0.2,
+  ))
+
+  content("kanal1", if type == "N" [n+] else [p+], anchor: "center", padding: 0.2, auto-scale: true)
+  content("kanal2", if type == "N" [n+] else [p+], anchor: "center", padding: 0.2, auto-scale: true)
+})
+
+#let FetModelConducting = zap.circuit({
+  import zap: *
+  import cetz.draw: *
+
+  rect(
+    (0, 0),
+    (12, 4),
+    fill: rgb("#ffb1b1"),
+    name: "p",
+  )
+  rect((0, -0.05), (12, -0.05), stroke: 3pt, name: "substrate")
+  earth("g1", (11.5, 0))
+
+  wire((13, 5.5), (13, 0), mark: (end: ">"))
+  node("n-r1", (13, 5.75))
+
+  wire((6, 4.5), (6, 5.75))
+  node("n-g1", (6, 5.75))
+  wire("n-g1", "n-r1")
+
+  node("n-s1", (4, 5))
+  wire("n-s1", (4, 4.25))
+
+  node("n-d1", (8, 5))
+  wire("n-d1", (8, 4.25))
+
+  rect((0, 4), (3, 4.5), fill: rgb("#fffc61"), name: "isolator2")
+  rect((5, 4), (7, 4.5), fill: rgb("#fffc61"))
+  rect((9, 4), (12, 4.5), fill: rgb("#fffc61"), name: "isolator")
+
+  rect((3, 4), (5, 4.25), fill: gray)
+  rect((7, 4), (9, 4.25), fill: gray)
+  rect((5.1, 4.5), (6.9, 4.75), fill: gray)
+
+  content("n-g1", [*G*\ate], anchor: "south", padding: 0.2)
+  content("n-s1", [*S*\ource], anchor: "south", padding: 0.2)
+  content("n-d1", [*D*\rain], anchor: "south", padding: 0.2)
+  content("substrate", [Bulk], anchor: "north", padding: 0.2)
+  content("p", [p])
+  content("isolator", [$"SiO"_2$])
+  content("isolator2", [Isolator])
+
+  rect((2.75, 3), (5.25, 4), fill: rgb("#61ff9f"), name: "kanal1", radius: (
+    south: 0.2,
+  ))
+  rect((6.75, 3), (9.25, 4), fill: rgb("#61ff9f"), name: "kanal2", radius: (
+    south: 0.2,
+  ))
+  rect((5.20, 3.99), (6.8, 3.9), fill: rgb("#61ff9f"), stroke: none)
+
+  content("kanal1", [n+], anchor: "center", padding: 0.2)
+  content("kanal2", [n+], anchor: "center", padding: 0.2)
+
+  rect((0.5, -1), (1, -0.70), fill: gray, stroke: none, name: "metal")
+  content("metal", [metal], anchor: "west", padding: 0.3)
+
+  rect((0.5, -1.2), (1, -1.5), fill: rgb("#61ff9f"), stroke: none, name: "n")
+  content("n", [n+], anchor: "west", padding: 0.3)
+
+  rect(
+    (2.5, -1),
+    (3, -0.7),
+    fill: rgb("#ffb1b1"),
+    stroke: none,
+    name: "p-substrate",
+  )
+  content("p-substrate", [p], anchor: "west", padding: 0.3)
+
+  rect((2.5, -1.2), (3, -1.5), fill: rgb("#fffc61"), stroke: none, name: "siO2")
+  content("siO2", [oxide], anchor: "west", padding: 0.3)
+})
+
+#let FetPlot() = {
+  let u_gs = 1
+  let beta = 1
+
+  cetz.canvas({
+    import cetz-plot: plot
+    import cetz: draw.content
+
+    cetz.draw.set-style(axes: (
+      shared-zero: false,
+      overshoot: 0.2,
+      x: (mark: (end: ">", fill: black, scale: 0.6)),
+      y: (mark: (end: ">", fill: black, scale: 0.6)),
+    ))
+
+    plot.plot(
+      size: (2, 2),
+      name: "plot",
+      axis-style: "school-book",
+      x-min: 0,
+      x-tick-step: none,
+      y-tick-step: none,
+      x-label: $U_"GS"$,
+      y-label: $U_"DS"$,
+      {
+        plot.add-fill-between(domain: (1, 6), ((1, 0), (1, 5)), u_gs => u_gs - u_t)
+
+        plot.add(domain: (0, 5), fill: true, axes: ("y", "x"), _ => 1)
+
+        plot.add(domain: (1, 6), fill: true, u_gs => u_gs - u_t)
+
+        plot.add-anchor("I", (0.5, 2.5))
+        plot.add-anchor("II", (4.5, 1.5))
+        plot.add-anchor("III", (2.5, 3.5))
+
+        plot.add-anchor("ut", (u_t, 0))
+      }
+    )
+    content("plot.ut", $U_t$, anchor: "north", padding: 0.1)
+
+    content("plot.I", [I])
+    content("plot.II", [II])
+    content("plot.III", [III])
+  })
+}

src/lib/logic.typ

@@ -0,0 +1,62 @@
+#import "@preview/zap:0.5.0": *
+#import "@preview/cetz:0.4.2": (
+  draw.anchor, draw.arc-through, draw.circle, draw.content, draw.line, draw.rect, draw.rotate, draw.get-ctx, draw.bezier
+)
+
+#let logic(name, node, text: $"&"$, invert: false, mirror: false, invert-inputs: (), angle: 0deg, inputs: 2, ..params) = {
+  assert(inputs >= 1, message: "logic supports minimum one inputs")
+
+  let style = (
+    width: 0.7,
+    min-height: 0.9,
+    spacing: 0.4,
+    padding: 0.25,
+    fill: white,
+    stroke: auto,
+  )
+
+  // Drawing function
+  let draw(ctx, position, _) = {
+    rotate(angle)
+
+    let height = calc.max(style.min-height, (inputs - 1) * style.spacing + 2 * style.padding)
+    let width = style.width * if mirror { -1 } else { 1 }
+
+    interface((-width / 2, -height / 2), (width / 2, height / 2), io: false)
+
+    rect((-width / 2, -height / 2), (rel: (width, height)), fill: style.fill, stroke: style.stroke)
+    content((0, height / 2 - style.padding / 2), text, anchor: "north", angle: angle)
+
+    let ball-radius = calc.min(height, width) * 0.1
+
+    for input in range(1, inputs + 1) {
+      let pad = (height - (inputs - 1) * style.spacing) / 2
+      let y = height / 2 - pad - (input - 1) * style.spacing;
+
+      if input in invert-inputs {
+        circle((-width / 2 - ball-radius, y), radius: ball-radius, stroke: style.stroke, fill: style.fill)
+        anchor("in" + str(input), (-width / 2, y))
+      } else {
+        anchor("in" + str(input), (-width / 2, y))
+      }
+    }
+
+    if invert {
+      circle((width / 2 + ball-radius, 0), radius: ball-radius, stroke: style.stroke, fill: style.fill)
+      anchor("out", (width / 2, 0))
+    } else {
+      anchor("out", (width / 2, 0))
+    }
+  }
+
+  // Component call
+  component("logic", name, node, draw: draw, ..params)
+}
+
+#let lnot(name, node, ..params) = logic(name, node, ..params, text: $1$, invert: true)
+#let land(name, node, ..params) = logic(name, node, ..params, text: $"&"$)
+#let lnand(name, node, ..params) = logic(name, node, ..params, text: $"&"$, invert: true)
+#let lor(name, node, ..params) = logic(name, node, ..params, text: $>=1$)
+#let lnor(name, node, ..params) = logic(name, node, ..params, text: $>=1$, invert: true)
+#let lxor(name, node, ..params) = logic(name, node, ..params, text: $=1$)
+#let lxnor(name, node, ..params) = logic(name, node, ..params, text: $=1$, invert: true)

src/lib/mathExpressions.typ

@@ -0,0 +1,13 @@
+// Math macors
+#let kern(x) = $op("kern")(#x)$
+#let alg(x) = $op("alg")(#x)$
+#let geo(x) = $op("geo")(#x)$
+#let spann(x) = $op("spann")(#x)$
+#let Bild(x) = $op("Bild")(#x)$
+#let Rang(x) = $op("Rang")(#x)$
+#let Eig(x) = $op("Eig")(#x)$
+#let lim = $limits("lim")$
+#let ip(x, y) = $lr(angle.l #x, #y angle.r)$
+
+#show math.integral: it => math.limits(math.integral)
+#show math.sum: it => math.limits(math.sum)

src/lib/table.typ

@@ -0,0 +1,80 @@
+#import "@preview/zap:0.5.0"
+#import "logic.typ"
+
+#let circuit(body) = zap.circuit({
+  import zap: *
+
+  set-style(
+    node: (
+      radius: 0.04,
+    )
+  )
+
+  body
+})
+
+#table(
+  columns: (1fr, 1fr),
+  align: center + horizon,
+  stroke: (x, y) => (
+    left: if x > 0 { 0.5pt },
+    top: if y == 1 { 1pt } else if y > 0 { 0.5pt },
+  ),
+  table.header([DNF], [KNF]),
+  circuit({
+    import zap: *
+
+    logic.land("A1", (0, 0.75), invert-inputs: (1,))
+    logic.land("A2", (0, -0.75), invert-inputs: (2,))
+
+    logic.lor("O1", (1.25, 0))
+
+    zwire("A1.out", "O1.in1", ratio: 50%)
+    zwire("A2.out", "O1.in2", ratio: 50%)
+
+    wire((-1, 1.25), (-1, -1.25), name: "A")
+    wire((-0.75, 1.25), (-0.75, -1.25), name: "B")
+
+    cetz.draw.content("A.in", [a], anchor: "south", padding: 2pt)
+    cetz.draw.content("B.in", [b], anchor: "south", padding: 2pt)
+
+    node("N4", ("A1.in1", "-|", "A.in"))
+    wire("A1.in1", "N4")
+    node("N3", ("A1.in2", "-|", "B.in"))
+    wire("A1.in2", "N3")
+    node("N2", ("A2.in1", "-|", "A.in"))
+    wire("A2.in1", "N2")
+    node("N1", ("A2.in2", "-|", "B.in"))
+    wire("A2.in2", "N1")
+
+    wire("O1.out", (rel: (0.3, 0)))
+  }),
+  circuit({
+    import zap: *
+
+    logic.lor("A1", (0, 0.75))
+    logic.lor("A2", (0, -0.75), invert-inputs: (1,2))
+
+    logic.land("O1", (1.25, 0))
+
+    zwire("A1.out", "O1.in1", ratio: 50%)
+    zwire("A2.out", "O1.in2", ratio: 50%)
+
+    wire((-1, 1.25), (-1, -1.25), name: "A")
+    wire((-0.75, 1.25), (-0.75, -1.25), name: "B")
+
+    cetz.draw.content("A.in", [a], anchor: "south", padding: 2pt)
+    cetz.draw.content("B.in", [b], anchor: "south", padding: 2pt)
+
+    node("N4", ("A1.in1", "-|", "A.in"))
+    wire("A1.in1", "N4")
+    node("N3", ("A1.in2", "-|", "B.in"))
+    wire("A1.in2", "N3")
+    node("N2", ("A2.in1", "-|", "A.in"))
+    wire("A2.in1", "N2")
+    node("N1", ("A2.in2", "-|", "B.in"))
+    wire("A2.in2", "N1")
+
+    wire("O1.out", (rel: (0.3, 0)))
+  })
+)

src/lib/truthtable.typ

@@ -0,0 +1,35 @@
+#let truth-table(outputs: (), inputs: none) = {
+  let variables = calc.max(..outputs.map(output => calc.ceil(calc.log(output.at(1).len()) / calc.log(2))))
+
+  if inputs == none {
+    inputs = ($a$, $b$, $c$, $d$).slice(0, variables)
+  }
+
+  assert(outputs.len() >= 1, message: "There has to be at least one output")
+  assert(inputs.len() == variables, message: "There aren't enough variables to label")
+
+  let num-to-bin(x, digits) = {
+    let bits = ()
+
+    while x != 0 {
+      bits.push(calc.rem(x, 2))
+
+      x = calc.floor(x / 2)
+    }
+
+    range(digits).map(x => bits.at(digits - x - 1, default: 0))
+  }
+
+  table(
+    columns: (auto,) * (variables + outputs.len()),
+    stroke: (x, y) => (
+      left: if x == variables { 1pt } else if x > 0 { 0.5pt },
+      top: if y == 1 { 1pt } else if y > 0 { 0.5pt },
+    ),
+    inset: 4pt,
+    if inputs != none { table.header(..inputs.map(x => [#x]), ..outputs.map(((x, _)) => [#x])) },
+    ..range(calc.pow(2, variables))
+      .map(x => (..num-to-bin(x, variables).map(y => [#y]), ..outputs.map(((_, y)) => [#y.at(x, default: [])])))
+      .flatten()
+  )
+}

src/sintable.json

@@ -0,0 +1,18 @@
+
+{
+    "x": [
+        "0", "pi/6", "pi/4", "pi/3", "pi/2", "(2pi)/3", "(3pi)/4", "(5pi)/6", "pi", "(7pi)/6", "(5pi)/4", "(4pi)/3", "(3pi)/2", "(5pi)/3", "(7pi)/4", "(11pi)/6", "2pi"
+    ],
+    "alpha": [
+        "0°", "30°", "45°", "60°", "90°", "120°", "135°", "150°", "180°", "210°", "225°", "240°", "270°", "300°", "315°", "330°", "360°"
+    ],
+    "cos(x)": [
+        "1", "sqrt(3)/2", "sqrt(2)/2", "1/2", "0", "-1/2", "-sqrt(2)/2", "-sqrt(3)/2", "-1", "-sqrt(3)/2", "-sqrt(2)/2", "-1/2", "0", "1/2", "sqrt(2)/2", "sqrt(3)/2", "1"
+    ],
+    "sin(x)": [
+        "0", "1/2", "sqrt(2)/2", "sqrt(3)/2", "1", "sqrt(3)/2", "sqrt(2)/2", "1/2", "0", "-1/2", "-sqrt(2)/2", "-sqrt(3)/2", "-1", "-sqrt(3)/2", "-sqrt(2)/2", "-1/2", "0"
+    ],
+    "tan(x)": [
+        "0", "1/sqrt(3)", "1", "sqrt(3)", "x", "-sqrt(3)", "-1", "-1/sqrt(3)", "0", "1/sqrt(3)", "1", "sqrt(3)", "x", "-sqrt(3)", "-1", "-1/sqrt(3)", "0"
+    ]
+}