class_docstr: Symbolic operator denoting a controlled operator.
  
  Args:
      base (~.operation.Operator): the operator that is controlled
      control_wires (Any): The wires to control on.
  
  Keyword Args:
      control_values (Iterable[Bool]): The values to control on. Must be the same
          length as ``control_wires``. Defaults to ``True`` for all control wires.
          Provided values are converted to `Bool` internally.
      work_wires (Any): Any auxiliary wires that can be used in the decomposition
  
  .. note::
      This class, ``Controlled``, denotes a controlled version of any individual operation.
      :class:`~.ControlledOp` adds :class:`~.Operation` specific methods and properties to the
      more general ``Controlled`` class.
  
  .. seealso:: :class:`~.ControlledOp`, and :func:`~.ctrl`
  
  **Example**
  
  >>> base = qml.RX(1.234, 1)
  >>> Controlled(base, (0, 2, 3), control_values=[True, False, True])
  Controlled(RX(1.234, wires=[1]), control_wires=[0, 2, 3], control_values=[True, False, True])
  >>> op = Controlled(base, 0, control_values=[0])
  >>> op
  Controlled(RX(1.234, wires=[1]), control_wires=[0], control_values=[0])
  
  The operation has both standard :class:`~.operation.Operator` properties
  and ``Controlled`` specific properties:
  
  >>> op.base
  RX(1.234, wires=[1])
  >>> op.data
  (1.234,)
  >>> op.wires
  <Wires = [0, 1]>
  >>> op.control_wires
  <Wires = [0]>
  >>> op.target_wires
  <Wires = [1]>
  
  Control values are lists of booleans, indicating whether or not to control on the
  ``0==False`` value or the ``1==True`` wire.
  
  >>> op.control_values
  [0]
  
  Provided control values are converted to booleans internally, so
  any "truthy" or "falsy" objects work.
  
  >>> Controlled(base, ("a", "b", "c"), control_values=["", None, 5]).control_values
  [False, False, True]
  
  Representations for an operator are available if the base class defines them.
  Sparse matrices are available if the base class defines either a sparse matrix
  or only a dense matrix.
  
  >>> np.set_printoptions(precision=4) # easier to read the matrix
  >>> qml.matrix(op)
  array([[0.8156+0.j    , 0.    -0.5786j, 0.    +0.j    , 0.    +0.j    ],
         [0.    -0.5786j, 0.8156+0.j    , 0.    +0.j    , 0.    +0.j    ],
         [0.    +0.j    , 0.    +0.j    , 1.    +0.j    , 0.    +0.j    ],
         [0.    +0.j    , 0.    +0.j    , 0.    +0.j    , 1.    +0.j    ]])
  >>> qml.eigvals(op)
  array([1.    +0.j    , 1.    +0.j    , 0.8156+0.5786j, 0.8156-0.5786j])
  >>> print(qml.generator(op, format='observable'))
  (-0.5) [Projector0 X1]
  >>> op.sparse_matrix()
  <4x4 sparse matrix of type '<class 'numpy.complex128'>'
              with 6 stored elements in Compressed Sparse Row format>
  
  If the provided base matrix is an :class:`~.operation.Operation`, then the created
  object will be of type :class:`~.ops.op_math.ControlledOp`. This class adds some additional
  methods and properties to the basic :class:`~.ops.op_math.Controlled` class.
  
  >>> type(op)
  <class 'pennylane.ops.op_math.controlled_class.ControlledOp'>
  >>> op.parameter_frequencies
  [(0.5, 1.0)]
docstr: The control wires.
docstr_tok: ["The","control","wires","."]
code: def control_wires(self):
      """The control wires."""
      return self.hyperparameters["control_wires"]
  
imports: import warnings
  from copy import copy
  from functools import wraps
  from inspect import signature
  from typing import List
  import numpy
  from scipy import sparse
  import pennylane
  from pennylane import operation
  from pennylane import math
  from pennylane.operation import Operator
  from pennylane.wires import Wires
  from pennylane.compiler import compiler
  from .symbolicop import SymbolicOp
  from .controlled_decompositions import ctrl_decomp_bisect, ctrl_decomp_zyz
label_desc: Use image node_id 12 for calling the Controlled obj's underlying member method code with example usage: obj.control_wires() and returns: self