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

pygsti/drivers/longsequence.py

@@ -24,6 +24,8 @@ from pygsti.baseobjs.advancedoptions import GSTAdvancedOptions as _GSTAdvancedOp
 from pygsti.models.model import Model as _Model
 from pygsti.models.modelconstruction import _create_explicit_model, create_explicit_model
 from pygsti.protocols.gst import _load_pspec_or_model
+from pygsti.forwardsims import ForwardSimulator
+from typing import Optional
 
 ROBUST_SUFFIX_LIST = [".robust", ".Robust", ".robust+", ".Robust+"]
 DEFAULT_BAD_FIT_THRESHOLD = 2.0
@@ -35,7 +37,8 @@ def run_model_test(model_filename_or_object,
                    germs_list_or_filename, max_lengths, gauge_opt_params=None,
                    advanced_options=None, comm=None, mem_limit=None,
                    output_pkl=None, verbosity=2, checkpoint=None, checkpoint_path=None,
-                   disable_checkpointing= False):
+                   disable_checkpointing=False,
+                   simulator: Optional[ForwardSimulator.Castable]=None):
     """
     Compares a :class:`Model`'s predictions to a `DataSet` using GST-like circuits.
 
@@ -138,6 +141,11 @@ def run_model_test(model_filename_or_object,
         to disk during the course of this protocol. It is strongly recommended
         that this be kept set to False without good reason to disable the checkpoints.
 
+    simulator : ForwardSimulator.Castable or None
+        Ignored if None. If not None, then we call
+            fwdsim = ForwardSimulator.cast(simulator),
+        and we set the .sim attribute of every Model we encounter to fwdsim.
+
     Returns
     -------
     Results
@@ -170,6 +178,7 @@ def run_model_test(model_filename_or_object,
     if isinstance(pspec_or_model, _Model):
         target_model= pspec_or_model
     elif isinstance(pspec_or_model, _ProcessorSpec):
+
         target_model= create_explicit_model(pspec_or_model, 
                                              basis= _load_model(model_filename_or_object).basis)
 
@@ -185,7 +194,9 @@ def run_model_test(model_filename_or_object,
     proto.circuit_weights = advanced_options.get('circuit_weights', None)
     proto.unreliable_ops = advanced_options.get('unreliable_ops', ['Gcnot', 'Gcphase', 'Gms', 'Gcn', 'Gcx', 'Gcz'])
 
-    results = proto.run(data, mem_limit, comm, checkpoint=checkpoint, checkpoint_path=checkpoint_path, disable_checkpointing=disable_checkpointing)
+    results = proto.run(data, mem_limit, comm,
+                        checkpoint=checkpoint, checkpoint_path=checkpoint_path, disable_checkpointing=disable_checkpointing,
+                        simulator=simulator)
     _output_to_pickle(results, output_pkl, comm)
     return results
 
@@ -306,7 +317,8 @@ def run_long_sequence_gst(data_filename_or_set, target_model_filename_or_object,
                           germs_list_or_filename, max_lengths, gauge_opt_params=None,
                           advanced_options=None, comm=None, mem_limit=None,
                           output_pkl=None, verbosity=2, checkpoint=None, checkpoint_path=None,
-                          disable_checkpointing = False):
+                          disable_checkpointing=False,
+                          simulator: Optional[ForwardSimulator.Castable]=None):
     """
     Perform long-sequence GST (LSGST).
 
