cirq-core 1.5.0.dev20250122072446__py3-none-any.whl → 1.5.0.dev20250122193029__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.dev20250122072446"
+__version__ = "1.5.0.dev20250122193029"

cirq/_version_test.py

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

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/devices/grid_qubit.py

@@ -38,7 +38,7 @@ class _BaseGridQid(ops.Qid):
 
     def __hash__(self) -> int:
         if self._hash is None:
-            self._hash = hash((self._row, self._col, self._dimension))
+            self._hash = ((self._dimension - 2) * 1_000_003 + self._col) * 1_000_003 + self._row
         return self._hash
 
     def __eq__(self, other) -> bool:

cirq/devices/line_qubit.py

@@ -34,7 +34,7 @@ class _BaseLineQid(ops.Qid):
 
     def __hash__(self) -> int:
         if self._hash is None:
-            self._hash = hash((self._x, self._dimension))
+            self._hash = (self._dimension - 2) * 1_000_003 + self._x
         return self._hash
 
     def __eq__(self, other) -> bool:

{cirq_core-1.5.0.dev20250122072446.dist-info → cirq_core-1.5.0.dev20250122193029.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cirq-core
-Version: 1.5.0.dev20250122072446
+Version: 1.5.0.dev20250122193029
 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.dev20250122072446.dist-info → cirq_core-1.5.0.dev20250122193029.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=470G-P6DA3djKNF_HCkuRFOH7f0FirM6QHAJHkyprS8,1206
-cirq/_version_test.py,sha256=4qRn82WFPwcgLmCjI2RUccL_VFZjv_vZgidg5VGjld8,147
+cirq/_version.py,sha256=VNvum6puwoivPgI01uE4_mzKs1mcRd64x8wXcVKjcHQ,1206
+cirq/_version_test.py,sha256=lddalsRUBod_GeiiguYus5hpJF2DAszETuWBNgVQBnM,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
@@ -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
@@ -154,11 +157,11 @@ cirq/devices/device.py,sha256=9rUZwpbbmqk8AUVH4N4KfJ59j5im7hVgDJAHtN9iH_0,5361
 cirq/devices/device_test.py,sha256=v3gT6jrGLLfYnZbTizIaIMkI3s5_xVM3OV9JQchvAxY,1124
 cirq/devices/grid_device_metadata.py,sha256=h4Xo_PaiZqQSVUgb1ctVtYYYE2tNik2KQhCgooilZrE,8629
 cirq/devices/grid_device_metadata_test.py,sha256=IeOqYOZcUGhB4ivuQW2g0Q9dt-zFA0H6Dav6yv6Lul0,8592
-cirq/devices/grid_qubit.py,sha256=CeR3ILjzN6H6UjOp2KBhxOoVSjX1TFaAUvbmsU-uGuQ,18793
+cirq/devices/grid_qubit.py,sha256=ynJYYih1QcZPLuNQYbooJWvSruhlep6qKFdiwdfVuSk,18819
 cirq/devices/grid_qubit_test.py,sha256=EzI8dWWnCfYbwruwsKlBzb41lQTA6AEOB2X16oQAz-0,14044
 cirq/devices/insertion_noise_model.py,sha256=-X07pSTp-lxQj6AQT_89gTHx_jKtI9GSMrD4dozCwTs,3614
 cirq/devices/insertion_noise_model_test.py,sha256=i9jB257VXO5wi5QdDO5G4tphx5RKMaouUsdsQT3kiBU,3992
-cirq/devices/line_qubit.py,sha256=q7rqUx8Pda3hlL8u6Zu2Ufe0eI5IN5m8Kz_oyBV_yTw,11825
+cirq/devices/line_qubit.py,sha256=SFN7VaxVhcEnH9VPtqPeQ3Aygp0xa8kZ0yntkI_DiVc,11836
 cirq/devices/line_qubit_test.py,sha256=_X1ofFHtuo0myFfsu1nlTJf9OLuLWRgZHHW2VG23ERY,9547
 cirq/devices/named_topologies.py,sha256=grFXvi0UDHZl1pRyHDWSqjub3xF_Yf7RLXfMAZbyoEA,15790
 cirq/devices/named_topologies_test.py,sha256=Nj_tlGmqPH7IVUzpUHPnAPlfUWhSGbZsIHdsLLjxIZs,4736
@@ -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.dev20250122072446.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.5.0.dev20250122072446.dist-info/METADATA,sha256=7qHaIYvtwyqsMcAD9TMOHh9mVdw8ixUszxYjpfA498Y,2105
-cirq_core-1.5.0.dev20250122072446.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-cirq_core-1.5.0.dev20250122072446.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.5.0.dev20250122072446.dist-info/RECORD,,
+cirq_core-1.5.0.dev20250122193029.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.5.0.dev20250122193029.dist-info/METADATA,sha256=mfgqH-SrwfF7mAeXQyquW9kWfj3G1J9OLSeTNo9FYjU,2105
+cirq_core-1.5.0.dev20250122193029.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+cirq_core-1.5.0.dev20250122193029.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.5.0.dev20250122193029.dist-info/RECORD,,