cirq-core 1.5.0.dev20240703215652__py3-none-any.whl → 1.5.0.dev20240710220908__py3-none-any.whl

cirq/_version.py

@@ -28,4 +28,4 @@ if sys.version_info < (3, 10, 0):  # pragma: no cover
         'of cirq (e.g. "python -m pip install cirq==1.1.*")'
     )
 
-__version__ = "1.5.0.dev20240703215652"
+__version__ = "1.5.0.dev20240710220908"

cirq/_version_test.py

@@ -3,4 +3,4 @@ import cirq
 
 
 def test_version():
-    assert cirq.__version__ == "1.5.0.dev20240703215652"
+    assert cirq.__version__ == "1.5.0.dev20240710220908"

cirq/circuits/circuit_operation_test.py

@@ -327,9 +327,9 @@ def test_repeat(add_measurements: bool, use_default_ids_for_initial_rep: bool) -
         _ = op_base.repeat()
 
     with pytest.raises(TypeError, match='Only integer or sympy repetitions are allowed'):
-        _ = op_base.repeat(1.3)  # type: ignore[arg-type]
-    assert op_base.repeat(3.00000000001).repetitions == 3  # type: ignore[arg-type]
-    assert op_base.repeat(2.99999999999).repetitions == 3  # type: ignore[arg-type]
+        _ = op_base.repeat(1.3)
+    assert op_base.repeat(3.00000000001).repetitions == 3
+    assert op_base.repeat(2.99999999999).repetitions == 3
 
 
 @pytest.mark.parametrize('add_measurements', [True, False])

cirq/experiments/qubit_characterizations.py

