a lot of work on the presentation

presentation/Makefile

@@ -10,6 +10,14 @@ graph_pngs= graphs/valid_graph.png \
 			graphs/clear_vop_05.png \
 			graphs/clear_vop_06.png
 
+example_graphpngs= example_graphs/graph_apply_CZ.png \
+				   example_graphs/graph_two_qbit_CZ_after.png \
+				   example_graphs/graph_two_qbit_CZ_before.png \
+				   example_graphs/graph_update_VOP.png\
+				   example_graphs/graph_EPR_state.png\
+				   example_graphs/graph_clear_VOPs_CZ_after.png\
+				   example_graphs/graph_clear_VOPs_CZ_before.png\
+				   example_graphs/graph_clear_VOPs_CZ_cleared.png
 
 
 all: main_long.pdf main.pdf
@@ -20,7 +28,7 @@ main_long.pdf: main_long.tex $(graph_pngs)
 	$(latex) main_long
 	$(pdflatex) main_long
 
-main.pdf: main.tex $(graph_pngs)
+main.pdf: main.tex $(graph_pngs) $(example_graphpngs)
 	$(latex) main
 	#$(bibtex) main
 	$(latex) main
@@ -28,6 +36,10 @@ main.pdf: main.tex $(graph_pngs)
 
 graphs/%.png: graphs/%.dot
 	dot $< -Tpng -o $@
+example_graphs/%.png:example_graphs/%.py
+	python3 $< > tmp.dot
+	dot -Tpng tmp.dot -o $@
+	rm tmp.dot
 	
 clean:
 	-rm main_long.aux
@@ -39,6 +51,7 @@ clean:
 	-rm main_long.toc
 	-rm main_long.bbl
 	-rm $(graph_pngs)
+	-rm $(example_graphpngs)
 	-rm main.aux
 	-rm main.blg
 	-rm main.dvi
@@ -47,3 +60,4 @@ clean:
 	-rm main.pdf
 	-rm main.toc
 	-rm main.bbl
+	-(cd example_graphs && make clean)

presentation/example_graphs/circuit_EPR_state.py

@@ -0,0 +1,17 @@
+from collections import deque
+import matplotlib.pyplot as plt
+import numpy as np
+import json
+
+from pyqcs import State, H, X, S, CZ, CX, list_to_circuit
+from pyqcs.graph.state import GraphState
+from pyqcs.util.to_diagram import circuit_to_diagram
+
+circuit = (H(0)
+        | list_to_circuit([CX(i, 0) for i in range(1, 5)]))
+
+#circuit = (list_to_circuit([H(i) for i in range(0, 5)])
+#            | list_to_circuit([CZ(i, 0) for i in range(1, 5)])
+#            | list_to_circuit([H(i) for i in range(1, 5)]))
+
+print(circuit_to_diagram(circuit))

presentation/example_graphs/graph_EPR_state.py

@@ -0,0 +1,35 @@
+from collections import deque
+import matplotlib.pyplot as plt
+import numpy as np
+import json
+
+from pyqcs import State, H, X, S, CZ, list_to_circuit
+from pyqcs.graph.state import GraphState
+
+
+circuit_CZ = list_to_circuit([CZ(0, i) for i in range(1, 5)])
+circuit_H = list_to_circuit([H(i) for i in range(1, 5)])
+circuit = circuit_CZ | circuit_H
+
+state = circuit * GraphState.new_plus_state(5)
+
+vops, edges = state._g_state.to_lists()
+
+VOP_strs = {0: "H", 2: "I"}
+
+dot_vertex_str = "\n".join((f"{i} [label=\"{i}, VOP = {VOP_strs[v]}\"]" for i,v in enumerate(vops)))
+
+handled_edges = set()
+dot_edges = deque()
+
+for i, ngbhd in enumerate(edges):
+    for j in ngbhd:
+        if((i,j) not in handled_edges):
+            dot_edges.append(f"{i} -- {j}")
+            handled_edges |= {(i,j), (j,i)}
+
+dot_edges_str = "\n".join(dot_edges)
+
+dot_str = "graph graphical_state{\n" + dot_vertex_str + "\n" + dot_edges_str + "\n}"
+
+print(dot_str)

presentation/example_graphs/graph_apply_CZ.py

@@ -0,0 +1,35 @@
+from collections import deque
+import matplotlib.pyplot as plt
+import numpy as np
+import json
+
+from pyqcs import State, H, X, S, CZ, list_to_circuit
+from pyqcs.graph.state import GraphState
+
+
+circuit_CZ = list_to_circuit([CZ(0, i) for i in range(1, 5)])
+circuit_H = list_to_circuit([H(i) for i in range(1, 5)])
+circuit = circuit_CZ | circuit_H | (H(2) | S(2)) | CZ(2, 0)
+
+state = circuit * GraphState.new_plus_state(5)
+
+vops, edges = state._g_state.to_lists()
+
+VOP_strs = {0: "H", 1: "S", 2: "I"}
+
+dot_vertex_str = "\n".join((f"{i} [label=\"{i}, VOP = {VOP_strs[v]}\"]" for i,v in enumerate(vops)))
+
+handled_edges = set()
+dot_edges = deque()
+
+for i, ngbhd in enumerate(edges):
+    for j in ngbhd:
+        if((i,j) not in handled_edges):
+            dot_edges.append(f"{i} -- {j}")
+            handled_edges |= {(i,j), (j,i)}
+
+dot_edges_str = "\n".join(dot_edges)
+
+dot_str = "graph graphical_state{\n" + dot_vertex_str + "\n" + dot_edges_str + "\n}"
+
+print(dot_str)

