a lot of work on the presentation
This commit is contained in:
parent
c4c5e88b8f
commit
91577ef2b6
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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))
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 12 KiB |
|
|
@ -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)
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 14 KiB |
|
|
@ -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)
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 31 KiB |
|
|
@ -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)
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 27 KiB |
|
|
@ -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)
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 32 KiB |
|
|
@ -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)
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 8.2 KiB |
|
|
@ -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)
|
||||
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 7.6 KiB |
|
|
@ -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)
|
||||
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 18 KiB |
|
|
@ -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)
|
||||
|
|
@ -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}
|
||||
|
||||
{
|
||||
|
|
|
|||
Loading…
Reference in New Issue