Added stuff

This reverts commit 6270f092ef.

.gitea/workflows/build-script.yaml

@@ -7,58 +7,74 @@ 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:
-          fetch-depth: 1
           submodules: false
           lfs: false
 
       - 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: |
-            Automated release of Typst-generated PDFs.
+            build/*.pdf
+            inventory.json
           
-            Commit: ${{ github.sha }}
+      - name: Update and push latest tag
-          files: ${{ env.BUILD_DIR }}/*.pdf
+        env:
+          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
+        run: |
+          set -euo pipefail
+
+          git config user.name  "gitea-actions"
+          git config user.email "actions@local"
+
+          # Ensure origin uses token auth
+          git remote set-url origin "https://oauth2:${GITEA_TOKEN}@gitea.mintcalc.com/alexander/TUM-Formelsammlungen.git"
+
+          # Move (or create) the tag locally
+          git tag -f latest
+
+          # Force-push the tag to overwrite remote 'latest'
+          git push origin refs/tags/latest --force
+          
+      - name: Trigger 
+        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

inventory.json

@@ -0,0 +1,25 @@
+{
+    "author": "alexander",
+    "cheatsheets": {
+        "sem1-Analysis_1.pdf": {
+            "module": "Analysis 1",
+            "semester": "1"
+        },
+        "sem1-Schaltungstheorie.pdf": {
+            "module": "Schaltungstheorie",
+            "semester": "1"
+        },
+        "sem1-Lineare-algebra.pdf": {
+            "module": "Lineare Algebra",
+            "semester": "1"
+        },
+        "sem1-Digitaltechnik.pdf": {
+            "module": "Digitaltechnik",
+            "semester": "1"
+        },
+        "sem1-Computertechnik.pdf": {
+            "module": "Computertechnik",
+            "semester": "1"
+        }
+    }
+}

src/Schaltungstheorie/Schaltungstheorie.typ

@@ -1,208 +0,0 @@
-#import "../lib/common_rewrite.typ" : *
-#import "@preview/mannot:0.3.1"
-#import "@preview/zap:0.5.0"
-
-#show math.equation.where(block: true): it => math.inline(it)
-
-#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,))]
-    )
-  ],
-)
-
-#let colorAllgemein = color.hsl(105.13deg, 92.13%, 75.1%)
-#let colorEineTore = color.hsl(202.05deg, 92.13%, 75.1%)
-#let colorZweiTore = color.hsl(235.9deg, 92.13%, 75.1%)
-#let colorAnalyseVerfahren = color.hsl(280deg, 92.13%, 75.1%)
-#let colorComplexAC = color.hsl(356.92deg, 92.13%, 75.1%)
-#let colorMathe = color.hsl(34.87deg, 92.13%, 75.1%)
-
-#place(top+center, scope: "parent", float: true, heading(
-  [Schaltungstheorie]
-))
-
-
-#columns(4, gutter: 2mm)[
-  #bgBlock(fill: colorEineTore)[
-    #subHeading(fill: colorEineTore)[Quelle Wandlung]
-
-    #zap.circuit({
-      import zap: *
-      set-style(scale: (x: 0.75, y:0.75), fill: none)
-      resistor("R1", (-2, 0), (0, 0))
-      vsource("V1", (-2, 0), (-2, -2))
-      wire((-2, -2), (0, -2))
-      node("n1", (0, 0), label: "1")
-      node("n2", (0, -2), label: "2")
-    })
-  ]
-
-  #bgBlock(fill: colorAnalyseVerfahren)[
-    #subHeading(fill: colorAnalyseVerfahren)[Graphen und Matrizen]
-
-    $bold(i_b)$ (oder $bold(i)$): Zweigstrom-Vektor \
-    $bold(u_b)$ (oder $bold(u)$): Zweigspannungs-Vektor \
-    $bold(i_m)$ : Maschenstrom-Vektor \
-      #text(rgb(20%, 20%, 20%))[(Strom in einer viruellen Masche)] \
-    $bold(u_k)$ : Kontenspannungs-Vektor \
-      #text(rgb(20%, 20%, 20%))[(Spannung zwischen Referenzknoten und Knoten k)] \
-
-    #line(length: 100%, stroke: (thickness: 0.2mm))
-
-    Knotenzidenzmatrix $bold(A)$
-
-    $bold(A) : bold(i_k) -> text("Knotenstrombianz") = 0$ \
-    $bold(A^T) : bold(u_b)-> bold(u_k)$
-    $ 
-      bold(A) = quad mannot.mark(mat(
-        a_11, a_12, ..., a_(1m);
-        a_21, a_22, ..., a_(2m);
-        dots.v, dots.v, dots.down, dots.v;
-        a_(n 1), a_(n 2), ..., a_(n m)
-      ), tag: #<1>)
-
-      #mannot.annot(<1>, pos:left, text(rgb("#404296"))[#rotate(-90deg)[$<-$ Knoten]], dx: 5mm)
-      #mannot.annot(<1>, pos:bottom, text(rgb("#404296"))[Zweige $->$], dy: -0.5mm)
-
-      a in {-1, 0, 1}
-    $
-    
-    #line(length: 100%, stroke: (thickness: 0.2mm))
-    
-    Mascheninsidenz Matrix $bold(B)$\
-
-
-    $bold(B) : bold(u_b) -> text("Zweigspannungsbilanz") = 0$ \
-    $bold(B^T) : bold(i_m) -> i_b$
-
-    $ 
-      bold(B) = quad mannot.mark(mat(
-        b_11, b_12, ..., b_(1m);
-        b_21, b_22, ..., b_(2m);
-        dots.v, dots.v, dots.down, dots.v;
-        b_(n 1), b_(n 2), ..., b_(n m)
-      ), tag: #<1>)
-
-      #mannot.annot(<1>, pos:left, text(rgb("#404296"))[#rotate(-90deg)[$<-$ Maschen]], dx: 6mm)
-      #mannot.annot(<1>, pos:bottom, text(rgb("#404296"))[Zweige $->$], dy: -0.5mm)
-
-      b in {-1, 0, 1}
-    $
-
-    #line(length: 100%, stroke: (thickness: 0.2mm))
-
-    *KCL und KVL* \
-
-    KCL in Nullraum: $ bold(A) bold(i_b) = bold(0)$ \
-    KVL in Bildraum: $ bold(A^T) bold(u_k) = bold(u_b)$
-
-    KVL in Nullraum: $bold(B) bold(u_b) = bold(0)$ \
-    KCL in Bildraum: $bold(B^T) bold(i_m) = bold(i_b)$ \
-
-    *Tellegen'sche Satz* \
-    $bold(A B^T) = bold(B^T A) = 0$ \
-    $bold(u_b^T i_b) = 0$
-  ]
-
-  #bgBlock(fill: colorAnalyseVerfahren)[
-    #subHeading(fill: colorAnalyseVerfahren)[Baumkonzept]
-  ]
-
-  #bgBlock(fill: colorAnalyseVerfahren)[
-    #subHeading(fill: colorAnalyseVerfahren)[Machenstrom-/Knotenpotenzial-Analyse]
-  ]
-
-  #bgBlock(fill: colorAnalyseVerfahren)[
-    #subHeading(fill: colorAnalyseVerfahren)[Reduzierte Knotenpotenzial-Analyse]
-  ]
-
-  
-]
-
-#pagebreak()
-#place(bottom+left, scope: "parent", float: true)[
-  #bgBlock(fill: colorZweiTore)[
-    #subHeading(fill: colorZweiTore)[Umrechnung Zweitormatrizen]
-      #show table.cell: it => pad(),
-
-      #table(
-        columns: (auto, 1fr, 1fr, 1fr, 1fr, 1fr, 1fr),
-        align: center,
-        gutter: 0.1mm,
-        [In $->$], $bold(R)$, $bold(G)$, $bold(H)$, $bold(H')$, $bold(A)$, $bold(A')$,
-        
-        $bold(R)$,
-        $mat(r_11, r_12; r_21, r_22)$,
-        $1/det(bold(G)) mat(g_22, -g_12; -g_21, g_11)$,
-        $1/h_22 mat(det(bold(H)), h_12; -h_21, 1)$,
-        $1/h'_11 mat(1, -h'_12; h'_21, det(bold(H')))$,
-        $1/a_21 mat(a_11, det(bold(A)); 1, a_22)$,
-        $1/a'_21 mat(a'_22, 1; det(bold(A')), a'_11)$,
-
-        $bold(G)$,
-        $1/det(bold(R)) mat(r_22, -r_12; -r_21, r_11)$,
-        $mat(g_11, g_12; g_21, g_22)$,
-        $1/h_11 mat(1, -h_12; h_21, det(bold(H)))$,
-        $1/h'_22 mat(det(bold(H')), h'_12; -h'_21, 1)$,
-        $1/a_12 mat(a_22, -det(bold(A)); -1, a_11)$,
-        $1/a'_12 mat(a'_11, -1; -det(bold(A')), a'_22)$,
-
-        $bold(H)$,
-        $1/r_22 mat(det(bold(R)), r_12; -r_21, 1)$,
-        $1/g_11 mat(1, -g_12; g_21, det(bold(G)))$,
-        $mat(h_11, h_12; h_21, h_22)$,
-        $1/det(bold(H')) mat(h'_22, -h'_12; -h'_21, h'_11)$,
-        $1/a_22 mat(a_12, det(bold(A)); -1, a_21)$,
-        $1/a'_11 mat(a'_12, 1; -det(bold(A')), a'_21)$,
-
-        $bold(H')$,
-        $1/r_11 mat(1, -r_12; r_21, det(bold(R)))$,
-        $1/g_22 mat(det(bold(G)), g_12; -g_21, 1)$,
-        $1/det(bold(H)) mat(h_22, -h_12; -h_21, h_11)$,
-        $mat(h'_11, h'_12; h'_21, h'_22)$,
-        $1/a_11 mat(a_21, -det(bold(A)); 1, a_12)$,
-        $1/a'_22 mat(a'_21, -1; det(bold(A')), a'_12)$,
-
-        $bold(A)$,
-        $1/r_21 mat(r_11, det(bold(R)); 1, r_22)$,
-        $1/g_21 mat(-g_22, -1; -det(bold(G)), -g_11)$,
-        $1/h_21 mat(-det(bold(H)), -h_11; -h_22, -1)$,
-        $1/h'_21 mat(1, h'_22; h'_11, det(bold(H')))$,
-        $mat(a_11, a_12; a_21, a_22)$,
-        $1/det(bold(A')) mat(a'_22, a'_12; a'_21, a'_11)$,
-
-        $bold(A')$,
-        $1/r_12 mat(r_22, det(bold(R)); 1, r_11)$,
-        $1/g_12 mat(-g_11, -1; -det(bold(G)), -g_22)$,
-        $1/h_12 mat(1, h_11; h_22, det(bold(H)))$,
-        $1/h'_12 mat(-det(bold(H')), -h'_22; -h'_11, -1)$,
-        $1/det(bold(A)) mat(a_22, a_12; a_21, a_11)$,
-        $mat(a'_11, a'_12; a'_21, a'_22)$,
-      )
-  ]
-]
-
-
-
-
-#place(bottom+left, scope: "parent", float: true)[
-  #bgBlock(fill: colorAllgemein, [
-    #subHeading(fill: colorAllgemein, [Sin-Table])
-    #sinTable
-  ])
-]
-

src/analysis1/Analysis1.typ

@@ -1,546 +0,0 @@
-#import "../lib/common_rewrite.typ" : *
-#import "@preview/mannot:0.3.1"
-
-#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(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)[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]
-    *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) + tan(y) = (tan(a) + tan(b))/(1 - tan(a) tan(b))$ \
-    $arctan(x) + arctan(y) = arctan((x+y)/(1 - x y))$ \
-
-    *Doppelwinkel Formel* \
-    $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)$],
-    )
-  ])
-
-
-  #bgBlock(fill: colorIntegral, [
-    #subHeading(fill: colorIntegral, [Integral])
-
-    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$
-
-    *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 g'(x) d x$
-    
-    1. Ersetzung: $ d x := d t dot 1/(g'(x))$ und $t := g(x)$
-    2. Grenzen: $t_0 = g(x_0)$, $t_1 = g(x_1)$
-    3. $x$-kürzen sich weg
-  ])
-
-]
-
-#bgBlock(fill: colorAllgemein, [
-  #subHeading(fill: colorAllgemein, [Sin-Table])
-  #sinTable
-])
-
-#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) $
-  #bgBlock(fill: colorIntegral, [
-    #subHeading(fill: colorIntegral, [Integral])
-
-    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$
-
-    *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 g'(x) d x$
-    
-    1. Ersetzung: $ d x := d t dot 1/(g'(x))$ und $t := g(x)$
-    2. Grenzen: $t_0 = g(x_0)$, $t_1 = g(x_1)$
-    3. $x$-kürzen sich weg
-  ])
-

src/cheatsheets/Analysis1.typ

@@ -0,0 +1,779 @@
+#import "@preview/mannot:0.3.1"
+
+#import "../lib/ableitungs_tabelle.typ" : *
+#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 $ \
+      ],
+
+      [
+        *Gaußklammer*: \
+          $floor(x) = text("floor")(x)$ \
+          $ceil(x) = text("ceil")(x)$ \
+      ],
+      [
+      ],
+    )
+
+    $bold("Fakultäten") 0! = 1! = 1\
+    e approx  2.71828 quad quad quad pi approx 3.14159
+    $
+  ]
+
+  // 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$
+    )
+
+    $tan(x)=sin(x)/cos(x) = -cot(x + pi/2)$
+
+    $cot(x)=cos(x)/sin(x)=-tan(x + pi/2)$
+
+    #grid(
+      gutter: 5mm,
+      row-gutter: 3mm,
+      columns: (auto, auto),
+      [$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 $a_(n+1) lt.eq.gt a_(n)$*
+    - Beweise: Induktion
+
+    *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] $
+    - unbeschränkt $=>$ Divergent
+  
+    *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),
+      gutter: 3mm,
+      row-gutter: 3mm,
+      $e^x = limits(sum)_(n=0)^m (x^n)/(n!) + O(x^(m+1))$,
+      $ln(x) = limits(sum)_(n=0)^m (-1)^n x^(n+1) + O(x^(m+1))$,
+      $sin(x) = limits(sum)_(n=0)^m (-1)^n (z^(2n+1))/((2n + 1)!) + O(x^(2m + 3))$,
+      $cos(x) = limits(sum)_(n=0)^m (-1)^n (z^(2n))/((2n)!) + O(x^(2m + 2))$
+    )
+  ]
+
+  // 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 y 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 \
+      $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
+
+    *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)
+    #ableitungsTabelle
+  ])
+
+  // 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 oder 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")\) d x = integral_g(x_0)^g(x_1) f(t) dot <1/(g'(x)) d t$
+    
+
+
+    1. Ersetzung: $t := g(x)$
+    2. Umformen:
+      $(d t)/(d x) = g'(x)$
+
+    *Weierstrass Subsitution/Brechstange* \
+    Subsitution: $t = tan(x/2)$
+
+    #grid(
+      columns: (1fr, 1fr),
+      row-gutter: 2.8mm,
+      $d x = 2/(1+t^2) d t$,
+      $sin(x) = 2t / (1 + t^2)$,
+      $tan(x) = (2t)/(1-t^2)$,
+      $cos(x) = (1-t^2) / (1 + t^2)$,
+    )
+
+    *Tricks aus der Schule*
+
+    $integral f(a x+b) d x = 1/a F(a x + b) +c \
+    integral (f'(x))/f(x) d x = ln abs(f(x)) \
+    integral f'(x) e^(f(x)) d x = e^(f(x)) +c \
+    $
+  ])
+
+  #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 t$
+    
+    1. Ersetzung: $ d x := 1/g'(x) dot d t$ und $t := g(x)$
+    2. Grenzen: $t_0 = g(x_0)$, $t_1 = g(x_1)$
+
+    *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*
+
+    $integral 1/(x-a) d x = ln(x - a) + c\
+    integral 1/(x-a)^n d x = - 1/(n-1) 1/(x - a)^(n-1) + c quad "für" n >= 2 \
+    integral 1/((x - a)^2 + b^2) d x = 1/b arctan((x - a)/b) + c quad "für" n > 0\
+    integral (x - a)/((x-a)^a + b^2) d x  = 1/2 ln((x-a)^2 + b^2) + c \    
+    $
+
+    #grid(
+      columns: (1fr),
+      column-gutter: 2mm,
+      row-gutter: 4mm,
+      $integral 1/x d x = ln abs(x) +c$,
+      $integral 1/x^2 d x = - 1/x + c$,
+      $integral 1/(a + x) d x = ln abs(a + x) + c$,
+      $integral 1/(a + x)^2 d x = - 1/(a + x) + c$,
+      $integral 1/(a - x) d x = - ln abs(a - x) + c$,
+      $integral 1/(a - x)^2 d x = 1/(a - x) + c$
+    )
+
+
+  ])
+
+  #bgBlock(fill: colorAllgemein, [
+    #subHeading(fill: colorAllgemein, [Sin-Table])
+    #sinTable
+  ])
+
+  /*
+  // Notwending und Hinreichend
+  #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"$,
+    )
+  ])
+  */
+
+  // Taylor Reihen
+  #bgBlock(fill: colorAbleitung)[
+    #subHeading(fill: colorAbleitung)[Taylorreihe]
+
+    $T_m (x_0;x) = sum^m_(k=0) (f^((k))(x_0))/(k!) (x-x_0)^k$
+
+    $f(x) = T_m (x_0;x) + R_(m+1)(x_0;x)$
+
+    *Restglied* \
+    $I = (a,b) quad x_0,x in I$
+    
+    $R_(m+1) (x) = 1/(m!) integral_(x_0)^x (x-t)^m f^((m+1))(t) d t$ \
+
+    $forall x in I space space exists xi_x in I "sodass" \
+    R_(m+1)(x_0;x) = (f^((m+1))(xi_x))/((m + 1)!) (x - x_0)^(m+1)\ 
+    = f(x_0 + h) - T_m (x_0; x_0 + h) = o(h^m) = O(h^(m+1))$
+  ]
+
+  // Lamdauer Notation
+  #bgBlock(fill: colorFolgen, [
+    #subHeading(fill: colorFolgen)[Landau Notation]
+
+    $f(x) = o(g(x)) "wenn" lim_(x->a) f(x)/g(x) = 0 \
+      f(x) = O(g(x)) "wenn" abs(f(x)) <= abs(g(g))$
+
+    *Rechen Regelen* \
+    - $f = o(g) => f = O(g)$
+    - $f_1 + f_2 = O\/o(f_1) + O\/o(f_2)$
+    - $f_1 dot f_2 = O\/o(f_1 dot f_2)$
+
+
+  ])
+
+  // Kurven
+  #bgBlock(fill: colorAbleitung)[
+    #subHeading(fill: colorAbleitung)[Kurven]
+
+    Länge einer Kurve $k(t)$: $L(k) = integral_a^b norm(k'(t)) d t$
+
+    Umparametrisierung: $h(tau)$ *streng monoton steigended* \
+    $h(tau): [a,b] -> [overline(a), overline(b)]$
+
+    $overline(k): [overline(a), overline(b)] -> R^n, quad overline(k) = k(h(tau))$
+
+    Parametriesierung nach Länge: \
+    $s(t) = integral_a^t norm(k'(tau)) d tau quad overline(k)(tau) = k(s^(-1)(tau))$
+
+    Wenn $k$ nach Länge param.: $T(t) =k'(t)$
+
+    Tangentenvektor: $T(t) = (k'(t))/norm(k'(t))$ \
+    Krümmung: $kappa(t) = 1/(s'(t)) norm(T'(t))$
+
+
+    $RR^2: kappa(t) = abs(x'(t)y''(t) - y'(t)x''(t))/((x'(t)^2 + y'(r)^2)^(3/2))$ \
+    Param Länge: $kappa(t) = abs(x'(t)y''(t) - y'(t)x''(t))$
+  ]
+]

