qadence 1.4.0__py3-none-any.whl → 1.5.0__py3-none-any.whl

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/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/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/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/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/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/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/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/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/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
 

qadence/libs.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+import importlib
+
+from qadence.logger import get_logger
+
+logger = get_logger(__name__)
+
+try:
+    module = importlib.import_module("qadence_libs.protocols")
+    available_libs = getattr(module, "available_libs")
+except ModuleNotFoundError:
+    raise ModuleNotFoundError(
+        "The 'qadence_libs' module is not present." " Please install the 'qadence-libs' package."
+    )

qadence/measurements/protocols.py

@@ -5,16 +5,16 @@ from dataclasses import dataclass
 from typing import Callable, cast
 
 PROTOCOL_TO_MODULE = {
-    "tomography": "qadence.measurements.tomography",
     "shadow": "qadence.measurements.shadow",
+    "tomography": "qadence.measurements.tomography",
 }
 
 
 # TODO: make this a StrEnum to keep consistency with the rest of the interface
 @dataclass
 class Measurements:
-    TOMOGRAPHY = "tomography"
     SHADOW = "shadow"
+    TOMOGRAPHY = "tomography"
 
     def __init__(self, protocol: str, options: dict) -> None:
         self.protocol: str = protocol

qadence/measurements/samples.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from collections import Counter
+from typing import List
+
+from torch import Tensor
+
+from qadence.blocks import AbstractBlock
+from qadence.blocks.utils import unroll_block_with_scaling
+from qadence.measurements.utils import pauli_z_expectation
+
+
+def compute_expectation(
+    observable: List[AbstractBlock],
+    samples: List[Counter],
+) -> List[Tensor]:
+    """Given a list of observables in Z basis, compute the expectation values against samples.
+
+    Args:
+        observables: A list of observables
+            to estimate the expectation values from.
+        samples: List of samples against which expectation value is to be computed
+    """
+
+    if not isinstance(observable, list):
+        raise TypeError(
+            f"Observables must be of type <class 'List[AbstractBlock]'>. Got {type(observable)}."
+        )
+
+    expectation_vals = []
+
+    for obs in observable:
+        decomposition = unroll_block_with_scaling(obs)
+        if not obs._is_diag_pauli or obs.is_identity:
+            raise TypeError("observable provided is not in the Z basis")
+        expectation_vals.append(pauli_z_expectation(decomposition, samples))
+
+    return expectation_vals

qadence/measurements/tomography.py

@@ -1,129 +1,19 @@
 from __future__ import annotations
 
-from collections import Counter
-from functools import reduce
-
-import numpy as np
 import torch
 from torch import Tensor
 
 from qadence.backend import Backend
 from qadence.backends.pyqtorch import Backend as PyQBackend
-from qadence.blocks import AbstractBlock, PrimitiveBlock, chain
+from qadence.blocks import AbstractBlock
 from qadence.blocks.utils import unroll_block_with_scaling
 from qadence.circuit import QuantumCircuit
 from qadence.engines.differentiable_backend import DifferentiableBackend
+from qadence.measurements.utils import iterate_pauli_decomposition
 from qadence.noise import Noise
-from qadence.operations import H, SDagger, X, Y, Z
-from qadence.parameters import evaluate
 from qadence.utils import Endianness
 
 
