Write IP Bericht

.gitignore

@@ -0,0 +1,4 @@
+result*
+.direnv/
+.envrc
+*.pdf

.typst-lsp

@@ -0,0 +1 @@
+main-file= "main.typ"

bibliography.bib

@@ -0,0 +1,185 @@
+@inproceedings{tmhd1,
+  title={Two-metric helper data for highly robust and secure delay PUFs},
+  author={Danger, Jean-Luc and Guilley, Sylvain and Schaub, Alexander},
+  booktitle={2019 IEEE 8th International Workshop on Advances in Sensors and Interfaces (IWASI)},
+  pages={184--188},
+  year={2019},
+  organization={IEEE}
+}
+
+@inproceedings{tmhd2,
+  title={Analysis and protection of the two-metric helper data scheme},
+  author={Tebelmann, Lars and K{\"u}hne, Ulrich and Danger, Jean-Luc and Pehl, Michael},
+  booktitle={International Workshop on Constructive Side-Channel Analysis and Secure Design},
+  pages={279--302},
+  year={2021},
+  organization={Springer}
+}
+
+@article{smhd,
+  title={Helper Data Schemes for Coded Modulation and Shaping in Physical Unclonable Functions},
+  author={Fischer, Robert FH},
+  journal={arXiv preprint arXiv:2402.18980},
+  year={2024}
+}
+
+@book{dekking2005modern,
+  title={A Modern Introduction to Probability and Statistics: Understanding why and how},
+  author={Dekking, Frederik Michel},
+  year={2005},
+  publisher={Springer Science \& Business Media}
+}
+
+@inproceedings{dataset,
+  title={Large scale RO PUF analysis over slice type, evaluation time and temperature on 28nm Xilinx FPGAs},
+  author={Hesselbarth, Robert and Wilde, Florian and Gu, Chongyan and Hanley, Neil},
+  booktitle={2018 IEEE International Symposium on Hardware Oriented Security and Trust (HOST)},
+  pages={126--133},
+  year={2018},
+  organization={IEEE}
+}
+
+@book{schmutz,
+  title={Introduction to mathematical statistics},
+  author={Hogg, Robert V and McKean, Joseph W and Craig, Allen T and others},
+  year={2013},
+  publisher={Pearson Education India}
+}
+
+@inproceedings{PUFIntro,
+  title={Introduction to physically unclonable fuctions: Properties and applications},
+  author={Garcia-Bosque, Miguel and D{\'\i}ez-Se{\~n}orans, Guillermo and S{\'a}nchez-Azqueta, Carlos and Celma, Santiago},
+  booktitle={2020 European Conference on Circuit Theory and Design (ECCTD)},
+  pages={1--4},
+  year={2020},
+  organization={IEEE}
+}
+
+@article{PUFChartRef,
+  title={Variable-length bit mapping and error-correcting codes for higher-order alphabet pufs—extended version},
+  author={Immler, Vincent and Hiller, Matthias and Liu, Qinzhi and Lenz, Andreas and Wachter-Zeh, Antonia},
+  journal={Journal of Hardware and Systems Security},
+  volume={3},
+  pages={78--93},
+  year={2019},
+  publisher={Springer}
+}
+
+
+@article{PUFIntro2,
+  title={Physically Unclonable Functions: Constructions, Properties and Applications (Fysisch onkloonbare functies: constructies, eigenschappen en toepassingen)},
+  author={Maes, Roel},
+  year={2012}
+}
+
+@inproceedings{fuzzycommitmentpaper,
+  title={Achieving secure fuzzy commitment scheme for optical pufs},
+  author={Ignatenko, Tanya and Willems, Frans},
+  booktitle={2009 Fifth International Conference on Intelligent Information Hiding and Multimedia Signal Processing},
+  pages={1185--1188},
+  year={2009},
+  organization={IEEE}
+}
+
+@article{ruchti2021decoder,
+  title={When the Decoder Has to Look Twice: Glitching a PUF Error Correction},
+  author={Ruchti, Jonas and Gruber, Michael and Pehl, Michael},
+  journal={Cryptology ePrint Archive},
+  year={2021}
+}
+
+@article{delvaux2014helper,
+  title={Helper data algorithms for PUF-based key generation: Overview and analysis},
+  author={Delvaux, Jeroen and Gu, Dawu and Schellekens, Dries and Verbauwhede, Ingrid},
+  journal={IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems},
+  volume={34},
+  number={6},
+  pages={889--902},
+  year={2014},
+  publisher={IEEE}
+}
+
+@inproceedings{maes2009soft,
+  title={A soft decision helper data algorithm for SRAM PUFs},
+  author={Maes, Roel and Tuyls, Pim and Verbauwhede, Ingrid},
+  booktitle={2009 IEEE international symposium on information theory},
+  pages={2101--2105},
+  year={2009},
+  organization={IEEE}
+}
+
+
+@inproceedings{bezdek_notes_2002,
+	address = {Berlin, Heidelberg},
+	title = {Some {Notes} on {Alternating} {Optimization}},
+	isbn = {978-3-540-45631-5},
+	doi = {10.1007/3-540-45631-7_39},
+	abstract = {Let f : ℜs ↦ ℜ be a real-valued scalar field, and let x = (x1,…, xs)T ∈ ℜs be partitioned into t subsets of non-overlapping variables as x = (X1,…,Xt )T, with Xi ∈ ℜp1, for i = 1,…, t, ∈ti=1pi = s Alternating optimization (AO) is an iterative procedure for minimizing (or maximizing) the function f(x) = f(X1,X2,…,Xt) jointly over all variables by alternating restricted minimizations over the individual subsets of variables X1,…,Xt. AO is the basis for the c-means clustering algorithms (t=2), many forms of vector quantization (t = 2, 3 and 4), and the expectation-maximization (EM) algorithm (t = 4) for normal mixture decomposition. First we review where and how AO fits into the overall optimization landscape. Then we discuss the important theoretical issues connected with the AO approach. Finally, we state (without proofs) two new theorems that give very general local and global convergence and rate of convergence results which hold for all partitionings of x.},
+	language = {en},
+	booktitle = {Advances in {Soft} {Computing} — {AFSS} 2002},
+	publisher = {Springer},
+	author = {Bezdek, James C. and Hathaway, Richard J.},
+	editor = {Pal, Nikhil R. and Sugeno, Michio},
+	year = {2002},
+	pages = {288--300},
+	file = {Bezdek and Hathaway - 2002 - Some Notes on Alternating Optimization.pdf:/home/mya/Zotero/storage/35MSSAAJ/Bezdek and Hathaway - 2002 - Some Notes on Alternating Optimization.pdf:application/pdf},
+}
+
+@phdthesis{janis_heims_checking_2024,
+	title = {Checking of {Quantum} {Circuits} using {Diff} {Algorithms}},
+	url = {https://github.com/TechnoElf/mqt-qcec-diff-thesis},
+	language = {en},
+	school = {Technical University of Munich},
+	author = {{Janis Heims}},
+	month = oct,
+	year = {2024},
+	file = {Janis Heims - 2024 - Checking of Quantum Circuits using Diff Algorithms.pdf:/home/mya/Zotero/storage/BKU9ANZH/Janis Heims - 2024 - Checking of Quantum Circuits using Diff Algorithms.pdf:application/pdf},
+}
+
+@article{dave_fuzzy_1990,
+	title = {Fuzzy {Shell}-{Clustering} and {Applications} to {Circle} {Detection} in {Digital} {Images}},
+	volume = {16},
+	issn = {0308-1079},
+	url = {https://doi.org/10.1080/03081079008935087},
+	doi = {10.1080/03081079008935087},
+	abstract = {A new type of Fuzzy Clustering algorithm called Fuzzy-Shell Clustering (FSC) is introduced, The FSC algorithm seeks cluster prototypes that are p-dimensional hyper-spherical-shells. In two-dimensional data, this amounts to finding cluster prototypes that are circles. Thus the FSC algorithm can be applied for detection of circles in digital images. The algorithm does not require the data-points to be in any particular order, therefore its performance can be compared with the global transformation techniques such as Hough transforms. Several numerical examples are considered and the performance of the FSC algorithm is compared to the performance of the methods based on generalized Hough transform (HT). The FSC is shown to be superior to the HT method with regards to memory requirement and computation time. Like the HT method, the FSC is successful even if only a part of a circular shape is present in the image. Other potential applications of FSC are also considered.},
+	number = {4},
+	urldate = {2024-10-07},
+	journal = {International Journal of General Systems},
+	author = {DAVE, RAJESH N.},
+	month = may,
+	year = {1990},
+	note = {Publisher: Taylor \& Francis
+\_eprint: https://doi.org/10.1080/03081079008935087},
+	pages = {343--355},
+	file = {Full Text PDF:/home/mya/Zotero/storage/APPNGAIZ/DAVE - 1990 - Fuzzy Shell-Clustering and Applications to Circle .pdf:application/pdf},
+}
+
+@article{al-nimr_international_nodate,
+	title = {{THE} {INTERNATIONAL} {ADVISORY} {BOARD}},
+	abstract = {A self-contained abstract outlining in a single paragraph the aims, scope and conclusions of the paper must be supplied.},
+	language = {en},
+	author = {Al-Nimr, Moh'd A},
+	file = {Al-Nimr - THE INTERNATIONAL ADVISORY BOARD.pdf:/home/mya/Zotero/storage/IML5EJ2I/Al-Nimr - THE INTERNATIONAL ADVISORY BOARD.pdf:application/pdf},
+}
+
+@article{do_what_2008,
+	title = {What is the expectation maximization algorithm?},
+	volume = {26},
+	copyright = {2008 Springer Nature America, Inc.},
+	issn = {1546-1696},
+	url = {https://www.nature.com/articles/nbt1406},
+	doi = {10.1038/nbt1406},
+	abstract = {The expectation maximization algorithm arises in many computational biology applications that involve probabilistic models. What is it good for, and how does it work?},
+	language = {en},
+	number = {8},
+	urldate = {2024-10-07},
+	journal = {Nature Biotechnology},
+	author = {Do, Chuong B. and Batzoglou, Serafim},
+	month = aug,
+	year = {2008},
+	note = {Publisher: Nature Publishing Group},
+	keywords = {Agriculture, Bioinformatics, Biomedical Engineering/Biotechnology, Biomedicine, Biotechnology, general, Life Sciences},
+	pages = {897--899},
+	file = {Full Text PDF:/home/mya/Zotero/storage/H4DCQ3TP/Do and Batzoglou - 2008 - What is the expectation maximization algorithm.pdf:application/pdf},
+}

content/background.typ

@@ -0,0 +1,92 @@
+#import "@preview/glossarium:0.5.6": *
+
+= Technischer Hintergrund
+
+
+
+Die Operation einer #gls("puf") beinhaltet zwei verschiedene Arbeitsschritte: *Enrollment* und *Reconstruction*.\
+Als Enrollment wird die erste Messung des Verhaltens des Schaltkreises bezeichnet.
+Diese kann direkt in der Fertigungsstätte des Schaltkreises durchgeführt werden.
+Da bis zu diesem Punkt noch keine andere Messung mit dem Schaltkreis durchgeführt worden ist, können die Ergebnisse aus diesem Schritt als unveränderlichen Referenzwert für das Geheimnis des Schaltkreises angenommen werden.
+Anschließend wird aus den Messergebnissen mittels eines Quantisierungsprozesses ein geheimer Schlüssel generiert.\
+Reconstruction bezeichnet jede weitere Messung des Verhaltens des Schaltkreises.
+Da Messfehler in diesem Schritt nicht ausgeschlossen werden können, ist davon auszugehen, dass das hier gemessene Geheimnis nicht mit dem Referenz-Geheimnis bzw. dem geheimen Schlüssel nach der Enrollment Phase vollständig übereinstimmt.
+Die Anzahl der Bits, die zwischen diesen beiden Schlüsseln verschieden ist, ist als Bitfehlerrate definiert.
+Zusätzlich ist davon auszugehen, dass die Messwerte einer #gls("puf") 
+normalverteilt und mittelwertfrei sind.
+
+Die Ausgangslage der Praxis stellt die Bachelorarbeit "Towards Efficient Helper Data Algorithms for Multi-Bit PUF Quantization" da.
+Konkret wurden in der Arbeit zwei verschiedene Methoden zur Verbesserung der Bitfehlerrate nach der Reconstruction Phase für Quantisierungen höherer Ordnung analyisert.
+Die erste Methode beschreibt eine Verallgemeinerung der #gls("tmhdt") @tmhd1.
+Mit Hilfe von #gls("tmhdt") werden zwei verschiedene Quantisiererfunktionen definiert. Während der Enrollment Phase wird anschließend entschieden, welche der beiden Funktionen ein verlässlicheres Ergebnis bei wiederholten Messergebnissen hervorrufen wird.
+Die #gls("smhdt") verallgemeinert dieses Konzept auf die Quantisierung mit mehr als einem Bit @smhd.
+Da mit der Publikation von Fischer @smhd bereits eine mögliche Implementation von #gls("smhdt") vorgestellt wurde, bildet die in der Arbeit vorgelegte Implementierung eine Basis um die Performanz der zweiten vorgestellten Methode einordnen zu können. 
+
+Im zweiten Teil der Arbeit wurde ein neuer Ansatz zur Verbesserung der Fehlerrate implementiert und genauer analysiert.
+Die Grundlage der neuen Methode ergibt sich aus der natürlichen Beschaffenheit der Standardnormalverteilung.
+Da der Erwartungswert einer mittelwertfreien Normalverteilung bei $0$ liegt und ein Vorzeichen-basierter 1-bit Quantisierer seine Entscheidungsgrenze ebenfalls bei $0$ definiert, sind die Messwerte welche nahe der $0$ liegen aufgrund ihrer inhärenten Messschwankungen dazu anfällig, bei wiederholten Messungen und Quantisierungen unterschiedliche Ergebnisse zu verursachen.
+
+Dieses Problem wird in @bach_original_1 grafisch verdeutlicht.
+
+#figure(
+  include("../graphics/background/sign-based-overlay.typ"), 
+  caption: [1-bit Quantisierer mit normalverteilten Eingangswerten]
+)<bach_original_1>
+
+Für die Umsetzung der neuen Methode werden gewichtete Summen aus mindestens 3 Eingangswerten -- wie Ring-Oszillator-Differenzen -- gebildet. Die Vorfaktoren der Summanden sind festgelegt als $plus.minus 1$, wobei die jeweiligen Vorzeichen als Helperdaten abgespeichert werden.
+
+$ f(bold(x), bold(h)) = h_1 x_1 + h_2 x_2 + h_3 x_3 $<eq:weighted_sum>
+
+@eq:weighted_sum zeigt die Struktur einer Funktion mit drei Eingangswerten und ihrer jeweiligen Gewichtung durch $h_1$, $h_2$ und $h_3$.
+Diese Vorfaktoren sollen nun so gewählt werden, dass die Werte der resultierenden Summen einen möglichst großen Abstand zu ihrer jeweils nächsten Quantisierergrenze haben.
+
+Eine Lösung für den 1-bit Fall der in @bach_original_1 dargestellt wird, ist die betragsmäßige Maximierung der Werte der gewichteten Summen.
+
+#figure(
+  include("../graphics/background/z_distribution.typ"),
+  caption: [Darstellung der optimierten Eingangswerte]
+)<fig:bach_1_optimal>
+
+Mathematisch lässt sich dies durch die Maximierung des Betrags der Funktion aus @eq:weighted_sum herleiten:
+
+$ max_(h_1, h_2, h_3) |f(bold(x), bold(h))|  $<eq:1bit_opt>
+
+@eq:1bit_opt definiert hiermit die Funktion zur Optimierung der Eingangwerte vor dem Quantisierer für den 1-bit Fall.
+Jedoch wird die Definition dieser Funktion für eine Vorbereitung der Quantisierung höherer Ordnung um einiges komplexer. 
+
+#figure(
+  include("../graphics/background/two-bit-enroll.typ"),
+  caption: [2-bit Quantisierer Funktion]
+)<fig:2bit_quant>
+
+Anstelle einer Quantisierung basierend auf dem Vorzeichen des Eingangswertes, wie in @bach_original_1 ist bei einer Quantisierung höherer Ordnung eine mehrstufige Entscheidungsfunktion mit mehreren Grenzen wie in @fig:2bit_quant notwendig. 
+Es stellt sich nun die Frage, wie man die Grenzen $g_1$ und $g_2$ aus @fig:2bit_quant wählt, um die Optimierung des 1-bit Falles aus @fig:bach_1_optimal auf Fälle höherer Bit-Ordnung zu übertragen.
+
+Die ersten Ansätze der Bachelorarbeit beinhalteten zunächst ein naives Raten der möglichen Grenzen für die Quantisierung basierend auf einer Schätzung der Form der resultierenden Verteilung.
+Zunächst wurde ein globales Optimierungsverfahren untersucht, bei dem nach einer ersten Optimierung nach der maximalen Distanz zu allen Grenzen, neue Grenzen basierend auf einer empirischen kumulativen Wahrscheinlichkeitsdichtefunktion definiert werden. Dieser Prozess wurde anschließend über mehrere Iterationen hinweg durchgeführt, um ein stabiles Ergebnis Wahrscheinlichkeitsverteilungen zu erhalten. 
+
+#figure(
+grid(
+  columns: (1fr, 1fr),
+  rows: (2),
+  [//#figure(
+  #image("../graphics/background/bach/instability/frame_1.png")
+  #v(-2em)
+  //)
+  Iteration 1],
+  [//#figure(
+  #image("../graphics/background/bach/instability/frame_18.png")
+  #v(-2em)
+  //)
+  Iteration 18],
+),
+  caption: [Wahrscheinlichkeitsverteilungen für verschiedene Iterationen]
+)<fig:bach_instability>
+
+@fig:bach_instability zeigt die Ergebnisse dieses iterativen Prozesses zu verschiedenen Zeitpunkten.
+Wegen des sehr instabilen Verhaltens der Verteilungen auch über mehrere Iterationen hinweg wurde eine zweite, konvergierende Methode untersucht.
+
+Anstelle die Gewichtungen zu wählen, dass die resultierende Summe möglichst weit weg von allen Grenzen liegt, sollen die Summen möglichst genau die Mitten zwischen den Grenzen treffen und so implizit möglichst weit weg von den Grenzen liegen. 
+Diese Methode hatte zwar den Vorteil, dass die hervorgehenden Verteilungen zu einer festen Verteilung konvergieren, jedoch zeigte eine spätere Analyse keine signifikante Verbesserung der Bitfehlerrate auf.
+
+Ziel der Ingenieurspraxis ist nun, eine mögliche Lösung für das Problem der Konvergenz dieses Ansatzes zu finden und mit anderen Methoden zur Verbesserung der Bitfehlerrate zu vergleichen. 

content/execution.typ

@@ -0,0 +1,116 @@
+#import "@preview/codly:1.3.0": *
+#import "@preview/codly-languages:0.1.1": *
+#show: codly-init.with()
+#codly(languages: codly-languages)
+
+= Konzeption und Durchführung
+
+== Literaturrecherche und Konzeption
+
+Zunächst fand eine tiefere Einarbeitung in die existierende Literatur zu alternierenden Optimierungsverfahren statt.
+Aufgrund der Nähe der Themen hat sich eine Recherche zu den "k-Means Clustering" und "Expectation-maximization" Algorithmen angeboten. Spannende Literatur zu diesen Themen wurde von Bezdek @bezdek_notes_2002 -- allgemein zu alternierenden Optimierungsverfahren und spezifischer von Do @do_what_2008 publiziert.
+Wenngleich diese Publikationen keinen direkten Weg zur Lösung der Problemstellung der Praxis bieten konnten, stellten sie ein gutes Grundverständnis für diese Art von Problem dar. 
+
+// Hier noch Unterschiede und Gemeinsamkeiten der Literatur vs. Problem aufstellen in Stichpunkten
+
+
+=== Festlegung der verwendeten Toolings
+
+Aufgrund der großen Effizienz und der gut ausgebauten Möglichkeit zur funktionalen Programmierung, wurde als Programmiersprache für das Projekt -- zur Implementierung der Algorithmen und Simulation der Bitfehlerrate -- Julia gewählt.
+Im weiteren Verlauf der Praxis wurde zusätzlich für die verbesserte Möglichkeit der Visualisierung der Ergebnisse das Pluto Framework -- ein Julia-Pendant zu Jupyter Notebooks -- mit einbezogen.
+
+== Durchführung und Projektdokumentation 
+
+Für eine effiziente und übersichtliche Implementierung der Algorithmen und Simulationen wurde zunächst diverse Hilfsfunktionen in Julia implementiert. #figure(
+  caption: "Generierung von allen möglichen Linearkombinationen"
+)[
+  ```julia
+function create_linearcombinations(inputs, weights, n) 
+    collect(map(
+        set -> begin
+            LinearCombinationSet(
+                collect(map(
+                    weights -> begin
+                            LinearCombination(weights, map(v -> [signbit(v)], weights), set, sum(weights .* set))
+                    end,
+                    weights
+                )))
+        end, 
+        Iterators.partition(inputs, n)))
+end
+  ```
+]<code:generate_lincombs>
+
+@code:generate_lincombs zeigt exemplarisch die Implementierung einer Funktion zur Generierung aller möglichen Linearkombinationen für eine Menge an Eingangswerten. 
+
+Anschließend wurde die betragsmäßige Optimierung, welche in @bach_original_1 und @fig:bach_1_optimal dargestellt wird, implementiert und getestet. 
+
+=== Rekursiver Ansatz
+
+Als nächste Möglichkeit für den Multi-Bit Fall ist ein rekursiver Ansatz des Problems implementiert worden. Hierfür werden die Eingangswerte zunächst mit der betragsmäßigen Optimierung verarbeitet um so eine "optimale" Verteilung für den 1-bit Fall zu konstruieren. Anschließend wird die Verteilung in zwei symmetrische Unterverteilungen aufgeteilt, und jeweils deren Mittelwert bestimmt.
+Anschließend werden für jede Summe der jeweiligen Unterverteilungen zusätzliche fraktionierte Gewichtungen auf die bereits bestehenden Gewichtungen aufaddiert. 
+Basierend auf der Mittelwertbestimmung werden zusätzliche Grenzen definiert, anhand deren die aufkommenden neuen Summen mit fraktionierte Gewichtungen optimal gewählt werden. 
+Basierend auf der Anzahl $m$ an  Bits die aus einer Summe extrahiert werden sollen wird dieses Verfahren $m$-Mal mit allen entstehenden Unterverteilungen durchgeführt. 
+
+Ein erstes positives Ergebnis hier war die schnelle Konvergenz der Verteilung und die Gleichverteilung der quantisierten Symbole, da in jeden Grenzbereich möglichst gleich viele Summen gelegt worden sind. @fig:bach_recursive_dist zeigt das Ergebnis des rekursiven Ansatzes für die Quantisierung von 2 Bit.
+
+// Notiz: Grafiken vielleicht nochmal separat exportieren wenn Pluto das irgendwie zulässt.
+#figure(
+  image("../graphics/execution/recursive_distribution .png", width: 70%),
+  caption: "Verteilung der Eingangswerte nach dem rekursiven Ansatz"
+)<fig:bach_recursive_dist>
+
+Jedoch stellte sich nach der Analyse der verwendeten Hilfsdatenvektoren heraus, dass durch die Zuweisung der Hilfsdaten Informationen über den Schlüssel ableitbar sind. 
+
+#figure(
+  image("../graphics/execution/helperdata_occurs.png", width: 70%),
+  caption: "Verteilung der Hilfsdatenvektoren für jedes Bitsymbol"
+)<fig:bach_recursive_hd_occurs>
+
+Das Histogramm in @fig:bach_recursive_hd_occurs zeigt dieses Problem auf. Damit über die Hilfsdaten keine Informationen über den Schlüssel bekannt werden, muss jeder verwendete Hilfsdatenvektor von jedem Symbol gleich häufig verwendet werden. Mit diesem Ansatz werden von je zwei Symbolen jedoch nur vier von acht möglichen Hilfsdatenvektoren verwendet.
+
+=== Vorgabe des Codeworts
+
+Eine weitere getestete Methode bestand aus dem vorgeben des zu verwendeten Codewords bzw. Schlüssels. 
+Hierfür werden die Grenzen der Quantisiererfunktion über die kumulative Verteilungsfunktion der Eingangswerte bestimmt. Anschließend wird jene Summe mit Hilfsdaten gewählt, welche die Summe zu ihrem vorgegebenen Codewort quantisieren. 
+
+#figure(
+  image("../graphics/execution/given_codeword.png", width: 65%),
+  caption: "Verteilung nach der Verarbeitung mit vorgegebenem Codewort"
+)<fig:bach_given_codeword>
+
+Leider stellte sich die Vorgabe, jene Linearkombination zu wählen welche am besten ein vorgegebenes Codewort approximiert nicht als praktikabel heraus, da -- wie in @fig:bach_given_codeword zu sehen ist -- bei einer Verarbeitung für 2 Bit keine vier voneinander unterscheidbaren Unterverteilungen ergeben. Nahe der 0 lässt sich lediglich eine kleine Abweichung vom 1-bit Fall feststellen, welche aber nicht signifikant genug ist, um die Bitfehlerrate zu minimieren. 
+
+=== Brute-Force-Ansatz 
+
+Als letzten möglichen Lösungsansatz wurde ein Brute-Force-Ansatz untersucht. 
+Um die optimalen Grenzen für eine Quantisierung höherer Ordnung zu erhalten, wurden für verschiedene Quantisierergrenzen die Verteilungen der Quantisierten Codewörter analysiert.
+Im Detail wurde für eine große Menge an möglichen Grenzen die Distanzmaximierung der Linearkombinationen durchgeführt. 
+// needs citation
+Direkt im Anschluss wurde über Pearson's Chi-square Test  die Gleichverteilung der Quantisierten Symbole überprüft und nach einem Maximum des Ergebnisses des Tests gesucht. 
+@fig:bach_brute_force zeigt das Ergebnis der Verarbeitung dieser Grenzen für einen 3-bit Fall.
+
+Da diese Brute-Force Operation sehr rechenaufwändig ist, wurden die bereits in Julia implementierten Lösungen für parallel Computing eingesetzt und die Berechnung der idealen Grenzen auf einem Computer mit hoher Rechenkapazität ausgelagert. 
+
+#figure(
+  image("../graphics/execution/brute-force.png", width: 80%),
+  caption: "Resultat nach Verwendung der durch den Brute-Force Ansatz gefundenen Grenzen"
+)<fig:bach_brute_force>
+
+Auch die Betrachtung des Histogramms der Hilfsdatenverteilung zeigt befriedigende Ergebnisse auf. 
+Wie in @fig:bach_brute_force_occurs zu sehen ist, wird jeder Hilfsdatenvektor von jedem Symbol gleich häufig verwendet. 
+
+#figure(
+  image("../graphics/execution/brute-force-occurs.png", width: 80%),
+  caption: "Resultat nach Verwendung der durch den Brute-Force Ansatz gefundenen Grenzen"
+)<fig:bach_brute_force_occurs>
+
+Außerdem ist über diese Methode eine signifikante Verbesserung de Bitfehlerrate im Bezug auf eine Quantisierung ohne Vorverarbeitung und Fehlerkorrekturcode vorzuweisen, weshalb sich hier gute Chancen auf ein zukünftiges Nutzbares Verfahren abbilden.
+
+=== Portieren der BCH-Code Python Bibliothek
+
+Für die weitere Integration und vollständige Implementierung zu einem allgemeinen Simulationsprogramm, das die gesamte Fehlerkorrektur bis zum Schlüssel abdeckt, ist ein BCH-Fehlerkorrektur-Code als Python-Codebasis vorgegeben worden. 
+Damit dieser auf die bereits in Julia programmierten Implementierungen angewendet werden kann, wurde diese Codebasis vollständig von Python nach Julia portiert. 
+Hierzu waren kleinere Zwischenrecherchen im Bezug auf die Differenzen und Ähnlichkeiten der beiden Sprachen notwendig, um eine ordnungsgemäße Portierung durchführen zu können.
+
+Aufgrund des kurz darauf folgenden Endes der Anstellung im Rahmen der Ingenieurspraxis war es leider nicht mehr möglich den portierten BCH-Code im Zusammenhang mit der gefundenen Lösung zur Optimierung der Grenzen einzusetzen. 

