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

pygsti/circuits/circuitconstruction.py

@@ -183,10 +183,6 @@ def repeat_with_max_length(x, max_length, assert_at_least_one_rep=False):
     """
     return repeat(x, repeat_count_with_max_length(x, max_length, assert_at_least_one_rep), assert_at_least_one_rep)
 
-#Useful for anything?
-#def repeat_empty(x,max_length,assert_at_least_one_rep=False):
-#    return ()
-
 
 def repeat_and_truncate(x, n, assert_at_least_one_rep=False):
     """

pygsti/circuits/circuitlist.py

@@ -158,11 +158,7 @@ class CircuitList(_NicelySerializable):
         -------
         CircuitList
         """
-        if isinstance(circuits_to_keep, set):
-            new_circuits = list(filter(lambda c: c in circuits_to_keep, self._circuits))
-        else:
-            current_circuits = set(self._circuits)
-            new_circuits = list(filter(lambda c: c in current_circuits, circuits_to_keep))
+        new_circuits = list(filter(lambda c: c in set(circuits_to_keep), self._circuits))
         return CircuitList(new_circuits, self.op_label_aliases)  # don't transfer weights or name
 
     def truncate_to_dataset(self, dataset):
@@ -205,3 +201,49 @@ class CircuitList(_NicelySerializable):
         self.__dict__.update(state_dict)
         if 'uuid' not in state_dict:  # backward compatibility
             self.uuid = _uuid.uuid4()  # create a new uuid
+
+    def elementvec_to_array(self, elementvec, layout, mergeop="sum"):
+        """
+        Form an array of values corresponding to this CircuitList from an element vector.
+
+        An element vector holds individual-outcome elements (e.g. the bulk probabilities
+        computed by a model).
+
+        Parameters
+        ----------
+        elementvec : numpy array
+            An array containting the values to use when constructing a
+            matrix of values for this CircuitList. This array may contain more
+            values than are needed by this CircuitList.  Indices into this array
+            are given by `elindices_lookup`.
+
+        layout : CircuitOutcomeProbabilityArrayLayout
+            The layout of `elementvec`, giving the mapping between its elements and
+            circuit outcomes.
+
+        mergeop : "sum" or format string, optional
+            Dictates how to combine the `elementvec` components corresponding to a single
+            plaquette entry (circuit).  If "sum", the returned array contains summed
+            values.  If a format string, e.g. `"%.2f"`, then the so-formatted components
+            are joined together with separating commas, and the resulting array contains
+            string (object-type) entries.
+
+        Returns
+        -------
+        numpy array
+        """
+        
+        if mergeop == "sum":
+                ret = _np.nan * _np.ones(len(self), 'd')
+                for i,ckt in enumerate(self._circuits):
+                    ret[i] = sum(elementvec[layout.indices(ckt)])
+        elif '%' in mergeop:
+            fmt = mergeop
+            ret = _np.nan * _np.ones(len(self), dtype=_np.object_)
+            for i,ckt in enumerate(self._circuits):
+                ret[i] = ", ".join(["NaN" if _np.isnan(x) else
+                                    (fmt % x) for x in elementvec[layout.indices(ckt)]])
+        else:
+            raise ValueError("Invalid `mergeop` arg: %s" % str(mergeop))
+        
+        return ret

pygsti/circuits/circuitparser/__init__.py

@@ -116,7 +116,7 @@ class CircuitLexer:
 
     @staticmethod
     def t_GATE(t):                                                                       # noqa
-        """
+        r"""
         ``'G[a-z0-9_]+(;[a-zQ0-9_\./]+)*(:[a-zQ0-9_]+)*(![0-9\.]+)?'``
         """
         
@@ -128,7 +128,7 @@ class CircuitLexer:
 
     @staticmethod
     def t_INSTRMT(t):                                                               # noqa
-        """
+        r"""
         ``'I[a-z0-9_]+(![0-9\.]+)?'``
         """
         #Note: don't need to convert parts[1],etc, to integers (if possible) as Label automatically does this
@@ -138,7 +138,7 @@ class CircuitLexer:
 
     @staticmethod
     def t_PREP(t):                                                                       # noqa
-        """
+        r"""
         ``'rho[a-z0-9_]+(![0-9\.]+)?'``
         """
         #Note: don't need to convert parts[1],etc, to integers (if possible) as Label automatically does this
