performance/plot_scaling_qbits_linear.py

@@ -3,9 +3,6 @@ import matplotlib
 import numpy as np
 import json
 
-matplotlib.rc('font', **{'family': 'serif', 'serif': ['Computer Modern']})
-matplotlib.rc('text', usetex=True)
-
 matplotlib.rcParams.update({'errorbar.capsize': 2})
 
 results_naive = np.genfromtxt("qbit_scaling_naive.csv")
@@ -14,18 +11,18 @@ with open("qbit_scaling_meta.json") as fin:
     meta = json.load(fin)
 
 
-h0 = plt.errorbar(results_naive[:, 0], results_naive[:, 2]*1000, results_naive[:, 3]*1000
+h0 = plt.errorbar(results_naive[:, 0], results_naive[:, 2], results_naive[:, 3]
                 , label=f"Dense Vector Simulator $N_c={int(results_naive[:, 1][0])}$ Circuits"
                 , marker="o"
                 , color="black")
-h1 = plt.errorbar(results_graph[:, 0], results_graph[:, 2]*1000, results_graph[:, 3]*1000
+h1 = plt.errorbar(results_graph[:, 0], results_graph[:, 2], results_graph[:, 3]
                 , label=f"Graphical Simulator $N_c={int(results_graph[:, 1][0])}$ Circuits"
                 , marker="^"
                 , color="black")
 
 plt.legend(handles=[h0, h1])
 plt.xlabel("Number of Qbits $N_q$")
-plt.ylabel("Execution Time per Circuit [ms]")
+plt.ylabel("Execution Time per Circuit [s]")
 plt.title(f"Execution Time for ${meta['ngates_per_qbit']}\\times N_q$ Gates with Random Circuits (Rescaled)")
 
 plt.savefig("scaling_qbits_linear.png", dpi=400)

performance/plot_scaling_qbits_log.py

@@ -3,9 +3,6 @@ import matplotlib
 import numpy as np
 import json
 
-matplotlib.rc('font', **{'family': 'serif', 'serif': ['Computer Modern']})
-matplotlib.rc('text', usetex=True)
-
 matplotlib.rcParams.update({'errorbar.capsize': 2})
 
 results_naive = np.genfromtxt("qbit_scaling_naive.csv")

performance/qbit_scaling_graph.csv

@@ -1,12 +1,12 @@
-4.000000000000000000e+00 5.000000000000000000e+01 3.484509700274429590e-04 9.681730019426008163e-07
-5.000000000000000000e+00 5.000000000000000000e+01 3.547070120002899260e-04 9.733495917822248312e-07
-6.000000000000000000e+00 5.000000000000000000e+01 3.644156266606539646e-04 8.595537339256123852e-07
-7.000000000000000000e+00 5.000000000000000000e+01 3.754197057086067777e-04 1.223686105133776916e-06
-8.000000000000000000e+00 5.000000000000000000e+01 3.907352674923458922e-04 1.315732635550278415e-06
-9.000000000000000000e+00 5.000000000000000000e+01 4.001314888854621372e-04 1.049960208967149392e-06
-1.000000000000000000e+01 5.000000000000000000e+01 4.195807880005304595e-04 1.334920356876227909e-06
-1.100000000000000000e+01 5.000000000000000000e+01 4.363701709073873071e-04 1.471394078704268421e-06
-1.200000000000000000e+01 5.000000000000000000e+01 4.579273133367678362e-04 1.285867017818870099e-06
-1.300000000000000000e+01 5.000000000000000000e+01 4.767101661505316278e-04 1.872249450138078510e-06
-1.400000000000000000e+01 5.000000000000000000e+01 5.013123571461619967e-04 2.227174447433320657e-06
-1.500000000000000000e+01 5.000000000000000000e+01 5.362610986679404706e-04 2.000896704568743328e-06
+4.000000000000000000e+00 5.000000000000000000e+01 3.429655850231938768e-04 3.964784429570424898e-07
+5.000000000000000000e+00 5.000000000000000000e+01 3.475331880617887111e-04 6.532202621031675207e-07
+6.000000000000000000e+00 5.000000000000000000e+01 3.569947167003799425e-04 6.858285888009526683e-07
+7.000000000000000000e+00 5.000000000000000000e+01 3.670373971337019710e-04 8.737464017398305182e-07
+8.000000000000000000e+00 5.000000000000000000e+01 3.798681950138416120e-04 8.880263000414631264e-07
+9.000000000000000000e+00 5.000000000000000000e+01 3.896756644503006329e-04 8.241847954707531607e-07
+1.000000000000000000e+01 5.000000000000000000e+01 4.098476440485683504e-04 1.154128418230815053e-06
+1.100000000000000000e+01 5.000000000000000000e+01 4.220041636488697039e-04 1.070578629651815833e-06
+1.200000000000000000e+01 5.000000000000000000e+01 4.430631950223565502e-04 1.530158225225066135e-06
+1.300000000000000000e+01 5.000000000000000000e+01 4.633520061347204356e-04 1.692271924113339457e-06
+1.400000000000000000e+01 5.000000000000000000e+01 4.852215242759225157e-04 1.838279848627781220e-06
+1.500000000000000000e+01 5.000000000000000000e+01 5.214459826529491832e-04 1.847875920612266566e-06

performance/qbit_scaling_naive.csv

@@ -1,12 +1,12 @@
-4.000000000000000000e+00 5.000000000000000000e+01 5.742717300199728621e-04 1.376083459359969811e-06
-5.000000000000000000e+00 5.000000000000000000e+01 5.856804319919319077e-04 1.145342547345569258e-06
-6.000000000000000000e+00 5.000000000000000000e+01 6.073178133131781030e-04 1.301510871683869304e-06
-7.000000000000000000e+00 5.000000000000000000e+01 6.544547342881350217e-04 1.225000970214631633e-06
-8.000000000000000000e+00 5.000000000000000000e+01 6.991200974925959339e-04 1.113213974802071661e-06
-9.000000000000000000e+00 5.000000000000000000e+01 7.872913288964710063e-04 1.773735728592762829e-06
-1.000000000000000000e+01 5.000000000000000000e+01 9.519731820055313612e-04 1.663559103282315900e-06
-1.100000000000000000e+01 5.000000000000000000e+01 1.298034858179810411e-03 3.258549538096835914e-06
-1.200000000000000000e+01 5.000000000000000000e+01 1.977239334996738675e-03 6.361955627923420395e-06
-1.300000000000000000e+01 5.000000000000000000e+01 3.386829553853133983e-03 1.045062312440070923e-05
-1.400000000000000000e+01 5.000000000000000000e+01 6.018249490002096878e-03 1.923587672545671009e-05
-1.500000000000000000e+01 5.000000000000000000e+01 1.119012055732916157e-02 4.010852629378700983e-05
+4.000000000000000000e+00 5.000000000000000000e+01 5.892368650893331028e-04 9.659514404922622761e-07
+5.000000000000000000e+00 5.000000000000000000e+01 6.003430280397878665e-04 1.065010131039797397e-06
+6.000000000000000000e+00 5.000000000000000000e+01 6.182032666644470377e-04 8.375309081009639130e-07
+7.000000000000000000e+00 5.000000000000000000e+01 6.621159000392905052e-04 1.116822172068341379e-06
+8.000000000000000000e+00 5.000000000000000000e+01 7.066036874857672999e-04 1.045121177378059615e-06
+9.000000000000000000e+00 5.000000000000000000e+01 7.926702222660727193e-04 1.521812902193708585e-06
+1.000000000000000000e+01 5.000000000000000000e+01 9.538586060516536600e-04 2.519431877046405846e-06
+1.100000000000000000e+01 5.000000000000000000e+01 1.276251990916948053e-03 3.274849717186824768e-06
+1.200000000000000000e+01 5.000000000000000000e+01 1.937763718330339988e-03 5.380974020943288937e-06
+1.300000000000000000e+01 5.000000000000000000e+01 3.305397004615559520e-03 1.094398743059485016e-05
+1.400000000000000000e+01 5.000000000000000000e+01 5.888714548590152226e-03 1.961078728083609431e-05
+1.500000000000000000e+01 5.000000000000000000e+01 1.090257817468470031e-02 3.954920246897699910e-05

performance/regimes/circuit_scaling_graph0.csv

@@ -1,44 +1,48 @@
-4.000000000000000000e+02 5.000000000000000000e+01 1.931225240095955009e-03 2.112013598717693821e-06
-4.500000000000000000e+02 5.000000000000000000e+01 2.111660479913552921e-03 2.847137081085609582e-06
-5.000000000000000000e+02 5.000000000000000000e+01 2.288848419921123492e-03 3.832802132508893657e-06
-5.500000000000000000e+02 5.000000000000000000e+01 2.476271999912569351e-03 3.146788456997646563e-06
-6.000000000000000000e+02 5.000000000000000000e+01 2.658127619997685716e-03 4.913056949652575384e-06
-6.500000000000000000e+02 5.000000000000000000e+01 2.843284639984631004e-03 5.988713071469712405e-06
-7.000000000000000000e+02 5.000000000000000000e+01 3.037242280024657001e-03 9.398645711837915070e-06
-7.500000000000000000e+02 5.000000000000000000e+01 3.263561659914557787e-03 2.474029637956172832e-05
-8.000000000000000000e+02 5.000000000000000000e+01 3.442404479992547048e-03 1.388115551910614284e-05
-8.500000000000000000e+02 5.000000000000000000e+01 3.699283740061218729e-03 2.646058029581309463e-05
-9.000000000000000000e+02 5.000000000000000000e+01 3.961829300078534115e-03 3.594241075191235751e-05
-9.500000000000000000e+02 5.000000000000000000e+01 4.313467119991401012e-03 5.795120372566926352e-05
-1.000000000000000000e+03 5.000000000000000000e+01 4.756924480007001209e-03 9.754210278672716388e-05
-1.050000000000000000e+03 5.000000000000000000e+01 5.048975600057019515e-03 9.832522057125359517e-05
-1.100000000000000000e+03 5.000000000000000000e+01 6.053356180000264014e-03 2.154349749321923476e-04
-1.150000000000000000e+03 5.000000000000000000e+01 6.894734680081456013e-03 3.606662590763895114e-04
-1.200000000000000000e+03 5.000000000000000000e+01 8.244570780007051680e-03 3.822308048345223288e-04
-1.250000000000000000e+03 5.000000000000000000e+01 9.553718940042017424e-03 5.302240688915590538e-04
-1.300000000000000000e+03 5.000000000000000000e+01 1.184980282003380084e-02 6.864058991245668585e-04
-1.350000000000000000e+03 5.000000000000000000e+01 1.417426442005307805e-02 8.741447240916265949e-04
-1.400000000000000000e+03 5.000000000000000000e+01 1.690690740002537620e-02 1.359623862012657777e-03
-1.450000000000000000e+03 5.000000000000000000e+01 2.352294856003936743e-02 1.643019317463906412e-03
-1.500000000000000000e+03 5.000000000000000000e+01 2.400547499995809783e-02 1.370994356865607106e-03
-1.550000000000000000e+03 5.000000000000000000e+01 3.000968385991654996e-02 1.694501521012075880e-03
-1.600000000000000000e+03 5.000000000000000000e+01 3.971789155988517117e-02 2.626076563300825013e-03
-1.650000000000000000e+03 5.000000000000000000e+01 5.087850068002808257e-02 2.183236898913883724e-03
-1.700000000000000000e+03 5.000000000000000000e+01 5.476505484008157426e-02 2.516891357755131342e-03
-1.750000000000000000e+03 5.000000000000000000e+01 6.191398139997545541e-02 3.556265728489130425e-03
-1.800000000000000000e+03 5.000000000000000000e+01 7.233656460004567190e-02 3.437157773249340138e-03
-1.850000000000000000e+03 5.000000000000000000e+01 8.504432361994986034e-02 3.693492224497613684e-03
-1.900000000000000000e+03 5.000000000000000000e+01 9.935499721992528677e-02 4.847772431507223374e-03
-1.950000000000000000e+03 5.000000000000000000e+01 1.146372398200401210e-01 4.894725406007245129e-03
-2.000000000000000000e+03 5.000000000000000000e+01 1.263222946400128499e-01 5.192728387072775495e-03
-2.050000000000000000e+03 5.000000000000000000e+01 1.392392367200045444e-01 5.543183168345876440e-03
-2.100000000000000000e+03 5.000000000000000000e+01 1.569292686599874365e-01 5.339760822306610644e-03
-2.150000000000000000e+03 5.000000000000000000e+01 1.698793484200541437e-01 5.850179759695975888e-03
-2.200000000000000000e+03 5.000000000000000000e+01 1.908933651599909465e-01 6.013030767869216933e-03
-2.250000000000000000e+03 5.000000000000000000e+01 2.138584588800222230e-01 6.246981714487595365e-03
-2.300000000000000000e+03 5.000000000000000000e+01 2.357358600800034676e-01 7.243216183112379664e-03
-2.350000000000000000e+03 5.000000000000000000e+01 2.531458577800731469e-01 7.701709672430835998e-03
-2.400000000000000000e+03 5.000000000000000000e+01 2.713865468400035730e-01 8.767331273014544735e-03
-2.450000000000000000e+03 5.000000000000000000e+01 2.981100642999808814e-01 8.410889362921478846e-03
-2.500000000000000000e+03 5.000000000000000000e+01 3.260302986400347436e-01 9.238400765371558576e-03
-2.550000000000000000e+03 5.000000000000000000e+01 3.507109312400097934e-01 8.723097508660151295e-03
+4.000000000000000000e+02 1.000000000000000000e+02 1.878297269940958384e-03 1.469699604704835522e-06
+4.500000000000000000e+02 1.000000000000000000e+02 2.055278760053624865e-03 1.715237596259608518e-06
+5.000000000000000000e+02 1.000000000000000000e+02 2.220861629939463629e-03 1.945376780331531752e-06
+5.500000000000000000e+02 1.000000000000000000e+02 2.415533940038585691e-03 3.703603558244418543e-06
+6.000000000000000000e+02 1.000000000000000000e+02 2.588112829980673216e-03 3.987060218289845164e-06
+6.500000000000000000e+02 1.000000000000000000e+02 2.761849560047267057e-03 3.981340552536311654e-06
+7.000000000000000000e+02 1.000000000000000000e+02 2.950303999969037302e-03 5.917667108000479223e-06
+7.500000000000000000e+02 1.000000000000000000e+02 3.159523300018918148e-03 1.023882160212621164e-05
+8.000000000000000000e+02 1.000000000000000000e+02 3.359561679935723234e-03 1.224085947659805602e-05
+8.500000000000000000e+02 1.000000000000000000e+02 3.626898989969049372e-03 2.129400040479119394e-05
+9.000000000000000000e+02 1.000000000000000000e+02 3.841637020050256771e-03 2.434921819346224365e-05
+9.500000000000000000e+02 1.000000000000000000e+02 4.171545780045562458e-03 3.666930452842941443e-05
+1.000000000000000000e+03 1.000000000000000000e+02 4.603988039816613378e-03 6.082264928340738172e-05
+1.050000000000000000e+03 1.000000000000000000e+02 5.112743269783095491e-03 9.611161984726047567e-05
+1.100000000000000000e+03 1.000000000000000000e+02 5.897319330142636144e-03 1.576824434319171338e-04
+1.150000000000000000e+03 1.000000000000000000e+02 6.631839999936346014e-03 2.091483361039986474e-04
+1.200000000000000000e+03 1.000000000000000000e+02 7.897017169780156179e-03 2.801692486183573810e-04
+1.250000000000000000e+03 1.000000000000000000e+02 9.044396739882358191e-03 2.748119728933274457e-04
+1.300000000000000000e+03 1.000000000000000000e+02 1.131971647970203727e-02 4.650817747928799204e-04
+1.350000000000000000e+03 1.000000000000000000e+02 1.478023339011997478e-02 7.016754168579358852e-04
+1.400000000000000000e+03 1.000000000000000000e+02 1.734726401005900684e-02 7.951340541898133021e-04
+1.450000000000000000e+03 1.000000000000000000e+02 2.102190037010586918e-02 1.002624218122781909e-03
+1.500000000000000000e+03 1.000000000000000000e+02 2.402437226992333238e-02 1.037823513475687100e-03
+1.550000000000000000e+03 1.000000000000000000e+02 3.051912467017246083e-02 1.168558928642808798e-03
+1.600000000000000000e+03 1.000000000000000000e+02 3.283033068997610882e-02 1.249844785100136550e-03
+1.650000000000000000e+03 1.000000000000000000e+02 4.531796266983292160e-02 1.759917786033934287e-03
+1.700000000000000000e+03 1.000000000000000000e+02 5.165379479996772688e-02 1.799192348621859701e-03
+1.750000000000000000e+03 1.000000000000000000e+02 6.068050979989493554e-02 2.315898416538343142e-03
+1.800000000000000000e+03 1.000000000000000000e+02 6.786087045005842477e-02 2.260252367511322510e-03
+1.850000000000000000e+03 1.000000000000000000e+02 8.373902886007272839e-02 2.654447861473096301e-03
+1.900000000000000000e+03 1.000000000000000000e+02 9.122002596010134190e-02 2.613980352536835351e-03
+1.950000000000000000e+03 1.000000000000000000e+02 1.087346132399034104e-01 3.130771289811267507e-03
+2.000000000000000000e+03 1.000000000000000000e+02 1.181711647100382873e-01 3.234989605282795420e-03
+2.050000000000000000e+03 1.000000000000000000e+02 1.346470424801373134e-01 4.163674923361087264e-03
+2.100000000000000000e+03 1.000000000000000000e+02 1.546626253095746417e-01 4.494893701434156223e-03
+2.150000000000000000e+03 1.000000000000000000e+02 1.646854265300135012e-01 4.091584128325677014e-03
+2.200000000000000000e+03 1.000000000000000000e+02 1.900906667797608030e-01 4.732069261775800027e-03
+2.250000000000000000e+03 1.000000000000000000e+02 2.079606859297200572e-01 4.779788452055614388e-03
+2.300000000000000000e+03 1.000000000000000000e+02 2.315051704902725827e-01 5.636123702875270834e-03
+2.350000000000000000e+03 1.000000000000000000e+02 2.495618172797549050e-01 5.018548718196205044e-03
+2.400000000000000000e+03 1.000000000000000000e+02 2.720929994599646240e-01 5.121098331551519889e-03
+2.450000000000000000e+03 1.000000000000000000e+02 2.855364293801903597e-01 5.864504716311486239e-03
+2.500000000000000000e+03 1.000000000000000000e+02 3.189779279900540332e-01 5.760209798368623457e-03
+2.550000000000000000e+03 1.000000000000000000e+02 3.334914251402005814e-01 6.504656122683366223e-03
+2.600000000000000000e+03 1.000000000000000000e+02 3.574019711399887278e-01 6.211228761635085791e-03
+2.650000000000000000e+03 1.000000000000000000e+02 3.789796420900893303e-01 5.768871972682301959e-03
+2.700000000000000000e+03 1.000000000000000000e+02 4.099927911701161110e-01 6.379357717969649441e-03
+2.750000000000000000e+03 1.000000000000000000e+02 4.301786762999472713e-01 7.305549794887298935e-03

performance/regimes/circuit_scaling_graph1.csv

@@ -1,44 +1,48 @@
-4.000000000000000000e+02 5.000000000000000000e+01 1.707738740005879585e-03 7.100286700408404613e-06
-4.500000000000000000e+02 5.000000000000000000e+01 1.906502640049438820e-03 9.853300832137104791e-06
-5.000000000000000000e+02 5.000000000000000000e+01 2.194008100050268747e-03 2.225048323246775191e-05
-5.500000000000000000e+02 5.000000000000000000e+01 2.483741079940955578e-03 2.902929435898853839e-05
-6.000000000000000000e+02 5.000000000000000000e+01 2.970475479905871751e-03 5.357547401616545894e-05
-6.500000000000000000e+02 5.000000000000000000e+01 3.360749460098304622e-03 7.760192059341477707e-05
-7.000000000000000000e+02 5.000000000000000000e+01 4.184713580034440245e-03 1.257844672870958591e-04
-7.500000000000000000e+02 5.000000000000000000e+01 5.004965839962096513e-03 1.756539085744744525e-04
-8.000000000000000000e+02 5.000000000000000000e+01 5.734667459946649927e-03 1.910387597965613972e-04
-8.500000000000000000e+02 5.000000000000000000e+01 7.131355419896862752e-03 1.934052327071289392e-04
-9.000000000000000000e+02 5.000000000000000000e+01 8.802635380070568394e-03 3.408876648940773542e-04
-9.500000000000000000e+02 5.000000000000000000e+01 1.094996251993506954e-02 3.780652528111945248e-04
-1.000000000000000000e+03 5.000000000000000000e+01 1.176883709997127853e-02 3.875201443014548758e-04
-1.050000000000000000e+03 5.000000000000000000e+01 1.426043346002188635e-02 4.682970383390439679e-04
-1.100000000000000000e+03 5.000000000000000000e+01 1.606511461995978676e-02 4.821875787626857496e-04
-1.150000000000000000e+03 5.000000000000000000e+01 1.810014320004484090e-02 5.439479727767238936e-04
-1.200000000000000000e+03 5.000000000000000000e+01 2.132428097998854272e-02 5.977411510180347153e-04
-1.250000000000000000e+03 5.000000000000000000e+01 2.537384307997854124e-02 6.676700647178173504e-04
-1.300000000000000000e+03 5.000000000000000000e+01 2.700082207993546174e-02 6.834614338333218136e-04
-1.350000000000000000e+03 5.000000000000000000e+01 2.877831694000633489e-02 6.806464215638255433e-04
-1.400000000000000000e+03 5.000000000000000000e+01 3.247053898001468070e-02 7.730662439967084590e-04
-1.450000000000000000e+03 5.000000000000000000e+01 3.598561208000319173e-02 8.005966432160921409e-04
-1.500000000000000000e+03 5.000000000000000000e+01 3.962553389999811521e-02 9.617593729943524914e-04
-1.550000000000000000e+03 5.000000000000000000e+01 4.163353030004145888e-02 9.548479191853584576e-04
-1.600000000000000000e+03 5.000000000000000000e+01 4.562790117995973310e-02 7.835441508272948316e-04
-1.650000000000000000e+03 5.000000000000000000e+01 4.898105746005967237e-02 8.710963335263738599e-04
-1.700000000000000000e+03 5.000000000000000000e+01 5.169834830003310067e-02 9.651211683144866882e-04
-1.750000000000000000e+03 5.000000000000000000e+01 5.374540261993388662e-02 1.000999207215783841e-03
-1.800000000000000000e+03 5.000000000000000000e+01 6.012160696005594551e-02 9.086338428378314819e-04
-1.850000000000000000e+03 5.000000000000000000e+01 6.043908248007937717e-02 1.230395679723121118e-03
-1.900000000000000000e+03 5.000000000000000000e+01 6.464911280001615912e-02 8.604282740948831793e-04
-1.950000000000000000e+03 5.000000000000000000e+01 6.818929374001526933e-02 1.115434394007077832e-03
-2.000000000000000000e+03 5.000000000000000000e+01 7.424652839998088782e-02 1.071955559986128735e-03
-2.050000000000000000e+03 5.000000000000000000e+01 7.574371884000356825e-02 9.012814866758098739e-04
-2.100000000000000000e+03 5.000000000000000000e+01 8.000210310005058389e-02 1.157114746495429376e-03
-2.150000000000000000e+03 5.000000000000000000e+01 8.131804838001699398e-02 1.246651522871319254e-03
-2.200000000000000000e+03 5.000000000000000000e+01 8.642062879996956215e-02 1.198064886081493755e-03
-2.250000000000000000e+03 5.000000000000000000e+01 9.114948505999563577e-02 8.960646114521502153e-04
-2.300000000000000000e+03 5.000000000000000000e+01 9.217601664009635043e-02 9.503993848618267530e-04
-2.350000000000000000e+03 5.000000000000000000e+01 9.563625923990912159e-02 1.108765711978444571e-03
-2.400000000000000000e+03 5.000000000000000000e+01 1.013627541600544690e-01 1.295486325060567429e-03
-2.450000000000000000e+03 5.000000000000000000e+01 1.034756118799668861e-01 1.204635265310459924e-03
-2.500000000000000000e+03 5.000000000000000000e+01 1.065721216400379451e-01 9.677911226791394888e-04
-2.550000000000000000e+03 5.000000000000000000e+01 1.141797984599725174e-01 1.006250648249219911e-03
+4.000000000000000000e+02 1.000000000000000000e+02 1.674102860051789347e-03 6.228299552356924658e-06
+4.500000000000000000e+02 1.000000000000000000e+02 1.903562340048665577e-03 1.316833211606872975e-05
+5.000000000000000000e+02 1.000000000000000000e+02 2.123120620053669041e-03 1.197622936239156575e-05
+5.500000000000000000e+02 1.000000000000000000e+02 2.480724299966823206e-03 2.750882032957220326e-05
+6.000000000000000000e+02 1.000000000000000000e+02 2.895569670145050744e-03 5.288688606734717474e-05
+6.500000000000000000e+02 1.000000000000000000e+02 3.315797200011729937e-03 6.324376155582976829e-05
+7.000000000000000000e+02 1.000000000000000000e+02 3.988737380132079471e-03 8.966749854463253178e-05
+7.500000000000000000e+02 1.000000000000000000e+02 5.103451869799755826e-03 1.584853305380074038e-04
+8.000000000000000000e+02 1.000000000000000000e+02 6.057379170051717387e-03 1.642264403316068798e-04
+8.500000000000000000e+02 1.000000000000000000e+02 6.927488980109046748e-03 1.944677459404338588e-04
+9.000000000000000000e+02 1.000000000000000000e+02 8.814388450155093147e-03 2.330794777089288878e-04
+9.500000000000000000e+02 1.000000000000000000e+02 1.064539701990725035e-02 3.041454790179711994e-04
+1.000000000000000000e+03 1.000000000000000000e+02 1.240550483009428794e-02 3.095759025769566721e-04
+1.050000000000000000e+03 1.000000000000000000e+02 1.434945806995529052e-02 3.462888056603818758e-04
+1.100000000000000000e+03 1.000000000000000000e+02 1.677911746977770249e-02 3.749990243690372164e-04
+1.150000000000000000e+03 1.000000000000000000e+02 1.831551297967962469e-02 4.604813699809882270e-04
+1.200000000000000000e+03 1.000000000000000000e+02 2.237008690015500345e-02 4.574082591796148041e-04
+1.250000000000000000e+03 1.000000000000000000e+02 2.469113503011612781e-02 5.159501949634852890e-04
+1.300000000000000000e+03 1.000000000000000000e+02 2.771557212010520785e-02 5.422901593142985836e-04
+1.350000000000000000e+03 1.000000000000000000e+02 3.089818914999341304e-02 6.274980749590892710e-04
+1.400000000000000000e+03 1.000000000000000000e+02 3.351067304993193829e-02 6.258951037710455863e-04
+1.450000000000000000e+03 1.000000000000000000e+02 3.672902733014780235e-02 6.463995733058402766e-04
+1.500000000000000000e+03 1.000000000000000000e+02 4.152314034017763611e-02 5.716930792484469599e-04
+1.550000000000000000e+03 1.000000000000000000e+02 4.438926930015441030e-02 6.721290882549972113e-04
+1.600000000000000000e+03 1.000000000000000000e+02 4.552266089023760537e-02 7.453956208500090320e-04
+1.650000000000000000e+03 1.000000000000000000e+02 5.021009291991504475e-02 6.862840120510182822e-04
+1.700000000000000000e+03 1.000000000000000000e+02 5.453786087025946222e-02 6.546641481410810049e-04
+1.750000000000000000e+03 1.000000000000000000e+02 5.628588498999306799e-02 8.462562766021738741e-04
+1.800000000000000000e+03 1.000000000000000000e+02 6.095474819019727764e-02 7.517515934752839373e-04
+1.850000000000000000e+03 1.000000000000000000e+02 6.366028950997133784e-02 8.152459203989234496e-04
+1.900000000000000000e+03 1.000000000000000000e+02 6.785009805011213424e-02 7.698881522351951924e-04
+1.950000000000000000e+03 1.000000000000000000e+02 7.188723056995513505e-02 6.833998803979537658e-04
+2.000000000000000000e+03 1.000000000000000000e+02 7.566429144997527390e-02 8.365863514799617290e-04
+2.050000000000000000e+03 1.000000000000000000e+02 7.861056976002146757e-02 8.193592148539533947e-04
+2.100000000000000000e+03 1.000000000000000000e+02 8.247058204007771953e-02 8.197200493282149258e-04
+2.150000000000000000e+03 1.000000000000000000e+02 8.493876021024333867e-02 8.342453122990786934e-04
+2.200000000000000000e+03 1.000000000000000000e+02 8.813758615971892252e-02 7.911501815949151164e-04
+2.250000000000000000e+03 1.000000000000000000e+02 9.468871829980343713e-02 9.350049573202011063e-04
+2.300000000000000000e+03 1.000000000000000000e+02 9.786318559981736775e-02 9.314812240165508146e-04
+2.350000000000000000e+03 1.000000000000000000e+02 1.018545777700273908e-01 9.261618059141366391e-04
+2.400000000000000000e+03 1.000000000000000000e+02 1.051895230298396239e-01 8.616776153947947308e-04
+2.450000000000000000e+03 1.000000000000000000e+02 1.070327199899838849e-01 9.274632293436604977e-04
+2.500000000000000000e+03 1.000000000000000000e+02 1.112921274800100918e-01 8.472622784928632040e-04
+2.550000000000000000e+03 1.000000000000000000e+02 1.145994285400956936e-01 9.315154484987448174e-04
+2.600000000000000000e+03 1.000000000000000000e+02 1.193636358499861605e-01 9.910600547399727421e-04
+2.650000000000000000e+03 1.000000000000000000e+02 1.218935546997090558e-01 8.861179673363818541e-04
+2.700000000000000000e+03 1.000000000000000000e+02 1.261190436399556303e-01 9.270747298007727191e-04
+2.750000000000000000e+03 1.000000000000000000e+02 1.291786062698520310e-01 9.713837766685412545e-04

performance/regimes/circuit_scaling_meta.json

@@ -1 +1 @@
-{"nstart": 400, "nstop": 2600, "step": 50, "ncircuits": 50, "nqbits0": 100, "nqbits1": 50, "seed": 3735928559}
+{"nstart": 400, "nstop": 2800, "step": 50, "ncircuits": 100, "nqbits0": 100, "nqbits1": 50, "seed": 3735928559}

performance/regimes/generate_data_scaling_circuits.py

@@ -51,9 +51,9 @@ def test_scaling_circuits(state_factory
 
 if __name__ == "__main__":
     nstart = 400
-    nstop = 2600
+    nstop = 2800
     step = 50
-    ncircuits = 50
+    ncircuits = 100
     nqbits0 = 100
     nqbits1 = 50
     seed = 0xdeadbeef
@@ -65,7 +65,7 @@ if __name__ == "__main__":
                                     , step
                                     , nqbits0
                                     , ncircuits
-                                    , repeat=5)
+                                    , repeat=10)
     np.random.seed(seed)
     results_graph1 = test_scaling_circuits(GraphState.new_zero_state
                                     , nstart
@@ -73,7 +73,7 @@ if __name__ == "__main__":
                                     , step
                                     , nqbits1
                                     , ncircuits
-                                    , repeat=4)
+                                    , repeat=10)
 
     np.savetxt("circuit_scaling_graph0.csv", results_graph0)
     print("saved results0 to circuit_scaling_graph0.csv")