src/cheatsheets/CT.typ

@@ -0,0 +1,443 @@
+#import "../lib/styles.typ" : *
+#import "../lib/common_rewrite.typ" : *
+#import "../lib/bit_fields.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 colorMMIX = color.hsl(280deg, 92.13%, 75.1%)
+#let colorRandomShit = 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)[Fixed Point]
+
+    #table(
+      columns: 17,
+      fill: (x, y) => if calc.rem(x, 2) == 1 { tableFillLow } else { tableFillHigh },
+
+      .. for i in range(0,17) {
+        ([$2^#i$],)
+      },
+      .. for i in range(0,17) {
+        ($#calc.pow(2,i)$,)
+      }
+    )
+
+    #columns(2, [
+      *Vorzeichen und Betrag:*
+
+      #grid(
+        columns: (2fr, 1fr),
+        [
+          $x = (-1)^"sign-bit" dot "Betrag"$
+
+          $0 -> "positiv", 1 -> "negativ"$
+
+          Range: \ $(-2^(n-1) - 1) dot 2^r$ bis $(2^(n-1) - 1) dot 2^r$
+
+          Achtung: $plus.minus 0$
+        ],
+        image("../images/ct/betragUndVorzeich.png", width: 2cm)
+      )
+
+      #line(length: 100%, stroke: (thickness: 0.2mm))
+
+      *Einer-Komplement*
+      
+      #grid(
+        columns: (2fr, 1fr),
+        [
+          $x = (-1)^"sign-bit" dot "Betrag"$
+
+          $0 -> "positiv normaler Betrag"$
+
+          $1 -> "negativ INVERT. Betrag"$
+
+          Range: \ 
+          $(-2^(n-1) - 1) dot 2^r$ bis $(2^(n-1) - 1) dot 2^r$
+
+          Achtung: $plus.minus 0$
+        ],
+        image("../images/ct/einerKomplement.png", width: 2cm)
+      )
+      #colbreak()
+
+      *Zweier-Komplement*
+
+      #grid(
+        columns: (2fr, 1fr),
+        [
+          $x = (-1)^"sign-bit" dot "Betrag"$
+
+          $0 -> "positiv"$
+
+          $1 -> "negativ"$
+
+          Range: \ $(-2^(n-1)) dot 2^r$ bis $(2^(n-1) - 1) dot 2^r$
+
+          Positiv: Normal Binär Kodierung
+
+          Negativ: #raw("Invertiert(Binär) + 1")
+
+        ],
+        image("../images/ct/zweierKomplement.png", width: 2cm)
+      )
+
+      #line(length: 100%, stroke: (thickness: 0.2mm))
+      
+      *Radix / Fixed Point*
+
+      $r = 0$ Normal Falle, nix änder sich
+
+      $r > 0$ : Komma nach Rechts und Nullen auffüllen \
+      Bsp. $r = 3 quad ->$  #raw("xxxxxxx000.")
+
+      $r < 0$ : Komma nach Links verschieben \
+      Bsp: $r = -4 quad ->$ #raw("xxxxx.xxxx")
+
+    ])
+  ]
+
+  #colbreak()
+  #bgBlock(fill: colorNumberSystems)[
+    #subHeading(fill: colorNumberSystems)[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)
+    })
+
+    $x = (-1)^"sign" dot #raw("1.[mantisse]")  dot 2^(("exponent" - k))$
+
+    #grid(
+      columns: (auto, auto),
+      column-gutter: 5mm,
+      row-gutter: 2mm,
+      $"float32"&, k = 127 &= #raw("    111 1111") "(7 x Einser)" \
+       "float64"&, k = 1023 &= #raw("11 1111 1111") "(10 x Einser)"$
+    )
+
+    *Spezial Cases* 
+    #table(
+      columns: (auto, auto),
+      [$0$], [exponent = 0 \ mantisse = 0],
+      [$plus.minus infinity$], [exponent = alle 1 \ mantisse = 0],
+      [NaN], [exponent = alle 1 \ mantisse > 0],
+      [denormalisierte Float], [exponent = 0 \ mantisse > 0],
+      [normalisierter Float], [0 < exponent < 255/2047]
+    )
+  ]
+
+  #bgBlock(fill: colorProgramming)[
+    #subHeading(fill: colorProgramming)[C]
+
+    #table(
+      columns: (auto, auto, auto),
+      fill: (x, y) => if calc.rem(y, 2) == 0 { tableFillLow } else { tableFillHigh },
+
+      [*C-Type*], [*min size*], [*typ. size*],
+      raw("char"), raw("1 byte"), raw("1 byte"),
+      raw("short (int)"), raw("2 byte"), raw("2 byte"),
+      raw("int"), raw("2 byte"), raw("4 byte"),
+      raw("long (int)"), raw("4 byte"), raw("8 byte"),
+      raw("long long"), raw("4 byte"), raw("8 byte"),
+      raw("float"), raw("4 byte"), raw("4 byte"),
+      raw("double"), raw("8 byte"), raw("8 byte"),
+
+    )
+
+    #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
+      ]
+    )
+  ]
+
+  #bgBlock(fill: colorProgramming)[
+    #subHeading(fill: colorProgramming)[#raw("scanf/printf") Format Specifier]
+
+    #columns(2)[
+      *printf* 
+      #table(
+        columns: (auto, auto),
+        fill: (x, y) => if calc.rem(y, 2) == 0 { tableFillLow } else { tableFillHigh },
+        raw("%s"), [*String*],
+        raw("%d"), [*Decimal: #raw("int/short/long"))*],
+        raw("%f"), [*Float*],
+        raw("%f"), [*Float*],
+        raw("%lf"), [*Double*],
+        raw("%x"), [* Hexdecimal #raw("int/short/long")*],
+      )
+
+      Allgemeiner Syntax: #raw("%[flags][width][.precision]type")
+
+      Flags:
+      - #raw("0") Prepend With left aligned
+      - #raw("-") Left-aligned
+
+      #table(columns: (auto, auto),
+        fill: (x, y) => if calc.rem(y, 2) == 0 { tableFillLow } else {  tableFillHigh },
+        raw("\\n"), [New Line],
+        raw("\\t"), [Tab],
+        raw("\\0"), [Null Terminator],
+        raw("\\\\"), [#raw("\\")],
+        raw("\\\""), [#raw("\"")],
+      )
+
+      #colbreak()
+
+      *scanf*
+      #table(
+        columns: (auto, auto),
+        fill: (x, y) => if calc.rem(y, 2) == 0 { tableFillLow } else { tableFillHigh },
+        raw("%[size of String]s"), [*String* \ Size of String (without the #raw("\\0")) \ Terminates with Whitespace],
+        raw("%i"), [*#raw("int")*],
+        raw("%f"), [*#raw("float")*],
+        raw("%lf"), [*#raw("double")*],
+        raw("%x"), [*#raw("int")* als Hexadezimal],
+        raw("%c"), [*#raw("char")* ],
+      )
+
+      #raw("fgets(char * s, int count, stdin)")
+    ]
+  ]
+
+  #bgBlock(fill: colorMMIX)[
+    #subHeading(fill: colorMMIX)[MMIX]
+    - $32$ Speziel Register
+    - $256$ Allzwickregister
+    - $2^64$ Speicher
+
+    Wort: $64$ Bit
+    
+    *Calling Convensions*
+
+    #cetz.canvas({
+      import cetz.draw : *
+
+      let cellHeight = 0.4
+      let cellWidth = 2
+
+      let c(y, c, x: 0, number: "") = {
+        rect((x, cellHeight*y), (x + cellWidth,  cellHeight*(y+1)), fill: white)
+        content((x+ cellWidth/2, cellHeight*(y+0.5)), c)
+        content((x - 0.2, cellHeight*(y+0.5)), number, anchor: "mid-east")
+      }
+
+      c(0, "3.Param", number: raw("0x3FFFFFFFFFFFFFF8"))
+      c(1, "2.Param", number: raw("0x3FFFFFFFFFFFFFF0"))
+      c(2, "1.Param", number: raw("0x3FFFFFFFFFFFFFE8"))
+      c(3, "Sicherung $1", number: raw("0x3FFFFFFFFFFFFFE0"))
+      c(4, "Sicherung $2", number: raw("0x3FFFFFFFFFFFFFD8"))
+
+      c(0, "Rückgabe wert", x: cellWidth)
+    })
+
+    #colbreak()
+
+#text(rgb("#1a00aa"))[
+*1. (Aufrufer) Parameter auf Stack ablegen*\
+#raw("SUB :SP,:SP,n*8
+STO $x0,:SP,0*8
+STO $x1,:SP,1*8
+...
+STO $xn,:SP,n*8")
+
+*2. (Aufrufer) Funktions Aufruf*\
+#raw("GO $0,:Fkt")
+]
+
+#text(rgb("#aa0000"))[
+*3. (Funktion) Sicherung der Register*\
+#raw("SUB :SP,:SP,n*8
+STO $y0,:SP,0*8
+STO $y1,:SP,1*8
+...
+STO $yn,:SP,n*8")
+
+*4. (Funktion) Funktions Code*\
+
+*5. (Funktion) Schreiben des Rückgabewerts*\
+#raw("
+STO $r,:SP,m*8
+")
+
+*6. (Funktion) Wiederherstellung der Register*\
+#raw("LDO $x0,:SP, 0*8 + k
+LDO $x1,:SP, 1*8 + k
+...
+LDO $xn,:SP, n*8 + k
+")
+
+*7. (Funktion) Rücksprung*\
+]
+
+#text(rgb("#1a00aa"))[
+*8. (Aufrufer) Lesen des Rückgabewerts*\
+
+
+]
+]
+
+  #bgBlock(fill: colorRandomShit)[
+    #subHeading(fill: colorRandomShit)[Register Register Magista]
+
+    *Zwei-Address-Maschine:* $quad X <-- X dot.o Y$, Parameter: $(X,Y)$ \
+    *Drei-Address-Maschine:* $quad X <-- Y dot.o Z$, Parameter: $(X,Y,Z)$ \
+    *Ein-Address-Maschine:* $quad "ACC" <-- X$, Parameter: $(X)$
+
+    *Register-Speicher-Architekture:* \
+    Operanden können Register und Addressen sein
+    
+    *Register-Register-Archiektur/Load-Store-Architektur* \
+    Operanden nur Register. Extra Befehle fürs Laden aus Speicher
+
+
+    *CISC*: Complex Instruction Set Architecture
+    - Eine Befehl kann viel $->$ Wenige Befehle
+    - Befehlslänge Variable (meistens)
+    - z.B. x86
+
+    *RISC*: Reduced Instruction Set Architecture
+    - Eine Befehl kann wenig $->$ Viel Befehle
+    - Befehlslänge fix (meistens)
+    - z.B. Arm, RISC, MMIX
+
+    *Universal Rechner*
+    
+    - M1: Ergebnis Qulle
+      - Input a,b,c oder ALU
+    - M2: ALU Operation 
+    - M3,M4: Operanden
+      - R0-R7
+    - D: Ergebnis Register
+      - R0-R7
+    - K: Konstante für Operanden 
+  ]
+]

