pyGSTi 0.9.12__cp38-cp38-win32.whl → 0.9.13__cp38-cp38-win32.whl

pygsti/protocols/treenode.py

@@ -106,11 +106,14 @@ class TreeNode(object):
         #else:  # just take from already-loaded edesign
         #    child_id_suffixes = preloaded_edesign._dirs.copy()
 
-        self._dirs = {nm: subdir for subdir, nm in doc['children'].items()}
+        def _to_immutable(x):
+            return tuple(x) if isinstance(x, list) else x
+
+        self._dirs = {_to_immutable(nm): subdir for subdir, nm in doc['children'].items()}
         self._vals = {}
 
         for subdir, child_id in doc['children_ids'].items():
-            child_nm = doc['children'][subdir]
+            child_nm = _to_immutable(doc['children'][subdir])
             child_doc = mongodb[doc['children_collection_name']].find_one({'_id': child_id})
             if child_doc is None:  # if there's no child document, generate the child value later
                 continue  # don't load anything - create child value on demand
@@ -134,6 +137,9 @@ class TreeNode(object):
     def __len__(self):
         return len(self._dirs)
 
+    def __iter__(self):
+        return iter(self._dirs)
+
     def items(self):
         """
         An iterator over the `(child_name, child_node)` pairs of this node.

pygsti/protocols/vb.py

@@ -11,11 +11,12 @@ Volumetric Benchmarking Protocol objects
 #***************************************************************************************************
 
 import numpy as _np
+import copy as _copy
 
-from pygsti.protocols import protocol as _proto
-from pygsti.models.oplessmodel import SuccessFailModel as _SuccessFailModel
 from pygsti import tools as _tools
 from pygsti.algorithms import randomcircuit as _rc
+from pygsti.protocols import protocol as _proto
+from pygsti.models.oplessmodel import SuccessFailModel as _SuccessFailModel
 
 
 class ByDepthDesign(_proto.CircuitListsDesign):
@@ -67,6 +68,25 @@ class ByDepthDesign(_proto.CircuitListsDesign):
         mapped_qubit_labels = self._mapped_qubit_labels(mapper)
         return ByDepthDesign(self.depths, mapped_circuit_lists, mapped_qubit_labels, remove_duplicates=False)
 
+    def truncate_to_lists(self, list_indices_to_keep):
+        """
+        Truncates this experiment design by only keeping a subset of its circuit lists.
+
+        Parameters
+        ----------
+        list_indices_to_keep : iterable
+            A list of the (integer) list indices to keep.
+
+        Returns
+        -------
+        ByDepthDesign
+            The truncated experiment design.
+        """
+        ret = _copy.deepcopy(self) # Works for derived classes too
+        ret.depths = [self.depths[i] for i in list_indices_to_keep]
+        ret.circuit_lists = [self.circuit_lists[i] for i in list_indices_to_keep]
+        return ret
+
 
 class BenchmarkingDesign(ByDepthDesign):
     """
