# An overview of Gate Set tomography the function-based way.¶

This tutorial shows you how to run gate set tomography using the older-style function-centric API. This can be useful in certain scenarios, but most of the time it's easier to use the newer, object-oriented approach outlined in the main GST overview tutorial. For more details and options for running GST, see the GST circuits tutorial and the tutorial covering the different pyGSTi functions for running GST.

To run GST, we need three inputs:

1. a "target model" which describes the desired, or ideal, operations we want our experimental hardware to perform. In the example below, we use one of pyGSTi's build-in "model packs" (see the tutorial on model packs) - which acts on a single qubit with the following operations:

• three gates: the identity, and $\pi/2$ rotations around the $x$- and $y$-axes.
• a single state preparation in the $|0\rangle$ state.
• a 2-outcome measurement with the label "0" associated with measuring $|0\rangle$ and "1" with measuring $|1\rangle$.
2. a list of circuits tailored to the target model; essentially a list of what experiments we need to run. Using a standard model makes things especially straightforward here, since the building blocks, called germ and fiducial circuits, needed to make good GST circuits have already been computed (see the tutorial on GST circuits).

3. data, in the form of experimental outcome counts, for each of the required sequences. In this example we'll generate "fake" or "simulated" data from a depolarized version of our ideal model. For more information about DataSet objects, see the tutorial on DataSets.

In [ ]:
#Import the pygsti module (always do this) and the XYI model pack
import pygsti
from pygsti.modelpacks import smq1Q_XYI

# 1) get the target Model
target_model = smq1Q_XYI.target_model()

# 2) get the building blocks needed to specify which operation sequences are needed
prep_fiducials, meas_fiducials = smq1Q_XYI.prep_fiducials(), smq1Q_XYI.meas_fiducials()
germs = smq1Q_XYI.germs()
maxLengths = [1,2,4,8,16,32] # roughly gives the length of the sequences used by GST

# 3) generate "fake" data from a depolarized version of target_model
mdl_datagen = target_model.depolarize(op_noise=0.01, spam_noise=0.001)
listOfExperiments = pygsti.construction.make_lsgst_experiment_list(
target_model, prep_fiducials, meas_fiducials, germs, maxLengths)
ds = pygsti.construction.generate_fake_data(mdl_datagen, listOfExperiments, n_samples=1000,
sample_error="binomial", seed=1234)

#Note: from listOfExperiments we can also create an empty dataset file
# which has columns of zeros where actual data should go.
pygsti.io.write_empty_dataset("../tutorial_files/GettingStartedDataTemplate.txt", listOfExperiments,
"## Columns = 0 count, 1 count")
# After replacing the zeros with actual data, the data set can be
# loaded back into pyGSTi using the line below and used in the rest
# of this tutorial.


Now that we have all of the inputs, we can run GST in a standard way using the do_stdpractice_gst function. For more information about this and related functions, see the GST methods tutorial. This returns a pygsti.report.Results object (see the Results tutorial), from which we can generate a report giving us a summary of the analysis.

In [ ]:
#Run GST and create a report
results = pygsti.do_stdpractice_gst(ds, target_model, prep_fiducials, meas_fiducials,
germs, maxLengths, verbosity=3)

pygsti.report.construct_standard_report(
results, title="GST Overview Tutorial Example Report", verbosity=2
).write_html("../tutorial_files/gettingStartedReport", verbosity=2)


You can now open the file ../tutorial_files/gettingStartedReport/main.html in your browser (Firefox works best) to view the report. That's it! You've just run GST!

In the cell above, results is a Results object, which is used to generate a HTML report. For more information see the Results object tutorial and report generation tutorial.

In [ ]: