cirq-core 1.5.0.dev20240720215906__py3-none-any.whl → 1.5.0.dev20240723233926__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.dev20240720215906"
+__version__ = "1.5.0.dev20240723233926"

cirq/_version_test.py

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

cirq/experiments/two_qubit_xeb.py

@@ -143,7 +143,9 @@ class TwoQubitXEBResult:
 
     def xeb_fidelity(self, q0: 'cirq.GridQubit', q1: 'cirq.GridQubit') -> float:
         """Return the XEB fidelity of a qubit pair."""
-        return self._record(q0, q1).layer_fid
+        return noise_utils.decay_constant_to_xeb_fidelity(
+            self._record(q0, q1).layer_fid, num_qubits=2
+        )
 
     def xeb_error(self, q0: 'cirq.GridQubit', q1: 'cirq.GridQubit') -> float:
         """Return the XEB error of a qubit pair."""
@@ -177,8 +179,7 @@ class TwoQubitXEBResult:
         """Return the Pauli error of all qubit pairs."""
         return {
             pair: noise_utils.decay_constant_to_pauli_error(
-                noise_utils.xeb_fidelity_to_decay_constant(self.xeb_fidelity(*pair), num_qubits=2),
-                num_qubits=2,
+                self._record(*pair).layer_fid, num_qubits=2
             )
             for pair in self.all_qubit_pairs
         }

cirq/experiments/two_qubit_xeb_test.py

