qadence 1.11.2__py3-none-any.whl → 1.11.3__py3-none-any.whl

qadence/backend.py

@@ -25,7 +25,14 @@ from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
 from qadence.noise import NoiseHandler
 from qadence.parameters import stringify
-from qadence.types import ArrayLike, BackendName, DiffMode, Endianness, Engine, ParamDictType
+from qadence.types import (
+    ArrayLike,
+    BackendName,
+    DiffMode,
+    Endianness,
+    Engine,
+    ParamDictType,
+)
 
 logger = getLogger(__name__)
 
@@ -215,7 +222,7 @@ class Backend(ABC):
         if observable is not None:
             observable = observable if isinstance(observable, list) else [observable]
             conv_obs = []
-            obs_embedding_fn_list = []
+            obs_embedding_fns = []
 
             for obs in observable:
                 obs = check_observable(obs)
@@ -224,13 +231,18 @@ class Backend(ABC):
                     c_obs.abstract, self.config._use_gate_params, self.engine
                 )
                 params.update(obs_params)
-                obs_embedding_fn_list.append(obs_embedding_fn)
+                obs_embedding_fns.append(obs_embedding_fn)
                 conv_obs.append(c_obs)
 
             def embedding_fn_dict(a: dict, b: dict) -> dict:
-                embedding_dict = circ_embedding_fn(a, b)
-                for o in obs_embedding_fn_list:
-                    embedding_dict.update(o(a, b))
+                if "circuit" in b or "observables" in b:
+                    embedding_dict = {"circuit": circ_embedding_fn(a, b), "observables": dict()}
+                    for obs_embedding_fn in obs_embedding_fns:
+                        embedding_dict["observables"].update(obs_embedding_fn(a, b))
+                else:
+                    embedding_dict = circ_embedding_fn(a, b)
+                    for obs_embedding_fn in obs_embedding_fns:
+                        embedding_dict.update(obs_embedding_fn(a, b))
                 return embedding_dict
 
             return Converted(conv_circ, conv_obs, embedding_fn_dict, params)
@@ -316,7 +328,11 @@ class Backend(ABC):
         raise NotImplementedError
 
     @abstractmethod
-    def assign_parameters(self, circuit: ConvertedCircuit, param_values: dict[str, Tensor]) -> Any:
+    def assign_parameters(
+        self,
+        circuit: ConvertedCircuit,
+        param_values: dict[str, Tensor] | dict[str, dict[str, Tensor]],
+    ) -> Any:
         raise NotImplementedError
 
     @staticmethod

qadence/backends/horqrux/backend.py

