qadence 1.1.1__py3-none-any.whl → 1.2.1__py3-none-any.whl

qadence/register.py

@@ -11,12 +11,16 @@ import numpy as np
 from deepdiff import DeepDiff
 from networkx.classes.reportviews import EdgeView, NodeView
 
+from qadence.analog import IdealDevice, RydbergDevice
 from qadence.types import LatticeTopology
 
 # Modules to be automatically added to the qadence namespace
 __all__ = ["Register"]
 
 
+DEFAULT_DEVICE = IdealDevice()
+
+
 def _scale_node_positions(graph: nx.Graph, min_distance: float, spacing: float) -> None:
     scaled_nodes = {}
     scale_factor = spacing / min_distance
@@ -27,8 +31,14 @@ def _scale_node_positions(graph: nx.Graph, min_distance: float, spacing: float)
 
 
 class Register:
-    def __init__(self, support: nx.Graph | int, spacing: float | None = 1.0):
-        """A 2D register of qubits which includes their coordinates.
+    def __init__(
+        self,
+        support: nx.Graph | int,
+        spacing: float | None = 1.0,
+        device_specs: RydbergDevice = DEFAULT_DEVICE,
+    ):
+        """
+        A 2D register of qubits which includes their coordinates.
 
         It is needed for e.g. analog computing.
         The coordinates are ignored in backends that don't need them. The easiest
