cirq-core 1.6.0.dev20250416221104__py3-none-any.whl → 1.6.0.dev20250417204649__py3-none-any.whl

cirq/interop/quirk/cells/qubit_permutation_cells.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, Iterator, Sequence, Tuple, TYPE_CHECKING
 
 from cirq import ops, value
@@ -42,7 +44,7 @@ class QuirkQubitPermutationGate(ops.QubitPermutationGate):
     def _value_equality_values_(self):
         return self.identifier, self.name, self.permutation
 
-    def _circuit_diagram_info_(self, args: 'cirq.CircuitDiagramInfoArgs') -> Tuple[str, ...]:
+    def _circuit_diagram_info_(self, args: cirq.CircuitDiagramInfoArgs) -> Tuple[str, ...]:
         return tuple(
             f'{self.name}[{i}>{self.permutation[i]}]' for i in range(len(self.permutation))
         )

cirq/interop/quirk/cells/scalar_cells.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 Iterator, TYPE_CHECKING
 
 from cirq import ops
@@ -28,5 +31,5 @@ def generate_all_scalar_cell_makers() -> Iterator[CellMaker]:
     yield _scalar("√-i", ops.global_phase_operation((-1j) ** 0.5))
 
 
-def _scalar(identifier: str, operation: 'cirq.Operation') -> CellMaker:
+def _scalar(identifier: str, operation: cirq.Operation) -> CellMaker:
     return CellMaker(identifier, size=1, maker=lambda _: operation)

cirq/interop/quirk/cells/single_qubit_rotation_cells.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 Callable, Iterator, TYPE_CHECKING
 
 import sympy
@@ -91,14 +94,14 @@ def generate_all_single_qubit_rotation_cell_makers() -> Iterator[CellMaker]:
     yield _formula_gate("Rzft", "pi*t*t", ops.rz)
 
 