@@ -98,12 +118,27 @@ class BenchmarkingDesign(ByDepthDesign):
         Whether to remove duplicates when automatically creating
         all the circuits that need data.
     """
+    
+    paired_with_circuit_attrs = None
+    """List of attributes which are paired up with circuit lists
+
+    These will be saved as external files during serialization,
+    and are truncated when circuit lists are truncated.
+    """
 
     def __init__(self, depths, circuit_lists, ideal_outs, qubit_labels=None, remove_duplicates=False):
         assert(len(depths) == len(ideal_outs))
         super().__init__(depths, circuit_lists, qubit_labels, remove_duplicates)
+        
         self.idealout_lists = ideal_outs
-        self.auxfile_types['idealout_lists'] = 'json'
+
+        if self.paired_with_circuit_attrs is None:
+            self.paired_with_circuit_attrs = ['idealout_lists']
+        else:
+            self.paired_with_circuit_attrs.insert(0, 'idealout_lists')
+        
+        for paired_attr in self.paired_with_circuit_attrs:
+            self.auxfile_types[paired_attr] = 'json'
 
     def _mapped_circuits_and_idealouts_by_depth(self, mapper):
         """ Used in derived classes """
@@ -133,6 +168,76 @@ class BenchmarkingDesign(ByDepthDesign):
         mapped_qubit_labels = self._mapped_qubit_labels(mapper)
         return BenchmarkingDesign(self.depths, mapped_circuit_lists, list(self.idealout_lists),
                                   mapped_qubit_labels, remove_duplicates=False)
+    
+    def truncate_to_lists(self, list_indices_to_keep):
+        """
+        Truncates this experiment design by only keeping a subset of its circuit lists.
+
+        Parameters
+        ----------
+        list_indices_to_keep : iterable
+            A list of the (integer) list indices to keep.
+
+        Returns
+        -------
+        BenchmarkingDesign
+            The truncated experiment design.
+        """
+        ret = _copy.deepcopy(self) # Works for derived classes too
+        ret.depths = [self.depths[i] for i in list_indices_to_keep]
+        ret.circuit_lists = [self.circuit_lists[i] for i in list_indices_to_keep]
+        for paired_attr in self.paired_with_circuit_attrs:
+            val = getattr(self, paired_attr)
+            new_val = [val[i] for i in list_indices_to_keep]
+            setattr(ret, paired_attr, new_val)
+        return ret
+
+    def _truncate_to_circuits_inplace(self, circuits_to_keep):
+        truncated_circuit_lists = []
+        paired_attr_lists_list = [getattr(self, paired_attr) for paired_attr in self.paired_with_circuit_attrs]
+        truncated_paired_attr_lists_list = [[] for _ in range(len(self.paired_with_circuit_attrs))]
+        for list_idx, circuits in enumerate(self.circuit_lists):
+            paired_attrs = [pal[list_idx] for pal in paired_attr_lists_list]
+            # Do the same filtering as CircuitList.truncate, but drag along any paired attributes
+            new_data = list(zip(*filter(lambda ci: ci[0] in set(circuits_to_keep), zip(circuits, *paired_attrs))))
+            if len(new_data):
+                truncated_circuit_lists.append(new_data[0])
+                for i, attr_data in enumerate(new_data[1:]):
+                    truncated_paired_attr_lists_list[i].append(attr_data)
+            else:
+                # If we have truncated all circuits, append empty lists
+                truncated_circuit_lists.append([])
+                truncated_paired_attr_lists_list.append([[] for _ in range(len(self.paired_with_circuit_attrs))])
+
+        self.circuit_lists = truncated_circuit_lists
+        for paired_attr, paired_attr_lists in zip(self.paired_with_circuit_attrs, truncated_paired_attr_lists_list):
+            setattr(self, paired_attr, paired_attr_lists)
+        super()._truncate_to_circuits_inplace(circuits_to_keep)
+
+    def _truncate_to_design_inplace(self, other_design):
+        truncated_circuit_lists = []
+        paired_attr_lists_list = [getattr(self, paired_attr) for paired_attr in self.paired_with_circuit_attrs]
+        truncated_paired_attr_lists_list = [[] for _ in range(len(self.paired_with_circuit_attrs))]
+        for list_idx, circuits in enumerate(self.circuit_lists):
+            paired_attrs = [pal[list_idx] for pal in paired_attr_lists_list]
+            # Do the same filtering as CircuitList.truncate, but drag along any paired attributes
+            new_data = list(zip(*filter(lambda ci: ci[0] in set(other_design.circuit_lists[list_idx]), zip(circuits, *paired_attrs))))
+            if len(new_data):
+                truncated_circuit_lists.append(new_data[0])
+                for i, attr_data in enumerate(new_data[1:]):
+                    truncated_paired_attr_lists_list[i].append(attr_data)
+            else:
+                # If we have truncated all circuits, append empty lists
+                truncated_circuit_lists.append([])
+                truncated_paired_attr_lists_list.append([[] for _ in range(len(self.paired_with_circuit_attrs))])
+
+        self.circuit_lists = truncated_circuit_lists
+        for paired_attr, paired_attr_lists in zip(self.paired_with_circuit_attrs, truncated_paired_attr_lists_list):
+            setattr(self, paired_attr, paired_attr_lists)
+        super()._truncate_to_design_inplace(other_design)
+
+    def _truncate_to_available_data_inplace(self, dataset):
+        self._truncate_to_circuits_inplace(set(dataset.keys()))
 
 
 class PeriodicMirrorCircuitDesign(BenchmarkingDesign):
@@ -351,10 +456,6 @@ class PeriodicMirrorCircuitDesign(BenchmarkingDesign):
                                                                   self.descriptor)
 
 
-
-
-
-
 class SummaryStatistics(_proto.Protocol):
     """
     A protocol that can construct "summary" quantities from raw data.
