Remove v0.13 deprecations. (quantumlib#4567)

Flush v0.13 deprecation backlog.

Author: MichaelBroughton

cirq-core/cirq/__init__.py

@@ -505,7 +505,6 @@
     ApplyMixtureArgs,
     ApplyUnitaryArgs,
     approx_eq,
-    channel,
     circuit_diagram_info,
     CircuitDiagramInfo,
     CircuitDiagramInfoArgs,
@@ -516,7 +515,6 @@
     DEFAULT_RESOLVERS,
     definitely_commutes,
     equal_up_to_global_phase,
-    has_channel,
     has_kraus,
     has_mixture,
     has_stabilizer_effect,
@@ -558,7 +556,6 @@
     SupportsApplyMixture,
     SupportsApproximateEquality,
     SupportsConsistentApplyUnitary,
-    SupportsChannel,
     SupportsCircuitDiagramInfo,
     SupportsCommutes,
     SupportsDecompose,

cirq-core/cirq/contrib/quimb/mps_simulator.py

@@ -19,13 +19,12 @@
 
 import dataclasses
 import math
-from typing import Any, Dict, List, Optional, Sequence, Set, TYPE_CHECKING, Iterable, Union
+from typing import Any, Dict, List, Optional, Sequence, Set, TYPE_CHECKING, Union
 
 import numpy as np
 import quimb.tensor as qtn
 
 from cirq import devices, study, ops, protocols, value
-from cirq._compat import deprecated_parameter
 from cirq.sim import simulator, simulator_base
 from cirq.sim.act_on_args import ActOnArgs
 
@@ -214,20 +213,13 @@ class MPSState(ActOnArgs):
 
     # TODO(#3388) Add documentation for Raises.
     # pylint: disable=missing-raises-doc
-    @deprecated_parameter(
-        deadline='v0.13',
-        fix='No longer needed. `protocols.act_on` infers axes.',
-        parameter_desc='axes',
-        match=lambda args, kwargs: 'axes' in kwargs or len(args) > 6,
-    )
     def __init__(
         self,
         qubits: Sequence['cirq.Qid'],
         prng: np.random.RandomState,
         simulation_options: MPSOptions = MPSOptions(),
         grouping: Optional[Dict['cirq.Qid', int]] = None,
         initial_state: int = 0,
-        axes: Iterable[int] = None,
         log_of_measurement_results: Dict[str, Any] = None,
     ):
         """Creates and MPSState
@@ -240,12 +232,10 @@ def __init__(
             simulation_options: Numerical options for the simulation.
             grouping: How to group qubits together, if None all are individual.
             initial_state: An integer representing the initial state.
-            axes: The indices of axes corresponding to the qubits that the
-                operation is supposed to act upon.
             log_of_measurement_results: A mutable object that measurements are
                 being recorded into.
         """
-        super().__init__(prng, qubits, axes, log_of_measurement_results)
+        super().__init__(prng, qubits, log_of_measurement_results)
         qubit_map = self.qubit_map
         self.grouping = qubit_map if grouping is None else grouping
         if self.grouping.keys() != self.qubit_map.keys():

cirq-core/cirq/ops/gate_operation.py

@@ -199,18 +199,6 @@ def _mixture_(self) -> Sequence[Tuple[float, Any]]:
             return getter()
         return NotImplemented
 
-    def _has_channel_(self) -> bool:
-        getter = getattr(self.gate, '_has_channel_', None)
-        if getter is not None:
-            return getter()
-        return NotImplemented
-
-    def _channel_(self) -> Union[Tuple[np.ndarray], NotImplementedType]:
-        getter = getattr(self.gate, '_channel_', None)
-        if getter is not None:
-            return getter()
-        return NotImplemented
-
     def _has_kraus_(self) -> bool:
         getter = getattr(self.gate, '_has_kraus_', None)
         if getter is not None:

cirq-core/cirq/ops/gate_operation_test.py

@@ -11,8 +11,6 @@
 # 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 Tuple
-
 import numpy as np
 import pytest
 import sympy
@@ -436,27 +434,3 @@ def _is_parameterized_(self):
     assert not cirq.is_parameterized(No1().on(q))
     assert not cirq.is_parameterized(No2().on(q))
     assert cirq.is_parameterized(Yes().on(q))
-
-
-def test_channel_propagates_to_gate():
-    class TestGate(cirq.SingleQubitGate):
-        def _channel_(self) -> np.ndarray:
-            return (np.eye(2),)
-
-        def _has_channel_(self) -> bool:
-            return True
-
-    def assert_kraus_eq(ks1: Tuple[np.ndarray, ...], ks2: Tuple[np.ndarray, ...]) -> None:
-        assert len(ks1) == len(ks2)
-        for k1, k2 in zip(ks1, ks2):
-            assert np.all(k1 == k2)
-
-    identity_kraus = (np.eye(2),)
-    q = cirq.LineQubit(0)
-    gate = TestGate()
-    gate_op = TestGate().on(q)
-    with cirq.testing.assert_deprecated(deadline='v0.13', count=None):
-        assert cirq.has_channel(gate)
-        assert cirq.has_channel(gate_op)
-        assert_kraus_eq(cirq.channel(gate), identity_kraus)
-        assert_kraus_eq(cirq.channel(gate_op), identity_kraus)

cirq-core/cirq/ops/kraus_channel.py

@@ -51,9 +51,7 @@ def __init__(
         self._key = key
 
     @staticmethod
-    def from_channel(
-        channel: 'protocols.SupportsChannel', key: Union[str, value.MeasurementKey, None] = None
-    ):
+    def from_channel(channel: 'KrausChannel', key: Union[str, value.MeasurementKey, None] = None):
         """Creates a copy of a channel with the given measurement key."""
         return KrausChannel(kraus_ops=list(protocols.kraus(channel)), key=key)
 

cirq-core/cirq/protocols/__init__.py

@@ -40,11 +40,8 @@
     SupportsApproximateEquality,
 )
 from cirq.protocols.kraus_protocol import (
-    channel,
     kraus,
-    has_channel,
     has_kraus,
-    SupportsChannel,
     SupportsKraus,
 )
 from cirq.protocols.commutes_protocol import (

cirq-core/cirq/protocols/act_on_protocol.py

@@ -132,12 +132,8 @@ def act_on(
     if is_op and qubits is not None:
         raise ValueError('Calls to act_on should not supply qubits if the action is an Operation.')
 
-    # todo: change to an exception after `args.axes` is deprecated.
     if not is_op and qubits is None:
-        from cirq.sim import ActOnArgs
-
-        if isinstance(args, ActOnArgs):
-            qubits = [args.qubits[i] for i in args.axes]
+        raise ValueError('Calls to act_on should supply qubits if the action is not an Operation.')
 
     action_act_on = getattr(action, '_act_on_', None)
     if action_act_on is not None:

cirq-core/cirq/protocols/act_on_protocol_test.py

@@ -83,30 +83,6 @@ def _act_on_(self, args):
         cirq.act_on(Op(), args)
 
 
-def test_act_on_args_axes_deprecation():
-    class Args(DummyActOnArgs):
-        def _act_on_fallback_(
-            self,
-            action: Union['cirq.Operation', 'cirq.Gate'],
-            qubits: Sequence['cirq.Qid'] = None,
-            allow_decompose: bool = True,
-        ) -> bool:
-            self.measurements.append(qubits)
-            return True
-
-    args = Args()
-    args._qubits = tuple(cirq.LineQubit.range(3))
-    with cirq.testing.assert_deprecated(
-        "ActOnArgs.axes", "Use `protocols.act_on` instead.", deadline="v0.13"
-    ):
-        args.axes = (1,)
-    with cirq.testing.assert_deprecated(
-        "ActOnArgs.axes", "Use `protocols.act_on` instead.", deadline="v0.13"
-    ):
-        cirq.act_on(object(), args)  # type: ignore
-    assert args.measurements == [[cirq.LineQubit(1)]]
-
-
 def test_qubits_not_allowed_for_operations():
     class Op(cirq.Operation):
         @property
@@ -121,3 +97,9 @@ def with_qubits(self: TSelf, *new_qubits: 'cirq.Qid') -> TSelf:
         ValueError, match='Calls to act_on should not supply qubits if the action is an Operation'
     ):
         cirq.act_on(Op(), args, qubits=[])
+
+
+def test_qubits_should_be_defined_for_operations():
+    args = DummyActOnArgs()
+    with pytest.raises(ValueError, match='Calls to act_on should'):
+        cirq.act_on(cirq.KrausChannel([np.array([[1, 0], [0, 0]])]), args, qubits=None)

cirq-core/cirq/protocols/json_test_data/spec.py

@@ -137,7 +137,6 @@
         'SupportsApplyChannel',
         'SupportsApplyMixture',
         'SupportsApproximateEquality',
-        'SupportsChannel',
         'SupportsCircuitDiagramInfo',
         'SupportsCommutes',
         'SupportsConsistentApplyUnitary',

cirq-core/cirq/protocols/kraus_protocol.py

@@ -20,10 +20,6 @@
 import numpy as np
 from typing_extensions import Protocol
 
-from cirq._compat import (
-    deprecated,
-    deprecated_class,
-)
 from cirq._doc import doc_private
 from cirq.protocols.decompose_protocol import (
     _try_decompose_into_operations_and_qubits,
@@ -45,11 +41,6 @@
 TDefault = TypeVar('TDefault')
 
 
-@deprecated_class(deadline='v0.13', fix='use cirq.SupportsKraus instead')
-class SupportsChannel(Protocol):
-    pass
-
-
 class SupportsKraus(Protocol):
     """An object that may be describable as a quantum channel."""
 
@@ -105,13 +96,6 @@ def _has_kraus_(self) -> bool:
         """
 
 
-@deprecated(deadline='v0.13', fix='use cirq.kraus instead')
-def channel(
-    val: Any, default: Any = RaiseTypeErrorIfNotProvided
-) -> Union[Tuple[np.ndarray, ...], TDefault]:
-    return kraus(val, default=default)
-
-
 def kraus(
     val: Any, default: Any = RaiseTypeErrorIfNotProvided
 ) -> Union[Tuple[np.ndarray, ...], TDefault]:
@@ -192,11 +176,6 @@ def kraus(
     )
 
 
-@deprecated(deadline='v0.13', fix='use cirq.has_kraus instead')
-def has_channel(val: Any, *, allow_decompose: bool = True) -> bool:
-    return has_kraus(val, allow_decompose=allow_decompose)
-
-
 def has_kraus(val: Any, *, allow_decompose: bool = True) -> bool:
     """Returns whether the value has a Kraus representation.
 
@@ -220,13 +199,6 @@ def has_kraus(val: Any, *, allow_decompose: bool = True) -> bool:
         has a non-default value. Returns False if none of these functions
         exists.
     """
-    channel_getter = getattr(val, '_has_channel_', None)
-    if channel_getter is not None:
-        warnings.warn(
-            '_has_channel_ is deprecated and will be removed in cirq 0.13, rename to _has_kraus_',
-            DeprecationWarning,
-        )
-
     kraus_getter = getattr(val, '_has_kraus_', None)
     result = NotImplemented if kraus_getter is None else kraus_getter()
     if result is not NotImplemented:
@@ -236,10 +208,6 @@ def has_kraus(val: Any, *, allow_decompose: bool = True) -> bool:
     if result is not NotImplemented and result:
         return result
 
-    result = NotImplemented if channel_getter is None else channel_getter()
-    if result is not NotImplemented:
-        return result
-
     if allow_decompose:
         operations, _, _ = _try_decompose_into_operations_and_qubits(val)
         if operations is not None:

cirq-core/cirq/protocols/kraus_protocol_test.py

@@ -52,25 +52,6 @@ def assert_not_implemented(val):
     assert not cirq.has_kraus(val)
 
 
-def test_supports_channel_class_is_deprecated():
-    with cirq.testing.assert_deprecated(deadline='v0.13'):
-
-        class SomeChannel(cirq.SupportsChannel):
-            pass
-
-        _ = SomeChannel()
-
-
-def test_channel_protocol_is_deprecated():
-    with cirq.testing.assert_deprecated(deadline='v0.13'):
-        assert np.allclose(cirq.channel(cirq.X), cirq.kraus(cirq.X))
-
-
-def test_has_channel_protocol_is_deprecated():
-    with cirq.testing.assert_deprecated(deadline='v0.13'):
-        assert cirq.has_channel(cirq.depolarize(0.1)) == cirq.has_kraus(cirq.depolarize(0.1))
-
-
 def test_kraus_returns_not_implemented():
     class ReturnsNotImplemented:
         def _kraus_(self):
@@ -79,23 +60,6 @@ def _kraus_(self):
     assert_not_implemented(ReturnsNotImplemented())
 
 
-def test_channel_generates_deprecation_warning():
-    class UsesDeprecatedChannelMethod:
-        def _has_channel_(self):
-            return True
-
-        def _channel_(self):
-            return (np.eye(2),)
-
-    val = UsesDeprecatedChannelMethod()
-    with pytest.warns(DeprecationWarning, match='_has_kraus_'):
-        assert cirq.has_kraus(val)
-    with pytest.warns(DeprecationWarning, match='_kraus_'):
-        ks = cirq.kraus(val)
-        assert len(ks) == 1
-        assert np.all(ks[0] == np.eye(2))
-
-
 def test_mixture_returns_not_implemented():
     class ReturnsNotImplemented:
         def _mixture_(self):