qadence 1.11.3__tar.gz → 1.11.5__tar.gz

{qadence-1.11.3 → qadence-1.11.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qadence
-Version: 1.11.3
+Version: 1.11.5
 Summary: Pasqal interface for circuit-based quantum computing SDKs
 Author-email: Aleksander Wennersteen <aleksander.wennersteen@pasqal.com>, Gert-Jan Both <gert-jan.both@pasqal.com>, Niklas Heim <niklas.heim@pasqal.com>, Mario Dagrada <mario.dagrada@pasqal.com>, Vincent Elfving <vincent.elfving@pasqal.com>, Dominik Seitz <dominik.seitz@pasqal.com>, Roland Guichard <roland.guichard@pasqal.com>, "Joao P. Moutinho" <joao.moutinho@pasqal.com>, Vytautas Abramavicius <vytautas.abramavicius@pasqal.com>, Gergana Velikova <gergana.velikova@pasqal.com>, Eduardo Maschio <eduardo.maschio@pasqal.com>, Smit Chaudhary <smit.chaudhary@pasqal.com>, Ignacio Fernández Graña <ignacio.fernandez-grana@pasqal.com>, Charles Moussa <charles.moussa@pasqal.com>, Giorgio Tosti Balducci <giorgio.tosti-balducci@pasqal.com>, Daniele Cucurachi <daniele.cucurachi@pasqal.com>, Pim Venderbosch <pim.venderbosch@pasqal.com>, Manu Lahariya <manu.lahariya@pasqal.com>, Sungwoo Ahn <sungwoo.ahn@pasqal.com>
 License: PASQAL OPEN-SOURCE SOFTWARE LICENSE (MIT-derived)
@@ -24,7 +24,7 @@ Requires-Dist: nevergrad
 Requires-Dist: numpy
 Requires-Dist: openfermion
 Requires-Dist: pasqal-cloud
-Requires-Dist: pyqtorch==1.7.6
+Requires-Dist: pyqtorch==1.7.7
 Requires-Dist: pyyaml
 Requires-Dist: rich
 Requires-Dist: scipy
@@ -44,7 +44,7 @@ Requires-Dist: nvidia-pyindex; extra == 'dlprof'
 Provides-Extra: horqrux
 Requires-Dist: einops; extra == 'horqrux'
 Requires-Dist: flax; extra == 'horqrux'
-Requires-Dist: horqrux==0.8.1; extra == 'horqrux'
+Requires-Dist: horqrux==0.9.0; extra == 'horqrux'
 Requires-Dist: jax; extra == 'horqrux'
 Requires-Dist: jaxopt; extra == 'horqrux'
 Requires-Dist: optax; extra == 'horqrux'
@@ -225,5 +225,15 @@ doi = {10.1109/MS.2025.3536607}
 }
 ```
 
+If you use the approximate Generalized parameter shift rule for your publication, we kindly ask you to cite:
+```latex
+@misc{2505.18090,
+Author = {Vytautas Abramavicius and Evan Philip and Kaonan Micadei and Charles Moussa and Mario Dagrada and Vincent E. Elfving and Panagiotis Barkoutsos and Roland Guichard},
+Title = {Evaluation of derivatives using approximate generalized parameter shift rule},
+Year = {2025},
+Eprint = {arXiv:2505.18090},
+}
+```
+
 ## License
 Qadence is a free and open source software package, released under the PASQAL OPEN-SOURCE SOFTWARE LICENSE (MIT-derived).

{qadence-1.11.3 → qadence-1.11.5}/README.md

@@ -150,5 +150,15 @@ doi = {10.1109/MS.2025.3536607}
 }
 ```
 
+If you use the approximate Generalized parameter shift rule for your publication, we kindly ask you to cite:
+```latex
+@misc{2505.18090,
+Author = {Vytautas Abramavicius and Evan Philip and Kaonan Micadei and Charles Moussa and Mario Dagrada and Vincent E. Elfving and Panagiotis Barkoutsos and Roland Guichard},
+Title = {Evaluation of derivatives using approximate generalized parameter shift rule},
+Year = {2025},
+Eprint = {arXiv:2505.18090},
+}
+```
+
 ## License
 Qadence is a free and open source software package, released under the PASQAL OPEN-SOURCE SOFTWARE LICENSE (MIT-derived).

{qadence-1.11.3 → qadence-1.11.5}/pyproject.toml

@@ -29,7 +29,7 @@ authors = [
 ]
 requires-python = ">=3.9"
 license = { text = "PASQAL OPEN-SOURCE SOFTWARE LICENSE (MIT-derived)" }
