class_docstr: Layers consisting of a simplified 2-design architecture of Pauli-Y rotations and controlled-Z entanglers
  proposed in `Cerezo et al. (2021) <https://doi.org/10.1038/s41467-021-21728-w>`_.
  
  A 2-design is an ensemble of unitaries whose statistical properties are the same as sampling random unitaries
  with respect to the Haar measure up to the first 2 moments.
  
  The template is not a strict 2-design, since
  it does not consist of universal 2-qubit gates as building blocks, but has been shown in
  `Cerezo et al. (2021) <https://doi.org/10.1038/s41467-021-21728-w>`_ to exhibit important properties to study "barren plateaus"
  in quantum optimization landscapes.
  
  The template starts with an initial layer of single qubit Pauli-Y rotations, before the main
  :math:`L` layers are applied. The basic building block of the main layers are controlled-Z entanglers
  followed by a pair of Pauli-Y rotation gates (one for each wire).
  Each layer consists of an "even" part whose entanglers start with the first qubit,
  and an "odd" part that starts with the second qubit.
  
  This is an example of two layers, including the initial layer:
  
  .. figure:: ../../_static/templates/layers/simplified_two_design.png
      :align: center
      :width: 40%
      :target: javascript:void(0);
  
  |
  
  The argument ``initial_layer_weights`` contains the rotation angles of the initial layer of Pauli-Y rotations,
  while ``weights`` contains the pairs of Pauli-Y rotation angles of the respective layers. Each layer takes
  :math:`\lfloor M/2 \rfloor + \lfloor (M-1)/2 \rfloor = M-1` pairs of angles, where :math:`M` is the number of wires.
  The number of layers :math:`L` is derived from the first dimension of ``weights``.
  
  Args:
      initial_layer_weights (tensor_like): weight tensor for the initial rotation block, shape ``(M,)``
      weights (tensor_like): tensor of rotation angles for the layers, shape ``(L, M-1, 2)``
      wires (Iterable): wires that the template acts on
  
  
  .. details::
      :title: Usage Details
  
      template - here shown for two layers - is used inside a :class:`QNode <pennylane.QNode>`:
  
      .. code-block:: python
  
          import pennylane as qml
          from math import pi
  
          n_wires = 3
          dev = qml.device('default.qubit', wires=n_wires)
  
          @qml.qnode(dev)
          def circuit(init_weights, weights):
              qml.SimplifiedTwoDesign(initial_layer_weights=init_weights, weights=weights, wires=range(n_wires))
              return [qml.expval(qml.PauliZ(wires=i)) for i in range(n_wires)]
  
          init_weights = [pi, pi, pi]
          weights_layer1 = [[0., pi],
                            [0., pi]]
          weights_layer2 = [[pi, 0.],
                            [pi, 0.]]
          weights = [weights_layer1, weights_layer2]
  
          >>> circuit(init_weights, weights)
          [1., -1., 1.]
  
      **Parameter shapes**
  
      A list of shapes for the two weights arguments can be computed with the static method
      :meth:`~.qml.SimplifiedTwoDesign.shape` and used when creating randomly
      initialised weight tensors:
  
      .. code-block:: python
  
          shapes = qml.SimplifiedTwoDesign.shape(n_layers=2, n_wires=2)
          weights = [np.random.random(size=shape) for shape in shapes]
docstr: Returns a list of shapes for the 2 parameter tensors.
  
  Args:
      n_layers (int): number of layers
      n_wires (int): number of wires
  
  Returns:
      list[tuple[int]]: list of shapes
docstr_tok: ["Returns","a","list","of","shapes","for","the","2","parameter","tensors",".","Args",":","n_layers","(","int",")",":","number","of","layers","n_wires","(","int",")",":","number","of","wires","Returns",":","list","[","tuple","[","int","]","]",":","list","of","shapes"]
code: def shape(n_layers, n_wires):
      r"""Returns a list of shapes for the 2 parameter tensors.
  
      Args:
          n_layers (int): number of layers
          n_wires (int): number of wires
  
      Returns:
          list[tuple[int]]: list of shapes
      """
  
      if n_wires == 1:
          return [(n_wires,), (n_layers,)]
  
      return [(n_wires,), (n_layers, n_wires - 1, 2)]
  
imports: import pennylane
  from pennylane.operation import Operation, AnyWires
label_desc: Use image node_id 4 for calling the SimplifiedTwoDesign obj's underlying member method code with example usage: obj.shape(n_layers, n_wires) and returns: list, list