qilisdk 0.1.4__py3-none-any.whl → 0.1.5__py3-none-any.whl

qilisdk/backends/__init__.py

@@ -0,0 +1,45 @@
+# Copyright 2025 Qilimanjaro Quantum Tech
+#
+# 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.
+import sys
+
+from qilisdk._optionals import ImportedFeature, OptionalFeature, Symbol, import_optional_dependencies
+
+__all__ = []
+
+OPTIONAL_FEATURES: list[OptionalFeature] = [
+    OptionalFeature(
+        name="cuda",
+        dependencies=["cuda-quantum-cu12"],
+        symbols=[
+            Symbol(path="qilisdk.backends.cuda_backend", name="CudaBackend"),
+            Symbol(path="qilisdk.backends.cuda_backend", name="CudaSamplingMethod"),
+        ],
+    ),
+    OptionalFeature(
+        name="qutip",
+        dependencies=["qutip", "qutip-qip", "matplotlib"],
+        symbols=[
+            Symbol(path="qilisdk.backends.qutip_backend", name="QutipBackend"),
+        ],
+    ),
+]
+
+current_module = sys.modules[__name__]
+
+# Dynamically import (or stub) each feature's symbols and attach them
+for feature in OPTIONAL_FEATURES:
+    imported_feature: ImportedFeature = import_optional_dependencies(feature)
+    for symbol_name, symbol_obj in imported_feature.symbols.items():
+        setattr(current_module, symbol_name, symbol_obj)
+        __all__ += [symbol_name]  # noqa: PLE0604

qilisdk/{digital/digital_algorithm.py → backends/__init__.pyi}

@@ -11,10 +11,8 @@
 # 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.
-from qilisdk.common.algorithm import Algorithm
 
+from .cuda_backend import CudaBackend, CudaSamplingMethod
+from .qutip_backend import QutipBackend
 
-class DigitalAlgorithm(Algorithm):
-    """
-    Abstract base class for digital quantum algorithms.
-    """
+__all__ = ["CudaBackend", "CudaSamplingMethod", "QutipBackend"]

qilisdk/backends/backend.py