-version = "1.11.3"
+version = "1.11.5"
 classifiers = [
     "License :: Other/Proprietary License",
     "Programming Language :: Python",
@@ -54,7 +54,7 @@ dependencies = [
     "jsonschema",
     "nevergrad",
     "scipy",
-    "pyqtorch==1.7.6",
+    "pyqtorch==1.7.7",
     "pyyaml",
     "matplotlib",
     "Arpeggio==2.0.2",
@@ -78,7 +78,7 @@ visualization = [
     # "scour",
 ]
 horqrux = [
-    "horqrux==0.8.1",
+    "horqrux==0.9.0",
     "jax",
     "flax",
     "optax",

{qadence-1.11.3 → qadence-1.11.5}/qadence/ml_tools/tensors.py

@@ -39,3 +39,12 @@ def promote_to(x: Tensor, dtype: Any) -> float | np.ndarray | Tensor:
         return x
     else:
         raise ValueError(f"Don't know how to convert Tensor to {dtype}")
+
+
+def detach_loss_metrics(
+    loss_metrics: tuple[torch.Tensor, dict[str, Any]],
+) -> tuple[torch.Tensor, dict[str, Any]]:
+    """Detach the tensors contained in the loss and metrics history."""
+    loss, metrics = loss_metrics
+    detached_metrics = {k: v.detach() if isinstance(v, Tensor) else v for k, v in metrics.items()}
+    return loss.detach(), detached_metrics

{qadence-1.11.3 → qadence-1.11.5}/qadence/ml_tools/trainer.py

@@ -15,6 +15,7 @@ from qadence.ml_tools.data import DictDataLoader, OptimizeResult, data_to_device
 from qadence.ml_tools.information import InformationContent
 from qadence.ml_tools.optimize_step import optimize_step, update_ng_parameters
 from qadence.ml_tools.stages import TrainingStage
+from qadence.ml_tools.tensors import detach_loss_metrics
 
 from .train_utils.base_trainer import BaseTrainer
 from .train_utils.accelerator import Accelerator
@@ -654,6 +655,8 @@ class Trainer(BaseTrainer):
         All metrics are prefixed with the proper state of the training process
          - "train_" or "val_" or "test_"
         A "{state}_loss" is added to metrics.
+        In order to save memory, all tensors are detached so that gradients
+        are not tracked.
 
         Args:
             loss_metrics (tuple[torch.Tensor, dict[str, Any]]): Original loss and metrics.
@@ -666,8 +669,8 @@ class Trainer(BaseTrainer):
                 loss, metrics = loss_metrics
                 updated_metrics = {f"{phase}_{key}": value for key, value in metrics.items()}
                 updated_metrics[f"{phase}_loss"] = loss
-                return loss, updated_metrics
-        return loss_metrics
+                loss_metrics = (loss, updated_metrics)
+        return detach_loss_metrics(loss_metrics)
 
     def _aggregate_result(
         self, result: tuple[torch.Tensor, dict[str, Any]]

{qadence-1.11.3 → qadence-1.11.5}/qadence/states.py

@@ -41,6 +41,10 @@ __all__ = [
     "DensityMatrix",
     "density_mat",
     "overlap",
+    "partial_trace",
+    "von_neumann_entropy",
+    "purity",
+    "fidelity",
 ]
 
 ATOL_64 = 1e-14  # 64 bit precision
@@ -589,3 +593,128 @@ def equivalent_state(
     fidelity = overlap(s0, s1)
     expected = torch.ones_like(fidelity)
     return torch.allclose(fidelity, expected, rtol=rtol, atol=atol)  # type: ignore[no-any-return]
+
+
+# DensityMatrix utility functions
+
+
+def partial_trace(rho: DensityMatrix, keep_indices: list[int]) -> DensityMatrix:
+    """
+    Compute the partial trace of a density matrix for a system of several qubits with batch size.
+
+    This function also permutes qubits according to the order specified in keep_indices.
+
+    Args:
+        rho (DensityMatrix) : Density matrix of shape [batch_size, 2**n_qubits, 2**n_qubits].
+        keep_indices (list[int]): Index of the qubit subsystems to keep.
+
+    Returns:
+        DensityMatrix: Reduced density matrix after the partial trace,
+        of shape [batch_size, 2**n_keep, 2**n_keep].
+    """
+    from pyqtorch.utils import dm_partial_trace
+
+    return dm_partial_trace(rho.permute((1, 2, 0)), keep_indices).permute((2, 0, 1))
+
+
+def von_neumann_entropy(rho: DensityMatrix, eps: float = 1e-12) -> torch.Tensor:
+    """Calculate the von Neumann entropy of a quantum density matrix.
+
+    The von Neumann entropy is defined as S(ρ) = -Tr(ρ log₂ ρ) = -∑ᵢ λᵢ log₂ λᵢ,
+    where λᵢ are the eigenvalues of ρ.
+
+    Args:
+        rho: Density matrix of shape [batch_size, dim, dim]
+        eps: Small value to avoid log(0) for zero eigenvalues
+
+    Returns:
+        Von Neumann entropy for each density matrix in the batch, shape [batch_size]
+    """
+
+    # Compute eigenvalues for each density matrix in the batch
+    # For a Hermitian density matrix, eigenvalues should be real and non-negative
+    eigenvalues = torch.linalg.eigvalsh(rho)
+
+    # Normalize eigenvalues to ensure they sum to 1 (trace preservation)
+    # This step might be redundant but helps with numerical stability
+    eigenvalues = eigenvalues / torch.sum(eigenvalues, dim=1, keepdim=True)
+
+    # Filter out very small eigenvalues to avoid numerical issues
+    valid_eigenvalues = eigenvalues.clone()
+    valid_eigenvalues[valid_eigenvalues < eps] = eps
+
+    # Compute the entropy: -∑ᵢ λᵢ log₂ λᵢ
+    # Using natural logarithm and converting to base 2
+    log_base_conversion = torch.log(torch.tensor(2.0, device=rho.device))
+    entropy = -torch.sum(
+        valid_eigenvalues * torch.log(valid_eigenvalues) / log_base_conversion, dim=1
+    )
+
+    return entropy
+
+
+def purity(rho: DensityMatrix, order: int = 2) -> Tensor:
+    """Compute the n-th purity of a density matrix.
+
+    Args:
+        rho (DensityMatrix): Density matrix.
+        order (int, optional): Exponent n.
+
+    Returns:
+        Tensor: Tr[rho ** n]
+    """
+    # Compute eigenvalues
+    eigenvalues = torch.linalg.eigvalsh(rho)
+
+    # Compute the sum of eigenvalues raised to power n
+    return torch.sum(eigenvalues**order, dim=1)
+
+
+def fidelity(rho: DensityMatrix, sigma: DensityMatrix) -> Tensor:
+    """Calculate the fidelity between two quantum states represented by density matrices.
+
+    The fidelity is defined as F(ρ,σ) = Tr[√(√ρ σ √ρ)], or equivalently,
+    F(ρ,σ) = ||√ρ·√σ||₁ where ||·||₁ is the trace norm.
+
+    Args:
+        rho: First density matrix of shape [batch_size, dim, dim]
+        sigma: Second density matrix of shape [batch_size, dim, dim]
+
+    Returns:
+        Fidelity between each pair of density matrices in the batch, shape [batch_size]
+    """
+
+    # Compute square root of rho
+    rho_eigvals, rho_eigvecs = torch.linalg.eigh(rho)
+
+    # Ensure non-negative eigenvalues
+    rho_eigvals = torch.clamp(rho_eigvals, min=0)
+
+    # Compute square root using eigendecomposition
+    sqrt_eigvals = torch.sqrt(rho_eigvals)
+
+    # Compute √ρ for each batch element
+    sqrt_rho = torch.zeros_like(rho)
+    for i in range(rho.shape[0]):
+        sqrt_rho[i] = torch.mm(
+            rho_eigvecs[i],
+            torch.mm(
+                torch.diag(sqrt_eigvals[i]).to(dtype=rho_eigvecs.dtype), rho_eigvecs[i].t().conj()
+            ),
+        )
+
+    # Compute √ρ σ √ρ for each batch element
+    inner_product = torch.zeros_like(rho)
+    for i in range(rho.shape[0]):
+        inner_product[i] = torch.mm(sqrt_rho[i], torch.mm(sigma[i], sqrt_rho[i]))
+
+    # Compute eigenvalues of inner product
+    inner_eigvals = torch.linalg.eigvalsh(inner_product)
+
+    # Ensure non-negative eigenvalues
+    inner_eigvals = torch.clamp(inner_eigvals, min=0)
+
+    # Compute the fidelity as the sum of the square roots of eigenvalues
+    fidelity_values = torch.sum(torch.sqrt(inner_eigvals), dim=1)
+
+    return fidelity_values