(LK-C-2) Add controlled named 2/4-qubit gate (e.g. NCIsingXX) support to Lightning Kokkos

pennylane_lightning/core/_version.py

@@ -16,4 +16,4 @@
    Version number (major.minor.patch[-label])
 """
 
-__version__ = "0.40.0-dev6"
+__version__ = "0.40.0-dev4"

pennylane_lightning/core/src/simulators/lightning_kokkos/gates/tests/Test_StateVectorKokkos_NonParam.cpp

@@ -1083,6 +1083,102 @@ TEMPLATE_TEST_CASE("StateVectorKokkos::applyOperation non-param "
     }
 }
 
+TEMPLATE_TEST_CASE("StateVectorKokkos::applyOperation non-param "
+                   "two-qubit with controls",
+                   "[StateVectorKokkos_NonParam]", float, double) {
+    using StateVectorT = StateVectorKokkos<TestType>;
+
+    const TestType EP = 1e-4;
+    const std::size_t num_qubits = 4;
+    const bool inverse = GENERATE(true, false);
+    const std::size_t control = GENERATE(0, 1, 2, 3);
+    const std::size_t wire0 = GENERATE(0, 1, 2, 3);
+    const std::size_t wire1 = GENERATE(0, 1, 2, 3);
+
+    auto ini_st = createNonTrivialState<StateVectorT>(num_qubits);
+
+    SECTION("N-controlled SWAP") {
+        if (control != wire0 && control != wire1 && wire0 != wire1) {
+
+            StateVectorT kokkos_sv0{ini_st.data(), ini_st.size()};
+            StateVectorT kokkos_sv1{ini_st.data(), ini_st.size()};
+            kokkos_sv0.applyOperation("CSWAP", {control, wire0, wire1},
+                                      inverse);
+            auto matrix = getSWAP<Kokkos::complex, TestType>();
+            kokkos_sv1.applyOperation("SWAP", std::vector<std::size_t>{control},
+                                      std::vector<bool>{true},
+                                      std::vector<std::size_t>{wire0, wire1},
+                                      inverse);
+            auto result_sv0 = kokkos_sv0.getDataVector();
+            auto result_sv1 = kokkos_sv1.getDataVector();
+            for (std::size_t j = 0; j < exp2(num_qubits); j++) {
+                CHECK(real(result_sv0[j]) ==
+                      Approx(real(result_sv1[j])).margin(EP));
+                CHECK(imag(result_sv0[j]) ==
+                      Approx(imag(result_sv1[j])).margin(EP));
+            }
+        }
+    }
+}
+
+TEMPLATE_TEST_CASE("StateVectorKokkos::applyOperation non-param "
+                   "two-qubit with multiple-controls",
+                   "[StateVectorKokkos_NonParam]", float, double) {
+    SECTION("2-controlled SWAP") {
+        using ComplexT = StateVectorKokkos<TestType>::ComplexT;
+        const std::size_t num_qubits = 4;
+
+        std::vector<ComplexT> ini_st{ComplexT{0.33377149, 0.2511291},
+                                     ComplexT{0.33013572, -0.14778699},
+                                     ComplexT{0.17288832, -0.041744},
+                                     ComplexT{0.11004883, -0.15105962},
+                                     ComplexT{0.17120967, 0.04376507},
+                                     ComplexT{0.33010645, 0.20088901},
+                                     ComplexT{-0.12770624, -0.17329647},
+                                     ComplexT{-0.34301996, 0.11944278},
+                                     ComplexT{0.0195779, -0.03687076},
+                                     ComplexT{0.34155068, 0.07464519},
+                                     ComplexT{0.00730597, 0.03670807},
+                                     ComplexT{0.08876188, -0.18019018},
+                                     ComplexT{-0.04946055, -0.10383813},
+                                     ComplexT{0.0715367, 0.04895361},
+                                     ComplexT{-0.12377521, -0.04781011},
+                                     ComplexT{-0.14509767, 0.2102171}};
+
+        std::vector<ComplexT> expected{ComplexT{0.33377149, 0.2511291},
+                                       ComplexT{0.33013572, -0.14778699},
+                                       ComplexT{0.17288832, -0.041744},
+                                       ComplexT{0.11004883, -0.15105962},
+                                       ComplexT{0.17120967, 0.04376507},
+                                       ComplexT{0.33010645, 0.20088901},
+                                       ComplexT{-0.12770624, -0.17329647},
+                                       ComplexT{-0.34301996, 0.11944278},
+                                       ComplexT{0.0195779, -0.03687076},
+                                       ComplexT{-0.04946055, -0.10383813},
+                                       ComplexT{0.00730597, 0.03670807},
+                                       ComplexT{0.08876188, -0.18019018},
+                                       ComplexT{0.34155068, 0.07464519},
+                                       ComplexT{0.0715367, 0.04895361},
+                                       ComplexT{-0.12377521, -0.04781011},
+                                       ComplexT{-0.14509767, 0.2102171}};
+
+        SECTION("Apply using dispatcher") {
+            StateVectorKokkos<TestType> kokkos_sv{num_qubits};
+            std::vector<ComplexT> result_sv(kokkos_sv.getLength(), {0, 0});
+
+            kokkos_sv.HostToDevice(ini_st.data(), ini_st.size());
+            kokkos_sv.applyOperation("SWAP", {0, 2}, {true, false}, {1, 3},
+                                     false);
+            kokkos_sv.DeviceToHost(result_sv.data(), result_sv.size());
+
+            for (std::size_t j = 0; j < exp2(num_qubits); j++) {
+                CHECK(imag(expected[j]) == Approx(imag(result_sv[j])));
+                CHECK(real(expected[j]) == Approx(real(result_sv[j])));
+            }
+        }
+    }
+}
+
 TEMPLATE_TEST_CASE("StateVectorKokkos::SetStateVector",
                    "[StateVectorKokkos_Nonparam]", float, double) {
     using PrecisionT = TestType;