@@ -521,17 +622,6 @@ class SummaryStatistics(_proto.Protocol):
 
         return self._compute_dict(data, self.circuit_statistics, _get_circuit_values, for_passes="first")
 
-    # def compute_dscmp_data(self, data, dscomparator):
-
-    #     def get_dscmp_values(icirc, circ, dsrow, idealout):
-    #         ret = {'tvds': dscomparator.tvds.get(circ, _np.nan),
-    #                'pvals': dscomparator.pVals.get(circ, _np.nan),
-    #                'jsds': dscomparator.jsds.get(circ, _np.nan),
-    #                'llrs': dscomparator.llrs.get(circ, _np.nan)}
-    #         return ret
-
-    #     return self.compute_dict(data, "dscmpdata", self.dsmp_statistics, get_dscmp_values, for_passes="none")
-
     def _compute_predicted_probs(self, data, model):
         """
         Compute the predicted success probabilities of `model` given `data`.
@@ -909,17 +999,6 @@ class ByDepthSummaryStatistics(SummaryStatistics):
             results.statistics[statistic_nm] = statistic_per_dwc
         return results
 
-# This is currently not used I think
-# class PredictedByDepthSummaryStatsConstructor(ByDepthSummaryStatsConstructor):
-#     """
-#     Runs a volumetric benchmark on success/fail data predicted from a model
-
-#     """
-#     def __init__(self, model_or_summary_data, depths='all', statistic='mean',
-#                  dscomparator=None, name=None):
-#         super().__init__(depths, 'success_probabilities', statistic,
-#                          dscomparator, model_or_summary_data, name)
-
 
 class SummaryStatisticsResults(_proto.ProtocolResults):
     """
@@ -951,180 +1030,3 @@ class SummaryStatisticsResults(_proto.ProtocolResults):
                 "SummaryStatisticsResults.statistics dict should be populated with NamedDicts, not %s" % str(type(v))
             stats[k] = v
         return stats
-
-
-#BDB = ByDepthBenchmark
-#VBGrid = VolumetricBenchmarkGrid
-#VBResults = VolumetricBenchmarkingResults  # shorthand
-
-#Add something like this?
-#class PassStabilityTest(_proto.Protocol):
-#    pass
-
-# Commented out as we are not using this currently. todo: revive or delete this in the future.
-# class VolumetricBenchmarkGrid(Benchmark):
-#     """ A protocol that creates an entire depth vs. width grid of volumetric benchmark values """
-
-#     def __init__(self, depths='all', widths='all', datatype='success_probabilities',
-#                  paths='all', statistic='mean', aggregate=True, rescaler='auto',
-#                  dscomparator=None, name=None):
-
-#         super().__init__(name)
-#         self.postproc = VolumetricBenchmarkGridPP(depths, widths, datatype, paths, statistic, aggregate, self.name)
-#         self.dscomparator = dscomparator
-#         self.rescaler = rescaler
-
-#         self.auxfile_types['postproc'] = 'protocolobj'
-#         self.auxfile_types['dscomparator'] = 'pickle'
-#         self.auxfile_types['rescaler'] = 'reset'  # punt for now - fix later
-
-#     def run(self, data, memlimit=None, comm=None):
-#         #Since we know that VolumetricBenchmark protocol objects Create a single results just fill
-#         # in data under the result object's 'volumetric_benchmarks' and 'failure_counts'
-#         # keys, and these are indexed by width and depth (even though each VolumetricBenchmark
-#         # only contains data for a single width), we can just "merge" the VB results of all
-#         # the underlying by-depth datas, so long as they're all for different widths.
-
-#         #Then run resulting data normally, giving a results object
-#         # with "top level" dicts correpsonding to different paths
-#         VB = ByDepthBenchmark(self.postproc.depths, self.postproc.datatype, self.postproc.statistic,
-#                               self.rescaler, self.dscomparator, name=self.name)
-#         separate_results = _proto.SimpleRunner(VB).run(data, memlimit, comm)
-#         pp_results = self.postproc.run(separate_results, memlimit, comm)
-#         pp_results.protocol = self
-#         return pp_results
-
-
-# Commented out as we are not using this currently. todo: revive this in the future.
-# class VolumetricBenchmark(_proto.ProtocolPostProcessor):
-#     """ A postprocesor that constructs a volumetric benchmark from existing results. """
-
-#     def __init__(self, depths='all', widths='all', datatype='polarization',
-#                  statistic='mean', paths='all', edesigntype=None, aggregate=True,
-#                  name=None):
-
-#         super().__init__(name)
-#         self.depths = depths
-#         self.widths = widths
-#         self.datatype = datatype
-#         self.paths = paths if paths == 'all' else sorted(paths)  # need to ensure paths are grouped by common prefix
-#         self.statistic = statistic
-#         self.aggregate = aggregate
-#         self.edesigntype = edesigntype
-
-#     def run(self, results, memlimit=None, comm=None):
-#         data = results.data
-#         paths = results.get_tree_paths() if self.paths == 'all' else self.paths
-#         #Note: above won't work if given just a results object - needs a dir
-
-#         #Process results
-#         #Merge/flatten the data from different paths into one depth vs width grid
-#         passnames = list(data.passes.keys()) if data.is_multipass() else [None]
-#         passresults = []
-#         for passname in passnames:
-#             vb = _tools.NamedDict('Depth', 'int', None, None)
-#             fails = _tools.NamedDict('Depth', 'int', None, None)
-#             path_for_gridloc = {}
-#             for path in paths:
-#                 #TODO: need to be able to filter based on widths... - maybe replace .update calls
-#                 # with something more complicated when width != 'all'
-#                 #print("Aggregating path = ", path)  #TODO - show progress something like this later?
-
-#                 #Traverse path to get to root of VB data
-#                 root = results
-#                 for key in path:
-#                     root = root[key]
-#                 root = root.for_protocol.get(self.name, None)
-#                 if root is None: continue
-
-#                 if passname:  # then we expect final Results are MultiPassResults
-#                     root = root.passes[passname]  # now root should be a BenchmarkingResults
-#                 assert(isinstance(root, VolumetricBenchmarkingResults))
-#                 if self.edesigntype is None:
-#                     assert(isinstance(root.data.edesign, ByDepthDesign)), \
-#                         "All paths must lead to by-depth exp. design, not %s!" % str(type(root.data.edesign))
-#                 else:
-#                     if not isinstance(root.data.edsign, self.edesigntype):
-#                         continue
-
-#                 #Get the list of depths we'll extract from this (`root`) sub-results
-#                 depths = root.data.edesign.depths if (self.depths == 'all') else \
-#                     filter(lambda d: d in self.depths, root.data.edesign.depths)
-#                 width = len(root.data.edesign.qubit_labels)  # sub-results contains only a single width
-#                 if self.widths != 'all' and width not in self.widths: continue  # skip this one
-
-#                 for depth in depths:
-#                     if depth not in vb:  # and depth not in fails
-#                         vb[depth] = _tools.NamedDict('Width', 'int', 'Value', 'float')
-#                         fails[depth] = _tools.NamedDict('Width', 'int', 'Value', None)
-#                         path_for_gridloc[depth] = {}  # just used for meaningful error message
-
-#                     if width in path_for_gridloc[depth]:
-#                         raise ValueError(("Paths %s and %s both give data for depth=%d, width=%d!  Set the `paths`"
-#                                           " argument of this VolumetricBenchmarkGrid to avoid this.") %
-#                                          (str(path_for_gridloc[depth][width]), str(path), depth, width))
-
-#                     vb[depth][width] = root.volumetric_benchmarks[depth][width]
-#                     fails[depth][width] = root.failure_counts[depth][width]
-#                     path_for_gridloc[depth][width] = path
-
-#             if self.statistic in ('minmin', 'maxmax') and not self.aggregate:
-#                 self._update_vb_minmin_maxmax(vb)   # aggregate now since we won't aggregate over passes
-
-#             #Create Results
-#             results = VolumetricBenchmarkingResults(data, self)
-#             results.volumetric_benchmarks = vb
-#             results.failure_counts = fails
-#             passresults.append(results)
-
-#         agg_fn = _get_statistic_function(self.statistic)
-
-#         if self.aggregate and len(passnames) > 1:  # aggregate pass data into a single set of qty dicts
-#             agg_vb = _tools.NamedDict('Depth', 'int', None, None)
-#             agg_fails = _tools.NamedDict('Depth', 'int', None, None)
-#             template = passresults[0].volumetric_benchmarks  # to get widths and depths
-
-#             for depth, template_by_width_data in template.items():
-#                 agg_vb[depth] = _tools.NamedDict('Width', 'int', 'Value', 'float')
-#                 agg_fails[depth] = _tools.NamedDict('Width', 'int', 'Value', None)
-
-#                 for width in template_by_width_data.keys():
-#                     # ppd = "per pass data"
-#                     vb_ppd = [r.volumetric_benchmarks[depth][width] for r in passresults]
-#                     fail_ppd = [r.failure_counts[depth][width] for r in passresults]
-
-#                     successcount = 0
-#                     failcount = 0
-#                     for (successcountpass, failcountpass) in fail_ppd:
-#                         successcount += successcountpass
-#                         failcount += failcountpass
-#                     agg_fails[depth][width] = (successcount, failcount)
-
-#                     if self.statistic == 'dist':
-#                         agg_vb[depth][width] = [item for sublist in vb_ppd for item in sublist]
-#                     else:
-#                         agg_vb[depth][width] = agg_fn(vb_ppd)
-
-#             aggregated_results = VolumetricBenchmarkingResults(data, self)
-#             aggregated_results.volumetric_benchmarks = agg_vb
-#             aggregated_results.failure_counts = agg_fails
-
-#             if self.statistic in ('minmin', 'maxmax'):
-#                 self._update_vb_minmin_maxmax(aggregated_results.qtys['volumetric_benchmarks'])
-#             return aggregated_results  # replace per-pass results with aggregated results
-#         elif len(passnames) > 1:
-#             multipass_results = _proto.MultiPassResults(data, self)
-#             multipass_results.passes.update({passname: r for passname, r in zip(passnames, passresults)})
-#             return multipass_results
-#         else:
-#             return passresults[0]
-
-#     def _update_vb_minmin_maxmax(self, vb):
-#         for d in vb.keys():
-#             for w in vb[d].keys():
-#                 for d2 in vb.keys():
-#                     for w2 in vb[d2].keys():
-#                         if self.statistic == 'minmin' and d2 <= d and w2 <= w and vb[d2][w2] < vb[d][w]:
-#                             vb[d][w] = vb[d2][w2]
-#                         if self.statistic == 'maxmax' and d2 >= d and w2 >= w and vb[d2][w2] > vb[d][w]:
-#                             vb[d][w] = vb[d2][w2]

pygsti/protocols/vbdataframe.py

@@ -19,7 +19,7 @@ def _calculate_summary_statistic(x, statistic, lower_cutoff=None):
     Utility function that returns statistic(x), or the maximum
     of statistic(x) and lower_cutoff if lower_cutoff is not None.
     """