@@ -148,7 +148,7 @@ class CircuitLexer:
 
     @staticmethod
     def t_POVM(t):                                                                       # noqa
-        """
+        r"""
         ``'M[a-z0-9_]+(![0-9\.]+)?'``
         """
         #Note: don't need to convert parts[1],etc, to integers (if possible) as Label automatically does this
@@ -158,14 +158,14 @@ class CircuitLexer:
 
     @staticmethod
     def t_STRINGIND(t):                                                                  # noqa
-        """
+        r"""
         ``'S(?=\s*\<)'``
         """
         return t
 
     @staticmethod
     def t_REFLBL(t):                                                                     # noqa
-        """
+        r"""
         ``'<\s*[a-zA-Z0-9_]+\s*>'``
         """
         t.value = t.value[1:-1].strip()
@@ -184,7 +184,7 @@ class CircuitLexer:
 
     @staticmethod
     def t_NOP(t):                                                                        # noqa
-        """
+        r"""
         ``'\{\}'``
         """
         t.value = tuple()
@@ -192,7 +192,7 @@ class CircuitLexer:
 
     @staticmethod
     def t_INTEGER(t):                                                                    # noqa
-        """
+        r"""
         ``'\d+'``
         """
         t.value = int(t.value)

pygsti/circuits/circuitstructure.py

@@ -117,9 +117,9 @@ class CircuitPlaquette(_NicelySerializable):
     def __len__(self):
         return len(self.elements)
 
-    def elementvec_to_matrix(self, elementvec, layout, mergeop="sum"):
+    def elementvec_to_array(self, elementvec, layout, mergeop="sum"):
         """
-        Form a matrix of values corresponding to this plaquette from an element vector.
+        Form a array of values corresponding to this plaquette from an element vector.
 
         An element vector holds individual-outcome elements (e.g. the bulk probabilities
         computed by a model).
@@ -644,7 +644,7 @@ class PlaquetteGridCircuitStructure(_CircuitList):
         else:
             op_label_aliases = weights_dict = name = None
 