performance/regimes/graph_intermediate_regime.py

@@ -1,34 +0,0 @@
-from collections import deque
-import matplotlib.pyplot as plt
-import numpy as np
-import json
-
-from pyqcs import State, H, X, S, CZ
-from pyqcs.graph.state import GraphState
-from pyqcs.util.random_circuits import random_circuit
-
-def S_with_extra_arg(act, i):
-    return S(act)
-
-np.random.seed(0xdeadbeef)
-
-circuit = random_circuit(50, 700, X, H, S_with_extra_arg, CZ)
-
-state = circuit * GraphState.new_plus_state(50)
-
-vops, edges = state._g_state.to_lists()
-
-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_edges_str + "\n}"
-
-print(dot_str)

performance/regimes/plot_scaling_circuits_50qbit_linear.py

@@ -4,8 +4,6 @@ import matplotlib.pyplot as plt
 import numpy as np
 import json
 
-matplotlib.rc('font', **{'family': 'serif', 'serif': ['Computer Modern']})
-matplotlib.rc('text', usetex=True)
 matplotlib.rcParams.update({'errorbar.capsize': 2})
 
 results_graph0 = np.genfromtxt("circuit_scaling_graph1.csv")
@@ -14,7 +12,7 @@ with open("circuit_scaling_meta.json") as fin:
 
 h0 = plt.errorbar(results_graph0[:, 0], results_graph0[:, 2], results_graph0[:, 3]
                 , label=f"Graphical Simulator $N_q={meta['nqbits1']}$ Qbits"
-                , marker="o"
+                , marker="^"
                 , color="black")
 
 plt.legend(handles=[h0])

performance/regimes/plot_scaling_circuits_linear.py

@@ -4,8 +4,6 @@ import matplotlib.pyplot as plt
 import numpy as np
 import json
 
