Replace indices, data arguments by word for PauliRot.

pennylane_lightning/core/src/simulators/lightning_qubit/StateVectorLQubit.hpp

@@ -448,14 +448,13 @@ class StateVectorLQubit : public StateVectorBase<PrecisionT, Derived> {
                        const std::vector<std::size_t> &wires,
                        const bool inverse,
                        const std::vector<PrecisionT> &params,
-                       const std::size_t *indices,
-                       const std::complex<PrecisionT> *data) {
+                       const std::string &word) {
         PL_ABORT_IF_NOT(controlled_wires.size() == controlled_values.size(),
                         "`controlled_wires` must have the same size as "
                         "`controlled_values`.");
         GateImplementationsLM::applyPauliRot<PrecisionT>(
             this->getData(), this->getNumQubits(), controlled_wires,
-            controlled_values, wires, inverse, params[0], indices, data);
+            controlled_values, wires, inverse, params[0], word);
     }
 
     /**

pennylane_lightning/core/src/simulators/lightning_qubit/bindings/LQubitBindings.hpp

@@ -178,12 +178,9 @@ void registerBackendClassSpecificBindings(PyClass &pyclass) {
         [](StateVectorT &sv, const std::vector<std::size_t> &controlled_wires,
            const std::vector<bool> &controlled_values,
            const std::vector<std::size_t> &wires, const bool inverse,
-           const std::vector<ParamT> &params, const np_arr_sparse_ind &indices,
-           const np_arr_c &data) {
-            sv.applyPauliRot(
-                controlled_wires, controlled_values, wires, inverse, params,
-                static_cast<std::size_t *>(indices.request().ptr),
-                static_cast<std::complex<PrecisionT> *>(data.request().ptr));
+           const std::vector<ParamT> &params, const std::string &word) {
+            sv.applyPauliRot(controlled_wires, controlled_values, wires,
+                             inverse, params, word);
         },
         "Apply a sparse operation.");
     pyclass

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

@@ -16,6 +16,7 @@
 #include "Util.hpp" // exp2, maxDecimalForQubit
 
 namespace Pennylane::LightningQubit::Gates {
+
 auto getIndicesAfterExclusion(const std::vector<std::size_t> &indicesToExclude,
                               std::size_t num_qubits)
     -> std::vector<std::size_t> {
@@ -47,4 +48,97 @@ auto generateBitPatterns(const std::vector<std::size_t> &qubitIndices,
     }
     return indices;
 }
+
+auto generatePauliWordIndices(const std::string &word)
+    -> std::vector<std::size_t> {
+    const std::size_t n_word = word.size();
+    const std::size_t n_indices = Pennylane::Util::exp2(n_word);
+    std::vector<std::size_t> indices(n_indices);
+    std::vector<std::size_t> mtype(n_word);
+    std::transform(word.begin(), word.end(), mtype.begin(), [](auto ch) {
+        return (ch == 'I' || ch == 'Z') ? 0UL : 1UL;
+    });
+    std::size_t current_size = 2;
+    indices[0] = 0UL;
+    indices[1] = 1UL;
+    if (mtype[n_word - 1 - 0] == 1) {
+        std::swap(indices[0], indices[1]);
+    }
+    for (std::size_t i = 1; i < n_word; i++) {
+        if (mtype[n_word - 1 - i] == 0) {
+            for (std::size_t j = 0; j < current_size; j++) {
+                indices[j + current_size] = indices[j] + current_size;
+            }
+        } else {
+            std::copy(indices.begin(), indices.begin() + current_size,
+                      indices.begin() + current_size);
+            for (std::size_t j = 0; j < current_size; j++) {
+                indices[j] += current_size;
+            }
+        }
+        current_size *= 2;
+    }
+    return indices;
+}
+
+template <class PrecisionT>
+auto generatePauliWordData(const std::string &word,
+                           const std::complex<PrecisionT> &coeff)
+    -> std::vector<std::complex<PrecisionT>> {
+    constexpr auto IMAG = Pennylane::Util::IMAG<PrecisionT>();
+    const std::size_t n_word = word.size();
+    const std::size_t n_data = Pennylane::Util::exp2(n_word);
+    std::vector<std::complex<PrecisionT>> data(n_data);
+    std::vector<std::size_t> mtype(n_word);
+    std::transform(word.begin(), word.end(), mtype.begin(), [](auto ch) {
+        return (ch == 'I' || ch == 'X') ? 0UL : ((ch == 'Y') ? 1UL : 2UL);
+    });
+    std::size_t current_size = 2;
+    switch (mtype[n_word - 1 - 0]) {
+    case 0:
+        data[0] = 1.0;
+        data[1] = 1.0;
+        break;
+    case 1:
+        data[0] = -IMAG;
+        data[1] = IMAG;
+        break;
+    default:
+        data[0] = 1.0;
+        data[1] = -1.0;
+        break;
+    }
+    data[0] *= coeff;
+    data[1] *= coeff;
+    for (std::size_t i = 1; i < n_word; i++) {
+        switch (mtype[n_word - 1 - i]) {
+        case 0:
+            std::copy(data.begin(), data.begin() + current_size,
+                      data.begin() + current_size);
+            break;
+        case 1:
+            for (std::size_t j = 0; j < current_size; j++) {
+                data[j + current_size] = IMAG * data[j];
+            }
+            for (std::size_t j = 0; j < current_size; j++) {
+                data[j] *= -IMAG;
+            }
+            break;
+        default:
+            for (std::size_t j = 0; j < current_size; j++) {
+                data[j + current_size] = -data[j];
+            }
+            break;
+        }
+        current_size *= 2;
+    }
+    return data;
+}
+template std::vector<std::complex<float>>
+generatePauliWordData<float>(const std::string &word,
+                             const std::complex<float> &coeff);
+template std::vector<std::complex<double>>
+generatePauliWordData<double>(const std::string &word,
+                              const std::complex<double> &coeff);
+
 } // namespace Pennylane::LightningQubit::Gates

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

@@ -20,6 +20,8 @@
 
 #include <cstdlib>
 #include <set>
+#include <string>
+#include <utility>
 #include <vector>
 
 #include "Util.hpp"
@@ -84,4 +86,13 @@ struct GateIndices {
           external{generateBitPatterns(
               getIndicesAfterExclusion(wires, num_qubits), num_qubits)} {}
 };
+
+auto generatePauliWordIndices(const std::string &word)
+    -> std::vector<std::size_t>;
+
+template <class PrecisionT>
+auto generatePauliWordData(const std::string &word,
+                           const std::complex<PrecisionT> &coeff)
+    -> std::vector<std::complex<PrecisionT>>;
+
 } // namespace Pennylane::LightningQubit::Gates

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

@@ -19,6 +19,7 @@
 #include <algorithm>
 #include <bit>
 #include <complex>
+#include <string>
 #include <tuple>
 #include <vector>
 
@@ -565,23 +566,26 @@ class GateImplementationsLM : public PauliGenerator<GateImplementationsLM> {
     }
 
     template <class PrecisionT>
-    static void applyPauliRot(std::complex<PrecisionT> *arr,
-                              std::size_t num_qubits,
-                              const std::vector<std::size_t> &controlled_wires,
-                              const std::vector<bool> &controlled_values,
-                              const std::vector<std::size_t> &wires,
-                              [[maybe_unused]] const bool inverse,
-                              PrecisionT angle, const std::size_t *indices,
-                              const std::complex<PrecisionT> *data) {
+    static void
+    applyPauliRot(std::complex<PrecisionT> *arr, std::size_t num_qubits,
+                  const std::vector<std::size_t> &controlled_wires,
+                  const std::vector<bool> &controlled_values,
+                  const std::vector<std::size_t> &wires, const bool inverse,
+                  PrecisionT angle, const std::string &word) {
         constexpr std::size_t one{1};
+        constexpr auto IMAG = Pennylane::Util::IMAG<PrecisionT>();
         const std::size_t n_wires = wires.size();
         const std::size_t dim = one << n_wires;
         const PrecisionT c = std::cos(angle / 2);
-        std::vector<std::complex<PrecisionT>> coeffs(dim);
-        auto core_function = [dim, c, &coeffs, &indices,
+        const std::complex<PrecisionT> s =
+            ((inverse) ? IMAG : -IMAG) * std::sin(angle / 2);
+        const auto data = generatePauliWordData(word, s);
+        const auto indices = generatePauliWordIndices(word);
+        auto core_function = [dim, c, &indices,
                               &data](std::complex<PrecisionT> *arr,
                                      const std::vector<std::size_t> &arr_inds,
                                      const std::size_t offset) {
+            std::vector<std::complex<PrecisionT>> coeffs(dim);
             for (std::size_t i = 0; i < dim; i++) {
                 coeffs[indices[i]] = arr[arr_inds[i] + offset];
             }

pennylane_lightning/lightning_qubit/_state_vector.py

@@ -318,16 +318,10 @@
                 )
             elif isinstance(operation, qml.PauliRot):
                 method = getattr(state, "applyPauliRot")
-                pw = operation._hyperparameters["pauli_word"]
-                pw = dict((i, w) for i, w in zip(wires, pw) if w != "I")
-                pw = qml.pauli.PauliWord(pw)
-                scale = 1.0j if invert_param else -1.0j
-                scale *= qml.math.sin(operation.parameters[0] / 2)
-                data = pw._get_csr_data(pw.wires, scale)
-                indices = pw._get_csr_indices(pw.wires)
+                word = operation._hyperparameters["pauli_word"]
                 method(
-                    [], [], pw.wires, False, operation.parameters, indices, data
-                )  # control wires and values
+                    [], [], wires, invert_param, operation.parameters, "".join(word)
+                )  # control wires and values empty
             elif method is not None:  # apply specialized gate
                 param = operation.parameters
                 method(wires, invert_param, param)