Add Pasqal target

.github/workflows/config/spelling_allowlist.txt

@@ -82,6 +82,7 @@ OpenSUSE
 Ou
 POSIX
 PSIRT
+Pasqal
 Pauli
 Paulis
 Photonic

.github/workflows/integration_tests.yml

@@ -21,6 +21,7 @@ on:
           - ionq
           - iqm
           - oqc
+          - pasqal
           - quantinuum
           - nvqc
           - orca
@@ -693,7 +694,37 @@ jobs:
             exit 1
           fi
         shell: bash
-
+
+      - name: Submit to Pasqal test server
+        if: (success() || failure()) && (inputs.target == 'pasqal' || github.event_name == 'schedule' || inputs.target == 'nightly')
+        run: |
+          echo "### Submit to Pasqal server" >> $GITHUB_STEP_SUMMARY
+          python3 -m pip install pasqal-cloud
+          export PASQAL_USERNAME='${{ secrets.PASQAL_USERNAME }}'
+          export PASQAL_PASSWORD='${{ secrets.PASQAL_PASSWORD }}'
+          export PASQAL_PROJECT_ID='${{ secrets.PASQAL_PROJECT_ID }}'
+          export PASQAL_MACHINE_TARGET="EMU_FREE" # Speedup queuing time
+          set +e # Allow script to keep going through errors
+          test_err_sum=0
+          python_tests="docs/sphinx/targets/python/pasqal.py"
+          for filename in $python_tests; do
+            [ -e "$filename" ] || echo "::error::Couldn't find file ($filename)"
+            python3 $filename 1> /dev/null
+            test_status=$?
+            if [ $test_status -eq 0 ]; then
+              echo ":white_check_mark: Successfully ran test: $filename" >> $GITHUB_STEP_SUMMARY
+            else
+              echo ":x: Test failed (failed to execute): $filename" >> $GITHUB_STEP_SUMMARY
+              test_err_sum=$((test_err_sum+1))
+            fi
+          done
+          set -e # Re-enable exit code error checking
+          if [ ! $test_err_sum -eq 0 ]; then
+            echo "::error::${test_err_sum} tests failed. See step summary for a list of failures"
+            exit 1
+          fi
+        shell: bash
+
       - name: Submit to ${{ inputs.target }}
         # The full set of tests used by this step is currently only supported on
         # Quantinuum.  The other supported tests are tested by the step above.

CMakeLists.txt

@@ -98,6 +98,11 @@ if (NOT DEFINED CUDAQ_ENABLE_BRAKET_BACKEND)
   set(CUDAQ_ENABLE_BRAKET_BACKEND ON CACHE BOOL "Enable building AWS SDK for Amazon Braket backends.")
 endif()
 
+# Enable Pasqal target by default.
+if (NOT DEFINED CUDAQ_ENABLE_PASQAL_BACKEND)
+  set(CUDAQ_ENABLE_PASQAL_BACKEND ON CACHE BOOL "Enable building the Pasqal target.")
+endif()
+
 # Generate a CompilationDatabase (compile_commands.json file) for our build,
 # for use by clang_complete, YouCompleteMe, etc.
 set(CMAKE_EXPORT_COMPILE_COMMANDS 1)

docs/sphinx/api/languages/cpp_api.rst

@@ -218,7 +218,9 @@ Platform
 
 .. doxygenclass:: cudaq::FermioniqBaseQPU
 
-.. doxygenclass:: cudaq::OrcaRemoteRESTQPU 
+.. doxygenclass:: cudaq::OrcaRemoteRESTQPU
+
+.. doxygenclass:: cudaq::PasqalBaseQPU
 
 .. doxygenclass:: cudaq::QuEraBaseQPU
 

docs/sphinx/targets/python/pasqal.py

