pyGSTi 0.9.12.1__cp310-cp310-win32.whl → 0.9.13__cp310-cp310-win32.whl

pygsti/modelmembers/operations/linearop.py

@@ -128,28 +128,6 @@ class LinearOperator(_modelmember.ModelMember):
         """
         pass
 
-    #def rep_at_time(self, t):
-    #    """
-    #    Retrieves a representation of this operator at time `t`.
-    #
-    #    This is operationally equivalent to calling `self.set_time(t)` and
-    #    then retrieving `self._rep`.  However, what is returned from this function
-    #    need not be the same rep object for different times, allowing the
-    #    operator object to cache many reps for different times to increase performance
-    #    (this avoids having to initialize the same rep at a given time).
-    #
-    #    Parameters
-    #    ----------
-    #    t : float
-    #        The time.
-    #
-    #    Returns
-    #    -------
-    #    object
-    #    """
-    #    self.set_time(t)
-    #    return self._rep
-
     def to_dense(self, on_space='minimal'):
         """
         Return this operation as a dense matrix.
@@ -483,12 +461,14 @@ class LinearOperator(_modelmember.ModelMember):
         numpy.ndarray
             A 1D-array of size equal to that of the flattened operation matrix.
         """
-        if transform is None and inv_transform is None:
-            return _ot.residuals(self.to_dense(on_space='minimal'), other_op.to_dense(on_space='minimal'))
+        dense_self = self.to_dense(on_space='minimal')
+        if transform is not None:
+            assert inv_transform is not None
+            dense_self = inv_transform @ (dense_self @ transform)
         else:
-            return _ot.residuals(_np.dot(
-                inv_transform, _np.dot(self.to_dense(on_space='minimal'), transform)),
-                other_op.to_dense(on_space='minimal'))
+            assert inv_transform is None
+        return (dense_self - other_op.to_dense(on_space='minimal')).ravel()
+
 
     def jtracedist(self, other_op, transform=None, inv_transform=None):
         """

pygsti/modelmembers/operations/opfactory.py

@@ -98,7 +98,7 @@ class OpFactory(_gm.ModelMember):
     def __init__(self, state_space, evotype):
         #self._paramvec = _np.zeros(nparams, 'd')
         state_space = _statespace.StateSpace.cast(state_space)
-        evotype = _Evotype.cast(evotype)
+        evotype = _Evotype.cast(evotype, state_space=state_space)
         _gm.ModelMember.__init__(self, state_space, evotype)
 
     def create_object(self, args=None, sslbls=None):

pygsti/modelmembers/operations/repeatedop.py

@@ -45,7 +45,7 @@ class RepeatedOp(_LinearOperator):
 
         if evotype == "auto":
             evotype = op_to_repeat._evotype
-        evotype = _Evotype.cast(evotype)
+        evotype = _Evotype.cast(evotype, state_space=state_space)
         rep = evotype.create_repeated_rep(self.repeated_op._rep, self.num_repetitions, state_space)
         _LinearOperator.__init__(self, rep, evotype)
         self.init_gpindices()  # initialize our gpindices based on sub-members
@@ -113,29 +113,6 @@ class RepeatedOp(_LinearOperator):
         op = self.repeated_op.to_dense(on_space)
         return _np.linalg.matrix_power(op, self.num_repetitions)
 
-    #def torep(self):
-    #    """
-    #    Return a "representation" object for this operation.
-    #
-    #    Such objects are primarily used internally by pyGSTi to compute
-    #    things like probabilities more efficiently.
-    #
-    #    Returns
-    #    -------
-    #    OpRep
-    #    """
-    #    if self._evotype == "densitymx":
-    #        return replib.DMOpRepExponentiated(self.repeated_op.torep(), self.power, self.dim)
-    #    elif self._evotype == "statevec":
-    #        return replib.SVOpRepExponentiated(self.repeated_op.torep(), self.power, self.dim)
-    #    elif self._evotype == "stabilizer":
-    #        nQubits = int(round(_np.log2(self.dim)))  # "stabilizer" is a unitary-evolution type mode
-    #        return replib.SVOpRepExponentiated(self.repeated_op.torep(), self.power, nQubits)
-    #    assert(False), "Invalid internal _evotype: %s" % self._evotype
-
-    #FUTURE: term-related functions (maybe base off of ComposedOp or use a composedop to generate them?)
-    # e.g. ComposedOp([self.repeated_op] * power, dim, evotype)
-
     @property
     def parameter_labels(self):
         """

pygsti/modelmembers/operations/staticstdop.py

@@ -54,7 +54,7 @@ class StaticStandardOp(_LinearOperator, _NoErrorGeneratorInterface):
             else _statespace.StateSpace.cast(state_space)
         basis = _Basis.cast(basis, state_space.dim)  # basis for Hilbert-Schmidt (superop) space
 
-        evotype = _Evotype.cast(evotype)
+        evotype = _Evotype.cast(evotype, state_space=state_space)
         rep = evotype.create_standard_rep(name, basis, state_space)
         _LinearOperator.__init__(self, rep, evotype)
 

pygsti/modelmembers/povms/__init__.py

@@ -125,8 +125,8 @@ def create_from_dmvecs(superket_vectors, povm_type, basis='pp', evotype='default
                 EffectiveExpErrorgen = _IdentityPlusErrorgenOp if lndtype.meta == '1+' else _ExpErrorgenOp
                 povm = ComposedPOVM(EffectiveExpErrorgen(errorgen), base_povm, mx_basis=basis)
             elif typ in ('computational', 'static pure', 'full pure'):
-                # RESHAPE NOTE: .flatten() added to line below (to convert pure *col* vec -> 1D) to fix unit tests
-                pure_vectors = {k: _ot.dmvec_to_state(_bt.change_basis(superket, basis, 'std')).flatten()
+                # RESHAPE NOTE: .ravel() added to line below (to convert pure *col* vec -> 1D) to fix unit tests
+                pure_vectors = {k: _ot.dmvec_to_state(_bt.change_basis(superket, basis, 'std')).ravel()
                                 for k, superket in superket_vectors.items()}
                 povm = create_from_pure_vectors(pure_vectors, typ, basis, evotype, state_space)
             else:
@@ -164,7 +164,7 @@ def create_effect_from_pure_vector(pure_vector, effect_type, basis='pp', evotype
                 superket = _bt.change_basis(_ot.state_to_dmvec(pure_vector), 'std', basis)
                 ef = create_effect_from_dmvec(superket, typ, basis, evotype, state_space)
             elif typ == 'static clifford':
-                ef = ComputationalBasisPOVMEffect.from_pure_vector(pure_vector.flatten())
+                ef = ComputationalBasisPOVMEffect.from_pure_vector(pure_vector.ravel())
             elif _ot.is_valid_lindblad_paramtype(typ):
                 from ..operations import LindbladErrorgen as _LindbladErrorgen, ExpErrorgenOp as _ExpErrorgenOp
                 from ..operations import IdentityPlusErrorgenOp as _IdentityPlusErrorgenOp

pygsti/modelmembers/povms/basepovm.py

@@ -21,7 +21,7 @@ from pygsti.modelmembers.povms.fulleffect import FullPOVMEffect as _FullPOVMEffe
 from pygsti.modelmembers.povms.povm import POVM as _POVM
 from pygsti.modelmembers import modelmember as _mm
 from pygsti.evotypes import Evotype as _Evotype
-from pygsti.baseobjs.statespace import StateSpace as _StateSpace
+from pygsti.baseobjs.statespace import StateSpace as _StateSpace, default_space_for_dim
 
 
 class _BasePOVM(_POVM):
@@ -67,7 +67,12 @@ class _BasePOVM(_POVM):
             self.complement_label = None
 
         if evotype is not None:
-            evotype = _Evotype.cast(evotype)  # e.g., resolve "default"
+            if state_space is None and isinstance(items[0][1], (_np.ndarray, list)):
+                evotype = _Evotype.cast(evotype, default_space_for_dim(len(items[0][1])))  # e.g., resolve "default"
+            elif state_space is not None:
+                evotype = _Evotype.cast(evotype, state_space)  # e.g., resolve "default"
+            else: #try to grab the state space from the first effect as a fall back.
+                evotype = _Evotype.cast(evotype, items[0][1].state_space)  # e.g., resolve "default"
 
         #Copy each effect vector and set it's parent and gpindices.
         # Assume each given effect vector's parameters are independent.
@@ -167,40 +172,6 @@ class _BasePOVM(_POVM):
                    for lbl, subm_serial_id in zip(mm_dict['effect_labels'], mm_dict['submembers'])}
         return cls(effects, mm_dict['evotype'], state_space)  # Note: __init__ call signature of derived classes
 
-    #def _reset_member_gpindices(self):
-    #    """
-    #    Sets gpindices for all non-complement items.  Assumes all non-complement
-    #    vectors have *independent* parameters (for now).
-    #    """
-    #    Np = 0
-    #    for k, effect in self.items():
-    #        if k == self.complement_label: continue
-    #        N = effect.num_params
-    #        pslc = slice(Np, Np + N)
-    #        if effect.gpindices != pslc:
-    #            effect.set_gpindices(pslc, self)
-    #        Np += N
-    #    self.Np = Np
-    #
-    #def _rebuild_complement(self, identity_for_complement=None):
-    #    """ Rebuild complement vector (in case other vectors have changed) """
-    #
-    #    if self.complement_label is not None and self.complement_label in self:
-    #        non_comp_effects = [v for k, v in self.items()
-    #                            if k != self.complement_label]
-    #
-    #        if identity_for_complement is None:
-    #            identity_for_complement = self[self.complement_label].identity
-    #
-    #        complement_effect = _ComplementPOVMEffect(
-    #            identity_for_complement, non_comp_effects)
-    #        complement_effect.set_gpindices(slice(0, self.Np), self)  # all parameters
-    #
-    #        #Assign new complement effect without calling our __setitem__
-    #        old_ro = self._readonly; self._readonly = False
-    #        _POVM.__setitem__(self, self.complement_label, complement_effect)
-    #        self._readonly = old_ro
-
     def __setitem__(self, key, value):
         if not self._readonly:  # when readonly == False, we're initializing
             return super(_BasePOVM, self).__setitem__(key, value)

