class_docstr: QutritBasisState(n, wires)
  Prepares a single computational basis state for a qutrit system.
  
  **Details:**
  
  * Number of wires: Any (the operation can act on any number of wires)
  * Number of parameters: 1
  * Gradient recipe: None (integer parameters not supported)
  
  .. note::
  
      If the ``QutritBasisState`` operation is not supported natively on the
      target device, PennyLane will attempt to decompose the operation
      into :class:`~.TShift` operations.
  
  .. note::
  
      When called in the middle of a circuit, the action of the operation is defined
      as :math:`U|0\rangle = |\psi\rangle`
  
  Args:
      n (array): prepares the basis state :math:`\ket{n}`, where ``n`` is an
          array of integers from the set :math:`\{0, 1, 2\}`, i.e.,
          if ``n = np.array([0, 1, 0])``, prepares the state :math:`|010\rangle`.
      wires (Sequence[int] or int): the wire(s) the operation acts on
  
  **Example**
  
  >>> dev = qml.device('default.qutrit', wires=2)
  >>> @qml.qnode(dev)
  ... def example_circuit():
  ...     qml.QutritBasisState(np.array([2, 2]), wires=range(2))
  ...     return qml.state()
  >>> print(example_circuit())
  [0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 0.+0.j 1.+0.j]
docstr: Representation of the operator as a product of other operators (static method). :
  
  .. math:: O = O_1 O_2 \dots O_n.
  
  .. seealso:: :meth:`~.BasisState.decomposition`.
  
  Args:
      n (array): prepares the basis state :math:`\ket{n}`, where ``n`` is an
          array of integers from the set :math:`\{0, 1, 2\}`
      wires (Iterable, Wires): the wire(s) the operation acts on
  
  Returns:
      list[Operator]: decomposition into lower level operations
  
  **Example:**
  
  >>> qml.QutritBasisState.compute_decomposition([1,0], wires=(0,1))
  [QutritBasisStatePreparation(array([1, 0]), wires=[0, 1])]
code: def compute_decomposition(n, wires):
      r"""Representation of the operator as a product of other operators (static method). :
  
      .. math:: O = O_1 O_2 \dots O_n.
  
      .. seealso:: :meth:`~.BasisState.decomposition`.
  
      Args:
          n (array): prepares the basis state :math:`\ket{n}`, where ``n`` is an
              array of integers from the set :math:`\{0, 1, 2\}`
          wires (Iterable, Wires): the wire(s) the operation acts on
  
      Returns:
          list[Operator]: decomposition into lower level operations
  
      **Example:**
  
      >>> qml.QutritBasisState.compute_decomposition([1,0], wires=(0,1))
      [QutritBasisStatePreparation(array([1, 0]), wires=[0, 1])]
  
      """
      return [QutritBasisStatePreparation(n, wires)]
  
file_path: pennylane/pennylane/ops/qutrit/state_preparation.py
imports: import numpy
  from pennylane import math
  from pennylane.operation import AnyWires, StatePrepBase
  from pennylane.templates.state_preparations import QutritBasisStatePreparation
  from pennylane.wires import Wires, WireError
label_desc: Use image node_id 1 for calling the QutritBasisState obj's underlying member method code with example usage: obj.compute_decomposition(n, wires) and returns: list