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

cirq/testing/routing_devices.py

@@ -11,8 +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.
+
 """Provides test devices that can validate circuits during a routing procedure."""
 
+from __future__ import annotations
+
 from typing import TYPE_CHECKING
 
 import networkx as nx
@@ -39,7 +42,7 @@ class RoutingTestingDevice(devices.Device):
     def metadata(self) -> devices.DeviceMetadata:
         return self._metadata
 
-    def validate_operation(self, operation: 'cirq.Operation') -> None:
+    def validate_operation(self, operation: cirq.Operation) -> None:
         if not self._metadata.qubit_set.issuperset(operation.qubits):
             raise ValueError(f'Qubits not on device: {operation.qubits!r}.')
 

cirq/testing/routing_devices_test.py

@@ -11,13 +11,16 @@
 # 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 networkx as nx
 import pytest
 
 import cirq
 
 
-def test_grid_device():
+def test_grid_device() -> None:
     rect_device = cirq.testing.construct_grid_device(5, 7)
     rect_device_graph = rect_device.metadata.nx_graph
     isomorphism_class = nx.Graph()
@@ -33,7 +36,7 @@ def test_grid_device():
     assert nx.is_isomorphic(isomorphism_class, rect_device_graph)
 
 
-def test_grid_op_validation():
+def test_grid_op_validation() -> None:
     device = cirq.testing.construct_grid_device(5, 7)
 
     with pytest.raises(ValueError, match="Qubits not on device"):
@@ -56,7 +59,7 @@ def test_grid_op_validation():
     device.validate_operation(cirq.CNOT(cirq.GridQubit(0, 0), cirq.GridQubit(1, 0)))
 
 
-def test_ring_device():
+def test_ring_device() -> None:
     undirected_device = cirq.testing.construct_ring_device(5)
     undirected_device_graph = undirected_device.metadata.nx_graph
     assert all(q in undirected_device_graph.nodes for q in cirq.LineQubit.range(5))
@@ -74,7 +77,7 @@ def test_ring_device():
     assert nx.is_isomorphic(isomorphism_class, directed_device_graph)
 
 
-def test_ring_op_validation():
+def test_ring_op_validation() -> None:
     directed_device = cirq.testing.construct_ring_device(5, directed=True)
     undirected_device = cirq.testing.construct_ring_device(5, directed=False)
 
@@ -93,7 +96,7 @@ def test_ring_op_validation():
     directed_device.validate_operation(cirq.CNOT(cirq.LineQubit(0), cirq.LineQubit(1)))
 
 
-def test_allowed_multi_qubit_gates():
+def test_allowed_multi_qubit_gates() -> None:
     device = cirq.testing.construct_ring_device(5)
 
     device.validate_operation(cirq.MeasurementGate(1).on(cirq.LineQubit(0)))
@@ -106,7 +109,7 @@ def test_allowed_multi_qubit_gates():
     device.validate_operation(cirq.CNOT(*cirq.LineQubit.range(2)))
 
 
-def test_namedqubit_device():
+def test_namedqubit_device() -> None:
     # 4-star graph
     nx_graph = nx.Graph([("a", "b"), ("a", "c"), ("a", "d")])
 

cirq/testing/sample_circuits.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
+
 from typing import TYPE_CHECKING
 
 from cirq import circuits, ops
@@ -19,7 +22,7 @@ if TYPE_CHECKING:
     import cirq
 
 