@@ -148,10 +148,10 @@ _TEST_RESULT = cirq.experiments.TwoQubitXEBResult(
 @pytest.mark.parametrize(
     'q0,q1,pauli',
     [
-        (cirq.GridQubit(4, 4), cirq.GridQubit(5, 4), 1 / 8),
-        (cirq.GridQubit(5, 3), cirq.GridQubit(6, 3), 1 / 4),
-        (cirq.GridQubit(4, 3), cirq.GridQubit(5, 3), 0.8 + 3 / 40),
-        (cirq.GridQubit(6, 3), cirq.GridQubit(6, 4), 5 / 8),
+        (cirq.GridQubit(4, 4), cirq.GridQubit(5, 4), 0.09374999999999997),
+        (cirq.GridQubit(5, 3), cirq.GridQubit(6, 3), 0.18749999999999994),
+        (cirq.GridQubit(4, 3), cirq.GridQubit(5, 3), 0.65625),
+        (cirq.GridQubit(6, 3), cirq.GridQubit(6, 4), 0.46875),
     ],
 )
 def test_pauli_error(q0: cirq.GridQubit, q1: cirq.GridQubit, pauli: float):
@@ -174,10 +174,10 @@ class MockParallelRandomizedBenchmarkingResult(ParallelRandomizedBenchmarkingRes
 @pytest.mark.parametrize(
     'q0,q1,pauli',
     [
-        (cirq.GridQubit(4, 4), cirq.GridQubit(5, 4), 1 / 8 - 0.03),
-        (cirq.GridQubit(5, 3), cirq.GridQubit(6, 3), 1 / 4 - 0.09),
-        (cirq.GridQubit(4, 3), cirq.GridQubit(5, 3), 0.8 + 3 / 40 - 0.08),
-        (cirq.GridQubit(6, 3), cirq.GridQubit(6, 4), 5 / 8 - 0.13),
+        (cirq.GridQubit(4, 4), cirq.GridQubit(5, 4), 0.09374999999999997 - 0.03),
+        (cirq.GridQubit(5, 3), cirq.GridQubit(6, 3), 0.18749999999999994 - 0.09),
+        (cirq.GridQubit(4, 3), cirq.GridQubit(5, 3), 0.65625 - 0.08),
+        (cirq.GridQubit(6, 3), cirq.GridQubit(6, 4), 0.46875 - 0.13),
     ],
 )
 def test_inferred_pauli_error(q0: cirq.GridQubit, q1: cirq.GridQubit, pauli: float):
@@ -191,10 +191,10 @@ def test_inferred_pauli_error(q0: cirq.GridQubit, q1: cirq.GridQubit, pauli: flo
 @pytest.mark.parametrize(
     'q0,q1,xeb',
     [
-        (cirq.GridQubit(4, 4), cirq.GridQubit(5, 4), 0.076),
-        (cirq.GridQubit(5, 3), cirq.GridQubit(6, 3), 0.128),
-        (cirq.GridQubit(4, 3), cirq.GridQubit(5, 3), 0.636),
-        (cirq.GridQubit(6, 3), cirq.GridQubit(6, 4), 0.396),
+        (cirq.GridQubit(4, 4), cirq.GridQubit(5, 4), 0.050999999999999934),
+        (cirq.GridQubit(5, 3), cirq.GridQubit(6, 3), 0.07799999999999996),
+        (cirq.GridQubit(4, 3), cirq.GridQubit(5, 3), 0.46099999999999997),
+        (cirq.GridQubit(6, 3), cirq.GridQubit(6, 4), 0.2709999999999999),
     ],
 )
 def test_inferred_xeb_error(q0: cirq.GridQubit, q1: cirq.GridQubit, xeb: float):
@@ -224,10 +224,10 @@ def test_inferred_single_qubit_pauli():
 @pytest.mark.parametrize(
     'q0,q1,pauli',
     [
-        (cirq.GridQubit(4, 4), cirq.GridQubit(5, 4), 1 / 8),
-        (cirq.GridQubit(5, 3), cirq.GridQubit(6, 3), 1 / 4),
-        (cirq.GridQubit(4, 3), cirq.GridQubit(5, 3), 0.8 + 3 / 40),
-        (cirq.GridQubit(6, 3), cirq.GridQubit(6, 4), 5 / 8),
+        (cirq.GridQubit(4, 4), cirq.GridQubit(5, 4), 0.09374999999999997),
+        (cirq.GridQubit(5, 3), cirq.GridQubit(6, 3), 0.18749999999999994),
+        (cirq.GridQubit(4, 3), cirq.GridQubit(5, 3), 0.65625),
+        (cirq.GridQubit(6, 3), cirq.GridQubit(6, 4), 0.46875),
     ],
 )
 def test_inferred_two_qubit_pauli(q0: cirq.GridQubit, q1: cirq.GridQubit, pauli: float):

cirq/transformers/randomized_measurements.py

@@ -13,17 +13,18 @@
 # limitations under the License.
 
 from collections.abc import Sequence
-from typing import Any, Literal
+from typing import Any
 
 import cirq
 import numpy as np
+from cirq.ops import SingleQubitCliffordGate
 from cirq.transformers import transformer_api
 
 
 @transformer_api.transformer
 class RandomizedMeasurements:
-    """A transformer that appends a moment of random rotations to map qubits to
-    random pauli bases."""
+    """A transformer that appends a moment of random rotations from a given unitary ensemble (pauli,
+    clifford, cue)"""
 
     def __init__(self, subsystem: Sequence[int] | None = None):
         """Class structure for performing and analyzing a general randomized measurement protocol.
@@ -31,79 +32,139 @@ class RandomizedMeasurements:
 
         Args:
             subsystem: The specific subsystem (e.g qubit index) to measure in random basis
+            rest of the qubits are measured in the computational basis
         """
         self.subsystem = subsystem
 
     def __call__(
         self,
-        circuit: 'cirq.AbstractCircuit',
+        circuit: "cirq.AbstractCircuit",
+        unitary_ensemble: str = "pauli",
         rng: np.random.Generator | None = None,
         *,
         context: transformer_api.TransformerContext | None = None,
-    ):
+    ) -> "cirq.Circuit":
         """Apply the transformer to the given circuit. Given an input circuit returns
-        a list of circuits with the pre-measurement unitaries. If no arguments are specified,
-        it will default to computing the entropy of the entire circuit.
+        a new circuit with the pre-measurement unitaries and measurements gates added.
+        to the qubits in the subsystem provided.If no subsystem is specified in the
+        construction of this class it defaults to measuring all the qubits in the
+        randomized bases.
 
         Args:
             circuit: The circuit to add randomized measurements to.
-            rng: Random number generator.
+            unitary_ensemble: Choice of unitary ensemble (pauli/clifford/cue(circular
+                unitary ensemble))
             context: Not used; to satisfy transformer API.
+            rng: Random number generator.
 
         Returns:
-            List of circuits with pre-measurement unitaries and measurements added
+            A circuit with pre-measurement unitaries and measurements added
         """
+
+        all_qubits = sorted(circuit.all_qubits())
+        if self.subsystem is None:
+            subsystem_qubits = all_qubits
+        else:
+            subsystem_qubits = [all_qubits[s] for s in self.subsystem]
         if rng is None:
             rng = np.random.default_rng()
 
-        qubits = sorted(circuit.all_qubits())
-        num_qubits = len(qubits)
-
-        pre_measurement_unitaries_list = self._generate_unitaries_list(rng, num_qubits)
-        pre_measurement_moment = self.unitaries_to_moment(pre_measurement_unitaries_list, qubits)
+        pre_measurement_moment = self.random_single_qubit_unitary_moment(
+            unitary_ensemble, subsystem_qubits, rng
+        )
 
         return cirq.Circuit.from_moments(
-            *circuit.moments, pre_measurement_moment, cirq.M(*qubits, key='m')
+            *circuit.moments, pre_measurement_moment, cirq.M(*subsystem_qubits, key="m")
         )
 
-    def _generate_unitaries_list(self, rng: np.random.Generator, num_qubits: int) -> Sequence[Any]:
-        """Generates a list of pre-measurement unitaries."""
-
-        pauli_strings = rng.choice(["X", "Y", "Z"], size=num_qubits)
-
-        if self.subsystem is not None:
-            for i in range(pauli_strings.shape[0]):
-                if i not in self.subsystem:
-                    pauli_strings[i] = np.array("Z")
-
-        return pauli_strings.tolist()
-
-    def unitaries_to_moment(
-        self, unitaries: Sequence[Literal["X", "Y", "Z"]], qubits: Sequence[Any]
-    ) -> 'cirq.Moment':
+    def random_single_qubit_unitary_moment(
+        self, unitary_ensemble: str, qubits: Sequence[Any], rng: np.random.Generator
+    ) -> "cirq.Moment":
         """Outputs the cirq moment associated with the pre-measurement rotations.
+
         Args:
-            unitaries: List of pre-measurement unitaries
+            unitary_ensemble: clifford, pauli, cue
             qubits: List of qubits
+            rng: Random number generator to be used in sampling.
 
-        Returns: The cirq moment associated with the pre-measurement rotations
+        Returns:
+            The cirq moment associated with the pre-measurement rotations
+
+        Raises:
+            ValueError: When unitary_ensemble is not one of "cue", "pauli" or "clifford"
         """
+
+        if unitary_ensemble.lower() == "pauli":
+            unitaries = [_pauli_basis_rotation(rng) for _ in range(len(qubits))]
+
+        elif unitary_ensemble.lower() == "clifford":
+            unitaries = [_single_qubit_clifford(rng) for _ in range(len(qubits))]
+
+        elif unitary_ensemble.lower() == "cue":
+            unitaries = [_single_qubit_cue(rng) for _ in range(len(qubits))]
+
+        else:
+            raise ValueError("Only pauli, clifford and cue unitaries are available")
+
         op_list: list[cirq.Operation] = []
-        for idx, pauli in enumerate(unitaries):
-            op_list.append(_pauli_basis_rotation(pauli).on(qubits[idx]))
+
+        for idx, unitary in enumerate(unitaries):
+            op_list.append(unitary.on(qubits[idx]))
 
         return cirq.Moment.from_ops(*op_list)
 
 
-def _pauli_basis_rotation(basis: Literal["X", "Y", "Z"]) -> 'cirq.Gate':
-    """Given a measurement basis returns the associated rotation.
+def _pauli_basis_rotation(rng: np.random.Generator) -> "cirq.Gate":
+    """Randomly generate a Pauli basis rotation.
+
     Args:
-        basis: Measurement basis
-    Returns: The cirq gate for associated with measurement basis
+        rng: Random number generator
+
+    Returns:
+        cirq gate
+    """
+    basis_idx = rng.choice(np.arange(3))
+
+    if basis_idx == 0:
+        gate: "cirq.Gate" = cirq.Ry(rads=-np.pi / 2)
+    elif basis_idx == 1:
+        gate = cirq.Rx(rads=np.pi / 2)
+    else:
+        gate = cirq.I
+    return gate
+
+
+def _single_qubit_clifford(rng: np.random.Generator) -> "cirq.Gate":
+    """Randomly generate a single-qubit Clifford rotation.
+
+    Args:
+        rng: Random number generator
+
+    Returns:
+        cirq gate
+    """
+
+    # there are 24 distinct single-qubit Clifford gates
+    clifford_idx = rng.choice(np.arange(24))
+
+    return SingleQubitCliffordGate.to_phased_xz_gate(
+        SingleQubitCliffordGate.all_single_qubit_cliffords[clifford_idx]
+    )
+
+
+def _single_qubit_cue(rng: np.random.Generator) -> "cirq.Gate":
+    """Randomly generate a CUE gate.
+
+    Args:
+        rng: Random number generator
+
+    Returns:
+        cirq gate
     """
-    if basis == "X":
-        return cirq.Ry(rads=-np.pi / 2)
-    elif basis == "Y":
-        return cirq.Rx(rads=np.pi / 2)
-    elif basis == "Z":
-        return cirq.I
+
+    # phasedxz parameters are distinct between -1 and +1
+    x_exponent, z_exponent, axis_phase_exponent = 1 - 2 * rng.random(size=3)
+
+    return cirq.PhasedXZGate(
+        x_exponent=x_exponent, z_exponent=z_exponent, axis_phase_exponent=axis_phase_exponent
+    )

cirq/transformers/randomized_measurements_test.py

@@ -14,19 +14,23 @@
 
 import cirq
 import cirq.transformers.randomized_measurements as rand_meas
+import pytest
 
 
 def test_randomized_measurements_appends_two_moments_on_returned_circuit():
     # Create a 4-qubit circuit
     q0, q1, q2, q3 = cirq.LineQubit.range(4)
-    circuit = cirq.Circuit([cirq.H(q0), cirq.CNOT(q0, q1), cirq.CNOT(q1, q2), cirq.CNOT(q2, q3)])
-    num_moments_pre = len(circuit.moments)
+    circuit_pre = cirq.Circuit(
+        [cirq.H(q0), cirq.CNOT(q0, q1), cirq.CNOT(q1, q2), cirq.CNOT(q2, q3)]
+    )
+    num_moments_pre = len(circuit_pre.moments)
 
     # Append randomized measurements to subsystem
-    circuit = rand_meas.RandomizedMeasurements()(circuit)
-
-    num_moments_post = len(circuit.moments)
-    assert num_moments_post == num_moments_pre + 2
+    unitary_ensembles = ['pauli', 'clifford', 'cue']
+    for u in unitary_ensembles:
+        circuit_post = rand_meas.RandomizedMeasurements()(circuit_pre, unitary_ensemble=u)
+        num_moments_post = len(circuit_post.moments)
+        assert num_moments_post == num_moments_pre + 2
 
 
 def test_append_randomized_measurements_leaves_qubits_not_in_specified_subsystem_unchanged():
@@ -36,10 +40,9 @@ def test_append_randomized_measurements_leaves_qubits_not_in_specified_subsystem
 
     # Append randomized measurements to subsystem
     circuit = rand_meas.RandomizedMeasurements(subsystem=(0, 1))(circuit)
-
     # assert latter subsystems were not changed.
-    assert circuit.operation_at(q2, 4) == cirq.I(q2)
-    assert circuit.operation_at(q3, 4) == cirq.I(q3)
+    assert circuit.operation_at(q2, 4) is None
+    assert circuit.operation_at(q3, 4) is None
 
 
 def test_append_randomized_measurements_leaves_qubits_not_in_noncontinuous_subsystem_unchanged():
@@ -51,5 +54,14 @@ def test_append_randomized_measurements_leaves_qubits_not_in_noncontinuous_subsy
     circuit = rand_meas.RandomizedMeasurements(subsystem=(0, 2))(circuit)
 
     # assert latter subsystems were not changed.
-    assert circuit.operation_at(q1, 4) == cirq.I(q1)
-    assert circuit.operation_at(q3, 4) == cirq.I(q3)
+    assert circuit.operation_at(q1, 4) is None
+    assert circuit.operation_at(q3, 4) is None
+
+
+def test_exception():
+    q0, q1, q2, q3 = cirq.LineQubit.range(4)
+    circuit = cirq.Circuit([cirq.H(q0), cirq.CNOT(q0, q1), cirq.CNOT(q1, q2), cirq.CNOT(q2, q3)])
+
+    # Append randomized measurements to subsystem
+    with pytest.raises(ValueError):
+        rand_meas.RandomizedMeasurements()(circuit, unitary_ensemble="coe")

{cirq_core-1.5.0.dev20240720215906.dist-info → cirq_core-1.5.0.dev20240723233926.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cirq-core
-Version: 1.5.0.dev20240720215906
+Version: 1.5.0.dev20240723233926
 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.dev20240720215906.dist-info → cirq_core-1.5.0.dev20240723233926.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=qWf7WGQCKqbcvL7noax2Has0rytfmts3dscLywWTidw,1206
-cirq/_version_test.py,sha256=xoly0YgCV1lQhnowYa6T9ZCpg-_PT_-eXHh6Av-Sz6E,147
+cirq/_version.py,sha256=vqNxUekJB6OW8tq4V5O46uke_u4hHGYkb1-RErSMfNk,1206
+cirq/_version_test.py,sha256=FXvASQTfU_0AoGcYal5mjjne-oPGZ2BnUUKSKyadLGs,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,8 +196,8 @@ 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=5-rieJ2ct6TQt7zHHq_2Yafu6ScQjjeEPawzWWTfoAA,19933
-cirq/experiments/two_qubit_xeb_test.py,sha256=Tlr32vuJpyepkMBVVkN6ipjRyDr8DIixfBumEeGXzDM,10073
+cirq/experiments/two_qubit_xeb.py,sha256=N2X9N1A6hRS2Xe4zcmLJTyZ80DKDB0Pmv2fN4-UOU_s,19943
+cirq/experiments/two_qubit_xeb_test.py,sha256=ZeZvClUAB8ir42Bd3PWr-s0_-QKWbFdYqfvvOMawsm0,10204
 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
@@ -1046,8 +1046,8 @@ cirq/transformers/optimize_for_target_gateset.py,sha256=MxhFsCm2XgW3gdpNW4NGVmz1
 cirq/transformers/optimize_for_target_gateset_test.py,sha256=MgAHjsPbVtd0fl2ytRz2R-LQuhSqImtrFK5F45QXkA8,19523
 cirq/transformers/qubit_management_transformers.py,sha256=A7Mweu9ElLSCsy_atmgFbYlzOFXKhct5gQ5YNTjjaVU,9430
 cirq/transformers/qubit_management_transformers_test.py,sha256=GGuZ4uxtFI59t9diW67_J17XQdBu9NFZjOHeMAHmm8Y,13991
-cirq/transformers/randomized_measurements.py,sha256=GfHI2dtx6MmHbp0akXACi44GD7CoDNB_wdmFZPyaETc,4049
-cirq/transformers/randomized_measurements_test.py,sha256=gvlXALIe1pm-fgNth0usSePnj0Gdx3kc40rKSbaAFHI,2265
+cirq/transformers/randomized_measurements.py,sha256=E1VG4sKWcZ-OZINpFT7F2n0I3kZpButkjNbHz95YaVw,5686
+cirq/transformers/randomized_measurements_test.py,sha256=z3K3YiGFiOrxw0dVjKUxRwbRHKspVvisyM1tpSKozl0,2736
 cirq/transformers/stratify.py,sha256=EEcXD6PEdHTZAoaAfaHnsw3Hf1SftbIl19hZOU_ZnXE,10469
 cirq/transformers/stratify_test.py,sha256=17ic2VAUPEGuPG2o5j98yDxQ2j2J_PN3EsPsfh5xwUk,15220
 cirq/transformers/synchronize_terminal_measurements.py,sha256=p061MYYglY6HhWYYkFzIny0CtaY9LUygPg4UbGewZhQ,3842
@@ -1181,8 +1181,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.dev20240720215906.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.5.0.dev20240720215906.dist-info/METADATA,sha256=m1Dp-LdtpXBGgGjjIFKWhJckJISEjZXQyBKJZmamVGo,2007
-cirq_core-1.5.0.dev20240720215906.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-cirq_core-1.5.0.dev20240720215906.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.5.0.dev20240720215906.dist-info/RECORD,,
+cirq_core-1.5.0.dev20240723233926.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.5.0.dev20240723233926.dist-info/METADATA,sha256=reaHCvMFs4BM9GguxY_5tcT4_A8Qua34H-QGz2D7EUQ,2007
+cirq_core-1.5.0.dev20240723233926.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+cirq_core-1.5.0.dev20240723233926.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.5.0.dev20240723233926.dist-info/RECORD,,