@@ -134,19 +134,32 @@ class Backend(BackendInterface):
         Returns:
             A jax.Array of shape (batch_size, n_observables)
         """
-        observable = observable if isinstance(observable, list) else [observable]
-        batch_size = max([arr.size for arr in param_values.values()])
+        observables = observable if isinstance(observable, list) else [observable]
+        if "observables" in param_values or "circuit" in param_values:
+            raise NotImplementedError("The Horqrux backend does not support separated parameters.")
+        else:
+            merged_params = param_values
+            batch_size = max([arr.size for arr in param_values.values()])  # type: ignore[union-attr]
         n_obs = len(observable)
 
         def _expectation(params: ParamDictType) -> ArrayLike:
+            param_circuits = params["circuit"] if "circuit" in params else params
+            param_observables = params["observables"] if "observables" in params else params
             out_state = self.run(
-                circuit, params, state, endianness, horqify_state=True, unhorqify_state=False
+                circuit,
+                param_circuits,
+                state,
+                endianness,
+                horqify_state=True,
+                unhorqify_state=False,
+            )
+            return jnp.array(
+                [observable.native(out_state, param_observables) for observable in observables]
             )
-            return jnp.array([o.native(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)
+            expvals = jax.vmap(_expectation, in_axes=({k: 0 for k in merged_params.keys()},))(
+                uniform_batchsize(merged_params)
             )
         else:
             expvals = _expectation(param_values)

qadence/backends/jax_utils.py

@@ -19,6 +19,7 @@ from qadence.blocks import (
 )
 from qadence.blocks.block_to_tensor import _gate_parameters
 from qadence.types import Endianness, ParamDictType
+from qadence.utils import merge_separate_params
 
 
 def jarr_to_tensor(arr: Array, dtype: Any = cdouble) -> Tensor:
@@ -52,9 +53,11 @@ def horqify(state: Array) -> Array:
 
 
 def uniform_batchsize(param_values: ParamDictType) -> ParamDictType:
-    max_batch_size = max(p.size for p in param_values.values())
+    if "observables" in param_values or "circuit" in param_values:
+        param_values = merge_separate_params(param_values)
+    max_batch_size = max(p.size for p in param_values.values())  # type: ignore[union-attr]
     batched_values = {
-        k: (v if v.size == max_batch_size else v.repeat(max_batch_size))
+        k: (v if v.size == max_batch_size else v.repeat(max_batch_size))  # type: ignore[union-attr]
         for k, v in param_values.items()
     }
     return batched_values

qadence/backends/pulser/backend.py

@@ -28,7 +28,7 @@ from qadence.noise import NoiseHandler
 from qadence.overlap import overlap_exact
 from qadence.register import Register
 from qadence.transpile import transpile
-from qadence.types import BackendName, DeviceType, Endianness, Engine, NoiseProtocol
+from qadence.types import BackendName, DeviceType, Endianness, Engine, NoiseProtocol, ParamDictType
 
 from .channels import GLOBAL_CHANNEL, LOCAL_CHANNEL
 from .cloud import get_client
@@ -183,7 +183,7 @@ class Backend(BackendInterface):
     def run(
         self,
         circuit: ConvertedCircuit,
-        param_values: dict[str, Tensor] = {},
+        param_values: ParamDictType = {},
         state: Tensor | None = None,
         endianness: Endianness = Endianness.BIG,
         noise: NoiseHandler | None = None,
@@ -235,7 +235,7 @@ class Backend(BackendInterface):
         self,
         circuit: ConvertedCircuit,
         noise: NoiseHandler,
-        param_values: dict[str, Tensor] = dict(),
+        param_values: ParamDictType = dict(),
         state: Tensor | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> Tensor:
@@ -284,7 +284,7 @@ class Backend(BackendInterface):
     def sample(
         self,
         circuit: ConvertedCircuit,
-        param_values: dict[str, Tensor] = {},
+        param_values: ParamDictType = {},
         n_shots: int = 1,
         state: Tensor | None = None,
         noise: NoiseHandler | None = None,
@@ -322,7 +322,7 @@ class Backend(BackendInterface):
         self,
         circuit: ConvertedCircuit,
         observable: list[ConvertedObservable] | ConvertedObservable,
-        param_values: dict[str, Tensor] = {},
+        param_values: ParamDictType = {},
         state: Tensor | None = None,
         measurement: Measurements | None = None,
         noise: NoiseHandler | None = None,
@@ -330,14 +330,19 @@ class Backend(BackendInterface):
         endianness: Endianness = Endianness.BIG,
     ) -> Tensor:
         observable = observable if isinstance(observable, list) else [observable]
+        param_circuit = param_values["circuit"] if "circuit" in param_values else param_values
+        param_observables = (
+            param_values["observables"] if "observables" in param_values else param_values
+        )
         if mitigation is None:
             if noise is None:
                 state = self.run(
-                    circuit, param_values=param_values, state=state, endianness=endianness
+                    circuit, param_values=param_circuit, state=state, endianness=endianness
                 )
                 support = sorted(list(circuit.abstract.register.support))
                 res_list = [
-                    obs.native(state, param_values, qubit_support=support) for obs in observable
+                    obs.native(state, param_observables, qubit_support=support)
+                    for obs in observable
                 ]
                 res = torch.transpose(torch.stack(res_list), 0, 1)
                 res = res if len(res.shape) > 0 else res.reshape(1)
@@ -345,7 +350,7 @@ class Backend(BackendInterface):
             elif noise is not None:
                 dms = self.run(
                     circuit=circuit,
-                    param_values=param_values,
+                    param_values=param_circuit,
                     state=state,
                     endianness=endianness,
                     noise=noise,
@@ -353,7 +358,9 @@ class Backend(BackendInterface):
                 support = sorted(list(circuit.abstract.register.support))
                 res_list = [
                     [
-                        obs.native(dm.squeeze(), param_values, qubit_support=support, noise=noise)
+                        obs.native(
+                            dm.squeeze(), param_observables, qubit_support=support, noise=noise
+                        )
                         for dm in dms
                     ]
                     for obs in observable

qadence/backends/pyqtorch/backend.py

@@ -31,7 +31,7 @@ from qadence.transpile import (
     set_noise,
     transpile,
 )
-from qadence.types import BackendName, Endianness, Engine
+from qadence.types import BackendName, Endianness, Engine, ParamDictType
 
 from .config import Configuration, default_passes
 from .convert_ops import convert_block, convert_readout_noise
@@ -182,16 +182,21 @@ class Backend(BackendInterface):
         self,
         circuit: ConvertedCircuit,
         observable: list[ConvertedObservable] | ConvertedObservable,
-        param_values: dict[str, Tensor] = {},
+        param_values: ParamDictType = {},
         state: Tensor | None = None,
         measurement: Measurements | None = None,
         noise: NoiseHandler | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> Tensor:
         set_block_and_readout_noises(circuit, noise, self.config)
+        param_circuit = param_values["circuit"] if "circuit" in param_values else param_values
+        param_observables = (
+            param_values["observables"] if "observables" in param_values else param_values
+        )
+
         state = self.run(
             circuit,
-            param_values=param_values,
+            param_values=param_circuit,
             state=state,
             endianness=endianness,
             pyqify_state=True,
@@ -200,7 +205,7 @@ class Backend(BackendInterface):
         )
         observable = observable if isinstance(observable, list) else [observable]
         _expectation = torch.hstack(
-            [obs.native.expectation(state, param_values).reshape(-1, 1) for obs in observable]
+            [obs.native.expectation(state, param_observables).reshape(-1, 1) for obs in observable]
         )
         return _expectation
 
@@ -208,7 +213,7 @@ class Backend(BackendInterface):
         self,
         circuit: ConvertedCircuit,
         observable: list[ConvertedObservable] | ConvertedObservable,
-        param_values: dict[str, Tensor] = {},
+        param_values: ParamDictType = {},
         state: Tensor | None = None,
         measurement: Measurements | None = None,
         noise: NoiseHandler | None = None,
@@ -230,9 +235,18 @@ class Backend(BackendInterface):
 
         list_expvals = []
         observables = observable if isinstance(observable, list) else [observable]
-        for vals in to_list_of_dicts(param_values):
-            wf = self.run(circuit, vals, state, endianness, pyqify_state=True, unpyqify_state=False)
-            exs = torch.cat([obs.native.expectation(wf, vals) for obs in observables], 0)
+        param_circuits = param_values["circuit"] if "circuit" in param_values else param_values
+        param_observables = (
+            param_values["observables"] if "observables" in param_values else param_values
+        )
+
+        for vals_circ, vals_obs in zip(
+            to_list_of_dicts(param_circuits), to_list_of_dicts(param_observables)
+        ):
+            wf = self.run(
+                circuit, vals_circ, state, endianness, pyqify_state=True, unpyqify_state=False
+            )
+            exs = torch.cat([obs.native.expectation(wf, vals_obs) for obs in observables], 0)
             list_expvals.append(exs)
 
         batch_expvals = torch.vstack(list_expvals)
@@ -242,7 +256,7 @@ class Backend(BackendInterface):
         self,
         circuit: ConvertedCircuit,
         observable: list[ConvertedObservable] | ConvertedObservable,
-        param_values: dict[str, Tensor] = {},
+        param_values: ParamDictType = {},
         state: Tensor | None = None,
         measurement: Measurements | None = None,
         noise: NoiseHandler | None = None,
@@ -269,7 +283,7 @@ class Backend(BackendInterface):
     def sample(
         self,
         circuit: ConvertedCircuit,
-        param_values: dict[str, Tensor] = {},
+        param_values: ParamDictType = {},
         n_shots: int = 1,
         state: Tensor | None = None,
         noise: NoiseHandler | None = None,
@@ -295,7 +309,7 @@ class Backend(BackendInterface):
             samples = apply_mitigation(noise=noise, mitigation=mitigation, samples=samples)
         return samples
 
-    def assign_parameters(self, circuit: ConvertedCircuit, param_values: dict[str, Tensor]) -> Any:
+    def assign_parameters(self, circuit: ConvertedCircuit, param_values: ParamDictType) -> Any:
         raise NotImplementedError
 
     @staticmethod

qadence/blocks/embedding.py

@@ -16,7 +16,14 @@ from qadence.blocks.utils import (
     uuid_to_expression,
 )
 from qadence.parameters import evaluate, make_differentiable, stringify
-from qadence.types import ArrayLike, DifferentiableExpression, Engine, ParamDictType, TNumber
+from qadence.types import (
+    ArrayLike,
+    DifferentiableExpression,
+    Engine,
+    ParamDictType,
+    TNumber,
+)
+from qadence.utils import merge_separate_params
 
 
 def _concretize_parameter(engine: Engine) -> Callable:
@@ -110,6 +117,8 @@ def embedding(
 
     def embedding_fn(params: ParamDictType, inputs: ParamDictType) -> ParamDictType:
         embedded_params: dict[sympy.Expr, ArrayLike] = {}
+        if "circuit" in inputs or "observables" in inputs:
+            inputs = merge_separate_params(inputs)
         for expr, fn in embeddings.items():
             angle: ArrayLike
             values = {}

qadence/blocks/utils.py

@@ -7,6 +7,7 @@ from logging import getLogger
 from typing import Generator, List, Type, TypeVar, Union, get_args
 
 from sympy import Array, Basic, Expr
+import torch
 from torch import Tensor
 
 from qadence.blocks import (
@@ -292,31 +293,39 @@ def uuid_to_eigen(
 
     result = {}
     for uuid, b in uuid_to_block(block).items():
-        if b.eigenvalues_generator is not None:
-            if b.eigenvalues_generator.numel() > 0:
-                # GPSR assumes a factor 0.5 for differentiation
-                # so need rescaling
-                if isinstance(b, TimeEvolutionBlock) and rescale_eigenvals_timeevo:
-                    if b.eigenvalues_generator.numel() > 1:
-                        result[uuid] = (
-                            b.eigenvalues_generator * 2.0,
-                            0.5,
-                        )
+        eigs_generator = None
+
+        # this is to handle the case for the N operator
+        try:
+            eigs_generator = b.eigenvalues_generator
+        except ValueError:
+            result[uuid] = (torch.zeros(2), 1.0)
+        else:
+            if eigs_generator is not None:
+                if eigs_generator.numel() > 0:
+                    # GPSR assumes a factor 0.5 for differentiation
+                    # so need rescaling
+                    if isinstance(b, TimeEvolutionBlock) and rescale_eigenvals_timeevo:
+                        if eigs_generator.numel() > 1:
+                            result[uuid] = (
+                                eigs_generator * 2.0,
+                                0.5,
+                            )
+                        else:
+                            result[uuid] = (
+                                eigs_generator * 2.0,
+                                (
+                                    1.0 / (eigs_generator.item() * 2.0)
+                                    if len(eigs_generator) == 1
+                                    else 1.0
+                                ),
+                            )
                     else:
-                        result[uuid] = (
-                            b.eigenvalues_generator * 2.0,
-                            (
-                                1.0 / (b.eigenvalues_generator.item() * 2.0)
-                                if len(b.eigenvalues_generator) == 1
-                                else 1.0
-                            ),
-                        )
-                else:
-                    result[uuid] = (b.eigenvalues_generator, 1.0)
-
-                # leave only angle parameter uuid with eigenvals for ConstantAnalogRotation block
-                if isinstance(block, ConstantAnalogRotation):
-                    break
+                        result[uuid] = (eigs_generator, 1.0)
+
+                    # leave only angle parameter uuid with eigenvals for ConstantAnalogRotation block
+                    if isinstance(block, ConstantAnalogRotation):
+                        break
 
     return result
 

qadence/engines/differentiable_backend.py

@@ -12,7 +12,13 @@ from qadence.circuit import QuantumCircuit
 from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
 from qadence.noise import NoiseHandler
-from qadence.types import ArrayLike, DiffMode, Endianness, Engine, ParamDictType
+from qadence.types import (
+    ArrayLike,
+    DiffMode,
+    Endianness,
+    Engine,
+    ParamDictType,
+)
 
 
 @dataclass(frozen=True, eq=True)

qadence/engines/jax/differentiable_backend.py

@@ -8,7 +8,13 @@ from qadence.engines.jax.differentiable_expectation import DifferentiableExpecta
 from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
 from qadence.noise import NoiseHandler
-from qadence.types import ArrayLike, DiffMode, Endianness, Engine, ParamDictType
+from qadence.types import (
+    ArrayLike,
+    DiffMode,
+    Endianness,
+    Engine,
+    ParamDictType,
+)
 
 
 class DifferentiableBackend(DifferentiableBackendInterface):

qadence/engines/torch/differentiable_backend.py

@@ -12,7 +12,13 @@ from qadence.backends.parameter_shift_rules import general_psr
 from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
 from qadence.noise import NoiseHandler
-from qadence.types import ArrayLike, DiffMode, Endianness, Engine, ParamDictType
+from qadence.types import (
+    ArrayLike,
+    DiffMode,
+    Endianness,
+    Engine,
+    ParamDictType,
+)
 
 
 class DifferentiableBackend(DifferentiableBackendInterface):

qadence/engines/torch/differentiable_expectation.py

@@ -20,7 +20,7 @@ from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
 from qadence.ml_tools import promote_to_tensor
 from qadence.noise import NoiseHandler
-from qadence.types import Endianness
+from qadence.types import Endianness, ParamDictType
 
 
 class PSRExpectation(Function):
@@ -94,7 +94,7 @@ class DifferentiableExpectation:
     backend: QuantumBackend
     circuit: ConvertedCircuit
     observable: list[ConvertedObservable] | ConvertedObservable
-    param_values: dict[str, Tensor]
+    param_values: ParamDictType
     state: Tensor | None = None
     measurement: Measurements | None = None
     noise: NoiseHandler | None = None
@@ -135,8 +135,6 @@ class DifferentiableExpectation:
         self.observable = (
             self.observable if isinstance(self.observable, list) else [self.observable]
         )
-        if len(self.observable) > 1:
-            raise NotImplementedError("AdjointExpectation currently only supports one observable.")
 
         n_qubits = self.circuit.abstract.n_qubits
         values_batch_size = infer_batchsize(self.param_values)
@@ -150,18 +148,21 @@ class DifferentiableExpectation:
                 else self.state
             )
         batch_size = max(values_batch_size, self.state.size(-1))
-        return (
-            AdjointExpectation.apply(
+
+        def expectation_fn(i: int) -> Tensor:
+            return AdjointExpectation.apply(
                 self.circuit.native,
                 self.state,
-                self.observable[0].native,  # Currently, adjoint only supports a single observable.
+                self.observable[i].native,  # Currently, adjoint only supports a single observable.
                 None,
                 self.param_values.keys(),
                 *self.param_values.values(),
-            )
-            .unsqueeze(1)
-            .reshape(batch_size, 1)
-        )  # we expect (batch_size, n_observables) shape
+            ).reshape(
+                batch_size, 1
+            )  # we expect (batch_size, n_observables) shape
+
+        expectation_list = [expectation_fn(i) for i in range(len(self.observable))]
+        return torch.vstack(expectation_list)
 
     def psr(self, psr_fn: Callable, **psr_args: int | float | None) -> Tensor:
         # wrapper which unpacks the parameters

qadence/ml_tools/__init__.py

@@ -10,6 +10,7 @@ from .optimize_step import optimize_step as default_optimize_step
 from .parameters import get_parameters, num_parameters, set_parameters
 from .tensors import numpy_to_tensor, promote_to, promote_to_tensor
 from .trainer import Trainer
+from .qcnn_model import QCNN
 
 # Modules to be automatically added to the qadence namespace
 __all__ = [
@@ -25,4 +26,5 @@ __all__ = [
     "OptimizeResult",
     "Trainer",
     "write_checkpoint",
+    "QCNN",
 ]

qadence/model.py

@@ -27,7 +27,12 @@ from qadence.mitigations import Mitigations
 from qadence.noise import NoiseHandler
 from qadence.parameters import Parameter
 from qadence.types import DiffMode, Endianness
-from qadence.utils import block_to_mathematical_expression
+from qadence.utils import (
+    block_to_mathematical_expression,
+    check_param_dict_values,
+    merge_separate_params,
+)
+from qadence.transpile import set_as_variational, set_as_fixed
 
 logger = getLogger(__name__)
 
@@ -142,12 +147,20 @@ class QuantumModel(nn.Module):
         self._measurement = measurement
         self._noise = noise
         self._mitigation = mitigation
-        self._params = nn.ParameterDict(
-            {
-                str(key): nn.Parameter(val, requires_grad=val.requires_grad)
-                for key, val in conv.params.items()
-            }
-        )
+        if check_param_dict_values(conv.params):
+            self._params = nn.ParameterDict(
+                {
+                    str(key): nn.Parameter(val, requires_grad=val.requires_grad)  # type: ignore[union-attr]
+                    for key, val in conv.params.items()
+                }
+            )
+        else:
+            self._params = nn.ParameterDict(
+                {
+                    str(key): nn.Parameter(val, requires_grad=val.requires_grad)  # type: ignore[union-attr]
+                    for key, val in merge_separate_params(conv.params).items()
+                }
+            )
 
     @property
     def vparams(self) -> OrderedDict:
@@ -194,6 +207,80 @@ class QuantumModel(nn.Module):
             current_config = self.backend.backend.config
         BackendConfiguration.change_config(current_config, new_config)
 
+    def set_as_variational(self, params: list[str] = list()) -> None:
+        """Set as variational the list of names in `params`.
+
+        Args:
+            params (list[str], optional): List of parameters to fix. Defaults to list().
+        """
+        circuit: QuantumCircuit = self._circuit.original
+        if self._observable is not None:
+            if isinstance(self._observable, list):
+                for obs in self._observable:
+                    set_as_variational(obs.original, params)
+                observable = [obs.original for obs in self._observable]
+            else:
+                set_as_variational(self._observable.original, params)
+                observable = [self._observable.original]
+        else:
+            observable = self._observable  # type: ignore[assignment]
+        set_as_variational(circuit.block, params)
+        conv = self.backend.convert(circuit, observable)
+        self.embedding_fn = conv.embedding_fn
+        self._circuit = conv.circuit
+        self._observable = conv.observable
+        if check_param_dict_values(conv.params):
+            self._params = nn.ParameterDict(
+                {
+                    str(key): nn.Parameter(val, requires_grad=val.requires_grad)  # type: ignore[union-attr]
+                    for key, val in conv.params.items()
+                }
+            )
+        else:
+            self._params = nn.ParameterDict(
+                {
+                    str(key): nn.Parameter(val, requires_grad=val.requires_grad)  # type: ignore[union-attr]
+                    for key, val in merge_separate_params(conv.params).items()
+                }
+            )
+
+    def set_as_fixed(self, params: list[str] = list()) -> None:
+        """Set as fixed the list of names in `params`.
+
+        Args:
+            params (list[str], optional): List of parameters to fix. Defaults to list().
+        """
+        circuit: QuantumCircuit = self._circuit.original
+        if self._observable is not None:
+            if isinstance(self._observable, list):
+                for obs in self._observable:
+                    set_as_fixed(obs.original, params)
+                observable = [obs.original for obs in self._observable]
+            else:
+                set_as_fixed(self._observable.original, params)
+                observable = [self._observable.original]
+        else:
+            observable = self._observable  # type: ignore[assignment]
+        set_as_fixed(circuit.block, params)
+        conv = self.backend.convert(circuit, observable)
+        self.embedding_fn = conv.embedding_fn
+        self._circuit = conv.circuit
+        self._observable = conv.observable
+        if check_param_dict_values(conv.params):
+            self._params = nn.ParameterDict(
+                {
+                    str(key): nn.Parameter(val, requires_grad=val.requires_grad)  # type: ignore[union-attr]
+                    for key, val in conv.params.items()
+                }
+            )
+        else:
+            self._params = nn.ParameterDict(
+                {
+                    str(key): nn.Parameter(val, requires_grad=val.requires_grad)  # type: ignore[union-attr]
+                    for key, val in merge_separate_params(conv.params).items()
+                }
+            )
+
     def circuit(self, circuit: QuantumCircuit) -> ConvertedCircuit:
         """Get backend-converted circuit.
 

