qadence 1.6.0__py3-none-any.whl → 1.6.2__py3-none-any.whl

qadence/backends/horqrux/backend.py

@@ -195,28 +195,6 @@ class Backend(BackendInterface):
         if n_shots < 1:
             raise ValueError("You can only call sample with n_shots>0.")
 
-        def _sample(
-            _probs: ArrayLike, n_shots: int, endianness: Endianness, n_qubits: int
-        ) -> Counter:
-            _logits = jax.vmap(lambda _p: jnp.log(_p / (1 - _p)))(_probs)
-
-            def _smple(accumulator: ArrayLike, i: int) -> tuple[ArrayLike, None]:
-                accumulator = accumulator.at[i].set(
-                    jax.random.categorical(jax.random.PRNGKey(i), _logits)
-                )
-                return accumulator, None
-
-            samples = jax.lax.scan(
-                _smple, jnp.empty_like(jnp.arange(n_shots)), jnp.arange(n_shots)
-            )[0]
-            return Counter(
-                {
-                    int_to_basis(k=k, n_qubits=n_qubits, endianness=endianness): count.item()
-                    for k, count in enumerate(jnp.bincount(samples))
-                    if count > 0
-                }
-            )
-
         wf = self.run(
             circuit=circuit,
             param_values=param_values,
@@ -225,16 +203,26 @@ class Backend(BackendInterface):
             unhorqify_state=False,
         )
         probs = jnp.abs(jnp.float_power(wf, 2.0)).ravel()
-        samples = [
-            _sample(
-                _probs=probs,
-                n_shots=n_shots,
-                endianness=endianness,
-                n_qubits=circuit.abstract.n_qubits,
-            ),
-        ]
+        key = jax.random.PRNGKey(0)
+        # JAX handles pseudo random number generation by tracking an explicit state via a random key
+        # For more details, see https://jax.readthedocs.io/en/latest/random-numbers.html
+        samples = jax.vmap(
+            lambda subkey: jax.random.choice(
+                key=subkey, a=jnp.arange(0, 2**circuit.abstract.n_qubits), p=probs
+            )
+        )(jax.random.split(key, n_shots))
 
-        return samples
+        return [
+            Counter(
+                {
+                    int_to_basis(
+                        k=k, n_qubits=circuit.abstract.n_qubits, endianness=endianness
+                    ): count.item()
+                    for k, count in enumerate(jnp.bincount(samples))
+                    if count > 0
+                }
+            )
+        ]
 
     def assign_parameters(self, circuit: ConvertedCircuit, param_values: ParamDictType) -> Any:
         raise NotImplementedError

qadence/backends/pulser/backend.py

@@ -264,7 +264,10 @@ class Backend(BackendInterface):
         if isinstance(noise_probs, Iterable):
             noisy_batched_dms = []
             for noise_prob in noise_probs:
-                noisy_batched_dms.append(run_noisy_sim(noise_prob))
+                noisy_sim = run_noisy_sim(noise_prob)
+                if not param_values:
+                    noisy_sim = noisy_sim[0]
+                noisy_batched_dms.append(noisy_sim)
             noisy_batched_dms = torch.stack(noisy_batched_dms)
         else:
             noisy_batched_dms = run_noisy_sim(noise_probs)
@@ -350,10 +353,18 @@ class Backend(BackendInterface):
                 # TODO: There should be a better check for batched density matrices.
                 if dms.size()[0] > 1:
                     res_list = [
-                        [obs.native(dm, param_values, qubit_support=support) for dm in dms]
+                        [
+                            obs.native(
+                                dm.squeeze(), param_values, qubit_support=support, noise=noise
+                            )
+                            for dm in dms
+                        ]
                         for obs in observable
                     ]