content/introduction.typ

@@ -0,0 +1,19 @@
+#import "@preview/glossarium:0.5.6": *
+
+= Motivation und Problemstellung
+
+#glspl("puf", capitalize: true) stellen in der Kryptographie einen spannenden Bereich zur Generierung und sicheren Speicherung Schlüsseln da.
+Durch minimale, nicht reproduzierbare Abweichungen im Fertigungsprozess lässt sich die Einzigartigkeit eines Schaltkreises nutzen, um ein Geheimnis direkt und sicher auf dem Chip zu speichern.
+
+Ein Problem bei der Verwendung der Einzigartigkeiten dieser Schaltkreise ist die verlässliche Rekonstruktion eines Schlüssels.
+Da diese minimalen Unterschiede nur gemessen werden können, ist das Ergebnis von einem unkontrollierbaren Messfehler behaftet, welcher
+unter Umständen den neuen generierten Schlüssel verfälscht.
+
+// Hier noch erklären, wie man von einem analogen auf einen digitalen Wert kommt.
+
+In der Regel lässt sich dieses Problem durch die Verwendung von Fehlerkorrekturcodes beheben.
+Diese werden üblicherweise nach der Quantisierung --- also der Diskretisierung der gemessenen Werte angewendet.
+
+Aufbauend auf die Bachelorarbeit "Towards Efficient Helper Data Algorithms for Mulit-Bit PUF Quantization" soll hier die Praktikabilität und Umsetzbarkeit einer neuen Methode zur Verbesserung der Bitfehlerrate bei einer PUF Quantisierung analysiert werden.
+
+// TODO eventuell noch mehr dazu in der Einleitung schreiben ansonsten steht hier recht wenig.