-def get_qubit_indices_for_op(pauli_term: tuple, op: PrimitiveBlock | None = None) -> list[int]:
-    """Get qubit indices for the given op in the Pauli term if any."""
-    indices = []
-    blocks = getattr(pauli_term[0], "blocks", None)
-    if blocks is not None:
-        for block in blocks:
-            if op is None:
-                indices.append(block.qubit_support[0])
-            if isinstance(block, type(op)):
-                indices.append(block.qubit_support[0])
-    else:
-        block = pauli_term[0]
-        if op is None:
-            indices.append(block.qubit_support[0])
-        if isinstance(block, type(op)):
-            indices.append(block.qubit_support[0])
-    return indices
-
-
-def rotate(circuit: QuantumCircuit, pauli_term: tuple) -> QuantumCircuit:
-    """Rotate circuit to measurement basis and return the qubit support."""
-    rotations = []
-
-    # Mypy expects concrete types. Although there definitely should be
-    # a better way to pass the operation type.
-    for op, gate in [(X(0), Z), (Y(0), SDagger)]:
-        qubit_indices = get_qubit_indices_for_op(pauli_term, op=op)
-        for index in qubit_indices:
-            rotations.append(gate(index) * H(index))
-    rotated_block = chain(circuit.block, *rotations)
-    return QuantumCircuit(circuit.register, rotated_block)
-
-
-def get_counts(samples: list, support: list) -> list:
-    """Marginalise the probablity mass function to the support."""
-    counts = []
-    for sample in samples:
-        sample_counts = []
-        for k, v in sample.items():
-            sample_counts.append(Counter({"".join([k[i] for i in support]): sample[k]}))
-        reduced_counts = reduce(lambda x, y: x + y, sample_counts)
-        counts.append(reduced_counts)
-    return counts
-
-
-def empirical_average(samples: list, support: list) -> Tensor:
-    """Compute the empirical average."""
-    counters = get_counts(samples, support)
-    expectations = []
-    n_shots = np.sum(list(counters[0].values()))
-    parity = -1
-    for counter in counters:
-        counter_exps = []
-        for bitstring, count in counter.items():
-            counter_exps.append(count * parity ** (np.sum([int(bit) for bit in bitstring])))
-        expectations.append(np.sum(counter_exps) / n_shots)
-    return torch.tensor(expectations)
-
-
-def iterate_pauli_decomposition(
-    circuit: QuantumCircuit,
-    param_values: dict,
-    pauli_decomposition: list,
-    n_shots: int,
-    state: Tensor | None = None,
-    backend: Backend | DifferentiableBackend = PyQBackend(),
-    noise: Noise | None = None,
-    endianness: Endianness = Endianness.BIG,
-) -> Tensor:
-    """Estimate total expectation value by averaging all Pauli terms."""
-
-    estimated_values = []
-
-    for pauli_term in pauli_decomposition:
-        if pauli_term[0].is_identity:
-            estimated_values.append(evaluate(pauli_term[1], as_torch=True))
-        else:
-            # Get the full qubit support for the Pauli term.
-            # Note: duplicates must be kept here to allow for
-            # observables chaining multiple operations on the same qubit
-            # such as `b = chain(Z(0), Z(0))`
-            support = get_qubit_indices_for_op(pauli_term)
-            # Rotate the circuit according to the given observable term.
-            rotated_circuit = rotate(circuit=circuit, pauli_term=pauli_term)
-            # Use the low-level backend API to avoid embedding of parameters
-            # already performed at the higher QuantumModel level.
-            # Therefore, parameters passed here have already been embedded.
-            conv_circ = backend.circuit(rotated_circuit)
-            samples = backend.sample(
-                circuit=conv_circ,
-                param_values=param_values,
-                n_shots=n_shots,
-                state=state,
-                noise=noise,
-                endianness=endianness,
-            )
-            estim_values = empirical_average(samples=samples, support=support)
-            # TODO: support for parametric observables to be tested
-            estimated_values.append(estim_values * evaluate(pauli_term[1]))
-    res = torch.sum(torch.stack(estimated_values), axis=0)
-    # Allow for automatic differentiation.
-    res.requires_grad = True
-    return res
-
-
 def compute_expectation(
     circuit: QuantumCircuit,
     observables: list[AbstractBlock],

qadence/measurements/utils.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+from collections import Counter
+from functools import reduce
+from typing import Dict, List, Tuple
+
+import numpy as np
+import torch
+from sympy import Basic
+from torch import Tensor
+
+from qadence.backend import Backend
+from qadence.backends.pyqtorch import Backend as PyQBackend
+from qadence.blocks import AbstractBlock, PrimitiveBlock, chain
+from qadence.circuit import QuantumCircuit
+from qadence.engines.differentiable_backend import DifferentiableBackend
+from qadence.noise import Noise
+from qadence.operations import H, SDagger, X, Y, Z
+from qadence.parameters import evaluate
+from qadence.utils import Endianness
+
+
+def get_qubit_indices_for_op(
+    pauli_term: Tuple[AbstractBlock, Basic], op: PrimitiveBlock | None = None
+) -> List[int]:
+    """Get qubit indices for the given op in the Pauli term if any.
+
+    Args:
+        pauli_term: Tuple of a Pauli block and a parameter.
+        op: Tuple of Primitive blocks or None.
+
+    Returns: A list of integers representing qubit indices.
+    """
+    blocks = getattr(pauli_term[0], "blocks", None)
+    blocks = blocks if blocks is not None else [pauli_term[0]]
+    indices = [
+        block.qubit_support[0] for block in blocks if (op is None) or (isinstance(block, type(op)))
+    ]
+    return indices
+
+
+def get_counts(samples: List, support: List[int]) -> List[Counter]:
+    """Marginalise the probability mass function to the support.
+
+    Args:
+        samples: List of samples against which expectation value is to be computed.
+        support: A list of integers representing qubit indices.
+
+    Returns: A List[Counter] of bit strings.
+    """
+    return [
+        reduce(
+            lambda x, y: x + y,
+            [Counter({"".join([k[i] for i in support]): sample[k]}) for k, v in sample.items()],
+        )
+        for sample in samples
+    ]
+
+
+def empirical_average(samples: List, support: List[int]) -> Tensor:
+    """Compute the empirical average.
+
+    Args:
+        samples: List of samples against which expectation value is to be computed.
+        support: A list of integers representing qubit indices.
+
+    Returns: A torch.Tensor of the empirical average.
+    """
+    PARITY = -1
+    counters = get_counts(samples, support)
+    n_shots = np.sum(list(counters[0].values()))
+    expectations = []
+    for counter in counters:
+        counter_exps = []
+        for bitstring, count in counter.items():
+            counter_exps.append(count * PARITY ** (np.sum([int(bit) for bit in bitstring])))
+        expectations.append(np.sum(counter_exps) / n_shots)
+    return torch.tensor(expectations)
+
+
+def pauli_z_expectation(
+    pauli_decomposition: List[Tuple[AbstractBlock, Basic]],
+    samples: List[Counter],
+) -> Tensor:
+    """Estimate total expectation value from samples by averaging all Pauli terms.
+
+    Args:
+        pauli_decomposition: A list of Pauli decomposed terms.
+        samples: Samples of bit string as Counters.
+
+    Returns: A torch.Tensor of the total expectation.
+    """
+
+    estimated_values = []
+    for pauli_term in pauli_decomposition:
+        support = get_qubit_indices_for_op(pauli_term)
+        estim_values = empirical_average(samples=samples, support=support)
+        # TODO: support for parametric observables to be tested
+        estimated_values.append(estim_values * evaluate(pauli_term[1]))
+    res = torch.sum(torch.stack(estimated_values), axis=0)
+    return res
+
+
+def rotate(circuit: QuantumCircuit, pauli_term: Tuple[AbstractBlock, Basic]) -> QuantumCircuit:
+    """Rotate circuit to measurement basis and return the qubit support.
+
+    Args:
+        circuit: The circuit that is executed.
+        pauli_term: Tuple of a Pauli term and a parameter.
+
+    Returns: Rotated QuantumCircuit.
+    """
+
+    rotations = []
+
+    for op, gate in [(X(0), Z), (Y(0), SDagger)]:
+        qubit_indices = get_qubit_indices_for_op(pauli_term, op=op)
+        for index in qubit_indices:
+            rotations.append(gate(index) * H(index))
+    rotated_block = chain(circuit.block, *rotations)
+    return QuantumCircuit(circuit.register, rotated_block)
+
+
+def iterate_pauli_decomposition(
+    circuit: QuantumCircuit,
+    param_values: Dict[str, Tensor],
+    pauli_decomposition: List[Tuple[AbstractBlock, Basic]],
+    n_shots: int,
+    state: Tensor | None = None,
+    backend: Backend | DifferentiableBackend = PyQBackend(),
+    noise: Noise | None = None,
+    endianness: Endianness = Endianness.BIG,
+) -> Tensor:
+    """Estimate total expectation value by averaging all Pauli terms.
+
+    Args:
+        circuit: The circuit that is executed.
+        param_values: Parameters of the circuit.
+        pauli_decomposition: A list of Pauli decomposed terms.
+        n_shots: Number of shots to sample.
+        state: Initial state.
+        backend: A backend for circuit execution.
+        noise: A noise model to use.
+        endianness: Endianness of the resulting bit strings.
+
+    Returns: A torch.Tensor of bit strings n_shots x n_qubits.
+    """
+
+    estimated_values = []
+
+    for pauli_term in pauli_decomposition:
+        if pauli_term[0].is_identity:
+            estimated_values.append(evaluate(pauli_term[1], as_torch=True))
+        else:
+            # Get the full qubit support for the Pauli term.
+            # Note: duplicates must be kept here to allow for
+            # observables chaining multiple operations on the same qubit
+            # such as `b = chain(Z(0), Z(0))`
+            support = get_qubit_indices_for_op(pauli_term)
+            # Rotate the circuit according to the given observable term.
+            rotated_circuit = rotate(circuit=circuit, pauli_term=pauli_term)
+            # Use the low-level backend API to avoid embedding of parameters
+            # already performed at the higher QuantumModel level.
+            # Therefore, parameters passed here have already been embedded.
+            conv_circ = backend.circuit(rotated_circuit)
+            samples = backend.sample(
+                circuit=conv_circ,
+                param_values=param_values,
+                n_shots=n_shots,
+                state=state,
+                noise=noise,
+                endianness=endianness,
+            )
+            estim_values = empirical_average(samples=samples, support=support)
+            # TODO: support for parametric observables to be tested
+            estimated_values.append(estim_values * evaluate(pauli_term[1]))
+    res = torch.sum(torch.stack(estimated_values), axis=0)
+    # Allow for automatic differentiation.
+    res.requires_grad = True
+    return res

qadence/ml_tools/data.py

@@ -82,34 +82,34 @@ def to_dataloader(*tensors: Tensor, batch_size: int = 1, infinite: bool = False)
 
 
 @singledispatch
-def data_to_device(xs: Any, device: torch_device) -> Any:
+def data_to_device(xs: Any, *args: Any, **kwargs: Any) -> Any:
     """Utility method to move arbitrary data to 'device'."""
-    raise ValueError(f"Cannot move {type(xs)} to a pytorch device.")
+    raise ValueError(f"Unable to move {type(xs)} with input args: {args} and kwargs: {kwargs}.")
 
 
 @data_to_device.register
-def _(xs: None, device: torch_device) -> None:
+def _(xs: None, *args: Any, **kwargs: Any) -> None:
     return xs
 
 
 @data_to_device.register(Tensor)
-def _(xs: Tensor, device: torch_device) -> Tensor:
-    return xs.to(device=device, non_blocking=True)
+def _(xs: Tensor, *args: Any, **kwargs: Any) -> Tensor:
+    return xs.to(*args, **kwargs)
 
 
 @data_to_device.register(list)
-def _(xs: list, device: torch_device) -> list:
-    return [data_to_device(x, device) for x in xs]
+def _(xs: list, *args: Any, **kwargs: Any) -> list:
+    return [data_to_device(x, *args, **kwargs) for x in xs]
 
 
 @data_to_device.register(dict)
-def _(xs: dict, device: torch_device) -> dict:
-    return {key: data_to_device(val, device) for key, val in xs.items()}
+def _(xs: dict, *args: Any, **kwargs: Any) -> dict:
+    return {key: data_to_device(val, *args, **kwargs) for key, val in xs.items()}
 
 
 @data_to_device.register(DataLoader)
-def _(xs: DataLoader, device: torch_device) -> DataLoader:
-    return DataLoader(data_to_device(xs.dataset, device))
+def _(xs: DataLoader, *args: Any, **kwargs: Any) -> DataLoader:
+    return DataLoader(data_to_device(xs.dataset, *args, **kwargs))
 
 
 @data_to_device.register(DictDataLoader)

qadence/ml_tools/models.py

@@ -286,15 +286,15 @@ class TransformedModule(torch.nn.Module):
             output_shifting=torch.tensor(d["_output_shifting"]),
         )
 