presentation/example_graphs/graph_clear_VOPs_CZ_after.py

@@ -0,0 +1,35 @@
+from collections import deque
+import matplotlib.pyplot as plt
+import numpy as np
+import json
+
+from pyqcs import State, H, X, S, CZ, list_to_circuit
+from pyqcs.graph.state import GraphState
+
+
+circuit_CZ = list_to_circuit([CZ(0, i) for i in range(1, 5)])
+circuit_H = list_to_circuit([H(i) for i in range(1, 5)])
+circuit = circuit_CZ | CZ(3, 1) | CZ(2, 4) | circuit_H | CZ(2, 1)
+
+state = circuit * GraphState.new_plus_state(5)
+
+vops, edges = state._g_state.to_lists()
+
+VOP_strs = {0: "H", 1: "S", 2: "I", 3:"HS", 5: "Z"}
+
+dot_vertex_str = "\n".join((f"{i} [label=\"{i}, VOP = {VOP_strs[v]}\"]" for i,v in enumerate(vops)))
+
+handled_edges = set()
+dot_edges = deque()
+
+for i, ngbhd in enumerate(edges):
+    for j in ngbhd:
+        if((i,j) not in handled_edges):
+            dot_edges.append(f"{i} -- {j}")
+            handled_edges |= {(i,j), (j,i)}
+
+dot_edges_str = "\n".join(dot_edges)
+
+dot_str = "graph graphical_state{\n" + dot_vertex_str + "\n" + dot_edges_str + "\n}"
+
+print(dot_str)

presentation/example_graphs/graph_clear_VOPs_CZ_before.py

@@ -0,0 +1,35 @@
+from collections import deque
+import matplotlib.pyplot as plt
+import numpy as np
+import json
+
+from pyqcs import State, H, X, S, CZ, list_to_circuit
+from pyqcs.graph.state import GraphState
+
+
+circuit_CZ = list_to_circuit([CZ(0, i) for i in range(1, 5)])
+circuit_H = list_to_circuit([H(i) for i in range(1, 5)])
+circuit = circuit_CZ | CZ(3, 1) | CZ(2, 4) | circuit_H# | CZ(2, 1)
+
+state = circuit * GraphState.new_plus_state(5)
+
+vops, edges = state._g_state.to_lists()
+
+VOP_strs = {0: "H", 1: "S", 2: "I", 3:"HS"}
+
+dot_vertex_str = "\n".join((f"{i} [label=\"{i}, VOP = {VOP_strs[v]}\"]" for i,v in enumerate(vops)))
+
+handled_edges = set()
+dot_edges = deque()
+
+for i, ngbhd in enumerate(edges):
+    for j in ngbhd:
+        if((i,j) not in handled_edges):
+            dot_edges.append(f"{i} -- {j}")
+            handled_edges |= {(i,j), (j,i)}
+
+dot_edges_str = "\n".join(dot_edges)
+
+dot_str = "graph graphical_state{\n" + dot_vertex_str + "\n" + dot_edges_str + "\n}"
+
+print(dot_str)

presentation/example_graphs/graph_clear_VOPs_CZ_cleared.py

@@ -0,0 +1,35 @@
+from collections import deque
+import matplotlib.pyplot as plt
+import numpy as np
+import json
+
+from pyqcs import State, H, X, S, CZ, list_to_circuit
+from pyqcs.graph.state import GraphState
+
+
+circuit_CZ = list_to_circuit([CZ(0, i) for i in range(1, 5)])
+circuit_H = list_to_circuit([H(i) for i in range(1, 5)])
+circuit = circuit_CZ | CZ(3, 1) | CZ(2, 4) | circuit_H | CZ(2, 1) | CZ(2, 1)
+
+state = circuit * GraphState.new_plus_state(5)
+
+vops, edges = state._g_state.to_lists()
+
+VOP_strs = {0: "H", 1: "S", 2: "I", 3:"HS", 5: "Z"}
+
+dot_vertex_str = "\n".join((f"{i} [label=\"{i}, VOP = {VOP_strs[v]}\"]" for i,v in enumerate(vops)))
+
+handled_edges = set()
+dot_edges = deque()
+
+for i, ngbhd in enumerate(edges):
+    for j in ngbhd:
+        if((i,j) not in handled_edges):
+            dot_edges.append(f"{i} -- {j}")
+            handled_edges |= {(i,j), (j,i)}
+
+dot_edges_str = "\n".join(dot_edges)
+
+dot_str = "graph graphical_state{\n" + dot_vertex_str + "\n" + dot_edges_str + "\n}"
+
+print(dot_str)

presentation/example_graphs/graph_two_qbit_CZ_after.py

@@ -0,0 +1,34 @@
+from collections import deque
+import matplotlib.pyplot as plt
+import numpy as np
+import json
+
+from pyqcs import State, H, X, S, CZ, list_to_circuit
+from pyqcs.graph.state import GraphState
+
+
+circuit = (S(0) | H(1) | S(1) | H(1)) | CZ(0, 1)
+
+state = circuit * GraphState.new_plus_state(2)
+
+vops, edges = state._g_state.to_lists()
+
+VOP_strs = {0: "H", 2: "I", 3: "HS", 12: "HSH", 1: "S"}
+
+dot_vertex_str = "\n".join((f"{i} [label=\"{i}, VOP = {VOP_strs[v]}\"]" for i,v in enumerate(vops)))
+
+handled_edges = set()
+dot_edges = deque()
+
+for i, ngbhd in enumerate(edges):
+    for j in ngbhd:
+        if((i,j) not in handled_edges):
+            dot_edges.append(f"{i} -- {j}")
+            handled_edges |= {(i,j), (j,i)}
+
+dot_edges_str = "\n".join(dot_edges)
+
+dot_str = "graph graphical_state{\n" + dot_vertex_str + "\n" + dot_edges_str + "\n}"
+
+print(dot_str)
+

