cirq-core 1.4.0.dev20240529225110__py3-none-any.whl → 1.5.0__py3-none-any.whl

cirq/interop/quirk/cells/arithmetic_cells.py

@@ -13,22 +13,22 @@
 # limitations under the License.
 import inspect
 from typing import (
+    Any,
     Callable,
-    Optional,
-    Union,
+    cast,
+    Dict,
     Iterable,
-    Sequence,
     Iterator,
-    Tuple,
-    Any,
-    cast,
     List,
-    Dict,
+    Optional,
+    Sequence,
+    Tuple,
     TYPE_CHECKING,
+    Union,
 )
 
 from cirq import ops, value
-from cirq.interop.quirk.cells.cell import Cell, CellMaker, CELL_SIZES
+from cirq.interop.quirk.cells.cell import Cell, CELL_SIZES, CellMaker
 
 if TYPE_CHECKING:
     import cirq

cirq/interop/quirk/cells/arithmetic_cells_test.py

@@ -17,9 +17,9 @@ import numpy as np
 import pytest
 
 import cirq
+from cirq import quirk_url_to_circuit
 from cirq.interop.quirk.cells import arithmetic_cells
 from cirq.interop.quirk.cells.testing import assert_url_to_circuit_returns
-from cirq import quirk_url_to_circuit
 
 
 def test_arithmetic_comparison_gates():

cirq/interop/quirk/cells/cell.py

@@ -13,20 +13,20 @@
 # limitations under the License.
 import abc
 from typing import (
+    Any,
     Callable,
-    Optional,
+    Dict,
+    Iterable,
     List,
     NamedTuple,
-    Any,
-    Iterable,
+    Optional,
     Sequence,
+    Tuple,
     TYPE_CHECKING,
     Union,
-    Dict,
-    Tuple,
 )
 
-from cirq import ops, value, devices
+from cirq import devices, ops, value
 
 if TYPE_CHECKING:
     import cirq

cirq/interop/quirk/cells/composite_cell.py

@@ -13,16 +13,16 @@
 # limitations under the License.
 
 from typing import (
-    List,
-    TYPE_CHECKING,
     Callable,
-    Optional,
-    Iterator,
     cast,
     Iterable,
+    Iterator,
+    List,
+    Optional,
+    Sequence,
+    TYPE_CHECKING,
     TypeVar,
     Union,
-    Sequence,
 )
 
 from cirq import circuits

cirq/interop/quirk/cells/composite_cell_test.py

@@ -16,8 +16,8 @@ import pytest
 
 import cirq
 from cirq import quirk_json_to_circuit
-from cirq.interop.quirk.cells.testing import assert_url_to_circuit_returns
 from cirq.interop.quirk.cells.composite_cell import _iterator_to_iterable
+from cirq.interop.quirk.cells.testing import assert_url_to_circuit_returns
 
 
 def test_iterator_to_iterable():

cirq/interop/quirk/cells/control_cells.py

@@ -109,7 +109,7 @@ class ParityControlCell(Cell):
             elif gate is not None:
                 column[i] = gate.controlled_by(self.qubits[0])
 
-    def basis_change(self) -> 'cirq.OP_TREE':
+    def basis_change(self) -> Iterator['cirq.OP_TREE']:
         yield from self._basis_change
 
         # Temporarily move the ZZZ..Z parity observable onto a single qubit.

cirq/interop/quirk/cells/frequency_space_cells.py

@@ -11,12 +11,12 @@
 # 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 Iterator, Callable
+from typing import Callable, Iterator
 
 import sympy
 
 import cirq
-from cirq.interop.quirk.cells.cell import CellMaker, CELL_SIZES, ExplicitOperationsCell
+from cirq.interop.quirk.cells.cell import CELL_SIZES, CellMaker, ExplicitOperationsCell
 
 
 def generate_all_frequency_space_cell_makers() -> Iterator[CellMaker]:

