[QAOA] Adds Built-In Mixer Hamiltonians

doc/code/qml_qaoa.rst

@@ -0,0 +1,9 @@
+qml.qaoa
+========
+
+.. currentmodule:: pennylane.qaoa
+
+.. automodapi:: pennylane.qaoa
+    :no-heading:
+    :no-inheritance-diagram:
+    :no-inherited-members:

doc/index.rst

@@ -214,3 +214,4 @@ PennyLane is **free** and **open source**, released under the Apache License, Ve
    code/qml_variable
    code/qml_wires
    code/qml_beta
+   code/qml_qaoa

pennylane/qaoa/__init__.py

@@ -0,0 +1,18 @@
+# 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"""
+This module contains functionality to construct QAOA workflows in PennyLane
+"""
+
+from .mixers import *

pennylane/qaoa/mixers.py

@@ -0,0 +1,79 @@
+# 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"""
+This file contains built-in functions for constructing QAOA mixer Hamiltonians.
+"""
+import networkx as nx
+import pennylane as qml
+
+
+def x_mixer(n):
+    r"""Creates a basic Pauli-X mixer Hamiltonian.
+
+    This Hamiltonian is defined as:
+
+    .. math:: H_M \ = \ \displaystyle\sum_{i} X_{i},
+
+    where :math:`i` ranges over all wires, and :math:`X_i`
+    denotes the Pauli-X operator on the :math:`i`-th wire.
+    This is the mixer that was used in the `original QAOA
+    paper <https://arxiv.org/abs/1411.4028>`__.
+
+
+    Args:
+        n (int): The number of wires on which the Hamiltonian is applied
+
+    Returns:
+        Hamiltonian: Mixer Hamiltonian
+    """
+
+    wires = range(n)
+
+    coeffs = [1 for w in wires]
+    obs = [qml.PauliX(w) for w in wires]
+
+    return qml.Hamiltonian(coeffs, obs)
+
+
+def xy_mixer(graph):
+    r"""Creates a generalized SWAP/XY mixer Hamiltonian.
+
+    This mixer Hamiltonian is defined as:
+
+    .. math:: H_M \ = \ \frac{1}{2} \displaystyle\sum_{(i, j) \in E(G)} X_i X_j \ + \ Y_i Y_j,
+
+    for some graph :math:`G`. :math:`X_i` and :math:`Y_i` denote the Pauli-X and Pauli-Y operators on the :math:`i`-th
+    wire respectively. This mixer was first presented in `this paper <https://arxiv.org/abs/1709.03489>`__.
+
+    Args:
+        graph (nx.Graph): A graph defining the pairs of wires on which each term of the Hamiltonian acts.
+
+    Returns:
+         Hamiltonian: Mixer Hamiltonian
+        """
+
+    if not isinstance(graph, nx.Graph):
+        raise ValueError(
+            "Input graph must be a nx.Graph object, got {}".format(type(graph).__name__)
+        )
+
+    edges = graph.edges
+    coeffs = 2 * [0.5 for e in edges]
+
+    obs = []
+    for node1, node2 in edges:
+        obs.append(qml.PauliX(node1) @ qml.PauliX(node2))
+        obs.append(qml.PauliY(node1) @ qml.PauliY(node2))
+
+    return qml.Hamiltonian(coeffs, obs)

tests/test_qaoa.py

@@ -0,0 +1,136 @@
+# 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.
+"""
+Unit tests for the :mod:`pennylane.qaoa` submodule.
+"""
+import pytest
+import numpy as np
+import pennylane as qml
+from pennylane import qaoa
+from networkx import Graph
+
+
+#####################################################
+
+graph = Graph()
+graph.add_nodes_from([0, 1, 2])
+graph.add_edges_from([(0, 1), (1, 2)])
+
+non_consecutive_graph = Graph([(0, 4), (3, 4), (2, 1), (2, 0)])
+
+
+class TestMixerHamiltonians:
+    """Tests that the mixer Hamiltonians are being generated correctly"""
+
+    def test_x_mixer_output(self):
+        """Tests that the output of the Pauli-X mixer is correct"""
+
+        num_wires = 4
+        mixer_hamiltonian = qaoa.x_mixer(num_wires)
+
+        mixer_coeffs = mixer_hamiltonian.coeffs
+        mixer_ops = [i.name for i in mixer_hamiltonian.ops]
+        mixer_wires = [i.wires[0] for i in mixer_hamiltonian.ops]
+
+        assert mixer_coeffs == [1, 1, 1, 1]
+        assert mixer_ops == ["PauliX", "PauliX", "PauliX", "PauliX"]
+        assert mixer_wires == [0, 1, 2, 3]
+
+    def test_xy_mixer_type_error(self):
+        """Tests that the XY mixer throws the correct error"""
+
+        graph = [(0, 1), (1, 2)]
+
+        with pytest.raises(ValueError, match=r"Input graph must be a nx.Graph object, got list"):
+            output = qaoa.xy_mixer(graph)
+
+    @pytest.mark.parametrize(
+        ("graph", "target_hamiltonian"),
+        [
+            (
+                Graph([(0, 1), (1, 2), (2, 3)]),
+                qml.Hamiltonian(
+                    [0.5, 0.5, 0.5, 0.5, 0.5, 0.5],
+                    [
+                        qml.PauliX(0) @ qml.PauliX(1),
+                        qml.PauliY(0) @ qml.PauliY(1),
+                        qml.PauliX(1) @ qml.PauliX(2),
+                        qml.PauliY(1) @ qml.PauliY(2),
+                        qml.PauliX(2) @ qml.PauliX(3),
+                        qml.PauliY(2) @ qml.PauliY(3),
+                    ],
+                ),
+            ),
+            (
+                Graph((np.array([0, 1]), np.array([1, 2]), np.array([2, 0]))),
+                qml.Hamiltonian(
+                    [0.5, 0.5, 0.5, 0.5, 0.5, 0.5],
+                    [
+                        qml.PauliX(0) @ qml.PauliX(1),
+                        qml.PauliY(0) @ qml.PauliY(1),
+                        qml.PauliX(0) @ qml.PauliX(2),
+                        qml.PauliY(0) @ qml.PauliY(2),
+                        qml.PauliX(1) @ qml.PauliX(2),
+                        qml.PauliY(1) @ qml.PauliY(2),
+                    ],
+                ),
+            ),
+            (
+                graph,
+                qml.Hamiltonian(
+                    [0.5, 0.5, 0.5, 0.5],
+                    [
+                        qml.PauliX(0) @ qml.PauliX(1),
+                        qml.PauliY(0) @ qml.PauliY(1),
+                        qml.PauliX(1) @ qml.PauliX(2),
+                        qml.PauliY(1) @ qml.PauliY(2),
+                    ],
+                ),
+            ),
+            (
+                non_consecutive_graph,
+                qml.Hamiltonian(
+                    [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5],
+                    [
+                        qml.PauliX(0) @ qml.PauliX(4),
+                        qml.PauliY(0) @ qml.PauliY(4),
+                        qml.PauliX(0) @ qml.PauliX(2),
+                        qml.PauliY(0) @ qml.PauliY(2),
+                        qml.PauliX(4) @ qml.PauliX(3),
+                        qml.PauliY(4) @ qml.PauliY(3),
+                        qml.PauliX(2) @ qml.PauliX(1),
+                        qml.PauliY(2) @ qml.PauliY(1),
+                    ],
+                ),
+            ),
+        ],
+    )
+    def test_xy_mixer_output(self, graph, target_hamiltonian):
+        """Tests that the output of the XY mixer is correct"""
+
+        print(graph.edges)
+
+        mixer_hamiltonian = qaoa.xy_mixer(graph)
+
+        mixer_coeffs = mixer_hamiltonian.coeffs
+        mixer_ops = [i.name for i in mixer_hamiltonian.ops]
+        mixer_wires = [i.wires for i in mixer_hamiltonian.ops]
+
+        target_coeffs = target_hamiltonian.coeffs
+        target_ops = [i.name for i in target_hamiltonian.ops]
+        target_wires = [i.wires for i in target_hamiltonian.ops]
+
+        assert mixer_coeffs == target_coeffs
+        assert mixer_ops == target_ops
+        assert mixer_wires == target_wires