cirq-core 1.5.0.dev20240710182542__py3-none-any.whl → 1.5.0.dev20240712174048__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.dev20240710182542"
+__version__ = "1.5.0.dev20240712174048"

cirq/_version_test.py

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

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/transformers/noise_adding.py

@@ -0,0 +1,114 @@
+# Copyright 2024 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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 collections.abc import Mapping
+
+from typing import cast
+from cirq import ops, circuits
+from cirq.transformers import transformer_api
+import numpy as np
+
+
+def _gate_in_moment(gate: ops.Gate, moment: circuits.Moment) -> bool:
+    """Check whether `gate` is in `moment`."""
+    return any(op.gate == gate for op in moment)
+
+
+@transformer_api.transformer
+class DepolerizingNoiseTransformer:
+    """Add local depolarizing noise after two-qubit gates in a specified circuit. More specifically,
+    with probability p, append a random non-identity two-qubit Pauli operator after each specified
+    two-qubit gate.
+
+    Attrs:
+        p: The probability with which to add noise.
+        target_gate: Add depolarizing nose after this type of gate
+    """
+
+    def __init__(
+        self, p: float | Mapping[tuple[ops.Qid, ops.Qid], float], target_gate: ops.Gate = ops.CZ
+    ):
+        """Initialize the depolarizing noise transformer with some depolarizing probability and
+        target gate.
+
+        Args:
+            p: The depolarizing probability, either a single float or a mapping from pairs of qubits
+               to floats.
+           target_gate: The gate after which to add depolarizing noise.
+
+        Raises:
+            TypeError: If `p` is not either be a float or a mapping from sorted qubit pairs to
+                       floats.
+        """
+
+        if not isinstance(p, (Mapping, float)):
+            raise TypeError(  # pragma: no cover
+                "p must either be a float or a mapping from"  # pragma: no cover
+                + "sorted qubit pairs to floats"  # pragma: no cover
+            )  # pragma: no cover
+        self.p = p
+        self.p_func = (
+            (lambda _: p)
+            if isinstance(p, (int, float))
+            else (lambda pair: cast(Mapping, p).get(pair, 0.0))
+        )
+        self.target_gate = target_gate
+
+    def __call__(
+        self,
+        circuit: circuits.AbstractCircuit,
+        rng: np.random.Generator | None = None,
+        *,
+        context: transformer_api.TransformerContext | None = None,
+    ):
+        """Apply the transformer to the given circuit.
+
+        Args:
+            circuit: The circuit to add noise to.
+            context: Not used; to satisfy transformer API.
+
+        Returns:
+            The transformed circuit.
+        """
+        if rng is None:
+            rng = np.random.default_rng()
+        target_gate = self.target_gate
+
+        # add random Pauli gates with probability p after each of the specified gate
+        assert target_gate.num_qubits() == 2, "`target_gate` must be a two-qubit gate."
+        paulis = [ops.I, ops.X, ops.Y, ops.Z]
+        new_moments = []
+        for moment in circuit:
+            new_moments.append(moment)
+            if _gate_in_moment(target_gate, moment):
+                # add a new moment with the Paulis
+                target_pairs = {
+                    tuple(sorted(op.qubits)) for op in moment.operations if op.gate == target_gate
+                }
+                added_moment_ops = []
+                for pair in target_pairs:
+                    pair_sorted_tuple = (pair[0], pair[1])
+                    p_i = self.p_func(pair_sorted_tuple)
+                    apply = rng.choice([True, False], p=[p_i, 1 - p_i])
+                    if apply:
+                        choices = [
+                            (pauli_a(pair[0]), pauli_b(pair[1]))
+                            for pauli_a in paulis
+                            for pauli_b in paulis
+                        ][1:]
+                        pauli_to_apply = rng.choice(np.array(choices, dtype=object))
+                        added_moment_ops.append(pauli_to_apply)
+                if len(added_moment_ops) > 0:
+                    new_moments.append(circuits.Moment(*added_moment_ops))
+        return circuits.Circuit.from_moments(*new_moments)

cirq/transformers/noise_adding_test.py

