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

cirq/protocols/equal_up_to_global_phase_protocol.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import numbers
 from collections.abc import Iterable
 from typing import Any

cirq/protocols/equal_up_to_global_phase_protocol_test.py

@@ -11,12 +11,15 @@
 # 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 cirq
 
 
-def test_equal_up_to_global_phase_primitives():
+def test_equal_up_to_global_phase_primitives() -> None:
     assert cirq.equal_up_to_global_phase(1.0 + 1j, 1.0 + 1j, atol=1e-9)
     assert not cirq.equal_up_to_global_phase(2.0, 1.0 + 1j, atol=1e-9)
     assert cirq.equal_up_to_global_phase(1.0 + 1j, 1.0 - 1j, atol=1e-9)
@@ -34,7 +37,7 @@ def test_equal_up_to_global_phase_primitives():
     assert cirq.equal_up_to_global_phase(1.0 + 1e-10j, 1.0, atol=1e-15)
 
 
-def test_equal_up_to_global_numeric_iterables():
+def test_equal_up_to_global_numeric_iterables() -> None:
     assert cirq.equal_up_to_global_phase([], [], atol=1e-9)
     assert cirq.equal_up_to_global_phase([[]], [[]], atol=1e-9)
     assert cirq.equal_up_to_global_phase([1j, 1], [1j, 1], atol=1e-9)
@@ -49,7 +52,7 @@ def test_equal_up_to_global_numeric_iterables():
     assert not cirq.equal_up_to_global_phase((1j, 1), (1, 1j), atol=1e-09)
 
 
-def test_equal_up_to_global_numpy_array():
+def test_equal_up_to_global_numpy_array() -> None:
     assert cirq.equal_up_to_global_phase(
         np.asarray([1j, 1j]), np.asarray([1, 1], dtype=np.complex64)
     )
@@ -60,7 +63,7 @@ def test_equal_up_to_global_numpy_array():
     assert cirq.equal_up_to_global_phase(np.asarray([[]]), np.asarray([[]]))
 
 
-def test_equal_up_to_global_mixed_array_types():
+def test_equal_up_to_global_mixed_array_types() -> None:
     a = [1j, 1, -1j, -1]
     b = [-1, 1j, 1, -1j]
     c = [-1, 1, -1, 1]
@@ -108,7 +111,7 @@ class B:
         return cirq.equal_up_to_global_phase(self.val[0], other, atol=atol)
 
 
-def test_equal_up_to_global_phase_eq_supported():
+def test_equal_up_to_global_phase_eq_supported() -> None:
     assert cirq.equal_up_to_global_phase(A(0.1 + 0j), A(0.1j), atol=1e-2)
     assert not cirq.equal_up_to_global_phase(A(0.0 + 0j), A(0.1j), atol=0.0)
     assert not cirq.equal_up_to_global_phase(A(0.0 + 0j), 0.1j, atol=0.0)
@@ -120,7 +123,7 @@ def test_equal_up_to_global_phase_eq_supported():
     assert not cirq.equal_up_to_global_phase(1e-8j, B(0.0), atol=1e-10)
 
 
-def test_equal_up_to_global_phase_non_eigen_gates():
+def test_equal_up_to_global_phase_non_eigen_gates() -> None:
     gate1 = cirq.PhasedXPowGate(phase_exponent=1.5, exponent=1.0)
     gate2 = cirq.PhasedXPowGate(phase_exponent=0.5, exponent=1.0)
     assert cirq.equal_up_to_global_phase(gate1, gate2)

cirq/protocols/has_stabilizer_effect_protocol.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Optional
+from __future__ import annotations
+
+from typing import Any
 
 import cirq.protocols.decompose_protocol as decompose_protocol
 import cirq.protocols.has_unitary_protocol as has_unitary_protocol
@@ -50,7 +52,7 @@ def has_stabilizer_effect(val: Any) -> bool:
     return False
 
 
