cirq-core 1.4.0.dev20231221183905__py3-none-any.whl → 1.4.0.dev20240111191543__py3-none-any.whl

cirq/_compat.py

@@ -61,12 +61,6 @@ def with_debug(value: bool) -> Iterator[None]:
         __cirq_debug__.reset(token)
 
 
-try:
-    from functools import cached_property  # pylint: disable=unused-import
-except ImportError:
-    from backports.cached_property import cached_property  # type: ignore[no-redef]
-
-
 # Sentinel used by wrapped_no_args below when method has not yet been cached.
 _NOT_FOUND = object()
 

cirq/_compat_test.py

@@ -38,7 +38,6 @@ import cirq.testing
 from cirq._compat import (
     block_overlapping_deprecation,
     cached_method,
-    cached_property,
     proper_repr,
     dataclass_repr,
     deprecated,
@@ -1011,23 +1010,6 @@ def test_block_overlapping_deprecation():
         f(5)
 
 
-def test_cached_property():
-    class Foo:
-        def __init__(self):
-            self.bar_calls = 0
-
-        @cached_property
-        def bar(self):
-            self.bar_calls += 1
-            return []
-
-    foo = Foo()
-    bar = foo.bar
-    bar2 = foo.bar
-    assert bar2 is bar
-    assert foo.bar_calls == 1
-
-
 class Bar:
     def __init__(self) -> None:
         self.foo_calls: Dict[int, int] = collections.Counter()

cirq/_version.py

@@ -1 +1 @@
-__version__ = "1.4.0.dev20231221183905"
+__version__ = "1.4.0.dev20240111191543"

cirq/circuits/circuit_operation.py

@@ -19,6 +19,7 @@ applied as part of a larger circuit, a CircuitOperation will execute all
 component operations in order, including any nested CircuitOperations.
 """
 import math
+from functools import cached_property
 from typing import (
     Callable,
     cast,
@@ -38,7 +39,7 @@ import numpy as np
 import sympy
 
 from cirq import circuits, ops, protocols, value, study
-from cirq._compat import cached_property, proper_repr
+from cirq._compat import proper_repr
 
 if TYPE_CHECKING:
     import cirq

cirq/circuits/frozen_circuit.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """An immutable version of the Circuit data structure."""
+from functools import cached_property
 from typing import (
     AbstractSet,
     FrozenSet,
@@ -90,7 +91,7 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
         """Returns a tuple of the Circuit's tags."""
         return self._tags
 
-    @_compat.cached_property
+    @cached_property
     def untagged(self) -> 'cirq.FrozenCircuit':
         """Returns the underlying FrozenCircuit without any tags."""
         return self._from_moments(self._moments) if self.tags else self
@@ -148,7 +149,7 @@ class FrozenCircuit(AbstractCircuit, protocols.SerializableByKey):
     def all_qubits(self) -> FrozenSet['cirq.Qid']:
         return super().all_qubits()
 
-    @_compat.cached_property
+    @cached_property
     def _all_operations(self) -> Tuple['cirq.Operation', ...]:
         return tuple(super().all_operations())
 

cirq/devices/superconducting_qubits_noise_properties.py

@@ -17,9 +17,10 @@
 
 import abc
 from dataclasses import dataclass, field
+from functools import cached_property
 from typing import Dict, TYPE_CHECKING, List, Set, Type
 
-from cirq import _compat, ops, devices
+from cirq import ops, devices
 from cirq.devices import noise_utils
 
 if TYPE_CHECKING:
@@ -131,7 +132,7 @@ class SuperconductingQubitsNoiseProperties(devices.NoiseProperties, abc.ABC):
             p_error -= noise_utils.decoherence_pauli_error(self.t1_ns[q], self.tphi_ns[q], time_ns)
         return p_error
 
-    @_compat.cached_property
+    @cached_property
     def _depolarizing_error(self) -> Dict[noise_utils.OpIdentifier, float]:
         """Returns the portion of Pauli error from depolarization."""
         depol_errors = {}

cirq/experiments/qubit_characterizations.py

@@ -14,6 +14,7 @@
 
 import dataclasses
 import itertools
+import functools
 
 from typing import (
     Any,
@@ -58,11 +59,11 @@ class Cliffords:
         s1_y
     """
 
-    c1_in_xy: List[List[ops.Gate]]
-    c1_in_xz: List[List[ops.Gate]]
-    s1: List[List[ops.Gate]]
-    s1_x: List[List[ops.Gate]]
-    s1_y: List[List[ops.Gate]]
+    c1_in_xy: List[List[ops.SingleQubitCliffordGate]]
+    c1_in_xz: List[List[ops.SingleQubitCliffordGate]]
+    s1: List[List[ops.SingleQubitCliffordGate]]
+    s1_x: List[List[ops.SingleQubitCliffordGate]]
+    s1_y: List[List[ops.SingleQubitCliffordGate]]
 
 
 class RandomizedBenchMarkResult:
@@ -256,10 +257,9 @@ def single_qubit_randomized_benchmarking(
         A RandomizedBenchMarkResult object that stores and plots the result.
     """
 
-    qubits = cast(Iterator['cirq.Qid'], (qubit,))
     result = parallel_single_qubit_randomized_benchmarking(
         sampler,
-        qubits,
+        (qubit,),
         use_xy_basis,
         num_clifford_range=num_clifford_range,
         num_circuits=num_circuits,
@@ -270,7 +270,7 @@ def single_qubit_randomized_benchmarking(
 
 def parallel_single_qubit_randomized_benchmarking(
     sampler: 'cirq.Sampler',
-    qubits: Iterator['cirq.Qid'],
+    qubits: Sequence['cirq.Qid'],
     use_xy_basis: bool = True,
     *,
     num_clifford_range: Sequence[int] = tuple(
@@ -299,17 +299,14 @@ def parallel_single_qubit_randomized_benchmarking(
         A dictionary from qubits to RandomizedBenchMarkResult objects.
     """
 
-    cliffords = _single_qubit_cliffords()
-    c1 = cliffords.c1_in_xy if use_xy_basis else cliffords.c1_in_xz
-    clifford_mats = np.array([_gate_seq_to_mats(gates) for gates in c1])
+    clifford_group = _single_qubit_cliffords()
+    c1 = clifford_group.c1_in_xy if use_xy_basis else clifford_group.c1_in_xz
 
     # create circuits
     circuits_all: List['cirq.AbstractCircuit'] = []
     for num_cliffords in num_clifford_range:
         for _ in range(num_circuits):
-            circuits_all.append(
-                _create_parallel_rb_circuit(qubits, num_cliffords, c1, clifford_mats)
-            )
+            circuits_all.append(_create_parallel_rb_circuit(qubits, num_cliffords, c1))
 
     # run circuits
     results = sampler.run_batch(circuits_all, repetitions=repetitions)
@@ -562,13 +559,16 @@ def two_qubit_state_tomography(
 
 
 def _create_parallel_rb_circuit(
-    qubits: Iterator['cirq.Qid'], num_cliffords: int, c1: list, clifford_mats: np.ndarray
+    qubits: Sequence['cirq.Qid'], num_cliffords: int, c1: list
 ) -> 'cirq.Circuit':
-    circuits_to_zip = [
-        _random_single_q_clifford(qubit, num_cliffords, c1, clifford_mats) for qubit in qubits
-    ]
-    circuit = circuits.Circuit.zip(*circuits_to_zip)
-    return circuits.Circuit.from_moments(*circuit, ops.measure_each(*qubits))
+    sequences_to_zip = [_random_single_q_clifford(qubit, num_cliffords, c1) for qubit in qubits]
+    # Ensure each sequence has the same number of moments.
+    num_moments = max(len(sequence) for sequence in sequences_to_zip)
+    for q, sequence in zip(qubits, sequences_to_zip):
+        if (n := len(sequence)) < num_moments:
+            sequence.extend([ops.SingleQubitCliffordGate.I(q)] * (num_moments - n))
+    moments = zip(*sequences_to_zip)
+    return circuits.Circuit.from_moments(*moments, ops.measure_each(*qubits))
 
 
 def _indices_after_basis_rot(i: int, j: int) -> Tuple[int, Sequence[int], Sequence[int]]:
@@ -612,18 +612,13 @@ def _two_qubit_clifford_matrices(
 
 
 def _random_single_q_clifford(
-    qubit: 'cirq.Qid',
-    num_cfds: int,
-    cfds: Sequence[Sequence['cirq.Gate']],
-    cfd_matrices: np.ndarray,
-) -> 'cirq.Circuit':
+    qubit: 'cirq.Qid', num_cfds: int, cfds: Sequence[Sequence['cirq.Gate']]
+) -> List['cirq.Operation']:
     clifford_group_size = 24
+    operations = [[gate(qubit) for gate in gates] for gates in cfds]
     gate_ids = list(np.random.choice(clifford_group_size, num_cfds))
-    gate_sequence = [gate for gate_id in gate_ids for gate in cfds[gate_id]]
-    idx = _find_inv_matrix(_gate_seq_to_mats(gate_sequence), cfd_matrices)
-    gate_sequence.extend(cfds[idx])
-    circuit = circuits.Circuit(gate(qubit) for gate in gate_sequence)
-    return circuit
+    adjoint = _reduce_gate_seq([gate for gate_id in gate_ids for gate in cfds[gate_id]]) ** -1
+    return [op for gate_id in gate_ids for op in operations[gate_id]] + [adjoint(qubit)]
 
 
 def _random_two_q_clifford(
@@ -681,11 +676,13 @@ def _matrix_bar_plot(
         ax.set_title(title)
 
 
-def _gate_seq_to_mats(gate_seq: Sequence['cirq.Gate']) -> np.ndarray:
-    mat_rep = protocols.unitary(gate_seq[0])
+def _reduce_gate_seq(
+    gate_seq: Sequence[ops.SingleQubitCliffordGate],
+) -> ops.SingleQubitCliffordGate:
+    cur = gate_seq[0]
     for gate in gate_seq[1:]:
-        mat_rep = np.dot(protocols.unitary(gate), mat_rep)
-    return mat_rep
+        cur = cur.merged_with(gate)
+    return cur
 
 
 def _two_qubit_clifford(
@@ -793,11 +790,16 @@ def _single_qubit_gates(
         yield gate(qubit)
 
 
+@functools.cache
 def _single_qubit_cliffords() -> Cliffords:
-    X, Y, Z = ops.X, ops.Y, ops.Z
+    X, Y, Z = (
+        ops.SingleQubitCliffordGate.X,
+        ops.SingleQubitCliffordGate.Y,
+        ops.SingleQubitCliffordGate.Z,
+    )
 
-    c1_in_xy: List[List['cirq.Gate']] = []
-    c1_in_xz: List[List['cirq.Gate']] = []
+    c1_in_xy: List[List[ops.SingleQubitCliffordGate]] = []
+    c1_in_xz: List[List[ops.SingleQubitCliffordGate]] = []
 
     for phi_0, phi_1 in itertools.product([1.0, 0.5, -0.5], [0.0, 0.5, -0.5]):
         c1_in_xy.append([X**phi_0, Y**phi_1])
@@ -820,8 +822,20 @@ def _single_qubit_cliffords() -> Cliffords:
     for z0, x, z1 in phi_xz:
         c1_in_xz.append([Z**z0, X**x, Z**z1])
 
-    s1: List[List['cirq.Gate']] = [[X**0.0], [Y**0.5, X**0.5], [X**-0.5, Y**-0.5]]
-    s1_x: List[List['cirq.Gate']] = [[X**0.5], [X**0.5, Y**0.5, X**0.5], [Y**-0.5]]
-    s1_y: List[List['cirq.Gate']] = [[Y**0.5], [X**-0.5, Y**-0.5, X**0.5], [Y, X**0.5]]
+    s1: List[List[ops.SingleQubitCliffordGate]] = [
+        [X**0.0],
+        [Y**0.5, X**0.5],
+        [X**-0.5, Y**-0.5],
+    ]
+    s1_x: List[List[ops.SingleQubitCliffordGate]] = [
+        [X**0.5],
+        [X**0.5, Y**0.5, X**0.5],
+        [Y**-0.5],
+    ]
+    s1_y: List[List[ops.SingleQubitCliffordGate]] = [
+        [Y**0.5],
+        [X**-0.5, Y**-0.5, X**0.5],
+        [Y, X**0.5],
+    ]
 
     return Cliffords(c1_in_xy, c1_in_xz, s1, s1_x, s1_y)

cirq/experiments/qubit_characterizations_test.py

@@ -75,9 +75,32 @@ def test_single_qubit_cliffords():
 
     # Check that XZ decomposition has at most one X gate per clifford.
     for gates in cliffords.c1_in_xz:
-        num_x = len([gate for gate in gates if isinstance(gate, cirq.XPowGate)])
-        num_z = len([gate for gate in gates if isinstance(gate, cirq.ZPowGate)])
-        assert num_x + num_z == len(gates)
+        num_i = len([gate for gate in gates if gate == cirq.ops.SingleQubitCliffordGate.I])
+        num_x = len(
+            [
+                gate
+                for gate in gates
+                if gate
+                in (
+                    cirq.ops.SingleQubitCliffordGate.X,
+                    cirq.ops.SingleQubitCliffordGate.X_sqrt,
+                    cirq.ops.SingleQubitCliffordGate.X_nsqrt,
+                )
+            ]
+        )
+        num_z = len(
+            [
+                gate
+                for gate in gates
+                if gate
+                in (
+                    cirq.ops.SingleQubitCliffordGate.Z,
+                    cirq.ops.SingleQubitCliffordGate.Z_sqrt,
+                    cirq.ops.SingleQubitCliffordGate.Z_nsqrt,
+                )
+            ]
+        )
+        assert num_x + num_z + num_i == len(gates)
         assert num_x <= 1
 
 

cirq/ops/clifford_gate.py

@@ -14,11 +14,13 @@
 
 from typing import Any, Dict, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
 
-
+import functools
+from dataclasses import dataclass
 import numpy as np
 
 from cirq import protocols, value, linalg, qis
 from cirq._import import LazyLoader
+from cirq._compat import cached_method
 from cirq.ops import common_gates, named_qubit, raw_types, pauli_gates, phased_x_z_gate
 from cirq.ops.pauli_gates import Pauli
 from cirq.type_workarounds import NotImplementedType
@@ -356,6 +358,8 @@ class CommonCliffordGates(metaclass=CommonCliffordGateMetaClass):
 class CliffordGate(raw_types.Gate, CommonCliffordGates):
     """Clifford rotation for N-qubit."""
 
+    _clifford_tableau: qis.CliffordTableau
+
     def __init__(self, *, _clifford_tableau: qis.CliffordTableau) -> None:
         # We use the Clifford tableau to represent a Clifford gate.
         # It is crucial to note that the meaning of tableau here is different
@@ -376,7 +380,7 @@ class CliffordGate(raw_types.Gate, CommonCliffordGates):
         # more precisely the conjugate transformation of ZI by this gate, becomes -ZI.
         # (Note the real clifford tableau has to satify the Symplectic property.
         # here is just for illustration)
-        self._clifford_tableau = _clifford_tableau.copy()
+        object.__setattr__(self, '_clifford_tableau', _clifford_tableau.copy())
 
     @property
     def clifford_tableau(self):
@@ -399,6 +403,12 @@ class CliffordGate(raw_types.Gate, CommonCliffordGates):
     def __pow__(self, exponent) -> 'CliffordGate':
         if exponent == -1:
             return CliffordGate.from_clifford_tableau(self.clifford_tableau.inverse())
+        if exponent == 0:
+            return CliffordGate.from_clifford_tableau(
+                qis.CliffordTableau(num_qubits=self._num_qubits_())
+            )
+        if exponent == 1:
+            return self
         if exponent > 0 and int(exponent) == exponent:
             base_tableau = self.clifford_tableau.copy()
             for _ in range(int(exponent) - 1):
@@ -457,6 +467,7 @@ class CliffordGate(raw_types.Gate, CommonCliffordGates):
         return NotImplemented
 
 
+@dataclass(frozen=True, init=False, eq=False, repr=False)
 @value.value_equality(manual_cls=True)
 class SingleQubitCliffordGate(CliffordGate):
     """Any single qubit Clifford rotation."""
@@ -468,6 +479,7 @@ class SingleQubitCliffordGate(CliffordGate):
         return 1
 
     @staticmethod
+    @functools.cache
     def from_clifford_tableau(tableau: qis.CliffordTableau) -> 'SingleQubitCliffordGate':
         if not isinstance(tableau, qis.CliffordTableau):
             raise ValueError('Input argument has to be a CliffordTableau instance.')
@@ -679,6 +691,10 @@ class SingleQubitCliffordGate(CliffordGate):
             * {middle point of xyz in 4 Quadrant} * 120 is [[0, 1], [1, 1]]
             * {middle point of xyz in 4 Quadrant} * 240 is [[1, 1], [1, 0]]
         """
+        return self._to_phased_xz_gate
+
+    @functools.cached_property
+    def _to_phased_xz_gate(self) -> phased_x_z_gate.PhasedXZGate:
         x_to_flip, z_to_flip = self.clifford_tableau.rs
         flip_index = int(z_to_flip) * 2 + x_to_flip
         a, x, z = 0.0, 0.0, 0.0
@@ -716,7 +732,7 @@ class SingleQubitCliffordGate(CliffordGate):
             z = -0.5 if x_to_flip else 0.5
         return phased_x_z_gate.PhasedXZGate(x_exponent=x, z_exponent=z, axis_phase_exponent=a)
 
-    def __pow__(self, exponent) -> 'SingleQubitCliffordGate':
+    def __pow__(self, exponent: Union[float, int]) -> 'SingleQubitCliffordGate':
         # First to check if we can get the sqrt and negative sqrt Clifford.
         if self._get_sqrt_map().get(exponent, None):
             pow_gate = self._get_sqrt_map()[exponent].get(self, None)
@@ -761,6 +777,7 @@ class SingleQubitCliffordGate(CliffordGate):
         to, flip = self.pauli_tuple(pauli)
         return to == pauli and not flip
 
+    @cached_method
     def merged_with(self, second: 'SingleQubitCliffordGate') -> 'SingleQubitCliffordGate':
         """Returns a SingleQubitCliffordGate such that the circuits
             --output-- and --self--second--
@@ -773,6 +790,10 @@ class SingleQubitCliffordGate(CliffordGate):
         return True
 
     def _unitary_(self) -> np.ndarray:
+        return self._unitary
+
+    @functools.cached_property
+    def _unitary(self) -> np.ndarray:
         mat = np.eye(2)
         qubit = named_qubit.NamedQubit('arbitrary')
         for op in protocols.decompose_once_with_qubits(self, (qubit,)):
@@ -787,6 +808,10 @@ class SingleQubitCliffordGate(CliffordGate):
             clifford gate if applied in order. This decomposition agrees with
             cirq.unitary(self), including global phase.
         """
+        return self._decompose_gate
+
+    @functools.cached_property
+    def _decompose_gate(self) -> Sequence['cirq.Gate']:
         if self == SingleQubitCliffordGate.H:
             return [common_gates.H]
         rotations = self.decompose_rotation()
@@ -802,6 +827,10 @@ class SingleQubitCliffordGate(CliffordGate):
         Note that the combined unitary effect of these rotations may
         differ from cirq.unitary(self) by a global phase.
         """
+        return self._decompose_rotation
+
+    @functools.cached_property
+    def _decompose_rotation(self) -> Sequence[Tuple[Pauli, int]]:
         x_rot = self.pauli_tuple(pauli_gates.X)
         y_rot = self.pauli_tuple(pauli_gates.Y)
         z_rot = self.pauli_tuple(pauli_gates.Z)
@@ -895,6 +924,10 @@ class SingleQubitCliffordGate(CliffordGate):
         )
 
     def _value_equality_values_(self):
+        return self._value_equality_values
+
+    @functools.cached_property
+    def _value_equality_values(self):
         return self._clifford_tableau.matrix().tobytes() + self._clifford_tableau.rs.tobytes()
 
     def _value_equality_values_cls_(self):

cirq/ops/control_values.py

@@ -12,10 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import abc
+from functools import cached_property
 from typing import Collection, Tuple, TYPE_CHECKING, Any, Dict, Iterator, Optional, Sequence, Union
 import itertools
 
-from cirq import protocols, value, _compat
+from cirq import protocols, value
 
 if TYPE_CHECKING:
     import cirq
@@ -144,7 +145,7 @@ class ProductOfSums(AbstractControlValues):
             (cv,) if isinstance(cv, int) else tuple(sorted(set(cv))) for cv in data
         )
 
-    @_compat.cached_property
+    @cached_property
     def is_trivial(self) -> bool:
         return self._qubit_sums == ((1,),) * self._num_qubits_()
 
@@ -252,7 +253,7 @@ class SumOfProducts(AbstractControlValues):
         if not all(len(p) == num_qubits for p in self._conjunctions):
             raise ValueError(f'Each term of {self._conjunctions} should be of length {num_qubits}.')
 
-    @_compat.cached_property
+    @cached_property
     def is_trivial(self) -> bool:
         return self._conjunctions == ((1,) * self._num_qubits_(),)
 

cirq/qis/clifford_tableau.py

@@ -17,7 +17,7 @@ from typing import Any, Dict, List, Optional, Sequence, TYPE_CHECKING
 import numpy as np
 
 from cirq import protocols
-from cirq._compat import proper_repr
+from cirq._compat import proper_repr, cached_method
 from cirq.qis import quantum_state_representation
 from cirq.value import big_endian_int_to_digits, linear_dict, random_state
 
@@ -652,3 +652,7 @@ class CliffordTableau(StabilizerState):
         self, axes: Sequence[int], seed: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None
     ) -> List[int]:
         return [self._measure(axis, random_state.parse_random_state(seed)) for axis in axes]
+
+    @cached_method
+    def __hash__(self) -> int:
+        return hash(self.matrix().tobytes() + self.rs.tobytes())

cirq/sim/clifford/clifford_simulator_test.py

@@ -324,9 +324,11 @@ def test_clifford_circuit_SHSYSHS():
     clifford_simulator = cirq.CliffordSimulator()
     state_vector_simulator = cirq.Simulator()
 
+    # workaround until #6402 is resolved.
+    final_state_vector = state_vector_simulator.simulate(circuit).final_state_vector
+    final_state_vector /= np.linalg.norm(final_state_vector)
     np.testing.assert_almost_equal(
-        clifford_simulator.simulate(circuit).final_state.state_vector(),
-        state_vector_simulator.simulate(circuit).final_state_vector,
+        clifford_simulator.simulate(circuit).final_state.state_vector(), final_state_vector
     )
 
 

cirq/sim/state_vector_simulator.py

@@ -14,6 +14,7 @@
 """Abstract classes for simulations which keep track of state vector."""
 
 import abc
+from functools import cached_property
 from typing import Any, Dict, Iterator, Sequence, Type, TYPE_CHECKING, Generic, TypeVar
 
 import numpy as np
@@ -121,7 +122,7 @@ class StateVectorTrialResult(
             qubit_map=final_simulator_state.qubit_map,
         )
 
-    @_compat.cached_property
+    @cached_property
     def final_state_vector(self) -> np.ndarray:
         return self._get_merged_sim_state().target_tensor.reshape(-1)
 

cirq/testing/circuit_compare.py

@@ -226,7 +226,7 @@ def assert_circuits_have_same_unitary_given_final_permutation(
     expected: circuits.AbstractCircuit,
     qubit_map: Dict[ops.Qid, ops.Qid],
 ) -> None:
-    """Asserts two circuits have the same unitary up to a final permuation of qubits.
+    """Asserts two circuits have the same unitary up to a final permutation of qubits.
 
     Args:
         actual: A circuit computed by some code under test.

cirq/transformers/qubit_management_transformers.py

@@ -71,7 +71,7 @@ def map_clean_and_borrowable_qubits(
     inserting all mapped operations in a resulting circuit using EARLIEST strategy. The reason
     is that preserving moment structure forces additional constraints on the qubit allocation
     strategy (i.e. if two operations `op1` and `op2` are in the same moment, then we cannot
-    reuse ancilla across `op1` and `op2`). We leave it upto the user to force such constraints
+    reuse ancilla across `op1` and `op2`). We leave it up to the user to force such constraints
     using the qubit manager instead of making it part of the transformer.
         3. However, for borrowable system qubits managed by the transformer, we do not reuse qubits
     within the same moment.

{cirq_core-1.4.0.dev20231221183905.dist-info → cirq_core-1.4.0.dev20240111191543.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cirq-core
-Version: 1.4.0.dev20231221183905
+Version: 1.4.0.dev20240111191543
 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.4.0.dev20231221183905.dist-info → cirq_core-1.4.0.dev20240111191543.dist-info}/RECORD

@@ -1,10 +1,10 @@
 cirq/__init__.py,sha256=GlOnPWDvat-Y203LsbXhkC0UnGm9HHiNx2ywz7Bkc3o,15708
-cirq/_compat.py,sha256=wXi3WIiKjfJp5mCB2Kha3LyfJzxCetEPXq5-wg_faq0,29536
-cirq/_compat_test.py,sha256=iQJYqIP1uyRe8mNUwi2VKccyUaJDFYH7b3Fg6cqQLQw,35053
+cirq/_compat.py,sha256=ogNbww9v943-ZNZcOx-ad8kGO8-jLBuS8865gQ3QA-c,29350
+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=_fcYtE8htVvnq0jJ7T652Geu1s2hsXFqB3QxzXgTFNo,40
+cirq/_version.py,sha256=JxwaDhKW-S1gML1FzVDlWvWtSpW28zxxzpe48wAK2Og,40
 cirq/_version_test.py,sha256=yYS6xm5-nuBRQJa9R3n41WdvFtVyY7Lb5Q8bea3VgBI,133
 cirq/conftest.py,sha256=X7yLFL8GLhg2CjPw0hp5e_dGASfvHx1-QT03aUbhKJw,1168
 cirq/json_resolver_cache.py,sha256=S0HaPOCUIck-vNSQlS6KxnQtle6w-2dGuSxkUbJQY9Y,13168
@@ -18,10 +18,10 @@ cirq/circuits/_box_drawing_character_data_test.py,sha256=XO94z0piwZRHaNZHTf-5tKH
 cirq/circuits/_bucket_priority_queue.py,sha256=hxFuii2fKD8G6EKT_aVLEsA7FmSfqFXPwIbA0KsoSC4,6745
 cirq/circuits/_bucket_priority_queue_test.py,sha256=t6u_hG7K2e2WKWrgCsKxNRtp4ghKwiCrp0_WSY0W25k,5288
 cirq/circuits/circuit.py,sha256=KP6tYjQ4pb1kz_jW3cfCgtnVvN_MRl0jHeNsOq0CA70,114383
-cirq/circuits/circuit_operation.py,sha256=qdJshRvGRFKwin7Ec_RndIb2Fm3sh7-N9SarEZo6AXM,34354
+cirq/circuits/circuit_operation.py,sha256=D4u8jDD4fGOca1xnZPN1obuKTIouXENUfnxOF2JrwgU,34375
 cirq/circuits/circuit_operation_test.py,sha256=_0iQJ3h_dnQcQmbGRZbc-NqdglJTXantbj72ggqLKNE,44724
 cirq/circuits/circuit_test.py,sha256=EYIApq2DpZe7HckvySR3JlJdUIfJTSbKHm0lgENP2HA,160111
-cirq/circuits/frozen_circuit.py,sha256=GnFZ6kT1hFpxK6sOzqy1hq2SnKbG7OSu0q3bfGwi7b8,9240
+cirq/circuits/frozen_circuit.py,sha256=_0SkmIiQ4UjIug-k_iO00ulDFoFnxmAHvXX2I2HHN8k,9262
 cirq/circuits/frozen_circuit_test.py,sha256=rHyii8hLhOQ6jdA8dC1OcYPGnyeBC4uY5Q53XspkkCk,4133
 cirq/circuits/insert_strategy.py,sha256=L0OLXuo24TtBfdJGOAG2PsVDMrbvQl4iN5lUk6IPuyo,2851
 cirq/circuits/insert_strategy_test.py,sha256=dgz13_ssa_GWqzzx5W4G4sJJw4SUHC3-g3K0_Z4TRiA,686
@@ -169,7 +169,7 @@ cirq/devices/noise_properties.py,sha256=DyaaNl2VlDFX38x4J7Zu5EMJBIj8bCDUYwSjbkBf
 cirq/devices/noise_properties_test.py,sha256=JTJW8_-rI4awd9jTbCgI5l8MpeDsNlXnO53s8QgJw2A,2341
 cirq/devices/noise_utils.py,sha256=q7LR7mT__oHYoCmmPln1PnsVa94p0i9ONjqKlcka5_o,6722
 cirq/devices/noise_utils_test.py,sha256=ha_P9Z_eycH97QIQ27WmwnvGM1CBUVoaJO8oy-VnIWI,4841
-cirq/devices/superconducting_qubits_noise_properties.py,sha256=Fg4S23uBPIBZWKdDyJ7AAZ_ajT1Vd6n1WxJ-k-0VUlM,8125
+cirq/devices/superconducting_qubits_noise_properties.py,sha256=1SMeHgfydqYL5iwD9s38yJnOtfXWdJLw069B2DDSn9s,8146
 cirq/devices/superconducting_qubits_noise_properties_test.py,sha256=u9B1_4uwRdNzeyW9f-CSbYfsNpxiJ0RtmttvaaNzXkk,12207
 cirq/devices/thermal_noise_model.py,sha256=qdWrN7Kqw5dq1rwVUBLY1DDw1nCPADSaxoLtGHC-zW4,11608
 cirq/devices/thermal_noise_model_test.py,sha256=ox9b0BoHH6d73CjWWI1fIAGd_o3r-4qy8v2ggUwc-pw,12246
@@ -184,8 +184,8 @@ cirq/experiments/n_qubit_tomography.py,sha256=9M_kf2-1hvFxfZOWND7ACwHYgD9SJU5nYF
 cirq/experiments/n_qubit_tomography_test.py,sha256=wHfV2OpGYSDXfoyEh-B5dc1Dv8sxKNFbUoHyjIWZoFk,4362
 cirq/experiments/purity_estimation.py,sha256=6D1UwFlQRzHeajXMTyTUfBYAc0jJQ8Cfz4lteFKeUaM,2467
 cirq/experiments/purity_estimation_test.py,sha256=xlBGp0NOBYR0IhTy3bckHPgi81FkGSGxKqk9hwXG-I8,923
-cirq/experiments/qubit_characterizations.py,sha256=EqoZd3BRnjpFDMGz_NffZnAmuunuSJVybnum6QTYOg0,31359
-cirq/experiments/qubit_characterizations_test.py,sha256=l5O--F9LJGn7lZX5LA535zr0O1qmYgasUTZ1JbBQwLI,8382
+cirq/experiments/qubit_characterizations.py,sha256=cyso_zmuU7xT9VBiI_Un5P8c-V8zOEETLuApLJ-QYWc,31792
+cirq/experiments/qubit_characterizations_test.py,sha256=l4wtsezdM6pxB4W4Xq0f7RTCREy-W25jUsE6gssztoY,9032
 cirq/experiments/random_quantum_circuit_generation.py,sha256=R_w7z35plUHEYBY0-F80bPcWJSSSjNQDaP2GbxVBEZg,28143
 cirq/experiments/random_quantum_circuit_generation_test.py,sha256=1rvgN8-Ajedn_70FyYKVzjvzR6NVpHj6KQgo6tra-Jc,15995
 cirq/experiments/readout_confusion_matrix.py,sha256=gsRjGJTDcxRPtY7G63t-nYoJ1BcByC1jl02zHh2B8fQ,17278
@@ -267,7 +267,7 @@ cirq/ops/boolean_hamiltonian.py,sha256=hjmzBvWiZnb18JfdhId-dVxt2VmbyAbqMSFAPWV7s
 cirq/ops/boolean_hamiltonian_test.py,sha256=1ey5yfYZPKZDsfM3jpCPAOpbPs_y8i4K_WvDK2d5_4Y,8518
 cirq/ops/classically_controlled_operation.py,sha256=bMqKutwzqbvN2r7mOVOI12HTPDGSJLkhQQgfAcTtbDU,9166
 cirq/ops/classically_controlled_operation_test.py,sha256=MNU0Adff4kTosqsrQ3PUT3ARcZee_PkchT6u0xDl8Qg,48039
-cirq/ops/clifford_gate.py,sha256=B1guFN4YvUzqjBPVZH_stYWdi9MicJYjuoByB6rrK_Q,38139
+cirq/ops/clifford_gate.py,sha256=xTAGYR24u__ctlY2fNsWYTQcJof4euRYMGN8cdERV2E,39235
 cirq/ops/clifford_gate_test.py,sha256=NF_if1X8LCMA9hy0vBO7lxvVPdumlvMMnI2XRQ-RLpk,37472
 cirq/ops/common_channels.py,sha256=mVGEta2wnaWOhRCXQO6gUj9Zll3rtXqpY-PRYcJ8m1U,38282
 cirq/ops/common_channels_test.py,sha256=EL_PxbqD3KPC8ioihiukhmW8bUdclqqigKoFyUQpmIM,29690
@@ -275,7 +275,7 @@ cirq/ops/common_gate_families.py,sha256=e5M8wlDYtdrpWBrhdns6iizIvSqzfxDyIsBdxt8h
 cirq/ops/common_gate_families_test.py,sha256=Oo3C7BPO3gt3ePuqwsI_lx_lY38et8Ps4AuVydX2Aww,5275
 cirq/ops/common_gates.py,sha256=YMcadPVRhrvkwYwm6-_TNYM9sz9TY7KSi0g7FvBTeCk,58075
 cirq/ops/common_gates_test.py,sha256=_5Kifb5k091qyzEVpryyFJV1e6pJ_fjDCag1PmPAQ2g,46227
-cirq/ops/control_values.py,sha256=O_ssaNxd50b4cS0hVhnRY0aEMr8J86TIh6iPohPKf_g,13397
+cirq/ops/control_values.py,sha256=nNDN6pgz_aWkUfrpOZ9zHHD42AGFaplWhVQj9rmJwbQ,13410
 cirq/ops/control_values_test.py,sha256=iDtdQjL39u80MaR16XLp00LRZqWgJqC54cIeADWf0IY,12906
 cirq/ops/controlled_gate.py,sha256=uVTZk6pA1ZpEwbVggLeXyAFq18_QJ38hWYhk9GbvQnc,14253
 cirq/ops/controlled_gate_test.py,sha256=5sUUV0xng-GpQOTSiyQqB_LBaTeXXqHehqQuvvw7Cf4,23113
@@ -869,7 +869,7 @@ cirq/protocols/json_test_data/sympy.pi.repr,sha256=ZQS0my0esr3dWTZ3mWlqgR63uorPC
 cirq/qis/__init__.py,sha256=f5U3udFQirbLPKcHsVO6ViD3uSwe81Bei1wQdSbq2HE,1583
 cirq/qis/channels.py,sha256=AxKgLUbWLrb1pz9xLtSpYm_stjN-IWOwLFYC9YZSons,12798
 cirq/qis/channels_test.py,sha256=iqkSyfvx_c2ZpJKAVEsFyZRmKpzNrJsyFjHbaJUMqcQ,14454
-cirq/qis/clifford_tableau.py,sha256=yA63laynA1LVDmO7Gy_JFOsb7_gfriaOj6ggrjGRVGo,25174
+cirq/qis/clifford_tableau.py,sha256=Ik1ogTElaB3nJCPCGj1yqxMdpu404AbZjkVOVYZOins,25305
 cirq/qis/clifford_tableau_test.py,sha256=Z-5YSysJw2H3AfgZxhptvUMr5GUjUFgPcAUdcust9Qk,18441
 cirq/qis/measures.py,sha256=-e2mStl9882z4mbLwWtbdmmdJilmf6Ex2b_jSXhMX3c,12194
 cirq/qis/measures_test.py,sha256=3LTTGdvuFfZWmFyWFeUHpg1yGc9z0VE8j7Kd7J7y8i4,10092
@@ -903,12 +903,12 @@ cirq/sim/sparse_simulator_test.py,sha256=3EAeCHUQeKllAAtdw14X592zBsGQY_vwfIYK-gE
 cirq/sim/state_vector.py,sha256=N6N9EELlW66UaLTBaq62ms0XkfIK7CzN9SBM7t52dXo,13428
 cirq/sim/state_vector_simulation_state.py,sha256=Ks3nGbIf6rq1Ap7Y5gZkcAJhu_Zr2-KWJhsE_wjwu8k,17624
 cirq/sim/state_vector_simulation_state_test.py,sha256=UtGMIurlV6N74nX7qoVnGoRhwF35-ghDEIP7Mj5AXmI,9841
-cirq/sim/state_vector_simulator.py,sha256=L2S0xyUGqRcVgYdzYef0gVREVZVIDcCXPclVbIJEpPE,7529
+cirq/sim/state_vector_simulator.py,sha256=Q-wCmJdLIoJAssTvrZmGCpnooFHjZNXr_yeyy5R0NFs,7559
 cirq/sim/state_vector_simulator_test.py,sha256=wJq1OZRzKokeM9cJyaJXi6wHH2qi97h0HmJlYOEBDzU,7864
 cirq/sim/state_vector_test.py,sha256=OjhAL2tWqJWstHV8RvJYQVqg95zm0PcS9nQKrLOhMmQ,16934
 cirq/sim/clifford/__init__.py,sha256=lD7l6JuE5n0xwvOYNYH-giCH3qAEVH1SUwDrZM1jKKY,636
 cirq/sim/clifford/clifford_simulator.py,sha256=V4rExIDeijZ-sjMAyS_dDt5aE-RIrzTWpwF3EnSujto,9732
-cirq/sim/clifford/clifford_simulator_test.py,sha256=L13hD6qXwDJ1Mq_gIctnyIZbOq8m6qS1KIce2imon1U,20242
+cirq/sim/clifford/clifford_simulator_test.py,sha256=pgLz8-SSFLBq6kcJ516ufQMJiJI2dG9NM2nkmzwY124,20380
 cirq/sim/clifford/clifford_tableau_simulation_state.py,sha256=fNkK0gZgfWIvMknGiCr4BjGO0wVYGW1Rc0pnwluerho,2160
 cirq/sim/clifford/clifford_tableau_simulation_state_test.py,sha256=KTzEoK5HcauVBj5tc8sXLt5vBXbDhxnFyj1bLt09nHo,3184
 cirq/sim/clifford/stabilizer_ch_form_simulation_state.py,sha256=2ZY_tQIp9J4NjoYkEEz1EdlNUGdyws1T7bl5hJ1VPgw,3028
@@ -931,7 +931,7 @@ cirq/study/sweepable_test.py,sha256=xjUksIurfbh240fEC7Al_TuiHGz7xZGktQUh86XBG9U,
 cirq/study/sweeps.py,sha256=IzonyU-LgEcMpvQrKZbl14v-BHi01oncp9CmHtLw0J4,19813
 cirq/study/sweeps_test.py,sha256=IqZp0ywYA430nNE_slBfc4vdKjULttzPl8ytxHLlgWo,11966
 cirq/testing/__init__.py,sha256=hbGRltgVaFhA6fMG2aVuRY-tXOluRyy4Rh9EQxqhQLg,3816
-cirq/testing/circuit_compare.py,sha256=c1uGQDfn2uAPtC-fiAwCrCzY-4NjerVBTm2uAnIceDQ,19175
+cirq/testing/circuit_compare.py,sha256=nBQES45wLVThOqC3WrPrYKLQP7HQ2pH5DjlJ5bHkrtU,19176
 cirq/testing/circuit_compare_test.py,sha256=AduZCzwBNFCYrjEpyS1DvIR6jU8GaFqQBBgPXyIALoU,19743
 cirq/testing/consistent_act_on.py,sha256=ofYxdotw7fDfEVaAoM3NJEG2-hTHmi5FlLZkLYfVBWE,7733
 cirq/testing/consistent_act_on_test.py,sha256=QXQCN76-zzNxZXc5S7XwPSvWWQ6Cl3v_k-1Sak5LCbo,3535
@@ -1028,7 +1028,7 @@ cirq/transformers/merge_single_qubit_gates.py,sha256=NRREV4Z6Ptc3mZnOUgzQePdj4H0
 cirq/transformers/merge_single_qubit_gates_test.py,sha256=0U5oitYfOIka1hUOn1Cv8zVK1Uo34DVaOnGMgqfRg4Q,9966
 cirq/transformers/optimize_for_target_gateset.py,sha256=2f93hEA_9vXbutkoOtzBTk_bjKLfdLWqsuue4-w4Rp0,6005
 cirq/transformers/optimize_for_target_gateset_test.py,sha256=G73RDFhdhXqpXMTEPyl_t5huhcyY1u6XqOToVEFpVJA,13848
-cirq/transformers/qubit_management_transformers.py,sha256=Uk1DcFCRFaFsLTxp_B5AKpSTDjqBKUhOGXD-kmEV0cM,9429
+cirq/transformers/qubit_management_transformers.py,sha256=A7Mweu9ElLSCsy_atmgFbYlzOFXKhct5gQ5YNTjjaVU,9430
 cirq/transformers/qubit_management_transformers_test.py,sha256=GGuZ4uxtFI59t9diW67_J17XQdBu9NFZjOHeMAHmm8Y,13991
 cirq/transformers/stratify.py,sha256=EEcXD6PEdHTZAoaAfaHnsw3Hf1SftbIl19hZOU_ZnXE,10469
 cirq/transformers/stratify_test.py,sha256=LmQFPB4grvRVvOgV8mA-pXNK3k9UC-banFJgWtDx_cA,15270
@@ -1148,8 +1148,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.4.0.dev20231221183905.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_core-1.4.0.dev20231221183905.dist-info/METADATA,sha256=mrzOuC9yUO4jQmsFxwRgPCJGNh1XpVgDtwKj8C7QQ_w,2075
-cirq_core-1.4.0.dev20231221183905.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-cirq_core-1.4.0.dev20231221183905.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
-cirq_core-1.4.0.dev20231221183905.dist-info/RECORD,,
+cirq_core-1.4.0.dev20240111191543.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_core-1.4.0.dev20240111191543.dist-info/METADATA,sha256=j0KlVLSwq0qrJhHIHAW8Ic1TmcKCZwJfS6TwRot0CyE,2075
+cirq_core-1.4.0.dev20240111191543.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+cirq_core-1.4.0.dev20240111191543.dist-info/top_level.txt,sha256=Sz9iOxHU0IEMLSFGwiwOCaN2e9K-jFbBbtpPN1hB73g,5
+cirq_core-1.4.0.dev20240111191543.dist-info/RECORD,,