Add LTensor Hermitian wire length check

.github/CHANGELOG.md

@@ -37,6 +37,9 @@
 
 ### Bug fixes
 
+* Check for the number of wires for Hermitian observables in Lightning-Tensor. Only 1-wire Hermitian observables are supported as of `cuTensorNet-v24.03.0`.
+  [(#806)](https://github.com/PennyLaneAI/pennylane-lightning/pull/806)
+
 * Set `PL_BACKEND` for the entire `build-wheel-lightning-gpu` Docker-build stage to properly build the Lightning-GPU wheel.
   [(#791)](https://github.com/PennyLaneAI/pennylane-lightning/pull/791)
 

pennylane_lightning/core/_version.py

@@ -16,4 +16,4 @@
    Version number (major.minor.patch[-label])
 """
 
-__version__ = "0.38.0-dev10"
+__version__ = "0.38.0-dev11"

pennylane_lightning/core/src/simulators/lightning_tensor/tncuda/observables/ObservablesTNCuda.hpp

@@ -20,6 +20,7 @@
 
 #include "Constant.hpp"
 #include "ConstantUtil.hpp" // lookup
+#include "Error.hpp"
 #include "Util.hpp"
 
 #include "cuda_helpers.hpp"
@@ -241,6 +242,8 @@ class HermitianObsTNCuda : public ObservableTNCuda<TensorNetT> {
      */
     HermitianObsTNCuda(MatrixT matrix, std::vector<std::size_t> wires)
         : matrix_{std::move(matrix)}, wires_{std::move(wires)} {
+        PL_ABORT_IF(wires_.size() != 1, "The number of Hermitian target wires "
+                                        "must be 1 for Lightning-Tensor.");
         PL_ASSERT(matrix_.size() == Pennylane::Util::exp2(2 * wires_.size()));
         BaseType::coeffs_.emplace_back(PrecisionT{1.0});
         BaseType::numTensors_.emplace_back(std::size_t{1});

pennylane_lightning/core/src/simulators/lightning_tensor/tncuda/observables/tests/Test_Observables_TNCuda.cpp

@@ -86,16 +86,18 @@ TEMPLATE_TEST_CASE("[Hermitian]", "[Observables]", float, double) {
     using HermitianObsT = HermitianObsTNCuda<TensorNetT>;
 
     SECTION("HermitianObs only accepts correct arguments") {
-        auto ob1 =
-            HermitianObsT{std::vector<ComplexT>{0.0, 0.0, 0.0, 0.0}, {0}};
-        auto ob2 = HermitianObsT{std::vector<ComplexT>(16, ComplexT{}), {0, 1}};
         REQUIRE_THROWS_AS(
             HermitianObsT(std::vector<ComplexT>{0.0, 0.0, 0.0}, {0}),
             LightningException);
         REQUIRE_THROWS_AS(
             HermitianObsT(std::vector<ComplexT>{0.0, 0.0, 0.0, 0.0, 0.0},
                           {0, 1}),
             LightningException);
+        REQUIRE_THROWS_WITH(
+            HermitianObsT(std::vector<ComplexT>(16, ComplexT{0.0, 0.0}),
+                          {0, 1}),
+            Catch::Matchers::Contains("The number of Hermitian target wires "
+                                      "must be 1 for Lightning-Tensor."));
     }
 
     SECTION("Test get obs name") {
@@ -153,8 +155,8 @@ TEMPLATE_TEST_CASE("[TensorProd]", "[Observables]", float, double) {
 
         SECTION("Overlapping wires throw an exception") {
             auto ob1 = std::make_shared<HermitianObsT>(
-                std::vector<ComplexT>(16, ComplexT{0.0, 0.0}),
-                std::vector<std::size_t>{0, 1});
+                std::vector<ComplexT>(4, ComplexT{0.0, 0.0}),
+                std::vector<std::size_t>{1});
             auto ob2_1 = std::make_shared<NamedObsT>(
                 "PauliX", std::vector<std::size_t>{1});
             auto ob2_2 = std::make_shared<NamedObsT>(
@@ -167,8 +169,8 @@ TEMPLATE_TEST_CASE("[TensorProd]", "[Observables]", float, double) {
 
         SECTION("Constructing an observable with non-overlapping wires ") {
             auto ob1 = std::make_shared<HermitianObsT>(
-                std::vector<ComplexT>(16, ComplexT{0.0, 0.0}),
-                std::vector<std::size_t>{0, 1});
+                std::vector<ComplexT>(4, ComplexT{0.0, 0.0}),
+                std::vector<std::size_t>{1});
             auto ob2_1 = std::make_shared<NamedObsT>(
                 "PauliX", std::vector<std::size_t>{2});
             auto ob2_2 = std::make_shared<NamedObsT>(

pennylane_lightning/lightning_tensor/_measurements.py

@@ -74,6 +74,10 @@
         if isinstance(measurementprocess.obs, qml.SparseHamiltonian):
             raise NotImplementedError("Sparse Hamiltonians are not supported.")
 
+        if isinstance(measurementprocess.obs, qml.Hermitian):
+            if len(measurementprocess.obs.wires) > 1:
+                raise ValueError("The number of Hermitian observables target wires should be 1.")
+
         ob_serialized = QuantumScriptSerializer(
             self._tensornet.device_name, self.dtype == np.complex64
         )._ob(measurementprocess.obs)

tests/test_expval.py

@@ -163,7 +163,7 @@ def circuit():
         circ_def = qml.QNode(circuit, dev_def)
         assert np.allclose(circ(), circ_def(), tol)
 
-    @pytest.mark.parametrize("n_wires", range(1, 7 if device_name != "lightning.tensor" else 5))
+    @pytest.mark.parametrize("n_wires", range(1, 7))
     def test_hermitian_expectation(self, n_wires, theta, phi, qubit_device, tol):
         """Test that Hermitian expectation value is correct"""
         n_qubits = 7
@@ -185,14 +185,26 @@ def test_hermitian_expectation(self, n_wires, theta, phi, qubit_device, tol):
             def circuit():
                 if device_name != "lightning.tensor":
                     qml.StatePrep(init_state, wires=range(n_qubits))
-                qml.RY(theta, wires=[0])
+                qml.RX(theta, wires=[0])
                 qml.RY(phi, wires=[1])
+                qml.RX(theta, wires=[2])
+                qml.RY(phi, wires=[3])
+                qml.RX(theta, wires=[4])
+                qml.RY(phi, wires=[5])
+                qml.RX(theta, wires=[6])
                 qml.CNOT(wires=[0, 1])
                 return qml.expval(obs)
 
             circ = qml.QNode(circuit, dev)
             circ_def = qml.QNode(circuit, dev_def)
-            assert np.allclose(circ(), circ_def(), tol)
+            if device_name == "lightning.tensor" and n_wires > 1:
+                with pytest.raises(
+                    ValueError,
+                    match="The number of Hermitian observables target wires should be 1.",
+                ):
+                    assert np.allclose(circ(), circ_def(), tol)
+            else:
+                assert np.allclose(circ(), circ_def(), tol)
 
 
 @pytest.mark.parametrize(