-def _strat_has_stabilizer_effect_from_has_stabilizer_effect(val: Any) -> Optional[bool]:
+def _strat_has_stabilizer_effect_from_has_stabilizer_effect(val: Any) -> bool | None:
     """Infer whether val has stabilizer effect via its `_has_stabilizer_effect_` method."""
     if hasattr(val, '_has_stabilizer_effect_'):
         result = val._has_stabilizer_effect_()
@@ -59,14 +61,14 @@ def _strat_has_stabilizer_effect_from_has_stabilizer_effect(val: Any) -> Optiona
     return None
 
 
-def _strat_has_stabilizer_effect_from_gate(val: Any) -> Optional[bool]:
+def _strat_has_stabilizer_effect_from_gate(val: Any) -> bool | None:
     """Infer whether val's gate has stabilizer effect via the _has_stabilizer_effect_ method."""
     if hasattr(val, 'gate'):
         return _strat_has_stabilizer_effect_from_has_stabilizer_effect(val.gate)
     return None
 
 
-def _strat_has_stabilizer_effect_from_unitary(val: Any) -> Optional[bool]:
+def _strat_has_stabilizer_effect_from_unitary(val: Any) -> bool | None:
     """Attempts to infer whether val has stabilizer effect from its unitary.
 
     Returns whether unitary of `val` normalizes the Pauli group. Works only for
@@ -101,7 +103,7 @@ def _strat_has_stabilizer_effect_from_unitary(val: Any) -> Optional[bool]:
     return True
 
 
-def _strat_has_stabilizer_effect_from_decompose(val: Any) -> Optional[bool]:
+def _strat_has_stabilizer_effect_from_decompose(val: Any) -> bool | None:
     decomposition, _, _ = decompose_protocol._try_decompose_into_operations_and_qubits(val)
     if decomposition is None:
         return None

cirq/protocols/has_stabilizer_effect_protocol_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 cirq
@@ -105,7 +107,7 @@ class GateDecomposes(cirq.Gate):
         yield YesOp(*qubits)
 
 
-def test_inconclusive():
+def test_inconclusive() -> None:
     assert not cirq.has_stabilizer_effect(object())
     assert not cirq.has_stabilizer_effect('boo')
     assert not cirq.has_stabilizer_effect(cirq.testing.SingleQubitGate())
@@ -113,21 +115,21 @@ def test_inconclusive():
     assert not cirq.has_stabilizer_effect(NoOp())
 
 
-def test_via_has_stabilizer_effect_method():
+def test_via_has_stabilizer_effect_method() -> None:
     assert not cirq.has_stabilizer_effect(No1())
     assert not cirq.has_stabilizer_effect(No2())
     assert not cirq.has_stabilizer_effect(No3())
     assert cirq.has_stabilizer_effect(Yes())
 
 
-def test_via_gate_of_op():
+def test_via_gate_of_op() -> None:
     assert cirq.has_stabilizer_effect(YesOp())
     assert not cirq.has_stabilizer_effect(NoOp1())
     assert not cirq.has_stabilizer_effect(NoOp2())
     assert not cirq.has_stabilizer_effect(NoOp3())
 
 
-def test_via_unitary():
+def test_via_unitary() -> None:
     op1 = OpWithUnitary(np.array([[0, 1], [1, 0]]))
     assert cirq.has_stabilizer_effect(op1)
 
@@ -148,7 +150,7 @@ def test_via_unitary():
     assert not cirq.has_stabilizer_effect(cirq.CCZ)
 
 
-def test_via_decompose():
+def test_via_decompose() -> None:
     assert cirq.has_stabilizer_effect(cirq.Circuit(cirq.H.on_each(cirq.LineQubit.range(4))))
     assert not cirq.has_stabilizer_effect(cirq.Circuit(cirq.T.on_each(cirq.LineQubit.range(4))))
     assert not cirq.has_stabilizer_effect(

cirq/protocols/has_unitary_protocol.py

@@ -12,12 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Optional, TypeVar
+from __future__ import annotations
+
+from typing import Any, TypeVar
 
 import numpy as np
 from typing_extensions import Protocol
 
-from cirq import qis
+from cirq import linalg, qis
 from cirq._doc import doc_private
 from cirq.protocols import qid_shape_protocol
 from cirq.protocols.apply_unitary_protocol import ApplyUnitaryArgs
@@ -108,8 +110,10 @@ def has_unitary(val: Any, *, allow_decompose: bool = True) -> bool:
     return False
 
 
-def _strat_has_unitary_from_has_unitary(val: Any) -> Optional[bool]:
+def _strat_has_unitary_from_has_unitary(val: Any) -> bool | None:
     """Attempts to infer a value's unitary-ness via its _has_unitary_ method."""
