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

qadence/backends/utils.py

@@ -17,9 +17,9 @@ from torch import (
     no_grad,
     rand,
 )
-from torch import flatten as torchflatten
 
-from qadence.utils import Endianness, int_to_basis
+from qadence.types import ParamDictType
+from qadence.utils import Endianness, int_to_basis, is_qadence_shape
 
 FINITE_DIFF_EPS = 1e-06
 # Dict of NumPy dtype -> torch dtype (when the correspondence exists)
@@ -92,7 +92,7 @@ def count_bitstrings(sample: Tensor, endianness: Endianness = Endianness.BIG) ->
     )
 
 
-def to_list_of_dicts(param_values: dict[str, Tensor]) -> list[dict[str, float]]:
+def to_list_of_dicts(param_values: ParamDictType) -> list[ParamDictType]:
     if not param_values:
         return [param_values]
 
@@ -119,17 +119,13 @@ def pyqify(state: Tensor, n_qubits: int = None) -> Tensor:
 
 def unpyqify(state: Tensor) -> Tensor:
     """Convert a state of shape [2] * n_qubits + [batch_size] to (batch_size, 2**n_qubits)."""
-    return torchflatten(state, start_dim=0, end_dim=-2).t()
+    return torch.flatten(state, start_dim=0, end_dim=-2).t()
 
 
 def is_pyq_shape(state: Tensor, n_qubits: int) -> bool:
     return state.size()[:-1] == [2] * n_qubits  # type: ignore[no-any-return]
 
 
-def is_qadence_shape(state: Tensor, n_qubits: int) -> bool:
-    return state.shape[1] == 2**n_qubits  # type: ignore[no-any-return]
-
-
 def validate_state(state: Tensor, n_qubits: int) -> None:
     """Check if a custom initial state conforms to the qadence or the pyqtorch format."""
     if state.dtype != complex128:
@@ -145,7 +141,7 @@ def validate_state(state: Tensor, n_qubits: int) -> None:
         )
 
 
-def infer_batchsize(param_values: dict[str, Tensor] = None) -> int:
+def infer_batchsize(param_values: ParamDictType = None) -> int:
     """Infer the batch_size through the length of the parameter tensors."""
     return max([len(tensor) for tensor in param_values.values()]) if param_values else 1
 

qadence/blocks/abstract.py

@@ -5,7 +5,7 @@ from abc import ABC, abstractmethod, abstractproperty
 from dataclasses import dataclass
 from functools import cached_property
 from pathlib import Path
-from typing import ClassVar, Iterable, Tuple, Union, get_args
+from typing import ClassVar, Iterable, Tuple, TypeVar, Union, get_args
 
 import sympy
 import torch
@@ -287,6 +287,7 @@ class AbstractBlock(ABC):
     def __hash__(self) -> int:
         return hash(self._to_json())
 
