pyGSTi 0.9.12__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

@@ -261,9 +261,12 @@ def _find_amped_polynomials_for_syntheticidle(qubit_filter, idle_str, model, sin
                 #print("DB: Rank %d: running itr=%d" % (comm.Get_rank(), itr))
 
                 printer.show_progress(loc_itr - 1, nLocIters, prefix='--- Finding amped-polys for idle: ')
-                prepFid = _Circuit((), line_labels=idle_str.line_labels)
+                
                 for i, el in enumerate(prep):
-                    prepFid = prepFid + _onqubit(el, qubit_filter[i])
+                    if i==0:
+                        prepFid = _onqubit(el, qubit_filter[i])
+                    else:
+                        prepFid = prepFid + _onqubit(el, qubit_filter[i])
 
                 for meas in _itertools.product(*([single_q_meas_fiducials] * nQubits)):
 
@@ -278,9 +281,11 @@ def _find_amped_polynomials_for_syntheticidle(qubit_filter, idle_str, model, sin
                         # if all are not the same or all are not different, skip
                         if not (all(cmp) or not any(cmp)): continue
 
-                    measFid = _Circuit((), line_labels=idle_str.line_labels)
                     for i, el in enumerate(meas):
-                        measFid = measFid + _onqubit(el, qubit_filter[i])
+                        if i==0:
+                            measFid = _onqubit(el, qubit_filter[i])
+                        else:
+                            measFid = measFid + _onqubit(el, qubit_filter[i])
 
                     gatename_fidpair_list = [(prep[i], meas[i]) for i in range(nQubits)]
                     if gatename_fidpair_list in selected_gatename_fidpair_lists:
@@ -673,9 +678,11 @@ def _find_amped_polynomials_for_clifford_syntheticidle(qubit_filter, core_filter
         #        prep[ qubit_filter.index(core_ql) ] = prep_core[i]
         #    prep = tuple(prep)
 
-        prepFid = _Circuit(())
         for i, el in enumerate(prep):
-            prepFid = prepFid + _onqubit(el, qubit_filter[i])
+            if i==0:
+                prepFid = _onqubit(el, qubit_filter[i])
+            else:
+                prepFid = prepFid + _onqubit(el, qubit_filter[i])
 
         #OLD: back when we tried iterating over *all* core fiducial pairs
         # (now we think/know this is unnecessary - the "true idle" fidpairs suffice)
@@ -687,9 +694,11 @@ def _find_amped_polynomials_for_clifford_syntheticidle(qubit_filter, core_filter
         #        #    meas[ qubit_filter.index(core_ql) ] = meas_core[i]
         #        meas = tuple(meas)
 
-        measFid = _Circuit(())
         for i, el in enumerate(meas):
-            measFid = measFid + _onqubit(el, qubit_filter[i])
+            if i==0:
+                measFid = _onqubit(el, qubit_filter[i])
+            else:
+                measFid = measFid + _onqubit(el, qubit_filter[i])
 
         #print("PREPMEAS = ",prepFid,measFid)
 
@@ -891,9 +900,11 @@ def _get_fidpairs_needed_to_access_amped_polynomials(qubit_filter, core_filter,
                     prep[qubit_filter.index(core_ql)] = prep_core[i]
                 prep = tuple(prep)
 
-            prepFid = _Circuit(())
             for i, el in enumerate(prep):
-                prepFid = prepFid + _onqubit(el, qubit_filter[i])
+                if i==0:
+                    prepFid = _onqubit(el, qubit_filter[i])
+                else:
+                    prepFid = prepFid + _onqubit(el, qubit_filter[i])
 
             #for meas in _itertools.product(*([single_q_fiducials]*nQubits) ):
             #for meas_core in _itertools.product(*([single_q_fiducials]*nCore) ):
@@ -908,9 +919,11 @@ def _get_fidpairs_needed_to_access_amped_polynomials(qubit_filter, core_filter,
                         meas[qubit_filter.index(core_ql)] = meas_core[i]
                     meas = tuple(meas)
 
-                measFid = _Circuit(())
                 for i, el in enumerate(meas):
-                    measFid = measFid + _onqubit(el, qubit_filter[i])
+                    if i==0:
+                        measFid = _onqubit(el, qubit_filter[i])
+                    else:
+                        measFid = measFid + _onqubit(el, qubit_filter[i])
                 #print("CONSIDER: ",prep,"-",meas)
 
                 opstr = prepFid + germ_power_str + measFid  # should be a Circuit
@@ -1324,7 +1337,7 @@ def _get_candidates_for_core(model, core_qubits, candidate_counts, seed_start):
     return candidate_germs
 
 
-@_deprecated_fn("Use pygsti.circuits.create_standard_cloudnoise_circuits(...).")
+@_deprecated_fn("Use pygsti.circuits.create_cloudnoise_circuits(...).")
 def _create_xycnot_cloudnoise_circuits(num_qubits, max_lengths, geometry, cnot_edges, max_idle_weight=1, maxhops=0,
                                        extra_weight_1_hops=0, extra_gate_weight=0, parameterization="H+S",
                                        verbosity=0, cache=None, idle_only=False,
@@ -2151,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)
@@ -647,9 +642,9 @@ class DataComparator():
             if self.inconsistent_datasets_detected:
                 print("The data are INCONSISTENT at {0:.2f}% significance.".format(self.significance * 100))
                 print("  - Details:")
-                print("    - The aggregate log-_likelihood ratio test is "
+                print("    - The aggregate log-likelihood ratio test is "
                       "significant at {0:.2f} standard deviations.".format(self._aggregate_nsigma))
-                print("    - The aggregate log-_likelihood ratio test "
+                print("    - The aggregate log-likelihood ratio test "
                       "standard deviations signficance threshold is {0:.2f}".format(self._aggregate_nsigma_threshold))
                 print(
                     "    - The number of sequences with data that is "

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,
@@ -1716,7 +1718,9 @@ class DataSet(_MongoSerializable):
 
     def _add_raw_arrays(self, circuit, oli_array, time_array, rep_array,
                         overwrite_existing, record_zero_counts, aux):
-
+        assert not self.bStatic, "Attempting to add arrays to a static DataSet. " + \
+            "Consider using .copy_nonstatic() to get a mutable DataSet first."
+        
         if rep_array is None:
             if self.repData is not None:
                 rep_array = _np.ones(len(oli_array), self.repType)
@@ -2114,7 +2118,8 @@ class DataSet(_MongoSerializable):
         -------
         None
         """
-        if self.bStatic: raise ValueError("Cannot add data to a static DataSet object")
+        if self.bStatic: raise ValueError("Cannot add data to a static DataSet object." + \
+            "Consider using .copy_nonstatic() to get a mutable DataSet first.")
         for circuit, dsRow in other_data_set.items():
             self.add_raw_series_data(circuit, dsRow.outcomes, dsRow.time, dsRow.reps, False)
 

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]