-    if len(x) == 0 or _np.all(_np.isnan(x)): return _np.NaN
+    if len(x) == 0 or _np.all(_np.isnan(x)): return _np.nan
     if statistic == 'mean': func = _np.nanmean
     elif statistic == 'max' or statistic == 'monotonic_max': func = _np.nanmax
     elif statistic == 'min' or statistic == 'monotonic_min': func = _np.nanmin

pygsti/report/factory.py

@@ -84,21 +84,6 @@ def _add_new_estimate_labels(running_lbls, estimates, combine_robust):
     return running_lbls
 
 
-#def _robust_estimate_has_same_models(estimates, est_lbl):
-#    lbl_robust = est_lbl+ROBUST_SUFFIX
-#    if lbl_robust not in estimates: return False #no robust estimate
-#
-#    for mdl_lbl in list(estimates[est_lbl].goparameters.keys()) \
-#        + ['final iteration estimate']:
-#        if mdl_lbl not in estimates[lbl_robust].models:
-#            return False #robust estimate is missing mdl_lbl!
-#
-#        mdl = estimates[lbl_robust].models[mdl_lbl]
-#        if estimates[est_lbl].models[mdl_lbl].frobeniusdist(mdl) > 1e-8:
-#            return False #model mismatch!
-#
-#    return True
-
 def _get_viewable_crf(est, est_lbl, mdl_lbl, verbosity=0):
     printer = _VerbosityPrinter.create_printer(verbosity)
 

