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

pygsti/evotypes/stabilizer/termreps.pyx

@@ -107,10 +107,3 @@ cdef class TermRep(_basereps_cython.TermRep):
         return TermRep(self.coeff.copy(), self.magnitude, self.logmagnitude,
                          self.pre_state, self.post_state, self.pre_effect, self.post_effect,
                          self.pre_ops, self.post_ops)
-
-    #Not needed - and this implementation is quite right as it will need to change
-    # the ordering of the pre/post ops also.
-    #def conjugate(self):
-    #    return TermRep(self.coeff.copy(), self.magnitude, self.logmagnitude,
-    #                     self.post_state, self.pre_state, self.post_effect, self.pre_effect,
-    #                     self.post_ops, self.pre_ops)

pygsti/evotypes/stabilizer_slow/effectreps.py

@@ -23,10 +23,6 @@ class EffectRep(_basereps.EffectRep):
     def nqubits(self):
         return self.state_space.num_qubits
 
-    #@property
-    #def dim(self):
-    #    return 2**self.nqubits  # assume "unitary evolution"-type mode
-
     def probability(self, state):
         return state.sframe.measurement_probability(self.zvals, check=True)  # use check for now?
 
@@ -37,10 +33,6 @@ class EffectRep(_basereps.EffectRep):
         return _mt.zvals_to_dense(self.zvals, superket=bool(on_space not in ('minimal', 'Hilbert')))
 
 
-#class EffectRepConjugatedState(EffectRep):
-#    pass  # TODO - this should be possible
-
-
 class EffectRepComputational(EffectRep):
 
     def __init__(self, zvals, basis, state_space):
@@ -49,17 +41,6 @@ class EffectRepComputational(EffectRep):
         assert(self.state_space.num_qubits == len(self.zvals))
         super(EffectRepComputational, self).__init__(state_space)
 
-    #@property
-    #def outcomes(self):
-    #    """
-    #    The 0/1 outcomes identifying this effect within its StabilizerZPOVM
-    #
-    #    Returns
-    #    -------
-    #    numpy.ndarray
-    #    """
-    #    return self.zvals
-
     def __str__(self):
         nQubits = len(self.zvals)
         s = "Stabilizer effect vector for %d qubits with outcome %s" % (nQubits, str(self.zvals))
@@ -80,9 +61,6 @@ class EffectRepComposed(EffectRep):
 
         super(EffectRepComposed, self).__init__(state_space)
 
-    #def __reduce__(self):
-    #    return (EffectRepComposed, (self.op_rep, self.effect_rep, self.op_id, self.state_space))
-
     def probability(self, state):
         state = self.op_rep.acton(state)  # *not* acton_adjoint
         return self.effect_rep.probability(state)

pygsti/evotypes/stabilizer_slow/opreps.py

@@ -34,10 +34,6 @@ class OpRep(_basereps.OpRep):
     def nqubits(self):
         return self.state_space.num_qubits
 
-    #@property
-    #def dim(self):
-    #    return 2**(self.nqubits)  # assume "unitary evolution"-type mode
-
 
 class OpRepClifford(OpRep):
     def __init__(self, unitarymx, symplecticrep, basis, state_space):

pygsti/evotypes/stabilizer_slow/statereps.py

@@ -42,10 +42,6 @@ class StateRep(_basereps.StateRep):
     def nqubits(self):
         return self.sframe.n
 
-    #@property
-    #def dim(self):
-    #    return 2**self.nqubits  # assume "unitary evolution"-type mode
-
     def actionable_staterep(self):
         # return a state rep that can be acted on by op reps or mapped to
         # a probability/amplitude by POVM effect reps.

pygsti/evotypes/statevec/effectreps.pyx

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

pygsti/evotypes/statevec/opreps.pyx

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

pygsti/evotypes/statevec/statereps.pyx

@@ -150,7 +150,7 @@ cdef class StateRepTensorProduct(StateRep):
 
     def __init__(self, factor_state_reps, state_space):
         self.factor_reps = factor_state_reps
-        dim = _np.product([fct.dim for fct in self.factor_reps])
+        dim = _np.prod([fct.dim for fct in self.factor_reps])
         self._cinit_base(_np.zeros(dim, complex), state_space, None)  # TODO: compute a tensorprod basis?
         self.reps_have_changed()
 