@@ -0,0 +1,117 @@
+# Copyright 2025 Qilimanjaro Quantum Tech
+#
+# 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.
+from __future__ import annotations
+
+from abc import ABC
+from typing import TYPE_CHECKING, Callable, TypeVar, cast, overload
+
+from qilisdk.functionals.functional_result import FunctionalResult
+from qilisdk.functionals.sampling import Sampling
+from qilisdk.functionals.time_evolution import TimeEvolution
+from qilisdk.functionals.variational_program import VariationalProgram
+from qilisdk.functionals.variational_program_result import VariationalProgramResult
+
+if TYPE_CHECKING:
+    from qilisdk.functionals.functional import Functional, PrimitiveFunctional
+    from qilisdk.functionals.sampling_result import SamplingResult
+    from qilisdk.functionals.time_evolution_result import TimeEvolutionResult
+
+TResult = TypeVar("TResult", bound=FunctionalResult)
+
+
+class Backend(ABC):
+    def __init__(self) -> None:
+        self._handlers: dict[type[Functional], Callable[[Functional], FunctionalResult]] = {
+            Sampling: lambda f: self._execute_sampling(cast("Sampling", f)),
+            TimeEvolution: lambda f: self._execute_time_evolution(cast("TimeEvolution", f)),
+            VariationalProgram: lambda f: self._execute_variational_program(cast("VariationalProgram", f)),
+        }
+
+    @overload
+    def execute(self, functional: Sampling) -> SamplingResult: ...
+
+    @overload
+    def execute(self, functional: TimeEvolution) -> TimeEvolutionResult: ...
+
+    @overload
+    def execute(self, functional: VariationalProgram[Sampling]) -> VariationalProgramResult[SamplingResult]: ...
+
+    @overload
+    def execute(
+        self, functional: VariationalProgram[TimeEvolution]
+    ) -> VariationalProgramResult[TimeEvolutionResult]: ...
+
+    @overload
+    def execute(self, functional: PrimitiveFunctional[TResult]) -> TResult: ...
+
+    def execute(self, functional: Functional) -> FunctionalResult:
+        try:
+            handler = self._handlers[type(functional)]
+        except KeyError as exc:
+            raise NotImplementedError(
+                f"{type(self).__qualname__} does not support {type(functional).__qualname__}"
+            ) from exc
+
+        return handler(functional)
+
+    def _execute_sampling(self, functional: Sampling) -> SamplingResult:
+        raise NotImplementedError(f"{type(self).__qualname__} has no Sampling implementation")
+
+    def _execute_time_evolution(self, functional: TimeEvolution) -> TimeEvolutionResult:
+        raise NotImplementedError(f"{type(self).__qualname__} has no TimeEvolution implementation")
+
+    def _execute_variational_program(
+        self, functional: VariationalProgram[PrimitiveFunctional[TResult]]
+    ) -> VariationalProgramResult[TResult]:
+        """Optimize a Parameterized Program (:class:`~qilisdk.functionals.variational_program.VariationalProgram`)
+            and returns the optimal parameters and results.
+
+        Args:
+            functional (VariationalProgram): The variational program to be optimized.
+
+        Returns:
+            ParameterizedProgramResults: The final optimizer and functional results.
+
+        Raises:
+            ValueError: If the functional is not parameterized.
+        """
+
+        def evaluate_sample(parameters: list[float]) -> float:
+            param_names = functional.functional.get_parameter_names()
+            functional.functional.set_parameters({param_names[i]: param for i, param in enumerate(parameters)})
+            results = self.execute(functional.functional)
+            final_results = functional.cost_function.compute_cost(results)
+            if isinstance(final_results, float):
+                return final_results
+            if isinstance(final_results, complex) and final_results.imag == 0:
+                return final_results.real
+            raise ValueError(f"Unsupported result type {type(final_results)}.")
+
+        if len(functional.functional.get_parameters()) == 0:
+            raise ValueError("Functional provided is not parameterized.")
+
+        optimizer_result = functional.optimizer.optimize(
+            cost_function=evaluate_sample,
+            init_parameters=list(functional.functional.get_parameters().values()),
+            bounds=list(functional.functional.get_parameter_bounds().values()),
+            store_intermediate_results=functional.store_intermediate_results,
+        )
+
+        param_names = functional.functional.get_parameter_names()
+        functional.functional.set_parameters(
+            {param_names[i]: param for i, param in enumerate(optimizer_result.optimal_parameters)}
+        )
+        optimal_results: TResult = cast("TResult", self.execute(functional.functional))
+
+        return VariationalProgramResult(optimizer_result=optimizer_result, result=optimal_results)

qilisdk/{extras/cuda → backends}/cuda_backend.py

@@ -13,41 +13,27 @@
 # limitations under the License.
 from __future__ import annotations
 
+from enum import Enum
 from typing import TYPE_CHECKING, Callable, Type, TypeVar
 
 import cudaq
 import numpy as np
 from cudaq import ElementaryOperator, OperatorSum, ScalarOperator, State, evolve, spin
-from cudaq import Schedule as cuda_schedule
+from cudaq import Schedule as CudaSchedule
+from loguru import logger
 
-from qilisdk.analog.analog_backend import AnalogBackend
 from qilisdk.analog.hamiltonian import Hamiltonian, PauliI, PauliOperator, PauliX, PauliY, PauliZ
-from qilisdk.analog.quantum_objects import QuantumObject
-from qilisdk.digital import (
-    RX,
-    RY,
-    RZ,
-    U1,
-    U2,
-    U3,
-    Circuit,
-    H,
-    M,
-    S,
-    T,
-    X,
-    Y,
-    Z,
-)
-from qilisdk.digital.digital_backend import DigitalBackend, DigitalSimulationMethod
+from qilisdk.backends.backend import Backend
+from qilisdk.common.qtensor import QTensor
 from qilisdk.digital.exceptions import UnsupportedGateError
