qadence 1.2.0__tar.gz → 1.2.1__tar.gz

{qadence-1.2.0 → qadence-1.2.1}/.github/workflows/build_docs.yml

@@ -35,7 +35,7 @@ jobs:
       run: sudo apt-get install -y graphviz
 
     - name: Set up Python 3.10
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
         python-version: '3.10'
 

{qadence-1.2.0 → qadence-1.2.1}/.github/workflows/lint.yml

@@ -17,7 +17,7 @@ jobs:
       uses: actions/checkout@v4
 
     - name: Set up Python 3.x
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
         python-version: '3.x'
 

{qadence-1.2.0 → qadence-1.2.1}/.github/workflows/test_all.yml

@@ -23,7 +23,7 @@ jobs:
       uses: actions/checkout@v4
 
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
         python-version: ${{ matrix.python-version }}
 
@@ -47,7 +47,7 @@ jobs:
       uses: actions/checkout@v4
 
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
         python-version: ${{ matrix.python-version }}
 

{qadence-1.2.0 → qadence-1.2.1}/.github/workflows/test_examples.yml

@@ -24,7 +24,7 @@ jobs:
       run: sudo apt-get install -y graphviz
 
     - name: Select Python 3.10
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
         python-version: '3.10'
 

{qadence-1.2.0 → qadence-1.2.1}/.github/workflows/test_fast.yml

@@ -27,7 +27,7 @@ jobs:
     - name: Checkout Qadence
       uses: actions/checkout@v4
     - name: Set up Python ${{ matrix.python-version }}
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
         python-version: ${{ matrix.python-version }}
     - name: Install Hatch
@@ -54,7 +54,7 @@ jobs:
         with:
           ref: ${{ github.ref }}
       - name: Set up Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: "3.10"
       - name: Install Python dependencies
@@ -94,7 +94,7 @@ jobs:
     - name: Install graphviz
       run: sudo apt-get install -y graphviz
     - name: Set up Python 3.10
-      uses: actions/setup-python@v4
+      uses: actions/setup-python@v5
       with:
         python-version: '3.10'
     - name: Install Hatch