pygsti/evotypes/statevec/termreps.pyx

@@ -112,13 +112,6 @@ cdef class TermRep(_basereps_cython.TermRep):
                          self.pre_state, self.post_state, self.pre_effect, self.post_effect,
                          self.pre_ops, self.post_ops)
 
-    #Not needed - and this implementation is quite right as it will need to change
-    # the ordering of the pre/post ops also.
-    #def conjugate(self):
-    #    return TermRep(self.coeff.copy(), self.magnitude, self.logmagnitude,
-    #                     self.post_state, self.pre_state, self.post_effect, self.pre_effect,
-    #                     self.post_ops, self.pre_ops)
-
 
 #Note: to use direct term reps (numerical coeffs) we'll need to update
 # what the members are called and add methods as was done for TermRep.

pygsti/evotypes/statevec_slow/effectreps.py

@@ -180,9 +180,6 @@ class EffectRepComposed(EffectRep):
 
         super(EffectRepComposed, self).__init__(effect_rep.state_space)
 
-    #def __reduce__(self):
-    #    return (EffectRepComposed, (self.op_rep, self.effect_rep, self.op_id, self.state_space))
-
     def probability(self, state):
         state = self.op_rep.acton(state)  # *not* acton_adjoint
         return self.effect_rep.probability(state)

pygsti/evotypes/statevec_slow/opreps.py

@@ -107,11 +107,6 @@ class OpRepStandard(OpRepDenseUnitary):
         super(OpRepStandard, self).__init__(U, basis, state_space)
 
 
-#class OpRepStochastic(OpRepDense):
-# - maybe we could add this, but it wouldn't be a "dense" op here,
-#   perhaps we need to change API?
-
-
 class OpRepComposed(OpRep):
     # exactly the same as densitymx case
     def __init__(self, factor_op_reps, state_space):

pygsti/extras/__init__.py

@@ -9,5 +9,4 @@
 """ Container for beyond-GST sub-packages """
 
 # from . import drift
-# from . import rb  # temporarily removed until RB analysis is fixed
 # from . import rpe

pygsti/extras/drift/signal.py

@@ -10,7 +10,7 @@
 
 import numpy as _np
 import numpy.random as _rnd
-from scipy import convolve as _convolve
+from numpy import convolve as _convolve
 from scipy.fftpack import dct as _dct
 from scipy.fftpack import fft as _fft
 from scipy.fftpack import idct as _idct

pygsti/extras/drift/stabilityanalyzer.py

@@ -1235,9 +1235,11 @@ class StabilityAnalyzer(object):
 
                     # If we're not testing a single spectrum we need to flatten the >1D array.
                     if len(_np.shape(spectra)) > 1:
+                        # Use flatten (rather than ravel) to ensure a copy is made.
                         powerlist = spectra[indices].flatten()
                     # If we're testing a single spectrum, we can just copy the 1D array.
-                    else: powerlist = spectra[indices].copy()
+                    else:
+                        powerlist = spectra[indices].copy()
 
                     # The indices that will go with the elements in the flattened spectra.
                     powerindices = [tup for tup in _itertools.product(*iterBenjHoch)]

pygsti/extras/interpygate/__init__.py

@@ -10,3 +10,15 @@
 
 from .core import PhysicalProcess, InterpolatedDenseOp, InterpolatedOpFactory
 from .process_tomography import vec, unvec, run_process_tomography
+
+# Note from Riley on September, 2024:
+#
+#   vec is deprecated, and shouldn't be called anywhere in the codebase.
+#
+#   unvec is deprecated and replaced with unvec_square; the latter function
+#   isn't imported here because we don't want people to access it just from
+#   the pygsti.extras.interpygate namespace.
+#
+#   Ideally we'd remove vec and unvec from the pygsti.extras.interpygate namespace
+#   and only have them available in pygsti.extras.interpygate.process_tomography.
+#

pygsti/extras/interpygate/core.py

@@ -241,15 +241,6 @@ class InterpolatedOpFactory(_OpFactory):
         return InterpolatedDenseOp(target_op, self.base_interpolator, self.aux_interpolator, self.to_vector(),
                                    _np.array(args), self._argument_indices)
 