-from qilisdk.digital.gates import Adjoint, BasicGate, Controlled
-
-from .cuda_analog_result import CudaAnalogResult
-from .cuda_digital_result import CudaDigitalResult
+from qilisdk.digital.gates import RX, RY, RZ, SWAP, U1, U2, U3, Adjoint, BasicGate, Controlled, H, I, M, S, T, X, Y, Z
+from qilisdk.functionals.sampling_result import SamplingResult
+from qilisdk.functionals.time_evolution_result import TimeEvolutionResult
 
 if TYPE_CHECKING:
-    from qilisdk.analog.schedule import Schedule
+    from qilisdk.digital.circuit import Circuit
+    from qilisdk.functionals.sampling import Sampling
+    from qilisdk.functionals.time_evolution import TimeEvolution
 
 
 TBasicGate = TypeVar("TBasicGate", bound=BasicGate)
@@ -57,9 +43,19 @@ TPauliOperator = TypeVar("TPauliOperator", bound=PauliOperator)
 PauliOperatorHandlersMapping = dict[Type[TPauliOperator], Callable[[TPauliOperator], ElementaryOperator]]
 
 
-class CudaBackend(DigitalBackend, AnalogBackend):
+class CudaSamplingMethod(str, Enum):
+    """
+    Enumeration of available simulation methods for the CUDA backend.
     """
-    Digital backend implementation using CUDA-based simulation.
+
+    STATE_VECTOR = "state_vector"
+    TENSOR_NETWORK = "tensor_network"
+    MATRIX_PRODUCT_STATE = "matrix_product_state"
+
+
+class CudaBackend(Backend):
+    """
+    Backend implementation using CUDA-based simulation.
 
     This backend translates a quantum circuit into a CUDA-compatible kernel and executes it
     using the cudaq library. It supports different simulation methods including state vector,
@@ -67,19 +63,19 @@ class CudaBackend(DigitalBackend, AnalogBackend):
     mapped to CUDA operations via dedicated handler functions.
     """
 
-    def __init__(
-        self, digital_simulation_method: DigitalSimulationMethod = DigitalSimulationMethod.STATE_VECTOR
-    ) -> None:
+    def __init__(self, sampling_method: CudaSamplingMethod = CudaSamplingMethod.STATE_VECTOR) -> None:
         """
         Initialize the CudaBackend.
 
         Args:
-            digital_simulation_method (SimulationMethod, optional): The simulation method to use for executing circuits.
+            sampling_method (CudaSamplingMethod, optional): The simulation method to use for sampling circuits.
                 Options include STATE_VECTOR, TENSOR_NETWORK, or MATRIX_PRODUCT_STATE.
                 Defaults to STATE_VECTOR.
         """
-        super().__init__(digital_simulation_method=digital_simulation_method)
+        super().__init__()
+        cudaq.register_operation("i", np.array([1, 0, 0, 1]))
         self._basic_gate_handlers: BasicGateHandlersMapping = {
+            I: CudaBackend._handle_I,
             X: CudaBackend._handle_X,
             Y: CudaBackend._handle_Y,
             Z: CudaBackend._handle_Z,
@@ -92,6 +88,7 @@ class CudaBackend(DigitalBackend, AnalogBackend):
             U1: CudaBackend._handle_U1,
             U2: CudaBackend._handle_U2,
             U3: CudaBackend._handle_U3,
+            SWAP: CudaBackend._handle_SWAP,  # type: ignore[dict-item]
         }
         self._pauli_operator_handlers: PauliOperatorHandlersMapping = {
             PauliX: CudaBackend._handle_PauliX,
@@ -99,6 +96,18 @@ class CudaBackend(DigitalBackend, AnalogBackend):
             PauliZ: CudaBackend._handle_PauliZ,
             PauliI: CudaBackend._handle_PauliI,
         }
