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

pygsti/layouts/termlayout.py

@@ -57,7 +57,7 @@ class _TermCOPALayoutAtom(_DistributableAtom):
         expanded_circuit_outcomes = _collections.OrderedDict()
         for i in group:
             observed_outcomes = None if (dataset is None) else dataset[ds_circuits[i]].outcomes
-            d = unique_complete_circuits[i].expand_instruments_and_separate_povm(model, observed_outcomes)
+            d = model.expand_instruments_and_separate_povm(unique_complete_circuits[i], observed_outcomes)
             expanded_circuit_outcomes_by_unique[i] = d
             expanded_circuit_outcomes.update(d)
 

pygsti/modelmembers/instruments/instrument.py

@@ -71,7 +71,7 @@ class Instrument(_mm.ModelMember, _collections.OrderedDict):
                 if state_space is None:
                     state_space = _statespace.default_space_for_dim(member_list[0][1].shape[0])
                 if evotype is None:
-                    evotype = _Evotype.cast('default')
+                    evotype = _Evotype.cast('default', state_space=state_space)
                 member_list = [(k, v if isinstance(v, _op.LinearOperator) else
                                 _op.FullArbitraryOp(v, None, evotype, state_space)) for k, v in member_list]
 
@@ -79,10 +79,10 @@ class Instrument(_mm.ModelMember, _collections.OrderedDict):
                 "Must specify `state_space` when there are no instrument members!"
             assert(len(member_list) > 0 or evotype is not None), \
                 "Must specify `evotype` when there are no instrument members!"
-            evotype = _Evotype.cast(evotype) if (evotype is not None) else member_list[0][1].evotype
             state_space = member_list[0][1].state_space if (state_space is None) \
                 else _statespace.StateSpace.cast(state_space)
-
+            evotype = _Evotype.cast(evotype, state_space=state_space) if (evotype is not None)\
+                else member_list[0][1].evotype
             items = []
             for k, member in member_list:
                 assert(evotype == member.evotype), \

pygsti/modelmembers/instruments/tpinstrument.py

@@ -77,8 +77,6 @@ class TPInstrument(_mm.ModelMember, _collections.OrderedDict):
         self._readonly = False  # until init is done
         if len(items) > 0:
             assert(op_matrices is None), "`items` was given when op_matrices != None"
-
-        evotype = _Evotype.cast(evotype)
         self.param_ops = []  # first element is TP sum (MT), following
         #elements are fully-param'd (Mi-Mt) for i=0...n-2
 
@@ -98,6 +96,7 @@ class TPInstrument(_mm.ModelMember, _collections.OrderedDict):
                 "Must specify `state_space` when there are no instrument members!"
             state_space = _statespace.default_space_for_dim(matrix_list[0][1].shape[0]) if (state_space is None) \
                 else _statespace.StateSpace.cast(state_space)
+            evotype = _Evotype.cast(evotype, state_space=state_space)
 
             # Create gate objects that are used to parameterize this instrument
             MT_mx = sum([v for k, v in matrix_list])  # sum-of-instrument-members matrix
@@ -125,6 +124,7 @@ class TPInstrument(_mm.ModelMember, _collections.OrderedDict):
             #    print(k,":\n",v)
         else:
             assert(state_space is not None), "`state_space` cannot be `None` when there are no members!"
+            evotype = _Evotype.cast(evotype, state_space=state_space)
 
         _collections.OrderedDict.__init__(self, items)
         _mm.ModelMember.__init__(self, state_space, evotype)

pygsti/modelmembers/modelmember.py

@@ -340,23 +340,6 @@ class ModelMember(ModelChild, _NicelySerializable):
         if (self.parent is not None) and (force or self.parent._obj_refcount(self) == 0):
             self._parent = None
 
-    # UNUSED - as this doesn't mark parameter for reallocation like it used to
-    #def clear_gpindices(self):
-    #    """
-    #    Sets gpindices to None, along with any submembers' gpindices.
-    #
-    #    This essentially marks these members for parameter re-allocation
-    #    (e.g. if the number - not just the value - of parameters they have
-    #    changes).
-    #
-    #    Returns
-    #    -------
-    #    None
-    #    """
-    #    for subm in self.submembers():
-    #        subm.clear_gpindices()
-    #    self._gpindices = None
-
     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.

pygsti/modelmembers/operations/__init__.py

@@ -38,6 +38,7 @@ from .staticstdop import StaticStandardOp
 from .staticunitaryop import StaticUnitaryOp
 from .stochasticop import StochasticNoiseOp
 from .lindbladcoefficients import LindbladCoefficientBlock as _LindbladCoefficientBlock
+from .affineshiftop import AffineShiftOp
 from pygsti.baseobjs import statespace as _statespace
 from pygsti.tools import basistools as _bt
 from pygsti.tools import optools as _ot
@@ -474,18 +475,16 @@ def optimize_operation(op_to_optimize, target_op):
         return
 
     from pygsti import optimize as _opt
-    from pygsti.tools import matrixtools as _mt
     assert(target_op.dim == op_to_optimize.dim)  # operations must have the same overall dimension
     targetMatrix = target_op.to_dense() if isinstance(target_op, LinearOperator) else target_op
 
     def _objective_func(param_vec):
         op_to_optimize.from_vector(param_vec)
-        return _mt.frobeniusnorm(op_to_optimize.to_dense() - targetMatrix)
+        return _np.linalg.norm(op_to_optimize.to_dense() - targetMatrix)
 
     x0 = op_to_optimize.to_vector()
     minSol = _opt.minimize(_objective_func, x0, method='BFGS', maxiter=10000, maxfev=10000,
                            tol=1e-6, callback=None)
 
     op_to_optimize.from_vector(minSol.x)
-    #print("DEBUG: optimized operation to min frobenius distance %g" %
-    #      _mt.frobeniusnorm(op_to_optimize-targetMatrix))
+    return

pygsti/modelmembers/operations/affineshiftop.py

@@ -0,0 +1,206 @@
+"""
+The AffineShiftOp class and supporting functionality.
+"""
+#***************************************************************************************************
+# Copyright 2015, 2019 National Technology & Engineering Solutions of Sandia, LLC (NTESS).
+# Under the terms of Contract DE-NA0003525 with NTESS, the U.S. Government retains certain rights
+# in this software.
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
+# in compliance with the License.  You may obtain a copy of the License at
+# http://www.apache.org/licenses/LICENSE-2.0 or in the LICENSE file in the root pyGSTi directory.
+#***************************************************************************************************
+
+import numpy as _np
+
+from pygsti.modelmembers.operations.denseop import DenseOperator as _DenseOperator
+from pygsti.modelmembers.operations.linearop import LinearOperator as _LinearOperator
+from pygsti.baseobjs.protectedarray import ProtectedArray as _ProtectedArray
+
+
+class AffineShiftOp(_DenseOperator):
+    """
+    An operation matrix that induces an affine shift.
+
+    An operation matrix with ones on the diagonal and nonzero values in
+    the first columns.
+
+    Meant to work in the Pauli basis for now.
+
+    Parameters
+    ----------
+    m : array_like or LinearOperator
+        a square 2D array-like or LinearOperator object representing the operation action.
+        The shape of m sets the dimension of the operation.
+
+    basis : Basis or {'pp','gm','std'} or None
+        The basis used to construct the Hilbert-Schmidt space representation
+        of this state as a super-operator.  If None, certain functionality,
+        such as access to Kraus operators, will be unavailable.
+
+    evotype : Evotype or str, optional
+        The evolution type.  The special value `"default"` is equivalent
+        to specifying the value of `pygsti.evotypes.Evotype.default_evotype`.
+
+    state_space : StateSpace, optional
+        The state space for this operation.  If `None` a default state space
+        with the appropriate number of qubits is used.
+
+    Attributes
+    ----------
+    base : numpy.ndarray
+        Direct access to the underlying process matrix data.
+    """
+
+    def __init__(self, m, basis=None, evotype="default", state_space=None):
+        #LinearOperator.__init__(self, LinearOperator.convert_to_matrix(m))
+        mx = _LinearOperator.convert_to_matrix(m)
+        assert(_np.isrealobj(mx)), "FullTPOp must have *real* values!"
+        
+        #this line checks whether the input matrix has the correct
+        #arrowhead structure.
+        if not (_np.allclose(_np.diag(mx), 1) and  _np.allclose((mx-_np.eye(mx.shape[0]))[:, 1:], 0.0)):
+            raise ValueError("Cannot create AffineShiftOp: "
+                             "Matrix does not have the correct arrowhead structure")
+        _DenseOperator.__init__(self, mx, basis, evotype, state_space)
+        assert(self._rep.base.flags['C_CONTIGUOUS'] and self._rep.base.flags['OWNDATA'])
+        assert(isinstance(self._ptr, _ProtectedArray))
+        
+        self._paramlbls = _np.array(["MxElement %d,0" % (i) for i in range(1, self.dim)],
+                                    dtype=object)
+
+    @property
+    def _ptr(self):
+        """
+        The underlying dense process matrix.
+        """
+        return _ProtectedArray(self._rep.base, indices_to_protect=[(0,slice(None,None,None)),
+                               (slice(1,None, None), slice(1, None, None))])
+
+    def set_dense(self, m):
+        """
+        Set the dense-matrix value of this operation.
+
+        Attempts to modify operation parameters so that the specified raw
+        operation matrix becomes m.  Will raise ValueError if this operation
+        is not possible.
+
+        Parameters
+        ----------
+        m : array_like or LinearOperator
+            An array of shape (dim, dim) or LinearOperator representing the operation action.
+
+        Returns
+        -------
+        None
+        """
+        mx = _LinearOperator.convert_to_matrix(m)
+        if(mx.shape != (self.dim, self.dim)):
+            raise ValueError("Argument must be a (%d,%d) matrix!"
+                             % (self.dim, self.dim))
+        if not (_np.allclose(_np.diag(mx), 1) and  _np.allclose((mx-_np.eye(mx.shape[0]))[:, 1:], 0.0)):
+            raise ValueError("Cannot create AffineShiftOp: "
+                             "Matrix does not have the correct arrowhead structure")
+            #For further debugging:  + "\n".join([str(e) for e in mx[0,:]])
+        self._ptr[1:, 0] = mx[1:, 0]
+        self._ptr_has_changed()
+        self.dirty = True
+
+    @property
+    def num_params(self):
+        """
+        Get the number of independent parameters which specify this operation.
+
+        Returns
+        -------
+        int
+            the number of independent parameters.
+        """
+        return self.dim-1
+
+    def to_vector(self):
+        """
+        Get the operation parameters as an array of values.
+
+        Returns
+        -------
+        numpy array
+            The operation parameters as a 1D array with length num_params().
+        """
+        # Use flatten (rather than ravel) to ensure a copy is made.
+        return self._ptr[1:,0].flatten() # .real in case of complex matrices?
+
+    def from_vector(self, v, close=False, dirty_value=True):
+        """
+        Initialize the operation using a vector of parameters.
+
+        Parameters
+        ----------
+        v : numpy array
+            The 1D vector of operation parameters.  Length
+            must == num_params()
+
+        close : bool, optional
+            Whether `v` is close to this operation's current
+            set of parameters.  Under some circumstances, when this
+            is true this call can be completed more quickly.
+
+        dirty_value : bool, optional
+            The value to set this object's "dirty flag" to before exiting this
+            call.  This is passed as an argument so it can be updated *recursively*.
+            Leave this set to `True` unless you know what you're doing.
+
+        Returns
+        -------
+        None
+        """
+        #TODO: Circle back to comments about it being faster to directly
+        #operate on the rep.
+        #assert(self._ptr.shape == (self.dim, self.dim))
+        assert (len(v) == self.dim-1)
+        self._ptr[1:, 0] = v
+        #self._rep.base[1:, :] = v.reshape((self.dim - 1, self.dim))  # faster than line above
+        #self._rep.base.flat[self.dim:] = v  # faster still
+        self._ptr_has_changed()  # because _rep.base == _ptr (same memory)
+        self.dirty = dirty_value
+
+    def deriv_wrt_params(self, wrt_filter=None):
+        """
+        The element-wise derivative this operation.
+
+        Construct a matrix whose columns are the vectorized
+        derivatives of the flattened operation matrix with respect to a
+        single operation parameter.  Thus, each column is of length
+        op_dim^2 and there is one column per operation parameter.
+
+        Parameters
+        ----------
+        wrt_filter : list or numpy.ndarray
+            List of parameter indices to take derivative with respect to.
+            (None means to use all the this operation's parameters.)
+
+        Returns
+        -------
+        numpy array
+            Array of derivatives with shape (dimension^2, num_params)
+        """
+        derivMx = _np.identity(self.dim**2, 'd')  # TP operations are assumed to be real
+
+        derivMx = derivMx[:, self.dim::self.dim]  # Extract only columns of derivMx matrix
+        #corresponding to the first column of the PTR less the first row.
+
+        if wrt_filter is None:
+            return derivMx
+        else:
+            return _np.take(derivMx, wrt_filter, axis=1)
+
+    def has_nonzero_hessian(self):
+        """
+        Whether this operation has a non-zero Hessian with respect to its parameters.
+
+        (i.e. whether it only depends linearly on its parameters or not)
+
+        Returns
+        -------
+        bool
+        """
+        return False

pygsti/modelmembers/operations/composederrorgen.py

@@ -63,7 +63,7 @@ class ComposedErrorgen(_LinearOperator):
 
         if evotype == "auto":
             evotype = errgens_to_compose[0]._evotype
-        evotype = _Evotype.cast(evotype)
+        evotype = _Evotype.cast(evotype, state_space=state_space)
         assert(all([evotype == eg._evotype for eg in errgens_to_compose])), \
             "All error generators must have the same evolution type (%s expected)!" % evotype
 

pygsti/modelmembers/operations/composedop.py

@@ -69,7 +69,7 @@ class ComposedOp(_LinearOperator):
             evotype = ops_to_compose[0]._evotype
         assert(all([evotype == operation._evotype for operation in ops_to_compose])), \
             "All operations must have the same evolution type (%s expected)!" % evotype
-        evotype = _Evotype.cast(evotype)
+        evotype = _Evotype.cast(evotype, state_space=state_space)
 
         rep = self._create_rep_object(evotype, state_space)
 
@@ -491,10 +491,6 @@ class ComposedOp(_LinearOperator):
 
         self.terms[order] = terms
 
-        #def _decompose_indices(x):
-        #    return tuple(_modelmember._decompose_gpindices(
-        #        self.gpindices, _np.array(x, _np.int64)))
-
         mapvec = _np.ascontiguousarray(_np.zeros(max_polynomial_vars, _np.int64))
         for ii, i in enumerate(gpindices_array):
             mapvec[i] = ii
@@ -555,25 +551,6 @@ class ComposedOp(_LinearOperator):
                 if mag >= min_term_mag:
                     terms.append(_term.compose_terms_with_mag(factors, mag))
         return terms
-        #def _decompose_indices(x):
-        #    return tuple(_modelmember._decompose_gpindices(
-        #        self.gpindices, _np.array(x, _np.int64)))
-        #
-        #mapvec = _np.ascontiguousarray(_np.zeros(max_polynomial_vars,_np.int64))
-        #for ii,i in enumerate(self.gpindices_as_array()):
-        #    mapvec[i] = ii
-        #
-        ##poly_coeffs = [t.coeff.map_indices(_decompose_indices) for t in terms]  # with *local* indices
-        #poly_coeffs = [t.coeff.mapvec_indices(mapvec) for t in terms]  # with *local* indices
-        #tapes = [poly.compact(complex_coeff_tape=True) for poly in poly_coeffs]
-        #if len(tapes) > 0:
-        #    vtape = _np.concatenate([t[0] for t in tapes])
-        #    ctape = _np.concatenate([t[1] for t in tapes])
-        #else:
-        #    vtape = _np.empty(0, _np.int64)
-        #    ctape = _np.empty(0, complex)
-        #coeffs_as_compact_polys = (vtape, ctape)
-        #self.local_term_poly_coeffs[order] = coeffs_as_compact_polys
 
     @property
     def total_term_magnitude(self):

pygsti/modelmembers/operations/denseop.py

@@ -313,7 +313,7 @@ class DenseOperator(DenseOperatorInterface, _KrausOperatorInterface, _LinearOper
         mx = _LinearOperator.convert_to_matrix(mx)
         state_space = _statespace.default_space_for_dim(mx.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)
         self._basis = _Basis.cast(basis, state_space.dim) if (basis is not None) else None  # for Hilbert-Schmidt space
         rep = evotype.create_dense_superop_rep(mx, self._basis, state_space)
         _LinearOperator.__init__(self, rep, evotype)
@@ -416,11 +416,11 @@ class DenseOperator(DenseOperatorInterface, _KrausOperatorInterface, _LinearOper
         #CHECK 1 (to unit test?) REMOVE
         #tmp_std = _bt.change_basis(superop_mx, self._basis, 'std')
         #B = _bt.basis_matrices('std', superop_mx.shape[0])
-        #check_superop = sum([ choi_mx[i,j] * _np.kron(B[i], B[j].T) for i in range(d*d) for j in range(d*d)])
+        #check_superop = sum([ choi_mx[i,j] * _np.kron(B[i], B[j].conjugate()) for i in range(d*d) for j in range(d*d)])
         #assert(_np.allclose(check_superop, tmp_std))
 
-        evals, evecs = _np.linalg.eig(choi_mx)
-        #assert(_np.allclose(evecs @ _np.diag(evals) @ (evecs.conjugate().T), choi_mx))
+        evals, evecs = _np.linalg.eigh(choi_mx)
+        assert(_np.allclose(evecs @ _np.diag(evals) @ (evecs.conjugate().T), choi_mx))
         TOL = 1e-7  # consider lowering this tolerance as it leads to errors of this order in the Kraus decomp
         if any([ev <= -TOL for ev in evals]):
             raise ValueError("Cannot compute Kraus decomposition of non-positive-definite superoperator!")
@@ -533,7 +533,7 @@ class DenseUnitaryOperator(DenseOperatorInterface, _KrausOperatorInterface, _Lin
         state_space = _statespace.default_space_for_udim(mx.shape[0]) if (state_space is None) \
             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)
 
         #Try to create a dense unitary rep.  If this fails, see if a dense superop rep
         # can be created, as this type of rep can also hold arbitrary unitary ops.

pygsti/modelmembers/operations/eigpdenseop.py

@@ -432,13 +432,13 @@ class EigenvalueParamDenseOp(_DenseOperator):
             dMx = _np.zeros((self.dim, self.dim), 'complex')
             for prefactor, (i, j) in pdesc:
                 dMx[i, j] = prefactor
-            tmp = _np.dot(self.B, _np.dot(dMx, self.Bi))
+            tmp = self.B @ (dMx @ self.Bi)
             if _np.linalg.norm(tmp.imag) >= IMAG_TOL:  # just a warning until we figure this out.
                 print("EigenvalueParamDenseOp deriv_wrt_params WARNING:"
                       " Imag part = ", _np.linalg.norm(tmp.imag), " pdesc = ", pdesc)  # pragma: no cover
             #assert(_np.linalg.norm(tmp.imag) < IMAG_TOL), \
             #       "Imaginary mag = %g!" % _np.linalg.norm(tmp.imag)
-            derivMx[:, k] = tmp.real.flatten()
+            derivMx[:, k] = tmp.real.ravel()
 
         if wrt_filter is None:
             return derivMx

pygsti/modelmembers/operations/embeddederrorgen.py

@@ -11,10 +11,10 @@ The EmbeddedErrorgen class and supporting functionality.
 #***************************************************************************************************
 
 import collections as _collections
+from pygsti.baseobjs.basis import Basis as _Basis
 import warnings as _warnings
 
 from pygsti.modelmembers.operations.embeddedop import EmbeddedOp as _EmbeddedOp
-from pygsti.baseobjs.basis import Basis as _Basis, EmbeddedBasis as _EmbeddedBasis
 
 
 # Idea:

pygsti/modelmembers/operations/embeddedop.py

@@ -18,7 +18,6 @@ import scipy.sparse as _sps
 
 from pygsti.modelmembers.operations.linearop import LinearOperator as _LinearOperator
 from pygsti.modelmembers import modelmember as _modelmember
-from pygsti.baseobjs.basis import EmbeddedBasis as _EmbeddedBasis
 from pygsti.baseobjs.statespace import StateSpace as _StateSpace
 
 

pygsti/modelmembers/operations/experrorgenop.py

@@ -699,10 +699,13 @@ class ExpErrorgenOp(_LinearOperator, _ErrorGeneratorContainer):
 
             #just act on postfactor and Lindbladian exponent:
             if typ == "prep":
-                mx = _mt.safe_dot(Uinv, mx)
+                mx = Uinv @ mx
             else:
-                mx = _mt.safe_dot(mx, U)
+                mx = mx @ U
             self.set_dense(mx)  # calls _update_rep() and sets dirty flag
+        else:
+            raise ValueError("Invalid transform for this LindbladErrorgen: type %s"
+                             % str(type(s)))
 
     def __str__(self):
         s = "Exponentiated operation map with dim = %d, num params = %d\n" % \

pygsti/modelmembers/operations/fullarbitraryop.py

@@ -93,6 +93,7 @@ class FullArbitraryOp(_DenseOperator):
         numpy array
             The operation parameters as a 1D array with length num_params().
         """
+        # Use flatten (rather than ravel) to ensure a copy is made.
         return self._ptr.flatten()
 
     def from_vector(self, v, close=False, dirty_value=True):

pygsti/modelmembers/operations/fullcptpop.py

@@ -42,7 +42,7 @@ class FullCPTPOp(_KrausOperatorInterface, _LinearOperator):
         choi_mx = _LinearOperator.convert_to_matrix(choi_mx)
         state_space = _statespace.default_space_for_dim(choi_mx.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)
         self._basis = _Basis.cast(basis, state_space.dim) if (basis is not None) else None  # for Hilbert-Schmidt space
 
         #scratch space
@@ -93,7 +93,7 @@ class FullCPTPOp(_KrausOperatorInterface, _LinearOperator):
             Lmx = _np.linalg.cholesky(choi_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!"
 
         self.params = _np.empty(dim**2, 'd')

pygsti/modelmembers/operations/fulltpop.py

@@ -10,14 +10,25 @@ The FullTPOp class and supporting functionality.
 # http://www.apache.org/licenses/LICENSE-2.0 or in the LICENSE file in the root pyGSTi directory.
 #***************************************************************************************************
 
-import numpy as _np
+from __future__ import annotations
+from typing import Tuple, TYPE_CHECKING
+if TYPE_CHECKING:
+    import torch as _torch
+try:
+    import torch as _torch
+except ImportError:
+    pass
 
+import numpy as _np
 from pygsti.modelmembers.operations.denseop import DenseOperator as _DenseOperator
 from pygsti.modelmembers.operations.linearop import LinearOperator as _LinearOperator
 from pygsti.baseobjs.protectedarray import ProtectedArray as _ProtectedArray
+from pygsti.modelmembers.torchable import Torchable as _Torchable
+
+
 
 
-class FullTPOp(_DenseOperator):
+class FullTPOp(_DenseOperator, _Torchable):
     """
     A trace-preserving operation matrix.
 
@@ -52,11 +63,9 @@ class FullTPOp(_DenseOperator):
     """
 
     def __init__(self, m, basis=None, evotype="default", state_space=None):
-        #LinearOperator.__init__(self, LinearOperator.convert_to_matrix(m))
         mx = _LinearOperator.convert_to_matrix(m)
         assert(_np.isrealobj(mx)), "FullTPOp must have *real* values!"
-        if not (_np.isclose(mx[0, 0], 1.0)
-                and _np.allclose(mx[0, 1:], 0.0)):
+        if not (_np.isclose(mx[0, 0], 1.0) and _np.allclose(mx[0, 1:], 0.0)):
             raise ValueError("Cannot create FullTPOp: "
                              "invalid form for 1st row!")
         _DenseOperator.__init__(self, mx, basis, evotype, state_space)
@@ -122,7 +131,7 @@ class FullTPOp(_DenseOperator):
         numpy array
             The operation parameters as a 1D array with length num_params().
         """
-        return self._ptr.flatten()[self.dim:]  # .real in case of complex matrices?
+        return self._ptr.ravel()[self.dim:].copy()  # .real in case of complex matrices?
 
     def from_vector(self, v, close=False, dirty_value=True):
         """
@@ -155,6 +164,19 @@ class FullTPOp(_DenseOperator):
         self._ptr_has_changed()  # because _rep.base == _ptr (same memory)
         self.dirty = dirty_value
 
+    def stateless_data(self) -> Tuple[int]:
+        return (self.dim,)
+
+    @staticmethod
+    def torch_base(sd: Tuple[int], t_param: _torch.Tensor) -> _torch.Tensor:
+        dim = sd[0]
+        t_const = _torch.zeros(size=(1, dim), dtype=_torch.double)
+        t_const[0,0] = 1.0
+        t_param_mat = t_param.reshape((dim - 1, dim))
+        t = _torch.row_stack((t_const, t_param_mat))
+        return t
+
+
     def deriv_wrt_params(self, wrt_filter=None):
         """
         The element-wise derivative this operation.

pygsti/modelmembers/operations/fullunitaryop.py

@@ -98,7 +98,8 @@ class FullUnitaryOp(_DenseUnitaryOperator):
         numpy array
             The operation parameters as a 1D array with length num_params().
         """
-        return _np.concatenate((self._ptr.real.flatten(), self._ptr.imag.flatten()), axis=0)
+        # _np.concatenate will make a copy for us, so use ravel instead of flatten.
+        return _np.concatenate((self._ptr.real.ravel(), self._ptr.imag.ravel()), axis=0)
 
     def from_vector(self, v, close=False, dirty_value=True):
         """
@@ -200,7 +201,7 @@ class FullUnitaryOp(_DenseUnitaryOperator):
             Uinv = s.transform_matrix_inverse
 
             my_superop_mx = _ot.unitary_to_superop(self._ptr, self._basis)
-            my_superop_mx = _mt.safe_dot(Uinv, _mt.safe_dot(my_superop_mx, U))
+            my_superop_mx = Uinv @ (my_superop_mx @ U)
 
             self._ptr[:, :] = _ot.superop_to_unitary(my_superop_mx, self._basis)
             self._ptr_has_changed()
@@ -250,9 +251,9 @@ class FullUnitaryOp(_DenseUnitaryOperator):
 
             #Note: this code may need to be tweaked to work with sparse matrices
             if typ == "prep":
-                my_superop_mx = _mt.safe_dot(Uinv, my_superop_mx)
+                my_superop_mx = Uinv @ my_superop_mx
             else:
-                my_superop_mx = _mt.safe_dot(my_superop_mx, U)
+                my_superop_mx = my_superop_mx @ U
 
             self._ptr[:, :] = _ot.superop_to_unitary(my_superop_mx, self._basis)
             self._ptr_has_changed()