pygsti/report/fogidiagram.py

@@ -379,10 +379,6 @@ class FOGIGraphDiagram(FOGIDiagram):
     def _normalize(self, v):
         return -_np.log10(max(v, 10**(-self.MAX_POWER)) * 10**self.MIN_POWER) / (self.MAX_POWER - self.MIN_POWER)
 
-    #def _normalize(v):
-    #    v = min(max(v, 10**(-MAX_POWER)), 10**(-MIN_POWER))
-    #    return 1.0 - v / (10**(-MIN_POWER) - 10**(-MAX_POWER))
-
     def _node_HScolor(self, Hvalue, Svalue):
         r, g, b, a = _Hcmap(self._normalize(Hvalue))
         r2, g2, b2, a2 = _Scmap(self._normalize(Svalue))
@@ -622,18 +618,6 @@ class FOGISvgGraphDiagram(FOGIGraphDiagram):
         if filename: d.saveSvg(filename)
         return d
 
-    #def _draw_node_simple(self, drawing, r, theta, coh, sto, op_label, total, val_max):
-    #    nodes = drawing.nodes
-    #    back_color, border_color, tcolor, _, labels, _ = self._get_node_colors(coh, sto, total)
-    #    x, y = r * _np.cos(theta), r * _np.sin(theta)
-    #    scale = (coh + sto) / val_max
-    #    node_width = 20 + 40 * scale
-    #    node_height = 20 + 40 * scale
-    #    nodes.append(_draw.Rectangle(x - node_width / 2, y - node_height / 2, node_width, node_height, rx=3,
-    #                                 fill=back_color, stroke=border_color, stroke_width=2))
-    #    nodes.append(_draw.Text(labels, self.node_fontsize * (0.5 + scale), x, y, fill=tcolor,
-    #                            text_anchor="middle", valign='middle', font_family='Times'))
-
     def _draw_node(self, drawing, r, theta, coh, sto, op_label, total, val_max, groupid, info):
         nodes = drawing.nodes
         back_color, border_color, tcolor, _, labels, _ = self._get_node_colors(coh, sto, total)