cirq/interop/quirk/cells/ignored_cells.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 from typing import Iterator
 
-from cirq.interop.quirk.cells.cell import CellMaker, CELL_SIZES
+from cirq.interop.quirk.cells.cell import CELL_SIZES, CellMaker
 
 
 def generate_all_ignored_cell_makers() -> Iterator[CellMaker]:

cirq/interop/quirk/cells/input_cells.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Optional, List, Iterator, Iterable, TYPE_CHECKING
+from typing import Iterable, Iterator, List, Optional, TYPE_CHECKING
 
 from cirq.interop.quirk.cells.cell import Cell, CELL_SIZES, CellMaker
 

cirq/interop/quirk/cells/input_cells_test.py

@@ -15,8 +15,8 @@
 import pytest
 
 from cirq import quirk_url_to_circuit
-from cirq.interop.quirk.cells.testing import assert_url_to_circuit_returns
 from cirq.interop.quirk.cells.input_cells import SetDefaultInputCell
+from cirq.interop.quirk.cells.testing import assert_url_to_circuit_returns
 
 
 def test_missing_input_cell():

cirq/interop/quirk/cells/input_rotation_cells.py

@@ -17,7 +17,7 @@ from typing import Any, Iterable, Iterator, List, Optional, Sequence, Tuple, Uni
 import numpy as np
 
 import cirq
-from cirq import ops, linalg, value
+from cirq import linalg, ops, value
 from cirq.interop.quirk.cells.cell import Cell, CellMaker
 
 

cirq/interop/quirk/cells/input_rotation_cells_test.py

@@ -16,8 +16,8 @@ import numpy as np
 import pytest
 
 import cirq
-from cirq.interop.quirk.cells.testing import assert_url_to_circuit_returns
 from cirq import quirk_url_to_circuit
+from cirq.interop.quirk.cells.testing import assert_url_to_circuit_returns
 
 
 def test_input_rotation_cells():

cirq/interop/quirk/cells/measurement_cells.py

@@ -11,7 +11,7 @@
 # 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 Iterator, Optional, cast, Iterable, TYPE_CHECKING
+from typing import cast, Iterable, Iterator, Optional, TYPE_CHECKING
 
 from cirq import ops
 from cirq.interop.quirk.cells.cell import CellMaker, ExplicitOperationsCell