presentation/example_graphs/graph_two_qbit_CZ_before.py

@@ -0,0 +1,34 @@
+from collections import deque
+import matplotlib.pyplot as plt
+import numpy as np
+import json
+
+from pyqcs import State, H, X, S, CZ, list_to_circuit
+from pyqcs.graph.state import GraphState
+
+
+circuit = S(0) | H(1) | S(1) | H(1)
+
+state = circuit * GraphState.new_plus_state(2)
+
+vops, edges = state._g_state.to_lists()
+
+VOP_strs = {0: "H", 2: "I", 3: "HS", 12: "HSH", 1: "S"}
+
+dot_vertex_str = "\n".join((f"{i} [label=\"{i}, VOP = {VOP_strs[v]}\"]" for i,v in enumerate(vops)))
+
+handled_edges = set()
+dot_edges = deque()
+
+for i, ngbhd in enumerate(edges):
+    for j in ngbhd:
+        if((i,j) not in handled_edges):
+            dot_edges.append(f"{i} -- {j}")
+            handled_edges |= {(i,j), (j,i)}
+
+dot_edges_str = "\n".join(dot_edges)
+
+dot_str = "graph graphical_state{\n" + dot_vertex_str + "\n" + dot_edges_str + "\n}"
+
+print(dot_str)
+

presentation/example_graphs/graph_update_VOP.py

@@ -0,0 +1,35 @@
+from collections import deque
+import matplotlib.pyplot as plt
+import numpy as np
+import json
+
+from pyqcs import State, H, X, S, CZ, list_to_circuit
+from pyqcs.graph.state import GraphState
+
+
+circuit_CZ = list_to_circuit([CZ(0, i) for i in range(1, 5)])
+circuit_H = list_to_circuit([H(i) for i in range(1, 5)])
+circuit = circuit_CZ | circuit_H | (H(2) | S(2))
+
+state = circuit * GraphState.new_plus_state(5)
+
+vops, edges = state._g_state.to_lists()
+
+VOP_strs = {0: "H", 1: "S", 2: "I"}
+
+dot_vertex_str = "\n".join((f"{i} [label=\"{i}, VOP = {VOP_strs[v]}\"]" for i,v in enumerate(vops)))
+
+handled_edges = set()
+dot_edges = deque()
+
+for i, ngbhd in enumerate(edges):
+    for j in ngbhd:
+        if((i,j) not in handled_edges):
+            dot_edges.append(f"{i} -- {j}")
+            handled_edges |= {(i,j), (j,i)}
+
+dot_edges_str = "\n".join(dot_edges)
+
+dot_str = "graph graphical_state{\n" + dot_vertex_str + "\n" + dot_edges_str + "\n}"
+
+print(dot_str)

presentation/main.tex

@@ -14,7 +14,9 @@
 %\usepackage{struktex}
 \usepackage{qcircuit}
 \usepackage{adjustbox}
-%\usepackage{tikz}
+\usepackage{tikz}
+\usepackage{calc}
+\usetikzlibrary{calc}
 
 
 \usetheme{metropolis}
@@ -31,6 +33,7 @@
     Faculty of the Institute of Theoretical Physics
     \vspace{-11mm}\flushright\includegraphics[height=1.0cm]{logo.png}}
 