-matplotlib.rc('font', **{'family': 'serif', 'serif': ['Computer Modern']})
-matplotlib.rc('text', usetex=True)
 matplotlib.rcParams.update({'errorbar.capsize': 2})
 
 results_graph0 = np.genfromtxt("circuit_scaling_graph0.csv")
@@ -15,11 +13,11 @@ with open("circuit_scaling_meta.json") as fin:
 
 h0 = plt.errorbar(results_graph0[:, 0], results_graph0[:, 2], results_graph0[:, 3]
                 , label=f"Graphical Simulator $N_q={meta['nqbits0']}$ Qbits"
-                , marker="o"
+                , marker="^"
                 , color="black")
 h1 = plt.errorbar(results_graph1[:, 0], results_graph1[:, 2], results_graph1[:, 3]
                 , label=f"Graphical Simulator $N_q={meta['nqbits1']}$ Qbits"
-                , marker="^"
+                , marker="o"
                 , color="black")
 
 plt.legend(handles=[h0, h1])

performance/regimes/plot_scaling_circuits_measurements_linear.py

@@ -4,8 +4,6 @@ import matplotlib.pyplot as plt
 import numpy as np
 import json
 
-matplotlib.rc('font', **{'family': 'serif', 'serif': ['Computer Modern']})
-matplotlib.rc('text', usetex=True)
 matplotlib.rcParams.update({'errorbar.capsize': 2})
 
 results_graph0 = np.genfromtxt("circuit_scaling_graph0_measurements.csv")
@@ -15,11 +13,11 @@ with open("circuit_scaling_measurements_meta.json") as fin:
 
 h0 = plt.errorbar(results_graph0[:, 0], results_graph0[:, 2], results_graph0[:, 3]
                 , label=f"Graphical Simulator $N_q={meta['nqbits0']}$ Qbits"
-                , marker="o"
+                , marker="^"
                 , color="black")
 h1 = plt.errorbar(results_graph1[:, 0], results_graph1[:, 2], results_graph1[:, 3]
                 , label=f"Graphical Simulator $N_q={meta['nqbits1']}$ Qbits"
-                , marker="^"
+                , marker="o"
                 , color="black")
 
 plt.legend(handles=[h0, h1])

presentation/Makefile

@@ -10,48 +10,21 @@ 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
+all: main.pdf
 
-main_long.pdf: main_long.tex $(graph_pngs)
-	$(latex) main_long
-	#$(bibtex) main_long
-	$(latex) main_long
-	$(pdflatex) main_long
-
-main.pdf: main.tex $(graph_pngs) $(example_graphpngs)
+main.pdf: main.tex $(graph_pngs)
 	$(latex) main
 	#$(bibtex) main
 	$(latex) main
 	$(pdflatex) main
 
+
 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
-	-rm main_long.blg
-	-rm main_long.dvi
-	-rm main_long.log
-	-rm main_long.out
-	-rm main_long.pdf
-	-rm main_long.toc
-	-rm main_long.bbl
-	-rm $(graph_pngs)
-	-rm $(example_graphpngs)
 	-rm main.aux
 	-rm main.blg
 	-rm main.dvi
@@ -60,4 +33,4 @@ clean:
 	-rm main.pdf
 	-rm main.toc
 	-rm main.bbl
-	-(cd example_graphs && make clean)
+	-rm $(graph_pngs)

presentation/example_graphs/circuit_EPR_state.py

@@ -1,17 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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/spin_chain/hamiltonian.py

@@ -16,7 +16,7 @@ def Mi(nqbits, i, M):
 
 
 def H_interaction(nqbits):
-    interaction_terms = [Mi(nqbits, i, Z) @ Mi(nqbits, i+1, Z) for i in range(nqbits - 1)]
+    interaction_terms = [Mi(nqbits, i, Z) @ Mi(nqbits, i+1, Z) for i in range(nqbits)]
     return sum(interaction_terms)
 
 def H_field(nqbits, g):

presentation/spin_chain/time_evolution.py

