cirq-core 1.5.0.dev20250409222543__py3-none-any.whl → 1.6.0__py3-none-any.whl

cirq/transformers/eject_phased_paulis.py

@@ -14,7 +14,9 @@
 
 """Transformer pass that pushes 180° rotations around axes in the XY plane later in the circuit."""
 
-from typing import cast, Dict, Iterable, Iterator, Optional, Tuple, TYPE_CHECKING, Union
+from __future__ import annotations
+
+from typing import cast, Iterable, Iterator, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -29,12 +31,12 @@ if TYPE_CHECKING:
 
 @transformer_api.transformer(add_deep_support=True)
 def eject_phased_paulis(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
+    context: cirq.TransformerContext | None = None,
     atol: float = 1e-8,
     eject_parameterized: bool = False,
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Transformer pass to push X, Y, PhasedX & (certain) PhasedXZ gates to the end of the circuit.
 
     As the gates get pushed, they may absorb Z gates, cancel against other
@@ -57,10 +59,10 @@ def eject_phased_paulis(
     Returns:
           Copy of the transformed input circuit.
     """
-    held_w_phases: Dict[ops.Qid, value.TParamVal] = {}
+    held_w_phases: dict[ops.Qid, value.TParamVal] = {}
     tags_to_ignore = set(context.tags_to_ignore) if context else set()
 
-    def map_func(op: 'cirq.Operation', _: int) -> 'cirq.OP_TREE':
+    def map_func(op: cirq.Operation, _: int) -> cirq.OP_TREE:
         # Dump if `op` marked with a no compile tag.
         if set(op.tags) & tags_to_ignore:
             return [_dump_held(op.qubits, held_w_phases, atol), op]
@@ -106,8 +108,8 @@ def eject_phased_paulis(
 
 
 def _absorb_z_into_w(
-    op: ops.Operation, held_w_phases: Dict[ops.Qid, value.TParamVal]
-) -> 'cirq.OP_TREE':
+    op: ops.Operation, held_w_phases: dict[ops.Qid, value.TParamVal]
+) -> cirq.OP_TREE:
     """Absorbs a Z^t gate into a W(a) flip.
 
     [Where W(a) is shorthand for PhasedX(phase_exponent=a).]
@@ -127,8 +129,8 @@ def _absorb_z_into_w(
 
 
 def _dump_held(
-    qubits: Iterable[ops.Qid], held_w_phases: Dict[ops.Qid, value.TParamVal], atol: float
-) -> Iterator['cirq.OP_TREE']:
+    qubits: Iterable[ops.Qid], held_w_phases: dict[ops.Qid, value.TParamVal], atol: float
+) -> Iterator[cirq.OP_TREE]:
     # Note: sorting is to avoid non-determinism in the insertion order.
     for q in sorted(qubits):
         p = held_w_phases.get(q)
@@ -139,8 +141,8 @@ def _dump_held(
 
 
 def _dump_into_measurement(
-    op: ops.Operation, held_w_phases: Dict[ops.Qid, value.TParamVal]
-) -> 'cirq.OP_TREE':
+    op: ops.Operation, held_w_phases: dict[ops.Qid, value.TParamVal]
+) -> cirq.OP_TREE:
     measurement = cast(ops.MeasurementGate, cast(ops.GateOperation, op).gate)
     new_measurement = measurement.with_bits_flipped(
         *[i for i, q in enumerate(op.qubits) if q in held_w_phases]
@@ -151,8 +153,8 @@ def _dump_into_measurement(
 
 
 def _potential_cross_whole_w(
-    op: ops.Operation, atol: float, held_w_phases: Dict[ops.Qid, value.TParamVal]
-) -> 'cirq.OP_TREE':
+    op: ops.Operation, atol: float, held_w_phases: dict[ops.Qid, value.TParamVal]
+) -> cirq.OP_TREE:
     """Grabs or cancels a held W gate against an existing W gate.
 
     [Where W(a) is shorthand for PhasedX(phase_exponent=a).]
@@ -165,7 +167,7 @@ def _potential_cross_whole_w(
         ≡ ───Z^2(b-a)───
     """
     _, phase_exponent = cast(
-        Tuple[value.TParamVal, value.TParamVal], _try_get_known_phased_pauli(op)
+        tuple[value.TParamVal, value.TParamVal], _try_get_known_phased_pauli(op)
     )
     q = op.qubits[0]
     a = held_w_phases.get(q, None)
@@ -184,8 +186,8 @@ def _potential_cross_whole_w(
 
 
 def _potential_cross_partial_w(
-    op: ops.Operation, held_w_phases: Dict[ops.Qid, value.TParamVal], atol: float
-) -> 'cirq.OP_TREE':
+    op: ops.Operation, held_w_phases: dict[ops.Qid, value.TParamVal], atol: float
+) -> cirq.OP_TREE:
     """Cross the held W over a partial W gate.
 
     [Where W(a) is shorthand for PhasedX(phase_exponent=a).]
@@ -202,7 +204,7 @@ def _potential_cross_partial_w(
     if a is None:
         return op
     exponent, phase_exponent = cast(
-        Tuple[value.TParamVal, value.TParamVal], _try_get_known_phased_pauli(op)
+        tuple[value.TParamVal, value.TParamVal], _try_get_known_phased_pauli(op)
     )
     gate = _phased_x_or_pauli_gate(
         exponent=exponent, phase_exponent=2 * a - phase_exponent, atol=atol
@@ -210,7 +212,7 @@ def _potential_cross_partial_w(
     return gate.on(op.qubits[0])
 
 
-def _single_cross_over_cz(op: ops.Operation, qubit_with_w: 'cirq.Qid') -> 'cirq.OP_TREE':
+def _single_cross_over_cz(op: ops.Operation, qubit_with_w: cirq.Qid) -> cirq.OP_TREE:
     """Crosses exactly one W flip over a partial CZ.
 
     [Where W(a) is shorthand for PhasedX(phase_exponent=a).]
@@ -250,8 +252,8 @@ def _single_cross_over_cz(op: ops.Operation, qubit_with_w: 'cirq.Qid') -> 'cirq.
 
 
 def _double_cross_over_cz(
-    op: ops.Operation, held_w_phases: Dict[ops.Qid, value.TParamVal]
-) -> 'cirq.OP_TREE':
+    op: ops.Operation, held_w_phases: dict[ops.Qid, value.TParamVal]
+) -> cirq.OP_TREE:
     """Crosses two W flips over a partial CZ.
 
     [Where W(a) is shorthand for PhasedX(phase_exponent=a).]
@@ -294,7 +296,7 @@ def _double_cross_over_cz(
 
 def _try_get_known_cz_half_turns(
     op: ops.Operation, no_symbolic: bool = False
-) -> Optional[value.TParamVal]:
+) -> value.TParamVal | None:
     if not isinstance(op.gate, ops.CZPowGate):
         return None
     h = op.gate.exponent
@@ -305,7 +307,7 @@ def _try_get_known_cz_half_turns(
 
 def _try_get_known_phased_pauli(
     op: ops.Operation, no_symbolic: bool = False
-) -> Optional[Tuple[value.TParamVal, value.TParamVal]]:
+) -> tuple[value.TParamVal, value.TParamVal] | None:
     if no_symbolic and protocols.is_parameterized(op):
         return None
     gate = op.gate
@@ -333,7 +335,7 @@ def _try_get_known_phased_pauli(
 
 def _try_get_known_z_half_turns(
     op: ops.Operation, no_symbolic: bool = False
-) -> Optional[value.TParamVal]:
+) -> value.TParamVal | None:
     g = op.gate
     if (
         isinstance(g, ops.PhasedXZGate)
@@ -354,8 +356,8 @@ def _try_get_known_z_half_turns(
 
 
 def _phased_x_or_pauli_gate(
-    exponent: Union[float, sympy.Expr], phase_exponent: Union[float, sympy.Expr], atol: float
-) -> Union['cirq.PhasedXPowGate', 'cirq.XPowGate', 'cirq.YPowGate']:
+    exponent: float | sympy.Expr, phase_exponent: float | sympy.Expr, atol: float
+) -> cirq.PhasedXPowGate | cirq.XPowGate | cirq.YPowGate:
     """Return PhasedXPowGate or X or Y gate if equivalent within atol in z-axis turns."""
     if not isinstance(phase_exponent, sympy.Expr) or phase_exponent.is_constant():
         half_turns = value.canonicalize_half_turns(float(phase_exponent))

cirq/transformers/eject_phased_paulis_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 dataclasses
 from typing import cast, Iterable
 
@@ -98,7 +101,7 @@ def quick_circuit(*moments: Iterable[cirq.OP_TREE]) -> cirq.Circuit:
     )
 
 
-def test_absorbs_z():
+def test_absorbs_z() -> None:
     q = cirq.NamedQubit('q')
     x = sympy.Symbol('x')
 
@@ -165,7 +168,7 @@ def test_absorbs_z():
     )
 
 
-def test_crosses_czs():
+def test_crosses_czs() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     x = sympy.Symbol('x')
@@ -232,7 +235,7 @@ def test_crosses_czs():
     )
 
 
-def test_toggles_measurements():
+def test_toggles_measurements() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     x = sympy.Symbol('x')
@@ -289,7 +292,7 @@ def test_toggles_measurements():
     )
 
 
-def test_eject_phased_xz():
+def test_eject_phased_xz() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
     c = cirq.Circuit(
@@ -305,7 +308,7 @@ def test_eject_phased_xz():
     cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(c, c_expected, 1e-8)
 
 
-def test_cancels_other_full_w():
+def test_cancels_other_full_w() -> None:
     q = cirq.NamedQubit('q')
     x = sympy.Symbol('x')
     y = sympy.Symbol('y')
@@ -365,7 +368,7 @@ def test_cancels_other_full_w():
     )
 
 
-def test_phases_partial_ws():
+def test_phases_partial_ws() -> None:
     q = cirq.NamedQubit('q')
     x = sympy.Symbol('x')
     y = sympy.Symbol('y')
@@ -420,7 +423,7 @@ def test_phases_partial_ws():
 
 
 @pytest.mark.parametrize('sym', [sympy.Symbol('x'), sympy.Symbol('x') + 1])
-def test_blocked_by_unknown_and_symbols(sym):
+def test_blocked_by_unknown_and_symbols(sym) -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -442,7 +445,7 @@ def test_blocked_by_unknown_and_symbols(sym):
     )
 
 
-def test_blocked_by_nocompile_tag():
+def test_blocked_by_nocompile_tag() -> None:
     a = cirq.NamedQubit('a')
     b = cirq.NamedQubit('b')
 
@@ -453,7 +456,7 @@ def test_blocked_by_nocompile_tag():
     )
 
 
-def test_zero_x_rotation():
+def test_zero_x_rotation() -> None:
     a = cirq.NamedQubit('a')
 
     assert_optimizes(before=quick_circuit([cirq.rx(0)(a)]), expected=quick_circuit([cirq.rx(0)(a)]))

cirq/transformers/eject_z.py

@@ -14,8 +14,10 @@
 
 """Transformer pass that pushes Z gates later and later in the circuit."""
 
+from __future__ import annotations
+
 from collections import defaultdict
-from typing import Dict, Iterable, Iterator, Optional, Tuple, TYPE_CHECKING
+from typing import Iterable, Iterator, TYPE_CHECKING
 
 import numpy as np
 
@@ -31,7 +33,7 @@ def _is_integer(n):
     return np.isclose(n, np.round(n))
 
 
-def _is_swaplike(gate: 'cirq.Gate'):
+def _is_swaplike(gate: cirq.Gate):
     if isinstance(gate, ops.SwapPowGate):
         return gate.exponent == 1
 
@@ -46,12 +48,12 @@ def _is_swaplike(gate: 'cirq.Gate'):
 
 @transformer_api.transformer(add_deep_support=True)
 def eject_z(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
+    context: cirq.TransformerContext | None = None,
     atol: float = 0.0,
     eject_parameterized: bool = False,
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Pushes Z gates towards the end of the circuit.
 
     As the Z gates get pushed they may absorb other Z gates, get absorbed into
@@ -70,14 +72,12 @@ def eject_z(
         Copy of the transformed input circuit.
     """
     # Tracks qubit phases (in half turns; multiply by pi to get radians).
-    qubit_phase: Dict[ops.Qid, float] = defaultdict(lambda: 0)
+    qubit_phase: dict[ops.Qid, float] = defaultdict(lambda: 0)
     tags_to_ignore = set(context.tags_to_ignore) if context else set()
-    phased_xz_replacements: Dict[Tuple[int, ops.Operation], ops.PhasedXZGate] = {}
-    last_phased_xz_op: Dict[ops.Qid, Optional[Tuple[int, ops.Operation]]] = defaultdict(
-        lambda: None
-    )
+    phased_xz_replacements: dict[tuple[int, ops.Operation], ops.PhasedXZGate] = {}
+    last_phased_xz_op: dict[ops.Qid, tuple[int, ops.Operation] | None] = defaultdict(lambda: None)
 
-    def dump_tracked_phase(qubits: Iterable[ops.Qid]) -> Iterator['cirq.OP_TREE']:
+    def dump_tracked_phase(qubits: Iterable[ops.Qid]) -> Iterator[cirq.OP_TREE]:
         """Zeroes qubit_phase entries by emitting Z gates."""
         for q in qubits:
             p, key = qubit_phase[q], last_phased_xz_op[q]
@@ -87,7 +87,7 @@ def eject_z(
             elif key:
                 phased_xz_replacements[key] = phased_xz_replacements[key].with_z_exponent(p * 2)
 
-    def map_func(op: 'cirq.Operation', moment_index: int) -> 'cirq.OP_TREE':
+    def map_func(op: cirq.Operation, moment_index: int) -> cirq.OP_TREE:
         last_phased_xz_op.update({q: None for q in op.qubits})
 
         if tags_to_ignore & set(op.tags):

cirq/transformers/eject_z_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 dataclasses
 
 import numpy as np
@@ -191,8 +193,6 @@ def test_unphaseable_causes_earlier_merge_without_size_increase():
         pass
 
     u = UnknownGate()
-
-    # pylint: disable=not-callable
     q = cirq.NamedQubit('q')
     assert_optimizes(
         before=cirq.Circuit(

cirq/transformers/expand_composite.py

@@ -14,7 +14,9 @@
 
 """Transformer pass that expands composite operations via `cirq.decompose`."""
 
-from typing import Callable, Optional, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import Callable, TYPE_CHECKING
 
 from cirq import circuits, ops, protocols
 from cirq.transformers import transformer_api, transformer_primitives
@@ -25,9 +27,9 @@ if TYPE_CHECKING:
 
 @transformer_api.transformer
 def expand_composite(
-    circuit: 'cirq.AbstractCircuit',
+    circuit: cirq.AbstractCircuit,
     *,
-    context: Optional['cirq.TransformerContext'] = None,
+    context: cirq.TransformerContext | None = None,
     no_decomp: Callable[[ops.Operation], bool] = (lambda _: False),
 ):
     """A transformer that expands composite operations via `cirq.decompose`.
@@ -48,7 +50,7 @@ def expand_composite(
           Copy of the transformed input circuit.
     """
 
-    def map_func(op: 'cirq.Operation', _) -> 'cirq.OP_TREE':
+    def map_func(op: cirq.Operation, _) -> cirq.OP_TREE:
         if context and context.deep and isinstance(op.untagged, circuits.CircuitOperation):
             return op
         return protocols.decompose(op, keep=no_decomp, on_stuck_raise=None)

cirq/transformers/expand_composite_test.py

@@ -14,6 +14,8 @@
 
 """Tests for the expand composite transformer pass."""
 
+from __future__ import annotations
+
 import cirq
 
 
@@ -189,7 +191,7 @@ def test_do_not_decompose_no_compile():
     assert_equal_mod_empty(c, cirq.expand_composite(c, context=context))
 
 
-def test_expands_composite_recursively_preserving_structur():
+def test_expands_composite_recursively_preserving_structure():
     q = cirq.LineQubit.range(2)
     c_nested = cirq.FrozenCircuit(
         cirq.SWAP(*q[:2]), cirq.SWAP(*q[:2]).with_tags("ignore"), cirq.SWAP(*q[:2])

cirq/transformers/gauge_compiling/__init__.py

@@ -39,4 +39,6 @@ from cirq.transformers.gauge_compiling.sqrt_iswap_gauge import (
     SqrtISWAPGaugeTransformer as SqrtISWAPGaugeTransformer,
 )
 
-from cirq.transformers.gauge_compiling.cphase_gauge import CPhaseGaugeTransformer
+from cirq.transformers.gauge_compiling.cphase_gauge import (
+    CPhaseGaugeTransformer as CPhaseGaugeTransformer,
+)

cirq/transformers/gauge_compiling/cphase_gauge.py

@@ -14,6 +14,8 @@
 
 """A Gauge Transformer for the cphase gate."""
 
+from __future__ import annotations
+
 import numpy as np
 
 import cirq.transformers.gauge_compiling.sqrt_cz_gauge as sqrt_cz_gauge

cirq/transformers/gauge_compiling/cphase_gauge_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 cirq
 from cirq.transformers.gauge_compiling.cphase_gauge import CPhaseGaugeTransformer
 from cirq.transformers.gauge_compiling.gauge_compiling_test_utils import GaugeTester

cirq/transformers/gauge_compiling/cz_gauge.py

@@ -14,6 +14,8 @@
 
 """A Gauge Transformer for the CZ gate."""
 
+from __future__ import annotations
+
 from cirq import ops
 from cirq.ops.common_gates import CZ
 from cirq.transformers.gauge_compiling.gauge_compiling import (

cirq/transformers/gauge_compiling/cz_gauge_test.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
 
 import cirq
 from cirq.transformers.gauge_compiling import CZGaugeTransformer