Default Operator.num_wires = None to indicate that the operator can be on any number of wires (#7312)

**Context:**

This PR is separated from #7311  to allow us to update catalyst easily.

`AllWires` and `AnyWires` are overkill that don't really need to exist.
Setting `Operator.num_wires = None` can sufficiently communicate "I can
accept any number of wires". We haven't validated `AllWires` or done
anything special about it for many releases. All these serve to do it
tell the default `Operator.__init__` to not validate how many wires the
user passes in. We can do that with `None`.

All they really do is make the interface more complicated and cluttered.

**Description of the Change:**

Default to using `Operator.num_wires = None` to indicate that the
operator can be on any number of wires.

**Benefits:**

Cleaner Operator interface. Sets us up for deprecating `WiresEnum`.

**Possible Drawbacks:**

Deprecations and removals always run the risk of breaking something for
someone, but I think this a harmless enough change.
[sc-89159]

Author: albi3ro

doc/development/adding_operators.rst

@@ -139,11 +139,6 @@ knows a native implementation for ``FlipAndRotate``). It also defines an adjoint
 
     class FlipAndRotate(qml.operation.Operation):
 
-        # Define how many wires the operator acts on in total.
-        # In our case this may be one or two, which is why we
-        # use the AnyWires Enumeration to indicate a variable number.
-        num_wires = qml.operation.AnyWires
-
         # This attribute tells PennyLane what differentiation method to use. Here
         # we request parameter-shift (or "analytic") differentiation.
         grad_method = "A"
@@ -242,8 +237,7 @@ If the above operator omitted the ``_unflatten`` custom definition, it would rai
     For local testing, try type(op)._unflatten(*op._flatten())
 
 
-The new gate can be used with PennyLane devices. Device support for an operation can be checked via
-``dev.stopping_condition(op)``.  If ``True``, then the device supports the operation.
+The new gate can be used with PennyLane devices.
 
 ``DefaultQubit`` first checks if the operator has a matrix using the :attr:`~.Operator.has_matrix` property.
 

doc/releases/changelog-dev.md