flake.lock

@@ -0,0 +1,82 @@
+{
+  "nodes": {
+    "flake-utils": {
+      "inputs": {
+        "systems": "systems"
+      },
+      "locked": {
+        "lastModified": 1731533236,
+        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1747179050,
+        "narHash": "sha256-qhFMmDkeJX9KJwr5H32f1r7Prs7XbQWtO0h3V0a0rFY=",
+        "owner": "NixOS",
+        "repo": "nixpkgs",
+        "rev": "adaa24fbf46737f3f1b5497bf64bae750f82942e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "NixOS",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "flake-utils": "flake-utils",
+        "nixpkgs": "nixpkgs",
+        "typix": "typix"
+      }
+    },
+    "systems": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
+    },
+    "typix": {
+      "inputs": {
+        "nixpkgs": [
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1746607658,
+        "narHash": "sha256-WKB6j7RddVr2NT1Wze03uw/yiFeEX/F5vdOWSKoj9Z0=",
+        "owner": "loqusion",
+        "repo": "typix",
+        "rev": "01160b19f90eeba0124dea8326779477b5313ebb",
+        "type": "github"
+      },
+      "original": {
+        "owner": "loqusion",
+        "repo": "typix",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

flake.nix

@@ -0,0 +1,97 @@
+{
+  description = "A Typst project";
+
+  inputs = {
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
+
+    typix = {
+      url = "github:loqusion/typix";
+      inputs.nixpkgs.follows = "nixpkgs";
+    };
+
+    flake-utils.url = "github:numtide/flake-utils";
+
+    # Example of downloading icons from a non-flake source
+    # font-awesome = {
+    #   url = "github:FortAwesome/Font-Awesome";
+    #   flake = false;
+    # };
+  };
+
+  outputs = inputs @ {
+    nixpkgs,
+    typix,
+    flake-utils,
+    ...
+  }:
+    flake-utils.lib.eachDefaultSystem (system: let
+      pkgs = nixpkgs.legacyPackages.${system};
+      inherit (pkgs) lib;
+
+      typixLib = typix.lib.${system};
+
+      src = typixLib.cleanTypstSource ./.;
+      commonArgs = {
+        typstSource = "main.typ";
+
+        fontPaths = [
+          # Add paths to fonts here
+          # "${pkgs.roboto}/share/fonts/truetype"
+          "template/resources"
+        ];
+
+        virtualPaths = [
+          # Add paths that must be locally accessible to typst here
+          # {
+          #   dest = "icons";
+          #   src = "${inputs.font-awesome}/svgs/regular";
+          # }
+        ];
+      };
+
+      # Compile a Typst project, *without* copying the result
+      # to the current directory
+      build-drv = typixLib.buildTypstProject (commonArgs
+        // {
+          inherit src;
+        });
+
+      # Compile a Typst project, and then copy the result
+      # to the current directory
+      build-script = typixLib.buildTypstProjectLocal (commonArgs
+        // {
+          inherit src;
+        });
+
+      # Watch a project and recompile on changes
+      watch-script = typixLib.watchTypstProject commonArgs;
+    in {
+      checks = {
+        inherit build-drv build-script watch-script;
+      };
+
+      packages.default = build-drv;
+
+      apps = rec {
+        default = watch;
+        build = flake-utils.lib.mkApp {
+          drv = build-script;
+        };
+        watch = flake-utils.lib.mkApp {
+          drv = watch-script;
+        };
+      };
+
+      devShells.default = typixLib.devShell {
+        inherit (commonArgs) fontPaths virtualPaths;
+        packages = [
+          # WARNING: Don't run `typst-build` directly, instead use `nix run .#build`
+          # See https://github.com/loqusion/typix/issues/2
+          # build-script
+          watch-script
+          # More packages can be added here, like typstfmt
+          # pkgs.typstfmt
+        ];
+      };
+    });
+}

glossary.typ

@@ -0,0 +1,8 @@
+#import "@preview/glossarium:0.5.6": print-glossary
+#import "glossary_items.typ": entry-list
+
+#counter(heading).update(0)
+#set heading(numbering: none)
+#heading[Abkürzungsverzeichnis]
+
+#print-glossary(entry-list)

glossary_items.typ

@@ -0,0 +1,10 @@
+#let entry-list = (
+  (key: "hda", short: "HDA", plural: "HDAs", long: "helper data algorithm", longplural: "helper data algorithms"),
+    (key: "cdf", short: "CDF", plural: "CDFs", long: "cumulative distribution function", longplural: "cumulative distribution functions"),
+    (key: "ecdf", short: "eCDF", plural: "eCDFs", long: "empirical Cumulative Distribution Function", longplural: "empirical Cumulative Distribution Functions"),
+    (key: "ber", short: "BER", plural: "BERs", long: "bit error rate", longplural: "bit error rates"),
+    (key: "smhdt", short: "SMHD", plural: "SMHDs", long: "S-Metric Helper Data method"),
+    (key: "puf", short: "PUF", plural: "PUFs", long: "physical unclonable function", longplural: "physical Unclonable Functions"),
+    (key: "tmhdt", short: "TMHD", plural: "TMHDs", long: "Two Metric Helper Data method"),
+    (key: "bach", short: "BACH", long: "Boundary Adaptive Clustering with Helper data")
+)

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: 2pt))
+#let dashed = (stroke: (dash: "dashed"))
+#canvas({
+
+  plot.plot(size: (6,3),
+    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: 2pt)),
+      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: 2pt))
+#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: 2pt))
+#let dashed = (stroke: (dash: "dashed"))
+#canvas({
+  plot.plot(size: (6,3),
+    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: 2pt)), label: [Optimierte PDF])
+    plot.add(((-5, 0), (0, 0), (0, 0.6), (5, 0.6)), style: line_style, label: [Quantisierer])
+  })
+})