+    @abstractmethod
     def dagger(self) -> AbstractBlock:
         raise NotImplementedError(
             f"Hermitian adjoint of the Block '{type(self)}' is not implemented yet!"
@@ -333,3 +334,6 @@ class AbstractBlock(ABC):
         elif isinstance(self, PrimitiveBlock):
             return self.name == "I"
         return False
+
+
+TAbstractBlock = TypeVar("TAbstractBlock", bound=AbstractBlock)

qadence/blocks/analog.py

@@ -59,8 +59,8 @@ class AnalogBlock(AbstractBlock):
     @property
     def eigenvalues_generator(self) -> torch.Tensor:
         msg = (
-            "Eigenvalues of analog blocks can be computed via "
-            "`add_interaction(register, block).eigenvalues`"
+            "Eigenvalues of for generator of analog blocks can be computed via "
+            "`add_background_hamiltonian(block, register).eigenvalues_generator`. "
         )
         raise NotImplementedError(msg)
 
@@ -68,7 +68,7 @@ class AnalogBlock(AbstractBlock):
     def eigenvalues(self) -> torch.Tensor:
         msg = (
             "Eigenvalues of analog blocks can be computed via "
-            "`add_interaction(register, block).eigenvalues`"
+            "`add_background_hamiltonian(block, register).eigenvalues`. "
         )
         raise NotImplementedError(msg)
 
@@ -83,11 +83,19 @@ class AnalogBlock(AbstractBlock):
         return s
 
     def compute_eigenvalues_generator(
-        self, register: Register, block: AbstractBlock
+        self,
+        block: AbstractBlock,
+        register: Register,
     ) -> torch.Tensor:
-        from qadence import add_interaction
+        # FIXME: Revisit analog blocks eigenvalues
+        from qadence.analog import add_background_hamiltonian
+
+        return add_background_hamiltonian(block, register).eigenvalues_generator  # type: ignore [union-attr]
 
-        return add_interaction(register, block).eigenvalues_generator
+    def dagger(self) -> AbstractBlock:
+        raise NotImplementedError(
+            f"Hermitian adjoint of block type {type(self)} is not implemented yet."
+        )
 
 
 @dataclass(eq=False, repr=False)
@@ -108,8 +116,6 @@ class WaitBlock(AnalogBlock):
     with `nᵢ = (1-Zᵢ)/2`.
 
     To construct this block, use the [`wait`][qadence.operations.wait] function.
-
-    Can be used with `add_interaction`.
     """
 
     _eigenvalues_generator: torch.Tensor | None = None
@@ -117,6 +123,8 @@ class WaitBlock(AnalogBlock):
     parameters: ParamMap = ParamMap(duration=1000.0)  # ns
     qubit_support: QubitSupport = QubitSupport("global")
 
+    add_pattern: bool = True
+
     @property
     def eigenvalues_generator(self) -> torch.Tensor | None:
         return self._eigenvalues_generator
@@ -145,7 +153,6 @@ class ConstantAnalogRotation(AnalogBlock):
       [`AnalogRY`][qadence.operations.AnalogRY],
       [`AnalogRZ`][qadence.operations.AnalogRZ]
 
-    Can be used with `add_interaction`.
     WARNING: do not use `ConstantAnalogRotation` with `alpha` as differentiable parameter - use
     the convenience wrappers mentioned above.
     """
@@ -161,6 +168,8 @@ class ConstantAnalogRotation(AnalogBlock):
     )
     qubit_support: QubitSupport = QubitSupport("global")
 
+    add_pattern: bool = True
+
     @property
     def _block_title(self) -> str:
         a = self.parameters.alpha

qadence/blocks/block_to_tensor.py

@@ -15,8 +15,11 @@ from qadence.blocks import (
     PrimitiveBlock,
     ScaleBlock,
 )
+from qadence.blocks.primitive import ProjectorBlock
 from qadence.blocks.utils import chain, kron, uuid_to_expression
 from qadence.parameters import evaluate, stringify
+
+# from qadence.states import product_state
 from qadence.types import Endianness, TensorType, TNumber
 
 J = torch.tensor(1j)
