cirq-core 1.5.0.dev20250121234557__py3-none-any.whl → 1.5.0.dev20250122154326__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.dev20250121234557"
+__version__ = "1.5.0.dev20250122154326"

cirq/_version_test.py

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

cirq/contrib/acquaintance/gates.py

@@ -316,10 +316,10 @@ class SwapNetworkGate(PermutationGate):
                 parts_qubits = list(left_part + right_part)
                 parts[i] = parts_qubits[: len(right_part)]
                 parts[i + 1] = parts_qubits[len(right_part) :]
-            layers.prior_interstitial.sort(key=op_sort_key)
+            layers.prior_interstitial.sort(key=op_sort_key)  # type: ignore[arg-type]
             for l in ('prior_interstitial', 'pre', 'intra', 'post'):
                 yield getattr(layers, l)
-        layers.posterior_interstitial.sort(key=op_sort_key)
+        layers.posterior_interstitial.sort(key=op_sort_key)  # type: ignore[arg-type]
         yield layers.posterior_interstitial
 
         assert list(

cirq/contrib/shuffle_circuits/__init__.py

@@ -0,0 +1,18 @@
+# Copyright 2025 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.
+"""Utility for shuffling circuits and do readout error benchmarking."""
+
+from cirq.contrib.shuffle_circuits.shuffle_circuits_with_readout_benchmarking import (
+    run_shuffled_with_readout_benchmarking as run_shuffled_with_readout_benchmarking,
+)

cirq/contrib/shuffle_circuits/shuffle_circuits_with_readout_benchmarking.py

@@ -0,0 +1,229 @@
+# Copyright 2025 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.
+"""Tools for running circuits in a shuffled order with readout error benchmarking."""
+import time
+from typing import Optional, Union
+
+import numpy as np
+
+from cirq import ops, circuits, work, protocols
+from cirq.experiments import SingleQubitReadoutCalibrationResult
+from cirq.study import ResultDict
+
+
+def _validate_input(
+    input_circuits: list[circuits.Circuit],
+    circuit_repetitions: Union[int, list[int]],
+    rng_or_seed: Union[np.random.Generator, int],
+    num_random_bitstrings: int,
+    readout_repetitions: int,
+):
+    if not input_circuits:
+        raise ValueError("Input circuits must not be empty.")
+    # Check input_circuits type is cirq.circuits
+    if not all(isinstance(circuit, circuits.Circuit) for circuit in input_circuits):
+        raise ValueError("Input circuits must be of type cirq.Circuit.")
+    # Check input_circuits have measurements
+    for circuit in input_circuits:
+        if not any(protocols.is_measurement(circuit) for op in circuit.all_operations()):
+            raise ValueError("Input circuits must have measurements.")
+
+    # Check circuit_repetitions
+    if isinstance(circuit_repetitions, int):
+        if circuit_repetitions <= 0:
+            raise ValueError("Must provide non-zero circuit_repetitions.")
+    if isinstance(circuit_repetitions, list) and len(circuit_repetitions) != len(input_circuits):
+        raise ValueError("Number of circuit_repetitions must match the number of input circuits.")
+
+    # Check rng is a numpy random generator
+    if not isinstance(rng_or_seed, np.random.Generator) and not isinstance(rng_or_seed, int):
+        raise ValueError("Must provide a numpy random generator or a seed")
+
+    # Check num_random_bitstrings is bigger than 0
+    if num_random_bitstrings <= 0:
+        raise ValueError("Must provide non-zero num_random_bitstrings.")
+
+    # Check readout_repetitions is bigger than 0
+    if readout_repetitions <= 0:
+        raise ValueError("Must provide non-zero readout_repetitions for readout calibration.")
+
+
+def _generate_readout_calibration_circuits(
+    qubits: list[ops.Qid], rng: np.random.Generator, num_random_bitstrings: int
+) -> tuple[list[circuits.Circuit], np.ndarray]:
+    """Generates the readout calibration circuits with random bitstrings."""
+    bit_to_gate = (ops.I, ops.X)
+
+    random_bitstrings = rng.integers(0, 2, size=(num_random_bitstrings, len(qubits)))
+
+    readout_calibration_circuits = []
+    for bitstr in random_bitstrings:
+        readout_calibration_circuits.append(
+            circuits.Circuit(
+                [bit_to_gate[bit](qubit) for bit, qubit in zip(bitstr, qubits)]
+                + [ops.M(qubits, key="m")]
+            )
+        )
+    return readout_calibration_circuits, random_bitstrings
+
+
+def _shuffle_circuits(
+    all_circuits: list[circuits.Circuit], all_repetitions: list[int], rng: np.random.Generator
+) -> tuple[list[circuits.Circuit], list[int], np.ndarray]:
+    """Shuffles the input circuits and readout calibration circuits."""
+    shuf_order = rng.permutation(len(all_circuits))
+    unshuf_order = np.zeros_like(shuf_order)  # Inverse permutation
+    unshuf_order[shuf_order] = np.arange(len(all_circuits))
+    shuffled_circuits = [all_circuits[i] for i in shuf_order]
+    all_repetitions = [all_repetitions[i] for i in shuf_order]
+    return shuffled_circuits, all_repetitions, unshuf_order
+
+
+def _analyze_readout_results(
+    unshuffled_readout_measurements: list[ResultDict],
+    random_bitstrings: np.ndarray,
+    readout_repetitions: int,
+    qubits: list[ops.Qid],
+    timestamp: float,
+) -> SingleQubitReadoutCalibrationResult:
+    """Analyzes the readout error rates from the unshuffled measurements.
+
+    Args:
+        readout_measurements: A list of dictionaries containing the measurement results
+                              for each readout calibration circuit.
+        random_bitstrings: A numpy array of random bitstrings used for measuring readout.
+        readout_repetitions: The number of repetitions for each readout bitstring.
+        qubits: The list of qubits for which the readout error rates are to be calculated.
+
+    Returns:
+        A dictionary mapping each qubit to a tuple of readout error rates(e0 and e1),
+        where e0 is the 0->1 readout error rate and e1 is the 1->0 readout error rate.
+    """
+
+    zero_state_trials = np.zeros((1, len(qubits)), dtype=np.int64)
+    one_state_trials = np.zeros((1, len(qubits)), dtype=np.int64)
+    zero_state_totals = np.zeros((1, len(qubits)), dtype=np.int64)
+    one_state_totals = np.zeros((1, len(qubits)), dtype=np.int64)
+    for measurement_result, bitstr in zip(unshuffled_readout_measurements, random_bitstrings):
+        for _, trial_result in measurement_result.measurements.items():
+            trial_result = trial_result.astype(np.int64)  # Cast to int64
+            sample_counts = np.sum(trial_result, axis=0)
+
+            zero_state_trials += sample_counts * (1 - bitstr)
+            zero_state_totals += readout_repetitions * (1 - bitstr)
+            one_state_trials += (readout_repetitions - sample_counts) * bitstr
+            one_state_totals += readout_repetitions * bitstr
+
+    zero_state_errors = {
+        q: (
+            zero_state_trials[0][qubit_idx] / zero_state_totals[0][qubit_idx]
+            if zero_state_totals[0][qubit_idx] > 0
+            else np.nan
+        )
+        for qubit_idx, q in enumerate(qubits)
+    }
+
+    one_state_errors = {
+        q: (
+            one_state_trials[0][qubit_idx] / one_state_totals[0][qubit_idx]
+            if one_state_totals[0][qubit_idx] > 0
+            else np.nan
+        )
+        for qubit_idx, q in enumerate(qubits)
+    }
+    return SingleQubitReadoutCalibrationResult(
+        zero_state_errors=zero_state_errors,
+        one_state_errors=one_state_errors,
+        repetitions=readout_repetitions,
+        timestamp=timestamp,
+    )
+
+
+def run_shuffled_with_readout_benchmarking(
+    input_circuits: list[circuits.Circuit],
+    sampler: work.Sampler,
+    circuit_repetitions: Union[int, list[int]],
+    rng_or_seed: Union[np.random.Generator, int],
+    num_random_bitstrings: int = 100,
+    readout_repetitions: int = 1000,
+    qubits: Optional[list[ops.Qid]] = None,
+) -> tuple[list[ResultDict], SingleQubitReadoutCalibrationResult]:
+    """Run the circuits in a shuffled order with readout error benchmarking.
+
+    Args:
+        input_circuits: The circuits to run.
+        sampler: The sampler to use.
+        circuit_repetitions: The repetitions for `circuits`.
+        rng_or_seed: A random number generator used to generate readout circuits.
+                     Or an integer seed.
+        num_random_bitstrings: The number of random bitstrings for measuring readout.
+        readout_repetitions: The number of repetitions for each readout bitstring.
+        qubits: The qubits to benchmark readout errors. If None, all qubits in the
+                input_circuits are used.
+
+    Returns:
+        A tuple containing:
+        - A list of dictionaries with the unshuffled measurement results.
+        - A dictionary mapping each qubit to a tuple of readout error rates(e0 and e1),
+          where e0 is the 0->1 readout error rate and e1 is the 1->0 readout error rate.
+
+    """
+
+    _validate_input(
+        input_circuits, circuit_repetitions, rng_or_seed, num_random_bitstrings, readout_repetitions
+    )
+
+    # If input qubits is None, extract qubits from input circuits
+    if qubits is None:
+        qubits_set: set[ops.Qid] = set()
+        for circuit in input_circuits:
+            qubits_set.update(circuit.all_qubits())
+        qubits = sorted(qubits_set)
+
+    # Generate the readout calibration circuits
+    rng = (
+        rng_or_seed
+        if isinstance(rng_or_seed, np.random.Generator)
+        else np.random.default_rng(rng_or_seed)
+    )
+    readout_calibration_circuits, random_bitstrings = _generate_readout_calibration_circuits(
+        qubits, rng, num_random_bitstrings
+    )
+
+    # Shuffle the circuits
+    if isinstance(circuit_repetitions, int):
+        circuit_repetitions = [circuit_repetitions] * len(input_circuits)
+    all_repetitions = circuit_repetitions + [readout_repetitions] * len(
+        readout_calibration_circuits
+    )
+
+    shuffled_circuits, all_repetitions, unshuf_order = _shuffle_circuits(
+        input_circuits + readout_calibration_circuits, all_repetitions, rng
+    )
+
+    # Run the shuffled circuits and measure
+    results = sampler.run_batch(shuffled_circuits, repetitions=all_repetitions)
+    timestamp = time.time()
+    shuffled_measurements = [res[0] for res in results]
+    unshuffled_measurements = [shuffled_measurements[i] for i in unshuf_order]
+
+    unshuffled_input_circuits_measiurements = unshuffled_measurements[: len(input_circuits)]
+    unshuffled_readout_measurements = unshuffled_measurements[len(input_circuits) :]
+
+    # Analyze results
+    readout_calibration_results = _analyze_readout_results(
+        unshuffled_readout_measurements, random_bitstrings, readout_repetitions, qubits, timestamp
+    )
+
+    return unshuffled_input_circuits_measiurements, readout_calibration_results

cirq/contrib/shuffle_circuits/shuffle_circuits_with_readout_benchmarking_test.py

@@ -0,0 +1,302 @@
+# Copyright 2025 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.
+
+import pytest
+
+import cirq
+import numpy as np
+
+from cirq.experiments.single_qubit_readout_calibration_test import NoisySingleQubitReadoutSampler
+from cirq.experiments import random_quantum_circuit_generation as rqcg
+from cirq.experiments import SingleQubitReadoutCalibrationResult
+from cirq.study import ResultDict
+
+
+def test_shuffled_circuits_with_readout_benchmarking_errors_no_noise():
+    """Test shuffled circuits with readout benchmarking with no noise from sampler."""
+    qubits = cirq.LineQubit.range(5)
+
+    # Generate random input circuits
+    input_circuits = []
+    input_circuits += rqcg.generate_library_of_2q_circuits(
+        n_library_circuits=5, two_qubit_gate=cirq.ISWAP**0.5, q0=qubits[0], q1=qubits[2]
+    )
+    input_circuits += rqcg.generate_library_of_2q_circuits(
+        n_library_circuits=5, two_qubit_gate=cirq.CNOT**0.5, q0=qubits[1], q1=qubits[3]
+    )
+    input_circuits += rqcg.generate_library_of_2q_circuits(
+        n_library_circuits=5, two_qubit_gate=cirq.CNOT**0.5, q0=qubits[0], q1=qubits[4]
+    )
+    input_circuits += rqcg.generate_library_of_2q_circuits(
+        n_library_circuits=5, two_qubit_gate=cirq.ISWAP**0.5, q0=qubits[2], q1=qubits[4]
+    )
+    for circuit in input_circuits:
+        circuit.append(cirq.measure(*qubits, key="m"))
+
+    sampler = cirq.Simulator()
+    circuit_repetitions = 1
+    # allow passing a seed
+    rng = 123
+    readout_repetitions = 1000
+
+    measurements, readout_calibration_results = (
+        cirq.contrib.shuffle_circuits.run_shuffled_with_readout_benchmarking(
+            input_circuits,
+            sampler,
+            circuit_repetitions,
+            rng,
+            num_random_bitstrings=100,
+            readout_repetitions=readout_repetitions,
+        )
+    )
+
+    for measurement in measurements:
+        assert isinstance(measurement, ResultDict)
+
+    assert isinstance(readout_calibration_results, SingleQubitReadoutCalibrationResult)
+
+    assert readout_calibration_results.zero_state_errors == {q: 0 for q in qubits}
+    assert readout_calibration_results.one_state_errors == {q: 0 for q in qubits}
+    assert readout_calibration_results.repetitions == readout_repetitions
+    assert isinstance(readout_calibration_results.timestamp, float)
+
+
+def test_shuffled_circuits_with_readout_benchmarking_errors_with_noise():
+    """Test shuffled circuits with readout benchmarking with noise from sampler."""
+    qubits = cirq.LineQubit.range(6)
+
+    # Generate random input circuits
+    input_circuits = []
+    input_circuits += rqcg.generate_library_of_2q_circuits(
+        n_library_circuits=5, two_qubit_gate=cirq.ISWAP**0.5, q0=qubits[0], q1=qubits[1]
+    )
+    input_circuits += rqcg.generate_library_of_2q_circuits(
+        n_library_circuits=5, two_qubit_gate=cirq.CNOT**0.5, q0=qubits[1], q1=qubits[3]
+    )
+    input_circuits += rqcg.generate_library_of_2q_circuits(
+        n_library_circuits=5, two_qubit_gate=cirq.CNOT**0.5, q0=qubits[0], q1=qubits[4]
+    )
+    input_circuits += rqcg.generate_library_of_2q_circuits(
+        n_library_circuits=5, two_qubit_gate=cirq.ISWAP**0.5, q0=qubits[2], q1=qubits[4]
+    )
+    input_circuits += rqcg.generate_library_of_2q_circuits(
+        n_library_circuits=5, two_qubit_gate=cirq.ISWAP**0.5, q0=qubits[2], q1=qubits[5]
+    )
+    for circuit in input_circuits:
+        circuit.append(cirq.measure(*qubits, key="m"))
+
+    sampler = NoisySingleQubitReadoutSampler(p0=0.1, p1=0.2, seed=1234)
+    circuit_repetitions = 1
+    rng = np.random.default_rng()
+    readout_repetitions = 1000
+
+    measurements, readout_calibration_results = (
+        cirq.contrib.shuffle_circuits.run_shuffled_with_readout_benchmarking(
+            input_circuits,
+            sampler,
+            circuit_repetitions,
+            rng,
+            num_random_bitstrings=100,
+            readout_repetitions=readout_repetitions,
+        )
+    )
+
+    for measurement in measurements:
+        assert isinstance(measurement, ResultDict)
+
+    assert isinstance(readout_calibration_results, SingleQubitReadoutCalibrationResult)
+
+    for error in readout_calibration_results.zero_state_errors.values():
+        assert 0.08 < error < 0.12
+    for error in readout_calibration_results.one_state_errors.values():
+        assert 0.18 < error < 0.22
+    assert readout_calibration_results.repetitions == readout_repetitions
+    assert isinstance(readout_calibration_results.timestamp, float)
+
+
+def test_shuffled_circuits_with_readout_benchmarking_errors_with_noise_and_input_qubits():
+    """Test shuffled circuits with readout benchmarking with noise from sampler and input qubits."""
+    qubits = cirq.LineQubit.range(6)
+    readout_qubits = qubits[:4]
+
+    # Generate random input circuits
+    input_circuits = []
+    input_circuits += rqcg.generate_library_of_2q_circuits(
+        n_library_circuits=5, two_qubit_gate=cirq.ISWAP**0.5, q0=qubits[0], q1=qubits[1]
+    )
+    input_circuits += rqcg.generate_library_of_2q_circuits(
+        n_library_circuits=5, two_qubit_gate=cirq.CNOT**0.5, q0=qubits[1], q1=qubits[3]
+    )
+    input_circuits += rqcg.generate_library_of_2q_circuits(
+        n_library_circuits=5, two_qubit_gate=cirq.CNOT**0.5, q0=qubits[0], q1=qubits[4]
+    )
+    input_circuits += rqcg.generate_library_of_2q_circuits(
+        n_library_circuits=5, two_qubit_gate=cirq.ISWAP**0.5, q0=qubits[2], q1=qubits[4]
+    )
+    input_circuits += rqcg.generate_library_of_2q_circuits(
+        n_library_circuits=5, two_qubit_gate=cirq.ISWAP**0.5, q0=qubits[2], q1=qubits[5]
+    )
+    for circuit in input_circuits:
+        circuit.append(cirq.measure(*qubits, key="m"))
+
+    sampler = NoisySingleQubitReadoutSampler(p0=0.1, p1=0.3, seed=1234)
+    circuit_repetitions = 1
+    rng = np.random.default_rng()
+    readout_repetitions = 1000
+
+    measurements, readout_calibration_results = (
+        cirq.contrib.shuffle_circuits.run_shuffled_with_readout_benchmarking(
+            input_circuits,
+            sampler,
+            circuit_repetitions,
+            rng,
+            num_random_bitstrings=100,
+            readout_repetitions=readout_repetitions,
+            qubits=readout_qubits,
+        )
+    )
+
+    for measurement in measurements:
+        assert isinstance(measurement, ResultDict)
+
+    assert isinstance(readout_calibration_results, SingleQubitReadoutCalibrationResult)
+
+    for error in readout_calibration_results.zero_state_errors.values():
+        assert 0.08 < error < 0.12
+    for error in readout_calibration_results.one_state_errors.values():
+        assert 0.28 < error < 0.32
+    assert readout_calibration_results.repetitions == readout_repetitions
+    assert isinstance(readout_calibration_results.timestamp, float)
+
+
+def test_empty_input_circuits():
+    """Test that the input circuits are empty."""
+    with pytest.raises(ValueError, match="Input circuits must not be empty."):
+        cirq.contrib.shuffle_circuits.run_shuffled_with_readout_benchmarking(
+            [],
+            cirq.ZerosSampler(),
+            circuit_repetitions=10,
+            rng_or_seed=np.random.default_rng(456),
+            num_random_bitstrings=5,
+            readout_repetitions=100,
+        )
+
+
+def test_non_circuit_input():
+    """Test that the input circuits are not of type cirq.Circuit."""
+    q = cirq.LineQubit(0)
+    with pytest.raises(ValueError, match="Input circuits must be of type cirq.Circuit."):
+        cirq.contrib.shuffle_circuits.run_shuffled_with_readout_benchmarking(
+            [q],
+            cirq.ZerosSampler(),
+            circuit_repetitions=10,
+            rng_or_seed=np.random.default_rng(456),
+            num_random_bitstrings=5,
+            readout_repetitions=100,
+        )
+
+
+def test_no_measurements():
+    """Test that the input circuits don't have measurements."""
+    q = cirq.LineQubit(0)
+    circuit = cirq.Circuit(cirq.H(q))
+    with pytest.raises(ValueError, match="Input circuits must have measurements."):
+        cirq.contrib.shuffle_circuits.run_shuffled_with_readout_benchmarking(
+            [circuit],
+            cirq.ZerosSampler(),
+            circuit_repetitions=10,
+            rng_or_seed=np.random.default_rng(456),
+            num_random_bitstrings=5,
+            readout_repetitions=100,
+        )
+
+
+def test_zero_circuit_repetitions():
+    """Test that the circuit repetitions are zero."""
+    q = cirq.LineQubit(0)
+    circuit = cirq.Circuit(cirq.H(q), cirq.measure(q))
+    with pytest.raises(ValueError, match="Must provide non-zero circuit_repetitions."):
+        cirq.contrib.shuffle_circuits.run_shuffled_with_readout_benchmarking(
+            [circuit],
+            cirq.ZerosSampler(),
+            circuit_repetitions=0,
+            rng_or_seed=np.random.default_rng(456),
+            num_random_bitstrings=5,
+            readout_repetitions=100,
+        )
+
+
+def test_mismatch_circuit_repetitions():
+    """Test that the number of circuit repetitions don't match the number of input circuits."""
+    q = cirq.LineQubit(0)
+    circuit = cirq.Circuit(cirq.H(q), cirq.measure(q))
+    with pytest.raises(
+        ValueError,
+        match="Number of circuit_repetitions must match the number of" + " input circuits.",
+    ):
+        cirq.contrib.shuffle_circuits.run_shuffled_with_readout_benchmarking(
+            [circuit],
+            cirq.ZerosSampler(),
+            circuit_repetitions=[10, 20],
+            rng_or_seed=np.random.default_rng(456),
+            num_random_bitstrings=5,
+            readout_repetitions=100,
+        )
+
+
+def test_zero_num_random_bitstrings():
+    """Test that the number of random bitstrings is zero."""
+    q = cirq.LineQubit(0)
+    circuit = cirq.Circuit(cirq.H(q), cirq.measure(q))
+    with pytest.raises(ValueError, match="Must provide non-zero num_random_bitstrings."):
+        cirq.contrib.shuffle_circuits.run_shuffled_with_readout_benchmarking(
+            [circuit],
+            cirq.ZerosSampler(),
+            circuit_repetitions=10,
+            rng_or_seed=np.random.default_rng(456),
+            num_random_bitstrings=0,
+            readout_repetitions=100,
+        )
+
+
+def test_zero_readout_repetitions():
+    """Test that the readout repetitions is zero."""
+    q = cirq.LineQubit(0)
+    circuit = cirq.Circuit(cirq.H(q), cirq.measure(q))
+    with pytest.raises(
+        ValueError, match="Must provide non-zero readout_repetitions for readout" + " calibration."
+    ):
+        cirq.contrib.shuffle_circuits.run_shuffled_with_readout_benchmarking(
+            [circuit],
+            cirq.ZerosSampler(),
+            circuit_repetitions=10,
+            rng_or_seed=np.random.default_rng(456),
+            num_random_bitstrings=5,
+            readout_repetitions=0,
+        )
+
+
+def test_rng_type_mismatch():
+    """Test that the rng is not a numpy random generator or a seed."""
+    q = cirq.LineQubit(0)
+    circuit = cirq.Circuit(cirq.H(q), cirq.measure(q))
+    with pytest.raises(ValueError, match="Must provide a numpy random generator or a seed"):
+        cirq.contrib.shuffle_circuits.run_shuffled_with_readout_benchmarking(
+            [circuit],
+            cirq.ZerosSampler(),
+            circuit_repetitions=10,
+            rng_or_seed="not a random generator or seed",
+            num_random_bitstrings=5,
+            readout_repetitions=100,
+        )

cirq/ops/phased_iswap_gate.py

@@ -253,4 +253,4 @@ def givens(angle_rads: value.TParamVal) -> PhasedISwapPowGate:
         A phased iswap gate for the given rotation.
     """
     pi = sympy.pi if protocols.is_parameterized(angle_rads) else np.pi
-    return PhasedISwapPowGate() ** (2 * angle_rads / pi)
+    return cast(PhasedISwapPowGate, PhasedISwapPowGate() ** (2 * angle_rads / pi))

cirq/ops/swap_gates.py

@@ -25,7 +25,7 @@ raised to a power (i.e. SQRT_ISWAP_INV=cirq.ISWAP**-0.5). See the definition in
 EigenGate.
 """
 
-from typing import Optional, Tuple, TYPE_CHECKING, List
+from typing import cast, Optional, Tuple, TYPE_CHECKING, List
 
 import numpy as np
 import sympy
@@ -294,7 +294,7 @@ class ISwapPowGate(gate_features.InterchangeableQubitsGate, eigen_gate.EigenGate
 def riswap(rads: value.TParamVal) -> ISwapPowGate:
     """Returns gate with matrix exp(+i angle_rads (X⊗X + Y⊗Y) / 2)."""
     pi = sympy.pi if protocols.is_parameterized(rads) else np.pi
-    return ISwapPowGate() ** (2 * rads / pi)
+    return cast(ISwapPowGate, ISwapPowGate() ** (2 * rads / pi))
 
 
 SWAP = SwapPowGate()

{cirq_core-1.5.0.dev20250121234557.dist-info → cirq_core-1.5.0.dev20250122154326.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cirq-core
-Version: 1.5.0.dev20250121234557
+Version: 1.5.0.dev20250122154326
 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.dev20250121234557.dist-info → cirq_core-1.5.0.dev20250122154326.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=ejPswaxgWYxO1GQJKgtWovDWenzTtsykhNG3Xgr0ZY0,1206
-cirq/_version_test.py,sha256=Z6dlR_3LN0v8-XrsD0r2ZtWPFriRg52fzcqUo1Z8vGo,147
+cirq/_version.py,sha256=fTKdmX6uzT4CUgMsCpHpp_ORy5_o9MHO1oCKkHNewo4,1206
+cirq/_version_test.py,sha256=Uy41AdBF00p__C3v9oyYksMvAmP0UEJfFo2w2dzBbr0,147
 cirq/conftest.py,sha256=X7yLFL8GLhg2CjPw0hp5e_dGASfvHx1-QT03aUbhKJw,1168
 cirq/json_resolver_cache.py,sha256=p-vEOa-8GQ2cFIAdze-kd6C1un1uRvtujVPljVKaHBg,13557
 cirq/py.typed,sha256=VFSlmh_lNwnaXzwY-ZuW-C2Ws5PkuDoVgBdNCs0jXJE,63
@@ -42,7 +42,7 @@ cirq/contrib/acquaintance/devices.py,sha256=1hWW9_WF5TZQXFMu9-yXNTk3GfSETyjikNbo
 cirq/contrib/acquaintance/devices_test.py,sha256=icl_9SOp8PuZu7msfW5H7zP7_-zfTwTjyPPkajDu-w4,1088
 cirq/contrib/acquaintance/executor.py,sha256=cdj8U9Wiv8HAupU_hezEaMbeFSq1nMgqPfWrk-8XsrI,8609
 cirq/contrib/acquaintance/executor_test.py,sha256=ir-LKuQTfHm5WCcjmLriJ8qCT89YnltLpFx89Q3bF_I,7837
-cirq/contrib/acquaintance/gates.py,sha256=o6drWh7kEBga6SWt5_E_UaSsqxFcKJ-twJv-tXTXJoU,13493
+cirq/contrib/acquaintance/gates.py,sha256=YSsxvvyXQQOsEOr9lKdy0s00w6EAN7mWbu3Y0zjHEU8,13545
 cirq/contrib/acquaintance/gates_test.py,sha256=5FVX7zAtZSUqDPNsXk_Wm7LwDmHIApzgNhjAIX1IQBM,15010
 cirq/contrib/acquaintance/inspection_utils.py,sha256=-olAKpSZPm4Q9xhaQwAjT2ovUqZQd5zXAJ0ImkffOWk,2607
 cirq/contrib/acquaintance/inspection_utils_test.py,sha256=N5WyOkZaP7Vy0DRoiq6ZtQ1S99j5F7XyRPnyRLJqmtM,1250
@@ -146,6 +146,9 @@ cirq/contrib/routing/swap_network.py,sha256=w14mOyeXGmZOUvnJFP1Evk89rsqdplGyxqts
 cirq/contrib/routing/swap_network_test.py,sha256=XxbjIvOowvtOVwT2RN4e7YWlLebLm98Ty2TtOI1zXzU,4816
 cirq/contrib/routing/utils.py,sha256=P0_PnaGfy4Rm6CVl9FE7RpdZ0YzGtimcW1acduvp5rU,3761
 cirq/contrib/routing/utils_test.py,sha256=1oGEDAd70uQ2OrBwbaQd1DYoPcMSZsBQ2l5VLJBtXBM,2021
+cirq/contrib/shuffle_circuits/__init__.py,sha256=AL-V3OaZiaF596WTLlyxDPk0t1WMpTHpQrpRW_A9t48,832
+cirq/contrib/shuffle_circuits/shuffle_circuits_with_readout_benchmarking.py,sha256=ly4O2xhukp8xkBbk-a0ukSykd1G1yR-L91XNxdePBWU,9660
+cirq/contrib/shuffle_circuits/shuffle_circuits_with_readout_benchmarking_test.py,sha256=3SQO5bjrfs1ZRbDNTa_D90f8gx_HL6WCZs1d0IPdEMQ,11790
 cirq/contrib/svg/__init__.py,sha256=m7d-CNT2j74uNQdmM2xJ1a7HG6v0FZMt8eAwW4rPJpI,148
 cirq/contrib/svg/svg.py,sha256=d4_XgDNb8o1lDINVJA44XXunGmK71qTAlqw2sc_UnAo,9366
 cirq/contrib/svg/svg_test.py,sha256=gBHXeosNRHzrKWVo-JwhZLguHbksKQSiFwZ8fUXp-a8,2379
@@ -340,7 +343,7 @@ cirq/ops/pauli_sum_exponential.py,sha256=n3fhKWJVMudzGuOcdPHskVNx3fHE2MAblVdkzbD
 cirq/ops/pauli_sum_exponential_test.py,sha256=wVnJ3FSpEimHT8ERVkmljALrgSuuDYo6GRg91uJ7ztk,5370
 cirq/ops/permutation_gate.py,sha256=2h8n76N2M3nu5MA8JkRQgVLByq5cOEluKUN042ClSRs,4196
 cirq/ops/permutation_gate_test.py,sha256=SwXRgsZNLn5jnGhfcKPJ0J0CIssNzElbFaqylV2TXD8,3281
-cirq/ops/phased_iswap_gate.py,sha256=j55nFjdF0r63oaT7cGw0YtosavaV24qUjC9T-8Y4Ghw,8997
+cirq/ops/phased_iswap_gate.py,sha256=UVg7-aPKxKU984CaKfEVZveu_nC4xGfNlUGx17a43AY,9023
 cirq/ops/phased_iswap_gate_test.py,sha256=oH3RQ8tlSD0sU5Cf3M0uR92y3M1Xd7Yk3ayOoca9Neg,6708
 cirq/ops/phased_x_gate.py,sha256=qjlkdbj7SWMvgTJkTqEqsLe2XDgAGioA6ayanns-apg,9983
 cirq/ops/phased_x_gate_test.py,sha256=IpY-Z-MsqtYbyIEdxWu1NqgAJF2B7nddxPc2Hxafr4s,10202
@@ -361,7 +364,7 @@ cirq/ops/raw_types.py,sha256=pPbdomUXHrS8e_eb4sZTVoOrOcbI_yW4ekn97Eowr6U,41700
 cirq/ops/raw_types_test.py,sha256=AtcaAgu50IK_bsMXo4MkM_fjWQj9EQrkn9ved0_cJoo,33872
 cirq/ops/state_preparation_channel.py,sha256=PjVtoLbjBAy_XqnFAY40Am-NifeuCFVVLW6RJxph5sQ,4778
 cirq/ops/state_preparation_channel_test.py,sha256=yKUvLw_ft6cvIgRJcFQ779wZS-V6V-pzQq-rZRWdCmU,5922
-cirq/ops/swap_gates.py,sha256=cp-lKHBIXbFa2PmJnJQ8jD5W-vTWnpOZ5GdqM-5Gy8Q,11608
+cirq/ops/swap_gates.py,sha256=8DrW7Hn-m0dx0e57FUPfjggRF0zC_HGbr3Eomm54jfE,11634
 cirq/ops/swap_gates_test.py,sha256=_CihLf6rY4PNphCkH-S5mLJQYZW9ILjnnwUyQ9b0Blg,7452
 cirq/ops/tags.py,sha256=B3nEsZQTurGPJodH7aDoreNSatqawTxwsmw8fSKaIlc,2294
 cirq/ops/tags_test.py,sha256=4V9twOuCXd7Glvj9p3RW-tZ4-bfLtC1tmonR4soKNA0,1158
@@ -1199,8 +1202,8 @@ cirq/work/sampler.py,sha256=bE5tmVkcR6cZZMLETxDfHehdsYUMbx2RvBeIBetehI4,19187
 cirq/work/sampler_test.py,sha256=hL2UWx3dz2ukZVNxWftiKVvJcQoLplLZdQm-k1QcA40,13282
 cirq/work/zeros_sampler.py,sha256=x1C7cup66a43n-3tm8QjhiqJa07qcJW10FxNp9jJ59Q,2356
 cirq/work/zeros_sampler_test.py,sha256=JIkpBBFPJe5Ba4142vzogyWyboG1Q1ZAm0UVGgOoZn8,3279
-cirq_core-1.5.0.dev20250121234557.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.5.0.dev20250121234557.dist-info/METADATA,sha256=v1lMNyp74w-P0_Tc-0pdANnNLstVupaXK60ru-aZGKk,2105
-cirq_core-1.5.0.dev20250121234557.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-cirq_core-1.5.0.dev20250121234557.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.5.0.dev20250121234557.dist-info/RECORD,,
+cirq_core-1.5.0.dev20250122154326.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.5.0.dev20250122154326.dist-info/METADATA,sha256=3TuLZ_0x0juwPRhwEAg-BZySuiwhYxKN1TW1RWvAGNw,2105
+cirq_core-1.5.0.dev20250122154326.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+cirq_core-1.5.0.dev20250122154326.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.5.0.dev20250122154326.dist-info/RECORD,,