Add Hermitian Support for Finite-Shot Measurement Statistics (#451)

Add hermitian support for finite-shot measurement statistics
[sc-53754]

---------

Co-authored-by: Ali Asadi <[email protected]>

Author: multiphaseCFD

.dep-versions

@@ -12,4 +12,4 @@ pennylane=0.40.0-dev20
 
 # For a custom LQ/LK version, update the package version here and at
 # 'doc/requirements.txt'
-lightning=0.40.0-dev24
+lightning=0.40.0-dev28

.github/workflows/build-wheel-macos-arm64.yaml

@@ -399,10 +399,10 @@ jobs:
     - name: Checkout Catalyst repo
       uses: actions/checkout@v4
 
-    - name: Install Python 3.10
+    - name: Install Python ${{ matrix.python_version }}
       uses: actions/setup-python@v5
       with:
-        python-version: '3.10'
+        python-version: ${{ matrix.python_version }}
 
     - name: Download Wheel Artifact
       uses: actions/download-artifact@v4
@@ -426,6 +426,7 @@ jobs:
         python${{ matrix.python_version }} -m pip install PennyLane-Lightning-Kokkos
         python${{ matrix.python_version }} -m pip install 'amazon-braket-pennylane-plugin>1.27.1'
 
+
     - name: Install OQC client
       run: |
         python${{ matrix.python_version }} -m pip install oqc-qcaas-client

doc/releases/changelog-dev.md

@@ -4,6 +4,9 @@
 
 <h3>Improvements 🛠</h3>
 
+* Lightning runtime shot-measurement support for Hermitian observables.
+  [(#451)](https://github.com/PennyLaneAI/catalyst/pull/451)
+
 * Replace pybind11 with nanobind for C++/Python bindings in the frontend and in the runtime.
   [(#1173)](https://github.com/PennyLaneAI/catalyst/pull/1173)
   [(#1293)](https://github.com/PennyLaneAI/catalyst/pull/1293)
@@ -128,5 +131,6 @@ Erick Ochoa Lopez,
 Mehrdad Malekmohammadi,
 William Maxwell
 Romain Moyard,
+Shuli Shu,
 Raul Torres,
 Paul Haochen Wang.

doc/requirements.txt

@@ -30,6 +30,6 @@ lxml_html_clean
 
 # Pre-install PL development wheels
 --extra-index-url https://test.pypi.org/simple/
-pennylane-lightning-kokkos==0.40.0-dev24
-pennylane-lightning==0.40.0-dev24
+pennylane-lightning-kokkos==0.40.0-dev28
+pennylane-lightning==0.40.0-dev28
 pennylane==0.40.0-dev20

frontend/catalyst/compiler.py

@@ -121,24 +121,25 @@ def get_default_flags(options):
         path_within_package = "lib"
         file_extension = ".so" if platform.system() == "Linux" else ".dylib"  # pragma: no branch
 
-        if platform.system() == "Darwin" and platform.machine() == "arm64":  # pragma: nocover
-            # use our own build of LAPACKe to interface with Accelerate
-            lapack_lib_name = "lapacke.3"
-        else:
-            package_spec = importlib.util.find_spec(package_name)
-            package_directory = path.dirname(package_spec.origin)
-            lapack_lib_path = path.join(package_directory, path_within_package)
+        package_spec = importlib.util.find_spec(package_name)
+        package_directory = path.dirname(package_spec.origin)
+        lapack_lib_path = path.join(package_directory, path_within_package)
+
+        search_pattern = path.join(lapack_lib_path, f"lib*{lib_name}*{file_extension}")
+        search_result = glob.glob(search_pattern)
+        if not search_result:  # pragma: nocover
+            raise CompileError(
+                f'Unable to find OpenBLAS library at "{search_pattern}". '
+                "Please ensure that scipy is installed and available via pip."
+            )
 
-            search_pattern = path.join(lapack_lib_path, f"lib*{lib_name}*{file_extension}")
-            search_result = glob.glob(search_pattern)
-            if not search_result:  # pragma: nocover
-                raise CompileError(
-                    f'Unable to find OpenBLAS library at "{search_pattern}". '
-                    "Please ensure that scipy is installed and available via pip."
-                )
+        lib_path_flags += [f"-Wl,-rpath,{lapack_lib_path}", f"-L{lapack_lib_path}"]
+        lapack_lib_name = path.basename(search_result[0])[3 : -len(file_extension)]
 
-            lib_path_flags += [f"-Wl,-rpath,{lapack_lib_path}", f"-L{lapack_lib_path}"]
-            lapack_lib_name = path.basename(search_result[0])[3 : -len(file_extension)]
+        lapack_libs = [lapack_lib_name]
+        if platform.system() == "Darwin" and platform.machine() == "arm64":  # pragma: nocover
+            # use our own build of LAPACKe to interface with Accelerate
+            lapack_libs += ["lapacke.3"]
 
         system_flags = []
         if platform.system() == "Linux":
@@ -158,6 +159,8 @@ def get_default_flags(options):
         elif options.async_qnodes and platform.system() == "Darwin":  # pragma: nocover
             system_flags += ["-lc++"]
 
+        lapack_libs = [f"-l{name}" for name in lapack_libs]
+
         default_flags = [
             "-shared",
             "-rdynamic",
@@ -166,7 +169,7 @@ def get_default_flags(options):
             "-lrt_capi",
             "-lpthread",
             "-lmlir_c_runner_utils",  # required for memref.copy
-            f"-l{lapack_lib_name}",  # required for custom_calls lib
+            *lapack_libs,
             "-lcustom_calls",
             "-lmlir_async_runtime",
         ]

frontend/test/pytest/test_measurements_shots_results.py

@@ -124,25 +124,26 @@ def circuit():
         result = qjit(circuit)()
         assert np.allclose(result, expected, atol=tol_stochastic, rtol=tol_stochastic)
 
-    def test_hermitian(self, backend):
+    def test_hermitian(self, backend, tol_stochastic):
         """Test expval Hermitian observables with shots."""
+        n_wires = 3
+        n_shots = 10000
+        dev = qml.device(backend, wires=n_wires, shots=n_shots)
 
-        @qjit
-        @qml.qnode(qml.device(backend, wires=3, shots=10000))
+        @qml.qnode(dev)
         def circuit(x, y):
             qml.RX(x, wires=0)
             qml.RX(y, wires=1)
             qml.CNOT(wires=[0, 1])
             A = np.array(
                 [[complex(1.0, 0.0), complex(2.0, 0.0)], [complex(2.0, 0.0), complex(1.0, 0.0)]]
             )
-            return qml.expval(qml.Hermitian(A, wires=2) + qml.PauliX(0) + qml.Hermitian(A, wires=1))
+            return qml.expval(qml.Hermitian(A, wires=2))
 
-        with pytest.raises(
-            RuntimeError,
-            match="Hermitian observables with shot measurement are not supported",
-        ):
-            circuit(np.pi / 4, np.pi / 4)
+        expected = circuit(np.pi / 4, np.pi / 4)
+        result = qjit(circuit)(np.pi / 4, np.pi / 4)
+
+        assert np.allclose(result, expected, atol=tol_stochastic, rtol=tol_stochastic)
 
     def test_paulix_pauliy(self, backend, tol_stochastic):
         """Test that a tensor product involving PauliX and PauliY works correctly"""
@@ -332,25 +333,26 @@ def circuit():
         result = qjit(circuit)()
         assert np.allclose(result, expected, atol=tol_stochastic, rtol=tol_stochastic)
 
-    def test_hermitian_shots(self, backend):
+    def test_hermitian_shots(self, backend, tol_stochastic):
         """Test var Hermitian observables with shots."""
+        n_wires = 3
+        n_shots = 10000
+        dev = qml.device(backend, wires=n_wires, shots=n_shots)
 
-        @qjit
-        @qml.qnode(qml.device(backend, wires=3, shots=10000))
+        @qml.qnode(dev)
         def circuit(x, y):
             qml.RX(x, wires=0)
             qml.RX(y, wires=1)
             qml.CNOT(wires=[0, 1])
             A = np.array(
                 [[complex(1.0, 0.0), complex(2.0, 0.0)], [complex(2.0, 0.0), complex(1.0, 0.0)]]
             )
-            return qml.var(qml.Hermitian(A, wires=2) + qml.PauliX(0) + qml.Hermitian(A, wires=1))
+            return qml.var(qml.Hermitian(A, wires=2))
 
-        with pytest.raises(
-            RuntimeError,
-            match="Hermitian observables with shot measurement are not supported",
-        ):
-            circuit(np.pi / 4, np.pi / 4)
+        expected = circuit(np.pi / 4, np.pi / 4)
+        result = qjit(circuit)(np.pi / 4, np.pi / 4)
+
+        assert np.allclose(result, expected, atol=tol_stochastic, rtol=tol_stochastic)
 
     def test_paulix_pauliy(self, backend, tol_stochastic):
         """Test that a tensor product involving PauliX and PauliY works correctly"""

runtime/README.rst

@@ -63,16 +63,16 @@ The following table shows the available devices along with supported features:
      - ``Identity``, ``PauliX``, ``PauliY``, ``PauliZ``, ``Hadamard``, ``Hermitian``, ``Hamiltonian``, and Tensor Product of Observables
      - ``Identity``, ``PauliX``, ``PauliY``, ``PauliZ``, ``Hadamard``, ``Hermitian``, and Tensor Product of Observables
    * - Expectation Value
-     - All observables; Finite-shots supported except for ``Hermitian``
-     - All observables; Finite-shots supported except for ``Hermitian``
+     - All observables; Finite-shots supported
+     - All observables; Finite-shots supported
      - All observables; Finite-shots supported
    * - Variance
-     - All observables; Finite-shots supported except for ``Hermitian``
-     - All observables; Finite-shots supported except for ``Hermitian``
+     - All observables; Finite-shots supported
+     - All observables; Finite-shots supported
      - All observables; Finite-shots supported
    * - Probability
-     - Only for the computational basis on the supplied qubits; Finite-shots supported except for ``Hermitian``
-     - Only for the computational basis on the supplied qubits; Finite-shots supported except for ``Hermitian``
+     - Only for the computational basis on the supplied qubits; Finite-shots supported
+     - Only for the computational basis on the supplied qubits; Finite-shots supported
      - The computational basis on all active qubits; Finite-shots supported
    * - Sampling
      - Only for the computational basis on the supplied qubits