pyGSTi 0.9.12__cp38-cp38-win_amd64.whl → 0.9.13__cp38-cp38-win_amd64.whl

pygsti/tools/rbtheory.py

@@ -218,7 +218,8 @@ def rb_gauge(model, target_model, weights=None, mx_basis=None, eigenvector_weigh
         vec_l_operator = vec_l_operator.real
 
     vec_l_operator[abs(vec_l_operator) < 10**(-15)] = 0.
-    l_operator = _mtls.unvec(vec_l_operator)
+    dim = int(_np.sqrt(vec_l_operator.size))
+    l_operator = vec_l_operator.reshape((dim, dim), order='F')
 
     return l_operator
 
@@ -457,255 +458,6 @@ def R_matrix(model, group, group_to_model=None, weights=None):  # noqa N802
 
     return R
 
-### COMMENTED OUT SO THAT THIS FILE DOESN'T NEED "from .. import construction as _cnst".
-### THIS SHOULD BE ADDED BACK IN AT SOME POINT.
-# def exact_rb_asps(model, group, m_max, m_min=0, m_step=1, success_outcomelabel=('0',),
-#                   group_to_model=None, weights=None, compilation=None, group_twirled=False):
-#     """
-#     Calculates the exact RB average success probablilites (ASP).
-
-#     Uses some generalizations of the formula given Proctor et al
-#     Phys. Rev. Lett. 119, 130502 (2017). This formula does not scale well with
-#     group size and qubit number, and for the Clifford group it is likely only
-#     practical for a single qubit.
-
-#     Parameters
-#     ----------
-#     model : Model
-#         The noisy model (e.g., the Cliffords) to calculate the R matrix of.
-#         The correpsonding `target` model (not required in this function)
-#         must be equal to or a subset of (a faithful rep of) the group `group`.
-#         If group_to_model is None, the labels of the gates in model should be
-#         the same as the labels of the corresponding group elements in `group`.
-#         For Clifford RB `model` should be the clifford model; for direct RB
-#         this should be the native model.
-
-#     group : MatrixGroup
-#         The group that the `model` model contains gates from. For Clifford RB
-#         or direct RB, this would be the Clifford group.
-
-#     m_max : int
-#         The maximal sequence length of the random gates, not including the
-#         inversion gate.
-
-#     m_min : int, optional
-#         The minimal sequence length. Defaults to the smallest valid value of 0.
-
-#     m_step : int, optional
-#         The step size between sequence lengths. Defaults to the smallest valid
-#         value of 1.
-
-#     success_outcomelabel : str or tuple, optional
-#         The outcome label associated with success.
-
-#     group_to_model : dict, optional
-#         If not None, a dictionary that maps labels of group elements to labels
-#         of model. This is required if the labels of the gates in `model` are different
-#         from the labels of the corresponding group elements in `group`.
-
-#     weights : dict, optional
-#         If not None, a dictionary of floats, whereby the keys are the gates in model
-#         and the values are the unnormalized probabilities to apply each gate at
-#         for each layer of the RB protocol. If None, the weighting defaults to an
-#         equal weighting on all gates, as used in most RB protocols (e.g., Clifford
-#         RB).
-
-#     compilation : dict, optional
-#         If `model` is not the full group `group` (with the same labels), then a
-#         compilation for the group elements, used to implement the inversion gate
-#         (and the initial randomgroup element, if `group_twirled` is True). This
-#         is a dictionary with the group labels as keys and a gate sequence of the
-#         elements of `model` as values.
-
-#     group_twirled : bool, optional
-#         If True, the random sequence starts with a single uniformly random group
-#         element before the m random elements of `model`.
-
-#     Returns
-#     -------
-#     m : float
-#         Array of sequence length values that the ASPs have been calculated for.
-
-#     P_m : float
-#         Array containing ASP values for the specified sequence length values.
-#     """
-#     if compilation is None:
-#         for key in list(model.operations.keys()):
-#             assert(key in group.labels), "Gates labels are not in `group`, so `compilation must be specified."
-#         for label in group.labels:
-#             assert(label in list(model.operations.keys())
-#                    ), "Some group elements not in `model`, so `compilation must be specified."
-
-#     i_max = _np.floor((m_max - m_min) / m_step).astype('int')
-#     m = _np.zeros(1 + i_max, _np.int64)
-#     P_m = _np.zeros(1 + i_max, float)
-#     group_dim = len(group)
-#     R = R_matrix(model, group, group_to_model=group_to_model, weights=weights)
-#     success_prepLabel = list(model.preps.keys())[0]  # just take first prep
-#     success_effectLabel = success_outcomelabel[-1] if isinstance(success_outcomelabel, tuple) \
-#         else success_outcomelabel
-#     extended_E = _np.kron(_mtls.column_basis_vector(0, group_dim).T, model.povms['Mdefault'][success_effectLabel].T)
-#     extended_rho = _np.kron(_mtls.column_basis_vector(0, group_dim), model.preps[success_prepLabel])
-
-#     if compilation is None:
-#         extended_E = group_dim * _np.dot(extended_E, R)
-#         if group_twirled is True:
-#             extended_rho = _np.dot(R, extended_rho)
-#     else:
-#         full_model = _cnst.create_explicit_alias_model(model, compilation)
-#         R_fullgroup = R_matrix(full_model, group)
-#         extended_E = group_dim * _np.dot(extended_E, R_fullgroup)
-#         if group_twirled is True:
-#             extended_rho = _np.dot(R_fullgroup, extended_rho)
-
-#     Rstep = _np.linalg.matrix_power(R, m_step)
-#     Riterate = _np.linalg.matrix_power(R, m_min)
-#     for i in range(0, 1 + i_max):
-#         m[i] = m_min + i * m_step
-#         P_m[i] = _np.dot(extended_E, _np.dot(Riterate, extended_rho))
-#         Riterate = _np.dot(Rstep, Riterate)
-
-#     return m, P_m
-
-### COMMENTED OUT SO THAT THIS FILE DOESN'T NEED "from .. import construction as _cnst"
-### THIS SHOULD BE ADDED BACK IN AT SOME POINT.
-# def L_matrix_asps(model, target_model, m_max, m_min=0, m_step=1, success_outcomelabel=('0',),  # noqa N802
-#                   compilation=None, group_twirled=False, weights=None, gauge_optimize=True,
-#                   return_error_bounds=False, norm='diamond'):
-#     """
-#     Computes RB average survival probablities, as predicted by the 'L-matrix' theory.
-
-#     This theory was introduced in Proctor et al Phys. Rev. Lett. 119, 130502
-#     (2017). Within the function, the model is gauge-optimized to target_model. This is
-#     *not* optimized to the gauge specified by Proctor et al, but instead performs the
-#     standard pyGSTi gauge-optimization (using the frobenius distance). In most cases,
-#     this is likely to be a reasonable proxy for the gauge optimization perscribed by
-#     Proctor et al.
-
-#     Parameters
-#     ----------
-#     model : Model
-#         The noisy model.
-
-#     target_model : Model
-#         The target model.
-
-#     m_max : int
-#         The maximal sequence length of the random gates, not including the inversion gate.
-
-#     m_min : int, optional
-#         The minimal sequence length. Defaults to the smallest valid value of 0.
-
-#     m_step : int, optional
-#         The step size between sequence lengths.
-
-#     success_outcomelabel : str or tuple, optional
-#         The outcome label associated with success.
-
-#     compilation : dict, optional
-#         If `model` is not the full group, then a compilation for the group elements,
-#         used to implement the inversion gate (and the initial random group element,
-#         if `group_twirled` is True). This is a dictionary with the group labels as
-#         keys and a gate sequence of the elements of `model` as values.
-
-#     group_twirled : bool, optional
-#         If True, the random sequence starts with a single uniformly random group
-#         element before the m random elements of `model`.
-
-#     weights : dict, optional
-#         If not None, a dictionary of floats, whereby the keys are the gates in model
-#         and the values are the unnormalized probabilities to apply each gate at
-#         for each layer of the RB protocol. If None, the weighting defaults to an
-#         equal weighting on all gates, as used in most RB protocols (e.g., Clifford
-#         RB).
-
-#     gauge_optimize : bool, optional
-#         If True a gauge-optimization to the target model is implemented before
-#         calculating all quantities. If False, no gauge optimization is performed.
-#         Whether or not a gauge optimization is performed does not affect the rate of
-#         decay but it will generally affect the exact form of the decay. E.g., if a
-#         perfect model is given to the function -- but in the "wrong" gauge -- no
-#         decay will be observed in the output P_m, but the P_m can be far from 1 (even
-#         for perfect SPAM) for all m. The gauge optimization is optional, as it is
-#         not guaranteed to always improve the accuracy of the reported P_m, although when
-#         gauge optimization is performed this limits the possible deviations of the
-#         reported P_m from the true P_m.
-
-#     return_error_bounds : bool, optional
-#         Sets whether or not to return error bounds for how far the true ASPs can deviate
-#         from the values returned by this function.
-
-#     norm : str, optional
-#         The norm used in the error bound calculation. Either 'diamond' for the diamond
-#         norm (the default) or '1to1' for the Hermitian 1 to 1 norm.
-
-#     Returns
-#     -------
-#     m : float
-#         Array of sequence length values that the ASPs have been calculated for.
-#     P_m : float
-#         Array containing predicted ASP values for the specified sequence length values.
-#     if error_bounds is True :
-#         lower_bound: float
-#             Array containing lower bounds on the possible ASP values
-
-#         upper_bound: float
-#             Array containing upper bounds on the possible ASP values
-#     """
-#     d = int(round(_np.sqrt(model.dim)))
-
-#     if gauge_optimize:
-#         model_go = _algs.gaugeopt_to_target(model, target_model)
-#     else:
-#         model_go = model.copy()
-#     L = L_matrix(model_go, target_model, weights=weights)
-#     success_prepLabel = list(model.preps.keys())[0]  # just take first prep
-#     success_effectLabel = success_outcomelabel[-1] if isinstance(success_outcomelabel, tuple) \
-#         else success_outcomelabel
-#     identity_vec = _mtls.vec(_np.identity(d**2, float))
-
-#     if compilation is not None:
-#         model_group = _cnst.create_explicit_alias_model(model_go, compilation)
-#         model_target_group = _cnst.create_explicit_alias_model(target_model, compilation)
-#         delta = gate_dependence_of_errormaps(model_group, model_target_group, norm=norm)
-#         emaps = errormaps(model_group, model_target_group)
-#         E_eff = _np.dot(model_go.povms['Mdefault'][success_effectLabel].T, emaps.operations['Gavg'])
-
-#         if group_twirled is True:
-#             L_group = L_matrix(model_group, model_target_group)
-
-#     if compilation is None:
-#         delta = gate_dependence_of_errormaps(model_go, target_model, norm=norm)
-#         emaps = errormaps(model_go, target_model)
-#         E_eff = _np.dot(model_go.povms['Mdefault'][success_effectLabel].T, emaps.operations['Gavg'])
-
-#     i_max = _np.floor((m_max - m_min) / m_step).astype('int')
-#     m = _np.zeros(1 + i_max, _np.int64)
-#     P_m = _np.zeros(1 + i_max, float)
-#     upper_bound = _np.zeros(1 + i_max, float)
-#     lower_bound = _np.zeros(1 + i_max, float)
-
-#     Lstep = _np.linalg.matrix_power(L, m_step)
-#     Literate = _np.linalg.matrix_power(L, m_min)
-#     for i in range(0, 1 + i_max):
-#         m[i] = m_min + i * m_step
-#         if group_twirled:
-#             L_m_rdd = _mtls.unvec(_np.dot(L_group, _np.dot(Literate, identity_vec)))
-#         else:
-#             L_m_rdd = _mtls.unvec(_np.dot(Literate, identity_vec))
-#         P_m[i] = _np.dot(E_eff, _np.dot(L_m_rdd, model_go.preps[success_prepLabel]))
-#         Literate = _np.dot(Lstep, Literate)
-#         upper_bound[i] = P_m[i] + delta / 2
-#         lower_bound[i] = P_m[i] - delta / 2
-#         if upper_bound[i] > 1:
-#             upper_bound[i] = 1.
-#         if lower_bound[i] < 0:
-#             lower_bound[i] = 0.
-#     if return_error_bounds:
-#         return m, P_m, lower_bound, upper_bound
-#     else:
-#         return m, P_m
-
 
 def errormaps(model, target_model):
     """
@@ -791,78 +543,9 @@ def gate_dependence_of_errormaps(model, target_model, norm='diamond', mx_basis=N
                                             mx_basis=mx_basis))
         elif norm == '1to1':
             gate_dif = error_gs.operations[gate] - error_gs.operations['Gavg']
-            delta.append(_optls.norm1to1(gate_dif, num_samples=1000, mx_basis=mx_basis, return_list=False))
+            delta.append(_optls.norm1to1(gate_dif, num_samples=1000, mx_basis=mx_basis))
         else:
             raise ValueError("Only diamond or 1to1 norm available.")
 
     delta_avg = _np.mean(delta)
     return delta_avg
-
-# Future : perhaps put these back in.
-#def Magesan_theory_predicted_decay(model, target_model, mlist, success_outcomelabel=('0',),
-#                                   norm='1to1', order='zeroth', return_all = False):
-#
-#    assert(order == 'zeroth' or order == 'first')
-#
-#    d = int(round(_np.sqrt(model.dim)))
-#    MTPs = {}
-#    MTPs['r'] = gateset_infidelity(model,target_model,itype='AGI')
-#    MTPs['p'] = _analysis.r_to_p(MTPs['r'],d,rtype='AGI')
-#    MTPs['delta'] = gate_dependence_of_errormaps(model, target_model, norm)
-#    error_gs = errormaps(model, target_model)
-#
-#    R_list = []
-#    Q_list = []
-#    for gate in list(target_model.operations.keys()):
-#        R_list.append(_np.dot(_np.dot(error_gs.operations[gate],target_model.operations[gate]),
-#              _np.dot(error_gs.operations['Gavg'],_np.transpose(target_model.operations[gate]))))
-#        Q_list.append(_np.dot(target_model.operations[gate],
-#              _np.dot(error_gs.operations[gate],_np.transpose(target_model.operations[gate]))))
-#
-#    error_gs.operations['GR'] = _np.mean(_np.array([ i for i in R_list]),axis=0)
-#    error_gs.operations['GQ'] = _np.mean(_np.array([ i for i in Q_list]),axis=0)
-#    error_gs.operations['GQ2'] = _np.dot(error_gs.operations['GQ'],error_gs.operations['Gavg'])
-#    error_gs.preps['rhoc_mixed'] = 1./d*_cnst.create_identity_vec(error_gs.basis)#
-#
-#    #Assumes standard POVM labels
-#    povm = _objs.UnconstrainedPOVM( [('0_cm', target_model.povms['Mdefault']['0']),
-#                                     ('1_cm', target_model.povms['Mdefault']['1'])] )
-#    ave_error_gsl = _cnst.to_circuits([('rho0','Gavg'),('rho0','GR'),('rho0','Gavg','GQ')])
-#    data = _cnst.simulate_data(error_gs, ave_error_gsl, num_samples=1, sample_error="none")#
-
-#    pr_L_p = data[('rho0','Gavg')][success_outcomelabel]
-#    pr_L_I = data[('rho0','Gavg')][success_outcomelabel_cm]
-#    pr_R_p = data[('rho0','GR')][success_outcomelabel]
-#    pr_R_I = data[('rho0','GR')][success_outcomelabel_cm]
-#    pr_Q_p = data[('rho0','Gavg','GQ')][success_outcomelabel]
-#    p = MTPs['p']
-#    B_1 = pr_R_I
-#    A_1 = (pr_Q_p/p) - pr_L_p + ((p -1)*pr_L_I/p) + ((pr_R_p - pr_R_I)/p)
-#    C_1 = pr_L_p - pr_L_I
-#    q = _tls.average_gate_infidelity(error_gs.operations['GQ2'],_np.identity(d**2,float))
-#    q = _analysis.r_to_p(q,d,rtype='AGI')
-#
-#    if order  == 'zeroth':
-#        MTPs['A'] = pr_L_I
-#        MTPs['B'] = pr_L_p - pr_L_I
-#    if order == 'first':
-#        MTPs['A'] = B_1
-#        MTPs['B'] = A_1 - C_1*(q - 1)/p**2
-#        MTPs['C'] = C_1*(q- p**2)/p**2
-#
-#    if order == 'zeroth':
-#        Pm = MTPs['A'] +  MTPs['B']*MTPs['p']**_np.array(mlist)
-#    if order == 'first':
-#        Pm = MTPs['A'] +  (MTPs['B'] + _np.array(mlist)*MTPs['C'])*MTPs['p']**_np.array(mlist)
-#
-#   sys_eb = (MTPs['delta'] + 1)**(_np.array(mlist)+1) - 1
-#    if order == 'first':
-#        sys_eb = sys_eb - (_np.array(mlist)+1)*MTPs['delta']
-#
-#    upper = Pm + sys_eb
-#    upper[upper > 1]=1.
-#
-#    lower = Pm - sys_eb
-#    lower[lower < 0]=0.
-#
-#   return mlist, Pm, upper, lower, MTPs

pygsti/tools/slicetools.py

@@ -26,7 +26,8 @@ def length(s):
     -------
     int
     """
-    if not isinstance(s, slice): return len(s)
+    if not isinstance(s, slice): 
+        return len(s)
     if s.start is None or s.stop is None:
         return 0
     if s.step is None:
@@ -191,7 +192,8 @@ def indices(s, n=None):
     elif s.start < 0:
         assert(n is not None), "Must supply `n` to obtain indices of a slice with negative start point!"
         start = n + s.start
-    else: start = s.start
+    else: 
+        start = s.start
 
     if s.stop is None:
         assert(n is not None), "Must supply `n` to obtain indices of a slice with unspecified stop point!"
@@ -199,12 +201,56 @@ def indices(s, n=None):
     elif s.stop < 0:
         assert(n is not None), "Must supply `n` to obtain indices of a slice with negative stop point!"
         stop = n + s.stop
-    else: stop = s.stop
+    else: 
+        stop = s.stop
 
     if s.step is None:
         return list(range(start, stop))
-    return list(range(start, stop, s.step))
+    else:
+        return list(range(start, stop, s.step))
+    
+def indices_as_array(s, n=None):
+    """
+    Returns a numpy array of the indices specified by slice `s`.
+
+    Parameters
+    ----------
+    s : slice
+        The slice to operate upon.
+
+    n : int, optional
+        The number of elements in the array being indexed,
+        used for computing *negative* start/stop points.
+
+    Returns
+    -------
+    numpy ndarray array of integers
+    """
+    if s.start is None and s.stop is None:
+        return []
+
+    if s.start is None:
+        start = 0
+    elif s.start < 0:
+        assert(n is not None), "Must supply `n` to obtain indices of a slice with negative start point!"
+        start = n + s.start
+    else: 
+        start = s.start
+
+    if s.stop is None:
+        assert(n is not None), "Must supply `n` to obtain indices of a slice with unspecified stop point!"
+        stop = n
+    elif s.stop < 0:
+        assert(n is not None), "Must supply `n` to obtain indices of a slice with negative stop point!"
+        stop = n + s.stop
+    else: 
+        stop = s.stop
 
+    if s.step is None:
+        return _np.arange(start, stop, dtype=_np.int64)
+    else:
+        return _np.arange(start, stop, s.step, dtype=_np.int64)
+    
 
 def list_to_slice(lst, array_ok=False, require_contiguous=True):
     """
@@ -240,17 +286,23 @@ def list_to_slice(lst, array_ok=False, require_contiguous=True):
                 else:
                     raise ValueError("Slice must be contiguous!")
         return lst
-    if lst is None or len(lst) == 0: return slice(0, 0)
+    if lst is None or len(lst) == 0: 
+        return slice(0, 0)
     start = lst[0]
 
-    if len(lst) == 1: return slice(start, start + 1)
-    step = lst[1] - lst[0]; stop = start + step * len(lst)
+    if len(lst) == 1: 
+        return slice(start, start + 1)
+    step = lst[1] - lst[0]
+    stop = start + step * len(lst)
 
-    if list(lst) == list(range(start, stop, step)):
+    if step != 0 and list(lst) == list(range(start, stop, step)):
         if require_contiguous and step != 1:
-            if array_ok: return _np.array(lst, _np.int64)
-            else: raise ValueError("Slice must be contiguous (or array_ok must be True)!")
-        if step == 1: step = None
+            if array_ok: 
+                return _np.array(lst, _np.int64)
+            else: 
+                raise ValueError("Slice must be contiguous (or array_ok must be True)!")
+        if step == 1: 
+            step = None
         return slice(start, stop, step)
     elif array_ok:
         return _np.array(lst, _np.int64)
@@ -272,7 +324,7 @@ def to_array(slc_or_list_like):
     numpy.ndarray
     """
     if isinstance(slc_or_list_like, slice):
-        return _np.array(indices(slc_or_list_like), _np.int64)
+        return indices_as_array(slc_or_list_like)
     else:
         return _np.array(slc_or_list_like, _np.int64)
 

pyGSTi-0.9.12.dist-info/METADATA

@@ -1,157 +0,0 @@
-Metadata-Version: 2.1
-Name: pyGSTi
-Version: 0.9.12
-Summary: A python implementation of Gate Set Tomography
-Home-page: http://www.pygsti.info
-Download-URL: https://github.com/pyGSTio/pyGSTi/tarball/master
-Author: Erik Nielsen, Kenneth Rudinger, Timothy Proctor, John Gamble, Robin Blume-Kohout
-Author-email: pygsti@sandia.gov
-Keywords: pygsti,tomography,gate set,pigsty,pig,quantum,qubit
-Platform: any
-Classifier: Development Status :: 4 - Beta
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Programming Language :: Python
-Classifier: Topic :: Scientific/Engineering :: Physics
-Classifier: Operating System :: Microsoft :: Windows
-Classifier: Operating System :: MacOS :: MacOS X
-Classifier: Operating System :: Unix
-Requires-Python: >=3.5
-License-File: LICENSE
-Requires-Dist: numpy >=1.15.0
-Requires-Dist: scipy
-Requires-Dist: plotly
-Requires-Dist: pandas
-Provides-Extra: complete
-Requires-Dist: csaps ; extra == 'complete'
-Requires-Dist: seaborn ; extra == 'complete'
-Requires-Dist: cvxopt ; extra == 'complete'
-Requires-Dist: ply ; extra == 'complete'
-Requires-Dist: flake8 ; extra == 'complete'
-Requires-Dist: zmq ; extra == 'complete'
-Requires-Dist: matplotlib ; extra == 'complete'
-Requires-Dist: packaging ; extra == 'complete'
-Requires-Dist: cirq-core ; extra == 'complete'
-Requires-Dist: pytest-cov ; extra == 'complete'
-Requires-Dist: pytest-xdist ; extra == 'complete'
-Requires-Dist: notebook ; extra == 'complete'
-Requires-Dist: autopep8 ; extra == 'complete'
-Requires-Dist: ipython ; extra == 'complete'
-Requires-Dist: mpi4py ; extra == 'complete'
-Requires-Dist: jupyter-server ; extra == 'complete'
-Requires-Dist: pandas ; extra == 'complete'
-Requires-Dist: qibo <=0.1.7 ; extra == 'complete'
-Requires-Dist: cvxopt <=1.3.0.1 ; extra == 'complete'
-Requires-Dist: jinja2 ; extra == 'complete'
-Requires-Dist: pytest ; extra == 'complete'
-Requires-Dist: deap ; extra == 'complete'
-Requires-Dist: cvxpy ; extra == 'complete'
-Requires-Dist: cython ; extra == 'complete'
-Requires-Dist: psutil ; extra == 'complete'
-Requires-Dist: nbval ; extra == 'complete'
-Requires-Dist: MarkupSafe ; extra == 'complete'
-Requires-Dist: pymongo ; extra == 'complete'
-Requires-Dist: msgpack ; extra == 'complete'
-Provides-Extra: diamond_norm
-Requires-Dist: cvxopt ; extra == 'diamond_norm'
-Requires-Dist: cvxpy ; extra == 'diamond_norm'
-Provides-Extra: evolutionary_optimization
-Requires-Dist: deap ; extra == 'evolutionary_optimization'
-Provides-Extra: extensions
-Requires-Dist: cython ; extra == 'extensions'
-Provides-Extra: html_reports
-Requires-Dist: jinja2 ; extra == 'html_reports'
-Requires-Dist: MarkupSafe ; extra == 'html_reports'
-Provides-Extra: interpygate
-Requires-Dist: csaps ; extra == 'interpygate'
-Provides-Extra: linting
-Requires-Dist: autopep8 ; extra == 'linting'
-Requires-Dist: flake8 ; extra == 'linting'
-Provides-Extra: memory_profiling
-Requires-Dist: psutil ; extra == 'memory_profiling'
-Provides-Extra: mongodb
-Requires-Dist: pymongo ; extra == 'mongodb'
-Provides-Extra: msgpack
-Requires-Dist: msgpack ; extra == 'msgpack'
-Provides-Extra: multiprocessor
-Requires-Dist: mpi4py ; extra == 'multiprocessor'
-Provides-Extra: no_mpi
-Requires-Dist: csaps ; extra == 'no_mpi'
-Requires-Dist: seaborn ; extra == 'no_mpi'
-Requires-Dist: cvxopt ; extra == 'no_mpi'
-Requires-Dist: ply ; extra == 'no_mpi'
-Requires-Dist: flake8 ; extra == 'no_mpi'
-Requires-Dist: zmq ; extra == 'no_mpi'
-Requires-Dist: matplotlib ; extra == 'no_mpi'
-Requires-Dist: packaging ; extra == 'no_mpi'
-Requires-Dist: cirq-core ; extra == 'no_mpi'
-Requires-Dist: pytest-cov ; extra == 'no_mpi'
-Requires-Dist: pytest-xdist ; extra == 'no_mpi'
-Requires-Dist: notebook ; extra == 'no_mpi'
-Requires-Dist: autopep8 ; extra == 'no_mpi'
-Requires-Dist: ipython ; extra == 'no_mpi'
-Requires-Dist: jupyter-server ; extra == 'no_mpi'
-Requires-Dist: pandas ; extra == 'no_mpi'
-Requires-Dist: qibo <=0.1.7 ; extra == 'no_mpi'
-Requires-Dist: cvxopt <=1.3.0.1 ; extra == 'no_mpi'
-Requires-Dist: jinja2 ; extra == 'no_mpi'
-Requires-Dist: pytest ; extra == 'no_mpi'
-Requires-Dist: deap ; extra == 'no_mpi'
-Requires-Dist: cvxpy ; extra == 'no_mpi'
-Requires-Dist: cython ; extra == 'no_mpi'
-Requires-Dist: psutil ; extra == 'no_mpi'
-Requires-Dist: nbval ; extra == 'no_mpi'
-Requires-Dist: MarkupSafe ; extra == 'no_mpi'
-Requires-Dist: pymongo ; extra == 'no_mpi'
-Requires-Dist: msgpack ; extra == 'no_mpi'
-Provides-Extra: notebooks
-Requires-Dist: ipython ; extra == 'notebooks'
-Requires-Dist: notebook ; extra == 'notebooks'
-Requires-Dist: jupyter-server ; extra == 'notebooks'
-Provides-Extra: report_pdf_figures
-Requires-Dist: matplotlib ; extra == 'report_pdf_figures'
-Provides-Extra: report_pickling
-Requires-Dist: pandas ; extra == 'report_pickling'
-Provides-Extra: testing
-Requires-Dist: pytest ; extra == 'testing'
-Requires-Dist: pytest-xdist ; extra == 'testing'
-Requires-Dist: pytest-cov ; extra == 'testing'
-Requires-Dist: nbval ; extra == 'testing'
-Requires-Dist: csaps ; extra == 'testing'
-Requires-Dist: cvxopt <=1.3.0.1 ; extra == 'testing'
-Requires-Dist: cvxpy ; extra == 'testing'
-Requires-Dist: cython ; extra == 'testing'
-Requires-Dist: matplotlib ; extra == 'testing'
-Requires-Dist: mpi4py ; extra == 'testing'
-Requires-Dist: msgpack ; extra == 'testing'
-Requires-Dist: packaging ; extra == 'testing'
-Requires-Dist: pandas ; extra == 'testing'
-Requires-Dist: psutil ; extra == 'testing'
-Requires-Dist: zmq ; extra == 'testing'
-Requires-Dist: jinja2 ; extra == 'testing'
-Requires-Dist: seaborn ; extra == 'testing'
-Requires-Dist: ply ; extra == 'testing'
-Requires-Dist: qibo <=0.1.7 ; extra == 'testing'
-Requires-Dist: cirq-core ; extra == 'testing'
-Requires-Dist: notebook ; extra == 'testing'
-Requires-Dist: ipython ; extra == 'testing'
-Requires-Dist: jupyter-server ; extra == 'testing'
-
-Gate set tomography (GST) is a quantum tomography protocol that provides full characterization of a quantum logic device
-(e.g. a qubit).  GST estimates a set of quantum logic gates and (simultaneously) the associated state preparation and
-measurement (SPAM) operations.  GST is self-calibrating.  This eliminates a key limitation of traditional quantum state
-and process tomography, which characterize either states (assuming perfect processes) or processes (assuming perfect
-state preparation and measurement), but not both together.  Compared with benchmarking protocols such as randomized
-benchmarking, GST provides much more detailed and accurate information about the gates, but demands more data.  The
-primary downside of GST has been its complexity.  Whereas benchmarking and state/process tomography data can be analyzed
-with relatively simple algorithms, GST requires more complex algorithms and more fine-tuning (linear GST is an exception
-that can be implemented easily).  pyGSTi addresses and eliminates this obstacle by providing a fully-featured, publicly
-available implementation of GST in the Python programming language.
-
-The primary goals of the pyGSTi project are to:
-
-- provide efficient and robust implementations of Gate Set Tomography algorithms;
-- allow straightforward interoperability with other software;
-- provide a powerful high-level interface suited to inexperienced programmers, so that
-  common GST tasks can be performed using just one or two lines of code;
-- use modular design to make it easy for users to modify, customize, and extend GST functionality.