-        return cls({}, [], [], circuits_or_structure,
+        return cls({}, [], [], '', '', circuits_or_structure,
                    op_label_aliases, weights_dict, name)
 
     def __init__(self, plaquettes, x_values, y_values, xlabel, ylabel, additional_circuits=None, op_label_aliases=None,

pygsti/circuits/cloudcircuitconstruction.py

@@ -2164,7 +2164,7 @@ def _get_kcoverage_template_k2(n):
     def invert(bstr):
         return [(0 if x else 1) for x in bstr]
 
-    half = [bitstr(n, k) for k in range(int(_np.ceil(_np.math.log(n, 2))))]
+    half = [bitstr(n, k) for k in range(int(_np.ceil(_np.log2(n))))]
     other_half = [invert(bstr) for bstr in half]
     return half + other_half
 

pygsti/data/datacomparator.py

@@ -49,11 +49,6 @@ def _loglikelihood(p_list, n_list):
         output += _xlogy(n_list[i], pVal)
     return output
 
-# Only used by the rectify data function, which is commented out,
-# so this is also commented out.
-# def loglikelihoodRatioObj(alpha,n_list_list,dof):
-#     return _np.abs(dof - _loglikelihood_ratio(alpha*n_list_list))
-
 
 def _loglikelihood_ratio(n_list_list):
     """
@@ -75,11 +70,11 @@ def _loglikelihood_ratio(n_list_list):
         The log-likehood ratio for this model comparison.
     """
     nListC = _np.sum(n_list_list, axis=0)
-    pListC = nListC / _np.float_(_np.sum(nListC))
+    pListC = nListC / _np.float64(_np.sum(nListC))
     lC = _loglikelihood(pListC, nListC)
     li_list = []
     for nList in n_list_list:
-        pList = _np.array(nList) / _np.float_(_np.sum(nList))
+        pList = _np.array(nList) / _np.float64(_np.sum(nList))
         li_list.append(_loglikelihood(pList, nList))
     lS = _np.sum(li_list)
     return -2 * (lC - lS)

pygsti/data/dataset.py

@@ -11,6 +11,7 @@ Defines the DataSet class and supporting classes and functions
 #***************************************************************************************************
 
 import bisect as _bisect
+from collections.abc import Iterable as _Iterable
 import copy as _copy
 import itertools as _itertools
 import numbers as _numbers
@@ -295,34 +296,10 @@ class _DataSetRow(object):
         last_time = None
         seriesDict = {self.dataset.olIndex[ol]: [] for ol in self.dataset.outcome_labels}
 
-        #REMOVED: (though this gives slightly different behavior)
-        #for outcome_label in self.outcomes:
-        #    if outcome_label not in seriesDict.keys():
-        #        seriesDict[outcome_label] = []
-
         if self.reps is None:
             reps = _np.ones(len(self.time), _np.int64)
         else: reps = self.reps
 
-        # An alternate implementation that appears to be (surprisingly?) slower...
-        ##Get time bin locations
-        #time_bins_borders = []
-        #last_time = None
-        #for i, t in enumerate(self.time):
-        #    if t != last_time:
-        #        time_bins_borders.append(i)
-        #        last_time = t
-        #time_bins_borders.append(len(self.time))
-        #nTimes = len(time_bins_borders) - 1
-        #
-        #seriesDict = {self.dataset.olIndex[ol]: _np.zeros(nTimes, _np.int64) for ol in self.dataset.outcome_labels}
-        #
-        #for i in range(nTimes):
-        #    slc = slice(time_bins_borders[i],time_bins_borders[i+1])
-        #    times.append( self.time[slc.start] )
-        #    for oli, rep in zip(self.oli[slc], reps[slc]):
-        #        seriesDict[oli][i] += rep
-
         for t, oli, rep in zip(self.time, self.oli, reps):
 
             if t != last_time:
@@ -585,26 +562,28 @@ class _DataSetRow(object):
             tslc = _np.where(_np.isclose(self.time, timestamp))[0]
         else: tslc = slice(None)
 
+        oli_tslc = self.oli[tslc]
         nOutcomes = len(self.dataset.olIndex)
-        nIndices = len(self.oli[tslc])
+        nIndices = len(oli_tslc)
+        
         if nOutcomes <= nIndices or all_outcomes:
             if self.reps is None:
                 for ol, i in self.dataset.olIndex.items():
-                    cnt = float(_np.count_nonzero(_np.equal(self.oli[tslc], i)))
-                    if all_outcomes or cnt > 0:
+                    cnt = float(_np.count_nonzero(_np.equal(oli_tslc, i)))
+                    if cnt > 0 or all_outcomes:
                         cntDict.setitem_unsafe(ol, cnt)
             else:
                 for ol, i in self.dataset.olIndex.items():
-                    inds = _np.nonzero(_np.equal(self.oli[tslc], i))[0]
-                    if all_outcomes or len(inds) > 0:
+                    inds = oli_tslc[oli_tslc == i]
+                    if len(inds) > 0 or all_outcomes:
                         cntDict.setitem_unsafe(ol, float(sum(self.reps[tslc][inds])))
         else:
             if self.reps is None:
-                for ol_index in self.oli[tslc]:
+                for ol_index in oli_tslc:
                     ol = self.dataset.ol[ol_index]
                     cntDict.setitem_unsafe(ol, 1.0 + cntDict.getitem_unsafe(ol, 0.0))
             else:
-                for ol_index, reps in zip(self.oli[tslc], self.reps[tslc]):
+                for ol_index, reps in zip(oli_tslc, self.reps[tslc]):
                     ol = self.dataset.ol[ol_index]
                     cntDict.setitem_unsafe(ol, reps + cntDict.getitem_unsafe(ol, 0.0))
 
@@ -615,7 +594,8 @@ class _DataSetRow(object):
         """
         Dictionary of per-outcome counts.
         """
-        if self._cntcache: return self._cntcache  # if not None *and* len > 0
+        if self._cntcache: 
+            return self._cntcache  # if not None *and* len > 0
         ret = self._get_counts()
         if self._cntcache is not None:  # == and empty dict {}
             self._cntcache.update(ret)
@@ -1031,12 +1011,13 @@ class DataSet(_MongoSerializable):
             self.olIndex = outcome_label_indices
             self.olIndex_max = max(self.olIndex.values()) if len(self.olIndex) > 0 else -1
         elif outcome_labels is not None:
-            if isinstance(outcome_labels, _np.int64):
-                nqubits = outcome_labels
-                tup_outcomeLabels = [("".join(x),) for x in _itertools.product(*([('0', '1')] * nqubits))]
-            else:
+            if isinstance(outcome_labels, _Iterable):
                 tup_outcomeLabels = [_ld.OutcomeLabelDict.to_outcome(ol)
                                      for ol in outcome_labels]  # strings -> tuple outcome labels
+            else: # Given an int which signifies how many qubits
+                nqubits = outcome_labels
+                tup_outcomeLabels = [("".join(x),) for x in _itertools.product(*([('0', '1')] * nqubits))]
+                
             self.olIndex = _OrderedDict([(ol, i) for (i, ol) in enumerate(tup_outcomeLabels)])
             self.olIndex_max = len(tup_outcomeLabels) - 1
         else:
@@ -1197,10 +1178,10 @@ class DataSet(_MongoSerializable):
         circuit = _cir.Circuit.cast(circuit)
 
         #Note: cirIndex value is either an int (non-static) or a slice (static)
-        repData = self.repData[self.cirIndex[circuit]] \
-            if (self.repData is not None) else None
-        return _DataSetRow(self, self.oliData[self.cirIndex[circuit]],
-                           self.timeData[self.cirIndex[circuit]], repData,
+        cirIndex = self.cirIndex[circuit]
+        repData = self.repData[cirIndex] if (self.repData is not None) else None
+        return _DataSetRow(self, self.oliData[cirIndex],
+                           self.timeData[cirIndex], repData,
                            self.cnt_cache[circuit] if self.bStatic else None,
                            self.auxInfo[circuit])
 
@@ -1413,17 +1394,19 @@ class DataSet(_MongoSerializable):
         # if "keepseparate" mode, set occurrence id existing circuits to next available (positive) integer.
         if self.collisionAction == "keepseparate":
             if circuit in self.cirIndex:
-                tagged_circuit = circuit.copy()
+                tagged_circuit = circuit.copy(editable=True)
                 i = 1; tagged_circuit.occurrence = i
                 while tagged_circuit in self.cirIndex:
                     i += 1; tagged_circuit.occurrence = i
+                tagged_circuit.done_editing()
                 #add data for a new (duplicate) circuit
                 circuit = tagged_circuit
 
         # in other modes ("overwrite" and "aggregate"), strip off occurrence so duplicates are acted on appropriately
         elif circuit.occurrence is not None:
-            stripped_circuit = circuit.copy()
+            stripped_circuit = circuit.copy(editable=True)
             stripped_circuit.occurrence = None
+            stripped_circuit.done_editing()
             circuit = stripped_circuit
 
         return circuit
@@ -1601,7 +1584,7 @@ class DataSet(_MongoSerializable):
         self._add_raw_arrays(circuit, outcome_index_array, time_array, count_array,
                              overwriteExisting, record_zero_counts, aux)
 
-    def add_cirq_trial_result(self, circuit, trial_result, key):
+    def add_cirq_trial_result(self, circuit, trial_result, key, convert_int_to_binary = True, num_qubits = None):
         """
         Add a single circuit's counts --- stored in a Cirq TrialResult --- to this DataSet
 
@@ -1617,6 +1600,16 @@ class DataSet(_MongoSerializable):
         key : str
             The string key of the measurement. Set by cirq.measure.
 
+        convert_int_to_binary : bool, optional (defaut True)
+            By default the keys in the cirq Results object are the integers representing
+            the bitstrings of the measurements on a set of qubits, in big-endian convention.
+            If True this converts back to a binary string before adding the counts as a 
+            entry into the pygsti dataset.
+
+        num_qubits : int, optional (default None)
+            Number of qubits used in the conversion from integers to binary when convert_int_to_binary
+            is True. If None, then the number of line_labels on the input circuit is used.
+
         Returns
         -------
         None
@@ -1629,8 +1622,17 @@ class DataSet(_MongoSerializable):
 
         # TrialResult.histogram returns a collections.Counter object, which is a subclass of dict.
         histogram_counter = trial_result.histogram(key=key)
+
+        if num_qubits is None:
+            num_qubits = len(circuit.line_labels)
+
         # The keys in histogram_counter are integers, but pyGSTi likes dictionary keys to be strings.
-        count_dict = {str(key): value for key, value in histogram_counter.items()}
+        count_dict = {}
+        for key, value in histogram_counter.items():
+            if convert_int_to_binary:
+                count_dict[_np.binary_repr(key, width= num_qubits)] = value
+            else:
+                count_dict[str(key)] = value
         self.add_count_dict(circuit, count_dict)
 
     def add_raw_series_data(self, circuit, outcome_label_list, time_stamp_list,

pygsti/data/hypothesistest.py

@@ -253,13 +253,6 @@ class HypothesisTest(object):
                 self.passing_graph[hind, :] = _np.ones(len(self.hypotheses), float) / (len(self.hypotheses) - 1)
                 self.passing_graph[hind, hind] = 0.
 
-    # def _check_permissible(self):
-    #     """
-    #     Todo
-    #     """
-    #     # Todo : test that the graph is acceptable.
-    #     return True
-
     def add_pvalues(self, pvalues):
         """
         Insert the p-values for the hypotheses.

pygsti/drivers/bootstrap.py

@@ -492,52 +492,3 @@ def _to_rms_model(gs_list, target_gs):
     output_gs = target_gs.copy()
     output_gs.from_vector(_np.mean(gsVecArray))
     return output_gs
-
-#Unused?
-#def gateset_jtracedist(mdl,target_model,mx_basis="gm"):
-#    output = _np.zeros(3,dtype=float)
-#    for i, gate in enumerate(target_model.operations.keys()):
-#        output[i] = _tools.jtracedist(mdl.operations[gate],target_model.operations[gate],mx_basis=mx_basis)
-##    print output
-#    return output
-#
-#def gateset_entanglement_fidelity(mdl,target_model):
-#    output = _np.zeros(3,dtype=float)
-#    for i, gate in enumerate(target_model.operations.keys()):
-#        output[i] = _tools.entanglement_fidelity(mdl.operations[gate],target_model.operations[gate])
-#    return output
-#
-#def gateset_decomp_angle(mdl):
-#    output = _np.zeros(3,dtype=float)
-#    for i, gate in enumerate(mdl.operations.keys()):
-#        output[i] = _tools.decompose_gate_matrix(mdl.operations[gate]).get('pi rotations',0)
-#    return output
-#
-#def gateset_decomp_decay_diag(mdl):
-#    output = _np.zeros(3,dtype=float)
-#    for i, gate in enumerate(mdl.operations.keys()):
-#        output[i] = _tools.decompose_gate_matrix(mdl.operations[gate]).get('decay of diagonal rotation terms',0)
-#    return output
-#
-#def gateset_decomp_decay_offdiag(mdl):
-#    output = _np.zeros(3,dtype=float)
-#    for i, gate in enumerate(mdl.operations.keys()):
-#        output[i] = _tools.decompose_gate_matrix(mdl.operations[gate]).get('decay of off diagonal rotation terms',0)
-#    return output
-#
-##def gateset_fidelity(mdl,target_model,mx_basis="gm"):
-##    output = _np.zeros(3,dtype=float)
-##    for i, gate in enumerate(target_model.operations.keys()):
-##        output[i] = _tools.fidelity(mdl.operations[gate],target_model.operations[gate])
-##    return output
-#
-#def gateset_diamonddist(mdl,target_model,mx_basis="gm"):
-#    output = _np.zeros(3,dtype=float)
-#    for i, gate in enumerate(target_model.operations.keys()):
-#        output[i] = _tools.diamonddist(mdl.operations[gate],target_model.operations[gate],mx_basis=mx_basis)
-#    return output
-#
-#def spamrameter(mdl):
-#    firstRho = list(mdl.preps.keys())[0]
-#    firstE = list(mdl.effects.keys())[0]
-#    return _np.dot(mdl.preps[firstRho].T,mdl.effects[firstE])[0,0]

pygsti/drivers/longsequence.py

@@ -178,6 +178,7 @@ def run_model_test(model_filename_or_object,
     if isinstance(pspec_or_model, _Model):
         target_model= pspec_or_model
     elif isinstance(pspec_or_model, _ProcessorSpec):
+
         target_model= create_explicit_model(pspec_or_model, 
                                              basis= _load_model(model_filename_or_object).basis)
 
@@ -930,7 +931,7 @@ def _get_optimizer(advanced_options, model_being_optimized):
     from pygsti.forwardsims.matrixforwardsim import MatrixForwardSimulator as _MatrixFSim
     advanced_options = advanced_options or {}
     default_fditer = 1 if isinstance(model_being_optimized.sim, _MatrixFSim) else 0
-    optimizer = {'maxiter': advanced_options.get('max_iterations', 100000),
+    optimizer = {'maxiter': advanced_options.get('max_iterations', 100),
                  'tol': advanced_options.get('tolerance', 1e-6),
                  'fditer': advanced_options.get('finitediff_iterations', default_fditer)}
     optimizer.update(advanced_options.get('extra_lm_opts', {}))

pygsti/evotypes/chp/opreps.py

@@ -49,11 +49,6 @@ class OpRep(_basereps.OpRep):
     def _chp_ops(self, seed_or_state=None):
         return self.base_chp_ops
 
-    #def chp_str(self, seed_or_state=None):
-    #    op_str = '\n'.join(self.chp_ops(seed_or_state=seed_or_state))
-    #    if len(op_str) > 0: op_str += '\n'
-    #    return op_str
-
     def to_dense(self, on_space):
         try:
             str_ops = str(self._chp_ops())
@@ -217,63 +212,7 @@ class OpRepStochastic(OpRepRandomUnitary):
 
         super(OpRepStochastic, self).__init__(basis, _np.array(rates, 'd'), reps, seed_or_state, state_space)
 
-        #OLD
-        #self.basis = basis
-        #assert (basis.name == 'pp'), "Only Pauli basis is allowed for 'chp' evotype"
-        #
-        #if isinstance(seed_or_state, _RandomState):
-        #    self.rand_state = seed_or_state
-        #else:
-        #    self.rand_state = _RandomState(seed_or_state)
-        #
-        ##TODO: need to fix this: `basis` above functions as basis to make superoperators out of, but here we have
-        ## a CHP stochastic op which is given a basis for the space - e.g. a dim=2 vector space for 1 qubit, so
-        ## we need to distinguish/specify the basis better for this... and what about rate_poly_dicts (see svterm)
-        #nqubits = state_space.num_qubits
-        #assert(self.basis.dim == 4**nqubits), "Must have an integral number of qubits"
-        #
-        #std_chp_ops = _itgs.standard_gatenames_chp_conversions()
-        #
-        ## For CHP, need to make a Composed + EmbeddedOp for the super operators
-        ## For lower overhead, make this directly using the rep instead of with objects
-        #self.stochastic_superop_reps = []
-        #for label in self.basis.labels[1:]:
-        #    combined_chp_ops = []
-        #
-        #    for i, pauli in enumerate(label):
-        #        name = 'Gi' if pauli == "I" else 'G%spi' % pauli.lower()
-        #        chp_op = std_chp_ops[name]
-        #        chp_op_targeted = [op.replace('0', str(i)) for op in chp_op]
-        #        combined_chp_ops.extend(chp_op_targeted)
-        #
-        #    sub_rep = OpRep(combined_chp_ops, state_space)
-        #    self.stochastic_superop_reps.append(sub_rep)
-        #self.rates = initial_rates
-        #super(OpRepStochastic, self).__init__([], state_space)  # don't store any chp_ops in base
-
     def update_rates(self, rates):
         unitary_rates = [1 - sum(rates)] + list(rates)
         self.rates[:] = rates
         self.update_unitary_rates(unitary_rates)
-
-    #TODO REMOVE - covered by OpRepRandomUnitary
-    #def chp_ops(self, seed_or_state=None):
-    #    # Optionally override RNG for this call
-    #    if seed_or_state is not None:
-    #        if isinstance(seed_or_state, _np.random.RandomState):
-    #            rand_state = seed_or_state
-    #        else:
-    #            rand_state = _np.random.RandomState(seed_or_state)
-    #    else:
-    #        rand_state = self.rand_state
-    #
-    #    rates = self.rates
-    #    all_rates = [*rates, 1.0 - sum(rates)]  # Include identity so that probabilities are 1
-    #    index = rand_state.choice(self.basis.size, p=all_rates)
-    #
-    #    # If final entry, no operation selected
-    #    if index == self.basis.size - 1:
-    #        return []
-    #
-    #    rep = self.stochastic_superop_reps[index]
-    #    return rep._chp_ops()

pygsti/evotypes/chp/statereps.py

@@ -40,16 +40,6 @@ class StateRep(_basereps.StateRep):
     def num_qubits(self):
         return self.state_space.num_qubits
 
-    #REMOVE
-    #def chp_ops(self, seed_or_state=None):
-    #    return self.base_chp_ops
-
-    #REMOVE
-    #def chp_str(self, seed_or_state=None):
-    #    op_str = '\n'.join(self.chp_ops(seed_or_state=seed_or_state))
-    #    if len(op_str) > 0: op_str += '\n'
-    #    return op_str
-
     def copy(self):
         return StateRep(self.chp_ops, self.state_space)
 
@@ -87,25 +77,3 @@ class StateRepComposed(StateRep):
     def actionable_staterep(self):
         state_rep = self.state_rep.actionable_staterep()
         return self.op_rep.acton(state_rep)
-
-#REMOVE
-#    def chp_ops(self, seed_or_state=None):
-#        return self.state_rep.chp_ops(seed_or_state=seed_or_state) \
-#            + self.op_rep.chp_ops(seed_or_state=seed_or_state)
-
-# TODO: Untested, only support computational and composed for now
-#class StateRepTensorProduct(StateRep):
-#    def __init__(self, factor_state_reps, state_space):
-#        self.factor_reps = factor_state_reps
-#        super(StateRepTensorProduct, self).__init__([], state_space)
-#        self.reps_have_changed()
-#
-#    def reps_have_changed(self):
-#        chp_ops = []
-#        current_iqubit = 0
-#        for factor in self.factor_reps:
-#            local_to_tp_index = {str(iloc): str(itp) for iloc, itp in
-#                                 enumerate(range(current_iqubit, current_iqubit + factor.num_qubits))}
-#            chp_ops.extend([_update_chp_op(op, local_to_tp_index) for op in self.chp_ops])
-#            current_iqubit += factor.num_qubits
-#        self.chp_ops = chp_ops

pygsti/evotypes/densitymx/effectcreps.cpp

@@ -147,7 +147,7 @@ namespace CReps_densitymx {
 	finalIndx += ((finds >> k) & 1) * 3 * base;
 	base = base >> 2; // /= 4 so base == 4**(N-1-k)
       }
-
+      
       //Apply result
       if(parity(finds & _zvals_int))
 	ret -= _abs_elval * state->_dataptr[finalIndx]; // minus sign
@@ -157,15 +157,14 @@ namespace CReps_densitymx {
     return ret;
   }
 
-  INT EffectCRep_Computational::parity(INT x) {
-    // int64-bit specific
-    x = (x & 0x00000000FFFFFFFF)^(x >> 32);
-    x = (x & 0x000000000000FFFF)^(x >> 16);
-    x = (x & 0x00000000000000FF)^(x >> 8);
-    x = (x & 0x000000000000000F)^(x >> 4);
-    x = (x & 0x0000000000000003)^(x >> 2);
-    x = (x & 0x0000000000000001)^(x >> 1);
-    return x & 1; // return the last bit (0 or 1)
+  inline INT EffectCRep_Computational::parity(INT x) {
+    x ^= (x >> 32);
+    x ^= (x >> 16);
+    x ^= (x >> 8);
+    x ^= (x >> 4);
+    x ^= (x >> 2);
+    x ^= (x >> 1);
+    return x & 1; // Return the last bit
   }
 
 

pygsti/evotypes/densitymx/effectreps.pyx

@@ -108,7 +108,7 @@ cdef class EffectRepTensorProduct(EffectRep):
         cdef _np.ndarray[_np.int64_t, ndim=1, mode='c'] factor_dims = \
             _np.ascontiguousarray(_np.array([fct.state_space.dim 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(povm_factors)
         self.povm_factors = povm_factors
         self.effect_labels = effect_labels

pygsti/evotypes/densitymx/opreps.pyx

@@ -540,7 +540,7 @@ def _compute_embedding_quantities_cachekey(state_space, target_labels, embedded_
     # 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))
 
@@ -550,7 +550,7 @@ def _compute_embedding_quantities_cachekey(state_space, target_labels, embedded_
     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_dimensions(k))
+        _np.array([_np.prod(state_space.tensor_product_block_dimensions(k))
                    for k in range(nblocks)], _np.int64)
     cdef INT i, j