diff --git a/.github/CHANGELOG.md b/.github/CHANGELOG.md
index 4c3e2fc344..8b233348a7 100644
--- a/.github/CHANGELOG.md
+++ b/.github/CHANGELOG.md
@@ -52,6 +52,9 @@
 
 ### Improvements
 
+* Refactor `cuda_utils` to remove its dependency on `custatevec.h`.
+  [(#681)](https://github.com/PennyLaneAI/pennylane-lightning/pull/681)
+
 * Add `test_templates.py` module where Grover and QSVT are tested.
   [(#684)](https://github.com/PennyLaneAI/pennylane-lightning/pull/684)
 
diff --git a/pennylane_lightning/core/_version.py b/pennylane_lightning/core/_version.py
index 60d8f6e108..9c6e90e856 100644
--- a/pennylane_lightning/core/_version.py
+++ b/pennylane_lightning/core/_version.py
@@ -16,4 +16,4 @@
    Version number (major.minor.patch[-label])
 """
 
-__version__ = "0.36.0-dev32"
+__version__ = "0.36.0-dev33"
diff --git a/pennylane_lightning/core/src/simulators/lightning_gpu/MPIWorker.hpp b/pennylane_lightning/core/src/simulators/lightning_gpu/MPIWorker.hpp
index f4c509f76d..eae1aa2413 100644
--- a/pennylane_lightning/core/src/simulators/lightning_gpu/MPIWorker.hpp
+++ b/pennylane_lightning/core/src/simulators/lightning_gpu/MPIWorker.hpp
@@ -21,6 +21,7 @@
 #include "MPIManager.hpp"
 #include "MPI_helpers.hpp"
 #include "cuError.hpp"
+#include "cuStateVecError.hpp"
 #include <cuda.h>
 #include <cuda_runtime.h>
 #include <custatevec.h>
diff --git a/pennylane_lightning/core/src/simulators/lightning_gpu/StateVectorCudaBase.hpp b/pennylane_lightning/core/src/simulators/lightning_gpu/StateVectorCudaBase.hpp
index 3e40420bd5..fba307ebed 100644
--- a/pennylane_lightning/core/src/simulators/lightning_gpu/StateVectorCudaBase.hpp
+++ b/pennylane_lightning/core/src/simulators/lightning_gpu/StateVectorCudaBase.hpp
@@ -27,6 +27,7 @@
 #include "DevTag.hpp"
 #include "Error.hpp"
 #include "StateVectorBase.hpp"
+#include "cuStateVecError.hpp"
 #include "cuda_helpers.hpp"
 
 /// @cond DEV
diff --git a/pennylane_lightning/core/src/simulators/lightning_gpu/StateVectorCudaMPI.hpp b/pennylane_lightning/core/src/simulators/lightning_gpu/StateVectorCudaMPI.hpp
index c7da5b82c3..0496a8042e 100644
--- a/pennylane_lightning/core/src/simulators/lightning_gpu/StateVectorCudaMPI.hpp
+++ b/pennylane_lightning/core/src/simulators/lightning_gpu/StateVectorCudaMPI.hpp
@@ -36,6 +36,8 @@
 #include "StateVectorCudaBase.hpp"
 #include "cuGateCache.hpp"
 #include "cuGates_host.hpp"
+#include "cuStateVecError.hpp"
+#include "cuStateVec_helpers.hpp"
 #include "cuda_helpers.hpp"
 
 #include "CPUMemoryModel.hpp"
diff --git a/pennylane_lightning/core/src/simulators/lightning_gpu/StateVectorCudaManaged.hpp b/pennylane_lightning/core/src/simulators/lightning_gpu/StateVectorCudaManaged.hpp
index 15fd843190..4e7c749ba6 100644
--- a/pennylane_lightning/core/src/simulators/lightning_gpu/StateVectorCudaManaged.hpp
+++ b/pennylane_lightning/core/src/simulators/lightning_gpu/StateVectorCudaManaged.hpp
@@ -37,6 +37,8 @@
 #include "CPUMemoryModel.hpp"
 
 #include "cuError.hpp"
+#include "cuStateVecError.hpp"
+#include "cuStateVec_helpers.hpp"
 
 #include "LinearAlg.hpp"
 
diff --git a/pennylane_lightning/core/src/simulators/lightning_gpu/measurements/MeasurementsGPU.hpp b/pennylane_lightning/core/src/simulators/lightning_gpu/measurements/MeasurementsGPU.hpp
index fca0175177..dc213c126f 100644
--- a/pennylane_lightning/core/src/simulators/lightning_gpu/measurements/MeasurementsGPU.hpp
+++ b/pennylane_lightning/core/src/simulators/lightning_gpu/measurements/MeasurementsGPU.hpp
@@ -34,6 +34,8 @@
 #include "Observables.hpp"
 #include "ObservablesGPU.hpp"
 #include "StateVectorCudaManaged.hpp"
+#include "cuStateVecError.hpp"
+#include "cuStateVec_helpers.hpp"
 #include "cuda_helpers.hpp"
 
 /// @cond DEV
diff --git a/pennylane_lightning/core/src/simulators/lightning_gpu/measurements/MeasurementsGPUMPI.hpp b/pennylane_lightning/core/src/simulators/lightning_gpu/measurements/MeasurementsGPUMPI.hpp
index d82ebfd0e4..9d0d986fa4 100644
--- a/pennylane_lightning/core/src/simulators/lightning_gpu/measurements/MeasurementsGPUMPI.hpp
+++ b/pennylane_lightning/core/src/simulators/lightning_gpu/measurements/MeasurementsGPUMPI.hpp
@@ -39,6 +39,7 @@
 #include "ObservablesGPUMPI.hpp"
 #include "StateVectorCudaMPI.hpp"
 #include "StateVectorCudaManaged.hpp"
+#include "cuStateVecError.hpp"
 #include "cuda_helpers.hpp"
 
 /// @cond DEV
diff --git a/pennylane_lightning/core/src/utils/cuda_utils/MPI_helpers.hpp b/pennylane_lightning/core/src/simulators/lightning_gpu/utils/MPI_helpers.hpp
similarity index 100%
rename from pennylane_lightning/core/src/utils/cuda_utils/MPI_helpers.hpp
rename to pennylane_lightning/core/src/simulators/lightning_gpu/utils/MPI_helpers.hpp
diff --git a/pennylane_lightning/core/src/simulators/lightning_gpu/utils/cuStateVecError.hpp b/pennylane_lightning/core/src/simulators/lightning_gpu/utils/cuStateVecError.hpp
new file mode 100644
index 0000000000..691ac7a2cf
--- /dev/null
+++ b/pennylane_lightning/core/src/simulators/lightning_gpu/utils/cuStateVecError.hpp
@@ -0,0 +1,96 @@
+// Copyright 2024 Xanadu Quantum Technologies Inc.
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Adapted from JET: https://github.com/XanaduAI/jet.git
+// and from Lightning: https://github.com/PennylaneAI/pennylane-lightning.git
+
+/**
+ * @file cuStateVecError.hpp
+ * Defines macros that throws Exception from cuStateVec failure error codes.
+ */
+
+#pragma once
+#include <string>
+#include <string_view>
+
+#include <custatevec.h>
+
+#include "Error.hpp"
+#include "Util.hpp"
+
+// LCOV_EXCL_START
+/// @cond DEV
+namespace {
+using namespace Pennylane::Util;
+}
+/// @endcond
+
+#ifndef CUDA_UNSAFE
+
+/**
+ * @brief Macro that throws Exception from cuStateVec failure error codes.
+ *
+ * @param err cuStateVec function error-code.
+ */
+#define PL_CUSTATEVEC_IS_SUCCESS(err)                                          \
+    PL_ABORT_IF_NOT(                                                           \
+        err == CUSTATEVEC_STATUS_SUCCESS,                                      \
+        Pennylane::LightningGPU::Util::GetCuStateVecErrorString(err).c_str())
+
+#else
+#define PL_CUSTATEVEC_IS_SUCCESS(err)                                          \
+    { static_cast<void>(err); }
+#endif
+
+namespace Pennylane::LightningGPU::Util {
+static const std::string
+GetCuStateVecErrorString(const custatevecStatus_t &err) {
+    using namespace std::string_literals;
+
+    switch (err) {
+    case CUSTATEVEC_STATUS_SUCCESS:
+        return "No errors"s;
+    case CUSTATEVEC_STATUS_NOT_INITIALIZED:
+        return "custatevec not initialized"s;
+    case CUSTATEVEC_STATUS_ALLOC_FAILED:
+        return "custatevec memory allocation failed"s;
+    case CUSTATEVEC_STATUS_INVALID_VALUE:
+        return "custatevec invalid value"s;
+    case CUSTATEVEC_STATUS_ARCH_MISMATCH:
+        return "custatevec CUDA device architecture mismatch"s;
+    case CUSTATEVEC_STATUS_EXECUTION_FAILED:
+        return "custatevec execution failed"s;
+    case CUSTATEVEC_STATUS_INTERNAL_ERROR:
+        return "custatevec internal error"s;
+    case CUSTATEVEC_STATUS_NOT_SUPPORTED:
+        return "custatevec unsupported operation/device"s;
+    case CUSTATEVEC_STATUS_INSUFFICIENT_WORKSPACE:
+        return "custatevec insufficient memory for gate-application workspace"s;
+    case CUSTATEVEC_STATUS_SAMPLER_NOT_PREPROCESSED:
+        return "custatevec sampler not preprocessed"s;
+    case CUSTATEVEC_STATUS_NO_DEVICE_ALLOCATOR:
+        return "custatevec no device allocator"s;
+    case CUSTATEVEC_STATUS_DEVICE_ALLOCATOR_ERROR:
+        return "custatevec device allocator error"s;
+    case CUSTATEVEC_STATUS_COMMUNICATOR_ERROR:
+        return "custatevec communicator failure"s;
+    case CUSTATEVEC_STATUS_LOADING_LIBRARY_FAILED:
+        return "custatevec dynamic library load failure"s;
+    default:
+        return "custatevec status not found. Error code="s +
+               std::to_string(err);
+    }
+}
+} // namespace Pennylane::LightningGPU::Util
+// LCOV_EXCL_STOP
diff --git a/pennylane_lightning/core/src/simulators/lightning_gpu/utils/cuStateVec_helpers.hpp b/pennylane_lightning/core/src/simulators/lightning_gpu/utils/cuStateVec_helpers.hpp
new file mode 100644
index 0000000000..8bd27c2dc8
--- /dev/null
+++ b/pennylane_lightning/core/src/simulators/lightning_gpu/utils/cuStateVec_helpers.hpp
@@ -0,0 +1,104 @@
+// Copyright 2024 Xanadu Quantum Technologies Inc.
+
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Adapted from JET: https://github.com/XanaduAI/jet.git
+
+/**
+ * @file cudaStateVec_helpers.hpp
+ */
+
+#pragma once
+#include <custatevec.h>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include "cuStateVecError.hpp"
+
+namespace Pennylane::LightningGPU::Util {
+
+inline static auto pauliStringToEnum(const std::string &pauli_word)
+    -> std::vector<custatevecPauli_t> {
+    // Map string rep to Pauli enums
+    const std::unordered_map<std::string, custatevecPauli_t> pauli_map{
+        std::pair<const std::string, custatevecPauli_t>{std::string("I"),
+                                                        CUSTATEVEC_PAULI_I},
+        std::pair<const std::string, custatevecPauli_t>{std::string("X"),
+                                                        CUSTATEVEC_PAULI_X},
+        std::pair<const std::string, custatevecPauli_t>{std::string("Y"),
+                                                        CUSTATEVEC_PAULI_Y},
+        std::pair<const std::string, custatevecPauli_t>{std::string("Z"),
+                                                        CUSTATEVEC_PAULI_Z}};
+
+    constexpr std::size_t num_char = 1;
+
+    std::vector<custatevecPauli_t> output;
+    output.reserve(pauli_word.size());
+
+    for (const auto &ch : pauli_word) {
+        auto out = pauli_map.at(std::string(num_char, ch));
+        output.push_back(out);
+    }
+    return output;
+}
+
+inline static auto pauliStringToOpNames(const std::string &pauli_word)
+    -> std::vector<std::string> {
+    // Map string rep to Pauli
+    const std::unordered_map<std::string, std::string> pauli_map{
+        std::pair<const std::string, std::string>{std::string("I"),
+                                                  std::string("Identity")},
+        std::pair<const std::string, std::string>{std::string("X"),
+                                                  std::string("PauliX")},
+        std::pair<const std::string, std::string>{std::string("Y"),
+                                                  std::string("PauliY")},
+        std::pair<const std::string, std::string>{std::string("Z"),
+                                                  std::string("PauliZ")}};
+
+    static constexpr std::size_t num_char = 1;
+
+    std::vector<std::string> output;
+    output.reserve(pauli_word.size());
+
+    for (const auto ch : pauli_word) {
+        auto out = pauli_map.at(std::string(num_char, ch));
+        output.push_back(out);
+    }
+    return output;
+}
+
+/**
+ * Utility function object to tell std::shared_ptr how to
+ * release/destroy cuStateVec objects.
+ */
+struct handleDeleter {
+    void operator()(custatevecHandle_t handle) const {
+        PL_CUSTATEVEC_IS_SUCCESS(custatevecDestroy(handle));
+    }
+};
+
+using SharedCusvHandle =
+    std::shared_ptr<std::remove_pointer<custatevecHandle_t>::type>;
+
+/**
+ * @brief Creates a SharedCusvHandle (a shared pointer to a custatevecHandle)
+ */
+inline SharedCusvHandle make_shared_cusv_handle() {
+    custatevecHandle_t h;
+    PL_CUSTATEVEC_IS_SUCCESS(custatevecCreate(&h));
+    return {h, handleDeleter()};
+}
+} // namespace Pennylane::LightningGPU::Util
diff --git a/pennylane_lightning/core/src/utils/cuda_utils/LinearAlg.hpp b/pennylane_lightning/core/src/utils/cuda_utils/LinearAlg.hpp
index 13a7ec9a90..eef358e9c4 100644
--- a/pennylane_lightning/core/src/utils/cuda_utils/LinearAlg.hpp
+++ b/pennylane_lightning/core/src/utils/cuda_utils/LinearAlg.hpp
@@ -22,7 +22,6 @@
 #include <cublas_v2.h>
 #include <cuda.h>
 #include <cusparse_v2.h>
-#include <custatevec.h>
 
 #include "DataBuffer.hpp"
 #include "cuError.hpp"
@@ -247,17 +246,12 @@ struct HandleDeleter {
     void operator()(cublasHandle_t handle) const {
         PL_CUBLAS_IS_SUCCESS(cublasDestroy(handle));
     }
-    void operator()(custatevecHandle_t handle) const {
-        PL_CUSTATEVEC_IS_SUCCESS(custatevecDestroy(handle));
-    }
     void operator()(cusparseHandle_t handle) const {
         PL_CUSPARSE_IS_SUCCESS(cusparseDestroy(handle));
     }
 };
 
 using SharedCublasCaller = std::shared_ptr<CublasCaller>;
-using SharedCusvHandle =
-    std::shared_ptr<std::remove_pointer<custatevecHandle_t>::type>;
 using SharedCusparseHandle =
     std::shared_ptr<std::remove_pointer<cusparseHandle_t>::type>;
 
@@ -268,15 +262,6 @@ inline SharedCublasCaller make_shared_cublas_caller() {
     return std::make_shared<CublasCaller>();
 }
 
-/**
- * @brief Creates a SharedCusvHandle (a shared pointer to a custatevecHandle)
- */
-inline SharedCusvHandle make_shared_cusv_handle() {
-    custatevecHandle_t h;
-    PL_CUSTATEVEC_IS_SUCCESS(custatevecCreate(&h));
-    return {h, HandleDeleter()};
-}
-
 /**
  * @brief Creates a SharedCusparseHandle (a shared pointer to a cusparseHandle)
  */
diff --git a/pennylane_lightning/core/src/utils/cuda_utils/MPILinearAlg.hpp b/pennylane_lightning/core/src/utils/cuda_utils/MPILinearAlg.hpp
index 9f0f3972a6..cfe9ec7d81 100644
--- a/pennylane_lightning/core/src/utils/cuda_utils/MPILinearAlg.hpp
+++ b/pennylane_lightning/core/src/utils/cuda_utils/MPILinearAlg.hpp
@@ -8,7 +8,6 @@
 #include <cublas_v2.h>
 #include <cuda.h>
 #include <cusparse_v2.h>
-#include <custatevec.h>
 
 #include "DataBuffer.hpp"
 #include "cuError.hpp"
diff --git a/pennylane_lightning/core/src/utils/cuda_utils/MPIManager.hpp b/pennylane_lightning/core/src/utils/cuda_utils/MPIManager.hpp
index e32295c9c6..d42d39082a 100644
--- a/pennylane_lightning/core/src/utils/cuda_utils/MPIManager.hpp
+++ b/pennylane_lightning/core/src/utils/cuda_utils/MPIManager.hpp
@@ -21,7 +21,6 @@
 #include <cuComplex.h>
 #include <cuda.h>
 #include <cuda_runtime.h>
-#include <custatevec.h>
 #include <mpi.h>
 #include <stdexcept>
 #include <string>
@@ -30,6 +29,10 @@
 #include <unordered_map>
 #include <vector>
 
+#ifdef _ENABLE_PLGPU
+#include <custatevec.h>
+#endif
+
 #include "DataBuffer.hpp"
 #include "Error.hpp"
 
@@ -155,7 +158,9 @@ class MPIManager final {
         {cppTypeToString<cuFloatComplex>(), MPI_C_FLOAT_COMPLEX},
         {cppTypeToString<double2>(), MPI_C_DOUBLE_COMPLEX},
         {cppTypeToString<cuDoubleComplex>(), MPI_C_DOUBLE_COMPLEX},
+#ifdef _ENABLE_PLGPU
         {cppTypeToString<custatevecIndex_t>(), MPI_INT64_T},
+#endif
         // cuda related types
         {cppTypeToString<cudaIpcMemHandle_t>(), MPI_UINT8_T},
         {cppTypeToString<cudaIpcEventHandle_t>(), MPI_UINT8_T}};
diff --git a/pennylane_lightning/core/src/utils/cuda_utils/cuError.hpp b/pennylane_lightning/core/src/utils/cuda_utils/cuError.hpp
index 11ff04e3b9..4824517493 100644
--- a/pennylane_lightning/core/src/utils/cuda_utils/cuError.hpp
+++ b/pennylane_lightning/core/src/utils/cuda_utils/cuError.hpp
@@ -25,7 +25,6 @@
 #include <cublas_v2.h>
 #include <cuda.h>
 #include <cusparse_v2.h>
-#include <custatevec.h>
 
 #include "Error.hpp"
 #include "Util.hpp"
@@ -50,16 +49,6 @@ using namespace Pennylane::Util;
 #define PL_CUSPARSE_IS_SUCCESS(err)                                            \
     PL_ABORT_IF_NOT(err == CUSPARSE_STATUS_SUCCESS, GetCuSparseErrorString(err))
 
-/**
- * @brief Macro that throws Exception from cuQuantum failure error codes.
- *
- * @param err cuQuantum function error-code.
- */
-#define PL_CUSTATEVEC_IS_SUCCESS(err)                                          \
-    PL_ABORT_IF_NOT(                                                           \
-        err == CUSTATEVEC_STATUS_SUCCESS,                                      \
-        Pennylane::LightningGPU::Util::GetCuStateVecErrorString(err).c_str())
-
 #else
 #define PL_CUDA_IS_SUCCESS(err)                                                \
     { static_cast<void>(err); }
@@ -67,8 +56,6 @@ using namespace Pennylane::Util;
     { static_cast<void>(err); }
 #define PL_CUSPARSE_IS_SUCCESS(err)                                            \
     { static_cast<void>(err); }
-#define PL_CUSTATEVEC_IS_SUCCESS(err)                                          \
-    { static_cast<void>(err); }
 #endif
 
 namespace Pennylane::LightningGPU::Util {
@@ -150,58 +137,5 @@ static const std::string GetCuSparseErrorString(const cusparseStatus_t &err) {
     return result;
 }
 
-static const std::string
-GetCuStateVecErrorString(const custatevecStatus_t &err) {
-    std::string result;
-    switch (err) {
-    case CUSTATEVEC_STATUS_SUCCESS:
-        result = "No errors";
-        break;
-    case CUSTATEVEC_STATUS_NOT_INITIALIZED:
-        result = "custatevec not initialized";
-        break;
-    case CUSTATEVEC_STATUS_ALLOC_FAILED:
-        result = "custatevec memory allocation failed";
-        break;
-    case CUSTATEVEC_STATUS_INVALID_VALUE:
-        result = "custatevec invalid value";
-        break;
-    case CUSTATEVEC_STATUS_ARCH_MISMATCH:
-        result = "custatevec CUDA device architecture mismatch";
-        break;
-    case CUSTATEVEC_STATUS_EXECUTION_FAILED:
-        result = "custatevec execution failed";
-        break;
-    case CUSTATEVEC_STATUS_INTERNAL_ERROR:
-        result = "custatevec internal error";
-        break;
-    case CUSTATEVEC_STATUS_NOT_SUPPORTED:
-        result = "custatevec unsupported operation/device";
-        break;
-    case CUSTATEVEC_STATUS_INSUFFICIENT_WORKSPACE:
-        result =
-            "custatevec insufficient memory for gate-application workspace";
-        break;
-    case CUSTATEVEC_STATUS_SAMPLER_NOT_PREPROCESSED:
-        result = "custatevec sampler not preprocessed";
-        break;
-    case CUSTATEVEC_STATUS_NO_DEVICE_ALLOCATOR:
-        result = "custatevec no device allocator";
-        break;
-    case CUSTATEVEC_STATUS_DEVICE_ALLOCATOR_ERROR:
-        result = "custatevec device allocator error";
-        break;
-    case CUSTATEVEC_STATUS_COMMUNICATOR_ERROR:
-        result = "custatevec communicator failure";
-        break;
-    case CUSTATEVEC_STATUS_LOADING_LIBRARY_FAILED:
-        result = "custatevec dynamic library load failure";
-        break;
-    default:
-        result =
-            "custatevec status not found. Error code=" + std::to_string(err);
-    }
-    return result;
-}
 } // namespace Pennylane::LightningGPU::Util
-  // LCOV_EXCL_STOP
\ No newline at end of file
+  // LCOV_EXCL_STOP
diff --git a/pennylane_lightning/core/src/utils/cuda_utils/cuda_helpers.hpp b/pennylane_lightning/core/src/utils/cuda_utils/cuda_helpers.hpp
index c7eeeb975c..1f0aa824cd 100644
--- a/pennylane_lightning/core/src/utils/cuda_utils/cuda_helpers.hpp
+++ b/pennylane_lightning/core/src/utils/cuda_utils/cuda_helpers.hpp
@@ -33,7 +33,6 @@
 #include <cublas_v2.h>
 #include <cuda.h>
 #include <cusparse_v2.h>
-#include <custatevec.h>
 
 #include "DevTag.hpp"
 #include "cuError.hpp"
@@ -339,56 +338,6 @@ static std::pair<int, int> getGPUArch(int device_number = 0) {
     return std::make_pair(deviceProp.major, deviceProp.minor);
 }
 
-inline static auto pauliStringToEnum(const std::string &pauli_word)
-    -> std::vector<custatevecPauli_t> {
-    // Map string rep to Pauli enums
-    const std::unordered_map<std::string, custatevecPauli_t> pauli_map{
-        std::pair<const std::string, custatevecPauli_t>{std::string("X"),
-                                                        CUSTATEVEC_PAULI_X},
-        std::pair<const std::string, custatevecPauli_t>{std::string("Y"),
-                                                        CUSTATEVEC_PAULI_Y},
-        std::pair<const std::string, custatevecPauli_t>{std::string("Z"),
-                                                        CUSTATEVEC_PAULI_Z},
-        std::pair<const std::string, custatevecPauli_t>{std::string("I"),
-                                                        CUSTATEVEC_PAULI_I}};
-
-    static constexpr std::size_t num_char = 1;
-
-    std::vector<custatevecPauli_t> output;
-    output.reserve(pauli_word.size());
-
-    for (const auto ch : pauli_word) {
-        auto out = pauli_map.at(std::string(num_char, ch));
-        output.push_back(out);
-    }
-    return output;
-}
-
-inline static auto pauliStringToOpNames(const std::string &pauli_word)
-    -> std::vector<std::string> {
-    // Map string rep to Pauli
-    const std::unordered_map<std::string, std::string> pauli_map{
-        std::pair<const std::string, std::string>{std::string("X"),
-                                                  std::string("PauliX")},
-        std::pair<const std::string, std::string>{std::string("Y"),
-                                                  std::string("PauliY")},
-        std::pair<const std::string, std::string>{std::string("Z"),
-                                                  std::string("PauliZ")},
-        std::pair<const std::string, std::string>{std::string("I"),
-                                                  std::string("Identity")}};
-
-    static constexpr std::size_t num_char = 1;
-
-    std::vector<std::string> output;
-    output.reserve(pauli_word.size());
-
-    for (const auto ch : pauli_word) {
-        auto out = pauli_map.at(std::string(num_char, ch));
-        output.push_back(out);
-    }
-    return output;
-}
-
 /**
  * Utility hash function for complex vectors representing matrices.
  */