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

pygsti/forwardsims/mapforwardsim_calc_generic.py

@@ -51,7 +51,6 @@ def mapfill_probs_atom(fwdsim, mx_to_fill, dest_indices, layout_atom, resource_a
 
     #TODO: if layout_atom is split, distribute somehow among processors(?) instead of punting for all but rank-0 above
     for iDest, iStart, remainder, iCache in layout_atom.table.contents:
-        remainder = remainder.circuit_without_povm.layertup
 
         if iStart is None:  # then first element of remainder is a state prep label
             rholabel = remainder[0]
@@ -73,7 +72,63 @@ def mapfill_probs_atom(fwdsim, mx_to_fill, dest_indices, layout_atom, resource_a
                 mx_to_fill[final_indices] = povmreps[povm_lbl].probabilities(final_state, None, effect_labels)
         else:
             ereps = [effectreps[j] for j in layout_atom.elbl_indices_by_expcircuit[iDest]]
+            #print(ereps)
+            if shared_mem_leader:
+                for j, erep in zip(final_indices, ereps):
+                    mx_to_fill[j] = erep.probability(final_state)  # outcome probability
+    #raise Exception
+#Version of the probability calculation that updates circuit probabilities conditionally based on
+#Whether the circuit is sensitive to the parameter. If not we leave that circuit alone.
+def cond_update_probs_atom(fwdsim, mx_to_fill, dest_indices, layout_atom, param_index, resource_alloc):
+
+    # The required ending condition is that array_to_fill on each processor has been filled.  But if
+    # memory is being shared and resource_alloc contains multiple processors on a single host, we only
+    # want *one* (the rank=0) processor to perform the computation, since array_to_fill will be
+    # shared memory that we don't want to have muliple procs using simultaneously to compute the
+    # same thing.  Thus, we carefully guard any shared mem updates/usage
+    # using "if shared_mem_leader" (and barriers, if needed) below.
+    shared_mem_leader = resource_alloc.is_host_leader if (resource_alloc is not None) else True
+
+    dest_indices = _slct.to_array(dest_indices)  # make sure this is an array and not a slice
+    cacheSize = layout_atom.jac_table.cache_size_by_parameter[param_index]
+
+    #Create rhoCache
+    rho_cache = [None] * cacheSize  # so we can store (s,p) tuples in cache
+
+    #Get operationreps and ereps now so we don't make unnecessary ._rep references
+    rhoreps = {rholbl: fwdsim.model._circuit_layer_operator(rholbl, 'prep')._rep for rholbl in layout_atom.rho_labels}
+    operationreps = {gl: fwdsim.model._circuit_layer_operator(gl, 'op')._rep for gl in layout_atom.op_labels}
+    povmreps = {plbl: fwdsim.model._circuit_layer_operator(plbl, 'povm')._rep for plbl in layout_atom.povm_labels}
+    if any([(povmrep is None) for povmrep in povmreps.values()]):
+        effectreps = {i: fwdsim.model._circuit_layer_operator(Elbl, 'povm')._rep
+                      for i, Elbl in enumerate(layout_atom.full_effect_labels)}  # cache these in future
+    else:
+        effectreps = None  # not needed, as we use povm reps directly
+
+
+    #TODO: if layout_atom is split, distribute somehow among processors(?) instead of punting for all but rank-0 above
+
+    for iDest, iStart, remainder, iCache in layout_atom.jac_table.contents_by_parameter[param_index]:
+ 
+        if iStart is None:  # then first element of remainder is a state prep label
+            rholabel = remainder[0]
+            init_state = rhoreps[rholabel]
+            remainder = remainder[1:]
+        else:
+            init_state = rho_cache[iStart]  # [:,None]
+
+        final_state = propagate_staterep(init_state, [operationreps[gl] for gl in remainder])
+        if iCache is not None: rho_cache[iCache] = final_state  # [:,0] #store this state in the cache
+
+        final_indices = [dest_indices[j] for j in layout_atom.elindices_by_expcircuit[iDest]]
+
+        if effectreps is None:
+            povm_lbl, *effect_labels = layout_atom.povm_and_elbls_by_expcircuit[iDest]
 
+            if shared_mem_leader:
+                mx_to_fill[final_indices] = povmreps[povm_lbl].probabilities(final_state, None, effect_labels)
+        else:
+            ereps = [effectreps[j] for j in layout_atom.elbl_indices_by_expcircuit[iDest]]
             if shared_mem_leader:
                 for j, erep in zip(final_indices, ereps):
                     mx_to_fill[j] = erep.probability(final_state)  # outcome probability
@@ -82,11 +137,10 @@ def mapfill_probs_atom(fwdsim, mx_to_fill, dest_indices, layout_atom, resource_a
 def mapfill_dprobs_atom(fwdsim, mx_to_fill, dest_indices, dest_param_indices, layout_atom, param_indices,
                         resource_alloc, eps):
 
-    #eps = 1e-7
-    #shared_mem_leader = resource_alloc.is_host_leader if (resource_alloc is not None) else True
+    num_params = fwdsim.model.num_params
 
     if param_indices is None:
-        param_indices = list(range(fwdsim.model.num_params))
+        param_indices = list(range(num_params))
     if dest_param_indices is None:
         dest_param_indices = list(range(_slct.length(param_indices)))
 
@@ -105,19 +159,43 @@ def mapfill_dprobs_atom(fwdsim, mx_to_fill, dest_indices, dest_param_indices, la
     nEls = layout_atom.num_elements
     probs, shm = _smt.create_shared_ndarray(resource_alloc, (nEls,), 'd', memory_tracker=None)
     probs2, shm2 = _smt.create_shared_ndarray(resource_alloc, (nEls,), 'd', memory_tracker=None)
+    #probs2_test, shm2_test = _smt.create_shared_ndarray(resource_alloc, (nEls,), 'd', memory_tracker=None)
+    
+    #mx_to_fill_test = mx_to_fill.copy()
+
     mapfill_probs_atom(fwdsim, probs, slice(0, nEls), layout_atom, resource_alloc)  # probs != shared
 
-    for i in range(fwdsim.model.num_params):
-        #print("dprobs cache %d of %d" % (i,self.Np))
-        if i in iParamToFinal:
-            iFinal = iParamToFinal[i]
-            vec = orig_vec.copy(); vec[i] += eps
-            fwdsim.model.from_vector(vec, close=True)
-            mapfill_probs_atom(fwdsim, probs2, slice(0, nEls), layout_atom, resource_alloc)
-            _fas(mx_to_fill, [dest_indices, iFinal], (probs2 - probs) / eps)
-    fwdsim.model.from_vector(orig_vec, close=True)
+    #Split off the first finite difference step, as the pattern I want in the loop with each step
+    #is to simultaneously undo the previous update and apply the new one.
+    if len(param_indices)>0:
+        probs2[:] = probs[:]
+        first_param_idx = param_indices[0]
+        iFinal = iParamToFinal[first_param_idx]
+        fwdsim.model.set_parameter_value(first_param_idx, orig_vec[first_param_idx]+eps)
+        #mapfill_probs_atom(fwdsim, probs2, slice(0, nEls), layout_atom, resource_alloc)
+        cond_update_probs_atom(fwdsim, probs2, slice(0, nEls), layout_atom, first_param_idx, resource_alloc)
+        #assert _np.linalg.norm(probs2_test-probs2) < 1e-10
+        #print(f'{_np.linalg.norm(probs2_test-probs2)=}')
+        _fas(mx_to_fill, [dest_indices, iFinal], (probs2 - probs) / eps)
+
+
+    for i in range(1, len(param_indices)):
+        probs2[:] = probs[:]
+        iFinal = iParamToFinal[param_indices[i]]
+        fwdsim.model.set_parameter_values([param_indices[i-1], param_indices[i]], 
+                                          [orig_vec[param_indices[i-1]], orig_vec[param_indices[i]]+eps])
+        #mapfill_probs_atom(fwdsim, probs2, slice(0, nEls), layout_atom, resource_alloc)
+        cond_update_probs_atom(fwdsim, probs2, slice(0, nEls), layout_atom, param_indices[i], resource_alloc)
+        #assert _np.linalg.norm(probs2_test-probs2) < 1e-10
+        #print(f'{_np.linalg.norm(probs2_test-probs2)=}')
+        _fas(mx_to_fill, [dest_indices, iFinal], (probs2 - probs) / eps)
+
+    #reset the final model parameter we changed to it's original value.
+    fwdsim.model.set_parameter_value(param_indices[-1], orig_vec[param_indices[-1]])
+
     _smt.cleanup_shared_ndarray(shm)
     _smt.cleanup_shared_ndarray(shm2)
+    #_smt.cleanup_shared_ndarray(shm2_test)
 
 
 def mapfill_TDchi2_terms(fwdsim, array_to_fill, dest_indices, num_outcomes, layout_atom, dataset_rows,

pygsti/forwardsims/matrixforwardsim.py

@@ -29,6 +29,8 @@ from pygsti.tools import mpitools as _mpit
 from pygsti.tools import sharedmemtools as _smt
 from pygsti.tools import slicetools as _slct
 from pygsti.tools.matrixtools import _fas
+from pygsti.tools import listtools as _lt
+from pygsti.circuits import CircuitList as _CircuitList
 
 _dummy_profiler = _DummyProfiler()
 
@@ -132,12 +134,18 @@ class SimpleMatrixForwardSimulator(_ForwardSimulator):
             obj_wrtFilter = []  # values = object-local param indices
             relevant_gpindices = []  # indices into original wrt_filter'd indices
 
-            gpindices = obj.gpindices_as_array()
+            if isinstance(obj.gpindices, slice):
+                gpindices_list = _slct.indices(obj.gpindices)
+            elif obj.gpindices is None:
+                gpindices_list = []
+            else:
+                gpindices_list = list(obj.gpindices)
+            gpindices_set = set(gpindices_list)
 
             for ii, i in enumerate(wrt_filter):
-                if i in gpindices:
+                if i in gpindices_set:
                     relevant_gpindices.append(ii)
-                    obj_wrtFilter.append(list(gpindices).index(i))
+                    obj_wrtFilter.append(gpindices_list.index(i))
             relevant_gpindices = _np.array(relevant_gpindices, _np.int64)
             if len(relevant_gpindices) == 1:
                 #Don't return a length-1 list, as this doesn't index numpy arrays
@@ -590,7 +598,7 @@ class SimpleMatrixForwardSimulator(_ForwardSimulator):
         use_scaling = False  # Hardcoded for now
         assert(time is None), "MatrixForwardSimulator cannot be used to simulate time-dependent circuits"
 
-        expanded_circuit_outcomes = circuit.expand_instruments_and_separate_povm(self.model, outcomes)
+        expanded_circuit_outcomes = self.model.expand_instruments_and_separate_povm(circuit, outcomes)
         outcome_to_index = {outc: i for i, outc in enumerate(outcomes)}
         for spc, spc_outcomes in expanded_circuit_outcomes.items():  # spc is a SeparatePOVMCircuit
             indices = [outcome_to_index[o] for o in spc_outcomes]
@@ -1025,7 +1033,7 @@ class MatrixForwardSimulator(_DistributableForwardSimulator, SimpleMatrixForward
         return hProdCache
 
     def create_layout(self, circuits, dataset=None, resource_alloc=None, array_types=('E',),
-                      derivative_dimensions=None, verbosity=0):
+                      derivative_dimensions=None, verbosity=0, layout_creation_circuit_cache= None):
         """
         Constructs an circuit-outcome-probability-array (COPA) layout for a list of circuits.
 
@@ -1056,6 +1064,12 @@ class MatrixForwardSimulator(_DistributableForwardSimulator, SimpleMatrixForward
             Determines how much output to send to stdout.  0 means no output, higher
             integers mean more output.
 
+        layout_creation_circuit_cache : dict, optional (default None)
+            A precomputed dictionary serving as a cache for completed
+            circuits. I.e. circuits with prep labels and POVM labels appended.
+            Along with other useful pre-computed circuit structures used in layout
+            creation.
+            
         Returns
         -------
         MatrixCOPALayout
@@ -1105,7 +1119,8 @@ class MatrixForwardSimulator(_DistributableForwardSimulator, SimpleMatrixForward
         assert(_np.prod((na,) + npp) <= nprocs), "Processor grid size exceeds available processors!"
 
         layout = _MatrixCOPALayout(circuits, self.model, dataset, natoms,
-                                   na, npp, param_dimensions, param_blk_sizes, resource_alloc, verbosity)
+                                   na, npp, param_dimensions, param_blk_sizes, resource_alloc, verbosity, 
+                                   layout_creation_circuit_cache=layout_creation_circuit_cache)
 
         if mem_limit is not None:
             loc_nparams1 = num_params / npp[0] if len(npp) > 0 else 0
@@ -1132,13 +1147,6 @@ class MatrixForwardSimulator(_DistributableForwardSimulator, SimpleMatrixForward
                                                   (blk1, blk2), max_atom_cachesize,
                                                   self.model.evotype.minimal_dim(self.model.state_space))
 
-            #def approx_mem_estimate(natoms, np1, np2):
-            #    approx_cachesize = (num_circuits / natoms) * 1.3  # inflate expected # circuits per atom => cache_size
-            #    return _bytes_for_array_types(array_types, num_elements, num_elements / natoms,
-            #                                  num_circuits, num_circuits / natoms,
-            #                                  (num_params, num_params), (num_params / np1, num_params / np2),
-            #                                  approx_cachesize, self.model.state_space.dim)
-
             GB = 1.0 / 1024.0**3
             if mem_estimate > mem_limit:
                 raise MemoryError("Not enough memory for desired layout! (limit=%.1fGB, required=%.1fGB)" % (
@@ -1147,6 +1155,46 @@ class MatrixForwardSimulator(_DistributableForwardSimulator, SimpleMatrixForward
                 printer.log("   Esimated memory required = %.1fGB" % (mem_estimate * GB))
 
         return layout
+    
+    @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.
+        """
+        cache = dict()
+        completed_circuits, split_circuits = model.complete_circuits(circuits, return_split=True)
+
+        cache['completed_circuits'] = {ckt: comp_ckt for ckt, comp_ckt in zip(circuits, completed_circuits)}
+        cache['split_circuits'] = {ckt: split_ckt for ckt, split_ckt in zip(circuits, split_circuits)}
+
+        if dataset is not None:
+            aliases = circuits.op_label_aliases if isinstance(circuits, _CircuitList) else None
+            ds_circuits = _lt.apply_aliases_to_circuits(circuits, aliases)
+            unique_outcomes_list = []
+            for ckt in ds_circuits:
+                ds_row = dataset[ckt]
+                unique_outcomes_list.append(ds_row.unique_outcomes if ds_row is not None else None)
+        else:
+            unique_outcomes_list = [None]*len(circuits)
+
+        expanded_circuit_outcome_list = model.bulk_expand_instruments_and_separate_povm(circuits, 
+                                                                                        observed_outcomes_list = unique_outcomes_list, 
+                                                                                        split_circuits = split_circuits)
+        
+        expanded_circuit_cache = {ckt: expanded_ckt for ckt,expanded_ckt in zip(circuits, expanded_circuit_outcome_list)}
+                    
+        cache['expanded_and_separated_circuits'] = expanded_circuit_cache
+
+        expanded_subcircuits_no_spam_cache = dict()
+        for expc_outcomes in cache['expanded_and_separated_circuits'].values():
+            for sep_povm_c, _ in expc_outcomes.items():  # for each expanded cir from unique_i-th circuit
+                exp_nospam_c = sep_povm_c.circuit_without_povm[1:] 
+                expanded_subcircuits_no_spam_cache[exp_nospam_c] = exp_nospam_c.expand_subcircuits()
+
+        cache['expanded_subcircuits_no_spam'] = expanded_subcircuits_no_spam_cache
+
+        return cache
 
     def _scale_exp(self, scale_exps):
         old_err = _np.seterr(over='ignore')
@@ -1194,7 +1242,8 @@ class MatrixForwardSimulator(_DistributableForwardSimulator, SimpleMatrixForward
         # dp_dOps[i,j] = dot( e, dot( d_gs, rho ) )[0,i,j,0]
         # dp_dOps      = squeeze( dot( e, dot( d_gs, rho ) ), axis=(0,3))
         old_err2 = _np.seterr(invalid='ignore', over='ignore')
-        dp_dOps = _np.squeeze(_np.dot(e, _np.dot(d_gs, rho)), axis=(0, 3)) * scale_vals[:, None]
+        path = _np.einsum_path('hk,ijkl,lm->ij', e, d_gs, rho, optimize='optimal')
+        dp_dOps = _np.einsum('hk,ijkl,lm->ij', e, d_gs, rho, optimize=path[0]) * scale_vals[:, None]
         _np.seterr(**old_err2)
         # may overflow, but OK ; shape == (len(circuit_list), nDerivCols)
         # may also give invalid value due to scale_vals being inf and dot-prod being 0. In
@@ -1234,7 +1283,6 @@ class MatrixForwardSimulator(_DistributableForwardSimulator, SimpleMatrixForward
             # dp_drhos[i,J0+J] = sum_kl e[0,k] gs[i,k,l] drhoP[l,J]
             # dp_drhos[i,J0+J] = dot(e, gs, drhoP)[0,i,J]
             # dp_drhos[:,J0+J] = squeeze(dot(e, gs, drhoP),axis=(0,))[:,J]
-
             dp_drhos = _np.zeros((nCircuits, nOpDerivCols))
             _fas(dp_drhos, [None, rho_gpindices],
                  _np.squeeze(_np.dot(_np.dot(e, gs),

pygsti/forwardsims/termforwardsim.py

@@ -243,16 +243,6 @@ class TermForwardSimulator(_DistributableForwardSimulator):
         # and this is done by the parent model which will cause _set_evotype to be called.
         return state
 
-    #OLD - now we have a _set_evotype method.
-    #@_ForwardSimulator.model.setter
-    #def model(self, val):
-    #    _ForwardSimulator.model.fset(self, val)  # set the base class property (self.model)
-    #
-    #    #Do some additional initialization
-    #    if self.model.evotype not in ("svterm", "cterm"):
-    #        #raise ValueError(f"Evolution type {self.model.evotype} is incompatible with term-based calculations")
-    #        _warnings.warn("Evolution type %s is incompatible with term-based calculations" % self.model.evotype)
-
     def copy(self):
         """
         Return a shallow copy of this TermForwardSimulator.
@@ -267,7 +257,7 @@ class TermForwardSimulator(_DistributableForwardSimulator):
                                     self.oob_check_interval, self.cache)
 
     def create_layout(self, circuits, dataset=None, resource_alloc=None, array_types=('E',),
-                      derivative_dimension=None, verbosity=0):
+                      derivative_dimension=None, verbosity=0, layout_creation_circuit_cache=None):
         """
         Constructs an circuit-outcome-probability-array (COPA) layout for a list of circuits.
 
@@ -296,6 +286,12 @@ class TermForwardSimulator(_DistributableForwardSimulator):
         verbosity : int or VerbosityPrinter
             Determines how much output to send to stdout.  0 means no output, higher
             integers mean more output.
+        
+        layout_creation_circuit_cache:
+            A precomputed dictionary serving as a cache for completed
+            circuits. I.e. circuits with prep labels and POVM labels appended.
+            Along with other useful pre-computed circuit structures used in layout
+            creation.
 
         Returns
         -------
@@ -330,6 +326,7 @@ class TermForwardSimulator(_DistributableForwardSimulator):
         printer.log("   %d atoms, parameter block size limits %s" % (natoms, str(param_blk_sizes)))
         assert(_np.prod((na,) + npp) <= nprocs), "Processor grid size exceeds available processors!"
 
+        # TODO: Layout circuit creation cache unused for TermCOPALayout
         layout = _TermCOPALayout(circuits, self.model, dataset, natoms, na, npp, param_dimensions,
                                  param_blk_sizes, resource_alloc, printer)
         #MEM debug_prof.print_memory("CreateLayout2 - nAtoms = %d" % len(layout.atoms), True)
@@ -409,105 +406,6 @@ class TermForwardSimulator(_DistributableForwardSimulator):
                 hpolys[0], hpolys[1], self.model.to_vector(), (nEls, len(wrtInds1), len(wrtInds2)))
         _fas(array_to_fill, [slice(0, array_to_fill.shape[0]), dest_param_slice1, dest_param_slice2], hprobs)
 
-    #DIRECT FNS - keep these around, but they need to be updated (as do routines in fastreplib.pyx)
-    #def _prs_directly(self, layout_atom, resource_alloc): #comm=None, mem_limit=None, reset_wts=True, repcache=None):
-    #    """
-    #    Compute probabilities of `layout`'s circuits using "direct" mode.
-    #
-    #    Parameters
-    #    ----------
-    #    layout : CircuitOutcomeProbabilityArrayLayout
-    #        The layout.
-    #
-    #    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, optional
-    #        A rough memory limit in bytes.
-    #
-    #    reset_wts : bool, optional
-    #        Whether term magnitudes should be updated based on current term coefficients
-    #        (which are based on the current point in model-parameter space) or not.
-    #
-    #    repcache : dict, optional
-    #        A cache of term representations for increased performance.
-    #    """
-    #    prs = _np.empty(layout_atom.num_elements, 'd')
-    #    #print("Computing prs directly for %d circuits" % len(circuit_list))
-    #    if repcache is None: repcache = {}  # new repcache...
-    #    k = 0   # *linear* evaluation order so we know final indices are just running
-    #    for i in eval_tree.evaluation_order():
-    #        circuit = eval_tree[i]
-    #        #print("Computing prs directly: circuit %d of %d" % (i,len(circuit_list)))
-    #        assert(self.evotype == "svterm")  # for now, just do SV case
-    #        fastmode = False  # start with slow mode
-    #        wtTol = 0.1
-    #        rholabel = circuit[0]
-    #        opStr = circuit[1:]
-    #        elabels = eval_tree.simplified_circuit_elabels[i]
-    #        prs[k:k + len(elabels)] = replib.SV_prs_directly(self, rholabel, elabels, opStr,
-    #                                                         repcache, comm, mem_limit, fastmode, wtTol, reset_wts,
-    #                                                         self.times_debug)
-    #        k += len(elabels)
-    #    #print("PRS = ",prs)
-    #    return prs
-    #
-    #def _dprs_directly(self, eval_tree, wrt_slice, comm=None, mem_limit=None, reset_wts=True, repcache=None):
-    #    """
-    #    Compute probability derivatives of `eval_tree`'s circuits using "direct" mode.
-    #
-    #    Parameters
-    #    ----------
-    #    eval_tree : TermEvalTree
-    #        The evaluation tree.
-    #
-    #    wrt_slice : slice
-    #        A slice specifying which model parameters to differentiate with respect to.
-    #
-    #    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, optional
-    #        A rough memory limit in bytes.
-    #
-    #    reset_wts : bool, optional
-    #        Whether term magnitudes should be updated based on current term coefficients
-    #        (which are based on the current point in model-parameter space) or not.
-    #
-    #    repcache : dict, optional
-    #        A cache of term representations for increased performance.
-    #    """
-    #    #Note: Finite difference derivatives are SLOW!
-    #    if wrt_slice is None:
-    #        wrt_indices = list(range(self.Np))
-    #    elif isinstance(wrt_slice, slice):
-    #        wrt_indices = _slct.indices(wrt_slice)
-    #    else:
-    #        wrt_indices = wrt_slice
-    #
-    #    eps = 1e-6  # HARDCODED
-    #    probs = self._prs_directly(eval_tree, comm, mem_limit, reset_wts, repcache)
-    #    dprobs = _np.empty((eval_tree.num_final_elements(), len(wrt_indices)), 'd')
-    #    orig_vec = self.to_vector().copy()
-    #    iParamToFinal = {i: ii for ii, i in enumerate(wrt_indices)}
-    #    for i in range(self.Np):
-    #        #print("direct dprobs cache %d of %d" % (i,self.Np))
-    #        if i in iParamToFinal:  # LATER: add MPI support?
-    #            iFinal = iParamToFinal[i]
-    #            vec = orig_vec.copy(); vec[i] += eps
-    #            self.from_vector(vec, close=True)
-    #            dprobs[:, iFinal] = (self._prs_directly(eval_tree,
-    #                                                   comm=None,
-    #                                                   mem_limit=None,
-    #                                                   reset_wts=False,
-    #                                                   repcache=repcache) - probs) / eps
-    #    self.from_vector(orig_vec, close=True)
-    #    return dprobs
-
     ## ----- Find a "minimal" path set (i.e. find thresholds for each circuit -----
     def _compute_pruned_pathmag_threshold(self, rholabel, elabels, circuit, polynomial_vindices_per_int,
                                           repcache, circuitsetup_cache,