+\newcommand{\tikzmark}[1]{\tikz[overlay,remember picture] \node (#1) {};}
 \makeatletter
 \setbeamertemplate{footline}
 {
@@ -45,6 +48,20 @@
   \end{beamercolorbox}}%
   
 }
+
+
+\NewDocumentCommand{\DrawBox}{s O{}}{%
+    \tikz[overlay,remember picture]{
+    \IfBooleanTF{#1}{%
+        \coordinate (RightPoint) at ($(left |- right)+(\linewidth-\labelsep-\labelwidth,0.0)$);
+    }{%
+        \coordinate (RightPoint) at (right.east);
+    }%
+    \draw[black,#2]
+      ($(left)+(-0.2em,0.9em)$) rectangle
+      ($(RightPoint)+(0.2em,-0.3em)$);}
+}
+
 \makeatother
 
 \begin{document}
@@ -56,7 +73,7 @@
 {
 \begin{frame}{Motivation: Exponentially Hard (Physical) Problems}
     \begin{itemize}
-        \item{Some mathematical problems are exponentially hard to solve, for instance prime factorization.}
+        \item{Some mathematical problems cannot be solved in polynomial time, for instance prime factorization.}
         \item{There exist several physical systems which are interesting to study but hard so simulate such as
             QCD simulations at finite chemical potential or real time scattering amplitudes in QCD.}
         \item{The exponential behaviour in time (and space) complexity brings classical supercomputers to their limits.}
@@ -115,32 +132,9 @@
 \end{frame}
 }
 
-%{
-%\begin{frame}{Quantum Errors and Quantum Error Correction}
-%    \begin{itemize}
-%        \item Quantum systems at non-zero temperature often have dephasing effects and a finite population lifetime (relaxation).
-%        %\pause
-%        \item Fault tolerant QC needs a way to correct for those errors.
-%        %\pause
-%        \item Several strategies exist; one important class of quantum error correction codes are \textbf{stabilizer codes}.
-%        \item{Parts of the theoretical description of quantum errors can be used for physical
-%            problems (see above).}
-%    \end{itemize}
-%\end{frame}
-%}
 
 \section{Binary Quantum Computing}
 
-%{
-%\begin{frame}{Qbits and Gates}
-%    \begin{itemize}
-%        \item{A qbit is a two level quantum mechanical system. The Hilbert space
-%            $\mathcal{H}$ is two dimensional and has the basis vectors $\ket{0}, \ket{1}$.}
-%        \item{$n$ qbits have the Hilbert space $\mathcal{H}^{\otimes n}$.}
-%        \item{Gates on a quantum computers are unitary operators acting on $\mathcal{H}^{\otimes n}$.}
-%    \end{itemize}
-%\end{frame}
-%}
 
 {
 \begin{frame}{One Qbit}
@@ -161,28 +155,14 @@
 \end{frame}
 }
 
-%{
-%\begin{frame}{Notable gates on $n$ Qbits}
-%    \begin{itemize}
-%        \item{For a unitary $U$ acting on $\mathcal{H}$ 
-%            \begin{equation}
-%                U_i := \left(\bigotimes\limits_{l < i} I\right) \otimes U \otimes \left(\bigotimes\limits_{l > i} I\right)
-%            \end{equation} 
-%            is the $U$ gate acting on qbit $i$.}
-%
-%        \item{For two qbits $i\neq j$ the controlled $X$ gate is 
-%            \begin{equation}
-%                CX_{i,j} = \ket{0}\bra{0}_j \otimes I_i + \ket{1}\bra{1}_j \otimes X_i.
-%            \end{equation}}
-%    \end{itemize}
-%\end{frame}
-%}
 {
 \begin{frame}{Universal Gates}
     \begin{itemize}
-        \item{A quantum computer should be able to simulate any unitary on $\mathcal{H}^{\otimes n}$.}
+        \item{A quantum computer should be able to simulate any unitary on $\mathcal{H}^{\otimes n}$ the
+            $n$ qbit Hilbert space.}
         \item{Similarly to classical computers a universal set of operations is required.}
-        \item{One can show that any unitary acting on $\mathcal{H}^{\otimes n}$
+        
+        \item{\tikzmark{left}One can show that any unitary acting on $\mathcal{H}^{\otimes n}$
             can be generated using the $CX$ and universal gates
             acting on $\mathcal{H}$ with
         
@@ -190,8 +170,10 @@
                 CX_{i,j} = \ket{0}\bra{0}_j \otimes I_i + \ket{1}\bra{1}_j \otimes X_i.
             \end{equation}
         }
-        \item{The gates $\{H, R_\phi\}$ are universal on $\mathcal{H}$.}
+        \item{The gates $\{H, R_\phi\}$ are universal on $\mathcal{H}$.\hfill\tikzmark{right}}
+        
     \end{itemize}
+    \DrawBox
 \end{frame}
 }
 
@@ -201,14 +183,6 @@
         \item{When measuring a qbit $i$ the observable $Z_i$ is measured.}
         \item{Operations on the $2^n$ dimensional state will have to update $2^n$ complex
             coefficients. This cannot be performed in $\mbox{poly}(n)$ time.}
-        %\item{The Hilbert space $\mathcal{H}^{\otimes n}$ has the integer basis
-        %    \begin{equation}
-        %        \ket{j} = \ket{\mbox{0b}j_{n-1}...j_1j_0} = \bigotimes\limits_{l=0}^{n-1} \ket{j_l}.
-        %    \end{equation}
-        %}
-        %\item{A general state $\ket{\psi}$ has $2^n$ coefficients in this basis.}
-        %\item{In general an operation on the state $\ket{\psi}$ will have to update $2^n$ coefficients.
-        %    Mapping a general state $\ket{\psi}$ to $\ket{\psi'}$ cannot be performed in $\mbox{poly}(n)$ time.}
     \end{itemize}
 
 \end{frame}
@@ -247,7 +221,7 @@
             \begin{equation}
             \begin{aligned}
                 \exp(t(A + B)) &= \left(\exp(\frac{t}{2N}A)\exp(\frac{t}{N}B)\exp(\frac{t}{2N}A)\right)^N \\
-                                & + \mathcal{O}\left(\frac{t^2}{N^2}\right)\\
+                                & + \mathcal{O}\left(\frac{t^3}{N^3}\right)\\
             \end{aligned}
             \end{equation}
             }
@@ -285,7 +259,7 @@
         \item{\textbf{Theorem}(\textit{Gottesman-Knill}):
             All states that can be reached using $H, R_\frac{\pi}{2}, CZ$ and measurements
             starting from the $\ket{0}^{\otimes n}$ state can be
-            simulated and sampled efficiently, i.e. in $\mbox{poly}(n, m)$ time
+            \textbf{simulated} and \textbf{sampled efficiently on a classical computer}, i.e. in $\mbox{poly}(n, m)$ time
             where $m$ is the amount of gates/measurements.}
     \end{itemize}
 
@@ -306,84 +280,9 @@
             }}
 
     \end{itemize}
-
 \end{frame}
 }
 
-{
-\begin{frame}{The multilocal Pauli Group and the Clifford Group}
-    \begin{itemize}
-        \item{Why is simulating $H, R_\frac{\pi}{2}, CZ$ and measurements
-            so much easier?}
-            %\pause
-        \item{
-            The Pauli group is $P := \{\pm 1, \pm i\} \cdot \{X, Y, Z, I\}$.
-            $P_n := P^{\otimes n}$ is called the multilocal Pauli group.
-             }
-            %\pause
-        \item{
-                $C_n$ is the normalizer of $P_n$, i.e. it maps $P_n$ to itself.\\
-                $C_n$ is generated by $H, R_\frac{\pi}{2}, CZ_{i,j}$.
-            }
-        \item{One can show that the normalizers of  a group such as the Pauli group can be simulated efficiently.}
-        \item{The simulation using $P_n$ is called stabilizer formalism.}
-    \end{itemize}
-\end{frame}
-}
-%{
-%\begin{frame}{Stabilizers and Stabilizer Spaces}
-%    \begin{itemize}
-%        \item{
-%            Choose a finite commuting Abelian subgroup $S$ of $P_n$ with $-I \notin S$.
-%            One can show that all elements of $S$ are hermitian.
-%            }
-%        \item{
-%            One says $S =  \langle S^{(i)} \rangle_{i=1,...,n}$ is generated by the $S^{(i)}$
-%            if every element of $S$ can be expressed as a product of the $S^{(i)}$ and the 
-%            $S^{(i)}$ are the minimal amount of matrices required for this property.
-%            }
-%        \item{
-%            One can show that for $S = \langle S^{(i)} \rangle_{i=1,...,n}$  the stabilizer space 
-%            $V_S := \{\ket{\psi} | S^{(i)}\ket{\psi} = \ket{\psi} \forall i\}$
-%            has dimension $1$. $\ket{\psi}$ is therefore up to a trivial phase unique.
-%            }
-%    \end{itemize}
-%
-%\end{frame}
-%}
-%
-%{
-%\begin{frame}{Some Notable Stabilizer States}
-%    \begin{itemize}
-%        \item{The state $\ket{\mbox{0b}00}$ is stabilized by 
-%            $\langle Z_0, Z_1\rangle$.}
-%        \item{Applying the Hadamard gate to the first qbit changes the state to
-%                $\frac{1}{\sqrt{2}}\left(\ket{\mbox{0b}00} + \ket{\mbox{0b}01}\right)$.
-%                This state is stabilized by 
-%                $\langle H_0 Z_0 H_0^\dagger, Z_1 \rangle = \langle X_0, Z_1 \rangle$.
-%                }
-%        \item{Applying a $CX_{1, 0}$ gate yields 
-%                $\frac{1}{\sqrt{2}}\left(\ket{\mbox{0b}00} + \ket{\mbox{0b}11}\right)$
-%                the famous EPR/Bell state which is stabilized by
-%                $\langle CX_{1, 0} X_0 CX_{1, 0}^\dagger, CX_{1, 0} Z_1 CX_{1, 0}^\dagger \rangle = \langle X_0 X_1, Z_0 Z_1 \rangle$.
-%                }
-%        \item{When measuring qbit $0$ the resulting state is either $\ket{\mbox{0b}00}$ or $\ket{\mbox{0b}11}$
-%            and the stabilizers are either $\langle Z_0, Z_1\rangle$ or $\langle -Z_0, -Z_1\rangle$.}
-%    \end{itemize}
-%\end{frame}
-%}
-%
-%{
-%\begin{frame}{Dynamics and Measurements}
-%    \begin{itemize}
-%        \item{In general a Clifford gate $U \in C_n$ will map a stabilizer state to another stabilizer state.
-%            The new state is stabilized by $\langle U S^{(i)} U^\dagger \rangle_i$.}
-%        \item{One can show that measurements of Pauli observables are covered by the stabilizer formalism.}
-%        \item{When measuring Pauli observable probability amplitudes of $0, 1$ or $\frac{1}{2}$ are
-%            possible.}
-%    \end{itemize}
-%\end{frame}
-%}
 
 {
 \begin{frame}{Graphical States}
@@ -402,53 +301,166 @@
             }
         \item{One can show that all stabilizer states can be brought into this form.}
         \item{For the derivation of the stabilizer and graphical states see my bachelor's thesis.}
-        %\item{The stabilizers of this state are $K_G^{(i)} = X_i \prod\limits_{\{i,j\} \in E} Z_j$.}
-        %\item{The stabilizers associated with $(V, E, O)$ are
-        %    \begin{equation}
-        %        \left\langle\left(\bigotimes\limits_{j=0}^{n-1} o_j \right) K_G^{(i)} \left(\bigotimes\limits_{j=0}^{n-1} o_j \right)^\dagger\right\rangle_i
-        %    \end{equation}
-        %    where
-        %    \begin{equation}
-        %        K_G^{(i)} = X_i \prod\limits_{\{i,j\} \in E} Z_j.
-        %    \end{equation}
-        %}
     \end{itemize}
-
 \end{frame}
 }
 
 {
-\begin{frame}{Counting Graphical States}
+\begin{frame}{Example: The $5$ Qbit EPR State}
+    
     \begin{itemize}
-        \item{Graphical states are finite and do not span a vector space.}
-        \item{There are $24$ local Clifford operators.}
-        \item{The amount of edges in a $n$ qbit state is $n^2 - n$.}
-        \item{For $n$ qbits there exist $24^n(n^2 - n)$ tuples $(V, E, O)$. But many of those states are equivalent.}
-        \item{There are fewer parameters that have to be updated under a quantum operation (see below).}
+        \item{Start from $\ket{0}^{\otimes n}$.}
+        \item{Get to the state $\ket{\psi} = \frac{\ket{0}^{\otimes n} + \ket{1}^{\otimes n}}{\sqrt{2}}$.}
+        \item{Use the circuit \\
+            \[
+            \Qcircuit @C=1em @R=.7em {
+            & \gate{H} & \ctrl{1} & \qw & \ctrl{2} & \qw & \ctrl{3} & \qw & \ctrl{4} &\qw \\
+            & \qw & \gate{X} & \qw & \qw & \qw & \qw & \qw & \qw &\qw \\
+            & \qw & \qw & \qw & \gate{X} & \qw & \qw & \qw & \qw &\qw \\
+            & \qw & \qw & \qw & \qw & \qw & \gate{X} & \qw & \qw &\qw \\
+            & \qw & \qw & \qw & \qw & \qw & \qw & \qw & \gate{X} &\qw \\
+            }
+            \]
+        }
+        \item{The state has the form
+            \begin{equation}
+                \ket{\psi} = \left(\prod\limits_{1 < i < 5} CX_{i,0}\right) H_0 \ket{0}.
+            \end{equation}}
     \end{itemize}
 \end{frame}
 }
 
+{
+\begin{frame}{Example: The $5$ Qbit EPR State}
+    \begin{itemize}
+        \item{$CX_{i,j} = H_i CZ_{i,j} H_i$.}
+        \item{The new circuit is
+            \[
+            \Qcircuit @C=1em @R=.7em {
+            & \gate{H} & \ctrl{1} & \qw & \ctrl{2} & \qw & \ctrl{3} & \qw & \ctrl{4} & \qw &\qw \\
+            & \gate{H} & \gate{Z} & \qw & \qw & \qw & \qw & \qw & \qw & \gate{H} &\qw \\
+            & \gate{H} & \qw & \qw & \gate{Z} & \qw & \qw & \qw & \qw & \gate{H} &\qw \\
+            & \gate{H} & \qw & \qw & \qw & \qw & \gate{Z} & \qw & \qw & \gate{H} &\qw \\
+            & \gate{H} & \qw & \qw & \qw & \qw & \qw & \qw & \gate{Z} & \gate{H} &\qw \\
+            }
+            \]
+        }
+        \item{Switching from starting state $\ket{0}^{\otimes n}$ to $\ket{+}^{\otimes n}$ gives the
+            graphical representation.}
+    \end{itemize}
+
+\end{frame}
+}
+{
+\begin{frame}{Example: The $5$ Qbit EPR State}
+    \noindent\begin{minipage}{0.4\textwidth}
+    \center
+    \adjustbox{max width=\textwidth}{
+            \Qcircuit @C=1em @R=.7em {
+            & \gate{H} & \ctrl{1} & \qw & \ctrl{2} & \qw & \ctrl{3} & \qw & \ctrl{4} &\qw \\
+            & \qw & \gate{X} & \qw & \qw & \qw & \qw & \qw & \qw &\qw \\
+            & \qw & \qw & \qw & \gate{X} & \qw & \qw & \qw & \qw &\qw \\
+            & \qw & \qw & \qw & \qw & \qw & \gate{X} & \qw & \qw &\qw \\
+            & \qw & \qw & \qw & \qw & \qw & \qw & \qw & \gate{X} &\qw \\
+            }
+    }\\
+    \begin{equation}
+    \begin{aligned}
+        \ket{\psi} &= \left(\prod\limits_{1 < i < 5} CX_{i,0}\right) H_0 \ket{0}^{\otimes n}\\
+    \end{aligned}
+    \end{equation}
+    \end{minipage} \hfill
+    \begin{minipage}{0.5\textwidth}
+    \center
+    \includegraphics[width=\textwidth, height=\textheight, keepaspectratio=true]{example_graphs/graph_EPR_state.png}
+    
+    The graphical state with $E =\{\{0,1\}, \{0,2\}, \{0,3\}, \{0,4\}\}$ and $O = (I, H, H, H, H)$.
+
+    \begin{equation}
+    \begin{aligned}
+        \ket{G} = \left(\prod\limits_{1 < i < 5} H_i\right) \left(\prod\limits_{1 < i < 5} CZ_{i,0}\right) \ket{+}^{\otimes n}
+    \end{aligned}
+    \end{equation}
+
+    \end{minipage} 
+\end{frame}
+}
 {
 \begin{frame}{Dynamics of Graphical States}
 \begin{itemize}
-    \item{Applying a local Clifford gate $U_i$ is trivial: 
-        Just the vertex operator is updated to $U o_i$.}
-    \item{If $o_a, o_b \in \{I, Z, R_\frac{\pi}{2}, R_\frac{\pi}{2}^\dagger\}$ applying a $CZ_{a,b}$
+    \item{
+    \noindent\begin{minipage}{0.4\textwidth}
+        Applying a local Clifford gate $U_i$ is trivial: 
+        Just the vertex operator is updated to $U o_i$.
+    \end{minipage} \hfill
+    \begin{minipage}{0.5\textwidth}
+        \tikzmark{left}Apply $SH = R_{\frac{\pi}{2}}H$ to qbit $2$:\\
+        \includegraphics[width=\textwidth, height=\textheight, keepaspectratio=true]{example_graphs/graph_update_VOP.png}\tikzmark{right}
+        \DrawBox
+    \end{minipage}
+    }
+    \item{
+    \noindent\begin{minipage}{0.4\textwidth}
+    If $o_a, o_b \in \{I, Z, R_\frac{\pi}{2}, R_\frac{\pi}{2}^\dagger\}$ applying a $CZ_{a,b}$
     just toggles the edge $\{a,b\}$ in $E$.%: $E' = E \Delta \{\{a,b\}\}$.
     %With the symmetric set difference $\Delta$.
+    \end{minipage} \hfill
+    \begin{minipage}{0.5\textwidth}
+        \tikzmark{left}Apply $CZ_{2,0}$:\\
+        \includegraphics[width=\textwidth, height=\textheight, keepaspectratio=true]{example_graphs/graph_apply_CZ.png}\hfill\tikzmark{right}
+        \DrawBox
+    \end{minipage}
     }
-    \item{If the vertices $a, b$ are isolated the resulting state after
-        applying $CZ_{a,b}$ can be precomputed. }
+            
 \end{itemize}
 \end{frame}
 }
 {
 \begin{frame}{Dynamics of Graphical States}
 \begin{itemize}
-    \item{When the VOPs do not commute with $CZ$ and the vertices are not isolated one can clear at least one
-        vertex operator (i.e. transforming it to $I$).}
-    \item{If both vertex operators can be cleared $\{a,b\}$ is toggled in $E$.
+    \item{
+    \noindent\begin{minipage}{0.4\textwidth}
+        If the vertices $a, b$ are isolated the resulting state after
+        applying $CZ_{a,b}$ can be precomputed. 
+    \end{minipage} \hfill
+    \begin{minipage}{0.5\textwidth}
+        \tikzmark{left}Before:\\
+        \includegraphics[width=\textwidth, height=0.3\textheight, keepaspectratio=true]{example_graphs/graph_two_qbit_CZ_before.png}\\
+        After:\\
+        \includegraphics[width=0.5\textwidth, height=0.3\textheight, keepaspectratio=true]{example_graphs/graph_two_qbit_CZ_after.png}\hfill\tikzmark{right}
+        \DrawBox
+    \end{minipage}
+    }
+    \item{
+
+        \noindent\begin{minipage}{0.4\textwidth}
+        When the VOPs do not commute with $CZ$ and the vertices are not isolated one can clear at least one
+        vertex operator (i.e. transforming it to $I$). This changes the neighbourhood of the vertices.
+        \end{minipage} \hfill
+        \begin{minipage}{0.5\textwidth}
+            \tikzmark{left}The starting state:\\
+            \includegraphics[width=0.7\textwidth, height=0.5\textheight, keepaspectratio=true]{example_graphs/graph_clear_VOPs_CZ_before.png}\hfill\tikzmark{right}
+            \DrawBox
+        \end{minipage}
+        }
+\end{itemize}
+\end{frame}
+}
+{
+\begin{frame}{Dynamics of Graphical States}
+\begin{itemize}
+    \item{
+        If both vertex operators can be cleared $\{a,b\}$ is toggled in $E$.
+    \noindent\begin{minipage}{0.4\textwidth}
+        \tikzmark{left}After clearing vertices $1,2$:\\
+        \includegraphics[width=0.7\textwidth, height=0.5\textheight, keepaspectratio=true]{example_graphs/graph_clear_VOPs_CZ_cleared.png}\hfill\tikzmark{right}
+        \DrawBox
+    \end{minipage} \hfill
+    \begin{minipage}{0.4\textwidth}
+        \tikzmark{left}Applying $CZ_{2, 1}$:\\
+        \includegraphics[width=0.7\textwidth, height=0.5\textheight, keepaspectratio=true]{example_graphs/graph_clear_VOPs_CZ_after.png}\tikzmark{right}
+        \DrawBox
+    \end{minipage}
         }
     \item{
         If just one vertex operator has been cleared the other vertex is isolated
@@ -457,151 +469,7 @@
 \end{frame}
 }
 
-{
-\begin{frame}{Clearing Vertex Operators}
-    \begin{itemize}
-        \item{One can show that for a non-isolated vertex $j$
-            the unitary $M_j = \sqrt{-iX_j} \prod\limits_{\{l,j\} \in E} \sqrt{iZ_l}$
-            when applied to a graphical state with $O = \{I, ..., I\}$ toggles the neighbourhood
-            of $j$.}
-        \item{The operation $L_j$ which simultaneously toggles the neighbourhood of $j$ and right-multiplies
-            $M_j^\dagger$ to the vertex operators keeps the state $\ket{G}$ invariant.}
-        \item{The group $C_1$ is generated by $\sqrt{-iX}, \sqrt{iZ}$. 
-            Any $U \in C_1$ is the product of at most $5$ of those matrices.
-            }
-        \item{
-            Let $a$ be the vertex to be cleared. Then there is one neighbour $j \neq b$ of $a$.
-            Clearing the vertex operator $o_a$ is done by moving from right to left through the product 
-            and applying
 
-            \begin{itemize}
-                \item{$L_a$ if the current matrix is $\sqrt{-iX}$ or}
-                \item{$L_j$ if the current matrix is $\sqrt{iZ}$.}
-            \end{itemize}
-
-            }
-    \end{itemize}
-\end{frame}
-}
-
-{
-\begin{frame}{Clearing VOPs: Example}
-    \noindent\begin{minipage}{0.5\textwidth}
-    \includegraphics[width=\textwidth]{graphs/clear_vop_01.png}
-    \end{minipage} \hfill
-    \begin{minipage}{0.4\textwidth}
-    Vertex operator \\
-    $19 = \left[\begin{matrix}\frac{\sqrt{2}}{2} & \frac{\sqrt{2} i}{2}\\- \frac{\sqrt{2} i}{2} & - \frac{\sqrt{2}}{2}\end{matrix}\right]$\\
-    $19 = \sqrt{iZ}^2\sqrt{-iX}^3$
-    \end{minipage}
-    \noindent\begin{minipage}{0.5\textwidth}
-    \includegraphics[width=\textwidth]{graphs/clear_vop_02.png}
-    \end{minipage} \hfill
-    \begin{minipage}{0.4\textwidth}
-    Vertex operator \\
-    $ 21 = \left[\begin{matrix}0 & -1\\1 & 0\end{matrix}\right]$\\
-    $ 21 = \sqrt{iZ}^2\sqrt{-iX}^2$
-    \end{minipage}
-\end{frame}
-}
-{
-\begin{frame}{Clearing VOPs: Example}
-    \noindent\begin{minipage}{0.5\textwidth}
-    \includegraphics[width=\textwidth]{graphs/clear_vop_02.png}
-    \end{minipage} \hfill
-    \begin{minipage}{0.4\textwidth}
-    Vertex operator \\
-    $ 21 = \left[\begin{matrix}0 & -1\\1 & 0\end{matrix}\right]$\\
-    $ 21 = \sqrt{iZ}^2\sqrt{-iX}^2$
-    \end{minipage}
-    \noindent\begin{minipage}{0.5\textwidth}
-    \includegraphics[width=\textwidth]{graphs/clear_vop_03.png}
-    \end{minipage} \hfill
-    \begin{minipage}{0.4\textwidth}
-    Vertex operator \\
-    $11 = \left[\begin{matrix}\frac{\sqrt{2}}{2} & - \frac{\sqrt{2} i}{2}\\\frac{\sqrt{2} i}{2} & - \frac{\sqrt{2}}{2}\end{matrix}\right]$\\
-    $11 = \sqrt{iZ}^2\sqrt{-iX}$
-    \end{minipage}
-\end{frame}
-}
-{
-\begin{frame}{Clearing VOPs: Example}
-    \noindent\begin{minipage}{0.5\textwidth}
-    \includegraphics[width=\textwidth]{graphs/clear_vop_03.png}
-    \end{minipage} \hfill
-    \begin{minipage}{0.4\textwidth}
-    Vertex operator \\
-    $11 = \left[\begin{matrix}\frac{\sqrt{2}}{2} & - \frac{\sqrt{2} i}{2}\\\frac{\sqrt{2} i}{2} & - \frac{\sqrt{2}}{2}\end{matrix}\right]$\\
-    $11 = \sqrt{iZ}^2\sqrt{-iX}$
-    \end{minipage}
-    \noindent\begin{minipage}{0.5\textwidth}
-    \includegraphics[width=\textwidth]{graphs/clear_vop_04.png}
-    \end{minipage} \hfill
-    \begin{minipage}{0.4\textwidth}
-    Vertex operator \\
-    $5 = \left[\begin{matrix}1 & 0\\0 & -1\end{matrix}\right]$\\
-    $5 = \sqrt{iZ}^2$
-    \end{minipage}
-\end{frame}
-}
-{
-\begin{frame}{Clearing VOPs: Example}
-    \noindent\begin{minipage}{0.5\textwidth}
-    \includegraphics[width=\textwidth]{graphs/clear_vop_04.png}
-    \end{minipage} \hfill
-    \begin{minipage}{0.4\textwidth}
-    Vertex operator \\
-    $5 = \left[\begin{matrix}1 & 0\\0 & -1\end{matrix}\right]$\\
-    $5 = \sqrt{iZ}^2$
-    \end{minipage}
-    \noindent\begin{minipage}{0.5\textwidth}
-    \includegraphics[width=\textwidth]{graphs/clear_vop_05.png}
-    \end{minipage} \hfill
-    \begin{minipage}{0.4\textwidth}
-    Vertex operator \\
-    $ 7 = \left[\begin{matrix}\frac{\sqrt{2}}{2} & - \frac{\sqrt{2}}{2}\\\frac{\sqrt{2}}{2} & \frac{\sqrt{2}}{2}\end{matrix}\right]$\\
-    $7 = \sqrt{iZ}$
-    \end{minipage}
-\end{frame}
-}
-{
-\begin{frame}{Clearing VOPs: Example}
-    \noindent\begin{minipage}{0.5\textwidth}
-    \includegraphics[width=\textwidth]{graphs/clear_vop_05.png}
-    \end{minipage} \hfill
-    \begin{minipage}{0.4\textwidth}
-    Vertex operator \\
-    $ 7 = \left[\begin{matrix}\frac{\sqrt{2}}{2} & - \frac{\sqrt{2}}{2}\\\frac{\sqrt{2}}{2} & \frac{\sqrt{2}}{2}\end{matrix}\right]$\\
-    $7 = \sqrt{iZ}$
-    \end{minipage}
-    \noindent\begin{minipage}{0.5\textwidth}
-    \includegraphics[width=\textwidth]{graphs/clear_vop_06.png}
-    \end{minipage} \hfill
-    \begin{minipage}{0.4\textwidth}
-    Vertex operator \\
-    $2 = \left[\begin{matrix}1 & 0\\0 & 1\end{matrix}\right]$\\
-    \end{minipage}
-\end{frame}
-}
-{
-\begin{frame}{Clearing VOPs: Example}
-    \noindent\begin{minipage}{0.5\textwidth}
-    \includegraphics[width=\textwidth]{graphs/clear_vop_01.png}
-    \end{minipage} \hfill
-    \begin{minipage}{0.4\textwidth}
-    Vertex operator \\
-    $19 = \left[\begin{matrix}\frac{\sqrt{2}}{2} & \frac{\sqrt{2} i}{2}\\- \frac{\sqrt{2} i}{2} & - \frac{\sqrt{2}}{2}\end{matrix}\right]$\\
-    $19 = \sqrt{iZ}^2\sqrt{-iX}^3$
-    \end{minipage}
-    \noindent\begin{minipage}{0.5\textwidth}
-    \includegraphics[width=\textwidth]{graphs/clear_vop_06.png}
-    \end{minipage} \hfill
-    \begin{minipage}{0.4\textwidth}
-    Vertex operator \\
-    $2 = \left[\begin{matrix}1 & 0\\0 & 1\end{matrix}\right]$
-    \end{minipage}
-\end{frame}
-}
 \section{Implementation and Performance}
 
 {