pyGSTi 0.9.12.1__cp39-cp39-win_amd64.whl → 0.9.13__cp39-cp39-win_amd64.whl

pygsti/modelmembers/states/state.py

@@ -350,11 +350,10 @@ class State(_modelmember.ModelMember):
         float
         """
         vec = self.to_dense(on_space='minimal')
-        if inv_transform is None:
-            return _ot.residuals(vec, other_spam_vec.to_dense(on_space='minimal'))
-        else:
-            return _ot.residuals(_np.dot(inv_transform, vec),
-                                 other_spam_vec.to_dense(on_space='minimal'))
+        if inv_transform is not None:
+            vec = inv_transform @ vec
+        return (vec - other_spam_vec.to_dense(on_space='minimal')).ravel()
+
 
     def transform_inplace(self, s):
         """
@@ -573,4 +572,4 @@ class State(_modelmember.ModelMember):
                 vector = _np.array(v, typ)[:, None]  # make into a 2-D column vec
 
         assert(len(vector.shape) == 2 and vector.shape[1] == 1)
-        return vector.flatten()  # HACK for convention change -> (N,) instead of (N,1)
+        return vector.ravel()  # HACK for convention change -> (N,) instead of (N,1)

pygsti/modelmembers/states/tpstate.py

@@ -11,16 +11,25 @@ The TPState class and supporting functionality.
 #***************************************************************************************************
 
 
-import numpy as _np
+from __future__ import annotations
+from typing import Tuple, TYPE_CHECKING
+if TYPE_CHECKING:
+    import torch as _torch
+try:
+    import torch as _torch
+except ImportError:
+    pass
 
+import numpy as _np
 from pygsti.baseobjs import Basis as _Basis
 from pygsti.baseobjs import statespace as _statespace
+from pygsti.modelmembers.torchable import Torchable as _Torchable
 from pygsti.modelmembers.states.densestate import DenseState as _DenseState
 from pygsti.modelmembers.states.state import State as _State
 from pygsti.baseobjs.protectedarray import ProtectedArray as _ProtectedArray
 
 
-class TPState(_DenseState):
+class TPState(_DenseState, _Torchable):
     """
     A fixed-unit-trace state vector.
 
@@ -57,15 +66,14 @@ class TPState(_DenseState):
     # alpha = 1/sqrt(d) = 1/(len(vec)**0.25).
     def __init__(self, vec, basis=None, evotype="default", state_space=None):
         vector = _State._to_vector(vec)
-        if basis is not None:
-            if not isinstance(basis, _Basis):
-                basis = _Basis.cast(basis, len(vector))  # don't perform this cast if we're given a basis
-            firstEl = basis.elsize**-0.25  # not dim, as the dimension of the vector space may be less
-            if not _np.isclose(vector[0], firstEl):
-                raise ValueError("Cannot create TPState: first element must equal %g!" % firstEl)
-        # if basis is None, don't check first element (hackfor de-serialization, so we don't need to store basis)
-
+        if basis is None:
+            dim = vector.size
+            basis = 'pp' if int(2**_np.log2(dim)) == dim else 'gm'
         _DenseState.__init__(self, vector, basis, evotype, state_space)
+        basis = self._basis              # <-- __init__ ensures that self._basis is a Basis object.
+        firstEl = basis.elsize ** -0.25  # <-- not dim, as the dimension of the vector space may be less
+        if not _np.isclose(vector[0], firstEl):
+            raise ValueError("Cannot create TPState: first element must equal %g!" % firstEl)
         assert(isinstance(self.columnvec, _ProtectedArray))
         self._paramlbls = _np.array(["VecElement %d" % i for i in range(1, self.dim)], dtype=object)
 
@@ -158,6 +166,16 @@ class TPState(_DenseState):
         self._ptr_has_changed()
         self.dirty = dirty_value
 
+    def stateless_data(self) -> Tuple[int]:
+        return (self.dim,)
+
+    @staticmethod
+    def torch_base(sd: Tuple[int], t_param: _torch.Tensor) -> _torch.Tensor:
+        dim = sd[0]
+        t_const = (dim ** -0.25) * _torch.ones(1, dtype=_torch.double) 
+        t = _torch.concat((t_const, t_param)) 
+        return t
+
     def deriv_wrt_params(self, wrt_filter=None):
         """
         The element-wise derivative this state vector.

