jupyter_notebooks/Tutorials/objects/advanced/GSTCircuitConstruction.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fiducials, Germs, and Max-Lengths (oh my!)\n",
    "This tutorial discusses the creation of `Circuit` objects for use with Gate Set Tomography (GST).  If you're not sure what a `Circuit` is, you might want to read through the [tutorial on circuits](../Circuit.ipynb) first. \n",
    "\n",
    "While pyGSTi allows one to create arbitrary lists of circuits, the GST algorithms have been designed to work well with circuits that have a particular structure.  At the beginning and the end of each string are \"preparation fiducial\" and \"measurement fiducial\" circuits (or \"sequences\"), respectively, whose purpose is to extend the native preparation and measurment operations to informationally complete sets.  In between the fiducial sequences is a \"germ\" sequence, or just \"germ\", that is repeated some number of times.  The purpose of the repeated-germ sequence is to amplify one or more particular types of errors.  By considering an entire set of germs (called an \"amplificationally complete\" set), *all* possible types of errors are amplified, giving the GST algorithms high sensitivity to all errors.  The longer the sequences, that is, the more repetitions of the germs, the higher the sensitivity.  \n",
    "\n",
    "While this may seem to imply that one should just to incredibly long sequences, there are several caveats.\n",
    "1) Because the gates are imperfect, there is some practical length (possibly germ-dependent) at which the initial state is so depolarized that it cannot be distinguished from the maximally-mixed state.  This sets an upper bound on the length of useful circuits.\n",
    "2) Because GST's numerical algorithms use local gradient-based optimization methods, starting with circuits of maximal length would often result in getting trapped in a local minima of the function being optimized (often the likelihood).  The GST algorithms iterate through multiple circuit lists, using the result of the previous iteration to seed the next one.  When operation sequences lists are chosen well they are able guide the GST optimization to a global (or near-global) maximum by *gradually* making the objective function sharper.\n",
    "\n",
    "In practice, well-chosen lists of operation sequences can be formed as follows.  First, we defne an increasing sequence of **maximum-lengths**, usually powers of 2, e.g. `[1,2,4,8,16,...]`, which terminates with the longest useful sequence length.  Secondly, we select preparation- and measurement-fiducial `Circuit` lists, and a list of germ circuits.  These lists are chosen such that the fiducial sequences result in informationally complete preparations and measurements, and the germs are amplificationally complete.  For each maximum-length $L$, the set of all\n",
    "\n",
    "`preparation_fiducial + repeated_germ + measurement_fiducial`\n",
    "\n",
    "sequences, where `preparation_fiducial` ranges over all preparation fiducials, `measurement_fiducial` ranges over all measurement fiducials, and `repeated_germ` ranges over all the germs *repeated such that the length of `repeated_germ` does not exceed $L$*.  To further increase the robustness of the numerics, the circuit list corresponding to $L$ will also contain all of the sequences from earlier (lower) values of $L$.  This procedure thus creates a list of operation sequences for each $L$ that are designed for use by pyGSTi's \"long-sequence\" GST algorithms.\n",
    "\n",
    "The fiducial and germ lists are obtained by pyGSTi's \"fiducial selection\" and \"germ selection\" algorithms, which are explained in more detail in the [tutorial on fiducial and germ selection](../algorithms/advanced/GST-FiducialAndGermSelection.ipynb).  This this tutorial we'll be using one of pyGSTi's \"standard\" models (see the [standard module tutorial](StandardModules.ipynb)), for which fiducial and germ sequences are pre-computed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Prep fiducials:\n",
      " [Circuit({}), Circuit(Gx), Circuit(Gy), Circuit(GxGx), Circuit(GxGxGx), Circuit(GyGyGy)]\n",
      "Meas fiducials:\n",
      " [Circuit({}), Circuit(Gx), Circuit(Gy), Circuit(GxGx), Circuit(GxGxGx), Circuit(GyGyGy)]\n",
      "Germs:\n",
      " [Circuit(Gx), Circuit(Gy), Circuit(GxGy), Circuit(GxGxGy), Circuit(GxGyGy), Circuit(GxGxGyGxGyGy)]\n"
     ]
    }
   ],
   "source": [
    "import pygsti\n",
    "from pygsti.construction import std1Q_XY #import the standard X(pi/2), Y(pi/2) model info\n",
    "\n",
    "prep_fiducials = std1Q_XY.prepStrs\n",
    "meas_fiducials = std1Q_XY.effectStrs\n",
    "germs = std1Q_XY.germs\n",
    "\n",
    "print(\"Prep fiducials:\\n\", prep_fiducials)\n",
    "print(\"Meas fiducials:\\n\", meas_fiducials)\n",
    "print(\"Germs:\\n\",germs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now construct a the lists of sequences used by a long-sequence GST algorithm by defining a list of maximum lenghts and calling `make_lsgst_lists`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "List 0 (max-length L=1): 56 Circuits\n",
      "{}\n",
      "Gx\n",
      "Gy\n",
      "GxGx\n",
      "GxGxGx\n",
      "GyGyGy\n",
      "GxGy\n",
      "GxGxGxGx\n",
      "GxGyGyGy\n",
      "GyGx\n",
      "GyGy\n",
      "GyGxGx\n",
      "GyGxGxGx\n",
      "GyGyGyGy\n",
      "GxGxGy\n",
      "GxGxGxGxGx\n",
      "GxGxGyGyGy\n",
      "GxGxGxGy\n",
      "GxGxGxGxGxGx\n",
      "GxGxGxGyGyGy\n",
      "GyGyGyGx\n",
      "GyGyGyGxGx\n",
      "GyGyGyGxGxGx\n",
      "GyGyGyGyGyGy\n",
      "Gy(Gx)Gy\n",
      "Gy(Gx)GxGxGx\n",
      "Gy(Gx)GyGyGy\n",
      "GxGxGx(Gx)Gy\n",
      "GxGxGx(Gx)GxGxGx\n",
      "GxGxGx(Gx)GyGyGy\n",
      "GyGyGy(Gx)Gy\n",
      "GyGyGy(Gx)GxGxGx\n",
      "GyGyGy(Gx)GyGyGy\n",
      "Gx(Gy)Gx\n",
      "Gx(Gy)Gy\n",
      "Gx(Gy)GxGx\n",
      "Gx(Gy)GxGxGx\n",
      "Gx(Gy)GyGyGy\n",
      "Gy(Gy)Gx\n",
      "Gy(Gy)GxGx\n",
      "Gy(Gy)GxGxGx\n",
      "Gy(Gy)GyGyGy\n",
      "GxGx(Gy)Gx\n",
      "GxGx(Gy)Gy\n",
      "GxGx(Gy)GxGx\n",
      "GxGx(Gy)GxGxGx\n",
      "GxGx(Gy)GyGyGy\n",
      "GxGxGx(Gy)Gx\n",
      "GxGxGx(Gy)Gy\n",
      "GxGxGx(Gy)GxGx\n",
      "GxGxGx(Gy)GxGxGx\n",
      "GxGxGx(Gy)GyGyGy\n",
      "GyGyGy(Gy)Gx\n",
      "GyGyGy(Gy)GxGx\n",
      "GyGyGy(Gy)GxGxGx\n",
      "GyGyGy(Gy)GyGyGy\n",
      "\n",
      "List 1 (max-length L=2): 96 Circuits\n",
      "{}\n",
      "Gx\n",
      "Gy\n",
      "GxGx\n",
      "GxGxGx\n",
      "GyGyGy\n",
      "GxGy\n",
      "GxGxGxGx\n",
      "GxGyGyGy\n",
      "GyGx\n",
      "GyGy\n",
      "GyGxGx\n",
      "GyGxGxGx\n",
      "GyGyGyGy\n",
      "GxGxGy\n",
      "GxGxGxGxGx\n",
      "GxGxGyGyGy\n",
      "GxGxGxGy\n",
      "GxGxGxGxGxGx\n",
      "GxGxGxGyGyGy\n",
      "GyGyGyGx\n",
      "GyGyGyGxGx\n",
      "GyGyGyGxGxGx\n",
      "GyGyGyGyGyGy\n",
      "Gy(Gx)Gy\n",
      "Gy(Gx)GxGxGx\n",
      "Gy(Gx)GyGyGy\n",
      "GxGxGx(Gx)Gy\n",
      "GxGxGx(Gx)GxGxGx\n",
      "GxGxGx(Gx)GyGyGy\n",
      "GyGyGy(Gx)Gy\n",
      "GyGyGy(Gx)GxGxGx\n",
      "GyGyGy(Gx)GyGyGy\n",
      "Gx(Gy)Gx\n",
      "Gx(Gy)Gy\n",
      "Gx(Gy)GxGx\n",
      "Gx(Gy)GxGxGx\n",
      "Gx(Gy)GyGyGy\n",
      "Gy(Gy)Gx\n",
      "Gy(Gy)GxGx\n",
      "Gy(Gy)GxGxGx\n",
      "Gy(Gy)GyGyGy\n",
      "GxGx(Gy)Gx\n",
      "GxGx(Gy)Gy\n",
      "GxGx(Gy)GxGx\n",
      "GxGx(Gy)GxGxGx\n",
      "GxGx(Gy)GyGyGy\n",
      "GxGxGx(Gy)Gx\n",
      "GxGxGx(Gy)Gy\n",
      "GxGxGx(Gy)GxGx\n",
      "GxGxGx(Gy)GxGxGx\n",
      "GxGxGx(Gy)GyGyGy\n",
      "GyGyGy(Gy)Gx\n",
      "GyGyGy(Gy)GxGx\n",
      "GyGyGy(Gy)GxGxGx\n",
      "GyGyGy(Gy)GyGyGy\n",
      "Gy(Gx)^2Gy\n",
      "Gy(Gx)^2GxGxGx\n",
      "Gy(Gx)^2GyGyGy\n",
      "GxGxGx(Gx)^2Gy\n",
      "GxGxGx(Gx)^2GxGxGx\n",
      "GxGxGx(Gx)^2GyGyGy\n",
      "GyGyGy(Gx)^2Gy\n",
      "GyGyGy(Gx)^2GxGxGx\n",
      "GyGyGy(Gx)^2GyGyGy\n",
      "Gx(Gy)^2Gx\n",
      "Gx(Gy)^2GxGx\n",
      "Gx(Gy)^2GxGxGx\n",
      "Gx(Gy)^2GyGyGy\n",
      "GxGx(Gy)^2Gx\n",
      "GxGx(Gy)^2GxGx\n",
      "GxGx(Gy)^2GxGxGx\n",
      "GxGx(Gy)^2GyGyGy\n",
      "GxGxGx(Gy)^2Gx\n",
      "GxGxGx(Gy)^2GxGx\n",
      "GxGxGx(Gy)^2GxGxGx\n",
      "GxGxGx(Gy)^2GyGyGy\n",
      "GyGyGy(Gy)^2Gx\n",
      "GyGyGy(Gy)^2GxGx\n",
      "GyGyGy(Gy)^2GxGxGx\n",
      "GyGyGy(Gy)^2GyGyGy\n",
      "Gy(GxGy)Gx\n",
      "Gy(GxGy)Gy\n",
      "Gy(GxGy)GxGx\n",
      "Gy(GxGy)GxGxGx\n",
      "Gy(GxGy)GyGyGy\n",
      "GxGxGx(GxGy)Gx\n",
      "GxGxGx(GxGy)Gy\n",
      "GxGxGx(GxGy)GxGx\n",
      "GxGxGx(GxGy)GxGxGx\n",
      "GxGxGx(GxGy)GyGyGy\n",
      "GyGyGy(GxGy)Gx\n",
      "GyGyGy(GxGy)Gy\n",
      "GyGyGy(GxGy)GxGx\n",
      "GyGyGy(GxGy)GxGxGx\n",
      "GyGyGy(GxGy)GyGyGy\n",
      "\n",
      "List 2 (max-length L=4): 189 Circuits\n",
      "{}\n",
      "Gx\n",
      "Gy\n",
      "GxGx\n",
      "GxGxGx\n",
      "GyGyGy\n",
      "GxGy\n",
      "GxGxGxGx\n",
      "GxGyGyGy\n",
      "GyGx\n",
      "GyGy\n",
      "GyGxGx\n",
      "GyGxGxGx\n",
      "GyGyGyGy\n",
      "GxGxGy\n",
      "GxGxGxGxGx\n",
      "GxGxGyGyGy\n",
      "GxGxGxGy\n",
      "GxGxGxGxGxGx\n",
      "GxGxGxGyGyGy\n",
      "GyGyGyGx\n",
      "GyGyGyGxGx\n",
      "GyGyGyGxGxGx\n",
      "GyGyGyGyGyGy\n",
      "Gy(Gx)Gy\n",
      "Gy(Gx)GxGxGx\n",
      "Gy(Gx)GyGyGy\n",
      "GxGxGx(Gx)Gy\n",
      "GxGxGx(Gx)GxGxGx\n",
      "GxGxGx(Gx)GyGyGy\n",
      "GyGyGy(Gx)Gy\n",
      "GyGyGy(Gx)GxGxGx\n",
      "GyGyGy(Gx)GyGyGy\n",
      "Gx(Gy)Gx\n",
      "Gx(Gy)Gy\n",
      "Gx(Gy)GxGx\n",
      "Gx(Gy)GxGxGx\n",
      "Gx(Gy)GyGyGy\n",
      "Gy(Gy)Gx\n",
      "Gy(Gy)GxGx\n",
      "Gy(Gy)GxGxGx\n",
      "Gy(Gy)GyGyGy\n",
      "GxGx(Gy)Gx\n",
      "GxGx(Gy)Gy\n",
      "GxGx(Gy)GxGx\n",
      "GxGx(Gy)GxGxGx\n",
      "GxGx(Gy)GyGyGy\n",
      "GxGxGx(Gy)Gx\n",
      "GxGxGx(Gy)Gy\n",
      "GxGxGx(Gy)GxGx\n",
      "GxGxGx(Gy)GxGxGx\n",
      "GxGxGx(Gy)GyGyGy\n",
      "GyGyGy(Gy)Gx\n",
      "GyGyGy(Gy)GxGx\n",
      "GyGyGy(Gy)GxGxGx\n",
      "GyGyGy(Gy)GyGyGy\n",
      "Gy(Gx)^2Gy\n",
      "Gy(Gx)^2GxGxGx\n",
      "Gy(Gx)^2GyGyGy\n",
      "GxGxGx(Gx)^2Gy\n",
      "GxGxGx(Gx)^2GxGxGx\n",
      "GxGxGx(Gx)^2GyGyGy\n",
      "GyGyGy(Gx)^2Gy\n",
      "GyGyGy(Gx)^2GxGxGx\n",
      "GyGyGy(Gx)^2GyGyGy\n",
      "Gx(Gy)^2Gx\n",
      "Gx(Gy)^2GxGx\n",
      "Gx(Gy)^2GxGxGx\n",
      "Gx(Gy)^2GyGyGy\n",
      "GxGx(Gy)^2Gx\n",
      "GxGx(Gy)^2GxGx\n",
      "GxGx(Gy)^2GxGxGx\n",
      "GxGx(Gy)^2GyGyGy\n",
      "GxGxGx(Gy)^2Gx\n",
      "GxGxGx(Gy)^2GxGx\n",
      "GxGxGx(Gy)^2GxGxGx\n",
      "GxGxGx(Gy)^2GyGyGy\n",
      "GyGyGy(Gy)^2Gx\n",
      "GyGyGy(Gy)^2GxGx\n",
      "GyGyGy(Gy)^2GxGxGx\n",
      "GyGyGy(Gy)^2GyGyGy\n",
      "Gy(GxGy)Gx\n",
      "Gy(GxGy)Gy\n",
      "Gy(GxGy)GxGx\n",
      "Gy(GxGy)GxGxGx\n",
      "Gy(GxGy)GyGyGy\n",
      "GxGxGx(GxGy)Gx\n",
      "GxGxGx(GxGy)Gy\n",
      "GxGxGx(GxGy)GxGx\n",
      "GxGxGx(GxGy)GxGxGx\n",
      "GxGxGx(GxGy)GyGyGy\n",
      "GyGyGy(GxGy)Gx\n",
      "GyGyGy(GxGy)Gy\n",
      "GyGyGy(GxGy)GxGx\n",
      "GyGyGy(GxGy)GxGxGx\n",
      "GyGyGy(GxGy)GyGyGy\n",
      "Gy(Gx)^4Gy\n",
      "Gy(Gx)^4GxGx\n",
      "Gy(Gx)^4GxGxGx\n",
      "Gy(Gx)^4GyGyGy\n",
      "GxGx(Gx)^4Gy\n",
      "GxGx(Gx)^4GxGxGx\n",
      "GxGx(Gx)^4GyGyGy\n",
      "GxGxGx(Gx)^4Gy\n",
      "GxGxGx(Gx)^4GxGxGx\n",
      "GxGxGx(Gx)^4GyGyGy\n",
      "GyGyGy(Gx)^4Gy\n",
      "GyGyGy(Gx)^4GxGx\n",
      "GyGyGy(Gx)^4GxGxGx\n",
      "GyGyGy(Gx)^4GyGyGy\n",
      "Gx(Gy)^4Gx\n",
      "Gx(Gy)^4GxGx\n",
      "Gx(Gy)^4GxGxGx\n",
      "Gx(Gy)^4GyGyGy\n",
      "GxGx(Gy)^4Gx\n",
      "GxGx(Gy)^4GxGx\n",
      "GxGx(Gy)^4GxGxGx\n",
      "GxGx(Gy)^4GyGyGy\n",
      "GxGxGx(Gy)^4Gx\n",
      "GxGxGx(Gy)^4GxGx\n",
      "GxGxGx(Gy)^4GxGxGx\n",
      "GxGxGx(Gy)^4GyGyGy\n",
      "GyGyGy(Gy)^4Gx\n",
      "GyGyGy(Gy)^4GxGx\n",
      "GyGyGy(Gy)^4GxGxGx\n",
      "GyGyGy(Gy)^4GyGyGy\n",
      "(GxGy)^2\n",
      "(GxGy)^2Gx\n",
      "(GxGy)^2Gy\n",
      "(GxGy)^2GxGx\n",
      "(GxGy)^2GxGxGx\n",
      "(GxGy)^2GyGyGy\n",
      "Gx(GxGy)^2\n",
      "Gx(GxGy)^2Gx\n",
      "Gx(GxGy)^2Gy\n",
      "Gx(GxGy)^2GxGx\n",
      "Gx(GxGy)^2GxGxGx\n",
      "Gx(GxGy)^2GyGyGy\n",
      "Gy(GxGy)^2\n",
      "Gy(GxGy)^2Gx\n",
      "Gy(GxGy)^2Gy\n",
      "Gy(GxGy)^2GxGx\n",
      "Gy(GxGy)^2GxGxGx\n",
      "Gy(GxGy)^2GyGyGy\n",
      "GxGx(GxGy)^2\n",
      "GxGx(GxGy)^2Gx\n",
      "GxGx(GxGy)^2Gy\n",
      "GxGx(GxGy)^2GxGx\n",
      "GxGx(GxGy)^2GxGxGx\n",
      "GxGx(GxGy)^2GyGyGy\n",
      "GxGxGx(GxGy)^2\n",
      "GxGxGx(GxGy)^2Gx\n",
      "GxGxGx(GxGy)^2Gy\n",
      "GxGxGx(GxGy)^2GxGx\n",
      "GxGxGx(GxGy)^2GxGxGx\n",
      "GxGxGx(GxGy)^2GyGyGy\n",
      "GyGyGy(GxGy)^2\n",
      "GyGyGy(GxGy)^2Gx\n",
      "GyGyGy(GxGy)^2Gy\n",
      "GyGyGy(GxGy)^2GxGx\n",
      "GyGyGy(GxGy)^2GxGxGx\n",
      "GyGyGy(GxGy)^2GyGyGy\n",
      "Gy(GxGxGy)Gx\n",
      "Gy(GxGxGy)Gy\n",
      "Gy(GxGxGy)GxGx\n",
      "Gy(GxGxGy)GxGxGx\n",
      "Gy(GxGxGy)GyGyGy\n",
      "GxGxGx(GxGxGy)Gx\n",
      "GxGxGx(GxGxGy)Gy\n",
      "GxGxGx(GxGxGy)GxGx\n",
      "GxGxGx(GxGxGy)GxGxGx\n",
      "GxGxGx(GxGxGy)GyGyGy\n",
      "GyGyGy(GxGxGy)Gx\n",
      "GyGyGy(GxGxGy)Gy\n",
      "GyGyGy(GxGxGy)GxGx\n",
      "GyGyGy(GxGxGy)GxGxGx\n",
      "GyGyGy(GxGxGy)GyGyGy\n",
      "Gy(GxGyGy)Gx\n",
      "Gy(GxGyGy)GxGx\n",
      "Gy(GxGyGy)GxGxGx\n",
      "Gy(GxGyGy)GyGyGy\n",
      "GxGxGx(GxGyGy)Gx\n",
      "GxGxGx(GxGyGy)GxGx\n",
      "GxGxGx(GxGyGy)GxGxGx\n",
      "GxGxGx(GxGyGy)GyGyGy\n",
      "GyGyGy(GxGyGy)Gx\n",
      "GyGyGy(GxGyGy)GxGx\n",
      "GyGyGy(GxGyGy)GxGxGx\n",
      "GyGyGy(GxGyGy)GyGyGy\n"
     ]
    }
   ],
   "source": [
    "maxLengths = [1,2,4]\n",
    "lsgst_lists = pygsti.construction.make_lsgst_lists(['Gx','Gy'], prep_fiducials, meas_fiducials, germs, maxLengths)\n",
    "\n",
    "#Print the result.  Note that larger L lists also contain all the elements of lower-L lists.  \n",
    "# Note also that germs which are length 4 only show up in the L=4 list, and there are only \"repeated\" once.\n",
    "for i,lst in enumerate(lsgst_lists):\n",
    "    print(\"\\nList %d (max-length L=%d): %d Circuits\" % (i,maxLengths[i],len(lst)))\n",
    "    print('\\n'.join([c.str for c in lst])) # Note: use \".str\" to get a *single-line* string representation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Why settle for lists, when you can have structures?\n",
    "\n",
    "While a list-of-lists such as `lsgst_lists` is all that is needed by the core long-sequence GST algorithms, one can also construct, in similar fashion, a list of `pygsti.objects.CircuitStructure` objects.  These objects mimic a list of `Circuits` in many ways, but retain the structure of each circuit so that per-circuit quantities may later be plotted according to their decomposition into fiducials, germ, and $L$.  The `allstrs` member of a `CircuitStructure` allows access to the underlying list of `Circuit` objects.  We'll demonstrate this when we get to plotting.  For now, just think of this as a slightly richer way to generate the circuits needed by a GST algorithm that facilitates post-processing and analysis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'pygsti.objects.circuitstructure.LsGermsStructure'>\n",
      "Struct 0 (L=1) has 56 strings\n",
      "Struct 1 (L=2) has 96 strings\n",
      "Struct 2 (L=4) has 189 strings\n"
     ]
    }
   ],
   "source": [
    "#Note: same arguments as make_lsgst_lists\n",
    "lsgst_structs = pygsti.construction.make_lsgst_structs(['Gx','Gy'], prep_fiducials, meas_fiducials, germs, maxLengths)\n",
    "print(type(lsgst_structs[0]))\n",
    "for i,struct in enumerate(lsgst_structs):\n",
    "    print(\"Struct %d (L=%d) has %d strings\" % (i,maxLengths[i],len(struct.allstrs)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List of experiments\n",
    "If you're taking data, not running a GST algorithm, then you just want a *single* list of all the circuits that the GST algorithm will need.  Since most of the time the lists are *nested*, that is, all of the lower-$L$ (shorter) circuits appear in the higher-$L$ (longer) circuits, the final element of `lsgst_lists` is often the list of required experiments.  However, in advanced usages this is not always the case, and so there is a dedicated function, `make_lsgst_experiment_list` which performs this constrution: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "189 experiments to do...\n"
     ]
    }
   ],
   "source": [
    "#Note: same arguments as make_lsgst_lists\n",
    "lsgst_experiment_list = pygsti.construction.make_lsgst_experiment_list(['Gx','Gy'], prep_fiducials,\n",
    "                                                                      meas_fiducials, germs, maxLengths)\n",
    "print(\"%d experiments to do...\" % len(lsgst_experiment_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example: generating LSGST sequences by hand\n",
    "As a final full-fledged example we demonstrate the use of pyGSTi's more general `Circuit` creation and processing functions to create the lists of LSGST circuits. The following example functions are very similar to `pygsti.construction.make_lsgst_lists` except we assume that the preparation and measurement fiducial sequences are the same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 LSGST sets w/lengths [56, 96, 189]\n",
      "56 strings\n",
      "96 strings\n",
      "189 strings\n"
     ]
    }
   ],
   "source": [
    "import pygsti.construction as pc\n",
    "\n",
    "def my_make_lsgst_lists(gateLabels, fiducialList, germList, maxLengthList):\n",
    "    singleOps = pc.circuit_list([(g,) for g in gateLabels])\n",
    "    lgstStrings = pc.list_lgst_circuits(fiducialList, fiducialList, gateLabels)\n",
    "    lsgst_list = pc.circuit_list([ () ]) #running list of all strings so far\n",
    "    \n",
    "    if maxLengthList[0] == 0:\n",
    "        lsgst_listOfLists = [ lgstStrings ]\n",
    "        maxLengthList = maxLengthList[1:]\n",
    "    else: lsgst_listOfLists = [ ]\n",
    "        \n",
    "    for maxLen in maxLengthList:\n",
    "        lsgst_list += pc.create_circuit_list(\"f0+R(germ,N)+f1\", f0=fiducialList,\n",
    "                                           f1=fiducialList, germ=germList, N=maxLen,\n",
    "                                           R=pc.repeat_with_max_length,\n",
    "                                           order=('germ','f0','f1'))\n",
    "        lsgst_listOfLists.append( pygsti.remove_duplicates(lgstStrings + lsgst_list) )\n",
    "\n",
    "    print(\"%d LSGST sets w/lengths\" % len(lsgst_listOfLists), list(map(len,lsgst_listOfLists)))\n",
    "    return lsgst_listOfLists\n",
    "\n",
    "my_lsgst_lists = my_make_lsgst_lists(['Gx','Gy'], prep_fiducials, germs, maxLengths)    \n",
    "print('\\n'.join(['%d strings' % len(l) for l in my_lsgst_lists]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}