+    if isinstance(val, np.ndarray):
+        return linalg.is_unitary(val)
     if hasattr(val, '_has_unitary_'):
         result = val._has_unitary_()
         if result is NotImplemented:
@@ -118,7 +122,7 @@ def _strat_has_unitary_from_has_unitary(val: Any) -> Optional[bool]:
     return None
 
 
-def _strat_has_unitary_from_unitary(val: Any) -> Optional[bool]:
+def _strat_has_unitary_from_unitary(val: Any) -> bool | None:
     """Attempts to infer a value's unitary-ness via its _unitary_ method."""
     getter = getattr(val, '_unitary_', None)
     if getter is None:
@@ -127,7 +131,7 @@ def _strat_has_unitary_from_unitary(val: Any) -> Optional[bool]:
     return result is not NotImplemented and result is not None
 
 
-def _strat_has_unitary_from_decompose(val: Any) -> Optional[bool]:
+def _strat_has_unitary_from_decompose(val: Any) -> bool | None:
     """Attempts to infer a value's unitary-ness via its _decompose_ method."""
     operations, _, _ = _try_decompose_into_operations_and_qubits(val)
     if operations is None:
@@ -135,7 +139,7 @@ def _strat_has_unitary_from_decompose(val: Any) -> Optional[bool]:
     return all(has_unitary(op) for op in operations)
 
 
-def _strat_has_unitary_from_apply_unitary(val: Any) -> Optional[bool]:
+def _strat_has_unitary_from_apply_unitary(val: Any) -> bool | None:
     """Attempts to infer a value's unitary-ness via its _apply_unitary_ method."""
     method = getattr(val, '_apply_unitary_', None)
     if method is None:

cirq/protocols/has_unitary_protocol_test.py

@@ -12,13 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import numpy as np
 import pytest
 
 import cirq
 
 
-def test_inconclusive():
+def test_inconclusive() -> None:
     class No:
         pass
 
@@ -30,7 +32,7 @@ def test_inconclusive():
 @pytest.mark.parametrize(
     'measurement_gate', (cirq.MeasurementGate(1, 'a'), cirq.PauliMeasurementGate([cirq.X], 'a'))
 )
-def test_fail_fast_measure(measurement_gate):
+def test_fail_fast_measure(measurement_gate) -> None:
     assert not cirq.has_unitary(measurement_gate)
 
     qubit = cirq.NamedQubit('q0')
@@ -40,13 +42,13 @@ def test_fail_fast_measure(measurement_gate):
     assert not cirq.has_unitary(circuit)
 
 
-def test_fail_fast_measure_large_memory():
+def test_fail_fast_measure_large_memory() -> None:
     num_qubits = 100
     measurement_op = cirq.MeasurementGate(num_qubits, 'a').on(*cirq.LineQubit.range(num_qubits))
     assert not cirq.has_unitary(measurement_op)
 
 
-def test_via_unitary():
+def test_via_unitary() -> None:
     class No1:
         def _unitary_(self):
             return NotImplemented
@@ -59,13 +61,16 @@ def test_via_unitary():
         def _unitary_(self):
             return np.array([[1]])
 
+    m = np.diag([1, -1])
     assert not cirq.has_unitary(No1())
     assert not cirq.has_unitary(No2())
+    assert not cirq.has_unitary(m * 2)
     assert cirq.has_unitary(Yes())
     assert cirq.has_unitary(Yes(), allow_decompose=False)