@@ -0,0 +1,53 @@
+# Copyright 2024 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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 cirq import ops, circuits, devices
+import cirq.transformers.noise_adding as na
+import numpy as np
+
+
+def test_noise_adding():
+    qubits = devices.LineQubit.range(4)
+    one_layer = circuits.Circuit(ops.CZ(*qubits[:2]), ops.CZ(*qubits[2:]))
+    circuit = one_layer * 10
+
+    # test that p=0 does nothing
+    transformed_circuit_p0 = na.DepolerizingNoiseTransformer(0.0)(circuit)
+    assert transformed_circuit_p0 == circuit
+
+    # test that p=1 doubles the circuit depth
+    transformed_circuit_p1 = na.DepolerizingNoiseTransformer(1.0)(circuit)
+    assert len(transformed_circuit_p1) == 20
+
+    # test that we get a deterministic result when using a specific rng
+    rng = np.random.default_rng(0)
+    transformed_circuit_p0_03 = na.DepolerizingNoiseTransformer(0.03)(circuit, rng=rng)
+    expected_circuit = (
+        one_layer * 2
+        + circuits.Circuit(ops.I(qubits[2]), ops.Z(qubits[3]))
+        + one_layer * 4
+        + circuits.Circuit(ops.Z(qubits[0]), ops.X(qubits[1]))
+        + one_layer * 4
+        + circuits.Circuit(ops.I(qubits[2]), ops.X(qubits[3]))
+    )
+    assert transformed_circuit_p0_03 == expected_circuit
+
+    # test that supplying a dictionary for p works
+    transformed_circuit_p_dict = na.DepolerizingNoiseTransformer(
+        {tuple(qubits[:2]): 1.0, tuple(qubits[2:]): 0.0}
+    )(circuit)
+    assert len(transformed_circuit_p_dict) == 20  # depth should be doubled
+    assert transformed_circuit_p_dict[1::2].all_qubits() == frozenset(
+        qubits[:2]
+    )  # no single-qubit gates get added to qubits[2:]

{cirq_core-1.5.0.dev20240710182542.dist-info → cirq_core-1.5.0.dev20240712174048.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cirq-core
-Version: 1.5.0.dev20240710182542
+Version: 1.5.0.dev20240712174048
 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.dev20240710182542.dist-info → cirq_core-1.5.0.dev20240712174048.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=HIIB0b9Wy7zEzEqod-2yDGhm22XK7euGHdvbV3cfVAM,1206
-cirq/_version_test.py,sha256=QZUwTHZTIQjXrPyBRB3BoYlofYOkMC8iFH_aW5I7X-w,147
+cirq/_version.py,sha256=iUhBnaAkxANMTntlE0vtUUwIfs0DksnHzH_qxhgat2s,1206
+cirq/_version_test.py,sha256=jsZSypKTqjpgtoUqQ_xhXrNpPwx3PqF0JcOJqT0-2pk,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
@@ -196,10 +196,10 @@ cirq/experiments/t1_decay_experiment.py,sha256=ealdmc_RTE__z1YUcaDEncDzQOaiT0K6I
 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
@@ -1038,6 +1038,8 @@ cirq/transformers/merge_k_qubit_gates.py,sha256=dUsswQOIHfbb6Lu37fecgrpT6_45zmDE
 cirq/transformers/merge_k_qubit_gates_test.py,sha256=k_ROZvUebHgPy5vsNnWNMBYU4kfIkrunPsw39ZngMwo,13920
 cirq/transformers/merge_single_qubit_gates.py,sha256=NRREV4Z6Ptc3mZnOUgzQePdj4H0aix17WOUwZUB7iQ8,5826
 cirq/transformers/merge_single_qubit_gates_test.py,sha256=SWf1Il7Bz0iUCDM7JoDG2Yxe4p2yYr2PgViQpjByFm0,9914
+cirq/transformers/noise_adding.py,sha256=Ng1JoGzSJdrA7WBAOLmM5kSGWP4bqEnQc-g9kYxePNQ,4439
+cirq/transformers/noise_adding_test.py,sha256=C0G16cj_hGWgpAYV0L7p3_p4LkD7SR99p0DJJq1fUwk,2134
 cirq/transformers/optimize_for_target_gateset.py,sha256=MxhFsCm2XgW3gdpNW4NGVmz1VdQvzKdNNCtVZDuZiVE,7229
 cirq/transformers/optimize_for_target_gateset_test.py,sha256=MgAHjsPbVtd0fl2ytRz2R-LQuhSqImtrFK5F45QXkA8,19523
 cirq/transformers/qubit_management_transformers.py,sha256=A7Mweu9ElLSCsy_atmgFbYlzOFXKhct5gQ5YNTjjaVU,9430
@@ -1175,8 +1177,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.dev20240710182542.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.5.0.dev20240710182542.dist-info/METADATA,sha256=yq79KiLKlMbvvBFq9FdSb5g3UXF_hdfNH-vYwSOtQSU,2007
-cirq_core-1.5.0.dev20240710182542.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-cirq_core-1.5.0.dev20240710182542.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.5.0.dev20240710182542.dist-info/RECORD,,
+cirq_core-1.5.0.dev20240712174048.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.5.0.dev20240712174048.dist-info/METADATA,sha256=NlXO10cYbogOnPAE1Ey5161fy8CcORzhbrcdiEYYDl8,2007
+cirq_core-1.5.0.dev20240712174048.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+cirq_core-1.5.0.dev20240712174048.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.5.0.dev20240712174048.dist-info/RECORD,,