-    def to(self, device: torch.device) -> TransformedModule:
+    def to(self, *args: Any, **kwargs: Any) -> TransformedModule:
         try:
-            self.model = self.model.to(device)
-            self._input_scaling = self._input_scaling.to(device)
-            self._input_shifting = self._input_shifting.to(device)
-            self._output_scaling = self._output_scaling.to(device)
-            self._output_shifting = self._output_shifting.to(device)
+            self.model = self.model.to(*args, **kwargs)
+            self._input_scaling = self._input_scaling.to(*args, **kwargs)
+            self._input_shifting = self._input_shifting.to(*args, **kwargs)
+            self._output_scaling = self._output_scaling.to(*args, **kwargs)
+            self._output_shifting = self._output_shifting.to(*args, **kwargs)
 
-            logger.debug(f"Moved {self} to device {device}.")
+            logger.debug(f"Moved {self} to {args}, {kwargs}.")
         except Exception as e:
-            logger.warning(f"Unable to move {self} to device {device} due to {e}.")
+            logger.warning(f"Unable to move {self} to {args}, {kwargs} due to {e}.")
         return self

qadence/ml_tools/optimize_step.py

@@ -15,6 +15,7 @@ def optimize_step(
     loss_fn: Callable,
     xs: dict | list | torch.Tensor | None,
     device: torch.device = None,
+    dtype: torch.dtype = None,
 ) -> tuple[torch.Tensor | float, dict | None]:
     """Default Torch optimize step with closure.
 
@@ -35,7 +36,7 @@ def optimize_step(
     """
 
     loss, metrics = None, {}