pygsti/modelmembers/term.py

@@ -384,7 +384,7 @@ class RankOnePrepTerm(RankOneTerm, _NoMagnitude):
         -------
         RankOnePrepTerm
         """
-        evotype = _Evotype.cast(evotype)
+        evotype = _Evotype.cast(evotype, state_space=state_space)
         default_basis = 'pp'
 
         if isinstance(pre_state, _mm.ModelMember):
@@ -459,7 +459,7 @@ class RankOneEffectTerm(RankOneTerm, _NoMagnitude):
         -------
         RankOneEffectTerm
         """
-        evotype = _Evotype.cast(evotype)
+        evotype = _Evotype.cast(evotype, state_space=state_space)
         default_basis = 'pp'
 
         if isinstance(pre_effect, _mm.ModelMember):
@@ -534,7 +534,7 @@ class RankOneOpTerm(RankOneTerm, _NoMagnitude):
         -------
         RankOneOpTerm
         """
-        evotype = _Evotype.cast(evotype)
+        evotype = _Evotype.cast(evotype, state_space=state_space)
         pre_reps = []
         post_reps = []
 
@@ -718,9 +718,6 @@ class _HasPolynomialCoefficient(object):
         """
         return _Polynomial.from_rep(self._rep.coeff)
 
-    #def _coeff_copy(self):
-    #    return self.coeff.copy()
-
     def map_indices_inplace(self, mapfn):
         """
         Performs a bulk find & replace on the coefficient polynomial's variable indices.

pygsti/modelmembers/torchable.py

@@ -0,0 +1,50 @@
+"""
+Defines the interface that ModelMembers must satisfy to be compatible with
+the PyTorch-backed forward simulator in pyGSTi/forwardsims/torchfwdsim.py.
+"""
+#***************************************************************************************************
+# Copyright 2024, National Technology & Engineering Solutions of Sandia, LLC (NTESS).
+# Under the terms of Contract DE-NA0003525 with NTESS, the U.S. Government retains certain rights
+# in this software.
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+# in compliance with the License.  You may obtain a copy of the License at
+# http://www.apache.org/licenses/LICENSE-2.0 or in the LICENSE file in the root pyGSTi directory.
+#***************************************************************************************************
+
+
+from __future__ import annotations
+from typing import Tuple, TYPE_CHECKING
+if TYPE_CHECKING:
+    import torch as _torch
+
+from pygsti.modelmembers.modelmember import ModelMember
+
+
+class Torchable(ModelMember):
+
+    def stateless_data(self) -> Tuple:
+        """
+        Return this ModelMember's data that is considered constant for purposes of model fitting.
+
+        Note: the word "stateless" here is used in the sense of object-oriented programming.
+        """
+        raise NotImplementedError()   
+
+    @staticmethod
+    def torch_base(sd : Tuple, t_param : _torch.Tensor) -> _torch.Tensor:
+        """
+        Suppose "obj" is an instance of some Torchable subclass. If we compute
+
+            vec = obj.to_vector()
+            t_param = torch.from_numpy(vec)
+            sd = obj.stateless_data()
+            t = type(obj).torch_base(sd, t_param)
+
+        then t will be a PyTorch Tensor that represents "obj" in a canonical numerical way.
+
+        The meaning of "canonical" is implementation dependent. If type(obj) implements
+        the ``.base`` attribute, then a reasonable implementation will probably satisfy
+
+            np.allclose(obj.base, t.numpy()).
+        """
+        raise NotImplementedError()

pygsti/modelpacks/_modelpack.py

@@ -129,7 +129,7 @@ class ModelPack(_ABC):
         QubitProcessorSpec
         """
         static_target_model = self.target_model('static', qubit_labels=qubit_labels)  # assumed to be an ExplicitOpModel