@@ -0,0 +1,65 @@
+import cudaq
+from cudaq.operator import *
+
+# This example illustrates how to use Pasqal's EMU_MPS emulator over Pasqal's cloud via CUDA-Q.
+
+# To obtain the authentication token we recommend logging in
+# by using Pasqal's Python SDK.
+# Fill in the  username and password via the environment variables.
+# The password can be left empty in an interactive session to be
+# prompted to enter the it securely via the command line interface.
+#
+# Contact Pasqal at help@pasqal.com or through https://community.pasqal.com for assistance.
+#
+# See our general docs https://docs.pasqal.com/cloud/set-up/
+# to see how to get this setup, or the CUDA-Q documentation at
+# https://nvidia.github.io/cuda-quantum/latest/using/backends/hardware/neutralatom.html#pasqal
+from pasqal_cloud import SDK
+import os
+
+sdk = SDK(
+    username=os.environ.get("PASQAL_USERNAME"),
+    password=os.environ.get("PASQAL_PASSWORD", None),
+)
+token = sdk._client.authenticator.token_provider.get_token()
+
+os.environ["PASQAL_AUTH_TOKEN"] = str(token)
+
+cudaq.set_target("pasqal",
+                 machine=os.environ.get("PASQAL_MACHINE_TARGET", "EMU_MPS"))
+
+# ```
+# cudaq.set_target("pasqal", machine="FRESNEL") ## To target QPU
+# ```
+
+# Define the 2-dimensional atom arrangement
+a = 5e-6
+register = [(a, 0), (2 * a, 0), (3 * a, 0)]
+time_ramp = 0.000001
+time_max = 0.000003
+# Times for the piece-wise linear waveforms
+steps = [0.0, time_ramp, time_max - time_ramp, time_max]
+schedule = Schedule(steps, ["t"])
+# Rabi frequencies at each step
+omega_max = 1000000
+delta_end = 1000000
+delta_start = 0.0
+omega = ScalarOperator(lambda t: omega_max if time_ramp < t < time_max else 0.0)
+# Global phase at each step
+phi = ScalarOperator.const(0.0)
+# Global detuning at each step
+delta = ScalarOperator(lambda t: delta_end
+                       if time_ramp < t < time_max else delta_start)
+
+async_result = evolve_async(RydbergHamiltonian(atom_sites=register,
+                                               amplitude=omega,
+                                               phase=phi,
+                                               delta_global=delta),
+                            schedule=schedule,
+                            shots_count=100).get()
+async_result.dump()
+
+## Sample result
+# ```
+# {'001': 16, '010': 23, '100': 19, '000': 42}
+# ```

docs/sphinx/using/backends/hardware/neutralatom.rst

@@ -130,6 +130,85 @@ Submitting
 
 
 