main.typ

@@ -0,0 +1,34 @@
+#import "template/conf.typ": conf
+#import "@preview/glossarium:0.5.6": *
+
+#show: doc => conf(
+  title: "Parameteroptimierung für Multi-Input Higher-Order Alphabet Quantization",
+  author: "Marius Drechsler",
+  chair: "Lehrstuhl für Sicherheit in der Informationstechnik",
+  school: "School of Computation, Information and Technology",
+  degree: "Ingenieurspraxis",
+  examiner: "Dr. Michael Pehl",
+  supervisor: "M.Sc. Jonas Ruchti",
+  submitted: "30.05.2025",
+  doc
+)
+
+#set math.equation(
+  numbering: "(1)"
+)
+
+// Include glossary items and register glossary
+#import "glossary_items.typ": entry-list
+#register-glossary(entry-list)
+
+// Include your content here
+#include "content/introduction.typ"
+#include "content/background.typ"
+#include "content/execution.typ"
+#include "content/results.typ"
+
+
+#show: make-glossary
+#include "glossary.typ"
+
+#bibliography("bibliography.bib", style: "ieee")

template/colour.typ

@@ -0,0 +1,3 @@
+#let tum_blue = rgb(0, 101, 189)
+#let tum_white = rgb(255, 255, 255)
+#let tum_black = rgb(0, 0, 0)