-        return static_target_model.create_processor_spec(self._sslbls)
+        return static_target_model.create_processor_spec(qubit_labels if qubit_labels is not None else self._sslbls)
 
     def _get_cachefile_names(self, param_type, simulator):
         """ Get the standard cache file names for a modelpack """

pygsti/modelpacks/smq1Q_ZN.py

@@ -1,7 +1,9 @@
 """
 A standard multi-qubit gate set module.
 
-Variables for working with the a model containing Idle, Z(pi/2) and rot(X=pi/2, Y=sqrt(3)/2) gates.
+Variables for working with the a model containing Idle, Z(pi/2) and N gate, where the N gate is a
+pi/2 rotation about the (np.sqrt(3)/2, 0, -1/2) axis of the Bloch sphere.
+gates.
 """
 #***************************************************************************************************
 # Copyright 2015, 2019 National Technology & Engineering Solutions of Sandia, LLC (NTESS).

pygsti/modelpacks/smq2Q_XXYYII.py

@@ -2,7 +2,8 @@
 A standard multi-qubit gate set module.
 
 Variables for working with the 2-qubit model containing the gates
-I*X(pi/2), I*Y(pi/2), X(pi/2)*I, Y(pi/2)*I, and CPHASE.
+I*I, I*X(pi/2), I*Y(pi/2), X(pi/2)*I, Y(pi/2)*I, X(pi/2)*X(pi/2),
+Y(pi/2)*Y(pi/2), X(pi/2)*Y(pi/2), and Y(pi/2)*X(pi/2) gates.
 """
 #***************************************************************************************************
 # Copyright 2015, 2019 National Technology & Engineering Solutions of Sandia, LLC (NTESS).

pygsti/modelpacks/smq2Q_XY.py

@@ -2,7 +2,7 @@
 A standard multi-qubit gate set module.
 
 Variables for working with the 2-qubit model containing the gates
-I*X(pi/2), I*Y(pi/2), X(pi/2)*I, Y(pi/2)*I, and CPHASE.
+I*X(pi/2), I*Y(pi/2), X(pi/2)*I, Y(pi/2)*I.
 """
 #***************************************************************************************************
 # Copyright 2015, 2019 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
@@ -17,9 +17,9 @@ from pygsti.modelpacks._modelpack import GSTModelPack
 
 
 class _Module(GSTModelPack):
-    description = "I*X(pi/2), I*Y(pi/2), X(pi/2)*I, Y(pi/2)*I, and CPHASE gates"
+    description = "I*X(pi/2), I*Y(pi/2), X(pi/2)*I, Y(pi/2)*I"
 
-    gates = [('Gxpi2', 1), ('Gypi2', 1), ('Gxpi2', 0), ('Gypi2', 0), ('Gcphase', 0, 1)]
+    gates = [('Gxpi2', 1), ('Gypi2', 1), ('Gxpi2', 0), ('Gypi2', 0)]
 
     _sslbls = (0, 1)
 

pygsti/modelpacks/smq2Q_XYI.py

@@ -2,7 +2,7 @@
 A standard multi-qubit gate set module.
 
 Variables for working with the 2-qubit model containing the gates