pygsti/modelmembers/povms/complementeffect.py

@@ -135,16 +135,11 @@ class ComplementPOVMEffect(_ConjugatedStatePOVMEffect):
         return len(self.gpindices_as_array())
 
     def to_vector(self):
+        msg = """
+        ComplementPOVMEffect.to_vector() should never be called.
+        Use use TPPOVM.to_vector() instead.
         """
-        Get the POVM effect vector parameters as an array of values.
-
-        Returns
-        -------
-        numpy array
-            The parameters as a 1D array with length num_params().
-        """
-        raise ValueError(("ComplementPOVMEffect.to_vector() should never be called"
-                          " - use TPPOVM.to_vector() instead"))
+        raise RuntimeError(msg)
 
     def from_vector(self, v, close=False, dirty_value=True):
         """

pygsti/modelmembers/povms/composedeffect.py

@@ -42,328 +42,8 @@ class ComposedPOVMEffect(_POVMEffect):  # , _ErrorMapContainer
         parameters with other gates and spam vectors.)
     """
 
-    #@classmethod
-    #def _from_spamvec_obj(cls, spamvec, typ, param_type="GLND", purevec=None,
-    #                      proj_basis="pp", mx_basis="pp", truncate=True,
-    #                      lazy=False):
-    #    """
-    #    Creates a LindbladSPAMVec from an existing SPAMVec object and some additional information.
-    #
-    #    This function is different from `from_spam_vector` in that it assumes
-    #    that `spamvec` is a :class:`SPAMVec`-derived object, and if `lazy=True`
-    #    and if `spamvec` is already a matching LindbladSPAMVec, it
-    #    is returned directly.  This routine is primarily used in spam vector
-    #    conversion functions, where conversion is desired only when necessary.
-    #
-    #    Parameters
-    #    ----------
-    #    spamvec : SPAMVec
-    #        The spam vector object to "convert" to a
-    #        `LindbladSPAMVec`.
-    #
-    #    typ : {"prep","effect"}
-    #        Whether this is a state preparation or POVM effect vector.
-    #
-    #    param_type : str, optional
-    #        The high-level "parameter type" of the gate to create.  This
-    #        specifies both which Lindblad parameters are included and what
-    #        type of evolution is used.  Examples of valid values are
-    #        `"CPTP"`, `"H+S"`, `"S terms"`, and `"GLND clifford terms"`.
-    #
-    #    purevec : numpy array or SPAMVec object, optional
-    #        A SPAM vector which represents a pure-state, taken as the "ideal"
-    #        reference state when constructing the error generator of the
-    #        returned `LindbladSPAMVec`.  Note that this vector
-    #        still acts on density matrices (if it's a SPAMVec it should have
-    #        a "densitymx", "svterm", or "cterm" evolution type, and if it's
-    #        a numpy array it should have the same dimension as `spamvec`).
-    #        If None, then it is taken to be `spamvec`, and so `spamvec` must
-    #        represent a pure state in this case.
-    #
-    #    proj_basis : {'std', 'gm', 'pp', 'qt'}, list of matrices, or Basis object
-    #        The basis used to construct the Lindblad-term error generators onto
-    #        which the SPAM vector's error generator is projected.  Allowed values
-    #        are Matrix-unit (std), Gell-Mann (gm), Pauli-product (pp),
-    #        and Qutrit (qt), list of numpy arrays, or a custom basis object.
-    #
-    #    mx_basis : {'std', 'gm', 'pp', 'qt'} or Basis object
-    #        The source and destination basis, respectively.  Allowed
-    #        values are Matrix-unit (std), Gell-Mann (gm), Pauli-product (pp),
-    #        and Qutrit (qt) (or a custom basis object).
-    #
-    #    truncate : bool, optional
-    #        Whether to truncate the projections onto the Lindblad terms in
-    #        order to meet constraints (e.g. to preserve CPTP) when necessary.
-    #        If False, then an error is thrown when the given `spamvec` cannot
-    #        be realized by the specified set of Lindblad projections.
-    #
-    #    lazy : bool, optional
-    #        If True, then if `spamvec` is already a LindbladSPAMVec
-    #        with the requested details (given by the other arguments), then
-    #        `spamvec` is returned directly and no conversion/copying is
-    #        performed. If False, then a new object is always returned.
-    #
-    #    Returns
-    #    -------
-    #    LindbladSPAMVec
-    #    """
-    #
-    #    if not isinstance(spamvec, SPAMVec):
-    #        spamvec = StaticSPAMVec(spamvec, typ=typ)  # assume spamvec is just a vector
-    #
-    #    if purevec is None:
-    #        purevec = spamvec  # right now, we don't try to extract a "closest pure vec"
-    #        # to spamvec - below will fail if spamvec isn't pure.
-    #    elif not isinstance(purevec, SPAMVec):
-    #        purevec = StaticSPAMVec(purevec, typ=typ)  # assume spamvec is just a vector
-    #
-    #    #Break param_type in to a "base" type and an evotype
-    #    from .operation import LindbladOp as _LPGMap
-    #    bTyp, evotype, nonham_mode, param_mode = _LPGMap.decomp_paramtype(param_type)
-    #
-    #    ham_basis = proj_basis if (("H" == bTyp) or ("H+" in bTyp) or bTyp in ("CPTP", "GLND")) else None
-    #    nonham_basis = None if bTyp == "H" else proj_basis
-    #
-    #    def beq(b1, b2):
-    #        """ Check if bases have equal names """
-    #        b1 = b1.name if isinstance(b1, _Basis) else b1
-    #        b2 = b2.name if isinstance(b2, _Basis) else b2
-    #        return b1 == b2
-    #
-    #    def normeq(a, b):
-    #        if a is None and b is None: return True
-    #        if a is None or b is None: return False
-    #        return _mt.safe_norm(a - b) < 1e-6  # what about possibility of Clifford gates?
-    #
-    #    if isinstance(spamvec, LindbladSPAMVec) \
-    #       and spamvec._evotype == evotype and spamvec.typ == typ \
-    #       and beq(ham_basis, spamvec.error_map.ham_basis) and beq(nonham_basis, spamvec.error_map.other_basis) \
-    #       and param_mode == spamvec.error_map.param_mode and nonham_mode == spamvec.error_map.nonham_mode \
-    #       and beq(mx_basis, spamvec.error_map.matrix_basis) and lazy:
-    #        #normeq(gate.pure_state_vec,purevec) \ # TODO: more checks for equality?!
-    #        return spamvec  # no creation necessary!
-    #    else:
-    #        #Convert vectors (if possible) to SPAMVecs
-    #        # of the appropriate evotype and 0 params.
-    #        bDiff = spamvec is not purevec
-    #        spamvec = _convert_to_lindblad_base(spamvec, typ, evotype, mx_basis)
-    #        purevec = _convert_to_lindblad_base(purevec, typ, evotype, mx_basis) if bDiff else spamvec
-    #        assert(spamvec._evotype == evotype)
-    #        assert(purevec._evotype == evotype)
-    #
-    #        return cls.from_spam_vector(
-    #            spamvec, purevec, typ, ham_basis, nonham_basis,
-    #            param_mode, nonham_mode, truncate, mx_basis, evotype)
-    #
-    #@classmethod
-    #def from_spam_vector(cls, spam_vec, pure_vec, typ,
-    #                     ham_basis="pp", nonham_basis="pp", param_mode="cptp",
-    #                     nonham_mode="all", truncate=True, mx_basis="pp",
-    #                     evotype="densitymx"):
-    #    """
-    #    Creates a Lindblad-parameterized spamvec from a state vector and a basis.
-    #
-    #    The basis specifies how to decompose (project) the vector's error generator.
-    #
-    #    Parameters
-    #    ----------
-    #    spam_vec : SPAMVec
-    #        the SPAM vector to initialize from.  The error generator that
-    #        tranforms `pure_vec` into `spam_vec` forms the parameterization
-    #        of the returned LindbladSPAMVec.
-    #
-    #    pure_vec : numpy array or SPAMVec
-    #        An array or SPAMVec in the *full* density-matrix space (this
-    #        vector will have the same dimension as `spam_vec` - 4 in the case
-    #        of a single qubit) which represents a pure-state preparation or
-    #        projection.  This is used as the "base" preparation/projection
-    #        when computing the error generator that will be parameterized.
-    #        Note that this argument must be specified, as there is no natural
-    #        default value (like the identity in the case of gates).
-    #
-    #    typ : {"prep","effect"}
-    #        Whether this is a state preparation or POVM effect vector.
-    #
-    #    ham_basis: {'std', 'gm', 'pp', 'qt'}, list of matrices, or Basis object
-    #        The basis is used to construct the Hamiltonian-type lindblad error
-    #        Allowed values are Matrix-unit (std), Gell-Mann (gm), Pauli-product (pp),
-    #        and Qutrit (qt), list of numpy arrays, or a custom basis object.
-    #
-    #    nonham_basis: {'std', 'gm', 'pp', 'qt'}, list of matrices, or Basis object
-    #        The basis is used to construct the Stochastic-type lindblad error
-    #        Allowed values are Matrix-unit (std), Gell-Mann (gm), Pauli-product (pp),
-    #        and Qutrit (qt), list of numpy arrays, or a custom basis object.
-    #
-    #    param_mode : {"unconstrained", "cptp", "depol", "reldepol"}
-    #        Describes how the Lindblad coefficients/projections relate to the
-    #        SPAM vector's parameter values.  Allowed values are:
-    #        `"unconstrained"` (coeffs are independent unconstrained parameters),
-    #        `"cptp"` (independent parameters but constrained so map is CPTP),
-    #        `"reldepol"` (all non-Ham. diagonal coeffs take the *same* value),
-    #        `"depol"` (same as `"reldepol"` but coeffs must be *positive*)
-    #
-    #    nonham_mode : {"diagonal", "diag_affine", "all"}
-    #        Which non-Hamiltonian Lindblad projections are potentially non-zero.
-    #        Allowed values are: `"diagonal"` (only the diagonal Lind. coeffs.),
-    #        `"diag_affine"` (diagonal coefficients + affine projections), and
-    #        `"all"` (the entire matrix of coefficients is allowed).
-    #
-    #    truncate : bool, optional
-    #        Whether to truncate the projections onto the Lindblad terms in
-    #        order to meet constraints (e.g. to preserve CPTP) when necessary.
-    #        If False, then an error is thrown when the given `gate` cannot
-    #        be realized by the specified set of Lindblad projections.
-    #
-    #    mx_basis : {'std', 'gm', 'pp', 'qt'} or Basis object
-    #        The source and destination basis, respectively.  Allowed
-    #        values are Matrix-unit (std), Gell-Mann (gm), Pauli-product (pp),
-    #        and Qutrit (qt) (or a custom basis object).
-    #
-    #    evotype : {"densitymx","svterm","cterm"}
-    #        The evolution type of the spamvec being constructed.  `"densitymx"` is
-    #        usual Lioville density-matrix-vector propagation via matrix-vector
-    #        products.  `"svterm"` denotes state-vector term-based evolution
-    #        (spamvec is obtained by evaluating the rank-1 terms up to
-    #        some order).  `"cterm"` is similar but stabilizer states.
-    #
-    #    Returns
-    #    -------
-    #    LindbladSPAMVec
-    #    """
-    #    #Compute a (errgen, pure_vec) pair from the given
-    #    # (spam_vec, pure_vec) pair.
-    #
-    #    assert(pure_vec is not None), "Must supply `pure_vec`!"  # since there's no good default?
-    #
-    #    if not isinstance(spam_vec, SPAMVec):
-    #        spam_vec = StaticSPAMVec(spam_vec, evotype, typ)  # assume spamvec is just a vector
-    #    if not isinstance(pure_vec, SPAMVec):
-    #        pure_vec = StaticSPAMVec(pure_vec, evotype, typ)  # assume spamvec is just a vector
-    #    d2 = pure_vec.dim
-    #
-    #    #Determine whether we're using sparse bases or not
-    #    sparse = None
-    #    if ham_basis is not None:
-    #        if isinstance(ham_basis, _Basis): sparse = ham_basis.sparse
-    #        elif not isinstance(ham_basis, str) and len(ham_basis) > 0:
-    #            sparse = _sps.issparse(ham_basis[0])
-    #    if sparse is None and nonham_basis is not None:
-    #        if isinstance(nonham_basis, _Basis): sparse = nonham_basis.sparse
-    #        elif not isinstance(nonham_basis, str) and len(nonham_basis) > 0:
-    #            sparse = _sps.issparse(nonham_basis[0])
-    #    if sparse is None: sparse = False  # the default
-    #
-    #    if spam_vec is None or spam_vec is pure_vec:
-    #        if sparse: errgen = _sps.csr_matrix((d2, d2), dtype='d')
-    #        else: errgen = _np.zeros((d2, d2), 'd')
-    #    else:
-    #        #Construct "spam error generator" by comparing *dense* vectors
-    #        pvdense = pure_vec.to_dense()
-    #        svdense = spam_vec.to_dense()
-    #        errgen = _ot.spam_error_generator(svdense, pvdense, mx_basis)
-    #        if sparse: errgen = _sps.csr_matrix(errgen)
-    #
-    #    assert(pure_vec._evotype == evotype), "`pure_vec` must have evotype == '%s'" % evotype
-    #
-    #    from .operation import LindbladErrorgen as _LErrorgen
-    #    from .operation import LindbladOp as _LPGMap
-    #    from .operation import LindbladDenseOp as _LPOp
-    #
-    #    errgen = _LErrorgen.from_error_generator(errgen, ham_basis,
-    #                                             nonham_basis, param_mode, nonham_mode,
-    #                                             mx_basis, truncate, evotype)
-    #    errcls = _LPOp if (pure_vec.dim <= 64 and evotype == "densitymx") else _LPGMap
-    #    errmap = errcls(None, errgen)
-    #
-    #    return cls(pure_vec, errmap, typ)
-
-    #@classmethod
-    #def from_lindblad_terms(cls, pure_vec, lindblad_term_dict, typ, basisdict=None,
-    #                        param_mode="cptp", nonham_mode="all", truncate=True,
-    #                        mx_basis="pp", evotype="densitymx"):
-    #    """
-    #    Create a Lindblad-parameterized spamvec with a given set of Lindblad terms.
-    #
-    #    Parameters
-    #    ----------
-    #    pure_vec : numpy array or SPAMVec
-    #        An array or SPAMVec in the *full* density-matrix space (this
-    #        vector will have dimension 4 in the case of a single qubit) which
-    #        represents a pure-state preparation or projection.  This is used as
-    #        the "base" preparation or projection that is followed or preceded
-    #        by, respectively, the parameterized Lindblad-form error generator.
-    #
-    #    lindblad_term_dict : dict
-    #        A dictionary specifying which Linblad terms are present in the gate
-    #        parameteriztion.  Keys are `(termType, basisLabel1, <basisLabel2>)`
-    #        tuples, where `termType` can be `"H"` (Hamiltonian), `"S"`
-    #        (Stochastic), or `"A"` (Affine).  Hamiltonian and Affine terms always
-    #        have a single basis label (so key is a 2-tuple) whereas Stochastic
-    #        tuples with 1 basis label indicate a *diagonal* term, and are the
-    #        only types of terms allowed when `nonham_mode != "all"`.  Otherwise,
-    #        Stochastic term tuples can include 2 basis labels to specify
-    #        "off-diagonal" non-Hamiltonian Lindblad terms.  Basis labels can be
-    #        strings or integers.  Values are complex coefficients (error rates).
-    #
-    #    typ : {"prep","effect"}
-    #        Whether this is a state preparation or POVM effect vector.
-    #
-    #    basisdict : dict, optional
-    #        A dictionary mapping the basis labels (strings or ints) used in the
-    #        keys of `lindblad_term_dict` to basis matrices (numpy arrays or Scipy sparse
-    #        matrices).
-    #
-    #    param_mode : {"unconstrained", "cptp", "depol", "reldepol"}
-    #        Describes how the Lindblad coefficients/projections relate to the
-    #        SPAM vector's parameter values.  Allowed values are:
-    #        `"unconstrained"` (coeffs are independent unconstrained parameters),
-    #        `"cptp"` (independent parameters but constrained so map is CPTP),
-    #        `"reldepol"` (all non-Ham. diagonal coeffs take the *same* value),
-    #        `"depol"` (same as `"reldepol"` but coeffs must be *positive*)
-    #
-    #    nonham_mode : {"diagonal", "diag_affine", "all"}
-    #        Which non-Hamiltonian Lindblad projections are potentially non-zero.
-    #        Allowed values are: `"diagonal"` (only the diagonal Lind. coeffs.),
-    #        `"diag_affine"` (diagonal coefficients + affine projections), and
-    #        `"all"` (the entire matrix of coefficients is allowed).
-    #
-    #    truncate : bool, optional
-    #        Whether to truncate the projections onto the Lindblad terms in
-    #        order to meet constraints (e.g. to preserve CPTP) when necessary.
-    #        If False, then an error is thrown when the given dictionary of
-    #        Lindblad terms doesn't conform to the constrains.
-    #
-    #    mx_basis : {'std', 'gm', 'pp', 'qt'} or Basis object
-    #        The source and destination basis, respectively.  Allowed
-    #        values are Matrix-unit (std), Gell-Mann (gm), Pauli-product (pp),
-    #        and Qutrit (qt) (or a custom basis object).
-    #
-    #    evotype : {"densitymx","svterm","cterm"}
-    #        The evolution type of the spamvec being constructed.  `"densitymx"` is
-    #        usual Lioville density-matrix-vector propagation via matrix-vector
-    #        products.  `"svterm"` denotes state-vector term-based evolution
-    #        (spamvec is obtained by evaluating the rank-1 terms up to
-    #        some order).  `"cterm"` is similar but stabilizer states.
-    #
-    #    Returns
-    #    -------
-    #    LindbladOp
-    #    """
-    #    #Need a dimension for error map construction (basisdict could be completely empty)
-    #    if not isinstance(pure_vec, SPAMVec):
-    #        pure_vec = StaticSPAMVec(pure_vec, evotype, typ)  # assume spamvec is just a vector
-    #    d2 = pure_vec.dim
-    #
-    #    from .operation import LindbladOp as _LPGMap
-    #    errmap = _LPGMap(d2, lindblad_term_dict, basisdict, param_mode, nonham_mode,
-    #                     truncate, mx_basis, evotype)
-    #    return cls(pure_vec, errmap, typ)
-
     def __init__(self, static_effect, errormap):
         evotype = errormap._evotype
