cirq-core 1.4.0.dev20240529225110__py3-none-any.whl → 1.5.0__py3-none-any.whl

cirq/vis/heatmap.py

@@ -11,6 +11,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+from __future__ import annotations
+
 import copy
 from dataclasses import astuple, dataclass
 from typing import (
@@ -111,6 +114,7 @@ class Heatmap:
                     applying format(value, annotation_format) for each key in value_map.
                     This is ignored if annotation_map is explicitly specified.
                 annotation_text_kwargs: Matplotlib Text **kwargs,
+                highlighted_qubits: An iterable of qubits to highlight.
 
                 colorbar_position: {'right', 'left', 'top', 'bottom'}, default = 'right'
                 colorbar_size: str, default = '5%'
@@ -157,6 +161,7 @@ class Heatmap:
             "annotation_map",
             "annotation_text_kwargs",
             "annotation_format",
+            "highlighted_qubits",
         ]
         valid_kwargs = (
             valid_colorbar_kwargs
@@ -231,13 +236,14 @@ class Heatmap:
         ax: plt.Axes,
     ) -> None:
         """Writes annotations to the center of cells. Internal."""
-        for (center, annotation), facecolor in zip(centers_and_annot, collection.get_facecolor()):
+        face_colors = cast(np.ndarray, collection.get_facecolor())
+        for (center, annotation), facecolor in zip(centers_and_annot, face_colors):
             # Calculate the center of the cell, assuming that it is a square
             # centered at (x=col, y=row).
             if not annotation:
                 continue
             x, y = center
-            face_luminance = vis_utils.relative_luminance(facecolor)  # type: ignore
+            face_luminance = vis_utils.relative_luminance(facecolor)
             text_color = 'black' if face_luminance > 0.4 else 'white'
             text_kwargs: Dict[str, Any] = dict(color=text_color, ha="center", va="center")
             text_kwargs.update(self._config.get('annotation_text_kwargs', {}))
@@ -294,11 +300,41 @@ class Heatmap:
             is plotted on. ``collection`` is the collection of paths drawn and filled.
         """
         show_plot = not ax
-        if not ax:
+        if ax is None:
             fig, ax = plt.subplots(figsize=(8, 8))
-            ax = cast(plt.Axes, ax)
         original_config = copy.deepcopy(self._config)
         self.update_config(**kwargs)
+
+        highlighted_qubits = frozenset(kwargs.get("highlighted_qubits", ()))
+        if highlighted_qubits:
+            edgecolors = tuple(
+                (
+                    "red"
+                    if not highlighted_qubits.isdisjoint(qubits)
+                    else self._config["collection_options"].get("edgecolors", "grey")
+                )
+                for qubits in sorted(self._value_map.keys())
+            )
+            linestyles = tuple(
+                (
+                    "solid"
+                    if not highlighted_qubits.isdisjoint(qubits)
+                    else self._config["collection_options"].get("linestyles", "dashed")
+                )
+                for qubits in sorted(self._value_map.keys())
+            )
+            linewidths = tuple(
+                (
+                    4
+                    if not highlighted_qubits.isdisjoint(qubits)
+                    else self._config["collection_options"].get("linewidths", 2)
+                )
+                for qubits in sorted(self._value_map.keys())
+            )
+            self._config["collection_options"].update(
+                {"edgecolors": edgecolors, "linestyles": linestyles, "linewidths": linewidths}
+            )
+
         collection = self._plot_on_axis(ax)
         if show_plot:
             fig.show()
@@ -381,22 +417,23 @@ class TwoQubitInteractionHeatmap(Heatmap):
             is plotted on. ``collection`` is the collection of paths drawn and filled.
         """
         show_plot = not ax
-        if not ax:
+        if ax is None:
             fig, ax = plt.subplots(figsize=(8, 8))
-            ax = cast(plt.Axes, ax)
         original_config = copy.deepcopy(self._config)
         self.update_config(**kwargs)
         qubits = set([q for qubits in self._value_map.keys() for q in qubits])
