qadence 1.1.1__py3-none-any.whl → 1.2.1__py3-none-any.whl

qadence/constructors/feature_maps.py

@@ -6,7 +6,7 @@ from collections.abc import Callable
 from math import isclose, pi
 from typing import Union
 
-from sympy import Function, acos
+from sympy import Basic, Function, acos
 
 from qadence.blocks import AbstractBlock, KronBlock, chain, kron, tag
 from qadence.logger import get_logger
@@ -36,65 +36,12 @@ RS_FUNC_DICT = {
 }
 
 
-def feature_map(
-    n_qubits: int,
-    support: tuple[int, ...] | None = None,
+def fm_parameter(
+    fm_type: BasisSet | type[Function] | str,
     param: Parameter | str = "phi",
-    op: RotationTypes = RX,
-    fm_type: BasisSet | type[Function] | str = BasisSet.FOURIER,
-    reupload_scaling: ReuploadScaling | Callable | str = ReuploadScaling.CONSTANT,
     feature_range: tuple[float, float] | None = None,
     target_range: tuple[float, float] | None = None,
-    multiplier: Parameter | TParameter | None = None,
-) -> KronBlock:
-    """Construct a feature map of a given type.
-
-    Arguments:
-        n_qubits: Number of qubits the feature map covers. Results in `support=range(n_qubits)`.
-        support: Puts one feature-encoding rotation gate on every qubit in `support`. n_qubits in
-            this case specifies the total overall qubits of the circuit, which may be wider than the
-            support itself, but not narrower.
-        param: Parameter of the feature map; you can pass a string or Parameter;
-            it will be set as non-trainable (FeatureParameter) regardless.
-        op: Rotation operation of the feature map; choose from RX, RY, RZ or PHASE.
-        fm_type: Basis set for data encoding; choose from `BasisSet.FOURIER` for Fourier
-            encoding, or `BasisSet.CHEBYSHEV` for Chebyshev polynomials of the first kind.
-        reupload_scaling: how the feature map scales the data that is re-uploaded for each qubit.
-            choose from `ReuploadScaling` enumeration or provide your own function with a single
-            int as input and int or float as output.
-        feature_range: range of data that the input data is assumed to come from.
-        target_range: range of data the data encoder assumes as the natural range. For example,
-            in Chebyshev polynomials it is (-1, 1), while for Fourier it may be chosen as (0, 2*pi).
-        multiplier: overall multiplier; this is useful for reuploading the feature map serially with
-            different scalings; can be a number or parameter/expression.
-
-    Example:
-    ```python exec="on" source="material-block" result="json"
-    from qadence import feature_map, BasisSet, ReuploadScaling
-
-    fm = feature_map(3, fm_type=BasisSet.FOURIER)
-    print(f"{fm = }")
-
-    fm = feature_map(3, fm_type=BasisSet.CHEBYSHEV)
-    print(f"{fm = }")
-
-    fm = feature_map(3, fm_type=BasisSet.FOURIER, reupload_scaling = ReuploadScaling.TOWER)
-    print(f"{fm = }")
-    ```
-    """
-
-    # Process input
-    if support is None:
-        support = tuple(range(n_qubits))
-    elif len(support) != n_qubits:
-        raise ValueError("Wrong qubit support supplied")
-
-    if op not in ROTATIONS:
-        raise ValueError(
-            f"Operation {op} not supported. "
-            f"Please provide one from {[rot.__name__ for rot in ROTATIONS]}."
-        )
-
+) -> Parameter | Basic:
     # Backwards compatibility
     if fm_type in ("fourier", "chebyshev", "tower"):
         logger.warning(
@@ -108,7 +55,6 @@ def feature_map(
             fm_type = BasisSet.CHEBYSHEV
         elif fm_type == "tower":
             fm_type = BasisSet.CHEBYSHEV
-            reupload_scaling = ReuploadScaling.TOWER
 
     if isinstance(param, Parameter):
         fparam = param
@@ -144,8 +90,12 @@ def feature_map(
             "the given feature parameter with."
         )
 
-    basis_tag = fm_type.value if isinstance(fm_type, BasisSet) else str(fm_type)
+    return transformed_feature
+
 
+def fm_reupload_scaling_fn(
+    reupload_scaling: ReuploadScaling | Callable | str = ReuploadScaling.CONSTANT,
+) -> tuple[Callable, str]:
     # Set reupload scaling function
     if callable(reupload_scaling):
         rs_func = reupload_scaling
@@ -163,8 +113,82 @@ def feature_map(
         else:
             rs_tag = reupload_scaling
 
+    return rs_func, rs_tag
+
+
+def feature_map(
+    n_qubits: int,
+    support: tuple[int, ...] | None = None,
+    param: Parameter | str = "phi",
+    op: RotationTypes = RX,
+    fm_type: BasisSet | type[Function] | str = BasisSet.FOURIER,
+    reupload_scaling: ReuploadScaling | Callable | str = ReuploadScaling.CONSTANT,
+    feature_range: tuple[float, float] | None = None,
+    target_range: tuple[float, float] | None = None,
+    multiplier: Parameter | TParameter | None = None,
+) -> KronBlock:
+    """Construct a feature map of a given type.
+
+    Arguments:
+        n_qubits: Number of qubits the feature map covers. Results in `support=range(n_qubits)`.
+        support: Puts one feature-encoding rotation gate on every qubit in `support`. n_qubits in
+            this case specifies the total overall qubits of the circuit, which may be wider than the
+            support itself, but not narrower.
+        param: Parameter of the feature map; you can pass a string or Parameter;
+            it will be set as non-trainable (FeatureParameter) regardless.
+        op: Rotation operation of the feature map; choose from RX, RY, RZ or PHASE.
+        fm_type: Basis set for data encoding; choose from `BasisSet.FOURIER` for Fourier
+            encoding, or `BasisSet.CHEBYSHEV` for Chebyshev polynomials of the first kind.
+        reupload_scaling: how the feature map scales the data that is re-uploaded for each qubit.
+            choose from `ReuploadScaling` enumeration or provide your own function with a single
+            int as input and int or float as output.
+        feature_range: range of data that the input data is assumed to come from.
+        target_range: range of data the data encoder assumes as the natural range. For example,
+            in Chebyshev polynomials it is (-1, 1), while for Fourier it may be chosen as (0, 2*pi).
+        multiplier: overall multiplier; this is useful for reuploading the feature map serially with
+            different scalings; can be a number or parameter/expression.
+
+    Example:
+    ```python exec="on" source="material-block" result="json"
+    from qadence import feature_map, BasisSet, ReuploadScaling
+
+    fm = feature_map(3, fm_type=BasisSet.FOURIER)
+    print(f"{fm = }")
+
+    fm = feature_map(3, fm_type=BasisSet.CHEBYSHEV)
+    print(f"{fm = }")
+
+    fm = feature_map(3, fm_type=BasisSet.FOURIER, reupload_scaling = ReuploadScaling.TOWER)
+    print(f"{fm = }")
+    ```
+    """
+
+    # Process input
+    if support is None:
+        support = tuple(range(n_qubits))
+    elif len(support) != n_qubits:
+        raise ValueError("Wrong qubit support supplied")
+
+    if op not in ROTATIONS:
+        raise ValueError(
+            f"Operation {op} not supported. "
+            f"Please provide one from {[rot.__name__ for rot in ROTATIONS]}."
+        )
+
+    transformed_feature = fm_parameter(
+        fm_type, param, feature_range=feature_range, target_range=target_range
+    )
+
+    # Backwards compatibility
+    if fm_type == "tower":
+        logger.warning("Forcing reupload scaling strategy to TOWER")
+        reupload_scaling = ReuploadScaling.TOWER
+
+    basis_tag = fm_type.value if isinstance(fm_type, BasisSet) else str(fm_type)
+    rs_func, rs_tag = fm_reupload_scaling_fn(reupload_scaling)
+
     # Set overall multiplier
-    multiplier = 1 if multiplier is None else multiplier
+    multiplier = 1 if multiplier is None else Parameter(multiplier)
 
     # Build feature map
     op_list = []

qadence/constructors/hamiltonians.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
-import warnings
-from typing import List, Tuple, Type, Union
+from typing import List, Type, Union
 
 import numpy as np
 from torch import Tensor, double, ones, rand
@@ -57,8 +56,7 @@ def hamiltonian_factory(
     interaction_strength: TArray | str | None = None,
     detuning_strength: TArray | str | None = None,
     random_strength: bool = False,
-    force_update: bool = False,
-    use_complete_graph: bool = False,
+    use_all_node_pairs: bool = False,
 ) -> AbstractBlock:
     """
     General Hamiltonian creation function.
@@ -80,9 +78,8 @@ def hamiltonian_factory(
             Alternatively, some string "x" can be passed, which will create a parameterized
             detuning for each qubit, each labelled as `"x_i"`.
         random_strength: set random interaction and detuning strengths between -1 and 1.
-        force_update: force override register detuning and interaction strengths.
-        use_complete_graph: computes an interaction for every edge in a complete graph,
-            independent of the edges in the register. Useful for defining Hamiltonians
+        use_all_node_pairs: computes an interaction term for every pair of nodes in the graph,
+            independent of the edge topology in the register. Useful for defining Hamiltonians
             where the interaction strength decays with the distance.
 
     Examples:
@@ -121,12 +118,9 @@ def hamiltonian_factory(
     register = Register(register) if isinstance(register, int) else register
 
     # Get interaction function
-    try:
-        int_fn = INTERACTION_DICT[interaction]  # type: ignore [index]
-    except (KeyError, ValueError) as error:
-        if interaction is None:
-            pass
-        else:
+    if interaction is not None:
+        int_fn = INTERACTION_DICT.get(interaction, None)
+        if int_fn is None:
             raise KeyError(f"Interaction {interaction} not supported.")
 
     # Check single-qubit detuning
@@ -134,37 +128,27 @@ def hamiltonian_factory(
         raise TypeError(f"Detuning of type {type(detuning)} not supported.")
 
     # Pre-process detuning and interaction strengths and update register
-    has_detuning_strength, detuning_strength = _preprocess_strengths(
-        register, detuning_strength, "nodes", force_update, random_strength
+    detuning_strength_array = _preprocess_strengths(
+        register, detuning_strength, "nodes", random_strength
     )
 
-    edge_str = "all_edges" if use_complete_graph else "edges"
-    has_interaction_strength, interaction_strength = _preprocess_strengths(
-        register, interaction_strength, edge_str, force_update, random_strength
+    edge_str = "all_node_pairs" if use_all_node_pairs else "edges"
+    interaction_strength_array = _preprocess_strengths(
+        register, interaction_strength, edge_str, random_strength
     )
 
-    if (not has_detuning_strength) or force_update:
-        register = _update_detuning_strength(register, detuning_strength)
-
-    if (not has_interaction_strength) or force_update:
-        register = _update_interaction_strength(register, interaction_strength, use_complete_graph)
-
     # Create single-qubit detunings:
     single_qubit_terms: List[AbstractBlock] = []
     if detuning is not None:
-        for node in register.nodes:
-            block_sq = detuning(node)  # type: ignore [operator]
-            strength_sq = register.nodes[node]["strength"]
-            single_qubit_terms.append(strength_sq * block_sq)
+        for strength, node in zip(detuning_strength_array, register.nodes):
+            single_qubit_terms.append(strength * detuning(node))
 
     # Create two-qubit interactions:
     two_qubit_terms: List[AbstractBlock] = []
-    edge_data = register.all_edges if use_complete_graph else register.edges
-    if interaction is not None:
-        for edge in edge_data:
-            block_tq = int_fn(*edge)  # type: ignore [operator]
-            strength_tq = edge_data[edge]["strength"]
-            two_qubit_terms.append(strength_tq * block_tq)
+    edge_data = register.all_node_pairs if use_all_node_pairs else register.edges
+    if interaction is not None and int_fn is not None:
+        for strength, edge in zip(interaction_strength_array, edge_data):
+            two_qubit_terms.append(strength * int_fn(*edge))
 
     return add(*single_qubit_terms, *two_qubit_terms)
 
@@ -173,22 +157,13 @@ def _preprocess_strengths(
     register: Register,
     strength: TArray | str | None,
     nodes_or_edges: str,
-    force_update: bool,
     random_strength: bool,
-) -> Tuple[bool, Union[TArray | str]]:
+) -> Tensor | list:
     data = getattr(register, nodes_or_edges)
 
     # Useful for error messages:
     strength_target = "detuning" if nodes_or_edges == "nodes" else "interaction"
 
-    # First we check if strength values already exist in the register
-    has_strength = any(["strength" in data[i] for i in data])
-    if has_strength and not force_update:
-        if strength is not None:
-            logger.warning(
-                "Register already includes " + strength_target + " strengths. "
-                "Skipping update. Use `force_update = True` to override them."
-            )
     # Next we process the strength given in the input arguments
     if strength is None:
         if random_strength:
@@ -202,8 +177,11 @@ def _preprocess_strengths(
             message = "Array of " + strength_target + " strengths has incorrect size."
             raise ValueError(message)
     elif isinstance(strength, str):
-        # Any string will be used as a prefix to variational parameters
-        pass
+        prefix = strength
+        if nodes_or_edges == "nodes":
+            strength = [prefix + f"_{node}" for node in data]
+        if nodes_or_edges in ["edges", "all_node_pairs"]:
+            strength = [prefix + f"_{edge[0]}{edge[1]}" for edge in data]
     else:
         # If not of the accepted types ARRAYS or str, we error out
         raise TypeError(
@@ -212,69 +190,27 @@ def _preprocess_strengths(
             "parameterized " + strength_target + "s."
         )
 
-    return has_strength, strength
-
-
-def _update_detuning_strength(register: Register, detuning_strength: TArray | str) -> Register:
-    for node in register.nodes:
-        if isinstance(detuning_strength, str):
-            register.nodes[node]["strength"] = detuning_strength + f"_{node}"
-        elif isinstance(detuning_strength, ARRAYS):
-            register.nodes[node]["strength"] = detuning_strength[node]
-    return register
-
-
-def _update_interaction_strength(
-    register: Register, interaction_strength: TArray | str, use_complete_graph: bool
-) -> Register:
-    edge_data = register.all_edges if use_complete_graph else register.edges
-    for idx, edge in enumerate(edge_data):
-        if isinstance(interaction_strength, str):
-            edge_data[edge]["strength"] = interaction_strength + f"_{edge[0]}{edge[1]}"
-        elif isinstance(interaction_strength, ARRAYS):
-            edge_data[edge]["strength"] = interaction_strength[idx]
-    return register
-
+    return strength
 
-# FIXME: Previous hamiltonian / observable functions, now refactored, to be deprecated:
 
-DEPRECATION_MESSAGE = "This function will be removed in the future. "
+def total_magnetization(n_qubits: int, z_terms: np.ndarray | list | None = None) -> AbstractBlock:
+    return hamiltonian_factory(n_qubits, detuning=Z, detuning_strength=z_terms)
 
 
 def single_z(qubit: int = 0, z_coefficient: float = 1.0) -> AbstractBlock:
-    message = DEPRECATION_MESSAGE + "Please use `z_coefficient * Z(qubit)` directly."
-    warnings.warn(message, FutureWarning)
     return Z(qubit) * z_coefficient
 
 
-def total_magnetization(n_qubits: int, z_terms: np.ndarray | list | None = None) -> AbstractBlock:
-    message = (
-        DEPRECATION_MESSAGE
-        + "Please use `hamiltonian_factory(n_qubits, detuning=Z, node_coeff=z_terms)`."
-    )
-    warnings.warn(message, FutureWarning)
-    return hamiltonian_factory(n_qubits, detuning=Z, detuning_strength=z_terms)
-
-
 def zz_hamiltonian(
     n_qubits: int,
     z_terms: np.ndarray | None = None,
     zz_terms: np.ndarray | None = None,
 ) -> AbstractBlock:
-    message = (
-        DEPRECATION_MESSAGE
-        + """
-Please use `hamiltonian_factory(n_qubits, Interaction.ZZ, Z, interaction_strength, z_terms)`. \
-Note that the argument `zz_terms` in this function is a 2D array of size `(n_qubits, n_qubits)`, \
-while `interaction_strength` is expected as a 1D array of size `0.5 * n_qubits * (n_qubits - 1)`."""
-    )
-    warnings.warn(message, FutureWarning)
     if zz_terms is not None:
         register = Register(n_qubits)
         interaction_strength = [zz_terms[edge[0], edge[1]] for edge in register.edges]
     else:
         interaction_strength = None
-
     return hamiltonian_factory(n_qubits, Interaction.ZZ, Z, interaction_strength, z_terms)
 
 
@@ -284,13 +220,6 @@ def ising_hamiltonian(
     z_terms: np.ndarray | None = None,
     zz_terms: np.ndarray | None = None,
 ) -> AbstractBlock:
-    message = (
-        DEPRECATION_MESSAGE
-        + """
-You can build a general transverse field ising model with the `hamiltonian_factory` function. \
-Check the hamiltonian construction tutorial in the documentation for more information."""
-    )
-    warnings.warn(message, FutureWarning)
     zz_ham = zz_hamiltonian(n_qubits, z_terms=z_terms, zz_terms=zz_terms)
     x_ham = hamiltonian_factory(n_qubits, detuning=X, detuning_strength=x_terms)
     return zz_ham + x_ham

qadence/constructors/rydberg_feature_maps.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from typing import Callable
+
+import numpy as np
+from sympy import Basic, Function
+
+from qadence.blocks import AnalogBlock, KronBlock, kron
+from qadence.constructors.feature_maps import fm_parameter
+from qadence.logger import get_logger
+from qadence.operations import AnalogRot, AnalogRX, AnalogRY, AnalogRZ
+from qadence.parameters import FeatureParameter, Parameter, VariationalParameter
+from qadence.types import BasisSet, ReuploadScaling, TParameter
+
+logger = get_logger(__file__)
+
+AnalogRotationTypes = [AnalogRX, AnalogRY, AnalogRZ]
+
+
+def rydberg_feature_map(
+    n_qubits: int,
+    param: str = "phi",
+    max_abs_detuning: float = 2 * np.pi * 10,
+    weights: list[float] | None = None,
+) -> KronBlock:
+    """Feature map using semi-local addressing patterns.
+
+    If not weights are specified, variational parameters are created
+    for the pattern
+
+    Args:
+        n_qubits (int): number of qubits
+        param: the name of the feature parameter
+        max_abs_detuning: maximum value of absolute detuning for each qubit. Defaulted at 10 MHz.
+        weights: a list of wegiths to assign to each qubit parameter in the feature map
+
+    Returns:
+        The block representing the feature map
+    """
+
+    tower_coeffs: list[float | Parameter]
+    tower_coeffs = (
+        [VariationalParameter(f"w_{param}_{i}") for i in range(n_qubits)]
+        if weights is None
+        else weights
+    )
+    tower_detuning = max_abs_detuning / (sum(tower_coeffs[i] for i in range(n_qubits)))
+
+    param = FeatureParameter(param)
+    duration = 1000 * param / tower_detuning
+    return kron(
+        AnalogRot(
+            duration=duration,
+            delta=-tower_detuning * tower_coeffs[i],
+            phase=0.0,
+            qubit_support=(i,),
+        )
+        for i in range(n_qubits)
+    )
+
+
+def rydberg_tower_feature_map(
+    n_qubits: int, param: str = "phi", max_abs_detuning: float = 2 * np.pi * 10
+) -> KronBlock:
+    weights = list(np.arange(1, n_qubits + 1))
+    return rydberg_feature_map(
+        n_qubits, param=param, max_abs_detuning=max_abs_detuning, weights=weights
+    )
+
+
+def analog_feature_map(
+    param: str = "phi",
+    op: Callable[[Parameter | Basic], AnalogBlock] = AnalogRX,
+    fm_type: BasisSet | type[Function] | str = BasisSet.FOURIER,
+    reupload_scaling: ReuploadScaling | Callable | str = ReuploadScaling.CONSTANT,
+    feature_range: tuple[float, float] | None = None,
+    target_range: tuple[float, float] | None = None,
+    multiplier: Parameter | TParameter | None = None,
+) -> AnalogBlock:
+    """Generate a fully analog feature map.
+
+    Args:
+        param: Parameter of the feature map; you can pass a string or Parameter;
+            it will be set as non-trainable (FeatureParameter) regardless.
+        op: type of operation. Choose among AnalogRX, AnalogRY, AnalogRZ or a custom
+            callable function returning an AnalogBlock instance
+        fm_type: Basis set for data encoding; choose from `BasisSet.FOURIER` for Fourier
+            encoding, or `BasisSet.CHEBYSHEV` for Chebyshev polynomials of the first kind.
+        reupload_scaling: how the feature map scales the data that is re-uploaded. Given that
+            this feature map uses analog rotations, the reuploading works by simply
+            adding additional operations with different scaling factors in the parameter.
+            Choose from `ReuploadScaling` enumeration, currently only CONSTANT works,
+            or provide your own function with the first argument being the given
+            operation `op` and the second argument the feature parameter
+        feature_range: range of data that the input data is assumed to come from.
+        target_range: range of data the data encoder assumes as the natural range. For example,
+            in Chebyshev polynomials it is (-1, 1), while for Fourier it may be chosen as (0, 2*pi).
+        multiplier: overall multiplier; this is useful for reuploading the feature map serially with
+            different scalings; can be a number or parameter/expression.
+    """
+    transformed_feature = fm_parameter(
+        fm_type, param, feature_range=feature_range, target_range=target_range
+    )
+    multiplier = 1.0 if multiplier is None else Parameter(multiplier)
+
+    if callable(reupload_scaling):
+        return reupload_scaling(op, multiplier * transformed_feature)  # type: ignore[no-any-return]
+    elif reupload_scaling == ReuploadScaling.CONSTANT:
+        return op(multiplier * transformed_feature)
+    # TODO: implement tower scaling by reuploading multiple times
+    # using different analog rotations
+    else:
+        raise NotImplementedError(f"Reupload scaling {str(reupload_scaling)} not implemented!")

qadence/divergences.py

@@ -36,3 +36,15 @@ def js_divergence(counter_p: Counter, counter_q: Counter) -> float:
     entropy_p = shannon_entropy(counter_p)
     entropy_q = shannon_entropy(counter_q)
     return float(average_entropy - (entropy_p + entropy_q) / 2.0)
+
+
+def norm_difference(counter_p: Counter, counter_q: Counter) -> float:
+    # Normalise counters
+
+    counter_p = np.array([v for v in counter_p.values()])
+    counter_q = np.array([v for v in counter_q.values()])
+
+    prob_p = counter_p / np.sum(counter_p)
+    prob_q = counter_q / np.sum(counter_q)
+
+    return float(np.linalg.norm(prob_p - prob_q))

qadence/engines/differentiable_backend.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections import Counter
+from dataclasses import dataclass
+from typing import Any, Callable
+
+from qadence.backend import Backend, Converted, ConvertedCircuit, ConvertedObservable
+from qadence.blocks import AbstractBlock, PrimitiveBlock
+from qadence.blocks.utils import uuid_to_block
+from qadence.circuit import QuantumCircuit
+from qadence.measurements import Measurements
+from qadence.mitigations import Mitigations
+from qadence.noise import Noise
+from qadence.types import ArrayLike, DiffMode, Endianness, Engine, ParamDictType
+
+
+@dataclass(frozen=True, eq=True)
+class DifferentiableBackend(ABC):
+    """The abstract class which wraps any (non)-natively differentiable QuantumBackend.
+
+       in an automatic differentiation engine.
+
+    Arguments:
+        backend: An instance of the QuantumBackend type perform execution.
+        engine: Which automatic differentiation engine the QuantumBackend runs on.
+        diff_mode: A differentiable mode supported by the differentiation engine.
+    """
+
+    backend: Backend
+    engine: Engine
+    diff_mode: DiffMode
+
+    # TODO: Add differentiable overlap calculation
+    _overlap: Callable = None  # type: ignore [assignment]
+
+    def sample(
+        self,
+        circuit: ConvertedCircuit,
+        param_values: ParamDictType = {},
+        n_shots: int = 100,
+        state: ArrayLike | None = None,
+        noise: Noise | None = None,
+        mitigation: Mitigations | None = None,
+        endianness: Endianness = Endianness.BIG,
+    ) -> list[Counter]:
+        """Sample bitstring from the registered circuit.
+
+        Arguments:
+            circuit: A backend native quantum circuit to be executed.
+            param_values: The values of the parameters after embedding
+            n_shots: The number of shots. Defaults to 1.
+            state: Initial state.
+            noise: A noise model to use.
+            mitigation: A mitigation protocol to apply to noisy samples.
+            endianness: Endianness of the resulting bitstrings.
+
+        Returns:
+            An iterable with all the sampled bitstrings
+        """
+
+        return self.backend.sample(
+            circuit=circuit,
+            param_values=param_values,
+            n_shots=n_shots,
+            state=state,
+            noise=noise,
+            mitigation=mitigation,
+            endianness=endianness,
+        )
+
+    def run(
+        self,
+        circuit: ConvertedCircuit,
+        param_values: ParamDictType = {},
+        state: ArrayLike | None = None,
+        endianness: Endianness = Endianness.BIG,
+    ) -> ArrayLike:
+        """Run on the underlying backend."""
+        return self.backend.run(
+            circuit=circuit, param_values=param_values, state=state, endianness=endianness
+        )
+
+    @abstractmethod
+    def expectation(
+        self,
+        circuit: ConvertedCircuit,
+        observable: list[ConvertedObservable] | ConvertedObservable,
+        param_values: ParamDictType = {},
+        state: ArrayLike | None = None,
+        measurement: Measurements | None = None,
+        noise: Noise | None = None,
+        mitigation: Mitigations | None = None,
+        endianness: Endianness = Endianness.BIG,
+    ) -> Any:
+        """Compute the expectation value of the `circuit` with the given `observable`.
+
+        Arguments:
+            circuit: A converted circuit as returned by `backend.circuit`.
+            observable: A converted observable as returned by `backend.observable`.
+            param_values: _**Already embedded**_ parameters of the circuit. See
+                [`embedding`][qadence.blocks.embedding.embedding] for more info.
+            state: Initial state.
+            measurement: Optional measurement protocol. If None, use
+                exact expectation value with a statevector simulator.
+            noise: A noise model to use.
+            mitigation: The error mitigation to use.
+            endianness: Endianness of the resulting bit strings.
+        """
+        raise NotImplementedError(
+            "A DifferentiableBackend needs to override the expectation method."
+        )
+
+    def default_configuration(self) -> Any:
+        return self.backend.default_configuration()
+
+    def circuit(self, circuit: QuantumCircuit) -> ConvertedCircuit:
+        if self.diff_mode == DiffMode.GPSR:
+            parametrized_blocks = list(uuid_to_block(circuit.block).values())
+            non_prim_blocks = filter(
+                lambda b: not isinstance(b, PrimitiveBlock), parametrized_blocks
+            )
+            if len(list(non_prim_blocks)) > 0:
+                raise ValueError(
+                    "The circuit contains non-primitive blocks that are currently\
+                    not supported by the PSR differentiable mode."
+                )
+        return self.backend.circuit(circuit)
+
+    def observable(self, observable: AbstractBlock, n_qubits: int) -> ConvertedObservable:
+        if self.diff_mode != DiffMode.AD and observable is not None:
+            msg = (
+                f"Differentiation mode '{self.diff_mode}' does not support parametric observables."
+            )
+            if isinstance(observable, list):
+                for obs in observable:
+                    if obs.is_parametric:
+                        raise ValueError(msg)
+            else:
+                if observable.is_parametric:
+                    raise ValueError(msg)
+        return self.backend.observable(observable, n_qubits)
+
+    def convert(
+        self,
+        circuit: QuantumCircuit,
+        observable: list[AbstractBlock] | AbstractBlock | None = None,
+    ) -> Converted:
+        return self.backend.convert(circuit, observable)
+
+    def assign_parameters(self, circuit: ConvertedCircuit, param_values: ParamDictType) -> Any:
+        return self.backend.assign_parameters(circuit, param_values)