cirq-core 1.1.0.dev20221219200817__py3-none-any.whl → 1.2.0__py3-none-any.whl

cirq/protocols/act_on_protocol.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Sequence, TYPE_CHECKING, Union
+from typing import Any, Optional, Sequence, TYPE_CHECKING, Union
 
 from typing_extensions import Protocol
 
@@ -89,7 +89,7 @@ class SupportsActOnQubits(Protocol):
 def act_on(
     action: Any,
     sim_state: 'cirq.SimulationStateBase',
-    qubits: Sequence['cirq.Qid'] = None,
+    qubits: Optional[Sequence['cirq.Qid']] = None,
     *,
     allow_decompose: bool = True,
 ):
@@ -149,7 +149,7 @@ def act_on(
 
     arg_fallback = getattr(sim_state, '_act_on_fallback_', None)
     if arg_fallback is not None:
-        qubits = action.qubits if isinstance(action, ops.Operation) else qubits
+        qubits = action.qubits if is_op else qubits
         result = arg_fallback(action, qubits=qubits, allow_decompose=allow_decompose)
         if result is True:
             return

cirq/protocols/act_on_protocol_test.py

@@ -12,12 +12,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 from typing import Any, Sequence, Tuple
+from typing_extensions import Self
 
 import numpy as np
 import pytest
 
 import cirq
-from cirq.ops.raw_types import TSelf
 
 
 class DummyQuantumState(cirq.QuantumStateRepresentation):
@@ -62,10 +62,10 @@ def test_act_on_fallback_errors():
 def test_act_on_errors():
     class Op(cirq.Operation):
         @property
-        def qubits(self) -> Tuple['cirq.Qid', ...]:
+        def qubits(self) -> Tuple['cirq.Qid', ...]:  # type: ignore[empty-body]
             pass
 
-        def with_qubits(self: TSelf, *new_qubits: 'cirq.Qid') -> TSelf:
+        def with_qubits(self, *new_qubits: 'cirq.Qid') -> Self:  # type: ignore[empty-body]
             pass
 
         def _act_on_(self, sim_state):
@@ -79,10 +79,10 @@ def test_act_on_errors():
 def test_qubits_not_allowed_for_operations():
     class Op(cirq.Operation):
         @property
-        def qubits(self) -> Tuple['cirq.Qid', ...]:
+        def qubits(self) -> Tuple['cirq.Qid', ...]:  # type: ignore[empty-body]
             pass
 
-        def with_qubits(self: TSelf, *new_qubits: 'cirq.Qid') -> TSelf:
+        def with_qubits(self, *new_qubits: 'cirq.Qid') -> Self:  # type: ignore[empty-body]
             pass
 
     state = DummySimulationState()

cirq/protocols/apply_channel_protocol.py

@@ -11,6 +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.
+
 """A protocol for implementing high performance channel evolutions."""
 
 from typing import Any, Iterable, Optional, Sequence, TypeVar, Tuple, Union
@@ -142,7 +143,7 @@ class SupportsApplyChannel(Protocol):
                 `args.target_tensor` and the given buffers.
 
         Returns:
-            If the receiving object is not able to apply a chanel, None
+            If the receiving object is not able to apply a channel, None
             or NotImplemented should be returned.
 
             If the receiving object is able to work inline, it should directly
@@ -224,13 +225,13 @@ def apply_channel(
         raise ValueError(
             'Invalid target_tensor shape or selected axes. '
             'The selected left and right shape of target_tensor '
-            'are not equal. Got {!r} and {!r}.'.format(left_shape, right_shape)
+            f'are not equal. Got {left_shape!r} and {right_shape!r}.'
         )
     if val_qid_shape != left_shape:
         raise ValueError(
             'Invalid channel qid shape is not equal to the '
             'selected left and right shape of target_tensor. '
-            'Got {!r} but expected {!r}.'.format(val_qid_shape, left_shape)
+            f'Got {val_qid_shape!r} but expected {left_shape!r}.'
         )
 
     # Check if the specialized method is present.
@@ -240,9 +241,9 @@ def apply_channel(
 
             def err_str(buf_num_str):
                 return (
-                    "Object of type '{}' returned a result object equal to "
-                    "auxiliary_buffer{}. This type violates the contract "
-                    "that appears in apply_channel's documentation.".format(type(val), buf_num_str)
+                    f"Object of type '{type(val)}' returned a result object equal to "
+                    f"auxiliary_buffer{buf_num_str}. This type violates the contract "
+                    "that appears in apply_channel's documentation."
                 )
 
             assert result is not args.auxiliary_buffer0, err_str('0')
@@ -263,9 +264,9 @@ def apply_channel(
     if default is not RaiseTypeErrorIfNotProvided:
         return default
     raise TypeError(
-        "object of type '{}' has no _apply_channel_, _apply_unitary_, "
+        f"object of type '{type(val)}' has no _apply_channel_, _apply_unitary_, "
         "_unitary_, or _kraus_ methods (or they returned None or "
-        "NotImplemented).".format(type(val))
+        "NotImplemented)."
     )
 
 

cirq/protocols/apply_mixture_protocol.py

@@ -11,6 +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.
+
 """A protocol for implementing high performance mixture evolutions."""
 
 from typing import Any, cast, Iterable, Optional, Tuple, TypeVar, Union
@@ -245,9 +246,9 @@ def apply_mixture(
 
             def err_str(buf_num_str):
                 return (
-                    "Object of type '{}' returned a result object equal to "
-                    "auxiliary_buffer{}. This type violates the contract "
-                    "that appears in apply_mixture's documentation.".format(type(val), buf_num_str)
+                    f"Object of type '{type(val)}' returned a result object equal to "
+                    f"auxiliary_buffer{buf_num_str}. This type violates the contract "
+                    "that appears in apply_mixture's documentation."
                 )
 
             assert result is not args.auxiliary_buffer0, err_str('0')
@@ -269,9 +270,8 @@ def apply_mixture(
     if default is not RaiseTypeErrorIfNotProvided:
         return default
     raise TypeError(
-        "object of type '{}' has no _apply_mixture_, _apply_unitary_, "
-        "_unitary_, or _mixture_ methods (or they returned None or "
-        "NotImplemented).".format(type(val))
+        f"object of type '{type(val)}' has no _apply_mixture_, _apply_unitary_, "
+        "_unitary_, or _mixture_ methods (or they returned None or NotImplemented)."
     )
 
 
@@ -287,7 +287,7 @@ def _validate_input(val: Any, args: 'ApplyMixtureArgs') -> Tuple[Any, 'ApplyMixt
         raise ValueError(
             'Invalid mixture qid shape is not equal to the '
             'selected left and right shape of target_tensor. '
-            'Got {!r} but expected {!r}.'.format(val_qid_shape, left_shape)
+            f'Got {val_qid_shape!r} but expected {left_shape!r}.'
         )
 
     if args.right_axes is not None:
@@ -298,7 +298,7 @@ def _validate_input(val: Any, args: 'ApplyMixtureArgs') -> Tuple[Any, 'ApplyMixt
             raise ValueError(
                 'Invalid target_tensor shape or selected axes. '
                 'The selected left and right shape of '
-                'target_tensor are not equal. Got {!r} and {!r}.'.format(left_shape, right_shape)
+                f'target_tensor are not equal. Got {left_shape!r} and {right_shape!r}.'
             )
 
     return val, args, is_density_matrix

cirq/protocols/apply_mixture_protocol_test.py

@@ -33,7 +33,7 @@ def assert_apply_mixture_returns(
     left_axes: Iterable[int],
     right_axes: Optional[Iterable[int]],
     assert_result_is_out_buf: bool = False,
-    expected_result: np.ndarray = None,
+    expected_result: Optional[np.ndarray] = None,
 ):
     out_buf, buf0, buf1 = make_buffers(rho.shape, rho.dtype)
     result = cirq.apply_mixture(

cirq/protocols/apply_unitary_protocol.py

@@ -11,7 +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.
+
 """A protocol for implementing high performance unitary left-multiplies."""
+
 import warnings
 from typing import Any, cast, Iterable, Optional, Sequence, Tuple, TYPE_CHECKING, TypeVar, Union
 
@@ -133,6 +135,33 @@ class ApplyUnitaryArgs:
         state = qis.one_hot(index=(0,) * num_qubits, shape=qid_shape, dtype=np.complex128)
         return ApplyUnitaryArgs(state, np.empty_like(state), range(num_qubits))
 
+    @classmethod
+    def for_unitary(
+        cls, num_qubits: Optional[int] = None, *, qid_shape: Optional[Tuple[int, ...]] = None
+    ) -> 'ApplyUnitaryArgs':
+        """A default instance corresponding to an identity matrix.
+
+        Specify exactly one argument.
+
+        Args:
+            num_qubits: The number of qubits to make space for in the state.
+            qid_shape: A tuple representing the number of quantum levels of each
+                qubit the identity matrix applies to. `qid_shape` is (2, 2, 2) for
+                a three-qubit identity operation tensor.
+
+        Raises:
+            TypeError: If exactly neither `num_qubits` or `qid_shape` is provided or
+                both are provided.
+        """
+        if (num_qubits is None) == (qid_shape is None):
+            raise TypeError('Specify exactly one of num_qubits or qid_shape.')
+        if num_qubits is not None:
+            qid_shape = (2,) * num_qubits
+        qid_shape = cast(Tuple[int, ...], qid_shape)  # Satisfy mypy
+        num_qubits = len(qid_shape)
+        state = qis.eye_tensor(qid_shape, dtype=np.complex128)
+        return ApplyUnitaryArgs(state, np.empty_like(state), range(num_qubits))
+
     def with_axes_transposed_to_start(self) -> 'ApplyUnitaryArgs':
         """Returns a transposed view of the same arguments.
 
@@ -376,8 +405,8 @@ def apply_unitary(
         "cirq.apply_unitary failed. "
         "Value doesn't have a (non-parameterized) unitary effect.\n"
         "\n"
-        "type: {}\n"
-        "value: {!r}\n"
+        f"type: {type(unitary_value)}\n"
+        f"value: {unitary_value!r}\n"
         "\n"
         "The value failed to satisfy any of the following criteria:\n"
         "- An `_apply_unitary_(self, args) method that returned a value "
@@ -386,7 +415,6 @@ def apply_unitary(
         "besides None or NotImplemented.\n"
         "- A `_decompose_(self)` method that returned a "
         "list of unitary operations.\n"
-        "".format(type(unitary_value), unitary_value)
     )
 
 
@@ -409,19 +437,7 @@ def _strat_apply_unitary_from_apply_unitary(
     return _incorporate_result_into_target(args, sub_args, sub_result)
 
 
-def _strat_apply_unitary_from_unitary(
-    unitary_value: Any, args: ApplyUnitaryArgs
-) -> Optional[np.ndarray]:
-    # Check for magic method.
-    method = getattr(unitary_value, '_unitary_', None)
-    if method is None:
-        return NotImplemented
-
-    # Attempt to get the unitary matrix.
-    matrix = method()
-    if matrix is NotImplemented or matrix is None:
-        return matrix
-
+def _apply_unitary_from_matrix(matrix: np.ndarray, unitary_value: Any, args: ApplyUnitaryArgs):
     if args.slices is None:
         val_qid_shape = qid_shape_protocol.qid_shape(unitary_value, default=(2,) * len(args.axes))
         slices = tuple(slice(0, size) for size in val_qid_shape)
@@ -450,11 +466,42 @@ def _strat_apply_unitary_from_unitary(
     return _incorporate_result_into_target(args, sub_args, sub_result)
 
 
+def _strat_apply_unitary_from_unitary(
+    unitary_value: Any, args: ApplyUnitaryArgs
+) -> Optional[np.ndarray]:
+    # Check for magic method.
+    method = getattr(unitary_value, '_unitary_', None)
+    if method is None:
+        return NotImplemented
+
+    # Attempt to get the unitary matrix.
+    matrix = method()
+    if matrix is NotImplemented or matrix is None:
+        return matrix
+
+    return _apply_unitary_from_matrix(matrix, unitary_value, args)
+
+
 def _strat_apply_unitary_from_decompose(val: Any, args: ApplyUnitaryArgs) -> Optional[np.ndarray]:
     operations, qubits, _ = _try_decompose_into_operations_and_qubits(val)
     if operations is None:
         return NotImplemented
-    return apply_unitaries(operations, qubits, args, None)
+    all_qubits = frozenset([q for op in operations for q in op.qubits])
+    ancilla = tuple(sorted(all_qubits.difference(qubits)))
+    if not len(ancilla):
+        return apply_unitaries(operations, qubits, args, None)
+    ordered_qubits = ancilla + tuple(qubits)
+    all_qid_shapes = qid_shape_protocol.qid_shape(ordered_qubits)
+    result = apply_unitaries(
+        operations, ordered_qubits, ApplyUnitaryArgs.for_unitary(qid_shape=all_qid_shapes), None
+    )
+    if result is None or result is NotImplemented:
+        return result
+    result = result.reshape((np.prod(all_qid_shapes, dtype=np.int64), -1))
+    val_qid_shape = qid_shape_protocol.qid_shape(qubits)
+    state_vec_length = np.prod(val_qid_shape, dtype=np.int64)
+    result = result[:state_vec_length, :state_vec_length]
+    return _apply_unitary_from_matrix(result, val, args)
 
 
 def apply_unitaries(
@@ -528,8 +575,8 @@ def apply_unitaries(
                     "There was a non-unitary value in the `unitary_values` "
                     "list.\n"
                     "\n"
-                    "non-unitary value type: {}\n"
-                    "non-unitary value: {!r}".format(type(op), op)
+                    f"non-unitary value type: {type(op)}\n"
+                    f"non-unitary value: {op!r}"
                 )
             return default
 

cirq/protocols/apply_unitary_protocol_test.py

@@ -717,3 +717,53 @@ def test_cast_to_complex():
         np.ComplexWarning, match='Casting complex values to real discards the imaginary part'
     ):
         cirq.apply_unitary(y0, args)
+
+
+class NotDecomposableGate(cirq.Gate):
+    def num_qubits(self):
+        return 1
+
+
+class DecomposableGate(cirq.Gate):
+    def __init__(self, sub_gate: cirq.Gate, allocate_ancilla: bool) -> None:
+        super().__init__()
+        self._sub_gate = sub_gate
+        self._allocate_ancilla = allocate_ancilla
+
+    def num_qubits(self):
+        return 1
+
+    def _decompose_(self, qubits):
+        if self._allocate_ancilla:
+            yield cirq.Z(cirq.NamedQubit('DecomposableGateQubit'))
+        yield self._sub_gate(qubits[0])
+
+
+def test_strat_apply_unitary_from_decompose():
+    state = np.eye(2, dtype=np.complex128)
+    args = cirq.ApplyUnitaryArgs(
+        target_tensor=state, available_buffer=np.zeros_like(state), axes=(0,)
+    )
+    np.testing.assert_allclose(
+        cirq.apply_unitaries(
+            [DecomposableGate(cirq.X, False)(cirq.LineQubit(0))], [cirq.LineQubit(0)], args
+        ),
+        [[0, 1], [1, 0]],
+    )
+
+    with pytest.raises(TypeError):
+        _ = cirq.apply_unitaries(
+            [DecomposableGate(NotDecomposableGate(), True)(cirq.LineQubit(0))],
+            [cirq.LineQubit(0)],
+            args,
+        )
+
+
+def test_unitary_construction():
+    with pytest.raises(TypeError):
+        _ = cirq.ApplyUnitaryArgs.for_unitary()
+
+    np.testing.assert_allclose(
+        cirq.ApplyUnitaryArgs.for_unitary(num_qubits=3).target_tensor,
+        cirq.eye_tensor((2,) * 3, dtype=np.complex128),
+    )

cirq/protocols/circuit_diagram_info_protocol.py

@@ -11,6 +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.
+
 import re
 from fractions import Fraction
 from typing import (
@@ -73,7 +74,7 @@ class CircuitDiagramInfo:
                 could be mistaken for an identity wire). Defaults to True.
 
         Raises:
-            ValueError: If `wire_symbols` is a string, and not an interable
+            ValueError: If `wire_symbols` is a string, and not an iterable
                 of strings.
         """
         if isinstance(wire_symbols, str):
@@ -118,13 +119,10 @@ class CircuitDiagramInfo:
             else:
                 ks = (0,)
             for k in ks:
-                result[k] += '^' + exponent
+                result[k] += f"^{exponent}"
         return result
 
-    def _formatted_exponent(
-        self: 'cirq.CircuitDiagramInfo', args: 'cirq.CircuitDiagramInfoArgs'
-    ) -> Optional[str]:
-
+    def _formatted_exponent(self, args: 'cirq.CircuitDiagramInfoArgs') -> Optional[str]:
         if protocols.is_parameterized(self.exponent):
             name = str(self.exponent)
             return f'({name})' if _is_exposed_formula(name) else name
@@ -273,7 +271,7 @@ class CircuitDiagramInfoArgs:
         if radians == 0:
             return '0'
         if radians == -np.pi:
-            return '-' + unit
+            return f"-{unit}"
         if self.precision is not None and not isinstance(radians, sympy.Basic):
             quantity = self.format_real(radians / np.pi)
             return quantity + unit
@@ -433,8 +431,8 @@ def circuit_diagram_info(
     if getter is None:
         raise TypeError(f"object of type '{type(val)}' has no _circuit_diagram_info_ method.")
     raise TypeError(
-        "object of type '{}' does have a _circuit_diagram_info_ "
-        "method, but it returned NotImplemented.".format(type(val))
+        f"object of type '{type(val)}' does have a _circuit_diagram_info_ "
+        "method, but it returned NotImplemented."
     )