@@ -1038,7 +1022,7 @@ class FOGIMultiscaleGridDiagram(FOGIDiagram):
         for i in range(nOps):
             for j in range(i, nOps):
                 total_items[i, j] = sum([len(by_qty_items[qty][i, j]) for qty in all_qtys])
-                if total_items[i, j] == 0: totals[i, j] = _np.NaN
+                if total_items[i, j] == 0: totals[i, j] = _np.nan
 
         box_size_mode = "condensed"  # or "inflated"
         if detail_level == 2:

pygsti/report/modelfunction.py

@@ -10,6 +10,8 @@ Defines the ModelFunction class
 # http://www.apache.org/licenses/LICENSE-2.0 or in the LICENSE file in the root pyGSTi directory.
 #***************************************************************************************************
 
+from pygsti.models.explicitmodel import ExplicitOpModel as _ExplicitOpModel
+from pygsti.models.localnoisemodel import LocalNoiseModel as _LocalNoiseModel
 
 class ModelFunction(object):
     """
@@ -233,9 +235,16 @@ def opsfn_factory(fn):
 
         def evaluate(self, model):
             """ Evaluate this gate-set-function at `model`."""
-            return fn(model.operations[self.gl].to_dense(on_space='HilbertSchmidt'),
-                      self.other_model.operations[self.gl].to_dense(on_space='HilbertSchmidt'),
-                      model.basis, *self.args, **self.kwargs)  # assume functions want *dense* gates
+            if isinstance(model, _ExplicitOpModel):
+                return fn(model.operations[self.gl].to_dense(on_space='HilbertSchmidt'),
+                          self.other_model.operations[self.gl].to_dense(on_space='HilbertSchmidt'),
+                          model.basis, *self.args, **self.kwargs)  # assume functions want *dense* gates
+            elif isinstance(model, _LocalNoiseModel):
+                return fn(model.operation_blks['gates'][self.gl].to_dense(on_space='HilbertSchmidt'),
+                          self.other_model.operation_blks['gates'][self.gl].to_dense(on_space='HilbertSchmidt'),
+                          model.basis, *self.args, **self.kwargs)  # assume functions want *dense* gates
+            else:
+                raise ValueError(f"Unsupported model type: {type(model)}!")
 
     GSFTemp.__name__ = fn.__name__ + str("_class")
     return GSFTemp

pygsti/report/mpl_colormaps.py

@@ -540,7 +540,7 @@ def plotly_to_matplotlib(pygsti_fig, save_to=None, fontsize=12, prec='compacthp'
                 axes.bar(x, y, barWidth, color=color)
             else:
                 axes.bar(x, y, barWidth, color=color,
-                         yerr=yerr.flatten().real)
+                         yerr=yerr.ravel().real)
 
             if xtickvals is not None:
                 xtics = _np.array(xtickvals) + 0.5  # _np.arange(plt_data.shape[1])+0.5

pygsti/report/plothelpers.py

@@ -18,6 +18,7 @@ from pygsti import tools as _tools
 from pygsti.objectivefns import objectivefns as _objfns
 from pygsti.circuits.circuitlist import CircuitList as _CircuitList
 from pygsti.baseobjs.smartcache import smart_cached
+from pygsti.baseobjs import Label
 
 
 def small_eigenvalue_err_rate(sigma, direct_gst_models):
@@ -43,7 +44,8 @@ def small_eigenvalue_err_rate(sigma, direct_gst_models):
     """
     if sigma is None: return _np.nan  # in plot processing, "None" circuits = no plot output = nan values
     mdl_direct = direct_gst_models[sigma]
