More work on presentation

graphics/background/sign-based-overlay.typ

@@ -0,0 +1,34 @@
+#import "@preview/cetz:0.3.4": canvas
+#import "@preview/cetz-plot:0.1.1": plot, chart
+
+#let ymax = 1/calc.sqrt(2*calc.pi)
+
+#let line_style = (stroke: (paint: black, thickness: 3pt))
+#let dashed = (stroke: (dash: "dashed"))
+#canvas({
+
+  plot.plot(size: (11,6),
+    legend: "north",
+    legend-style: (orientation: ltr, item: (spacing: 0.5)),
+    x-tick-step: none,
+    x-ticks: ((0, [0]), (100, [0])),
+    y-label: $cal(Q)(1, x)$,
+    x-label: $x$,
+    y-tick-step: none,
+    y-ticks: ((0, [0]), (ymax, [1])),
+    axis-style: "left",
+    x-min: -3,
+    x-max: 3,
+    y-min: 0,
+    y-max: ymax,{
+    plot.add(
+      plot.sample-fn(
+        (x) => 1/calc.sqrt(2*calc.pi)*calc.exp(-(calc.pow(x,2)/2)),
+        (-3, 3),
+        300),
+      style: (stroke: (paint: red, thickness: 3pt)),
+ //     label: [PDF einer Normalverteilung]
+    )
+    plot.add(((-3,0), (0,0), (0,ymax), (3,ymax)), style: line_style, /*label: [$cal(Q)(1,x)$]*/)
+  })
+})

graphics/background/two-bit-enroll.typ

@@ -0,0 +1,26 @@
+#import "@preview/cetz:0.3.4": canvas, draw, palette
+#import "@preview/cetz-plot:0.1.1": plot, chart
+
+#let line_style = (stroke: (paint: black, thickness: 3pt))
+#let dashed = (stroke: (dash: "dashed"))
+#canvas({
+  import draw: *
+  set-style(axes: (shared-zero: false))
+  plot.plot(size: (8,6),
+    x-tick-step: none,
+    x-ticks: ((0.25, [$g_1$]), (0.5, [0]), (0.75, [$g_2$])),
+    y-label: $cal(Q)(2, 1, tilde(x))$,
+    x-label: $tilde(x)$,
+    y-tick-step: none,
+    y-ticks: ((0.25, [00]), (0.5, [01]), (0.75, [10]), (1, [11])),
+    axis-style: "left",
+    //x-min: 0,
+    x-max: 1,
+    y-min: 0,
+    y-max: 1,{
+    plot.add(((0,0.25), (0.25,0.25), (0.5,0.5), (0.75,0.75), (1, 1)), line: "vh", style: line_style)
+    //plot.add(((0,0), (0,0)), style: (stroke: none))
+    plot.add-hline(0.25, 0.5, 0.75, 1, style: dashed)
+    plot.add-vline(0.25, 0.5, 0.75, 1, style: dashed)
+  })
+})

graphics/background/z_distribution.typ

@@ -0,0 +1,27 @@
+#import "@preview/cetz:0.3.4": canvas
+#import "@preview/cetz-plot:0.1.1": plot, chart
+
+#let data = csv("./z_distribution.csv")
+#let data = data.map(value => value.map(v => float(v)))
+
+#let line_style = (stroke: (paint: black, thickness: 3pt))
+#let dashed = (stroke: (dash: "dashed"))
+#canvas({
+  plot.plot(size: (11,5),
+    legend : "south",
+    legend-style: (orientation: ltr, item: (spacing: 0.5)),
+    x-tick-step: none,
+    x-ticks: ((0, [0]), (100, [0])),
+    y-label: $cal(Q)(1, z), abs(f_"Z" (z))$,
+    x-label: $z$,
+    y-tick-step: none,
+    y-ticks: ((0, [0]), (0.6, [1])),
+    axis-style: "left",
+    x-min: -5,
+    x-max: 5,
+    y-min: 0,
+    y-max: 0.6,{
+    plot.add((data), style: (stroke: (paint: red, thickness: 3pt)), /*label: [Optimierte PDF]*/)
+    plot.add(((-5, 0), (0, 0), (0, 0.6), (5, 0.6)), style: line_style, /*label: [Quantisierer]*/)
+  })
+})

graphics/execution/recursive.typ

