qadence 1.10.1__py3-none-any.whl → 1.10.3__py3-none-any.whl

qadence/backends/horqrux/convert_ops.py

@@ -245,7 +245,7 @@ class HorqHamiltonianEvolution(NativeHorqHEvo):
 
         self._time_evolution = lambda values: values[self.param_names[0]]
 
-    def unitary(self, values: dict[str, Array]) -> Array:
+    def _unitary(self, values: dict[str, Array]) -> Array:
         """The evolved operator given current parameter values for generator and time evolution."""
         return expm(self._hamiltonian(self, values) * (-1j * self._time_evolution(values)))
 

qadence/blocks/block_to_tensor.py

@@ -79,6 +79,7 @@ def _fill_identities(
         torch.Tensor: augmented matrix with dimensions (2**nqubits, 2**nqubits)
         or a tensor (2**n_qubits) if diag_only
     """
+    full_qubit_support = tuple(sorted(full_qubit_support))
     qubit_support = tuple(sorted(qubit_support))
     block_mat = block_mat.to(device)
     mat = IMAT.to(device) if qubit_support[0] != full_qubit_support[0] else block_mat
@@ -469,14 +470,13 @@ def _block_to_tensor_embedded(
         )
 
     elif isinstance(block, MatrixBlock):
-        mat = block.matrix.unsqueeze(0)
-        # FIXME: properly handle identity filling in matrix blocks
-        # mat = _fill_identities(
-        #    block.matrix.unsqueeze(0),
-        #    block.qubit_support,
-        #    qubit_support,
-        #    endianness=endianness,
-        # )
+        mat = _fill_identities(
+            block.matrix.unsqueeze(0),
+            block.qubit_support,
+            qubit_support,
+            endianness=endianness,
+            device=device,
+        )
 
     elif isinstance(block, SWAP):
         swap_block = _swap_block(block)

qadence/blocks/matrix.py

@@ -7,6 +7,8 @@ import numpy as np
 import torch
 from torch.linalg import eigvals
 
+from math import log
+
 from qadence.blocks import PrimitiveBlock
 from qadence.noise import NoiseHandler
 
@@ -84,6 +86,8 @@ class MatrixBlock(PrimitiveBlock):
             if not self.is_unitary(matrix):
                 logger.warning("Provided matrix is not unitary.")
         self.matrix = matrix.clone()
+        if int(log(self.matrix.size(1), 2)) != len(qubit_support):
+            raise ValueError("Provided matrix does not match the qubit_support length.")
         super().__init__(qubit_support, noise)
 
     @cached_property

qadence/ml_tools/__init__.py

@@ -4,6 +4,7 @@ from .callbacks.saveload import load_checkpoint, load_model, write_checkpoint
 from .config import AnsatzConfig, FeatureMapConfig, TrainConfig
 from .constructors import create_ansatz, create_fm_blocks, observable_from_config
 from .data import DictDataLoader, InfiniteTensorDataset, OptimizeResult, to_dataloader
+from .information import InformationContent
 from .models import QNN
 from .optimize_step import optimize_step as default_optimize_step
 from .parameters import get_parameters, num_parameters, set_parameters

qadence/ml_tools/config.py

@@ -434,15 +434,17 @@ class AnsatzConfig:
     """What type of ansatz.
 
     `AnsatzType.HEA` for Hardware Efficient Ansatz.
-    `AnsatzType.IIA` for Identity intialized Ansatz.
+    `AnsatzType.IIA` for Identity Intialized Ansatz.
+    `AnsatzType.ALA` for Alternating Layer Ansatz.
     """
 
     ansatz_strategy: Strategy = Strategy.DIGITAL
     """Ansatz strategy.
 
-    `Strategy.DIGITAL` for fully digital ansatz. Required if `ansatz_type` is `AnsatzType.IIA`.
-    `Strategy.SDAQC` for analog entangling block.
-    `Strategy.RYDBERG` for fully rydberg hea ansatz.
+    `Strategy.DIGITAL` for fully digital ansatz. Required if `ansatz_type` is `AnsatzType.ALA`.
+    `Strategy.SDAQC` for analog entangling block. Only available for `AnsatzType.HEA` or
+    `AnsatzType.ALA`.
+    `Strategy.RYDBERG` for fully rydberg hea ansatz. Only available for `AnsatzType.HEA`.
     """
 
     strategy_args: dict = field(default_factory=dict)
@@ -484,6 +486,13 @@ class AnsatzConfig:
     """
     # The default for a dataclass can not be a mutable object without using this default_factory.
 
+    m_block_qubits: int | None = None
+    """
+    The number of qubits in the local entangling block of an Alternating Layer Ansatz (ALA).
+
+    Only used when `ansatz_type` is `AnsatzType.ALA`.
+    """
+
     param_prefix: str = "theta"
     """The base bame of the variational parameter."""
 
@@ -499,3 +508,13 @@ class AnsatzConfig:
             assert (
                 self.ansatz_strategy != Strategy.RYDBERG
             ), "Rydberg strategy not allowed for Identity-initialized ansatz."
+
+        if self.ansatz_type == AnsatzType.ALA:
+            assert (
+                self.ansatz_strategy == Strategy.DIGITAL
+            ), f"{self.ansatz_strategy} not allowed for Alternating Layer Ansatz.\
+            Only `Strategy.DIGITAL` allowed."
+
+            assert (
+                self.m_block_qubits is not None
+            ), "m_block_qubits must be specified for Alternating Layer Ansatz."

qadence/ml_tools/constructors.py

@@ -13,13 +13,14 @@ from qadence.constructors import (
     analog_feature_map,
     feature_map,
     hamiltonian_factory,
-    iia,
     rydberg_feature_map,
     rydberg_hea,
     rydberg_tower_feature_map,
 )
+from qadence.constructors.ala import ala_digital
 from qadence.constructors.hamiltonians import ObservableConfig, TDetuning
 from qadence.constructors.hea import hea_digital, hea_sDAQC
+from qadence.constructors.iia import iia
 from qadence.measurements import Measurements
 from qadence.noise import NoiseHandler
 from qadence.operations import CNOT, RX, RY, I, N, Z
@@ -596,6 +597,58 @@ def _create_hea(
         )
 
 
+def _create_ala_digital(
+    num_qubits: int,
+    config: AnsatzConfig,
+) -> AbstractBlock:
+    """
+    Create the Digital Alternating Layer Ansatz based on the configuration.
+
+    Args:
+        num_qubits (int): The number of qubits.
+        config (AnsatzConfig): The configuration for the ansatz.
+
+    Returns:
+        AbstractBlock: The Digital Alternating Layer Ansatz.
+    """
+    operations = config.strategy_args.get("operation", [RX, RY, RX])
+    entangler = config.strategy_args.get("entangler", CNOT)
+
+    return ala_digital(
+        n_qubits=num_qubits,
+        m_block_qubits=config.m_block_qubits,  # type: ignore[arg-type]
+        param_prefix=config.param_prefix,
+        operations=operations,
+        entangler=entangler,
+    )
+
+
+def _create_ala(
+    num_qubits: int,
+    config: AnsatzConfig,
+) -> AbstractBlock:
+    """
+    Create the Alternating Layer Ansatz based on the configuration.
+
+    Args:
+        num_qubits (int): The number of qubits.
+        config (AnsatzConfig): The configuration for the ansatz.
+
+    Returns:
+        AbstractBlock: The Alternating Layer Ansatz.
+
+    Raises:
+        ValueError: If the ansatz strategy is not `Strategy.DIGITAL`.
+    """
+    if config.ansatz_strategy == Strategy.DIGITAL:
+        return _create_ala_digital(num_qubits=num_qubits, config=config)
+    else:
+        raise ValueError(
+            f"Invalid ansatz strategy {config.ansatz_strategy} provided. Only `Strategy.DIGITAL` \
+                allowed"
+        )
+
+
 def create_ansatz(
     register: int | Register,
     config: AnsatzConfig,
@@ -619,6 +672,8 @@ def create_ansatz(
         return _create_iia(num_qubits=num_qubits, config=config)
     elif config.ansatz_type == AnsatzType.HEA:
         return _create_hea(register=register, config=config)
+    elif config.ansatz_type == AnsatzType.ALA:
+        return _create_ala(num_qubits=num_qubits, config=config)
     else:
         raise NotImplementedError(
             f"Ansatz of type {config.ansatz_type} not implemented yet. Only `AnsatzType.HEA` and\

qadence/ml_tools/information/__init__.py

@@ -0,0 +1,3 @@
+from __future__ import annotations
+
+from .information_content import InformationContent

qadence/ml_tools/information/information_content.py

@@ -0,0 +1,339 @@
+from __future__ import annotations
+
+import functools
+from logging import getLogger
+from math import log, sqrt
+from statistics import NormalDist
+from typing import Any, Callable
+
+import torch
+from torch import nn
+from torch.func import functional_call  # type: ignore
+
+logger = getLogger("ml_tools")
+
+
+class InformationContent:
+    def __init__(
+        self,
+        model: nn.Module,
+        loss_fn: Callable,
+        xs: Any,
+        epsilons: torch.Tensor,
+        variation_multiple: int = 20,
+    ) -> None:
+        """Information Landscape class.
+
+        This class handles the study of loss landscape from information theoretic
+        perspective and provides methods to get bounds on the norm of the
+        gradient from the Information Content of the loss landscape.
+
+        Args:
+            model: The quantum or classical model to analyze.
+            loss_fn: Loss function that takes model output and calculates loss
+            xs: Input data to evaluate the model on
+            epsilons: The thresholds to use for discretization of the finite derivatives
+            variation_multiple: The number of sets of variational parameters to generate per each
+                variational parameter. The number of variational parameters required for the
+                statistical analysis scales linearly with the amount of them present in the
+                model. This is that linear factor.
+
+        Notes:
+            This class provides flexibility in terms of what the model, the loss function,
+            and the xs are. The only requirement is that the loss_fn takes the model and xs as
+            arguments and returns the loss, and another dictionary of other metrics.
+
+            Thus, assumed structure:
+                loss_fn(model, xs) -> (loss, metrics, ...)
+
+            Example: A Classifier
+                ```python
+                model = nn.Linear(10, 1)
+
+                def loss_fn(
+                    model: nn.Module,
+                    xs: tuple[torch.Tensor, torch.Tensor]
+                ) -> tuple[torch.Tensor, dict[str, float]:
+                    criterion = nn.MSELoss()
+                    inputs, labels = xs
+                    outputs = model(inputs)
+                    loss = criterion(outputs, labels)
+                    metrics = {"loss": loss.item()}
+                    return loss, metrics
+
+                xs = (torch.randn(10, 10), torch.randn(10, 1))
+
+                info_landscape = InfoLandscape(model, loss_fn, xs)
+                ```
+                In this example, the model is a linear classifier, and the `xs` include both the
+                inputs and the target labels. The logic for calculation of the loss from this lies
+                entirely within the `loss_fn` function. This can then further be used to obtain the
+                bounds on the average norm of the gradient of the loss function.
+
+            Example: A Physics Informed Neural Network
+                ```python
+                class PhysicsInformedNN(nn.Module):
+                    // <Initialization Logic>
+
+                    def forward(self, xs: dict[str, torch.Tensor]):
+                        return {
+                            "pde_residual": pde_residual(xs["pde"]),
+                            "boundary_condition": bc_term(xs["bc"]),
+                        }
+
+                def loss_fn(
+                    model: PhysicsInformedNN,
+                    xs: dict[str, torch.Tensor]
+                ) -> tuple[torch.Tensor, dict[str, float]:
+                    pde_residual, bc_term = model(xs)
+                    loss = torch.mean(torch.sum(pde_residual**2, dim=1), dim=0)
+                        + torch.mean(torch.sum(bc_term**2, dim=1), dim=0)
+
+                    return loss, {"pde_residual": pde_residual, "bc_term": bc_term}
+
+                xs = {
+                    "pde": torch.linspace(0, 1, 10),
+                    "bc": torch.tensor([0.0]),
+                }
+
+                info_landscape = InfoLandscape(model, loss_fn, xs)
+                ```
+
+                In this example, the model is a Physics Informed Neural Network, and the `xs`
+                are the inputs to the different residual components of the model. The logic
+                for calculation of the residuals lies within the PhysicsInformedNN class, and
+                the loss function is defined to calculate the loss that is to be optimized
+                from these residuals. This can then further be used to obtain the
+                bounds on the average norm of the gradient of the loss function.
+
+            The first value that the `loss_fn` returns is the loss value that is being optimized.
+            The function is also expected to return other value(s), often the metrics that are
+            used to calculate the loss. These values are ignored for the purpose of this class.
+        """
+        self.model = model
+        self.loss_fn = loss_fn
+        self.xs = xs
+        self.epsilons = epsilons
+        self.device = next(model.parameters()).device
+
+        self.param_shapes = {}
+        self.total_params = 0
+
+        for name, param in model.named_parameters():
+            self.param_shapes[name] = param.shape
+            self.total_params += param.numel()
+        self.n_variations = variation_multiple * self.total_params
+        self.all_variations = torch.empty(
+            (self.n_variations, self.total_params), device=self.device
+        ).uniform_(0, 2 * torch.pi)
+
+    def reshape_param_variations(self) -> dict[str, torch.Tensor]:
+        """Reshape variations of the model's variational parameters.
+
+        Returns:
+            Dictionary of parameter tensors, each with shape [n_variations, *param_shape]
+        """
+        param_variations = {}
+        start_idx = 0
+
+        for name, shape in self.param_shapes.items():
+            param_size = torch.prod(torch.tensor(shape)).item()
+            param_variations[name] = self.all_variations[
+                :, start_idx : start_idx + param_size
+            ].view(self.n_variations, *shape)
+            start_idx += param_size
+
+        return param_variations
+
+    def batched_loss(self) -> torch.Tensor:
+        """Calculate loss for all parameter variations in a batched manner.
+
+        Returns: Tensor of loss values for each parameter variation
+        """
+        param_variations = self.reshape_param_variations()
+        losses = torch.zeros(self.n_variations, device=self.device)
+
+        for i in range(self.n_variations):
+            params = {name: param[i] for name, param in param_variations.items()}
+            current_model = lambda x: functional_call(self.model, params, (x,))
+            losses[i] = self.loss_fn(current_model, self.xs)[0]
+
+        return losses
+
+    def randomized_finite_der(self) -> torch.Tensor:
+        """
+        Calculate normalized finite difference of loss on doing random walk in the parameter space.
+
+        This serves as a proxy for the derivative of the loss with respect to parameters.
+
+        Returns:
+            Tensor containing normalized finite differences (approximate directional derivatives)
+            between consecutive points in the random walk. Shape: [n_variations - 1]
+        """
+        losses = self.batched_loss()
+
+        return (losses[1:] - losses[:-1]) / (
+            torch.norm(self.all_variations[1:] - self.all_variations[:-1], dim=1) + 1e-8
+        )
+
+    def discretize_derivatives(self) -> torch.Tensor:
+        """
+        Convert finite derivatives into discrete values.
+
+        Returns:
+            Tensor containing discretized derivatives with shape [n_epsilons, n_variations-2]
+            Each row contains {-1, 0, 1} values for that epsilon
+        """
+        derivatives = self.randomized_finite_der()
+
+        derivatives = derivatives.unsqueeze(0)
+        epsilons = self.epsilons.unsqueeze(1)
+
+        discretized = torch.zeros((len(epsilons), len(derivatives[0])), device=self.device)
+        discretized[derivatives > epsilons] = 1
+        discretized[derivatives < -epsilons] = -1
+
+        return discretized
+
+    def calculate_transition_probabilities_batch(self) -> torch.Tensor:
+        """
+        Calculate transition probabilities for multiple epsilon values.
+
+        Returns:
+            Tensor of shape [n_epsilons, 6] containing probabilities for each transition type
+            Columns order: [+1to0, +1to-1, 0to+1, 0to-1, -1to0, -1to+1]
+        """
+        discretized = self.discretize_derivatives()
+
+        current = discretized[:, :-1]
+        next_val = discretized[:, 1:]
+
+        transitions = torch.stack(
+            [
+                ((current == 1) & (next_val == 0)).sum(dim=1),
+                ((current == 1) & (next_val == -1)).sum(dim=1),
+                ((current == 0) & (next_val == 1)).sum(dim=1),
+                ((current == 0) & (next_val == -1)).sum(dim=1),
+                ((current == -1) & (next_val == 0)).sum(dim=1),
+                ((current == -1) & (next_val == 1)).sum(dim=1),
+            ],
+            dim=1,
+        ).float()
+
+        total_transitions = current.size(1)
+        probabilities = transitions / total_transitions
+
+        return probabilities
+
+    @functools.cached_property
+    def calculate_IC(self) -> torch.Tensor:
+        """
+        Calculate Information Content for multiple epsilon values.
+
+        Returns: Tensor of IC values for each epsilon [n_epsilons]
+        """
+        probs = self.calculate_transition_probabilities_batch()
+
+        mask = probs > 1e-4
+
+        ic_terms = torch.where(mask, -probs * torch.log(probs), torch.zeros_like(probs))
+        ic_values = ic_terms.sum(dim=1) / torch.log(torch.tensor(6.0))
+
+        return ic_values
+
+    def max_IC(self) -> tuple[float, float]:
+        """
+        Get the maximum Information Content and its corresponding epsilon.
+
+        Returns: Tuple of (maximum IC value, optimal epsilon)
+        """
+        max_ic, max_idx = torch.max(self.calculate_IC, dim=0)
+        max_epsilon = self.epsilons[max_idx]
+        return max_ic.item(), max_epsilon.item()
+
+    def sensitivity_IC(self, eta: float) -> float:
+        """
+        Find the minimum value of epsilon such that the information content is less than eta.
+
+        Args:
+            eta: Threshold value, the sensitivity IC.
+
+        Returns: The epsilon value that gives IC that is less than the sensitivity IC.
+        """
+        ic_values = self.calculate_IC
+        mask = ic_values < eta
+        epsilons = self.epsilons[mask]
+        return float(epsilons.min().item())
+
+    @staticmethod
+    @functools.lru_cache
+    def q_value(H_value: float) -> float:
+        """
+        Compute the q value.
+
+        q is the solution to the equation:
+        H(x) = 4h(x) + 2h(1/2 - 2x)
+
+        It is the value of the probability of 4 of the 6 transitions such that
+        the IC is the same as the IC of our system.
+
+        This quantity is useful in calculating the bounds on the norms of the gradients.
+
+        Args:
+            H_value (float): The information content.
+
+        Returns:
+            float: The q value
+        """
+
+        x = torch.linspace(0.001, 0.16667, 10000)
+
+        H = -4 * x * torch.log(x) / torch.log(torch.tensor(6)) - 2 * (0.5 - 2 * x) * torch.log(
+            0.5 - 2 * x
+        ) / torch.log(torch.tensor(6))
+        err = torch.abs(H - H_value)
+        idx = torch.argmin(err)
+        return float(x[idx].item())
+
+    def get_grad_norm_bounds_max_IC(self) -> tuple[float, float]:
+        """
+        Compute the bounds on the average norm of the gradient.
+
+        Returns:
+            tuple[Tensor, Tensor]: The lower and upper bounds.
+        """
+        max_IC, epsilon_m = self.max_IC()
+        lower_bound = (
+            epsilon_m
+            * sqrt(self.total_params)
+            / (NormalDist().inv_cdf(1 - 2 * self.q_value(max_IC)))
+        )
+        upper_bound = (
+            epsilon_m
+            * sqrt(self.total_params)
+            / (NormalDist().inv_cdf(0.5 * (1 + 2 * self.q_value(max_IC))))
+        )
+
+        if max_IC < log(2, 6):
+            logger.warning(
+                "Warning: The maximum IC is less than the required value. The bounds may be"
+                + " inaccurate."
+            )
+
+        return lower_bound, upper_bound
+
+    def get_grad_norm_bounds_sensitivity_IC(self, eta: float) -> float:
+        """
+        Compute the bounds on the average norm of the gradient.
+
+        Args:
+            eta (float): The sensitivity IC.
+
+        Returns:
+            Tensor: The lower bound.
+        """
+        epsilon_sensitivity = self.sensitivity_IC(eta)
+        upper_bound = (
+            epsilon_sensitivity * sqrt(self.total_params) / (NormalDist().inv_cdf(1 - 3 * eta / 2))
+        )
+        return upper_bound

qadence/ml_tools/trainer.py

@@ -14,7 +14,8 @@ from torch import dtype as torch_dtype
 from torch.utils.data import DataLoader
 
 from qadence.ml_tools.config import TrainConfig
-from qadence.ml_tools.data import DictDataLoader, OptimizeResult
+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
 
@@ -711,3 +712,107 @@ class Trainer(BaseTrainer):
         self.opt_result = OptimizeResult(
             self.current_epoch, self.model_old, self.optimizer_old, loss, metrics
         )
+
+    def get_ic_grad_bounds(
+        self,
+        eta: float,
+        epsilons: torch.Tensor,
+        variation_multiple: int = 20,
+        dataloader: DataLoader | DictDataLoader | None = None,
+    ) -> tuple[float, float, float]:
+        """
+        Calculate the bounds on the gradient norm of the loss using Information Content.
+
+        Args:
+            eta (float): The sensitivity IC.
+            epsilons (torch.Tensor): The epsilons to use for thresholds to for discretization of the
+                finite derivatives.
+            variation_multiple (int): The number of sets of variational parameters to generate per
+                each variational parameter. The number of variational parameters required for the
+                statisctiacal analysis scales linearly with the amount of them present in the
+                model. This is that linear factor.
+            dataloader (DataLoader | DictDataLoader | None): The dataloader for training data. A
+                new dataloader can be provided, or the dataloader provided in the trinaer will be
+                used. In case no dataloaders are provided at either places, it assumes that the
+                model does not require any input data.
+
+        Returns:
+            tuple[float, float, float]: The max IC lower bound, max IC upper bound, and sensitivity
+                IC upper bound.
+
+        Examples:
+            ```python
+            import torch
+            from torch.optim.adam import Adam
+
+            from qadence.constructors import ObservableConfig
+            from qadence.ml_tools.config import AnsatzConfig, FeatureMapConfig, TrainConfig
+            from qadence.ml_tools.data import to_dataloader
+            from qadence.ml_tools.models import QNN
+            from qadence.ml_tools.optimize_step import optimize_step
+            from qadence.ml_tools.trainer import Trainer
+            from qadence.operations.primitive import Z
+
+            fm_config = FeatureMapConfig(num_features=1)
+            ansatz_config = AnsatzConfig(depth=4)
+            obs_config = ObservableConfig(detuning=Z)
+
+            qnn = QNN.from_configs(
+                register=4,
+                obs_config=obs_config,
+                fm_config=fm_config,
+                ansatz_config=ansatz_config,
+            )
+
+            optimizer = Adam(qnn.parameters(), lr=0.001)
+
+            batch_size = 25
+            x = torch.linspace(0, 1, 32).reshape(-1, 1)
+            y = torch.sin(x)
+            train_loader = to_dataloader(x, y, batch_size=batch_size, infinite=True)
+
+            train_config = TrainConfig(max_iter=100)
+
+            trainer = Trainer(
+                model=qnn,
+                optimizer=optimizer,
+                config=train_config,
+                loss_fn="mse",
+                train_dataloader=train_loader,
+                optimize_step=optimize_step,
+            )
+
+            # Perform exploratory landscape analysis with Information Content
+            ic_sensitivity_threshold = 1e-4
+            epsilons = torch.logspace(-2, 2, 10)
+
+            max_ic_lower_bound, max_ic_upper_bound, sensitivity_ic_upper_bound = (
+                trainer.get_ic_grad_bounds(
+                    eta=ic_sensitivity_threshold,
+                    epsilons=epsilons,
+                )
+            )
+
+            # Resume training as usual...
+
+            trainer.fit(train_loader)
+            ```
+        """
+        if not self._use_grad:
+            logger.warning(
+                "Gradient norm bounds are only relevant when using a gradient based optimizer. \
+                    Currently the trainer is set to use a gradient-free optimizer."
+            )
+
+        dataloader = dataloader if dataloader is not None else self.train_dataloader
+
+        batch = next(iter(self._batch_iter(dataloader, num_batches=1)))
+
+        xs = data_to_device(batch, device=self.device, dtype=self.data_dtype)
+
+        ic = InformationContent(self.model, self.loss_fn, xs, epsilons)
+
+        max_ic_lower_bound, max_ic_upper_bound = ic.get_grad_norm_bounds_max_IC()
+        sensitivity_ic_upper_bound = ic.get_grad_norm_bounds_sensitivity_IC(eta)
+
+        return max_ic_lower_bound, max_ic_upper_bound, sensitivity_ic_upper_bound

qadence/operations/primitive.py

@@ -376,10 +376,6 @@ class SWAP(PrimitiveBlock):
     def eigenvalues(self) -> Tensor:
         return torch.tensor([-1, 1, 1, 1], dtype=cdouble)
 
-    @property
-    def n_qubits(self) -> int:
-        return 2
-
     @property
     def _block_title(self) -> str:
         c, t = self.qubit_support

qadence/states.py

@@ -40,6 +40,7 @@ __all__ = [
     "equivalent_state",
     "DensityMatrix",
     "density_mat",
+    "overlap",
 ]
 
 ATOL_64 = 1e-14  # 64 bit precision
@@ -559,11 +560,32 @@ def rand_bitstring(N: int) -> str:
     return "".join(str(random.randint(0, 1)) for _ in range(N))
 
 
+def overlap(s0: torch.Tensor, s1: torch.Tensor) -> torch.Tensor:
+    """
+    Computes the exact overlap between two statevectors.
+
+    Arguments:
+        s0 (torch.Tensor): A statevector or batch of statevectors.
+        s1 (torch.Tensor): A statevector or batch of statevectors.
+
+    Returns:
+        A torch.Tensor with the result.
+
+    Examples:
+    ```python exec="on" source="material-block" result="json"
+    from qadence.states import rand_bitstring
+
+    print(rand_bitstring(N=8))
+    ```
+    """
+    from qadence.overlap import overlap_exact
+
+    return overlap_exact(s0, s1)
+
+
 def equivalent_state(
     s0: torch.Tensor, s1: torch.Tensor, rtol: float = 0.0, atol: float = NORMALIZATION_ATOL
 ) -> bool:
-    from qadence.overlap import fidelity
-
-    fid = fidelity(s0, s1)
-    expected = torch.ones_like(fid)
-    return torch.allclose(fid, expected, rtol=rtol, atol=atol)  # type: ignore[no-any-return]
+    fidelity = overlap(s0, s1)
+    expected = torch.ones_like(fidelity)
+    return torch.allclose(fidelity, expected, rtol=rtol, atol=atol)  # type: ignore[no-any-return]

qadence/types.py

@@ -176,6 +176,8 @@ class AnsatzType(StrEnum):
     """Hardware-efficient ansatz."""
     IIA = "iia"
     """Identity-Initialised Ansatz."""
+    ALA = "ala"
+    """Alternating Layer Ansatz."""
 
 
 class _DiffMode(StrEnum):

qadence/utils.py

@@ -290,5 +290,3 @@ def one_qubit_projector_matrix(state: str) -> Tensor:
 
 P0 = partial(one_qubit_projector, "0")
 P1 = partial(one_qubit_projector, "1")
-P0_MATRIX = one_qubit_projector_matrix("0")
-P1_MATRIX = one_qubit_projector_matrix("1")

{qadence-1.10.1.dist-info → qadence-1.10.3.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: qadence
-Version: 1.10.1
+Version: 1.10.3
 Summary: Pasqal interface for circuit-based quantum computing SDKs
-Author-email: Aleksander Wennersteen <aleksander.wennersteen@pasqal.com>, Gert-Jan Both <gert-jan.both@pasqal.com>, Niklas Heim <niklas.heim@pasqal.com>, Mario Dagrada <mario.dagrada@pasqal.com>, Vincent Elfving <vincent.elfving@pasqal.com>, Dominik Seitz <dominik.seitz@pasqal.com>, Roland Guichard <roland.guichard@pasqal.com>, "Joao P. Moutinho" <joao.moutinho@pasqal.com>, Vytautas Abramavicius <vytautas.abramavicius@pasqal.com>, Gergana Velikova <gergana.velikova@pasqal.com>, Eduardo Maschio <eduardo.maschio@pasqal.com>, Smit Chaudhary <smit.chaudhary@pasqal.com>, Ignacio Fernández Graña <ignacio.fernandez-grana@pasqal.com>, Charles Moussa <charles.moussa@pasqal.com>, Giorgio Tosti Balducci <giorgio.tosti-balducci@pasqal.com>, Daniele Cucurachi <daniele.cucurachi@pasqal.com>, Pim Venderbosch <pim.venderbosch@pasqal.com>
+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>
 License: Apache 2.0
 License-File: LICENSE
 Classifier: License :: OSI Approved :: Apache Software License
@@ -43,7 +43,7 @@ Requires-Dist: nvidia-pyindex; extra == 'dlprof'
 Provides-Extra: horqrux
 Requires-Dist: einops; extra == 'horqrux'
 Requires-Dist: flax; extra == 'horqrux'
-Requires-Dist: horqrux==0.6.2; extra == 'horqrux'
+Requires-Dist: horqrux==0.7.0; extra == 'horqrux'
 Requires-Dist: jax; extra == 'horqrux'
 Requires-Dist: jaxopt; extra == 'horqrux'
 Requires-Dist: optax; extra == 'horqrux'
@@ -56,8 +56,8 @@ Provides-Extra: protocols
 Requires-Dist: qadence-protocols; extra == 'protocols'
 Provides-Extra: pulser
 Requires-Dist: pasqal-cloud==0.12.7; extra == 'pulser'
-Requires-Dist: pulser-core==1.2.0; extra == 'pulser'
-Requires-Dist: pulser-simulation==1.2.0; extra == 'pulser'
+Requires-Dist: pulser-core==1.2.2; extra == 'pulser'
+Requires-Dist: pulser-simulation==1.2.2; extra == 'pulser'
 Provides-Extra: visualization
 Requires-Dist: graphviz; extra == 'visualization'
 Description-Content-Type: text/markdown
@@ -75,7 +75,10 @@ programs** with tunable qubit interactions and arbitrary register topologies rea
 
 **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/).**
+**For more detailed information, [check out the documentation](https://pasqal-io.github.io/qadence/latest/).
+
+**For any questions or comments, [feel free to start a discussion](https://github.com/pasqal-io/qadence/discussions).
+**
 
 [![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)

{qadence-1.10.1.dist-info → qadence-1.10.3.dist-info}/RECORD

@@ -18,9 +18,9 @@ qadence/qubit_support.py,sha256=Nkn1Q01RVViTcggSIom7EFKdWpAuM4TMGwBZ5feCUxA,2120
 qadence/register.py,sha256=mwmvS6PcTY0F9cIhTUXG3NT73FIagfMCwVqYa4DrQrk,13001
 qadence/serial_expr_grammar.peg,sha256=z5ytL7do9kO8o4h-V5GrsDuLdso0KsRcMuIYURFfmAY,328
 qadence/serialization.py,sha256=qEET6Gu9u2aSibPve3bJrqDzK2_gO3RPDJjt4ZY8GbE,15596
-qadence/states.py,sha256=OMFuPAmPTLfZYwefXMv82P96xp5aBDJpanmCNgkRO-o,15379
-qadence/types.py,sha256=Jhd_qTI8X7R61LcueNfIsODLUFB7WfVHWiJpsQkrixs,11999
-qadence/utils.py,sha256=zb2j7wURfy8kazaS84r4t35vAeDpo4Tpm4HbmPH-kFA,9865
+qadence/states.py,sha256=Aj28aNHGWkZrFw_mKpHrxCA1bDXlkFhw18D70tg0RF0,15953
+qadence/types.py,sha256=fFjSG9JlPqxFizIK4PfjNZ4e13-yGckejq-fP5TEMdc,12051
+qadence/utils.py,sha256=U670ftNhxkD2hejvV1mTM2YnhDgTms_39saZs-7GKl8,9777
 qadence/analog/__init__.py,sha256=BCyS9R4KUjzUXN0Ax3b0eMo8ZAuSkGoJQVtZ4_pvAFs,279
 qadence/analog/addressing.py,sha256=GSt4heEmRkBmoQIgdgkTclEFxZY-jjuAd77_SsZtGdI,6513
 qadence/analog/constants.py,sha256=B2phQoN1ASL8CwM-Dsa1rbraYwGwwPSeiB3HbVe-MPA,1243
@@ -35,7 +35,7 @@ qadence/backends/utils.py,sha256=SSiMxZjaFS8e8sB6ZBLXPKuJNQGl93pRMy9hnI4oDrw,910
 qadence/backends/horqrux/__init__.py,sha256=0OdVy6cq0oQggV48LO1WXdaZuSkDkz7OYNEPIkNAmfk,140
 qadence/backends/horqrux/backend.py,sha256=KNFFGN9dsgB9QKtNXiP3LyMY9DQ-7W7ScyE6k29fHJY,8842
 qadence/backends/horqrux/config.py,sha256=xz7JlUcwW_4JAbvProbSI9hA1SXZRRAN0Hr2bvmLzfg,892
-qadence/backends/horqrux/convert_ops.py,sha256=LTT8xptZ6DfhgEvFaACtal-qY2doy_Jj3dvV6HXE1Q8,8646
+qadence/backends/horqrux/convert_ops.py,sha256=lUQ3faf3Y4MvIzWzczHLVLs9f9iPij0Dy8JgSHx9ufo,8647
 qadence/backends/pulser/__init__.py,sha256=capQ-eHqwtOeLf4mWsI0BIseAHhiLGie5cFD4-iVhUo,116
 qadence/backends/pulser/backend.py,sha256=cI4IgijPpItNdDmLpKkJFas0X02wMiZd_XmVas41gEI,14846
 qadence/backends/pulser/channels.py,sha256=ZF0yEXUFHAmi3IdeXjzdTNGR5NzaRRFTiUpUGVg2sO4,329
@@ -52,11 +52,11 @@ qadence/backends/pyqtorch/convert_ops.py,sha256=qG26-HmtUDaZO0KDnw2sbT3CRx_poS7e
 qadence/blocks/__init__.py,sha256=H6jEA_CptkE-eoB4UfSbUiDszbxxhZwECV_TgoZWXoU,960
 qadence/blocks/abstract.py,sha256=DSQUE71rMyRBwAP--4Tx1WQC_LCXaNlftjd7goGyrpQ,12027
 qadence/blocks/analog.py,sha256=ymnnlSVoW1XL05ZvnnHCqRTHuOXIEY_7E9M0PNKJZy4,10812
-qadence/blocks/block_to_tensor.py,sha256=Sg7YGKUoPUUHKvyB8Khztrk7UYnV5SD451_3I00n84w,17367
+qadence/blocks/block_to_tensor.py,sha256=CG4KUeBhbfCr6o7JCN6CN-herDUXA8tcC4shi06uUmk,17338
 qadence/blocks/composite.py,sha256=f9D8L3u5Ktu_-xDBWsWiPlY8I-YW5YFgU18BtqwFHK0,8937
 qadence/blocks/embedding.py,sha256=MI-gTPEe1e56AiHJr6MJwMAHdA7ZYmTo0b0VmFfyISQ,7029
 qadence/blocks/manipulate.py,sha256=kPmzej7mnWFoqTJA2CkGulT7hcPha0GGPARC8rjZltg,2387
-qadence/blocks/matrix.py,sha256=unE8mVWBTTcmSLX4le2fHqHFu4fbGeMTK8MrGoPsVRY,4036
+qadence/blocks/matrix.py,sha256=JgzFLWoWDytaE0MEYe-Di7tbwb4jSmMF8tsOF04RIRo,4214
 qadence/blocks/primitive.py,sha256=GLruKpiFBStWVd_M9mzLr3MqDNPbyaMUzEVB6xV3cPQ,17657
 qadence/blocks/utils.py,sha256=_V43qD7kQNK8JS3gxfpkRn56ZIF_GGrhAnARn1hq2hk,17772
 qadence/constructors/__init__.py,sha256=kFAMJMZbEUQlNZBAJi2XOaPFMh-ynb2_A1lI85la4y0,1027
@@ -101,22 +101,24 @@ qadence/mitigations/__init__.py,sha256=RzaxYJftePFMloGhBVSixZ8fSe-ps_Jc-EyPm6xz-
 qadence/mitigations/analog_zne.py,sha256=5n1ffjGM1I5sd9TATsB90pKdDh32UTFJ-ZyOHKdM5z0,7821
 qadence/mitigations/protocols.py,sha256=0TeHvlGTN8_88XNEwrjA97C5BUlrh34wYmx0w6-5Tyw,1622
 qadence/mitigations/readout.py,sha256=nI-voV5N0R7630Cn8t8x9EdV9iB76P0LDkRosy1s0Ec,6631
-qadence/ml_tools/__init__.py,sha256=a52dLBtUh5rTJ0ks_LREv-txtQ8pQZZhnQaIg28fSOw,936
-qadence/ml_tools/config.py,sha256=KcwvfyUb1XT-8NkP1ULjaGRNZqJm6dmWnuY9Bl4KZl0,19406
-qadence/ml_tools/constructors.py,sha256=bhARCCN-GHwSyBCBROnMGH32jo2wj3KV2FEVxIo5zDM,28021
+qadence/ml_tools/__init__.py,sha256=AsZyk_i3EKR12m038o4cAdEfRje8RaCNW6CgmyZ9I94,980
+qadence/ml_tools/config.py,sha256=r78n5tHDuMBPnItWP9FYaDPxneTEAtbUJb5yLZBs64A,20163
+qadence/ml_tools/constructors.py,sha256=MT37r2OZ9uqlf0J7jBGNzMlnaZjfhF6rmll0sIWyaAg,29700
 qadence/ml_tools/data.py,sha256=5sAqG9rUtGZPzFlzEDhMjSeOXF8Z0BmszJ_FRzYAy2A,5311
 qadence/ml_tools/models.py,sha256=DKSVFNC-Iq0-AmBrCZ1kqUpTBHQh_pX_1MqYT8eCG08,17045
 qadence/ml_tools/optimize_step.py,sha256=wUnxfWy0c9rEKe41-26On1bPFBwmSYBF4WCGn76oyq8,3376
 qadence/ml_tools/parameters.py,sha256=gew2Kq_5-RgRpaTvs8eauVhgo0sTqqDQEV6WHFEiLGM,1301
 qadence/ml_tools/stages.py,sha256=qW2phMIvQBLM3tn2UoGN-ePiBnZoNq5k844eHVnnn8Y,1407
 qadence/ml_tools/tensors.py,sha256=xZ9ZRzOqEaMgLUGWQf1najDmL6iLuN1ojCGVFs1Tm94,1337
-qadence/ml_tools/trainer.py,sha256=xU7qffXzWZDfJLlcYebGt4cGXnI8PPls_WdVrGQE31M,27026
+qadence/ml_tools/trainer.py,sha256=XOwupRd6lWihNCZCoX3X6S8pzTBqyEvPaWGJ7HYnl98,31317
 qadence/ml_tools/utils.py,sha256=PW8FyoV0mG_DtN1U8njTDV5qxZ0EK4mnFwMAsLBArfk,1410
 qadence/ml_tools/callbacks/__init__.py,sha256=pTdfjulDGNKca--9BgrdmMyvJSah_0spp929Th6RzC8,913
 qadence/ml_tools/callbacks/callback.py,sha256=XoqTS1uLOkbh4FtKpDSXbUA5_LzjOAoVMaa2jYcYB3w,28800
 qadence/ml_tools/callbacks/callbackmanager.py,sha256=HwxgbqJi1GWYg2lgUqEyw9Y6a71YG_m5DmhpaeB6kLs,8007
 qadence/ml_tools/callbacks/saveload.py,sha256=2z8v1A3qIIPZuusEcSNqgYTnKGKkDj71KvY_atJvKnM,6015
 qadence/ml_tools/callbacks/writer_registry.py,sha256=_lPb4VvDHiiRNh2EaEKxOSslnJgBAImGw5SoVReg-Rs,15351
+qadence/ml_tools/information/__init__.py,sha256=ShyaFJtSRmahI8dIRgDlfjp8XobJ23GTd7X3kU-5F34,88
+qadence/ml_tools/information/information_content.py,sha256=Uv6e831Pi4udhnvEBBALqbkScuDfez-mGM5XTdZyo_w,12750
 qadence/ml_tools/loss/__init__.py,sha256=d_0FlisdmgLY0qL1PeaabbcWX1B42RBdm7220cfzSN4,247
 qadence/ml_tools/loss/loss.py,sha256=Bditg8nelMEpG4Yt0aopcAQz84xIc6O-AGUO2M0nqbM,2982
 qadence/ml_tools/train_utils/__init__.py,sha256=1A2FlFg7kn68R1fdRC73S8DzA9gkBW7whdNHjzH5UTA,235
@@ -129,7 +131,7 @@ qadence/operations/analog.py,sha256=v11DSrg-XUbwIAWAWM43y3VQbYKsx2ynx-HimUoC-x0,
 qadence/operations/control_ops.py,sha256=fPSwOxJaVtJNbwri1UdD20W1JXQlB-inPTCJG3Fk4hI,10187
 qadence/operations/ham_evo.py,sha256=brJ11tlwj6UPYkUcnId-BKlzNStsZd0vp9FKHCFTjlM,10642
 qadence/operations/parametric.py,sha256=kV5d-diaQAoRlqKqoo0CGCbPej6eAxHQXniqfFKff3g,5394
-qadence/operations/primitive.py,sha256=hDuwWndfPWqchM_98mOMf40qpkuPuwh39DIwHAbzGRo,9944
+qadence/operations/primitive.py,sha256=hPJMDgWaEEdSYDZsr__hAcwy-QJEtzbM4qtFDcLmNBg,9881
 qadence/transpile/__init__.py,sha256=JrrQ4Osc4nNRWWjRGmVn57fWc8WwF92MokhKLRZ1vVA,499
 qadence/transpile/apply_fn.py,sha256=glZo2_wMOjw7_KgWKYbqg8j-9SDs-RefWIfxWgdQK8I,1336
 qadence/transpile/block.py,sha256=jV-EyatrwwdL2ahjF3wyEhC3PKMBPLaL5sQN1VNFc_w,11582
@@ -139,7 +141,7 @@ qadence/transpile/flatten.py,sha256=k4HAfVzvDV40HyfaukiEHyJtAtvFRIcyDbAWiCL8tf0,
 qadence/transpile/invert.py,sha256=IeyidgBwECCKB0i7Ym0KkLyfcx42LyT2mbqkfbK1H8M,4843
 qadence/transpile/noise.py,sha256=LDcDJtQGkgUPkL2t69gg6AScTb-p3J3SxCDZbYOu1L8,1668
 qadence/transpile/transpile.py,sha256=xnzkHA6Qdb-Y5Fv9Latrolrpw44N6_OKc7_QGt70f0I,2713
-qadence-1.10.1.dist-info/METADATA,sha256=hRLL8cpJOL3kBZn3Mpj0vcnaO_s5LSNPP1ihtssf-d0,10029
-qadence-1.10.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-qadence-1.10.1.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-qadence-1.10.1.dist-info/RECORD,,
+qadence-1.10.3.dist-info/METADATA,sha256=fytA26nk5vWG6gnLJZHXngs9fKcLuVpafBiLZH2yQCQ,10191
+qadence-1.10.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+qadence-1.10.3.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+qadence-1.10.3.dist-info/RECORD,,