qadence/transpile/__init__.py

@@ -5,7 +5,8 @@ from .block import (
     chain_single_qubit_ops,
     repeat,
     scale_primitive_blocks_only,
-    set_trainable,
+    set_as_variational,
+    set_as_fixed,
     validate,
 )
 from .circuit import fill_identities
@@ -15,4 +16,4 @@ from .invert import invert_endianness, reassign
 from .noise import set_noise
 from .transpile import blockfn_to_circfn, transpile
 
-__all__ = ["set_trainable", "invert_endianness", "set_noise"]
+__all__ = ["set_as_variational", "set_as_fixed", "invert_endianness", "set_noise"]

qadence/transpile/block.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
 from copy import deepcopy
-from functools import singledispatch
 from logging import getLogger
+from functools import singledispatch
 from typing import Callable, Iterable, Type
 
 import sympy
@@ -42,13 +42,17 @@ def repeat(
 
 
 def set_trainable(
-    blocks: AbstractBlock | list[AbstractBlock], value: bool = True, inplace: bool = True
+    blocks: AbstractBlock | list[AbstractBlock],
+    restricted_names: list[str] = list(),
+    value: bool = True,
+    inplace: bool = True,
 ) -> AbstractBlock | list[AbstractBlock]:
     """Set the trainability of all parameters in a block to a given value.
 
     Args:
         blocks (AbstractBlock | list[AbstractBlock]): Block or list of blocks for which
             to set the trainable attribute
+        restricted_names (list[str]): Restricted list of parameters names to set the value.
         value (bool, optional): The value of the trainable attribute to assign to the input blocks
         inplace (bool, optional): Whether to modify the block(s) in place or not. Currently, only
 
@@ -66,16 +70,65 @@ def set_trainable(
 
     if inplace:
         for block in blocks:
-            params: list[sympy.Basic] = parameters(block)
+            params: list[sympy.Basic] = list(filter(lambda p: not p.is_number, parameters(block)))
+            if bool(restricted_names):
+                params = list(filter(lambda p: p.name in restricted_names, params))
             for p in params:
-                if not p.is_number:
-                    p.trainable = value
+                p.trainable = value
     else:
         raise NotImplementedError("Not inplace set_trainable is not yet available")
 
     return blocks if len(blocks) > 1 else blocks[0]
 
 
+def set_as_variational(
+    blocks: AbstractBlock | list[AbstractBlock],
+    restricted_names: list[str] = list(),
+    inplace: bool = True,
+) -> AbstractBlock | list[AbstractBlock]:
+    """Set parameters in blocks as variational (trainable parameters).
+
+    Args:
+        blocks (AbstractBlock | list[AbstractBlock]): Block or list of blocks for which
+            to set the trainable attribute
+        restricted_names (list[str]): Restricted list of parameters names to set the value.
+        inplace (bool, optional): Whether to modify the block(s) in place or not. Currently, only
+
+    Raises:
+        NotImplementedError: if the `inplace` argument is set to False, the function will
+            raise  this exception
+
+    Returns:
+        AbstractBlock | list[AbstractBlock]: the input block or list of blocks with the trainable
+            attribute set to True
+    """
+    return set_trainable(blocks, restricted_names=restricted_names, inplace=inplace)
+
+
+def set_as_fixed(
+    blocks: AbstractBlock | list[AbstractBlock],
+    restricted_names: list[str] = list(),
+    inplace: bool = True,
+) -> AbstractBlock | list[AbstractBlock]:
+    """Set parameters in blocks as fixed (non-trainable parameters).
+
+    Args:
+        blocks (AbstractBlock | list[AbstractBlock]): Block or list of blocks for which
+            to set the trainable attribute
+        restricted_names (list[str]): Restricted list of parameters names to set the value.
+        inplace (bool, optional): Whether to modify the block(s) in place or not. Currently, only
+
+    Raises:
+        NotImplementedError: if the `inplace` argument is set to False, the function will
+            raise  this exception
+
+    Returns:
+        AbstractBlock | list[AbstractBlock]: the input block or list of blocks with the trainable
+            attribute set to False
+    """
+    return set_trainable(blocks, restricted_names=restricted_names, value=False, inplace=inplace)
+
+
 def validate(block: AbstractBlock) -> AbstractBlock:
     """Moves a block from global to local qubit numbers by adding PutBlocks.
 

qadence/types.py

@@ -430,7 +430,7 @@ class ReadOutOptimization(StrEnum):
     CONSTRAINED = "constrained"
 
 
-ParamDictType = dict[str, ArrayLike]
+ParamDictType = dict[str, Union[ArrayLike, dict[str, ArrayLike]]]
 DifferentiableExpression = Callable[..., ArrayLike]
 
 

qadence/utils.py

@@ -17,7 +17,7 @@ from torch.linalg import eigvals
 from rich.tree import Tree
 
 from qadence.blocks import AbstractBlock
-from qadence.types import Endianness, ResultType, TNumber
+from qadence.types import Endianness, ResultType, TNumber, ParamDictType
 
 if TYPE_CHECKING:
     from qadence.operations import Projector
@@ -30,6 +30,28 @@ __all__ = []  # type: ignore
 logger = getLogger(__name__)
 
 
+def merge_separate_params(param_dict: ParamDictType) -> ParamDictType:
+    """Merge circuit and observables parameters."""
+    merged_dict: ParamDictType = dict()
+    for p in param_dict.values():
+        merged_dict |= p
+    return merged_dict
+
+
+def check_param_dict_values(param_dict: ParamDictType) -> bool:
+    """Check if `param_dict` contains array values.
+
+    Args:
+        param_dict (ParamDictType): Dictionary of parameters.
+
+    Returns:
+        bool: True if values are arrays, False if values are dict.
+    """
+    if all(isinstance(p, dict) for p in param_dict.values()):
+        return False
+    return True
+
+
 def basis_to_int(basis: str, endianness: Endianness = Endianness.BIG) -> int:
     """
     Converts a computational basis state to an int.

{qadence-1.11.2.dist-info → qadence-1.11.3.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: qadence
-Version: 1.11.2
+Version: 1.11.3
 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>, Eduardo Maschio <eduardo.maschio@pasqal.com>, Smit Chaudhary <smit.chaudhary@pasqal.com>, Ignacio Fernández Graña <ignacio.fernandez-grana@pasqal.com>, Charles Moussa <charles.moussa@pasqal.com>, Giorgio Tosti Balducci <giorgio.tosti-balducci@pasqal.com>, Daniele Cucurachi <daniele.cucurachi@pasqal.com>, Pim Venderbosch <pim.venderbosch@pasqal.com>, Manu Lahariya <manu.lahariya@pasqal.com>
+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>, Eduardo Maschio <eduardo.maschio@pasqal.com>, Smit Chaudhary <smit.chaudhary@pasqal.com>, Ignacio Fernández Graña <ignacio.fernandez-grana@pasqal.com>, Charles Moussa <charles.moussa@pasqal.com>, Giorgio Tosti Balducci <giorgio.tosti-balducci@pasqal.com>, Daniele Cucurachi <daniele.cucurachi@pasqal.com>, Pim Venderbosch <pim.venderbosch@pasqal.com>, Manu Lahariya <manu.lahariya@pasqal.com>, Sungwoo Ahn <sungwoo.ahn@pasqal.com>
 License: PASQAL OPEN-SOURCE SOFTWARE LICENSE (MIT-derived)
 License-File: LICENSE
 Classifier: License :: Other/Proprietary License
@@ -24,7 +24,7 @@ Requires-Dist: nevergrad
 Requires-Dist: numpy
 Requires-Dist: openfermion
 Requires-Dist: pasqal-cloud
-Requires-Dist: pyqtorch==1.7.5
+Requires-Dist: pyqtorch==1.7.6
 Requires-Dist: pyyaml
 Requires-Dist: rich
 Requires-Dist: scipy
@@ -44,15 +44,25 @@ Requires-Dist: nvidia-pyindex; extra == 'dlprof'
 Provides-Extra: horqrux
 Requires-Dist: einops; extra == 'horqrux'
 Requires-Dist: flax; extra == 'horqrux'
-Requires-Dist: horqrux==0.8.0; extra == 'horqrux'
+Requires-Dist: horqrux==0.8.1; extra == 'horqrux'
 Requires-Dist: jax; extra == 'horqrux'
 Requires-Dist: jaxopt; extra == 'horqrux'
 Requires-Dist: optax; extra == 'horqrux'
 Requires-Dist: sympy2jax; extra == 'horqrux'
+Provides-Extra: hub
+Requires-Dist: qadence-measurement; extra == 'hub'
+Requires-Dist: qadence-mitigation; extra == 'hub'
+Requires-Dist: qadence-model; extra == 'hub'
 Provides-Extra: libs
 Requires-Dist: qadence-libs; extra == 'libs'
+Provides-Extra: measurement
+Requires-Dist: qadence-measurement; extra == 'measurement'
+Provides-Extra: mitigation
+Requires-Dist: qadence-mitigation; extra == 'mitigation'
 Provides-Extra: mlflow
 Requires-Dist: mlflow; extra == 'mlflow'
+Provides-Extra: model
+Requires-Dist: qadence-model; extra == 'model'
 Provides-Extra: protocols
 Requires-Dist: qadence-protocols; extra == 'protocols'
 Provides-Extra: pulser

{qadence-1.11.2.dist-info → qadence-1.11.3.dist-info}/RECORD

@@ -1,5 +1,5 @@
 qadence/__init__.py,sha256=c3y-Tbq_P4cbWKi7b45Z6zUFlnqgd8Q68OOpL2O2GOI,2671
-qadence/backend.py,sha256=r9Ymrou3IoxJ4yWIJ-Rc2MyNq56NNwZg5rpmLM_pJaE,13721
+qadence/backend.py,sha256=dcgGHncwK5Ul7COVccUyxGOKqbTuoK-KVLZ1qL7Abx8,14166
 qadence/circuit.py,sha256=r8QvzLWHvavqLOlNstq8aHg6UpKmPClEDoZVBkk-tzY,6970
 qadence/decompose.py,sha256=C4LYia_GcC9Rx3QO0ZLWTI9dN63a8WTEAXO0ZVQWuiE,5221
 qadence/divergences.py,sha256=JhpELhWSnuDvQxa9hJp_DE3EQg2Ban-Ta0mHZ_fVrHg,1832
@@ -8,7 +8,7 @@ qadence/extensions.py,sha256=TqkUGhc7vVUQeGsfuPruQ_Q3Vp7QQVHsHC_dayZ5EXU,5754
 qadence/libs.py,sha256=HetkKO8TCTlVCViQdVQJvxwBekrhd-y_iMox4UJMY1M,410
 qadence/log_config.yaml,sha256=QiwoB1bnRdk9NpxnvfgWX2PjN7EDfYlrc3GVD38rtdI,739
 qadence/logger.py,sha256=Hb76pK3VyQjVjJb4_NqFlOJgjYJVa8t7DHJFlzOM86M,407
-qadence/model.py,sha256=LbWXVoysyrFGz-xjMwzm5RGKBGVysrwL-PUEy0UAhHo,23346
+qadence/model.py,sha256=dVabrxs4lJjgx5FXXcq9AmEr81zPrctCmLuWHxXptVc,27128
 qadence/overlap.py,sha256=ekaUnIcQWdF4hSFuUWpRjaxo43JyDGFOayP7vMXCZpw,16821
 qadence/parameters.py,sha256=g7OET8_HLjo1zKlX6WNCeSPtgzC3WMl6hVPAVZ9uiHU,12744
 qadence/pasqal_cloud_connection.py,sha256=1lz_AJRo54-YMnsYGJD_SFpUK-0_ZzJRWr9Qqa_pBZU,9675
@@ -19,8 +19,8 @@ qadence/register.py,sha256=MlI1-L1P_e7ugjelhH-1YdxrfPsgmLmX5m-dueawuWQ,13172
 qadence/serial_expr_grammar.peg,sha256=z5ytL7do9kO8o4h-V5GrsDuLdso0KsRcMuIYURFfmAY,328
 qadence/serialization.py,sha256=IB0OgYhtV3F9AmMMMbGcfgNil9vBzs92j5G3yj4KPhg,15616
 qadence/states.py,sha256=Aj28aNHGWkZrFw_mKpHrxCA1bDXlkFhw18D70tg0RF0,15953
-qadence/types.py,sha256=RfsUA7jksqsK2gRNOj7QSsAJc0N1rAeI2k-6MWbuPC4,11898
-qadence/utils.py,sha256=J3NsYYty7Oys6SrrpB4UkxunjE_h6-vWI0e2I1TpDAw,11735
+qadence/types.py,sha256=HtOKf6xi-kTtncqctRWK0Wpxut7KEXHdqoQVqfx0vxo,11927
+qadence/utils.py,sha256=fChJDz7OelWNGLPjoBBcmleWGluWhR36Mf0LnqCx8FA,12376
 qadence/analog/__init__.py,sha256=BCyS9R4KUjzUXN0Ax3b0eMo8ZAuSkGoJQVtZ4_pvAFs,279
 qadence/analog/addressing.py,sha256=GSt4heEmRkBmoQIgdgkTclEFxZY-jjuAd77_SsZtGdI,6513
 qadence/analog/constants.py,sha256=B2phQoN1ASL8CwM-Dsa1rbraYwGwwPSeiB3HbVe-MPA,1243
@@ -30,15 +30,15 @@ qadence/analog/parse_analog.py,sha256=9Y_LMdw4wCHH6YSkvHhs6PUNwzT14HS7cUGheNSmDQ
 qadence/backends/__init__.py,sha256=ibm7wmZxuIoMYAQxgAx0MsfLYWOVHNWgLwyS1HjMuuI,215
 qadence/backends/agpsr_utils.py,sha256=CfjMG3S4ws5M3PImbjhg8KEAzRPKuh7h5YR8WpHgzas,2965
 qadence/backends/api.py,sha256=54l6a0sUSkSN1AEjZPaMXGwg0JNjl2i0GWAJ828QFII,3095
-qadence/backends/jax_utils.py,sha256=VfKhqCKknHDWZO21UFipWH_Lkiq175Z5GkP49gWjbyw,5038
+qadence/backends/jax_utils.py,sha256=n-m4_q795Uw01ra-sNsqarF03d47TxHSyMMnu3K3WBg,5268
 qadence/backends/parameter_shift_rules.py,sha256=CV_pU09HbipKrWGpFBRa5DJ-t2RRm0tstAJdEee-TzM,6654
 qadence/backends/utils.py,sha256=SSiMxZjaFS8e8sB6ZBLXPKuJNQGl93pRMy9hnI4oDrw,9104
 qadence/backends/horqrux/__init__.py,sha256=0OdVy6cq0oQggV48LO1WXdaZuSkDkz7OYNEPIkNAmfk,140
-qadence/backends/horqrux/backend.py,sha256=Dmtj9RUA7CnzoYCQS8C049W_XVH8hUD1z3b2BBgf7Ik,8904
+qadence/backends/horqrux/backend.py,sha256=4M_23e0oGbcC_PUHpig8V1rNboI8xKATtp92guOTqPQ,9489
 qadence/backends/horqrux/config.py,sha256=m8rroGPBwvzuHoCDPB4VlNQaKBPp7Rbgrb8KHINpTEo,1415
 qadence/backends/horqrux/convert_ops.py,sha256=3vjzbMGEFH4CUzIDFdvmPbyT5_gecHLMoLxQ_ATFhSw,6327
 qadence/backends/pulser/__init__.py,sha256=capQ-eHqwtOeLf4mWsI0BIseAHhiLGie5cFD4-iVhUo,116
-qadence/backends/pulser/backend.py,sha256=cI4IgijPpItNdDmLpKkJFas0X02wMiZd_XmVas41gEI,14846
+qadence/backends/pulser/backend.py,sha256=xHIv4CVm2VxLko6yYioRyXLs_PiQtZZXZsTDhf7qMgI,15157
 qadence/backends/pulser/channels.py,sha256=ZF0yEXUFHAmi3IdeXjzdTNGR5NzaRRFTiUpUGVg2sO4,329
 qadence/backends/pulser/cloud.py,sha256=0uUluvbFV9sOuCPraE-9uiVtC3Q8QaDY1IJMDi8grDM,2057
 qadence/backends/pulser/config.py,sha256=crIv1IJDk7uMZiQa994sDPqKKLHDH0RC17JYv_6N1cY,2708
@@ -47,7 +47,7 @@ qadence/backends/pulser/devices.py,sha256=DermLZNfmCB3SqteKVW4uhg4jp6ya1G6ptnXbB
 qadence/backends/pulser/pulses.py,sha256=F4fExIRAhLPMtVg1bhNtDihUYHxu5RExGjovk8-CQIo,11884
 qadence/backends/pulser/waveforms.py,sha256=0uz95b7rUaUUtN0tuHBZmJ0H6UBmfHST_59ozwsRCzg,2227
 qadence/backends/pyqtorch/__init__.py,sha256=0OdVy6cq0oQggV48LO1WXdaZuSkDkz7OYNEPIkNAmfk,140
-qadence/backends/pyqtorch/backend.py,sha256=Sjuof9b332w4gk9o8Rso2rgSHxskexfkIazRfxRD0Ng,11458
+qadence/backends/pyqtorch/backend.py,sha256=JXfZiFu-9PYZbO_C7rZ7Bg8vbzNwpUujZQ3KHKaeCuk,12034
 qadence/backends/pyqtorch/config.py,sha256=v3IUzyGSsXPBE5WeAZo7PegrIoEeuztCyYm8u3IwNho,2920
 qadence/backends/pyqtorch/convert_ops.py,sha256=qG26-HmtUDaZO0KDnw2sbT3CRx_poS7eqJ3dn9wpWgc,13457
 qadence/blocks/__init__.py,sha256=H6jEA_CptkE-eoB4UfSbUiDszbxxhZwECV_TgoZWXoU,960
@@ -55,11 +55,11 @@ qadence/blocks/abstract.py,sha256=DSQUE71rMyRBwAP--4Tx1WQC_LCXaNlftjd7goGyrpQ,12
 qadence/blocks/analog.py,sha256=ymnnlSVoW1XL05ZvnnHCqRTHuOXIEY_7E9M0PNKJZy4,10812
 qadence/blocks/block_to_tensor.py,sha256=DceLKuyjhG87QGsl34lk1CXHtris42Sc8A7bavGrRA0,17207
 qadence/blocks/composite.py,sha256=f9D8L3u5Ktu_-xDBWsWiPlY8I-YW5YFgU18BtqwFHK0,8937
-qadence/blocks/embedding.py,sha256=MI-gTPEe1e56AiHJr6MJwMAHdA7ZYmTo0b0VmFfyISQ,7029
+qadence/blocks/embedding.py,sha256=2odczunlLSl_8jx94SsHnt_WHpo09Zxt96BGwzoeoL8,7212
 qadence/blocks/manipulate.py,sha256=kPmzej7mnWFoqTJA2CkGulT7hcPha0GGPARC8rjZltg,2387
 qadence/blocks/matrix.py,sha256=JgzFLWoWDytaE0MEYe-Di7tbwb4jSmMF8tsOF04RIRo,4214
 qadence/blocks/primitive.py,sha256=21D7YIWw8N_uWcZwM9-DtyqQJ-8Ng1tZIJL4zaSK6uQ,17644
-qadence/blocks/utils.py,sha256=_V43qD7kQNK8JS3gxfpkRn56ZIF_GGrhAnARn1hq2hk,17772
+qadence/blocks/utils.py,sha256=zdpaIh-OYFnLIWdnL-ogY8RONt5Yk-nUqSArXnhKy5E,18052
 qadence/constructors/__init__.py,sha256=LiFkGzgMa27LrY1LhINfmj3UWfrjoUk9wwRM9a54rK0,1211
 qadence/constructors/ala.py,sha256=76rdD_vMki5F_r_Iq-68zU3NHrJiebVmr-e7L4lIDAo,8359
 qadence/constructors/feature_maps.py,sha256=BaAxFi6fSKwjsfFjqZ8T7lyZfjotcgH2OW3b0j67YVk,8644
@@ -83,13 +83,13 @@ qadence/draw/assets/dark/measurement.svg,sha256=6ALGjaCX3xZ1NqB6RW6yzOchzZV-j8uk
 qadence/draw/assets/light/measurement.png,sha256=q6AMI7Lmb1O42sEzvSiK9ZtyTpXOGj-zIAh4FiPbhsk,278
 qadence/draw/assets/light/measurement.svg,sha256=kL424wtIEU7ihxecZnthyYnvHhNW_F75daoO9pBHNiw,7282
 qadence/engines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qadence/engines/differentiable_backend.py,sha256=o9fuXapvoWB4Rr0QsQP3YRFe1Wdq-Fhww0NUvWR7oqA,5896
+qadence/engines/differentiable_backend.py,sha256=VLi2QiBdGU0MXDr39tOfL26p8gcVT6JYB4hNGT_QEI0,5921
 qadence/engines/jax/__init__.py,sha256=qcW09lcnblwRVQM6mDmW9su5kDVPe--buWCCuvPbOVM,223
-qadence/engines/jax/differentiable_backend.py,sha256=FcSrzzjzb0zfXC0-4mUJ6UB-wGO5RnNjQOGPAsM25zs,3076
+qadence/engines/jax/differentiable_backend.py,sha256=EnuhC1kW0Lkf1voZcIQjgO9PuBa3T3Td0kwgAKhnQwU,3101
 qadence/engines/jax/differentiable_expectation.py,sha256=rn_l7IH-S4IvuAcyAIgyEuMZOIqswu5Nsfz0JffXjaE,3694
 qadence/engines/torch/__init__.py,sha256=iZFdD32ot0B0CVyC-f5dVViOBnqoalxa6M9Lj4WQuPE,160
-qadence/engines/torch/differentiable_backend.py,sha256=bab2Lk-P2nCtj66a0foaajSwxKmfzwIrqa3nwF2RRyQ,3433
-qadence/engines/torch/differentiable_expectation.py,sha256=kc4WTos7d65DDmao6YSrpTM0rCBnpqhGK4xLHm_K4yk,10351
+qadence/engines/torch/differentiable_backend.py,sha256=ySWpMXLtt4HhuqTu58098p7qGKbUrEniBDf1jZppZBQ,3458
+qadence/engines/torch/differentiable_expectation.py,sha256=zHJbgl1elBU6QN_NBQ348lYsxvKtGdnVs6sEbkCsX98,10374
 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
@@ -102,7 +102,7 @@ qadence/mitigations/__init__.py,sha256=RzaxYJftePFMloGhBVSixZ8fSe-ps_Jc-EyPm6xz-
 qadence/mitigations/analog_zne.py,sha256=KGtdq3TmqipIVP-0U3mIkF_xf91dWbB3SYkM_26plaY,7895
 qadence/mitigations/protocols.py,sha256=0TeHvlGTN8_88XNEwrjA97C5BUlrh34wYmx0w6-5Tyw,1622
 qadence/mitigations/readout.py,sha256=nI-voV5N0R7630Cn8t8x9EdV9iB76P0LDkRosy1s0Ec,6631
-qadence/ml_tools/__init__.py,sha256=Z744FRFAzU5iw-4JC5YC43mDQD6rTa5ApdkWbUFuTbQ,970
+qadence/ml_tools/__init__.py,sha256=AG0WaQTvP_jXVx4xmiFWroYZ53ydFzrmTXcXC6nV7Wg,1011
 qadence/ml_tools/config.py,sha256=0qN0FVXRwYNMLGKgvk70cHTnEbl5_p83dU85sIyXls4,22728
 qadence/ml_tools/constructors.py,sha256=rfJ4VqUbhwnCMtOm3oQ94N_DmGCLtljPlhsCaDGQ2FY,36227
 qadence/ml_tools/data.py,sha256=-HUQk3-0UHOBA4KMFQ63tlt3si4W66psbgR1DAjtoVE,5481
@@ -137,16 +137,16 @@ qadence/operations/control_ops.py,sha256=fPSwOxJaVtJNbwri1UdD20W1JXQlB-inPTCJG3F
 qadence/operations/ham_evo.py,sha256=brJ11tlwj6UPYkUcnId-BKlzNStsZd0vp9FKHCFTjlM,10642
 qadence/operations/parametric.py,sha256=kV5d-diaQAoRlqKqoo0CGCbPej6eAxHQXniqfFKff3g,5394
 qadence/operations/primitive.py,sha256=hPJMDgWaEEdSYDZsr__hAcwy-QJEtzbM4qtFDcLmNBg,9881
-qadence/transpile/__init__.py,sha256=JrrQ4Osc4nNRWWjRGmVn57fWc8WwF92MokhKLRZ1vVA,499
+qadence/transpile/__init__.py,sha256=AuWxqao_KFOJOfmlBRASqwbhFYbu1MM1f-pMTRBvFNc,543
 qadence/transpile/apply_fn.py,sha256=glZo2_wMOjw7_KgWKYbqg8j-9SDs-RefWIfxWgdQK8I,1336
-qadence/transpile/block.py,sha256=jV-EyatrwwdL2ahjF3wyEhC3PKMBPLaL5sQN1VNFc_w,11582
+qadence/transpile/block.py,sha256=qsGixA8MVGwEh4-j7qR8H4UapKdOyufFGA1TyHWQVAg,13783
 qadence/transpile/circuit.py,sha256=KTh6Gv1czZddFuA1JhNNszheZbwViVixiGh4rGvIgTM,451
 qadence/transpile/digitalize.py,sha256=7oNHEBs50ff3rvP-Tb72tCQ5sk6vMpoQvz4CXyvH6Tc,1521
 qadence/transpile/flatten.py,sha256=k4HAfVzvDV40HyfaukiEHyJtAtvFRIcyDbAWiCL8tf0,3425
 qadence/transpile/invert.py,sha256=IeyidgBwECCKB0i7Ym0KkLyfcx42LyT2mbqkfbK1H8M,4843
 qadence/transpile/noise.py,sha256=LDcDJtQGkgUPkL2t69gg6AScTb-p3J3SxCDZbYOu1L8,1668
 qadence/transpile/transpile.py,sha256=xnzkHA6Qdb-Y5Fv9Latrolrpw44N6_OKc7_QGt70f0I,2713
-qadence-1.11.2.dist-info/METADATA,sha256=59o3ZoZh4OCOH_1qjHjcolovDDDc0YAdgz8nUqukis0,10308
-qadence-1.11.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-qadence-1.11.2.dist-info/licenses/LICENSE,sha256=IfA3wQpmMOjCnDZ0P8Od2Bxb39rND9s5zfGHp1vMTbQ,2359
-qadence-1.11.2.dist-info/RECORD,,
+qadence-1.11.3.dist-info/METADATA,sha256=KnEzhBVUnxeEgo778rmcj9l5R_otThJo6lUH6sKyuMI,10752
+qadence-1.11.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+qadence-1.11.3.dist-info/licenses/LICENSE,sha256=IfA3wQpmMOjCnDZ0P8Od2Bxb39rND9s5zfGHp1vMTbQ,2359
+qadence-1.11.3.dist-info/RECORD,,