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

cirq/ops/boolean_hamiltonian.py

@@ -22,9 +22,12 @@ References:
 [4] Efficient Quantum Circuits for Diagonal Unitaries Without Ancillas by Jonathan Welch, Daniel
     Greenbaum, Sarah Mostame, and Alán Aspuru-Guzik, https://arxiv.org/abs/1306.3991
 """
+
+from __future__ import annotations
+
 import functools
 import itertools
-from typing import Any, Dict, Generator, List, Sequence, Tuple
+from typing import Any, Generator, Sequence
 
 import sympy.parsing.sympy_parser as sympy_parser
 
@@ -77,13 +80,13 @@ class BooleanHamiltonianGate(raw_types.Gate):
         self._boolean_strs: Sequence[str] = boolean_strs
         self._theta: float = theta
 
-    def _qid_shape_(self) -> Tuple[int, ...]:
+    def _qid_shape_(self) -> tuple[int, ...]:
         return (2,) * len(self._parameter_names)
 
     def _value_equality_values_(self) -> Any:
         return tuple(self._parameter_names), tuple(self._boolean_strs), self._theta
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {
             'parameter_names': self._parameter_names,
             'boolean_strs': self._boolean_strs,
@@ -93,10 +96,10 @@ class BooleanHamiltonianGate(raw_types.Gate):
     @classmethod
     def _from_json_dict_(
         cls, parameter_names, boolean_strs, theta, **kwargs
-    ) -> 'cirq.BooleanHamiltonianGate':
+    ) -> cirq.BooleanHamiltonianGate:
         return cls(parameter_names, boolean_strs, theta)
 
-    def _decompose_(self, qubits: Sequence['cirq.Qid']) -> 'cirq.OP_TREE':
+    def _decompose_(self, qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
         qubit_map = dict(zip(self._parameter_names, qubits))
         boolean_exprs = [sympy_parser.parse_expr(boolean_str) for boolean_str in self._boolean_strs]
         hamiltonian_polynomial_list = [
@@ -118,7 +121,7 @@ class BooleanHamiltonianGate(raw_types.Gate):
         )
 
 
-def _gray_code_comparator(k1: Tuple[int, ...], k2: Tuple[int, ...], flip: bool = False) -> int:
+def _gray_code_comparator(k1: tuple[int, ...], k2: tuple[int, ...], flip: bool = False) -> int:
     """Compares two Gray-encoded binary numbers.
 
     Args:
@@ -141,8 +144,8 @@ def _gray_code_comparator(k1: Tuple[int, ...], k2: Tuple[int, ...], flip: bool =
 
 
 def _simplify_commuting_cnots(
-    cnots: List[Tuple[int, int]], flip_control_and_target: bool
-) -> Tuple[bool, List[Tuple[int, int]]]:
+    cnots: list[tuple[int, int]], flip_control_and_target: bool
+) -> tuple[bool, list[tuple[int, int]]]:
     """Attempts to commute CNOTs and remove cancelling pairs.
 
     Commutation relations are based on 9 (flip_control_and_target=False) or 10
@@ -181,7 +184,7 @@ def _simplify_commuting_cnots(
     target, control = (0, 1) if flip_control_and_target else (1, 0)
 
     to_remove = set()
-    qubit_to_index: List[Tuple[int, Dict[int, int]]] = []
+    qubit_to_index: list[tuple[int, dict[int, int]]] = []
     for j in range(len(cnots)):
         if not qubit_to_index or cnots[j][target] != qubit_to_index[-1][0]:
             # The targets (resp. control) don't match, so we create a new dict.
@@ -202,8 +205,8 @@ def _simplify_commuting_cnots(
 
 
 def _simplify_cnots_triplets(
-    cnots: List[Tuple[int, int]], flip_control_and_target: bool
-) -> Tuple[bool, List[Tuple[int, int]]]:
+    cnots: list[tuple[int, int]], flip_control_and_target: bool
+) -> tuple[bool, list[tuple[int, int]]]:
     """Simplifies CNOT pairs according to equation 11 of [4].
 
     CNOT(i, j) @ CNOT(j, k) == CNOT(j, k) @ CNOT(i, k) @ CNOT(i, j)