template/conf.typ

@@ -0,0 +1,156 @@
+#import "cover.typ": cover_page
+#import "title.typ": title_page
+#import "contents.typ": contents_page
+
+#let conf(
+  title: "",
+  author: "",
+  chair: "",
+  school: "",
+  degree: "",
+  examiner: "",
+  supervisor: "",
+  submitted: "",
+  doc
+) = {
+  cover_page(
+    title: title,
+    author: author,
+    chair: chair,
+    school: school
+  )
+
+  title_page(
+    title: title,
+    author: author,
+    chair: chair,
+    school: school,
+    degree: degree,
+    examiner: examiner,
+    supervisor: supervisor,
+    submitted: submitted
+  )
+
+set document(title: title, author: author)
+
+/*
+  set heading(numbering: "1.")
+  show heading: it => locate(loc => {
+    let levels = counter(heading).at(loc)
+
+    set text(font: "TUM Neue Helvetica")
+    if it.level == 1 [
+      #if levels.at(0) != 1 {
+        pagebreak(to: "odd")
+      }
+      #set text(size: 24pt)
+      #if levels.at(0) != 0 {
+        numbering("1", levels.at(0))
+      }
+      #it.body
+      #v(1em, weak: true)
+    ] else if it.level == 2 [
+      #set text(size: 16pt)
+      #v(1em)
+      #numbering("1.1", levels.at(0), levels.at(1))
+      #it.body
+      #v(1em, weak: true)
+    ] else if it.level == 3 [
+      #set text(size: 16pt)
+      #v(1em, weak: true)
+      #numbering("1.1.1", levels.at(0), levels.at(1), levels.at(2))
+      #it.body
+      #v(1em, weak: true)
+    ] else [
+      #set text(size: 12pt)
+      #v(1em, weak: true)
+      #it.body
+      #v(1em, weak: true)
+    ]
+  })
+*/
+
+contents_page()
+
+// This section defines the heading numberins and stylings for different heading levels
+// Kind of a hack but works.
+// TODO needs some refactoring
+set heading(numbering: "1.")
+show heading: it => [
+  #v(1em)
+  #text(
+    size: 12pt,
+    font: "TUM Neue Helvetica",
+    it.body
+  )
+  #v(1em, weak:true)
+]
+
+show heading.where(
+  level: 1
+): it => [
+  #pagebreak()
+  #v(1em)
+  #text(
+  size: 24pt,
+  font: "TUM Neue Helvetica",
+  //[#context counter(heading).display() ] + it.body,
+  [#context{
+      if counter(heading).get().at(0) == 0 [
+        #it.body 
+    ] else [
+      #counter(heading).display()  #it.body
+    ]
+    }]
+  )
+  #v(1em, weak: true)
+]
+
+show heading.where(
+  level: 3
+): it => [
+  #v(1em)
+  #text(
+    size: 16pt,
+    font: "TUM Neue Helvetica",
+    [#context counter(heading).display() ] + it.body
+  )
+  #v(1em, weak:true)
+]
+
+show heading.where(
+  level: 2
+): it => [
+  #v(1em)
+  #text(
+    size: 16pt,
+    font: "TUM Neue Helvetica",
+    context[#counter(heading).display() ] + it.body
+  )
+  #v(1em, weak: true)
+]
+
+
+
+set page(
+  paper: "a4",
+  margin: (
+    top: 3cm,
+    bottom: 3cm,
+    x: 2cm,
+  ),
+  numbering: "1",
+  header: [],
+    //footer: []
+)
+
+
+  set par(justify: true)
+  set align(left)
+  set text(
+    lang: "de",
+   // font: "Times New Roman",
+    size: 12pt
+  )
+  doc
+}