@@ -463,6 +466,14 @@ def _block_to_tensor_embedded(
         # add missing identities on unused qubits
         mat = _fill_identities(block_mat, block.qubit_support, qubit_support, endianness=endianness)
 
+    elif isinstance(block, ProjectorBlock):
+        from qadence.states import product_state
+
+        bra = product_state(block.bra)
+        ket = product_state(block.ket)
+
+        mat = torch.kron(ket, bra.T)
+
     else:
         raise TypeError(f"Conversion for block type {type(block)} not supported.")
 

qadence/blocks/embedding.py

@@ -2,11 +2,10 @@ from __future__ import annotations
 
 from typing import Callable, Iterable, List
 
-import numpy as np
 import sympy
-import sympytorch  # type: ignore [import]
-import torch
-from torch import Tensor
+from numpy import array as nparray
+from numpy import cdouble as npcdouble
+from torch import tensor
 
 from qadence.blocks import (
     AbstractBlock,
@@ -16,9 +15,24 @@ from qadence.blocks.utils import (
     parameters,
     uuid_to_expression,
 )
-from qadence.parameters import evaluate, stringify, torchify
+from qadence.parameters import evaluate, make_differentiable, stringify
+from qadence.types import ArrayLike, DifferentiableExpression, Engine, ParamDictType, TNumber
 
-StrTensorDict = dict[str, Tensor]
+
+def _concretize_parameter(engine: Engine) -> Callable:
+    if engine == Engine.JAX:
+        from jax.numpy import array as jaxarray
+        from jax.numpy import float64 as jaxfloat64
+
+        def concretize_parameter(value: TNumber, trainable: bool = False) -> ArrayLike:
+            return jaxarray([value], dtype=jaxfloat64)
+
+    else:
+
+        def concretize_parameter(value: TNumber, trainable: bool = False) -> ArrayLike:
+            return tensor([value], requires_grad=trainable)
+
+    return concretize_parameter
 
 
 def unique(x: Iterable) -> List:
@@ -26,14 +40,13 @@ def unique(x: Iterable) -> List:
 
 
 def embedding(
-    block: AbstractBlock, to_gate_params: bool = False
-) -> tuple[StrTensorDict, Callable[[StrTensorDict, StrTensorDict], StrTensorDict],]:
-    """Construct embedding function.
+    block: AbstractBlock, to_gate_params: bool = False, engine: Engine = Engine.TORCH
+) -> tuple[ParamDictType, Callable[[ParamDictType, ParamDictType], ParamDictType],]:
+    """Construct embedding function which maps user-facing parameters to either *expression-level*.
 
-    It maps user-facing parameters to either *expression-level*
-    parameters or *gate-level* parameters. The construced embedding function has the signature:
+    parameters or *gate-level* parameters. The constructed embedding function has the signature:
 
-         embedding_fn(params: StrTensorDict, inputs: StrTensorDict) -> StrTensorDict:
+         embedding_fn(params: ParamDictType, inputs: ParamDictType) -> ParamDictType:
 
     which means that it maps the *variational* parameter dict `params` and the *feature* parameter
     dict `inputs` to one new parameter dict `embedded_dict` which holds all parameters that are
@@ -56,6 +69,13 @@ def embedding(
     Returns:
         A tuple with variational parameter dict and the embedding function.
     """
+    concretize_parameter = _concretize_parameter(engine)
+    if engine == Engine.TORCH:
+        cast_dtype = tensor
+    else:
+        from jax.numpy import array
+
+        cast_dtype = array
 
     unique_expressions = unique(expressions(block))
     unique_symbols = [p for p in unique(parameters(block)) if not isinstance(p, sympy.Array)]
@@ -77,16 +97,18 @@ def embedding(
     # we dont need to care about constant symbols if they are contained in an symbolic expression
     # we only care about gate params which are ONLY a constant
 
-    embeddings: dict[sympy.Expr, sympytorch.SymPyModule] = {
-        expr: torchify(expr) for expr in unique_expressions if not expr.is_number
+    embeddings: dict[sympy.Expr, DifferentiableExpression] = {
+        expr: make_differentiable(expr=expr, engine=engine)
+        for expr in unique_expressions
+        if not expr.is_number
     }
 
     uuid_to_expr = uuid_to_expression(block)
 
-    def embedding_fn(params: StrTensorDict, inputs: StrTensorDict) -> StrTensorDict:
-        embedded_params: dict[sympy.Expr, Tensor] = {}
+    def embedding_fn(params: ParamDictType, inputs: ParamDictType) -> ParamDictType:
+        embedded_params: dict[sympy.Expr, ArrayLike] = {}
         for expr, fn in embeddings.items():
-            angle: Tensor
+            angle: ArrayLike
             values = {}
             for symbol in expr.free_symbols:
                 if symbol.name in inputs:
@@ -112,26 +134,26 @@ def embedding(
             embedded_params[e] = params[stringify(e)]
 
         if to_gate_params:
-            gate_lvl_params: StrTensorDict = {}
+            gate_lvl_params: ParamDictType = {}
             for uuid, e in uuid_to_expr.items():
                 gate_lvl_params[uuid] = embedded_params[e]
             return gate_lvl_params
         else:
             return {stringify(k): v for k, v in embedded_params.items()}
 
-    params: StrTensorDict
-    params = {p.name: torch.tensor([p.value], requires_grad=True) for p in trainable_symbols}
+    params: ParamDictType
+    params = {
+        p.name: concretize_parameter(value=p.value, trainable=True) for p in trainable_symbols
+    }
     params.update(
         {
-            stringify(expr): torch.tensor([evaluate(expr)], requires_grad=False)
+            stringify(expr): concretize_parameter(value=evaluate(expr), trainable=False)
             for expr in constant_expressions
         }
     )
     params.update(
         {
-            stringify(expr): torch.tensor(
-                np.array(expr.tolist(), dtype=np.cdouble), requires_grad=False
-            )
+            stringify(expr): cast_dtype(nparray(expr.tolist(), dtype=npcdouble))
             for expr in unique_const_matrices
         }
     )

qadence/blocks/primitive.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from abc import abstractmethod
+from copy import deepcopy
 from typing import Any, Iterable, Tuple
 
 import sympy
@@ -13,6 +14,7 @@ from qadence.blocks.abstract import AbstractBlock
 from qadence.parameters import (
     Parameter,
     ParamMap,
+    dagger_expression,
     evaluate,
     extract_original_param_entry,
     stringify,
@@ -101,6 +103,9 @@ class PrimitiveBlock(AbstractBlock):
     def n_supports(self) -> int:
         return len(self.qubit_support)
 
+    def dagger(self) -> PrimitiveBlock:
+        return self
+
 
 class ParametricBlock(PrimitiveBlock):
     """Parameterized primitive blocks."""
@@ -200,11 +205,10 @@ class ParametricBlock(PrimitiveBlock):
         target = d["qubit_support"][0]
         return cls(target, params)  # type: ignore[call-arg]
 
-    def dagger(self) -> ParametricBlock:  # type: ignore[override]
+    def dagger(self) -> ParametricBlock:
         exprs = self.parameters.expressions()
-        args = tuple(-extract_original_param_entry(param) for param in exprs)
-        args = args if -1 in self.qubit_support else (*self.qubit_support, *args)
-        return self.__class__(*args)  # type: ignore[arg-type]
+        params = tuple(-extract_original_param_entry(param) for param in exprs)
+        return type(self)(*self.qubit_support, *params)  # type: ignore[arg-type]
 
 
 class ScaleBlock(ParametricBlock):
@@ -304,9 +308,8 @@ class ScaleBlock(ParametricBlock):
             )
 
     def dagger(self) -> ScaleBlock:
-        return self.__class__(
-            self.block, Parameter(-extract_original_param_entry(self.parameters.parameter))
-        )
+        p = list(self.parameters.expressions())[0]
+        return self.__class__(self.block.dagger(), dagger_expression(p))
 
     def _to_dict(self) -> dict:
         return {
@@ -350,13 +353,25 @@ class ControlBlock(PrimitiveBlock):
     """The abstract ControlBlock."""
 
     name = "Control"
+    control: tuple[int, ...]
+    target: tuple[int, ...]
 
     def __init__(self, control: tuple[int, ...], target_block: PrimitiveBlock) -> None:
+        self.control = control
         self.blocks = (target_block,)
+        self.target = target_block.qubit_support
 
         # using tuple expansion because some control operations could
         # have multiple targets, e.g. CSWAP
-        super().__init__((*control, *target_block.qubit_support))  # target_block.qubit_support[0]))
+        super().__init__((*control, *self.target))  # target_block.qubit_support[0]))
+
+    @property
+    def n_controls(self) -> int:
+        return len(self.control)
+
+    @property
+    def n_targets(self) -> int:
+        return len(self.target)
 
     @property
     def _block_title(self) -> str:
@@ -391,16 +406,28 @@ class ControlBlock(PrimitiveBlock):
         target = d["qubit_support"][1]
         return cls(control, target)
 
+    def dagger(self) -> ControlBlock:
+        blk = deepcopy(self)
+        blk.blocks = (self.blocks[0].dagger(),)
+        return blk
+
 
 class ParametricControlBlock(ParametricBlock):
     """The abstract parametrized ControlBlock."""
 
     name = "ParameterizedControl"
+    control: tuple[int, ...] = ()
+    blocks: tuple[ParametricBlock, ...]
 
     def __init__(self, control: tuple[int, ...], target_block: ParametricBlock) -> None:
         self.blocks = (target_block,)
+        self.control = control
         self.parameters = target_block.parameters
-        super().__init__((*control, target_block.qubit_support[0]))
+        super().__init__((*control, *target_block.qubit_support))
+
+    @property
+    def n_controls(self) -> int:
+        return len(self.control)
 
     @property
     def eigenvalues_generator(self) -> torch.Tensor:
@@ -454,3 +481,48 @@ class ParametricControlBlock(ParametricBlock):
 
         s += rf" \[params: {params_str}]"
         return s if self.tag is None else (s + rf" \[tag: {self.tag}]")
+
+    def dagger(self) -> ParametricControlBlock:
+        blk = deepcopy(self)
+        blocks = tuple(b.dagger() for b in blk.blocks)
+        blk.blocks = blocks
+        blk.parameters = blocks[0].parameters
+        return blk
+
+
+class ProjectorBlock(PrimitiveBlock):
+    """The abstract ProjectorBlock."""
+
+    name = "ProjectorBlock"
+
+    def __init__(
+        self,
+        ket: str,
+        bra: str,
+        qubit_support: int | tuple[int, ...],
+    ) -> None:
+        """
+        Arguments:
+
+            ket (str): The ket given as a bitstring.
+            bra (str): The bra given as a bitstring.
+            qubit_support (int | tuple[int]): The qubit_support of the block.
+        """
+        if isinstance(qubit_support, int):
+            qubit_support = (qubit_support,)
+        if len(bra) != len(ket):
+            raise ValueError(
+                "Bra and ket must be bitstrings of same length in the 'Projector' definition."
+            )
+        elif len(bra) != len(qubit_support):
+            raise ValueError("Bra or ket must be of same length as the 'qubit_support'")
+        for wf in [bra, ket]:
+            if not all(int(item) == 0 or int(item) == 1 for item in wf):
+                raise ValueError(
+                    "All qubits must be either in the '0' or '1' state"
+                    " in the 'ProjectorBlock' definition."
+                )
+
+        self.ket = ket
+        self.bra = bra
+        super().__init__(qubit_support)

qadence/blocks/utils.py

@@ -5,7 +5,7 @@ from enum import Enum
 from itertools import chain as _flatten
 from typing import Generator, List, Type, TypeVar, Union, get_args
 
-from sympy import Basic, Expr
+from sympy import Array, Basic, Expr
 from torch import Tensor
 
 from qadence.blocks import (
@@ -503,3 +503,22 @@ def assert_same_block(b1: AbstractBlock, b2: AbstractBlock) -> None:
         ), f"Blocks {b1} and {b2} have differing numbers of parameters."
         for p1, p2 in zip(b1.parameters.expressions(), b2.parameters.expressions()):
             assert p1 == p2
+
+
+def unique_parameters(block: AbstractBlock) -> list[Parameter]:
+    """Return the unique parameters in the block.
+
+    These parameters are the actual user-facing parameters which
+    can be assigned by the user. Multiple gates can contain the
+    same unique parameter
+
+    Returns:
+        list[Parameter]: List of unique parameters in the circuit
+    """
+    symbols = []
+    for p in parameters(block):
+        if isinstance(p, Array):
+            continue
+        elif not p.is_number and p not in symbols:
+            symbols.append(p)
+    return symbols

qadence/circuit.py

@@ -5,10 +5,10 @@ from itertools import chain as flatten
 from pathlib import Path
 from typing import Iterable
 
-from sympy import Array, Basic
+from sympy import Basic
 
 from qadence.blocks import AbstractBlock, AnalogBlock, CompositeBlock, chain
-from qadence.blocks.utils import parameters, primitive_blocks
+from qadence.blocks.utils import parameters, primitive_blocks, unique_parameters
 from qadence.parameters import Parameter
 from qadence.register import Register
 
@@ -88,13 +88,7 @@ class QuantumCircuit:
         Returns:
             list[Parameter]: List of unique parameters in the circuit
         """
-        symbols = []
-        for p in parameters(self.block):
-            if isinstance(p, Array):
-                continue
-            elif not p.is_number and p not in symbols:
-                symbols.append(p)
-        return symbols
+        return unique_parameters(self.block)
 
     @property
     def num_unique_parameters(self) -> int:

qadence/constructors/__init__.py

@@ -23,6 +23,7 @@ from .hamiltonians import (
 )
 
 from .rydberg_hea import rydberg_hea, rydberg_hea_layer
+from .rydberg_feature_maps import rydberg_feature_map, analog_feature_map, rydberg_tower_feature_map
 
 from .qft import qft
 
@@ -45,4 +46,7 @@ __all__ = [
     "daqc_transform",
     "rydberg_hea",
     "rydberg_hea_layer",
+    "rydberg_feature_map",
+    "analog_feature_map",
+    "rydberg_tower_feature_map",
 ]