+        self._sampling_method = sampling_method
+        logger.success("CudaBackend initialised (sampling_method={})", sampling_method.value)
+
+    @property
+    def sampling_method(self) -> CudaSamplingMethod:
+        """
+        Get the simulation method currently configured for the backend.
+
+        Returns:
+            SimulationMethod: The simulation method to be used for circuit execution.
+        """
+        return self._sampling_method
 
     def _apply_digital_simulation_method(self) -> None:
         """
@@ -107,53 +116,110 @@ class CudaBackend(DigitalBackend, AnalogBackend):
         For the STATE_VECTOR method, it checks for GPU availability and selects an appropriate target.
         For TENSOR_NETWORK and MATRIX_PRODUCT_STATE methods, it explicitly sets the target to use tensor network-based simulations.
         """
-        if self.digital_simulation_method == DigitalSimulationMethod.STATE_VECTOR:
+        logger.info("Applying sampling simulation method {}", self.sampling_method.value)
+        if self.sampling_method == CudaSamplingMethod.STATE_VECTOR:
             if cudaq.num_available_gpus() == 0:
                 cudaq.set_target("qpp-cpu")
+                logger.debug("No GPU detected, using cudaq's 'qpp-cpu' backend")
             else:
                 cudaq.set_target("nvidia")
-        elif self.digital_simulation_method == DigitalSimulationMethod.TENSOR_NETWORK:
+                logger.debug("GPU detected, using cudaq's 'nvidia' backend")
+        elif self.sampling_method == CudaSamplingMethod.TENSOR_NETWORK:
             cudaq.set_target("tensornet")
+            logger.debug("Using cudaq's 'tensornet' backend")
         else:
             cudaq.set_target("tensornet-mps")
+            logger.debug("Using cudaq's 'tensornet-mps' backend")
 
-    def execute(self, circuit: Circuit, nshots: int = 1000) -> CudaDigitalResult:
-        """
-        Execute a quantum circuit and return the measurement results.
-
-        This method applies the selected simulation method, translates the circuit's gates into
-        CUDA operations via their respective handlers, runs the simulation, and returns the result
-        as a CudaDigitalResult.
-
-        Args:
-            circuit (Circuit): The quantum circuit to be executed.
-            nshots (int, optional): The number of measurement shots to perform. Defaults to 1000.
-
-        Returns:
-            DigitalResult: A result object containing the measurement samples and computed probabilities.
-
-        Raises:
-            UnsupportedGateError: If the circuit contains a gate for which no handler is registered.
-        """
+    def _execute_sampling(self, functional: Sampling) -> SamplingResult:
+        logger.info("Executing Sampling (shots={})", functional.nshots)
         self._apply_digital_simulation_method()
         kernel = cudaq.make_kernel()
-        qubits = kernel.qalloc(circuit.nqubits)
+        qubits = kernel.qalloc(functional.circuit.nqubits)
 
-        for gate in circuit.gates:
+        for gate in functional.circuit.gates:
             if isinstance(gate, Controlled):
                 self._handle_controlled(kernel, gate, qubits[gate.control_qubits[0]], qubits[gate.target_qubits[0]])
             elif isinstance(gate, Adjoint):
                 self._handle_adjoint(kernel, gate, qubits[gate.target_qubits[0]])
             elif isinstance(gate, M):
-                self._handle_M(kernel, gate, circuit, qubits)
+                self._handle_M(kernel, gate, functional.circuit, qubits)
             else:
                 handler = self._basic_gate_handlers.get(type(gate), None)
                 if handler is None:
                     raise UnsupportedGateError
-                handler(kernel, gate, qubits[gate.target_qubits[0]])
+                handler(kernel, gate, *(qubits[gate.target_qubits[i]] for i in range(len(gate.target_qubits))))
+
+        cudaq_result = cudaq.sample(kernel, shots_count=functional.nshots)
+        logger.success("Sampling finished; {} distinct bitstrings", len(cudaq_result))
+        return SamplingResult(nshots=functional.nshots, samples=dict(cudaq_result.items()))
+
+    def _execute_time_evolution(self, functional: TimeEvolution) -> TimeEvolutionResult:
+        logger.info("Executing TimeEvolution (T={}, dt={})", functional.schedule.T, functional.schedule.dt)
+        cudaq.set_target("dynamics")
+
+        steps = np.linspace(0, functional.schedule.T, (round(functional.schedule.T / functional.schedule.dt) + 1))
+
+        cuda_schedule = CudaSchedule(steps, ["t"])
+
+        def get_schedule(key: str) -> Callable:
+            return lambda t: (functional.schedule.get_coefficient(t.real, key))
 
