#import "@preview/touying:0.6.1": *
#import "./template/conf.typ": *

#show: tum-slides.with(
  aspect-ratio: "16-9", 
  language: "de",
  config-info(
    title: [Parameteroptimierung für Multi-Bit HO Alphabet PUF Quantisierung],
    // Author to be shown in the title slide
    author: [Marius Drechsler],
    // Author to be shown in the footer
    footer-author: [M. Drechsler],
    date: [26. Juni 2025],
  ),
)

= Ausgangslage

== 1-Bit Quantisierung

#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

1. Teile Verteilung am Erwartungswert auf 
2. Addiere weitere Weights ($0.25, 0.125, ...$)
3. Maximiere Abstand zur nächstgelegenen Grenze
4. Teile neue Verteilungen wieder am Erwartungswert auf

== Rekursiver Ansatz
#align(horizon)[
#include("./graphics/execution/recursive.typ")
]

== Rekursiver Ansatz --- Resultierende Verteilung

#align(horizon)[
#figure(
  image("./graphics/recursive_distribution.svg", width: 60%)
)]

== Rekursiver Ansatz --- Helperdaten

#align(horizon)[
  #figure(
    image("./graphics/recursive_helperdata_dist.svg", width: 60%)
  )
]

== Vorgabe des Codeworts

- Generierung eines zufälligen Schlüssels 
- Nutze Quantile der Normalverteilung als vorgegebene Grenzen 
- Wähle jeweilige Linearkombination, die am besten das Quantil des Vorgegebenen Bits annähert

== Vorgabe des Codeworts --- Verteilung

#figure(
  image("./graphics/given_codeword_dist.svg")
)

== Brute-Force Ansatz

- Großer Datensatz mit Grenzen 
- Führe Optimierung und Quantisierung mit jedem Satz Grenzen durch
- Pearson's Chi-Square Test der Quantisierten Symbole auf Gleichverteilung 
- Maximales Resultat des Chi-Square Tests gibt optimale Grenzen zurück

== Brute-Force Ansatz --- Verteilung

#figure(
  image("./graphics/bruteforce_dist.svg")
)

== Brute-Force Ansatz --- Helperdaten 

#figure(
  image("./graphics/bruteforce_helperdata1.svg")
)

= Fazit

- Rekursiver Ansatz generiert gleichverteilte Ausgansverteilungen 
  - Helperdaten geben Informationen über das Codewort bekannt 
- Vorgabe des Codeworts als Bedingung nicht stark genug 
- Brute-Force Ansatz findet Gleichverteilungen
  - Helperdaten geben keine Informationen bekannt 
  - Verbesserung der Bitfehlerrate um einen Faktor $10$
  - Vorberechnete Grenzen können auf beliebige Normalverteilungen angewendet werden
