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

qadence/backend.py

@@ -26,7 +26,6 @@ from qadence.mitigations import Mitigations
 from qadence.noise import Noise
 from qadence.parameters import stringify
 from qadence.types import ArrayLike, BackendName, DiffMode, Endianness, Engine, ParamDictType
-from qadence.utils import validate_values_and_state
 
 logger = get_logger(__file__)
 
@@ -259,29 +258,6 @@ class Backend(ABC):
         """
         raise NotImplementedError
 
-    @abstractmethod
-    def _run(
-        self,
-        circuit: ConvertedCircuit,
-        param_values: dict[str, ArrayLike] = {},
-        state: ArrayLike | None = None,
-        endianness: Endianness = Endianness.BIG,
-    ) -> ArrayLike:
-        """Run a circuit and return the resulting wave function.
-
-        Arguments:
-            circuit: A converted circuit as returned by `backend.circuit`.
-            param_values: _**Already embedded**_ parameters of the circuit. See
-                [`embedding`][qadence.blocks.embedding.embedding] for more info.
-            state: Initial state.
-            endianness: Endianness of the resulting wavefunction.
-
-        Returns:
-            A list of Counter objects where each key represents a bitstring
-            and its value the number of times it has been sampled from the given wave function.
-        """
-        raise NotImplementedError
-
     def run(
         self,
         circuit: ConvertedCircuit,
@@ -304,8 +280,7 @@ class Backend(ABC):
             A list of Counter objects where each key represents a bitstring
             and its value the number of times it has been sampled from the given wave function.
         """
-        validate_values_and_state(state, circuit.abstract.n_qubits, param_values)
-        return self._run(circuit, param_values, state, endianness, *args, **kwargs)
+        raise NotImplementedError
 
     @abstractmethod
     def run_dm(

qadence/backends/braket/backend.py

@@ -88,7 +88,7 @@ class Backend(BackendInterface):
         ).squeeze(0)
         return ConvertedObservable(native=native, abstract=obs, original=obs)
 