-        cudaq_result = cudaq.sample(kernel, shots_count=nshots)
-        return CudaDigitalResult(nshots=nshots, samples=dict(cudaq_result.items()))
+        cuda_hamiltonian = sum(
+            ScalarOperator(get_schedule(key)) * self._hamiltonian_to_cuda(ham)
+            for key, ham in functional.schedule.hamiltonians.items()
+        )
+
+        logger.trace("Hamiltonian compiled for evolution")
+
+        cuda_observables = []
+        for observable in functional.observables:
+            if isinstance(observable, PauliOperator):
+                cuda_observables.append(self._pauli_operator_handlers[type(observable)](observable))
+            elif isinstance(observable, Hamiltonian):
+                cuda_observables.append(self._hamiltonian_to_cuda(observable))
+            else:
+                logger.error("Unsupported observable type {}", observable.__class__.__name__)
+                raise ValueError(f"unsupported observable type of {observable.__class__}")
+        logger.trace("Observables compiled for evolution")
+
+        evolution_result = evolve(
+            hamiltonian=cuda_hamiltonian,
+            dimensions=dict.fromkeys(range(functional.schedule.nqubits), 2),
+            schedule=cuda_schedule,
+            initial_state=State.from_data(np.array(functional.initial_state.unit().dense, dtype=np.complex128)),
+            observables=cuda_observables,
+            collapse_operators=[],
+            store_intermediate_results=functional.store_intermediate_results,
+        )
+
+        logger.success("TimeEvolution finished")
+
+        final_expected_values = np.array(
+            [exp_val.expectation() for exp_val in evolution_result.final_expectation_values()]
+        )
+        expected_values = (
+            np.array([[val.expectation() for val in exp_vals] for exp_vals in evolution_result.expectation_values()])
+            if evolution_result.expectation_values() is not None and functional.store_intermediate_results
+            else None
+        )
+        final_state = (
+            QTensor(np.array(evolution_result.final_state()).reshape(-1, 1))
+            if evolution_result.final_state() is not None
+            else None
+        )
+        intermediate_states = (
+            [QTensor(np.array(state).reshape(-1, 1)) for state in evolution_result.intermediate_states()]
+            if evolution_result.intermediate_states() is not None and functional.store_intermediate_results
+            else None
+        )
+
+        return TimeEvolutionResult(
+            final_expected_values=final_expected_values,
+            expected_values=expected_values,
+            final_state=final_state,
+            intermediate_states=intermediate_states,
+        )
 
     def _handle_controlled(
         self, kernel: cudaq.Kernel, gate: Controlled, control_qubit: cudaq.QuakeValue, target_qubit: cudaq.QuakeValue
@@ -174,10 +240,12 @@ class CudaBackend(DigitalBackend, AnalogBackend):
             UnsupportedGateError: If the number of control qubits is not equal to one or if the basic gate is unsupported.
         """
         if len(gate.control_qubits) != 1:
+            logger.error("Controlled gate with {} control qubits not supported", len(gate.control_qubits))
             raise UnsupportedGateError
         target_kernel, qubit = cudaq.make_kernel(cudaq.qubit)
         handler = self._basic_gate_handlers.get(type(gate.basic_gate), None)
         if handler is None:
+            logger.error("Unsupported gate inside Controlled: {}", type(gate.basic_gate).__name__)
             raise UnsupportedGateError
         handler(target_kernel, gate.basic_gate, qubit)
         kernel.control(target_kernel, control_qubit, target_qubit)
@@ -200,103 +268,11 @@ class CudaBackend(DigitalBackend, AnalogBackend):
         target_kernel, qubit = cudaq.make_kernel(cudaq.qubit)
         handler = self._basic_gate_handlers.get(type(gate.basic_gate), None)
         if handler is None:
+            logger.error("Unsupported gate inside Adjoint: {}", type(gate.basic_gate).__name__)
             raise UnsupportedGateError
         handler(target_kernel, gate.basic_gate, qubit)
         kernel.adjoint(target_kernel, target_qubit)
 
-    def _hamiltonian_to_cuda(self, hamiltonian: Hamiltonian) -> OperatorSum:
-        out = None
-        for offset, terms in hamiltonian:
-            if out is None:
-                out = offset * np.prod([self._pauli_operator_handlers[type(pauli)](pauli) for pauli in terms])
-            else:
-                out += offset * np.prod([self._pauli_operator_handlers[type(pauli)](pauli) for pauli in terms])
-        return out
-
-    def evolve(
-        self,
-        schedule: Schedule,
-        initial_state: QuantumObject,
-        observables: list[PauliOperator | Hamiltonian],
-        store_intermediate_results: bool = False,
-    ) -> CudaAnalogResult:
-        """computes the time evolution under of an initial state under the given schedule.
-
-        Args:
-            schedule (Schedule): The evolution schedule of the system.
-            initial_state (QuantumObject): the initial state of the evolution.
-            observables (list[PauliOperator  |  Hamiltonian]): the list of observables to be measured at the end of the evolution.
-            store_intermediate_results (bool): A flag to store the intermediate results along the evolution.
-
-        Raises:
-            ValueError: if the observables provided are not an instance of the PauliOperator or a Hamiltonian class.
-
-        Returns:
-            AnalogResult: The results of the evolution.
-        """
-        cudaq.set_target("dynamics")
-
-        cuda_hamiltonian = None
-        steps = np.linspace(0, schedule.T, int(schedule.T / schedule.dt))
-
-        def parameter_values(time_steps: np.ndarray) -> cuda_schedule:
-            def compute_value(param_name: str, step_idx: int) -> float:
-                return schedule.get_coefficient(time_steps[int(step_idx)], param_name)
-
-            return cuda_schedule(list(range(len(time_steps))), list(schedule.hamiltonians), compute_value)
-
-        _cuda_schedule = parameter_values(steps)
-
-        def get_schedule(key: str) -> Callable:
-            return lambda **args: args[key]
-
-        cuda_hamiltonian = sum(
-            ScalarOperator(get_schedule(key)) * self._hamiltonian_to_cuda(ham)
-            for key, ham in schedule.hamiltonians.items()
-        )
-
-        cuda_observables = []
-        for observable in observables:
-            if isinstance(observable, PauliOperator):
-                cuda_observables.append(self._pauli_operator_handlers[type(observable)](observable))
-            elif isinstance(observable, Hamiltonian):
-                cuda_observables.append(self._hamiltonian_to_cuda(observable))
-            else:
-                raise ValueError(f"unsupported observable type of {observable.__class__}")
-
-        evolution_result = evolve(
-            hamiltonian=cuda_hamiltonian,
-            dimensions=dict.fromkeys(range(schedule.nqubits), 2),
-            schedule=_cuda_schedule,
-            initial_state=State.from_data(np.array(initial_state.to_density_matrix().dense, dtype=np.complex128)),
-            observables=cuda_observables,
-            collapse_operators=[],
-            store_intermediate_results=store_intermediate_results,
-        )
-
-        return CudaAnalogResult(
-            final_expected_values=np.array(
-                [exp_val.expectation() for exp_val in evolution_result.final_expectation_values()[0]]
-            ),
-            expected_values=(
-                np.array(
-                    [[val.expectation() for val in exp_vals] for exp_vals in evolution_result.expectation_values()]
-                )
-                if evolution_result.expectation_values() is not None
-                else None
-            ),
-            final_state=(
-                QuantumObject(np.array(evolution_result.final_state())).adjoint()
-                if evolution_result.final_state() is not None
-                else None
-            ),
-            intermediate_states=(
-                [QuantumObject(np.array(state)).adjoint() for state in evolution_result.intermediate_states()]
-                if evolution_result.intermediate_states() is not None
-                else None
-            ),
-        )
-
     @staticmethod
     def _handle_M(kernel: cudaq.Kernel, gate: M, circuit: Circuit, qubits: cudaq.QuakeValue) -> None:
         """
@@ -317,6 +293,11 @@ class CudaBackend(DigitalBackend, AnalogBackend):
             for idx in gate.target_qubits:
                 kernel.mz(qubits[idx])
 
+    @staticmethod
+    def _handle_I(kernel: cudaq.Kernel, gate: I, qubit: cudaq.QuakeValue) -> None:
+        """Handle an X gate operation."""
+        kernel.i(qubit)
+
     @staticmethod
     def _handle_X(kernel: cudaq.Kernel, gate: X, qubit: cudaq.QuakeValue) -> None:
         """Handle an X gate operation."""
@@ -350,17 +331,17 @@ class CudaBackend(DigitalBackend, AnalogBackend):
     @staticmethod
     def _handle_RX(kernel: cudaq.Kernel, gate: RX, qubit: cudaq.QuakeValue) -> None:
         """Handle an RX gate operation."""
-        kernel.rx(*gate.parameter_values, qubit)
+        kernel.rx(*gate.get_parameter_values(), qubit)
 
     @staticmethod
     def _handle_RY(kernel: cudaq.Kernel, gate: RY, qubit: cudaq.QuakeValue) -> None:
         """Handle an RY gate operation."""
-        kernel.ry(*gate.parameter_values, qubit)
+        kernel.ry(*gate.get_parameter_values(), qubit)
 
     @staticmethod
     def _handle_RZ(kernel: cudaq.Kernel, gate: RZ, qubit: cudaq.QuakeValue) -> None:
         """Handle an RZ gate operation."""
-        kernel.rz(*gate.parameter_values, qubit)
+        kernel.rz(*gate.get_parameter_values(), qubit)
 
     @staticmethod
     def _handle_U1(kernel: cudaq.Kernel, gate: U1, qubit: cudaq.QuakeValue) -> None:
@@ -376,20 +357,32 @@ class CudaBackend(DigitalBackend, AnalogBackend):
     def _handle_U3(kernel: cudaq.Kernel, gate: U3, qubit: cudaq.QuakeValue) -> None:
         """Handle an U3 gate operation."""
         kernel.u3(theta=gate.theta, phi=gate.phi, delta=gate.gamma, target=qubit)
-        kernel.u3(theta=gate.theta, phi=gate.phi, delta=gate.gamma, target=qubit)
 
     @staticmethod
-    def _handle_PauliX(operator: PauliX) -> ElementaryOperator:
+    def _handle_SWAP(kernel: cudaq.Kernel, gate: SWAP, qubit_0: cudaq.QuakeValue, qubit_1: cudaq.QuakeValue) -> None:
+        kernel.swap(qubit_0, qubit_1)
+
+    def _hamiltonian_to_cuda(self, hamiltonian: Hamiltonian, padding: int = 0) -> OperatorSum:  # type: ignore
+        out = None
+        for offset, terms in hamiltonian:
+            if out is None:
+                out = offset * np.prod([self._pauli_operator_handlers[type(pauli)](pauli) for pauli in terms])
+            else:
+                out += offset * np.prod([self._pauli_operator_handlers[type(pauli)](pauli) for pauli in terms])
+        return out
+
+    @staticmethod
+    def _handle_PauliX(operator: PauliX) -> ElementaryOperator:  # type: ignore
         return spin.x(target=operator.qubit)
 
     @staticmethod
-    def _handle_PauliY(operator: PauliY) -> ElementaryOperator:
+    def _handle_PauliY(operator: PauliY) -> ElementaryOperator:  # type: ignore
         return spin.y(target=operator.qubit)
 
     @staticmethod
-    def _handle_PauliZ(operator: PauliZ) -> ElementaryOperator:
+    def _handle_PauliZ(operator: PauliZ) -> ElementaryOperator:  # type: ignore
         return spin.z(target=operator.qubit)
 
     @staticmethod
-    def _handle_PauliI(operator: PauliI) -> ElementaryOperator:
+    def _handle_PauliI(operator: PauliI) -> ElementaryOperator:  # type: ignore
         return spin.i(target=operator.qubit)