class_docstr: Implements the heuristic VQE ansatz for Quantum Chemistry simulations using the
  particle-conserving entangler :math:`U_\mathrm{ent}(\vec{\theta}, \vec{\phi})` proposed in
  `arXiv:1805.04340 <https://arxiv.org/abs/1805.04340>`_.
  
  This template prepares :math:`N`-qubit trial states by applying :math:`D` layers of the entangler
  block :math:`U_\mathrm{ent}(\vec{\theta}, \vec{\phi})` to the Hartree-Fock state
  
  .. math::
  
      \vert \Psi(\vec{\theta}, \vec{\phi}) \rangle = \hat{U}^{(D)}_\mathrm{ent}(\vec{\theta}_D,
      \vec{\phi}_D) \dots \hat{U}^{(2)}_\mathrm{ent}(\vec{\theta}_2, \vec{\phi}_2)
      \hat{U}^{(1)}_\mathrm{ent}(\vec{\theta}_1, \vec{\phi}_1) \vert \mathrm{HF}\rangle,
  
  where :math:`\hat{U}^{(i)}_\mathrm{ent}(\vec{\theta}_i, \vec{\phi}_i) =
  \hat{R}_\mathrm{z}(\vec{\theta}_i) \hat{U}_\mathrm{2,\mathrm{ex}}(\vec{\phi}_i)`.
  The circuit implementing the entangler blocks is shown in the figure below:
  
  |
  
  .. figure:: ../../_static/templates/layers/particle_conserving_u2.png
      :align: center
      :width: 60%
      :target: javascript:void(0);
  
  |
  
  Each layer contains :math:`N` rotation gates :math:`R_\mathrm{z}(\vec{\theta})` and
  :math:`N-1` particle-conserving exchange gates :math:`U_{2,\mathrm{ex}}(\phi)`
  that act on pairs of nearest-neighbors qubits. The repeated units across several qubits are
  shown in dotted boxes.  The unitary matrix representing :math:`U_{2,\mathrm{ex}}(\phi)`
  (`arXiv:1805.04340 <https://arxiv.org/abs/1805.04340>`_) is decomposed into its elementary
  gates and implemented in the :func:`~.u2_ex_gate` function using PennyLane quantum operations.
  
  |
  
  .. figure:: ../../_static/templates/layers/u2_decomposition.png
      :align: center
      :width: 60%
      :target: javascript:void(0);
  
  |
  
  
  Args:
      weights (tensor_like): Weight tensor of shape ``(D, M)`` where ``D`` is the number of
          layers and ``M`` = ``2N-1`` is the total number of rotation ``(N)`` and exchange
          ``(N-1)`` gates per layer.
      wires (Iterable): wires that the template acts on
      init_state (tensor_like): iterable or shape ``(len(wires),)`` tensor representing the Hartree-Fock state
          used to initialize the wires.
  
  .. details::
      :title: Usage Details
  
  
      #. The number of wires has to be equal to the number of spin orbitals included in
         the active space.
  
      #. The number of trainable parameters scales with the number of layers :math:`D` as
         :math:`D(2N-1)`.
  
      An example of how to use this template is shown below:
  
      .. code-block:: python
  
          import pennylane as qml
          import numpy as np
          from functools import partial
  
          # Build the electronic Hamiltonian
          symbols, coordinates = (['H', 'H'], np.array([0., 0., -0.66140414, 0., 0., 0.66140414]))
          h, qubits = qml.qchem.molecular_hamiltonian(symbols, coordinates)
  
          # Define the HF state
          ref_state = qml.qchem.hf_state(2, qubits)
  
          # Define the device
          dev = qml.device('default.qubit', wires=qubits)
  
          # Define the ansatz
          ansatz = partial(qml.ParticleConservingU2, init_state=ref_state)
  
          # Define the cost function
          cost_fn = qml.ExpvalCost(ansatz, h, dev)
  
          # Compute the expectation value of 'h' for a given set of parameters
          layers = 1
          shape = qml.ParticleConservingU2.shape(layers, qubits)
          params = np.random.random(shape)
          print(cost_fn(params))
  
      **Parameter shape**
  
      The shape of the trainable weights tensor can be computed by the static method
      :meth:`~qml.ParticleConservingU2.shape` and used when creating randomly
      initialised weight tensors:
  
      .. code-block:: python
  
          shape = qml.ParticleConservingU2.shape(n_layers=2, n_wires=2)
          params = np.random.random(size=shape)
code: def num_params(self):
      return 1
  
file_path: pennylane/pennylane/templates/layers/particle_conserving_u2.py
imports: import pennylane
  from pennylane.operation import Operation, AnyWires
label_desc: Use image node_id 2 for calling the ParticleConservingU2 obj's underlying member method code with example usage: obj.num_params() and returns: int