+    assert cirq.has_unitary(m)
 
 
-def test_via_apply_unitary():
+def test_via_apply_unitary() -> None:
     class No1(EmptyOp):
         def _apply_unitary_(self, args):
             return None
@@ -100,7 +105,7 @@ def test_via_apply_unitary():
     assert not cirq.has_unitary(No4())
 
 
-def test_via_decompose():
+def test_via_decompose() -> None:
     class Yes1:
         def _decompose_(self):
             return []
@@ -132,7 +137,7 @@ def test_via_decompose():
     assert not cirq.has_unitary(No1(), allow_decompose=False)
 
 
-def test_via_has_unitary():
+def test_via_has_unitary() -> None:
     class No1:
         def _has_unitary_(self):
             return NotImplemented
@@ -150,7 +155,7 @@ def test_via_has_unitary():
     assert cirq.has_unitary(Yes())
 
 
-def test_order():
+def test_order() -> None:
     class Yes1(EmptyOp):
         def _has_unitary_(self):
             return True

cirq/protocols/hash_from_pickle_test.py

@@ -50,13 +50,6 @@ _EXCLUDE_JSON_FILES = (
     "cirq/protocols/json_test_data/sympy.Indexed.json",
     "cirq/protocols/json_test_data/sympy.IndexedBase.json",
     "cirq/protocols/json_test_data/sympy.pi.json",
-    # Cirq-Rigetti is deprecated per #7058
-    # Instead of handling deprecation-in-test errors we exclude
-    # all cirq_rigetti classes here.
-    "cirq_rigetti/json_test_data/AspenQubit.json",
-    "cirq_rigetti/json_test_data/OctagonalQubit.json",
-    # RigettiQCSAspenDevice does not pickle
-    "cirq_rigetti/json_test_data/RigettiQCSAspenDevice.json",
 )
 
 
@@ -87,11 +80,9 @@ def _read_json(json_filename: str) -> Any:
 
 def test_exclude_json_files_has_valid_entries() -> None:
     """Verify _EXCLUDE_JSON_FILES has valid entries."""
-    # do not check rigetti files if not installed
-    skip_rigetti = all(m.name != "cirq_rigetti" for m in MODULE_TEST_SPECS)
     json_file_validates = lambda f: any(
         m.test_data_path.joinpath(os.path.basename(f)).is_file() for m in MODULE_TEST_SPECS
-    ) or (skip_rigetti and f.startswith("cirq_rigetti/"))
+    )
     invalid_json_paths = [f for f in _EXCLUDE_JSON_FILES if not json_file_validates(f)]
     assert invalid_json_paths == []
 
@@ -105,7 +96,7 @@ def test_exclude_json_files_has_valid_entries() -> None:
         if _is_included(f"{abs_path}.json")
     ],
 )
-def test_hash_from_pickle(json_filename: str, pool: multiprocessing.pool.Pool):
+def test_hash_from_pickle(json_filename: str, pool: multiprocessing.pool.Pool) -> None:
     obj_local = _read_json(json_filename)
     if not isinstance(obj_local, Hashable):
         return

cirq/protocols/inverse_protocol.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Iterable, List, overload, Tuple, TYPE_CHECKING, TypeVar, Union
+from __future__ import annotations
+
+from typing import Any, Iterable, overload, TYPE_CHECKING, TypeVar
 
 from cirq import ops
 
@@ -21,49 +23,48 @@ if TYPE_CHECKING:
 
 # This is a special indicator value used by the inverse method to determine
 # whether or not the caller provided a 'default' argument.
-RaiseTypeErrorIfNotProvided: Tuple[List[Any]] = ([],)
+RaiseTypeErrorIfNotProvided: tuple[list[Any]] = ([],)
 
 TDefault = TypeVar('TDefault')
 
 
-# pylint: disable=function-redefined
 @overload
-def inverse(val: 'cirq.Gate') -> 'cirq.Gate':
+def inverse(val: cirq.Gate) -> cirq.Gate:
     pass
 
 
 @overload