@@ -20,8 +20,8 @@ matplotlib.rcParams.update(
 nqbits = 6
 g = 3
 N_trot = 80
-t_stop = 29
-delta_t = 0.1
+t_stop = 9
+delta_t = 0.09
 qbits = list(range(nqbits))
 
 n_sample = 2200
@@ -33,7 +33,6 @@ measure_coefficient_mask = [False if (i & measure) else True for i in range(2**n
 results_qc = []
 results_np = []
 errors_sampling = []
-amplitudes_qc = []
 
 print()
 for t in np.arange(0, t_stop, delta_t):
@@ -47,10 +46,10 @@ for t in np.arange(0, t_stop, delta_t):
     result = sample(state, measure, n_sample)
     results_qc.append(result[0] / n_sample)
 
-    errors_sampling.append(bootstrap(result[0], n_sample, n_sample, n_sample // 2, np.average))
+    errors_sampling.append(bootstrap(result[0], n_sample, n_sample // 4, n_sample // 10, np.average))
 
-    amplitude = np.sum(np.abs(state._qm_state[measure_coefficient_mask])**2)
-    amplitudes_qc.append(amplitude)
+    #amplitude = np.sqrt(np.sum(np.abs(state._qm_state[measure_coefficient_mask])**2))
+    #results_qc.append(amplitude)
 
     # Simulation using matrices
     np_zero_state = np.zeros(2**nqbits)
@@ -68,24 +67,17 @@ print()
 print("done.")
 
 results_qc = np.array(results_qc)
-amplitudes_qc = np.array(amplitudes_qc)
 
-errors_trotter = (np.arange(0, t_stop, delta_t))**3 / N_trot**3
+errors_trotter = (np.arange(0, t_stop, delta_t) * g)**2 / N_trot**2
 errors_sampling = np.array(errors_sampling)
-#errors_sampling = np.abs(results_qc - amplitudes_qc)
-#errors_sampling = (amplitudes_qc * (1 - amplitudes_qc))**2 / n_sample
 
-#hm1 = plt.errorbar(np.arange(0, t_stop, delta_t)
-#                , results_qc
-#                , yerr=(errors_sampling + errors_trotter)
-#                , color="red")
+
 h0 = plt.errorbar(np.arange(0, t_stop, delta_t)
                 , results_qc
-                , yerr=errors_sampling
+                , yerr=(errors_trotter + errors_sampling)
                 , label=f"Quantum computing ({n_sample} samples, {N_trot} trotterization steps)"
                 , )
 h1, = plt.plot(np.arange(0, t_stop, delta_t), results_np, label="Classical simulation using explicit transfer matrix")
-#h2, = plt.plot(np.arange(0, t_stop, delta_t), amplitudes_qc, label="QC amplitude")
 plt.xlabel("t")
 plt.ylabel(r"$|0\rangle$ probability amplitude for second spin")
 plt.title(f"{nqbits} site spin chain with g={g} coupling to external field")

pyqcs

@@ -1 +1 @@
-Subproject commit 51efe195fe0378b0b9c4bad0ff6eefb1f17e4b3a
+Subproject commit bcebc7860c47e4d8d1f5ec79b816032f31d8138d

thesis/chapters/appendix.tex

@@ -1,14 +1,14 @@
 % vim: ft=tex
-\chapter{Appendix}
+\section{Appendix}
 
-\section{Source Code for the Benchmarks}
+\subsection{Source Code for the Benchmarks}
 \label{ref:code_benchmarks}
 
-The benchmarks used in \ref{ref:performance} are based on this code. Note
+The benchmarks used in \ref{ref:performance} are done using this code. Note
 that the execution time is measured which is inherently noisy. To account for
 the noise several strategies are used:
 
-\begin{enumerate}[1.]
+\begin{enumerate}[1]
     \item{The same circuit is applied to the starting state several times. The
         minimal result is used as the noise must be positive}
     \item{Several circuits are applied to the starting state. The remaining
@@ -25,14 +25,20 @@ The code used to benchmark the three regimes is analogous and not included here.
 
 \lstinputlisting[title={Code for Measuring and Computing the Execution Time and Statistics}, language=Python, breaklines=true]{../performance/measure_circuit.py}
 
-\section{Complete Graphical States from the Three Regimes}
+\subsection{Complete Graphical States from the Three Regimes}
 \label{ref:complete_graphs}
 
 Because the whole graphs are barely percetible windows have been used
 in Figure \ref{fig:graph_high_linear_regime} and Figure \ref{fig:graph_intermediate_regime}.
-For the sake of completeness the whole graphs are included here in 
+For the sake of completeness the whole graphs are included here in Figure \ref{fig:graph_low_linear_regime_full},
 Figure \ref{fig:graph_intermediate_regime_full} and Figure \ref{fig:graph_high_linear_regime_full}.
 
+\begin{figure}[H]
+    \centering
+    \includegraphics[width=\linewidth]{graphics/graph_low_linear_regime.png}
+    \caption[Typical Graphical State in the Low-Linear Regime]{Typical Graphical State in the Low-Linear Regime}
+    \label{fig:graph_low_linear_regime_full}
+\end{figure}
 
 \begin{figure}[H]
     \centering
@@ -48,32 +54,32 @@ Figure \ref{fig:graph_intermediate_regime_full} and Figure \ref{fig:graph_high_l
     \label{fig:graph_high_linear_regime_full}
 \end{figure}
 
-\section{Code to Generate the Example Graphs}
+\subsection{Code to Generate the Example Graphs}
 \label{ref:code_example_graphs}
 
-This code has been used to generate the example graphs in \ref{ref:performance}
-and \ref{ref:complete_graphs}. Note that generating the graph is done with
-a random circuit as in \ref{ref:code_benchmarks}. The generated \lstinline{dot}
+This code has been used to generate the example graphs used in
+\ref{ref:performance}. Note that generating the graph is done using a random
+circuit as used in \ref{ref:code_benchmarks}. The generated \lstinline{dot}
 code is converted to an image using 
 \lstinline{dot i_regime.dot -Tpng -o i_regime.png}.
 
 \lstinputlisting[title={Code used to Generate the Example Graphs}, language=Python, breaklines=true]{../performance/regimes/graph_intermediate_regime.py}
 
 
-\section{Code to Benchmark \lstinline{ufunc} Gates against Python}
+\subsection{Code to Benchmark \lstinline{ufunc} Gates against Python}
 \label{ref:benchmark_ufunc_py}
 
-It has been mentioned several times that the implementation with
-\lstinline{ufuncs} as gates is faster than a pure \lstinline{python}
-implementation.  To support this statement a simple benchmark is written. The
-relatively simple Pauli $X$ gate is implemented, more complicated gates like $CX$ or $H$
-have worse performance when written in \lstinline{python}. The performance
-improvement in this example is a factor around $6.4$.
-One must note that the tested \lstinline{python} code is not
-realistic and in a possible application there would be a significant overhead.
+It has been mentioned several times that the implementation using
+\lstinline{ufuncs} as gates is faster than using a \lstinline{python}
+implementation.  To support this statement a simple benchmark can be used. The
+relatively simple Pauli $X$ is used, more complicated gates like $CX$ or $H$
+have worse performance when implemented in \lstinline{python}. The performance
+improvement when using the \lstinline{ufunc} is a factor around $6.4$ in this tested
+case. One must however note that the tested \lstinline{python} code is not
+realistic and in a possible applications there would be a significant overhead.
 
 \lstinputlisting[title={Code to Benchmark \lstinline{ufunc} Gates against Python}, language=Python, breaklines=True]{extra_benchmark/benchmark.py}
 
 When using \lstinline{result_py[0::2] = qm_state[1::2]} the result is identical and
-the performance is only increased by a factor around $1.7$. This method is not
+the performance is only increased by a factor around $1.7$. This method is however not
 applicable to general act-qbits and the bit mask has to be used.

thesis/chapters/conclusion.tex

@@ -1,11 +1,11 @@
 % vim: ft=tex
-\chapter{Conclusion and Outlook}
+\section{Conclusion and Outlook}
 
 As seen in \ref{ref:performance} simulation using stabilizers is exponentially
-faster than simulating with dense state vectors. The graphical representation
-for stabilizer states is in realistic cases more efficiently than the
-stabilizer tableaux \cite{andersbriegel2005}. In particular one can simulate
-more qbits while only applying Clifford gates.
+faster than simulating using state vectors. Using a graphical representation
+for the stabilizers is on average more efficiently than using a stabilizer
+tableaux. In particular one can simulate more qbits while only applying
+Clifford gates.
 
 This is considerably useful when working on quantum error correcting strategies
 as they often include many qbits; the smallest quantum error correcting
@@ -13,7 +13,7 @@ stabilizer code requires $5$ qbits to encode one logical qbit
 \cite{nielsen_chuang_2010}.  Several layers of data encoding increase the
 number of required qbits exponentially.
 
-Simulating in the stabilizer formalism is uninteresting from a physical
+Simulating in the stabilizer formalism is rather uninteresting from a physical
 point of view as basically no physically interesting simulations can be
 performed: As shown in \ref{ref:meas_stab} probability amplitudes have to be
 $0, \frac{1}{2}, 1$; this leaves very few points in time that could be
@@ -21,7 +21,7 @@ simulated by applying a transfer matrix. Algorithms like the quantum fourier
 transform also require non-Clifford gates for qbit counts $n \neq 2, 4$.
 
 The basic idea of not simulating a state but (after imposing some conditions on
-the Hilbert space) other objects that describe the state is 
+the Hilbert space) other objects that describe the state is extremely
 interesting for physics as often the exponentially large or infinitely large
 Hilbert spaces cannot be mapped to a classical (super) computer.  One key idea
 to take from the stabilizer formalism is to simulate the Hamiltonian instead of
@@ -34,14 +34,14 @@ ground state of this Hamiltonian.
 
 While trying to extend the stabilizer formalism one inevitably hits the
 question:\\ \textit{Why is there a constraint on the $R_\phi$ angle? Why is it
-$\frac{\pi}{2}$?}\\ The answer to this question can be found by taking a look
-at the Clifford group. Recalling Definition \ref{def:clifford_group} the
-Clifford group is not defined to be generated by $H, S, CZ$, but by its property
-of normalizing the multilocal Pauli group. Storing and manipulating the
-multilocal Pauli group is only so efficient (or possible) because it is the
-tensor product of Pauli matrices. A general unitary on $n$ qbits would be
-a $2^{n} \times 2^{n}$ matrix which requires more space than a dense state
-vector. The Clifford group is a group preserving this tensor product property.
+$\frac{\pi}{2}$?}\\ The answer to this question is hidden in the Clifford
+group. Recalling Definition \ref{def:clifford_group} the Clifford group is not
+defined to be generated by $H, S, CZ$ but by its property of normalizing the
+multilocal Pauli group. Storing and manipulating the multilocal Pauli group is
+only so efficient (or possible) because it is the tensor product of Pauli
+matrices. A general unitary on $n$ qbits would be a $2^{n} \times 2^{n}$ matrix
+which requires more space than a dense state vector. The Clifford group is
+a group preserving this tensor product property.
 
 %{{{
 %When lifting the constraint that $\ket{\varphi}$ is stabilized by the multilocal Pauli
@@ -103,10 +103,10 @@ vector. The Clifford group is a group preserving this tensor product property.
 The stabilizer formalism as introduced in \ref{ref:stab_states} has since been
 generalized to normalizers of a finite Abelian group over the Hilbert space
 \cite{bermejovega_lin_vdnest2015}\cite{bermejovega_vdnest2018}\cite{vandennest2019}\cite{vandennest2018}.
-This allows to simulate more classes of circuits efficiently on classical
-computers including the Quantum Fourier Transforms which is often believed to
-be responsible for exponential speedups. One must note that in the definition
-of the QFTs as in \cite{vandennest2018} the QFT depends on the Abelian group it
+This allows to simulate more classes of circuits efficiently on classical computers 
+including the Quantum Fourier Transforms which is often believed to be
+responsible for exponential speedups. One must note that in the definition of
+the QFTs as in \cite{vandennest2018} the QFT depends on the Abelian group it
 acts on. In particular the QFT on the group that decomposes the Hilbert space
 as seen in this paper ($Z_2^n$) is just the tensor product of the $H$ gates.
 The QFT as used in \ref{ref:quantum_algorithms} for the phase estimation
@@ -115,9 +115,8 @@ interesting results: It is not the tensor product property of the multilocal
 Pauli group that makes computations efficient but the normalization property of
 the Clifford group \cite{vandennest2018}.
 
-The exponential speedup of quantum computing is often attributed to
+The exponential speedup of quantum computing is often attributed to 
 entanglement, superposition and interference effects
-\cite{uwaterloo}\cite{21732}\cite{vandennest2018}. Stabilizer states show
-entanglement, superposition and interference effects; as do computations using
-general normalizers \cite{vandennest2018}. The question why quantum computing
-can speed up computations exponentially is non-trivial.
+\cite{uwaterloo}\cite{21732}\cite{vandennest2018}. Stabilizer states
+however show both entanglement, superposition and interference effects;
+as do computations done using general normalizers \cite{vandennest2018}.

thesis/chapters/implementation.tex

@@ -1,23 +1,19 @@
 % vim: ft=tex
-\chapter{Implementation}
+\section{Implementation}
 
 This chapter discusses how the concepts introduced before are implemented into
-a simulator. Further the infrastructure around the simulation and some tools are
+a simulator. Futher the infrastructure around the simulation and some tools are
 explained.
 
 The implementation is written as the \lstinline{python3} package \lstinline{pyqcs} \cite{pyqcs}. This allows
 users to quickly construct circuits, apply them to states and measure
-amplitudes.  Full access to the states (including intermediate states) has been
-prioritized over execution speed. To keep the simulation speed as high as
+amplitudes.  Full access to the state (including intermediate states) has been
+priorized over execution speed. To keep the simulation speed as high as
 possible under these constraints some parts are implemented in \lstinline{C}.
 
-This document is based on \lstinline{pyqcs} \lstinline{2.1.0} that 
-can be downloaded under \\
-\href{https://github.com/daknuett/PyQCS/releases/tag/v2.1.0}{https://github.com/daknuett/PyQCS/releases/tag/v2.1.0}.
+\subsection{Dense State Vector Simulation}
 
-\section{Dense State Vector Simulation}
-
-\subsection{Representation of Dense State Vectors}
+\subsubsection{Representation of Dense State Vectors}
 
 Recalling \eqref{eq:ci} any $n$-qbit state can be represented as a $2^n$
 component vector in the integer state basis. This representation has some
@@ -27,33 +23,34 @@ useful features when it comes to computations:
     \item{The projection on the integer states is trivial.}
     \item{For any qbit $j$ and $0 \le i \le 2^n-1$ the coefficient $c_i$ is part of the $\ket{1}_j$ amplitude iff
         $i \& (1 << j)$ and part of the $\ket{0}_j$ amplitude otherwise.}
-    \item{For a qbit $j$ the coefficients $c_i$ and $c_{i \wedge (1 << j)}$ are the conjugated coefficients.}
+    \item{For a qbit $j$ the coefficients $c_i$ and $c_{i \hat{ } (1 << j)}$ are the conjugated coefficients.}
 \end{itemize}
 
-Where $\wedge$ is the binary XOR, $\&$ the binary AND and $<<$ the binary
+Where $\hat{}$ is the binary XOR, $\&$ the binary AND and $<<$ the binary
 leftshift operator.
 
-While implementing the dense state vectors two key points were a simple way to
-use them and easy access to the underlaying data.  To meet both requirements
-the states are implemented as Python objects that provide abstract features such
-as normalization checking, checking for sufficient qbit number when applying
-a circuit, computing overlaps with other states, a stringify method and stored
-measurement results.  To store the measurement results a NumPy \lstinline{int8}
-array \cite{numpy_array} is used; this is called the classical state.  The
-Python states also have a NumPy \lstinline{cdouble} array that stores the
-quantum mechanical state.  Using NumPy arrays has the advantage that access to
-the data is simple and safe while operations on the states can be implemented
-in \lstinline{C} \cite{numpy_ufunc} providing a considerable speedup
-(see \ref{ref:benchmark_ufunc_py}).
+While implementing the dense state vectors two key points were allowing
+a simple and readable way to use them and simple access to the states by users
+that want more information than an abstracted view could allow. To meet both
+requirements the states are implemented as Python objects providing abstract
+features such as normalization checking, checking for sufficient qbit number
+when applying a circuit, computing overlaps with other states, a stringify
+method and stored measurement results.  To store the measurement results
+a NumPy \lstinline{int8} array \cite{numpy_array} is used; this is called the
+classical state.  The Python states also have a NumPy \lstinline{cdouble} array
+that stores the quantum mechanical state.  Using NumPy arrays has the advantage
+that access to the data is simple and safe while operations on the states can
+be implemented in \lstinline{C} \cite{numpy_ufunc} providing a considerable
+speedup \ref{ref:benchmark_ufunc_py}.
 
 This quantum mechanical state is the component vector in integer basis
 therefore it has $2^n$ components.  Storing those components is acceptable in
 a range from $1$ to $30$ qbits; above this range the state requires space in
-the order of magnitude $1 \mbox{ GiB}$  which is in the range of usual RAM sizes for
+the order of $1 \mbox{ GiB}$  which is in the range of usual RAM sizes for
 personal computers. For higher qbit numbers moving to high performance
 computers and other simulators is necessary.
 
-\subsection{Gates}
+\subsubsection{Gates}
 
 Gates on dense state vectors are implemented as NumPy Universal Functions
 (ufuncs) \cite{numpy_ufunc} mapping a classical and a quantum state to a new
@@ -62,7 +59,7 @@ what qbits have been measured. Using ufuncs has the great advantage that
 managing memory is done by NumPy and an application programmer just has to
 implement the logic of the function. Because ufuncs are written in
 \lstinline{C} they provide a considerable speedup compared to an implementation
-in Python (see \ref{ref:benchmark_ufunc_py}).
+in Python \ref{ref:benchmark_ufunc_py}.
 
 The logic of gates is usually easy to implement using the integer basis. The
 example below implements the Hadamard gate \ref{ref:singleqbitgates}:
@@ -75,7 +72,7 @@ A basic set of gates is implemented in PyQCS:
     \item{Hadamard $H$ gate.}
     \item{Pauli $X$ or \textit{NOT} gate.}
     \item{Pauli $Z$ gate.}
-    \item{Phase gate $S$.}
+    \item{The $S$ phase gate.}
     \item{$Z$ rotation $R_\phi$ gate.}
     \item{Controlled $X$ gate: $CX$.}
     \item{Controlled $Z$ gate: $CZ$.}
@@ -86,7 +83,7 @@ To allow the implementation of possible hardware related gates the class
 \lstinline{GenericGate} takes a unitary $2\times2$ matrix as a NumPy
 \lstinline{cdouble} array and builds a gate from it.
 
-\subsection{Circuits}
+\subsubsection{Circuits}
 \label{ref:pyqcs_circuits}
 
 As mentioned in \ref{ref:quantum_circuits} quantum circuits are central in
@@ -101,8 +98,8 @@ new_state = circuit * state
 \end{lstlisting}
 
 
-The elementary gates are implemented as single gate
-circuits and can be constructed using the built-in generators. These generators
+The elementary gates such as $H, R_\phi, CX$ are implemented as single gate
+circuits and can be constructing using the built-in generators. The generators
 take the act-qbit as first argument, parameters such as the control qbit or an
 angle as second argument:
 
@@ -120,7 +117,7 @@ Out[2]: (0.7071067811865476+0j)*|0b0>
         + (0.7071067811865476+0j)*|0b11>
 \end{lstlisting}
 
-Large circuits can be built using the binary OR operator \lstinline{|} in
+Large circuits can be constructed using the binary OR operator \lstinline{|} in
 an analogy to the pipeline operator on many *NIX shells. As usual circuits are
 read from left to right similar to pipelines on *NIX shells:
 
@@ -144,7 +141,7 @@ Out[2]: (0.7071067811865477+0j)*|0b0>
 \end{lstlisting}
 %}
 
-A quick way to generate circuits programmatically is to use the \lstinline{list_to_circuit}
+A quick way to generate circuits programatically is to use the \lstinline{list_to_circuit}
 function:
 
 %\adjustbox{max width=\textwidth}{
@@ -163,22 +160,15 @@ Out[2]: (0.7071067811865476+0j)*|0b0>
 \end{lstlisting}
 %}
 
-\section{Graphical State Simulation}
+\subsection{Graphical State Simulation}
 
-\subsection{Graphical States}
-\label{ref:impl_g_states}
+\subsubsection{Graphical States}
 
 For the graphical state $(V, E, O)$ the list of vertices $V$ can be stored implicitly
 by demanding $V = \{0, ..., n - 1\}$. This leaves two components that have to be stored:
 The edges $E$ and the vertex operators $O$. Storing the vertex operators is
 done using a \lstinline{uint8_t} array. Every local Clifford operator is
-associated with an integer ranging from $0$ to $23$
-\footnote{
-    \cite{andersbriegel2005} also uses integers from $0$ to $23$ to represent
-    the Clifford operators. The authors do not describe the mapping from integer
-    to operator and the order might be different.
-}
-. Their order is
+associated with an integer ranging from $0$ to $24$, their order is
 
 \begin{equation}
 \begin{aligned}
@@ -226,28 +216,27 @@ The edges are stored in an adjacency matrix
 Recalling some operations on the graph as described in
 \ref{ref:dynamics_graph}, \ref{ref:meas_graph} or Lemma \ref{lemma:M_a} one
 sees that it is important to efficiently access and modify the neighbourhood of
-a vertex.  Also one must take care to keep the memory required to store a state
-low.  To meet both requirements a linked list-array hybrid is used.  For every
-vertex the neighbourhood is stored in a sorted linked list (which is a sparse
-representation of a column vector) and these adjacency lists are stored in
-a length $n$ array. \cite{andersbriegel2005} uses the same representation for
-the graph.
+a vertex.  To ensure good performance when accessing the neighbourhood while
+keeping the required  memory low a linked list-array hybrid is used to store
+the adjacency matrix. For every vertex the neighbourhood is stored in a sorted
+linked list (which is a sparse representation of a column vector) and these
+adjacency lists are stored in a length $n$ array.
 
-Using this storage method all operations - including searching and toggling edges -
-inherit their time complexity from the sorted linked list.
+Using this storage method all operations including searching and toggling edges
+inherite their time complexity from the sorted linked list.
 
-\subsection{Operations on Graphical States}
+\subsubsection{Operations on Graphical States}
 
 Operations on Graphical States are divided into three classes: Local Clifford
 operations, the CZ operation and measurements. The graphical states are
-implemented in \lstinline{C} and are exported to \lstinline{python3} in the class
+implemented in \lstinline{C} and are exported to python3 in the class
 \lstinline{RawGraphState}. This class has three main methods to implement the
 three classes of operations. 
 
 \begin{description} 
     \item[\hspace{-1em}]{\lstinline{RawGraphState.apply_C_L}\\
         This method implements local Clifford gates. It takes the qbit index
-        and the index of the local Clifford operator (ranging from $0$ to $23$).}
+        and the index of the local Clifford operator (ranging form $0$ to $23$).}
     \item[\hspace{-1em}]{\lstinline{RawGraphState.apply_CZ}\\
             Applies the $CZ$ gate to the state. The first argument is the
             act-qbit, the second the control qbit (note that this is just for
@@ -260,16 +249,16 @@ three classes of operations.
             returns either $1$ or $0$ as a measurement result.}
 \end{description}
 
-Because this way of modifying the state is inconvenient and might lead to many
+Because this way of modifying the state is rather unconvenient and might lead to many
 errors the \lstinline{RawGraphState} is wrapped by the pure python class\\
 \lstinline{pyqcs.graph.state.GraphState}. It allows the use of circuits as
 described in \ref{ref:pyqcs_circuits} and provides the method
 \lstinline{GraphState.to_naive_state} to convert the graphical state to a dense
 vector state.
 
-\subsection{Pure C Implementation}
+\subsubsection{Pure C Implementation}
 
-Because python tends to be slow \cite{benchmarkgame} and might not run on any architecture
+Because python tends to be rather slow \cite{benchmarkgame} and might not run on any architecture
 a pure \lstinline{C} implementation of the graphical simulator is also provided.
 It should be seen as a reference implementation that can be extended to the needs
 of the user.
@@ -277,44 +266,38 @@ of the user.
 This implementation reads byte code from a file and executes it. The execution is 
 always done in three steps:
 
-\begin{enumerate}[1.]
-    \item{Initializing the state according to the header of the byte code file.}
-    \item{Applying operations given by the byte code to the state. This includes local
+\begin{enumerate}[1]
+    \item{Initializing the state according the the header of the bytecode file.}
+    \item{Applying operations given by the bytecode to the state. This includes local
             Clifford gates, $CZ$ gates and measurements (the measurement outcome is ignored).}
-    \item{Sampling the state according to the description in the header of the byte code 
+    \item{Sampling the state according the the description given in the header of the byte code 
         file and writing the sampling results to either a file or \lstinline{stdout}. }
 \end{enumerate}
 
-\section{Utilities}
+\subsection{Utilities}
 
-The package \lstinline{pyqcs} ships with several utilities that are supposed to
-make using the simulators more convenient. Some utilities are designed to help
-in a scientific and educational context.  This chapter explains some of them.
+To make both using the simulators more convenient and to help with using them
+in as scientific or educational context several utilities have been written.
+This chapter explains some of them.
 
-\subsection{Sampling and Circuit Generation}
+\subsubsection{Sampling and Circuit Generation}
 
 The function \lstinline{pyqcs.sample} provides a simple way to sample from
-a state.  Copies of the state are made when necessary, and the results are
+a state.  Copies of the state are made when necessary and the results are
 returned in a \lstinline{collections.Counter} object. Several qbits can be
 sampled at once; they can be passed to the function either as an integer which
-will be interpreted as a bit mask, and the least significant bit will be sampled
+will be interpreted as a bit mask and the least significant bit will be sampled
 first. When passing the qbits to sample as a list of integers the integers are
 interpreted as qbit indices and are measured in the order they appear.
 
 If the keyword argument \lstinline{keep_states} is \lstinline{True} the
-sampling function will include the collapsed states in the result. At the
+sampling function will include the resulting states in the result. At the
 moment this works for dense vectors only. Checking for equality on graphical
-states is not implemented due to the computational hardness.
-\cite{bouchet1991} introduced an algorithm to test whether two VOP-free graph states
-are equivalent with complexity $\mathcal{O}\left(n^4\right)$.
-So checking for equivalency is $c-NP$ complete because the vertex operators have
-to be checked as well. It might be necessary to compute all equivalent graphical
-states. \cite{dahlberg_ea2019} showed that counting equivalent VOP-free 
-graphical states is $\#P$ complete. Showing that two graphical states are 
-equivalent might considerably hard.
+states has yet to be implemented but has $NP$ computational hardness
+\cite{dahlberg_ea2019}.
 
-Writing circuits out by hand can be inconvenient. The function\\
-\lstinline{pyqcs.list_to_circuit} converts a list of circuits to a circuit.
+Writing circuits out by hand can be rather painful. The function\\
+\lstinline{pyqcs.list_to_circuit} Converts a list of circuits to a circuit.
 This is particularly helpful in combination with python's
 \lstinline{listcomp}:
 
@@ -325,40 +308,41 @@ circuit_H = list_to_circuit([H(i) for i in range(nqbits)])
 The module \lstinline{pyqcs.util.random_circuits} provides the method described
 in \ref{ref:performance} to generate random circuits for both graphical and
 dense vector simulation. Using the module \lstinline{pyqcs.util.random_graphs}
-one can generate random graphical states which is faster than using random
-circuits.
+one can generate random graphical states which is more performant than using
+random circuits.
 
 The function \lstinline{pyqcs.util.to_circuit.graph_state_to_circuit} converts
 graphical states to circuits (mapping the $\ket{0b0..0}$ to this state).
-By utilization of these circuits the graphical state can be copied or converted to a
+Using these circuits the graphical state can be copied or converted to a
 dense vector state. Further it is a way to optimize circuits and later run them on 
 other simulators. Also the circuits can be exported to \lstinline{qcircuit} code
-(see below) which is a way to represent graphical states.
+(see below) which is a relatively readable way to represent graphical states.
 
-\subsection{Exporting and Flattening Circuits}
+\subsubsection{Exporting and Flattening Circuits}
 
-Circuits can be drawn with the \LaTeX  package \lstinline{qcircuit}; all
-circuits in this documents use \lstinline{qcircuit}. To visualize 
-\lstinline{pyqcs} circuits the function\\
+Circuits can be drawn using the \LaTeX  package \lstinline{qcircuit}; all
+circuits in this documents use \lstinline{qcircuit}. To visualize the circuits
+built using \lstinline{pyqcs} the function\\
 \lstinline{pyqcs.util.to_diagram.circuit_to_diagram} can be used to generate
-\lstinline{qcircuit} code. The diagrams produced by this function are not
-optimized, and the diagrams can be unnecessary long.  Usually this can be fixed
-easily by editing the resulting code manually.
+\lstinline{qcircuit} code that can be used in \LaTeX documents or exported to
+PDFs directly. The diagrams produced by this function are not optimized and the
+diagrams can be unnecessary long.  Usually this can be fixed easily by editing
+the produced code manually.
 
 The circuits constructed using the \lstinline{|} operator have a tree structure
-which is rather inconvenient when optimizing circuits or exporting them.
+which is rather unconvenient when optimizing circuits or exporting them.
 The function \\
 \lstinline{pyqcs.util.flatten.flatten} converts a circuit
-to a list of single gate circuits that can be simply analyzed or exported.
+to a list of single gate circuits that can be analyzed or exported easily.
 
 
-\section{Performance}
+\subsection{Performance}
 \label{ref:performance}
 
-Testing the performance and comparing the graphical with the dense vector
-simulator is done with the python module. Although the pure \lstinline{C}
-implementation has potential for better performance the python module is better
-comparable to the dense vector simulator which is a python module as well.
+To test the performance and compare it to the dense vector simulator the python
+module is used. Although the pure \lstinline{C} implementation has potential
+for better performance the python module is better comparable to the dense
+vector simulator which is a python module as well.
 
 For performance tests (and for tests against the dense vector simulator) random
 circuits are used. Length $m$ circuits are generated from the probability space
@@ -366,11 +350,14 @@ circuits are used. Length $m$ circuits are generated from the probability space
 
 \begin{equation}
     \Omega = \left(\{1, ..., 4n\} \otimes \{1, ..., n-1\} \otimes [0, 2\pi)\right)^{\otimes m}
-\end{equation} 
-with the uniform distribution. The continuous part $[0, 2\pi)$ is ignored when
-generating random circuits for the graphical simulator; in order to generate
-random circuits for dense vector simulations this is used as the argument $\phi$ of the
-$R_\phi$ gate.  For $m=1$ an outcome is mapped to a gate with 
+\end{equation}
+
+with the uniform distribution. The continous part $[0, 2\pi)$ is unused when
+generating random circuits for the graphical simulator; when generating random
+circuits for dense vector simulations this is the argument $\phi$ of the
+$R_\phi$ gate.
+
+For $m=1$ an outcome is mapped to a gate using
 
 \begin{equation}
 \begin{aligned}
@@ -389,14 +376,9 @@ dense vector simulator $S$ can be replaced by $R_\phi$ with the parameter $x$.
 
 Using this method circuits are generated and applied both to graphical and
 dense vector states and the time required to execute the operations
-\cite{timeit} is measured\footnote{
-    The used computer had an \lstinline{Intel(R) Core(TM) i5-4590 CPU @ 3.30GHz} processor, 
-    \lstinline{7.7 GiB} RAM, and \lstinline{27 GiB} SSD swap space (which was unused).
-    The operating system was \lstinline{Linux 4.19.0-8-amd64 #1 SMP Debian 4.19.98-1 (2020-01-26) x86_64 GNU/Linux}.
-
-}. The resulting graph can be seen in
+\cite{timeit} is measured. The resulting graph can be seen in
 Figure \ref{fig:scaling_qbits_linear} and Figure \ref{fig:scaling_qbits_log}.
-Note that in both cases the length of the circuits have been scaled linearly
+Note that in both cases the length of the circuits have been scaled linearely
 with the amount of qbits and the measured time was divided by the number of
 qbits:
 
@@ -421,10 +403,10 @@ qbits:
     \label{fig:scaling_qbits_log}
 \end{figure}
 
-The reason for this scaling will be clear later. From simulation data one can
-observe that the performance of the graphical simulator increases in some cases
-with growing number of qbits when the circuit length is constant. The code used
-to generate the data for these plots can be found in \ref{ref:code_benchmarks}.
+The reason for this scaling will be clear later; one can observe that the
+performance of the graphical simulator increases in some cases with growing
+number of qbits when the circuit length is constant. The code used to generate the
+data for these plots can be found in \ref{ref:code_benchmarks}.
 
 As described by \cite{andersbriegel2005} the graphical simulator is exponentially
 faster than the dense vector simulator. According to \cite{andersbriegel2005} it
@@ -432,12 +414,11 @@ is considerably faster than a simulator using the straight forward approach simu
 the stabilizer tableaux like CHP \cite{CHP} with an average runtime behaviour
 of $\mathcal{O}\left(n\log(n)\right)$ instead of $\mathcal{O}\left(n^2\right)$.
 
-One should be aware that the gate execution time (the time required to apply
-a gate to the state) highly depends on the  state it is applied to \cite{andersbriegel2005}. For the
-dense vector simulator and CHP this is not true: Gate execution time is
-constant for all gates and states. Because the graphical simulator has to
-toggle neighbourhoods the gate execution time of the $CZ$ and $M$ gates vary
-significantly \cite{andersbriegel2005}. The plot Figure \ref{fig:scaling_circuits_linear}
+One should be aware that the gate execution time (the time required to apply a gate
+to the state) highly depends on the  state it is applied to. For the dense vector 
+simulator and CHP this is not true: Gate execution time is constant for all gates
+and states. Because the graphical simulator has to toggle neighbourhoods the
+gate execution time of the $CZ$ gate varies greatly. The plot Figure \ref{fig:scaling_circuits_linear}
 shows the circuit execution time for two different numbers of qbits. One can observe three
 regimes:
 
@@ -449,11 +430,11 @@ regimes:
 \end{figure}
 
 \begin{description}
-    \item[Low-Linear Regime] {\textit{(Ca. $0-10N_q$ gates)} Here the circuit execution time scales approximately linear
+    \item[Low-Linear Regime] {Here the circuit execution time scales approximately linearely
         with the number of gates in the circuit (i.e. the $CZ$ gate execution time is approximately constant).
         }
-    \item[Intermediate Regime]{\textit{(Ca. $10N_q-20N_q$ gates)} The circuit execution time has a nonlinear dependence on the circuit length.}
-    \item[High-Linear Regime]{\textit{(Above ca. $20N_q$ gates)} This regime shows a linear dependence on the circuit length; the slope is
+    \item[Intermediate Regime]{The circuit execution time has a nonlinear dependence on the circuit length.}
+    \item[High-Linear Regime]{This regime shows a linear dependence on the circuit length; the slope is
         higher than in the low-linear regime.}
 \end{description}
 
@@ -464,19 +445,6 @@ regimes:
     \label{fig:scaling_circuits_measurements_linear}
 \end{figure}
 
-
-These three regimes can be explained when considering the graphical states that
-typical live in these regimes. With increased circuit length the amount of
-edges increases which makes toggling neighbourhoods harder \cite{andersbriegel2005}. Graphs from the
-low-linear, intermediate and high-linear regime can be seen in Figure
-\ref{fig:graph_low_linear_regime}, Figure \ref{fig:graph_intermediate_regime}
-and Figure \ref{fig:graph_high_linear_regime}. Due to the great amount of edges
-in the intermediate and high-linear regime the pictures show a window of the
-actual graph.  The full images are in \ref{ref:complete_graphs}.  Further the
-regimes are not clearly visible for $n>30$ qbits therefore choosing smaller graphs is
-not possible. The code that was used to generate these images can be found
-in \ref{ref:code_example_graphs}.
-
 \begin{figure}
     \centering
     \includegraphics[width=\linewidth]{graphics/graph_low_linear_regime.png}
@@ -498,34 +466,51 @@ in \ref{ref:code_example_graphs}.
     \label{fig:graph_high_linear_regime}
 \end{figure}
 
+These two regimes can be explained when considering the graphical states that
+typical live in these regimes. With increased circuit length the amount of
+edges increases which makes toggling neighbourhoods harder. Graphs from the
+low-linear, intermediate and high-linear regime can be seen in Figure
+\ref{fig:graph_low_linear_regime}, Figure \ref{fig:graph_intermediate_regime}
+and Figure \ref{fig:graph_high_linear_regime}. Due to the great amount of edges
+in the intermediate and high-linear regime the pictures show a window of the
+actual graph.  The full images are in \ref{ref:complete_graphs}.  Further the
+regimes are not clearly visibe for $n>30$ qbits so choosing smaller graphs is
+not possible. The code that was used to generate these images can be found
+in \ref{ref:code_example_graphs}.
+
 The Figure \ref{fig:scaling_circuits_measurements_linear} brings more substance
 to this interpretation. In this simulation the Pauli $X$ gate has been replaced
 by the measurement gate $M$, .i.e. in every gate drawn from the probability
-space a qbit is measured with probability $\frac{1}{4}$. Pauli measurements
-decrease the entanglement (and the amount of edges) in a state
+space a qbit is measured with probability $\frac{1}{4}$. As described in
+\cite{hein_eisert_briegel2008} the Schmidt measure for entropy is bounded from
+above by Pauli persistency, i.e. the minimal amount of Pauli measurements
+required to disentangle a state. This Pauli persistency is closely related to
+the amount (and structure of) vertices in the graph
+\cite{hein_eisert_briegel2008}. In particular Pauli measurements decrease the
+entanglement (and the amount of edges) in a state
 \cite{hein_eisert_briegel2008}\cite{li_chen_fisher2019}.  The frequent
 measurements in the simulation therefore keeps the amount of edges low thus
 preventing a transition from the low linear regime to the intermediate regime.
 
 
 Because states with more qbits reach the intermediate regime at higher circuit
-lengths it is important to compensate this virtual performance boost when
+lengths it is important to account for this virtual performance boost when
 comparing with other simulation methods. This explains why the circuit length
 in Figure \ref{fig:scaling_qbits_linear} had to be scaled with the qbit number.
 
-\section{Future Work}
+\subsection{Future Work}
 
 Although the simulator(s) are in a working state and have been tested there is
 still some work that can be done.  A noise model helping to teach and analyze
-noisy execution would be an interesting improvement to implement. In order to
-allow a user to execute circuits on other machines, including both real
-hardware and simulators, a module that exports circuits to OpenQASM
-\cite{openqasm} seems useful. 
+noisy execution is one particularly interesting piece of work.  To allow a user
+to execute circuits on other machines, including both real hardware and
+simulators, a module that exports circuits to OpenQASM \cite{openqasm} seems
+useful. 
 
 The current implementation of some graphical operations can be optimized. While
 clearing VOPs as described in \ref{ref:dynamics_graph} the neighbourhood of
 a vertex is toggled for every $L_a$ transformation. This is the most straight
-forward implementation, but often the $L_a$ transformation is performed several
+forward implementation but often the $L_a$ transformation is performed several
 times on the same vertex. The neighbourhood would have to be toggled either
 once or not at all depending on whether the number of $L_a$ transformations is
 odd or even.

thesis/chapters/introduction.tex

@@ -1,31 +1,31 @@
 % vim: ft=tex
-\chapter{Introduction}
+\section{Introduction}
 
 Quantum computing has been a rapidly growing field over the last years with
 many companies and institutions working on building and using quantum computers
-\cite{ibmq}\cite{intelqc}\cite{microsoftqc}\cite{dwavesys}.
+\cite{ibmq}\cite{intelqc}\cite{microsoftqc}\cite{dwavesys}\cite{lrzqc}\cite{heise25_18}.
 One important topic in this research is quantum error correction
 \cite{nielsen_chuang_2010}\cite{gottesman2009}\cite{gottesman1997}\cite{shor1995}
-that will allow the execution of arbitrarily long quantum circuits \cite{nielsen_chuang_2010}. 
-A notable class of quantum error correction strategies are stabilizer codes
+that will allow the execution of arbitrarily long quantum circuits \cite{nielsen_chuang_2010}. One
+important class of quantum error correction strategies are stabilizer codes
 \cite{gottesman2009}\cite{gottesman1997} that can be simulated exponentially
 faster than general quantum circuits
 \cite{gottesman_aaronson2008}\cite{CHP}\cite{andersbriegel2005}.
 
-Being able to simulate large stabilizer states is particularly interesting for 
-exploring quantum error correction strategies as fault tolerant quantum computing
-requires several layers of encoding - so called concatenated codes \cite{nielsen_chuang_2010} -
-that use many physical qbits organized in several layers to encode one logical qbit. 
-
 One particularly efficient way to simulate stabilizer states is the graphical
 representation \cite{andersbriegel2005} that has been studied extensively in
 the context of both quantum error correction and quantum information theory
 \cite{schlingenmann2001}\cite{dahlberg_ea2019}\cite{vandennest_ea2004}\cite{hein_eisert_briegel2008}.
 This paper describes the development of a quantum computing simulator 
 using both the usual dense state vector representation for a general state
-and a graphical representation for stabilizer states. After giving an introduction
-to quantum computing, some basic properties of stabilizer states and their
+and a graphical representation for stabilizer states. After giving some introduction
+to quantum computing some basic properties of stabilizer states and their
 dynamics are elucidated. Using this the graphical representation is introduced
-and notable operations on the graphical states are explained. Following is
+and some operations on the graphical states are explained. Following is
 a chapter describing the implementation of these techniques and some performance
 analysis.
+
+Being able to simulate large stabilizer states is particularly interesting for 
+exploring quantum error correction strategies as fault tolerant quantum computing
+requires several layers of encoding - so called concatenated codes \cite{nielsen_chuang_2010} -
+that require many physical qbits to encode one logical qbit. 

thesis/chapters/quantum_computing.tex

@@ -1,13 +1,13 @@
 % vim: ft=tex
-\chapter{Quantum Computing}
+\section{Quantum Computing}
 
 This chapter gives an introduction to binary quantum computing 
 and some basic properties of quantum systems such as measurement
 and time evolution. It is based on \cite{nielsen_chuang_2010}
 but introduces a notation that will often be different.
 
-\section{Qbits and Gates}
-\subsection{Single Qbits}
+\subsection{Qbits and Gates}
+\subsubsection{Single Qbits}
 
 \begin{definition}
     A qbit is a two-level quantum mechanical system \cite{nielsen_chuang_2010}, i.e. it has the eigenbasis
@@ -43,7 +43,7 @@ with
 
 Note that $X = HZH$ and $Z = R_{\pi}$, so the set of $H, R_\phi$ is sufficient. 
 Further note that the basis vectors are chosen s.t. $Z\ket{0} = +\ket{0}$ and $Z\ket{1} = -\ket{1}$;
-transforming to the other Pauli eigenstates is done using $H$ and $S$
+transforming to the other Pauli eigenstates is done using $H$ and $SH$
 
 \begin{equation}
     S := R_{\frac{\pi}{2}} = \left(\begin{array}{cc} 1 & 0 \\ 0 & i\end{array}\right)
@@ -66,7 +66,7 @@ and will be used in some calculations later:
     \end{aligned}
 \end{equation}
 
-\subsection{Many-Qbit Systems}
+\subsubsection{Many-Qbit Systems}
 \label{ref:many_qbits}
 
 \begin{postulate}
@@ -148,10 +148,10 @@ For a single-qbit gate $U$ and a qbit $j = 0, 1, ..., n - 1$
 
     In particular for $X, Z$
     \begin{equation}\label{eq:CX_pr}
-        CX_{i, j} = \ket{0}\bra{0}_j\otimes I_i + \ket{1}\bra{1}_j \otimes X_i 
+        CX(i, j) = \ket{0}\bra{0}_j\otimes I_i + \ket{1}\bra{1}_j \otimes X_i 
     \end{equation}
     \begin{equation}\label{eq:CZ_pr}
-        CZ_{i, j} = \ket{0}\bra{0}_j\otimes I_i + \ket{1}\bra{1}_j \otimes Z_i .
+        CZ(i, j) = \ket{0}\bra{0}_j\otimes I_i + \ket{1}\bra{1}_j \otimes Z_i .
     \end{equation}
 
     This follows the definition given in \cite{barenco_ea_1995}.
@@ -172,7 +172,7 @@ The matrix representation of $CX$ and $CZ$ for two qbits is given by
     CZ_{1, 0} = \left(\begin{array}{cccc} 1 & 0 & 0 & 0\\ 0 & 1 & 0 & 0\\ 0 & 0 & 1 & 0\\ 0 & 0 & 0 & -1 \end{array}\right).
 \end{equation}
 
-\subsection{Measurements}
+\subsubsection{Measurements}
 
 \begin{postulate}
     Let 
@@ -207,15 +207,13 @@ In the following discussion the term \textit{measurement gate} will be used from
 to time as a measurement can be treated similarly while doing numerics. 
 
 
-\section{Quantum Circuits}
+\subsection{Quantum Circuits}
 \label{ref:quantum_circuits}
 
 As mentioned in \ref{ref:many_qbits} one can approximate an arbitrary $n$-qbit 
 gate $U$ as a product of some single-qbit gates and either $CX$ or $CZ$.
 Writing (possibly huge) products of matrices is quite unpractical and
 unreadable. To address this problem quantum circuits have been introduced.
-The quantum circuits introduced here follow the conventions from 
-\cite{nielsen_chuang_2010}.
 These represent the qbits as a horizontal line and a gate acting on a qbit is
 a box with a name on the respective line. Quantum circuits are read from
 left to right. This means that a gate $U_i = Z_i X_i H_i$ has the
@@ -246,17 +244,8 @@ Several qbits can be abbreviated by writing a slash on the qbit line:
 }
 \]
 
-Measurements are denoted using a special "gate", the classical result
-is written as double lines:
 
-\[
-\Qcircuit @C=1em @R=.7em {
-& \gate{H} & \gate{X} & \qw & \meter & \cw \\
-}
-\]
-
-
-\section{Quantum Algorithms}
+\subsection{Quantum Algorithms}
 \label{ref:quantum_algorithms}
 
 The great hope behind quantum computing is that it will speed up some
@@ -283,8 +272,7 @@ Where $T\ket{\varphi} = \exp(2\pi i\varphi) \ket{\varphi}$ and the measurement
 result $\tilde{\varphi} = \frac{x}{2^n}$ is an estimation for $\varphi$. If
 a success rate of $1-\epsilon$ and an accuracy of $| \varphi - \tilde{\varphi}
 | < 2^{-m}$ is wanted, then $N = m + \log_2(2 + \frac{1}{2\epsilon})$ qbits are
-required \cite{nielsen_chuang_2010}.
-The gate $FT^\dagger$ is the inverse quantum fourier transform as described in \cite{nielsen_chuang_2010}.
+required \cite{nielsen_chuang_2010}\cite{lehner2019}.
 
 %Another possible way to use quantum computers in physics is to simulate a system's
 %time evolution using the transfer matrix. By mapping an interesting system to

thesis/chapters/stabilizer.tex

@@ -1,24 +1,22 @@
 % vim: ft=tex
 
-\chapter{The Stabilizer Formalism}
+\section{The Stabilizer Formalism}
 
 The stabilizer formalism was originally introduced by Gottesman
 \cite{gottesman1997} for quantum error correction and is a useful tool to
 encode quantum information such that it is protected against noise. The
 prominent Shor code \cite{shor1995} is an example of a stabilizer code
-(although it was described before the stabilizer formalism was discovered), as
+(although it was discovered before the stabilizer formalism was discovered), as
 are the 3-qbit bit-flip and phase-flip codes.
 
-It was only later that Gottesman and Knill realized that stabilizer states can
-be simulated in polynomial time on a classical machine \cite{gottesman2008}.
-This performance has since been improved to $n\log(n)$ time on average
-\cite{andersbriegel2005}.
+It was only later that Gottesman and Knill discovered that stabilizer states
+can be simulated in polynomial time on a classical machine
+\cite{gottesman2008}. This performance has since been improved to $n\log(n)$
+time on average \cite{andersbriegel2005}.
 
-\section{Stabilizers and Stabilizer States}
+\subsection{Stabilizers and Stabilizer States}
 
-The discussion below follows the argumentation given in \cite{nielsen_chuang_2010}.
-
-\subsection{Local Pauli Group and Multilocal Pauli Group}
+\subsubsection{Local Pauli Group and Multilocal Pauli Group}
 
 \begin{definition}
     \begin{equation}
@@ -41,13 +39,14 @@ either commute or anticommute.
     is called the multilocal Pauli group on $n$ qbits \cite{andersbriegel2005}. 
 \end{definition}
 
-The group property of $P_n$ and the (anti-)commutator relationships can be
-deduced from its definition via the tensor product.
+The group property of $P_n$ and the (anti-)commutator relationships follow
+directly from its definition via the tensor product.
 %Further are $p \in P_n$ hermitian and have the eigenvalues $\pm 1$ for
 %$p \neq \pm I$, $+1$ for $p = I$  and $-1$ for $p = -I$.
 
-\subsection{Stabilizers}
+\subsubsection{Stabilizers}
 
+The discussion below follows the argumentation given in \cite{nielsen_chuang_2010}.
 
 \begin{definition}
     \label{def:stabilizer}
@@ -60,19 +59,20 @@ deduced from its definition via the tensor product.
 \end{definition}
 
 \begin{lemma}
-    If $S$ is a set of stabilizers, these statements follow directly:
+    If $S$ is a set of stabilizers, the following statements follow
+    directly:
 
     \begin{enumerate}
         \item{$\pm iI \notin S$}
-        \item{$(S^{(i)})^2 = I$ $\forall i$}
-        \item{$S^{(i)}$ are hermitian $\forall i$ }
+        \item{$(S^{(i)})^2 = I$ for all $i$}
+        \item{$S^{(i)}$ are hermitian for all $i$ }
     \end{enumerate}
 \end{lemma}
 \begin{proof}
 
     \begin{enumerate}
         \item{$(iI)^2 = (-iI)^2 = -I$. Which contradicts the definition of $S$.}
-        \item{From the definition of $S$ ($P_n$ respectively) one sees that any
+        \item{From the definition of $S$ ($P_n$ respectively) follows that any
             $S^{(i)} \in S$ has the form $\pm i^l \left(\bigotimes\limits_{j=0}^{n-1} \tilde{p}_j\right)$ where
             $\tilde{p}_j \in \{X, Y, Z, I\}$ and $l \in \{0, 1\}$. As $\left(\bigotimes\limits_{j=0}^{n-1} \tilde{p}_j\right)$
             is hermitian and unitary $(S^{(i)})^2$ is either $+I$ or $-I$. As $-I \notin S$ $(S^{(i)})^2 = I$ follows directly. 
@@ -85,7 +85,7 @@ deduced from its definition via the tensor product.
 
 Considering all the elements of a group can be impractical for some
 calculations, the generators of a group are introduced. Often it is enough to
-discuss the generator's properties in order to understand those of the
+discuss the generator's properties in order to understand the properties of the
 group.
 
 \begin{definition}
@@ -99,19 +99,20 @@ group.
     $g_i$ and $m$ is the smallest integer for which these statements hold.
 \end{definition}
 
-From now on the generators $\langle S^{(i)} \rangle_{i}$ will be
+In the following discussions $\langle S^{(i)} \rangle_{i=0, ..., n-1}$ will be
 used as the required properties of a set of stabilizers that can be studied on
 its generators.
 
-\subsection{Stabilizer States}
+\subsubsection{Stabilizer States}
 \label{ref:stab_states}
 
-One important property of hermitian operators is that they have real
-eigenvalues and eigenspaces which are associated with these eigenvalues.
-Finding these eigenvalues and eigenvectors is what one calls solving a quantum
-mechanical system. It is fundamental for quantum mechanics that commuting
-operators have a common set of eigenvectors, i.e. they can be diagonalized
-simultaneously. This motivates and justifies the following definition.
+One important basic insight from quantum mechanics is that hermitian operators
+have real eigenvalues and eigenspaces which are associated with these
+eigenvalues. Finding these eigenvalues and eigenvectors is what one calls
+solving a quantum mechanical system. One of the most fundamental insights of
+quantum mechanics is that commuting operators have a common set of
+eigenvectors, i.e. they can be diagonalized simultaneously. This motivates and
+justifies the following definition.
 
 \begin{definition}
     For a set of stabilizers $S$ the vector space
@@ -127,9 +128,9 @@ simultaneously. This motivates and justifies the following definition.
 It is clear that to show the stabilization property of $S$ the proof for the
 generators is sufficient, as all the generators forming an element in $S$ can
 be absorbed into $\ket{\psi}$.  The dimension of $V_S$ is not immediately
-clear. One can show that for a set of stabilizers $\langle S^{(i)}
+clear. One can however show that for a set of stabilizers $\langle S^{(i)}
 \rangle_{i=1, ..., n-m}$ the dimension $\dim V_S = 2^m$ \cite[Chapter
-10.5]{nielsen_chuang_2010}. This yields this important result:
+10.5]{nielsen_chuang_2010}. This yields the following important result:
 
 \begin{theorem} \label{thm:unique_s_state} For a $n$ qbit system and
     stabilizers $S = \langle S^{(i)} \rangle_{i=1, ..., n}$ the stabilizer
@@ -142,17 +143,17 @@ In the following discussions for $n$ qbits a set $S = \langle S^{(i)}
 \rangle_{i=1,...,n}$ of $n$ independent stabilizers will be assumed.
 
 
-\subsection{Dynamics of Stabilizer States}
+\subsubsection{Dynamics of Stabilizer States}
 \label{ref:dynamics_stabilizer}
 
-Consider a $n$-qbit state $\ket{\psi}$ that is the $+1$ eigenstate of $S
+Consider a $n$ qbit state $\ket{\psi}$ that is the $+1$ eigenstate of $S
 = \langle S^{(i)} \rangle_{i=1,...,n}$ and a unitary transformation $U$ that
 describes the dynamics of the system, i.e. 
 
 \begin{equation} \ket{\psi'} = U \ket{\psi} \end{equation}
 
 It is clear that in general $\ket{\psi'}$ will not be stabilized by $S$
-anymore. Under some constraints there are statements that can be made
+anymore. There are however some statements that can be made
 \cite{nielsen_chuang_2010}:
 
 \begin{equation}
@@ -177,7 +178,7 @@ a set of stabilizers.
         C_n := \left\{U \in U(2^n) \middle| \forall p \in P_n: UpU^\dagger \in P_n \right\}
     \end{equation}
 
-    is called the Clifford group, $C_1 =: C_L$ the local Clifford
+    is called the Clifford group. $C_1 =: C_L$ is called the local Clifford
     group \cite{andersbriegel2005}.
 \end{definition}
 
@@ -189,8 +190,8 @@ a set of stabilizers.
             and $\sqrt{-iX} = \frac{1}{\sqrt{2}} \left(\begin{array}{cc} 1 & -i
             \\ -i & 1 \end{array}\right)$. 
 
-             When using $\sqrt{iZ}, \sqrt{-iX}$ the product has a length
-             not greater than $5$.  }
+                Also $C_L$ is generated by a product of at most $5$ matrices
+            $\sqrt{iZ}$, $\sqrt{-iX}$.  }
             \item{$C_n$ can be generated using $C_L$ and $CZ$ or $CX$.} 
     \end{enumerate} 
 \end{theorem}
@@ -210,17 +211,17 @@ a set of stabilizers.
     \end{enumerate} 
 \end{proof}
 
-This is an important result: As under a transformation $U \in C_n$ $S'
+This is quite an important result: As under a transformation $U \in C_n$ $S'
 = U S U^\dagger$ is a set of $n$ independent stabilizers and $\ket{\psi'}$ is
 stabilized by $S'$ one can consider the dynamics of the stabilizers instead of
-the actual state. Updating the $n$ stabilizers is considerably more efficient
-as each stabilizer the tensor product of $n$ Pauli matrices.  This has led to
-the simulation using stabilizer tableaux
+the actual state. This is considerably more efficient as only $n$ stabilizers
+have to be modified, each being just the tensor product of $n$ Pauli matrices.
+This has led to the simulation using stabilizer tableaux
 \cite{gottesman_aaronson2008}\cite{CHP}.
 
-\subsection{Measurements on Stabilizer States} \label{ref:meas_stab}
+\subsubsection{Measurements on Stabilizer States} \label{ref:meas_stab}
 
-Also measurements are dynamics covered by the stabilizers
+Interestingly also measurements are dynamics covered by the stabilizers
 \cite{nielsen_chuang_2010}.  When an observable $g_a \in \{\pm X_a, \pm Y_a,
 \pm Z_a\}$ acting on qbit $a$ is measured one has to consider the projector
 
@@ -228,9 +229,8 @@ Also measurements are dynamics covered by the stabilizers
 P_{g_a,s} = \frac{I + (-1)^s g_a}{2}.  
 \end{equation}
 
-If now $g_a$ commutes with all $S^{(i)}$ a result of $s=0,1$ (depending on
-whether $g_a \in S$ or $-g_a \in S$) is measured with probability $1$ and the
-stabilizers are left unchanged:
+If now $g_a$ commutes with all $S^{(i)}$ a result of $s=0$ is measured with
+probability $1$ and the stabilizers are left unchanged:
 
 \begin{equation}
     \begin{aligned}
@@ -244,14 +244,14 @@ stabilizers are left unchanged:
 As the state that is stabilized by $S$ is unique $\ket{\psi'} = \ket{\psi}$
 \cite{nielsen_chuang_2010}.  
 
-If $g_a$ does not commute with all stabilizers the Lemma \ref{lemma:stab_measurement} gives the
+If $g_a$ does not commute with all stabilizers the following lemma gives the
 result of the measurement.
 
 \begin{lemma}
     \label{lemma:stab_measurement} Let $J := \left\{ S^{(i)} \middle| [g_a,
     S^{(i)}] \neq 0\right\} \neq \{\}$ and $J^c := \left\{S^{(i)} \middle|
 S^{(i)} \notin J \right\}$. When measuring $\frac{I + (-1)^s g_a}{2} $ $s=1$
-and $s=0$ are obtained with probability $\frac{1}{2}$ and after choosing a $S^{(j)}
+and $s=0$ are obtained with probability $\frac{1}{2}$ and after choosing a $j
 \in J$ the new state $\ket{\psi'}$ is stabilized by \cite{nielsen_chuang_2010} 
     \begin{equation}
         \langle \{(-1)^s g_a\} \cup \left\{S^{(i)} S^{(j)} \middle| S^{(i)} \in J \setminus \{S^{(j)}\} \right\} \cup J^c \rangle.
@@ -259,7 +259,7 @@ and $s=0$ are obtained with probability $\frac{1}{2}$ and after choosing a $S^{(
 \end{lemma}
 
 \begin{proof}
-    As $g_a$ is a Pauli operator and $S^{(i)} \in J$ are multilocal Pauli
+    As $g_a$ is a Pauli operator and $S^{(i)} \in J$ are multi-local Pauli
     operators, $S^{(i)}$ and $g_a$ anticommute. Choose a $S^{(j)} \in J$. Then
 
     \begin{equation}
@@ -271,6 +271,7 @@ and $s=0$ are obtained with probability $\frac{1}{2}$ and after choosing a $S^{(
                 &= \left|\hbox{Tr}\left(\frac{I - g_a}{2}\ket{\psi}\bra{\psi}\right)\right|\\
                 &= P(s=1)
     \end{aligned}
+    \notag
     \end{equation}
 
     With $P(s=+1) + P(s=-1) = 1$ follows $P(s=+1) = \frac{1}{2} = P(s=-1)$.
@@ -283,20 +284,20 @@ and $s=0$ are obtained with probability $\frac{1}{2}$ and after choosing a $S^{(
             &=  S^{(j)}S^{(i)}\frac{I + (-1)^{s + 2}g_a}{2}\ket{\psi} \\
             &=  S^{(j)}S^{(i)}\frac{I + (-1)^sg_a}{2}\ket{\psi}
     \end{aligned}
+    \notag
     \end{equation}
 
-    The state after measurement is stabilized by $S^{(j)}S^{(i)}$ for $S^{(j)},S^{(i)} \in J$,
+    The state after measurement is stabilized by $S^{(j)}S^{(i)}$ $i,j \in J$,
     and by $S^{(i)} \in J^c$. $(-1)^sg_a$ trivially stabilizes $\ket{\psi'}$
     \cite{nielsen_chuang_2010}.
 \end{proof}
 
-\section{The VOP-free Graph States}
+\subsection{The VOP-free Graph States}
 This section will discuss the vertex operator (VOP)-free graph states. Why they
-are called vertex operator-free will be clear in \ref{ref:sec_g_states}.
-Most of the discussion here is adapted from \cite{hein_eisert_briegel2008}
-whith some parts from \cite{andersbriegel2005}.
+are called vertex operator-free will be clear in the following section about
+graph states.
 
-\subsection{VOP-free Graph States}
+\subsubsection{VOP-free Graph States}
 
 \begin{definition} \label{def:graph} The tuple $(V, E)$ is called a graph iff
     $V$ is a set of vertices with $|V| = n \in \mathbb{N}$ elements.  In the
@@ -310,7 +311,7 @@ called the neighbourhood of $i$ \cite{hein_eisert_briegel2008}.
 This definition of a graph is way less general than the definition of a graph
 in graph theory.  Using this definition will however allow to avoid an
 extensive list of constraints on the graph from graph theory that are implied
-here.
+in this definition.
 
 \begin{definition}
     For a graph $G = (V = \{0, ..., n-1\}, E)$ the associated stabilizers are 
@@ -323,35 +324,34 @@ here.
 \end{definition}
 
 It is clear that the $K_G^{(i)}$ are multilocal Pauli operators. That they
-commute is trivial for $\{a,b\} \notin E$. If $\{a, b\} \in E$
+commute is clear if $\{a,b\} \notin E$. If $\{a, b\} \in E$
 
 \begin{equation}
 \begin{aligned}
     K_G^{(a)} K_G^{(b)} &= X_a \left(\prod\limits_{i \in n_a} Z_i\right)
                             X_b \left(\prod\limits_{j\in n_b} Z_j\right)\\
-                        &= X_a \left(\prod\limits_{i \in n_a\setminus \{b\}} Z_i\right) Z_b
-                            X_b \left(\prod\limits_{j\in n_b\setminus \{a\}} Z_j\right) Z_a\\
+                        &= X_a \left(\prod\limits_{i \in \setminus \{b\}} Z_i\right) Z_b
+                            X_b \left(\prod\limits_{j\in n_b\setminus \{b\}} Z_j\right) Z_a\\
                         &= X_a Z_b X_b Z_a 
-                            \left(\prod\limits_{j\in n_b\setminus \{a\}} Z_j\right)
-                            \left(\prod\limits_{i \in n_a\setminus \{b\}} Z_i\right)\\
+                            \left(\prod\limits_{j\in n_b\setminus \{b\}} Z_j\right)
+                            \left(\prod\limits_{i \in \setminus \{b\}} Z_i\right)\\
                         &= -X_b Z_b X_a Z_a
-                            \left(\prod\limits_{j\in n_b\setminus \{a\}} Z_j\right)
-                            \left(\prod\limits_{i \in n_a\setminus \{b\}} Z_i\right)\\
+                            \left(\prod\limits_{j\in n_b\setminus \{b\}} Z_j\right)
+                            \left(\prod\limits_{i \in \setminus \{b\}} Z_i\right)\\
                         &= X_b Z_a X_a Z_b
-                            \left(\prod\limits_{j\in n_b\setminus \{a\}} Z_j\right)
-							\left(\prod\limits_{i \in n_a \setminus \{b\}} Z_i\right)\\
+                            \left(\prod\limits_{j\in n_b\setminus \{b\}} Z_j\right)
+							\left(\prod\limits_{i \in \setminus \{b\}} Z_i\right)\\
 					    &=  K_G^{(b)} K_G^{(a)}.\\
 \end{aligned}
 \end{equation}
 
 
-This definition of a graph state might not seem too helpful but recalling
-Theorem \ref{thm:unique_s_state} it is clear that $\ket{\bar{G}}$ is unique.
-Lemma \ref{lemma:g_bar} will provide a way to construct this state from the
+This definition of a graph state might not seem to be straight forward but
+recalling Theorem \ref{thm:unique_s_state} it is clear that $\ket{\bar{G}}$ is
+unique. The following lemma will provide a way to construct this state from the
 graph. 
 
 \begin{lemma}
-    \label{lemma:g_bar}
     For a graph $G = (V, E)$ the associated state $\ket{\bar{G}}$ is
     constructed using \cite{hein_eisert_briegel2008}
 
@@ -446,7 +446,7 @@ graph.
     %of $K_G^{(i)}$ and $\ket{\tilde{G}}$.
 \end{proof}
 
-\subsection{Dynamics of the VOP-free Graph States}
+\subsubsection{Dynamics of the VOP-free Graph States}
 
 This representation gives an immediate result to how the stabilizers $\langle
 K_G^{(i)} \rangle_i$ change under the $CZ$ gate: When applying $CZ_{i,j}$ on $G
@@ -472,18 +472,18 @@ Another transformation on the VOP-free graph states for a vertex $a \in V$ is
 \end{equation}
 
 This transformation toggles the neighbourhood of $a$ which is an operation
-that will be used later \cite{andersbriegel2005}.
+that will be used later\cite{andersbriegel2005}.
 
 \begin{lemma}
     \label{lemma:M_a}
     When applying $M_a$ to a state $\ket{\bar{G}}$ the new state
     $\ket{\bar{G}'}$ is again a VOP-free graph state and the 
-    graph is updated according to \cite{andersbriegel2005}:
+    graph is updated according to\cite{andersbriegel2005}:
     \begin{equation}
         \begin{aligned}
             n_a' &= n_a \\
             n_j' &= n_j, \hbox{ if } j \notin n_a\\
-            n_j' &= n_j \Delta n_a \setminus \{j\}, \hbox{ if } j \in n_a
+            n_j' &= n_j \Delta n_a, \hbox{ if } j \in n_a
         \end{aligned}
     \end{equation}
 \end{lemma}
@@ -509,7 +509,7 @@ that will be used later \cite{andersbriegel2005}.
                 &= \sqrt{iZ_j} X_j\sqrt{iZ_j}^\dagger\left(\prod\limits_{m \in n_j \setminus \{a\}} Z_m\right) 
                                 \sqrt{-iX_a} Z_a \sqrt{-iX_a}^\dagger \\
                 &= (-1)^2 Y_j Y_a \left(\prod\limits_{m \in n_j \setminus \{a\}} Z_m\right)\\
-                &= (-1)i^2 Z_j X_a X_j Z_a \left(\prod\limits_{m \in n_j \setminus \{a\}} Z_m\right).
+                &= (-1)i^2 Z_j X_a X_j Z_a \left(\prod\limits_{m \in n_j \setminus \{a\}} Z_m\right)
         \end{aligned}
     \end{equation}
 
@@ -517,8 +517,8 @@ that will be used later \cite{andersbriegel2005}.
     \ket{\bar{G}}$ is the $+1$ eigenstate of the new $K_{G'}^{(i)}$. Because
     $\forall i\in V\setminus n_a$ $[K_G^{(i)}, M_a] = 0$ it is clear that
     $\forall j \notin n_a$  $K_{G'}^{(j)} = K_G^{(j)}$.  To construct the
-    $K_{G'}^{(i)}$ choose a $j \in n_a$ and partition the neighbourhoods $n_a
-    =: \{j\} \cup F$ and $n_j =: \{a\} \cup D$.  Then follows:
+    $K_{G'}^{(i)}$ let for some $j \in n_a$ $n_a =: \{j\} \cup F$ and $n_j =:
+    \{a\} \cup D$.  Then follows:
 
     \begin{equation}
         \begin{aligned}
@@ -526,7 +526,7 @@ that will be used later \cite{andersbriegel2005}.
                     &= Z_j X_a X_j Z_a \left(\prod\limits_{l \in D} Z_l\right)
                                         \left(\prod\limits_{l \in F}Z_l\right)
                                         \left(\prod\limits_{l \in F}Z_l\right) \\
-                    &= Z_j X_a X_j Z_a \left(\prod\limits_{l \in ((F\cup D) \setminus (F\cap D))} Z_l\right)
+                    &= Z_j X_a X_j Z_a \left(\prod\limits_{l \in ((F\cup D) \setminus (F\cap D))} Z_L\right)
                                         \left(\prod\limits_{l \in F}Z_l\right) \\
                     &= K_{G'}^{(a)} K_{G'}^{(j)} \\
                     &= K_{G}^{(a)} K_{G'}^{(j)}
@@ -543,32 +543,31 @@ that will be used later \cite{andersbriegel2005}.
     Because $\left\{K_G^{(i)} \middle| i \notin n_a\right\} \cup \left\{S^{(i)}
     \middle| i\in n_a\right\}$ and $\left\{K_G^{(i)} \middle| i \notin
 n_a\right\} \cup \left\{K_{G'}^{(i)} \middle| i\in n_a \right\}$ are both $n$
-commuting multilocal Pauli operators where the $S^{(i)}$ can be generated from
+commuting multi-local Pauli operators where the $S^{(i)}$ can be generated from
 the $K_{G'}^{(i)}$ and $\ket{\bar{G}'}$ is a $+1$ eigenstate of $K_{G'}^{(j)}$
 $\langle\left\{K_G^{(i)} \middle| i \notin n_a\right\} \cup \left\{K_{G'}^{(i)}
 \middle| i\in n_a \right\}\rangle$ are the stabilizers of $\ket{\bar{G}'}$.
 Therefore the associated graph is changed as given in the third equation.
 \end{proof}
 
-\section{Graph States}
-\label{ref:sec_g_states}
+\subsection{Graph States}
 
 The definition of a VOP-free graph state above raises an obvious question: Can
-any stabilizer state be described using just a graph?  The answer is no. The
-most simple cases are the single qbit states $\ket{0},\ket{1}$ and $\ket{+_Y},
-\ket{-_Y}$. But there is an extension to the VOP-free graph states that allows
-the representation of an arbitrary stabilizer state. The proof that any
-state can be represented is purely constructive. As seen in Theorem
-\ref{thm:clifford_group_approx} any $c \in C_n$ can be constructed from $CZ$
-and $C_L$. In the following discussion it will become clear that both $C_L$ and
-$CZ$ can be applied to a general graph state
+any stabilizer state be described using just a graph?  The answer is straight
+forward: No. The most simple cases are the single qbit states $\ket{0},\ket{1}$
+and $\ket{+_Y}, \ket{-_Y}$. But there is an extension to the VOP-free graph
+states that allows the representation of an arbitrary stabilizer state. The
+proof that indeed any state can be represented is purely constructive. As seen
+in Theorem \ref{thm:clifford_group_approx} any $c \in C_n$ can be constructed
+from $CZ$ and $C_L$. In the following discussion it will become clear that both
+$C_L$ and $CZ$ can be applied to a general graph state
 \footnote{
     One can show that any stabilizer state is local Clifford equivalent to
     a VOP-free graph state, i.e. only tensor products of $C_L$ matrices are
     required to map a stabilizer state to a VOP-free graph state \cite{andersbriegel2005}.
 }.
 
-\subsection{Graph States and Vertex Operators}
+\subsubsection{Graph States and Vertex Operators}
 \label{ref:g_states_vops}
 
 \begin{definition}
@@ -588,9 +587,9 @@ $CZ$ can be applied to a general graph state
     The notation in \cite{andersbriegel2005} is different. Instead of using $(V, E, O)$
     to represent any stabilizer $(V, E)$ is used to represent what is called a VOP-free
     graph state in this paper. Then the state $\ket{\bar{G}}$ is extended with local Clifford
-    gates $c_1, ..., c_n$ to an arbitrary stabilizer state. The full state is denoted as
+    gates $c_1, ..., c_n$ to an arbitrary stabilizer state. The state is then denoted as
     $\ket{\bar{G}; (c_1, ..., c_n)} \equiv \ket{\bar{G}; \vec{c}}$. This paper prefers 
-    the notation $(V, E, O)$ as it both emphasizes the use of stabilizers and is closer
+    the notation using $(V, E, O)$ as it both emphasizes the use of stabilizers and is closer
     to the representation used in the simulator.
     }. 
 \end{definition}
@@ -604,33 +603,30 @@ immediately:
 
 The great advantage of this representation of a stabilizer state is its space
 requirement: Instead of storing $n^2$ Pauli matrices only some vertices (which
-are implicit when choosing $V=\{0, ..., n-1\}$), the edges and some vertex
-operators ($n$ matrices) have to be stored. Theorem \ref{thm:cl24} will improve
-this even further: Instead of $n$ matrices it is sufficient to store $n$
-integers representing the vertex operators.
+often are implicit), the edges and some vertex operators ($n$ matrices) have to
+be stored. The following theorem will improve this even further: instead of $n$
+matrices it is sufficient to store $n$ integers representing the vertex
+operators:
 
 \begin{theorem}
-    \label{thm:cl24}
     $C_L$ has $24$ degrees of freedom disregarding a global phase \cite{andersbriegel2005}.
 \end{theorem}
-\begin{proof} It is clear that any $a \in C_L$ is a group isomorphism $P
+\begin{proof} It is clear that $\forall a \in C_L$ a is a group isomorphism $P
     \rightarrow P$: $apa^\dagger a p' a^\dagger = a pp'a^\dagger$.  Therefore
     $a$ will preserve the (anti-)commutator relations of $P$.  Further note
-    that $Y = iXZ$, so one has to consider the (anti-)commutator relations of
+    that $Y = iXZ$, so one has to consider the anti-commutator relations of
     $X,Z$ only.
 
     As the transformations are unitary they preserve eigenvalues, so $X$ can be
     mapped to $\pm X, \pm Y, \pm Z$ which gives $6$ degrees of freedom.
-    Furthermore the image of $Z$ has to anti-commute with the image of $X$ therefore
+    Furthermore the image of $Z$ has to anti-commute with the image of $X$ so
     $Z$ has four possible images under the transformation.  This gives another
-$4$ degrees of freedom and a total of $24$.  
-\end{proof}
+$4$ degrees of freedom and a total of $24$.  \end{proof}
 
 From now on $C_L = \langle H, S \rangle$ (disregarding a global phase) will be
 used.  One can show (by construction) that $H, S$ generate a possible choice of
 $C_L$, as do $\sqrt{-iX}, \sqrt{-iZ}$ which is required in one specific
-operation on graph states \cite{andersbriegel2005}. All elements of $C_L$ can 
-be found in \ref{ref:impl_g_states}.
+operation on graph states \cite{andersbriegel2005}.
 
 \begin{equation}
     S = \left(\begin{array}{cc} 1 & 0 \\ 0 & i \end{array}\right)
@@ -643,17 +639,17 @@ be found in \ref{ref:impl_g_states}.
 \end{equation}
 
 
-\subsection{Dynamics of Graph States}
+\subsubsection{Dynamics of Graph States}
 \label{ref:dynamics_graph}
 
 So far the graphical representation of stabilizer states is just another way to
 store basically a stabilizer tableaux that might require less memory than the
-tableaux used in CHP \cite{CHP}. The power of this formalism can be seen by
+tableaux used in CHP\cite{CHP}. The true power of this formalism is seen when
 studying its dynamics. The simplest case is a local Clifford operator $c_j$
-acting on a qbit $j$ changing the stabilizers to $\langle c_j S^{(i)}
+acting on a qbit $j$: The stabilizers are changed to $\langle c_j S^{(i)}
 c_j^\dagger\rangle_i$. Using the definition of the graphical representation one
 sees that just the vertex operators are changed and the new vertex operators
-are given by \cite{andersbriegel2005}
+are given by
 
 \begin{equation}
     \begin{aligned}
@@ -663,9 +659,9 @@ are given by \cite{andersbriegel2005}
 \end{equation}
 
 The action of a $CZ$ gate on the state $(V, E, O)$ is in most cases less
-trivial.  Let $a \neq b$ be two qbits. Consider the action of $CZ_{a,b}$ on
+trivial.  Let $a \neq b$ be two qbits, now consider the action of $CZ_{a,b}$ on
 $(V, E, O)$.  The cases given here follow the implementation of a $CZ$
-application in \cite{pyqcs}. The respective paragraphs from
+application in \cite{pyqcs}, the respective paragraphs from
 \cite{andersbriegel2005} are given in italic.  Most of the discussion follows
 the one given in \cite{andersbriegel2005} closely.
 
@@ -686,7 +682,7 @@ options with and without an edge between the qbits and $24$ Clifford operators
 on each vertex.
 
 All those states and the resulting state after a $CZ$ application can be
-computed which leads to another interesting insight that will be useful later:
+computed which leads to another interesting result that will be useful later:
 If one vertex has the vertex operator $I$ the resulting state can be chosen
 such that at least one of the vertex operators is $I$ again and in particular
 the identity on the vertex can be preserved under the application of a $CZ$.
@@ -697,7 +693,7 @@ has non-operand (i.e. neighbours that are neither $a$ nor $b$) neighbours. In
 this case one can try to clear the vertex operators which will succeed for at
 least one qbit.
 
-The transformation given in Lemma \ref{lemma:M_a} is used to clear the vertex
+The transformation given in Lemma \ref{lemma:M_a} is used to "clear" the vertex
 operators. Recalling that the transformation $M_j$ toggles the neighbourhood of
 vertex $j$ gives substance to the following theorem:
 
@@ -734,7 +730,7 @@ steps:
         }
 \end{enumerate}
 
-This algorithm has the important properties that if it succeeds $o_a
+This algorithm has the important properties that if the algorithm succeeds $o_a
 = I$ and $o_b$ has picked up powers of $\sqrt{iZ}^\dagger$.  If $b$ has
 non-operand neighbours after clearing the vertex operators on $a$, then the
 vertex operators on $b$ can be cleared using the same algorithm which gives
@@ -755,31 +751,30 @@ non-operand neighbours and $b$ does not. Now the state $\ket{G}$ has the form
     \begin{aligned}
         \ket{G} &= \left(\prod\limits_{o_i \in O} o_i\right) \left(\prod\limits_{\{i,j\} \in E} CZ_{i,j}\right) \ket{+}_n \\
                 &= \left(\prod\limits_{o_i \in O \setminus \{o_b\}} o_i \right) \left(\prod\limits_{\{i,j\} \in E \setminus \{a,b\}} CZ_{i,j}\right) o_b (CZ_{a,b})^s \ket{+}_n \\
-                &= \left(\prod\limits_{o_i \in O \setminus \{o_b\}} o_i \right) \left(\prod\limits_{\{i,j\} \in E \setminus \{a,b\}} CZ_{i,j}\right) \ket{+}_{n-2} \otimes \left(o_b (CZ_{a,b})^s \ket{+}_2\right).\\
+                &= \left(\prod\limits_{o_i \in O \setminus \{o_b\}} o_i \right) \left(\prod\limits_{\{i,j\} \in E \setminus \{a,b\}} CZ_{i,j}\right) \ket{+}_{n-2} \otimes \left(o_b (CZ_{a,b})^s \ket{+}_2\right) .\\
     \end{aligned}
 \end{equation}
 
 As $o_b$ commutes with all operators but $CZ_{a,b}$ and $s \in \{0, 1\}$
-indicates whether there is an edge between $a$ and $b$. Applying the $CZ$
-gives
+indicates whether there is an edge between $a$ and $b$.
 
 \begin{equation}
     \begin{aligned}
         CZ_{a,b}\ket{G} &= CZ_{a,b}\left(\prod\limits_{o_i \in O \setminus \{o_b\}} o_i \right) \left(\prod\limits_{\{i,j\} \in E \setminus \{a,b\}} CZ_{i,j}\right) o_b (CZ_{a,b})^s \ket{+} \\
-                        &= \left(\prod\limits_{o_i \in O \setminus \{o_b\}} o_i \right) \left(\prod\limits_{\{i,j\} \in E \setminus \{a,b\}} CZ_{i,j}\right) \ket{+}_{n-2} \otimes \left(CZ_{a,b} o_b (CZ_{a,b})^s \ket{+}_2\right). \\
+                        &= \left(\prod\limits_{o_i \in O \setminus \{o_b\}} o_i \right) \left(\prod\limits_{\{i,j\} \in E \setminus \{a,b\}} CZ_{i,j}\right) \ket{+}_{n-2} \otimes \left(CZ_{a,b} o_b (CZ_{a,b})^s \ket{+}_2\right) \\
     \end{aligned}
 \end{equation}
 
-This allows to reuse the method in Case 2 to apply the $CZ$ while keeping the
+This allows to re-use the method in Case 2 to apply the $CZ$ while keeping the
 $o_a = I$.
 
 As it has been shown how both $CZ$ and $C_L$  act on a graph state $\ket{G}$
 and the resulting state is a graph state as well this proofs constructively
-that the graphical representation of a stabilizer state is able to represent
-any stabilizer state.  If one wants to do computations using this formalism it
-is also necessary to perform measurements.
+that the graphical representation of a stabilizer state is indeed able to
+represent any stabilizer state.  If one wants to do computations using this
+formalism it is however also necessary to perform measurements.
 
-\subsection{Measurements on Graph States}
+\subsubsection{Measurements on Graph States}
 \label{ref:meas_graph}
 
 This is adapted from \cite{andersbriegel2005}; measurement results and updating
@@ -787,13 +782,13 @@ the graph after a measurement is described in \cite{hein_eisert_briegel2008}.
 
 Recalling \ref{ref:meas_stab} it is clear that one has to compute the
 commutator of the observable $g_a = Z_a$ with the stabilizers to get the
-probability amplitudes which is an expensive computation in theory. It is
+probability amplitudes which is a quite expensive computation in theory. It is
 possible to simplify the problem by pulling the observable behind the vertex
 operators. For this consider the projector $P_{a,s} = \frac{I + (-1)^sZ_a}{2}$
 
 \begin{equation}
     \begin{aligned}
-        P_{a,s} \ket{G} &= P_{a,s} \left(\prod\limits_{o_i \in O} o_i \right) \ket{\bar{G}} \\
+        P_{a,s} \ket{\psi} &= P_{a,s} \left(\prod\limits_{o_i \in O} o_i \right) \ket{\bar{G}} \\
                         &= \left(\prod\limits_{o_i \in O \setminus \{o_a\}}o_i \right)P_a  o_a \ket{\bar{G}} \\
                         &= \left(\prod\limits_{o_i \in O \setminus \{o_a\}}o_i \right) o_a o_a^\dagger P_a o_a \ket{\bar{G}} \\
                         &= \left(\prod\limits_{o_i \in O} o_i \right) o_a^\dagger P_a o_a \ket{\bar{G}} \\
@@ -813,11 +808,11 @@ projector as $o_a$ is a Clifford operator
     \end{aligned}
 \end{equation}
 
-Where $\tilde{g}_a \in \{\pm X_a, \pm Y_a, \pm Z_a\}$. Therefore, it is enough
-to study the measurements of any Pauli operator on the VOP-free graph states.
-The commutators of the observable with the $K_G^{(i)}$ are easy to compute.
-Note that Pauli matrices either commute or anticommute and it is simpler to
-list the operators that anticommute:
+Where $\tilde{g}_a \in \{\pm X_a, \pm Y_a, \pm Z_a\}$. Therefore, it is
+enough to study the measurements of any Pauli operator on the vertex operator
+free graph states. The commutators of the observable with the $K_G^{(i)}$ are
+quite easy to compute. Note that Pauli matrices either commute or anticommute
+and it is easier to list the operators that anticommute:
 
 \begin{equation}
     \begin{aligned}
@@ -832,26 +827,25 @@ $\tilde{g}_a = X_a (-X_a)$ is measured the result $s=0(1)$ is obtained with
 probability $1$ and $(V, E, O)$ is unchanged.  In any other case the results
 $s=1$ and $s=0$ have probability $\frac{1}{2}$ and both graph and vertex
 operators have to be updated. Further it is clear that measurements of
-$-\tilde{g}_a$ and $\tilde{g}_a$ are related by inverting the result $s$.
+$-\tilde{g}_a$ and $\tilde{g}_a$ are related by just inverting the result $s$.
 
 The calculations to obtain the transformation on graph and vertex operators are
 lengthy and follow the scheme of Lemma \ref{lemma:M_a}. \cite[Section
 IV]{hein_eisert_briegel2008} also contains the steps required to obtain the
-following results:
+following results
 
 \begin{equation}
     \begin{aligned}
         U_{Z,s} &= \left(\prod\limits_{b \in n_a} Z_b^s\right) X_a^s H_a \\
-        U_{Y,s} &= \prod\limits_{b \in n_a} \sqrt{(-1)^{1-s} iZ_b} \sqrt{(-1)^{1-s} iZ_a}\\
+        U_{Y,s} &= \prod\limits_{b \in n_a} \sqrt{(-1)^{1-s} iZ_b} \sqrt{(-1)^{1-s} iZ_a}.\\
     \end{aligned}
 \end{equation}
 
-These transformations split it in two parts: the first is a result of Lemma
+These transformations split it two parts: the first is a result of Lemma
 \ref{lemma:stab_measurement}.  The second part makes sure that the qbit $a$ is
-diagonal in the measured observable and has the correct eigenvalue.  When comparing
-with Lemma \ref{lemma:stab_measurement} in both cases $Y$ and $Z$ the anticommuting
+diagonal in measured observable and has the correct eigenvalue.  When comparing
+with Lemma \ref{lemma:stab_measurement} in both cases $Y,Z$ the anticommuting
 stabilizer $K_G^{(a)}$ is chosen. The graph is changed according to
-\footnote{$n_a \otimes n_a$ should be read as $\{\{i,j\} | i,j \in n_a, i \neq j\}$.}
 
 \begin{equation}
     \begin{aligned}
@@ -861,7 +855,7 @@ stabilizer $K_G^{(a)}$ is chosen. The graph is changed according to
 \end{equation}
 
 
-For $g_a = X_a$ one has to choose a neighbour $b \in n_a$ and the transformations are
+For $g_a = X_a$ one has to choose a $b \in n_a$ and the transformations are
 
 \begin{equation}
     \begin{aligned}

thesis/main.bib

@@ -21,7 +21,7 @@
     CHP,
     url={https://www.scottaaronson.com/chp/},
     urldate={09.03.2020},
-    author={Scott Aaronson and Daniel Gottesman},
+    author={Scott Aaronson, Daniel Gottesman},
     title={CHP: CNOT-Hadamard-Phase},
     year=2005,
     note={https://www.scottaaronson.com/chp/}
@@ -39,7 +39,6 @@
     andersbriegel2005,
     title={Fast simulation of stabilizer circuits using a graph state representation},
     author={Simon Anders and Hans J. Briegel},
-    note={http://arxiv.org/abs/quant-ph/0504117v2},
     year=2005
 }
 @book{
@@ -52,7 +51,7 @@
 @book{
     kaye_ea2007,
     title={An Introduction to Quantum Computing},
-    author={Phillip Kaye and Raymond Laflamme and Michelle Mosca},
+    author={Phillip Kaye, Raymond Laflamme and Michelle Mosca},
     year=2007,
     publisher={Oxford University Press}
 }
@@ -76,7 +75,7 @@
     gottesman_aaronson2008,
     title={Improved Simulation of Stabilizer Circuits},
     year=2008,
-    author={Daniel Gottesman and Scott Aaronson},
+    author={Daniel Gottesman, Scott Aaronson},
     note={https://arxiv.org/abs/quant-ph/0406196v5}
 }
 
@@ -107,7 +106,7 @@
     nielsen_chuang_2010,
     title={Quantum Computation and Quantum Information},
     year=2010,
-    author={Michael A. Nielsen and Isaac L. Chuang},
+    author={Michael A. Nielsen, Isaac L. Chuang},
     publisher={CAMBRIDGE UNIVERSITY PRESS},
     note={www.cambridge.org/9781107002173}
 }
@@ -124,7 +123,7 @@
     marquezino_ea_2019,
     title={A Primer on Quantum Computing},
     year=2019,
-    author={Franklin de Lima Marquezino and Renato Portugal and Carlile Lavor},
+    author={Franklin de Lima Marquezino, Renato Portugal, Carlile Lavor},
     publisher={Springer}
 }
 @article{
@@ -156,7 +155,7 @@
     hein_eisert_briegel2008,
     title={Multi-party entanglement in graph states},
     year=2008,
-    author={M. Hein and J. Eisert and H.J. Briegel},
+    author={M. Hein, J. Eisert, H.J. Briegel},
     note={https://arxiv.org/abs/quant-ph/0307130v7}
 }
 @article{
@@ -191,13 +190,11 @@
     urldate={19.09.2019},
     title={IBM Q - What is quantum computing?},
     author={IBM},
-    note={https://www.ibm.com/quantum-computing/learn/what-is-quantum-computing/},
     year=2019
 }
 @online{
     intelqc,
     url={https://newsroom.intel.com/press-kits/quantum-computing/\#gs.2s0dux},
-    note={https://newsroom.intel.com/press-kits/quantum-computing/\#gs.2s0dux},
     urldate={19.09.2019},
     title={Intel Press Kit: Quantum Computing},
     author={Intel},
@@ -206,7 +203,6 @@
 @online{
     microsoftqc,
     url={https://www.microsoft.com/en-us/quantum/default.aspx},
-    note={https://www.microsoft.com/en-us/quantum/default.aspx},
     urldate={19.09.2019},
     title={Quantum Computing | Microsoft},
     author={Microsoft},
@@ -215,7 +211,6 @@
 @online{
 	dwavesys,
 	url={https://www.dwavesys.com/quantum-computing},
-	note={https://www.dwavesys.com/quantum-computing},
     urldate={19.09.2019},
     title={Quantum Computing | D-Wave Systems},
     author={D-Wave Systems Inc}
@@ -223,7 +218,6 @@
 @online{
 	lrzqc,
 	url={https://www.lrz.de/wir/newsletter/2019-08/\#LRZ_bereit_fuer_bayerische_Quantechnologie},
-	note={https://www.lrz.de/wir/newsletter/2019-08/\#LRZ_bereit_fuer_bayerische_Quantechnologie},
     urldate={19.09.2019},
     title={LRZ-Newsletter Nr. 08/2019 vom 01.08.2019},
     author={S. Vieser},
@@ -232,7 +226,6 @@
 @online{
 	heise25_18,
 	url={https://www.heise.de/select/ct/2018/25/1544250249368810},
-	note={https://www.heise.de/select/ct/2018/25/1544250249368810},
     urldate={19.09.2019},
     title={Europa entfesselt Quanten-Power},
     author={Arne Grävemeyer},
@@ -241,14 +234,14 @@
 @article{
     li_chen_fisher2019,
     year=2019,
-    author={Yaodong Li and Xiao Chen and Matthew P. A. Fisher},
+    author={Yaodong Li, Xiao Chen, Matthew P. A. Fisher},
     title={Measurement-driven entanglement transition in hybrid quantum circuits},
     note={https://arxiv.org/abs/1901.08092}
 }
 @article{
     bermejovega_lin_vdnest2015,
     year=2015,
-    author={Juan Bermejo-Vega and Cedric Yen-Yu Lin and Maarten Van den Nest},
+    author={Juan Bermejo-Vega, Cedric Yen-Yu Lin, Maarten Van den Nest},
     title={Normalizer circuits and a Gottesman-Knill theoremfor infinite-dimensional systems},
     note={https://arxiv.org/pdf/1409.3208.pdf}
 }
@@ -269,7 +262,7 @@
 @article{
     bermejovega_vdnest2018,
     year=2018,
-    author={Juan Bermejo-Vega and Maarten Van den Nest},
+    author={Juan Bermejo-Vega, Maarten Van den Nest},
     title={Classical simulations of Abelian-group normalizer circuits with intermediate measurements},
     note={https://arxiv.org/abs/1210.3637v2}
 }
@@ -294,10 +287,3 @@
     title={The Computer Language Benchmarks Game},
     note={https://benchmarksgame-team.pages.debian.net/benchmarksgame/}
 }
-@article{
-    bouchet1991,
-    author={Andrk Bouchet},
-    title={Recognizing locally equivalent graphs},
-    year=1991,
-    note={https://pdf.sciencedirectassets.com/271536/1-s2.0-S0012365X00X02166/1-s2.0-0012365X9390357Y/main.pdf}
-}

thesis/main.tex

@@ -1,4 +1,4 @@
-\documentclass[a4paper,12pt,numbers=noenddot,egregdoesnotlikesansseriftitles]{scrreprt}
+\documentclass[a4paper,12pt,numbers=noenddot,egregdoesnotlikesansseriftitles]{scrartcl}
 \usepackage[utf8]{inputenc} 
 \usepackage{graphicx} 
 \usepackage{amssymb, amsthm}
@@ -52,18 +52,18 @@ Supervised by Prof. Dr. Christoph Lehner}
 
     {\LARGE University of Regensburg\par}
     {\Large Institute I - Theoretical Physics\par}
-    \vspace{0.7cm}
+    \vspace{1cm}
     {\Large Bachelor Thesis\par}
-    \vspace{0.7cm}
+    \vspace{1cm}
     {\huge\bfseries An Efficient Quantum Computing Simulator using a Graphical Description for Many-Qbit Systems \par}
-    \vspace{0.7cm}
+    \vspace{1cm}
     {\Large\itshape Daniel Knüttel\par}
 
     \includegraphics[width=\textwidth]{cover.png}
 
     \vfill
     {\Large\itshape Supervised by \par
-    Prof. Dr. Christoph Lehner}
+    Dr. Christoph Lehner}
     \vfill
     {\large 10.04.2020}
 \end{titlepage}
@@ -82,34 +82,16 @@ Supervised by Prof. Dr. Christoph Lehner}
 \include{chapters/appendix}
 \end{appendices}
 
-\newpage
-\listoffigures
-
 \bibliographystyle{unsrt} 
 \bibliography{main}{}
 
-\newpage
-{\Large\textbf{Acknowledgements}}
-\\
-\\
-I want to thank Prof. Dr. Christoph Lehner for offering me the possibility to
-write this thesis in his workgroup. He also found the time to answer my
-questions and help me when I got stuck while keeping an inspiring atmosphere.\\
-Further I own a big thank you to Simon Feyrer for proof-reading my thesis. \\
-Also I want to thank Andreas Hackl for proof-reading my thesis and helping out
-with several technical problems.\\
-Thanks to Shirley Galbaw for helping to fix some of my terrible ingris grammar.
-
-
-
 \newpage
 \textbf{Erklärung zur Anfertigung:}\\
-Ich habe die Arbeit selbständig verfasst, keine anderen als die angegebenen
-Quellen und Hilfsmittel benutzt und bisher keiner anderen Prüfungsbehörde
-vorgelegt. Außerdem bestätige ich hiermit, dass die vorgelegten Druckexemplare
-und die vorgelegte elektronische Version der Arbeit identisch sind, dass ich
-über wissenschaftlich korrektes Arbeiten und Zitieren aufgeklärt wurde und dass
-ich von den in § 24 Abs.  5 vorgesehenen Rechtsfolgen Kenntnis habe.
+Ich habe die Arbeit selbständig verfasst, keine anderen als die angegebenen Quellen und Hilfsmittel be-
+nutzt und bisher keiner anderen Prüfungsbehörde vorgelegt. Außerdem bestätige ich hiermit, dass die
+vorgelegten Druckexemplare und die vorgelegte elektronische Version der Arbeit identisch sind, dass ich
+über wissenschaftlich korrektes Arbeiten und Zitieren aufgeklärt wurde und dass ich von den in § 24 Abs.
+5 vorgesehenen Rechtsfolgen Kenntnis habe.
 \\
 \\
 Unterschrift: