pyGSTi 0.9.12.1__cp39-cp39-win_amd64.whl → 0.9.13__cp39-cp39-win_amd64.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

@@ -475,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

@@ -126,6 +126,7 @@ class AffineShiftOp(_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[1:,0].flatten() # .real in case of complex matrices?
 
     def from_vector(self, v, close=False, dirty_value=True):

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,9 +699,9 @@ 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"

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()

pygsti/modelmembers/operations/lindbladcoefficients.py

@@ -8,78 +8,73 @@ import warnings as _warnings
 from pygsti.tools import lindbladtools as _lt
 from pygsti.tools import matrixtools as _mt
 from pygsti.tools import optools as _ot
+from pygsti.tools import fastcalc as _fc
 from pygsti.baseobjs.basis import Basis as _Basis, BuiltinBasis as _BuiltinBasis
 from pygsti.modelmembers import term as _term
 from pygsti.baseobjs.polynomial import Polynomial as _Polynomial
 from pygsti.baseobjs.nicelyserializable import NicelySerializable as _NicelySerializable
 
+from functools import lru_cache
+
 IMAG_TOL = 1e-7  # tolerance for imaginary part being considered zero
 
 
 class LindbladCoefficientBlock(_NicelySerializable):
-    """ SCRATCH:
-        This routine computes the Hamiltonian and Non-Hamiltonian ("other")
-        superoperator generators which correspond to the terms of the Lindblad
-        expression:
-
-        L(rho) = sum_i( h_i [A_i,rho] ) +
-                 sum_ij( o_ij * (B_i rho B_j^dag -
-                                 0.5( rho B_j^dag B_i + B_j^dag B_i rho) ) )
-
-        where {A_i} and {B_i} are bases (possibly the same) for Hilbert Schmidt
-        (density matrix) space with the identity element removed so that each
-        A_i and B_i are traceless.  If we write L(rho) in terms of superoperators
-        H_i and O_ij,
-
-        L(rho) = sum_i( h_i H_i(rho) ) + sum_ij( o_ij O_ij(rho) )
-
-        then this function computes the matrices for H_i and O_ij using the given
-        density matrix basis.  Thus, if `dmbasis` is expressed in the standard
-        basis (as it should be), the returned matrices are also in this basis.
-
-        If these elements are used as projectors it may be usedful to normalize
-        them (by setting `normalize=True`).  Note, however, that these projectors
-        are not all orthogonal - in particular the O_ij's are not orthogonal to
-        one another.
-
-        Parameters
-        ----------
-        dmbasis_ham : list
-            A list of basis matrices {B_i} *including* the identity as the first
-            element, for the returned Hamiltonian-type error generators.  This
-            argument is easily obtained by call to  :func:`pp_matrices` or a
-            similar function.  The matrices are expected to be in the standard
-            basis, and should be traceless except for the identity.  Matrices
-            should be NumPy arrays or SciPy CSR sparse matrices.
-
-        dmbasis_other : list
-            A list of basis matrices {B_i} *including* the identity as the first
-            element, for the returned Stochastic-type error generators.  This
-            argument is easily obtained by call to  :func:`pp_matrices` or a
-            similar function.  The matrices are expected to be in the standard
-            basis, and should be traceless except for the identity.  Matrices
-            should be NumPy arrays or SciPy CSR sparse matrices.
-
-        normalize : bool
-            Whether or not generators should be normalized so that
-            numpy.linalg.norm(generator.flat) == 1.0  Note that the generators
-            will still, in general, be non-orthogonal.
-
-        other_mode : {"diagonal", "diag_affine", "all"}
-            Which non-Hamiltonian Lindblad error generators to construct.
-            Allowed values are: `"diagonal"` (only the diagonal Stochastic
-            generators are returned; that is, the generators corresponding to the
-            `i==j` terms in the Lindblad expression.), `"diag_affine"` (diagonal +
-            affine generators), and `"all"` (all generators).
+    """ 
+    Class for storing and managing the parameters associated with particular subblocks of error-generator
+    parameters. Responsible for management of different internal representations utilized when employing
+    various error generator constraints.
     """
 
     _superops_cache = {}  # a custom cache for create_lindblad_term_superoperators method calls
 
     def __init__(self, block_type, basis, basis_element_labels=None, initial_block_data=None, param_mode='static',
                  truncate=False):
+        """
+        Parameters
+        ----------
+        block_type : str
+            String specifying the type of error generator parameters contained within this block. Allowed
+            values are 'ham' (for Hamiltonian error generators), 'other_diagonal' (for Pauli stochastic error generators),
+            and 'other' (for Pauli stochastic, Pauli correlation and active error generators).
+        
+        basis : `Basis`
+            `Basis` object to be used by this coefficient block. Not this must be an actual `Basis` object, and not
+            a string (as the coefficient block doesn't have the requisite dimensionality information needed for casting).
+        
+        basis_element_labels : list or tuple of str
+            Iterable of strings corresponding to the basis element subscripts used by the error generators managed by
+            this coefficient block.
+        
+        initial_block_data : _np.ndarray, optional (default None)
+            Numpy array with initial parameter values to use in setting initial state of this coefficient block.
+        
+        param_mode : str, optional (default 'static')
+            String specifying the type of internal parameterization used by this coefficient block. Allowed options are:
+            
+            - For all block types: 'static'
+            - For 'ham': 'elements'
+            - For 'other_diagonal': 'elements', 'cholesky', 'depol', 'reldepol'
+            - For 'other': 'elements', 'cholesky'
+
+            Note that the most commonly encounted settings in practice are 'elements' and 'cholesky',
+            which when used in the right combination are utilized in the construction of GLND and CPTPLND
+            parameterized models. For both GLND and CPTPLND the 'ham' block used the 'elements' `param_mode`.
+            GLND the 'other' block uses 'elements', and for CPTPLND it uses 'cholesky'. 
+            
+            'depol' and 'reldepol' are special modes used only for Pauli stochastic only coefficient blocks
+            (i.e. 'other_diagonal'), and correspond to special reduced parameterizations applicable to depolarizing
+            channels. (TODO: Add better explanation of the difference between depol and reldepol).
+        
+        truncate : bool, optional (default False)
+            Flag specifying whether to truncate the parameters given by `initial_block_data` in order to meet
+            constraints (e.g. to preserve CPTP) when necessary. If False, then an error is thrown when the 
+            given intial data cannot be parameterized as specified. 
+        """
+
         super().__init__()
         self._block_type = block_type  # 'ham' or 'other' or 'other_diagonal'
-        self._param_mode = param_mode  # 'static', 'elements', 'cholesky', or 'real_cholesky', 'depol', 'reldepol'
+        self._param_mode = param_mode  # 'static', 'elements', 'cholesky', 'depol', 'reldepol'
         self._basis = basis  # must be a full Basis object, not just a string, as we otherwise don't know dimension
         self._bel_labels = tuple(basis_element_labels) if (basis_element_labels is not None) \
             else tuple(basis.labels[1:])  # Note: don't include identity
@@ -195,7 +190,7 @@ class LindbladCoefficientBlock(_NicelySerializable):
                 if sparse:
                     #Note: complex OK here sometimes, as only linear combos of "other" gens
                     # (like (i,j) + (j,i) terms) need to be real.
-                    superops = [_mt.safe_dot(leftTrans, _mt.safe_dot(mx, rightTrans)) for mx in superops]
+                    superops = [leftTrans @ (mx @ rightTrans) for mx in superops]
                     for mx in superops: mx.sort_indices()
                 else:
                     #superops = _np.einsum("ik,akl,lj->aij", leftTrans, superops, rightTrans)
@@ -816,12 +811,19 @@ class LindbladCoefficientBlock(_NicelySerializable):
                 #  encodes a lower-triangular matrix "cache_mx" via:
                 #  cache_mx[i,i] = params[i,i]
                 #  cache_mx[i,j] = params[i,j] + 1j*params[j,i] (i > j)
+
                 cache_mx = self._cache_mx
-                iparams = 1j * params
-                for i in range(num_bels):
-                    cache_mx[i, i] = params[i, i]
-                    cache_mx[i, :i] = params[i, :i] + iparams[:i, i]
 
+                params_upper_indices = _fc.fast_triu_indices(num_bels) 
+                params_upper = 1j*params[params_upper_indices]
+                params_lower = (params.T)[params_upper_indices]
+
+                cache_mx_trans = cache_mx.T
+                cache_mx_trans[params_upper_indices] = params_lower + params_upper
+                        
+                diag_indices = cached_diag_indices(num_bels)
+                cache_mx[diag_indices] = params[diag_indices]
+                
                 #The matrix of (complex) "other"-coefficients is build by assuming
                 # cache_mx is its Cholesky decomp; means otherCoeffs is pos-def.
 
@@ -830,27 +832,28 @@ class LindbladCoefficientBlock(_NicelySerializable):
                 # matrix, but we don't care about this uniqueness criteria and so
                 # the diagonal els of cache_mx can be negative and that's fine -
                 # block_data will still be posdef.
-                self.block_data[:, :] = _np.dot(cache_mx, cache_mx.T.conjugate())
+                self.block_data[:, :] = cache_mx@cache_mx.T.conj()
 
-                #DEBUG - test for pos-def
-                #evals = _np.linalg.eigvalsh(block_data)
-                #DEBUG_TOL = 1e-16; #print("EVALS DEBUG = ",evals)
-                #assert(all([ev >= -DEBUG_TOL for ev in evals]))
 
             elif self._param_mode == "elements":  # params mx stores block_data (hermitian) directly
                 #params holds block_data real and imaginary parts directly
-                iparams = 1j * params
-                for i in range(num_bels):
-                    self.block_data[i, i] = params[i, i]
-                    self.block_data[i, :i] = params[i, :i] + iparams[:i, i]
-                    self.block_data[:i, i] = params[i, :i] - iparams[:i, i]
+                params_upper_indices = _fc.fast_triu_indices(num_bels) 
+                params_upper = -1j*params[params_upper_indices]
+                params_lower = (params.T)[params_upper_indices]
+
+                block_data_trans = self.block_data.T
+                self.block_data[params_upper_indices] = params_lower + params_upper
+                block_data_trans[params_upper_indices] = params_lower - params_upper
+
+                diag_indices = cached_diag_indices(num_bels)
+                self.block_data[diag_indices] = params[diag_indices]
+
             else:
                 raise ValueError("Internal error: invalid parameter mode (%s) for block type %s!"
                                  % (self._param_mode, self._block_type))
         else:
             raise ValueError("Internal error: invalid block type!")
 
-    #def paramvals_to_coefficients_deriv(self, parameter_values, cache_mx=None):
     def deriv_wrt_params(self, v=None):
         """
         Construct derivative of Lindblad coefficients (for this block) from a set of parameter values.
@@ -1112,11 +1115,11 @@ class LindbladCoefficientBlock(_NicelySerializable):
             if self._param_mode == "depol":
                 #d2Odp2  = _np.einsum('alj->lj', self.otherGens)[:,:,None,None] * 2
                 d2Odp2 = _np.sum(superops, axis=0)[:, :, None, None] * 2
-            elif self.parameterization.param_mode == "cptp":
+            elif self._param_mode == "cholesky":
                 assert(nP == num_bels)
                 #d2Odp2  = _np.einsum('alj,aq->ljaq', self.otherGens, 2*_np.identity(nP,'d'))
                 d2Odp2 = _np.transpose(superops, (1, 2, 0))[:, :, :, None] * 2 * _np.identity(nP, 'd')
-            else:  # param_mode == "unconstrained" or "reldepol"
+            else:  # param_mode == "elements" or "reldepol"
                 assert(nP == num_bels)
             d2Odp2 = _np.zeros((superops.shape[1], superops.shape[2], nP, nP), 'd')
 
@@ -1124,7 +1127,10 @@ class LindbladCoefficientBlock(_NicelySerializable):
             if self._param_mode == "cholesky":
                 if superops_are_flat:  # then un-flatten
                     superops = superops.reshape((num_bels, num_bels, superops.shape[1], superops.shape[2]))
-                d2Odp2 = _np.zeros([superops.shape[2], superops.shape[3], nP, nP, nP, nP], 'complex')
+                sqrt_nP = _np.sqrt(nP)
+                snP = int(sqrt_nP)
+                assert snP == sqrt_nP == num_bels
+                d2Odp2 = _np.zeros([superops.shape[2], superops.shape[3], snP, snP, snP, snP], 'complex')
                 # yikes! maybe make this SPARSE in future?
 
                 #Note: correspondence w/Erik's notes: a=alpha, b=beta, q=gamma, r=delta
@@ -1136,11 +1142,11 @@ class LindbladCoefficientBlock(_NicelySerializable):
                         parameter indices s.t. ab > base and qr > base.  If
                         ab_inc_eq == True then the > becomes a >=, and likewise
                         for qr_inc_eq.  Used for looping over nonzero hessian els. """
-                    for _base in range(nP):
+                    for _base in range(snP):
                         start_ab = _base if ab_inc_eq else _base + 1
                         start_qr = _base if qr_inc_eq else _base + 1
-                        for _ab in range(start_ab, nP):
-                            for _qr in range(start_qr, nP):
+                        for _ab in range(start_ab, snP):
+                            for _qr in range(start_qr, snP):
                                 yield (_base, _ab, _qr)
 
                 for base, a, q in iter_base_ab_qr(True, True):  # Case1: base=b=r, ab=a, qr=q
@@ -1153,7 +1159,12 @@ class LindbladCoefficientBlock(_NicelySerializable):
                     d2Odp2[:, :, base, b, base, r] = superops[b, r] + superops[r, b]
 
             elif self._param_mode == 'elements':  # unconstrained
-                d2Odp2 = _np.zeros([superops.shape[2], superops.shape[3], nP, nP, nP, nP], 'd')  # all params linear
+                if superops_are_flat:  # then un-flatten
+                    superops = superops.reshape((num_bels, num_bels, superops.shape[1], superops.shape[2]))
+                sqrt_nP = _np.sqrt(nP)
+                snP = int(sqrt_nP)
+                assert snP == sqrt_nP == num_bels
+                d2Odp2 = _np.zeros([superops.shape[2], superops.shape[3], snP, snP, snP, snP], 'd')  # all params linear
             else:
                 raise ValueError("Internal error: invalid parameter mode (%s) for block type %s!"
                                  % (self._param_mode, self._block_type))
@@ -1204,3 +1215,7 @@ class LindbladCoefficientBlock(_NicelySerializable):
         if len(self._bel_labels) < 10:
             s += " Coefficients are:\n" + str(_np.round(self.block_data, 4))
         return s
+
+@lru_cache(maxsize=16)
+def cached_diag_indices(n):
+    return _np.diag_indices(n)