cirq-core 1.6.0.dev20250505215959__py3-none-any.whl → 1.6.0.dev20250507223949__py3-none-any.whl

cirq/_compat_test.py

@@ -11,6 +11,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+from __future__ import annotations
+
 import collections
 import dataclasses
 import importlib.metadata
@@ -635,7 +638,7 @@ _repeated_child_deprecation_msg = [
 ] + _deprecation_origin
 
 
-def _trace_unhandled_exceptions(*args, queue: 'multiprocessing.Queue', func: Callable):
+def _trace_unhandled_exceptions(*args, queue: multiprocessing.Queue, func: Callable):
     try:
         func(*args)
         queue.put(None)

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.6.0.dev20250505215959"
+__version__ = "1.6.0.dev20250507223949"

cirq/_version_test.py

@@ -3,4 +3,4 @@ import cirq
 
 
 def test_version():
-    assert cirq.__version__ == "1.6.0.dev20250505215959"
+    assert cirq.__version__ == "1.6.0.dev20250507223949"

cirq/circuits/insert_strategy.py

@@ -14,16 +14,18 @@
 
 """Hard-coded options for adding multiple operations to a circuit."""
 
+from __future__ import annotations
+
 
 class InsertStrategy:
     """Indicates preferences on how to add multiple operations to a circuit."""
 
-    NEW: 'InsertStrategy'
-    NEW_THEN_INLINE: 'InsertStrategy'
-    INLINE: 'InsertStrategy'
-    EARLIEST: 'InsertStrategy'
+    NEW: InsertStrategy
+    NEW_THEN_INLINE: InsertStrategy
+    INLINE: InsertStrategy
+    EARLIEST: InsertStrategy
 
-    def __new__(cls, name: str, doc: str) -> 'InsertStrategy':
+    def __new__(cls, name: str, doc: str) -> InsertStrategy:
         inst = getattr(cls, name, None)
         if not inst or not isinstance(inst, cls):
             inst = super().__new__(cls)

cirq/contrib/acquaintance/gates_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from itertools import combinations, product
 from random import randint
 from string import ascii_lowercase as alphabet
@@ -257,7 +259,7 @@ class OtherOperation(cirq.Operation):
     def qubits(self) -> Tuple[cirq.Qid, ...]:
         return self._qubits
 
-    def with_qubits(self, *new_qubits: cirq.Qid) -> 'OtherOperation':
+    def with_qubits(self, *new_qubits: cirq.Qid) -> OtherOperation:
         return type(self)(self._qubits)
 
     def __eq__(self, other):

cirq/contrib/graph_device/hypergraph.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import itertools
 import random
 from typing import Any, Dict, FrozenSet, Hashable, Iterable, Mapping, Optional, Set, Tuple, Union
@@ -103,7 +105,7 @@ class UndirectedHypergraph:
     @classmethod
     def random(
         cls, vertices: Union[int, Iterable], edge_probs: Mapping[int, float]
-    ) -> 'UndirectedHypergraph':
+    ) -> UndirectedHypergraph:
         """A random hypergraph.
 
         Every possible edge is included with probability edge_prob[len(edge)].

cirq/contrib/paulistring/clifford_optimize.py

@@ -65,7 +65,7 @@ def clifford_optimized_circuit(circuit: circuits.Circuit, atol: float = 1e-8) ->
                     furthest_i = i
                 break
             if cont_cond == CONTINUE:
-                modified_op = modified_op.pass_operations_over([op], after_to_before=True)
+                modified_op = modified_op.conjugated_by(protocols.inverse(op))
             num_passed_over += 1
             if len(modified_op.pauli_string) == 1:
                 furthest_op = modified_op
@@ -122,7 +122,7 @@ def clifford_optimized_circuit(circuit: circuits.Circuit, atol: float = 1e-8) ->
                 all_ops.insert(merge_i + 1, part_cliff_gate(qubit))
             elif isinstance(other_op, ops.PauliStringPhasor):
                 # Pass over a non-Clifford gate
-                mod_op = other_op.pass_operations_over([part_cliff_gate(qubit)])
+                mod_op = other_op.conjugated_by([part_cliff_gate(qubit)])
                 all_ops[merge_i] = mod_op
                 all_ops.insert(merge_i + 1, part_cliff_gate(qubit))
             elif merge_i > start_i + 1 and num_passed > 0:

cirq/contrib/paulistring/pauli_string_measurement_with_readout_mitigation.py

@@ -11,19 +11,25 @@
 # 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 measuring expectation values of Pauli strings with readout error mitigation."""