-    def _run(
+    def run(
         self,
         circuit: ConvertedCircuit,
         param_values: dict[str, Tensor] = {},

qadence/backends/horqrux/backend.py

@@ -66,7 +66,7 @@ class Backend(BackendInterface):
         hq_obs = convert_observable(block, n_qubits=n_qubits, config=self.config)
         return ConvertedObservable(native=hq_obs, abstract=block, original=observable)
 
-    def _run(
+    def run(
         self,
         circuit: ConvertedCircuit,
         param_values: ParamDictType = {},

qadence/backends/pulser/backend.py

@@ -200,7 +200,7 @@ class Backend(BackendInterface):
 
         return circuit.native.build(**numpy_param_values)
 
-    def _run(
+    def run(
         self,
         circuit: ConvertedCircuit,
         param_values: dict[str, Tensor] = {},

qadence/backends/pyqtorch/backend.py

@@ -80,7 +80,7 @@ class Backend(BackendInterface):
         (native,) = convert_observable(block, n_qubits=n_qubits, config=self.config)
         return ConvertedObservable(native=native, abstract=block, original=observable)
 
-    def _run(
+    def run(
         self,
         circuit: ConvertedCircuit,
         param_values: dict[str, Tensor] = {},

qadence/ml_tools/models.py

@@ -289,11 +289,23 @@ class TransformedModule(torch.nn.Module):
     def to(self, *args: Any, **kwargs: Any) -> TransformedModule:
         try:
             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)
-
+            if isinstance(self.model, QuantumModel):
+                device = self.model._circuit.native.device
+                dtype = (
+                    torch.float64
+                    if self.model._circuit.native.dtype == torch.cdouble
+                    else torch.float32
+                )
+
+                self._input_scaling = self._input_scaling.to(device=device, dtype=dtype)
+                self._input_shifting = self._input_shifting.to(device=device, dtype=dtype)
+                self._output_scaling = self._output_scaling.to(device=device, dtype=dtype)
+                self._output_shifting = self._output_shifting.to(device=device, dtype=dtype)
+            elif isinstance(self.model, torch.nn.Module):
+                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 {args}, {kwargs}.")
         except Exception as e:
             logger.warning(f"Unable to move {self} to {args}, {kwargs} due to {e}.")

qadence/ml_tools/train_grad.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import Callable, Union
 
 from rich.progress import BarColumn, Progress, TaskProgressColumn, TextColumn, TimeRemainingColumn
+from torch import complex128, float32, float64
 from torch import device as torch_device
 from torch import dtype as torch_dtype
 from torch.nn import DataParallel, Module
@@ -110,17 +111,17 @@ def train(
     train_with_grad(model, data, optimizer, config, loss_fn=loss_fn)
     ```
     """
+    # load available checkpoint
+    init_iter = 0
+    if config.folder:
+        model, optimizer, init_iter = load_checkpoint(config.folder, model, optimizer)
+        logger.debug(f"Loaded model and optimizer from {config.folder}")
 
     # Move model to device before optimizer is loaded
     if isinstance(model, DataParallel):
         model = model.module.to(device=device, dtype=dtype)
     else:
         model = model.to(device=device, dtype=dtype)
-    # load available checkpoint
-    init_iter = 0
-    if config.folder:
-        model, optimizer, init_iter = load_checkpoint(config.folder, model, optimizer)
-        logger.debug(f"Loaded model and optimizer from {config.folder}")
     # initialize tensorboard
     writer = SummaryWriter(config.folder, purge_step=init_iter)
 
@@ -131,7 +132,9 @@ def train(
         TaskProgressColumn(),
         TimeRemainingColumn(elapsed_when_finished=True),
     )
-
+    data_dtype = None
+    if dtype:
+        data_dtype = float64 if dtype == complex128 else float32
     with progress:
         dl_iter = iter(dataloader) if dataloader is not None else None
 
@@ -143,7 +146,12 @@ def train(
                 # which do not have classical input data (e.g. chemistry)
                 if dataloader is None:
                     loss, metrics = optimize_step(
-                        model=model, optimizer=optimizer, loss_fn=loss_fn, xs=None, device=device
+                        model=model,
+                        optimizer=optimizer,
+                        loss_fn=loss_fn,
+                        xs=None,
+                        device=device,
+                        dtype=data_dtype,
                     )
                     loss = loss.item()
 
@@ -154,6 +162,7 @@ def train(
                         loss_fn=loss_fn,
                         xs=next(dl_iter),  # type: ignore[arg-type]
                         device=device,
+                        dtype=data_dtype,
                     )
 
                 else:

qadence/models/quantum_model.py

@@ -342,9 +342,10 @@ class QuantumModel(nn.Module):
         return self.backend.assign_parameters(self._circuit, params)
 
     def to(self, *args: Any, **kwargs: Any) -> QuantumModel:
+        from pyqtorch import QuantumCircuit as PyQCircuit
+
         try:
-            if isinstance(self._circuit.native, torch.nn.Module):
-                # Backends which are not torch-based cannot be moved to 'device'
+            if isinstance(self._circuit.native, PyQCircuit):
                 self._circuit.native = self._circuit.native.to(*args, **kwargs)
                 if self._observable is not None:
                     if isinstance(self._observable, ConvertedObservable):
@@ -359,6 +360,8 @@ class QuantumModel(nn.Module):
                     else torch.float32,
                 )
                 logger.debug(f"Moved {self} to {args}, {kwargs}.")
+            else:
+                logger.debug("QuantumModel.to only supports pyqtorch.QuantumCircuits.")
         except Exception as e:
             logger.warning(f"Unable to move {self} to {args}, {kwargs} due to {e}.")
         return self

qadence/serial_expr_grammar.peg

@@ -0,0 +1,11 @@
+Program = expr EOF
+expr = id '(' args ')'
+args = (value / expr) (',' (value / expr))*
+value = int / float_str / str / pair
+pair = param '=' (int / bool / str)
+param = r"[a-z][a-zA-Z]*"
+id = r"[a-zA-Z][a-zA-Z_0-9]*"
+bool = 'True' / 'False'
+int = r"-?(0|[1-9][0-9]*)"
+float_str = r"'-?(0|\d*(\.\d*))'"
+str = r"'[a-zA-Z0-9\_\.]+'"

qadence/serialization.py

@@ -2,21 +2,26 @@ from __future__ import annotations
 
 import json
 import os
+import sys
+from dataclasses import dataclass
+from dataclasses import field as dataclass_field
+from functools import lru_cache
 from pathlib import Path
-from typing import Any, get_args
+from typing import Any, Callable, get_args
 from typing import Union as TypingUnion
 
 import torch
+from arpeggio import NoMatch
+from arpeggio.cleanpeg import ParserPEG
 from sympy import *
-from sympy import Basic, Expr, srepr
+from sympy import core, srepr
 
-from qadence import QuantumCircuit, operations
+from qadence import QuantumCircuit, operations, parameters
 from qadence import blocks as qadenceblocks
 from qadence.blocks import AbstractBlock
 from qadence.blocks.utils import tag
 from qadence.logger import get_logger
-from qadence.ml_tools.models import TransformedModule
-from qadence.models import QNN, QuantumModel
+from qadence.models import QuantumModel
 from qadence.parameters import Parameter
 from qadence.register import Register
 from qadence.types import SerializationFormat
@@ -43,27 +48,172 @@ SUPPORTED_OBJECTS = [
     AbstractBlock,
     QuantumCircuit,
     QuantumModel,
-    QNN,
-    TransformedModule,
     Register,
-    Basic,
+    core.Basic,
     torch.nn.Module,
 ]
 SUPPORTED_TYPES = TypingUnion[
     AbstractBlock,
     QuantumCircuit,
     QuantumModel,
-    QNN,
-    TransformedModule,
     Register,
-    Basic,
+    core.Basic,
     torch.nn.Module,
 ]
 
-
 ALL_BLOCK_NAMES = [
     n for n in dir(qadenceblocks) if not (n.startswith("__") and n.endswith("__"))
 ] + [n for n in dir(operations) if not (n.startswith("__") and n.endswith("__"))]
+SYMPY_EXPRS = [n for n in dir(core) if not (n.startswith("__") and n.endswith("__"))]
+QADENCE_PARAMETERS = [n for n in dir(parameters) if not (n.startswith("__") and n.endswith("__"))]
+
+
+THIS_PATH = Path(__file__).parent
+GRAMMAR_FILE = THIS_PATH / "serial_expr_grammar.peg"
+
+
+@lru_cache
+def _parser_fn() -> ParserPEG:
+    with open(GRAMMAR_FILE, "r") as f:
+        grammar = f.read()
+    return ParserPEG(grammar, "Program")
+
+
+_parsing_serialize_expr = _parser_fn()
+
+
+def parse_expr_fn(code: str) -> bool:
+    """
+    A parsing expressions function that checks whether a given code is valid on.
+
+    the parsing grammar. The grammar is defined to be compatible with `sympy`
+    expressions, such as `Float('-0.33261030434342942', precision=53)`, while
+    avoiding code injection such as `2*3` or `__import__('os').system('ls -la')`.
+
+    Args:
+        code (str): code to be parsed and checked.
+
+    Returns:
+        Boolean indicating whether the code matches the defined grammar or not.
+    """
+
+    parser = _parsing_serialize_expr
+    try:
+        parser.parse(code)
+    except NoMatch:
+        return False
+    else:
+        return True
+
+
+@dataclass
+class SerializationModel:
+    """
+    A serialization model class to serialize data from `QuantumModel`s,.
+
+    `torch.nn.Module` and similar structures. The data included in the
+    serialization logic includes: the `AbstractBlock` and its children
+    classes, `QuantumCircuit`, `Register`, and `sympy` expressions
+    (including `Parameter` class from `qadence.parameters`).
+
+    A children class must define the `value` attribute type and how to
+    handle it, since it is the main property for the class to be used
+    by the serialization process. For instance:
+
+    ```python
+    @dataclass
+    class QuantumCircuitSerialization(SerializationModel):
+        value: QuantumCircuit = dataclass_field(init=False)
+
+        def __post_init__(self) -> None:
+            self.value = (
+                QuantumCircuit._from_dict(self.d)
+                if isinstance(self.d, dict)
+                else self.d
+            )
+    ```
+    """
+
+    d: dict = dataclass_field(default_factory=dict)
+    value: Any = dataclass_field(init=False)
+
+
+@dataclass
+class BlockTypeSerialization(SerializationModel):
+    value: AbstractBlock = dataclass_field(init=False)
+
+    def __post_init__(self) -> None:
+        block = (
+            getattr(operations, self.d["type"])
+            if hasattr(operations, self.d["type"])
+            else getattr(qadenceblocks, self.d["type"])
+        )._from_dict(self.d)
+        if self.d["tag"] is not None:
+            block = tag(block, self.d["tag"])
+        self.value = block
+
+
+@dataclass
+class QuantumCircuitSerialization(SerializationModel):
+    value: QuantumCircuit = dataclass_field(init=False)
+
+    def __post_init__(self) -> None:
+        self.value = QuantumCircuit._from_dict(self.d) if isinstance(self.d, dict) else self.d
+
+
+@dataclass
+class RegisterSerialization(SerializationModel):
+    value: Register = dataclass_field(init=False)
+
+    def __post_init__(self) -> None:
+        self.value = Register._from_dict(self.d)
+
+
+@dataclass
+class ModelSerialization(SerializationModel):
+    as_torch: bool = False
+    value: torch.nn.Module = dataclass_field(init=False)
+
+    def __post_init__(self) -> None:
+        module_name = list(self.d.keys())[0]
+        obj = globals().get(module_name, None)
+        if obj is None:
+            obj = self._resolve_module(module_name)
+        if hasattr(obj, "_from_dict"):
+            self.value = obj._from_dict(self.d, self.as_torch)
+        elif hasattr(obj, "load_state_dict"):
+            self.value = obj.load_state_dict(self.d[module_name])
+        else:
+            msg = (
+                f"Unable to deserialize object '{module_name}'. "
+                f"Supported types are {SUPPORTED_OBJECTS}."
+            )
+            logger.error(TypeError(msg))
+            raise TypeError(msg)
+
+    @staticmethod
+    def _resolve_module(module: str) -> Any:
+        for loaded_module in sys.modules.keys():
+            if "qadence" in loaded_module:
+                obj = getattr(sys.modules[loaded_module], module, None)
+                if obj:
+                    return obj
+        raise ValueError(f"Couldn't resolve module '{module}'.")
+
+
+@dataclass
+class ExpressionSerialization(SerializationModel):
+    value: str | core.Expr | float = dataclass_field(init=False)
+
+    def __post_init__(self) -> None:
+        if parse_expr_fn(self.d["expression"]):
+            expr = eval(self.d["expression"])
+            if hasattr(expr, "free_symbols"):
+                for s in expr.free_symbols:
+                    s.value = float(self.d["symbols"][s.name]["value"])
+            self.value = expr
+        else:
+            raise ValueError(f"Invalid expression: {self.d['expression']}")
 
 
 def save_pt(d: dict, file_path: str | Path) -> None:
@@ -94,11 +244,11 @@ def serialize(obj: SUPPORTED_TYPES, save_params: bool = False) -> dict:
     """
     Supported Types:
 
-    AbstractBlock | QuantumCircuit | QuantumModel | TransformedModule | Register | Module
+    AbstractBlock | QuantumCircuit | QuantumModel | torch.nn.Module | Register | Module
     Serializes a qadence object to a dictionary.
 
     Arguments:
-        obj (AbstractBlock | QuantumCircuit | QuantumModel | Register | Module):
+        obj (AbstractBlock | QuantumCircuit | QuantumModel | Register | torch.nn.Module):
     Returns:
         A dict.
 
@@ -132,21 +282,28 @@ def serialize(obj: SUPPORTED_TYPES, save_params: bool = False) -> dict:
     """
     if not isinstance(obj, get_args(SUPPORTED_TYPES)):
         logger.error(TypeError(f"Serialization of object type {type(obj)} not supported."))
-    d: dict = {}
+
+    d: dict = dict()
     try:
-        if isinstance(obj, Expr):
-            symb_dict = {}
+        if isinstance(obj, core.Expr):
+            symb_dict = dict()
             expr_dict = {"name": str(obj), "expression": srepr(obj)}
-            symbs: set[Parameter | Basic] = obj.free_symbols
+            symbs: set[Parameter | core.Basic] = obj.free_symbols
             if symbs:
                 symb_dict = {"symbols": {str(s): s._to_dict() for s in symbs}}
             d = {**expr_dict, **symb_dict}
-        elif isinstance(obj, (QuantumModel, QNN, TransformedModule)):
-            d = obj._to_dict(save_params)
-        elif isinstance(obj, torch.nn.Module):
-            d = {type(obj).__name__: obj.state_dict()}
         else:
-            d = obj._to_dict()
+            if hasattr(obj, "_to_dict"):
+                model_to_dict: Callable = obj._to_dict
+                d = (
+                    model_to_dict(save_params)
+                    if isinstance(obj, torch.nn.Module)
+                    else model_to_dict()
+                )
+            elif hasattr(obj, "state_dict"):
+                d = {type(obj).__name__: obj.state_dict()}
+            else:
+                raise ValueError(f"Cannot serialize object {obj}.")
     except Exception as e:
         logger.error(f"Serialization of object {obj} failed due to {e}")
     return d
@@ -156,13 +313,14 @@ def deserialize(d: dict, as_torch: bool = False) -> SUPPORTED_TYPES:
     """
     Supported Types:
 
-    AbstractBlock | QuantumCircuit | QuantumModel | TransformedModule | Register | Module
+    AbstractBlock | QuantumCircuit | QuantumModel | Register | torch.nn.Module
     Deserializes a dict to one of the supported types.
 
     Arguments:
         d (dict): A dict containing a serialized object.
+        as_torch (bool): Whether to transform to torch for the deserialized object.
     Returns:
-        AbstractBlock, QuantumCircuit, QuantumModel, TransformedModule, Register, Module.
+        AbstractBlock, QuantumCircuit, QuantumModel, Register, torch.nn.Module.
 
     Examples:
     ```python exec="on" source="material-block" result="json"
@@ -192,51 +350,18 @@ def deserialize(d: dict, as_torch: bool = False) -> SUPPORTED_TYPES:
     assert torch.isclose(qm.expectation({}), qm_deserialized.expectation({}))
     ```
     """
-    obj: Any
+    obj: SerializationModel
     if d.get("expression"):
-        expr = eval(d["expression"])
-        if hasattr(expr, "free_symbols"):
-            for symb in expr.free_symbols:
-                symb.value = float(d["symbols"][symb.name]["value"])
-        obj = expr
-    elif d.get("QuantumModel"):
-        obj = QuantumModel._from_dict(d, as_torch)
-    elif d.get("QNN"):
-        obj = QNN._from_dict(d, as_torch)
-    elif d.get("TransformedModule"):
-        obj = TransformedModule._from_dict(d, as_torch)
+        obj = ExpressionSerialization(d)
     elif d.get("block") and d.get("register"):
-        obj = QuantumCircuit._from_dict(d)
+        obj = QuantumCircuitSerialization(d)
     elif d.get("graph"):
-        obj = Register._from_dict(d)
+        obj = RegisterSerialization(d)
     elif d.get("type"):
-        if d["type"] in ALL_BLOCK_NAMES:
-            block: AbstractBlock = (
-                getattr(operations, d["type"])._from_dict(d)
-                if hasattr(operations, d["type"])
-                else getattr(qadenceblocks, d["type"])._from_dict(d)
-            )
-            if d["tag"] is not None:
-                block = tag(block, d["tag"])
-            obj = block
+        obj = BlockTypeSerialization(d)
     else:
-        import warnings
-
-        msg = warnings.warn(
-            "In order to load a custom torch.nn.Module, make sure its imported in the namespace."
-        )
-        try:
-            module_name = list(d.keys())[0]
-            obj = getattr(globals(), module_name)
-            obj.load_state_dict(d[module_name])
-        except Exception as e:
-            logger.error(
-                TypeError(
-                    f"{msg}. Unable to deserialize object due to {e}.\
-                    Supported objects are: {SUPPORTED_OBJECTS}"
-                )
-            )
-    return obj
+        obj = ModelSerialization(d, as_torch=as_torch)
+    return obj.value
 
 
 def save(

qadence/utils.py

@@ -154,11 +154,17 @@ def format_number(x: float | complex, num_digits: int = 3) -> str:
         raise ValueError(f"Unknown number type: {type(x)}")
 
 
-def format_parameter(p: sympy.Basic) -> str:
+def format_parameter(p: sympy.Basic, num_digits: int = 3) -> str:
+    """Format numerical values within a sympy expression."""
+
     def round_expr(expr: sympy.Basic, num_digits: int) -> sympy.Basic:
         return expr.xreplace({n: round(n, num_digits) for n in expr.atoms(sympy.Number)})
 
-    return str(round_expr(p, 3))
+    expr = round_expr(p, num_digits)
+    conv_str = str(expr)
+    if expr.is_real and len(conv_str) > num_digits + 2:
+        conv_str = conv_str[0 : num_digits + 2]
+    return conv_str
 
 
 def print_sympy_expr(expr: sympy.Expr, num_digits: int = 3) -> str:

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

@@ -1,8 +1,8 @@
 Metadata-Version: 2.3
 Name: qadence
-Version: 1.5.0
+Version: 1.5.2
 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>
+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>
 License: Apache 2.0
 License-File: LICENSE
 Classifier: License :: OSI Approved :: Apache Software License
@@ -14,6 +14,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: <3.13,>=3.9
+Requires-Dist: arpeggio==2.0.2
 Requires-Dist: deepdiff
 Requires-Dist: jsonschema
 Requires-Dist: matplotlib
@@ -27,7 +28,7 @@ Requires-Dist: sympytorch>=0.1.2
 Requires-Dist: tensorboard>=2.12.0
 Requires-Dist: torch
 Provides-Extra: all
-Requires-Dist: amazon-braket-sdk; extra == 'all'
+Requires-Dist: amazon-braket-sdk==1.71.0; extra == 'all'
 Requires-Dist: graphviz; extra == 'all'
 Requires-Dist: libs; extra == 'all'
 Requires-Dist: protocols; extra == 'all'
@@ -53,19 +54,21 @@ Provides-Extra: visualization
 Requires-Dist: graphviz; extra == 'visualization'
 Description-Content-Type: text/markdown
 
-<picture>
-  <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>
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="./docs/extras/assets/logo/qadence_logo_white.svg" width="75%">
+    <source media="(prefers-color-scheme: light)" srcset="./docs/extras/assets/logo/qadence_logo.svg" width="75%">
+    <img alt="Qadence logo" src="./docs/assets/logo/qadence_logo.svg" width="75%">
+  </picture>
+</p>
+
+**Qadence** is a Python package that provides a simple interface to build **digital-analog quantum
+programs** with tunable qubit interactions and arbitrary register topologies realizable on neutral atom devices.
 
 **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.
-
 [![Linting](https://github.com/pasqal-io/qadence/actions/workflows/lint.yml/badge.svg)](https://github.com/pasqal-io/qadence/actions/workflows/lint.yml)
 [![Tests](https://github.com/pasqal-io/qadence/actions/workflows/test_fast.yml/badge.svg)](https://github.com/pasqal-io/qadence/actions/workflows/test_fast.yml)
 [![Documentation](https://github.com/pasqal-io/qadence/actions/workflows/build_docs.yml/badge.svg)](https://pasqal-io.github.io/qadence/latest)
@@ -74,27 +77,26 @@ 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>
-
+<p align="center">
+  <picture>
+    <source media="(prefers-color-scheme: dark)" srcset="./docs/extras/assets/qadence_arch.svg" width="75%">
+    <source media="(prefers-color-scheme: light)" srcset="./docs/extras/assets/qadence_arch.svg" width="75%">
+    <img alt="Qadence architecture" src="./docs/assets/qadence_arch.svg" width="75%">
+  </picture>
+<p align="center">
 
-* A [block-based system](docs/tutorials/getting_started.md) for composing _**complex digital-analog
+* A [block-based system](docs/content/block_system.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.
 
-* A [simple interface](docs/digital_analog_qc/analog-basics.md) to work with _**interacting neutral-atom qubit systems**_
-  using [arbitrary registers topologies](docs/tutorials/register.md).
-
-* An intuitive [expression-based system](docs/tutorials/parameters.md) developed on top of the symbolic library [Sympy](https://www.sympy.org/en/index.html) to construct _**parametric quantum programs**_ easily.
-
-* [High-order generalized parameter shift rules](docs/advanced_tutorials/differentiability.md) for _**differentiating parametrized quantum operations**_.
+* An intuitive [expression-based system](docs/content/parameters.md) developed on top of the symbolic library [Sympy](https://www.sympy.org/en/index.html) to construct _**parametric quantum programs**_ easily.
 
 * Out-of-the-box _**automatic differentiability**_ of quantum programs with [PyTorch](https://pytorch.org/) integration.
 
-* _**Efficient execution**_ on a variety of different purpose backends: from state vector simulators to tensor network emulators and real devices.
+* [High-order generalized parameter shift rules](docs/tutorials/advanced_tutorials/differentiability.md) for _**differentiating parametrized quantum operations**_.
+
+* A [simple interface](docs/tutorials/digital_analog_qc/analog-basics.md) to work with _**interacting neutral-atom qubit systems**_
+  using [arbitrary registers topologies](docs/content/register.md).
 
 ## Installation guide
 
@@ -106,11 +108,10 @@ pip install qadence
 
 The default, pre-installed backend for Qadence is [PyQTorch](https://github.com/pasqal-io/pyqtorch), a differentiable state vector simulator for digital-analog simulation based on `PyTorch`. It is possible to install additional, `PyTorch` -based backends and the circuit visualization library using the following extras:
 
-* `pulser`: The [Pulser](https://github.com/pasqal-io/Pulser) backend for composing, simulating and executing pulse sequences for neutral-atom quantum devices.
-* `braket`: The [Braket](https://github.com/amazon-braket/amazon-braket-sdk-python) backend, an open source library that provides a framework for interacting with quantum computing hardware devices through Amazon Braket.
 * `visualization`: A visualization library to display quantum circuit diagrams.
 * `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.
+* `pulser`: The [Pulser](https://github.com/pasqal-io/Pulser) backend for composing, simulating and executing pulse sequences for neutral-atom quantum devices (experimental).
 
 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).
 
@@ -118,7 +119,7 @@ Qadence also supports a `JAX` engine which is currently supporting the [Horqrux]
 To install individual extras, use the following syntax (**IMPORTANT** Make sure to use quotes):
 
 ```bash
-pip install "qadence[braket,pulser,visualization]"
+pip install "qadence[pulser,visualization]"
 ```
 
 To install all available extras, simply do:
@@ -144,10 +145,10 @@ conda install python-graphviz
 
 ## Contributing
 
-Before making a contribution, please review our [code of conduct](docs/CODE_OF_CONDUCT.md).
+Before making a contribution, please review our [code of conduct](docs/getting_started/CODE_OF_CONDUCT.md).
 
 - **Submitting Issues:** To submit bug reports or feature requests, please use our [issue tracker](https://github.com/pasqal-io/qadence/issues).
-- **Developing in qadence:** To learn more about how to develop within `qadence`, please refer to [contributing guidelines](docs/CONTRIBUTING.md).
+- **Developing in qadence:** To learn more about how to develop within `qadence`, please refer to [contributing guidelines](docs/getting_started/CONTRIBUTING.md).
 
 ### Setting up qadence in development mode
 

{qadence-1.5.0.dist-info → qadence-1.5.2.dist-info}/RECORD

@@ -1,5 +1,5 @@
 qadence/__init__.py,sha256=-UKQQ_dYiaa7viishl2baAbxS82eS6dAoCnq_CLSmao,1708
-qadence/backend.py,sha256=5sfXUTRts_13v6lajq1Wvy3u_eOCOeIYnTiaZV_NGFQ,15493
+qadence/backend.py,sha256=qxTCLfSqjtFAxlu3QgNj_npx_xbY9P2f3SP0mFkL-e8,14410
 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
@@ -14,10 +14,11 @@ qadence/protocols.py,sha256=bcYTxSjgMPV-a-D6yv90jCpnGik8myzaNpFv9z1gzJ0,442
 qadence/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qadence/qubit_support.py,sha256=Nkn1Q01RVViTcggSIom7EFKdWpAuM4TMGwBZ5feCUxA,2120
 qadence/register.py,sha256=cBMzwZ7GWZ5ieuFt0bpproEI6a2ncNwfjj7ic379zyg,10276
-qadence/serialization.py,sha256=BmBCFVAeLOL7KCYhUIN38cA43mA0tc5R7l0Fm2xtABU,11702
+qadence/serial_expr_grammar.peg,sha256=z5ytL7do9kO8o4h-V5GrsDuLdso0KsRcMuIYURFfmAY,328
+qadence/serialization.py,sha256=ra6oBB2KPDj0BlAL2fWqOSce9IBCfZuSKgFlh0Zjv-A,15695
 qadence/states.py,sha256=_J__vZuDPsKqKDFSCfgWxSNY2Ho6cCqTHjJ9-gMtd8M,14341
 qadence/types.py,sha256=cA3L3hlPW320_03n8_weCuAUXmDX5Jq3puawtkgOK7s,9699
-qadence/utils.py,sha256=c8qzsW1wtkBNhYW_aJwh40Jo9qqw6railN85KmTm7Qs,8829
+qadence/utils.py,sha256=tSLXSt8pC1Oixs3gmgkAkHYG9MEH_Dfzyt6uxYfWhwg,9065
 qadence/analog/__init__.py,sha256=BCyS9R4KUjzUXN0Ax3b0eMo8ZAuSkGoJQVtZ4_pvAFs,279
 qadence/analog/addressing.py,sha256=fu5-xW9lquEbagApNp23S_ET1kl0iDtZUrIYSVNmw9s,6435
 qadence/analog/constants.py,sha256=B2phQoN1ASL8CwM-Dsa1rbraYwGwwPSeiB3HbVe-MPA,1243
@@ -31,15 +32,15 @@ qadence/backends/gpsr.py,sha256=227h5KPI_KStrwfP5zuwkzOqviRZmqa7ijIIhhawwPM,4341
 qadence/backends/jax_utils.py,sha256=VfKhqCKknHDWZO21UFipWH_Lkiq175Z5GkP49gWjbyw,5038
 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/backend.py,sha256=XRrrkdylsH8GejbtY8fSJMmX2X7xWmZmEZPxcqWWM5E,8729
 qadence/backends/braket/config.py,sha256=b9aIdma0DRwC_3A6xUSLdXMCZe6z6kDcAgkp6MxcXIk,603
 qadence/backends/braket/convert_ops.py,sha256=DVXV7sT9sX_yGOgPKclD9KIGgmbBRuDy_e39i1Z8I1s,3417
 qadence/backends/horqrux/__init__.py,sha256=0OdVy6cq0oQggV48LO1WXdaZuSkDkz7OYNEPIkNAmfk,140
-qadence/backends/horqrux/backend.py,sha256=qdThkUXbhDrsD1lAio2SFsxdYATxLVXoNsuXNcD3ZBU,9330
+qadence/backends/horqrux/backend.py,sha256=ZOkkklcqqM0T5CTwfSpNAAcW_a0l922h48gj6kPNw4I,9329
 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=3p9cB5QN60nzqhWvdLZol0t66PugaWqvWHdDEXgGRwM,13868
+qadence/backends/pulser/backend.py,sha256=ZxGg9zLyGTg3gJAZXTL7b96PHvhmN5D4yOAAdnVgLu4,13867
 qadence/backends/pulser/channels.py,sha256=ZF0yEXUFHAmi3IdeXjzdTNGR5NzaRRFTiUpUGVg2sO4,329
 qadence/backends/pulser/cloud.py,sha256=0uUluvbFV9sOuCPraE-9uiVtC3Q8QaDY1IJMDi8grDM,2057
 qadence/backends/pulser/config.py,sha256=1qu_GhGTGcCpFoKctGt_IhKOKWiMcJIL2vHTFJg9I3E,3122
@@ -48,7 +49,7 @@ qadence/backends/pulser/devices.py,sha256=DermLZNfmCB3SqteKVW4uhg4jp6ya1G6ptnXbB
 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=hNo9nKxfJ3rFDEPjZOhfmbKUUVsNzTl0aRh9sgeKlqc,9763
+qadence/backends/pyqtorch/backend.py,sha256=eaC-yV-Ckgq6YCq1UrrOh6Ug_vFHmUR43RQBiXfcv1Q,9762
 qadence/backends/pyqtorch/config.py,sha256=f5BjWehCqm9do2OahNWrv2w55y3orkw0Wj2f6flwRaU,1907
 qadence/backends/pyqtorch/convert_ops.py,sha256=By_p1-Oem8MhHYP8jx5qdut9lhDWN0xc4B9YaP0MSxA,17512
 qadence/blocks/__init__.py,sha256=H6jEA_CptkE-eoB4UfSbUiDszbxxhZwECV_TgoZWXoU,960
@@ -105,18 +106,18 @@ qadence/mitigations/readout.py,sha256=HPfYmdjRlieUdOBMZTghFK4DRWfveM4KkDkEI0bMI0
 qadence/ml_tools/__init__.py,sha256=_H5A_BWZRZVGoJszb9s8XRJnLnJxUNfYjuT9HT2yASo,786
 qadence/ml_tools/config.py,sha256=X8dHyjq4D9-ITjs7UQo0vjJTcHkpbZC0gChH5eEN2G8,2356
 qadence/ml_tools/data.py,sha256=8ZUFjhQSp94w7icX7RzM2J39Yo7P_T-AgjcThBc8miI,4283
-qadence/ml_tools/models.py,sha256=biUWnqXKmGMJfT-QObJ-cQ6770YIfOTz-o28EKPkM3Q,11736
+qadence/ml_tools/models.py,sha256=-9XOmMRXQDI5fAjlrqlSGI7vCV3DKJVmRdngu98QroM,12476
 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=b_FxOkK3QoLAOwSowjkkMIjlBEDjoLcjeo3Vk_RHhkc,7399
+qadence/ml_tools/train_grad.py,sha256=zNzkgK73OtIllc8JLTqaM8P9m233BGa116HelsQBQqU,7727
 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=ucExUBPBYWrC7mLF4SQbvHqjdXmkEi7-wIdXqpfaGew,14107
+qadence/models/quantum_model.py,sha256=SetO2TPd9pe2QcNCcfdHKtGM1Rj-bhCTOsaExq7smnY,14186
 qadence/noise/__init__.py,sha256=r0nR8uEZeB1M9pI2UisjWq0bjw50fPFfVGzIMev923g,147
 qadence/noise/protocols.py,sha256=-aZ06JvMnpxCeT5v5lI_RNPOLbb9Ju1Pi1AB6uAXxVE,1653
 qadence/noise/readout.py,sha256=BqBIZbPXWqZaKi6EpBSpXXQ9NhQXdQ-YL6ZmwbSjgfE,6736
@@ -134,7 +135,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.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.5.2.dist-info/METADATA,sha256=19euItyRCLcNIYDi0bnc0RRw4eJBL7_zFAI6A7aW9xo,8931
+qadence-1.5.2.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
+qadence-1.5.2.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+qadence-1.5.2.dist-info/RECORD,,

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

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