-    #def write(self, dirname):
-    #    dirname = _pathlib.Path(dirname)
-    #    with open(str(dirname / "targetop.pkl"), 'wb') as f:
-    #        _pickle.dump(self.target_op, f)
-    #    _np.save(dirname / "paramvec.np", self._paramvec_with_time)
-    #    self.base_interpolator.write(dirname / "base.interp")
-    #    if self.aux_interpolator is not None:
-    #        self.aux_interptolator.write(dirname / "aux.interp")
-
     @property
     def num_params(self):
         return len(self._paramvec)
@@ -267,24 +258,6 @@ class InterpolatedOpFactory(_OpFactory):
 
 class InterpolatedDenseOp(_DenseOperator):
 
-    #@classmethod
-    #def from_dir(cls, dirname):
-    #    dirname = _pathlib.Path(dirname)
-    #    with open(str(dirname / "targetop.pkl"), 'rb') as f:
-    #        target_op = _pickle.load(f)
-    #    pt = _np.load(dirname / "paramvec.np")
-    #    base_interp = InterpolatedQuantity.from_file(dirname / "base.interp")
-    #    aux_interp = InterpolatedQuantity.from_file(dirname / "aux.interp") \
-    #        if (dirname / "aux.interp").exists() else None
-    #
-    #    if base_interp.times is not None:
-    #        tm = pt[-1]
-    #        pt = pt[0:-1]
-    #    else:
-    #        tm = None
-    #
-    #    return cls(target_op, base_interp, aux_interp, pt, tm)
-
     @classmethod
     def create_by_interpolating_physical_process(cls, target_op, physical_process, parameter_ranges=None,
                                                  parameter_points=None, comm=None,
@@ -391,15 +364,6 @@ class InterpolatedDenseOp(_DenseOperator):
         # initialize object
         self.from_vector(self._paramvec)
 
-    #def write(self, dirname):
-    #    dirname = _pathlib.Path(dirname)
-    #    with open(str(dirname / "targetop.pkl"), 'wb') as f:
-    #        _pickle.dump(self.target_op, f)
-    #    _np.save(dirname / "paramvec.np", self._paramvec_with_time)
-    #    self.base_interpolator.write(dirname / "base.interp")
-    #    if self.aux_interpolator is not None:
-    #        self.aux_interptolator.write(dirname / "aux.interp")
-
     @property
     def num_params(self):
         return len(self._paramvec)

pygsti/extras/interpygate/process_tomography.py

@@ -7,6 +7,7 @@ import numpy as _np
 import numpy.linalg as _lin
 
 from pygsti.tools.basistools import change_basis
+from pygsti.tools.legacytools import deprecate
 
 
 #Helper functions
@@ -15,8 +16,11 @@ def multi_kron(*a):
     return reduce(_np.kron, a)
 
 
+@deprecate("Calls to this function should be replaced with in-lined code: matrix.reshape((matrix.size, 1), 'F')")
 def vec(matrix):
-    """A function that vectorizes a matrix.
+    """
+    Returns an explicit column-vector representation of a square matrix, obtained by reading
+    from the square matrix in column-major order.
 
     Args:
         matrix (list,numpy.ndarray): NxN matrix
@@ -30,11 +34,12 @@ def vec(matrix):
     """
     matrix = _np.array(matrix)
     if matrix.shape == (len(matrix), len(matrix)):
-        return _np.array([_np.concatenate(_np.array(matrix).T)]).T
+        return matrix.reshape(shape=(matrix.size, 1), order='F')
     else:
         raise ValueError('The input matrix must be square.')
 
 
+@deprecate("Calls to this function should be replaced by unvec_square(vectorized, 'F')")
 def unvec(vectorized):
     """A function that vectorizes a process in the basis of matrix units, sorted first
     by column, then row.
@@ -49,13 +54,42 @@ def unvec(vectorized):
         ValueError: If the length of the input is not a perfect square
 
     """
-    vectorized = _np.array(vectorized)
-    length = int(_np.sqrt(max(vectorized.shape)))
-    if len(vectorized) == length ** 2:
-        return _np.reshape(vectorized, [length, length]).T
+    return unvec_square(vectorized, order='F')
+
+
+def unvec_square(vectorized, order):
+    """
+    Takes a vector whose length is a perfect square, and returns a square matrix
+    representation by reading from the vectors entries to define the matrix in 
+    column-major order (order='F') or row-major order (order='C').
+
+    Args:
+        vectorized: array-like, where np.array(vectorized).size is a perfect square.
+        order: 'F' or 'C'
+
+    Returns:
+        numpy.ndarray: NxN dimensional array
+
+    Raises:
+        ValueError: If the length of the input is not a perfect square.
+
+    """
+    assert order == 'F' or order == 'C'
+    if not isinstance(vectorized, _np.ndarray):
+        vectorized = _np.array(vectorized)
+
+    if vectorized.ndim == 2:
+        assert min(vectorized.shape) == 1
+        vectorized = vectorized.ravel()
+    elif vectorized.ndim > 2:
+        raise ValueError('vectorized.ndim must be <= 2.')
+
+    n = int(_np.sqrt(max(vectorized.shape)))
+    if len(vectorized) == n ** 2:
+        return vectorized.reshape((n, n), order=order)
     else:
-        raise ValueError(
-            'The input vector length must be a perfect square, but this input has length %d.' % len(vectorized))
+        msg = 'The input vector length must be a perfect square, but this input has length %d.' % len(vectorized)
+        raise ValueError(msg)
 
 
 def split(n, a):
@@ -129,7 +163,7 @@ def run_process_tomography(state_to_density_matrix_fn, n_qubits=1, comm=None,
     states = _itertools.product(one_qubit_states, repeat=n_qubits)
     states = [multi_kron(*state) for state in states]
     in_density_matrices = [_np.outer(state, state.conj()) for state in states]
-    in_states = _np.column_stack(list([vec(rho) for rho in in_density_matrices]))
+    in_states = _np.column_stack(list([rho.ravel(order='F') for rho in in_density_matrices]))
     my_states = split(size, states)[rank]
     if verbose:
         print("Process %d of %d evaluating %d input states." % (rank, size, len(my_states)))
@@ -150,7 +184,7 @@ def run_process_tomography(state_to_density_matrix_fn, n_qubits=1, comm=None,
         out_density_matrices = _np.array([y for x in gathered_out_density_matrices for y in x])
         # Sort the list by time
         out_density_matrices = _np.transpose(out_density_matrices, [1, 0, 2, 3])
-        out_states = [_np.column_stack(list([vec(rho) for rho in density_matrices_at_time]))
+        out_states = [_np.column_stack(list([rho.ravel(order='F') for rho in density_matrices_at_time]))
                       for density_matrices_at_time in out_density_matrices]
         process_matrices = [_np.dot(out_states_at_time, _lin.inv(in_states)) for out_states_at_time in out_states]
         process_matrices = [change_basis(process_matrix_at_time, 'col', basis)

pygsti/extras/rpe/rpeconstruction.py

@@ -113,8 +113,6 @@ def create_parameterized_rpe_model(alpha_true, epsilon_true, aux_rot, spam_depol
 
     return outputModel
 
-#def make_rpe_alpha_str_lists(k_list,angleStr,rpeconfig_inst):
-
 
 def create_rpe_angle_circuit_lists(k_list, angle_name, rpeconfig_inst):
     """

pygsti/forwardsims/__init__.py

@@ -12,6 +12,7 @@ pyGSTi Forward Simulators Python Package
 
 from .forwardsim import ForwardSimulator
 from .mapforwardsim import SimpleMapForwardSimulator, MapForwardSimulator
+from .torchfwdsim import TorchForwardSimulator
 from .matrixforwardsim import SimpleMatrixForwardSimulator, MatrixForwardSimulator
 from .termforwardsim import TermForwardSimulator
 from .weakforwardsim import WeakForwardSimulator

pygsti/forwardsims/forwardsim.py

@@ -9,7 +9,7 @@ Defines the ForwardSimulator calculator class
 # 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.
 #***************************************************************************************************
-
+from __future__ import annotations
 import collections as _collections
 import warnings as _warnings
 
@@ -21,6 +21,7 @@ from pygsti.baseobjs import outcomelabeldict as _ld
 from pygsti.baseobjs.resourceallocation import ResourceAllocation as _ResourceAllocation
 from pygsti.baseobjs.nicelyserializable import NicelySerializable as _NicelySerializable
 from pygsti.tools import slicetools as _slct
+from typing import Union, Callable, Literal
 
 
 class ForwardSimulator(_NicelySerializable):
@@ -44,22 +45,38 @@ class ForwardSimulator(_NicelySerializable):
         The model this forward simulator will use to compute circuit outcome probabilities.
     """
 
+    Castable = Union[
+        'ForwardSimulator',
+        Callable[[], 'ForwardSimulator'],
+        Literal['map'],
+        Literal['matrix'],
+        Literal['auto']
+    ]
+    # ^ Define a type alias we can reference elsewhere in our code.
+
     @classmethod
-    def cast(cls, obj, num_qubits=None):
+    def cast(cls, obj : ForwardSimulator.Castable, num_qubits=None):
         """ num_qubits only used if `obj == 'auto'` """
         from .matrixforwardsim import MatrixForwardSimulator as _MatrixFSim
         from .mapforwardsim import MapForwardSimulator as _MapFSim
 
         if isinstance(obj, ForwardSimulator):
             return obj
-        elif obj == "auto":
-            return _MapFSim() if (num_qubits is None or num_qubits > 2) else _MatrixFSim()
-        elif obj == "map":
-            return _MapFSim()
-        elif obj == "matrix":
-            return _MatrixFSim()
+        elif isinstance(obj, str):
+            if obj == "auto" or obj == "map":
+                return _MapFSim()
+            elif obj == "matrix":
+                return _MatrixFSim()
+            else:
+                raise ValueError(f'Unrecognized string argument, {obj}')
+        elif isinstance(obj, Callable):
+            out_obj = obj()
+            if isinstance(out_obj, ForwardSimulator):
+                return out_obj
+            else:
+                raise ValueError(f'Argument {obj} cannot be cast to a ForwardSimulator.')
         else:
-            raise ValueError("Cannot convert %s to a forward simulator!" % str(obj))
+            raise ValueError(f'Argument {obj} cannot be cast to a ForwardSimulator.')
 
     @classmethod
     def _array_types_for_method(cls, method_name):
@@ -128,57 +145,6 @@ class ForwardSimulator(_NicelySerializable):
             `evotype` will be `None` when the current model is None"""
         pass
 
-    #def to_vector(self):
-    #    """
-    #    Returns the parameter vector of the associated Model.
-    #
-    #    Returns
-    #    -------
-    #    numpy array
-    #        The vectorized model parameters.
-    #    """
-    #    return self.paramvec
-    #
-    #def from_vector(self, v, close=False, nodirty=False):
-    #    """
-    #    The inverse of to_vector.
-    #
-    #    Initializes the Model-like members of this
-    #    calculator based on `v`. Used for computing finite-difference derivatives.
-    #
-    #    Parameters
-    #    ----------
-    #    v : numpy.ndarray
-    #        The parameter vector.
-    #
-    #    close : bool, optional
-    #        Set to `True` if `v` is close to the current parameter vector.
-    #        This can make some operations more efficient.
-    #
-    #    nodirty : bool, optional
-    #        If True, the framework for marking and detecting when operations
-    #        have changed and a Model's parameter-vector needs to be updated
-    #        is disabled.  Disabling this will increases the speed of the call.
-    #
-    #    Returns
-    #    -------
-    #    None
-    #    """
-    #    #Note: this *will* initialize the parent Model's objects too,
-    #    # since only references to preps, effects, and gates are held
-    #    # by the calculator class.  ORDER is important, as elements of
-    #    # POVMs and Instruments rely on a fixed from_vector ordering
-    #    # of their simplified effects/gates.
-    #    self.paramvec = v.copy()  # now self.paramvec is *not* the same as the Model's paramvec
-    #    self.sos.from_vector(v, close, nodirty)  # so don't always want ", nodirty=True)" - we
-    #    # need to set dirty flags so *parent* will re-init it's paramvec...
-    #
-    #    #Re-init reps for computation
-    #    #self.operationreps = { i:self.operations[lbl].torep() for lbl,i in self.operation_lookup.items() }
-    #    #self.operationreps = { lbl:g.torep() for lbl,g in gates.items() }
-    #    #self.prepreps = { lbl:p.torep('prep') for lbl,p in preps.items() }
-    #    #self.effectreps = { lbl:e.torep('effect') for lbl,e in effects.items() }
-
     def _compute_circuit_outcome_probabilities(self, array_to_fill, circuit, outcomes, resource_alloc, time=None):
         raise NotImplementedError("Derived classes should implement this!")
 
@@ -304,7 +270,8 @@ class ForwardSimulator(_NicelySerializable):
     # ---------------------------------------------------------------------------
 
     def create_layout(self, circuits, dataset=None, resource_alloc=None,
-                      array_types=(), derivative_dimensions=None, verbosity=0):
+                      array_types=(), derivative_dimensions=None, verbosity=0,
+                      layout_creation_circuit_cache = None):
         """
         Constructs an circuit-outcome-probability-array (COPA) layout for `circuits` and `dataset`.
 
@@ -337,49 +304,39 @@ class ForwardSimulator(_NicelySerializable):
 
         derivative_dimensions : tuple, optional
             A tuple containing, optionally, the parameter-space dimension used when taking first
-            and second derivatives with respect to the cirucit outcome probabilities.  This must be
+            and second derivatives with respect to the cirucit outcome probabilities.  This should
             have minimally 1 or 2 elements when `array_types` contains `'ep'` or `'epp'` types,
-            respectively.
+            respectively. If `array_types` contains either of these strings and derivative_dimensions
+            is None on input then we automatically set derivative_dimensions based on self.model.
 
         verbosity : int or VerbosityPrinter
             Determines how much output to send to stdout.  0 means no output, higher
             integers mean more output.
+        
+        
 
         Returns
         -------
         CircuitOutcomeProbabilityArrayLayout
         """
+        if derivative_dimensions is None:
+            if 'epp' in array_types:
+                derivative_dimensions = (self.model.num_params, self.model.num_params)
+            elif 'ep' in array_types:
+                derivative_dimensions = (self.model.num_params,)
+            else:
+                derivative_dimensions = tuple()
         return _CircuitOutcomeProbabilityArrayLayout.create_from(circuits, self.model, dataset, derivative_dimensions,
                                                                  resource_alloc=resource_alloc)
-
-    #TODO UPDATE
-    #def bulk_prep_probs(self, eval_tree, comm=None, mem_limit=None):
-    #    """
-    #    Performs initial computation needed for bulk_fill_probs and related calls.
-    #
-    #    For example, as computing probability polynomials. This is usually coupled with
-    #    the creation of an evaluation tree, but is separated from it because this
-    #    "preparation" may use `comm` to distribute a computationally intensive task.
-    #
-    #    Parameters
-    #    ----------
-    #    eval_tree : EvalTree
-    #        The evaluation tree used to define a list of circuits and hold (cache)
-    #        any computed quantities.
-    #
-    #    comm : mpi4py.MPI.Comm, optional
-    #        When not None, an MPI communicator for distributing the computation
-    #        across multiple processors.  Distribution is performed over
-    #        subtrees of `eval_tree` (if it is split).
-    #
-    #    mem_limit : int
-    #        Rough memory limit in bytes.
-    #
-    #    Returns
-    #    -------
-    #    None
-    #    """
-    #    pass  # default is to have no pre-computed quantities (but not an error to call this fn)
+    
+    @staticmethod
+    def create_copa_layout_circuit_cache(circuits, model, dataset=None):
+        """
+        Helper function for pre-computing/pre-processing circuits structures
+        used in matrix layout creation.
+        """
+        msg = "Not currently implemented for this forward simulator class."
+        raise NotImplementedError(msg)
 
     def bulk_probs(self, circuits, clip_to=None, resource_alloc=None, smartc=None):
         """
@@ -642,7 +599,7 @@ class ForwardSimulator(_NicelySerializable):
                 iFinal = iParamToFinal[i]
                 vec = orig_vec.copy(); vec[i] += eps
                 self.model.from_vector(vec, close=True)
-                self._bulk_fill_probs_block(probs2, layout, resource_alloc)
+                self._bulk_fill_probs_block(probs2, layout)
                 array_to_fill[:, iFinal] = (probs2 - probs) / eps
         self.model.from_vector(orig_vec, close=True)