Add C++ adjoint diff methods

.github/CHANGELOG.md

@@ -9,6 +9,17 @@
 
 ### Improvements
 
+* A new state-vector class `StateVectorManaged` was added, enabling memory use to be bound to 
+  statevector lifetime.
+  [(136)](https://github.com/PennyLaneAI/pennylane-lightning/pull/136)
+
+* The repository now has a well-defined component hierarchy, allowing each indepedent unit to be 
+  compiled and linked separately.
+  [(136)](https://github.com/PennyLaneAI/pennylane-lightning/pull/136)
+
+* PennyLane-Lightning now has support for the adjoint Jacobian method of http://arxiv.org/abs/2009.02823.
+  [(136)](https://github.com/PennyLaneAI/pennylane-lightning/pull/136)
+
 * PennyLane-Lightning can now be installed without compiling its C++ binaries and will fall back
   to using the `default.qubit` implementation. Skipping compilation is achieved by setting the
   `SKIP_COMPILATION` environment variable, e.g., Linux/MacOS: `export SKIP_COMPILATION=True`,
@@ -32,6 +43,8 @@
 
 ### Bug fixes
 
+* An indexing error in the CRY gate is fixed. [(#136)](https://github.com/PennyLaneAI/pennylane-lightning/pull/136)
+
 * Column-major data in numpy is now correctly converted to row-major upon pass to the C++ layer.
   [(#126)](https://github.com/PennyLaneAI/pennylane-lightning/pull/126)
 

.github/workflows/tests.yml

@@ -31,7 +31,7 @@ jobs:
             cmake . -BBuild  -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTS=1
             cmake --build ./Build
             mkdir -p ./Build/tests/results
-            ./Build/tests/runner --order lex --reporter junit --out ./Build/tests/results/report.xml
+            ./Build/pennylane_lightning/src/tests/runner --order lex --reporter junit --out ./Build/tests/results/report.xml
 
       - name: Upload test results
         uses: actions/upload-artifact@v2
@@ -74,6 +74,8 @@ jobs:
           cd main
           python -m pip install --upgrade pip
           pip install -r requirements.txt
+          pip uninstall pennylane -y
+          pip install git+https://github.com/PennyLaneAI/pennylane.git
 
       - name: Install lightning.qubit device
         run: |

.github/workflows/tests_without_binary.yml

@@ -37,6 +37,8 @@ jobs:
           cd main
           python -m pip install --upgrade pip
           pip install -r requirements.txt
+          pip uninstall pennylane -y
+          pip install git+https://github.com/PennyLaneAI/pennylane.git
 
       - name: Install lightning.qubit device
         run: |

.github/workflows/wheel_macos_x86_64.yml

@@ -11,7 +11,7 @@ env:
   # MacOS specific build settings
   CIBW_BEFORE_ALL_MACOS: |
     brew uninstall --force oclint
-    brew install gcc libomp
+    brew install llvm libomp
 
   # Python build settings
   CIBW_BEFORE_BUILD: |
@@ -53,6 +53,8 @@ jobs:
         run: python -m cibuildwheel --output-dir wheelhouse
         env:
           CIBW_ARCHS_MACOS: ${{matrix.arch}}
+          CC: /usr/local/opt/llvm/bin/clang
+          CXX: /usr/local/opt/llvm/bin/clang++
 
       - uses: actions/upload-artifact@v2
         if: github.ref == 'refs/heads/master'

CMakeLists.txt

@@ -21,7 +21,6 @@ message(STATUS "pennylane_lightning version ${VERSION_STRING}")
 set(PROJECT_VERSION ${VERSION_STRING})
 
 set(CMAKE_CXX_STANDARD 17) # At least C++17 is required
-find_package(OpenMP REQUIRED) # find OpenMP
 
 if(NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE Release)
@@ -39,7 +38,12 @@ FetchContent_Declare(
 )
 FetchContent_MakeAvailable(pybind11)
 
-add_library(pennylane_lightning SHARED "pennylane_lightning/src/StateVector.cpp")
+add_subdirectory(pennylane_lightning/src)
+
+add_library(pennylane_lightning INTERFACE)
+target_link_libraries(pennylane_lightning INTERFACE     lightning_utils 
+                                                        lightning_simulator 
+                                                        lightning_algorithms)
 target_include_directories(pennylane_lightning INTERFACE "pennylane_lightning/src")
 
 add_library(external_dependency INTERFACE)
@@ -50,24 +54,21 @@ if ("$ENV{USE_OPENBLAS}" OR "${USE_OPENBLAS}")
     target_compile_options(external_dependency INTERFACE "-DOPENBLAS=1")
 endif()
 
-pybind11_add_module(lightning_qubit_ops "pennylane_lightning/src/StateVector.cpp"
-                                        "pennylane_lightning/src/Bindings.cpp")
-target_link_libraries(lightning_qubit_ops PRIVATE external_dependency)
+pybind11_add_module(lightning_qubit_ops     "pennylane_lightning/src/bindings/Bindings.cpp")
+target_link_libraries(lightning_qubit_ops PRIVATE pennylane_lightning external_dependency)
 set_target_properties(lightning_qubit_ops PROPERTIES CXX_VISIBILITY_PRESET hidden)
 
-target_link_libraries(lightning_qubit_ops PRIVATE OpenMP::OpenMP_CXX)
 target_compile_options(lightning_qubit_ops PRIVATE "$<$<CONFIG:RELEASE>:-W>")
 target_compile_options(lightning_qubit_ops PRIVATE "$<$<CONFIG:DEBUG>:-Wall>")
 target_compile_definitions(lightning_qubit_ops PRIVATE VERSION_INFO=${VERSION_STRING})
 
 if(ENABLE_NATIVE)
-    message(STATUS "ENABLE_NATIVE is ON. Use -march=native for lightning_qubit_ops.")
-    target_compile_options(pennylane_lightning PRIVATE -march=native)
+    message(STATUS "ENABLE_NATIVE is ON. Using -march=native")
+    add_compile_options(-march=native)
+    target_compile_options(pennylane_lightning INTERFACE -march=native)
     target_compile_options(lightning_qubit_ops PRIVATE -march=native)
 endif()
 
-
 if (BUILD_TESTS)
     enable_testing()
-    add_subdirectory("pennylane_lightning/src/tests" "tests")
 endif()

Makefile

@@ -73,12 +73,12 @@ test-cpp:
 	rm -rf ./BuildTests
 	cmake . -BBuildTests -DBUILD_TESTS=1
 	cmake --build ./BuildTests
-	./BuildTests/tests/runner
+	./BuildTests/pennylane_lightning/src/tests/runner
 
 .PHONY: format
 format:
 ifdef check
-	./bin/format --check pennylane_lightning/src tests
+	./bin/format --check pennylane_lightning/src/* tests
 else
-	./bin/format pennylane_lightning/src tests
+	./bin/format pennylane_lightning/src/* tests
 endif

pennylane_lightning/_serialize.py

@@ -0,0 +1,148 @@
+# Copyright 2021 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"""
+Helper functions for serializing quantum tapes.
+"""
+from typing import List, Tuple
+
+import numpy as np
+from pennylane import BasisState, Hadamard, Projector, QubitStateVector, Rot
+from pennylane.grouping import is_pauli_word
+from pennylane.operation import Observable, Tensor
+from pennylane.tape import QuantumTape
+
+try:
+    from .lightning_qubit_ops import StateVectorC128, ObsStructC128
+except ImportError:
+    pass
+
+
+def _obs_has_kernel(obs: Observable) -> bool:
+    """Returns True if the input observable has a supported kernel in the C++ backend.
+
+    Args:
+        obs (Observable): the input observable
+
+    Returns:
+        bool: indicating whether ``obs`` has a dedicated kernel in the backend
+    """
+    if is_pauli_word(obs):
+        return True
+    if isinstance(obs, (Hadamard, Projector)):
+        return True
+    if isinstance(obs, Tensor):
+        return all(_obs_has_kernel(o) for o in obs.obs)
+    return False
+
+
+def _serialize_obs(tape: QuantumTape, wires_map: dict) -> List:
+    """Serializes the observables of an input tape.
+
+    Args:
+        tape (QuantumTape): the input quantum tape
+        wires_map (dict): a dictionary mapping input wires to the device's backend wires
+
+    Returns:
+        list(ObsStructC128): A list of observable objects compatible with the C++ backend
+    """
+    obs = []
+
+    for o in tape.observables:
+        is_tensor = isinstance(o, Tensor)
+
+        wires = []
+
+        if is_tensor:
+            for o_ in o.obs:
+                wires_list = o_.wires.tolist()
+                w = [wires_map[w] for w in wires_list]
+                wires.append(w)
+        else:
+            wires_list = o.wires.tolist()
+            w = [wires_map[w] for w in wires_list]
+            wires.append(w)
+
+        name = o.name if is_tensor else [o.name]
+
+        params = []
+
+        if not _obs_has_kernel(o):
+            if is_tensor:
+                for o_ in o.obs:
+                    if not _obs_has_kernel(o_):
+                        params.append(o_.matrix.ravel().astype(np.complex128))
+                    else:
+                        params.append([])
+            else:
+                params.append(o.matrix.ravel().astype(np.complex128))
+
+        ob = ObsStructC128(name, params, wires)
+        obs.append(ob)
+
+    return obs
+
+
+def _serialize_ops(
+    tape: QuantumTape, wires_map: dict
+) -> Tuple[List[List[str]], List[np.ndarray], List[List[int]], List[bool], List[np.ndarray]]:
+    """Serializes the operations of an input tape.
+
+    The state preparation operations are not included.
+
+    Args:
+        tape (QuantumTape): the input quantum tape
+        wires_map (dict): a dictionary mapping input wires to the device's backend wires
+
+    Returns:
+        Tuple[list, list, list, list, list]: A serialization of the operations, containing a list
+        of operation names, a list of operation parameters, a list of observable wires, a list of
+        inverses, and a list of matrices for the operations that do not have a dedicated kernel.
+    """
+    names = []
+    params = []
+    wires = []
+    inverses = []
+    mats = []
+
+    uses_stateprep = False
+
+    for o in tape.operations:
+        if isinstance(o, (BasisState, QubitStateVector)):
+            uses_stateprep = True
+            continue
+        elif isinstance(o, Rot):
+            op_list = o.expand().operations
+        else:
+            op_list = [o]
+
+        for single_op in op_list:
+            is_inverse = single_op.inverse
+
+            name = single_op.name if not is_inverse else single_op.name[:-4]
+            names.append(name)
+
+            if getattr(StateVectorC128, name, None) is None:
+                params.append([])
+                mats.append(single_op.matrix)
+
+                if is_inverse:
+                    is_inverse = False
+            else:
+                params.append(single_op.parameters)
+                mats.append([])
+
+            wires_list = single_op.wires.tolist()
+            wires.append([wires_map[w] for w in wires_list])
+            inverses.append(is_inverse)
+    return (names, params, wires, inverses, mats), uses_stateprep