-I*X(pi/2), I*Y(pi/2), X(pi/2)*I, Y(pi/2)*I, and CPHASE.
+I*X(pi/2), I*Y(pi/2), X(pi/2)*I, Y(pi/2)*I, and Idle.
 """
 #***************************************************************************************************
 # Copyright 2015, 2019 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
@@ -19,7 +19,7 @@ from pygsti.modelpacks._modelpack import GSTModelPack
 
 
 class _Module(GSTModelPack):
-    description = "I*I, I*X(pi/2), I*Y(pi/2), X(pi/2)*I, and Y(pi/2)*I gates"
+    description = "I*I, I*X(pi/2), I*Y(pi/2), X(pi/2)*I, and Y(pi/2)*I gates and Idle"
 
     gates = [(), ('Gxpi2', 1), ('Gypi2', 1), ('Gxpi2', 0), ('Gypi2', 0)]
 

pygsti/modelpacks/smq2Q_XYICNOT.py

@@ -2,7 +2,7 @@
 A standard multi-qubit gate set module.
 
 Variables for working with the 2-qubit model containing the gates
-I*X(pi/2), I*Y(pi/2), X(pi/2)*I, Y(pi/2)*I, and CNOT.
+I*X(pi/2), I*Y(pi/2), X(pi/2)*I, Y(pi/2)*I, CNOT and idle.
 """
 #***************************************************************************************************
 # Copyright 2015, 2019 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
@@ -17,9 +17,9 @@ from pygsti.modelpacks._modelpack import GSTModelPack
 
 
 class _Module(GSTModelPack):
-    description = "I*X(pi/2), I*Y(pi/2), X(pi/2)*I, Y(pi/2)*I, and CNOT gates"
+    description = "I*X(pi/2), I*Y(pi/2), X(pi/2)*I, Y(pi/2)*I, CNOT and idle gates"
 
-    gates = [('Gxpi2', 1), ('Gypi2', 1), ('Gxpi2', 0), ('Gypi2', 0), ('Gcnot', 0, 1)]
+    gates = [(), ('Gxpi2', 1), ('Gypi2', 1), ('Gxpi2', 0), ('Gypi2', 0), ('Gcnot', 0, 1)]
 
     _sslbls = (0, 1)
 

pygsti/modelpacks/smq2Q_XYICPHASE.py

@@ -2,7 +2,7 @@
 A standard multi-qubit gate set module.
 
 Variables for working with the 2-qubit model containing the gates
-I*X(pi/2), I*Y(pi/2), X(pi/2)*I, Y(pi/2)*I, and CPHASE.
+I*X(pi/2), I*Y(pi/2), X(pi/2)*I, Y(pi/2)*I, CPHASE, and idle.
 """
 #***************************************************************************************************
 # Copyright 2015, 2019 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
@@ -17,9 +17,9 @@ from pygsti.modelpacks._modelpack import GSTModelPack
 
 
 class _Module(GSTModelPack):
-    description = "I*X(pi/2), I*Y(pi/2), X(pi/2)*I, Y(pi/2)*I, and CPHASE gates"
+    description = "I*X(pi/2), I*Y(pi/2), X(pi/2)*I, Y(pi/2)*I, CPHASE and idle gates"
 
-    gates = [('Gxpi2', 1), ('Gypi2', 1), ('Gxpi2', 0), ('Gypi2', 0), ('Gcphase', 0, 1)]
+    gates = [(), ('Gxpi2', 1), ('Gypi2', 1), ('Gxpi2', 0), ('Gypi2', 0), ('Gcphase', 0, 1)]
 
     _sslbls = (0, 1)
 

pygsti/modelpacks/smq2Q_XYXX.py

@@ -2,7 +2,7 @@
 A standard multi-qubit gate set module.
 
 Variables for working with the 2-qubit model containing the gates
-I*X(pi/2), I*Y(pi/2), X(pi/2)*I, Y(pi/2)*I, and CNOT.
+I*X(pi/2), I*Y(pi/2), X(pi/2)*I, Y(pi/2)*I, and XX gates
 """
 #***************************************************************************************************
 # Copyright 2015, 2019 National Technology & Engineering Solutions of Sandia, LLC (NTESS).

pygsti/modelpacks/smq2Q_XYZICNOT.py

@@ -2,7 +2,7 @@
 A standard multi-qubit gate set module.
 
 Variables for working with the 2-qubit model containing the gates