-        #from .operation import LindbladOp as _LPGMap
-        #assert(evotype in ("densitymx", "svterm", "cterm")), \
-        #    "Invalid evotype: %s for %s" % (evotype, self.__class__.__name__)
 
         if not isinstance(static_effect, _POVMEffect):
             # UNSPECIFIED BASIS -- should be able to use static_effect._rep.basis once we get std attribute setup

pygsti/modelmembers/povms/computationaleffect.py

@@ -151,7 +151,7 @@ class ComputationalBasisPOVMEffect(_POVMEffect):
         # or maybe remove and use self._rep.basis if that's the std attribute
         self._basis = basis
 
-        evotype = _Evotype.cast(evotype)
+        evotype = _Evotype.cast(evotype, state_space=state_space)
         self._evotype = evotype  # set this before call to _State.__init__ so self.to_dense() can work...
         rep = evotype.create_computational_effect_rep(zvals, basis, state_space)
         _POVMEffect.__init__(self, rep, evotype)

pygsti/modelmembers/povms/computationalpovm.py

@@ -72,11 +72,13 @@ class ComputationalBasisPOVM(_POVM, _NoErrorGeneratorInterface):
         #LATER - do something with qubit_filter here
         # qubits = self.qubit_filter if (self.qubit_filter is not None) else list(range(self.nqubits))
 
-        evotype = _Evotype.cast(evotype)
         items = []  # init as empty (lazy creation of members)
         if state_space is None:
             state_space = _statespace.QubitSpace(nqubits)
         assert(state_space.num_qubits == nqubits), "`state_space` must describe %d qubits!" % nqubits
+        
+        evotype = _Evotype.cast(evotype, state_space=state_space)
+
         try:
             rep = evotype.create_computational_povm_rep(self.nqubits, self.qubit_filter)
         except AttributeError:

pygsti/modelmembers/povms/effect.py

@@ -170,11 +170,9 @@ class POVMEffect(_modelmember.ModelMember):
         float
         """
         vec = self.to_dense()
-        if transform is None:
-            return _ot.residuals(vec, other_spam_vec.to_dense())
-        else:
-            return _ot.residuals(_np.dot(_np.transpose(transform),
-                                         vec), other_spam_vec.to_dense())
+        if transform is not None:
+            vec = transform.T @ vec
+        return (vec - other_spam_vec.to_dense()).ravel()
 
     def transform_inplace(self, s):
         """