pyGSTi 0.9.12.1__cp310-cp310-win32.whl → 0.9.13__cp310-cp310-win32.whl

pygsti/models/modelconstruction.py

@@ -99,7 +99,7 @@ def create_spam_vector(vec_expr, state_space, basis):
     std_basis = basis.create_equivalent('std')
     vecInSimpleStdBasis = _np.zeros(std_basis.elshape, 'd')  # a matrix, but flattened it is our spamvec
     vecInSimpleStdBasis[index, index] = 1.0  # now a matrix with just a single 1 on the diag
-    vecInReducedStdBasis = _np.dot(std_basis.from_elementstd_transform_matrix, vecInSimpleStdBasis.flatten())
+    vecInReducedStdBasis = std_basis.from_elementstd_transform_matrix @ vecInSimpleStdBasis.ravel()
     # translates the density matrix / state vector to the std basis with our desired block structure
 
     vec = _bt.change_basis(vecInReducedStdBasis, std_basis, basis)
@@ -752,7 +752,7 @@ def _create_explicit_model(processor_spec, modelnoise, custom_gates=None, evotyp
     state_space = _statespace.QubitSpace(qudit_labels) if all([udim == 2 for udim in processor_spec.qudit_udims]) \
         else _statespace.QuditSpace(qudit_labels, processor_spec.qudit_udims)
     std_gate_unitaries = _itgs.standard_gatename_unitaries()
-    evotype = _Evotype.cast(evotype)
+    evotype = _Evotype.cast(evotype, state_space=state_space)
     modelnoise = _OpModelNoise.cast(modelnoise)
     modelnoise.reset_access_counters()
 
@@ -1676,7 +1676,7 @@ def _create_crosstalk_free_model(processor_spec, modelnoise, custom_gates=None,
     qudit_labels = processor_spec.qudit_labels
     state_space = _statespace.QubitSpace(qudit_labels) if all([udim == 2 for udim in processor_spec.qudit_udims]) \
         else _statespace.QuditSpace(qudit_labels, processor_spec.qudit_udims)
-    evotype = _Evotype.cast(evotype)
+    evotype = _Evotype.cast(evotype, state_space=state_space)
     modelnoise = _OpModelNoise.cast(modelnoise)
     modelnoise.reset_access_counters()
 
@@ -1867,7 +1867,7 @@ def _create_cloud_crosstalk_model(processor_spec, modelnoise, custom_gates=None,
     qudit_labels = processor_spec.qudit_labels
     state_space = _statespace.QubitSpace(qudit_labels) if all([udim == 2 for udim in processor_spec.qudit_udims]) \
         else _statespace.QuditSpace(qudit_labels, processor_spec.qudit_udims)  # FUTURE: allow more types of spaces
-    evotype = _Evotype.cast(evotype)
+    evotype = _Evotype.cast(evotype, state_space=state_space)
     modelnoise = _OpModelNoise.cast(modelnoise)
     modelnoise.reset_access_counters()
     printer = _VerbosityPrinter.create_printer(verbosity)

pygsti/models/modelnoise.py

@@ -799,7 +799,7 @@ class DepolarizationNoise(OpNoise):
 
         # LindbladErrorgen with "depol" or "diagonal" param
         basis_size = state_space.dim  # e.g. 4 for a single qubit
-        basis = _BuiltinBasis('pp', basis_size)
+        basis = _BuiltinBasis('PP', basis_size)
         rate_per_pauli = self.depolarization_rate / (basis_size - 1)
         errdict = {('S', bl): rate_per_pauli for bl in basis.labels[1:]}
         return _op.LindbladErrorgen.from_elementary_errorgens(
@@ -896,7 +896,7 @@ class StochasticNoise(OpNoise):
             raise ValueError("Stochastic noise parameterization must be one of %s" % str(allowed_values))
 
         basis_size = state_space.dim  # e.g. 4 for a single qubit
-        basis = _BuiltinBasis('pp', basis_size)
+        basis = _BuiltinBasis('PP', basis_size)
         errdict = {('S', bl): rate for bl, rate in zip(basis.labels[1:], sto_rates)}
         return _op.LindbladErrorgen.from_elementary_errorgens(
             errdict, "S", basis, mx_basis='pp',

pygsti/models/modelparaminterposer.py

@@ -77,7 +77,7 @@ class LinearInterposer(ModelParamsInterposer):
         # This can and should be improved later - particularly this will be awful when labels (els of wl) are tuples.
         ret = []
         for irow in range(self.inv_transform_matrix.shape[0]):
-            lbl = ' + '.join(["%g%s" % (coeff, str(lbl)) for coeff, lbl in zip(self.inv_transform_matrix[irow, :], wl)])
+            lbl = ' + '.join(["%g%s" % (coeff, str(lbl)) for coeff, lbl in zip(self.inv_transform_matrix[irow, :], wl) if abs(coeff)>1e-10])
             ret.append(lbl)
         return ret
 

pygsti/models/oplessmodel.py

@@ -405,7 +405,7 @@ class ErrorRatesModel(SuccessFailModel):
                 return [g_inds[self._alias_dict.get(_Label(lbl.name, lbl.sslbls), _Label(lbl.name, lbl.sslbls))]]
             else:
                 indices = []
-                assert(not lbl.is_simple()), "Cannot find error rate for label: %s" % str(lbl)
+                assert(not lbl.is_simple), "Cannot find error rate for label: %s" % str(lbl)
                 for component in lbl:
                     indices.extend(indices_for_label(component))
                 return indices

pygsti/models/qutrit.py

@@ -14,9 +14,10 @@ import numpy as _np
 from scipy import linalg as _linalg
 
 from pygsti.baseobjs import Basis as _Basis, statespace as _statespace
-from pygsti.models.gaugegroup import FullGaugeGroup as _FullGaugeGroup
-from pygsti.modelmembers.operations import FullArbitraryOp as _FullArbitraryOp
-from pygsti.modelmembers.povms import UnconstrainedPOVM as _UnconstrainedPOVM
+from pygsti.models.gaugegroup import TPGaugeGroup as _TPGaugeGroup
+from pygsti.modelmembers.operations import FullTPOp as _FullTPOp
+from pygsti.modelmembers.povms import TPPOVM as _TPPOVM
+from pygsti.modelmembers.states import TPState as _TPState
 from pygsti.models import ExplicitOpModel as _ExplicitOpModel
 from pygsti.tools import unitary_to_superop, change_basis
 
@@ -32,7 +33,7 @@ Y = _np.array([[0, -1j], [1j, 0]])
 
 
 def _x_2qubit(theta):
-    """
+    r"""
     Returns X(theta)^\otimes 2 (2-qubit 'XX' unitary)
 
     Parameters
@@ -49,7 +50,7 @@ def _x_2qubit(theta):
 
 
 def _y_2qubit(theta):
-    """
+    r"""
     Returns Y(theta)^\otimes 2 (2-qubit 'YY' unitary)
 
     Parameters
@@ -282,14 +283,14 @@ def create_qutrit_model(error_scale, x_angle=_np.pi / 2, y_angle=_np.pi / 2,
 
     state_space = _statespace.ExplicitStateSpace(['QT'], [3])
     qutritMDL = _ExplicitOpModel(state_space, _Basis.cast(basis, 9), evotype=evotype)
-    qutritMDL.preps['rho0'] = rho0final
-    qutritMDL.povms['Mdefault'] = _UnconstrainedPOVM([('0bright', E0final),
-                                                      ('1bright', E1final),
-                                                      ('2bright', E2final)], evotype=evotype)
-    qutritMDL.operations['Gi'] = _FullArbitraryOp(arrType(gateISOfinal), basis, evotype, state_space)
-    qutritMDL.operations['Gx'] = _FullArbitraryOp(arrType(gateXSOfinal), basis, evotype, state_space)
-    qutritMDL.operations['Gy'] = _FullArbitraryOp(arrType(gateYSOfinal), basis, evotype, state_space)
-    qutritMDL.operations['Gm'] = _FullArbitraryOp(arrType(gateMSOfinal), basis, evotype, state_space)
-    qutritMDL.default_gauge_group = _FullGaugeGroup(state_space, qutritMDL.basis, evotype)
+    qutritMDL.preps['rho0'] = _TPState(rho0final, evotype=evotype)
+    qutritMDL.povms['Mdefault'] = _TPPOVM([('0bright', E0final),
+                                           ('1bright', E1final),
+                                           ('2bright', E2final)], evotype=evotype)
+    qutritMDL.operations['Gi', 'QT'] = _FullTPOp(arrType(gateISOfinal), basis, evotype, state_space)
+    qutritMDL.operations['Gx', 'QT'] = _FullTPOp(arrType(gateXSOfinal), basis, evotype, state_space)
+    qutritMDL.operations['Gy', 'QT'] = _FullTPOp(arrType(gateYSOfinal), basis, evotype, state_space)
+    qutritMDL.operations['Gm', 'QT'] = _FullTPOp(arrType(gateMSOfinal), basis, evotype, state_space)
+    qutritMDL.default_gauge_group = _TPGaugeGroup(state_space, qutritMDL.basis, evotype)
 
     return qutritMDL

pygsti/objectivefns/objectivefns.py

@@ -19,11 +19,13 @@ import numpy as _np
 
 from pygsti import tools as _tools
 from pygsti.layouts.distlayout import DistributableCOPALayout as _DistributableCOPALayout
+from pygsti.layouts.matrixlayout import MatrixCOPALayout as _MatrixCOPALayout
 from pygsti.tools import slicetools as _slct, mpitools as _mpit, sharedmemtools as _smt
 from pygsti.circuits.circuitlist import CircuitList as _CircuitList
 from pygsti.baseobjs.resourceallocation import ResourceAllocation as _ResourceAllocation
 from pygsti.baseobjs.nicelyserializable import NicelySerializable as _NicelySerializable
 from pygsti.baseobjs.verbosityprinter import VerbosityPrinter as _VerbosityPrinter
+from pygsti.models.model import OpModel as _OpModel
 
 
 def _objfn(objfn_cls, model, dataset, circuits=None,
@@ -110,9 +112,6 @@ def _objfn(objfn_cls, model, dataset, circuits=None,
 
     return ofn
 
-    #def __len__(self):
-    #    return len(self.circuits)
-
 
 class ObjectiveFunctionBuilder(_NicelySerializable):
     """
@@ -843,12 +842,10 @@ class ModelDatasetCircuitsStore(object):
     point.
     """
     def __init__(self, model, dataset, circuits=None, resource_alloc=None, array_types=(),
-                 precomp_layout=None, verbosity=0):
+                 precomp_layout=None, verbosity=0, outcome_count_by_circuit=None):
         self.dataset = dataset
         self.model = model
-        #self.opBasis = mdl.basis
         self.resource_alloc = _ResourceAllocation.cast(resource_alloc)
-        # expand = ??? get from model based on fwdsim type?
 
         circuit_list = circuits if (circuits is not None) else list(dataset.keys())
         bulk_circuit_list = circuit_list if isinstance(
@@ -872,8 +869,21 @@ class ModelDatasetCircuitsStore(object):
         else:
             self.global_circuits = self.circuits
 
-        #self.circuits = bulk_circuit_list[:]
-        #self.circuit_weights = bulk_circuit_list.circuit_weights
+        #If a matrix layout then we have some precached circuit structures we can
+        #grab to speed up store generation.
+        if isinstance(self.layout, _MatrixCOPALayout):
+            #Grab the split_circuit_cache and down select to those in
+            #self.circuits
+            self.split_circuit_cache = self.layout.split_circuit_cache
+            self.split_circuits = [self.split_circuit_cache[ckt] for ckt in self.circuits]
+        #currently only implemented for matrix, will eventually add map support.
+        else:
+            self.split_circuits = None
+            self.split_circuit_cache = None
+
+        #set the value of the circuit outcome count cache (can be None)
+        self.outcome_count_by_circuit_cache = outcome_count_by_circuit
+
         self.ds_circuits = self.circuits.apply_aliases()
 
         # computed by add_count_vectors
@@ -888,18 +898,6 @@ class ModelDatasetCircuitsStore(object):
 
         self.time_dependent = False  # indicates whether the data should be treated as time-resolved
 
-        #if not self.cache.has_evaltree():
-        #    subcalls = self.get_evaltree_subcalls()
-        #    evt_resource_alloc = _ResourceAllocation(self.raw_objfn.comm, evt_mlim,
-        #                                             self.raw_objfn.profiler, self.raw_objfn.distribute_method)
-        #    self.cache.add_evaltree(self.mdl, self.dataset, bulk_circuit_list, evt_resource_alloc,
-        #                            subcalls, self.raw_objfn.printer - 1)
-        #self.eval_tree = self.cache.eval_tree
-        #self.lookup = self.cache.lookup
-        #self.outcomes_lookup = self.cache.outcomes_lookup
-        #self.wrt_block_size = self.cache.wrt_block_size
-        #self.wrt_block_size2 = self.cache.wrt_block_size2
-
         #convenience attributes (could make properties?)
         if isinstance(self.layout, _DistributableCOPALayout):
             self.global_nelements = self.layout.global_num_elements
@@ -916,8 +914,8 @@ class ModelDatasetCircuitsStore(object):
             assert(self.global_nparams is None or self.global_nparams == self.model.num_params)
         else:
             self.global_nelements = self.host_nelements = self.nelements = len(self.layout)
-            self.global_nparams = self.host_nparams = self.nparams = self.model.num_params
-            self.global_nparams2 = self.host_nparams2 = self.nparams2 = self.model.num_params
+            self.global_nparams = self.host_nparams = self.nparams = self.model.num_params if self.model else 0
+            self.global_nparams2 = self.host_nparams2 = self.nparams2 = self.model.num_params if self.model else 0
 
     @property
     def opBasis(self):
@@ -940,14 +938,36 @@ class ModelDatasetCircuitsStore(object):
         """
         if self.firsts is None or force:
             # FUTURE: add any tracked memory? self.resource_alloc.add_tracked_memory(...)
-            self.firsts = []; self.indicesOfCircuitsWithOmittedData = []
-            for i, c in enumerate(self.circuits):
-                indices = _slct.to_array(self.layout.indices_for_index(i))
-                lklen = _slct.length(self.layout.indices_for_index(i))
-                if 0 < lklen < self.model.compute_num_outcomes(c):
+            self.firsts = [] 
+            self.indicesOfCircuitsWithOmittedData = []
+
+            if self.outcome_count_by_circuit_cache is None:
+                #bulk compute the number of outcomes.
+                if isinstance(self.model, _OpModel) and self.split_circuits is not None:
+                    bulk_outcomes_list = self.model.bulk_circuit_outcomes(self.circuits, split_circuits=self.split_circuits)
+                    num_outcomes_list = [len(outcome_tup) for outcome_tup in bulk_outcomes_list]
+                else:
+                    num_outcomes_list = [self.model.compute_num_outcomes(c) for c in self.circuits]
+            else:
+                num_outcomes_list = []
+                for ckt in self.circuits:
+                    num_outcomes = self.outcome_count_by_circuit_cache.get(ckt, None)
+                    if num_outcomes is None:
+                        num_outcomes = self.model.compute_num_outcomes(ckt)
+                        #also add this to the cache, just in case it is later needed.
+                        self.outcome_count_by_circuit_cache[ckt] = num_outcomes
+                    num_outcomes_list.append(num_outcomes)
+
+            for i in range(len(self.circuits)):
+                indices = self.layout.indices_for_index(i)
+                #The return types of indices_for_index are either ndarrays
+                #or slices.
+                if isinstance(indices, slice): 
+                    indices = _slct.indices(indices)
+                if 0 < len(indices) < num_outcomes_list[i]:
                     self.firsts.append(indices[0])
                     self.indicesOfCircuitsWithOmittedData.append(i)
-            if len(self.firsts) > 0:
+            if self.firsts:
                 self.firsts = _np.array(self.firsts, 'i')
                 self.indicesOfCircuitsWithOmittedData = _np.array(self.indicesOfCircuitsWithOmittedData, 'i')
                 self.dprobs_omitted_rowsum = _np.empty((len(self.firsts), self.nparams), 'd')
@@ -974,13 +994,15 @@ class ModelDatasetCircuitsStore(object):
 
             for (i, circuit) in enumerate(self.ds_circuits):
                 cnts = self.dataset[circuit].counts
-                totals[self.layout.indices_for_index(i)] = sum(cnts.values())  # dataset[opStr].total
-                counts[self.layout.indices_for_index(i)] = [cnts.get(x, 0) for x in self.layout.outcomes_for_index(i)]
+                idcs_for_idx = self.layout.indices_for_index(i)
+                totals[idcs_for_idx] = sum(cnts.values())  # dataset[opStr].
+                counts[idcs_for_idx] = [cnts.getitem_unsafe(x, 0) for x in self.layout.outcomes_for_index(i)]
 
             if self.circuits.circuit_weights is not None:
                 for i in range(len(self.ds_circuits)):  # multiply N's by weights
-                    counts[self.layout.indices_for_index(i)] *= self.circuits.circuit_weights[i]
-                    totals[self.layout.indices_for_index(i)] *= self.circuits.circuit_weights[i]
+                    idcs_for_idx = self.layout.indices_for_index(i)
+                    counts[idcs_for_idx] *= self.circuits.circuit_weights[i]
+                    totals[idcs_for_idx] *= self.circuits.circuit_weights[i]
 
             self.counts = counts
             self.total_counts = totals
@@ -994,7 +1016,7 @@ class EvaluatedModelDatasetCircuitsStore(ModelDatasetCircuitsStore):
 
     def __init__(self, mdc_store, verbosity):
         super().__init__(mdc_store.model, mdc_store.dataset, mdc_store.global_circuits, mdc_store.resource_alloc,
-                         mdc_store.array_types, mdc_store.layout, verbosity)
+                         mdc_store.array_types, mdc_store.layout, verbosity, mdc_store.outcome_count_by_circuit_cache)
 
         # Memory check - see if there's enough memory to hold all the evaluated quantities
         #persistent_mem = self.layout.memory_estimate()
@@ -1436,96 +1458,6 @@ class MDCObjectiveFunction(ObjectiveFunction, EvaluatedModelDatasetCircuitsStore
         """
         raise NotImplementedError("Derived classes should implement this!")
 
-    #MOVED - but these versions have updated names
-    #def _persistent_memory_estimate(self, num_elements=None):
-    #    #  Estimate & check persistent memory (from allocs within objective function)
-    #    """
-    #    Compute the amount of memory needed to perform evaluations of this objective function.
-    #
-    #    This number includes both intermediate and final results, and assumes
-    #    that the types of evauations given by :meth:`_evaltree_subcalls`
-    #    are required.
-    #
-    #    Parameters
-    #    ----------
-    #    num_elements : int, optional
-    #        The number of elements (circuit outcomes) that will be computed.
-    #
-    #    Returns
-    #    -------
-    #    int
-    #    """
-    #    if num_elements is None:
-    #        nout = int(round(_np.sqrt(self.mdl.dim)))  # estimate of avg number of outcomes per string
-    #        nc = len(self.circuits)
-    #        ne = nc * nout  # estimate of the number of elements (e.g. probabilities, # LS terms, etc) to compute
-    #    else:
-    #        ne = num_elements
-    #    np = self.mdl.num_params
-    #
-    #    # "persistent" memory is that used to store the final results.
-    #    obj_fn_mem = FLOATSIZE * ne
-    #    jac_mem = FLOATSIZE * ne * np
-    #    hess_mem = FLOATSIZE * ne * np**2
-    #    persistent_mem = 4 * obj_fn_mem + jac_mem  # 4 different objective-function sized arrays, 1 jacobian array?
-    #    if any([nm == "bulk_fill_hprobs" for nm in self._evaltree_subcalls()]):
-    #        persistent_mem += hess_mem  # we need room for the hessian too!
-    #    # TODO: what about "bulk_hprobs_by_block"?
-    #
-    #    return persistent_mem
-    #
-    #def _evaltree_subcalls(self):
-    #    """
-    #    The types of calls that will be made to an evaluation tree.
-    #
-    #    This information is used for memory estimation purposes.
-    #
-    #    Returns
-    #    -------
-    #    list
-    #    """
-    #    calls = ["bulk_fill_probs", "bulk_fill_dprobs"]
-    #    if self.enable_hessian: calls.append("bulk_fill_hprobs")
-    #    return calls
-    #
-    #def num_data_params(self):
-    #    """
-    #    The number of degrees of freedom in the data used by this objective function.
-    #
-    #    Returns
-    #    -------
-    #    int
-    #    """
-    #    return self.dataset.degrees_of_freedom(self.ds_circuits,
-    #                                               aggregate_times=not self.time_dependent)
-
-    #def _precompute_omitted_freqs(self):
-    #    """
-    #    Detect omitted frequences (assumed to be 0) so we can compute objective fn correctly
-    #    """
-    #    self.firsts = []; self.indicesOfCircuitsWithOmittedData = []
-    #    for i, c in enumerate(self.circuits):
-    #        lklen = _slct.length(self.lookup[i])
-    #        if 0 < lklen < self.mdl.compute_num_outcomes(c):
-    #            self.firsts.append(_slct.to_array(self.lookup[i])[0])
-    #            self.indicesOfCircuitsWithOmittedData.append(i)
-    #    if len(self.firsts) > 0:
-    #        self.firsts = _np.array(self.firsts, 'i')
-    #        self.indicesOfCircuitsWithOmittedData = _np.array(self.indicesOfCircuitsWithOmittedData, 'i')
-    #        self.dprobs_omitted_rowsum = _np.empty((len(self.firsts), self.nparams), 'd')
-    #        self.raw_objfn.printer.log("SPARSE DATA: %d of %d rows have sparse data" %
-    #                                   (len(self.firsts), len(self.circuits)))
-    #    else:
-    #        self.firsts = None  # no omitted probs
-    #
-    #def _compute_count_vectors(self):
-    #    """
-    #    Ensure self.cache contains count and total-count vectors.
-    #    """
-    #    if not self.cache.has_count_vectors():
-    #        self.cache.add_count_vectors(self.dataset, self.ds_circuits, self.circuit_weights)
-    #    return self.cache.counts, self.cache.total_counts
-
     def _construct_hessian(self, counts, total_counts, prob_clip_interval):
         """
         Framework for constructing a hessian matrix row by row using a derived
@@ -1630,7 +1562,7 @@ class MDCObjectiveFunction(ObjectiveFunction, EvaluatedModelDatasetCircuitsStore
                                  len(layout.atoms), atom.num_elements))
                         _sys.stdout.flush(); k += 1
 
-                    hessian_blk = self._hessian_from_block(hprobs, dprobs12, probs, atom_counts,
+                    hessian_blk = self._hessian_from_block(hprobs, dprobs12, probs, atom.element_slice, atom_counts,
                                                            atom_total_counts, freqs, param2_resource_alloc)
                     #NOTE: _hessian_from_hprobs MAY modify hprobs and dprobs12
                     #NOTE2: we don't account for memory within _hessian_from_block - maybe we should?
@@ -1645,7 +1577,7 @@ class MDCObjectiveFunction(ObjectiveFunction, EvaluatedModelDatasetCircuitsStore
 
         return atom_hessian  # (my_nparams1, my_nparams2)
 
-    def _hessian_from_block(self, hprobs, dprobs12, probs, counts, total_counts, freqs, resource_alloc):
+    def _hessian_from_block(self, hprobs, dprobs12, probs, element_slice, counts, total_counts, freqs, resource_alloc):
         raise NotImplementedError("Derived classes should implement this!")
 
     def _gather_hessian(self, local_hessian):
@@ -5122,7 +5054,7 @@ class TimeIndependentMDCObjectiveFunction(MDCObjectiveFunction):
         if paramvec is not None: self.model.from_vector(paramvec)
         return self._gather_hessian(self._construct_hessian(self.counts, self.total_counts, self.prob_clip_interval))
 
-    def _hessian_from_block(self, hprobs, dprobs12, probs, counts, total_counts, freqs, resource_alloc):
+    def _hessian_from_block(self, hprobs, dprobs12, probs, element_slice, counts, total_counts, freqs, resource_alloc):
         """ Factored-out computation of hessian from raw components """
 
         # Note: hprobs, dprobs12, probs are sometimes shared memory, but the caller (e.g. _construct_hessian)
@@ -5141,18 +5073,23 @@ class TimeIndependentMDCObjectiveFunction(MDCObjectiveFunction):
         hprobs_coeffs = self.raw_objfn.dterms(probs, counts, total_counts, freqs)
 
         if self.firsts is not None:
+            # iel = element index (of self.layout), ic = circuit index
+            firsts, indicesWithOmitted = zip(*([(iel - element_slice.start, ic) for (iel, ic)
+                                                in zip(self.firsts, self.indicesOfCircuitsWithOmittedData)
+                                                if element_slice.start <= iel < element_slice.stop]))
+
             #Allocate these above?  Need to know block sizes of dprobs12 & hprobs...
-            dprobs12_omitted_rowsum = _np.empty((len(self.firsts),) + dprobs12.shape[1:], 'd')
-            hprobs_omitted_rowsum = _np.empty((len(self.firsts),) + hprobs.shape[1:], 'd')
+            dprobs12_omitted_rowsum = _np.empty((len(firsts),) + dprobs12.shape[1:], 'd')
+            hprobs_omitted_rowsum = _np.empty((len(firsts),) + hprobs.shape[1:], 'd')
 
             omitted_probs = 1.0 - _np.array([_np.sum(probs[self.layout.indices_for_index(i)])
-                                             for i in self.indicesOfCircuitsWithOmittedData])
-            for ii, i in enumerate(self.indicesOfCircuitsWithOmittedData):
+                                             for i in indicesWithOmitted])
+            for ii, i in enumerate(indicesWithOmitted):
                 dprobs12_omitted_rowsum[ii, :, :] = _np.sum(dprobs12[self.layout.indices_for_index(i), :, :], axis=0)
                 hprobs_omitted_rowsum[ii, :, :] = _np.sum(hprobs[self.layout.indices_for_index(i), :, :], axis=0)
 
-            dprobs12_omitted_coeffs = -self.raw_objfn.zero_freq_hterms(total_counts[self.firsts], omitted_probs)
-            hprobs_omitted_coeffs = -self.raw_objfn.zero_freq_dterms(total_counts[self.firsts], omitted_probs)
+            dprobs12_omitted_coeffs = -self.raw_objfn.zero_freq_hterms(total_counts[firsts], omitted_probs)
+            hprobs_omitted_coeffs = -self.raw_objfn.zero_freq_dterms(total_counts[firsts], omitted_probs)
 
         # hessian = hprobs_coeffs * hprobs + dprobs12_coeff * dprobs12
         #  but re-using dprobs12 and hprobs memory (which is overwritten!)
@@ -5160,8 +5097,10 @@ class TimeIndependentMDCObjectiveFunction(MDCObjectiveFunction):
             hprobs *= hprobs_coeffs[:, None, None]
             dprobs12 *= dprobs12_coeffs[:, None, None]
             if self.firsts is not None:
-                hprobs[self.firsts, :, :] += hprobs_omitted_coeffs[:, None, None] * hprobs_omitted_rowsum
-                dprobs12[self.firsts, :, :] += dprobs12_omitted_coeffs[:, None, None] * dprobs12_omitted_rowsum
+                firsts = [(iel - element_slice.start) for iel in self.firsts
+                      if element_slice.start <= iel < element_slice.stop]
+                hprobs[firsts, :, :] += hprobs_omitted_coeffs[:, None, None] * hprobs_omitted_rowsum
+                dprobs12[firsts, :, :] += dprobs12_omitted_coeffs[:, None, None] * dprobs12_omitted_rowsum
             hessian = dprobs12; hessian += hprobs
         else:
             hessian = dprobs12
@@ -6474,10 +6413,6 @@ class LogLWildcardFunction(ObjectiveFunction):
         self.logl_objfn.resource_alloc.add_tracked_memory(self.logl_objfn.probs.size)
         self.probs = self.logl_objfn.probs.copy()
 
-    #def _default_evalpt(self):
-    #    """The default point to evaluate functions at """
-    #    return self.wildcard_budget.to_vector()
-
     #Mimic the underlying LogL objective
     def __getattr__(self, attr):
         return getattr(self.__dict__['logl_objfn'], attr)  # use __dict__ so no chance for recursive __getattr__

pygsti/objectivefns/wildcardbudget.py

@@ -143,11 +143,6 @@ class WildcardBudget(_NicelySerializable):
         """
         raise NotImplementedError("Derived classes must implement `description`")
 
-    #def compute_circuit_wildcard_budget(c, w_vec):
-    #    #raise NotImplementedError("TODO!!!")
-    #    #for now, assume w_vec is a length-1 vector
-    #    return abs(w_vec[0]) * len(c)
-
     def precompute_for_same_circuits(self, circuits):
         """
         Compute a pre-computed quantity for speeding up circuit calculations.
@@ -596,7 +591,7 @@ class PrimitiveOpsWildcardBudgetBase(WildcardBudget):
             elif lbl.name in error_per_op:
                 return pos(error_per_op[lbl.name])
             else:
-                assert(not lbl.is_simple()), "Simple label %s must be a primitive op of this WEB!" % str(lbl)
+                assert(not lbl.is_simple), "Simple label %s must be a primitive op of this WEB!" % str(lbl)
                 return sum([budget_for_label(component) for component in lbl.components])
 
         budget = error_per_op.get('SPAM', 0)
@@ -656,7 +651,7 @@ class PrimitiveOpsWildcardBudgetBase(WildcardBudget):
                 deriv[self.primitive_op_index[lbl.name]] = 1.0
                 return deriv
             else:
-                assert(not lbl.is_simple()), "Simple label %s must be a primitive op of this WEB!" % str(lbl)
+                assert(not lbl.is_simple), "Simple label %s must be a primitive op of this WEB!" % str(lbl)
                 return sum([budget_deriv_for_label(component) for component in lbl.components])
 
         circuit_budget_matrix = _np.zeros((len(circuits), self.num_primitive_ops), 'd')

pygsti/optimize/__init__.py

@@ -12,6 +12,7 @@ pyGSTi Optimization Python Package
 
 from .arraysinterface import *
 from .customlm import *
+from .simplerlm import *
 from .customsolve import *
 # Import the most important/useful routines of each module into
 # the package namespace

pygsti/optimize/arraysinterface.py

@@ -579,6 +579,19 @@ class UndistributedArraysInterface(ArraysInterface):
         """
         return _np.diag_indices_from(jtj)
 
+    def jtj_update_regularization(self, jtj, prd, mu):
+        ind = self.jtj_diag_indices(jtj)
+        jtj[ind] = prd + mu
+        return
+
+    def jtj_pre_regularization_data(self, jtj):
+        return jtj[self.jtj_diag_indices(jtj)].copy()
+    
+    
+    def jtj_max_diagonal_element(self, jtj):
+        diag = jtj[self.jtj_diag_indices(jtj)]
+        return self.max_x(diag)
+
 
 class DistributedArraysInterface(ArraysInterface):
     """
@@ -626,6 +639,9 @@ class DistributedArraysInterface(ArraysInterface):
         """
         Allocate an array for holding a Jacobian matrix (type `'ep'`).
 
+        Note: this function is only called when the Jacobian needs to be
+        approximated with finite differences.
+
         Returns
         -------
         numpy.ndarray or LocalNumpyArray
@@ -1266,3 +1282,15 @@ class DistributedArraysInterface(ArraysInterface):
         col_indices = _np.arange(global_param_indices.start, global_param_indices.stop)
         assert(len(row_indices) == len(col_indices))  # checks that global_param_indices is good
         return row_indices, col_indices  # ~ _np.diag_indices_from(jtj)
+
+    def jtj_update_regularization(self, jtj, prd, mu):
+        ind = self.jtj_diag_indices(jtj)
+        jtj[ind] = prd + mu
+        return
+
+    def jtj_pre_regularization_data(self, jtj):
+        return jtj[self.jtj_diag_indices(jtj)].copy()
+    
+    def jtj_max_diagonal_element(self, jtj):
+        diag = jtj[self.jtj_diag_indices(jtj)]
+        return self.max_x(diag)

pygsti/optimize/customcg.py

@@ -244,15 +244,3 @@ def _finite_diff_dfdx_and_bdflag(f, x, delta):
         #completely undefined
 
     return dfdx, bd
-
-#def f6(param):
-#    '''Schaffer's F6 function'''
-#    para = param*10
-#    para = param[0:2]
-#    num = (sin(sqrt((para[0] * para[0]) + (para[1] * para[1])))) * \
-#        (sin(sqrt((para[0] * para[0]) + (para[1] * para[1])))) - 0.5
-#    denom = (1.0 + 0.001 * ((para[0] * para[0]) + (para[1] * para[1]))) * \
-#            (1.0 + 0.001 * ((para[0] * para[0]) + (para[1] * para[1])))
-#    f6 =  0.5 - (num/denom)
-#    errorf6 = 1 - f6
-#    return f6, errorf6;