-    minEigval = min(abs(_np.linalg.eigvals(mdl_direct.operations["GsigmaLbl"])))
+    key = Label('GsigmaLbl') if sigma.line_labels == ('*',) else Label('GsigmaLbl', sigma.line_labels)
+    minEigval = min(abs(_np.linalg.eigvals(mdl_direct.operations[key])))
     # (approximate) per-gate error rate; max averts divide by zero error
     return 1.0 - minEigval**(1.0 / max(len(sigma), 1))
 
@@ -101,7 +103,7 @@ def _eformat(f, prec):
 
 
 def _num_non_nan(array):
-    ixs = _np.where(_np.isnan(_np.array(array).flatten()) == False)[0]  # noqa: E712
+    ixs = _np.where(_np.isnan(_np.array(array).ravel()) == False)[0]  # noqa: E712
     return int(len(ixs))
 
 
@@ -145,7 +147,7 @@ def _compute_num_boxes_dof(sub_mxs, sum_up, element_dof):
 
         # Gets all the non-NaN boxes, flattens the resulting
         # array, and does the sum.
-        n_boxes = _np.sum(~_np.isnan(sub_mxs).flatten())
+        n_boxes = _np.sum(~_np.isnan(sub_mxs).ravel())
 
     return n_boxes, dof_per_box
 