src/cheatsheets/LinearAlgebra.typ

@@ -0,0 +1,901 @@
+#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: 6pt)
+
+#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 MathAlignLeft(e) = {
+  align(left, block(e))
+}
+#columns(5, gutter: 2mm)[
+
+    // Gruppen
+    #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$ \
+            z.B. Komposition von Funktionen
+        - Abgeschlossenheit
+        *Monoid* Halbgruppe $M$ mit:
+        - Neutrales-/Identäts-Element: $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)$
+        - Wenn $a = a^(-1) =>$ Gruppe kommutativ 
+
+
+
+        *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_
+
+        #SeperatorLine
+
+        $S_n$: Symetrisch Gruppe (Permutation von element) \
+        $(S_n, compose)$ ist Gruppe, aber nicht kommutativ
+    ]
+
+    /*
+    // Komplex Zahlen
+    #bgBlock(fill: colorAllgemein)[
+        #subHeading(fill: colorAllgemein)[Komplexe Zahlen]
+        
+        #ComplexNumbersSection()
+    ]
+    */
+
+    // Matrix Typen
+    #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))$, 110%)) #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 : *
+                let scale = 0.76;
+
+                rect((0, 0), (1*scale, 1*scale), fill: rgb("#9292926b"))
+
+                set-style(mark: (end: (symbol: "straight")))
+                line((0, -0.2*scale), (1*scale, -0.2*scale), stroke: (paint: blue, thickness: 0.3mm))
+                line((-0.2*scale, 1*scale), (-0.2*scale, 0), stroke: (paint: red, thickness: 0.3mm))
+
+                content((-0.45*scale, 0.5*scale), $colred(bold(m))$)
+                content((0.5*scale, -0.35*scale), $colblue(bold(n))$)
+                content((0.5*scale, 0.5*scale), $A$)
+            })
+        )
+    ]
+
+    // Matrix Normen
+    #bgBlock(fill: colorMatrix)[
+        #subHeading(fill: colorMatrix)[Matrix Normen]
+
+        $|| dot ||_M$ Matrix Norm, $|| dot ||_V$ Vektornorm
+
+        - 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$
+            - submultiplikativ
+            - verträglich mit einer Vektornorm $||dot||_V$
+
+        *maximale Spaltensumme* $||A||_r = max_(1<= i <= n) sum_(j=1)^n |a_(j)|$
+    ]
+
+
+    #colbreak()
+
+    // Vektorräume
+    #bgBlock(fill: colorVR)[
+        #subHeading(fill: colorVR)[Vektorräume (VR)]
+        Bsp: $KK^n$ ($RR^n, CC^n$) \
+        $(V, plus.o, dot.o)$ ist ein über Körper $K (V, +, dot)$ \
+            $(V, +), (V, dot)$ kommutativ Gruppe
+        - Vektor-Addition $+: V times V -> V, (v,w) -> v + w$
+        - Scalar-Multiplikation $dot: K times V -> V, (lambda,v) -> lambda v$
+        Es gilt: $lambda,mu in K, space v,w in V "über" K$ 
+        - Linearität $(lambda mu)v = lambda (mu v)$ \
+            $lambda(v + w) = lambda v + lambda w$\
+            $(lambda + mu)v = lambda v + mu v$
+        - Neutrales Element für $dot.o : 1v = v$
+        - Neutrales Element für $plus.o : arrow(0) in V$
+
+        *Untervektorraum: (UVR)* $U subset V$ \
+        #grid(columns: (1fr, 1fr, 1fr),
+            align(center, $forall v,w : v + w in U$),
+            align(center, $arrow(0) in U$),
+            align(center, $forall v,lambda : lambda v in U$)
+        )
+    ]
+
+    // Spann Erzeugendessystem ect
+    #bgBlock(fill: colorVR)[
+        #subHeading(fill: colorVR)[Spann, Erzeugendensystem, Basis, Dim]
+        $"Sei" V "ein" KK"-VR"\ M = {ve(v_1), ve(v)_2, ve(v)_3, ...}, ve(v_i) in V "Menge von Vektoren"$
+
+        *Spann:* UVR von $V quad quad spann(M) subset V$
+        - UVR $= op("spann")(M) = limits(inter)_(M subset U) U$ \
+                $spann(M)$ ist der Durchschnitt aller Untervektorräume $U subset.eq V$ , die M enthalten:
+        - $op("spann")(M) = $ Alle lin. Kombindation von $ve(v_1), ve(v_2), ... in M$ \
+            $lambda_1 ve(v_1) + lambda_2 ve(v_2) + ... = ve(v) in spann(M)$
+        - Linear Abbildung $Phi : op("spann")(Phi(M)) = Phi(op("spann")(M))$
+
+        *Erzeugendensystem* \
+        Menge $M = {ve(v_1), ve(v)_2, ve(v)_3, ...}$ ist Erzeugendensystem von UVR $U$ wenn $spann(M) = U$
+
+        #SeperatorLine
+
+        *Basis:* #underline("kleinstmögliches") Erzeugendensystem \
+        - Immer linear unabhänige Menge $B$ an $v in V$, sodass $op("spann")(v_1, ..., v_n) = op("spann")(V)$
+        - Jede Basis $B$ ist Erzeugerssystem (ABER NICHT ungekehrt)
+        - Endliche Erzeugerssystem: \
+            $B_1, B_2, ...$ Erzeugerssystem vom gleichen $V$ \
+            $=> abs(B_1)=abs(B_2)...$
+
+        
+        Vektor dratstellung durch Basis Vektoren: \
+        $ve(v) = lambda_1 ve(b_1) + lambda_2 ve(b_2) + ...$
+        - $lambda_1, lambda_2, ...$ beschreiben ein #underline[eindeutig] Punk
+
+        *Basisergänzungssatz:* Sei $M = {ve(v_1), ... ve(v_n)}, ve(v_i) in V$ lin. unabhänig aber $M$ kein Basis des $V$. Dann $exists v_(n+1)$ sodass $M union {ve(v_(n+1))}$ lin unabhänig (aber evt. eine Basis ist)
+
+        #SeperatorLine
+
+        *Linear unabhänige:* \
+        - $v$ ist linear unabhänig wenn \ $spann(M) != spann(M without {ve(v)})$
+        - $M$ besteht nur aus linear unabhänig Vektoren wenn \ 
+            $lambda_0 = 0, ..., lambda_n = 0$ die EINZIEGE Lösung für  \ $lambda_0 ve(v_0) + ... + lambda_1 ve(v_1) = ve(0)$ \
+            $->$ Bei Matrizen: $A ve(v) = ve(0)$ lösen \
+        - Überprüfung by Inspection
+        - Überprüfung: Spalten Vekotren ein Matrix $A : A ve(v) = ve(0)$
+            - $ve(v)$ Nur $ve(0)$ als Lösung $<=>$ Linearunabhänig
+            - $kern(A) = {ve(0)} <=>$ Linerarunabhänig
+
+        #SeperatorLine
+
+        *Dimension:* 
+        - $dim V = \#$Vektoren der Basis (#underline[linear unabhänigs] Erzeugendensystem)
+        - $dim V = infinity$, wenn $V$ nicht endlich erzeugt ist
+        - $dim {ve(0)} = 0$
+
+        $U "UVR von "V => dim U <= dim V$
+        - Kodimension: $dim V - dim U$ 
+        - Wenn $dim U = dim V <=> U = V "(Kodimension"=0")"$
+        - Kodimension $= 1$ Hyperebend
+    ]
+
+    // Darstellungs Matrix
+    #bgBlock(fill: colorVR)[
+        #subHeading([Darstellungs Matrix], fill: colorVR)
+        *Vektorraum Isomorphismus*
+        - $V tilde.equiv W <=> dim(V) = dim(W)$
+        - $V tilde.equiv W <=> exists f: V -> W, f "bijektiv (umkehrbar)"$
+    
+        *Koordinatensystem* Ein bestimmte Wahl von Basisvektoren/Basis $ve(b_1), ve(b_2), ...$
+
+        #SeperatorLine
+        #grid(
+            columns: (auto, 1fr),
+            column-gutter: 2mm,
+            image("../images/linAlg/BasisWechsel.jpg", height: 1.3cm),
+
+            [
+                Vektorraum $V tilde.equiv KK^n$ (in Basis $A$)\
+                Vektorraum $V tilde.equiv KK^n$ (in Basis $B$)\
+
+                $Phi_A, Phi_B$ Bijektiv Mappings zwischen $V$ und dem $KK^n_A slash KK^n_B$
+            ]
+        )
+
+        $space_A T_B$: Basiswechsel: $K^n$ (in Basis $A$) $->$ $K^n$ (in Basis $B$)
+        $space_B T_A$: Basiswechsel: $K^n$ (in Basis $B$) $->$ $K^n$ (in Basis $A$)
+
+        Wenn $V, KK^n "(in Basis A/B)"$ ein $RR^n slash CC^n$ \ ist $Phi_(A slash B) = mat(|, |; ve(b_1), ve(b_2), ...; |, |,)$, $ve(b_1), ve(b_2), ...$ \ Basisvektoren der Basis von $A slash B$
+
+        #SeperatorLine
+        *Darstellungs-Matrix*
+
+        Idee: Wir führen Abbildung $f$ nicht $V -> W$ sonderem in $KK^n -> KK^m$ durch $-->$ Darstellungs-Matrix $D$
+
+        #grid(
+            columns: (auto, 1fr),
+            column-gutter: 2mm,
+            image("../images/linAlg/DarstellungsMatrix.jpg", height: 1.6cm),
+            [
+                $f: V -> W$ Orignal Abbildung \
+                Vektorraum $V tilde.equiv KK^n$ (in Basis $A$)\
+                Vektorraum $W tilde.equiv KK^m$ (in Basis $B$)\
+
+                $Phi_A, Phi_B$ Bijektiv Mappings zwischen $V,W$ und dem $KK^n, KK^m$
+            ],
+        )
+
+        #grid(columns: (1fr, 1fr),
+            $D = Phi_C compose f compose Phi_B$,
+            $$
+        )
+
+        #SeperatorLine
+
+        Normalweiße alle Abbildung/Matrizen in Kannoischer Basis $hat(e)_1 = vec(1, 0, dots.v), hat(e)_2 = vec(0, 1, dots.v), ...$
+    ]
+
+
+    // Rekursive Folgen
+    #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)$
+
+    ]
+
+    #colbreak()
+    #bgBlock(fill: colorAbbildungen)[
+        #subHeading([Abbildungen], fill: colorAbbildungen)
+        
+        $f(x)=y, f: A -> B$
+
+        *Linear Abbildung:* $Phi: M -> N$ 
+        - $Phi(0) = 0 quad quad Phi(lambda v + w) = lambda Phi(v) + Phi(w)$
+        - Menge aller linearen Abbildung: $L(M,N), space "Mengen" M,N$
+        - $spann(Phi(M)) = Phi(spann(M))$
+        - $Phi_1 compose Phi_2 = Phi_1 (Phi_2(x)) = Phi$ wieder linerar
+
+        *Vektorraum-Homomorphismus:* linear Abbildung zwischen VR, 
+        Bsp. jede Matrix
+
+        *Injectiv (Monomorphismus):*\
+        _one to one_ \
+        $f(x) = f(y) <=> x = y$ \
+        Gilt immer: $x = y => f(x) = f(y)$
+
+        Injektiv zweigen: Beweiß durch Wiederspruch. \
+        Angnomen $x != y, f(x) = f(y) -"Umstellen"--> x = y$
+
+        Nicht Injektiv: Gegenbeispiel finden
+        
+
+
+        *Surjectiv (Epimorhismus):* \
+        _Output space coverered_ \
+        - Zeigen das $f(f^(-1)(x)) = x$ für $x in DD$
+        - $forall y in B: exists x in A : f(x) = y$
+        NICHT surjektiv wenn $abs(A) < abs(B)$
+
+        *Bijektiv (Isomorphismus):* \
+        _Injectiv und Surjectiv_ \
+        - $<=>$ Umkehrbar
+        - 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$ \
+        Endomorphismus: $KK^n -> KK^n$ \
+        KEIN Endomorphismus: $KK^n -> KK^m, m != n$ \
+        Bsp. #underline("Qudratische") Matrix
+
+        *Automorphismus:* Endomorphismus und Bijektiv (Isomorphismus) \
+        Bsp. #underline("Invertierbare") Matrix, $f(x) = x$        
+    ]
+
+    // Spann und Bild, Kern
+    #bgBlock(fill: colorAbbildungen)[
+        #subHeading(fill: colorAbbildungen)[Spann und Bild]
+        $f: A -> B$
+
+        *Urbild:* $f^(-1)(I subset B) subset.eq A$
+
+        *Bild:* Wertemenge $WW$ 
+        - $f(I subset A) = B$ (Oft $I = A$)
+        - Bei Matrix: $Bild(M) = spann("Spalten Vektoren")$
+        - $op("Bild") Phi := {Phi in W | v in V}$
+
+        *Rang:*
+        $op("Rang") f := dim op("Bild") f$
+        - Bei Matrizen: \ $Rang(f) <= min(n, m) equiv min("#Spalten", "#Zeilen")$ 
+        - $Rang("Zeilen Vektoren") = Rang("Spalten Rang")$ 
+        - $Rang(A) = Rang(A^T)$
+        - $"#Linear unabhäniger Spalten/Zeilen"$
+
+        *Nullraum/Kern:* \
+        $kern(Phi) := {v in V | Phi(v) = 0}$
+        - $A ve(x) = ve(0)$ (Lösung des Homogenen Gleichungssystem)
+
+        *Dimensionssatz:* lineare Abbildung $A: V -> W$ \
+        $dim(V) = dim(kern(A)) + dim(Bild(A))$ \
+        $dim(V) = dim(kern(A)) + Rang(A)$
+
+        #linebreak()
+        
+        $"Wenn" dim(V) = dim(Bild(A)) "oder" dim(kern(A)) = 0 \ <=> A "bijektiv" <=> "invertierbar"$
+
+        #SeperatorLine
+
+        - Homogense Lineares Gleichungsystem: $A ve(x) = ve(0) $ Lösungsmenge: $LL = kern(A)$, immer: $ve(0) in L$ \
+
+        - In-Homogense LGS: $A ve(x) = ve(b) $<<
+        
+        #SeperatorLine
+
+        *Gaußalgorithmus*
+
+        #grid(columns: (auto, 1fr),
+            row-gutter: 1mm,
+            column-gutter: 2mm,
+    
+            image("../images/linAlg/Gauss1a.jpg", width: 2cm),
+            [
+                Gleichungssystem: $A ve(x) = b$ \
+                $A in KK^(m times n)$
+                In Zeilenstufenform Bringen, Operationen:
+                - Zeile $dot lambda$ ($x in CC$ mit $dot i$)
+                - Zeile vertauschen
+                - Zeile $+$ Zeile
+            ],
+        )
+
+        #grid(columns: (auto, 1fr),
+            row-gutter: 3mm,
+            column-gutter: 2mm,
+            image("../images/linAlg/Gauss2.jpg", width: 2cm),
+            [
+                *Eindeutige Lösung* $-->$ Normale Rückeinsetzung
+
+                Nur bei $A in RR^(n times n)$ möglich
+
+                Bei qudratischen $A:$ \ $n equiv "#Spalten" equiv dim ve(x)$
+            ],
+
+            image("../images/linAlg/Gauss1.jpg", width: 2cm),
+            [
+                *Nullzeile*:
+                Pro Nullzeile eine frei Var $t, s, ...$
+            ],
+
+            image("../images/linAlg/Gauss3.jpg", width: 2cm),
+            [
+                *Wiederspruch*: Keine Lösung
+            ]
+        )
+
+        $Rang(A) = "#Nicht-Null-Zeilen"$ \
+        $=$ Anzahl der linear unabhänigen Zeilen/Spalten
+        
+        $kern(A) = dim ve(x) - Rang(A)$ (Dimensionssatz)
+
+        #SeperatorLine
+        *Matrix Invertieren*
+        #image("../images/linAlg/InverseMatrix.jpg")
+
+        $KK^(2 times 2): A = mat(a, b; c, d) \ A^(-1) = 1/det(A) mat(d, -b; -c, a) = 1/(a d - b c) mat(d, -b; -c, a) $
+    ]
+    
+        // Matrix Basics
+    #bgBlock(fill: colorMatrix)[
+        #subHeading(fill: colorMatrix)[Matrix Basics]
+        Linera Abbildung $equiv$ EINER eindeutige Matrix  \
+
+        - Sclar/Matrix: $lambda dot A$
+        - Matrix/Matrix: $A + B$
+        - Matrix-Matrix: $A dot B = Phi_A compose Phi_B = Phi_A (Phi_B (ve(x)))$ \
+        $c_(j i) = sum^n_(s=1) a_(j s) b_(s i)$
+
+        $(KK^(n times n), +)$ sind Gruppe, $(KK^(n times n), dot)$ sind Monoid, 
+
+        #image("../images/linAlg/matMul.jpg")
+
+        #SeperatorLine
+
+        #grid(columns: (1fr, 1fr, 1fr),
+            row-gutter: 2mm,
+            align(center, $(lambda mu) A = lambda (mu A)$), 
+            grid.cell(colspan: 2, align(center, $(lambda + mu) A = lambda A + mu A$)),
+            align(center, $$), 
+            grid.cell(colspan: 2, align(center, $lambda (A + B) = lambda A + lambda B$)),
+        )
+
+        *Transponieren*
+
+        #grid(columns: (1fr, 1fr),
+            row-gutter: 2mm,
+            $(A + B)^T = A^T + B^T$,
+            $(lambda A)^T = lambda A^T$,
+            $(A^T)^T = A$,
+            $(A dot B)^T = B^T dot A^T$
+        )
+    ]  
+
+]
+
+#columns(5, gutter: 2mm)[
+    #bgBlock(fill: colorAbbildungen)[
+        #subHeading(fill: colorAbbildungen)[Linearform]
+
+        - Sclar-Produkt $ip(ve(a), ve(b))$ ist Bi-Linearform
+            - Symetrisch
+        - Determinante einer Matrix: $det(A in RR^(m times n))$ ist $n$-Linearform (sogar alternierend)
+
+        *$k$-Linearform:* Lineare $f: KK^n times KK^n times ... -> KK$
+        - Für $k=2 : $ Bi-Linerform
+        - Linearität: (in beiden Argumente)  \
+            $f(ve(v)_1, lambda ve(v)_2) = lambda f(ve(v)_1, ve(v)_2) \
+                f(ve(v)_1,  ve(x) + ve(y)) = f(ve(v)_1,  ve(x)) + f(ve(v)_1, ve(y))
+            $ 
+        - *Symetrisch* wenn: $f(ve(v)_1, ve(v)_2) = f(ve(v)_2, ve(v)_1), space space forall ve(v)_1, ve(v)_2 in KK^n$
+
+        - *Alternierend* wenn: $f(ve(v), ve(v)) = 0, space space forall ve(v) in KK^n$
+            - $f(ve(v)_1, ... #text(red, $ve(v)_i$),   #text(blue, $ve(v)_j$), ... ve(v)_k) = -f(ve(v)_1, ... #text(blue, $ve(v)_j$), #text(red, $ve(v)_i$), ... ve(v)_k) $
+            - Tauschung von  Argumenten $->$ Vorzeichen Flip
+            - $ve(v)_1,  ... "linear abhänig" <=> f(ve(v)_1, ...) = 0$
+            - $ve(v)_1, ... "linear unabhänig" <=> f(ve(v)_1, ...) != 0$, eindeutig
+    ]
+
+    #bgBlock(fill: colorAbbildungen)[
+        #subHeading(fill: colorAbbildungen)[Determinante] 
+
+        *Determinaten Form* \
+        Nicht tiviale ($f(...) = 0$) alternierende n-Linearform auf einem VR.
+        $exists$ Immer, in jeder Scalierung
+
+        Speziell für Martizen $in KK^(n times n)$ \ (Qudratische, Endomorphismus)
+
+        *Herleitung:*
+        Für die $det equiv delta$: $delta(ve(e)_1, ve(e)_2, ve(e)_3, ...) = 1$,  alternierend und n-Linearform 
+
+        1. Mit Linearität zerlegen
+        2. Mit Alterniered, Element tauschen: $delta(ve(e)_1, ve(e)_2, ve(e)_3, ...) dot ...$
+
+        *Leibniz-Formel*
+
+        $det(A) = limits(sum)_(sigma in S_n) sign(sigma)( a_(sigma(1)1) dot a_(sigma(2)2) dot dots dot a_(sigma(n)n))$
+
+        $S_n := "Alle Permutation von n Element" $ \
+        $sign(sigma) = (-1)^"#Vertauschungen"$ \
+        Anzahl der Vertauschungen, die nötig sind um $sigma$ von $(1, 2, 3, ...)$ zu erzeugen \
+        $sigma(n): n$-te Element aus der Tupel $sigma$
+        
+        *Bsp:* $A in KK^(n times n)$
+        #grid(
+            columns: 9,
+            row-gutter: 1mm,
+            $S_3 =$, ${$, $(1,2,3),$, $(1,3,2),$, $(2,1,3),$, $(2,3,1),$, $(3,1,2),$, $(3,2,1)$, $}$,
+            "#Vert.", $$, 
+            align(center, $0$),
+            align(center, $1$),
+            align(center, $1$),
+            align(center, $2$),
+            align(center, $2$),
+            align(center, $1$), $$,
+            $sign(sigma)$, $$, 
+            align(center, $1$),
+            align(center, $-1$),
+            align(center, $-1$),
+            align(center, $1$),
+            align(center, $1$),
+            align(center, $-1$),
+        )
+
+        $det(A) = &(a_11 a_22 a_33) - (a_11 a_23 a_32) - (a_12 a_21 a_33) + \ 
+        &(a_12 a_23 a_31) + (a_13 a_21 a_32) - (a_13 a_22 a_31) + \
+        $
+
+        #SeperatorLine
+
+        *Regel von Saurus*
+        #grid(
+            columns: (auto, 1fr),
+            image("../images/linAlg/saurus.png", height: 0.6cm),
+            align(center+horizon, $= a_11 a_22 a_33 + a_12 a_23 a_31 + a_13 a_21 a_32 \ 
+            - a_13 a_22 a_31 - a_12 a_21 a_33 - a_11 a_23 a_32
+            $)
+        )
+
+        *Laplace Entwicklung*
+
+        #grid(
+            columns: (auto, 1fr),
+            column-gutter: 2mm,
+            image("../images/linAlg/laplace.jpg", height: 1.6cm),
+            [
+                - Nach Spalte oder Zeile Entwicklung
+                - #underline([Auf Vorzeichen Achten!!!])
+                - Zeilen mit vielen Nuller wählen
+            ]
+        )
+
+        *Determinate Tricke-Kiste*
+
+        - Orthogonal-Matrix: $det(A) = 1$
+        - Diagonal-/Oberdreiecks-/Unterdreick-Matrix: \ $det(A) = product a_(i i)$
+        - $det(A) = product lambda_(i i) "(Eigenwerte)"$
+
+        - Partionen: $mat(A, B; 0, C) slash mat(A, 0; B, C) -> det(A) = det(A) dot det(C)$
+
+        #grid(
+            columns: (1fr, 1fr),
+            column-gutter: 2mm,
+            row-gutter: 2mm,
+            $A,B in KK^(n times n) :$, $$,
+            $det(A dot B) = det A dot det B$,
+            $det(A^(-1)) = 1/det(A)$,
+            $det(A) = det(A^T)$,
+            $det(lambda A) = lambda^n det(A)$,
+            $det mat(a, b; c, d) = a d - b c$,
+        )
+
+        Elementare (Gauß) Zeilen Umfohrungen kann man machen
+
+        NICHT Qudratischen Matrizen $det(D)$ nicht definiert, Nur für Endomorphisen
+
+        $det(A) = 0 <=> "invertierbar" <=> "bijektiv"$
+
+
+    ]
+
+    #bgBlock(fill: colorVR)[
+        #subHeading(fill: colorVR)[Eukldische VRs]
+    
+        - *Skalarprodukt:* Positiv definite symetrisch Bilinearform
+            - $equiv$ Skalarprodukt $ip(dot, dot)$ in $RR$
+            - $f(ve(v)_1, ve(v)_2) = f(ve(v)_2, ve(v)_1), space space forall ve(v)_1, ve(v)_2 in KK^n$
+        - Linear in beiden Argument: \
+            $ip(lambda ve(x), ve(y)) = lambda ip(ve(x), ve(y))$\
+            $ip(ve(x) + ve(a), ve(y)) = ip(ve(x), ve(y)) + ip(ve(a), ve(y))$
+        - $f(ve(v), ve(v)) > 0, v in V without {ve(0)}$
+
+        *Kannonische Scalar Produkt*  $ip(ve(x), ve(y)) := limits(sum)_(i=1)^n x_i y_i$
+        - Positiv definit: $ip(ve(x), ve(x)) > 0$
+
+        #SeperatorLine
+
+        #grid(
+            columns: (auto, auto),
+            column-gutter: 3mm,
+            [*Norm*],
+            [
+            - $norm(ve(v)) = 0 <=> ve(v) = ve(0)$
+            - $norm(lambda ve(v)) = abs(lambda) norm(ve(v))$
+            - Dreieckesungleichung: $norm(x + y) <= norm(x) + norm(y)$
+            ]
+        )
+
+
+        *Generisch/$L_p$-Norm*: $|| v ||_p = root(p, sum_(k=1)^n (x_k)^p)$
+
+        *Induzierte Norm:* $norm(ve(v)) = sqrt(ip(ve(v), ve(v)))$ (Bliebiges $ip(dot, dot)$)
+
+        *Eukldische Norm:*
+        - $L_2$-Norm/kannoische Norm: $norm(ve(v)) = sqrt(ip(ve(v), ve(v)))$
+
+        *Cauchy-Schwarz-Ungleichung:* $abs(ip(v, w)) <= norm(v) norm(w)$
+        - Gilt in Eukldische Vektoraum
+        - Gilt nur mit aus Eukldischer Norm
+
+        *Euklidsche Vektorraum:* $ = (RR^n"-VR", ip(dot, dot))$, (Irgendeine Skalarprodukt
+        - Eigenschaften:
+            - Polarisation: $ip(v, w) = 1/4 (norm(v + w)^2 - norm(v -w )^2)$
+            - Parallelogrammgleichung: \
+            $2 (norm(v)^2 + norm(w)^2) = norm(v + w)^2 + norm(v - w)^2$
+        - Winkel: $cos alpha = ip(v, w)/(norm(v) norm(w))$
+        
+        *Orthogonal Vektoren:* $ip(v, w) = 0$ \
+        *Ortho#text(red)[normal] Vektoren:* \
+        $ip(v, w) = 0 "UND" norm(v),norm(w) = 1, p(v, v) = ip(w, w) = 1$
+
+        #SeperatorLine
+        *Orthogonal Projektion* $pi_U(v) = limits(sum)_(i=1)^k ip(v, u_i) u_i$
+
+        $U subset V$ Untervektorraum eines Eukldische VRs $V$, \ $U$ in orthogo#text(red)[normal] Basis
+
+        Orthogonals Kompliment: $kern(pi_U) = U^tack.t$
+
+    ]
+
+    #bgBlock(fill: colorVR)[
+        #subHeading(fill: colorVR)[Unitäre Vektorräume]
+        alles $in CC$
+
+
+        *Sequilinearform:* $ip(x, y)$
+        - $ip(x, y)$ linear im #underline("1.") Argument
+        - $ip(v, w_1 + w_2) = ip(v, w_1) + ip(v, w_2) = \
+            ip(v, lambda w) = overline(lambda) ip(v, w)$
+
+        *Hermitische Form:* $ip(v, w) = ip(w, v)$
+
+        *Hermitische Skalarprodukt:* $in RR$
+    ]
+
+
+    #colbreak()
+    
+    // Eigenwert und Eigenvektoren
+    #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)$
+
+    ]
+
+    // Gram-Schmit ONB
+    #bgBlock(fill: colorMatrixVerfahren)[
+        #subHeading(fill: colorMatrixVerfahren)[Gram-Schmit]
+
+        Idee: $ip("Orth"#text(red)[normal] ve(v), ve(x)) = "Anteil von" ve(x) "an" ve(v)$ \
+        Ziel: Basis $W -->$ Orthogonal Basis $V$
+
+        1. $v_1 = 1/norm(w_1)$
+        2. $hat(v)_(j+1) = w_(j+1) -ip(w_(j+1), v_1)v_1 - ip(w_(j+2), v_2)v_2 ... $
+
+        3. $v_(j+1) = hat(v)_(j+1)/norm(hat(v)_(j+1))$
+        4. Repeat for $w_1, w_2, w_3, ...$
+
+
+    ]
+
+    // Diagonalisierung
+    #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]
+        Wenn dsa charakteristische Polynom $chi_A "von" A in CC^(n times n) slash RR^(n times n) "in" chi_A(lambda) = (lambda_1 - lambda)(lambda_2 - lambda)... "zerfällt"$ dann ist Schur-Zerlegung möglich 
+        - Gilt für $CC^(n times n)$ immer
+
+        #grid(
+            columns: (1fr, 3fr),
+            $R = B^* A B$,
+            [
+                $B:$ orthogonal/unitair $KK^(n times n)$ \
+                $R:$ Oberedreiecks Matrix $KK^(n times n)$ \
+                $B^* = B^T "für" RR, B^* = B^(-T) "für" CC$
+            ]
+        )
+
+        - $A,R$ haben die selben Eigenwerte
+        - Schur-Zerlegung ist nicht eindeutig, (Diagnoal elemen bis auf die Reihnfolge schon)
+        - Wenn $A$ diagonaliserbar $=>$ $R$ Dignoalmatrix
+    ]
+
+    #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$ (dabei EWs, EVs berechen)
+
+        3. Singulärwerte 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)$
+    ]
+    
+    
+    #sinTable
+
+    // Lineare Differenzialgleichungen
+    #bgBlock(fill: colorMatrix)[
+        #subHeading(fill: colorMatrix)[Lineare Differenzialgleichungen]
+
+        $y'_1(t) &= alpha_11 &dot y_1(t) + alpha_12 dot y_2(t) + ...\
+        y'_1(t) &= alpha_11 &dot y_1(t) + alpha_12 dot y_2(t) + ... \
+        &dots.v &dots.v\
+        y'_1(t) &= alpha_11 &dot y_1(t) + alpha_12 dot y_2(t) + ...
+        $
+    ]
+
+    #colbreak()
+
+    // Table
+    #table(
+        columns: (auto, 1fr),
+        inset: 2mm,
+        fill: (x, y) => if (calc.rem(y, 2) == 0) { tableFillLow } else { tableFillHigh },
+        [*Einheits Matrix*\ $I,E$], [
+            $det(E) = 1$
+        ],
+        [*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
+            - $A x = b$ eindeutig
+            - $A x = 0$ nur $ve(0)$
+            - Spalten/Zeilen Vekoren lin. unabhänig
+            - $Rang(A) = n, A in KK^(n times n)$ \
+            - $det(A) != 0$
+            - $0$ ist keine Eigenwert
+
+            *Nicht Invertierbar wenn:*\
+            $exists$ EW $!= 0 => not "invertierbar"$
+            Keine Qudratische Matrix
+        ],
+        [*Orthogonal*], [
+            - Immer Bijektiv
+            - $det (A) = plus.minus 1$
+            - $O^T = O^(-1)$
+            - $O^T O = O O^T = I$
+            - $ip(O v, O w) = ip(v, w)$
+        ],
+        [*Unitair* \ $equiv$ Orthogonal $in CC$], [
+            - Immer Bijektiv
+            $V = 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) "UND" alg(lambda) = geo(lambda)$
+        ],
+        [*postiv-semi-definit*], [
+            $forall$ EW $>= 0$
+        ],
+    )
+]

src/cheatsheets/test.typ

@@ -0,0 +1,25 @@
+#set page(
+  paper: "a3", 
+  margin: (
+    bottom: 10mm,
+    top: 5mm,
+    left: 5mm,
+    right: 5mm
+  ),
+  flipped:true,
+)
+
+#import "../lib/styles.typ" : *
+#import "../lib/common_rewrite.typ" : *
+#import "../lib/mathExpressions.typ" : *
+
+
+#columns(5)[
+  #bgBlock(fill: gray)[
+    #block(height: 100%)
+    #block(height: 100%)
+    #block(height: 100%)
+    #block(height: 100%)
+    #block(height: 100%)
+  ]
+]