@@ -0,0 +1,56 @@
+#import "@preview/fletcher:0.5.8" as fletcher: diagram, node, edge 
+#import fletcher.shapes: pill
+
+#diagram(
+  spacing: (-3mm, 8mm), // wide columns, narrow rows
+  node-stroke: 1pt, // outline node shapes
+  edge-stroke: 1pt, // make lines thicker
+  mark-scale: 60%, // make arrowheads smaller
+  node((0,0), [Start], name: <start>),
+  node((-4, 1), [u1], name: <u1>),
+  node((4, 1), [u2], name: <u2>),
+
+  node((-6, 2), [u11], name: <u11>),
+  node((-2, 2), [u12], name: <u12>),
+  node((2, 2), [u21], name: <u21>),
+  node((6, 2), [u22], name: <u22>),
+
+  node((-7, 3), [u111], name: <u111>),
+  node((-5, 3), [u112], name: <u112>),
+  node((-3, 3), [u121], name: <u121>),
+  node((-1, 3), [u122], name: <u122>),
+  node((1, 3), [u211], name: <u211>),
+  node((3, 3), [u212], name: <u212>),
+  node((5, 3), [u221], name: <u221>),
+  node((7, 3), [u222], name: <u222>),
+
+  node((-20mm, 33mm), [n1], shape: pill, name: <n1>),
+  node((-20mm, 18.5mm), [n2], shape: pill, name: <n2>),
+  node((-20mm, 4mm), [n3], shape: pill, name: <n3>),
+
+  edge(<n1>, <iter1>, "->"),
+  edge(<n2>, <iter2>, "->"),
+  edge(<n3>, <iter3>, "->"),
+
+  edge(<start>, <u1.north>, "->"),
+  edge(<start>, <u2.north>, "->"),
+
+  edge(<u1>, <u11.north>, "->"),
+  edge(<u1>, <u12.north>, "->"),
+  edge(<u2>, <u21.north>, "->"),
+  edge(<u2>, <u22.north>, "->"),
+
+  edge(<u11>, <u111.north>, "->"),
+  edge(<u11>, <u112.north>, "->"),
+  edge(<u12>, <u121.north>, "->"),
+  edge(<u12>, <u122.north>, "->"),
+  edge(<u21>, <u211.north>, "->"),
+  edge(<u21>, <u212.north>, "->"),
+  edge(<u22>, <u221.north>, "->"),
+  edge(<u22>, <u222.north>, "->"),
+
+  node(enclose: (<u1>, <u2>), stroke: aqua, fill: aqua.lighten(90%), name: <iter1>),
+  node(enclose: (<u11>, <u22>), stroke: teal, fill: teal.lighten(90%), name: <iter2>),
+  node(enclose: (<u111>, <u222>), stroke: eastern, fill: eastern.lighten(90%), name: <iter3>)
+
+)

main.typ

@@ -14,12 +14,104 @@
   ),
 )
 
-= Einführung 
+= Ausgangslage
 
-== Ausgangslage 
+== 1-Bit Quantisierung
 
-== Planung 
+#figure(
+  include("./graphics/background/sign-based-overlay.typ"),
+ // caption: []
+)
+
+- Stufe des Quantisiererfunktion nahe des Erwartungswertes der Wahrscheinlichkeitsverteilung
+
+== Optimierung der 1-Bit Quantisierung 
+
+- Eingangswerte als Gewichtete Summen 
+
+#v(1em)
+
+$ f(bold(x), bold(h)) = h_1 x_1 + h_2 x_2 + h_3 x_3 $
+
+- $h_i$ als Helperdaten 
+
+#v(1em)
+
+- Betragsmäßige Maximierung von $f(bold(x), bold(h))$ für möglichst wenige Werte nahe der $0$
+
+#v(1em) 
+
+$ max_(h_1, h_2, h_3) |f(bold(x), bold(h))|  $
+
+== Optimierung der 1-Bit Quantisierung (2)
+
+#align(horizon)[
+#figure(
+  include("./graphics/background/z_distribution.typ"),
+  caption: [Optimierte Sign-Based Quantisierung]
+)]
+
+== Verallgemeinerung auf n-Bit
+
+- Definition der Quantisierung höherer Ordnung als mehrstufige Funktion
+
+#v(1em)
+
+#figure(
+  include("./graphics/background/two-bit-enroll.typ")
+)
+
+- Problem: Optimale Position der Quantisierergrenzen $g_1$ und $g_2$
+
+== Verallgemeinerung auf n-Bit --- Optimierungsbedingung
+
+- Zwei Möglichkeiten zur optimalen Positionierung der Linearkombinationen: 
+  1. Beste Approximation zur Mitte einer Quantisiererstufe 
+  2. Maximierung des Abstandes zur nächstgelegenen Grenze der Linearkombination
+
+== Verallgemeinerung auf n-Bit --- Algorithmus
+
+1. Naives Raten der Grenzen $g_(1,2)$ und erste Optimierung
+2. Über eCDF der resultierenden Verteilung neue Grenzen definieren, sodass jedes Symbol gleich wahrscheinlich ist
+
+
+
+== Verallgemeinerung auf n-Bit --- Probleme 
+
+- Approximation zur Mitte konvergiert, allerdings keine Verbesserung der Fehlerrate
+- Maximierung des Abstandes konvergiert nicht
+
+#figure(
+grid(
+  columns: (1fr, 1fr),
+  rows: (2),
+  [//#figure(
+  #image("./graphics/background/bach/instability/frame_1.png", width: 80%)
+  #v(-0.5em)
+  //)
+  Iteration 1],
+  [//#figure(
+  #image("./graphics/background/bach/instability/frame_18.png", width: 80%)
+  #v(-0.5em)
+  //)
+  Iteration 18],
+),
+)
+
+= Implementierung
+
+== Mögliche Lösungen
+
+- Rekursiver Ansatz 
+
+- Vorgabe des Codeworts 
+
+- Brute-Force Ansatz 
+
+== Rekursiver Ansatz 
+
+== Vorgabe des Codeworts 
+
+== Brute-Force Ansatz
 
 = Ergebnisse
-
-== Hier dann