@@ -52,21 +62,16 @@ class Register:
         reg.draw()
         ```
         """
-        self.graph = support if isinstance(support, nx.Graph) else alltoall_graph(support)
+        if device_specs is not None and not isinstance(device_specs, RydbergDevice):
+            raise ValueError("Device specs are not valid. Please pass a `RydbergDevice` instance.")
 
-        # Auxiliary complete graph
-        support = self.graph.nodes
-        all_edges = list(filter(lambda x: x[0] < x[1], product(support, support)))
-        self.complete_graph = nx.Graph()
-        self.complete_graph.add_nodes_from(support)
-        self.complete_graph.add_edges_from(all_edges)
+        self.device_specs = device_specs
+
+        self.graph = support if isinstance(support, nx.Graph) else alltoall_graph(support)
 
         if spacing is not None and self.min_distance != 0.0:
             _scale_node_positions(self.graph, self.min_distance, spacing)
 
-        pos_values = nx.get_node_attributes(self.graph, "pos")
-        nx.set_node_attributes(self.complete_graph, pos_values, "pos")
-
     @property
     def n_qubits(self) -> int:
         return len(self.graph)
@@ -77,27 +82,43 @@ class Register:
         coords: list[tuple],
         lattice: LatticeTopology | str = LatticeTopology.ARBITRARY,
         spacing: float | None = None,
+        device_specs: RydbergDevice = DEFAULT_DEVICE,
     ) -> Register:
         graph = nx.Graph()
         for i, pos in enumerate(coords):
             graph.add_node(i, pos=pos)
-        return cls(graph, spacing)
+        return cls(graph, spacing, device_specs)
 
     @classmethod
-    def line(cls, n_qubits: int, spacing: float = 1.0) -> Register:
-        return cls(line_graph(n_qubits), spacing)
+    def line(
+        cls,
+        n_qubits: int,
+        spacing: float = 1.0,
+        device_specs: RydbergDevice = DEFAULT_DEVICE,
+    ) -> Register:
+        return cls(line_graph(n_qubits), spacing, device_specs)
 
     @classmethod
-    def circle(cls, n_qubits: int, spacing: float = 1.0) -> Register:
+    def circle(
+        cls,
+        n_qubits: int,
+        spacing: float = 1.0,
+        device_specs: RydbergDevice = DEFAULT_DEVICE,
+    ) -> Register:
         graph = nx.grid_2d_graph(n_qubits, 1, periodic=True)
         graph = nx.relabel_nodes(graph, {(i, 0): i for i in range(n_qubits)})
         coords = nx.circular_layout(graph)
         values = {i: {"pos": pos} for i, pos in coords.items()}
         nx.set_node_attributes(graph, values)
-        return cls(graph, spacing)
+        return cls(graph, spacing, device_specs)
 
     @classmethod
-    def square(cls, qubits_side: int, spacing: float = 1.0) -> Register:
+    def square(
+        cls,
+        qubits_side: int,
+        spacing: float = 1.0,
+        device_specs: RydbergDevice = DEFAULT_DEVICE,
+    ) -> Register:
         n_points = 4 * (qubits_side - 1)
 
         def gen_points() -> np.ndarray:
@@ -122,35 +143,52 @@ class Register:
         graph = nx.relabel_nodes(graph, {(i, 0): i for i in range(n_points)})
         values = {i: {"pos": point} for i, point in zip(graph.nodes, gen_points())}
         nx.set_node_attributes(graph, values)
-        return cls(graph, spacing)
+        return cls(graph, spacing, device_specs)
 
     @classmethod
-    def all_to_all(cls, n_qubits: int, spacing: float = 1.0) -> Register:
-        return cls(alltoall_graph(n_qubits), spacing)
+    def all_to_all(
+        cls,
+        n_qubits: int,
+        spacing: float = 1.0,
+        device_specs: RydbergDevice = DEFAULT_DEVICE,
+    ) -> Register:
+        return cls(alltoall_graph(n_qubits), spacing, device_specs)
 
     @classmethod
     def rectangular_lattice(
-        cls, qubits_row: int, qubits_col: int, spacing: float = 1.0
+        cls,
+        qubits_row: int,
+        qubits_col: int,
+        spacing: float = 1.0,
+        device_specs: RydbergDevice = DEFAULT_DEVICE,
     ) -> Register:
         graph = nx.grid_2d_graph(qubits_col, qubits_row)
         values = {i: {"pos": node} for (i, node) in enumerate(graph.nodes)}
         graph = nx.relabel_nodes(graph, {(i, j): k for k, (i, j) in enumerate(graph.nodes)})
         nx.set_node_attributes(graph, values)
-        return cls(graph, spacing)
+        return cls(graph, spacing, device_specs)
 
     @classmethod
     def triangular_lattice(
-        cls, n_cells_row: int, n_cells_col: int, spacing: float = 1.0
+        cls,
+        n_cells_row: int,
+        n_cells_col: int,
+        spacing: float = 1.0,
+        device_specs: RydbergDevice = DEFAULT_DEVICE,
     ) -> Register:
-        return cls(triangular_lattice_graph(n_cells_row, n_cells_col), spacing)
+        return cls(triangular_lattice_graph(n_cells_row, n_cells_col), spacing, device_specs)
 
     @classmethod
     def honeycomb_lattice(
-        cls, n_cells_row: int, n_cells_col: int, spacing: float = 1.0
+        cls,
+        n_cells_row: int,
+        n_cells_col: int,
+        spacing: float = 1.0,
+        device_specs: RydbergDevice = DEFAULT_DEVICE,
     ) -> Register:
         graph = nx.hexagonal_lattice_graph(n_cells_row, n_cells_col)
         graph = nx.relabel_nodes(graph, {(i, j): k for k, (i, j) in enumerate(graph.nodes)})
-        return cls(graph, spacing)
+        return cls(graph, spacing, device_specs)
 
     @classmethod
     def lattice(cls, topology: LatticeTopology | str, *args: Any, **kwargs: Any) -> Register:
@@ -166,25 +204,29 @@ class Register:
         return self.graph.nodes[item]
 
     @property
-    def support(self) -> set:
-        return set(self.graph.nodes)
-
-    @property
-    def coords(self) -> dict:
-        return {i: tuple(node.get("pos", ())) for i, node in self.graph.nodes.items()}
+    def nodes(self) -> NodeView:
+        return self.graph.nodes
 
     @property
     def edges(self) -> EdgeView:
         return self.graph.edges
 
     @property
-    def all_edges(self) -> EdgeView:
-        return self.complete_graph.edges
+    def support(self) -> set:
+        return set(self.nodes)
+
+    @property
+    def coords(self) -> dict:
+        return {i: tuple(node.get("pos", ())) for i, node in self.nodes.items()}
+
+    @property
+    def all_node_pairs(self) -> EdgeView:
+        return list(filter(lambda x: x[0] < x[1], product(self.support, self.support)))
 
     @property
     def distances(self) -> dict:
         coords = self.coords
-        return {edge: dist(coords[edge[0]], coords[edge[1]]) for edge in self.all_edges}
+        return {edge: dist(coords[edge[0]], coords[edge[1]]) for edge in self.all_node_pairs}
 
     @property
     def edge_distances(self) -> dict:
@@ -197,21 +239,27 @@ class Register:
         value: float = min(self.distances.values()) if len(distances) > 0 else 0.0
         return value
 
-    @property
-    def nodes(self) -> NodeView:
-        return self.graph.nodes
-
     def rescale_coords(self, scaling: float) -> Register:
         g = deepcopy(self.graph)
         _scale_node_positions(g, min_distance=1.0, spacing=scaling)
-        return Register(g, spacing=None)
+        return Register(g, spacing=None, device_specs=self.device_specs)
 
     def _to_dict(self) -> dict:
-        return {"graph": nx.node_link_data(self.graph)}
+        return {
+            "graph": nx.node_link_data(self.graph),
+            "device_specs": self.device_specs._to_dict(),
+        }
 
     @classmethod
     def _from_dict(cls, d: dict) -> Register:
-        return cls(nx.node_link_graph(d["graph"]))
+        device_dict = d.get("device_specs", None)
+        if device_dict is None:
+            device_dict = DEFAULT_DEVICE._to_dict()
+
+        return cls(
+            support=nx.node_link_graph(d["graph"]),
+            device_specs=RydbergDevice._from_dict(device_dict),
+        )
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, Register):

qadence/transpile/__init__.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from .apply_fn import apply_fn_to_blocks
 from .block import (
     chain_single_qubit_ops,
     repeat,

qadence/transpile/apply_fn.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+
+from qadence.blocks import AbstractBlock, CompositeBlock, add, chain, kron
+from qadence.blocks.analog import AnalogChain
+
+COMPOSE_FN_DICT = {
+    "ChainBlock": chain,
+    "AnalogChain": chain,
+    "KronBlock": kron,
+    "AnalogKron": kron,
+    "AddBlock": add,
+}
+
+
+def apply_fn_to_blocks(
+    input_block: AbstractBlock, block_fn: Callable, *args: Any, **kwargs: Any
+) -> AbstractBlock:
+    """
+    Recurses through the block tree and applies a given function to all the leaf blocks.
+
+    Arguments:
+        input_block: tree of blocks on which to apply the recurse.
+        block_fn: callable function to apply to each leaf block.
+        args: any positional arguments to pass to the leaf function.
+        kwargs: any keyword arguments to pass to the leaf function.
+    """
+
+    if isinstance(input_block, (CompositeBlock, AnalogChain)):
+        parsed_blocks = [
+            apply_fn_to_blocks(block, block_fn, *args, **kwargs) for block in input_block.blocks
+        ]
+        compose_fn = COMPOSE_FN_DICT[type(input_block).__name__]
+        output_block = compose_fn(*parsed_blocks)  # type: ignore [arg-type]
+    else:
+        # AnalogKrons are considered as a leaf block
+        output_block = block_fn(input_block, *args, **kwargs)
+
+    return output_block

qadence/types.py

@@ -2,10 +2,11 @@ from __future__ import annotations
 
 import importlib
 from enum import Enum
-from typing import Iterable, Tuple, Union
+from typing import Callable, Iterable, Tuple, Union
 
 import numpy as np
 import sympy
+from numpy.typing import ArrayLike
 from torch import Tensor, pi
 
 TNumber = Union[int, float, complex]
@@ -39,6 +40,7 @@ __all__ = [
     "DiffMode",
     "BackendName",
     "Interaction",
+    "DeviceType",
     "OverlapMethod",
     "AlgoHEvo",
     "SerializationFormat",
@@ -163,7 +165,7 @@ class QubitSupportType(StrEnum):
 class Interaction(StrEnum):
     """Interaction types used in.
 
-    - `add_interaction`.
+    - `RydbergDevice`.
     - [`hamiltonian_factory`][qadence.constructors.hamiltonians.hamiltonian_factory].
     """
 
@@ -177,6 +179,16 @@ class Interaction(StrEnum):
     """XYZ Interaction."""
 
 
+class DeviceType(StrEnum):
+    """Supported types of devices for Pulser backend."""
+
+    IDEALIZED = "IdealDevice"
+    """Idealized device, least realistic."""
+
+    REALISTIC = "RealisticDevice"
+    """Device with realistic specs."""
+
+
 class _BackendName(StrEnum):
     """The available backends for running circuits."""
 
@@ -186,6 +198,8 @@ class _BackendName(StrEnum):
     """The Braket backend."""
     PULSER = "pulser"
     """The Pulser backend."""
+    HORQRUX = "horqrux"
+    """The horqrux backend."""
 
 
 # If proprietary qadence_extensions is available, import the
@@ -368,3 +382,19 @@ class OpName(StrEnum):
     """The entanglement operation."""
     WAIT = "wait"
     """The wait operation."""
+    PROJ = "Projector"
+    """The projector operation."""
+
+
+class ReadOutOptimization(StrEnum):
+    MLE = "mle"
+    CONSTRAINED = "constrained"
+
+
+class Engine(StrEnum):
+    TORCH = "torch"
+    JAX = "jax"
+
+
+ParamDictType = dict[str, ArrayLike]
+DifferentiableExpression = Callable[..., ArrayLike]

qadence/utils.py

@@ -205,3 +205,38 @@ def _round_complex(t: torch.Tensor, decimals: int = 4) -> torch.Tensor:
 
     fn = torch.vmap(_round)
     return fn(t)
+
+
+def is_qadence_shape(state: torch.Tensor, n_qubits: int) -> bool:
+    if len(state.size()) < 2:
+        raise ValueError(
+            f"Provided state is required to have atleast two dimensions. Got shape {state.shape}"
+        )
+    return state.shape[1] == 2**n_qubits  # type: ignore[no-any-return]
+
+
+def infer_batchsize(param_values: dict[str, torch.Tensor] = None) -> int:
+    """Infer the batch_size through the length of the parameter tensors."""
+    try:
+        return max([len(tensor) for tensor in param_values.values()]) if param_values else 1
+    except Exception:
+        return 1
+
+
+def validate_values_and_state(
+    state: torch.Tensor | None, n_qubits: int, param_values: dict[str, torch.Tensor] = None
+) -> None:
+    if state is not None:
+        batch_size_state = (
+            state.shape[0] if is_qadence_shape(state, n_qubits=n_qubits) else state.size(-1)
+        )
+        batch_size_values = infer_batchsize(param_values)
+        if batch_size_state != batch_size_values and (
+            batch_size_values > 1 and batch_size_state > 1
+        ):
+            raise ValueError(
+                "Batching of parameter values and states is only valid for the cases:\
+                            (1) batch_size_values == batch_size_state\
+                            (2) batch_size_values == 1 and batch_size_state > 1\
+                            (3) batch_size_values > 1 and batch_size_state == 1."
+            )

{qadence-1.1.1.dist-info → qadence-1.2.1.dist-info}/METADATA

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

{qadence-1.1.1.dist-info → qadence-1.2.1.dist-info}/RECORD

@@ -1,63 +1,72 @@
-qadence/__init__.py,sha256=me88jOt3wtGMiobi1-956mO5sCyWYvcspbKmwADnV-4,1684
-qadence/backend.py,sha256=tBvu3P24-LDB56yKdBw-q_dM8BIXQG0GALuJvCuTI5M,14049
-qadence/circuit.py,sha256=DbRHKAqiClEUOsiuQN_EaoI4xScK2_sGk1VkOnX-NpE,7071
+qadence/__init__.py,sha256=XxVbw_UToWu0PUKxOg2C42lYT22cgQH_ysy8PRGT0q0,1707
+qadence/backend.py,sha256=M8uCxZhom7N2I454ghZBnMwy2_VoRLXoNJr1_IthNb0,15479
+qadence/circuit.py,sha256=EGBPRRWlK-mcXaaAhJnp-hxVWQ8NxngGKbvhPqrEeKM,6892
 qadence/decompose.py,sha256=_L0hI3SbYErXEDp-aXFeNk0JR9ffJ_JD_EnRJbJKT20,5230
-qadence/divergences.py,sha256=UQ9u_pyhPCAejKDOy7NFYjSlujEVvUJ3gXiUZoJbFd8,1480
+qadence/divergences.py,sha256=JhpELhWSnuDvQxa9hJp_DE3EQg2Ban-Ta0mHZ_fVrHg,1832
 qadence/execution.py,sha256=zczhPbBOf91PtAso0fe3uHxnseXyJ5QHMw7melB4XmQ,9134
-qadence/extensions.py,sha256=zMXuPhMuIAZ8rWEnL1x69gUsQpCRf8qfu0y_2Eml3b8,3952
+qadence/extensions.py,sha256=eqZ7_M2mht39zqXxWMHubDJCr9li9lLUu0XnWsfkbfE,4487
+qadence/finitediff.py,sha256=TijuaWUbX9VlbLyMYco6HkK9eCoRTVnKug4Ekd6mlTI,1592
 qadence/logger.py,sha256=mdTr52nL30ipPRwp11nIHKLEoB3hqs7J-Mric5KVfyM,912
-qadence/operations.py,sha256=OnZnhk70Z4ltr3I1oUKPFJwVKg5HYhFURNpNL-Zukhc,37250
+qadence/operations.py,sha256=7xsc3yXzngGoEHF6iaTeIHjrDKRuFhxgcxjPNoeQDH0,37143
 qadence/overlap.py,sha256=3vsg0HLOO3X8LiVgvjSc5s-cs8Di4TpEA657LWZ5HEY,17294
-qadence/parameters.py,sha256=zc4HLmHQpBoIm5ww1DdQW7DpnWrT6HKnS6Vog66jp_8,11833
+qadence/parameters.py,sha256=svZ3L-Z4pzm2PkPDIlb-DWkwGOQLAm1eECCtu7nd3W0,12334
 qadence/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qadence/qubit_support.py,sha256=Nkn1Q01RVViTcggSIom7EFKdWpAuM4TMGwBZ5feCUxA,2120
-qadence/register.py,sha256=CKLPiJzDLMp1hkeJgY3OX3LVG3Q5-EaEuMPWWVMWtpk,9172
+qadence/register.py,sha256=cBMzwZ7GWZ5ieuFt0bpproEI6a2ncNwfjj7ic379zyg,10276
 qadence/serialization.py,sha256=BmBCFVAeLOL7KCYhUIN38cA43mA0tc5R7l0Fm2xtABU,11702
 qadence/states.py,sha256=p5J4-aceTHxLK89DLC191K1H5c3y6gb2dd-I5YPqBMo,14343
-qadence/types.py,sha256=LuXxzHhUApm0rA1sSgFpTAGfzyscaxar9Fo-zK2yQ6w,8938
-qadence/utils.py,sha256=QE2SvQnrKH0WijOeDjwZQfv_GCqKNbN5WSktZBLP5Vo,6818
-qadence/analog/__init__.py,sha256=emAi8xEwuwAQKENkD6ePbTeSMmWJG-tudpZ1stnmc7M,108
-qadence/analog/interaction.py,sha256=PiYORiIZUVggWXSNljyvb_-VCHRLt76TJ8OxzgKri0Y,7440
-qadence/analog/utils.py,sha256=5uSBZq16nMtsEY27zzqtnMasefreVFhR0XEvUSWTudc,3564
-qadence/backends/__init__.py,sha256=cg7wolh0jKwwE_6JZpSFaS7GOPIr6rdYobTQnvAAwqQ,291
+qadence/types.py,sha256=pidqyNqpyeYz4KBKjK15Tm70y26FZfKDUwdfYgU9hb8,9586
+qadence/utils.py,sha256=sWHQ8C6CVhXsaZif0jKnkiOaxKTG5EXSMDfk_lXmgRE,8257
+qadence/analog/__init__.py,sha256=BCyS9R4KUjzUXN0Ax3b0eMo8ZAuSkGoJQVtZ4_pvAFs,279
+qadence/analog/addressing.py,sha256=9KsZnmf-UDCy0rco2gvatd8ERlZd0QZGwt7SS_a_DZo,6410
+qadence/analog/constants.py,sha256=B2phQoN1ASL8CwM-Dsa1rbraYwGwwPSeiB3HbVe-MPA,1243
+qadence/analog/device.py,sha256=nY6esVJEHHJjK2tRZVMjdNy0SHcP3eSGh1Zi55KcX_4,2430
+qadence/analog/hamiltonian_terms.py,sha256=9LKidqqEMJTTdXeaxkxP_otTmcv9i4yeJ-JKCLOCK3Y,3421
+qadence/analog/parse_analog.py,sha256=L2mh0uU4JwTteInR07pe5gPM4kQz17y9yS2O7n8u-SU,4070
+qadence/backends/__init__.py,sha256=ibm7wmZxuIoMYAQxgAx0MsfLYWOVHNWgLwyS1HjMuuI,215
 qadence/backends/adjoint.py,sha256=kX4QX_6UjVJcochm6dSjFHpFYmdV0DQRfXqybNnlRcU,6788
-qadence/backends/api.py,sha256=sfPGj2-NYHHKD64Z9Emg5oFa-Y4dvPUKycSNdhYaRoY,2358
+qadence/backends/api.py,sha256=6PoK4ydhi2tj9w0ePMQl1G4kEFROoWe3lrkrtQwWxkc,3224
 qadence/backends/gpsr.py,sha256=nGNdXJi59vmEhrkysRscVQbWZs34A8YW9FlD1lolt4o,4356
-qadence/backends/pytorch_wrapper.py,sha256=PoyglpSg6YGjm2P6y7-urB-oVx_Uq3HoMoyP43sFYuc,15344
-qadence/backends/utils.py,sha256=O8PD-8kPaGaSlxJ9cgP-gDlWb8qVmipXFoOk6whEl-w,6530
+qadence/backends/jax_utils.py,sha256=RMs1sSZmPANEKb7ZrMz_H2VJwkrW4WMrfPdWUd5UvKI,1350
+qadence/backends/utils.py,sha256=E-IubQ5YWJnKxXlvh0vemof1G7zSBycva2xc_8KQIts,6402
 qadence/backends/braket/__init__.py,sha256=eruyDZKMqkh1LE7eJ980vcrLJbia35uUX6krAP78clI,121
-qadence/backends/braket/backend.py,sha256=X94HzXBsdeV6STFNFHTR8PdajNYMxSiLFvzpJB6RCSU,8560
+qadence/backends/braket/backend.py,sha256=oZkLQb6kEiFporjlHqJe3j6E8mXnCJZaCi9x5SddsfY,8603
 qadence/backends/braket/config.py,sha256=b9aIdma0DRwC_3A6xUSLdXMCZe6z6kDcAgkp6MxcXIk,603
 qadence/backends/braket/convert_ops.py,sha256=D-hHfYkvxZtMaiK3I286CSsBg8vf854dEigeFgxaQ5Y,3422
-qadence/backends/pulser/__init__.py,sha256=D53znqi5Ltxl1rHZ6NeltRhwwEhicrD-jI_QtKBvj1g,144
-qadence/backends/pulser/backend.py,sha256=qZ1k7TMOoeUFfWF_Oc2f3iIMNgtM8idXP1CAa-qJOCg,12693
+qadence/backends/horqrux/__init__.py,sha256=0OdVy6cq0oQggV48LO1WXdaZuSkDkz7OYNEPIkNAmfk,140
+qadence/backends/horqrux/backend.py,sha256=tnW1jz3ScKQlwNeZ6n64sx33NeT0y4giDjq1NeDNmmA,8052
+qadence/backends/horqrux/config.py,sha256=FmXVkN5L01CCB7Ae9Cnmw9bgUWHYC9X3Kp2PAbyfIYI,540
+qadence/backends/horqrux/convert_ops.py,sha256=Aaq6SElReoJByE-XMn5OBDkMTKcmMQyfTshE6N-c41k,8717
+qadence/backends/pulser/__init__.py,sha256=capQ-eHqwtOeLf4mWsI0BIseAHhiLGie5cFD4-iVhUo,116
+qadence/backends/pulser/backend.py,sha256=Yl21WHl_IPVPt_4T1IytsMYN95cgto9BhnqLF2kpaEk,13499
 qadence/backends/pulser/channels.py,sha256=ZF0yEXUFHAmi3IdeXjzdTNGR5NzaRRFTiUpUGVg2sO4,329
 qadence/backends/pulser/cloud.py,sha256=0uUluvbFV9sOuCPraE-9uiVtC3Q8QaDY1IJMDi8grDM,2057
-qadence/backends/pulser/config.py,sha256=qprNFI_ZRG-GA5ipQrJkuvpt0dgkw7JiZxrx1woMjHM,2852
+qadence/backends/pulser/config.py,sha256=DdboScn5TrtVwCcsHgZjNCQmWy46aSrf44FhOTJRxaw,3038
 qadence/backends/pulser/convert_ops.py,sha256=0HGWe5kIwI1ZALHf2j68B8aBOhwFNZV-mDy1_6zsF5g,1227
-qadence/backends/pulser/devices.py,sha256=i2vj0uWBSZ_oajJfjVE3ZOC_nre7H0eYLohK1_kjngI,2266
-qadence/backends/pulser/pulses.py,sha256=C9dYyIuVbj8N7pdmOsBKVXD6FqY3rzNEFShaH3kjtdo,9377
+qadence/backends/pulser/devices.py,sha256=KBgyBbdL1ZLllHHoWY5W6Z_aALhxFZMlXABkN7tQsmQ,2439
+qadence/backends/pulser/pulses.py,sha256=KwhiW3vcA7bKyYgADA2mHuUiah8J5Ytw2eocmAlasiA,11685
 qadence/backends/pulser/waveforms.py,sha256=0uz95b7rUaUUtN0tuHBZmJ0H6UBmfHST_59ozwsRCzg,2227
 qadence/backends/pyqtorch/__init__.py,sha256=0OdVy6cq0oQggV48LO1WXdaZuSkDkz7OYNEPIkNAmfk,140
-qadence/backends/pyqtorch/backend.py,sha256=U0cuJtClhsYFOykTQOxpKF_mCooHkZxK-mrsWph8KKI,9418
-qadence/backends/pyqtorch/config.py,sha256=6g14PV8Mw7171AAiyi3-9CAiJOhky1dvolbIs_kSwBg,1722
-qadence/backends/pyqtorch/convert_ops.py,sha256=S3nrBI_BsgtonZ9Tzp5PDEmVi0G7uuyh5d5YH2ne2Js,15130
+qadence/backends/pyqtorch/backend.py,sha256=wKAzoKf_eoG2vpmFDD3PFsGGTtRva3UDUL5GH9oZAj8,9457
+qadence/backends/pyqtorch/config.py,sha256=f5BjWehCqm9do2OahNWrv2w55y3orkw0Wj2f6flwRaU,1907
+qadence/backends/pyqtorch/convert_ops.py,sha256=J20E5Lze2TyxA1ODClSH1d_TC32jr2VuEpDY2zb_yqY,15537
 qadence/blocks/__init__.py,sha256=SXj5NbnJkFcsEeyP4WJ2EfV-frmoL3qzz0XTExpMQpg,940
-qadence/blocks/abstract.py,sha256=khWoHxsv-wkNMTB7lrZZ0e9LmCeBXu6z_zH9pCd5stQ,11701
-qadence/blocks/analog.py,sha256=qS3Hy5Hnk4935WQ3hV0LY_OSTj-1HHZDx_2GXThYO8M,10328
-qadence/blocks/block_to_tensor.py,sha256=d6RqRTLXFpgZT2fQVGlr4xJBWhD1uh-7BbWq0fYt6do,15972
+qadence/blocks/abstract.py,sha256=35RcVlNvD1BmBoJ8bbYJ3LrdU72wixt9ZmTbCtEwNus,11796
+qadence/blocks/analog.py,sha256=ySzvniSF89dsTd_GzgAESkv3OVseBgUKkKTAQK7sqVc,10655
+qadence/blocks/block_to_tensor.py,sha256=bt28er90ltu1GzRQCz4hziBLKoBgQhC8VZwKTziM1JE,16279
 qadence/blocks/composite.py,sha256=z_lXRBVnh-DdvfZdv6T0ZEmVhlU76zBt72P_FGGa-PQ,8897
-qadence/blocks/embedding.py,sha256=wNpvk3EG1ex9gJ0o_RI4ztIvlzMCK5GocgXV1WS8TMA,5670
+qadence/blocks/embedding.py,sha256=TQt620UIVaNYHP34tpK9slv-PFiLvTQRYw5Ez9RuImE,6513
 qadence/blocks/manipulate.py,sha256=kPmzej7mnWFoqTJA2CkGulT7hcPha0GGPARC8rjZltg,2387
 qadence/blocks/matrix.py,sha256=XQI6D4CWhCf3j-hvA0jRKOgprs0RA6su7OythCoH6Ls,3785
-qadence/blocks/primitive.py,sha256=yfY7UWQmkaOSgNBV5-Tnq8cI95ARflTputRhQftcAX0,14642
-qadence/blocks/utils.py,sha256=pj0b3yEQ3wpiK_mdpkBS8shAPyaeHZii2bCjtts8jVE,15729
-qadence/constructors/__init__.py,sha256=IgujYHDgyRmxECLOyt4yv4wbBTAUfu_nRX_PytkurMw,965
+qadence/blocks/primitive.py,sha256=rM-l5wvf3nGCrYFMJ6cI2ULPv_vhw1gxt1zd-77bupM,16716
+qadence/blocks/utils.py,sha256=WQKx5e2Uq0TG8bwxFGaMsIbvYFJHfH95TBCVqlpuQ5s,16299
+qadence/constructors/__init__.py,sha256=d4ndrNCTCDS_kUYeigGFQOUFSAMaPKL--_FcdZy7eQo,1152
 qadence/constructors/ansatze.py,sha256=PWC6ILioReF6vlS22UevCSLIHGR1HMQpUVPlCyZ4rNY,12026
-qadence/constructors/feature_maps.py,sha256=O4QkvCDDRk6yazzDe52YEchM15yMBzNdvjGVUZAa7_I,9808
-qadence/constructors/hamiltonians.py,sha256=nn3f93JZwTD3ALo_zxpU64gBw7jrvx11BkTObiN0ctQ,11380
+qadence/constructors/feature_maps.py,sha256=PgbbwYcq2TrvJmn8BZefX2j20BTrVd7axmSVldbJxPk,10569
+qadence/constructors/hamiltonians.py,sha256=d-rdOSsI7gEp9pn89M60EYierBpPFmEP3Y3W7BrdbMM,8327
 qadence/constructors/iia.py,sha256=12Dizl1BZwktmp4h4FNm-ISFCRVFkW_EsIAg7rqAo1E,4720
 qadence/constructors/qft.py,sha256=h_wVAEvb6kIr_pzx9RWK8PVsosqDB8np3qvZFkFmbf4,7508
+qadence/constructors/rydberg_feature_maps.py,sha256=u_BTGfsgXqKSJb72DP_CyqBCfoSQFI6GRsc-Fqiuw5E,4729
 qadence/constructors/rydberg_hea.py,sha256=GrIrboyjEe1fJEbhtRYeCZ5dYzDVpMt-SQucS9UyNtw,8372
 qadence/constructors/utils.py,sha256=PKVkxD2Ev2OVl-aCC9jl6rTET6iEhDXOWIdXf30w4iw,3073
 qadence/constructors/daqc/__init__.py,sha256=50_4Ak32d5A4CZeR65l0s-0lUsxgKerWNDK7GDmkNY4,140
@@ -72,6 +81,14 @@ qadence/draw/assets/dark/measurement.png,sha256=hSMhZZCFKHNO2tCpYTTSYIF-nsAfNalR
 qadence/draw/assets/dark/measurement.svg,sha256=6ALGjaCX3xZ1NqB6RW6yzOchzZV-j8ukW4aGhEWe4Lk,7282
 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=rrMA-54AC1wx4a1WFQKGZL_YIdgjoyvBGagT0H1bL1Y,5875
+qadence/engines/jax/__init__.py,sha256=qcW09lcnblwRVQM6mDmW9su5kDVPe--buWCCuvPbOVM,223
+qadence/engines/jax/differentiable_backend.py,sha256=W5rDA8wb-ECnFWoLj4dVugF9v1lecC0t9FTLBWnw2vM,3062
+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=PoyglpSg6YGjm2P6y7-urB-oVx_Uq3HoMoyP43sFYuc,15344
 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
@@ -81,11 +98,11 @@ qadence/measurements/tomography.py,sha256=TiD6xwD9b7hK0cKoMccAZwpz56rCLz2xb-dZai
 qadence/mitigations/__init__.py,sha256=RzaxYJftePFMloGhBVSixZ8fSe-ps_Jc-EyPm6xz-bs,159
 qadence/mitigations/analog_zne.py,sha256=6B_rb0Od8sOvzyVwjAb6hM3hCe5Xcr1LnsxL3L9byRk,3579
 qadence/mitigations/protocols.py,sha256=Jq9MyLujfTyWmc7XVUGYVRUkJT1MmZw-GgmWpVjmX2Y,1608
-qadence/mitigations/readout.py,sha256=qSGly-yfYMX8QX_uGBvFKidUCOn3h0ybb3KiprVCF2k,3978
+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=GptMgStgpyLM0nLWT_SCWSkW8DWuhU7EcYEDgUTXXzs,3191
-qadence/ml_tools/models.py,sha256=z8_kcp0p5kZpuGmsBFLGMqQ1MQcrVFXC-UcCRRA3DqU,10815
+qadence/ml_tools/models.py,sha256=BfGPb761riKjl5jpm2VFrk08IZPvDtCAc_lwqJ5QXuM,11096
 qadence/ml_tools/optimize_step.py,sha256=HfDbRPt-sPxq4QT2-8Ur63r11Tty6mgJb3CFPb_7YWs,1540
 qadence/ml_tools/parameters.py,sha256=gew2Kq_5-RgRpaTvs8eauVhgo0sTqqDQEV6WHFEiLGM,1301
 qadence/ml_tools/printing.py,sha256=kwwD9yLVqezaqWX5OAsXr8GLdJUnGrY-t5SnoKHtl9g,707
@@ -95,19 +112,20 @@ qadence/ml_tools/train_grad.py,sha256=wKltZZQ911tsUucjZp1uuqng_Zdr1D3vFmlqhqdXEc
 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=_SkW76jFSyuXRhUlP5lmGQZlg0Y8vgiVkxz6gYuI1Hs,5833
-qadence/models/quantum_model.py,sha256=WmQVIbpdmDVIgcVPzRgoHDdCB0D0GCOqBroP0NcHrEw,11575
+qadence/models/qnn.py,sha256=ne261gZn-1JDhCL2rzj-PykhkhP2MWhFlX7Ok7eCqFQ,8586
+qadence/models/quantum_model.py,sha256=lADpj_HY1393JjE558ckH4RiiEM5qkYyfdBJ-rVVvXM,12053
 qadence/noise/__init__.py,sha256=r0nR8uEZeB1M9pI2UisjWq0bjw50fPFfVGzIMev923g,147
 qadence/noise/protocols.py,sha256=-aZ06JvMnpxCeT5v5lI_RNPOLbb9Ju1Pi1AB6uAXxVE,1653
 qadence/noise/readout.py,sha256=BqBIZbPXWqZaKi6EpBSpXXQ9NhQXdQ-YL6ZmwbSjgfE,6736
-qadence/transpile/__init__.py,sha256=NMCoKsy9vKoKycBxtD9oa1CYtmgG9U9XeTDFsOTq1_4,416
+qadence/transpile/__init__.py,sha256=lb5LwsYb6lN5YFBsU3YBey7-0OcUQpYa3Q4hG6zmgi0,457
+qadence/transpile/apply_fn.py,sha256=glZo2_wMOjw7_KgWKYbqg8j-9SDs-RefWIfxWgdQK8I,1336
 qadence/transpile/block.py,sha256=kuDATVQm-e1EbI22_bl4KzSpby5jfzMtboC_k8T8n6g,11591
 qadence/transpile/circuit.py,sha256=KTh6Gv1czZddFuA1JhNNszheZbwViVixiGh4rGvIgTM,451
 qadence/transpile/digitalize.py,sha256=iWRwYAYQsD2INHj0HNbGJriv_3fRCuBW1nDBrwtKSuI,1523
 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.1.1.dist-info/METADATA,sha256=Zu8IoHxF-4F9zj0V9u9NIGajXWwxLp-JLn7IKa-kBlo,6755
-qadence-1.1.1.dist-info/WHEEL,sha256=9QBuHhg6FNW7lppboF2vKVbCGTVzsFykgRQjjlajrhA,87
-qadence-1.1.1.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-qadence-1.1.1.dist-info/RECORD,,
+qadence-1.2.1.dist-info/METADATA,sha256=S3d0CDfRPyXuASpiupmqW7j6eKkdPcZJcOt0BJ1WafI,7648
+qadence-1.2.1.dist-info/WHEEL,sha256=0wCxn4rnLsvRWBK-NC7mK2QMIQ_aZSl7Qvk-8IWl_pY,87
+qadence-1.2.1.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+qadence-1.2.1.dist-info/RECORD,,

{qadence-1.1.1.dist-info → qadence-1.2.1.dist-info}/WHEEL

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