-    xs_to_device = data_to_device(xs, device)
+    xs_to_device = data_to_device(xs, device=device, dtype=dtype)
 
     def closure() -> Any:
         # NOTE: We need the nonlocal as we can't return a metric dict and

qadence/ml_tools/train_grad.py

@@ -4,6 +4,7 @@ from typing import Callable, Union
 
 from rich.progress import BarColumn, Progress, TaskProgressColumn, TextColumn, TimeRemainingColumn
 from torch import device as torch_device
+from torch import dtype as torch_dtype
 from torch.nn import DataParallel, Module
 from torch.optim import Optimizer
 from torch.utils.data import DataLoader
@@ -28,6 +29,7 @@ def train(
     device: torch_device = None,
     optimize_step: Callable = optimize_step,
     write_tensorboard: Callable = write_tensorboard,
+    dtype: torch_dtype = None,
 ) -> tuple[Module, Optimizer]:
     """Runs the training loop with gradient-based optimizer.
 
@@ -111,9 +113,9 @@ def train(
 
     # Move model to device before optimizer is loaded
     if isinstance(model, DataParallel):
-        model = model.module.to(device)
+        model = model.module.to(device=device, dtype=dtype)
     else:
-        model = model.to(device)
+        model = model.to(device=device, dtype=dtype)
     # load available checkpoint
     init_iter = 0
     if config.folder:

qadence/models/quantum_model.py

@@ -341,19 +341,24 @@ class QuantumModel(nn.Module):
         params = self.embedding_fn(self._params, values)
         return self.backend.assign_parameters(self._circuit, params)
 
-    def to(self, device: torch.device) -> QuantumModel:
+    def to(self, *args: Any, **kwargs: Any) -> QuantumModel:
         try:
             if isinstance(self._circuit.native, torch.nn.Module):
                 # Backends which are not torch-based cannot be moved to 'device'
-                self._params = self._params.to(device)
-                self._circuit.native = self._circuit.native.to(device)
+                self._circuit.native = self._circuit.native.to(*args, **kwargs)
                 if self._observable is not None:
                     if isinstance(self._observable, ConvertedObservable):
-                        self._observable.native = self._observable.native.to(device)
+                        self._observable.native = self._observable.native.to(*args, **kwargs)
                     elif isinstance(self._observable, list):
                         for obs in self._observable:
-                            obs.native = obs.native.to(device)
-                logger.debug(f"Moved {self} to device {device}.")
+                            obs.native = obs.native.to(*args, **kwargs)
+                self._params = self._params.to(
+                    device=self._circuit.native.device,
+                    dtype=torch.float64
+                    if self._circuit.native.dtype == torch.cdouble
+                    else torch.float32,
+                )
+                logger.debug(f"Moved {self} to {args}, {kwargs}.")
         except Exception as e:
-            logger.warning(f"Unable to move {self} to device {device} due to {e}.")
+            logger.warning(f"Unable to move {self} to {args}, {kwargs} due to {e}.")
         return self

qadence/operations/analog.py

@@ -84,6 +84,7 @@ def AnalogInteraction(
     return InteractionBlock(parameters=ps, qubit_support=q, add_pattern=add_pattern)
 
 
+# FIXME: Remove in v1.5.0
 def wait(
     duration: TNumber | sympy.Basic,
     qubit_support: str | QubitSupport | tuple = "global",

{qadence-1.4.0.dist-info → qadence-1.5.0.dist-info}/METADATA

@@ -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.dist-info → qadence-1.5.0.dist-info}/RECORD

@@ -1,11 +1,12 @@
-qadence/__init__.py,sha256=XxVbw_UToWu0PUKxOg2C42lYT22cgQH_ysy8PRGT0q0,1707
+qadence/__init__.py,sha256=-UKQQ_dYiaa7viishl2baAbxS82eS6dAoCnq_CLSmao,1708
 qadence/backend.py,sha256=5sfXUTRts_13v6lajq1Wvy3u_eOCOeIYnTiaZV_NGFQ,15493
 qadence/circuit.py,sha256=EGBPRRWlK-mcXaaAhJnp-hxVWQ8NxngGKbvhPqrEeKM,6892
 qadence/decompose.py,sha256=_L0hI3SbYErXEDp-aXFeNk0JR9ffJ_JD_EnRJbJKT20,5230
 qadence/divergences.py,sha256=JhpELhWSnuDvQxa9hJp_DE3EQg2Ban-Ta0mHZ_fVrHg,1832
 qadence/execution.py,sha256=5_P5OSatiwEAu7aAkCLau5VcmtIZiC3VFIj5YYdwAbY,9287
-qadence/extensions.py,sha256=KVuAFLmytpy7TdSCRTHGS1s-OdkgiJmoidtzt0lpEmM,4548
+qadence/extensions.py,sha256=CgaUR3amh80g_zwxGaAjFvgI-JT_pmDiUMzzzVQP7zc,4582
 qadence/finitediff.py,sha256=TijuaWUbX9VlbLyMYco6HkK9eCoRTVnKug4Ekd6mlTI,1592
+qadence/libs.py,sha256=HetkKO8TCTlVCViQdVQJvxwBekrhd-y_iMox4UJMY1M,410
 qadence/logger.py,sha256=mdTr52nL30ipPRwp11nIHKLEoB3hqs7J-Mric5KVfyM,912
 qadence/overlap.py,sha256=3vsg0HLOO3X8LiVgvjSc5s-cs8Di4TpEA657LWZ5HEY,17294
 qadence/parameters.py,sha256=svZ3L-Z4pzm2PkPDIlb-DWkwGOQLAm1eECCtu7nd3W0,12334
@@ -28,7 +29,7 @@ qadence/backends/adjoint.py,sha256=C2BdLUs2rdV9TiErkVlE0hoeLx_nK7up9mzIO-0vB2g,6
 qadence/backends/api.py,sha256=6PoK4ydhi2tj9w0ePMQl1G4kEFROoWe3lrkrtQwWxkc,3224
 qadence/backends/gpsr.py,sha256=227h5KPI_KStrwfP5zuwkzOqviRZmqa7ijIIhhawwPM,4341
 qadence/backends/jax_utils.py,sha256=VfKhqCKknHDWZO21UFipWH_Lkiq175Z5GkP49gWjbyw,5038
-qadence/backends/utils.py,sha256=q8vVk5GOZgbaijRdKgPGPuHsoXBkQfzX0cr9rf17W2U,6460
+qadence/backends/utils.py,sha256=hnV9AXztMvAPcO8mv9UhdGMbS9albiMQBxlYPgLrD68,6490
 qadence/backends/braket/__init__.py,sha256=eruyDZKMqkh1LE7eJ980vcrLJbia35uUX6krAP78clI,121
 qadence/backends/braket/backend.py,sha256=PLW-NCNp_RqAQy149ASEOOvwPrLsFGjCKWuEmTnS5Qg,8730
 qadence/backends/braket/config.py,sha256=b9aIdma0DRwC_3A6xUSLdXMCZe6z6kDcAgkp6MxcXIk,603
@@ -38,18 +39,18 @@ qadence/backends/horqrux/backend.py,sha256=qdThkUXbhDrsD1lAio2SFsxdYATxLVXoNsuXN
 qadence/backends/horqrux/config.py,sha256=fPWFag1hmRhqj0T-fJOx5x8_C5UEZUXpdUnpOgX0Jpc,901
 qadence/backends/horqrux/convert_ops.py,sha256=nzfYF0yjB7zwaHCEXWZUUYDfz38Yi22xF2zDRFaOwR0,8564
 qadence/backends/pulser/__init__.py,sha256=capQ-eHqwtOeLf4mWsI0BIseAHhiLGie5cFD4-iVhUo,116
-qadence/backends/pulser/backend.py,sha256=vd2fycEoGpYQsYJkpvx1abpy4tnyzKvoo2dReol9VvI,13868
+qadence/backends/pulser/backend.py,sha256=3p9cB5QN60nzqhWvdLZol0t66PugaWqvWHdDEXgGRwM,13868
 qadence/backends/pulser/channels.py,sha256=ZF0yEXUFHAmi3IdeXjzdTNGR5NzaRRFTiUpUGVg2sO4,329
 qadence/backends/pulser/cloud.py,sha256=0uUluvbFV9sOuCPraE-9uiVtC3Q8QaDY1IJMDi8grDM,2057
-qadence/backends/pulser/config.py,sha256=DdboScn5TrtVwCcsHgZjNCQmWy46aSrf44FhOTJRxaw,3038
+qadence/backends/pulser/config.py,sha256=1qu_GhGTGcCpFoKctGt_IhKOKWiMcJIL2vHTFJg9I3E,3122
 qadence/backends/pulser/convert_ops.py,sha256=0HGWe5kIwI1ZALHf2j68B8aBOhwFNZV-mDy1_6zsF5g,1227
 qadence/backends/pulser/devices.py,sha256=DermLZNfmCB3SqteKVW4uhg4jp6ya1G6ptnXbBnJogI,2448
 qadence/backends/pulser/pulses.py,sha256=DopdEZ8eeWK7wZxqJTBhqY0w5bEXu6fVK7rnZOb50ns,11893
 qadence/backends/pulser/waveforms.py,sha256=0uz95b7rUaUUtN0tuHBZmJ0H6UBmfHST_59ozwsRCzg,2227
 qadence/backends/pyqtorch/__init__.py,sha256=0OdVy6cq0oQggV48LO1WXdaZuSkDkz7OYNEPIkNAmfk,140
-qadence/backends/pyqtorch/backend.py,sha256=CcbWWKQfee7cSz19xiw9g_ZyFsLJ1KmriIjTReSSb_k,9584
+qadence/backends/pyqtorch/backend.py,sha256=hNo9nKxfJ3rFDEPjZOhfmbKUUVsNzTl0aRh9sgeKlqc,9763
 qadence/backends/pyqtorch/config.py,sha256=f5BjWehCqm9do2OahNWrv2w55y3orkw0Wj2f6flwRaU,1907
-qadence/backends/pyqtorch/convert_ops.py,sha256=SEOoVpbznlVDmeb1ZPGmw-WO0sOUNj1OgQPSjx5eAok,16928
+qadence/backends/pyqtorch/convert_ops.py,sha256=By_p1-Oem8MhHYP8jx5qdut9lhDWN0xc4B9YaP0MSxA,17512
 qadence/blocks/__init__.py,sha256=H6jEA_CptkE-eoB4UfSbUiDszbxxhZwECV_TgoZWXoU,960
 qadence/blocks/abstract.py,sha256=35RcVlNvD1BmBoJ8bbYJ3LrdU72wixt9ZmTbCtEwNus,11796
 qadence/blocks/analog.py,sha256=ymnnlSVoW1XL05ZvnnHCqRTHuOXIEY_7E9M0PNKJZy4,10812
@@ -61,8 +62,8 @@ qadence/blocks/matrix.py,sha256=XQI6D4CWhCf3j-hvA0jRKOgprs0RA6su7OythCoH6Ls,3785
 qadence/blocks/primitive.py,sha256=fC5ItpA-52LOiGPT1ERM4RshP6PQlkxlgR9p2J0Rgz4,16631
 qadence/blocks/utils.py,sha256=lNWNCGpM4q_KilaiSGj1u8XJrilR5PdV92KZHZt6MEQ,16358
 qadence/constructors/__init__.py,sha256=d4ndrNCTCDS_kUYeigGFQOUFSAMaPKL--_FcdZy7eQo,1152
-qadence/constructors/ansatze.py,sha256=PWC6ILioReF6vlS22UevCSLIHGR1HMQpUVPlCyZ4rNY,12026
-qadence/constructors/feature_maps.py,sha256=WEUPdHY-v_dftWhb8sziL85FJ_qiBGGhM7MMnfi1qEA,11462
+qadence/constructors/ansatze.py,sha256=8JoYvv7nYPgygIZpB227Zx7csPxg8SIR1tnYl0SzAb4,12170
+qadence/constructors/feature_maps.py,sha256=Z8h_UDpG9wtpt72htZK6c0mV0YNwzSsH4rv2A_vRhNw,11566
 qadence/constructors/hamiltonians.py,sha256=rEeMkMepQE5xe-siAfhIlgUE2aIGwk8SUdPLNTPHUnU,8860
 qadence/constructors/iia.py,sha256=z-4AA9Oj-j2oZ0QDkLYNk4duS3UHY_98Qwt9VO_ZDDU,7001
 qadence/constructors/qft.py,sha256=2LpgQ-z1HUxB3rqHzYsbjqpdU63gyuuaUVCbNEFbjo8,7688
@@ -88,37 +89,39 @@ qadence/engines/jax/differentiable_backend.py,sha256=W5rDA8wb-ECnFWoLj4dVugF9v1l
 qadence/engines/jax/differentiable_expectation.py,sha256=XBYHT1XKRuZfKxTcNy8KJpSDPt-2PR4ZCanImCPI9OI,3677
 qadence/engines/torch/__init__.py,sha256=iZFdD32ot0B0CVyC-f5dVViOBnqoalxa6M9Lj4WQuPE,160
 qadence/engines/torch/differentiable_backend.py,sha256=AWthwvKE8pCOih4dZ3tXxQX4W1ps9mBcvo7n4V9V24Y,3553
-qadence/engines/torch/differentiable_expectation.py,sha256=EaGcDvdF_lDKuD2qp8Uv1naXLdfURhPdcq_weCnR9p8,15382
+qadence/engines/torch/differentiable_expectation.py,sha256=w_9infZDQRRU7sII8V0aklXrR73IOU0Bjf8C5neJLIY,9161
 qadence/exceptions/__init__.py,sha256=BU6vWrI9mshzr1aTPm1Ticr_o_42GjTrWI4OZXhThsI,203
 qadence/exceptions/exceptions.py,sha256=4j_VJpx2sZ2Mir5BJUWu4nwb131FY1ygO4q8-XlyfRc,190
 qadence/measurements/__init__.py,sha256=RIjG9tVJMqhNzyj7maZI250Um0KgHl2PizDcKJag-JU,161
-qadence/measurements/protocols.py,sha256=815fqd0kfFpiD4W4QFN0uumucSDBUG3xwVx60JjADOQ,1161
+qadence/measurements/protocols.py,sha256=mD50R9yPs5bIYH7Efd0BsR0503apiyrsZydi_Q6BJag,1161
+qadence/measurements/samples.py,sha256=AVvszDwgfKnZ_ooATyTA3270vGeg1V3WO94jsfrTk-8,1200
 qadence/measurements/shadow.py,sha256=ROMQFtV9LaUB2Q6pjcBY1qDAYjDUGq1FUFmI8WXTd0g,12550
-qadence/measurements/tomography.py,sha256=i0IBJnDyeSFUvgzREwtKCByhHD6RNcLfjzdY-sTKuEE,7023
+qadence/measurements/tomography.py,sha256=8fzXhYOu_DaMiUoZzLvpP03WhuwlZ3ldkWepLUHjWqM,2665
+qadence/measurements/utils.py,sha256=CJmnSobzdeR4T4FuEpad7d-BSJ9W-wTaU9hRbveB6kY,6534
 qadence/mitigations/__init__.py,sha256=RzaxYJftePFMloGhBVSixZ8fSe-ps_Jc-EyPm6xz-bs,159
 qadence/mitigations/analog_zne.py,sha256=g0QkjSdF-N9Dv2N8Oza4sylnjUMid5ea-4NCT9Tcm3Y,7768
 qadence/mitigations/protocols.py,sha256=Jq9MyLujfTyWmc7XVUGYVRUkJT1MmZw-GgmWpVjmX2Y,1608
 qadence/mitigations/readout.py,sha256=HPfYmdjRlieUdOBMZTghFK4DRWfveM4KkDkEI0bMI0E,6262
 qadence/ml_tools/__init__.py,sha256=_H5A_BWZRZVGoJszb9s8XRJnLnJxUNfYjuT9HT2yASo,786
 qadence/ml_tools/config.py,sha256=X8dHyjq4D9-ITjs7UQo0vjJTcHkpbZC0gChH5eEN2G8,2356
-qadence/ml_tools/data.py,sha256=KvEGeN6AaCXIhLcSO7WZUMNUhfscmI_V3KR40mmT4Ng,4215
-qadence/ml_tools/models.py,sha256=ZCIzxJvwQigL4uBXkR8EYLasclLVRDdDD4XT9IgzNZ4,11684
-qadence/ml_tools/optimize_step.py,sha256=UtyF68CJC-bYP5yEovu5EhWe9XpSjwFUtC6NQjkaUq8,1749
+qadence/ml_tools/data.py,sha256=8ZUFjhQSp94w7icX7RzM2J39Yo7P_T-AgjcThBc8miI,4283
+qadence/ml_tools/models.py,sha256=biUWnqXKmGMJfT-QObJ-cQ6770YIfOTz-o28EKPkM3Q,11736
+qadence/ml_tools/optimize_step.py,sha256=ATXWmAqybJVK3QmAaDqVXB5mxjTo2MIi_e0a5WSPFpc,1800
 qadence/ml_tools/parameters.py,sha256=gew2Kq_5-RgRpaTvs8eauVhgo0sTqqDQEV6WHFEiLGM,1301
 qadence/ml_tools/printing.py,sha256=kwwD9yLVqezaqWX5OAsXr8GLdJUnGrY-t5SnoKHtl9g,707
 qadence/ml_tools/saveload.py,sha256=Xi3o2bMsYueFPxrU6AXgDB0MHSev8gKLVhdqecPDBt8,4663
 qadence/ml_tools/tensors.py,sha256=xZ9ZRzOqEaMgLUGWQf1najDmL6iLuN1ojCGVFs1Tm94,1337
-qadence/ml_tools/train_grad.py,sha256=ydZjbGCCe1W31AOUp7D7ya4wdREV1s44fgcGaM-tG1k,7289
+qadence/ml_tools/train_grad.py,sha256=b_FxOkK3QoLAOwSowjkkMIjlBEDjoLcjeo3Vk_RHhkc,7399
 qadence/ml_tools/train_no_grad.py,sha256=erwus-pUOg8q6WgoQsDW6MeH80wlRPBh69W1ZMHKoL8,4714
 qadence/ml_tools/utils.py,sha256=_GZSN5Flk1nRFutkXih397Q3cWKdX0UP8c9CRXpUL7c,1654
 qadence/models/__init__.py,sha256=0nZzAC2TGr8Yuf40-R7m2cSsr_BlNq_GsMOwaOYZLqM,193
 qadence/models/qnn.py,sha256=gc_iC1GG6WJbeLaln9jy4yYp9fY0p8fkpKkKJpXJ3ck,10397
-qadence/models/quantum_model.py,sha256=6fSq9Oh6JstA12GMPfTyRFK9r0TkLHbLcJd1pQ3XkQk,13859
+qadence/models/quantum_model.py,sha256=ucExUBPBYWrC7mLF4SQbvHqjdXmkEi7-wIdXqpfaGew,14107
 qadence/noise/__init__.py,sha256=r0nR8uEZeB1M9pI2UisjWq0bjw50fPFfVGzIMev923g,147
 qadence/noise/protocols.py,sha256=-aZ06JvMnpxCeT5v5lI_RNPOLbb9Ju1Pi1AB6uAXxVE,1653
 qadence/noise/readout.py,sha256=BqBIZbPXWqZaKi6EpBSpXXQ9NhQXdQ-YL6ZmwbSjgfE,6736
 qadence/operations/__init__.py,sha256=6D2yNOJ78BgFBZpHpHYMUDzU2R1HovB-mwGgNq-Uwwk,1944
-qadence/operations/analog.py,sha256=h2wx4DqRvvhD9DwmAyxHorGuZvpuoEJx_8nmgJ0yK-w,7756
+qadence/operations/analog.py,sha256=FkwAtsL7M6EPk5_shCXqHXzJDr0MY3_mA9R5LbZKu8w,7782
 qadence/operations/control_ops.py,sha256=6PVTFELkbvfvgczPbKw0QDin_CpDFzganIdJFaQJHjY,9492
 qadence/operations/ham_evo.py,sha256=EhBz5ZgoWsP4PhR8DLvTdje8bl17oEBipBdSkpCTWV4,7400
 qadence/operations/parametric.py,sha256=RVRTlKOd2_bKXwNorO3TYhZ88AFaEgGkxKYKzT_RuIA,4919
@@ -131,7 +134,7 @@ qadence/transpile/digitalize.py,sha256=iWRwYAYQsD2INHj0HNbGJriv_3fRCuBW1nDBrwtKS
 qadence/transpile/flatten.py,sha256=EdhSG5WyF56nbnxINNLqrHgY84MRM1YFjT3fR4aph5Q,3427
 qadence/transpile/invert.py,sha256=KAefHTG2AWr39aengVhXrzCtJPhrZC-ZnL6vYvmbnY0,4867
 qadence/transpile/transpile.py,sha256=6MRRkk1OS279L1fwUQjazA6qlfpbd-T_EJMKT8hAhOU,2721
-qadence-1.4.0.dist-info/METADATA,sha256=Uu4ENgsHtoKV_J3thoHJYKDJMy7eNtvJfPFtZB1goSk,8210
-qadence-1.4.0.dist-info/WHEEL,sha256=TJPnKdtrSue7xZ_AVGkp9YXcvDrobsjBds1du3Nx6dc,87
-qadence-1.4.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-qadence-1.4.0.dist-info/RECORD,,
+qadence-1.5.0.dist-info/METADATA,sha256=NgAwZRUkuLfgnTuo46gGAW1Pj8EmPCAvvPr3FbPi1Ww,8997
+qadence-1.5.0.dist-info/WHEEL,sha256=uNdcs2TADwSd5pVaP0Z_kcjcvvTUklh2S7bxZMF8Uj0,87
+qadence-1.5.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+qadence-1.5.0.dist-info/RECORD,,

{qadence-1.4.0.dist-info → qadence-1.5.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.21.1
+Generator: hatchling 1.22.4
 Root-Is-Purelib: true
 Tag: py3-none-any