-I*X(pi/2), I*Y(pi/2), I*Z(pi/2), X(pi/2)*I, Y(pi/2)*I, Z(pi/2)*I and CNOT.
+I*X(pi/2), I*Y(pi/2), I*Z(pi/2), X(pi/2)*I, Y(pi/2)*I, Z(pi/2)*I, CNOT and idle.
 """
 #***************************************************************************************************
 # Copyright 2015, 2019 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
@@ -17,9 +17,9 @@ from pygsti.modelpacks._modelpack import GSTModelPack
 
 
 class _Module(GSTModelPack):
-    description = "I*X(pi/2), I*Y(pi/2), I*Z(pi/2), X(pi/2)*I, Y(pi/2)*I, Z(pi/2)*I and CNOT gates"
+    description = "I*X(pi/2), I*Y(pi/2), I*Z(pi/2), X(pi/2)*I, Y(pi/2)*I, Z(pi/2)*I, CNOT and idle gates"
 
-    gates = [('Gxpi2', 1), ('Gypi2', 1), ('Gzpi2', 1), ('Gxpi2', 0), ('Gypi2', 0), ('Gzpi2', 0), ('Gcnot', 0, 1)]
+    gates = [(), ('Gxpi2', 1), ('Gypi2', 1), ('Gzpi2', 1), ('Gxpi2', 0), ('Gypi2', 0), ('Gzpi2', 0), ('Gcnot', 0, 1)]
 
     _sslbls = (0, 1)
 

pygsti/modelpacks/smq2Q_XYZZ.py

@@ -2,7 +2,7 @@
 A standard multi-qubit gate set module.
 
 Variables for working with the 2-qubit model containing the gates
-I*X(pi/2), I*Y(pi/2), X(pi/2)*I, Y(pi/2)*I, and CNOT.
+I*X(pi/2), I*Y(pi/2), X(pi/2)*I, Y(pi/2)*I, and ZZ gates.
 """
 #***************************************************************************************************
 # Copyright 2015, 2019 National Technology & Engineering Solutions of Sandia, LLC (NTESS).

pygsti/modelpacks/stdtarget.py

@@ -42,127 +42,6 @@ def _get_cachefile_names(std_module, param_type, simulator, py_version):
     raise ValueError("No cache files used for param-type=%s" % param_type)
 
 