@@ -156,7 +158,13 @@ def _compute_sub_mxs(gss, model, sub_mx_creation_fn, dataset=None, sub_mx_creati
                for x in gss.used_xs] for y in gss.used_ys]
     #Note: subMxs[y-index][x-index] is proper usage
     return subMxs
+    
+#define a modified version that is meant for working with CircuitList objects of lists of them.
+#@smart_cached
+def _compute_sub_mxs_circuit_list(circuit_lists, model, sub_mx_creation_fn, dataset=None, sub_mx_creation_fn_extra_arg=None):
+    subMxs = [sub_mx_creation_fn(circuit_list, sub_mx_creation_fn_extra_arg) for circuit_list in circuit_lists]
 
+    return subMxs
 
 @smart_cached
 def dscompare_llr_matrices(gsplaq, dscomparator):

pygsti/report/report.py

@@ -206,6 +206,11 @@ class Report:
         who want to tinker with the standard analysis presented in the static
         HTML or LaTeX format reports.
 
+        Note that interactive cells in report notebooks require JavaScript,
+        and therefore do not work with JupyterLab. Please continue to use
+        classic Jupyter notebooks for PyGSTi report notebooks. To track this issue,
+        see https://github.com/pyGSTio/pyGSTi/issues/205.
+
         Parameters
         ----------
         path : str or path-like object
@@ -249,6 +254,12 @@ class Report:
         nb = _Notebook()
         nb.add_markdown('# {title}\n(Created on {date})'.format(
             title=title, date=_time.strftime("%B %d, %Y")))
+        
+        nb.add_markdown("## JupyterLab Incompatibility Warning\n" + 
+        "<font color='red'>Note that interactive cells in report notebooks require JavaScript, " +
+        "and therefore do not work with JupyterLab. Please continue to use " +
+        "classic Jupyter notebooks for PyGSTi report notebooks. To track this issue, " +
+        "see https://github.com/pyGSTio/pyGSTi/issues/205.</font>")
 
         nb.add_code("""\
             import pickle
@@ -353,6 +364,11 @@ class Report:
 
         printer.log("Report Notebook created as %s" % path)
 
+        printer.warning("""Note that interactive cells in report notebooks require JavaScript,
+         and therefore do not work with JupyterLab. Please continue to use
+         classic Jupyter notebooks for PyGSTi report notebooks. To track this issue,
+         see https://github.com/pyGSTio/pyGSTi/issues/205.""")
+
         if auto_open:
             port = "auto" if auto_open is True else int(auto_open)
             nb.launch(str(path), port=port)