cirq/interop/quirk/cells/parse.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import cmath
+import re
 from typing import (
     Any,
     Callable,
@@ -22,14 +24,11 @@ from typing import (
     List,
     Mapping,
     Optional,
-    Union,
     SupportsFloat,
     TypeVar,
+    Union,
 )
 
-import cmath
-import re
-
 import numpy as np
 import sympy
 
@@ -86,7 +85,7 @@ def _tokenize(text: str) -> List[str]:
     return _merge_scientific_float_tokens(g for g in result if g.strip())
 
 
-_ResolvedToken = Union[sympy.Expr, int, float, complex]
+_ResolvedToken = Union[sympy.Expr, complex]
 
 
 class _CustomQuirkOperationToken:
@@ -154,7 +153,7 @@ def _parse_formula_using_token_map(
         a = vals.pop()
         # Note: vals seems to be _HangingToken
         # func operates on _ResolvedTokens. Ignoring type issues for now.
-        vals.append(op.func(a, b))  # type: ignore[arg-type]
+        vals.append(op.func(a, b))
 
     def close_paren() -> None:
         while True:
@@ -191,7 +190,9 @@ def _parse_formula_using_token_map(
             elif token.unary_action is not None:
                 burn_ops(token.priority)
                 vals.append(None)
-                ops.append(_HangingNode(func=lambda _, b: token.unary_action(b), weight=np.inf))
+                # this avoids mypy complaint about None not being callable
+                token_unary_action = token.unary_action
+                ops.append(_HangingNode(func=lambda _, b: token_unary_action(b), weight=np.inf))
             elif token.binary_action is not None:
                 raise ValueError("Bad expression: binary op in bad spot.\ntext={text!r}")
 

cirq/interop/quirk/cells/parse_test.py

@@ -16,7 +16,7 @@ import numpy as np
 import pytest
 import sympy
 
-from cirq.interop.quirk.cells.parse import parse_matrix, parse_formula, parse_complex
+from cirq.interop.quirk.cells.parse import parse_complex, parse_formula, parse_matrix
 
 
 def test_parse_matrix():
@@ -102,7 +102,7 @@ def test_parse_complex_raw_cases_from_quirk():
 
     assert parse_complex("3/2i") == 1.5j
 
-    assert parse_complex("\u221A2-\u2153i") == np.sqrt(2) - 1j / 3
+    assert parse_complex("\u221a2-\u2153i") == np.sqrt(2) - 1j / 3
 
     assert parse_complex("1e-10") == 0.0000000001
     assert parse_complex("1e+10") == 10000000000

cirq/interop/quirk/cells/single_qubit_rotation_cells.py

@@ -11,7 +11,7 @@
 # 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 Iterator, Callable, TYPE_CHECKING
+from typing import Callable, Iterator, TYPE_CHECKING
 
 import sympy
 

cirq/interop/quirk/cells/swap_cell_test.py

@@ -15,8 +15,8 @@
 import pytest
 
 import cirq
-from cirq.interop.quirk.cells.testing import assert_url_to_circuit_returns
 from cirq import quirk_url_to_circuit
+from cirq.interop.quirk.cells.testing import assert_url_to_circuit_returns
 
 
 def test_swap():

cirq/interop/quirk/cells/unsupported_cells.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 from typing import Iterator
 
-from cirq.interop.quirk.cells.cell import CellMaker, CELL_SIZES
+from cirq.interop.quirk.cells.cell import CELL_SIZES, CellMaker
 
 
 def generate_all_unsupported_cell_makers() -> Iterator[CellMaker]:

cirq/interop/quirk/url_to_circuit.py

@@ -15,28 +15,28 @@ import json
 import urllib.parse
 from typing import (
     Any,
-    List,
+    cast,
     Dict,
+    Iterable,
+    List,
+    Mapping,
     Optional,
     Sequence,
-    cast,
+    Tuple,
     TYPE_CHECKING,
-    Iterable,
     Union,
-    Mapping,
-    Tuple,
 )
 
 import numpy as np
 
-from cirq import devices, circuits, ops, protocols
+from cirq import circuits, devices, ops, protocols
 from cirq.interop.quirk.cells import (
     Cell,
     CellMaker,
     CellMakerArgs,
     CompositeCell,
-    generate_all_quirk_cell_makers,
     ExplicitOperationsCell,
+    generate_all_quirk_cell_makers,
 )
 from cirq.interop.quirk.cells.parse import parse_matrix
 

cirq/interop/quirk/url_to_circuit_test.py

@@ -18,7 +18,7 @@ import numpy as np
 import pytest
 
 import cirq
-from cirq import quirk_url_to_circuit, quirk_json_to_circuit
+from cirq import quirk_json_to_circuit, quirk_url_to_circuit
 from cirq.interop.quirk.cells.testing import assert_url_to_circuit_returns
 
 

cirq/ion/__init__.py

@@ -14,6 +14,8 @@
 
 """Trapped ion devices, gates, and compiling utilties."""
 
-from cirq.ops import ms
+from cirq.ops import ms as ms
 
-from cirq.transformers import two_qubit_matrix_to_ion_operations
+from cirq.transformers import (
+    two_qubit_matrix_to_ion_operations as two_qubit_matrix_to_ion_operations,
+)

cirq/json_resolver_cache.py

@@ -20,8 +20,8 @@ from cirq.protocols.json_serialization import ObjectFactory
 
 if TYPE_CHECKING:
     import cirq
-    import cirq.ops.pauli_gates
     import cirq.devices.unconstrained_device
+    import cirq.ops.pauli_gates
 
 
 # Needed for backwards compatible named tuples of CrossEntropyResult
@@ -42,14 +42,14 @@ CrossEntropyResultDict = NamedTuple(
 
 @functools.lru_cache()
 def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
-    import cirq
-    from cirq.ops import raw_types
-    import pandas as pd
     import numpy as np
-    from cirq.devices.noise_model import _NoNoiseModel
+    import pandas as pd
+
+    import cirq
     from cirq.devices import InsertionNoiseModel
+    from cirq.devices.noise_model import _NoNoiseModel
     from cirq.experiments import GridInteractionLayer
-    from cirq.experiments.grid_parallel_two_qubit_xeb import GridParallelXEBMetadata
+    from cirq.ops import raw_types
 
     def _boolean_hamiltonian_gate_op(qubit_map, boolean_strs, theta):
         return cirq.BooleanHamiltonianGate(
@@ -107,6 +107,7 @@ def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
         'AnyUnitaryGateFamily': cirq.AnyUnitaryGateFamily,
         'AsymmetricDepolarizingChannel': cirq.AsymmetricDepolarizingChannel,
         'BitFlipChannel': cirq.BitFlipChannel,
+        'BitMaskKeyCondition': cirq.BitMaskKeyCondition,
         'BitstringAccumulator': cirq.work.BitstringAccumulator,
         'BooleanHamiltonianGate': cirq.BooleanHamiltonianGate,
         'CCNotPowGate': cirq.CCNotPowGate,
@@ -120,6 +121,7 @@ def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
         'CliffordState': cirq.CliffordState,
         'CliffordTableau': cirq.CliffordTableau,
         'CNotPowGate': cirq.CNotPowGate,
+        'Concat': cirq.Concat,
         'ConstantQubitNoiseModel': cirq.ConstantQubitNoiseModel,
         'ControlledGate': cirq.ControlledGate,
         'ControlledOperation': cirq.ControlledOperation,
@@ -141,7 +143,6 @@ def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
         'GlobalPhaseGate': cirq.GlobalPhaseGate,
         'GridDeviceMetadata': cirq.GridDeviceMetadata,
         'GridInteractionLayer': GridInteractionLayer,
-        'GridParallelXEBMetadata': GridParallelXEBMetadata,
         'GridQid': cirq.GridQid,
         'GridQubit': cirq.GridQubit,
         'HPowGate': cirq.HPowGate,
@@ -149,6 +150,7 @@ def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
         'IdentityGate': cirq.IdentityGate,
         'InitObsSetting': cirq.work.InitObsSetting,
         'InsertionNoiseModel': InsertionNoiseModel,
+        '_InverseCompositeGate': raw_types._InverseCompositeGate,
         'KeyCondition': cirq.KeyCondition,
         'KrausChannel': cirq.KrausChannel,
         'LinearDict': cirq.LinearDict,
@@ -272,6 +274,12 @@ def _class_resolver_dictionary() -> Dict[str, ObjectFactory]:
         'sympy.StrictLessThan': lambda args: sympy.StrictLessThan(*args),
         'sympy.Equality': lambda args: sympy.Equality(*args),
         'sympy.Unequality': lambda args: sympy.Unequality(*args),
+        'sympy.And': lambda args: sympy.And(*args),
+        'sympy.Or': lambda args: sympy.Or(*args),
+        'sympy.Not': lambda args: sympy.Not(*args),
+        'sympy.Xor': lambda args: sympy.Xor(*args),
+        'sympy.Indexed': lambda args: sympy.Indexed(*args),
+        'sympy.IndexedBase': lambda args: sympy.IndexedBase(*args),
         'sympy.Float': lambda approx: sympy.Float(approx),
         'sympy.Integer': sympy.Integer,
         'sympy.Rational': sympy.Rational,

cirq/linalg/__init__.py

@@ -17,70 +17,81 @@ Focuses on methods useful for analyzing and optimizing quantum circuits.
 Avoids duplicating functionality present in numpy.
 """
 
-from cirq.linalg.combinators import block_diag, CONTROL_TAG, dot, kron, kron_with_controls
+from cirq.linalg.combinators import (
+    block_diag as block_diag,
+    CONTROL_TAG as CONTROL_TAG,
+    dot as dot,
+    kron as kron,
+    kron_with_controls as kron_with_controls,
+)
 
 from cirq.linalg.decompositions import (
-    axis_angle,
-    AxisAngleDecomposition,
-    deconstruct_single_qubit_matrix_into_angles,
-    extract_right_diag,
-    kak_canonicalize_vector,
-    kak_decomposition,
-    kak_vector,
-    KakDecomposition,
-    kron_factor_4x4_to_2x2s,
-    map_eigenvalues,
-    num_cnots_required,
-    unitary_eig,
-    scatter_plot_normalized_kak_interaction_coefficients,
-    so4_to_magic_su2s,
+    # pylint: disable=line-too-long
+    axis_angle as axis_angle,
+    AxisAngleDecomposition as AxisAngleDecomposition,
+    deconstruct_single_qubit_matrix_into_angles as deconstruct_single_qubit_matrix_into_angles,
+    extract_right_diag as extract_right_diag,
+    kak_canonicalize_vector as kak_canonicalize_vector,
+    kak_decomposition as kak_decomposition,
+    kak_vector as kak_vector,
+    KakDecomposition as KakDecomposition,
+    kron_factor_4x4_to_2x2s as kron_factor_4x4_to_2x2s,
+    map_eigenvalues as map_eigenvalues,
+    num_cnots_required as num_cnots_required,
+    unitary_eig as unitary_eig,
+    scatter_plot_normalized_kak_interaction_coefficients as scatter_plot_normalized_kak_interaction_coefficients,
+    so4_to_magic_su2s as so4_to_magic_su2s,
 )
 
-
 from cirq.linalg.diagonalize import (
-    bidiagonalize_real_matrix_pair_with_symmetric_products,
-    bidiagonalize_unitary_with_special_orthogonals,
-    diagonalize_real_symmetric_and_sorted_diagonal_matrices,
-    diagonalize_real_symmetric_matrix,
+    # pylint: disable=line-too-long
+    bidiagonalize_real_matrix_pair_with_symmetric_products as bidiagonalize_real_matrix_pair_with_symmetric_products,
+    bidiagonalize_unitary_with_special_orthogonals as bidiagonalize_unitary_with_special_orthogonals,
+    diagonalize_real_symmetric_and_sorted_diagonal_matrices as diagonalize_real_symmetric_and_sorted_diagonal_matrices,
+    diagonalize_real_symmetric_matrix as diagonalize_real_symmetric_matrix,
 )
 
 from cirq.linalg.operator_spaces import (
-    expand_matrix_in_orthogonal_basis,
-    hilbert_schmidt_inner_product,
-    kron_bases,
-    matrix_from_basis_coefficients,
-    PAULI_BASIS,
-    pow_pauli_combination,
+    expand_matrix_in_orthogonal_basis as expand_matrix_in_orthogonal_basis,
+    hilbert_schmidt_inner_product as hilbert_schmidt_inner_product,
+    kron_bases as kron_bases,
+    matrix_from_basis_coefficients as matrix_from_basis_coefficients,
+    PAULI_BASIS as PAULI_BASIS,
+    pow_pauli_combination as pow_pauli_combination,
 )
 
 from cirq.linalg.predicates import (
-    allclose_up_to_global_phase,
-    is_cptp,
-    is_diagonal,
-    is_hermitian,
-    is_normal,
-    is_orthogonal,
-    is_special_orthogonal,
-    is_special_unitary,
-    is_unitary,
-    matrix_commutes,
-    slice_for_qubits_equal_to,
+    allclose_up_to_global_phase as allclose_up_to_global_phase,
+    is_cptp as is_cptp,
+    is_diagonal as is_diagonal,
+    is_hermitian as is_hermitian,
+    is_normal as is_normal,
+    is_orthogonal as is_orthogonal,
+    is_special_orthogonal as is_special_orthogonal,
+    is_special_unitary as is_special_unitary,
+    is_unitary as is_unitary,
+    matrix_commutes as matrix_commutes,
+    slice_for_qubits_equal_to as slice_for_qubits_equal_to,
 )
 
-from cirq.linalg.tolerance import all_near_zero, all_near_zero_mod
+from cirq.linalg.tolerance import (
+    all_near_zero as all_near_zero,
+    all_near_zero_mod as all_near_zero_mod,
+)
 
 from cirq.linalg.transformations import (
-    apply_matrix_to_slices,
-    density_matrix_kronecker_product,
-    match_global_phase,
-    partial_trace,
-    partial_trace_of_state_vector_as_mixture,
-    reflection_matrix_pow,
-    state_vector_kronecker_product,
-    sub_state_vector,
-    targeted_conjugate_about,
-    targeted_left_multiply,
-    to_special,
-    transpose_flattened_array,
-    can_numpy_support_shape,
+    apply_matrix_to_slices as apply_matrix_to_slices,
+    density_matrix_kronecker_product as density_matrix_kronecker_product,
+    can_numpy_support_shape as can_numpy_support_shape,
+    match_global_phase as match_global_phase,
+    partial_trace as partial_trace,
+    partial_trace_of_state_vector_as_mixture as partial_trace_of_state_vector_as_mixture,
+    phase_delta as phase_delta,
+    reflection_matrix_pow as reflection_matrix_pow,
+    state_vector_kronecker_product as state_vector_kronecker_product,
+    sub_state_vector as sub_state_vector,
+    targeted_conjugate_about as targeted_conjugate_about,
+    targeted_left_multiply as targeted_left_multiply,
+    to_special as to_special,
+    transpose_flattened_array as transpose_flattened_array,
 )

cirq/linalg/combinators.py

@@ -15,17 +15,17 @@
 """Utility methods for combining matrices."""
 
 import functools
-from typing import Union, TYPE_CHECKING
+from typing import TYPE_CHECKING, Union
 
 import numpy as np
 
 from cirq._doc import document
 
 if TYPE_CHECKING:
-    from numpy.typing import DTypeLike, ArrayLike
+    from numpy.typing import ArrayLike, DTypeLike
 
 
-def kron(*factors: Union[np.ndarray, complex, float], shape_len: int = 2) -> np.ndarray:
+def kron(*factors: Union[np.ndarray, complex], shape_len: int = 2) -> np.ndarray:
     """Computes the kronecker product of a sequence of values.
 
     A *args version of lambda args: functools.reduce(np.kron, args).
@@ -56,7 +56,7 @@ document(
 )
 
 
-def kron_with_controls(*factors: Union[np.ndarray, complex, float]) -> np.ndarray:
+def kron_with_controls(*factors: Union[np.ndarray, complex]) -> np.ndarray:
     """Computes the kronecker product of a sequence of values and control tags.
 
     Use `cirq.CONTROL_TAG` to represent controls. Any entry of the output

cirq/linalg/combinators_test.py

@@ -11,8 +11,8 @@
 # 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.
-import pytest
 import numpy as np
+import pytest
 
 import cirq
 
@@ -104,6 +104,9 @@ def test_block_diag():
         ),
     )
 
+    with pytest.raises(ValueError, match='Blocks must be square'):
+        _ = cirq.block_diag(np.array([[1, 2, 3], [3, 4, 5]]))
+
 
 def test_block_diag_dtype():
     assert cirq.block_diag().dtype == np.complex128