template/contents.typ

@@ -0,0 +1,28 @@
+#import "colour.typ": *
+
+#let contents_page() = {
+  set text(font: "TUM Neue Helvetica", lang: "de")
+
+  // Override the heading function to not make the Contents page affected by heading numbering 0
+
+  show heading.where(
+    level: 1
+  ): it => [
+    #v(1em)
+    #text(
+    size: 24pt,
+    font: "TUM Neue Helvetica",
+    it.body
+    )
+    #v(1em, weak: true)
+  ]
+
+  show outline.entry.where(
+    level: 1
+  ): it => {
+    v(1em)
+    strong(it)
+  }
+
+  outline(indent: auto)
+}

template/cover.typ

@@ -0,0 +1,43 @@
+#import "colour.typ": *
+
+#let cover_page(
+  title: "",
+  author: "",
+  chair: "",
+  school: ""
+) = {
+  page(
+    paper: "a4",
+    margin: (
+      top: 3cm,
+      bottom: 1cm,
+      x: 1cm,
+    ),
+    header: [
+      #grid(
+        columns: (1fr, 1fr),
+        rows: (auto),
+        text(
+          fill: tum_blue,
+          size: 8pt,
+          font: "TUM Neue Helvetica",
+          [#chair \ #school \ Technische Universität München]
+        ),
+        align(bottom + right, image("resources/TUM_Logo_blau.svg", height: 50%))
+      )
+    ],
+    footer: []
+  )[
+    #v(1cm)
+
+    #align(top + left)[#text(font: "TUM Neue Helvetica", size: 24pt, [*#title*])]
+
+    #v(3cm)
+
+    #text(font: "TUM Neue Helvetica", fill: tum_blue, size: 17pt, [*#author*])
+
+    #align(bottom + right)[#image("resources/TUM_Tower.png", width: 60%)]
+  ]
+
+  pagebreak()
+}

