Replacing existing spin_ops with the general operators

.github/workflows/config/gitlab_commits.txt

@@ -1,2 +1,2 @@
-nvidia-mgpu-repo: cuda-quantum/cuquantum-mgpu.git
-nvidia-mgpu-commit: ddfaacf2ffd7dc1a9a4333e06474b213887d437c
+nvidia-mgpu-repo: cuda-quantum/cuquantum-mgpu.git
+nvidia-mgpu-commit: 966ff7b2f775128fa3339e19672892d8ff1a4e74

cmake/Modules/CMakeLists.txt

@@ -10,7 +10,6 @@ set(CONFIG_FILES
   CUDAQCommonConfig.cmake
   CUDAQEmDefaultConfig.cmake
   CUDAQNloptConfig.cmake
-  CUDAQSpinConfig.cmake
   CUDAQOperatorConfig.cmake
   CUDAQConfig.cmake
   CUDAQEnsmallenConfig.cmake

cmake/Modules/CUDAQConfig.cmake

@@ -11,9 +11,6 @@ get_filename_component(CUDAQ_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
 include(CMakeFindDependencyMacro)
 list(APPEND CMAKE_MODULE_PATH "${CUDAQ_CMAKE_DIR}")
 
-set (CUDAQSpin_DIR "${CUDAQ_CMAKE_DIR}")
-find_dependency(CUDAQSpin REQUIRED)
-
 set (CUDAQOperator_DIR "${CUDAQ_CMAKE_DIR}")
 find_dependency(CUDAQOperator REQUIRED)
 

cmake/Modules/CUDAQEmDefaultConfig.cmake

@@ -8,9 +8,6 @@
 
 get_filename_component(CUDAQ_EM_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH)
 
-set (CUDAQSpin_DIR "${CUDAQ_EM_CMAKE_DIR}")
-find_dependency(CUDAQSpin REQUIRED)
-
 set (CUDAQOperator_DIR "${CUDAQ_EM_CMAKE_DIR}")
 find_dependency(CUDAQOperator REQUIRED)
 

cmake/Modules/CUDAQPlatformDefaultConfig.cmake

@@ -14,9 +14,6 @@ find_dependency(CUDAQEmDefault REQUIRED)
 set (CUDAQOperator_DIR "${CUDAQ_CMAKE_DIR}")
 find_dependency(CUDAQOperator REQUIRED)
 
-set (CUDAQSpin_DIR "${CUDAQ_CMAKE_DIR}")
-find_dependency(CUDAQSpin REQUIRED)
-
 set (CUDAQCommon_DIR "${CUDAQ_CMAKE_DIR}")
 find_dependency(CUDAQCommon REQUIRED)
 

cmake/Modules/NVQIRConfig.cmake.in

@@ -11,7 +11,6 @@ include(CMakeFindDependencyMacro)
 
 get_filename_component(PARENT_DIRECTORY ${NVQIR_CMAKE_DIR} DIRECTORY)
 
-find_dependency(CUDAQSpin REQUIRED HINTS "${PARENT_DIRECTORY}/cudaq")
 find_dependency(CUDAQOperator REQUIRED HINTS "${PARENT_DIRECTORY}/cudaq")
 find_dependency(CUDAQCommon REQUIRED HINTS "${PARENT_DIRECTORY}/cudaq")
 find_package(fmt QUIET)

docs/sphinx/api/languages/cpp_api.rst

@@ -1,12 +1,6 @@
 CUDA-Q C++ API
 ******************************
 
-Operators 
-=============
-
-.. doxygenclass:: cudaq::spin_op
-    :members:
-
 Quantum
 =========
 
@@ -38,9 +32,9 @@ Common
 .. doxygenstruct:: cudaq::observe_options
     :members:
 
-.. doxygenfunction:: cudaq::observe(const observe_options &options, QuantumKernel &&kernel, spin_op H, Args &&...args)
-.. doxygenfunction:: cudaq::observe(std::size_t shots, QuantumKernel &&kernel, spin_op H, Args &&...args)
-.. doxygenfunction:: cudaq::observe(QuantumKernel &&kernel, spin_op H, Args &&...args)
+.. doxygenfunction:: cudaq::observe(const observe_options &options, QuantumKernel &&kernel, const spin_op &H, Args &&...args)
+.. doxygenfunction:: cudaq::observe(std::size_t shots, QuantumKernel &&kernel, const spin_op &H, Args &&...args)
+.. doxygenfunction:: cudaq::observe(QuantumKernel &&kernel, const spin_op &H, Args &&...args)
 .. doxygenfunction:: cudaq::observe(QuantumKernel &&kernel, const SpinOpContainer &termList, Args &&...args)
 
 .. doxygenclass:: cudaq::ExecutionContext

docs/sphinx/applications/cpp/qaoa_maxcut.cpp

@@ -8,7 +8,6 @@
 #include <cudaq/algorithm.h>
 #include <cudaq/gradients.h>
 #include <cudaq/optimizers.h>
-#include <cudaq/spin_op.h>
 
 // Here we build up a CUDA-Q kernel for QAOA with p layers, with each
 // layer containing the alternating set of unitaries corresponding to the
@@ -51,13 +50,13 @@ struct ansatz {
 
 int main() {
 
-  using namespace cudaq::spin;
-
   cudaq::set_random_seed(13); // set for repeatability
 
   // Problem Hamiltonian
-  const cudaq::spin_op Hp = 0.5 * z(0) * z(1) + 0.5 * z(1) * z(2) +
-                            0.5 * z(0) * z(3) + 0.5 * z(2) * z(3);
+  const cudaq::spin_op Hp = 0.5 * cudaq::spin_op::z(0) * cudaq::spin_op::z(1) +
+                            0.5 * cudaq::spin_op::z(1) * cudaq::spin_op::z(2) +
+                            0.5 * cudaq::spin_op::z(0) * cudaq::spin_op::z(3) +
+                            0.5 * cudaq::spin_op::z(2) * cudaq::spin_op::z(3);
 
   // Problem parameters
   const int n_qubits = 4;

docs/sphinx/applications/cpp/trotter_kernel_mode.cpp

@@ -57,19 +57,22 @@ struct initState {
   }
 };
 
-std::vector<double> term_coefficients(cudaq::spin_op op) {
+std::vector<double> term_coefficients(const cudaq::spin_op &op) {
   std::vector<double> result{};
-  op.for_each_term([&](cudaq::spin_op &term) {
-    const auto coeff = term.get_coefficient().real();
+  for (const auto &term : op) {
+    const auto coeff = term.evaluate_coefficient().real();
     result.push_back(coeff);
-  });
+  }
   return result;
 }
 
-std::vector<cudaq::pauli_word> term_words(cudaq::spin_op op) {
-  std::vector<cudaq::pauli_word> result{};
-  op.for_each_term(
-      [&](cudaq::spin_op &term) { result.push_back(term.to_string(false)); });
+std::vector<cudaq::pauli_word> term_words(const cudaq::spin_op &op) {
+  // Our kernel uses these words to apply exp_pauli to the entire state.
+  // we hence ensure that each pauli word covers the entire space.
+  auto n_spins = op.num_qubits();
+  std::vector<cudaq::pauli_word> result;
+  for (const auto &term : op)
+    result.push_back(term.get_pauli_word(n_spins));
   return result;
 }
 
@@ -93,22 +96,22 @@ int run_steps(int steps, int spins) {
   const double Jz = g;
   const double dt = 0.05;
   const int n_steps = steps;
-  const int n_spins = spins;
+  const std::size_t n_spins = spins;
   const double omega = 2 * M_PI;
   const auto heisenbergModelHam = [&](double t) -> cudaq::spin_op {
     cudaq::spin_op tdOp(n_spins);
-    for (int i = 0; i < n_spins - 1; ++i) {
+    for (std::size_t i = 0; i < n_spins - 1; ++i) {
       tdOp += (Jx * cudaq::spin::x(i) * cudaq::spin::x(i + 1));
       tdOp += (Jy * cudaq::spin::y(i) * cudaq::spin::y(i + 1));
       tdOp += (Jz * cudaq::spin::z(i) * cudaq::spin::z(i + 1));
     }
-    for (int i = 0; i < n_spins; ++i)
+    for (std::size_t i = 0; i < n_spins; ++i)
       tdOp += (std::cos(omega * t) * cudaq::spin::x(i));
     return tdOp;
   };
   // Observe the average magnetization of all spins (<Z>)
   cudaq::spin_op average_magnetization(n_spins);
-  for (int i = 0; i < n_spins; ++i)
+  for (std::size_t i = 0; i < n_spins; ++i)
     average_magnetization += ((1.0 / n_spins) * cudaq::spin::z(i));
   average_magnetization -= 1.0;
 

docs/sphinx/applications/python/adapt_qaoa.ipynb

@@ -102,7 +102,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -118,23 +118,28 @@
     "        # Add a term to the Hamiltonian for the edge (u,v)\n",
     "        ham += 0.5 * (weight[count] * cudaq.spin.z(qubitu) * cudaq.spin.z(qubitv) -\n",
     "                            weight[count] * cudaq.spin.i(qubitu) * cudaq.spin.i(qubitv))\n",
-    "        count+=1\n",
+    "        count += 1\n",
     "\n",
     "    return ham\n",
     "\n",
     "# Collect coefficients from a spin operator so we can pass them to a kernel\n",
     "def term_coefficients(ham: cudaq.SpinOperator) -> list[complex]:\n",
     "    result = []\n",
-    "    ham.for_each_term(lambda term: result.append(term.get_coefficient()))\n",
+    "    for term in ham:\n",
+    "        result.append(term.get_coefficient())\n",
     "    return result\n",
     "\n",
     "# Collect Pauli words from a spin operator so we can pass them to a kernel\n",
     "def term_words(ham: cudaq.SpinOperator) -> list[str]:\n",
+    "    # Our kernel uses these words to apply exp_pauli to the entire state.\n",
+    "    # we hence ensure that each pauli word covers the entire space.\n",
+    "    n_spins = ham.get_qubit_count()\n",
     "    result = []\n",
-    "    ham.for_each_term(lambda term: result.append(term.to_string(False)))\n",
+    "    for term in ham:\n",
+    "        result.append(term.get_pauli_word(n_spins))\n",
     "    return result\n",
     "\n",
-    "# Generate the Spin Hmiltonian:\n",
+    "# Generate the Spin Hamiltonian:\n",
     "\n",
     "ham = spin_ham(edges, weight)\n",
     "ham_coef = term_coefficients(ham)\n",
@@ -185,7 +190,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -200,7 +205,6 @@
     "# Generate the mixer pool\n",
     "\n",
     "pools = mixer_pool(qubits_num)\n",
-    "#print([op.to_string(False) for op in pools])\n",
     "print('Number of pool operator: ', len(pools))"
    ]
   },
@@ -289,7 +293,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -402,7 +406,7 @@
     "        layer.append(1) \n",
     "        random_mixer = random.choice(temp_pool)\n",
     "        \n",
-    "        mixer_pool = mixer_pool + [random_mixer.to_string(False)]\n",
+    "        mixer_pool = mixer_pool + [random_mixer.get_pauli_word(qubits_num)]\n",
     "    \n",
     "        print('Mixer pool at step', istep)\n",
     "        print(mixer_pool)\n",

docs/sphinx/applications/python/digitized_counterdiabatic_qaoa.ipynb

@@ -122,14 +122,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "# Generate the Hamiltonian\n",
     "def ham_clique(penalty, nodes, weights, non_edges) -> cudaq.SpinOperator:\n",
     "\n",
-    "    spin_ham = 0.0\n",
+    "    spin_ham = 0\n",
     "    for wt, node in zip(weights, nodes):\n",
     "        #print(wt,node)\n",
     "        spin_ham += 0.5 * wt * spin.z(node)\n",
@@ -153,7 +153,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
@@ -180,15 +180,20 @@
     "# Collect coefficients from a spin operator so we can pass them to a kernel\n",
     "def term_coefficients(ham: cudaq.SpinOperator) -> list[complex]:\n",
     "    result = []\n",
-    "    ham.for_each_term(lambda term: result.append(term.get_coefficient()))\n",
+    "    for term in ham:\n",
+    "        result.append(term.get_coefficient())\n",
     "    return result\n",
     "\n",
     "    # Collect Pauli words from a spin operator so we can pass them to a kernel\n",
     "\n",
     "\n",
     "def term_words(ham: cudaq.SpinOperator) -> list[str]:\n",
+    "    # Our kernel uses these words to apply exp_pauli to the entire state.\n",
+    "    # we hence ensure that each pauli word covers the entire space.\n",
+    "    n_spins = ham.get_qubit_count()\n",
     "    result = []\n",
-    "    ham.for_each_term(lambda term: result.append(term.to_string(False)))\n",
+    "    for term in ham:\n",
+    "        result.append(term.get_pauli_word(n_spins))\n",
     "    return result\n",
     "\n",
     "\n",

docs/sphinx/applications/python/divisive_clustering_coresets.ipynb

@@ -223,7 +223,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [

docs/sphinx/applications/python/hamiltonian_simulation.ipynb

@@ -191,14 +191,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "id": "heisenberg-code",
    "metadata": {},
    "outputs": [],
    "source": [
     "def create_hamiltonian_heisenberg(n_spins: int, Jx: float, Jy: float, Jz: float, h_x: list[float], h_y: list[float], h_z: list[float]):\n",
     "    \"\"\"Create the Hamiltonian operator\"\"\"\n",
-    "    ham = cudaq.SpinOperator(num_qubits=n_spins)\n",
+    "    ham = 0\n",
     "\n",
     "    # Add two-qubit interaction terms for Heisenberg Hamiltonian\n",
     "    for i in range(0, n_spins - 1):\n",
@@ -221,14 +221,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "id": "tfim-code",
    "metadata": {},
    "outputs": [],
    "source": [
     "def create_hamiltonian_tfim(n_spins: int, h_field: float):\n",
     "    \"\"\"Create the Hamiltonian operator\"\"\"\n",
-    "    ham = cudaq.SpinOperator(num_qubits=n_spins)\n",
+    "    ham = 0\n",
     "   \n",
     "    # Add single-qubit terms\n",
     "    for i in range(0, n_spins):\n",
@@ -253,19 +253,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "id": "extract-code",
    "metadata": {},
    "outputs": [],
    "source": [
     "def extractCoefficients(hamiltonian: cudaq.SpinOperator):\n",
     "    result = []\n",
-    "    hamiltonian.for_each_term(lambda term: result.append(term.get_coefficient()))\n",
+    "    for term in hamiltonian:\n",
+    "        result.append(term.get_coefficient())\n",
     "    return result\n",
     "\n",
     "def extractWords(hamiltonian: cudaq.SpinOperator):\n",
+    "    # Our kernel uses these words to apply exp_pauli to the entire state.\n",
+    "    # we hence ensure that each pauli word covers the entire space.\n",
+    "    n_spins = hamiltonian.get_qubit_count()\n",
     "    result = []\n",
-    "    hamiltonian.for_each_term(lambda term: result.append(term.to_string(False)))\n",
+    "    for term in hamiltonian:\n",
+    "        result.append(term.get_pauli_word(n_spins))\n",
     "    return result"
    ]
   },