qadence 1.7.0__py3-none-any.whl → 1.7.2__py3-none-any.whl

qadence/model.py

@@ -37,6 +37,36 @@ class QuantumModel(nn.Module):
     This class should be used as base class for any new quantum model supported in the qadence
     framework for information on the implementation of custom models see
     [here](../tutorials/advanced_tutorials/custom-models.md).
+
+    Example:
+    ```python exec="on" source="material-block" result="json"
+    import torch
+    from qadence import QuantumModel, QuantumCircuit, RX, RY, Z, PI, chain, kron
+    from qadence import FeatureParameter, VariationalParameter
+
+    theta = VariationalParameter("theta")
+    phi = FeatureParameter("phi")
+
+    block = chain(
+        kron(RX(0, theta), RY(1, theta)),
+        kron(RX(0, phi), RY(1, phi)),
+    )
+
+    circuit = QuantumCircuit(2, block)
+
+    observable = Z(0) + Z(1)
+
+    model = QuantumModel(circuit, observable)
+    values = {"phi": torch.tensor([PI, PI/2]), "theta": torch.tensor([PI, PI/2])}
+
+    wf = model.run(values)
+    xs = model.sample(values, n_shots=100)
+    ex = model.expectation(values)
+    print(wf)
+    print(xs)
+    print(ex)
+    ```
+    ```
     """
 
     backend: Backend | DifferentiableBackend
@@ -120,6 +150,7 @@ class QuantumModel(nn.Module):
 
     @property
     def vparams(self) -> OrderedDict:
+        """Variational parameters."""
         return OrderedDict({k: v.data for k, v in self._params.items() if v.requires_grad})
 
     @property
@@ -145,9 +176,26 @@ class QuantumModel(nn.Module):
         return len(self.vals_vparams)
 
     def circuit(self, circuit: QuantumCircuit) -> ConvertedCircuit:
+        """Get backend-converted circuit.
+
+        Args:
+            circuit: QuantumCircuit instance.
+
+        Returns:
+            Backend circuit.
+        """
         return self.backend.circuit(circuit)
 
     def observable(self, observable: AbstractBlock, n_qubits: int) -> Any:
+        """Get backend observable.
+
+        Args:
+            observable: Observable block.
+            n_qubits: Number of qubits
+
+        Returns:
+            Backend observable.
+        """
         return self.backend.observable(observable, n_qubits)
 
     def reset_vparams(self, values: Sequence) -> None:
@@ -161,6 +209,11 @@ class QuantumModel(nn.Module):
             current_vparams[k].data = torch.tensor([values[i]])
 
     def forward(self, *args: Any, **kwargs: Any) -> Tensor:
+        """Calls run method with arguments.
+
+        Returns:
+            Tensor: A torch.Tensor representing output.
+        """
         return self.run(*args, **kwargs)
 
     def run(
@@ -169,9 +222,26 @@ class QuantumModel(nn.Module):
         state: Tensor | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> Tensor:
+        r"""Run model.
+
+        Given an input state $| \psi_0 \rangle$,
+        a set of variational parameters $\vec{\theta}$
+        and the unitary representation of the model $U(\vec{\theta})$
+        we return $U(\vec{\theta}) | \psi_0 \rangle$.
+
+        Arguments:
+            values: Values dict which contains values for the parameters.
+            state: Optional input state to apply model on.
+            endianness: Storage convention for binary information.
+
+        Returns:
+            A torch.Tensor representing output.
+        """
         if values is None:
             values = {}
+
         params = self.embedding_fn(self._params, values)
+
         return self.backend.run(self._circuit, params, state=state, endianness=endianness)
 
     def sample(
@@ -183,6 +253,19 @@ class QuantumModel(nn.Module):
         mitigation: Mitigations | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> list[Counter]:
+        """Obtain samples from model.
+
+        Arguments:
+            values: Values dict which contains values for the parameters.
+            n_shots: Observable part of the expectation.
+            state: Optional input state to apply model on.
+            noise: A noise model to use.
+            mitigation: A mitigation protocol to use.
+            endianness: Storage convention for binary information.
+
+        Returns:
+            A list of Counter instances with the sample results.
+        """
         params = self.embedding_fn(self._params, values)
         if noise is None:
             noise = self._noise
@@ -208,7 +291,27 @@ class QuantumModel(nn.Module):
         mitigation: Mitigations | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> Tensor:
-        """Compute expectation using the given backend.
+        r"""Compute expectation using the given backend.
+
+
+
+        Given an input state $|\psi_0 \rangle$,
+        a set of variational parameters $\vec{\theta}$
+        and the unitary representation of the model $U(\vec{\theta})$
+        we return $\langle \psi_0 | U(\vec{\theta}) | \psi_0 \rangle$.
+
+        Arguments:
+            values: Values dict which contains values for the parameters.
+            observable: Observable part of the expectation.
+            state: Optional input state.
+            measurement: Optional measurement protocol. If None, use
+                exact expectation value with a statevector simulator.
+            noise: A noise model to use.
+            mitigation: A mitigation protocol to use.
+            endianness: Storage convention for binary information.
+
+        Raises:
+            ValueError: when no observable is set.
 
         Returns:
             A torch.Tensor of shape n_batches x n_obs
@@ -243,9 +346,22 @@ class QuantumModel(nn.Module):
         )
 
     def overlap(self) -> Tensor:
+        """Overlap of model.
+
+        Raises:
+            NotImplementedError: The overlap method is not implemented for this model.
+        """
         raise NotImplementedError("The overlap method is not implemented for this model.")
 
     def _to_dict(self, save_params: bool = False) -> dict[str, Any]:
+        """Convert QuantumModel to a dictionary for serialization.
+
+        Arguments:
+            save_params: Optionally save parameters. Defaults to False.
+
+        Returns:
+            The dictionary
+        """
         d = dict()
         try:
             if isinstance(self._observable, list):
@@ -275,6 +391,15 @@ class QuantumModel(nn.Module):
 
     @classmethod
     def _from_dict(cls, d: dict, as_torch: bool = False) -> QuantumModel:
+        """Initialize instance of QuantumModel from dictionary.
+
+        Args:
+            d: Dictionary.
+            as_torch: Load parameters as torch tensors. Defaults to False.
+
+        Returns:
+            QuantumModel instance
+        """
         from qadence.serialization import deserialize
 
         qm: QuantumModel
@@ -310,6 +435,16 @@ class QuantumModel(nn.Module):
     def save(
         self, folder: str | Path, file_name: str = "quantum_model.pt", save_params: bool = True
     ) -> None:
+        """Save model.
+
+        Arguments:
+            folder: Folder where model is saved.
+            file_name: File name for saving model. Defaults to "quantum_model.pt".
+            save_params: Save parameters if True. Defaults to True.
+
+        Raises:
+            FileNotFoundError: If folder is not a directory.
+        """
         if not os.path.isdir(folder):
             raise FileNotFoundError
         try:
@@ -321,6 +456,16 @@ class QuantumModel(nn.Module):
     def load(
         cls, file_path: str | Path, as_torch: bool = False, map_location: str | torch.device = "cpu"
     ) -> QuantumModel:
+        """Load QuantumModel.
+
+        Arguments:
+            file_path: File path to load model from.
+            as_torch: Load parameters as torch tensor. Defaults to False.
+            map_location (str | torch.device, optional): Location for loading. Defaults to "cpu".
+
+        Returns:
+            QuantumModel from file_path.
+        """
         qm_pt = {}
         if isinstance(file_path, str):
             file_path = Path(file_path)
@@ -336,11 +481,23 @@ class QuantumModel(nn.Module):
         return cls._from_dict(qm_pt, as_torch)
 
     def assign_parameters(self, values: dict[str, Tensor]) -> Any:
-        """Return the final, assigned circuit that is used in e.g. `backend.run`."""
+        """Return the final, assigned circuit that is used in e.g. `backend.run`.
+
+        Arguments:
+            values: Values dict which contains values for the parameters.
+
+        Returns:
+            Final, assigned circuit that is used in e.g. `backend.run`
+        """
         params = self.embedding_fn(self._params, values)
         return self.backend.assign_parameters(self._circuit, params)
 
     def to(self, *args: Any, **kwargs: Any) -> QuantumModel:
+        """Conversion method for device or types.
+
+        Returns:
+            QuantumModel with conversions.
+        """
         from pyqtorch import QuantumCircuit as PyQCircuit
 
         try:
@@ -369,6 +526,11 @@ class QuantumModel(nn.Module):
 
     @property
     def device(self) -> torch.device:
+        """Get device.
+
+        Returns:
+            torch.device
+        """
         return (
             self._circuit.native.device
             if self.backend.backend.name == "pyqtorch"  # type: ignore[union-attr]

qadence/operations/ham_evo.py

@@ -43,6 +43,7 @@ class HamEvo(TimeEvolutionBlock):
         generator: Either a AbstractBlock, torch.Tensor or numpy.ndarray.
         parameter: A scalar or vector of numeric or torch.Tensor type.
         qubit_support: The qubits on which the evolution will be performed on.
+        duration: duration of evolution in case of time-dependent generator
 
     Examples:
 
@@ -66,6 +67,7 @@ class HamEvo(TimeEvolutionBlock):
         generator: Union[TGenerator, AbstractBlock],
         parameter: TParameter,
         qubit_support: tuple[int, ...] = None,
+        duration: float | None = None,
     ):
         gen_exprs = {}
         if qubit_support is None and not isinstance(generator, AbstractBlock):
@@ -75,6 +77,10 @@ class HamEvo(TimeEvolutionBlock):
             qubit_support = generator.qubit_support
             if generator.is_parametric:
                 gen_exprs = {str(e): e for e in expressions(generator)}
+
+                if generator.is_time_dependent and duration is None:
+                    raise ValueError("For time-dependent generators, a duration must be specified.")
+
         elif isinstance(generator, torch.Tensor):
             msg = "Please provide a square generator."
             if len(generator.shape) == 2:
@@ -99,6 +105,7 @@ class HamEvo(TimeEvolutionBlock):
         ps = {"parameter": Parameter(parameter), **gen_exprs}
         self.parameters = ParamMap(**ps)
         self.generator = generator
+        self.duration = duration
 
     @classmethod
     def num_parameters(cls) -> int:
@@ -197,3 +204,6 @@ class HamEvo(TimeEvolutionBlock):
             raise NotImplementedError(
                 "The current digital decomposition can be applied only to Pauli Hamiltonians."
             )
+
+    def __matmul__(self, other: AbstractBlock) -> AbstractBlock:
+        return super().__matmul__(other)

qadence/parameters.py

@@ -16,7 +16,7 @@ from torch import Tensor, heaviside, no_grad, rand, tensor
 from qadence.types import DifferentiableExpression, Engine, TNumber
 
 # Modules to be automatically added to the qadence namespace
-__all__ = ["FeatureParameter", "Parameter", "VariationalParameter", "ParamMap"]
+__all__ = ["FeatureParameter", "Parameter", "VariationalParameter", "ParamMap", "TimeParameter"]
 
 logger = getLogger(__name__)
 
@@ -61,6 +61,8 @@ class Parameter(Symbol):
     value: TNumber
     """(Initial) value of the parameter."""
 
+    is_time: bool
+
     def __new__(
         cls, name: str | TNumber | Tensor | Basic | Parameter, **assumptions: Any
     ) -> Parameter | Basic | Expr | Array:
@@ -111,6 +113,7 @@ class Parameter(Symbol):
             p.name = name.name
             p.trainable = name.trainable
             p.value = name.value
+            p.is_time = name.is_time
             return p
         elif isinstance(name, (Basic, Expr)):
             if name.is_number:
@@ -120,6 +123,7 @@ class Parameter(Symbol):
             p = super().__new__(cls, name, **assumptions)
             p.trainable = assumptions.get("trainable", True)
             p.value = assumptions.get("value", None)
+            p.is_time = assumptions.get("is_time", False)
             if p.value is None:
                 p.value = rand(1).item()
             return p
@@ -178,6 +182,11 @@ def VariationalParameter(name: str, **kwargs: Any) -> Parameter:
     return Parameter(name, trainable=True, **kwargs)
 
 
+def TimeParameter(name: str) -> Parameter:
+    """Shorthand for `Parameter(..., trainable=False, is_time=True)`."""
+    return Parameter(name, trainable=False, is_time=True)
+
+
 def extract_original_param_entry(
     param: Expr,
 ) -> TNumber | Tensor | Expr:

qadence/register.py

@@ -38,28 +38,31 @@ class Register:
         device_specs: RydbergDevice = DEFAULT_DEVICE,
     ):
         """
-        A 2D register of qubits which includes their coordinates.
+        A register of qubits including 2D coordinates.
 
-        It is needed for e.g. analog computing.
-        The coordinates are ignored in backends that don't need them. The easiest
-        way to construct a register is via its classmethods like `Register.triangular_lattice`.
+        Instantiating the Register class directly is only recommended for building custom registers.
+        For most uses where a predefined lattice is desired it is recommended to use the various
+        class methods available, e.g. `Register.triangular_lattice`.
 
         Arguments:
-            support: A graph or number of qubits. Nodes can include a `"pos"` attribute
+            support: A NetworkX graph or number of qubits. Nodes can include a `"pos"` attribute
                 such that e.g.: `graph.nodes = {0: {"pos": (2,3)}, 1: {"pos": (0,0)}, ...}` which
-                will be used in backends that need qubit coordinates.
-                See the classmethods for simple construction of some predefined lattices if you
-                don't want to build a graph manually.
-                If you pass an integer the resulting register is the same as
-                `Register.all_to_all(n_qubits)`.
-            spacing: Value set as the distance between the two closest qubits.
+                will be used in backends that need qubit coordinates. Passing a number of qubits
+                calls `Register.all_to_all(n_qubits)`.
+            spacing: Value set as the distance between the two closest qubits. The spacing
+                argument is also available for all the class method constructors.
 
         Examples:
-        ```python exec="on" source="material-block" result="json"
+        ```python exec="on" source="material-block"
         from qadence import Register
 
-        reg = Register.honeycomb_lattice(2,3)
-        reg.draw()
+        reg_all = Register.all_to_all(n_qubits = 4)
+        reg_line = Register.line(n_qubits = 4)
+        reg_circle = Register.circle(n_qubits = 4)
+        reg_squre = Register.square(qubits_side = 2)
+        reg_rect = Register.rectangular_lattice(qubits_row = 2, qubits_col = 2)
+        reg_triang = Register.triangular_lattice(n_cells_row = 2, n_cells_col = 2)
+        reg_honey = Register.honeycomb_lattice(n_cells_row = 2, n_cells_col = 2)
         ```
         """
         if device_specs is not None and not isinstance(device_specs, RydbergDevice):
@@ -74,6 +77,7 @@ class Register:
 
     @property
     def n_qubits(self) -> int:
+        """Total number of qubits in the register."""
         return len(self.graph)
 
     @classmethod
@@ -84,6 +88,15 @@ class Register:
         spacing: float | None = None,
         device_specs: RydbergDevice = DEFAULT_DEVICE,
     ) -> Register:
+        """
+        Build a register from a list of qubit coordinates.
+
+        Each node is added to the underlying
+        graph with the respective coordinates, but the edges are left empty.
+
+        Arguments:
+            coords: List of qubit coordinate tuples.
+        """
         graph = nx.Graph()
         for i, pos in enumerate(coords):
             graph.add_node(i, pos=pos)
@@ -96,6 +109,12 @@ class Register:
         spacing: float = 1.0,
         device_specs: RydbergDevice = DEFAULT_DEVICE,
     ) -> Register:
+        """
+        Build a line register.
+
+        Arguments:
+            n_qubits: Total number of qubits.
+        """
         return cls(line_graph(n_qubits), spacing, device_specs)
 
     @classmethod
@@ -105,6 +124,12 @@ class Register:
         spacing: float = 1.0,
         device_specs: RydbergDevice = DEFAULT_DEVICE,
     ) -> Register:
+        """
+        Build a circle register.
+
+        Arguments:
+            n_qubits: Total number of qubits.
+        """
         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)
@@ -119,6 +144,12 @@ class Register:
         spacing: float = 1.0,
         device_specs: RydbergDevice = DEFAULT_DEVICE,
     ) -> Register:
+        """
+        Build a square register.
+
+        Arguments:
+            qubits_side: Number of qubits on one side of the square.
+        """
         n_points = 4 * (qubits_side - 1)
 
         def gen_points() -> np.ndarray:
@@ -152,6 +183,15 @@ class Register:
         spacing: float = 1.0,
         device_specs: RydbergDevice = DEFAULT_DEVICE,
     ) -> Register:
+        """
+        Build a register with an all-to-all connectivity graph.
+
+        The graph is projected
+        onto a 2D space and the qubit coordinates are set using a spring layout algorithm.
+
+        Arguments:
+            n_qubits: Total number of qubits.
+        """
         return cls(alltoall_graph(n_qubits), spacing, device_specs)
 
     @classmethod
@@ -166,6 +206,13 @@ class Register:
         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)
+        """
+        Build a rectangular lattice register.
+
+        Arguments:
+            qubits_row: Number of qubits in each row.
+            qubits_col: Number of qubits in each column.
+        """
         return cls(graph, spacing, device_specs)
 
     @classmethod
@@ -176,6 +223,15 @@ class Register:
         spacing: float = 1.0,
         device_specs: RydbergDevice = DEFAULT_DEVICE,
     ) -> Register:
+        """
+        Build a triangular lattice register.
+
+        Each cell is a triangle made up of three qubits.
+
+        Arguments:
+            n_cells_row: Number of cells in each row.
+            n_cells_col: Number of cells in each column.
+        """
         return cls(triangular_lattice_graph(n_cells_row, n_cells_col), spacing, device_specs)
 
     @classmethod
@@ -186,6 +242,15 @@ class Register:
         spacing: float = 1.0,
         device_specs: RydbergDevice = DEFAULT_DEVICE,
     ) -> Register:
+        """
+        Build a honeycomb lattice register.
+
+        Each cell is an hexagon made up of six qubits.
+
+        Arguments:
+            n_cells_row: Number of cells in each row.
+            n_cells_col: Number of cells in each column.
+        """
         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, device_specs)
@@ -195,6 +260,7 @@ class Register:
         return getattr(cls, topology)(*args, **kwargs)  # type: ignore[no-any-return]
 
     def draw(self, show: bool = True) -> None:
+        """Draw the underlying NetworkX graph representing the register."""
         coords = {i: n["pos"] for i, n in self.graph.nodes.items()}
         nx.draw(self.graph, with_labels=True, pos=coords)
         if show:
@@ -205,41 +271,59 @@ class Register:
 
     @property
     def nodes(self) -> NodeView:
+        """Return the NodeView of the underlying NetworkX graph."""
         return self.graph.nodes
 
     @property
     def edges(self) -> EdgeView:
+        """Return the EdgeView of the underlying NetworkX graph."""
         return self.graph.edges
 
     @property
     def support(self) -> set:
+        """Return the set of qubits in the register."""
         return set(self.nodes)
 
     @property
     def coords(self) -> dict:
+        """Return the dictionary of qubit coordinates."""
         return {i: tuple(node.get("pos", ())) for i, node in self.nodes.items()}
 
     @property
     def all_node_pairs(self) -> EdgeView:
+        """Return a list of all possible qubit pairs in the register."""
         return list(filter(lambda x: x[0] < x[1], product(self.support, self.support)))
 
     @property
     def distances(self) -> dict:
+        """Return a dictionary of distances for all qubit pairs in the register."""
         coords = self.coords
         return {edge: dist(coords[edge[0]], coords[edge[1]]) for edge in self.all_node_pairs}
 
     @property
     def edge_distances(self) -> dict:
+        """
+        Return a dictionary of distances for the qubit pairs that are.
+
+        connected by an edge in the underlying NetworkX graph.
+        """
         coords = self.coords
         return {edge: dist(coords[edge[0]], coords[edge[1]]) for edge in self.edges}
 
     @property
     def min_distance(self) -> float:
+        """Return the minimum distance between two qubts in the register."""
         distances = self.distances
         value: float = min(self.distances.values()) if len(distances) > 0 else 0.0
         return value
 
     def rescale_coords(self, scaling: float) -> Register:
+        """
+        Rescale the coordinates of all qubits in the register.
+
+        Arguments:
+            scaling: Scaling value.
+        """
         g = deepcopy(self.graph)
         _scale_node_positions(g, min_distance=1.0, spacing=scaling)
         return Register(g, spacing=None, device_specs=self.device_specs)
@@ -272,14 +356,6 @@ class Register:
 
 
 def line_graph(n_qubits: int) -> nx.Graph:
-    """Create graph representing linear lattice.
-
-    Args:
-        n_qubits (int): number of nodes in the graph
-
-    Returns:
-        graph instance
-    """
     graph = nx.Graph()
     for i in range(n_qubits):
         graph.add_node(i, pos=(i, 0.0))

qadence/types.py

@@ -7,6 +7,7 @@ from typing import Callable, Iterable, Tuple, Union
 import numpy as np
 import sympy
 from numpy.typing import ArrayLike
+from pyqtorch.utils import SolverType
 from torch import Tensor, pi
 
 TNumber = Union[int, float, complex, np.int64, np.float64]
@@ -47,6 +48,7 @@ __all__ = [
     "AlgoHEvo",
     "SerializationFormat",
     "PI",
+    "SolverType",
 ]  # type: ignore
 
 

qadence/utils.py

@@ -234,18 +234,12 @@ def is_qadence_shape(state: ArrayLike, n_qubits: int) -> bool:
     return state.shape[1] == 2**n_qubits  # type: ignore[no-any-return]
 
 
-def infer_batchsize(param_values: dict[str, 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: ArrayLike | None, n_qubits: int, param_values: dict[str, Tensor] = None
 ) -> None:
     if state is not None:
+        from qadence.backends.utils import infer_batchsize
+
         if isinstance(state, Tensor):
             if state is not None:
                 batch_size_state = (

{qadence-1.7.0.dist-info → qadence-1.7.2.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.3
 Name: qadence
-Version: 1.7.0
+Version: 1.7.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>, Eduardo Maschio <eduardo.maschio@pasqal.com>, Smit Chaudhary <smit.chaudhary@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>
 License: Apache 2.0
 License-File: LICENSE
 Classifier: License :: OSI Approved :: Apache Software License
@@ -22,10 +22,11 @@ Requires-Dist: matplotlib
 Requires-Dist: nevergrad
 Requires-Dist: numpy
 Requires-Dist: openfermion
-Requires-Dist: pyqtorch==1.2.1
+Requires-Dist: pyqtorch==1.2.5
 Requires-Dist: pyyaml
 Requires-Dist: rich
 Requires-Dist: scipy
+Requires-Dist: sympy<1.13
 Requires-Dist: sympytorch>=0.1.2
 Requires-Dist: tensorboard>=2.12.0
 Requires-Dist: torch
@@ -53,9 +54,9 @@ Requires-Dist: qadence-libs; extra == 'libs'
 Provides-Extra: protocols
 Requires-Dist: qadence-protocols; extra == 'protocols'
 Provides-Extra: pulser
-Requires-Dist: pasqal-cloud==0.10.1; extra == 'pulser'
-Requires-Dist: pulser-core==0.18.1; extra == 'pulser'
-Requires-Dist: pulser-simulation==0.18.1; extra == 'pulser'
+Requires-Dist: pasqal-cloud==0.11.1; extra == 'pulser'
+Requires-Dist: pulser-core==0.19.0; extra == 'pulser'
+Requires-Dist: pulser-simulation==0.19.0; extra == 'pulser'
 Provides-Extra: visualization
 Requires-Dist: graphviz; extra == 'visualization'
 Description-Content-Type: text/markdown