@@ -228,7 +231,7 @@ def _simplify_cnots_triplets(
         # First, we look back for as long as the controls (resp. targets) are the same.
         # They all commute, so all are potential candidates for being simplified.
         # prev_match_index is qubit to index in `cnots` array.
-        prev_match_index: Dict[int, int] = {}
+        prev_match_index: dict[int, int] = {}
         for i in range(j - 1, -1, -1):
             # These CNOTs have the same target (resp. control) and though they are not candidates
             # for simplification, since they commute, we can keep looking for candidates.
@@ -242,7 +245,7 @@ def _simplify_cnots_triplets(
         # Next, we look forward for as long as the targets (resp. controls) are the
         # same. They all commute, so all are potential candidates for being simplified.
         # post_match_index is qubit to index in `cnots` array.
-        post_match_index: Dict[int, int] = {}
+        post_match_index: dict[int, int] = {}
         for k in range(j + 1, len(cnots)):
             # These CNOTs have the same control (resp. target) and though they are not candidates
             # for simplification, since they commute, we can keep looking for candidates.
@@ -257,7 +260,7 @@ def _simplify_cnots_triplets(
         keys = prev_match_index.keys() & post_match_index.keys()
         for key in keys:
             # We perform the swap which removes the pivot.
-            new_idx: List[int] = (
+            new_idx: list[int] = (
                 # Anything strictly before the pivot that is not the CNOT to swap.
                 [idx for idx in range(j) if idx != prev_match_index[key]]
                 # The two swapped CNOTs.
@@ -272,7 +275,7 @@ def _simplify_cnots_triplets(
     return False, cnots
 
 
-def _simplify_cnots(cnots: List[Tuple[int, int]]) -> List[Tuple[int, int]]:
+def _simplify_cnots(cnots: list[tuple[int, int]]) -> list[tuple[int, int]]:
     """Takes a series of CNOTs and tries to applies rule to cancel out gates.
 
     Algorithm based on "Efficient quantum circuits for diagonal unitaries without ancillas" by
@@ -299,10 +302,8 @@ def _simplify_cnots(cnots: List[Tuple[int, int]]) -> List[Tuple[int, int]]:
 
 
 def _get_gates_from_hamiltonians(
-    hamiltonian_polynomial_list: List['cirq.PauliSum'],
-    qubit_map: Dict[str, 'cirq.Qid'],
-    theta: float,
-) -> Generator['cirq.Operation', None, None]:
+    hamiltonian_polynomial_list: list[cirq.PauliSum], qubit_map: dict[str, cirq.Qid], theta: float
+) -> Generator[cirq.Operation, None, None]:
     """Builds a circuit according to [1].
 
     Args:
@@ -325,8 +326,8 @@ def _get_gates_from_hamiltonians(
         qubit_idx = tuple(sorted(qubit_indices[qubit] for qubit in pauli_string.qubits))
         hamiltonians[qubit_idx] = w
 
-    def _apply_cnots(prevh: Tuple[int, ...], currh: Tuple[int, ...]):
-        cnots: List[Tuple[int, int]] = []
+    def _apply_cnots(prevh: tuple[int, ...], currh: tuple[int, ...]):
+        cnots: list[tuple[int, int]] = []
 
         cnots.extend((prevh[i], prevh[-1]) for i in range(len(prevh) - 1))
         cnots.extend((currh[i], currh[-1]) for i in range(len(currh) - 1))
@@ -340,7 +341,7 @@ def _get_gates_from_hamiltonians(
         hamiltonians.keys(), key=functools.cmp_to_key(_gray_code_comparator)
     )
 
-    previous_h: Tuple[int, ...] = ()
+    previous_h: tuple[int, ...] = ()
     for h in sorted_hamiltonian_keys:
         w = hamiltonians[h]
         yield _apply_cnots(previous_h, h)

cirq/ops/boolean_hamiltonian_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 functools
 import itertools
 import math
@@ -53,7 +56,7 @@ import cirq.ops.boolean_hamiltonian as bh
         '(x2 | x1) ^ x0',
     ],
 )
-def test_circuit(boolean_str):
+def test_circuit(boolean_str) -> None:
     boolean_expr = sympy_parser.parse_expr(boolean_str)
     var_names = cirq.parameter_names(boolean_expr)
     qubits = [cirq.NamedQubit(name) for name in var_names]
@@ -73,7 +76,7 @@ def test_circuit(boolean_str):
     circuit.append(cirq.H.on_each(*qubits))
 
     hamiltonian_gate = cirq.BooleanHamiltonianGate(
-        {q.name: q for q in qubits}, [boolean_str], 0.1 * math.pi
+        [q.name for q in qubits], [boolean_str], 0.1 * math.pi
     )
 
     assert hamiltonian_gate.num_qubits() == n
@@ -87,7 +90,7 @@ def test_circuit(boolean_str):
     np.testing.assert_array_equal(actual, expected)
 
 
-def test_gate_with_custom_names():
+def test_gate_with_custom_names() -> None:
     q0, q1, q2, q3 = cirq.LineQubit.range(4)
     gate = cirq.BooleanHamiltonianGate(['a', 'b'], ['a'], 0.1)
     assert cirq.decompose(gate.on(q0, q1)) == [cirq.Rz(rads=-0.05).on(q0)]
@@ -101,7 +104,7 @@ def test_gate_with_custom_names():
         gate.on(q0, cirq.LineQid(1, 3))
 
 
-def test_gate_consistent():
+def test_gate_consistent() -> None:
     gate = cirq.BooleanHamiltonianGate(['a', 'b'], ['a'], 0.1)
     op = gate.on(*cirq.LineQubit.range(2))
     cirq.testing.assert_implements_consistent_protocols(gate)
@@ -116,7 +119,7 @@ def test_gate_consistent():
         (3, [(), (0,), (0, 1), (1,), (1, 2), (0, 1, 2), (0, 2), (2,)]),
     ],
 )
-def test_gray_code_sorting(n_bits, expected_hs):
+def test_gray_code_sorting(n_bits, expected_hs) -> None:
     hs_template = []
     for x in range(2**n_bits):
         h = []
@@ -139,7 +142,7 @@ def test_gray_code_sorting(n_bits, expected_hs):
 @pytest.mark.parametrize(
     'seq_a,seq_b,expected', [((), (), 0), ((), (0,), -1), ((0,), (), 1), ((0,), (0,), 0)]
 )
-def test_gray_code_comparison(seq_a, seq_b, expected):
+def test_gray_code_comparison(seq_a, seq_b, expected) -> None:
     assert bh._gray_code_comparator(seq_a, seq_b) == expected
 
 
@@ -170,7 +173,7 @@ def test_gray_code_comparison(seq_a, seq_b, expected):
 )
 def test_simplify_commuting_cnots(
     input_cnots, input_flip_control_and_target, expected_simplified, expected_output_cnots
-):
+) -> None:
     actual_simplified, actual_output_cnots = bh._simplify_commuting_cnots(
         input_cnots, input_flip_control_and_target
     )
@@ -203,7 +206,7 @@ def test_simplify_commuting_cnots(
 )
 def test_simplify_cnots_triplets(
     input_cnots, input_flip_control_and_target, expected_simplified, expected_output_cnots
-):
+) -> None:
     actual_simplified, actual_output_cnots = bh._simplify_cnots_triplets(
         input_cnots, input_flip_control_and_target
     )