+        collection_options: Dict[str, Any] = {"cmap": "binary"}
+        highlighted_qubits = frozenset(kwargs.get("highlighted_qubits", ()))
+        if not highlighted_qubits:
+            collection_options.update(
+                {"linewidths": 2, "edgecolors": "lightgrey", "linestyles": "dashed"}
+            )
         Heatmap({q: 0.0 for q in qubits}).plot(
             ax=ax,
-            collection_options={
-                'cmap': 'binary',
-                'linewidths': 2,
-                'edgecolor': 'lightgrey',
-                'linestyle': 'dashed',
-            },
+            collection_options=collection_options,
             plot_colorbar=False,
             annotation_format=None,
+            highlighted_qubits=highlighted_qubits,
         )
         collection = self._plot_on_axis(ax)
         if show_plot:

cirq/vis/heatmap_test.py

@@ -18,11 +18,11 @@ import shutil
 import string
 from tempfile import mkdtemp
 
-import numpy as np
-import pytest
-
 import matplotlib as mpl
 import matplotlib.pyplot as plt
+import numpy as np
+import pytest
+from matplotlib.colors import to_rgba_array
 
 from cirq.devices import grid_qubit
 from cirq.vis import heatmap
@@ -34,6 +34,11 @@ def ax():
     return figure.add_subplot(111)
 
 