+
+from __future__ import annotations
+
 import itertools
 import time
-from typing import cast, Dict, FrozenSet, List, Optional, Sequence, Tuple, Union
+from typing import cast, Dict, FrozenSet, List, Optional, Sequence, Tuple, TYPE_CHECKING, Union
 
 import attrs
 import numpy as np
 
 from cirq import circuits, ops, work
 from cirq.contrib.shuffle_circuits import run_shuffled_with_readout_benchmarking
-from cirq.experiments import SingleQubitReadoutCalibrationResult
 from cirq.experiments.readout_confusion_matrix import TensoredConfusionMatrices
-from cirq.study import ResultDict
+
+if TYPE_CHECKING:
+    from cirq.experiments import SingleQubitReadoutCalibrationResult
+    from cirq.study import ResultDict
 
 
 @attrs.frozen

cirq/contrib/paulistring/pauli_string_measurement_with_readout_mitigation_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import itertools
 import random
 from typing import Dict, Sequence

cirq/contrib/paulistring/pauli_string_optimize.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import networkx
 
 from cirq import circuits, linalg

cirq/contrib/paulistring/recombine.py

@@ -53,7 +53,7 @@ def _sorted_best_string_placements(
             ):
                 # This is as far through as this Pauli string can move
                 break
-            string_op = string_op.pass_operations_over([out_op], after_to_before=True)
+            string_op = string_op.conjugated_by(protocols.inverse(out_op))
             curr = (string_op, i + 1, possible_node)
             if sort_key(curr) > sort_key(node_max):
                 node_max = curr

cirq/contrib/paulistring/separate.py

@@ -89,8 +89,9 @@ def pauli_string_half(circuit: circuits.Circuit) -> circuits.Circuit:
 
 
 def _pull_non_clifford_before(circuit: circuits.Circuit) -> Iterator[ops.OP_TREE]:
-    def _iter_ops_range_reversed(moment_end):
-        for i in reversed(range(moment_end)):
+
+    def _iter_ops_range(moment_end):
+        for i in range(moment_end):
             moment = circuit[i]
             for op in moment.operations:
                 if not isinstance(op, ops.PauliStringPhasor):