@@ -127,6 +127,10 @@
 * Alias for Identity (`I`) is now accessible from `qml.ops`.
   [(#7200)](https://github.com/PennyLaneAI/pennylane/pull/7200)
 
+* `Operator.num_wires` now defaults to `None` to indicate that the operator can be on
+  any number of wires.
+  [(#7312)](https://github.com/PennyLaneAI/pennylane/pull/7312)
+
 * Shots can now be overridden for specific `qml.Snapshot` instances via a `shots` keyword argument.
   [(#7326)](https://github.com/PennyLaneAI/pennylane/pull/7326)
 

pennylane/noise/conditionals.py

@@ -21,7 +21,6 @@
 import pennylane as qml
 from pennylane.boolean_fn import BooleanFn
 from pennylane.measurements import MeasurementProcess, MeasurementValue, MidMeasureMP
-from pennylane.operation import AnyWires
 from pennylane.ops import Adjoint, Controlled
 from pennylane.templates import ControlledSequence
 from pennylane.wires import WireError, Wires
@@ -747,7 +746,7 @@ def _partial(wires=None, **partial_kwargs):
                 op_args[key] = val
 
         if issubclass(op_class, qml.operation.Operation):
-            num_wires = getattr(op_class, "num_wires", AnyWires)
+            num_wires = getattr(op_class, "num_wires", None)
             if "wires" in op_args and isinstance(num_wires, int):
                 if num_wires < len(op_args["wires"]) and num_wires == 1:
                     op_wires = op_args.pop("wires")

pennylane/operation.py

@@ -302,20 +302,24 @@ class ParameterFrequenciesUndefinedError(OperatorPropertyUndefined):
 class WiresEnum(IntEnum):
     """Integer enumeration class
     to represent the number of wires
-    an operation acts on"""
+    an operation acts on.
+
+    """
 
     AnyWires = -1
+    """A enumeration that represents that an operator can act on any number of wires.
+
+    """
+
     AllWires = -2
+    """A enumeration that represents that an operator acts on all wires in the system.
 
 
-AllWires = WiresEnum.AllWires
-"""IntEnum: An enumeration which represents all wires in the
-subsystem. It is equivalent to an integer with value 0."""
+    """
 
-AnyWires = WiresEnum.AnyWires
-"""IntEnum: An enumeration which represents any wires in the
-subsystem. It is equivalent to an integer with value -1."""
 
+AnyWires = WiresEnum.AnyWires
+AllWires = WiresEnum.AllWires
 
 # =============================================================================
 # Class property
@@ -434,11 +438,6 @@ class Operator(abc.ABC, metaclass=ABCCaptureMeta):
 
         class FlipAndRotate(qml.operation.Operation):
 
-            # Define how many wires the operator acts on in total.
-            # In our case this may be one or two, which is why we
-            # use the AnyWires Enumeration to indicate a variable number.
-            num_wires = qml.operation.AnyWires
-
             # This attribute tells PennyLane what differentiation method to use. Here
             # we request parameter-shift (or "analytic") differentiation.
             grad_method = "A"
@@ -972,7 +971,7 @@ def terms(self) -> tuple[list[TensorLike], list["Operation"]]:  # pylint: disabl
         """
         raise TermsUndefinedError
 
-    num_wires: Union[int, WiresEnum] = AnyWires
+    num_wires: Optional[Union[int, WiresEnum]] = None
     """Number of wires the operator acts on."""
 
     @property
@@ -1136,7 +1135,9 @@ def __init__(
         self._wires: Wires = Wires(wires)
 
         # check that the number of wires given corresponds to required number
-        if self.num_wires not in {AllWires, AnyWires} and len(self._wires) != self.num_wires:
+        if (self.num_wires is not None and not isinstance(self.num_wires, WiresEnum)) and len(
+            self._wires
+        ) != self.num_wires:
             raise ValueError(
                 f"{self.name}: wrong number of wires. "
                 f"{len(self._wires)} wires given, {self.num_wires} expected."
@@ -1886,7 +1887,7 @@ def parameter_frequencies(self) -> list[tuple[Union[float, int]]]:
                 warnings.filterwarnings(
                     action="ignore", message=r".+ eigenvalues will be computed numerically\."
                 )
-                eigvals = qml.eigvals(gen, k=2**self.num_wires)
+                eigvals = qml.eigvals(gen, k=2 ** len(self.wires))
 
             eigvals = tuple(np.round(eigvals, 8))
             return [qml.gradients.eigvals_to_frequencies(eigvals)]

pennylane/ops/channel.py

@@ -19,7 +19,7 @@
 import warnings
 
 from pennylane import math as np
-from pennylane.operation import AnyWires, Channel
+from pennylane.operation import Channel
 from pennylane.wires import Wires, WiresLike
 
 
@@ -559,9 +559,6 @@ class PauliError(Channel):
                [0.70710678, 0.        ]])
     """
 
-    num_wires = AnyWires
-    """int: Number of wires that the operator acts on."""
-
     num_params = 2
     """int: Number of trainable parameters that the operator depends on."""
 
@@ -713,7 +710,6 @@ class QubitChannel(Channel):
         id (str or None): String representing the operation (optional)
     """
 
-    num_wires = AnyWires
     grad_method = None
 
     def __init__(self, K_list, wires: WiresLike, id=None):

pennylane/ops/cv.py

@@ -42,7 +42,7 @@
 from scipy.linalg import block_diag
 
 from pennylane import math as qml_math
-from pennylane.operation import AnyWires, CVObservable, CVOperation
+from pennylane.operation import CVObservable, CVOperation
 
 from .identity import I, Identity  # pylint: disable=unused-import
 from .meta import Snapshot  # pylint: disable=unused-import
@@ -667,7 +667,6 @@ class InterferometerUnitary(CVOperation):
     """
 
     num_params = 1
-    num_wires = AnyWires
     grad_method = None
     grad_recipe = None
 
@@ -833,7 +832,6 @@ class GaussianState(CVOperation):
     """
 
     num_params = 2
-    num_wires = AnyWires
     grad_method = "F"
 
     def __init__(self, V, r, wires, id=None):
@@ -952,7 +950,6 @@ def circuit():
     """
 
     num_params = 1
-    num_wires = AnyWires
     grad_method = "F"
 
     def __init__(self, state, wires, id=None):
@@ -1001,7 +998,6 @@ class FockDensityMatrix(CVOperation):
     """
 
     num_params = 1
-    num_wires = AnyWires
     grad_method = "F"
 
     def __init__(self, state, wires, id=None):
@@ -1133,7 +1129,6 @@ class TensorN(CVObservable):
     """
 
     num_params = 0
-    num_wires = AnyWires
     ev_order = None
 
     def __init__(self, wires):
@@ -1326,7 +1321,6 @@ class PolyXP(CVObservable):
     """
 
     num_params = 1
-    num_wires = AnyWires
 
     grad_method = "F"
     ev_order = 2
@@ -1385,7 +1379,6 @@ class FockStateProjector(CVObservable):
     """
 
     num_params = 1
-    num_wires = AnyWires
 
     grad_method = None
     ev_order = None

pennylane/ops/identity.py

@@ -21,13 +21,7 @@
 from scipy import sparse
 
 import pennylane as qml
-from pennylane.operation import (
-    AllWires,
-    AnyWires,
-    CVObservable,
-    Operation,
-    SparseMatrixUndefinedError,
-)
+from pennylane.operation import CVObservable, Operation, SparseMatrixUndefinedError
 from pennylane.wires import WiresLike
 
 
@@ -52,8 +46,6 @@ class Identity(CVObservable, Operation):
     """
 
     num_params = 0
-    num_wires = AnyWires
-    """int: Number of wires that the operator acts on."""
 
     grad_method = None
     """Gradient computation method."""
@@ -299,9 +291,6 @@ def circuit():
 
     """
 
-    num_wires = AllWires
-    """int: Number of wires that the operator acts on."""
-
     num_params = 1
     """int: Number of trainable parameters that the operator depends on."""
 

pennylane/ops/meta.py

@@ -22,7 +22,7 @@
 from typing import Literal, Optional, Sequence, Union
 
 import pennylane as qml
-from pennylane.operation import AnyWires, Operation
+from pennylane.operation import Operation
 from pennylane.wires import Wires, WiresLike
 
 
@@ -43,9 +43,6 @@ class Barrier(Operation):
     num_params = 0
     """int: Number of trainable parameters that the operator depends on."""
 
-    num_wires = AnyWires
-    par_domain = None
-
     def __init__(self, wires: WiresLike = (), only_visual=False, id=None):
         wires = Wires(wires)
         self.only_visual = only_visual
@@ -117,7 +114,6 @@ class WireCut(Operation):
     """
 
     num_params = 0
-    num_wires = AnyWires
     grad_method = None
 
     def __init__(self, wires: WiresLike = (), id=None):
@@ -211,7 +207,6 @@ def circuit():
     .. seealso:: :func:`~.snapshots`
     """
 
-    num_wires = AnyWires
     num_params = 0
     grad_method = None
 

pennylane/ops/op_math/condition.py

@@ -23,7 +23,7 @@
 from pennylane.capture import FlatFn
 from pennylane.compiler import compiler
 from pennylane.measurements import MeasurementValue, MidMeasureMP, get_mcm_predicates
-from pennylane.operation import AnyWires, Operation, Operator
+from pennylane.operation import Operation, Operator
 from pennylane.ops.op_math.symbolicop import SymbolicOp
 
 
@@ -88,8 +88,6 @@ class Conditional(SymbolicOp, Operation):
             can be useful for some applications where the instance has to be identified
     """
 
-    num_wires = AnyWires
-
     def __init__(self, expr, then_op: Type[Operation], id=None):
         self.hyperparameters["meas_val"] = expr
         self._name = f"Conditional({then_op.name})"

pennylane/ops/op_math/controlled_ops.py

@@ -24,10 +24,9 @@
 
 import pennylane as qml
 from pennylane.decomposition import add_decomps, register_resources
-from pennylane.operation import AnyWires, Wires
 from pennylane.ops.qubit.parametric_ops_single_qubit import stack_last
 from pennylane.typing import TensorLike
-from pennylane.wires import WiresLike
+from pennylane.wires import Wires, WiresLike
 
 from .controlled import ControlledOp
 from .controlled_decompositions import decompose_mcx
@@ -94,9 +93,6 @@ class ControlledQubitUnitary(ControlledOp):
     >>> qml.ControlledQubitUnitary(U, wires=[0, 1, 2, 3], control_values=[False, True, True])
     """
 
-    num_wires = AnyWires
-    """int: Number of wires that the operator acts on."""
-
     num_params = 1
     """int: Number of trainable parameters that the operator depends on."""
 
@@ -1319,9 +1315,6 @@ class MultiControlledX(ControlledOp):
     is_self_inverse = True
     """bool: Whether or not the operator is self-inverse."""
 
-    num_wires = AnyWires
-    """int: Number of wires the operation acts on."""
-
     num_params = 0
     """int: Number of trainable parameters that the operator depends on."""
 

pennylane/ops/op_math/exp.py

@@ -23,7 +23,6 @@
 from pennylane import math
 from pennylane.math import expand_matrix
 from pennylane.operation import (
-    AnyWires,
     DecompositionUndefinedError,
     GeneratorUndefinedError,
     Operation,
@@ -297,11 +296,11 @@ def _smart_decomposition(self, coeff, base):
         for op_name in qml.ops.qubit.__all__:  # pylint:disable=no-member
             op_class = getattr(qml.ops.qubit, op_name)  # pylint:disable=no-member
             if op_class.has_generator:
-                if op_class.num_wires == AnyWires:
+                if op_class.num_wires is None:
                     has_generator_types_anywires.append(op_class)
                 elif op_class.num_wires == len(base.wires):
                     has_generator_types.append(op_class)
-        # Ensure op_class.num_wires == base.num_wires before op_class.num_wires == AnyWires
+        # Ensure op_class.num_wires == base.num_wires before op_class.num_wires is None
         has_generator_types.extend(has_generator_types_anywires)
 
         for op_class in has_generator_types:

pennylane/ops/op_math/linear_combination.py

@@ -103,7 +103,6 @@ class LinearCombination(Sum):
     using the :func:`compute_grouping <pennylane.ops.LinearCombination.compute_grouping>` method.
     """
 
-    num_wires = qml.operation.AnyWires
     grad_method = "A"  # supports analytic gradients
     batch_size = None
     ndim_params = None  # could be (0,) * len(coeffs), but it is not needed. Define at class-level

pennylane/ops/qubit/arithmetic_ops.py

@@ -23,7 +23,7 @@
 
 import pennylane as qml
 from pennylane.decomposition import add_decomps, register_resources
-from pennylane.operation import AnyWires, FlatPytree, Operation
+from pennylane.operation import FlatPytree, Operation
 from pennylane.ops import Identity
 from pennylane.typing import TensorLike
 from pennylane.wires import Wires, WiresLike
@@ -401,7 +401,6 @@ class IntegerComparator(Operation):
     """
 
     is_self_inverse: bool = True
-    num_wires = AnyWires
     num_params: int = 0
     """int: Number of trainable parameters that the operator depends on."""