+Pasqal
+++++++++++++++++
+
+Pasqal is a quantum computing hardware company that builds quantum processors from ordered neutral atoms in 2D and 3D
+arrays to bring a practical quantum advantage to its customers and address real-world problems.
+The currently available Pasqal QPUs are analog quantum computers, and one, named Fresnel, is available through our cloud
+portal.
+
+In order to access Pasqal's devices you need an account for `Pasqal's cloud platform <https://portal.pasqal.cloud>`__
+and an active project. Although a different interface, `Pasqal's Pulser library <https://pulser.readthedocs.io/en/latest/>`__, is a good
+resource for getting started with analog neutral atom quantum computing. For support you can also use `Pasqal Community <https://community.pasqal.com/>`__.
+
+
+.. _pasqal-backend:
+
+Setting Credentials
+```````````````````
+
+An authentication token for the session must be obtained from Pasqal's cloud platform.
+For example from Python one can use the `pasqal-cloud package <https://github.com/pasqal-io/pasqal-cloud>`__ as below:
+
+.. code:: python
+
+    from pasqal_cloud import SDK
+    import os
+
+    sdk = SDK(
+        username=os.environ.get['PASQAL_USERNAME'],
+        password=os.environ.get('PASQAL_PASSWORD', None)
+    )
+
+    token = sdk._client.authenticator.token_provider.get_token()
+    os.environ['PASQAL_AUTH_TOKEN'] = str(token)
+    os.environ['PASQAL_PROJECT_ID'] = 'your project id'
+
+Alternatively, users can set the following environment variables directly.
+
+.. code:: bash
+
+  export PASQAL_AUTH_TOKEN=<>
+  export PASQAL_PROJECT_ID=<>
+
+
+Submission from Python
+`````````````````````````
+
+The target to which quantum kernels are submitted 
+can be controlled with the ``cudaq::set_target()`` function.
+
+.. code:: python
+
+    cudaq.set_target('pasqal')
+
+
+Due to the nature of the underlying hardware, this target only supports the 
+``evolve`` and ``evolve_async`` APIs.
+The `hamiltonian` must be an `Operator` of the type `RydbergHamiltonian`. Only 
+other parameters supported are `schedule` (mandatory) and `shots_count` (optional).
+
+For example,
+
+.. code:: python
+
+    evolution_result = evolve(RydbergHamiltonian(atom_sites=register,
+                                                 amplitude=omega,
+                                                 phase=phi,
+                                                 delta_global=delta),
+                               schedule=schedule)
+
+The number of shots for a kernel execution can be set through the ``shots_count``
+argument to ``evolve`` or ``evolve_async``. By default, the ``shots_count`` is 
+set to 100.
+
+.. code:: python 
+
+    cudaq.evolve(RydbergHamiltonian(...), schedule=s, shots_count=1000)
+
+To see a complete example for using Pasqal's backend, take a look at our :doc:`Python examples <../../examples/hardware_providers>`.
+
 
 QuEra Computing
 ++++++++++++++++

docs/sphinx/using/examples/hardware_providers.rst

@@ -114,7 +114,18 @@ This experiment is performed on ORCA's backends by the code below.
 
    .. literalinclude:: ../../targets/cpp/orca.cpp
       :language: cpp
-
+
+Pasqal
+==================================
+
+The following code illustrates how to run kernels on Pasqal's backends.
+
+.. tab:: Python
+
+   .. literalinclude:: ../../targets/python/pasqal.py
+      :language: python
+
+
 Quantinuum
 ==================================
 

python/cudaq/operator/evolution.py

@@ -25,6 +25,8 @@
 from ..kernel.kernel_builder import PyKernel, make_kernel
 from ..runtime.observe import observe
 
+analog_targets = ["pasqal", "quera"]
+
 
 def _taylor_series_expm(op_matrix: NDArray[numpy.complexfloating],
                         order: int = 20) -> NDArray[numpy.complexfloating]:
@@ -210,7 +212,7 @@ def evolve_single(
                                collapse_operators, observables,
                                store_intermediate_results, integrator)
 
-    if target_name == "quera":
+    if target_name in analog_targets:
         ## TODO: Convert result from `sample_result` to `evolve_result`
         return _launch_analog_hamiltonian_kernel(target_name, hamiltonian,
                                                  schedule, shots_count)
@@ -351,11 +353,10 @@ def evolve(
         during evolution.
     """
     target_name = cudaq_runtime.get_target().name
-
     if not isinstance(schedule, Schedule):
         raise ValueError(
             f"Invalid argument `schedule` for target {target_name}.")
-    if target_name == "quera":
+    if target_name in analog_targets:
         if not isinstance(hamiltonian, RydbergHamiltonian):
             raise ValueError(
                 f"Invalid argument `hamiltonian` for target {target_name}. Must be `RydbergHamiltonian` operator."
@@ -432,7 +433,7 @@ def evolve_single_async(
             collapse_operators, observables, store_intermediate_results,
             integrator))
 
-    if target_name == "quera":
+    if target_name in analog_targets:
         return _launch_analog_hamiltonian_kernel(target_name, hamiltonian,
                                                  schedule, shots_count, True)
 
@@ -548,7 +549,7 @@ def evolve_async(
     if not isinstance(schedule, Schedule):
         raise ValueError(
             f"Invalid argument `schedule` for target {target_name}.")
-    if target_name == "quera":
+    if target_name in analog_targets:
         if not isinstance(hamiltonian, RydbergHamiltonian):
             raise ValueError(
                 f"Invalid argument `hamiltonian` for target {target_name}. Must be `RydbergHamiltonian` operator."

python/cudaq/operator/expressions.py

@@ -1272,8 +1272,8 @@ def __rsub__(self: ScalarOperator, other: Any) -> ScalarOperator:
 
 class RydbergHamiltonian(OperatorSum):
     """
-    Representation for the time-dependent Hamiltonian which is simulated by 
-    QuEra's Aquila machine.
+    Representation for the time-dependent Hamiltonian which is simulated by
+    analog neutral-atom machines such as QuEra's Aquila and Pasqal's Fresnel.
     Ref: https://docs.aws.amazon.com/braket/latest/developerguide/braket-quera-submitting-analog-program-aquila.html#braket-quera-ahs-program-schema
     """
 

python/extension/CMakeLists.txt

@@ -82,6 +82,8 @@ declare_mlir_python_extension(CUDAQuantumPythonSources.Extension
     ../../runtime/cudaq/platform/orca/OrcaQPU.cpp
     ../../runtime/cudaq/platform/orca/OrcaRemoteRESTQPU.cpp
     ../../runtime/cudaq/platform/orca/OrcaServerHelper.cpp
+    ../../runtime/cudaq/platform/pasqal/PasqalRemoteRESTQPU.cpp
+    ../../runtime/cudaq/platform/pasqal/PasqalServerHelper.cpp
 
   EMBED_CAPI_LINK_LIBS
    CUDAQuantumMLIRCAPI

python/tests/backends/test_Pasqal.py

@@ -0,0 +1,72 @@
+# ============================================================================ #
+# Copyright (c) 2022 - 2025 NVIDIA Corporation & Affiliates.                   #
+# All rights reserved.                                                         #
+#                                                                              #
+# This source code and the accompanying materials are made available under     #
+# the terms of the Apache License 2.0 which accompanies this distribution.     #
+# ============================================================================ #
+
+import cudaq
+from cudaq.operator import *
+import json
+import os
+import pytest
+
+skipIfPasqalNotInstalled = pytest.mark.skipif(
+    not (cudaq.has_target("pasqal")),
+    reason='Could not find `pasqal` in installation')
+
+
+@pytest.fixture(scope="session", autouse=True)
+def do_something():
+    # NOTE: Credentials can be set with environment variables
+    cudaq.set_target("pasqal")
+    yield "Running the tests."
+    cudaq.reset_target()
+
+
+@skipIfPasqalNotInstalled
+def test_JSON_payload():
+    input = {
+        "setup": {
+            "ahs_register": {
+                "sites": [[0, 0], [0, 0.000004], [0.000004, 0]],
+                "filling": [1, 1, 1]
+            }
+        },
+        "hamiltonian": {
+            "drivingFields": [{
+                "amplitude": {
+                    "time_series": {
+                        "values": [0, 15700000, 15700000, 0],
+                        "times": [0, 0.000001, 0.000002, 0.000003]
+                    },
+                    "pattern": "uniform"
+                },
+                "phase": {
+                    "time_series": {
+                        "values": [0, 0],
+                        "times": [0, 0.000003]
+                    },
+                    "pattern": "uniform"
+                },
+                "detuning": {
+                    "time_series": {
+                        "values": [-54000000, 54000000],
+                        "times": [0, 0.000003]
+                    },
+                    "pattern": "uniform"
+                }
+            }],
+            "localDetuning": []
+        }
+    }
+    # NOTE: For internal testing only, not user-level API; this does not return results
+    cudaq.cudaq_runtime.pyAltLaunchAnalogKernel("__analog_hamiltonian_kernel__",
+                                                json.dumps(input))
+
+
+# leave for gdb debugging
+if __name__ == "__main__":
+    loc = os.path.abspath(__file__)
+    pytest.main([loc, "-rP"])