@@ -99,5 +100,5 @@ def _pull_non_clifford_before(circuit: circuits.Circuit) -> Iterator[ops.OP_TREE
     for i, moment in enumerate(circuit):
         for op in moment.operations:
             if isinstance(op, ops.PauliStringPhasor):
-                ops_to_cross = _iter_ops_range_reversed(i)
-                yield op.pass_operations_over(ops_to_cross)
+                ops_to_cross = _iter_ops_range(i)
+                yield op.conjugated_by(ops_to_cross)

cirq/contrib/qasm_import/qasm.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from cirq import circuits
 from cirq.contrib.qasm_import._parser import QasmParser
 

cirq/contrib/quimb/density_matrix.py

@@ -1,4 +1,7 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
+
+from __future__ import annotations
+
 from functools import lru_cache
 from typing import Dict, List, Optional, Sequence, Tuple, Union
 
@@ -77,7 +80,7 @@ def _add_to_positions(
 
 def circuit_to_density_matrix_tensors(
     circuit: cirq.Circuit, qubits: Optional[Sequence[cirq.Qid]] = None
-) -> Tuple[List[qtn.Tensor], Dict['cirq.Qid', int], Dict[Tuple[str, str], Tuple[float, float]]]:
+) -> Tuple[List[qtn.Tensor], Dict[cirq.Qid, int], Dict[Tuple[str, str], Tuple[float, float]]]:
     """Given a circuit with mixtures or channels, construct a tensor network
     representation of the density matrix.
 

cirq/contrib/quimb/state_vector.py

@@ -1,4 +1,7 @@
 # pylint: disable=wrong-or-nonexistent-copyright-notice
+
+from __future__ import annotations
+
 import warnings
 from typing import cast, Dict, List, Optional, Sequence, Tuple, Union
 
@@ -28,7 +31,7 @@ def circuit_to_tensors(
     circuit: cirq.Circuit,
     qubits: Optional[Sequence[cirq.Qid]] = None,
     initial_state: Union[int, None] = 0,
-) -> Tuple[List[qtn.Tensor], Dict['cirq.Qid', int], None]:
+) -> Tuple[List[qtn.Tensor], Dict[cirq.Qid, int], None]:
     """Given a circuit, construct a tensor network representation.
 
     Indices are named "i{i}_q{x}" where i is a time index and x is a

cirq/contrib/quirk/quirk_gate.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import Any, Callable, cast, Dict, Optional, Union
 
 import numpy as np
@@ -46,7 +48,7 @@ class QuirkOp:
         self.keys = keys
         self.can_merge = can_merge
 
-    def controlled(self, control_count: int = 1) -> 'QuirkOp':
+    def controlled(self, control_count: int = 1) -> QuirkOp:
         return QuirkOp(*['•'] * control_count, *self.keys, can_merge=False)
 
 

cirq/contrib/routing/router.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import Callable, Optional
 
 import networkx as nx

cirq/contrib/shuffle_circuits/shuffle_circuits_with_readout_benchmarking.py

@@ -11,7 +11,11 @@
 # 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."""
+
+from __future__ import annotations
+
 import time
 from typing import Dict, List, Optional, Tuple, Union
 

cirq/experiments/fidelity_estimation.py

@@ -11,16 +11,22 @@
 # 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.
+
 """Estimation of fidelity associated with experimental circuit executions."""
-from typing import Callable, Mapping, Optional, Sequence
+
+from __future__ import annotations
+
+from typing import Callable, Mapping, Optional, Sequence, TYPE_CHECKING
 
 import numpy as np
 
-from cirq.circuits import Circuit
 from cirq.ops import QubitOrder, QubitOrderOrList
 from cirq.sim import final_state_vector
 from cirq.value import state_vector_to_probabilities
 
+if TYPE_CHECKING:
+    import cirq
+
 
 def linear_xeb_fidelity_from_probabilities(
     hilbert_space_dimension: int, probabilities: Sequence[float]
@@ -132,7 +138,7 @@ def hog_score_xeb_fidelity_from_probabilities(
 
 
 def xeb_fidelity(
-    circuit: Circuit,
+    circuit: cirq.Circuit,
     bitstrings: Sequence[int],
     qubit_order: QubitOrderOrList = QubitOrder.DEFAULT,
     amplitudes: Optional[Mapping[int, complex]] = None,
@@ -197,7 +203,7 @@ def xeb_fidelity(
 
 
 def linear_xeb_fidelity(
-    circuit: Circuit,
+    circuit: cirq.Circuit,
     bitstrings: Sequence[int],
     qubit_order: QubitOrderOrList = QubitOrder.DEFAULT,
     amplitudes: Optional[Mapping[int, complex]] = None,
@@ -213,7 +219,7 @@ def linear_xeb_fidelity(
 
 
 def log_xeb_fidelity(
-    circuit: Circuit,
+    circuit: cirq.Circuit,
     bitstrings: Sequence[int],
     qubit_order: QubitOrderOrList = QubitOrder.DEFAULT,
     amplitudes: Optional[Mapping[int, complex]] = None,

cirq/linalg/combinators.py

@@ -14,6 +14,8 @@
 
 """Utility methods for combining matrices."""
 
+from __future__ import annotations
+
 import functools
 from typing import TYPE_CHECKING, Union
 
@@ -107,7 +109,7 @@ def kron_with_controls(*factors: Union[np.ndarray, complex]) -> np.ndarray:
     return product
 
 
-def dot(*values: 'ArrayLike') -> np.ndarray:
+def dot(*values: ArrayLike) -> np.ndarray:
     """Computes the dot/matrix product of a sequence of values.
 
     Performs the computation in serial order without regard to the matrix
@@ -136,7 +138,7 @@ def dot(*values: 'ArrayLike') -> np.ndarray:
     return result
 
 
-def _merge_dtypes(dtype1: 'DTypeLike', dtype2: 'DTypeLike') -> np.dtype:
+def _merge_dtypes(dtype1: DTypeLike, dtype2: DTypeLike) -> np.dtype:
     return (np.zeros(0, dtype1) + np.zeros(0, dtype2)).dtype
 
 

cirq/linalg/predicates.py

@@ -11,7 +11,12 @@
 # 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 methods for checking properties of matrices."""
+
+from __future__ import annotations
+
+from types import EllipsisType
 from typing import cast, List, Optional, Sequence, Tuple, Union
 
 import numpy as np
@@ -228,7 +233,7 @@ def slice_for_qubits_equal_to(
     big_endian_qureg_value: int = 0,
     num_qubits: Optional[int] = None,
     qid_shape: Optional[Tuple[int, ...]] = None,
-) -> Tuple[Union[slice, int, 'ellipsis'], ...]:
+) -> Tuple[Union[slice, int, EllipsisType], ...]:
     """Returns an index corresponding to a desired subset of an np.ndarray.
 
     It is assumed that the np.ndarray's shape is of the form (2, 2, 2, ..., 2).

cirq/linalg/tolerance.py

@@ -14,6 +14,9 @@
 
 """Utility for testing approximate equality of matrices and scalars within
 tolerances."""
+
+from __future__ import annotations
+
 from typing import Iterable, TYPE_CHECKING, Union
 
 import numpy as np
@@ -22,7 +25,7 @@ if TYPE_CHECKING:
     from numpy.typing import ArrayLike
 
 
-def all_near_zero(a: 'ArrayLike', *, atol: float = 1e-8) -> bool:
+def all_near_zero(a: ArrayLike, *, atol: float = 1e-8) -> bool:
     """Checks if the tensor's elements are all near zero.
 
     Args:

cirq/neutral_atoms/convert_to_neutral_atom_gates.py

@@ -12,15 +12,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from cirq import ops
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 from cirq.neutral_atoms import neutral_atom_devices
 
+if TYPE_CHECKING:
+    import cirq
+
 
-def is_native_neutral_atom_op(operation: ops.Operation) -> bool:
+def is_native_neutral_atom_op(operation: cirq.Operation) -> bool:
     """Returns true if the operation is in the default neutral atom gateset."""
     return operation in neutral_atom_devices.neutral_atom_gateset()
 
 
-def is_native_neutral_atom_gate(gate: ops.Gate) -> bool:
+def is_native_neutral_atom_gate(gate: cirq.Gate) -> bool:
     """Returns true if the gate is in the default neutral atom gateset."""
     return gate in neutral_atom_devices.neutral_atom_gateset()

cirq/ops/clifford_gate_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import functools
 import itertools
 from typing import Tuple, Type
@@ -59,7 +61,7 @@ def _all_rotation_pairs():
 
 
 @functools.lru_cache()
-def _all_clifford_gates() -> Tuple['cirq.SingleQubitCliffordGate', ...]:
+def _all_clifford_gates() -> Tuple[cirq.SingleQubitCliffordGate, ...]:
     return tuple(
         cirq.SingleQubitCliffordGate.from_xz_map(trans_x, trans_z)
         for trans_x, trans_z in _all_rotation_pairs()

cirq/ops/pauli_string.py

@@ -45,6 +45,7 @@ import numpy as np
 import sympy
 
 from cirq import _compat, linalg, protocols, qis, value
+from cirq._compat import deprecated
 from cirq._doc import document
 from cirq._import import LazyLoader
 from cirq.ops import (
@@ -1070,9 +1071,10 @@ class PauliString(raw_types.Operation, Generic[TKey]):
         """
         return self.conjugated_by(ops)
 
+    @deprecated(deadline="v2.0", fix="Use conjuagetd_by()/before()/after() instead.")
     def pass_operations_over(
         self, ops: Iterable[cirq.Operation], after_to_before: bool = False
-    ) -> PauliString:
+    ) -> PauliString:  # pragma: no cover
         """Determines how the Pauli string changes when conjugated by Cliffords.
 
         The output and input pauli strings are related by a circuit equivalence.
@@ -1099,9 +1101,6 @@ class PauliString(raw_types.Operation, Generic[TKey]):
                 pauli string, instead of before (and so are moving in the
                 opposite direction).
         """
-        # TODO(#6946): deprecate this method.
-        # Note: This method is supposed to be replaced by conjugated_by()
-        #  (see #2351 for details).
         if after_to_before:
             return self.after(ops)
 

cirq/ops/pauli_string_phasor.py

@@ -30,7 +30,7 @@ from typing import (
 import sympy
 
 from cirq import protocols, value
-from cirq._compat import proper_repr
+from cirq._compat import deprecated, proper_repr
 from cirq.ops import (
     common_gates,
     dense_pauli_string as dps,
@@ -199,9 +199,21 @@ class PauliStringPhasor(gate_operation.GateOperation):
         syms = tuple(sym(qubit) for qubit in qubits)
         return protocols.CircuitDiagramInfo(wire_symbols=syms, exponent=self.exponent_relative)
 
+    def conjugated_by(self, clifford: 'cirq.OP_TREE') -> 'PauliStringPhasor':
+        r"""Returns the Pauli string conjugated by a clifford operation.
+
+        The PauliStringPhasor $P$ conjugated by the Clifford operation $C$ is
+          $C^\dagger P C$.
+        """
+        new_pauli_string: ps.PauliString = self.pauli_string.conjugated_by(clifford)
+        pp = self.exponent_pos
+        pn = self.exponent_neg
+        return PauliStringPhasor(new_pauli_string, exponent_pos=pp, exponent_neg=pn)
+
+    @deprecated(deadline="v2.0", fix="Use conjuagetd_by() instead.")
     def pass_operations_over(
         self, ops: Iterable[raw_types.Operation], after_to_before: bool = False
-    ) -> PauliStringPhasor:
+    ) -> PauliStringPhasor:  # pragma: no cover
         """Determines how the Pauli phasor changes when conjugated by Cliffords.
 
         The output and input pauli phasors are related by a circuit equivalence.
@@ -228,7 +240,12 @@ class PauliStringPhasor(gate_operation.GateOperation):
                 pauli string, instead of before (and so are moving in the
                 opposite direction).
         """
-        new_pauli_string = self.pauli_string.pass_operations_over(ops, after_to_before)
+        new_pauli_string: ps.PauliString = ps.PauliString()
+        if after_to_before:
+            new_pauli_string = self.pauli_string.after(ops)
+        else:
+            all_ops = list(op_tree.flatten_to_ops(ops))
+            new_pauli_string = self.pauli_string.before(all_ops[::-1])
         pp = self.exponent_pos
         pn = self.exponent_neg
         return PauliStringPhasor(new_pauli_string, exponent_pos=pp, exponent_neg=pn)

cirq/ops/pauli_string_phasor_test.py

@@ -155,7 +155,7 @@ def test_consistent():
     cirq.testing.assert_implements_consistent_protocols(p)
 
 
-def test_pass_operations_over():
+def test_conjugated_by():
     q0, q1 = _make_qubits(2)
     op = cirq.SingleQubitCliffordGate.from_double_map(
         {cirq.Z: (cirq.X, False), cirq.X: (cirq.Z, False)}
@@ -164,10 +164,7 @@ def test_pass_operations_over():
     ps_after = cirq.PauliString({q0: cirq.Z, q1: cirq.Y}, -1)
     before = cirq.PauliStringPhasor(ps_before, exponent_neg=0.1)
     after = cirq.PauliStringPhasor(ps_after, exponent_neg=0.1)
-    assert before.pass_operations_over([op]).pauli_string == after.pauli_string
-    assert (
-        after.pass_operations_over([op], after_to_before=True).pauli_string == before.pauli_string
-    )
+    assert before.conjugated_by(op).pauli_string == after.pauli_string
 
 
 def test_extrapolate_effect():