template/resources/TUM_Logo_blau.svg

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:cc="http://creativecommons.org/ns#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#" xmlns:svg="http://www.w3.org/2000/svg" xmlns="http://www.w3.org/2000/svg" xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd" xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape" version="1.1" id="Ebene_1" x="0px" y="0px" width="408.16" height="212.46684" viewBox="-16.014 -31 408.16 212.46684" enable-background="new -16.014 -31 149 114" xml:space="preserve" sodipodi:docname="TUM_Web_Logo_blau.svg" inkscape:version="1.0.1 (3bc2e813f5, 2020-09-07)"><metadata id="metadata13"><rdf:RDF><cc:Work rdf:about=""><dc:format>image/svg+xml</dc:format><dc:type rdf:resource="http://purl.org/dc/dcmitype/StillImage"/><dc:title>TUM_Web_Logo_blau</dc:title></cc:Work></rdf:RDF></metadata><defs id="defs11"/><sodipodi:namedview pagecolor="#ffffff" bordercolor="#666666" borderopacity="1" objecttolerance="10" gridtolerance="10" guidetolerance="10" inkscape:pageopacity="0" inkscape:pageshadow="2" inkscape:window-width="1920" inkscape:window-height="986" id="namedview9" showgrid="false" fit-margin-top="0" fit-margin-left="0" fit-margin-right="0" fit-margin-bottom="0" inkscape:zoom="1.754386" inkscape:cx="124.61021" inkscape:cy="115.2546" inkscape:window-x="-11" inkscape:window-y="-11" inkscape:window-maximized="1" inkscape:current-layer="Ebene_1"/>
+<title id="title2">TUM_Web_Logo_blau</title>
+<desc id="desc4">TUM</desc>
+<path fill="#3070b3" d="m 140.54052,-31 v 173.32822 h 44.72985 V -31 H 392.146 V 181.46685 H 353.00738 V 8.138629 H 308.2775 V 181.46685 H 269.13887 V 8.138629 H 224.40902 V 181.46685 H 101.4019 V 8.138629 H 62.26327 V 181.46685 H 23.12462 V 8.138629 H -16.014 V -31 Z" id="path6" style="stroke-width:5.59123"/>
+</svg>