-def _gate(identifier: str, gate: 'cirq.Gate') -> CellMaker:
+def _gate(identifier: str, gate: cirq.Gate) -> CellMaker:
     return CellMaker(
         identifier=identifier, size=gate.num_qubits(), maker=lambda args: gate.on(*args.qubits)
     )
 
 
 def _formula_gate(
-    identifier: str, default_formula: str, gate_func: Callable[['cirq.TParamVal'], 'cirq.Gate']
+    identifier: str, default_formula: str, gate_func: Callable[[cirq.TParamVal], cirq.Gate]
 ) -> CellMaker:
     return CellMaker(
         identifier=identifier,

cirq/interop/quirk/cells/swap_cell.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, Iterable, Iterator, List, Optional, TYPE_CHECKING
 
 from cirq import ops, value
@@ -23,20 +25,20 @@ if TYPE_CHECKING:
 
 @value.value_equality(unhashable=True)
 class SwapCell(Cell):
-    def __init__(self, qubits: Iterable['cirq.Qid'], controls: Iterable['cirq.Qid']):
+    def __init__(self, qubits: Iterable[cirq.Qid], controls: Iterable[cirq.Qid]):
         self._qubits = list(qubits)
         self._controls = list(controls)
 
     def gate_count(self) -> int:
         return 1
 
-    def with_line_qubits_mapped_to(self, qubits: List['cirq.Qid']) -> 'Cell':
+    def with_line_qubits_mapped_to(self, qubits: List[cirq.Qid]) -> Cell:
         return SwapCell(
             qubits=Cell._replace_qubits(self._qubits, qubits),
             controls=Cell._replace_qubits(self._controls, qubits),
         )
 
-    def modify_column(self, column: List[Optional['Cell']]):
+    def modify_column(self, column: List[Optional[Cell]]):
         # Swallow other swap cells.
         for i in range(len(column)):
             gate = column[i]
@@ -45,12 +47,12 @@ class SwapCell(Cell):
                 self._qubits += gate._qubits
                 column[i] = None
 
-    def operations(self) -> 'cirq.OP_TREE':
+    def operations(self) -> cirq.OP_TREE:
         if len(self._qubits) != 2:
             raise ValueError('Wrong number of swap gates in a column.')
         return ops.SWAP(*self._qubits).controlled_by(*self._controls)
 
-    def controlled_by(self, qubit: 'cirq.Qid'):
+    def controlled_by(self, qubit: cirq.Qid):
         return SwapCell(self._qubits, self._controls + [qubit])
 
     def _value_equality_values_(self) -> Any:

cirq/interop/quirk/cells/testing.py

@@ -22,7 +22,7 @@ from cirq import quirk_url_to_circuit
 
 def assert_url_to_circuit_returns(
     json_text: str,
-    circuit: Optional['cirq.Circuit'] = None,
+    circuit: Optional[cirq.Circuit] = None,
     *,
     unitary: Optional[np.ndarray] = None,
     diagram: Optional[str] = None,

cirq/interop/quirk/url_to_circuit.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 json
 import urllib.parse
 from typing import (
@@ -47,12 +50,12 @@ if TYPE_CHECKING:
 def quirk_url_to_circuit(
     quirk_url: str,
     *,
-    qubits: Optional[Sequence['cirq.Qid']] = None,
+    qubits: Optional[Sequence[cirq.Qid]] = None,
     extra_cell_makers: Union[
-        Dict[str, 'cirq.Gate'], Iterable['cirq.interop.quirk.cells.CellMaker']
+        Dict[str, cirq.Gate], Iterable[cirq.interop.quirk.cells.CellMaker]
     ] = (),
     max_operation_count: int = 10**6,
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Parses a Cirq circuit out of a Quirk URL.
 
     Args:
@@ -150,13 +153,13 @@ def quirk_url_to_circuit(
 def quirk_json_to_circuit(
     data: dict,
     *,
-    qubits: Optional[Sequence['cirq.Qid']] = None,
+    qubits: Optional[Sequence[cirq.Qid]] = None,
     extra_cell_makers: Union[
-        Dict[str, 'cirq.Gate'], Iterable['cirq.interop.quirk.cells.CellMaker']
+        Dict[str, cirq.Gate], Iterable[cirq.interop.quirk.cells.CellMaker]
     ] = (),
     quirk_url: Optional[str] = None,
     max_operation_count: int = 10**6,
-) -> 'cirq.Circuit':
+) -> cirq.Circuit:
     """Constructs a Cirq circuit from Quirk's JSON format.
 
     Args:
@@ -239,7 +242,7 @@ def quirk_json_to_circuit(
     if qubits is not None:
         qs = qubits
 
-        def map_qubit(qubit: 'cirq.Qid') -> 'cirq.Qid':
+        def map_qubit(qubit: cirq.Qid) -> cirq.Qid:
             q = cast(devices.LineQubit, qubit)
             if q.x >= len(qs):
                 raise IndexError(
@@ -343,7 +346,7 @@ def _register_custom_gate(gate_json: Any, registry: Dict[str, CellMaker]):
         )
 
 
-def _init_ops(data: Dict[str, Any]) -> 'cirq.OP_TREE':
+def _init_ops(data: Dict[str, Any]) -> cirq.OP_TREE:
     if 'init' not in data:
         return []
     init = data['init']

cirq/json_resolver_cache.py

@@ -12,16 +12,18 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Methods for resolving JSON types during serialization."""
+
+from __future__ import annotations
+
 import datetime
 import functools
 from typing import Dict, List, NamedTuple, Optional, Tuple, TYPE_CHECKING
 
-from cirq.protocols.json_serialization import ObjectFactory
-
 if TYPE_CHECKING:
     import cirq
     import cirq.devices.unconstrained_device
     import cirq.ops.pauli_gates
+    from cirq.protocols.json_serialization import ObjectFactory
 
 
 # Needed for backwards compatible named tuples of CrossEntropyResult
@@ -80,7 +82,7 @@ def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
         )
 
     def _cross_entropy_result_dict(
-        results: List[Tuple[List['cirq.Qid'], CrossEntropyResult]], **kwargs
+        results: List[Tuple[List[cirq.Qid], CrossEntropyResult]], **kwargs
     ) -> CrossEntropyResultDict:
         return CrossEntropyResultDict(results={tuple(qubits): result for qubits, result in results})
 

cirq/linalg/decompositions.py

@@ -12,9 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
 """Utility methods for breaking matrices into useful pieces."""
 
+from __future__ import annotations
+
 import cmath
 import math
 from typing import (
@@ -271,7 +272,7 @@ class AxisAngleDecomposition:
         self.axis = tuple(axis)
         self.angle = float(angle)
 
-    def canonicalize(self, atol: float = 1e-8) -> 'AxisAngleDecomposition':
+    def canonicalize(self, atol: float = 1e-8) -> AxisAngleDecomposition:
         """Returns a standardized AxisAngleDecomposition with the same unitary.
 
         Ensures the axis (x, y, z) satisfies x+y+z >= 0.
@@ -524,7 +525,7 @@ class KakDecomposition:
 
 
 def scatter_plot_normalized_kak_interaction_coefficients(
-    interactions: Iterable[Union[np.ndarray, 'cirq.SupportsUnitary', 'KakDecomposition']],
+    interactions: Iterable[Union[np.ndarray, cirq.SupportsUnitary, KakDecomposition]],
     *,
     include_frame: bool = True,
     ax: Optional[mplot3d.axes3d.Axes3D] = None,
@@ -786,7 +787,7 @@ KAK_GAMMA = np.array([[1, 1, 1, 1],
 
 def kak_decomposition(
     unitary_object: Union[
-        np.ndarray, 'cirq.SupportsUnitary', 'cirq.Gate', 'cirq.Operation', KakDecomposition
+        np.ndarray, cirq.SupportsUnitary, cirq.Gate, cirq.Operation, KakDecomposition
     ],
     *,
     rtol: float = 1e-5,

cirq/linalg/decompositions_test.py

@@ -582,7 +582,7 @@ def _local_two_qubit_unitaries(samples, random_state):
 _kak_gens = np.array([np.kron(X, X), np.kron(Y, Y), np.kron(Z, Z)])
 
 
-def _random_two_qubit_unitaries(num_samples: int, random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE'):
+def _random_two_qubit_unitaries(num_samples: int, random_state: cirq.RANDOM_STATE_OR_SEED_LIKE):
     # Randomly generated two-qubit unitaries and the KAK vectors (not canonical)
     kl = _local_two_qubit_unitaries(num_samples, random_state)
 

cirq/linalg/operator_spaces.py

@@ -13,6 +13,9 @@
 # limitations under the License.
 
 """Utilities for manipulating linear operators as elements of vector space."""
+
+from __future__ import annotations
+
 from typing import Dict, Tuple, TYPE_CHECKING
 
 import numpy as np
@@ -82,16 +85,13 @@ def matrix_from_basis_coefficients(
 
 
 def pow_pauli_combination(
-    ai: 'cirq.TParamValComplex',
-    ax: 'cirq.TParamValComplex',
-    ay: 'cirq.TParamValComplex',
-    az: 'cirq.TParamValComplex',
+    ai: cirq.TParamValComplex,
+    ax: cirq.TParamValComplex,
+    ay: cirq.TParamValComplex,
+    az: cirq.TParamValComplex,
     exponent: int,
 ) -> Tuple[
-    'cirq.TParamValComplex',
-    'cirq.TParamValComplex',
-    'cirq.TParamValComplex',
-    'cirq.TParamValComplex',
+    cirq.TParamValComplex, cirq.TParamValComplex, cirq.TParamValComplex, cirq.TParamValComplex
 ]:
     """Computes non-negative integer power of single-qubit Pauli combination.
 

cirq/ops/arithmetic_operation.py

@@ -13,6 +13,8 @@
 # limitations under the License.
 """Helper class for implementing classical arithmetic operations."""
 
+from __future__ import annotations
+
 import abc
 import itertools
 from typing import cast, Iterable, List, Sequence, Tuple, TYPE_CHECKING, Union
@@ -170,7 +172,7 @@ class ArithmeticGate(Gate, metaclass=abc.ABCMeta):
                     shape.append(i)
         return tuple(shape)
 
-    def _apply_unitary_(self, args: 'cirq.ApplyUnitaryArgs'):
+    def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs):
         registers = self.registers()
         input_ranges: List[Sequence[int]] = []
         shape: List[int] = []
@@ -231,7 +233,7 @@ class ArithmeticGate(Gate, metaclass=abc.ABCMeta):
 
 
 def _describe_bad_arithmetic_changed_const(
-    registers: Sequence[Union[int, Sequence[Union['cirq.Qid', int]]]],
+    registers: Sequence[Union[int, Sequence[Union[cirq.Qid, int]]]],
     inputs: List[int],
     outputs: List[int],
 ) -> str:

cirq/ops/boolean_hamiltonian.py

@@ -22,6 +22,9 @@ 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
@@ -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 = [
@@ -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:

cirq/ops/classically_controlled_operation.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 (
     AbstractSet,
     Any,
@@ -79,8 +82,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[Union[str, cirq.MeasurementKey, cirq.Condition, sympy.Basic]],
     ):
         """Initializes a `ClassicallyControlledOperation`.
 
@@ -106,7 +109,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 +118,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 +140,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: Optional[cirq.DecompositionContext] = None):
         result = protocols.decompose_once(
             self._sub_operation, NotImplemented, flatten=False, context=context
         )
@@ -168,14 +171,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
+    ) -> Optional[protocols.CircuitDiagramInfo]:
         sub_args = protocols.CircuitDiagramInfoArgs(
             known_qubit_count=args.known_qubit_count,
             known_qubits=args.known_qubits,
@@ -210,39 +213,39 @@ class ClassicallyControlledOperation(raw_types.Operation):
     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)
 
-    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)
 
     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) -> Optional[str]:
         args.validate_version('2.0', '3.0')
         if len(self._conditions) > 1:
             raise ValueError('QASM does not support multiple conditions.')