Compare commits
No commits in common. "master" and "titlepage" have entirely different histories.
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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")
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
|
@ -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
|
||||
|
|
|
|||
|
|
|
@ -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
|
||||
|
|
|
|||
|
|
|
@ -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
|
||||
|
|
|
|||
|
|
|
@ -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}
|
||||
|
|
@ -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")
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
@ -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])
|
||||
|
|
|
|||
|
|
@ -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])
|
||||
|
|
|
|||
|
|
@ -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])
|
||||
|
|
|
|||
Binary file not shown.
|
Before Width: | Height: | Size: 133 KiB After Width: | Height: | Size: 167 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 160 KiB After Width: | Height: | Size: 196 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 164 KiB After Width: | Height: | Size: 227 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 133 KiB After Width: | Height: | Size: 183 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 142 KiB After Width: | Height: | Size: 173 KiB |
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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))
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 12 KiB |
|
|
@ -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)
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 14 KiB |
|
|
@ -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)
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 31 KiB |
|
|
@ -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)
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 27 KiB |
|
|
@ -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)
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 32 KiB |
|
|
@ -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)
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 8.2 KiB |
|
|
@ -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)
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 7.6 KiB |
|
|
@ -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)
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 18 KiB |
|
|
@ -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)
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
Binary file not shown.
|
Before Width: | Height: | Size: 145 KiB |
|
|
@ -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):
|
||||
|
|
|
|||
|
|
@ -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")
|
||||
|
|
|
|||
2
pyqcs
2
pyqcs
|
|
@ -1 +1 @@
|
|||
Subproject commit 51efe195fe0378b0b9c4bad0ff6eefb1f17e4b3a
|
||||
Subproject commit bcebc7860c47e4d8d1f5ec79b816032f31d8138d
|
||||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
@ -117,7 +117,6 @@ the Clifford group \cite{vandennest2018}.
|
|||
|
||||
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}.
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
@ -367,10 +351,13 @@ 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
|
||||
|
||||
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.
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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}
|
||||
|
|
|
|||
BIN
thesis/cover.png
BIN
thesis/cover.png
Binary file not shown.
|
Before Width: | Height: | Size: 133 KiB After Width: | Height: | Size: 183 KiB |
|
|
@ -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}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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:
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user