+def _to_linestyle_tuple(linestyles, linewidths=None):
+    collection = mpl.collections.Collection(linestyles=linestyles, linewidths=linewidths)
+    return collection.get_linestyles()[0]
+
+
 def test_default_ax():
     row_col_list = ((0, 5), (8, 1), (7, 0), (13, 5), (1, 6), (3, 2), (2, 8))
     test_value_map = {
@@ -240,7 +245,7 @@ def test_non_float_values(ax, format_string):
     for artist in ax.get_children():
         if isinstance(artist, mpl.text.Text):
             col, row = artist.get_position()
-            if (row, col) in test_value_map:
+            if (row, col) in test_value_map:  # pragma: no cover
                 foo = test_value_map[(row, col)]
                 actual_text = artist.get_text()
                 expected_text = format(foo, format_string)
@@ -343,3 +348,162 @@ def test_plot_updates_local_config():
         _, ax = plt.subplots()
         random_heatmap.plot(ax)
         assert ax.get_title() == original_title
+
+
+@pytest.mark.usefixtures('closefigures')
+def test_heatmap_plot_highlighted_qubits():
+    value_map = {
+        (grid_qubit.GridQubit(0, 0),): 0.1,
+        (grid_qubit.GridQubit(0, 1),): 0.2,
+        (grid_qubit.GridQubit(0, 2),): 0.3,
+        (grid_qubit.GridQubit(1, 0),): 0.4,
+    }
+    single_qubit_heatmap = heatmap.Heatmap(value_map)
+
+    highlighted_qubits = [grid_qubit.GridQubit(0, 1), grid_qubit.GridQubit(1, 0)]
+
+    expected_linewidths = [2, 4, 2, 4]
+    expected_edgecolors = np.vstack(
+        (to_rgba_array("grey"), to_rgba_array("red"), to_rgba_array("grey"), to_rgba_array("red"))
+    )
+    # list of tuples: (offset, onoffseq), onoffseq = None for solid line.
+    expected_linestyles = [
+        _to_linestyle_tuple("dashed", linewidths=2),
+        _to_linestyle_tuple("solid"),
+        _to_linestyle_tuple("dashed", linewidths=2),
+        _to_linestyle_tuple("solid"),
+    ]
+
+    _, ax = plt.subplots()
+    _ = single_qubit_heatmap.plot(ax, highlighted_qubits=highlighted_qubits)
+
+    for artist in ax.get_children():
+        if isinstance(artist, mpl.collections.PolyCollection):
+            assert np.all(artist.get_linewidths() == expected_linewidths)
+            assert np.array_equal(artist.get_edgecolors(), expected_edgecolors)
+            assert artist.get_linestyles() == expected_linestyles
+
+
+@pytest.mark.usefixtures('closefigures')
+def test_heatmap_plot_highlighted_qubits_two_qubit():
+    value_map = {
+        (grid_qubit.GridQubit(0, 0), grid_qubit.GridQubit(0, 1)): 0.1,
+        (grid_qubit.GridQubit(0, 1), grid_qubit.GridQubit(0, 2)): 0.2,
+        (grid_qubit.GridQubit(1, 0), grid_qubit.GridQubit(0, 0)): 0.3,
+        (grid_qubit.GridQubit(3, 3), grid_qubit.GridQubit(3, 2)): 0.9,
+    }
+    two_qubit_interaction_heatmap = heatmap.TwoQubitInteractionHeatmap(value_map)
+
+    highlighted_qubits = [
+        grid_qubit.GridQubit(0, 1),
+        grid_qubit.GridQubit(0, 0),
+        grid_qubit.GridQubit(3, 3),
+    ]
+
+    expected_linewidths = [4, 4, 2, 2, 2, 4]
+    expected_edgecolors = np.vstack(
+        (
+            to_rgba_array("red"),
+            to_rgba_array("red"),
+            to_rgba_array("grey"),
+            to_rgba_array("grey"),
+            to_rgba_array("grey"),
+            to_rgba_array("red"),
+        )
+    )
+    # list of tuples: (offset, onoffseq), onoffseq = None for solid line.
+    expected_linestyles = [
+        _to_linestyle_tuple("solid"),
+        _to_linestyle_tuple("solid"),
+        _to_linestyle_tuple("dashed", linewidths=2),
+        _to_linestyle_tuple("dashed", linewidths=2),
+        _to_linestyle_tuple("dashed", linewidths=2),
+        _to_linestyle_tuple("solid"),
+    ]
+
+    _, ax = plt.subplots()
+    _ = two_qubit_interaction_heatmap.plot(ax, highlighted_qubits=highlighted_qubits)
+
+    for artist in ax.get_children():
+        if isinstance(artist, mpl.collections.PolyCollection):
+            # Since for two qubit interactions, there are two collections:
+            # one to highlight individual qubits and one showing their interaction.
+            # Here, the former is required, so the latter is excluded.
+            if artist.get_cmap().name != 'viridis':  # assuming 'viridis' is the default cmap used.
+                assert np.all(artist.get_linewidths() == expected_linewidths)
+                assert np.array_equal(artist.get_edgecolors(), expected_edgecolors)
+                assert artist.get_linestyles() == expected_linestyles
+
+
+@pytest.mark.usefixtures('closefigures')
+def test_heatmap_highlighted_repeat_qubits():
+    value_map = {
+        (grid_qubit.GridQubit(0, 0), grid_qubit.GridQubit(0, 1)): 0.1,
+        (grid_qubit.GridQubit(0, 1), grid_qubit.GridQubit(0, 2)): 0.2,
+        (grid_qubit.GridQubit(1, 0), grid_qubit.GridQubit(0, 0)): 0.3,
+        (grid_qubit.GridQubit(3, 3), grid_qubit.GridQubit(3, 2)): 0.9,
+    }
+    two_qubit_interaction_heatmap = heatmap.TwoQubitInteractionHeatmap(value_map)
+
+    highlighted_qubits_1 = [
+        grid_qubit.GridQubit(0, 1),
+        grid_qubit.GridQubit(0, 0),
+        grid_qubit.GridQubit(3, 3),
+    ]
+    highlighted_qubits_2 = highlighted_qubits_1 + [grid_qubit.GridQubit(0, 0)] * 5
+
+    _, ax1 = plt.subplots()
+    _ = two_qubit_interaction_heatmap.plot(ax1, highlighted_qubits=highlighted_qubits_1)
+    _, ax2 = plt.subplots()
+    _ = two_qubit_interaction_heatmap.plot(ax2, highlighted_qubits=highlighted_qubits_2)
+
+    for artist_1, artist_2 in zip(ax1.get_children(), ax2.get_children()):
+        if isinstance(artist_1, mpl.collections.PolyCollection) and isinstance(
+            artist_2, mpl.collections.PolyCollection
+        ):
+            # Since for two qubit interactions, there are two collections:
+            # one to highlight individual qubits and one showing their interaction.
+            # Here, the former is required, so the latter is excluded.
+            if (
+                artist_1.get_cmap().name != 'viridis' and artist_2.get_cmap().name != 'viridis'
+            ):  # assuming 'viridis' is the default cmap used.
+                assert np.all(artist_1.get_linewidths() == artist_1.get_linewidths())
+                assert np.array_equal(artist_1.get_edgecolors(), artist_2.get_edgecolors())
+                assert artist_1.get_linestyles() == artist_2.get_linestyles()
+
+
+@pytest.mark.usefixtures('closefigures')
+def test_heatmap_highlighted_init_collection_options_used():
+    value_map = {
+        (grid_qubit.GridQubit(0, 0),): 0.1,
+        (grid_qubit.GridQubit(0, 1),): 0.2,
+        (grid_qubit.GridQubit(0, 2),): 0.3,
+        (grid_qubit.GridQubit(1, 0),): 0.4,
+    }
+    single_qubit_heatmap = heatmap.Heatmap(
+        value_map,
+        collection_options={"edgecolors": "blue", "linewidths": 6, "linestyles": "dashed"},
+    )
+
+    highlighted_qubits = [grid_qubit.GridQubit(0, 1), grid_qubit.GridQubit(1, 0)]
+
+    expected_linewidths = [6, 4, 6, 4]
+    expected_edgecolors = np.vstack(
+        (to_rgba_array("blue"), to_rgba_array("red"), to_rgba_array("blue"), to_rgba_array("red"))
+    )
+    # list of tuples: (offset, onoffseq), onoffseq = None for solid line.
+    expected_linestyles = [
+        _to_linestyle_tuple("dashed", linewidths=6),
+        _to_linestyle_tuple("solid"),
+        _to_linestyle_tuple("dashed", linewidths=6),
+        _to_linestyle_tuple("solid"),
+    ]
+
+    _, ax = plt.subplots()
+    _ = single_qubit_heatmap.plot(ax, highlighted_qubits=highlighted_qubits)
+
+    for artist in ax.get_children():
+        if isinstance(artist, mpl.collections.PolyCollection):
+            assert np.all(artist.get_linewidths() == expected_linewidths)
+            assert np.array_equal(artist.get_edgecolors(), expected_edgecolors)
+            assert artist.get_linestyles() == expected_linestyles

cirq/vis/histogram.py

@@ -11,7 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from typing import Any, Mapping, Optional, Sequence, Union, SupportsFloat
+from typing import Any, Mapping, Optional, Sequence, SupportsFloat, Union
 
 import numpy as np
 from matplotlib import pyplot as plt

cirq/vis/histogram_test.py

@@ -13,11 +13,10 @@
 # limitations under the License.
 """Tests for Histogram."""
 
+import matplotlib.pyplot as plt
 import numpy as np
 import pytest
 
-import matplotlib.pyplot as plt
-
 from cirq.vis import integrated_histogram
 
 

cirq/vis/state_histogram.py

@@ -14,10 +14,12 @@
 
 """Tool to visualize the results of a study."""
 
-from typing import cast, Optional, Sequence, SupportsFloat, Union
 import collections
-import numpy as np
+from typing import Optional, Sequence, SupportsFloat, Union
+
 import matplotlib.pyplot as plt
+import numpy as np
+
 import cirq.study.result as result
 
 
@@ -85,13 +87,13 @@ def plot_state_histogram(
         The axis that was plotted on.
     """
     show_fig = not ax
-    if not ax:
+    if ax is None:
         fig, ax = plt.subplots(1, 1)
-        ax = cast(plt.Axes, ax)
     if isinstance(data, result.Result):
         values = get_state_histogram(data)
     elif isinstance(data, collections.Counter):
-        tick_label, values = zip(*sorted(data.items()))
+        tick_label, counts = zip(*sorted(data.items()))
+        values = np.asarray(counts)
     else:
         values = np.array(data)
     if tick_label is None:

cirq/vis/state_histogram_test.py

@@ -14,10 +14,10 @@
 
 """Tests for state_histogram."""
 
-import numpy as np
-from matplotlib import pyplot as plt
 import matplotlib as mpl
+import numpy as np
 import pytest
+from matplotlib import pyplot as plt
 
 import cirq
 from cirq.devices import GridQubit

cirq/work/__init__.py

@@ -14,20 +14,26 @@
 
 """Workflow utilities for sampling and measurement collection."""
 
-from cirq.work.collector import CircuitSampleJob, Collector
-from cirq.work.pauli_sum_collector import PauliSumCollector
-from cirq.work.observable_settings import InitObsSetting, _MeasurementSpec, observables_to_settings
-from cirq.work.observable_grouping import group_settings_greedy
+from cirq.work.collector import CircuitSampleJob as CircuitSampleJob, Collector as Collector
+from cirq.work.pauli_sum_collector import PauliSumCollector as PauliSumCollector
+from cirq.work.observable_settings import (
+    InitObsSetting as InitObsSetting,
+    _MeasurementSpec as _MeasurementSpec,
+    observables_to_settings as observables_to_settings,
+)
+from cirq.work.observable_grouping import group_settings_greedy as group_settings_greedy
 from cirq.work.observable_measurement_data import (
-    ObservableMeasuredResult,
-    BitstringAccumulator,
-    flatten_grouped_results,
+    ObservableMeasuredResult as ObservableMeasuredResult,
+    BitstringAccumulator as BitstringAccumulator,
+    flatten_grouped_results as flatten_grouped_results,
 )
 from cirq.work.observable_measurement import (
-    VarianceStoppingCriteria,
-    RepetitionsStoppingCriteria,
-    measure_grouped_settings,
+    VarianceStoppingCriteria as VarianceStoppingCriteria,
+    RepetitionsStoppingCriteria as RepetitionsStoppingCriteria,
+    measure_grouped_settings as measure_grouped_settings,
+)
+from cirq.work.observable_readout_calibration import (
+    calibrate_readout_error as calibrate_readout_error,
 )
-from cirq.work.observable_readout_calibration import calibrate_readout_error
-from cirq.work.sampler import Sampler
-from cirq.work.zeros_sampler import ZerosSampler
+from cirq.work.sampler import Sampler as Sampler
+from cirq.work.zeros_sampler import ZerosSampler as ZerosSampler

cirq/work/collector.py

@@ -14,10 +14,10 @@
 
 import abc
 from typing import Any, Iterator, List, Optional, Tuple, TYPE_CHECKING, Union
-from typing_extensions import Protocol
 
 import duet
 import numpy as np
+from typing_extensions import Protocol
 
 from cirq import study, value
 
@@ -171,7 +171,7 @@ class Collector(metaclass=abc.ABCMeta):
         job_error = None
         running_jobs = 0
         queued_jobs: List[CircuitSampleJob] = []
-        remaining_samples = np.infty if max_total_samples is None else max_total_samples
+        remaining_samples = np.inf if max_total_samples is None else max_total_samples
 
         async def run_job(job):
             nonlocal job_error

cirq/work/observable_grouping.py

@@ -12,10 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Iterable, Dict, List, TYPE_CHECKING, cast, Callable
+from typing import Callable, cast, Dict, Iterable, List, TYPE_CHECKING
 
 from cirq import ops, value
-from cirq.work.observable_settings import InitObsSetting, _max_weight_state, _max_weight_observable
+from cirq.work.observable_settings import _max_weight_observable, _max_weight_state, InitObsSetting
 
 if TYPE_CHECKING:
     pass

cirq/work/observable_measurement.py

@@ -24,15 +24,15 @@ import numpy as np
 import pandas as pd
 import sympy
 
-from cirq import circuits, study, ops, value, protocols
+from cirq import circuits, ops, protocols, study, value
 from cirq._doc import document
 from cirq.work.observable_grouping import group_settings_greedy, GROUPER_T
 from cirq.work.observable_measurement_data import (
     BitstringAccumulator,
-    ObservableMeasuredResult,
     flatten_grouped_results,
+    ObservableMeasuredResult,
 )
-from cirq.work.observable_settings import InitObsSetting, observables_to_settings, _MeasurementSpec
+from cirq.work.observable_settings import _MeasurementSpec, InitObsSetting, observables_to_settings
 
 if TYPE_CHECKING:
     import cirq

cirq/work/observable_measurement_data.py

@@ -18,14 +18,14 @@ from typing import Any, Dict, Iterable, List, Mapping, Optional, Tuple, TYPE_CHE
 
 import numpy as np
 import sympy
-from cirq import ops, protocols, value
 
+from cirq import ops, protocols, value
 from cirq._compat import proper_repr
 from cirq.work.observable_settings import (
-    InitObsSetting,
     _max_weight_observable,
     _max_weight_state,
     _MeasurementSpec,
+    InitObsSetting,
     zeros_state,
 )
 
@@ -109,6 +109,9 @@ class ObservableMeasuredResult:
     repetitions: int
     circuit_params: Mapping[Union[str, sympy.Expr], Union[value.Scalar, sympy.Expr]]
 
+    # unhashable because of the mapping-type circuit_params attribute
+    __hash__ = None  # type: ignore
+
     def __repr__(self):
         # I wish we could use the default dataclass __repr__ but
         # we need to prefix our class name with `cirq.work.`

cirq/work/observable_measurement_test.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import tempfile
-from typing import Iterable, Dict, List
+from typing import Dict, Iterable, List
 
 import numpy as np
 import pytest
@@ -21,19 +21,19 @@ import cirq
 import cirq.work as cw
 from cirq.work import _MeasurementSpec, BitstringAccumulator, group_settings_greedy, InitObsSetting
 from cirq.work.observable_measurement import (
-    _with_parameterized_layers,
-    _get_params_for_setting,
-    _pad_setting,
-    _subdivide_meas_specs,
     _aggregate_n_repetitions,
     _check_meas_specs_still_todo,
-    StoppingCriteria,
+    _get_params_for_setting,
+    _pad_setting,
     _parse_checkpoint_options,
-    measure_observables_df,
+    _subdivide_meas_specs,
+    _with_parameterized_layers,
     CheckpointFileOptions,
-    VarianceStoppingCriteria,
     measure_observables,
+    measure_observables_df,
     RepetitionsStoppingCriteria,
+    StoppingCriteria,
+    VarianceStoppingCriteria,
 )
 
 

cirq/work/observable_readout_calibration.py

@@ -1,8 +1,8 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
 import dataclasses
-from typing import Union, Iterable, TYPE_CHECKING
+from typing import Iterable, TYPE_CHECKING, Union
 
-from cirq import circuits, study, ops
+from cirq import circuits, ops, study
 from cirq.work.observable_measurement import measure_grouped_settings, StoppingCriteria
 from cirq.work.observable_settings import InitObsSetting, zeros_state
 

cirq/work/observable_readout_calibration_test.py

@@ -1,9 +1,10 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
 from typing import Sequence
 
+import numpy as np
+
 import cirq
 import cirq.work as cw
-import numpy as np
 
 
 class DepolarizingWithDampedReadoutNoiseModel(cirq.NoiseModel):

cirq/work/observable_settings.py

@@ -16,19 +16,19 @@ import dataclasses
 import numbers
 from typing import (
     AbstractSet,
-    Mapping,
-    Union,
-    Iterable,
     Dict,
+    FrozenSet,
+    Iterable,
+    Mapping,
     Optional,
-    TYPE_CHECKING,
     Tuple,
-    FrozenSet,
+    TYPE_CHECKING,
+    Union,
 )
 
 import sympy
 
-from cirq import ops, value, protocols
+from cirq import ops, protocols, value
 
 if TYPE_CHECKING:
     import cirq
@@ -149,7 +149,8 @@ def _fix_precision(val: Union[value.Scalar, sympy.Expr], precision) -> Union[int
         raise ValueError(f'Cannot convert {val} to fixed precision in observable settings')
     if isinstance(val, (complex, numbers.Complex)):
         return int(val.real * precision), int(val.imag * precision)
-    return int(val * precision)
+    # Pretty much all numbers are instances of numbers.Complex
+    return int(val * precision)  # pragma: no cover
 
 
 def _hashable_param(

cirq/work/observable_settings_test.py

@@ -16,8 +16,8 @@ import pytest
 import sympy
 
 import cirq
-from cirq.work.observable_settings import _max_weight_state, _max_weight_observable, _hashable_param
-from cirq.work import InitObsSetting, observables_to_settings, _MeasurementSpec
+from cirq.work import _MeasurementSpec, InitObsSetting, observables_to_settings
+from cirq.work.observable_settings import _hashable_param, _max_weight_observable, _max_weight_state
 
 
 def test_init_obs_setting():
@@ -68,6 +68,7 @@ def test_param_hash():
     params3 = [('beta', 1.24), ('gamma', 4.57)]
     params4 = [('beta', 1.23 + 0.01j), ('gamma', 4.56 + 0.01j)]
     params5 = [('beta', 1.23 + 0.01j), ('gamma', 4.56 + 0.01j)]
+    params3 = [('beta', 1.24), ('gamma', 4.57)]
     assert _hashable_param(params1) == _hashable_param(params1)
     assert hash(_hashable_param(params1)) == hash(_hashable_param(params1))
     assert _hashable_param(params1) == _hashable_param(params2)

cirq/work/pauli_sum_collector.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 import collections
-from typing import cast, Dict, Optional, Union, TYPE_CHECKING
+from typing import cast, Dict, Optional, TYPE_CHECKING, Union
 
 import numpy as np