Add hardware-efficient particle-conserving ansatz U2

doc/introduction/templates.rst

@@ -110,6 +110,11 @@ neural network. Note arbitrary templates or operations can also be layered using
     :description: BasicEntanglerLayers
     :figure: ../_static/templates/layers/basic_entangler.png
 
+.. customgalleryitem::
+    :link: ../code/api/pennylane.templates.layers.ParticleConservingU2.html
+    :description: ParticleConservingU2
+    :figure: ../_static/templates/layers/particle_conserving_u2.png
+
 .. raw:: html
 
         <div style='clear:both'></div>

pennylane/init.py

@@ -20,6 +20,64 @@
 from pennylane import numpy as np
 
 
+def particle_conserving_u2_uniform(n_layers, n_wires, low=0, high=2 * pi, seed=None):
+    r"""Creates a parameter array for :func:`~.ParticleConservingU2`, drawn from a uniform
+    distribution.
+    Each parameter is drawn uniformly at random from between ``low`` and ``high``.
+    The parameters define the trainable angles entering the Z rotation
+    :math:`R_\mathrm{z}(\vec{\theta})` and particle-conserving gate :math:`U_{2,\mathrm{ex}}`
+    implemented by the :func:`~.u2_ex_gate()`.
+    Args:
+        n_layers (int): number of layers
+        n_wires (int): number of qubits
+        low (float): minimum value of uniform distribution
+        high (float): maximum value of uniform distribution
+        seed (int): seed used in sampling the parameters, makes function call deterministic
+    Returns:
+        array: parameter array
+    """
+
+    if seed is not None:
+        np.random.seed(seed)
+
+    if n_wires < 2:
+        raise ValueError(
+            "The number of qubits must be greater than one; got 'n_wires' = {}".format(n_wires)
+        )
+
+    params = np.random.uniform(low=low, high=high, size=(n_layers, 2 * n_wires - 1))
+    return params
+
+
+def particle_conserving_u2_normal(n_layers, n_wires, mean=0, std=0.1, seed=None):
+    r"""Creates a parameter array for :func:`~.ParticleConservingU2`, drawn from a normal
+    distribution.
+    Each parameter is drawn from a normal distribution with ``mean`` and standard deviation ``std``.
+    The parameters define the trainable angles entering the Z rotation
+    :math:`R_\mathrm{z}(\vec{\theta})` and particle-conserving gate :math:`U_{2,\mathrm{ex}}`
+    implemented by the :func:`~.u2_ex_gate()`.
+    Args:
+        n_layers (int): number of layers
+        n_wires (int): number of qubits
+        mean (float): mean of parameters
+        std (float): standard deviation of parameters
+        seed (int): seed used in sampling the parameters, makes function call deterministic
+    Returns:
+        array: parameter array
+    """
+
+    if seed is not None:
+        np.random.seed(seed)
+
+    if n_wires < 2:
+        raise ValueError(
+            "The number of qubits must be greater than one; got 'n_wires' = {}".format(n_wires)
+        )
+
+    params = np.random.normal(loc=mean, scale=std, size=(n_layers, 2 * n_wires - 1))
+    return params
+
+
 def qaoa_embedding_uniform(n_layers, n_wires, low=0, high=2 * pi, seed=None):
     r"""Creates a parameter array for :func:`~.QAOAEmbedding`, drawn from a uniform
     distribution.

pennylane/templates/layers/__init__.py

@@ -21,3 +21,4 @@
 from .cv_neural_net import CVNeuralNetLayers
 from .simplified_two_design import SimplifiedTwoDesign
 from .basic_entangler import BasicEntanglerLayers
+from .particle_conserving_u2 import ParticleConservingU2

pennylane/templates/layers/particle_conserving_u2.py

@@ -0,0 +1,192 @@
+# Copyright 2018-2020 Xanadu Quantum Technologies Inc.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+r"""
+Contains the hardware efficient ``ParticleConservingU2`` template.
+"""
+import pennylane as qml
+
+# pylint: disable-msg=too-many-branches,too-many-arguments,protected-access
+from pennylane.templates.decorator import template
+from pennylane.ops import CNOT, CRX, RZ
+from pennylane.templates.utils import (
+    check_shape,
+    get_shape,
+)
+from pennylane.wires import Wires
+
+
+def u2_ex_gate(phi, wires=None):
+    r"""Implement the two-qubit exchange gate :math:`U_{2,\mathrm{ex}}` proposed in
+    `arXiv:1805.04340 <https://arxiv.org/abs/1805.04340>`_ to build particle-conserving VQE ansatze
+    for Quantum Chemistry simulations.
+
+    The unitary matrix :math:`U_{2, \mathrm{ex}}` acts on the Hilbert space of two qubits
+
+    .. math::
+
+        U_{2, \mathrm{ex}}(\phi) = \left(\begin{array}{cccc}
+        1 & 0 & 0 & 0 \\
+        0 & \mathrm{cos}(\phi) & -i\;\mathrm{sin}(\phi) & 0 \\
+        0 & -i\;\mathrm{sin}(\phi) & \mathrm{cos}(\phi) & 0 \\
+        0 & 0 & 0 & 1 \\
+        \end{array}\right).
+
+    The figure below shows the circuit used to decompose :math:`U_{2, \mathrm{ex}}` in
+    elementary gates
+
+    |
+
+    .. figure:: ../../_static/templates/layers/u2_decomposition.png
+        :align: center
+        :width: 60%
+        :target: javascript:void(0);
+
+    |
+
+    Args:
+        phi (float): angle entering the controlled-RX operator :math:`CRX(2\phi)`
+        wires (list[Wires]): the two wires ``n`` and ``m`` the circuit acts on
+    """
+
+    CNOT(wires=wires)
+    CRX(2 * phi, wires=wires[::-1])
+    CNOT(wires=wires)
+
+
+@template
+def ParticleConservingU2(weights, wires, init_state=None):
+    r"""Implements the heuristic VQE ansatz for Quantum Chemistry simulations using the
+    particle-conserving gate :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 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}^{(i)}_\mathrm{z}(\vec{\theta}_i) \hat{U}^{(i)}_\mathrm{2,\mathrm{ex}}(\vec{\phi}_i)`
+    as 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 (array[float]): Array of weights of shape ``(D, M)`` where ``D`` is the number of
+            layers and ``M`` = :math:`2N-1` is the total number of rotation ``(N)`` and exchange
+            ``(N-1)`` gates per layer.
+        wires (Iterable or Wires): Wires that the template acts on. Accepts an iterable of numbers
+            or strings, or a Wires object.
+        init_state (array[int]): Length ``len(wires)`` occupation-number vector representing the
+            HF state. ``init_state`` is used to initialize the wires.
+
+    Raises:
+        ValueError: if inputs do not have the correct format
+
+    .. UsageDetails::
+
+        Notice that:
+
+        #. 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
+            from pennylane.templates import ParticleConservingU2
+
+            from functools import partial
+
+            # Build the electronic Hamiltonian
+            h, qubits = qml.qchem.molecular_hamiltonian("h2", "h2.xyz")
+
+            # 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(ParticleConservingU2, init_state=ref_state)
+
+            # Define the cost function
+            cost_fn = qml.VQECost(ansatz, h, dev)
+
+            # Compute the expectation value of 'h' for given set of parameters
+            layers = 1
+            params = qml.init.particle_conserving_u2_normal(layers, qubits)
+            print(cost_fn(params))
+    """
+
+    wires = Wires(wires)
+
+    layers = weights.shape[0]
+
+    if len(wires) < 2:
+        raise ValueError(
+            "This template requires the number of qubits to be greater than one;"
+            " got 'len(wires)' = {}".format(len(wires))
+        )
+
+    expected_shape = (layers, 2 * len(wires) - 1)
+    check_shape(
+        weights,
+        expected_shape,
+        msg="'weights' must be of shape {}; got {}".format(expected_shape, get_shape(weights)),
+    )
+
+    nm_wires = [wires.subset([l, l + 1]) for l in range(0, len(wires) - 1, 2)]
+    nm_wires += [wires.subset([l, l + 1]) for l in range(1, len(wires) - 1, 2)]
+
+    qml.BasisState(init_state, wires=wires)
+
+    for l in range(layers):
+
+        for j, _ in enumerate(wires):
+            RZ(weights[l, j], wires=wires[j])
+
+        for i, wires_ in enumerate(nm_wires):
+            u2_ex_gate(weights[l, len(wires) + i], wires=wires_)

tests/templates/test_integration.py

@@ -148,6 +148,10 @@
                                {'wires': [0, 1, 2, 3], 's_wires': [[0, 1, 2], [1, 2, 3]],
                                 'd_wires': [[[0, 1], [2, 3]]], 'init_state':np.array([1, 1, 0, 0])},
                                4),
+                              (qml.templates.ParticleConservingU2,
+                               {'weights': np.array([[0.35172862, 0.60808317, 1.44397231]])},
+                               {'wires': [0, 1], 'init_state': np.array([1, 0])},
+                               2),
                               ]
 
 CV_DIFFABLE_NONDIFFABLE = [(qml.templates.DisplacementEmbedding,
@@ -184,7 +188,7 @@
 # before they are called in a quantum function.
 # These templates will be skipped in tests of that nature.
 
-NO_OP_BEFORE = ["AmplitudeEmbedding", "UCCSD"]
+NO_OP_BEFORE = ["AmplitudeEmbedding", "UCCSD",  "ParticleConservingU2"]
 
 # Each entry to QUBIT_INIT and CV_INIT adds a template with specified inputs to the
 # integration tests ``TestIntegrationInitFunctions``