/
build_results.py
executable file
·122 lines (98 loc) · 5.93 KB
/
build_results.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
#!/usr/bin/env python3
from __future__ import print_function
import time
import pickle
import pygsti
from pygsti.construction import std2Q_XYCNOT
gs_target = pygsti.construction.build_gateset(
[4], [('Q0','Q1')],['Gix','Giy','Gxi','Gyi','Gcnot'],
[ "X(pi/2,Q1)", "Y(pi/2,Q1)", "X(pi/2,Q0)", "Y(pi/2,Q0)", "CNOT(Q0,Q1)" ],
prepLabels=['rho0'], prepExpressions=["0"],
effectLabels=['E0','E1','E2'], effectExpressions=["0","1","2"],
spamdefs={'upup': ('rho0','E0'), 'updn': ('rho0','E1'),
'dnup': ('rho0','E2'), 'dndn': ('rho0','remainder') }, basis="pp")
gs_targetB = pygsti.construction.build_gateset(
[4], [('Q0','Q1')],['Gix','Giy','Gxi','Gyi','Gcnot'],
[ "I(Q0):X(pi/2,Q1)", "I(Q0):Y(pi/2,Q1)", "X(pi/2,Q0):I(Q1)", "Y(pi/2,Q0):I(Q1)", "CNOT(Q0,Q1)" ],
prepLabels=['rho0'], prepExpressions=["0"],
effectLabels=['E0','E1','E2'], effectExpressions=["0","1","2"],
spamdefs={'upup': ('rho0','E0'), 'updn': ('rho0','E1'),
'dnup': ('rho0','E2'), 'dndn': ('rho0','remainder') }, basis="pp")
# If you're lucky and your gateset is one of pyGSTi's "standard" gate sets, you can just import it.
gs_targetC = std2Q_XYCNOT.gs_target
#check that these are all the same
assert(abs(gs_target.frobeniusdist(gs_targetB)) < 1e-6)
assert(abs(gs_target.frobeniusdist(gs_targetC)) < 1e-6)
# ### Step 2: Obtain lists of fiducial and germ gate sequences
# These are the building blocks of the gate sequences performed in the experiment. Typically, these lists are either given to you by the folks at Sandia National Labs (email pygsti@sandia.gov), provided by pyGSTi because you're using a "standard" gate set, or computed using "fiducial selection" and "germ selection" algorithms (which are a part of pyGSTi, but not covered in this tutorial).
# In[4]:
#If you know the fiducial strings you can create a list manually. Note
# that in general there can be different "preparation" and "measurement"
# (or "effect") fiducials.
prep_fiducials = pygsti.construction.gatestring_list( [ (), ('Gix',), ('Giy',), ('Gix','Gix'),
('Gxi',), ('Gxi','Gix'), ('Gxi','Giy'), ('Gxi','Gix','Gix'),
('Gyi',), ('Gyi','Gix'), ('Gyi','Giy'), ('Gyi','Gix','Gix'),
('Gxi','Gxi'), ('Gxi','Gxi','Gix'), ('Gxi','Gxi','Giy'), ('Gxi','Gxi','Gix','Gix') ] )
effect_fiducials = pygsti.construction.gatestring_list( [(), ('Gix',), ('Giy',),
('Gix','Gix'), ('Gxi',),
('Gyi',), ('Gxi','Gxi'),
('Gxi','Gix'), ('Gxi','Giy'),
('Gyi','Gix'), ('Gyi','Giy')] )
#Or, if you're lucky, you can just import them
prep_fiducialsB = std2Q_XYCNOT.prepStrs
effect_fiducialsB = std2Q_XYCNOT.effectStrs
#check that these are the same
assert(prep_fiducials == prep_fiducialsB)
assert(effect_fiducials == effect_fiducialsB)
#Use fiducial sequences to create a "spam specifiers" object, telling
# GST which preparation and measurement fiducials to follow and precede which
# state preparation and effect operators, respectively.
specs = pygsti.construction.build_spam_specs(
prepStrs=prep_fiducials,
effectStrs=effect_fiducials,
prep_labels=gs_target.get_prep_labels(),
effect_labels=gs_target.get_effect_labels() )
#Alternatively, if you're lucky, you can grab the specs directly:
specsB = std2Q_XYCNOT.specs
assert(specs[0] == specsB[0])
# In[5]:
#germ lists can be specified in the same way. In this case, there are
# 71 germs required to do honest GST. Since this would crowd this tutorial
# notebook, we create some smaller lists of germs manually and import the
# full 71-germ list from std2Q_XYCNOT
germs4 = pygsti.construction.gatestring_list(
[ ('Gix',), ('Giy',), ('Gxi',), ('Gyi',) ] )
germs11 = pygsti.construction.gatestring_list( [ ('Gix',), ('Giy',), ('Gxi',), ('Gyi',), ('Gcnot',), ('Gxi','Gyi'), ('Gix','Giy'), ('Gix','Gcnot'), ('Gxi','Gcnot'), ('Giy','Gcnot'), ('Gyi','Gcnot') ] )
germs71 = std2Q_XYCNOT.germs
#A list of maximum lengths for each GST iteration
maxLengths = [1,2,4]
#Create a list of GST experiments for this gateset, with
#the specified fiducials, germs, and maximum lengths. We use
#"germs4" here so that the tutorial runs quickly; really, you'd
#want to use germs71!
listOfExperiments = pygsti.construction.make_lsgst_experiment_list(gs_target.gates.keys(), prep_fiducials,
effect_fiducials, germs4, maxLengths)
#Create an empty dataset file, which stores the list of experiments
# and zerod-out columns where data should be inserted. Note the use of the SPAM
# labels in the "Columns" header line.
pygsti.io.write_empty_dataset("tutorial_files/My2QDataTemplate.txt", listOfExperiments,
"## Columns = upup count, updn count, dnup count, dndn count")
#Generate some "fake" (simulated) data based on a depolarized version of the target gateset
gs_datagen = gs_target.depolarize(gate_noise=0.1, spam_noise=0.001)
ds = pygsti.construction.generate_fake_data(gs_datagen, listOfExperiments, nSamples=1000,
sampleError="multinomial", seed=2016)
start = time.time()
'''
results = pygsti.do_long_sequence_gst(ds, gs_target, prep_fiducials, effect_fiducials, germs4,
maxLengths, gaugeOptParams={'itemWeights': {'spam':0.1,'gates': 1.0}},
advancedOptions={ 'depolarizeStart' : 0.1 }, memLimit=3*(1024)**3,
verbosity=3 )
'''
results = pygsti.do_long_sequence_gst(ds, gs_target, prep_fiducials, effect_fiducials, germs4,
maxLengths, gaugeOptParams=None,
advancedOptions={ 'depolarizeStart' : 0.1 }, memLimit=3*(1024)**3,
verbosity=3 )
end = time.time()
print("Total time=%f hours" % ((end - start) / 3600.0))
#If you wanted to, you could pickle the results for later analysis:
pickle.dump(results, open("gaugeopt/2qbit_results.pkl", "wb"))