-def nonoptimal_toffoli_circuit(q0: 'cirq.Qid', q1: 'cirq.Qid', q2: 'cirq.Qid') -> circuits.Circuit:
+def nonoptimal_toffoli_circuit(q0: cirq.Qid, q1: cirq.Qid, q2: cirq.Qid) -> circuits.Circuit:
     ret = circuits.Circuit(
         ops.Y(q2) ** 0.5,
         ops.X(q2),

cirq/testing/sample_circuits_test.py

@@ -12,10 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import cirq
 
 
-def test_nonoptimal_toffoli_circuit():
+def test_nonoptimal_toffoli_circuit() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     cirq.testing.assert_allclose_up_to_global_phase(
         cirq.testing.nonoptimal_toffoli_circuit(q0, q1, q2).unitary(),

cirq/testing/sample_gates.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
 
 import numpy as np

cirq/testing/sample_gates_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 numpy as np
 import pytest
 
@@ -19,7 +22,7 @@ from cirq.testing import sample_gates
 
 
 @pytest.mark.parametrize('theta', np.linspace(0, 2 * np.pi, 20))
-def test_phase_using_clean_ancilla(theta: float):
+def test_phase_using_clean_ancilla(theta: float) -> None:
     g = sample_gates.PhaseUsingCleanAncilla(theta)
     q = cirq.LineQubit(0)
     qubit_order = cirq.QubitOrder.explicit([q], fallback=cirq.QubitOrder.DEFAULT)
@@ -45,7 +48,7 @@ def test_phase_using_clean_ancilla(theta: float):
     'target_bitsize, phase_state', [(1, 0), (1, 1), (2, 0), (2, 1), (2, 2), (2, 3)]
 )
 @pytest.mark.parametrize('ancilla_bitsize', [1, 4])
-def test_phase_using_dirty_ancilla(target_bitsize, phase_state, ancilla_bitsize):
+def test_phase_using_dirty_ancilla(target_bitsize, phase_state, ancilla_bitsize) -> None:
     g = sample_gates.PhaseUsingDirtyAncilla(phase_state, target_bitsize, ancilla_bitsize)
     q = cirq.LineQubit.range(target_bitsize)
     qubit_order = cirq.QubitOrder.explicit(q, fallback=cirq.QubitOrder.DEFAULT)

cirq/transformers/__init__.py

@@ -15,13 +15,12 @@
 """Classes and methods for transforming circuits."""
 
 from cirq.transformers.analytical_decompositions import (
-    # pylint: disable=line-too-long
-    compute_cphase_exponents_for_fsim_decomposition as compute_cphase_exponents_for_fsim_decomposition,
+    compute_cphase_exponents_for_fsim_decomposition as compute_cphase_exponents_for_fsim_decomposition,  # noqa: E501
     decompose_cphase_into_two_fsim as decompose_cphase_into_two_fsim,
     decompose_clifford_tableau_to_operations as decompose_clifford_tableau_to_operations,
     decompose_multi_controlled_x as decompose_multi_controlled_x,
     decompose_multi_controlled_rotation as decompose_multi_controlled_rotation,
-    decompose_two_qubit_interaction_into_four_fsim_gates as decompose_two_qubit_interaction_into_four_fsim_gates,
+    decompose_two_qubit_interaction_into_four_fsim_gates as decompose_two_qubit_interaction_into_four_fsim_gates,  # noqa: E501
     is_negligible_turn as is_negligible_turn,
     parameterized_2q_op_to_sqrt_iswap_operations as parameterized_2q_op_to_sqrt_iswap_operations,
     prepare_two_qubit_state_using_cz as prepare_two_qubit_state_using_cz,
@@ -36,7 +35,7 @@ from cirq.transformers.analytical_decompositions import (
     three_qubit_matrix_to_operations as three_qubit_matrix_to_operations,
     two_qubit_matrix_to_cz_isometry as two_qubit_matrix_to_cz_isometry,
     two_qubit_matrix_to_cz_operations as two_qubit_matrix_to_cz_operations,
-    two_qubit_matrix_to_diagonal_and_cz_operations as two_qubit_matrix_to_diagonal_and_cz_operations,
+    two_qubit_matrix_to_diagonal_and_cz_operations as two_qubit_matrix_to_diagonal_and_cz_operations,  # noqa: E501
     two_qubit_matrix_to_ion_operations as two_qubit_matrix_to_ion_operations,
     two_qubit_matrix_to_sqrt_iswap_operations as two_qubit_matrix_to_sqrt_iswap_operations,
     unitary_to_pauli_string as unitary_to_pauli_string,
@@ -101,6 +100,7 @@ from cirq.transformers.merge_single_qubit_gates import (
     merge_single_qubit_gates_to_phased_x_and_z as merge_single_qubit_gates_to_phased_x_and_z,
     merge_single_qubit_gates_to_phxz as merge_single_qubit_gates_to_phxz,
     merge_single_qubit_moments_to_phxz as merge_single_qubit_moments_to_phxz,
+    merge_single_qubit_gates_to_phxz_symbolized as merge_single_qubit_gates_to_phxz_symbolized,
 )
 
 from cirq.transformers.qubit_management_transformers import (
@@ -119,6 +119,8 @@ from cirq.transformers.transformer_api import (
     transformer as transformer,
 )
 
+from cirq.transformers.tag_transformers import index_tags as index_tags, remove_tags as remove_tags
+
 from cirq.transformers.transformer_primitives import (
     map_moments as map_moments,
     map_operations as map_operations,
@@ -133,6 +135,11 @@ from cirq.transformers.transformer_primitives import (
     unroll_circuit_op_greedy_frontier as unroll_circuit_op_greedy_frontier,
 )
 
+from cirq.transformers.symbolize import (
+    SymbolizeTag as SymbolizeTag,
+    symbolize_single_qubit_gates_by_indexed_tags as symbolize_single_qubit_gates_by_indexed_tags,
+)
+
 from cirq.transformers.gauge_compiling import (
     CZGaugeTransformer as CZGaugeTransformer,
     ConstantGauge as ConstantGauge,

cirq/transformers/align.py

@@ -14,8 +14,10 @@
 
 """Transformer passes which align operations to the left or right of the circuit."""
 
+from __future__ import annotations
+
 import dataclasses
-from typing import Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from cirq import circuits, ops
 from cirq.transformers import transformer_api
@@ -26,9 +28,9 @@ if TYPE_CHECKING:
 
 @transformer_api.transformer(add_deep_support=True)
 def align_left(
-    circuit: 'cirq.AbstractCircuit', *, context: Optional['cirq.TransformerContext'] = None
-) -> 'cirq.Circuit':
-    """Align gates to the left of the circuit.
+    circuit: cirq.AbstractCircuit, *, context: cirq.TransformerContext | None = None
+) -> cirq.Circuit:
+    """Aligns gates to the left of the circuit.
 
     Note that tagged operations with tag in `context.tags_to_ignore` will continue to stay in their
     original position and will not be aligned.
@@ -58,9 +60,9 @@ def align_left(
 
 @transformer_api.transformer(add_deep_support=True)
 def align_right(
-    circuit: 'cirq.AbstractCircuit', *, context: Optional['cirq.TransformerContext'] = None
-) -> 'cirq.Circuit':
-    """Align gates to the right of the circuit.
+    circuit: cirq.AbstractCircuit, *, context: cirq.TransformerContext | None = None
+) -> cirq.Circuit:
+    """Aligns gates to the right of the circuit.
 
     Note that tagged operations with tag in `context.tags_to_ignore` will continue to stay in their
     original position and will not be aligned.

cirq/transformers/align_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
 
 

cirq/transformers/analytical_decompositions/__init__.py

@@ -24,8 +24,7 @@ from cirq.transformers.analytical_decompositions.controlled_gate_decomposition i
 )
 
 from cirq.transformers.analytical_decompositions.cphase_to_fsim import (
-    # pylint: disable=line-too-long
-    compute_cphase_exponents_for_fsim_decomposition as compute_cphase_exponents_for_fsim_decomposition,
+    compute_cphase_exponents_for_fsim_decomposition as compute_cphase_exponents_for_fsim_decomposition,  # noqa: E501
     decompose_cphase_into_two_fsim as decompose_cphase_into_two_fsim,
 )
 
@@ -47,14 +46,12 @@ from cirq.transformers.analytical_decompositions.three_qubit_decomposition impor
 )
 
 from cirq.transformers.analytical_decompositions.two_qubit_to_cz import (
-    # pylint: disable=line-too-long
     two_qubit_matrix_to_cz_operations as two_qubit_matrix_to_cz_operations,
-    two_qubit_matrix_to_diagonal_and_cz_operations as two_qubit_matrix_to_diagonal_and_cz_operations,
+    two_qubit_matrix_to_diagonal_and_cz_operations as two_qubit_matrix_to_diagonal_and_cz_operations,  # noqa: E501
 )
 
 from cirq.transformers.analytical_decompositions.two_qubit_to_fsim import (
-    # pylint: disable=line-too-long
-    decompose_two_qubit_interaction_into_four_fsim_gates as decompose_two_qubit_interaction_into_four_fsim_gates,
+    decompose_two_qubit_interaction_into_four_fsim_gates as decompose_two_qubit_interaction_into_four_fsim_gates,  # noqa: E501
 )
 
 from cirq.transformers.analytical_decompositions.two_qubit_to_ms import (

cirq/transformers/analytical_decompositions/clifford_decomposition.py

@@ -14,8 +14,10 @@
 
 """Utility methods to decompose Clifford gates into circuits."""
 
+from __future__ import annotations
+
 import functools
-from typing import List, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -28,8 +30,8 @@ if TYPE_CHECKING:
 def _X(
     q: int,
     args: sim.CliffordTableauSimulationState,
-    operations: List[ops.Operation],
-    qubits: List['cirq.Qid'],
+    operations: list[ops.Operation],
+    qubits: list[cirq.Qid],
 ):
     protocols.act_on(ops.X, args, qubits=[qubits[q]], allow_decompose=False)
     operations.append(ops.X(qubits[q]))
@@ -38,8 +40,8 @@ def _X(
 def _Z(
     q: int,
     args: sim.CliffordTableauSimulationState,
-    operations: List[ops.Operation],
-    qubits: List['cirq.Qid'],
+    operations: list[ops.Operation],
+    qubits: list[cirq.Qid],
 ):
     protocols.act_on(ops.Z, args, qubits=[qubits[q]], allow_decompose=False)
     operations.append(ops.Z(qubits[q]))
@@ -48,8 +50,8 @@ def _Z(
 def _Sdg(
     q: int,
     args: sim.CliffordTableauSimulationState,
-    operations: List[ops.Operation],
-    qubits: List['cirq.Qid'],
+    operations: list[ops.Operation],
+    qubits: list[cirq.Qid],
 ):
     # Apply the tableau with S^\{dagger}
     protocols.act_on(ops.S**-1, args, qubits=[qubits[q]], allow_decompose=False)
@@ -59,8 +61,8 @@ def _Sdg(
 def _H(
     q: int,
     args: sim.CliffordTableauSimulationState,
-    operations: List[ops.Operation],
-    qubits: List['cirq.Qid'],
+    operations: list[ops.Operation],
+    qubits: list[cirq.Qid],
 ):
     protocols.act_on(ops.H, args, qubits=[qubits[q]], allow_decompose=False)
     operations.append(ops.H(qubits[q]))
@@ -70,8 +72,8 @@ def _CNOT(
     q1: int,
     q2: int,
     args: sim.CliffordTableauSimulationState,
-    operations: List[ops.Operation],
-    qubits: List['cirq.Qid'],
+    operations: list[ops.Operation],
+    qubits: list[cirq.Qid],
 ):
     protocols.act_on(ops.CNOT, args, qubits=[qubits[q1], qubits[q2]], allow_decompose=False)
     operations.append(ops.CNOT(qubits[q1], qubits[q2]))
@@ -81,16 +83,16 @@ def _SWAP(
     q1: int,
     q2: int,
     args: sim.CliffordTableauSimulationState,
-    operations: List[ops.Operation],
-    qubits: List['cirq.Qid'],
+    operations: list[ops.Operation],
+    qubits: list[cirq.Qid],
 ):
     protocols.act_on(ops.SWAP, args, qubits=[qubits[q1], qubits[q2]], allow_decompose=False)
     operations.append(ops.SWAP(qubits[q1], qubits[q2]))
 
 
 def decompose_clifford_tableau_to_operations(
-    qubits: List['cirq.Qid'], clifford_tableau: qis.CliffordTableau
-) -> List[ops.Operation]:
+    qubits: list[cirq.Qid], clifford_tableau: qis.CliffordTableau
+) -> list[ops.Operation]:
     """Decompose an n-qubit Clifford Tableau into a list of one/two qubit operations.
 
     The implementation is based on Theorem 8 in [1].
@@ -114,7 +116,7 @@ def decompose_clifford_tableau_to_operations(
     ), "The provided clifford_tableau must satisfy the symplectic property."
 
     t: qis.CliffordTableau = clifford_tableau.copy()
-    operations: List[ops.Operation] = []
+    operations: list[ops.Operation] = []
     args = sim.CliffordTableauSimulationState(
         tableau=t, qubits=qubits, prng=np.random.RandomState()
     )

cirq/transformers/analytical_decompositions/clifford_decomposition_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 numpy as np
 import pytest
 

cirq/transformers/analytical_decompositions/controlled_gate_decomposition.py

@@ -12,7 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import List, Tuple, TYPE_CHECKING
+from __future__ import annotations
+
+import itertools
+from typing import TYPE_CHECKING
 
 import numpy as np
 
@@ -34,10 +37,10 @@ def _is_identity(matrix):
 
 
 def _flatten(x):
-    return sum(x, [])
+    return list(itertools.chain.from_iterable(x))
 
 
-def _decompose_abc(matrix: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarray, float]:
+def _decompose_abc(matrix: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray, float]:
     """Decomposes 2x2 unitary matrix.
 
     Returns 2x2 special unitary matrices A, B, C and phase delta, such that:
@@ -70,8 +73,8 @@ def _decompose_abc(matrix: np.ndarray) -> Tuple[np.ndarray, np.ndarray, np.ndarr
 
 
 def _decompose_single_ctrl(
-    matrix: np.ndarray, control: 'cirq.Qid', target: 'cirq.Qid'
-) -> List['cirq.Operation']:
+    matrix: np.ndarray, control: cirq.Qid, target: cirq.Qid
+) -> list[cirq.Operation]:
     """Decomposes controlled gate with one control.
 
     See [1], chapter 5.1.
@@ -93,7 +96,7 @@ def _decompose_single_ctrl(
     return result
 
 
-def _ccnot_congruent(c0: 'cirq.Qid', c1: 'cirq.Qid', target: 'cirq.Qid') -> List['cirq.Operation']:
+def _ccnot_congruent(c0: cirq.Qid, c1: cirq.Qid, target: cirq.Qid) -> list[cirq.Operation]:
     """Implements 3-qubit gate 'congruent' to CCNOT.
 
     Returns sequence of operations which is equivalent to applying
@@ -111,8 +114,8 @@ def _ccnot_congruent(c0: 'cirq.Qid', c1: 'cirq.Qid', target: 'cirq.Qid') -> List
 
 
 def decompose_multi_controlled_x(
-    controls: List['cirq.Qid'], target: 'cirq.Qid', free_qubits: List['cirq.Qid']
-) -> List['cirq.Operation']:
+    controls: list[cirq.Qid], target: cirq.Qid, free_qubits: list[cirq.Qid]
+) -> list[cirq.Operation]:
     """Implements action of multi-controlled Pauli X gate.
 
     Result is guaranteed to consist exclusively of 1-qubit, CNOT and CCNOT
@@ -164,8 +167,8 @@ def decompose_multi_controlled_x(
 
 
 def _decompose_su(
-    matrix: np.ndarray, controls: List['cirq.Qid'], target: 'cirq.Qid'
-) -> List['cirq.Operation']:
+    matrix: np.ndarray, controls: list[cirq.Qid], target: cirq.Qid
+) -> list[cirq.Operation]:
     """Decomposes controlled special unitary gate into elementary gates.
 
     Result has O(len(controls)) operations.
@@ -190,10 +193,10 @@ def _decompose_su(
 def _decompose_recursive(
     matrix: np.ndarray,
     power: float,
-    controls: List['cirq.Qid'],
-    target: 'cirq.Qid',
-    free_qubits: List['cirq.Qid'],
-) -> List['cirq.Operation']:
+    controls: list[cirq.Qid],
+    target: cirq.Qid,
+    free_qubits: list[cirq.Qid],
+) -> list[cirq.Operation]:
     """Decomposes controlled unitary gate into elementary gates.
 
     Result has O(len(controls)^2) operations.
@@ -215,8 +218,8 @@ def _decompose_recursive(
 
 
 def decompose_multi_controlled_rotation(
-    matrix: np.ndarray, controls: List['cirq.Qid'], target: 'cirq.Qid'
-) -> List['cirq.Operation']:
+    matrix: np.ndarray, controls: list[cirq.Qid], target: cirq.Qid
+) -> list[cirq.Operation]:
     """Implements action of multi-controlled unitary gate.
 
     Returns a sequence of operations, which is equivalent to applying

cirq/transformers/analytical_decompositions/controlled_gate_decomposition_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 numpy as np
 import scipy.stats
 

cirq/transformers/analytical_decompositions/cphase_to_fsim.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Optional, Sequence, Tuple, TYPE_CHECKING
+from __future__ import annotations
+
+from typing import Sequence, TYPE_CHECKING
 
 import numpy as np
 import sympy
@@ -32,8 +34,8 @@ def _asinsin(x: float) -> float:
 
 
 def compute_cphase_exponents_for_fsim_decomposition(
-    fsim_gate: 'cirq.FSimGate',
-) -> Sequence[Tuple[float, float]]:
+    fsim_gate: cirq.FSimGate,
+) -> Sequence[tuple[float, float]]:
     """Returns intervals of CZPowGate exponents valid for FSim decomposition.
 
     Ideal intervals associated with the constraints are closed, but due to
@@ -56,8 +58,8 @@ def compute_cphase_exponents_for_fsim_decomposition(
     """
 
     def nonempty_intervals(
-        intervals: Sequence[Tuple[float, float]],
-    ) -> Sequence[Tuple[float, float]]:
+        intervals: Sequence[tuple[float, float]],
+    ) -> Sequence[tuple[float, float]]:
         return tuple((a, b) for a, b in intervals if a < b)
 
     # Each of the two FSimGate parameters sets a bound on phase angle.
@@ -93,12 +95,12 @@ def compute_cphase_exponents_for_fsim_decomposition(
 
 
 def decompose_cphase_into_two_fsim(
-    cphase_gate: 'cirq.CZPowGate',
+    cphase_gate: cirq.CZPowGate,
     *,
-    fsim_gate: 'cirq.FSimGate',
-    qubits: Optional[Sequence['cirq.Qid']] = None,
+    fsim_gate: cirq.FSimGate,
+    qubits: Sequence[cirq.Qid] | None = None,
     atol: float = 1e-8,
-) -> 'cirq.OP_TREE':
+) -> cirq.OP_TREE:
     """Decomposes CZPowGate into two FSimGates.
 
     This function implements the decomposition described in section VII F I

cirq/transformers/analytical_decompositions/cphase_to_fsim_test.py

@@ -12,8 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import itertools
-from typing import List, Sequence, Tuple
+from typing import Sequence
 
 import numpy as np
 import pytest
@@ -111,9 +113,9 @@ def test_valid_cphase_exponents(theta, phi):
                 assert_decomposition_valid(cphase_gate, fsim_gate=fsim_gate)
 
 
-def complement_intervals(intervals: Sequence[Tuple[float, float]]) -> Sequence[Tuple[float, float]]:
+def complement_intervals(intervals: Sequence[tuple[float, float]]) -> Sequence[tuple[float, float]]:
     """Computes complement of union of intervals in [0, 2]."""
-    complements: List[Tuple[float, float]] = []
+    complements: list[tuple[float, float]] = []
     a = 0.0
     for b, c in intervals:
         complements.append((a, b))

cirq/transformers/analytical_decompositions/pauli_string_decomposition.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import cast, Optional, Tuple
+from __future__ import annotations
+
+from typing import cast
 
 import numpy as np
 import numpy.typing as npt
@@ -21,7 +23,7 @@ from cirq import protocols
 from cirq.ops import DensePauliString
 
 
-def _argmax(V: npt.NDArray) -> Tuple[int, float]:
+def _argmax(V: npt.NDArray) -> tuple[int, float]:
     """Returns a tuple (index of max number, max number)."""
     V = (V * V.conj()).real
     idx_max = np.argmax(V)
@@ -60,7 +62,7 @@ def _conjugate_with_hadamard(U: npt.NDArray) -> npt.NDArray:
     return U
 
 
-def unitary_to_pauli_string(U: npt.NDArray, eps: float = 1e-15) -> Optional[DensePauliString]:
+def unitary_to_pauli_string(U: npt.NDArray, eps: float = 1e-15) -> DensePauliString | None:
     """Attempts to find a pauli string (with possible phase) equivalent to U up to eps.
 
         Based on this answer https://shorturl.at/aA079.

cirq/transformers/analytical_decompositions/pauli_string_decomposition_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 cmath
 import itertools
 from typing import cast
@@ -28,7 +30,7 @@ from cirq.transformers.analytical_decompositions import unitary_to_pauli_string
 @pytest.mark.parametrize(
     'pauli_string', [''.join(p) for p in itertools.product(['', 'I', 'X', 'Y', 'Z'], repeat=4)]
 )
-def test_unitary_to_pauli_string(pauli_string: str, phase: complex):
+def test_unitary_to_pauli_string(pauli_string: str, phase: complex) -> None:
     want = DensePauliString(pauli_string, coefficient=phase)
     got = unitary_to_pauli_string(protocols.unitary(want))
     assert got is not None
@@ -36,7 +38,7 @@ def test_unitary_to_pauli_string(pauli_string: str, phase: complex):
     assert np.isclose(cast(np.complex128, want.coefficient), cast(np.complex128, got.coefficient))
 
 
-def test_unitary_to_pauli_string_non_pauli_input():
+def test_unitary_to_pauli_string_non_pauli_input() -> None:
     got = unitary_to_pauli_string(protocols.unitary(T))
     assert got is None
 
@@ -50,7 +52,7 @@ def test_unitary_to_pauli_string_non_pauli_input():
     assert got is None
 
 
-def test_invalid_input():
+def test_invalid_input() -> None:
     with pytest.raises(ValueError, match='Input has a non-square shape.*'):
         _ = unitary_to_pauli_string(np.zeros((2, 3)))