-# XXX is this used?
-# def _make_hs_cache_for_std_model(std_module, term_order, max_length, json_too=False, comm=None):
-#     """
-#     A utility routine to for creating the term-based cache files for a standard module
-#     """
-#     target_model = std_module.target_model()
-#     prep_fiducials = std_module.prepStrs
-#     effect_fiducials = std_module.effectStrs
-#     germs = std_module.germs
-#
-#     x = 1
-#     maxLengths = []
-#     while(x <= max_length):
-#         maxLengths.append(x)
-#         x *= 2
-#
-#     listOfExperiments = _stdlists.create_lsgst_circuits(
-#         target_model, prep_fiducials, effect_fiducials, germs, maxLengths)
-#
-#     mdl_terms = target_model.copy()
-#     mdl_terms.set_all_parameterizations("H+S terms")  # CPTP terms?
-#     my_calc_cache = {}
-#     mdl_terms.sim = _TermFSim(mode="taylor", max_order=term_order, cache=my_calc_cache)
-#
-#     comm_method = "scheduler"
-#     if comm is not None and comm.Get_size() > 1 and comm_method == "scheduler":
-#         from mpi4py import MPI  # just needed for MPI.SOURCE below
-#
-#         #Alternate: use rank0 as "scheduler"
-#         rank = 0 if (comm is None) else comm.Get_rank()
-#         nprocs = 1 if (comm is None) else comm.Get_size()
-#         N = len(listOfExperiments); cur_index = 0; active_workers = nprocs - 1
-#         buf = _np.zeros(1, _np.int64)  # use buffer b/c mpi4py .send/.recv seem buggy
-#         if rank == 0:
-#             # ** I am the scheduler **
-#             # Give each "worker" rank an initial index to compute
-#             for i in range(1, nprocs):
-#                 if cur_index == N:  # there are more procs than items - just send -1 index to mean "you're done!"
-#                     buf[0] = -1
-#                     comm.Send(buf, dest=i, tag=1)  # tag == 1 => scheduler to worker
-#                     active_workers -= 1
-#                 else:
-#                     buf[0] = cur_index
-#                     comm.Send(buf, dest=i, tag=1); cur_index += 1
-#
-#             # while there are active workers keep dishing out indices
-#             while active_workers > 0:
-#                 comm.Recv(buf, source=MPI.ANY_SOURCE, tag=2)  # worker requesting assignment
-#                 worker_rank = buf[0]
-#                 if cur_index == N:  # nothing more to do: just send -1 index to mean "you're done!"
-#                     buf[0] = -1
-#                     comm.Send(buf, dest=worker_rank, tag=1)  # tag == 1 => scheduler to worker
-#                     active_workers -= 1
-#                 else:
-#                     buf[0] = cur_index
-#                     comm.Send(buf, dest=worker_rank, tag=1)
-#                     cur_index += 1
-#
-#         else:
-#             # ** I am a worker **
-#             comm.Recv(buf, source=0, tag=1)
-#             index_to_compute = buf[0]
-#
-#             while index_to_compute >= 0:
-#                 print("Worker %d computing prob %d of %d" % (rank, index_to_compute, N))
-#                 t0 = _time.time()
-#                 mdl_terms.probabilities(listOfExperiments[index_to_compute])
-#                 print("Worker %d finished computing prob %d in %.2fs" % (rank, index_to_compute, _time.time() - t0))
-#
-#                 buf[0] = rank
-#                 comm.Send(buf, dest=0, tag=2)  # tag == 2 => worker requests next assignment
-#                 comm.Recv(buf, source=0, tag=1)
-#                 index_to_compute = buf[0]
-#
-#         print("Rank %d at barrier" % rank)
-#         comm.barrier()  # wait here until all workers and scheduler are done
-#
-#     else:
-#
-#         #divide up strings among ranks
-#         my_expList, _, _ = _mpit.distribute_indices(listOfExperiments, comm, False)
-#         rankStr = "" if (comm is None) else "Rank%d: " % comm.Get_rank()
-#
-#         if comm is not None and comm.Get_rank() == 0:
-#             print("%d circuits divided among %d processors" % (len(listOfExperiments), comm.Get_size()))
-#
-#         t0 = _time.time()
-#         for i, opstr in enumerate(my_expList):
-#             print("%s%.2fs: Computing prob %d of %d" % (rankStr, _time.time() - t0, i, len(my_expList)))
-#             mdl_terms.probabilities(opstr)
-#         #mdl_terms.bulk_probs(my_expList) # also fills cache, but allocs more mem at once
-#
-#     py_version = 3 if (_sys.version_info > (3, 0)) else 2
-#     key_fn, val_fn = _get_cachefile_names(std_module, "H+S terms",
-#                                           "termorder:%d" % term_order, py_version)
-#     _write_calccache(my_calc_cache, key_fn, val_fn, json_too, comm)
-#
-#     if comm is None or comm.Get_rank() == 0:
-#         print("Completed in %.2fs" % (_time.time() - t0))
-#         print("Num of Experiments = ", len(listOfExperiments))
-#
-#     #if comm is None:
-#     #    calcc_list = [ my_calc_cache ]
-#     #else:
-#     #    calcc_list = comm.gather(my_calc_cache, root=0)
-#     #
-#     #if comm is None or comm.Get_rank() == 0:
-#     #    calc_cache = {}
-#     #    for c in calcc_list:
-#     #        calc_cache.update(c)
-#     #
-#     #    print("Completed in %.2fs" % (_time.time()-t0))
-#     #    print("Cachesize = ",len(calc_cache))
-#     #    print("Num of Experiments = ", len(listOfExperiments))
-#     #
-#     #    py_version = 3 if (_sys.version_info > (3, 0)) else 2
-#     #    key_fn, val_fn = _get_cachefile_names(std_module, "H+S terms",
-#     #                                          "termorder:%d" % term_order,py_version)
-#    #    _write_calccache(calc_cache, key_fn, val_fn, json_too, comm)
-
-
 # XXX apparently only used from _make_hs_cache_for_std_model which itself looks unused
 def _write_calccache(calc_cache, key_fn, val_fn, json_too=False, comm=None):
     """

pygsti/models/cloudnoisemodel.py

@@ -156,8 +156,7 @@ class CloudNoiseModel(_ImplicitOpModel):
 
         simulator = _FSim.cast(simulator,
                                state_space.num_qubits if isinstance(state_space, _statespace.QubitSpace) else None)
-        prefer_dense_reps = isinstance(simulator, _MatrixFSim)
-        evotype = _Evotype.cast(evotype, default_prefer_dense_reps=prefer_dense_reps)
+        evotype = _Evotype.cast(evotype, state_space=state_space)
 
         # Build gate dictionaries. A value of `gatedict` can be an array, a LinearOperator, or an OpFactory.
         # For later processing, we'll create mm_gatedict to contain each item as a ModelMember.  For cloud-

pygsti/models/explicitcalc.py

@@ -283,7 +283,7 @@ class ExplicitOpModelCalc(object):
                     wt * Evec.residuals(other_calc.effects[lbl]))
                 nSummands += wt**2 * Evec.dim
 
-        resids = [r.flatten() for r in resids]
+        resids = [r.ravel() for r in resids]
         resids = _np.concatenate(resids)
         return resids, nSummands
 
@@ -545,7 +545,7 @@ class ExplicitOpModelCalc(object):
                 # parameterization object, which gives a vector of length
                 # equal to the number of model *elements*.
                 to_vector = _np.concatenate(
-                    [obj.flatten() for obj in _itertools.chain(
+                    [obj.ravel() for obj in _itertools.chain(
                         mdlDeriv_preps.values(), mdlDeriv_effects.values(),
                         mdlDeriv_ops.values())], axis=0)
                 dPG[:, nParams + i * dim + j] = to_vector
@@ -688,7 +688,7 @@ class ExplicitOpModelCalc(object):
                                 - unitMx_i @ gate @ unitMx_j - unitMx_j @ gate @ unitMx_i
 
                         to_vector = _np.concatenate(
-                            [obj.flatten() for obj in _itertools.chain(
+                            [obj.ravel() for obj in _itertools.chain(
                                 mdlHess_preps.values(), mdlHess_effects.values(),
                                 mdlHess_ops.values())], axis=0)
                         Heps[:, i1 * dim + i2, j1 * dim + j2] = to_vector

pygsti/models/explicitmodel.py

@@ -186,16 +186,6 @@ class ExplicitOpModel(_mdl.OpModel):
         return _explicitcalc.ExplicitOpModelCalc(self.state_space.dim, simplified_preps, simplified_ops,
                                                  simplified_effects, self.num_params, self._param_interposer)
 
-    #Unneeded - just use string processing & rely on effect labels *not* having underscores in them
-    #def simplify_spamtuple_to_outcome_label(self, simplified_spamTuple):
-    #    #TODO: make this more efficient (prep lbl isn't even used!)
-    #    for prep_lbl in self.preps:
-    #        for povm_lbl in self.povms:
-    #            for elbl in self.povms[povm_lbl]:
-    #                if simplified_spamTuple == (prep_lbl, povm_lbl + "_" + elbl):
-    #                    return (elbl,) # outcome "label" (a tuple)
-    #    raise ValueError("No outcome label found for simplified spam_tuple: ", simplified_spamTuple)
-
     def _embed_operation(self, op_target_labels, op_val, force=False):
         """
         Called by OrderedMemberDict._auto_embed to create an embedded-gate