@@ -211,7 +214,7 @@ def test_simplify_cnots_triplets(
     assert actual_output_cnots == expected_output_cnots
 
     # Check that the unitaries are the same.
-    qubit_ids = set(sum(input_cnots, ()))
+    qubit_ids = set(itertools.chain.from_iterable(input_cnots))
     qubits = {qubit_id: cirq.NamedQubit(f"{qubit_id}") for qubit_id in qubit_ids}
 
     target, control = (0, 1) if input_flip_control_and_target else (1, 0)

cirq/ops/classically_controlled_operation.py

@@ -11,19 +11,10 @@
 # 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 typing import (
-    AbstractSet,
-    Any,
-    Dict,
-    FrozenSet,
-    List,
-    Mapping,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    Union,
-)
+
+from __future__ import annotations
+
+from typing import AbstractSet, Any, cast, Mapping, Sequence, TYPE_CHECKING
 
 import sympy
 
@@ -79,8 +70,8 @@ class ClassicallyControlledOperation(raw_types.Operation):
 
     def __init__(
         self,
-        sub_operation: 'cirq.Operation',
-        conditions: Sequence[Union[str, 'cirq.MeasurementKey', 'cirq.Condition', sympy.Basic]],
+        sub_operation: cirq.Operation,
+        conditions: Sequence[str | cirq.MeasurementKey | cirq.Condition | sympy.Basic],
     ):
         """Initializes a `ClassicallyControlledOperation`.
 
@@ -106,7 +97,7 @@ class ClassicallyControlledOperation(raw_types.Operation):
         if isinstance(sub_operation, ClassicallyControlledOperation):
             conditions += sub_operation._conditions
             sub_operation = sub_operation._sub_operation
-        conds: List['cirq.Condition'] = []
+        conds: list[cirq.Condition] = []
         for c in conditions:
             if isinstance(c, str):
                 c = value.MeasurementKey.parse_serialized(c)
@@ -115,14 +106,14 @@ class ClassicallyControlledOperation(raw_types.Operation):
             if isinstance(c, sympy.Basic):
                 c = value.SympyCondition(c)
             conds.append(c)
-        self._conditions: Tuple['cirq.Condition', ...] = tuple(conds)
-        self._sub_operation: 'cirq.Operation' = sub_operation
+        self._conditions: tuple[cirq.Condition, ...] = tuple(conds)
+        self._sub_operation: cirq.Operation = sub_operation
 
     @property
-    def classical_controls(self) -> FrozenSet['cirq.Condition']:
+    def classical_controls(self) -> frozenset[cirq.Condition]:
         return frozenset(self._conditions).union(self._sub_operation.classical_controls)
 
-    def without_classical_controls(self) -> 'cirq.Operation':
+    def without_classical_controls(self) -> cirq.Operation:
         return self._sub_operation.without_classical_controls()
 
     @property
@@ -137,7 +128,7 @@ class ClassicallyControlledOperation(raw_types.Operation):
     def _decompose_(self):
         return self._decompose_with_context_()
 
-    def _decompose_with_context_(self, context: Optional['cirq.DecompositionContext'] = None):
+    def _decompose_with_context_(self, context: cirq.DecompositionContext | None = None):
         result = protocols.decompose_once(
             self._sub_operation, NotImplemented, flatten=False, context=context
         )
@@ -168,14 +159,14 @@ class ClassicallyControlledOperation(raw_types.Operation):
         return protocols.parameter_names(self._sub_operation)
 
     def _resolve_parameters_(
-        self, resolver: 'cirq.ParamResolver', recursive: bool
-    ) -> 'ClassicallyControlledOperation':
+        self, resolver: cirq.ParamResolver, recursive: bool
+    ) -> ClassicallyControlledOperation:
         new_sub_op = protocols.resolve_parameters(self._sub_operation, resolver, recursive)
         return ClassicallyControlledOperation(new_sub_op, self._conditions)
 
     def _circuit_diagram_info_(
-        self, args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> Optional['protocols.CircuitDiagramInfo']:
+        self, args: cirq.CircuitDiagramInfoArgs
+    ) -> protocols.CircuitDiagramInfo | None:
         sub_args = protocols.CircuitDiagramInfoArgs(
             known_qubit_count=args.known_qubit_count,
             known_qubits=args.known_qubits,
@@ -207,42 +198,46 @@ class ClassicallyControlledOperation(raw_types.Operation):
             wire_symbols=wire_symbols, exponent=sub_info.exponent, exponent_qubit_index=exp_index
         )
 
-    def _json_dict_(self) -> Dict[str, Any]:
+    def _json_dict_(self) -> dict[str, Any]:
         return {'conditions': self._conditions, 'sub_operation': self._sub_operation}
 
-    def _act_on_(self, sim_state: 'cirq.SimulationStateBase') -> bool:
+    def _act_on_(self, sim_state: cirq.SimulationStateBase) -> bool:
         if all(c.resolve(sim_state.classical_data) for c in self._conditions):
             protocols.act_on(self._sub_operation, sim_state)
         return True
 
     def _with_measurement_key_mapping_(
         self, key_map: Mapping[str, str]
-    ) -> 'ClassicallyControlledOperation':
+    ) -> ClassicallyControlledOperation:
         conditions = [protocols.with_measurement_key_mapping(c, key_map) for c in self._conditions]
         sub_operation = protocols.with_measurement_key_mapping(self._sub_operation, key_map)
         sub_operation = self._sub_operation if sub_operation is NotImplemented else sub_operation
-        return sub_operation.with_classical_controls(*conditions)
+        return cast(
+            ClassicallyControlledOperation, sub_operation.with_classical_controls(*conditions)
+        )
 
-    def _with_key_path_prefix_(self, prefix: Tuple[str, ...]) -> 'ClassicallyControlledOperation':
+    def _with_key_path_prefix_(self, prefix: tuple[str, ...]) -> ClassicallyControlledOperation:
         conditions = [protocols.with_key_path_prefix(c, prefix) for c in self._conditions]
         sub_operation = protocols.with_key_path_prefix(self._sub_operation, prefix)
         sub_operation = self._sub_operation if sub_operation is NotImplemented else sub_operation
-        return sub_operation.with_classical_controls(*conditions)
+        return cast(
+            ClassicallyControlledOperation, sub_operation.with_classical_controls(*conditions)
+        )
 
     def _with_rescoped_keys_(
-        self, path: Tuple[str, ...], bindable_keys: FrozenSet['cirq.MeasurementKey']
-    ) -> 'ClassicallyControlledOperation':
+        self, path: tuple[str, ...], bindable_keys: frozenset[cirq.MeasurementKey]
+    ) -> ClassicallyControlledOperation:
         conds = [protocols.with_rescoped_keys(c, path, bindable_keys) for c in self._conditions]
         sub_operation = protocols.with_rescoped_keys(self._sub_operation, path, bindable_keys)
         return sub_operation.with_classical_controls(*conds)
 
-    def _control_keys_(self) -> FrozenSet['cirq.MeasurementKey']:
-        local_keys: FrozenSet['cirq.MeasurementKey'] = frozenset(
+    def _control_keys_(self) -> frozenset[cirq.MeasurementKey]:
+        local_keys: frozenset[cirq.MeasurementKey] = frozenset(
             k for condition in self._conditions for k in condition.keys
         )
         return local_keys.union(protocols.control_keys(self._sub_operation))
 
-    def _qasm_(self, args: 'cirq.QasmArgs') -> Optional[str]:
+    def _qasm_(self, args: cirq.QasmArgs) -> str | None:
         args.validate_version('2.0', '3.0')
         if len(self._conditions) > 1:
             raise ValueError('QASM does not support multiple conditions.')