The gate sequences used in standard Long Sequence GST are more than what are needed to amplify every possible gate error. (Technically, this is due to the fact that the informationaly complete fiducial sub-sequences allow extraction of each germ's entire process matrix, when all that is needed is the part describing the amplified directions in gate set space.) Because of this over-completeness, fewer sequences, i.e. experiments, may be used whilst retaining the desired Heisenberg-like scaling ($\sim 1/L$, where $L$ is the maximum length sequence). The over-completeness can still be desirable, however, as it makes the GST optimization more robust to model violation and so can serve to stabilize the GST parameter optimization in the presence of significant non-Markovian noise. Recall that the form of a GST gate sequence is
$$S = F_i (g_k)^n F_j $$where $F_i$ is a "preparation fiducial" sequence, $F_j$ is a "measurement fiducial" sequence, and "g_k" is a "germ" sequence. The repeated germ sequence $(g_k)^n$ we refer to as a "germ-power". There are currently three different ways to reduce a standard set of GST gate sequences within pyGSTi, each of which removes certain $(F_i,F_j)$ fiducial pairs for certain germ-powers.
We now demonstrate how to invoke each of these methods within pyGSTi for the case of a single qubit, using our standard $X(\pi/2)$, $Y(\pi/2)$, $I$ gateset. First, we retrieve a target GateSet
as usual, along with corresponding sets of fiducial and germ sequences. We set the maximum length to be 32, roughly consistent with our data-generating gate set having gates depolarized by 10%.
import matplotlib
matplotlib.use("Agg") #so report creation works within ipython notebooks
#Import pyGSTi and the "stardard 1-qubit quantities for a gateset with X(pi/2), Y(pi/2), and idle gates"
import pygsti
import pygsti.construction as pc
from pygsti.construction import std1Q_XYI
#Collect a target gate set, germ and fiducial strings, and set
# a list of maximum lengths.
gs_target = std1Q_XYI.gs_target
prep_fiducials = std1Q_XYI.fiducials
meas_fiducials = std1Q_XYI.fiducials
germs = std1Q_XYI.germs
maxLengths = [0,1,2,4,8,16,32]
gateLabels = list(gs_target.gates.keys())
print("Gate labels = ", gateLabels)
Gate labels = ['Gi', 'Gx', 'Gy']
Now let's generate a list of all the gate sequences for each maximum length - so a list of lists. We'll generate the full lists (without any reduction) and the lists for each of the three reduction types listed above. In the random reduction case, we'll keep 30% of the fiducial pairs, removing 70% of them.
#Make list-of-lists of GST gate sequences
fullLists = pc.make_lsgst_lists(
gateLabels, prep_fiducials, meas_fiducials, germs, maxLengths)
#Print the number of gate sequences for each maximum length
print("** Without any reduction ** ")
for L,lst in zip(maxLengths,fullLists):
print("L=%d: %d gate sequences" % (L,len(lst)))
#Make a (single) list of all the GST sequences ever needed,
# that is, the list of all the experiments needed to perform GST.
fullExperiments = pc.make_lsgst_experiment_list(
gateLabels, prep_fiducials, meas_fiducials, germs, maxLengths)
print("\n%d experiments to run GST." % len(fullExperiments))
** Without any reduction ** L=0: 92 gate sequences L=1: 92 gate sequences L=2: 168 gate sequences L=4: 441 gate sequences L=8: 817 gate sequences L=16: 1201 gate sequences L=32: 1585 gate sequences 1585 experiments to run GST.
fidPairs = pygsti.alg.find_sufficient_fiducial_pairs(
gs_target, prep_fiducials, meas_fiducials, germs,
searchMode="random", nRandom=100, seed=1234,
verbosity=1, memLimit=int(2*(1024)**3), minimumPairs=2)
# fidPairs is a list of (prepIndex,measIndex) 2-tuples, where
# prepIndex indexes prep_fiducials and measIndex indexes meas_fiducials
print("Global FPR says we only need to keep the %d pairs:\n %s\n"
% (len(fidPairs),fidPairs))
gfprLists = pc.make_lsgst_lists(
gateLabels, prep_fiducials, meas_fiducials, germs, maxLengths,
fidPairs=fidPairs)
print("Global FPR reduction")
for L,lst in zip(maxLengths,gfprLists):
print("L=%d: %d gate sequences" % (L,len(lst)))
gfprExperiments = pc.make_lsgst_experiment_list(
gateLabels, prep_fiducials, meas_fiducials, germs, maxLengths,
fidPairs=fidPairs)
print("\n%d experiments to run GST." % len(gfprExperiments))
------ Fiducial Pair Reduction -------- maximum number of amplified parameters = 34 Beginning search for a good set of 2 pairs (630 pair lists to test) Beginning search for a good set of 3 pairs (7140 pair lists to test) Global FPR says we only need to keep the 3 pairs: [(2, 3), (5, 1), (5, 2)] Global FPR reduction L=0: 92 gate sequences L=1: 92 gate sequences L=2: 100 gate sequences L=4: 130 gate sequences L=8: 163 gate sequences L=16: 196 gate sequences L=32: 229 gate sequences 229 experiments to run GST.
fidPairsDict = pygsti.alg.find_sufficient_fiducial_pairs_per_germ(
gs_target, prep_fiducials, meas_fiducials, germs,
searchMode="random", constrainToTP=True,
nRandom=100, seed=1234, verbosity=1,
memLimit=int(2*(1024)**3))
print("\nPer-germ FPR to keep the pairs:")
for germ,pairsToKeep in fidPairsDict.items():
print("%s: %s" % (str(germ),pairsToKeep))
pfprLists = pc.make_lsgst_lists(
gateLabels, prep_fiducials, meas_fiducials, germs, maxLengths,
fidPairs=fidPairsDict) #note: fidPairs arg can be a dict too!
print("\nPer-germ FPR reduction")
for L,lst in zip(maxLengths,pfprLists):
print("L=%d: %d gate sequences" % (L,len(lst)))
pfprExperiments = pc.make_lsgst_experiment_list(
gateLabels, prep_fiducials, meas_fiducials, germs, maxLengths,
fidPairs=fidPairsDict)
print("\n%d experiments to run GST." % len(pfprExperiments))
------ Individual Fiducial Pair Reduction -------- Progress: [##################################################] 100.0% -- GxGxGyGxGyGy germ (4 params) Per-germ FPR to keep the pairs: GxGiGy: [(1, 3), (1, 4), (4, 0), (5, 0)] Gi: [(0, 0), (1, 1), (5, 1), (5, 2)] GxGyGi: [(1, 3), (1, 4), (4, 0), (5, 0)] GxGxGyGxGyGy: [(1, 3), (1, 4), (4, 0), (5, 0)] GxGyGyGi: [(0, 2), (1, 3), (1, 4), (4, 4), (5, 0), (5, 2)] GyGiGi: [(0, 0), (0, 5), (1, 1), (4, 4)] Gx: [(0, 0), (0, 4), (3, 3), (5, 2)] Gy: [(0, 0), (0, 5), (1, 1), (4, 4)] GxGy: [(1, 3), (1, 4), (4, 0), (5, 0)] GxGiGi: [(0, 0), (0, 4), (3, 3), (5, 2)] GxGxGiGy: [(0, 2), (0, 4), (1, 3), (2, 5), (3, 2), (4, 4)] Per-germ FPR reduction L=0: 92 gate sequences L=1: 92 gate sequences L=2: 99 gate sequences L=4: 138 gate sequences L=8: 185 gate sequences L=16: 233 gate sequences L=32: 281 gate sequences 281 experiments to run GST.
#keep only 30% of the pairs
rfprLists = pc.make_lsgst_lists(
gateLabels, prep_fiducials, meas_fiducials, germs, maxLengths,
keepFraction=0.30, keepSeed=1234)
print("Random FPR reduction")
for L,lst in zip(maxLengths,rfprLists):
print("L=%d: %d gate sequences" % (L,len(lst)))
rfprExperiments = pc.make_lsgst_experiment_list(
gateLabels, prep_fiducials, meas_fiducials, germs, maxLengths,
keepFraction=0.30, keepSeed=1234)
print("\n%d experiments to run GST." % len(rfprExperiments))
Random FPR reduction L=0: 92 gate sequences L=1: 92 gate sequences L=2: 113 gate sequences L=4: 207 gate sequences L=8: 324 gate sequences L=16: 442 gate sequences L=32: 561 gate sequences 561 experiments to run GST.
In each case above, we constructed (1) a list-of-lists giving the GST gate sequences for each maximum-length stage, and (2) a list of the experiments. In what follows, we'll use the experiment list to generate some simulated ("fake") data for each case, and then run GST on it. Since this is done in exactly the same way for all three cases, we'll put all of the logic in a function.
#use a depolarized version of the target gates to generate the data
gs_datagen = gs_target.depolarize(gate_noise=0.1, spam_noise=0.001)
def runGST(gstLists, exptList):
#Use list of experiments, expList, to generate some data
ds = pc.generate_fake_data(gs_datagen, exptList,
nSamples=1000,sampleError="binomial", seed=1234)
#Pass in list-of-lists of GST sequences as 'lsgstLists' argument
return pygsti.do_long_sequence_gst(
ds, gs_target, prep_fiducials, meas_fiducials,
germs, maxLengths,lsgstLists=gstLists, verbosity=1)
print("\n------ GST with standard (full) sequences ------")
full_results = runGST(fullLists, fullExperiments)
print("\n------ GST with GFPR sequences ------")
gfpr_results = runGST(gfprLists, gfprExperiments)
print("\n------ GST with PFPR sequences ------")
pfpr_results = runGST(pfprLists, pfprExperiments)
print("\n------ GST with RFPR sequences ------")
rfpr_results = runGST(rfprLists, rfprExperiments)
------ GST with standard (full) sequences ------ --- LGST --- --- Iterative MLGST: [##################################################] 100.0% 1585 gate strings --- Iterative MLGST Total Time: 11.0s ------ GST with GFPR sequences ------ --- LGST --- --- Iterative MLGST: [##################################################] 100.0% 229 gate strings --- Iterative MLGST Total Time: 3.4s ------ GST with PFPR sequences ------ --- LGST --- --- Iterative MLGST: [##################################################] 100.0% 281 gate strings --- Iterative MLGST Total Time: 7.0s ------ GST with RFPR sequences ------ --- LGST --- --- Iterative MLGST: [##################################################] 100.0% 561 gate strings --- Iterative MLGST Total Time: 11.8s
Finally, one can generate reports using GST with reduced-sequences:
full_results.create_full_report_pdf(
filename="tutorial_files/example_stdstrs_report.pdf")
gfpr_results.create_full_report_pdf(
filename="tutorial_files/example_gfpr_report.pdf")
pfpr_results.create_full_report_pdf(
filename="tutorial_files/example_pfpr_report.pdf")
rfpr_results.create_full_report_pdf(
filename="tutorial_files/example_rfpr_report.pdf")
If all has gone well, the Standard GST, GFPR, PFPR, and RFPR, reports may now be viewed. The only notable difference in the output are "gaps" in the color box plots which plot quantities such as the log-likelihood across all gate sequences, organized by germ and fiducials (see figure 2 in each report).