@@ -909,7 +899,7 @@ class ExplicitOpModel(_mdl.OpModel):
         for lbl, inst in self.instruments.items():
             s += "%s = " % str(lbl) + str(inst) + "\n"
         for lbl, factory in self.factories.items():
-            s += "%s = (factory)" % lbl + '\n'
+            s += "%s = (factory)" % str(lbl) + '\n'
         s += "\n"
 
         return s
@@ -1521,11 +1511,11 @@ class ExplicitOpModel(_mdl.OpModel):
             return U_extracted
 
         def add_availability(opkey, op):
-            if opkey == _Label(()) or opkey.is_simple():
+            if opkey == _Label(()) or opkey.is_simple:
                 if opkey == _Label(()):  # special case: turn empty tuple labels into "{idle}" gate in processor spec
                     gn = "{idle}"
                     sslbls = None
-                elif opkey.is_simple():
+                elif opkey.is_simple:
                     gn = opkey.name
                     sslbls = opkey.sslbls
                     #if sslbls is not None:

pygsti/models/fogistore.py

@@ -265,8 +265,9 @@ class FirstOrderGaugeInvariantStore(object):
         errorgen_vec = _np.zeros(self.errorgen_space_dim, 'd')
         for i, (op_label, elem_lbl) in enumerate(self.errorgen_space_op_elem_labels):
             errorgen_vec[i] += op_coeffs[op_label].get(elem_lbl, 0.0)