template/title.typ

@@ -0,0 +1,67 @@
+#import "colour.typ": *
+
+#let title_page(
+  title: "",
+  author: "",
+  chair: "",
+  school: "",
+  degree: "",
+  examiner: "",
+  supervisor: "",
+  submitted: ""
+) = {
+  page(
+    paper: "a4",
+    margin: (
+      top: 5cm,
+      bottom: 3cm,
+      x: 2cm,
+    ),
+    header: [
+      #grid(
+        columns: (1fr, 1fr),
+        rows: (auto),
+        text(
+          fill: tum_blue,
+          size: 8pt,
+          font: "TUM Neue Helvetica",
+          [#chair \ #school \ Technische Universität München]
+        ),
+        align(bottom + right, image("resources/TUM_Logo_blau.svg", height: 30%))
+      )
+    ],
+    footer: []
+  )[
+    #set text(
+      font: "TUM Neue Helvetica",
+      size: 10pt
+    )
+
+    #v(1cm)
+
+    #set align(top + left)
+    #text(size: 24pt, [*#title*])
+
+    #v(3cm)
+
+    #text(fill: tum_blue, size: 17pt, [*#author*])
+
+    #v(3cm)
+
+    Bericht zur Ableistung der
+    #v(1em)
+    *#degree*
+    #v(1em)
+    an der #school der Technischen Universität München.
+
+    #v(3cm)
+
+    *Prüfer:*\ #examiner
+    #v(0em)
+    *Betreuer:*\ #supervisor
+    #v(0em)
+    *Eingereicht am:*\ Munich, #submitted
+  ]
+
+  pagebreak()
+}

typst.toml

@@ -0,0 +1,2 @@
+[[tinymist.input]]
+entry = "main.typ"