@@ -17,8 +17,8 @@ import itertools
 import functools
 
 from typing import (
-    Any,
     cast,
+    Any,
     Iterator,
     List,
     Optional,
@@ -107,7 +107,6 @@ class RandomizedBenchMarkResult:
         show_plot = not ax
         if not ax:
             fig, ax = plt.subplots(1, 1, figsize=(8, 8))  # pragma: no cover
-            ax = cast(plt.Axes, ax)  # pragma: no cover
         ax.set_ylim((0.0, 1.0))  # pragma: no cover
         ax.plot(self._num_cfds_seq, self._gnd_state_probs, 'ro', label='data', **plot_kwargs)
         x = np.linspace(self._num_cfds_seq[0], self._num_cfds_seq[-1], 100)
@@ -304,7 +303,9 @@ class TomographyResult:
         """
         show_plot = axes is None
         if axes is None:
-            fig, axes = plt.subplots(1, 2, figsize=(12.0, 5.0), subplot_kw={'projection': '3d'})
+            fig, axes_v = plt.subplots(1, 2, figsize=(12.0, 5.0), subplot_kw={'projection': '3d'})
+            axes_v = cast(np.ndarray, axes_v)
+            axes = list(axes_v)
         elif len(axes) != 2:
             raise ValueError('A TomographyResult needs 2 axes to plot.')
         mat = self._density_matrix

cirq/experiments/single_qubit_readout_calibration.py

@@ -14,7 +14,7 @@
 """Single qubit readout experiments using parallel or isolated statistics."""
 import dataclasses
 import time
-from typing import Any, Dict, Iterable, List, Optional, TYPE_CHECKING
+from typing import cast, Any, Dict, Iterable, List, Optional, TYPE_CHECKING
 
 import sympy
 import numpy as np
@@ -77,8 +77,9 @@ class SingleQubitReadoutCalibrationResult:
         """
 
         if axs is None:
-            _, axs = plt.subplots(1, 2, dpi=200, facecolor='white', figsize=(12, 4))
-
+            _, axs_v = plt.subplots(1, 2, dpi=200, facecolor='white', figsize=(12, 4))
+            axs_v = cast(np.ndarray, axs_v)
+            axs = cast(tuple[plt.Axes, plt.Axes], (axs_v[0], axs_v[1]))
         else:
             if (
                 not isinstance(axs, (tuple, list, np.ndarray))

cirq/experiments/two_qubit_xeb.py

@@ -347,7 +347,7 @@ class InferredXEBResult:
         return ax
 
 
-def parallel_two_qubit_xeb(
+def parallel_xeb_workflow(
     sampler: 'cirq.Sampler',
     qubits: Optional[Sequence['cirq.GridQubit']] = None,
     entangling_gate: 'cirq.Gate' = ops.CZ,
@@ -358,8 +358,8 @@ def parallel_two_qubit_xeb(
     random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
     ax: Optional[plt.Axes] = None,
     **plot_kwargs,
-) -> TwoQubitXEBResult:
-    """A convenience method that runs the full XEB workflow.
+) -> Tuple[pd.DataFrame, Sequence['cirq.Circuit'], pd.DataFrame]:
+    """A utility method that runs the full XEB workflow.
 
     Args:
         sampler: The quantum engine or simulator to run the circuits.
@@ -375,7 +375,12 @@ def parallel_two_qubit_xeb(
         **plot_kwargs: Arguments to be passed to 'plt.Axes.plot'.
 
     Returns:
-        A TwoQubitXEBResult object representing the results of the experiment.
+        - A DataFrame with columns 'cycle_depth' and 'fidelity'.
+        - The circuits used to perform XEB.
+        - A pandas dataframe with index given by ['circuit_i', 'cycle_depth'].
+            Columns always include "sampled_probs". If `combinations_by_layer` is
+            not `None` and you are doing parallel XEB, additional metadata columns
+            will be attached to the returned DataFrame.
 
     Raises:
         ValueError: If qubits are not specified and the sampler has no device.
@@ -420,6 +425,52 @@ def parallel_two_qubit_xeb(
         sampled_df=sampled_df, circuits=circuit_library, cycle_depths=cycle_depths
     )
 
+    return fids, circuit_library, sampled_df
+
+
+def parallel_two_qubit_xeb(
+    sampler: 'cirq.Sampler',
+    qubits: Optional[Sequence['cirq.GridQubit']] = None,
+    entangling_gate: 'cirq.Gate' = ops.CZ,
+    n_repetitions: int = 10**4,
+    n_combinations: int = 10,
+    n_circuits: int = 20,
+    cycle_depths: Sequence[int] = tuple(np.arange(3, 100, 20)),
+    random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+    ax: Optional[plt.Axes] = None,
+    **plot_kwargs,
+) -> TwoQubitXEBResult:
+    """A convenience method that runs the full XEB workflow.
+
+    Args:
+        sampler: The quantum engine or simulator to run the circuits.
+        qubits: Qubits under test. If none, uses all qubits on the sampler's device.
+        entangling_gate: The entangling gate to use.
+        n_repetitions: The number of repetitions to use.
+        n_combinations: The number of combinations to generate.
+        n_circuits: The number of circuits to generate.
+        cycle_depths: The cycle depths to use.
+        random_state: The random state to use.
+        ax: the plt.Axes to plot the device layout on. If not given,
+            no plot is created.
+        **plot_kwargs: Arguments to be passed to 'plt.Axes.plot'.
+    Returns:
+        A TwoQubitXEBResult object representing the results of the experiment.
+    Raises:
+        ValueError: If qubits are not specified and the sampler has no device.
+    """
+    fids, *_ = parallel_xeb_workflow(
+        sampler=sampler,
+        qubits=qubits,
+        entangling_gate=entangling_gate,
+        n_repetitions=n_repetitions,
+        n_combinations=n_combinations,
+        n_circuits=n_circuits,
+        cycle_depths=cycle_depths,
+        random_state=random_state,
+        ax=ax,
+        **plot_kwargs,
+    )
     return TwoQubitXEBResult(fit_exponential_decays(fids))
 
 

cirq/experiments/xeb_fitting.py

@@ -146,6 +146,69 @@ class XEBCharacterizationOptions(ABC):
         """Return an initial Nelder-Mead simplex and the names for each parameter."""
 
 
+def _try_defaults_from_unitary(gate: 'cirq.Gate') -> Optional[Dict[str, 'cirq.TParamVal']]:
+    r"""Try to figure out the PhasedFSim angles from the unitary of the gate.
+
+    The unitary of a PhasedFSimGate has the form:
+    $$
+    \begin{bmatrix}
+        1 & 0 & 0 & 0 \\
+        0 & e^{-i \gamma - i \zeta} \cos(\theta) & -i e^{-i \gamma + i\chi} \sin(\theta) & 0 \\
+        0 & -i e^{-i \gamma - i \chi} \sin(\theta) & e^{-i \gamma + i \zeta} \cos(\theta) & 0 \\
+        0 & 0 & 0 & e^{-2i \gamma - i \phi}
+    \end{bmatrix}
+    $$
+    That's the information about the five angles $\theta, \phi, \gamma, \zeta, \chi$ is encoded in
+    the submatrix unitary[1:3, 1:3] and the element u[3][3]. With some algebra, we can isolate each
+    of the angles as an argument of a combination of those elements (and potentially other angles).
+
+    Args:
+        A cirq gate.
+
+    Returns:
+        A dictionary mapping angles to values or None if the gate doesn't have a unitary or if it
+        can't be represented by a PhasedFSimGate.
+    """
+    u = protocols.unitary(gate, default=None)
+    if u is None:
+        return None
+
+    gamma = np.angle(u[1, 1] * u[2, 2] - u[1, 2] * u[2, 1]) / -2
+    phi = -np.angle(u[3, 3]) - 2 * gamma
+    phased_cos_theta_2 = u[1, 1] * u[2, 2]
+    if phased_cos_theta_2 == 0:
+        # The zeta phase is multiplied with cos(theta),
+        # so if cos(theta) is zero then any value is possible.
+        zeta = 0
+    else:
+        zeta = np.angle(u[2, 2] / u[1, 1]) / 2
+
+    phased_sin_theta_2 = u[1, 2] * u[2, 1]
+    if phased_sin_theta_2 == 0:
+        # The chi phase is multiplied with sin(theta),
+        # so if sin(theta) is zero then any value is possible.
+        chi = 0
+    else:
+        chi = np.angle(u[1, 2] / u[2, 1]) / 2
+
+    theta = np.angle(np.exp(1j * (gamma + zeta)) * u[1, 1] - np.exp(1j * (gamma - chi)) * u[1, 2])
+
+    if np.allclose(
+        u,
+        protocols.unitary(
+            ops.PhasedFSimGate(theta=theta, phi=phi, chi=chi, zeta=zeta, gamma=gamma)
+        ),
+    ):
+        return {
+            'theta_default': theta,
+            'phi_default': phi,
+            'gamma_default': gamma,
+            'zeta_default': zeta,
+            'chi_default': chi,
+        }
+    return None
+
+
 def phased_fsim_angles_from_gate(gate: 'cirq.Gate') -> Dict[str, 'cirq.TParamVal']:
     """For a given gate, return a dictionary mapping '{angle}_default' to its noiseless value
     for the five PhasedFSim angles."""
@@ -175,6 +238,11 @@ def phased_fsim_angles_from_gate(gate: 'cirq.Gate') -> Dict[str, 'cirq.TParamVal
             'phi_default': gate.phi,
         }
 
+    # Handle all gates that can be represented using an FSimGate.
+    from_unitary = _try_defaults_from_unitary(gate)
+    if from_unitary is not None:
+        return from_unitary
+
     raise ValueError(f"Unknown default angles for {gate}.")
 
 
@@ -580,15 +648,6 @@ def _fit_exponential_decay(
     return a, layer_fid, a_std, layer_fid_std
 
 
-def _one_unique(df, name, default):
-    """Helper function to assert that there's one unique value in a column and return it."""
-    if name not in df.columns:
-        return default
-    vals = df[name].unique()
-    assert len(vals) == 1, name
-    return vals[0]
-
-
 def fit_exponential_decays(fidelities_df: pd.DataFrame) -> pd.DataFrame:
     """Fit exponential decay curves to a fidelities DataFrame.
 

cirq/experiments/xeb_fitting_test.py

@@ -32,6 +32,7 @@ from cirq.experiments.xeb_fitting import (
     fit_exponential_decays,
     before_and_after_characterization,
     XEBPhasedFSimCharacterizationOptions,
+    phased_fsim_angles_from_gate,
 )
 from cirq.experiments.xeb_sampling import sample_2q_xeb_circuits
 
@@ -354,7 +355,7 @@ def test_options_with_defaults_from_gate():
     assert options.zeta_default == 0.0
 
     with pytest.raises(ValueError):
-        _ = XEBPhasedFSimCharacterizationOptions().with_defaults_from_gate(cirq.CZ)
+        _ = XEBPhasedFSimCharacterizationOptions().with_defaults_from_gate(cirq.XX)
 
 
 def test_options_defaults_set():
@@ -395,3 +396,34 @@ def test_options_defaults_set():
         phi_default=0.0,
     )
     assert o3.defaults_set() is True
+
+
+def _random_angles(n, seed):
+    rng = np.random.default_rng(seed)
+    r = 2 * rng.random((n, 5)) - 1
+    return np.pi * r
+
+
+@pytest.mark.parametrize(
+    'gate',
+    [
+        cirq.CZ,
+        cirq.SQRT_ISWAP,
+        cirq.SQRT_ISWAP_INV,
+        cirq.ISWAP,
+        cirq.ISWAP_INV,
+        cirq.cphase(0.1),
+        cirq.CZ**0.2,
+    ]
+    + [cirq.PhasedFSimGate(*r) for r in _random_angles(10, 0)],
+)
+def test_phased_fsim_angles_from_gate(gate):
+    angles = phased_fsim_angles_from_gate(gate)
+    angles = {k.removesuffix('_default'): v for k, v in angles.items()}
+    phasedfsim = cirq.PhasedFSimGate(**angles)
+    np.testing.assert_allclose(cirq.unitary(phasedfsim), cirq.unitary(gate), atol=1e-9)
+
+
+def test_phased_fsim_angles_from_gate_unsupporet_gate():
+    with pytest.raises(ValueError, match='Unknown default angles'):
+        _ = phased_fsim_angles_from_gate(cirq.testing.TwoQubitGate())

cirq/interop/quirk/cells/parse.py

@@ -154,7 +154,7 @@ def _parse_formula_using_token_map(
         a = vals.pop()
         # Note: vals seems to be _HangingToken
         # func operates on _ResolvedTokens. Ignoring type issues for now.
-        vals.append(op.func(a, b))  # type: ignore[arg-type]
+        vals.append(op.func(a, b))
 
     def close_paren() -> None:
         while True:

cirq/ops/common_gates_test.py

@@ -899,6 +899,8 @@ def test_cphase_unitary(angle_rads, expected_unitary):
     np.testing.assert_allclose(cirq.unitary(cirq.cphase(angle_rads)), expected_unitary)
 
 
+# TODO(#6663): fix this use case.
+@pytest.mark.xfail
 def test_parameterized_cphase():
     assert cirq.cphase(sympy.pi) == cirq.CZ
     assert cirq.cphase(sympy.pi / 2) == cirq.CZ**0.5

cirq/ops/global_phase_op.py

@@ -28,7 +28,7 @@ from cirq.type_workarounds import NotImplementedType
 class GlobalPhaseGate(raw_types.Gate):
     def __init__(self, coefficient: 'cirq.TParamValComplex', atol: float = 1e-8) -> None:
         if not isinstance(coefficient, sympy.Basic):
-            if abs(1 - abs(coefficient)) > atol:  # type: ignore[operator]
+            if abs(1 - abs(coefficient)) > atol:
                 raise ValueError(f'Coefficient is not unitary: {coefficient!r}')
         self._coefficient = coefficient
 

cirq/sim/density_matrix_simulator_test.py

@@ -402,10 +402,10 @@ def test_run_param_resolver(dtype: Type[np.complexfloating], split: bool):
                 cirq.measure(q1),
             )
             param_resolver = {'b0': b0, 'b1': b1}
-            result = simulator.run(circuit, param_resolver=param_resolver)  # type: ignore
+            result = simulator.run(circuit, param_resolver=param_resolver)
             np.testing.assert_equal(result.measurements, {'q(0)': [[b0]], 'q(1)': [[b1]]})
             # pylint: disable=line-too-long
-            np.testing.assert_equal(result.params, cirq.ParamResolver(param_resolver))  # type: ignore
+            np.testing.assert_equal(result.params, cirq.ParamResolver(param_resolver))
 
 
 @pytest.mark.parametrize('dtype', [np.complex64, np.complex128])

cirq/sim/sparse_simulator_test.py

@@ -498,11 +498,11 @@ def test_simulate_param_resolver(dtype: Type[np.complexfloating], split: bool):
                 (cirq.X ** sympy.Symbol('b0'))(q0), (cirq.X ** sympy.Symbol('b1'))(q1)
             )
             resolver = {'b0': b0, 'b1': b1}
-            result = simulator.simulate(circuit, param_resolver=resolver)  # type: ignore
+            result = simulator.simulate(circuit, param_resolver=resolver)
             expected_state = np.zeros(shape=(2, 2))
             expected_state[b0][b1] = 1.0
             np.testing.assert_equal(result.final_state_vector, np.reshape(expected_state, 4))
-            assert result.params == cirq.ParamResolver(resolver)  # type: ignore
+            assert result.params == cirq.ParamResolver(resolver)
             assert len(result.measurements) == 0
 
 

cirq/study/flatten_expressions.py

@@ -225,8 +225,7 @@ class _ParamFlattener(resolver.ParamResolver):
             params = param_dict if param_dict else {}
         # TODO: Support complex values for typing below.
         symbol_params: resolver.ParamDictType = {
-            _ensure_not_str(param): _ensure_not_str(val)  # type: ignore[misc]
-            for param, val in params.items()
+            _ensure_not_str(param): _ensure_not_str(val) for param, val in params.items()
         }
         super().__init__(symbol_params)
         if get_param_name is None:

cirq/study/resolver.py

@@ -139,10 +139,10 @@ class ParamResolver:
             if isinstance(param_value, str):
                 param_value = sympy.Symbol(param_value)
             elif not isinstance(param_value, sympy.Basic):
-                return value  # type: ignore[return-value]
+                return value
             if recursive:
                 param_value = self._value_of_recursive(value)
-            return param_value  # type: ignore[return-value]
+            return param_value
 
         if not isinstance(value, sympy.Basic):
             # No known way to resolve this variable, return unchanged.
@@ -207,7 +207,7 @@ class ParamResolver:
 
         # There isn't a full evaluation for 'value' yet. Until it's ready,
         # map value to None to identify loops in component evaluation.
-        self._deep_eval_map[value] = _RECURSION_FLAG  # type: ignore
+        self._deep_eval_map[value] = _RECURSION_FLAG
 
         v = self.value_of(value, recursive=False)
         if v == value:
@@ -220,10 +220,8 @@ class ParamResolver:
         new_dict: Dict['cirq.TParamKey', Union[float, str, sympy.Symbol, sympy.Expr]] = {
             k: k for k in resolver
         }
-        new_dict.update({k: self.value_of(k, recursive) for k in self})  # type: ignore[misc]
-        new_dict.update(
-            {k: resolver.value_of(v, recursive) for k, v in new_dict.items()}  # type: ignore[misc]
-        )
+        new_dict.update({k: self.value_of(k, recursive) for k in self})
+        new_dict.update({k: resolver.value_of(v, recursive) for k, v in new_dict.items()})
         if recursive and self._param_dict:
             new_resolver = ParamResolver(cast(ParamDictType, new_dict))
             # Resolve down to single-step mappings.

cirq/study/sweepable.py

@@ -65,11 +65,7 @@ def to_sweeps(sweepable: Sweepable, metadata: Optional[dict] = None) -> List[Swe
         product_sweep = dict_to_product_sweep(sweepable)
         return [_resolver_to_sweep(resolver, metadata) for resolver in product_sweep]
     if isinstance(sweepable, Iterable) and not isinstance(sweepable, str):
-        return [
-            sweep
-            for item in sweepable
-            for sweep in to_sweeps(item, metadata)  # type: ignore[arg-type]
-        ]
+        return [sweep for item in sweepable for sweep in to_sweeps(item, metadata)]
     raise TypeError(f'Unrecognized sweepable type: {type(sweepable)}.\nsweepable: {sweepable}')
 
 

cirq/study/sweeps.py

@@ -589,10 +589,7 @@ def dict_to_product_sweep(factor_dict: ProductOrZipSweepLike) -> Product:
         Cartesian product of the sweeps.
     """
     return Product(
-        *(
-            Points(k, v if isinstance(v, Sequence) else [v])  # type: ignore
-            for k, v in factor_dict.items()
-        )
+        *(Points(k, v if isinstance(v, Sequence) else [v]) for k, v in factor_dict.items())
     )
 
 

cirq/vis/heatmap.py

@@ -298,7 +298,6 @@ class Heatmap:
         show_plot = not ax
         if not ax:
             fig, ax = plt.subplots(figsize=(8, 8))
-            ax = cast(plt.Axes, ax)
         original_config = copy.deepcopy(self._config)
         self.update_config(**kwargs)
 
@@ -416,7 +415,6 @@ class TwoQubitInteractionHeatmap(Heatmap):
         show_plot = not ax
         if not ax:
             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])

cirq/vis/state_histogram.py

@@ -14,7 +14,7 @@
 
 """Tool to visualize the results of a study."""
 
-from typing import cast, Optional, Sequence, SupportsFloat, Union
+from typing import Optional, Sequence, SupportsFloat, Union
 import collections
 import numpy as np
 import matplotlib.pyplot as plt
@@ -87,7 +87,6 @@ def plot_state_histogram(
     show_fig = not ax
     if not ax:
         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):

{cirq_core-1.5.0.dev20240703215652.dist-info → cirq_core-1.5.0.dev20240710220908.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cirq-core
-Version: 1.5.0.dev20240703215652
+Version: 1.5.0.dev20240710220908
 Summary: A framework for creating, editing, and invoking Noisy Intermediate Scale Quantum (NISQ) circuits.
 Home-page: http://github.com/quantumlib/cirq
 Author: The Cirq Developers

{cirq_core-1.5.0.dev20240703215652.dist-info → cirq_core-1.5.0.dev20240710220908.dist-info}/RECORD

@@ -4,8 +4,8 @@ cirq/_compat_test.py,sha256=Qq3ZcfgD-Nb81cEppQdJqhAyrVqXKtfXZYGXT0p-Wh0,34718
 cirq/_doc.py,sha256=yDyWUD_2JDS0gShfGRb-rdqRt9-WeL7DhkqX7np0Nko,2879
 cirq/_import.py,sha256=p9gMHJscbtDDkfHOaulvd3Aer0pwUF5AXpL89XR8dNw,8402
 cirq/_import_test.py,sha256=6K_v0riZJXOXUphHNkGA8MY-JcmGlezFaGmvrNhm3OQ,1015
-cirq/_version.py,sha256=3_Sg3uzfaOMgG4mv6g4f4SmHc-QPmxmWQIua8U1iYtk,1206
-cirq/_version_test.py,sha256=mSjfxLVKVW7U6XVjlcfXqkvjbv2PqlztLLqA6oVn3yk,147
+cirq/_version.py,sha256=ow3fcIM6yzwNASceUWYIGlTgHkysbg9vO85xoQgtdjs,1206
+cirq/_version_test.py,sha256=wmmA2WCnJ-WU8DUtbgS_wyvjUMWTnyl9B8RcZvNYxrI,147
 cirq/conftest.py,sha256=X7yLFL8GLhg2CjPw0hp5e_dGASfvHx1-QT03aUbhKJw,1168
 cirq/json_resolver_cache.py,sha256=ytePZtNZgKjOF2NiVpUTuotB-JKZmQNOFIFdvXqsxHw,13271
 cirq/py.typed,sha256=VFSlmh_lNwnaXzwY-ZuW-C2Ws5PkuDoVgBdNCs0jXJE,63
@@ -19,7 +19,7 @@ cirq/circuits/_bucket_priority_queue.py,sha256=hxFuii2fKD8G6EKT_aVLEsA7FmSfqFXPw
 cirq/circuits/_bucket_priority_queue_test.py,sha256=t6u_hG7K2e2WKWrgCsKxNRtp4ghKwiCrp0_WSY0W25k,5288
 cirq/circuits/circuit.py,sha256=XIwQh9Gkb8ya4Q2Q92EfsAUh9W6YZemcGqlu1cZCi2s,114620
 cirq/circuits/circuit_operation.py,sha256=D4u8jDD4fGOca1xnZPN1obuKTIouXENUfnxOF2JrwgU,34375
-cirq/circuits/circuit_operation_test.py,sha256=_0iQJ3h_dnQcQmbGRZbc-NqdglJTXantbj72ggqLKNE,44724
+cirq/circuits/circuit_operation_test.py,sha256=u-23dDZ6htNSiP8oXR67rmtb-XDBmObvbJjJrARhmis,44646
 cirq/circuits/circuit_test.py,sha256=sRZC558PZZZUHByZ1R00_j8ez6TL9l5ZmT8YLGopH_Q,160117
 cirq/circuits/frozen_circuit.py,sha256=_0SkmIiQ4UjIug-k_iO00ulDFoFnxmAHvXX2I2HHN8k,9262
 cirq/circuits/frozen_circuit_test.py,sha256=rHyii8hLhOQ6jdA8dC1OcYPGnyeBC4uY5Q53XspkkCk,4133
@@ -184,22 +184,22 @@ cirq/experiments/n_qubit_tomography.py,sha256=9M_kf2-1hvFxfZOWND7ACwHYgD9SJU5nYF
 cirq/experiments/n_qubit_tomography_test.py,sha256=wHfV2OpGYSDXfoyEh-B5dc1Dv8sxKNFbUoHyjIWZoFk,4362
 cirq/experiments/purity_estimation.py,sha256=6D1UwFlQRzHeajXMTyTUfBYAc0jJQ8Cfz4lteFKeUaM,2467
 cirq/experiments/purity_estimation_test.py,sha256=xlBGp0NOBYR0IhTy3bckHPgi81FkGSGxKqk9hwXG-I8,923
-cirq/experiments/qubit_characterizations.py,sha256=Zi925SVZ0U5HbkyuGD6BspjzPAhsqOe5gLxNgZy0FrQ,36702
+cirq/experiments/qubit_characterizations.py,sha256=yimdW20qqP4iP0wyO83W6VSQWDToJKO6Nx4okBxjn_I,36726
 cirq/experiments/qubit_characterizations_test.py,sha256=b_ONqxyW6s01Ts8T65BEdb4e8Xy24Qp4zTGXWesL0ic,9733
 cirq/experiments/random_quantum_circuit_generation.py,sha256=R_w7z35plUHEYBY0-F80bPcWJSSSjNQDaP2GbxVBEZg,28143
 cirq/experiments/random_quantum_circuit_generation_test.py,sha256=1rvgN8-Ajedn_70FyYKVzjvzR6NVpHj6KQgo6tra-Jc,15995
 cirq/experiments/readout_confusion_matrix.py,sha256=jIyikXfYWGbVrOjU1pbV2VZL-m03VTFYS18KT1Cf2qk,21404
 cirq/experiments/readout_confusion_matrix_test.py,sha256=ETvKHVuJWvq8KuL0l6w22UOfZHhBNH-TVeWAKqjSQEc,10632
-cirq/experiments/single_qubit_readout_calibration.py,sha256=ZmfsARZ_33Pg4lh5toJaoi4h4RGKHISAfWBODq1Icsg,14599
+cirq/experiments/single_qubit_readout_calibration.py,sha256=x6fF6GqU1D4YY05YvW1DFlTlbjC12_bfj7W2psd75-U,14722
 cirq/experiments/single_qubit_readout_calibration_test.py,sha256=_002QXj2rIFHkH3vw9iTVMh45vCPuCI_fTqOUK8uMe4,7718
 cirq/experiments/t1_decay_experiment.py,sha256=ealdmc_RTE__z1YUcaDEncDzQOaiT0K6IRWB7lNtPfs,7087
 cirq/experiments/t1_decay_experiment_test.py,sha256=Pgbm-37JiCdw9iQg2OaXVvs72xGWV2629CgsTQlLQnw,9139
 cirq/experiments/t2_decay_experiment.py,sha256=lTgZ9yJ7Fk9_ozUCHysQn1qKrMQwTpsgEv-QnvsEif0,19158
 cirq/experiments/t2_decay_experiment_test.py,sha256=DFR0BGn0Id4qNPfqIExj70TEAqf7Vrc8eK91Wj0YKTc,15031
-cirq/experiments/two_qubit_xeb.py,sha256=wdLxBi3LrAlPF-SQV9Tf66k31XC2cVHNPhpR-VLvCao,17762
+cirq/experiments/two_qubit_xeb.py,sha256=NU8JsM6yqpTfWQCPf6dCAlD89MmYpprI5kVz2bxAJhI,19879
 cirq/experiments/two_qubit_xeb_test.py,sha256=Tlr32vuJpyepkMBVVkN6ipjRyDr8DIixfBumEeGXzDM,10073
-cirq/experiments/xeb_fitting.py,sha256=54FKzGqhZgyvAkP_AR2-7peDnL-PJxOp-MkQdfp8bfU,27178
-cirq/experiments/xeb_fitting_test.py,sha256=nfFhKPr_Nx5rbfCcvrcUFQxphCZuTnJVnpT-xBjxRFI,14349
+cirq/experiments/xeb_fitting.py,sha256=tD678gTY495cDA6b55YIPdwq22VQFbB2AlnkeX_X9P0,29332
+cirq/experiments/xeb_fitting_test.py,sha256=LEgC76mYFwsX-ZqRqg2j85EiHACq8nK9ITrcl-TgeiA,15286
 cirq/experiments/xeb_sampling.py,sha256=6ZOidGi7Kt6p4cMQCjK7qQuIUXVHCYl47B2GnL8M-Bw,14987
 cirq/experiments/xeb_sampling_test.py,sha256=0XkQGvcURsug3IblE_wZrHVDoOQV3WuQilrqCJbDHjI,6784
 cirq/experiments/xeb_simulation.py,sha256=DpCWVxzWnZvjrdfgIbwR9rWenehqz7Su3LPIVHoK7gI,5055
@@ -228,7 +228,7 @@ cirq/interop/quirk/cells/input_rotation_cells.py,sha256=mo75TGkbtD_phNPM-ZPFs2VJ
 cirq/interop/quirk/cells/input_rotation_cells_test.py,sha256=1jmEBHbHpmSSB3grPbn8LFzMEwkc6Or3kAULxVofTEg,6318
 cirq/interop/quirk/cells/measurement_cells.py,sha256=1jLtGMHCbxfNN9r5E_GWPIqz7fLdNKJK0WgrcjXsS3I,1504
 cirq/interop/quirk/cells/measurement_cells_test.py,sha256=AYYzjn3BrQbk-Rg1L3WjCOQN9eGLRQzqwYr6i8UH0Fk,1574
-cirq/interop/quirk/cells/parse.py,sha256=-_-YrhbV8-OpLtbHCUoTK5rkvEKAHS9nqOaxd-z2x-w,11781
+cirq/interop/quirk/cells/parse.py,sha256=lUN0cioK9-1iDnKmrC1X1wpdPwbDwqoEI9QJpF2uFGY,11755
 cirq/interop/quirk/cells/parse_test.py,sha256=xCTS6lKv4i8HAuTSivH2Tjwun1yMQbnl7HLfB-nEKY4,7473
 cirq/interop/quirk/cells/qubit_permutation_cells.py,sha256=F9Br_SFB1ys4pP-hYlpPRMXH_4Cd8LePtOl4aTE_p8g,3390
 cirq/interop/quirk/cells/qubit_permutation_cells_test.py,sha256=n0veQKx0EdFzu_gdY_AVjwqyoHae7JGkDFX6qhLeGrQ,4460
@@ -276,7 +276,7 @@ cirq/ops/common_channels_test.py,sha256=EL_PxbqD3KPC8ioihiukhmW8bUdclqqigKoFyUQp
 cirq/ops/common_gate_families.py,sha256=e5M8wlDYtdrpWBrhdns6iizIvSqzfxDyIsBdxt8hVMc,8611
 cirq/ops/common_gate_families_test.py,sha256=Oo3C7BPO3gt3ePuqwsI_lx_lY38et8Ps4AuVydX2Aww,5275
 cirq/ops/common_gates.py,sha256=YMcadPVRhrvkwYwm6-_TNYM9sz9TY7KSi0g7FvBTeCk,58075
-cirq/ops/common_gates_test.py,sha256=XCVswZbd_k9Y2k5n-2TXnS8CnJoLoC3VmBQN0QijIKw,46218
+cirq/ops/common_gates_test.py,sha256=n4Ud_5t-iB2RzMpPSwXngeU1rR198gk0-J7R2xUxp6Q,46271
 cirq/ops/control_values.py,sha256=nNDN6pgz_aWkUfrpOZ9zHHD42AGFaplWhVQj9rmJwbQ,13410
 cirq/ops/control_values_test.py,sha256=iDtdQjL39u80MaR16XLp00LRZqWgJqC54cIeADWf0IY,12906
 cirq/ops/controlled_gate.py,sha256=uVTZk6pA1ZpEwbVggLeXyAFq18_QJ38hWYhk9GbvQnc,14253
@@ -299,7 +299,7 @@ cirq/ops/gate_operation.py,sha256=Fa3O_-bLGAtFznYv-b_RWAn2X4JgvM3yGbqbLcsJkgM,13
 cirq/ops/gate_operation_test.py,sha256=ftd-GZxvOtzFS1L153K89_PV1volGroU7G5nFGp9afE,17507
 cirq/ops/gateset.py,sha256=Tx1CIlve0RhnX9jHZsCVw7EHtfC6b3drbBncmCEtcsQ,21634
 cirq/ops/gateset_test.py,sha256=BY5UJ1k3NC0jz0d4yocyO1qcQU6e4UbN9mapWE7z7AM,16361
-cirq/ops/global_phase_op.py,sha256=y4AT1_dQfGl44WHbCkXfp1d1Hh5BN1geQ35HpvI5dLE,4868
+cirq/ops/global_phase_op.py,sha256=XYnzmquhGaVY91oYm9RHo1qbX1eOx2ZqLPzLsl8jyQw,4842
 cirq/ops/global_phase_op_test.py,sha256=FjtUsohIYabTtiGytvPQw9Rzkqd6dlT7qrj4oltDbTI,9814
 cirq/ops/greedy_qubit_manager.py,sha256=O9qY8GB1KGxm3B7JEjq50sGVD51bNwTSupJpi3WUeAc,4039
 cirq/ops/greedy_qubit_manager_test.py,sha256=iVZDKes-r08raTiJHpYNmP-Dp89ok3hIU-QboL2BHdw,3300
@@ -892,7 +892,7 @@ cirq/sim/classical_simulator_test.py,sha256=TxPhVNLoOBPwTlyUCOQoqwid76ZBxQfmN9IP
 cirq/sim/density_matrix_simulation_state.py,sha256=XRxKsKq13OlXR7429WBbKps_jmOoCBRa6U9PzYrYrTc,14065
 cirq/sim/density_matrix_simulation_state_test.py,sha256=uqSKZrXEPLYO7R3UW2d1y_Yq6CcyJ0drTSCjGbtzBuc,4369
 cirq/sim/density_matrix_simulator.py,sha256=-BIY8JjmzAJDmF6tWcv5lbH1yS7UQIlKicU1AJgttfA,17462
-cirq/sim/density_matrix_simulator_test.py,sha256=LgND8eN3AXgJzP3nYh0JmsTWJfT878BSzgIo4gZ54xY,61154
+cirq/sim/density_matrix_simulator_test.py,sha256=Wnj0gWABa-EJ6zP5z9G4fyTN7641Q5OrAo2u1FkY1QQ,61122
 cirq/sim/density_matrix_utils.py,sha256=9Fbzh0c9hzwEff383YwRit2K_tvlpT4Vyq3rjLijRyA,10273
 cirq/sim/density_matrix_utils_test.py,sha256=ZJpeolcie9rSIvrWhxcGhzr6Ojyn8me00rfrDwn4y-M,14225
 cirq/sim/mux.py,sha256=gnQGQmArs0LdLnVmxAesOTnVmaudZmgIH6JUatGUXtE,12509
@@ -909,7 +909,7 @@ cirq/sim/simulator_base.py,sha256=mAcIKPT6lsIvAJFdSC4a-cGQFU0kegqbL80K1K7mlFM,18
 cirq/sim/simulator_base_test.py,sha256=Ik_28QV2Pzdc4tGxYMAVnGrNG1IWMiwuKUJcaCeuG7M,14955
 cirq/sim/simulator_test.py,sha256=9cHMoY7M5_82gfeBsCg6O0PnictzZu172vQAgUngJqA,18119
 cirq/sim/sparse_simulator.py,sha256=OvVjqNk5Kb92DM8Nrdw1BGOB7GFlT6yiXwIPpAcLV7I,12854
-cirq/sim/sparse_simulator_test.py,sha256=3EAeCHUQeKllAAtdw14X592zBsGQY_vwfIYK-gEr_zA,53587
+cirq/sim/sparse_simulator_test.py,sha256=gv2SxYQL93j1xoP4ocg0zmb9bUxW4Yo5nJxOysuRGkw,53555
 cirq/sim/state_vector.py,sha256=N6N9EELlW66UaLTBaq62ms0XkfIK7CzN9SBM7t52dXo,13428
 cirq/sim/state_vector_simulation_state.py,sha256=e4it_DT1J-30S3OX_gfMJiWAttFaVOMEPQ-Y1ARWnDg,17616
 cirq/sim/state_vector_simulation_state_test.py,sha256=UtGMIurlV6N74nX7qoVnGoRhwF35-ghDEIP7Mj5AXmI,9841
@@ -930,15 +930,15 @@ cirq/sim/clifford/stabilizer_simulation_state_test.py,sha256=dsphoXTaIwRCjprGJQi
 cirq/sim/clifford/stabilizer_state_ch_form.py,sha256=yz9x7F72wfgqfSiEhoH2rJ-n14nsYMapMvpkhwidIOY,14032
 cirq/sim/clifford/stabilizer_state_ch_form_test.py,sha256=FK0IsyrTfT6ZPZeBYmyPG2xpzUT7RG6P6UQw_61c6kU,3149
 cirq/study/__init__.py,sha256=HCuFRBzCJGGDhtoHRzrnD5IWB8EnMrX-4M6AmVO0tP0,1220
-cirq/study/flatten_expressions.py,sha256=LIePrTJJW3PfdQS2jJ-DxhjpuOdwdBZi0WbtXHf2qmw,15638
+cirq/study/flatten_expressions.py,sha256=B-CQcj8eSWAJPIff5bQiZGobnYx8kB0c5WTLowfCVXo,15604
 cirq/study/flatten_expressions_test.py,sha256=6e7pTkaBrZW-EmG4teZxcwemqnxCtJW3kq2KOlPcwW8,6078
-cirq/study/resolver.py,sha256=-X6R4FQ5nkEyaf4YsNFTN1Ui8Ss-Mkn39pHOV-vgsZQ,11773
+cirq/study/resolver.py,sha256=YiX2VBxQScGJCm01ZkSyiJufxubKiMBN67oMOeXwgdQ,11631
 cirq/study/resolver_test.py,sha256=QQe9Rr0z6qNbSWPEvCKd_DNka6454AWVKbG2J2DD1Wg,10228
 cirq/study/result.py,sha256=KzjpjvDVCTFjMyq9r91pZSYdtcD1x3yj8jP_StlOSMg,19285
 cirq/study/result_test.py,sha256=fq5BH78RswfTiYjMchJ4wEDDyaJu0QdJoGobMjKDeSI,15591
-cirq/study/sweepable.py,sha256=IsOw1rdaKGT4HGj6zpOM1ZhaiRoETRwIeqyyzJIRXMU,4428
+cirq/study/sweepable.py,sha256=hHBXn5MQZJawiiIXWZdn_qygbPeIFtt300wIqVHiYl8,4356
 cirq/study/sweepable_test.py,sha256=ENv03_GJmbUc_ukJoqfgG-H5C_yyx1jCcvxohSMyQVU,5502
-cirq/study/sweeps.py,sha256=8mUc5dnOJxZH8m_6ncgkZRY7a2TBe7_9d3WcvJAyZlA,19900
+cirq/study/sweeps.py,sha256=zKz8hmLnpukNzUp7YjsrD8wEGxf2peX19522kUKUfWI,19850
 cirq/study/sweeps_test.py,sha256=YdXHzZO10OHoPTU2ifmsfH7KByIJeeANy91AHqX8nwg,12135
 cirq/testing/__init__.py,sha256=cACho8s-V5tNOjBcDUtr2DipQxQcbUgbr4MESJb4l1I,3870
 cirq/testing/circuit_compare.py,sha256=nBQES45wLVThOqC3WrPrYKLQP7HQ2pH5DjlJ5bHkrtU,19176
@@ -1148,11 +1148,11 @@ cirq/value/value_equality_attr_test.py,sha256=k_nl5hWxo4yMO6WNu0wU68wyeb-RN9Ua_I
 cirq/vis/__init__.py,sha256=e3Z1PI-Ay0hDHhIgFZEDwQIuO8C_aayNdL-EByF0J4o,1001
 cirq/vis/density_matrix.py,sha256=kMAPcRh6f0ghZKSe86nB_2iFngrDsw0pNael1EZ5BEw,4819
 cirq/vis/density_matrix_test.py,sha256=Xg41NQZBfoyrkaX3n9pW4q1LIxWpOW3Cr_I_Wx51GlQ,6965
-cirq/vis/heatmap.py,sha256=9FHviJR0-OY9ksdoh0OrjdDvkb5ISd5OxcYd9WRlqYo,17758
+cirq/vis/heatmap.py,sha256=VVAj_aW0u4jRId2T1RUl_gL-xcxsG6jjKbf8qVJQl9A,17686
 cirq/vis/heatmap_test.py,sha256=5kWIxJZZbZcc93XZrZ18lF2gRUleR1iqYbWfHs4cvu4,20531
 cirq/vis/histogram.py,sha256=gQUrcebsk5wgPT38pWFW55jG9zaKhxp8zLRGmmVDk8s,5107
 cirq/vis/histogram_test.py,sha256=Qlw0e3amw_MFga-hNweiLzRCH174W9bB2qkmX_RiS-U,1904
-cirq/vis/state_histogram.py,sha256=i8PvGLMHu74mJVD18EuS7YFGw9aM3pTa-ocnZHOW2kc,4298
+cirq/vis/state_histogram.py,sha256=lmYrPrqWoxhdXGbBdMahKK4isqmmeO6v45KKVbH3MkA,4260
 cirq/vis/state_histogram_test.py,sha256=KzxDJedwE-KZR-K_TZlMh01DroSnZPArZPOo4CBEYWI,3761
 cirq/vis/vis_utils.py,sha256=CsNHb9vMBF9UjxZ2k5XqMESbATOx0FXhWAwxFbq-9pQ,1239
 cirq/vis/vis_utils_test.py,sha256=-aiL5WmhPDs_5BF2lDol1koD4JuHTiYxLK2ofyWrbCU,939
@@ -1175,8 +1175,8 @@ cirq/work/sampler.py,sha256=JEAeQQRF3bqlO9AkOf4XbrTATDI5f5JgyM_FAUCNxao,19751
 cirq/work/sampler_test.py,sha256=B2ZsuqGT854gQtBIAh8k0LiG9Vj5wSzcGvkxOUoTcW4,13217
 cirq/work/zeros_sampler.py,sha256=x1C7cup66a43n-3tm8QjhiqJa07qcJW10FxNp9jJ59Q,2356
 cirq/work/zeros_sampler_test.py,sha256=JIkpBBFPJe5Ba4142vzogyWyboG1Q1ZAm0UVGgOoZn8,3279
-cirq_core-1.5.0.dev20240703215652.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.5.0.dev20240703215652.dist-info/METADATA,sha256=P59m_cyl4kh6I1druK4i0HC1Mw4BwyITZcPin2G-zLY,2007
-cirq_core-1.5.0.dev20240703215652.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-cirq_core-1.5.0.dev20240703215652.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.5.0.dev20240703215652.dist-info/RECORD,,
+cirq_core-1.5.0.dev20240710220908.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.5.0.dev20240710220908.dist-info/METADATA,sha256=8GDfDiN4H53cFOnyL9z749aiCNozOl8b8rUfcmqfL20,2007
+cirq_core-1.5.0.dev20240710220908.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+cirq_core-1.5.0.dev20240710220908.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.5.0.dev20240710220908.dist-info/RECORD,,