Initial commit

content/SMHD.typ

@@ -0,0 +1,3 @@
+= S-Metric Helper Data Method
+
+#figure(include("../graphics/quantizers/two-metric-enroll.typ"))

content/background.typ

@@ -0,0 +1,70 @@
+#import "@preview/fletcher:0.5.1": diagram, node, edge
+#import "@preview/gentle-clues:0.9.0": example
+#import "@preview/quill:0.3.0": quantum-circuit, lstick, rstick, ctrl, targ, mqgate, meter
+
+
+= Background
+== Quantum Computation and Quantum Circuits
+A quantum computer is a device that performs calculations by using certain phenomena of quantum mechanics.
+The algorithms that run on this device are specified in quantum circuits. 
+
+#example[
+  @example_qc shows a simple quantum circuit that implements a specific quantum algorithm.
+
+  #figure(
+    quantum-circuit(
+      lstick($|0〉$), $H$, mqgate($U$, n: 2, width: 5em, inputs: ((qubit: 0, label: $x$), (qubit: 1, label: $y$)), outputs: ((qubit: 0, label: $x$), (qubit: 1, label: $y plus.circle f(x)$))), $H$, meter(), [\ ],
+      lstick($|1〉$), $H$, 1, 1, 1
+    ),
+    caption: [A quantum circuit implementing the Deutsch-Jozsa algorithm]
+  ) <example_qc>
+]
+
+
+== Decision Diagrams
+Decision diagrams in general are directed acyclical graphs, that may be used to express control flow through a series of conditions.
+It consists of a set of decision nodes and terminal nodes.
+The decision nodes represent an arbitrary decision based on an input value and may thus have any number of outgoing edges.
+The terminal nodes represent output values and may not have outgoing edges.
+
+A @bdd is a specific kind of decision diagram, where there are two terminal nodes (0 and 1) and each decision node has two outgoing edges, depending solely on a single bit of an input value.
+@bdd[s] may be used to represent any boolean function.
+
+#example[
+  Example @bdd[s] implementing boolean functions with an arity of $2$ are show in @example_bdd_xor and @example_bdd_and.
+
+  #figure(
+    diagram(
+      node-stroke: .1em,
+      node((0, 0), [$x_0$], radius: 1em),
+      edge((0, 0), (-1, 1), [0], "->"),
+      edge((0, 0), (1, 1), [1], "->"),
+      node((-1, 1), [$x_1$], radius: 1em),
+      node((1, 1), [$x_1$], radius: 1em),
+      edge((-1, 1), (-1, 2), [0], "->"),
+      edge((-1, 1), (1, 2), [1], "->"),
+      edge((1, 1), (1, 2), [0], "->"),
+      edge((1, 1), (-1, 2), [1], "->"),
+      node((-1, 2), [$0$]),
+      node((1, 2), [$1$]),
+    ),
+    caption: [A @bdd for an XOR gate.]
+  ) <example_bdd_xor>
+
+  #figure(
+    diagram(
+      node-stroke: .1em,
+      node((1, 0), [$x_0$], radius: 1em),
+      edge((1, 0), (0, 2), [0], "->"),
+      edge((1, 0), (1, 1), [1], "->"),
+      node((1, 1), [$x_1$], radius: 1em),
+      edge((1, 1), (0, 2), [0], "->"),
+      edge((1, 1), (1, 2), [1], "->"),
+      node((0, 2), [$0$]),
+      node((1, 2), [$1$]),
+    ),
+    caption: [A @bdd for an AND gate.]
+  ) <example_bdd_and>
+]
+
+

content/benchmarks.typ

@@ -0,0 +1,16 @@
+#import "@preview/tablex:0.0.8": tablex
+#import "@preview/unify:0.6.0": qty
+
+= Benchmarks
+== Google Benchmark
+
+== MQT QCEC Bench
+To generate test cases for the application schemes, @mqt Bench was used. @quetschlich2023mqtbench
+
+#tablex(
+  columns: (1fr, 1fr, 1fr),
+  rows: (auto, auto, auto),
+  [*Benchmark Name*], [*Diff Run Time*], [*Proportional Run Time*],
+  [DJ], [$qty("1.2e-6", "s")$], [$qty("1.5e-6", "s")$],
+  [Grover], [$qty("1.3e-3", "s")$], [$qty("1.7e-3", "s")$]
+)

content/conclusion.typ

@@ -0,0 +1,2 @@
+= Conclusion
+#lorem(200)

content/implementation.typ

@@ -0,0 +1,36 @@
+#import "@preview/lovelace:0.3.0": pseudocode-list
+
+= Implementation
+== Visualisation
+Initially, a visualisation of the diff algorithms applied to quantum circuits was created to assess their usefulness in equivalence checking.
+Additionally, this served as exercise to better understand the algorithms to be used for the implementation in @qcec.
+
+
+== QCEC Application Scheme
+The Myers' Algorithm was implemented as an application scheme in @qcec.
+
+#figure(
+  block(
+    pseudocode-list[
+      + do something
+      + do something else
+      + *while* still something to do
+        + do even more
+        + *if* not done yet *then*
+          + wait a bit
+          + resume working
+        + *else*
+          + go home
+        + *end*
+      + *end*
+    ],
+    width: 100%
+  ),
+  caption: [Myers' algorithm.]
+) <myers_algorithm>
+
+
+
+== QCEC Benchmarking Tool
+As @qcec doesn’t have built-in benchmarks, a benchmarking tool was developed to test different configurations on various circuit pairs.
+

content/introduction.typ

@@ -0,0 +1,35 @@
+= Introduction
+
+These are the introducing words
+
+== Notation
+
+To ensure a consistent notation of functions and ideas, we will now introduce some required conventions 
+
+Random distributed variables will be notated with a capital letter, i.e. $X$, its realization will be the corresponding lower case letter, $x$.
+
+Vectors will be written in bold test: $bold(k)$ represents a vector of quantized symbols.
+
+We will call a quantized symbol $k$. $k$ consists of all possible binary symbols, i.e. $0, 01, 110$.
+
+A quantizer will be defined as a function $cal(Q)(x, bold(a))$ that returns a quantized symbol $k$. 
+
+@example-quantizer shows the curve of a 2-bit quantizer that receives $tilde(x)$ as input. In the case, that the value of $tilde(x)$ equals one of the four bounds, the quantized value is chosen randomly from the relevant bins.
+
+#figure(
+  include("../graphics/quantizers/two-metric-enroll.typ"),
+  caption: [Example quantizer function]) <example-quantizer>
+
+For the S-Metric Helper Data Method, we introduce a function
+
+$ cal(Q)(s,m) $<eq-1>
+
+where s determines the amount of metrics and m the bit width of the symbols.
+
+=== Tilde-Domain<tilde-domain>
+
+AS also described in REFSMHD, we will use a CDF to transform the real PUF values into the Tilde-Domain
+This transformation can be performed using the function $sym(xi) = tilde(x)$. The key property of this transformation is the resulting uniform distribution of $x$. 
+
+Considering a normal distribution, the CDF is defined as 
+$ sym(xi)(frac(x - sym(mu))(sym(sigma))) = frac(1)(2)[1 + erf(frac(x - sym(mu))(sym(sigma) sqrt(2)))] $

content/outlook.typ

@@ -0,0 +1,2 @@
+= Outlook
+#lorem(200)

content/state.typ

@@ -0,0 +1,3 @@
+= State of the Art
+There are a variety of existing approaches to providing a suitable oracle for quantum circuit equivalence checking based on @dd[s].
+@qcec currently implements gate-cost, lookahead, one-to-one, proportional and sequential application schemes. @burgholzer2021ec