SX gate implementation for lightning.qubit

pennylane_lightning/core/src/gates/Constant.hpp

@@ -57,6 +57,7 @@ using GateView = typename std::pair<GateOperation, std::string_view>;
     GateView{GateOperation::Hadamard, "Hadamard"},
     GateView{GateOperation::S, "S"},
     GateView{GateOperation::T, "T"},
+    GateView{GateOperation::SX, "SX"},
     GateView{GateOperation::PhaseShift, "PhaseShift"},
     GateView{GateOperation::RX, "RX"},
     GateView{GateOperation::RY, "RY"},
@@ -94,6 +95,7 @@ using CGateView = typename std::pair<ControlledGateOperation, std::string_view>;
     CGateView{ControlledGateOperation::Hadamard, "Hadamard"},
     CGateView{ControlledGateOperation::S, "S"},
     CGateView{ControlledGateOperation::T, "T"},
+    CGateView{ControlledGateOperation::SX, "SX"},
     CGateView{ControlledGateOperation::PhaseShift, "PhaseShift"},
     CGateView{ControlledGateOperation::RX, "RX"},
     CGateView{ControlledGateOperation::RY, "RY"},
@@ -208,6 +210,7 @@ using GateNWires = typename std::pair<GateOperation, std::size_t>;
     GateNWires{GateOperation::Hadamard, 1},
     GateNWires{GateOperation::S, 1},
     GateNWires{GateOperation::T, 1},
+    GateNWires{GateOperation::SX, 1},
     GateNWires{GateOperation::PhaseShift, 1},
     GateNWires{GateOperation::RX, 1},
     GateNWires{GateOperation::RY, 1},
@@ -245,6 +248,7 @@ using CGateNWires = typename std::pair<ControlledGateOperation, std::size_t>;
     CGateNWires{ControlledGateOperation::Hadamard, 1},
     CGateNWires{ControlledGateOperation::S, 1},
     CGateNWires{ControlledGateOperation::T, 1},
+    CGateNWires{ControlledGateOperation::SX, 1},
     CGateNWires{ControlledGateOperation::PhaseShift, 1},
     CGateNWires{ControlledGateOperation::RX, 1},
     CGateNWires{ControlledGateOperation::RY, 1},
@@ -322,6 +326,7 @@ using GateNParams = typename std::pair<GateOperation, std::size_t>;
     GateNParams{GateOperation::Hadamard, 0},
     GateNParams{GateOperation::S, 0},
     GateNParams{GateOperation::T, 0},
+    GateNParams{GateOperation::SX, 0},
     GateNParams{GateOperation::PhaseShift, 1},
     GateNParams{GateOperation::RX, 1},
     GateNParams{GateOperation::RY, 1},
@@ -364,6 +369,7 @@ using CGateNParams = typename std::pair<ControlledGateOperation, std::size_t>;
     CGateNParams{ControlledGateOperation::S, 0},
     CGateNParams{ControlledGateOperation::T, 0},
     CGateNParams{ControlledGateOperation::PhaseShift, 1},
+    CGateNParams{ControlledGateOperation::SX, 0},
     CGateNParams{ControlledGateOperation::RX, 1},
     CGateNParams{ControlledGateOperation::RY, 1},
     CGateNParams{ControlledGateOperation::RZ, 1},

pennylane_lightning/core/src/gates/GateOperation.hpp