{qadence-1.2.0 → qadence-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qadence
-Version: 1.2.0
+Version: 1.2.1
 Summary: Pasqal interface for circuit-based quantum computing SDKs
 Author-email: Aleksander Wennersteen <aleksander.wennersteen@pasqal.com>, Gert-Jan Both <gert-jan.both@pasqal.com>, Niklas Heim <niklas.heim@pasqal.com>, Mario Dagrada <mario.dagrada@pasqal.com>, Vincent Elfving <vincent.elfving@pasqal.com>, Dominik Seitz <dominik.seitz@pasqal.com>, Roland Guichard <roland.guichard@pasqal.com>, "Joao P. Moutinho" <joao.moutinho@pasqal.com>, Vytautas Abramavicius <vytautas.abramavicius@pasqal.com>
 License: Apache 2.0
@@ -18,6 +18,7 @@ Requires-Dist: deepdiff
 Requires-Dist: jsonschema
 Requires-Dist: matplotlib
 Requires-Dist: nevergrad
+Requires-Dist: numpy
 Requires-Dist: openfermion
 Requires-Dist: pyqtorch==1.0.3
 Requires-Dist: rich
@@ -27,10 +28,25 @@ Requires-Dist: tensorboard>=2.12.0
 Requires-Dist: torch
 Provides-Extra: all
 Requires-Dist: amazon-braket-sdk; extra == 'all'
+Requires-Dist: einops; extra == 'all'
+Requires-Dist: flax; extra == 'all'
 Requires-Dist: graphviz; extra == 'all'
+Requires-Dist: horqrux==0.3.0; extra == 'all'
+Requires-Dist: jax; extra == 'all'
+Requires-Dist: jaxopt; extra == 'all'
+Requires-Dist: optax; extra == 'all'
 Requires-Dist: pulser>=0.15.2; extra == 'all'
+Requires-Dist: sympy2jax; extra == 'all'
 Provides-Extra: braket
 Requires-Dist: amazon-braket-sdk; extra == 'braket'
+Provides-Extra: horqrux
+Requires-Dist: einops; extra == 'horqrux'
+Requires-Dist: flax; extra == 'horqrux'
+Requires-Dist: horqrux==0.3.0; extra == 'horqrux'
+Requires-Dist: jax; extra == 'horqrux'
+Requires-Dist: jaxopt; extra == 'horqrux'
+Requires-Dist: optax; extra == 'horqrux'
+Requires-Dist: sympy2jax; extra == 'horqrux'
 Provides-Extra: pulser
 Requires-Dist: pasqal-cloud>=0.3.5; extra == 'pulser'
 Requires-Dist: pulser>=v0.15.2; extra == 'pulser'
@@ -74,12 +90,15 @@ Qadence is available on [PyPI](https://pypi.org/project/qadence/) and can be ins
 pip install qadence
 ```
 
-The default, pre-installed backend for Qadence is [PyQTorch](https://github.com/pasqal-io/pyqtorch), a differentiable state vector simulator for digital-analog simulation. It is possible to install additional backends and the circuit visualization library using the following extras:
+The default, pre-installed backend for Qadence is [PyQTorch](https://github.com/pasqal-io/pyqtorch), a differentiable state vector simulator for digital-analog simulation based on `PyTorch`. It is possible to install additional, `PyTorch` -based backends and the circuit visualization library using the following extras:
 
 * `pulser`: The [Pulser](https://github.com/pasqal-io/Pulser) backend for composing, simulating and executing pulse sequences for neutral-atom quantum devices.
 * `braket`: The [Braket](https://github.com/amazon-braket/amazon-braket-sdk-python) backend, an open source library that provides a framework for interacting with quantum computing hardware devices through Amazon Braket.
 * `visualization`: A visualization library to display quantum circuit diagrams.
 
+Qadence also supports a `JAX` engine which is currently supporting the [Horqrux](https://github.com/pasqal-io/horqrux) backend. `horqrux` is currently only available via the [low-level API](examples/backends/low_level/horqrux_backend.py).
+
+
 To install individual extras, use the following syntax (**IMPORTANT** Make sure to use quotes):
 
 ```bash

{qadence-1.2.0 → qadence-1.2.1}/README.md

@@ -34,12 +34,15 @@ Qadence is available on [PyPI](https://pypi.org/project/qadence/) and can be ins
 pip install qadence
 ```
 
-The default, pre-installed backend for Qadence is [PyQTorch](https://github.com/pasqal-io/pyqtorch), a differentiable state vector simulator for digital-analog simulation. It is possible to install additional backends and the circuit visualization library using the following extras:
+The default, pre-installed backend for Qadence is [PyQTorch](https://github.com/pasqal-io/pyqtorch), a differentiable state vector simulator for digital-analog simulation based on `PyTorch`. It is possible to install additional, `PyTorch` -based backends and the circuit visualization library using the following extras:
 
 * `pulser`: The [Pulser](https://github.com/pasqal-io/Pulser) backend for composing, simulating and executing pulse sequences for neutral-atom quantum devices.
 * `braket`: The [Braket](https://github.com/amazon-braket/amazon-braket-sdk-python) backend, an open source library that provides a framework for interacting with quantum computing hardware devices through Amazon Braket.
 * `visualization`: A visualization library to display quantum circuit diagrams.
 
+Qadence also supports a `JAX` engine which is currently supporting the [Horqrux](https://github.com/pasqal-io/horqrux) backend. `horqrux` is currently only available via the [low-level API](examples/backends/low_level/horqrux_backend.py).
+
+
 To install individual extras, use the following syntax (**IMPORTANT** Make sure to use quotes):
 
 ```bash

{qadence-1.2.0 → qadence-1.2.1}/pyproject.toml

@@ -19,7 +19,7 @@ authors = [
 ]
 requires-python = ">=3.9,<3.12"
 license = {text = "Apache 2.0"}
-version = "1.2.0"
+version = "1.2.1"
 classifiers=[
     "License :: OSI Approved :: Apache Software License",
     "Programming Language :: Python",
@@ -31,8 +31,9 @@ classifiers=[
     "Programming Language :: Python :: Implementation :: PyPy",
 ]
 dependencies = [
-    "openfermion",
+    "numpy",
     "torch",
+    "openfermion",
     "sympytorch>=0.1.2",
     "rich",
     "tensorboard>=2.12.0",
@@ -41,7 +42,7 @@ dependencies = [
     "nevergrad",
     "scipy",
     "pyqtorch==1.0.3",
-    "matplotlib"
+    "matplotlib",
 ]
 
 [tool.hatch.metadata]
@@ -57,6 +58,15 @@ visualization = [
   # "latex2svg @ git+https://github.com/Moonbase59/latex2svg.git#egg=latex2svg",
   # "scour",
 ]
+horqrux = [
+    "horqrux==0.3.0",
+    "jax",
+    "flax",
+    "optax",
+    "jaxopt",
+    "einops",
+    "sympy2jax"]
+
 all = [
   "pulser>=0.15.2",
   "amazon-braket-sdk",
@@ -64,6 +74,13 @@ all = [
   # FIXME: will be needed once we support latex labels
   # "latex2svg @ git+https://github.com/Moonbase59/latex2svg.git#egg=latex2svg",
   # "scour",
+    "horqrux==0.3.0",
+    "jax",
+    "flax",
+    "optax",
+    "jaxopt",
+    "einops",
+    "sympy2jax"
 ]
 
 [tool.hatch.envs.default]
@@ -120,7 +137,7 @@ dependencies = [
   "markdown-exec",
   "mike",
 ]
-features = ["pulser", "braket", "visualization"]
+features = ["pulser", "braket", "horqrux", "visualization"]
 
 [tool.hatch.envs.docs.scripts]
 build = "mkdocs build --clean --strict"
@@ -167,6 +184,7 @@ required-imports = ["from __future__ import annotations"]
 [tool.ruff.per-file-ignores]
 "__init__.py" = ["F401"]
 "operations.py" = ["E742"]  # Avoid ambiguous class name warning for identity.
+"qadence/backends/horqrux/convert_ops.py" = ["E741"]  # Avoid ambiguous class name warning for 0.
 
 [tool.ruff.mccabe]
 max-complexity = 15

{qadence-1.2.0 → qadence-1.2.1}/qadence/__init__.py

@@ -11,6 +11,7 @@ from .backends import *
 from .blocks import *
 from .circuit import *
 from .constructors import *
+from .engines import *
 from .exceptions import *
 from .execution import *
 from .measurements import *

{qadence-1.2.0 → qadence-1.2.1}/qadence/backend.py

@@ -25,7 +25,7 @@ from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
 from qadence.noise import Noise
 from qadence.parameters import stringify
-from qadence.types import BackendName, DiffMode, Endianness
+from qadence.types import ArrayLike, BackendName, DiffMode, Endianness, Engine, ParamDictType
 from qadence.utils import validate_values_and_state
 
 logger = get_logger(__file__)
@@ -100,11 +100,14 @@ class Backend(ABC):
         name: backend unique string identifier
         supports_ad: whether or not the backend has a native autograd
         supports_bp: whether or not the backend has a native backprop
+        supports_adjoint: Does the backend support native adjoint differentation.
         is_remote: whether computations are executed locally or remotely on this
             backend, useful when using cloud platforms where credentials are
             needed for example.
         with_measurements: whether it supports counts or not
         with_noise: whether to add realistic noise or not
+        native_endianness: The native endianness of the backend
+        engine: The underlying (native) automatic differentiation engine of the backend.
     """
 
     name: BackendName
@@ -114,6 +117,7 @@ class Backend(ABC):
     is_remote: bool
     with_measurements: bool
     native_endianness: Endianness
+    engine: Engine
 
     # FIXME: should this also go into the configuration?
     with_noise: bool
@@ -199,7 +203,7 @@ class Backend(ABC):
 
         conv_circ = self.circuit(circuit)
         circ_params, circ_embedding_fn = embedding(
-            conv_circ.abstract.block, self.config._use_gate_params
+            conv_circ.abstract.block, self.config._use_gate_params, self.engine
         )
         params = circ_params
         if observable is not None:
@@ -211,7 +215,7 @@ class Backend(ABC):
                 obs = check_observable(obs)
                 c_obs = self.observable(obs, max(circuit.n_qubits, obs.n_qubits))
                 obs_params, obs_embedding_fn = embedding(
-                    c_obs.abstract, self.config._use_gate_params
+                    c_obs.abstract, self.config._use_gate_params, self.engine
                 )
                 params.update(obs_params)
                 obs_embedding_fn_list.append(obs_embedding_fn)
@@ -236,7 +240,7 @@ class Backend(ABC):
         circuit: ConvertedCircuit,
         param_values: dict[str, Tensor] = {},
         n_shots: int = 1000,
-        state: Tensor | None = None,
+        state: ArrayLike | None = None,
         noise: Noise | None = None,
         mitigation: Mitigations | None = None,
         endianness: Endianness = Endianness.BIG,
@@ -259,10 +263,10 @@ class Backend(ABC):
     def _run(
         self,
         circuit: ConvertedCircuit,
-        param_values: dict[str, Tensor] = {},
-        state: Tensor | None = None,
+        param_values: dict[str, ArrayLike] = {},
+        state: ArrayLike | None = None,
         endianness: Endianness = Endianness.BIG,
-    ) -> Tensor:
+    ) -> ArrayLike:
         """Run a circuit and return the resulting wave function.
 
         Arguments:
@@ -281,12 +285,12 @@ class Backend(ABC):
     def run(
         self,
         circuit: ConvertedCircuit,
-        param_values: dict[str, Tensor] = {},
+        param_values: dict[str, ArrayLike] = {},
         state: Tensor | None = None,
         endianness: Endianness = Endianness.BIG,
         *args: Any,
         **kwargs: Any,
-    ) -> Tensor:
+    ) -> ArrayLike:
         """Run a circuit and return the resulting wave function.
 
         Arguments:
@@ -308,7 +312,7 @@ class Backend(ABC):
         self,
         circuit: ConvertedCircuit,
         noise: Noise,
-        param_values: dict[str, Tensor] = {},
+        param_values: dict[str, ArrayLike] = {},
         state: Tensor | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> Tensor:
@@ -335,13 +339,13 @@ class Backend(ABC):
         self,
         circuit: ConvertedCircuit,
         observable: list[ConvertedObservable] | ConvertedObservable,
-        param_values: dict[str, Tensor] = {},
-        state: Tensor | None = None,
+        param_values: ParamDictType = {},
+        state: ArrayLike | None = None,
         measurement: Measurements | None = None,
         noise: Noise | None = None,
         mitigation: Mitigations | None = None,
         endianness: Endianness = Endianness.BIG,
-    ) -> Tensor:
+    ) -> ArrayLike:
         """Compute the expectation value of the `circuit` with the given `observable`.
 
         Arguments:
@@ -398,7 +402,7 @@ class Converted:
     circuit: ConvertedCircuit
     observable: list[ConvertedObservable] | ConvertedObservable | None
     embedding_fn: Callable
-    params: dict[str, Tensor]
+    params: ParamDictType
 
     def __iter__(self) -> Iterator:
         yield self.circuit

{qadence-1.2.0 → qadence-1.2.1}/qadence/backends/__init__.py

@@ -2,7 +2,6 @@
 from __future__ import annotations
 
 from .api import backend_factory, config_factory
-from .pytorch_wrapper import DifferentiableBackend
 
 # Modules to be automatically added to the qadence namespace
-__all__ = ["backend_factory", "config_factory", "DifferentiableBackend"]
+__all__ = ["backend_factory", "config_factory"]

{qadence-1.2.0 → qadence-1.2.1}/qadence/backends/api.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 from qadence.backend import Backend, BackendConfiguration
-from qadence.backends.pytorch_wrapper import DifferentiableBackend
-from qadence.extensions import available_backends, set_backend_config
-from qadence.types import BackendName, DiffMode
+from qadence.engines.differentiable_backend import DifferentiableBackend
+from qadence.extensions import available_backends, available_engines, set_backend_config
+from qadence.types import BackendName, DiffMode, Engine
 
 __all__ = ["backend_factory", "config_factory"]
 
@@ -14,13 +14,18 @@ def backend_factory(
     configuration: BackendConfiguration | dict | None = None,
 ) -> Backend | DifferentiableBackend:
     backend_inst: Backend | DifferentiableBackend
-    backend_name = BackendName(backend)
     backends = available_backends()
-
+    try:
+        backend_name = BackendName(backend)
+    except ValueError:
+        raise NotImplementedError(f"The requested backend '{backend}' is not implemented.")
     try:
         BackendCls = backends[backend_name]
-    except (KeyError, ValueError):
-        raise NotImplementedError(f"The requested backend '{backend_name}' is not implemented.")
+    except Exception as e:
+        raise ImportError(
+            f"The requested backend '{backend_name}' is either not installed\
+              or could not be imported due to {e}."
+        )
 
     default_config = BackendCls.default_configuration()
     if configuration is None:
@@ -44,9 +49,22 @@ def backend_factory(
 
     # Set backend configurations which depend on the differentiation mode
     set_backend_config(backend_inst, diff_mode)
-
+    # Wrap the quantum Backend in a DifferentiableBackend if a diff_mode is passed.
     if diff_mode is not None:
-        backend_inst = DifferentiableBackend(backend_inst, DiffMode(diff_mode))
+        try:
+            engine_name = Engine(backend_inst.engine)
+        except ValueError:
+            raise NotImplementedError(
+                f"The requested engine '{backend_inst.engine}' is not implemented."
+            )
+        try:
+            diff_backend_cls = available_engines()[engine_name]
+            backend_inst = diff_backend_cls(backend=backend_inst, diff_mode=DiffMode(diff_mode))  # type: ignore[arg-type]
+        except Exception as e:
+            raise ImportError(
+                f"The requested engine '{engine_name}' is either not installed\
+                or could not be imported due to {e}."
+            )
     return backend_inst
 
 

{qadence-1.2.0 → qadence-1.2.1}/qadence/backends/braket/backend.py

@@ -23,7 +23,7 @@ from qadence.noise import Noise
 from qadence.noise.protocols import apply_noise
 from qadence.overlap import overlap_exact
 from qadence.transpile import transpile
-from qadence.types import BackendName
+from qadence.types import BackendName, Engine
 from qadence.utils import Endianness
 
 from .config import Configuration, default_passes
@@ -55,6 +55,7 @@ class Backend(BackendInterface):
     with_noise: bool = False
     native_endianness: Endianness = Endianness.BIG
     config: Configuration = field(default_factory=Configuration)
+    engine: Engine = Engine.TORCH
 
     # braket specifics
     # TODO: include it in the configuration?

qadence-1.2.1/qadence/backends/horqrux/backend.py

@@ -0,0 +1,216 @@
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import dataclass, field
+from typing import Any
+
+import jax
+import jax.numpy as jnp
+from horqrux.utils import prepare_state
+from jax.typing import ArrayLike
+
+from qadence.backend import Backend as BackendInterface
+from qadence.backend import ConvertedCircuit, ConvertedObservable
+from qadence.backends.jax_utils import (
+    tensor_to_jnp,
+    unhorqify,
+    uniform_batchsize,
+)
+from qadence.backends.utils import pyqify
+from qadence.blocks import AbstractBlock
+from qadence.circuit import QuantumCircuit
+from qadence.measurements import Measurements
+from qadence.mitigations import Mitigations
+from qadence.noise import Noise
+from qadence.transpile import flatten, scale_primitive_blocks_only, transpile
+from qadence.types import BackendName, Endianness, Engine, ParamDictType
+from qadence.utils import int_to_basis
+
+from .config import Configuration, default_passes
+from .convert_ops import HorqruxCircuit, convert_block, convert_observable
+
+
+@dataclass(frozen=True, eq=True)
+class Backend(BackendInterface):
+    # set standard interface parameters
+    name: BackendName = BackendName.HORQRUX  # type: ignore[assignment]
+    supports_ad: bool = True
+    supports_adjoint: bool = False
+    support_bp: bool = True
+    supports_native_psr: bool = False
+    is_remote: bool = False
+    with_measurements: bool = True
+    with_noise: bool = False
+    native_endianness: Endianness = Endianness.BIG
+    config: Configuration = field(default_factory=Configuration)
+    engine: Engine = Engine.JAX
+
+    def circuit(self, circuit: QuantumCircuit) -> ConvertedCircuit:
+        passes = self.config.transpilation_passes
+        if passes is None:
+            passes = default_passes(self.config)
+
+        original_circ = circuit
+        if len(passes) > 0:
+            circuit = transpile(*passes)(circuit)
+        ops = convert_block(circuit.block, n_qubits=circuit.n_qubits, config=self.config)
+        return ConvertedCircuit(
+            native=HorqruxCircuit(ops), abstract=circuit, original=original_circ
+        )
+
+    def observable(self, observable: AbstractBlock, n_qubits: int) -> ConvertedObservable:
+        transpilations = [
+            flatten,
+            scale_primitive_blocks_only,
+        ]
+        block = transpile(*transpilations)(observable)  # type: ignore[call-overload]
+        hq_obs = convert_observable(block, n_qubits=n_qubits, config=self.config)
+        return ConvertedObservable(native=hq_obs, abstract=block, original=observable)
+
+    def _run(
+        self,
+        circuit: ConvertedCircuit,
+        param_values: ParamDictType = {},
+        state: ArrayLike | None = None,
+        endianness: Endianness = Endianness.BIG,
+        horqify_state: bool = True,
+        unhorqify_state: bool = True,
+    ) -> ArrayLike:
+        n_qubits = circuit.abstract.n_qubits
+        if state is None:
+            state = prepare_state(n_qubits, "0" * n_qubits)
+        else:
+            state = tensor_to_jnp(pyqify(state)) if horqify_state else state
+        state = circuit.native.forward(state, param_values)
+        if endianness != self.native_endianness:
+            state = jnp.reshape(state, (1, 2**n_qubits))  # batch_size is always 1
+            ls = list(range(2**n_qubits))
+            permute_ind = jnp.array([int(f"{num:0{n_qubits}b}"[::-1], 2) for num in ls])
+            state = state[:, permute_ind]
+        if unhorqify_state:
+            state = unhorqify(state)
+        return state
+
+    def run_dm(
+        self,
+        circuit: ConvertedCircuit,
+        noise: Noise,
+        param_values: ParamDictType = {},
+        state: ArrayLike | None = None,
+        endianness: Endianness = Endianness.BIG,
+    ) -> ArrayLike:
+        raise NotImplementedError
+
+    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,
+    ) -> ArrayLike:
+        observable = observable if isinstance(observable, list) else [observable]
+        batch_size = max([arr.size for arr in param_values.values()])
+        n_obs = len(observable)
+
+        def _expectation(params: ParamDictType) -> ArrayLike:
+            out_state = self.run(
+                circuit, params, state, endianness, horqify_state=True, unhorqify_state=False
+            )
+            return jnp.array([o.native.forward(out_state, params) for o in observable])
+
+        if batch_size > 1:  # We vmap for batch_size > 1
+            expvals = jax.vmap(_expectation, in_axes=({k: 0 for k in param_values.keys()},))(
+                uniform_batchsize(param_values)
+            )
+        else:
+            expvals = _expectation(param_values)
+        if expvals.size > 1:
+            expvals = jnp.reshape(expvals, (batch_size, n_obs))
+        else:
+            expvals = jnp.squeeze(
+                expvals, 0
+            )  # For the case of batch_size == n_obs == 1, we remove the dims
+        return expvals
+
+    def sample(
+        self,
+        circuit: ConvertedCircuit,
+        param_values: ParamDictType = {},
+        n_shots: int = 1,
+        state: ArrayLike | None = None,
+        noise: Noise | None = None,
+        mitigation: Mitigations | None = None,
+        endianness: Endianness = Endianness.BIG,
+    ) -> list[Counter]:
+        """Samples from a batch of discrete probability distributions.
+
+        Args:
+            circuit: A ConvertedCircuit object holding the native PyQ Circuit.
+            param_values: A dict holding the embedded parameters which the native ciruit expects.
+            n_shots: The number of samples to generate per distribution.
+            state: The input state.
+            endianness (Endianness): The target endianness of the resulting samples.
+
+        Returns:
+            A list of Counter objects where each key represents a bitstring
+            and its value the number of times it has been sampled from the given wave function.
+        """
+        if n_shots < 1:
+            raise ValueError("You can only call sample with n_shots>0.")
+
+        def _sample(
+            _probs: ArrayLike, n_shots: int, endianness: Endianness, n_qubits: int
+        ) -> Counter:
+            _logits = jax.vmap(lambda _p: jnp.log(_p / (1 - _p)))(_probs)
+
+            def _smple(accumulator: ArrayLike, i: int) -> tuple[ArrayLike, None]:
+                accumulator = accumulator.at[i].set(
+                    jax.random.categorical(jax.random.PRNGKey(i), _logits)
+                )
+                return accumulator, None
+
+            samples = jax.lax.scan(
+                _smple, jnp.empty_like(jnp.arange(n_shots)), jnp.arange(n_shots)
+            )[0]
+            return Counter(
+                {
+                    int_to_basis(k=k, n_qubits=n_qubits, endianness=endianness): count.item()
+                    for k, count in enumerate(jnp.bincount(samples))
+                    if count > 0
+                }
+            )
+
+        wf = self.run(
+            circuit=circuit,
+            param_values=param_values,
+            state=state,
+            horqify_state=True,
+            unhorqify_state=False,
+        )
+        probs = jnp.abs(jnp.float_power(wf, 2.0)).ravel()
+        samples = [
+            _sample(
+                _probs=probs,
+                n_shots=n_shots,
+                endianness=endianness,
+                n_qubits=circuit.abstract.n_qubits,
+            ),
+        ]
+
+        return samples
+
+    def assign_parameters(self, circuit: ConvertedCircuit, param_values: ParamDictType) -> Any:
+        raise NotImplementedError
+
+    @staticmethod
+    def _overlap(bras: ArrayLike, kets: ArrayLike) -> ArrayLike:
+        # TODO
+        raise NotImplementedError
+
+    @staticmethod
+    def default_configuration() -> Configuration:
+        return Configuration()