pyGSTi 0.9.12__cp39-cp39-win32.whl → 0.9.13__cp39-cp39-win32.whl

pygsti/modelmembers/povms/marginalizedpovm.py

@@ -14,6 +14,7 @@ import collections as _collections
 
 # from .. import modelmember as _mm
 from pygsti.modelmembers.povms.povm import POVM as _POVM
+from pygsti.modelmembers.povms import ComposedPOVMEffect as _ComposedPOVMEffect
 from pygsti.modelmembers.povms.staticeffect import StaticPOVMEffect as _StaticPOVMEffect
 from pygsti.baseobjs.statespace import StateSpace as _StateSpace
 from pygsti.baseobjs.label import Label as _Label
@@ -193,8 +194,8 @@ class MarginalizedPOVM(_POVM):
                     effect_vec = e.to_dense()
                 else:
                     effect_vec += e.to_dense()
-            effect = _StaticPOVMEffect(effect_vec, e._basis, self._evotype)
-            # UNSPECIFIED BASIS -- may need to rename e._basis -> e._rep.basis above if that's the std attribute name?
+            rep = e.effect_vec._rep if isinstance(e, _ComposedPOVMEffect) else e._rep
+            effect = _StaticPOVMEffect(effect_vec, rep.basis, self._evotype)
             assert(effect.allocate_gpindices(0, self.parent) == 0)  # functional! (do not remove)
             _collections.OrderedDict.__setitem__(self, key, effect)
             return effect
@@ -206,85 +207,6 @@ class MarginalizedPOVM(_POVM):
                                    self.sslbls_after_marginalizing),
                 {'_gpindices': self._gpindices})  # preserve gpindices (but not parent)
 
-    #May need to implement this in future if we allow non-static MarginalizedPOVMs
-    #def allocate_gpindices(self, starting_index, parent, memo=None):
-    #    """
-    #    Sets gpindices array for this object or any objects it
-    #    contains (i.e. depends upon).  Indices may be obtained
-    #    from contained objects which have already been initialized
-    #    (e.g. if a contained object is shared with other
-    #     top-level objects), or given new indices starting with
-    #    `starting_index`.
-    #
-    #    Parameters
-    #    ----------
-    #    starting_index : int
-    #        The starting index for un-allocated parameters.
-    #
-    #    parent : Model or ModelMember
-    #        The parent whose parameter array gpindices references.
-    #
-    #    memo : set, optional
-    #        Used to prevent duplicate calls and self-referencing loops.  If
-    #        `memo` contains an object's id (`id(self)`) then this routine
-    #        will exit immediately.
-    #
-    #    Returns
-    #    -------
-    #    num_new: int
-    #        The number of *new* allocated parameters (so
-    #        the parent should mark as allocated parameter
-    #        indices `starting_index` to `starting_index + new_new`).
-    #    """
-    #    if memo is None: memo = set()
-    #    if id(self) in memo: return 0
-    #    memo.add(id(self))
-    #
-    #    assert(self.base_povm.num_params == 0)  # so no need to do anything w/base_povm
-    #    num_new_params = self.error_map.allocate_gpindices(starting_index, parent, memo)  # *same* parent as self
-    #    _mm.ModelMember.set_gpindices(
-    #        self, self.error_map.gpindices, parent)
-    #    return num_new_params
-
-    #def relink_parent(self, parent):  # Unnecessary?
-    #    """
-    #    Sets the parent of this object *without* altering its gpindices.
-    #
-    #    In addition to setting the parent of this object, this method
-    #    sets the parent of any objects this object contains (i.e.
-    #    depends upon) - much like allocate_gpindices.  To ensure a valid
-    #    parent is not overwritten, the existing parent *must be None*
-    #    prior to this call.
-    #    """
-    #    self.povm_to_marginalize.relink_parent(parent)
-    #    _mm.ModelMember.relink_parent(self, parent)
-
-    #def set_gpindices(self, gpindices, parent, memo=None):
-    #    """
-    #    Set the parent and indices into the parent's parameter vector that
-    #    are used by this ModelMember object.
-    #
-    #    Parameters
-    #    ----------
-    #    gpindices : slice or integer ndarray
-    #        The indices of this objects parameters in its parent's array.
-    #
-    #    parent : Model or ModelMember
-    #        The parent whose parameter array gpindices references.
-    #
-    #    Returns
-    #    -------
-    #    None
-    #    """
-    #    if memo is None: memo = set()
-    #    elif id(self) in memo: return
-    #    memo.add(id(self))
-    #
-    #    assert(self.base_povm.num_params == 0)  # so no need to do anything w/base_povm
-    #    self.error_map.set_gpindices(gpindices, parent, memo)
-    #    self.terms = {}  # clear terms cache since param indices have changed now
-    #    _mm.ModelMember._set_only_my_gpindices(self, gpindices, parent)
-
     def simplify_effects(self, prefix=""):
         """
         Creates a dictionary of simplified effect vectors.

pygsti/modelmembers/povms/tppovm.py

@@ -10,11 +10,23 @@ Defines the TPPOVM class
 # 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
+try:
+    import torch as _torch
+except ImportError:
+    pass
+
+import numpy as _np
+from pygsti.modelmembers.torchable import Torchable as _Torchable
 from pygsti.modelmembers.povms.basepovm import _BasePOVM
-from pygsti.modelmembers.povms.effect import POVMEffect as _POVMEffect
+from pygsti.modelmembers.povms.fulleffect import FullPOVMEffect as _FullPOVMEffect
+import warnings
 
 
-class TPPOVM(_BasePOVM):
+class TPPOVM(_BasePOVM, _Torchable):
     """
     A POVM whose sum-of-effects is constrained to what, by definition, we call the "identity".
 
@@ -37,6 +49,23 @@ class TPPOVM(_BasePOVM):
         The state space for this POVM.  If `None`, the space is inferred
         from the first effect vector.  If `len(effects) == 0` in this case,
         an error is raised.
+
+    Notes
+    -----
+    Just like TPState, we're restricted to the Pauli-product or Gell-Mann basis.
+    
+    We inherit from BasePOVM, which inherits from POVM, which inherits from OrderedDict.
+
+    A TPPOVM "p" has an attribute p.complement_label that's set during construction.
+    This label is such that e = p[p.complement_label] is a ComplementPOVMEffect, with
+    an associated FullState object given in e.identity. If v = e.identity.to_vector(),
+    then e's vector representation is
+    
+            v - sum(all non-complement effects in p).
+    
+    Under typical conditions v will be proportional to the first standard basis vector,
+    and, in fact, if v is length "d," then we'll have v[0] == d ** 0.25. However, 
+    neither of these conditions is strictly required by the API.
     """
 
     def __init__(self, effects, evotype=None, state_space=None, called_from_reduce=False):
@@ -56,3 +85,46 @@ class TPPOVM(_BasePOVM):
 
         return (TPPOVM, (effects, self.evotype, self.state_space, True),
                 {'_gpindices': self._gpindices, '_submember_rpindices': self._submember_rpindices})
+    
+    @property
+    def dim(self):
+        effect = next(iter(self.values()))
+        return effect.dim
+    
+    def to_vector(self):
+        effect_vecs = []
+        for i, (lbl, effect) in enumerate(self.items()):
+            if lbl != self.complement_label:
+                assert isinstance(effect, _FullPOVMEffect)
+                effect_vecs.append(effect.to_vector())
+            else:
+                assert i == len(self) - 1
+        vec = _np.concatenate(effect_vecs)
+        return vec
+
+    def stateless_data(self) -> Tuple[int, _np.ndarray]:
+        num_effects = len(self)
+        complement_effect = self[self.complement_label]
+        identity = complement_effect.identity.to_vector()
+        return (num_effects, identity)
+
+    @staticmethod
+    def torch_base(sd: Tuple[int, _np.ndarray], t_param: _torch.Tensor) -> _torch.Tensor:
+        num_effects, identity = sd
+        dim = identity.size
+
+        first_basis_vec = _np.zeros(dim)
+        first_basis_vec[0] = dim ** 0.25
+        TOL = 1e-15 * _np.sqrt(dim)
+        if _np.linalg.norm(first_basis_vec - identity) > TOL:
+            # Don't error out. The documentation for the class
+            # clearly indicates that the meaning of "identity"
+            # can be nonstandard.
+            warnings.warn('Unexpected normalization!') 
+
+        identity = identity.reshape((1, -1)) # make into a row vector
+        t_identity = _torch.from_numpy(identity)
+        t_param_mat = t_param.reshape((num_effects - 1, dim))
+        t_func = t_identity - t_param_mat.sum(axis=0, keepdim=True)
+        t = _torch.row_stack((t_param_mat, t_func))
+        return t

pygsti/modelmembers/states/__init__.py

@@ -15,8 +15,6 @@ import scipy.linalg as _spl
 import scipy.optimize as _spo
 import warnings as _warnings
 
-from numpy.lib.arraysetops import isin
-
 from pygsti.modelmembers.povms.computationalpovm import ComputationalBasisPOVM
 
 from .composedstate import ComposedState
@@ -426,17 +424,16 @@ def optimize_state(vec_to_optimize, target_vec):
         return
 
     from pygsti import optimize as _opt
-    from pygsti.tools import matrixtools as _mt
     assert(target_vec.dim == vec_to_optimize.dim)  # vectors must have the same overall dimension
     targetVector = target_vec.to_dense() if isinstance(target_vec, State) else target_vec
 
     def _objective_func(param_vec):
         vec_to_optimize.from_vector(param_vec)
-        return _mt.frobeniusnorm(vec_to_optimize.to_dense() - targetVector)
+        return _np.linalg.norm(vec_to_optimize.to_dense() - targetVector)
 
     x0 = vec_to_optimize.to_vector()
     minSol = _opt.minimize(_objective_func, x0, method='BFGS', maxiter=10000, maxfev=10000,
                            tol=1e-6, callback=None)
 
     vec_to_optimize.from_vector(minSol.x)
-    #print("DEBUG: optimized vector to min frobenius distance %g" % _mt.frobeniusnorm(vec_to_optimize-targetVector))
+    return

pygsti/modelmembers/states/composedstate.py

@@ -43,323 +43,6 @@ class ComposedState(_State):  # , _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_state, errormap):
         evotype = errormap._evotype
         #from .operation import LindbladOp as _LPGMap

pygsti/modelmembers/states/computationalstate.py

@@ -88,7 +88,7 @@ class ComputationalBasisState(_State, _NoErrorGeneratorInterface):
 
         for zvals in _itertools.product(*([(0, 1)] * nqubits)):
             testvec = _functools.reduce(_np.kron, [v[i] for i in zvals])
-            if _np.allclose(testvec, vec.flatten()):
+            if _np.allclose(testvec, vec.ravel()):
                 return cls(zvals, basis, evotype, state_space)
         raise ValueError(("Given `vec` is not a z-basis product state - "
                           "cannot construct ComputationalBasisState"))
@@ -128,7 +128,7 @@ class ComputationalBasisState(_State, _NoErrorGeneratorInterface):
         v = (_np.array([1, 0], 'd'), _np.array([0, 1], 'd'))  # (v0,v1)
         for zvals in _itertools.product(*([(0, 1)] * nqubits)):
             testvec = _functools.reduce(_np.kron, [v[i] for i in zvals])
-            if _np.allclose(testvec, purevec.flatten()):
+            if _np.allclose(testvec, purevec.ravel()):
                 return cls(zvals, basis, evotype, state_space)
         raise ValueError(("Given `purevec` must be a z-basis product state - "
                           "cannot construct ComputationalBasisState"))
@@ -140,7 +140,7 @@ class ComputationalBasisState(_State, _NoErrorGeneratorInterface):
             else _statespace.StateSpace.cast(state_space)
         basis = _Basis.cast(basis, state_space)  # basis for Hilbert-Schmidt (superop) space
 
-        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_state_rep(self._zvals, basis, state_space)
         _State.__init__(self, rep, evotype)

pygsti/modelmembers/states/cptpstate.py

@@ -84,7 +84,7 @@ class CPTPState(_DenseState):
         state_space = _statespace.default_space_for_dim(len(vector)) if (state_space is None) \
             else _statespace.StateSpace.cast(state_space)
 
-        evotype = _Evotype.cast(evotype)
+        evotype = _Evotype.cast(evotype, state_space=state_space)
         _DenseState.__init__(self, vector, basis, evotype, state_space)
         self._paramlbls = _np.array(labels, dtype=object)
 
@@ -150,7 +150,7 @@ class CPTPState(_DenseState):
             Lmx = _np.linalg.cholesky(density_mx)
 
         #check TP condition: that diagonal els of Lmx squared add to 1.0
-        Lmx_norm = _np.trace(_np.dot(Lmx.T.conjugate(), Lmx))  # sum of magnitude^2 of all els
+        Lmx_norm = _np.linalg.norm(Lmx)  # = sqrt(tr(Lmx' Lmx))
         assert(_np.isclose(Lmx_norm, 1.0)), \
             "Cholesky decomp didn't preserve trace=1!"
 
@@ -180,7 +180,7 @@ class CPTPState(_DenseState):
             for j in range(i):
                 self.Lmx[i, j] = (self.params[i * dmDim + j] + 1j * self.params[j * dmDim + i]) / paramNorm
 
-        Lmx_norm = _np.trace(_np.dot(self.Lmx.T.conjugate(), self.Lmx))  # sum of magnitude^2 of all els
+        Lmx_norm = _np.linalg.norm(self.Lmx)  # = sqrt(tr(Lmx' Lmx))
         assert(_np.isclose(Lmx_norm, 1.0)), "Violated trace=1 condition!"
 
         #The (complex, Hermitian) density matrix is build by
@@ -192,7 +192,7 @@ class CPTPState(_DenseState):
         # write density matrix in given basis: = sum_i alpha_i B_i
         # ASSUME that basis is orthogonal, i.e. Tr(Bi^dag*Bj) = delta_ij
         basis_mxs = _np.rollaxis(self.basis_mxs, 2)  # shape (dmDim, dmDim, len(vec))
-        vec = _np.array([_np.trace(_np.dot(M.T.conjugate(), density_mx)) for M in basis_mxs])
+        vec = _np.array([_np.vdot(M, density_mx) for M in basis_mxs])
 
         #for now, assume Liouville vector should always be real (TODO: add 'real' flag later?)
         assert(_np.linalg.norm(_np.imag(vec)) < IMAG_TOL)

pygsti/modelmembers/states/densestate.py

@@ -166,9 +166,11 @@ class DenseState(DenseStateInterface, _State):
 
     def __init__(self, vec, basis, evotype, state_space):
         vec = _State._to_vector(vec)
-        state_space = _statespace.default_space_for_dim(vec.shape[0]) if (state_space is None) \
-            else _statespace.StateSpace.cast(state_space)
-        evotype = _Evotype.cast(evotype)
+        if state_space is None:
+            state_space = _statespace.default_space_for_dim(vec.shape[0])
+        else:
+            state_space = _statespace.StateSpace.cast(state_space)
+        evotype = _Evotype.cast(evotype, state_space=state_space)
         self._basis = _Basis.cast(basis, state_space.dim)
         rep = evotype.create_dense_state_rep(vec, self._basis, state_space)
 
@@ -263,15 +265,16 @@ class DensePureState(DenseStateInterface, _State):
         purevec = purevec.astype(complex)
         state_space = _statespace.default_space_for_udim(purevec.shape[0]) if (state_space is None) \
             else _statespace.StateSpace.cast(state_space)
-        evotype = _Evotype.cast(evotype)
+        evotype = _Evotype.cast(evotype, state_space=state_space)
         basis = _Basis.cast(basis, state_space.dim)  # basis for Hilbert-Schmidt (superop) space
-
-        #Try to create a dense pure rep.  If this fails, see if a dense superkey rep
+        
+        #Try to create a dense pure rep.  If this fails, see if a dense superket rep
         # can be created, as this type of rep can also hold arbitrary pure states.
         try:
             rep = evotype.create_pure_state_rep(purevec, basis, state_space)
             self._reptype = 'pure'
-            self._purevec = self._basis = None
+            self._purevec = None
+            self._basis = basis #this was previously being set as None, not sure why.
         except Exception:
             if len(purevec) == basis.dim and _np.linalg.norm(purevec.imag) < 1e-10:
                 # Special case when a *superket* was provided instead of a purevec
@@ -350,7 +353,6 @@ class DensePureState(DenseStateInterface, _State):
 
         mm_dict['dense_state_vector'] = self._encodemx(self.to_dense('Hilbert'))
         mm_dict['basis'] = self._basis.to_nice_serialization() if (self._basis is not None) else None
-
         return mm_dict
 
     @classmethod