class_docstr: The MPS template broadcasts an input circuit across many wires following the architecture of a Matrix Product State tensor network.
  The result is similar to the architecture in `arXiv:1803.11537 <https://arxiv.org/abs/1803.11537>`_.
  
  The keyword argument ``block`` is a user-defined quantum circuit that should accept two arguments: ``wires`` and ``weights``.
  The latter argument is optional in case the implementation of ``block`` doesn't require any weights. Any additional arguments
  should be provided using the ``kwargs``.
  
  Args:
      wires (Iterable): wires that the template acts on
      n_block_wires (int): number of wires per block
      block (Callable): quantum circuit that defines a block
      n_params_block (int): the number of parameters in a block; equal to the length of the ``weights`` argument in ``block``
      template_weights (Sequence): list containing the weights for all blocks
      offset (int): offset value for positioning the subsequent blocks relative to each other.
          If ``None``, it defaults to :math:`\text{offset} = \lfloor \text{n_block_wires}/2  \rfloor`,
          otherwise :math:`\text{offset} \in [1, \text{n_block_wires} - 1]`
      **kwargs: additional keyword arguments for implementing the ``block``
  
  .. note::
  
      The expected number of blocks can be obtained from ``qml.MPS.get_n_blocks(wires, n_block_wires, offset=0)``, and
      the length of ``template_weights`` argument should match the number of blocks. Whenever either ``n_block_wires``
      is odd or ``offset`` is not :math:`\lfloor \text{n_block_wires}/2  \rfloor`, the template deviates from the maximally
      unbalanced tree architecture described in `arXiv:1803.11537 <https://arxiv.org/abs/1803.11537>`_.
  
  .. details::
      :title: Usage Details
  
      This example demonstrates the use of ``MPS`` for a simple block.
  
      .. code-block:: python
  
          import pennylane as qml
          import numpy as np
  
          def block(weights, wires):
              qml.CNOT(wires=[wires[0],wires[1]])
              qml.RY(weights[0], wires=wires[0])
              qml.RY(weights[1], wires=wires[1])
  
          n_wires = 4
          n_block_wires = 2
          n_params_block = 2
          n_blocks = qml.MPS.get_n_blocks(range(n_wires),n_block_wires)
          template_weights = [[0.1, -0.3]] * n_blocks
  
          dev= qml.device('default.qubit',wires=range(n_wires))
          @qml.qnode(dev)
          def circuit(template_weights):
              qml.MPS(range(n_wires),n_block_wires,block, n_params_block, template_weights)
              return qml.expval(qml.PauliZ(wires=n_wires-1))
  
      >>> print(qml.draw(circuit, expansion_strategy='device')(template_weights))
      0: ─╭●──RY(0.10)──────────────────────────────┤
      1: ─╰X──RY(-0.30)─╭●──RY(0.10)────────────────┤
      2: ───────────────╰X──RY(-0.30)─╭●──RY(0.10)──┤
      3: ─────────────────────────────╰X──RY(-0.30)─┤  <Z>
  
      MPS can also be used with an ``offset`` argument that shifts the positioning the subsequent blocks from the default ``n_block_wires/2``.
  
      .. code-block:: python
  
          import pennylane as qml
          import numpy as np
  
          def block(wires):
              qml.MultiControlledX(wires=[wires[i] for i in range(len(wires))])
  
          n_wires = 8
          n_block_wires = 4
          n_params_block = 2
  
          dev= qml.device('default.qubit',wires=n_wires)
          @qml.qnode(dev)
          def circuit():
              qml.MPS(range(n_wires),n_block_wires, block, n_params_block, offset = 1)
              return qml.state()
  
      >>> print(qml.draw(circuit, expansion_strategy='device')())
      0: ─╭●─────────────┤  State
      1: ─├●─╭●──────────┤  State
      2: ─├●─├●─╭●───────┤  State
      3: ─╰X─├●─├●─╭●────┤  State
      4: ────╰X─├●─├●─╭●─┤  State
      5: ───────╰X─├●─├●─┤  State
      6: ──────────╰X─├●─┤  State
      7: ─────────────╰X─┤  State
code: def __init__(
      self,
      wires,
      n_block_wires,
      block,
      n_params_block=0,
      template_weights=None,
      offset=None,
      id=None,
      **kwargs,
  ):
      ind_gates = compute_indices_MPS(wires, n_block_wires, offset)
      n_blocks = self.get_n_blocks(wires, n_block_wires, offset)
  
      if template_weights is not None:
          shape = qml.math.shape(
              template_weights
          )  # (n_blocks, n_params_block)
          if shape[0] != n_blocks:
              raise ValueError(
                  f"Weights tensor must have first dimension of length {n_blocks}; got {shape[0]}"
              )
          if shape[-1] != n_params_block:
              raise ValueError(
                  f"Weights tensor must have last dimension of length {n_params_block}; got {shape[-1]}"
              )
  
      self._weights = template_weights
      self._hyperparameters = {
          "ind_gates": ind_gates,
          "block": block,
          **kwargs,
      }
  
      if self._weights is None:
          super().__init__(wires=wires, id=id)
      else:
          super().__init__(self._weights, wires=wires, id=id)
  
file_path: pennylane/pennylane/templates/tensornetworks/mps.py
imports: import warnings
  import pennylane
  from pennylane.operation import Operation, AnyWires
label_desc: Use image node_id 2 to create a new MPS object from inherited base classes: Operation with example: obj = MPS(wires, n_block_wires, block, n_params_block, template_weights, offset, id)