-                    res = torch.stack([torch.transpose(torch.stack(res), 0, 1) for res in res_list])
+                    res = torch.stack(
+                        [torch.transpose(torch.stack(res), 0, -1) for res in res_list]
+                    )
+
                 else:
                     res_list = [
                         obs.native(dms, param_values, qubit_support=support) for obs in observable

qadence/backends/pulser/convert_ops.py

@@ -5,6 +5,7 @@ from typing import Sequence
 import torch
 from torch.nn import Module
 
+from qadence import Noise
 from qadence.blocks import (
     AbstractBlock,
 )
@@ -26,17 +27,29 @@ class PulserObservable(Module):
     def __init__(self, block: AbstractBlock, n_qubits: int | None):
         super().__init__()
         self.block = block
-        self.n_qubits = n_qubits
+        self.n_qubits = n_qubits if n_qubits else max(block.qubit_support) + 1
+
+        if not self.block.is_parametric:
+            block_mat = block_to_tensor(
+                self.block, {}, qubit_support=tuple(i for i in range(self.n_qubits))
+            ).squeeze(0)
+            self.register_buffer("block_mat", block_mat)
 
     def forward(
         self,
         state: torch.Tensor,
-        values: dict[str, torch.Tensor] | list = {},
+        values: dict[str, torch.Tensor] = dict(),
         qubit_support: tuple | None = None,
+        noise: Noise | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> torch.Tensor:
-        # FIXME: cache this, it is very inefficient for non-parametric observables
-        block_mat = block_to_tensor(
-            self.block, values, qubit_support=qubit_support, endianness=endianness  # type: ignore [arg-type]  # noqa
-        ).squeeze(0)
-        return torch.sum(torch.matmul(state, block_mat) * state.conj(), dim=1)
+        if not self.block.is_parametric:
+            block_mat = self.block_mat
+        else:
+            block_mat = block_to_tensor(
+                self.block, values, qubit_support=qubit_support, endianness=endianness  # type: ignore [arg-type]  # noqa
+            ).squeeze(0)
+        if noise is None:  # Compute expectations for state vector.
+            return torch.sum(torch.matmul(state, block_mat) * state.conj(), dim=1)
+        else:  # Compute expectations for density matrices.
+            return torch.trace(torch.matmul(block_mat, state))

qadence/backends/pyqtorch/convert_ops.py

@@ -4,7 +4,7 @@ from functools import reduce
 from itertools import chain as flatten
 from math import prod
 from operator import add
-from typing import Any, Sequence, Tuple
+from typing import Any, Iterable, Sequence, Tuple
 
 import pyqtorch as pyq
 import sympy
@@ -203,20 +203,36 @@ class PyQComposedBlock(pyq.QuantumCircuit):
         n_qubits: int,
         config: Configuration = None,
     ):
-        """Compose a chain of single qubit operations on the same qubit into a single.
+        """
+        Merge operations that are adjacent and have identical qubit_support.
 
-        call to _apply_batch_gate.
+        It results in fewer call of apply_operator
         """
         super().__init__(n_qubits, ops)
         self.qubits = qubits
+        self.merged_qubits_support = [
+            grouped_op[-1].qubit_support for grouped_op in self.grouped_operations()
+        ]
 
-    def forward(self, state: Tensor, values: dict[str, Tensor] | None = None) -> Tensor:
-        batch_size = infer_batchsize(values)
-        return apply_operator(
-            state, self.unitary(values, batch_size), self.qubits, self.n_qubits, batch_size
-        )
+    def grouped_operations(self) -> list[list[Module]]:
+        # takes a list of operations and group adjacent operations into sublist
+        # if those operations have the same control qubits
+        def _sublist_grouper(x: Iterable[list[Module]], y: Module) -> list[list[Module]]:
+            # Appends the element y with the last sublist in the list x
+            # if they have the same qubit_support.
+            # Appends the element y as a new sublist to x if it has different qubit_domain
+            x = list(x)
+            if y.qubit_support == x[-1][-1].qubit_support:
+                x[-1].append(y)
+                return x
+            else:
+                x.append([y])
+                return x
 
-    def unitary(self, values: dict[str, Tensor] | None, batch_size: int) -> Tensor:
+        return list(reduce(_sublist_grouper, iter(self.operations[1:]), [[self.operations[0]]]))
+
+    def merged_unitary(self, values: dict[str, Tensor] | None, batch_size: int) -> list[Tensor]:
+        # compute the tensor multiplication of each group of operations
         batch_first_perm = (2, 0, 1)
         undo_perm = tuple(argsort(tensor(batch_first_perm)))
 
@@ -225,7 +241,7 @@ class PyQComposedBlock(pyq.QuantumCircuit):
                 m = m.unsqueeze(2).repeat(
                     1, 1, batch_size
                 )  # Primitive gates are 2D, so we expand them.
-            elif m.shape != (2, 2, batch_size):
+            elif m.shape != (2, 2, batch_size) and m.shape != (4, 4, batch_size):
                 m = m.repeat(1, 1, batch_size)  # In case a tensor is 3D doesnt have batch_size.
             return m
 
@@ -237,13 +253,21 @@ class PyQComposedBlock(pyq.QuantumCircuit):
                 m, undo_perm
             )  # We need to undo the permute since PyQ expects (2, 2, batch_size).
 
-        # We reverse the list of tensors here since matmul is not commutative.
+        def _list_wise_bmm(ops: list[Module]) -> Tensor:
+            # Takes a list of operations and apply torch.bmm to all the unitaries of the list
+            return _batch_last(
+                reduce(bmm, [_batch_first(_expand(op.unitary(values))) for op in reversed(ops)])
+            )  # We reverse the list of tensors here since matmul is not commutative.
 
-        return _batch_last(
-            reduce(
-                bmm,
-                (_batch_first(_expand(op.unitary(values))) for op in reversed(self.operations)),
-            )
+        return list(map(_list_wise_bmm, reversed(self.grouped_operations())))[::-1]
+
+    def forward(self, state: Tensor, values: dict[str, Tensor] | None = None) -> Tensor:
+        # compute evolution of the state by the list of operations
+        batch_size = infer_batchsize(values)
+        return reduce(
+            lambda y, x: apply_operator(state=y, operator=x[0], qubits=x[1]),
+            zip(self.merged_unitary(values, batch_size), self.merged_qubits_support),
+            state,
         )
 
 

qadence/blocks/block_to_tensor.py

@@ -181,12 +181,13 @@ def _controlled_block_with_params(
         AbstractBlock: redefined controlled rotation block
         dict with new parameters which are added
     """
-    from qadence.operations import I, Z
+    from qadence.operations import I
+    from qadence.utils import P1
 
     # redefine controlled rotation block in a way suitable for matrix evaluation
     control = block.qubit_support[:-1]
     target = block.qubit_support[-1]
-    p1 = kron(0.5 * I(qubit) + (-0.5) * Z(qubit) for qubit in control)
+    p1 = kron(P1(qubit) for qubit in control)
     p0 = I(control[0]) - p1
     c_block = kron(p0, I(target)) + kron(p1, block.blocks[0])
 

qadence/blocks/primitive.py

@@ -20,7 +20,6 @@ from qadence.parameters import (
     stringify,
 )
 from qadence.types import TParameter
-from qadence.utils import format_parameter
 
 
 class PrimitiveBlock(AbstractBlock):
@@ -258,6 +257,8 @@ class ScaleBlock(ParametricBlock):
 
     @property
     def _block_title(self) -> str:
+        from qadence.utils import format_parameter
+
         (scale,) = self.parameters.expressions()
         s = rf"\[mul: {format_parameter(scale)}] "
         return s

qadence/measurements/shadow.py

@@ -10,13 +10,7 @@ from torch import Tensor
 from qadence.backend import Backend
 from qadence.backends.pyqtorch import Backend as PyQBackend
 from qadence.blocks import AbstractBlock, chain, kron
-from qadence.blocks.block_to_tensor import (
-    HMAT,
-    IMAT,
-    SDAGMAT,
-    ZMAT,
-    block_to_tensor,
-)
+from qadence.blocks.block_to_tensor import HMAT, IMAT, SDAGMAT, ZMAT, block_to_tensor
 from qadence.blocks.composite import CompositeBlock
 from qadence.blocks.primitive import PrimitiveBlock
 from qadence.blocks.utils import get_pauli_blocks, unroll_block_with_scaling
@@ -24,8 +18,8 @@ from qadence.circuit import QuantumCircuit
 from qadence.engines.differentiable_backend import DifferentiableBackend
 from qadence.noise import Noise
 from qadence.operations import X, Y, Z
-from qadence.states import one_state, zero_state
 from qadence.types import Endianness
+from qadence.utils import P0_MATRIX, P1_MATRIX
 
 pauli_gates = [X, Y, Z]
 
@@ -37,13 +31,6 @@ UNITARY_TENSOR = [
 ]
 
 
-# Projector matrices in Big-Endian convention.
-PROJECTOR_MATRICES = {
-    "0": zero_state(n_qubits=1).t() @ zero_state(n_qubits=1),
-    "1": one_state(n_qubits=1).t() @ one_state(n_qubits=1),
-}
-
-
 def identity(n_qubits: int) -> Tensor:
     return torch.eye(2**n_qubits, dtype=torch.complex128)
 
@@ -113,7 +100,7 @@ def local_shadow(sample: Counter, unitary_ids: list) -> Tensor:
     bitstring = list(sample.keys())[0]
     local_density_matrices = []
     for bit, unitary_id in zip(bitstring, unitary_ids):
-        proj_mat = PROJECTOR_MATRICES[bit]
+        proj_mat = P0_MATRIX if bit == "0" else P1_MATRIX
         unitary_tensor = UNITARY_TENSOR[unitary_id].squeeze(dim=0)
         local_density_matrices.append(
             3 * (unitary_tensor.adjoint() @ proj_mat @ unitary_tensor) - identity(1)

qadence/ml_tools/config.py

@@ -38,6 +38,16 @@ class TrainConfig:
     """
     checkpoint_best_only: bool = False
     """Write model/optimizer checkpoint only if a metric has improved."""
+    val_every: int | None = None
+    """Calculate validation metric.
+
+    If None, validation check is not performed.
+    """
+    val_epsilon: float = 1e-5
+    """Safety margin to check if validation loss is smaller than the lowest.
+
+    validation loss across previous iterations.
+    """
     validation_criterion: Optional[Callable] = None
     """A boolean function which evaluates a given validation metric is satisfied."""
     trainstop_criterion: Optional[Callable] = None
@@ -59,4 +69,4 @@ class TrainConfig:
         if self.trainstop_criterion is None:
             self.trainstop_criterion = lambda x: x <= self.max_iter
         if self.validation_criterion is None:
-            self.validation_criterion = lambda x: False
+            self.validation_criterion = lambda *x: False

qadence/ml_tools/printing.py

@@ -11,9 +11,7 @@ def print_metrics(loss: float | None, metrics: dict, iteration: int) -> None:
     print(msg)
 
 
-def write_tensorboard(
-    writer: SummaryWriter, loss: float | None, metrics: dict, iteration: int
-) -> None:
+def write_tensorboard(writer: SummaryWriter, loss: float, metrics: dict, iteration: int) -> None:
     writer.add_scalar("loss", loss, iteration)
     for key, arg in metrics.items():
         writer.add_scalar(key, arg, iteration)

qadence/ml_tools/saveload.py

@@ -53,7 +53,7 @@ def load_checkpoint(
 
 
 def write_checkpoint(
-    folder: Path, model: Module, optimizer: Optimizer | NGOptimizer, iteration: int
+    folder: Path, model: Module, optimizer: Optimizer | NGOptimizer, iteration: int | str
 ) -> None:
     from qadence.ml_tools.models import TransformedModule
     from qadence.models import QNN, QuantumModel
@@ -64,11 +64,19 @@ def write_checkpoint(
         device = str(model.device).split(":")[0]  # in case of using several CUDA devices
     except Exception:
         pass
+
+    iteration_substring = f"{iteration:03n}" if isinstance(iteration, int) else iteration
     model_checkpoint_name: str = (
-        f"model_{type(model).__name__}_ckpt_" + f"{iteration:03n}" + f"_device_{device}" + ".pt"
+        f"model_{type(model).__name__}_ckpt_"
+        + f"{iteration_substring}"
+        + f"_device_{device}"
+        + ".pt"
     )
     opt_checkpoint_name: str = (
-        f"opt_{type(optimizer).__name__}_ckpt_" + f"{iteration:03n}" + f"_device_{device}" + ".pt"
+        f"opt_{type(optimizer).__name__}_ckpt_"
+        + f"{iteration_substring}"
+        + f"_device_{device}"
+        + ".pt"
     )
     try:
         d = (
@@ -112,10 +120,7 @@ def load_model(
     except Exception as e:
         msg = f"Unable to load state dict due to {e}.\
                No corresponding pre-trained model found. Returning the un-trained model."
-        import warnings
-
-        warnings.warn(msg, UserWarning)
-        logger.warn(msg)
+        logger.warning(msg)
     return model, iteration
 
 

qadence/ml_tools/train_grad.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import math
 from logging import getLogger
 from typing import Callable, Union
 
@@ -13,7 +14,7 @@ from torch.utils.data import DataLoader
 from torch.utils.tensorboard import SummaryWriter
 
 from qadence.ml_tools.config import TrainConfig
-from qadence.ml_tools.data import DictDataLoader
+from qadence.ml_tools.data import DictDataLoader, data_to_device
 from qadence.ml_tools.optimize_step import optimize_step
 from qadence.ml_tools.printing import print_metrics, write_tensorboard
 from qadence.ml_tools.saveload import load_checkpoint, write_checkpoint
@@ -125,6 +126,22 @@ def train(
     # initialize tensorboard
     writer = SummaryWriter(config.folder, purge_step=init_iter)
 
+    perform_val = isinstance(config.val_every, int)
+    if perform_val:
+        if not isinstance(dataloader, DictDataLoader):
+            raise ValueError(
+                "If `config.val_every` is provided as an integer, dataloader must"
+                "be an instance of `DictDataLoader`."
+            )
+        iter_keys = dataloader.dataloaders.keys()
+        if "train" not in iter_keys or "val" not in iter_keys:
+            raise ValueError(
+                "If `config.val_every` is provided as an integer, the dictdataloader"
+                "must have `train` and `val` keys to access the respective dataloaders."
+            )
+        val_dataloader = dataloader.dataloaders["val"]
+        dataloader = dataloader.dataloaders["train"]
+
     ## Training
     progress = Progress(
         TextColumn("[progress.description]{task.description}"),
@@ -135,8 +152,12 @@ def train(
     data_dtype = None
     if dtype:
         data_dtype = float64 if dtype == complex128 else float32
+
+    best_val_loss = math.inf
     with progress:
         dl_iter = iter(dataloader) if dataloader is not None else None
+        if perform_val:
+            dl_iter_val = iter(val_dataloader) if val_dataloader is not None else None
 
         # outer epoch loop
         for iteration in progress.track(range(init_iter, init_iter + config.max_iter)):
@@ -177,8 +198,20 @@ def train(
                 if iteration % config.write_every == 0:
                     write_tensorboard(writer, loss, metrics, iteration)
 
+                if perform_val:
+                    if iteration % config.val_every == 0:
+                        xs = next(dl_iter_val)
+                        xs_to_device = data_to_device(xs, device=device, dtype=data_dtype)
+                        val_loss, _ = loss_fn(model, xs_to_device)
+                        if config.validation_criterion(val_loss, best_val_loss, config.val_epsilon):  # type: ignore[misc]
+                            best_val_loss = val_loss
+                            if config.folder and config.checkpoint_best_only:
+                                write_checkpoint(config.folder, model, optimizer, iteration="best")
+                            metrics["val_loss"] = val_loss
+                            write_tensorboard(writer, math.nan, metrics, iteration)
+
                 if config.folder:
-                    if iteration % config.checkpoint_every == 0:
+                    if iteration % config.checkpoint_every == 0 and not config.checkpoint_best_only:
                         write_checkpoint(config.folder, model, optimizer, iteration)
 
             except KeyboardInterrupt:
@@ -186,7 +219,7 @@ def train(
                 break
 
     # Final writing and checkpointing
-    if config.folder:
+    if config.folder and not config.checkpoint_best_only:
         write_checkpoint(config.folder, model, optimizer, iteration)
     write_tensorboard(writer, loss, metrics, iteration)
     writer.close()

qadence/operations/ham_evo.py

@@ -10,10 +10,7 @@ import sympy
 import torch
 from torch import Tensor
 
-from qadence.blocks import (
-    AbstractBlock,
-    TimeEvolutionBlock,
-)
+from qadence.blocks import AbstractBlock, TimeEvolutionBlock
 from qadence.blocks.block_to_tensor import block_to_tensor
 from qadence.blocks.utils import (
     add,  # noqa
@@ -30,7 +27,6 @@ from qadence.parameters import (
     extract_original_param_entry,
 )
 from qadence.types import LTSOrder, OpName, TGenerator, TParameter
-from qadence.utils import eigenvalues
 
 logger = getLogger(__name__)
 
@@ -112,6 +108,8 @@ class HamEvo(TimeEvolutionBlock):
     def eigenvalues_generator(
         self, max_num_evals: int | None = None, max_num_gaps: int | None = None
     ) -> Tensor:
+        from qadence.utils import eigenvalues
+
         if isinstance(self.generator, AbstractBlock):
             generator_tensor = block_to_tensor(self.generator)
         elif isinstance(self.generator, Tensor):

qadence/overlap.py

@@ -14,21 +14,20 @@ from qadence.circuit import QuantumCircuit
 from qadence.divergences import js_divergence
 from qadence.measurements import Measurements
 from qadence.models.quantum_model import QuantumModel
-from qadence.operations import SWAP, H, I, S, Z
+from qadence.operations import SWAP, H, I, S
 from qadence.transpile import reassign
 from qadence.types import BackendName, DiffMode, OverlapMethod
+from qadence.utils import P0, P1
 
 # Modules to be automatically added to the qadence namespace
 __all__ = ["Overlap", "OverlapMethod"]
 
 
 def _cswap(control: int, target1: int, target2: int) -> AbstractBlock:
-    # define projectors on control qubit
-    p0 = 0.5 * I(control) + 0.5 * Z(control)
-    p1 = 0.5 * I(control) + (-0.5) * Z(control)
-
     # construct controlled-SWAP block
-    cswap_blocks = kron(p0, I(target1), I(target2)) + kron(p1, SWAP(target1, target2))
+    cswap_blocks = kron(P0(control), I(target1), I(target2)) + kron(
+        P1(control), SWAP(target1, target2)
+    )
     cswap = tag(cswap_blocks, f"CSWAP({control}, {target1}, {target2})")
 
     return cswap
@@ -37,16 +36,12 @@ def _cswap(control: int, target1: int, target2: int) -> AbstractBlock:
 def _controlled_unitary(control: int, unitary_block: AbstractBlock) -> AbstractBlock:
     n_qubits = unitary_block.n_qubits
 
-    # define projectors on control qubit
-    p0 = 0.5 * I(control) + 0.5 * Z(control)
-    p1 = 0.5 * I(control) + (-0.5) * Z(control)
-
     # shift qubit support of unitary
     shifted_unitary_block = reassign(unitary_block, {i: control + i + 1 for i in range(n_qubits)})
 
     # construct controlled-U block
-    cu_blocks = kron(p0, *[I(control + i + 1) for i in range(n_qubits)]) + kron(
-        p1, shifted_unitary_block
+    cu_blocks = kron(P0(control), *[I(control + i + 1) for i in range(n_qubits)]) + kron(
+        P1(control), shifted_unitary_block
     )
     cu = tag(cu_blocks, f"c-U({control}, {shifted_unitary_block.qubit_support})")
 

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"]
+__all__ = ["FeatureParameter", "Parameter", "VariationalParameter", "ParamMap"]
 
 logger = getLogger(__name__)
 

qadence/states.py

@@ -5,14 +5,15 @@ from functools import singledispatch
 from typing import List
 
 import torch
+from numpy.typing import ArrayLike
 from torch import Tensor, concat
 from torch.distributions import Categorical, Distribution
 
 from qadence.blocks import ChainBlock, KronBlock, PrimitiveBlock, chain, kron
 from qadence.circuit import QuantumCircuit
 from qadence.execution import run
+from qadence.logger import get_script_logger
 from qadence.operations import CNOT, RX, RY, RZ, H, I, X
-from qadence.overlap import fidelity
 from qadence.types import PI, BackendName, Endianness, StateGeneratorType
 from qadence.utils import basis_to_int
 
@@ -44,6 +45,7 @@ DTYPE = torch.cdouble
 
 parametric_single_qubit_gates: List = [RX, RY, RZ]
 
+logger = get_script_logger(__name__)
 # PRIVATE
 
 
@@ -185,14 +187,18 @@ def one_state(n_qubits: int, batch_size: int = 1) -> Tensor:
 
 @singledispatch
 def product_state(
-    bitstring: str, batch_size: int = 1, endianness: Endianness = Endianness.BIG
-) -> Tensor:
+    bitstring: str,
+    batch_size: int = 1,
+    endianness: Endianness = Endianness.BIG,
+    backend: BackendName = BackendName.PYQTORCH,
+) -> ArrayLike:
     """
     Creates a product state from a bitstring.
 
     Arguments:
         bitstring (str): A bitstring.
         batch_size (int) : Batch size.
+        backend (BackendName): The backend to use. Default is "pyqtorch".
 
     Returns:
         A torch.Tensor.
@@ -201,10 +207,16 @@ def product_state(
     ```python exec="on" source="material-block" result="json"
     from qadence.states import product_state
 
-    print(product_state("1100"))
+    print(product_state("1100", backend="pyqtorch"))
+    print(product_state("1100", backend="horqrux"))
     ```
     """
-    return _state_from_bitstring(bitstring, batch_size, endianness=endianness)
+    if batch_size:
+        logger.debug(
+            "The input `batch_size` is going to be deprecated. "
+            "For now, default batch_size is set to 1."
+        )
+    return run(product_block(bitstring), backend=backend, endianness=endianness)
 
 
 @product_state.register
@@ -529,6 +541,8 @@ def rand_bitstring(N: int) -> str:
 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]

qadence/utils.py

@@ -2,8 +2,9 @@ from __future__ import annotations
 
 import math
 from collections import Counter
+from functools import partial
 from logging import getLogger
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import numpy as np
 import sympy
@@ -14,6 +15,10 @@ from torch.linalg import eigvals
 
 from qadence.types import Endianness, ResultType, TNumber
 
+if TYPE_CHECKING:
+    from qadence.operations import Projector
+
+
 # Modules to be automatically added to the qadence namespace
 __all__ = []  # type: ignore
 
@@ -259,3 +264,37 @@ def validate_values_and_state(
         else:
             if not is_qadence_shape(state, n_qubits) or state.shape[0] > 1:
                 raise ValueError("Jax only supports unbatched states.")
+
+
+def one_qubit_projector(state: str, target: int) -> Projector:
+    """Returns the projector for a single qubit system.
+
+    Args:
+        state (str): The state of the projector.
+        target (int): The target qubit.
+
+    Returns:
+        Projector: The projector operator.
+    """
+    from qadence.operations import Projector
+
+    assert state in ["0", "1"], "State must be either '0' or '1'."
+    return Projector(ket=state, bra=state, qubit_support=target)
+
+
+def one_qubit_projector_matrix(state: str) -> Tensor:
+    """Returns the projector for a single qubit system.
+
+    Args:
+        state (str): The state of the projector.
+
+    Returns:
+        Tensor: The projector operator.
+    """
+    return one_qubit_projector(state, 0).tensor().squeeze()
+
+
+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.6.0.dist-info → qadence-1.6.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qadence
-Version: 1.6.0
+Version: 1.6.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>
 License: Apache 2.0
@@ -30,13 +30,11 @@ Requires-Dist: sympytorch>=0.1.2
 Requires-Dist: tensorboard>=2.12.0
 Requires-Dist: torch
 Provides-Extra: all
-Requires-Dist: amazon-braket-sdk<1.71.2; extra == 'all'
-Requires-Dist: graphviz; extra == 'all'
+Requires-Dist: braket; extra == 'all'
 Requires-Dist: libs; extra == 'all'
-Requires-Dist: pasqal-cloud==0.8.1; extra == 'all'
 Requires-Dist: protocols; extra == 'all'
-Requires-Dist: pulser-core==0.18.0; extra == 'all'
-Requires-Dist: pulser-simulation==0.18.0; extra == 'all'
+Requires-Dist: pulser; extra == 'all'
+Requires-Dist: visualization; extra == 'all'
 Provides-Extra: braket
 Requires-Dist: amazon-braket-sdk<1.71.2; extra == 'braket'
 Provides-Extra: dlprof
@@ -55,9 +53,9 @@ Requires-Dist: qadence-libs; extra == 'libs'
 Provides-Extra: protocols
 Requires-Dist: qadence-protocols; extra == 'protocols'
 Provides-Extra: pulser
-Requires-Dist: pasqal-cloud==0.8.1; extra == 'pulser'
-Requires-Dist: pulser-core==0.18.0; extra == 'pulser'
-Requires-Dist: pulser-simulation==0.18.0; 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'
 Provides-Extra: visualization
 Requires-Dist: graphviz; extra == 'visualization'
 Description-Content-Type: text/markdown

{qadence-1.6.0.dist-info → qadence-1.6.2.dist-info}/RECORD

@@ -9,17 +9,17 @@ qadence/finitediff.py,sha256=TijuaWUbX9VlbLyMYco6HkK9eCoRTVnKug4Ekd6mlTI,1592
 qadence/libs.py,sha256=HetkKO8TCTlVCViQdVQJvxwBekrhd-y_iMox4UJMY1M,410
 qadence/log_config.yaml,sha256=WwSpxqMSXgPJ7wO_wh46UnFzXdgX9NVA4MbN3TcJFyE,485
 qadence/logger.py,sha256=Hb76pK3VyQjVjJb4_NqFlOJgjYJVa8t7DHJFlzOM86M,407
-qadence/overlap.py,sha256=3vsg0HLOO3X8LiVgvjSc5s-cs8Di4TpEA657LWZ5HEY,17294
-qadence/parameters.py,sha256=9BuEt2MZRwxhmPZHVPLt-GF1ZUgXkmg63owgDiJa74U,12325
+qadence/overlap.py,sha256=VHEXfsqcn7aax1-f_iJ8Fe5Eoz4AcceQbwgqipifgzY,17104
+qadence/parameters.py,sha256=WdHCcLJ8tyRfBdaLAo89GwJboj6wLdfhdHdqPDLLAhM,12337
 qadence/protocols.py,sha256=bcYTxSjgMPV-a-D6yv90jCpnGik8myzaNpFv9z1gzJ0,442
 qadence/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qadence/qubit_support.py,sha256=Nkn1Q01RVViTcggSIom7EFKdWpAuM4TMGwBZ5feCUxA,2120
 qadence/register.py,sha256=cBMzwZ7GWZ5ieuFt0bpproEI6a2ncNwfjj7ic379zyg,10276
 qadence/serial_expr_grammar.peg,sha256=z5ytL7do9kO8o4h-V5GrsDuLdso0KsRcMuIYURFfmAY,328
 qadence/serialization.py,sha256=0UdcDQP2tJOtygVQI258G3MgnDiZJmBY4o15w0G-O0Y,15686
-qadence/states.py,sha256=_J__vZuDPsKqKDFSCfgWxSNY2Ho6cCqTHjJ9-gMtd8M,14341
+qadence/states.py,sha256=5QIOBBYs8e2uLFiMa8iMYZ-MvWIFEqkZAjNYx0SyYPI,14843
 qadence/types.py,sha256=wsxZNik5d8xdw46Dp1xRHpVS1-mSM-kMl2J_W64UhgA,9732
-qadence/utils.py,sha256=Y-Xc7zP6DOZDwn7QI43qA4670-n8yuCK01pG4BpypSI,9056
+qadence/utils.py,sha256=mTDI54uXsFXrKKFshmXFzDdoaeLMLlqA1MR2G061TSc,10092
 qadence/analog/__init__.py,sha256=BCyS9R4KUjzUXN0Ax3b0eMo8ZAuSkGoJQVtZ4_pvAFs,279
 qadence/analog/addressing.py,sha256=fu5-xW9lquEbagApNp23S_ET1kl0iDtZUrIYSVNmw9s,6435
 qadence/analog/constants.py,sha256=B2phQoN1ASL8CwM-Dsa1rbraYwGwwPSeiB3HbVe-MPA,1243
@@ -37,31 +37,31 @@ qadence/backends/braket/backend.py,sha256=WX5FG4WsrtdnG0at2DvIY0n_AFm44t4g5OIJ1e
 qadence/backends/braket/config.py,sha256=7cu22dmYdp48Fu760HPfxBHinaUnGmzx9MkE_EPhVN8,594
 qadence/backends/braket/convert_ops.py,sha256=DVXV7sT9sX_yGOgPKclD9KIGgmbBRuDy_e39i1Z8I1s,3417
 qadence/backends/horqrux/__init__.py,sha256=0OdVy6cq0oQggV48LO1WXdaZuSkDkz7OYNEPIkNAmfk,140
-qadence/backends/horqrux/backend.py,sha256=SxelrhCELJ0lJcThOCtMVyV-LjyzxZ7t-U4l_9Tmupw,9421
+qadence/backends/horqrux/backend.py,sha256=W5sYvX9QP-xD3MMjwX-ZMcpHuncPVqBTyn80jgWViUM,9094
 qadence/backends/horqrux/config.py,sha256=xz7JlUcwW_4JAbvProbSI9hA1SXZRRAN0Hr2bvmLzfg,892
 qadence/backends/horqrux/convert_ops.py,sha256=nzfYF0yjB7zwaHCEXWZUUYDfz38Yi22xF2zDRFaOwR0,8564
 qadence/backends/pulser/__init__.py,sha256=capQ-eHqwtOeLf4mWsI0BIseAHhiLGie5cFD4-iVhUo,116
-qadence/backends/pulser/backend.py,sha256=3n0ytKVIxjz3T29AbfCxvEEsrfg3wG0ir3z5Sq2ga7A,15028
+qadence/backends/pulser/backend.py,sha256=51lbX-KfK6wFxFW7t0QwsXXwAw06D6z2msvSZzM_vD8,15363
 qadence/backends/pulser/channels.py,sha256=ZF0yEXUFHAmi3IdeXjzdTNGR5NzaRRFTiUpUGVg2sO4,329
 qadence/backends/pulser/cloud.py,sha256=0uUluvbFV9sOuCPraE-9uiVtC3Q8QaDY1IJMDi8grDM,2057
 qadence/backends/pulser/config.py,sha256=aoHDmtgq5i0Zryxenw_p3uARY0B1w-UaYvfqDmrWHM0,2175
-qadence/backends/pulser/convert_ops.py,sha256=0HGWe5kIwI1ZALHf2j68B8aBOhwFNZV-mDy1_6zsF5g,1227
+qadence/backends/pulser/convert_ops.py,sha256=of8NCZwHX0zSisRo-sBRSyQVg841iFKLhUm6WWZGsCY,1800
 qadence/backends/pulser/devices.py,sha256=DermLZNfmCB3SqteKVW4uhg4jp6ya1G6ptnXbBnJogI,2448
 qadence/backends/pulser/pulses.py,sha256=F4fExIRAhLPMtVg1bhNtDihUYHxu5RExGjovk8-CQIo,11884
 qadence/backends/pulser/waveforms.py,sha256=0uz95b7rUaUUtN0tuHBZmJ0H6UBmfHST_59ozwsRCzg,2227
 qadence/backends/pyqtorch/__init__.py,sha256=0OdVy6cq0oQggV48LO1WXdaZuSkDkz7OYNEPIkNAmfk,140
 qadence/backends/pyqtorch/backend.py,sha256=7CkXccCHwK3pijNDmIB_-hdRGa79yhZ3_3A2p7wOSB0,9785
 qadence/backends/pyqtorch/config.py,sha256=hhea1dDAeee7uDE1fiCh4lJRS0EMSc3mmbXn92HBdyA,1898
-qadence/backends/pyqtorch/convert_ops.py,sha256=By_p1-Oem8MhHYP8jx5qdut9lhDWN0xc4B9YaP0MSxA,17512
+qadence/backends/pyqtorch/convert_ops.py,sha256=0CLIncSmOSOZh4o7kjdOSc9a60srtegGul-dj_Q8Ufc,18935
 qadence/blocks/__init__.py,sha256=H6jEA_CptkE-eoB4UfSbUiDszbxxhZwECV_TgoZWXoU,960
 qadence/blocks/abstract.py,sha256=35RcVlNvD1BmBoJ8bbYJ3LrdU72wixt9ZmTbCtEwNus,11796
 qadence/blocks/analog.py,sha256=ymnnlSVoW1XL05ZvnnHCqRTHuOXIEY_7E9M0PNKJZy4,10812
-qadence/blocks/block_to_tensor.py,sha256=VleicLSyn8kLFoRKGMmcaj1DKpLIyMFZSC3zahr4Evo,17362
+qadence/blocks/block_to_tensor.py,sha256=Sg7YGKUoPUUHKvyB8Khztrk7UYnV5SD451_3I00n84w,17367
 qadence/blocks/composite.py,sha256=z_lXRBVnh-DdvfZdv6T0ZEmVhlU76zBt72P_FGGa-PQ,8897
 qadence/blocks/embedding.py,sha256=TQt620UIVaNYHP34tpK9slv-PFiLvTQRYw5Ez9RuImE,6513
 qadence/blocks/manipulate.py,sha256=kPmzej7mnWFoqTJA2CkGulT7hcPha0GGPARC8rjZltg,2387
 qadence/blocks/matrix.py,sha256=WTByjt_0yf3OiK-OcJNEfSGO8Hyq_tIBlklSO_BtOb0,3776
-qadence/blocks/primitive.py,sha256=fC5ItpA-52LOiGPT1ERM4RshP6PQlkxlgR9p2J0Rgz4,16631
+qadence/blocks/primitive.py,sha256=NWxgpG77cjBy-APg-kAGOX2kOR-OuH8hzml8U_Zfv1A,16640
 qadence/blocks/utils.py,sha256=iCJDi6HTYYaQQCoP3cdIKeCDuy8KQCxctrHN5QWXV-M,16349
 qadence/constructors/__init__.py,sha256=PWfSKcEJmo5azIkcRuRWsmch3FOeXl055iPsboNzryQ,938
 qadence/constructors/ansatze.py,sha256=bTrcF2RsyA_Btmkk80tWxP1dn9fK_SXAQFueIuWkT-c,9660
@@ -97,7 +97,7 @@ qadence/exceptions/exceptions.py,sha256=4j_VJpx2sZ2Mir5BJUWu4nwb131FY1ygO4q8-Xly
 qadence/measurements/__init__.py,sha256=RIjG9tVJMqhNzyj7maZI250Um0KgHl2PizDcKJag-JU,161
 qadence/measurements/protocols.py,sha256=mD50R9yPs5bIYH7Efd0BsR0503apiyrsZydi_Q6BJag,1161
 qadence/measurements/samples.py,sha256=AVvszDwgfKnZ_ooATyTA3270vGeg1V3WO94jsfrTk-8,1200
-qadence/measurements/shadow.py,sha256=ROMQFtV9LaUB2Q6pjcBY1qDAYjDUGq1FUFmI8WXTd0g,12550
+qadence/measurements/shadow.py,sha256=lYZWbBCJJh7pFXPV5jSvsyN_0g22ao3jARpKnx1jeJQ,12342
 qadence/measurements/tomography.py,sha256=8fzXhYOu_DaMiUoZzLvpP03WhuwlZ3ldkWepLUHjWqM,2665
 qadence/measurements/utils.py,sha256=CJmnSobzdeR4T4FuEpad7d-BSJ9W-wTaU9hRbveB6kY,6534
 qadence/mitigations/__init__.py,sha256=RzaxYJftePFMloGhBVSixZ8fSe-ps_Jc-EyPm6xz-bs,159
@@ -105,15 +105,15 @@ qadence/mitigations/analog_zne.py,sha256=g0QkjSdF-N9Dv2N8Oza4sylnjUMid5ea-4NCT9T
 qadence/mitigations/protocols.py,sha256=Jq9MyLujfTyWmc7XVUGYVRUkJT1MmZw-GgmWpVjmX2Y,1608
 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/config.py,sha256=bA_9TYeuy0DPdhFg0_3PFctd6bx4hKugg4LmlUB2jyw,2647
 qadence/ml_tools/data.py,sha256=8ZUFjhQSp94w7icX7RzM2J39Yo7P_T-AgjcThBc8miI,4283
 qadence/ml_tools/models.py,sha256=lELcq__wfGsurUm2UOgYkOzdBDwu66Nik9ySoAjDKnY,12673
 qadence/ml_tools/optimize_step.py,sha256=ATXWmAqybJVK3QmAaDqVXB5mxjTo2MIi_e0a5WSPFpc,1800
 qadence/ml_tools/parameters.py,sha256=gew2Kq_5-RgRpaTvs8eauVhgo0sTqqDQEV6WHFEiLGM,1301
-qadence/ml_tools/printing.py,sha256=kwwD9yLVqezaqWX5OAsXr8GLdJUnGrY-t5SnoKHtl9g,707
-qadence/ml_tools/saveload.py,sha256=ZjG1dvJvJpSgEIj6Ln-ogDX2fjuM51YaZiter7NU6H0,4946
+qadence/ml_tools/printing.py,sha256=YK2zc9SOc5wiLnMxm3Q1gSwPAVW9Vy2Pcnjg9gP0aKU,694
+qadence/ml_tools/saveload.py,sha256=_5ni1sUohbtpGAcCRynh4j1dXkMXDpvgoDN-Jby2miQ,5041
 qadence/ml_tools/tensors.py,sha256=xZ9ZRzOqEaMgLUGWQf1najDmL6iLuN1ojCGVFs1Tm94,1337
-qadence/ml_tools/train_grad.py,sha256=wBrWyYzV2U9iJ4Q2xaNiHEEfAl55wqhQ9ljHIPA0rXA,7724
+qadence/ml_tools/train_grad.py,sha256=6ZFFd7wGKFFqz3wpVkSD_xFjQPJ4IgIpA0IjYanohcs,9507
 qadence/ml_tools/train_no_grad.py,sha256=PrOfPwu6C-YqfFxnRkbeyOQzqSyjRrx4AZZd6C-1xRw,4705
 qadence/ml_tools/utils.py,sha256=_GZSN5Flk1nRFutkXih397Q3cWKdX0UP8c9CRXpUL7c,1654
 qadence/models/__init__.py,sha256=0nZzAC2TGr8Yuf40-R7m2cSsr_BlNq_GsMOwaOYZLqM,193
@@ -125,7 +125,7 @@ qadence/noise/readout.py,sha256=UpUdxaGu09SmqKXn0O7RYfF7b7UcRZiNMfDlpY0weV0,6726
 qadence/operations/__init__.py,sha256=HAAo9VZUTq2H7kcEarChTgTWCIq7LT25-xBxkwE0F9c,1922
 qadence/operations/analog.py,sha256=v11DSrg-XUbwIAWAWM43y3VQbYKsx2ynx-HimUoC-x0,7435
 qadence/operations/control_ops.py,sha256=ZDOmTXxQJXSP2ASNWNUlt7pIuEjAVNT2FmexbK_TisM,9484
-qadence/operations/ham_evo.py,sha256=u8ZuEycES_TjZTyIRC_qRDAUQUH9hNvnZLLnO7aBMyc,7391
+qadence/operations/ham_evo.py,sha256=4KdIIkvkDZwoMs19qxDdNBsDC3W4keg33j1wZHXJNrE,7387
 qadence/operations/parametric.py,sha256=BHGGn8k7hIZX8_0V1K1_FOnILAROEtqZGjBdIfzMcWI,4911
 qadence/operations/primitive.py,sha256=ekiylIW7mWjesBXVyVmowF75Ek82T_eNUVcDTEAGzFg,9002
 qadence/transpile/__init__.py,sha256=lb5LwsYb6lN5YFBsU3YBey7-0OcUQpYa3Q4hG6zmgi0,457
@@ -136,7 +136,7 @@ qadence/transpile/digitalize.py,sha256=iWRwYAYQsD2INHj0HNbGJriv_3fRCuBW1nDBrwtKS
 qadence/transpile/flatten.py,sha256=EdhSG5WyF56nbnxINNLqrHgY84MRM1YFjT3fR4aph5Q,3427
 qadence/transpile/invert.py,sha256=KAefHTG2AWr39aengVhXrzCtJPhrZC-ZnL6vYvmbnY0,4867
 qadence/transpile/transpile.py,sha256=6MRRkk1OS279L1fwUQjazA6qlfpbd-T_EJMKT8hAhOU,2721
-qadence-1.6.0.dist-info/METADATA,sha256=T3KtrCaUGRmSBxawR1QrU5yoM8NMKJv4_n18kC7sKo4,9302
-qadence-1.6.0.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
-qadence-1.6.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-qadence-1.6.0.dist-info/RECORD,,
+qadence-1.6.2.dist-info/METADATA,sha256=8vr_cvIxfMOFrYUEiQpTUDRyA3CeOJQ3_YpV1kCFatA,9169
+qadence-1.6.2.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
+qadence-1.6.2.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+qadence-1.6.2.dist-info/RECORD,,