-        return self.errorgen_vec_to_fogi_components_array(errorgen_vec), \
-            self.errorgen_vec_to_fogv_components_array(errorgen_vec)
+        out1 = self.errorgen_vec_to_fogi_components_array(errorgen_vec)
+        out2 = self.errorgen_vec_to_fogv_components_array(errorgen_vec)
+        return out1, out2
 
     def fogi_components_array_to_errorgen_vec(self, fogi_components):
         assert(self._dependent_fogi_action == 'drop'), \
@@ -547,7 +548,8 @@ class FirstOrderGaugeInvariantStore(object):
         else:
             raise ValueError("Invalid intrinsic_or_relational value: `%s`" % str(intrinsic_or_relational))
 
-        space = _mt.remove_dependent_cols(space)
+        col_indices = _mt.independent_columns(space)
+        space = space[:, col_indices]
         return space
 
     @classmethod

pygsti/models/localnoisemodel.py

@@ -152,8 +152,7 @@ class LocalNoiseModel(_ImplicitOpModel):
 
         simulator = _FSim.cast(simulator,
                                state_space.num_qubits if isinstance(state_space, _statespace.QubitSpace) else None)
-        prefer_dense_reps = isinstance(simulator, _MatrixFSim)
-        evotype = _Evotype.cast(evotype, default_prefer_dense_reps=prefer_dense_reps)
+        evotype = _Evotype.cast(evotype, state_space=state_space)
 
         # Build gate dictionaries. A value of `gatedict` can be an array, a LinearOperator, or an OpFactory.
         # For later processing, we'll create mm_gatedict to contain each item as a ModelMember.  In local noise

pygsti/models/memberdict.py

@@ -45,18 +45,6 @@ class _PrefixOrderedDict(_collections.OrderedDict):
                            "beginning with the prefix '%s'" % self._prefix)
         super(_PrefixOrderedDict, self).__setitem__(key, val)
 
-    #Handled by derived classes
-    #def __reduce__(self):
-    #    items = [(k,v) for k,v in self.iteritems()]
-    #    return (_PrefixOrderedDict, (self._prefix, items), None)
-
-    """
-    An ordered dictionary whose keys must begin with a given prefix,
-    and which holds LinearOperator objects.  This class ensures that every value is a
-    :class:`LinearOperator`-derived object by converting any non-`LinearOperator` values into
-    `LinearOperator`s upon assignment and raising an error if this is not possible.
-    """
-
 
 class OrderedMemberDict(_PrefixOrderedDict, _mm.ModelChild):
     """