@@ -439,11 +451,17 @@ def run_long_sequence_gst(data_filename_or_set, target_model_filename_or_object,
         completed iteration number appended to it before writing it to disk.
         If none, the value of {name} will be set to the name of the protocol
         being run.
+
     disable_checkpointing : bool, optional (default False)
         When set to True checkpoint objects will not be constructed and written
         to disk during the course of this protocol. It is strongly recommended
         that this be kept set to False without good reason to disable the checkpoints.
 
+    simulator : ForwardSimulator.Castable or None
+        Ignored if None. If not None, then we call
+            fwdsim = ForwardSimulator.cast(simulator),
+        and we set the .sim attribute of every Model we encounter to fwdsim.
+
     Returns
     -------
     Results
@@ -488,7 +506,9 @@ def run_long_sequence_gst(data_filename_or_set, target_model_filename_or_object,
     proto.circuit_weights = advanced_options.get('circuit_weights', None)
     proto.unreliable_ops = advanced_options.get('unreliable_ops', ['Gcnot', 'Gcphase', 'Gms', 'Gcn', 'Gcx', 'Gcz'])
 
-    results = proto.run(data, mem_limit, comm, checkpoint=checkpoint, checkpoint_path= checkpoint_path, disable_checkpointing=disable_checkpointing)
+    results = proto.run(data, mem_limit, comm,
+                        checkpoint=checkpoint, checkpoint_path= checkpoint_path, disable_checkpointing=disable_checkpointing,
+                        simulator=simulator)
     _output_to_pickle(results, output_pkl, comm)
     return results
 
@@ -497,7 +517,8 @@ def run_long_sequence_gst_base(data_filename_or_set, target_model_filename_or_ob
                                lsgst_lists, gauge_opt_params=None,
                                advanced_options=None, comm=None, mem_limit=None,
                                output_pkl=None, verbosity=2, checkpoint=None, checkpoint_path=None,
-                               disable_checkpointing = False):
+                               disable_checkpointing=False,
+                               simulator: Optional[ForwardSimulator.Castable]=None):
     """
     A more fundamental interface for performing end-to-end GST.
 
@@ -582,7 +603,12 @@ def run_long_sequence_gst_base(data_filename_or_set, target_model_filename_or_ob
         When set to True checkpoint objects will not be constructed and written
         to disk during the course of this protocol. It is strongly recommended
         that this be kept set to False without good reason to disable the checkpoints.
-        
+
+    simulator : ForwardSimulator.Castable or None
+        Ignored if None. If not None, then we call
+            fwdsim = ForwardSimulator.cast(simulator),
+        and we set the .sim attribute of every Model we encounter to fwdsim.
+
     Returns
     -------
     Results
@@ -615,7 +641,9 @@ def run_long_sequence_gst_base(data_filename_or_set, target_model_filename_or_ob
     proto.circuit_weights = advanced_options.get('circuit_weights', None)
     proto.unreliable_ops = advanced_options.get('unreliable_ops', ['Gcnot', 'Gcphase', 'Gms', 'Gcn', 'Gcx', 'Gcz'])
 
-    results = proto.run(data, mem_limit, comm, checkpoint=checkpoint, checkpoint_path=checkpoint_path, disable_checkpointing=disable_checkpointing)
+    results = proto.run(data, mem_limit, comm,
+                        checkpoint=checkpoint, checkpoint_path=checkpoint_path, disable_checkpointing=disable_checkpointing,
+                        simulator=simulator)
     _output_to_pickle(results, output_pkl, comm)
     return results
 
@@ -624,7 +652,8 @@ def run_stdpractice_gst(data_filename_or_set, target_model_filename_or_object, p
                         meas_fiducial_list_or_filename, germs_list_or_filename, max_lengths,
                         modes=('full TP','CPTPLND','Target'), gaugeopt_suite='stdgaugeopt', gaugeopt_target=None,
                         models_to_test=None, comm=None, mem_limit=None, advanced_options=None, output_pkl=None,
-                        verbosity=2, checkpoint=None, checkpoint_path=None, disable_checkpointing = False):
+                        verbosity=2, checkpoint=None, checkpoint_path=None, disable_checkpointing=False,
+                        simulator: Optional[ForwardSimulator.Castable]=None):
     """
     Perform end-to-end GST analysis using standard practices.
 
@@ -748,6 +777,11 @@ def run_stdpractice_gst(data_filename_or_set, target_model_filename_or_object, p
         to disk during the course of this protocol. It is strongly recommended
         that this be kept set to False without good reason to disable the checkpoints.
 
+    simulator : ForwardSimulator.Castable or None
+        Ignored if None. If not None, then we call
+            fwdsim = ForwardSimulator.cast(simulator),
+        and we set the .sim attribute of every Model we encounter to fwdsim.
+
     Returns
     -------
     Results
@@ -791,7 +825,9 @@ def run_stdpractice_gst(data_filename_or_set, target_model_filename_or_object, p
                                badfit_options=_get_badfit_options(advanced_options), verbosity=printer,
                                name=advanced_options.get('estimate_label', None))
 
-    results = proto.run(data, mem_limit, comm, checkpoint=checkpoint, checkpoint_path= checkpoint_path, disable_checkpointing=disable_checkpointing)
+    results = proto.run(data, mem_limit, comm,
+                        checkpoint=checkpoint, checkpoint_path= checkpoint_path, disable_checkpointing=disable_checkpointing,
+                        simulator=simulator)
     _output_to_pickle(results, output_pkl, comm)
     return results
 
@@ -895,7 +931,7 @@ def _get_optimizer(advanced_options, model_being_optimized):
     from pygsti.forwardsims.matrixforwardsim import MatrixForwardSimulator as _MatrixFSim
     advanced_options = advanced_options or {}
     default_fditer = 1 if isinstance(model_being_optimized.sim, _MatrixFSim) else 0
-    optimizer = {'maxiter': advanced_options.get('max_iterations', 100000),
+    optimizer = {'maxiter': advanced_options.get('max_iterations', 100),
                  'tol': advanced_options.get('tolerance', 1e-6),
                  'fditer': advanced_options.get('finitediff_iterations', default_fditer)}
     optimizer.update(advanced_options.get('extra_lm_opts', {}))

pygsti/evotypes/chp/opreps.py

@@ -49,11 +49,6 @@ class OpRep(_basereps.OpRep):
     def _chp_ops(self, seed_or_state=None):
         return self.base_chp_ops
 
-    #def chp_str(self, seed_or_state=None):
-    #    op_str = '\n'.join(self.chp_ops(seed_or_state=seed_or_state))
-    #    if len(op_str) > 0: op_str += '\n'
-    #    return op_str
-
     def to_dense(self, on_space):
         try:
             str_ops = str(self._chp_ops())
@@ -217,63 +212,7 @@ class OpRepStochastic(OpRepRandomUnitary):
 
         super(OpRepStochastic, self).__init__(basis, _np.array(rates, 'd'), reps, seed_or_state, state_space)
 
-        #OLD
-        #self.basis = basis
-        #assert (basis.name == 'pp'), "Only Pauli basis is allowed for 'chp' evotype"
-        #
-        #if isinstance(seed_or_state, _RandomState):
-        #    self.rand_state = seed_or_state
-        #else:
-        #    self.rand_state = _RandomState(seed_or_state)
-        #
-        ##TODO: need to fix this: `basis` above functions as basis to make superoperators out of, but here we have
-        ## a CHP stochastic op which is given a basis for the space - e.g. a dim=2 vector space for 1 qubit, so
-        ## we need to distinguish/specify the basis better for this... and what about rate_poly_dicts (see svterm)
-        #nqubits = state_space.num_qubits
-        #assert(self.basis.dim == 4**nqubits), "Must have an integral number of qubits"
-        #
-        #std_chp_ops = _itgs.standard_gatenames_chp_conversions()
-        #
-        ## For CHP, need to make a Composed + EmbeddedOp for the super operators
-        ## For lower overhead, make this directly using the rep instead of with objects
-        #self.stochastic_superop_reps = []
-        #for label in self.basis.labels[1:]:
-        #    combined_chp_ops = []
-        #
-        #    for i, pauli in enumerate(label):
-        #        name = 'Gi' if pauli == "I" else 'G%spi' % pauli.lower()
-        #        chp_op = std_chp_ops[name]
-        #        chp_op_targeted = [op.replace('0', str(i)) for op in chp_op]
-        #        combined_chp_ops.extend(chp_op_targeted)
-        #
-        #    sub_rep = OpRep(combined_chp_ops, state_space)
-        #    self.stochastic_superop_reps.append(sub_rep)
-        #self.rates = initial_rates
-        #super(OpRepStochastic, self).__init__([], state_space)  # don't store any chp_ops in base
-
     def update_rates(self, rates):
         unitary_rates = [1 - sum(rates)] + list(rates)
         self.rates[:] = rates
         self.update_unitary_rates(unitary_rates)
-
-    #TODO REMOVE - covered by OpRepRandomUnitary
-    #def chp_ops(self, seed_or_state=None):
-    #    # Optionally override RNG for this call
-    #    if seed_or_state is not None:
-    #        if isinstance(seed_or_state, _np.random.RandomState):
-    #            rand_state = seed_or_state
-    #        else:
-    #            rand_state = _np.random.RandomState(seed_or_state)
-    #    else:
-    #        rand_state = self.rand_state
-    #
-    #    rates = self.rates
-    #    all_rates = [*rates, 1.0 - sum(rates)]  # Include identity so that probabilities are 1
-    #    index = rand_state.choice(self.basis.size, p=all_rates)
-    #
-    #    # If final entry, no operation selected
-    #    if index == self.basis.size - 1:
-    #        return []
-    #
-    #    rep = self.stochastic_superop_reps[index]
-    #    return rep._chp_ops()

pygsti/evotypes/chp/statereps.py

@@ -40,16 +40,6 @@ class StateRep(_basereps.StateRep):
     def num_qubits(self):
         return self.state_space.num_qubits
 
-    #REMOVE
-    #def chp_ops(self, seed_or_state=None):
-    #    return self.base_chp_ops
-
-    #REMOVE
-    #def chp_str(self, seed_or_state=None):
-    #    op_str = '\n'.join(self.chp_ops(seed_or_state=seed_or_state))
-    #    if len(op_str) > 0: op_str += '\n'
-    #    return op_str
-
     def copy(self):
         return StateRep(self.chp_ops, self.state_space)
 
@@ -87,25 +77,3 @@ class StateRepComposed(StateRep):
     def actionable_staterep(self):
         state_rep = self.state_rep.actionable_staterep()
         return self.op_rep.acton(state_rep)
-
-#REMOVE
-#    def chp_ops(self, seed_or_state=None):
-#        return self.state_rep.chp_ops(seed_or_state=seed_or_state) \
-#            + self.op_rep.chp_ops(seed_or_state=seed_or_state)
-
-# TODO: Untested, only support computational and composed for now
-#class StateRepTensorProduct(StateRep):
-#    def __init__(self, factor_state_reps, state_space):
-#        self.factor_reps = factor_state_reps
-#        super(StateRepTensorProduct, self).__init__([], state_space)
-#        self.reps_have_changed()
-#
-#    def reps_have_changed(self):
-#        chp_ops = []
-#        current_iqubit = 0
-#        for factor in self.factor_reps:
-#            local_to_tp_index = {str(iloc): str(itp) for iloc, itp in
-#                                 enumerate(range(current_iqubit, current_iqubit + factor.num_qubits))}
-#            chp_ops.extend([_update_chp_op(op, local_to_tp_index) for op in self.chp_ops])
-#            current_iqubit += factor.num_qubits
-#        self.chp_ops = chp_ops

pygsti/evotypes/densitymx/effectcreps.cpp

@@ -147,7 +147,7 @@ namespace CReps_densitymx {
 	finalIndx += ((finds >> k) & 1) * 3 * base;
 	base = base >> 2; // /= 4 so base == 4**(N-1-k)
       }
-
+      
       //Apply result
       if(parity(finds & _zvals_int))
 	ret -= _abs_elval * state->_dataptr[finalIndx]; // minus sign
@@ -157,15 +157,14 @@ namespace CReps_densitymx {
     return ret;
   }
 
-  INT EffectCRep_Computational::parity(INT x) {
-    // int64-bit specific
-    x = (x & 0x00000000FFFFFFFF)^(x >> 32);
-    x = (x & 0x000000000000FFFF)^(x >> 16);
-    x = (x & 0x00000000000000FF)^(x >> 8);
-    x = (x & 0x000000000000000F)^(x >> 4);
-    x = (x & 0x0000000000000003)^(x >> 2);
-    x = (x & 0x0000000000000001)^(x >> 1);
-    return x & 1; // return the last bit (0 or 1)
+  inline INT EffectCRep_Computational::parity(INT x) {
+    x ^= (x >> 32);
+    x ^= (x >> 16);
+    x ^= (x >> 8);
+    x ^= (x >> 4);
+    x ^= (x >> 2);
+    x ^= (x >> 1);
+    return x & 1; // Return the last bit
   }
 
 

pygsti/evotypes/densitymx/effectreps.pyx

@@ -108,7 +108,7 @@ cdef class EffectRepTensorProduct(EffectRep):
         cdef _np.ndarray[_np.int64_t, ndim=1, mode='c'] factor_dims = \
             _np.ascontiguousarray(_np.array([fct.state_space.dim for fct in povm_factors], _np.int64))
 
-        cdef INT dim = _np.product(factor_dims)
+        cdef INT dim = _np.prod(factor_dims)
         cdef INT nfactors = len(povm_factors)
         self.povm_factors = povm_factors
         self.effect_labels = effect_labels

pygsti/evotypes/densitymx/opreps.pyx

@@ -540,7 +540,7 @@ def _compute_embedding_quantities_cachekey(state_space, target_labels, embedded_
     # final map just acts as identity w.r.t.
     labelIndices = [tensorProdBlkLabels.index(label) for label in target_labels]
     cdef _np.ndarray[_np.int64_t, ndim=1, mode='c'] action_inds = _np.array(labelIndices, _np.int64)
-    assert(_np.product([num_basis_els[i] for i in action_inds]) == embedded_rep_dim), \
+    assert(_np.prod([num_basis_els[i] for i in action_inds]) == embedded_rep_dim), \
         "Embedded operation has dimension (%d) inconsistent with the given target labels (%s)" % (
             embedded_rep_dim, str(target_labels))
 
@@ -550,7 +550,7 @@ def _compute_embedding_quantities_cachekey(state_space, target_labels, embedded_
     cdef INT ncomponents_in_active_block = len(state_space.tensor_product_block_labels(active_block_index))
     cdef INT embedded_dim = embedded_rep_dim
     cdef _np.ndarray[_np.int64_t, ndim=1, mode='c'] blocksizes = \
-        _np.array([_np.product(state_space.tensor_product_block_dimensions(k))
+        _np.array([_np.prod(state_space.tensor_product_block_dimensions(k))
                    for k in range(nblocks)], _np.int64)
     cdef INT i, j
 

pygsti/evotypes/densitymx/statereps.pyx

@@ -163,7 +163,7 @@ cdef class StateRepTensorProduct(StateRep):
 
     def __cinit__(self, factor_state_reps, state_space):
         self.factor_reps = factor_state_reps
-        dim = _np.product([fct.dim for fct in self.factor_reps])
+        dim = _np.prod([fct.dim for fct in self.factor_reps])
         self._cinit_base(_np.zeros(dim, 'd'), state_space)
         self.reps_have_changed()
 

pygsti/evotypes/densitymx_slow/effectreps.py

@@ -13,12 +13,13 @@ POVM effect representation classes for the `densitymx_slow` evolution type.
 import numpy as _np
 
 # import functools as _functools
-from .. import basereps as _basereps
 from pygsti.baseobjs.statespace import StateSpace as _StateSpace
 from ...tools import matrixtools as _mt
 
 
-class EffectRep(_basereps.EffectRep):
+class EffectRep:
+    """Any representation of an "effect" in the sense of a POVM."""
+
     def __init__(self, state_space):
         self.state_space = _StateSpace.cast(state_space)
 
@@ -27,6 +28,10 @@ class EffectRep(_basereps.EffectRep):
 
 
 class EffectRepConjugatedState(EffectRep):
+    """
+    A real superket representation of an "effect" in the sense of a POVM.
+    Internally uses a StateRepDense object to hold the real superket.
+    """
 
     def __init__(self, state_rep):
         self.state_rep = state_rep
@@ -100,11 +105,6 @@ class EffectRepTensorProduct(EffectRep):
         super(EffectRepTensorProduct, self).__init__(state_space)
         self.factor_effects_have_changed()
 
-    #TODO: fix this:
-    #def __reduce__(self):
-    #    return (EffectRepTensorProduct,
-    #            (self.kron_array, self.factor_dims, self.nfactors, self.max_factor_dim, self.dim))
-
     def to_dense(self, on_space, outvec=None):
 
         if on_space not in ('minimal', 'HilbertSchmidt'):
@@ -159,22 +159,6 @@ class EffectRepTensorProduct(EffectRep):
     def factor_effects_have_changed(self):
         self._fill_fast_kron()  # updates effect reps
 
-    #def to_dense(self):
-    #    if len(self.factors) == 0: return _np.empty(0, complex if self._evotype == "statevec" else 'd')
-    #        #NOTE: moved a fast version of to_dense to replib - could use that if need a fast to_dense call...
-    #
-    #        factorPOVMs = self.factors
-    #        ret = factorPOVMs[0][self.effectLbls[0]].to_dense()
-    #        for i in range(1, len(factorPOVMs)):
-    #            ret = _np.kron(ret, factorPOVMs[i][self.effectLbls[i]].to_dense())
-    #        return ret
-    #    elif self._evotype == "stabilizer":
-    #        # each factor is a StabilizerEffectVec
-    #        raise ValueError("Cannot convert Stabilizer tensor product effect to an array!")
-    #    # should be using effect.outcomes property...
-    #    else:  # self._evotype in ("svterm","cterm")
-    #        raise NotImplementedError("to_dense() not implemented for %s evolution type" % self._evotype)
-
 
 class EffectRepComposed(EffectRep):
     def __init__(self, op_rep, effect_rep, op_id, state_space):

pygsti/evotypes/densitymx_slow/opreps.py

@@ -17,7 +17,6 @@ import scipy.sparse as _sps
 from scipy.sparse.linalg import LinearOperator
 
 from .statereps import StateRepDense as _StateRepDense
-from .. import basereps as _basereps
 from pygsti.baseobjs.statespace import StateSpace as _StateSpace
 from ...tools import basistools as _bt
 from ...tools import internalgates as _itgs
@@ -26,7 +25,11 @@ from ...tools import matrixtools as _mt
 from ...tools import optools as _ot
 
 
-class OpRep(_basereps.OpRep):
+class OpRep:
+    """
+    A real superoperator on Hilbert-Schmidt space.
+    """
+
     def __init__(self, state_space):
         self.state_space = state_space
 
@@ -41,6 +44,10 @@ class OpRep(_basereps.OpRep):
         raise NotImplementedError()
 
     def aslinearoperator(self):
+        """
+        Return a SciPy LinearOperator that accepts superket representations of vectors
+        in Hilbert-Schmidt space and returns a vector of that same representation.
+        """
         def mv(v):
             if v.ndim == 2 and v.shape[1] == 1: v = v[:, 0]
             in_state = _StateRepDense(_np.ascontiguousarray(v, 'd'), self.state_space, None)
@@ -54,6 +61,12 @@ class OpRep(_basereps.OpRep):
 
 
 class OpRepDenseSuperop(OpRep):
+    """
+    A real superoperator on Hilbert-Schmidt space.
+    The operator's action (and adjoint action) work with Hermitian matrices
+    stored as *vectors* in their real superket representations.
+    """
+
     def __init__(self, mx, basis, state_space):
         state_space = _StateSpace.cast(state_space)
         if mx is None:
@@ -174,7 +187,7 @@ class OpRepStandard(OpRepDenseSuperop):
         state_space = _StateSpace.cast(state_space)
         assert(superop.shape[0] == state_space.dim)
 
-        super(OpRepStandard, self).__init__(superop, state_space)
+        super(OpRepStandard, self).__init__(superop, basis, state_space)
 
 
 class OpRepKraus(OpRep):
@@ -257,10 +270,6 @@ class OpRepStochastic(OpRepRandomUnitary):
         self.rates[:] = rates
         self.update_unitary_rates(unitary_rates)
 
-#class OpRepClifford(OpRep):  # TODO?
-#    #def __init__(self, unitarymx, symplecticrep):
-#    #    pass
-
 
 class OpRepComposed(OpRep):
 
@@ -362,13 +371,6 @@ class OpRepEmbedded(OpRep):
         self.offset = sum(blocksizes[0:self.active_block_index])
         super(OpRepEmbedded, self).__init__(state_space)
 
-    #def __reduce__(self):
-    #    return (DMOpRepEmbedded, (self.embedded,
-    #                              self.num_basis_els, self.action_inds,
-    #                              self.blocksizes, self.embeddedDim,
-    #                              self.ncomponents, self.active_block_index,
-    #                              self.nblocks, self.dim))
-
     def _acton_other_blocks_trivially(self, output_state, state):
         offset = 0
         for iBlk, blockSize in enumerate(self.blocksizes):
@@ -453,15 +455,6 @@ class OpRepExpErrorgen(OpRep):
     def exp_params(self):
         return (self.mu, self.eta, self.m_star, self.s)
 
-    #def __reduce__(self):
-    #    if self.unitary_postfactor is None:
-    #        return (DMOpRepLindblad, (self.errorgen_rep, self.mu, self.eta, self.m_star, self.s,
-    #                                  _np.empty(0, 'd'), _np.empty(0, _np.int64), _np.zeros(1, _np.int64)))
-    #    else:
-    #        return (DMOpRepLindblad, (self.errorgen_rep, self.mu, self.eta, self.m_star, self.s,
-    #                                  self.unitary_postfactor.data, self.unitary_postfactor.indices,
-    #                                  self.unitary_postfactor.indptr))
-
     def acton(self, state):
         """ Act this gate map on an input state """
         statedata = state.data.copy()  # must COPY because _custom... call below *modifies* "b" arg

pygsti/evotypes/densitymx_slow/statereps.py

@@ -14,7 +14,6 @@ import functools as _functools
 
 import numpy as _np
 
-from .. import basereps as _basereps
 from pygsti.baseobjs.statespace import StateSpace as _StateSpace
 from ...tools import basistools as _bt
 from ...tools import optools as _ot
@@ -25,13 +24,17 @@ except ImportError:
     _fastcalc = None
 
 
-class StateRep(_basereps.StateRep):
+class StateRep:
+    """A real superket representation of an element in Hilbert-Schmidt space."""
+
     def __init__(self, data, state_space):
         #vec = _np.asarray(vec, dtype='d')
         assert(data.dtype == _np.dtype('d'))
         self.data = _np.require(data.copy(), requirements=['OWNDATA', 'C_CONTIGUOUS'])
         self.state_space = _StateSpace.cast(state_space)
-        assert(len(self.data) == self.state_space.dim)
+        ds0 = self.data.shape[0]
+        assert(ds0 == self.state_space.dim)
+        assert(ds0 == self.data.size)
 
     def __reduce__(self):
         return (StateRep, (self.data, self.state_space), (self.data.flags.writeable,))
@@ -62,6 +65,10 @@ class StateRep(_basereps.StateRep):
 
 
 class StateRepDense(StateRep):
+    """
+    An almost-trivial wrapper around StateRep.
+    Implements the "base" property and defines a trivial "base_has_changed" function.
+    """
 
     def __init__(self, data, state_space, basis):
         #ignore basis for now (self.basis = basis in future?)

pygsti/evotypes/evotype.py

@@ -1,6 +1,7 @@
 import importlib as _importlib
 
 from . import basereps as _basereps
+from pygsti.baseobjs.statespace import StateSpace as _StateSpace
 
 
 class Evotype(object):
@@ -50,10 +51,46 @@ class Evotype(object):
     }
 
     @classmethod
-    def cast(cls, obj, default_prefer_dense_reps=False):
+    def cast(cls, obj, default_prefer_dense_reps=None, state_space=None):
+        """
+        Cast the specified object to an Evotype with options for default Evotype
+        handling.
+
+        Parameters
+        ----------
+        obj : Evotype or str
+            Object to cast to an Evotype. If already an Evotype the object is simply
+            returned. Otherwise if a string we attempt to cast it to a recognized
+            evotype option. If the string "default" is passed in then we determine
+            the type of evotype used in conjunction with the two optional kwargs below.
+
+        default_prefer_dense_reps : None or bool, optional (default None)
+            Flag to indicate preference for dense representation types when casting
+            a string. If None then there is no preference and this will be determined
+            by the optional state_space kwarg, if present. Otherwise if a boolean value
+            this selection overrides any logic based on the state space.
+
+        state_space : StateSpace, optional (default None)
+            If not None then the dimension of the state space is used to determine whether
+            or not to prefer the use of dense representation types when not already specified
+            by the default_prefer_dense_reps kwarg.
+        
+        Returns
+        -------
+        Evotype
+        """
         if isinstance(obj, Evotype):
             return obj
-        elif obj == "default":
+        
+        if default_prefer_dense_reps is None:
+            if state_space is None:
+                default_prefer_dense_reps = False #reproduces legacy behavior.
+            else:
+                if not isinstance(state_space, _StateSpace):
+                    raise ValueError('state_space must be a StateSpace object.')
+                default_prefer_dense_reps = False if state_space.dim > 64 else True #HARDCODED
+
+        if obj == "default":
             return Evotype(cls.default_evotype, default_prefer_dense_reps)
         else:  # assume obj is a string naming an evotype
             return Evotype(str(obj), default_prefer_dense_reps)

pygsti/evotypes/stabilizer/effectreps.pyx

@@ -39,10 +39,6 @@ cdef class EffectRep(_basereps_cython.EffectRep):
     def nqubits(self):
         return self.state_space.num_qubits
 
-    #@property
-    #def dim(self):
-    #    return 2**(self.c_effect._n)  # assume "unitary evolution"-type mode
-
     def probability(self, StateRep state not None):
         #unnecessary (just put in signature): cdef StateRep st = <StateRep?>state
         return self.c_effect.probability(state.c_state)

pygsti/evotypes/stabilizer/opreps.pyx

@@ -40,10 +40,6 @@ cdef class OpRep(_basereps_cython.OpRep):
     def nqubits(self):
         return self.state_space.num_qubits
 
-    #@property
-    #def dim(self):
-    #    return 2**(self.nqubits)  # assume "unitary evolution"-type mode
-
     def acton(self, StateRep state not None):
         cdef INT n = self.c_rep._n
         cdef INT namps = state.c_state._namps

pygsti/evotypes/stabilizer/statereps.pyx

@@ -49,10 +49,6 @@ cdef class StateRep(_basereps_cython.StateRep):
     def nqubits(self):
         return self.state_space.num_qubits
 
-    #@property
-    #def dim(self):
-    #    return 2**(self.c_state._n) # assume "unitary evolution"-type mode
-
     def actionable_staterep(self):
         # return a state rep that can be acted on by op reps or mapped to
         # a probability/amplitude by POVM effect reps.
@@ -129,7 +125,7 @@ cdef class StateRepTensorProduct(StateRep):
     def __cinit__(self, factor_state_reps, state_space):
         self.factor_reps = factor_state_reps
         n = sum([sf.nqubits for sf in self.factor_reps])  # total number of qubits
-        np = int(_np.product([len(sf.pvectors) for sf in self.factor_reps]))
+        np = int(_np.prod([len(sf.pvectors) for sf in self.factor_reps]))
         self._cinit_base(_np.zeros((2 * n, 2 * n), _np.int64),
                          _np.zeros((np, 2 * n), _np.int64),
                          _np.ones(np, complex),