qadence 1.4.0__tar.gz → 1.5.0__tar.gz

{qadence-1.4.0 → qadence-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: qadence
-Version: 1.4.0
+Version: 1.5.0
 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>, Gergana Velikova <gergana.velikova@pasqal.com>
 License: Apache 2.0
@@ -13,14 +13,14 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
-Requires-Python: <3.12,>=3.9
+Requires-Python: <3.13,>=3.9
 Requires-Dist: deepdiff
 Requires-Dist: jsonschema
 Requires-Dist: matplotlib
 Requires-Dist: nevergrad
 Requires-Dist: numpy
 Requires-Dist: openfermion
-Requires-Dist: pyqtorch==1.0.6
+Requires-Dist: pyqtorch==1.1.0
 Requires-Dist: rich
 Requires-Dist: scipy
 Requires-Dist: sympytorch>=0.1.2
@@ -29,10 +29,11 @@ Requires-Dist: torch
 Provides-Extra: all
 Requires-Dist: amazon-braket-sdk; extra == 'all'
 Requires-Dist: graphviz; extra == 'all'
+Requires-Dist: libs; extra == 'all'
 Requires-Dist: protocols; extra == 'all'
 Requires-Dist: pulser>=0.15.2; extra == 'all'
 Provides-Extra: braket
-Requires-Dist: amazon-braket-sdk; extra == 'braket'
+Requires-Dist: amazon-braket-sdk==1.71.0; extra == 'braket'
 Provides-Extra: horqrux
 Requires-Dist: einops; extra == 'horqrux'
 Requires-Dist: flax; extra == 'horqrux'
@@ -41,6 +42,8 @@ Requires-Dist: jax; extra == 'horqrux'
 Requires-Dist: jaxopt; extra == 'horqrux'
 Requires-Dist: optax; extra == 'horqrux'
 Requires-Dist: sympy2jax; extra == 'horqrux'
+Provides-Extra: libs
+Requires-Dist: qadence-libs; extra == 'libs'
 Provides-Extra: protocols
 Requires-Dist: qadence-protocols; extra == 'protocols'
 Provides-Extra: pulser
@@ -51,13 +54,15 @@ Requires-Dist: graphviz; extra == 'visualization'
 Description-Content-Type: text/markdown
 
 <picture>
-  <source media="(prefers-color-scheme: dark)" srcset="./docs/logo/qadence_logo_white.svg">
-  <source media="(prefers-color-scheme: light)" srcset="./docs/logo/qadence_logo.svg">
-  <img alt="Qadence logo" src="./docs/logo/qadence_logo.svg">
+  <source media="(prefers-color-scheme: dark)" srcset="./docs/assets/logo/qadence_logo_white.svg">
+  <source media="(prefers-color-scheme: light)" srcset="./docs/assets/logo/qadence_logo.svg">
+  <img alt="Qadence logo" src="./docs/assets/logo/qadence_logo.svg">
 </picture>
 
 **For a high-level overview of Qadence features, [check out our white paper](https://arxiv.org/abs/2401.09915).**
 
+**For more detailed information, [check out the documentation](https://pasqal-io.github.io/qadence/latest/).**
+
 **Qadence** is a Python package that provides a simple interface to build _**digital-analog quantum
 programs**_ with tunable qubit interaction defined on _**arbitrary register topologies**_ realizable on neutral atom devices.
 
@@ -69,6 +74,13 @@ programs**_ with tunable qubit interaction defined on _**arbitrary register topo
 
 ## Feature highlights
 
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="./docs/assets/qadence_arch.svg">
+  <source media="(prefers-color-scheme: light)" srcset="./docs/assets/qadence_arch.svg">
+  <img alt="Qadence architecture" src="./docs/assets/qadence_arch.svg">
+</picture>
+
+
 * A [block-based system](docs/tutorials/getting_started.md) for composing _**complex digital-analog
   programs**_ in a flexible and scalable manner, inspired by the Julia quantum SDK
   [Yao.jl](https://github.com/QuantumBFS/Yao.jl) and functional programming concepts.
@@ -97,6 +109,8 @@ The default, pre-installed backend for Qadence is [PyQTorch](https://github.com/
 * `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.
+* `protocols`: A collection of [protocols](https://github.com/pasqal-io/qadence-protocols) for error mitigation in Qadence.
+* `libs`: A collection of [functionalities](https://github.com/pasqal-io/qadence-libs) for graph machine learning problems build on top of Qadence.
 
 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).
 

{qadence-1.4.0 → qadence-1.5.0}/README.md

@@ -1,11 +1,13 @@
 <picture>
-  <source media="(prefers-color-scheme: dark)" srcset="./docs/logo/qadence_logo_white.svg">
-  <source media="(prefers-color-scheme: light)" srcset="./docs/logo/qadence_logo.svg">
-  <img alt="Qadence logo" src="./docs/logo/qadence_logo.svg">
+  <source media="(prefers-color-scheme: dark)" srcset="./docs/assets/logo/qadence_logo_white.svg">
+  <source media="(prefers-color-scheme: light)" srcset="./docs/assets/logo/qadence_logo.svg">
+  <img alt="Qadence logo" src="./docs/assets/logo/qadence_logo.svg">
 </picture>
 
 **For a high-level overview of Qadence features, [check out our white paper](https://arxiv.org/abs/2401.09915).**
 
+**For more detailed information, [check out the documentation](https://pasqal-io.github.io/qadence/latest/).**
+
 **Qadence** is a Python package that provides a simple interface to build _**digital-analog quantum
 programs**_ with tunable qubit interaction defined on _**arbitrary register topologies**_ realizable on neutral atom devices.
 
@@ -17,6 +19,13 @@ programs**_ with tunable qubit interaction defined on _**arbitrary register topo
 
 ## Feature highlights
 
+<picture>
+  <source media="(prefers-color-scheme: dark)" srcset="./docs/assets/qadence_arch.svg">
+  <source media="(prefers-color-scheme: light)" srcset="./docs/assets/qadence_arch.svg">
+  <img alt="Qadence architecture" src="./docs/assets/qadence_arch.svg">
+</picture>
+
+
 * A [block-based system](docs/tutorials/getting_started.md) for composing _**complex digital-analog
   programs**_ in a flexible and scalable manner, inspired by the Julia quantum SDK
   [Yao.jl](https://github.com/QuantumBFS/Yao.jl) and functional programming concepts.
@@ -45,6 +54,8 @@ The default, pre-installed backend for Qadence is [PyQTorch](https://github.com/
 * `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.
+* `protocols`: A collection of [protocols](https://github.com/pasqal-io/qadence-protocols) for error mitigation in Qadence.
+* `libs`: A collection of [functionalities](https://github.com/pasqal-io/qadence-libs) for graph machine learning problems build on top of Qadence.
 
 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).
 

{qadence-1.4.0 → qadence-1.5.0}/mkdocs.yml

@@ -79,7 +79,7 @@ edit_uri: edit/main/docs/
 
 theme:
   name: material
-  logo: logo/qadence_logo_small_white.svg
+  logo: assets/logo/qadence_logo_small_white.svg
   features:
   - content.code.annotate
   - content.action.view

{qadence-1.4.0 → qadence-1.5.0}/pyproject.toml

@@ -18,9 +18,9 @@ authors = [
     { name = "Vytautas Abramavicius", email = "vytautas.abramavicius@pasqal.com" },
     { name = "Gergana Velikova", email = "gergana.velikova@pasqal.com" },
 ]
-requires-python = ">=3.9,<3.12"
+requires-python = ">=3.9,<3.13"
 license = {text = "Apache 2.0"}
-version = "1.4.0"
+version = "1.5.0"
 classifiers=[
     "License :: OSI Approved :: Apache Software License",
     "Programming Language :: Python",
@@ -42,7 +42,7 @@ dependencies = [
     "jsonschema",
     "nevergrad",
     "scipy",
-    "pyqtorch==1.0.6",
+    "pyqtorch==1.1.0",
     "matplotlib",
 ]
 
@@ -52,7 +52,7 @@ allow-ambiguous-features = true
 
 [project.optional-dependencies]
 pulser = ["pulser>=v0.15.2", "pasqal-cloud>=0.3.5"]
-braket = ["amazon-braket-sdk"]
+braket = ["amazon-braket-sdk==1.71.0"]
 visualization = [
   "graphviz",
   # FIXME: will be needed once we support latex labels
@@ -68,11 +68,13 @@ horqrux = [
     "einops",
     "sympy2jax"]
 protocols = ["qadence-protocols"]
+libs = ["qadence-libs"]
 all = [
   "pulser>=0.15.2",
   "amazon-braket-sdk",
   "graphviz",
   "protocols",
+  "libs",
   # FIXME: will be needed once we support latex labels
   # "latex2svg @ git+https://github.com/Moonbase59/latex2svg.git#egg=latex2svg",
   # "scour",

{qadence-1.4.0 → qadence-1.5.0}/qadence/__init__.py

@@ -32,6 +32,7 @@ DEFAULT_FLOAT_DTYPE = torchfloat64
 DEFAULT_COMPLEX_DTYPE = cdouble
 set_default_dtype(DEFAULT_FLOAT_DTYPE)
 
+
 """Fetch the functions defined in the __all__ of each sub-module.
 
 Import to the qadence name space. Make sure each added submodule has the respective definition:

{qadence-1.4.0 → qadence-1.5.0}/qadence/backends/pulser/backend.py

@@ -71,7 +71,7 @@ def make_sequence(circ: QuantumCircuit, config: Configuration) -> Sequence:
         )
 
     ########
-    # FIXME: Remove the block below in V1.1.0
+    # FIXME: Remove the block below in V1.5.0
     if config.spacing is not None:
         logger.warning(
             "Passing register spacing in the backend configuration is deprecated. "

{qadence-1.4.0 → qadence-1.5.0}/qadence/backends/pulser/config.py

@@ -30,6 +30,7 @@ class Configuration(BackendConfiguration):
 
     FIXME: This is deprecated, the device_type is now controlled in the
     Qadence Device, as detailed in the documentation.
+    FIXME: Remove in v1.5.0
     """
 
     sampling_rate: float = 1.0
@@ -44,6 +45,7 @@ class Configuration(BackendConfiguration):
 
     FIXME: This is deprecated, spacing is now controlled in the Register,
     as detailed in the register tutorial.
+    FIXME: Remove in v1.5.0
     """
 
     method_solv: str = "adams"
@@ -89,6 +91,7 @@ class Configuration(BackendConfiguration):
 
     FIXME: This is deprecated, the interaction is now controlled in the
     Qadence Device, as detailed in the documentation.
+    FIXME: Remove in v1.5.0
     """
 
     # configuration for cloud simulations

{qadence-1.4.0 → qadence-1.5.0}/qadence/backends/pyqtorch/backend.py

@@ -151,7 +151,9 @@ class Backend(BackendInterface):
         if state is None:
             from qadence.states import zero_state
 
-            state = zero_state(circuit.abstract.n_qubits, batch_size=1)
+            state = zero_state(circuit.abstract.n_qubits, batch_size=1).to(
+                dtype=circuit.native.dtype
+            )
         if state.size(0) != 1:
             raise ValueError(
                 "Looping expectation does not make sense with batched initial state. "
@@ -222,28 +224,29 @@ class Backend(BackendInterface):
                 }
             )
 
-        wf = self.run(circuit=circuit, param_values=param_values, state=state)
-        probs = torch.abs(torch.pow(wf, 2))
-        samples = list(
-            map(
-                lambda _probs: _sample(
-                    _probs=_probs,
-                    n_shots=n_shots,
-                    endianness=endianness,
-                    n_qubits=circuit.abstract.n_qubits,
-                ),
-                probs,
-            )
-        )
-        if noise is not None:
-            samples = apply_noise(noise=noise, samples=samples)
-        if mitigation is not None:
-            logger.warning(
-                "Mitigation protocol is deprecated. Use qadence-protocols instead.",
+        with torch.no_grad():
+            wf = self.run(circuit=circuit, param_values=param_values, state=state)
+            probs = torch.abs(torch.pow(wf, 2))
+            samples = list(
+                map(
+                    lambda _probs: _sample(
+                        _probs=_probs,
+                        n_shots=n_shots,
+                        endianness=endianness,
+                        n_qubits=circuit.abstract.n_qubits,
+                    ),
+                    probs,
+                )
             )
-            assert noise
-            samples = apply_mitigation(noise=noise, mitigation=mitigation, samples=samples)
-        return samples
+            if noise is not None:
+                samples = apply_noise(noise=noise, samples=samples)
+            if mitigation is not None:
+                logger.warning(
+                    "Mitigation protocol is deprecated. Use qadence-protocols instead.",
+                )
+                assert noise
+                samples = apply_mitigation(noise=noise, mitigation=mitigation, samples=samples)
+            return samples
 
     def assign_parameters(self, circuit: ConvertedCircuit, param_values: dict[str, Tensor]) -> Any:
         raise NotImplementedError

{qadence-1.4.0 → qadence-1.5.0}/qadence/backends/pyqtorch/convert_ops.py

@@ -4,7 +4,7 @@ from functools import reduce
 from itertools import chain as flatten
 from math import prod
 from operator import add
-from typing import Sequence, Tuple
+from typing import Any, Sequence, Tuple
 
 import pyqtorch as pyq
 import sympy
@@ -26,6 +26,7 @@ from torch import (
     transpose,
 )
 from torch import device as torch_device
+from torch import dtype as torch_dtype
 from torch.nn import Module
 
 from qadence.backends.utils import (
@@ -178,6 +179,7 @@ class PyQMatrixBlock(Module):
         self.register_buffer("mat", block.matrix.unsqueeze(2))
         self.mat: Tensor
         self._device: torch_device = self.mat.device
+        self._dtype: torch_dtype = self.mat.dtype
 
     def forward(self, state: Tensor, _: dict[str, Tensor] = None) -> Tensor:
         return apply_operator(state, self.mat, self.qubits, self.n_qubits)
@@ -186,9 +188,10 @@ class PyQMatrixBlock(Module):
     def device(self) -> torch_device:
         return self._device
 
-    def to(self, device: torch_device) -> PyQMatrixBlock:
-        self.mat = self.mat.to(device)
-        self._device = device
+    def to(self, *args: Any, **kwargs: Any) -> PyQMatrixBlock:
+        self.mat = self.mat.to(*args, **kwargs)
+        self._device = self.mat.device
+        self._dtype = self.mat.dtype
         return self
 
 
@@ -262,6 +265,7 @@ class PyQObservable(Module):
             )
             self._forward = lambda self, state, values: self.operation(state, values)
         self._device = self.operation.device
+        self._dtype = self.operation.dtype
 
     def run(self, state: Tensor, values: dict[str, Tensor]) -> Tensor:
         return self._forward(self, state, values)
@@ -273,9 +277,14 @@ class PyQObservable(Module):
     def device(self) -> torch_device:
         return self._device
 
-    def to(self, device: torch_device) -> PyQObservable:
-        self.operation = self.operation.to(device)
-        self._device = device
+    @property
+    def dtype(self) -> torch_dtype:
+        return self._dtype
+
+    def to(self, *args: Any, **kwargs: Any) -> PyQObservable:
+        self.operation = self.operation.to(*args, **kwargs)
+        self._device = self.operation.device
+        self._dtype = self.operation.dtype
         return self
 
 
@@ -338,6 +347,7 @@ class PyQHamiltonianEvolution(Module):
         self._device: torch_device = (
             self.hmat.device if hasattr(self, "hmat") else torch_device("cpu")
         )
+        self._dtype: torch_dtype = self.hmat.dtype if hasattr(self, "hmat") else cdouble
 
     def _unitary(self, hamiltonian: Tensor, time_evolution: Tensor) -> Tensor:
         self.batch_size = max(hamiltonian.size()[2], len(time_evolution))
@@ -419,10 +429,15 @@ class PyQHamiltonianEvolution(Module):
     def device(self) -> torch_device:
         return self._device
 
-    def to(self, device: torch_device) -> PyQHamiltonianEvolution:
+    @property
+    def dtype(self) -> torch_dtype:
+        return self._dtype
+
+    def to(self, *args: Any, **kwargs: Any) -> PyQHamiltonianEvolution:
         if hasattr(self, "hmat"):
-            self.hmat = self.hmat.to(device)
-        self._device = device
+            self.hmat = self.hmat.to(*args, **kwargs)
+            self._device = self.hmat.device
+            self._dtype = self.hmat.dtype
         return self
 
 

{qadence-1.4.0 → qadence-1.5.0}/qadence/backends/utils.py

@@ -13,6 +13,7 @@ from pyqtorch.parametric import Parametric as PyQParametric
 from torch import (
     Tensor,
     cat,
+    complex64,
     complex128,
     mean,
     no_grad,
@@ -129,8 +130,8 @@ def is_pyq_shape(state: Tensor, n_qubits: int) -> bool:
 
 def validate_state(state: Tensor, n_qubits: int) -> None:
     """Check if a custom initial state conforms to the qadence or the pyqtorch format."""
-    if state.dtype != complex128:
-        raise TypeError(f"Expected type complex128, got {state.dtype}")
+    if state.dtype not in [complex128, complex64]:
+        raise TypeError(f"Expected complex dtype, got {state.dtype}")
     elif len(state.size()) < 2:
         raise ValueError(f"Invalid state shape. Got {state.shape}")
     elif not is_qadence_shape(state, n_qubits) and not is_pyq_shape(state, n_qubits):

{qadence-1.4.0 → qadence-1.5.0}/qadence/constructors/ansatze.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import itertools
+import warnings
 from typing import Any, Optional, Type, Union
 
 from qadence.blocks import AbstractBlock, block_is_qubit_hamiltonian, chain, kron, tag
@@ -328,6 +329,7 @@ def hea_analog(*args: Any, **kwargs: Any) -> Any:
 #########
 
 
+# FIXME: Remove in v1.5.0
 def build_qnn(
     n_qubits: int,
     n_features: int,
@@ -360,6 +362,9 @@ def build_qnn(
     Returns:
         A list of Abstract blocks to be used for constructing a quantum circuit
     """
+
+    warnings.warn("Function build_qnn is deprecated and will be removed in v1.5.0.", FutureWarning)
+
     depth = n_qubits if depth is None else depth
 
     idx_fms = build_idx_fms(basis, fm_pauli, fm_strategy, n_features, n_qubits, spectrum)

{qadence-1.4.0 → qadence-1.5.0}/qadence/constructors/feature_maps.py

@@ -35,6 +35,7 @@ RS_FUNC_DICT = {
 }
 
 
+# FIXME: Remove in v1.5.0
 def backwards_compatibility(
     fm_type: BasisSet | Callable | str,
     reupload_scaling: ReuploadScaling | Callable | str,
@@ -224,6 +225,7 @@ def feature_map(
     return fm
 
 
+# FIXME: Remove in v1.5.0
 def fourier_feature_map(
     n_qubits: int, support: tuple[int, ...] = None, param: str = "phi", op: RotationTypes = RX
 ) -> AbstractBlock:
@@ -241,6 +243,7 @@ def fourier_feature_map(
     return fm
 
 
+# FIXME: Remove in v1.5.0
 def chebyshev_feature_map(
     n_qubits: int, support: tuple[int, ...] = None, param: str = "phi", op: RotationTypes = RX
 ) -> AbstractBlock:
@@ -259,6 +262,7 @@ def chebyshev_feature_map(
     return fm
 
 
+# FIXME: Remove in v1.5.0
 def tower_feature_map(
     n_qubits: int, support: tuple[int, ...] = None, param: str = "phi", op: RotationTypes = RX
 ) -> AbstractBlock:

{qadence-1.4.0 → qadence-1.5.0}/qadence/engines/torch/differentiable_expectation.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from collections import Counter, OrderedDict
+from collections import OrderedDict
 from dataclasses import dataclass
 from functools import partial
 from typing import Any, Callable, Sequence
@@ -8,22 +8,19 @@ from typing import Any, Callable, Sequence
 import torch
 from torch import Tensor
 from torch.autograd import Function
-from torch.nn import Module
 
 from qadence.backend import Backend as QuantumBackend
-from qadence.backend import Converted, ConvertedCircuit, ConvertedObservable
+from qadence.backend import ConvertedCircuit, ConvertedObservable
 from qadence.backends.adjoint import AdjointExpectation
 from qadence.backends.utils import infer_batchsize, is_pyq_shape, param_dict, pyqify, validate_state
 from qadence.blocks.abstract import AbstractBlock
-from qadence.blocks.primitive import PrimitiveBlock
-from qadence.blocks.utils import uuid_to_block, uuid_to_eigen
+from qadence.blocks.utils import uuid_to_eigen
 from qadence.circuit import QuantumCircuit
-from qadence.extensions import get_gpsr_fns
 from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
 from qadence.ml_tools import promote_to_tensor
 from qadence.noise import Noise
-from qadence.types import DiffMode, Endianness
+from qadence.types import Endianness
 
 
 class PSRExpectation(Function):
@@ -232,160 +229,3 @@ class DifferentiableExpectation:
                 # Since they are constants their gradients are 0.
                 param_to_psr[param_id] = lambda x: torch.tensor([0.0], requires_grad=False)
         return param_to_psr
-
-
-class DifferentiableBackend(Module):
-    """A class to abstract the operations done by the autodiff engine.
-
-    Arguments:
-        backend: An instance of the QuantumBackend type perform execution.
-        diff_mode: A differentiable mode supported by the differentiation engine.
-        **psr_args: Arguments that will be passed on to `DifferentiableExpectation`.
-    """
-
-    def __init__(
-        self,
-        backend: QuantumBackend,
-        diff_mode: DiffMode = DiffMode.AD,
-        **psr_args: int | float | None,
-    ) -> None:
-        super().__init__()
-
-        self.backend = backend
-        self.diff_mode = diff_mode
-        self.psr_args = psr_args
-        # TODO: Add differentiable overlap calculation
-        self._overlap: Callable = None  # type: ignore [assignment]
-
-    def run(
-        self,
-        circuit: ConvertedCircuit,
-        param_values: dict = {},
-        state: Tensor | None = None,
-        endianness: Endianness = Endianness.BIG,
-    ) -> Tensor:
-        """Run on the underlying backend."""
-        return self.backend.run(
-            circuit=circuit, param_values=param_values, state=state, endianness=endianness
-        )
-
-    def expectation(
-        self,
-        circuit: ConvertedCircuit,
-        observable: list[ConvertedObservable] | ConvertedObservable,
-        param_values: dict[str, Tensor] = {},
-        state: Tensor | None = None,
-        measurement: Measurements | None = None,
-        noise: Noise | None = None,
-        mitigation: Mitigations | None = None,
-        endianness: Endianness = Endianness.BIG,
-    ) -> Tensor:
-        """Compute the expectation value of a given observable.
-
-        Arguments:
-            circuit: A backend native quantum circuit to be executed.
-            observable: A backend native observable to compute the expectation value from.
-            param_values: A dict of values for symbolic substitution.
-            state: An initial state.
-            measurement: A shot-based measurement protocol.
-            endianness: Endianness of the state.
-
-        Returns:
-            A tensor of expectation values.
-        """
-        observable = observable if isinstance(observable, list) else [observable]
-        differentiable_expectation = DifferentiableExpectation(
-            backend=self.backend,
-            circuit=circuit,
-            observable=observable,
-            param_values=param_values,
-            state=state,
-            measurement=measurement,
-            noise=noise,
-            mitigation=mitigation,
-            endianness=endianness,
-        )
-
-        if self.diff_mode == DiffMode.AD:
-            expectation = differentiable_expectation.ad
-        elif self.diff_mode == DiffMode.ADJOINT:
-            expectation = differentiable_expectation.adjoint
-        else:
-            try:
-                fns = get_gpsr_fns()
-                psr_fn = fns[self.diff_mode]
-            except KeyError:
-                raise ValueError(f"{self.diff_mode} differentiation mode is not supported")
-            expectation = partial(differentiable_expectation.psr, psr_fn=psr_fn, **self.psr_args)
-        return expectation()
-
-    def sample(
-        self,
-        circuit: ConvertedCircuit,
-        param_values: dict[str, Tensor],
-        n_shots: int = 1,
-        state: Tensor | 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
-        """
-        with torch.no_grad():
-            return self.backend.sample(
-                circuit=circuit,
-                param_values=param_values,
-                n_shots=n_shots,
-                state=state,
-                noise=noise,
-                mitigation=mitigation,
-                endianness=endianness,
-            )
-
-    def circuit(self, circuit: QuantumCircuit) -> ConvertedCircuit:
-        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 observable is not None and observable.is_parametric:
-            raise ValueError("PSR cannot be applied to a parametric observable.")
-        return self.backend.observable(observable, n_qubits)
-
-    def convert(
-        self,
-        circuit: QuantumCircuit,
-        observable: list[AbstractBlock] | AbstractBlock | None = None,
-    ) -> Converted:
-        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.convert(circuit, observable)
-
-    def assign_parameters(self, circuit: ConvertedCircuit, param_values: dict[str, Tensor]) -> Any:
-        return self.backend.assign_parameters(circuit, param_values)

{qadence-1.4.0 → qadence-1.5.0}/qadence/extensions.py

@@ -79,6 +79,7 @@ def _validate_diff_mode(backend: Backend, diff_mode: DiffMode) -> None:
 
 def _validate_backend_config(backend: Backend) -> None:
     if backend.config.use_gradient_checkpointing:
+        # FIXME: Remove in v1.5.0
         msg = "use_gradient_checkpointing is deprecated."
         import warnings