@@ -34,6 +34,7 @@ enum class GateOperation : uint32_t {
     Hadamard,
     S,
     T,
+    SX,
     PhaseShift,
     RX,
     RY,
@@ -79,6 +80,7 @@ enum class ControlledGateOperation : uint32_t {
     Hadamard,
     S,
     T,
+    SX,
     PhaseShift,
     RX,
     RY,

pennylane_lightning/core/src/gates/Gates.hpp

@@ -97,6 +97,21 @@ static constexpr auto getHadamard() -> std::vector<ComplexT<T>> {
             INVSQRT2<ComplexT, T>(), -INVSQRT2<ComplexT, T>()};
 }
 
+/**
+ * @brief Create a matrix representation of the SX gate data in row-major
+ * format.
+ *
+ * @tparam ComplexT<T> Required precision of gate (`float` or `double`).
+ * @return constexpr std::vector<ComplexT<T>> Return constant expression
+ * of SX data.
+ */
+template <template <typename...> class ComplexT, typename T>
+static constexpr auto getSX() -> std::vector<ComplexT<T>> {
+    const ComplexT<T> z0{0.5, 0.5};
+    const ComplexT<T> z1{0.5, -0.5};
+    return {z0, z1, z1, z0};
+}
+
 /**
  * @brief Create a matrix representation of the S gate data in row-major format.
  *

pennylane_lightning/core/src/simulators/lightning_qubit/gates/AssignKernelMap_Default.cpp

@@ -62,6 +62,9 @@ void assignKernelsForGateOp_Default() {
     instance.assignKernelForOp(GateOperation::T, all_threading,
                                all_memory_model, all_qubit_numbers,
                                KernelType::LM);
+    instance.assignKernelForOp(GateOperation::SX, all_threading,
+                               all_memory_model, all_qubit_numbers,
+                               KernelType::LM);
     instance.assignKernelForOp(GateOperation::PhaseShift, all_threading,
                                all_memory_model, all_qubit_numbers,
                                KernelType::LM);
@@ -254,6 +257,9 @@ void assignKernelsForControlledGateOp_Default() {
     instance.assignKernelForOp(ControlledGateOperation::T, all_threading,
                                all_memory_model, all_qubit_numbers,
                                KernelType::LM);
+    instance.assignKernelForOp(ControlledGateOperation::SX, all_threading,
+                               all_memory_model, all_qubit_numbers,
+                               KernelType::LM);
     instance.assignKernelForOp(ControlledGateOperation::PhaseShift,
                                all_threading, all_memory_model,
                                all_qubit_numbers, KernelType::LM);

pennylane_lightning/core/src/simulators/lightning_qubit/gates/OpToMemberFuncPtr.hpp

@@ -93,6 +93,12 @@ struct GateOpToMemberFuncPtr<PrecisionT, ParamT, GateImplementation,
         &GateImplementation::template applyT<PrecisionT>;
 };
 template <class PrecisionT, class ParamT, class GateImplementation>
+struct GateOpToMemberFuncPtr<PrecisionT, ParamT, GateImplementation,
+                             GateOperation::SX> {
+    constexpr static auto value =
+        &GateImplementation::template applySX<PrecisionT>;
+};
+template <class PrecisionT, class ParamT, class GateImplementation>
 struct GateOpToMemberFuncPtr<PrecisionT, ParamT, GateImplementation,
                              GateOperation::PhaseShift> {
     constexpr static auto value =
@@ -309,6 +315,12 @@ struct ControlledGateOpToMemberFuncPtr<PrecisionT, ParamT, GateImplementation,
         &GateImplementation::template applyNCT<PrecisionT>;
 };
 template <class PrecisionT, class ParamT, class GateImplementation>
+struct ControlledGateOpToMemberFuncPtr<PrecisionT, ParamT, GateImplementation,
+                                       ControlledGateOperation::SX> {
+    constexpr static auto value =
+        &GateImplementation::template applyNCSX<PrecisionT>;
+};
+template <class PrecisionT, class ParamT, class GateImplementation>
 struct ControlledGateOpToMemberFuncPtr<PrecisionT, ParamT, GateImplementation,
                                        ControlledGateOperation::PhaseShift> {
     constexpr static auto value =

pennylane_lightning/core/src/simulators/lightning_qubit/gates/cpu_kernels/GateImplementationsLM.cpp

@@ -107,6 +107,12 @@ GateImplementationsLM::applyT<float>(std::complex<float> *, std::size_t,
 template void
 GateImplementationsLM::applyT<double>(std::complex<double> *, std::size_t,
                                       const std::vector<std::size_t> &, bool);
+template void
+GateImplementationsLM::applySX<float>(std::complex<float> *, size_t,
+                                            const std::vector<size_t> &, bool);
+template void
+GateImplementationsLM::applySX<double>(std::complex<double> *, size_t,
+                                             const std::vector<size_t> &, bool);
 template void GateImplementationsLM::applyPhaseShift<float, float>(
     std::complex<float> *, std::size_t, const std::vector<std::size_t> &, bool,
     float);
@@ -323,8 +329,14 @@ template void GateImplementationsLM::applyNCT<float>(
     std::complex<float> *, std::size_t, const std::vector<std::size_t> &,
     const std::vector<bool> &, const std::vector<std::size_t> &, bool);
 template void GateImplementationsLM::applyNCT<double>(
-    std::complex<double> *, std::size_t, const std::vector<std::size_t> &,
-    const std::vector<bool> &, const std::vector<std::size_t> &, bool);
+    std::complex<double> *, size_t, const std::vector<size_t> &,
+    const std::vector<bool> &, const std::vector<size_t> &, bool);
+template void GateImplementationsLM::applyNCSX<float>(
+    std::complex<float> *, size_t, const std::vector<size_t> &,
+    const std::vector<bool> &, const std::vector<size_t> &, bool);
+template void GateImplementationsLM::applyNCSX<double>(
+    std::complex<double> *, size_t, const std::vector<size_t> &,
+    const std::vector<bool> &, const std::vector<size_t> &, bool);
 template void GateImplementationsLM::applyNCPhaseShift<float, float>(
     std::complex<float> *, std::size_t, const std::vector<std::size_t> &,
     const std::vector<bool> &, const std::vector<std::size_t> &, bool, float);

pennylane_lightning/core/src/simulators/lightning_qubit/gates/cpu_kernels/GateImplementationsLM.hpp

@@ -121,6 +121,7 @@ class GateImplementationsLM : public PauliGenerator<GateImplementationsLM> {
         GateOperation::Hadamard,
         GateOperation::S,
         GateOperation::T,
+        GateOperation::SX,
         GateOperation::PhaseShift,
         GateOperation::RX,
         GateOperation::RY,
@@ -158,6 +159,7 @@ class GateImplementationsLM : public PauliGenerator<GateImplementationsLM> {
         ControlledGateOperation::Hadamard,
         ControlledGateOperation::S,
         ControlledGateOperation::T,
+        ControlledGateOperation::SX,
         ControlledGateOperation::PhaseShift,
         ControlledGateOperation::RX,
         ControlledGateOperation::RY,
@@ -818,6 +820,7 @@ class GateImplementationsLM : public PauliGenerator<GateImplementationsLM> {
         applyNCHadamard(arr, num_qubits, {}, {}, wires, inverse);
     }
 
+
     template <class PrecisionT>
     static void
     applyNCS(std::complex<PrecisionT> *arr, const std::size_t num_qubits,
@@ -885,6 +888,44 @@ class GateImplementationsLM : public PauliGenerator<GateImplementationsLM> {
         applyNCT(arr, num_qubits, {}, {}, wires, inverse);
     }
 
+    template <class PrecisionT>
+    static void applyNCSX(std::complex<PrecisionT> *arr,
+                                const size_t num_qubits,
+                                 const std::vector<size_t> &controlled_wires,
+                                const std::vector<bool> &controlled_values,
+                                const std::vector<size_t> &wires,
+                                const bool inverse) {
+        using ParamT = PrecisionT;
+
+        const PrecisionT half = 0.5;
+        const std::complex<PrecisionT> z0{half, (inverse) ? -half : half};
+        const std::complex<PrecisionT> z1 = std::conj(z0);
+
+        auto core_function = [&z0,&z1](std::complex<PrecisionT> *arr,
+                                const std::size_t i0, const std::size_t i1) {
+            const std::complex<PrecisionT> v0 = arr[i0];
+            const std::complex<PrecisionT> v1 = arr[i1];
+            arr[i0] = z0 * v0 + z1 * v1;
+            arr[i1] = z1 * v0 + z0 * v1;
+        };
+        if (controlled_wires.empty()) {
+            applyNC1<PrecisionT, ParamT, decltype(core_function), false>(
+                arr, num_qubits, controlled_wires, controlled_values, wires,
+                core_function);
+        } else {
+            applyNC1<PrecisionT, ParamT, decltype(core_function), true>(
+                arr, num_qubits, controlled_wires, controlled_values, wires,
+                core_function);
+        }
+    }
+
+    template <class PrecisionT>
+    static void
+    applySX(std::complex<PrecisionT> *arr, const size_t num_qubits,
+                  const std::vector<size_t> &wires, const bool inverse) {
+        applyNCSX(arr, num_qubits, {}, {}, wires, inverse);
+    }
+
     template <class PrecisionT, class ParamT = PrecisionT>
     static void
     applyNCPhaseShift(std::complex<PrecisionT> *arr,

pennylane_lightning/core/src/simulators/lightning_qubit/gates/tests/Test_GateImplementations_Nonparam.cpp

@@ -243,6 +243,33 @@ template <typename PrecisionT, class GateImplementation> void testApplyT() {
     }
 }
 PENNYLANE_RUN_TEST(T);
+
+template <typename PrecisionT, class GateImplementation>
+void testApplySX() {
+        // Test using |000> state
+        using ComplexT = std::complex<PrecisionT>;
+        const size_t num_qubits = 3;
+
+        ComplexT z(0.0, 0.0);
+        // ComplexT p(static_cast<PrecisionT>(0.5),static_cast<PrecisionT>(0.5));
+        // ComplexT m(static_cast<PrecisionT>(0.5),static_cast<PrecisionT>(-0.5));
+        ComplexT p(0.5,  0.5);
+        ComplexT m(0.5, -0.5);
+
+        const std::vector<std::vector<ComplexT>> expected_results = {
+            {p, z, z, z, m, z, z, z},
+            {p, z, m, z, z, z, z, z},
+            {p, m, z, z, z, z, z, z}};
+
+    for (size_t index = 0; index < num_qubits; index++) {
+        auto st = createZeroState<ComplexT>(num_qubits);
+
+        GateImplementation::applySX(st.data(), num_qubits, {index}, false);
+
+        CHECK(st == approx(expected_results[index]));
+    }
+}
+PENNYLANE_RUN_TEST(SX);
 /*******************************************************************************
  * Two-qubit gates
  ******************************************************************************/

pennylane_lightning/core/src/simulators/lightning_qubit/gates/tests/Test_OpToMemberFuncPtr.cpp

@@ -138,6 +138,7 @@ class DummyImplementation {
     PENNYLANE_TESTS_DEFINE_GATE_OP(Hadamard, 0)
     PENNYLANE_TESTS_DEFINE_GATE_OP(S, 0)
     PENNYLANE_TESTS_DEFINE_GATE_OP(T, 0)
+    PENNYLANE_TESTS_DEFINE_GATE_OP(SX, 0)
     PENNYLANE_TESTS_DEFINE_GATE_OP(PhaseShift, 1)
     PENNYLANE_TESTS_DEFINE_GATE_OP(RX, 1)
     PENNYLANE_TESTS_DEFINE_GATE_OP(RY, 1)

pennylane_lightning/core/src/utils/config.h

@@ -17,6 +17,7 @@
  * Config file for the path to scipy.libs at compile time.
  */
 
+
 #ifndef CONFIG_H
 #define CONFIG_H
 #define SCIPY_LIBS_PATH ""

pennylane_lightning/lightning_qubit/lightning_qubit.py

@@ -254,6 +254,7 @@ def simulate_and_vjp(
         "C(Hadamard)",
         "C(S)",
         "C(T)",
+        "C(SX)",
         "C(PhaseShift)",
         "C(RX)",
         "C(RY)",

tests/test_gates.py

@@ -378,6 +378,7 @@ def circuit():
         qml.PauliY,
         qml.PauliZ,
         qml.Hadamard,
+        qml.SX,
         qml.S,
         qml.T,
         qml.PhaseShift,