-def inverse(val: 'cirq.Operation') -> 'cirq.Operation':
+def inverse(val: cirq.Operation) -> cirq.Operation:
     pass
 
 
 @overload
-def inverse(val: 'cirq.Circuit') -> 'cirq.Circuit':
+def inverse(val: cirq.Circuit) -> cirq.Circuit:
     pass
 
 
 @overload
-def inverse(val: 'cirq.OP_TREE') -> 'cirq.OP_TREE':
+def inverse(val: cirq.OP_TREE) -> cirq.OP_TREE:
     pass
 
 
 @overload
-def inverse(val: 'cirq.Gate', default: TDefault) -> Union[TDefault, 'cirq.Gate']:
+def inverse(val: cirq.Gate, default: TDefault) -> TDefault | cirq.Gate:
     pass
 
 
 @overload
-def inverse(val: 'cirq.Operation', default: TDefault) -> Union[TDefault, 'cirq.Operation']:
+def inverse(val: cirq.Operation, default: TDefault) -> TDefault | cirq.Operation:
     pass
 
 
 @overload
-def inverse(val: 'cirq.Circuit', default: TDefault) -> Union[TDefault, 'cirq.Circuit']:
+def inverse(val: cirq.Circuit, default: TDefault) -> TDefault | cirq.Circuit:
     pass
 
 
 @overload
-def inverse(val: 'cirq.OP_TREE', default: TDefault) -> Union[TDefault, 'cirq.OP_TREE']:
+def inverse(val: cirq.OP_TREE, default: TDefault) -> TDefault | cirq.OP_TREE:
     pass
 
 
@@ -98,7 +99,6 @@ def inverse(val: Any, default: Any = RaiseTypeErrorIfNotProvided) -> Any:
     # Check if object defines an inverse via __pow__.
     raiser = getattr(val, '__pow__', None)
 
-    # pylint: disable=not-callable
     result = NotImplemented if raiser is None else raiser(-1)
     if result is not NotImplemented:
         return result
@@ -106,7 +106,7 @@ def inverse(val: Any, default: Any = RaiseTypeErrorIfNotProvided) -> Any:
     # Maybe it's an iterable of invertible items?
     # Note: we avoid str because 'a'[0] == 'a', which creates an infinite loop.
     if isinstance(val, Iterable) and not isinstance(val, (str, ops.Operation)):
-        unique_indicator: List[Any] = []
+        unique_indicator: list[Any] = []
         results = tuple(inverse(e, unique_indicator) for e in val)
         if all(e is not unique_indicator for e in results):
             return results[::-1]
@@ -119,6 +119,3 @@ def inverse(val: Any, default: Any = RaiseTypeErrorIfNotProvided) -> Any:
         "It has no __pow__ method (or the method returned NotImplemented) "
         "and it isn't an iterable of invertible objects."
     )
-
-
-# pylint: enable=function-redefined

cirq/protocols/inverse_protocol_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 pytest
 
 import cirq
@@ -32,7 +34,7 @@ class ReturnsFive:
 
 
 class SelfInverse:
-    def __pow__(self, exponent) -> 'SelfInverse':
+    def __pow__(self, exponent) -> SelfInverse:
         return self
 
 
@@ -50,7 +52,7 @@ class IsIterable:
 @pytest.mark.parametrize(
     'val', (NoMethod(), 'text', object(), ReturnsNotImplemented(), [NoMethod(), 5])
 )
-def test_objects_with_no_inverse(val):
+def test_objects_with_no_inverse(val) -> None:
     with pytest.raises(TypeError, match="isn't invertible"):
         _ = cirq.inverse(val)
     assert cirq.inverse(val, None) is None
@@ -76,6 +78,6 @@ def test_objects_with_no_inverse(val):
         (IsIterable(), (0.5, 1)),
     ),
 )
-def test_objects_with_inverse(val, inv):
+def test_objects_with_inverse(val, inv) -> None:
     assert cirq.inverse(val) == inv
     assert cirq.inverse(val, 0) == inv