cirq-core 1.6.0.dev20250428201230__py3-none-any.whl → 1.6.0.dev20250429161116__py3-none-any.whl

cirq/testing/lin_alg_utils.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.
+
 """A testing class with utilities for checking linear algebra."""
 
+from __future__ import annotations
+
 from typing import Optional, TYPE_CHECKING
 
 import numpy as np
@@ -24,7 +27,7 @@ if TYPE_CHECKING:
 
 
 def random_superposition(
-    dim: int, *, random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None
+    dim: int, *, random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None
 ) -> np.ndarray:
     """Returns a random unit-length vector from the uniform distribution.
 
@@ -46,7 +49,7 @@ def random_superposition(
 
 
 def random_density_matrix(
-    dim: int, *, random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None
+    dim: int, *, random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None
 ) -> np.ndarray:
     """Returns a random density matrix distributed with Hilbert-Schmidt measure.
 
@@ -68,9 +71,7 @@ def random_density_matrix(
     return mat / np.trace(mat)
 
 
-def random_unitary(
-    dim: int, *, random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None
-) -> np.ndarray:
+def random_unitary(dim: int, *, random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None) -> np.ndarray:
     """Returns a random unitary matrix distributed with Haar measure.
 
     Args:
@@ -93,7 +94,7 @@ def random_unitary(
 
 
 def random_orthogonal(
-    dim: int, *, random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None
+    dim: int, *, random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None
 ) -> np.ndarray:
     """Returns a random orthogonal matrix distributed with Haar measure.
 
@@ -139,7 +140,7 @@ def random_special_unitary(
 
 
 def random_special_orthogonal(
-    dim: int, *, random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None
+    dim: int, *, random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None
 ) -> np.ndarray:
     """Returns a random special orthogonal matrix distributed with Haar measure.
 

cirq/testing/random_circuit.py

@@ -12,27 +12,28 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 from typing import Dict, List, Optional, Sequence, TYPE_CHECKING, Union
 
 from cirq import circuits, ops, value
 from cirq._doc import document
-from cirq.ops import Qid
 
 if TYPE_CHECKING:
     import cirq
 
 DEFAULT_GATE_DOMAIN: Dict[ops.Gate, int] = {
-    ops.CNOT: 2,
-    ops.CZ: 2,
-    ops.H: 1,
-    ops.ISWAP: 2,
+    ops.CNOT: 2,  # type: ignore[has-type]
+    ops.CZ: 2,  # type: ignore[has-type]
+    ops.H: 1,  # type: ignore[has-type]
+    ops.ISWAP: 2,  # type: ignore[has-type]
     ops.CZPowGate(): 2,
-    ops.S: 1,
-    ops.SWAP: 2,
-    ops.T: 1,
-    ops.X: 1,
-    ops.Y: 1,
-    ops.Z: 1,
+    ops.S: 1,  # type: ignore[has-type]
+    ops.SWAP: 2,  # type: ignore[has-type]
+    ops.T: 1,  # type: ignore[has-type]
+    ops.X: 1,  # type: ignore[has-type]
+    ops.Y: 1,  # type: ignore[has-type]
+    ops.Z: 1,  # type: ignore[has-type]
 }
 document(
     DEFAULT_GATE_DOMAIN,
@@ -45,11 +46,11 @@ and Z gates.
 
 
 def random_circuit(
-    qubits: Union[Sequence[ops.Qid], int],
+    qubits: Union[Sequence[cirq.Qid], int],
     n_moments: int,
     op_density: float,
     gate_domain: Optional[Dict[ops.Gate, int]] = None,
-    random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+    random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
 ) -> circuits.Circuit:
     """Generates a random circuit.
 
@@ -125,9 +126,9 @@ def random_circuit(
 
 def random_two_qubit_circuit_with_czs(
     num_czs: int = 3,
-    q0: Optional[Qid] = None,
-    q1: Optional[Qid] = None,
-    random_state: 'cirq.RANDOM_STATE_OR_SEED_LIKE' = None,
+    q0: Optional[cirq.Qid] = None,
+    q1: Optional[cirq.Qid] = None,
+    random_state: cirq.RANDOM_STATE_OR_SEED_LIKE = None,
 ) -> circuits.Circuit:
     """Creates a random two qubit circuit with the given number of CNOTs.
 

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/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/transformers/align.py

@@ -14,6 +14,8 @@
 
 """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
 
@@ -26,8 +28,8 @@ if TYPE_CHECKING:
 
 @transformer_api.transformer(add_deep_support=True)
 def align_left(
-    circuit: 'cirq.AbstractCircuit', *, context: Optional['cirq.TransformerContext'] = None
-) -> 'cirq.Circuit':
+    circuit: cirq.AbstractCircuit, *, context: Optional[cirq.TransformerContext] = None
+) -> cirq.Circuit:
     """Align gates to the left of the circuit.
 
     Note that tagged operations with tag in `context.tags_to_ignore` will continue to stay in their
@@ -58,8 +60,8 @@ def align_left(
 
 @transformer_api.transformer(add_deep_support=True)
 def align_right(
-    circuit: 'cirq.AbstractCircuit', *, context: Optional['cirq.TransformerContext'] = None
-) -> 'cirq.Circuit':
+    circuit: cirq.AbstractCircuit, *, context: Optional[cirq.TransformerContext] = None
+) -> cirq.Circuit:
     """Align gates to the right of the circuit.
 
     Note that tagged operations with tag in `context.tags_to_ignore` will continue to stay in their

cirq/transformers/analytical_decompositions/clifford_decomposition.py

@@ -14,6 +14,8 @@
 
 """Utility methods to decompose Clifford gates into circuits."""
 
+from __future__ import annotations
+
 import functools
 from typing import List, TYPE_CHECKING
 
@@ -29,7 +31,7 @@ def _X(
     q: int,
     args: sim.CliffordTableauSimulationState,
     operations: List[ops.Operation],
-    qubits: List['cirq.Qid'],
+    qubits: List[cirq.Qid],
 ):
     protocols.act_on(ops.X, args, qubits=[qubits[q]], allow_decompose=False)
     operations.append(ops.X(qubits[q]))
@@ -39,7 +41,7 @@ def _Z(
     q: int,
     args: sim.CliffordTableauSimulationState,
     operations: List[ops.Operation],
-    qubits: List['cirq.Qid'],
+    qubits: List[cirq.Qid],
 ):
     protocols.act_on(ops.Z, args, qubits=[qubits[q]], allow_decompose=False)
     operations.append(ops.Z(qubits[q]))
@@ -49,7 +51,7 @@ def _Sdg(
     q: int,
     args: sim.CliffordTableauSimulationState,
     operations: List[ops.Operation],
-    qubits: List['cirq.Qid'],
+    qubits: List[cirq.Qid],
 ):
     # Apply the tableau with S^\{dagger}
     protocols.act_on(ops.S**-1, args, qubits=[qubits[q]], allow_decompose=False)
@@ -60,7 +62,7 @@ def _H(
     q: int,
     args: sim.CliffordTableauSimulationState,
     operations: List[ops.Operation],
-    qubits: List['cirq.Qid'],
+    qubits: List[cirq.Qid],
 ):
     protocols.act_on(ops.H, args, qubits=[qubits[q]], allow_decompose=False)
     operations.append(ops.H(qubits[q]))
@@ -71,7 +73,7 @@ def _CNOT(
     q2: int,
     args: sim.CliffordTableauSimulationState,
     operations: List[ops.Operation],
-    qubits: List['cirq.Qid'],
+    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]))
@@ -82,14 +84,14 @@ def _SWAP(
     q2: int,
     args: sim.CliffordTableauSimulationState,
     operations: List[ops.Operation],
-    qubits: List['cirq.Qid'],
+    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
+    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.
 

cirq/transformers/analytical_decompositions/controlled_gate_decomposition.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 List, Tuple, TYPE_CHECKING
 
 import numpy as np
@@ -70,8 +72,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 +95,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 +113,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 +166,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 +192,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 +217,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/cphase_to_fsim.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 Optional, Sequence, Tuple, TYPE_CHECKING
 
 import numpy as np
@@ -32,7 +34,7 @@ def _asinsin(x: float) -> float:
 
 
 def compute_cphase_exponents_for_fsim_decomposition(
-    fsim_gate: 'cirq.FSimGate',
+    fsim_gate: cirq.FSimGate,
 ) -> Sequence[Tuple[float, float]]:
     """Returns intervals of CZPowGate exponents valid for FSim decomposition.
 
@@ -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: Optional[Sequence[cirq.Qid]] = 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/quantum_shannon_decomposition.py

@@ -12,13 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
 """Utility methods for decomposing arbitrary n-qubit (2^n x 2^n) unitary.
 
 Based on:
 Synthesis of Quantum Logic Circuits. Tech. rep. 2006,
 https://arxiv.org/abs/quant-ph/0406176
 """
+
+from __future__ import annotations
+
 from typing import Callable, Iterable, List, TYPE_CHECKING
 
 import numpy as np
@@ -40,8 +42,8 @@ if TYPE_CHECKING:
 
 
 def quantum_shannon_decomposition(
-    qubits: 'List[cirq.Qid]', u: np.ndarray, atol: float = 1e-8
-) -> Iterable['cirq.Operation']:
+    qubits: List[cirq.Qid], u: np.ndarray, atol: float = 1e-8
+) -> Iterable[cirq.Operation]:
     """Decomposes n-qubit unitary 1-q, 2-q and GlobalPhase gates, preserving global phase.
 
     The gates used are CX/YPow/ZPow/CNOT/GlobalPhase/CZ/PhasedXZGate/PhasedXPowGate.
@@ -139,7 +141,7 @@ def quantum_shannon_decomposition(
     yield from _msb_demuxer(qubits, u1, u2)
 
 
-def _single_qubit_decomposition(qubit: 'cirq.Qid', u: np.ndarray) -> Iterable['cirq.Operation']:
+def _single_qubit_decomposition(qubit: cirq.Qid, u: np.ndarray) -> Iterable[cirq.Operation]:
     """Decomposes single-qubit gate, and returns list of operations, keeping phase invariant.
 
     Args:
@@ -183,8 +185,8 @@ def _single_qubit_decomposition(qubit: 'cirq.Qid', u: np.ndarray) -> Iterable['c
 
 
 def _msb_demuxer(
-    demux_qubits: 'List[cirq.Qid]', u1: np.ndarray, u2: np.ndarray
-) -> Iterable['cirq.Operation']:
+    demux_qubits: List[cirq.Qid], u1: np.ndarray, u2: np.ndarray
+) -> Iterable[cirq.Operation]:
     """Demultiplexes a unitary matrix that is multiplexed in its most-significant-qubit.
 
     Decomposition structure:
@@ -246,8 +248,8 @@ def _nth_gray(n: int) -> int:
 
 
 def _multiplexed_cossin(
-    cossin_qubits: 'List[cirq.Qid]', angles: List[float], rot_func: Callable = ops.ry
-) -> Iterable['cirq.Operation']:
+    cossin_qubits: List[cirq.Qid], angles: List[float], rot_func: Callable = ops.ry
+) -> Iterable[cirq.Operation]:
     """Performs a multiplexed rotation over all qubits in this unitary matrix,
 
     Uses ry and rz multiplexing for quantum shannon decomposition

cirq/transformers/analytical_decompositions/single_to_two_qubit_isometry.py

@@ -13,6 +13,9 @@
 # limitations under the License.
 
 """Analytical decompositions for 2-qubit unitaries when one input qubit is in the |0> state."""
+
+from __future__ import annotations
+
 from typing import List, TYPE_CHECKING
 
 import numpy as np
@@ -25,13 +28,13 @@ if TYPE_CHECKING:
 
 
 def two_qubit_matrix_to_cz_isometry(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
+    q0: cirq.Qid,
+    q1: cirq.Qid,
     mat: np.ndarray,
     allow_partial_czs: bool = False,
     atol: float = 1e-8,
     clean_operations: bool = True,
-) -> List['cirq.Operation']:
+) -> List[cirq.Operation]:
     """Decomposes a 2q operation into at-most 2 CZs + 1q rotations; assuming `q0` is initially |0>.
 
     The method implements isometry from one to two qubits; assuming qubit `q0` is always in the |0>

cirq/transformers/analytical_decompositions/two_qubit_state_preparation.py

@@ -14,6 +14,8 @@
 
 """Utility methods for efficiently preparing two qubit states."""
 
+from __future__ import annotations
+
 from typing import List, TYPE_CHECKING
 
 import numpy as np
@@ -38,12 +40,8 @@ def _1q_matrices_to_ops(g0, g1, q0, q1, include_identity=False):
 
 
 def prepare_two_qubit_state_using_sqrt_iswap(
-    q0: 'cirq.Qid',
-    q1: 'cirq.Qid',
-    state: 'cirq.STATE_VECTOR_LIKE',
-    *,
-    use_sqrt_iswap_inv: bool = True,
-) -> List['cirq.Operation']:
+    q0: cirq.Qid, q1: cirq.Qid, state: cirq.STATE_VECTOR_LIKE, *, use_sqrt_iswap_inv: bool = True
+) -> List[cirq.Operation]:
     """Prepares the given 2q state from |00> using at-most 1 √iSWAP gate + single qubit rotations.
 
     Entangled states are prepared using exactly 1 √iSWAP gate while product states are prepared
@@ -77,8 +75,8 @@ def prepare_two_qubit_state_using_sqrt_iswap(
 
 
 def prepare_two_qubit_state_using_cz(
-    q0: 'cirq.Qid', q1: 'cirq.Qid', state: 'cirq.STATE_VECTOR_LIKE'
-) -> List['cirq.Operation']:
+    q0: cirq.Qid, q1: cirq.Qid, state: cirq.STATE_VECTOR_LIKE
+) -> List[cirq.Operation]:
     """Prepares the given 2q state from |00> using at-most 1 CZ gate + single qubit rotations.
 
     Entangled states are prepared using exactly 1 CZ gate while product states are prepared
@@ -110,8 +108,8 @@ def prepare_two_qubit_state_using_cz(
 
 
 def prepare_two_qubit_state_using_iswap(
-    q0: 'cirq.Qid', q1: 'cirq.Qid', state: 'cirq.STATE_VECTOR_LIKE', use_iswap_inv: bool = False
-) -> List['cirq.Operation']:
+    q0: cirq.Qid, q1: cirq.Qid, state: cirq.STATE_VECTOR_LIKE, use_iswap_inv: bool = False
+) -> List[cirq.Operation]:
     """Prepares the given 2q state from |00> using at-most 1 ISWAP gate + single qubit rotations.
 
     Entangled states are prepared using exactly 1 ISWAP gate while product states are prepared

{cirq_core-1.6.0.dev20250428201230.dist-info → cirq_core-1.6.0.dev20250429161116.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cirq-core
-Version: 1.6.0.dev20250428201230
+Version: 1.6.0.dev20250429161116
 Summary: A framework for creating, editing, and invoking Noisy Intermediate Scale Quantum (NISQ) circuits.
 Home-page: http://github.com/quantumlib/cirq
 Author: The Cirq Developers