qadence 1.7.8__py3-none-any.whl → 1.9.0__py3-none-any.whl

qadence/backends/pyqtorch/convert_ops.py

@@ -1,37 +1,23 @@
 from __future__ import annotations
 
+import re
+from functools import partial, reduce
 from itertools import chain as flatten
-from math import prod
-from typing import Any, Sequence, Tuple
+from typing import Any, Callable, Sequence
 
 import pyqtorch as pyq
 import sympy
 import torch
-from pyqtorch.embed import Embedding
-from pyqtorch.matrices import _dagger
-from pyqtorch.time_dependent.sesolve import sesolve
-from pyqtorch.utils import is_diag
+from pyqtorch.embed import ConcretizedCallable
 from torch import (
     Tensor,
     cdouble,
     complex64,
-    diag_embed,
-    diagonal,
-    exp,
     float64,
-    linalg,
     tensor,
-    transpose,
-)
-from torch import device as torch_device
-from torch import dtype as torch_dtype
-from torch.nn import Module, ParameterDict
-
-from qadence.backends.utils import (
-    finitediff,
-    pyqify,
-    unpyqify,
 )
+from torch.nn import Module
+
 from qadence.blocks import (
     AbstractBlock,
     AddBlock,
@@ -43,11 +29,8 @@ from qadence.blocks import (
     ScaleBlock,
     TimeEvolutionBlock,
 )
-from qadence.blocks.block_to_tensor import (
-    _block_to_tensor_embedded,
-)
 from qadence.blocks.primitive import ProjectorBlock
-from qadence.blocks.utils import parameters
+from qadence.noise import NoiseHandler
 from qadence.operations import (
     U,
     multi_qubit_gateset,
@@ -56,10 +39,28 @@ from qadence.operations import (
     three_qubit_gateset,
     two_qubit_gateset,
 )
-from qadence.types import OpName
+from qadence.types import NoiseProtocol, OpName
 
 from .config import Configuration
 
+SYMPY_TO_PYQ_MAPPING = {
+    sympy.Pow: "pow",
+    sympy.cos: "cos",
+    sympy.Add: "add",
+    sympy.Mul: "mul",
+    sympy.sin: "sin",
+    sympy.log: "log",
+    sympy.tan: "tan",
+    sympy.tanh: "tanh",
+    sympy.Heaviside: "hs",
+    sympy.Abs: "abs",
+    sympy.exp: "exp",
+    sympy.acos: "acos",
+    sympy.asin: "asin",
+    sympy.atan: "atan",
+}
+
+
 # Tdagger is not supported currently
 supported_gates = list(set(OpName.list()) - set([OpName.TDAGGER]))
 """The set of supported gates.
@@ -98,9 +99,99 @@ def extract_parameter(block: ScaleBlock | ParametricBlock, config: Configuration
     return config.get_param_name(block)[0]
 
 
+def replace_underscore_floats(s: str) -> str:
+    """Replace underscores with periods for all floats in given string.
+
+    Needed for correct parsing of string by sympy parser.
+
+    Args:
+        s (str): string expression
+
+    Returns:
+        str: transformed string expression
+    """
+
+    # Regular expression to match floats written with underscores instead of dots
+    float_with_underscore_pattern = r"""
+        (?<!\w)            # Negative lookbehind to ensure not part of a word
+        -?                 # Optional negative sign
+        \d+                # One or more digits (before underscore)
+        _                  # The underscore acting as decimal separator
+        \d+                # One or more digits (after underscore)
+        ([eE][-+]?\d+)?    # Optional exponent part for scientific notation
+        (?!\w)             # Negative lookahead to ensure not part of a word
+    """
+
+    # Function to replace the underscore with a dot
+    def underscore_to_dot(match: re.Match) -> Any:
+        return match.group(0).replace("_", ".")
+
+    # Compile the regular expression
+    pattern = re.compile(float_with_underscore_pattern, re.VERBOSE)
+
+    return pattern.sub(underscore_to_dot, s)
+
+
+def sympy_to_pyq(expr: sympy.Expr) -> ConcretizedCallable | Tensor:
+    """Convert sympy expression to pyqtorch ConcretizedCallable object.
+
+    Args:
+        expr (sympy.Expr): sympy expression
+
+    Returns:
+        ConcretizedCallable: expression encoded as ConcretizedCallable
+    """
+
+    # base case - independent argument
+    if len(expr.args) == 0:
+        try:
+            res = torch.as_tensor(float(expr))
+        except Exception as e:
+            res = str(expr)
+
+            if "/" in res:  # Found a rational
+                res = torch.as_tensor(float(sympy.Rational(res).evalf()))
+        return res
+
+    # Recursively iterate through current function arguments
+    all_results = []
+    for arg in expr.args:
+        res = sympy_to_pyq(arg)
+        all_results.append(res)
+
+    # deal with multi-argument (>2) sympy functions: converting to nested
+    # ConcretizedCallable objects
+    if len(all_results) > 2:
+
+        def fn(x: str | ConcretizedCallable, y: str | ConcretizedCallable) -> Callable:
+            return partial(ConcretizedCallable, call_name=SYMPY_TO_PYQ_MAPPING[expr.func])(  # type: ignore [no-any-return]
+                abstract_args=[x, y]
+            )
+
+        concretized_callable = reduce(fn, all_results)
+    else:
+        concretized_callable = ConcretizedCallable(SYMPY_TO_PYQ_MAPPING[expr.func], all_results)
+    return concretized_callable
+
+
 def convert_block(
-    block: AbstractBlock, n_qubits: int = None, config: Configuration = None
+    block: AbstractBlock,
+    n_qubits: int = None,
+    config: Configuration = None,
 ) -> Sequence[Module | Tensor | str | sympy.Expr]:
+    """Convert block to native Pyqtorch representation.
+
+    Args:
+        block (AbstractBlock): Block to convert.
+        n_qubits (int, optional): Number of qubits. Defaults to None.
+        config (Configuration, optional): Backend configuration instance. Defaults to None.
+
+    Raises:
+        NotImplementedError: For non supported blocks.
+
+    Returns:
+        Sequence[Module | Tensor | str | sympy.Expr]: List of native operations.
+    """
     if isinstance(block, (Tensor, str, sympy.Expr)):  # case for hamevo generators
         if isinstance(block, Tensor):
             block = block.permute(1, 2, 0)  # put batch size in the back
@@ -112,41 +203,73 @@ def convert_block(
     if config is None:
         config = Configuration()
 
+    noise: NoiseHandler | None = None
+    if hasattr(block, "noise") and block.noise:
+        noise = convert_digital_noise(block.noise)
+
     if isinstance(block, ScaleBlock):
         scaled_ops = convert_block(block.block, n_qubits, config)
-        scale = extract_parameter(block, config)
-        return [pyq.Scale(pyq.Sequence(scaled_ops), scale)]
+        scale = extract_parameter(block, config=config)
+
+        # replace underscore by dot when underscore is between two numbers in string
+        if isinstance(scale, str):
+            scale = replace_underscore_floats(scale)
+
+        if isinstance(scale, str) and not config._use_gate_params:
+            param = sympy_to_pyq(sympy.parse_expr(scale))
+        else:
+            param = scale
+
+        return [pyq.Scale(pyq.Sequence(scaled_ops), param)]
 
     elif isinstance(block, TimeEvolutionBlock):
+        duration = block.duration  # type: ignore [attr-defined]
         if getattr(block.generator, "is_time_dependent", False):
-            return [PyQTimeDependentEvolution(qubit_support, n_qubits, block, config)]
-        else:
-            if isinstance(block.generator, sympy.Basic):
-                generator = config.get_param_name(block)[1]
-            elif isinstance(block.generator, Tensor):
-                m = block.generator.to(dtype=cdouble)
-                generator = convert_block(
-                    MatrixBlock(
-                        m,
-                        qubit_support=qubit_support,
-                        check_unitary=False,
-                        check_hermitian=True,
-                    )
-                )[0]
-            else:
-                generator = convert_block(block.generator, n_qubits, config)[0]  # type: ignore[arg-type]
-            time_param = config.get_param_name(block)[0]
-            return [
-                pyq.HamiltonianEvolution(
+            config._use_gate_params = False
+            duration = config.get_param_name(block)[1]
+            generator = convert_block(block.generator, config=config)[0]  # type: ignore [arg-type]
+        elif isinstance(block.generator, sympy.Basic):
+            generator = config.get_param_name(block)[1]
+
+        elif isinstance(block.generator, Tensor):
+            m = block.generator.to(dtype=cdouble)
+            generator = convert_block(
+                MatrixBlock(
+                    m,
                     qubit_support=qubit_support,
-                    generator=generator,
-                    time=time_param,
-                    cache_length=0,
+                    check_unitary=False,
+                    check_hermitian=True,
                 )
+            )[0]
+        else:
+            generator = convert_block(block.generator, n_qubits, config)[0]  # type: ignore[arg-type]
+        time_param = config.get_param_name(block)[0]
+
+        # convert noise operators here
+        noise_operators: list = [
+            convert_block(noise_block, config=config)[0] for noise_block in block.noise_operators
+        ]
+        if len(noise_operators) > 0:
+            # squeeze batch size for noise operators
+            noise_operators = [
+                pyq_op.tensor(full_support=qubit_support).squeeze(-1) for pyq_op in noise_operators
             ]
 
+        return [
+            pyq.HamiltonianEvolution(
+                qubit_support=qubit_support,
+                generator=generator,
+                time=time_param,
+                cache_length=0,
+                duration=duration,
+                solver=config.ode_solver,
+                steps=config.n_steps_hevo,
+                noise_operators=noise_operators,
+            )
+        ]
+
     elif isinstance(block, MatrixBlock):
-        return [pyq.primitives.Primitive(block.matrix, block.qubit_support)]
+        return [pyq.primitives.Primitive(block.matrix, block.qubit_support, noise=noise)]
     elif isinstance(block, CompositeBlock):
         ops = list(flatten(*(convert_block(b, n_qubits, config) for b in block.blocks)))
         if isinstance(block, AddBlock):
@@ -159,38 +282,66 @@ def convert_block(
         if isinstance(block, ProjectorBlock):
             projector = getattr(pyq, block.name)
             if block.name == OpName.N:
-                return [projector(target=qubit_support)]
+                return [projector(target=qubit_support, noise=noise)]
             else:
-                return [projector(qubit_support=qubit_support, ket=block.ket, bra=block.bra)]
+                return [
+                    projector(
+                        qubit_support=qubit_support,
+                        ket=block.ket,
+                        bra=block.bra,
+                        noise=noise,
+                    )
+                ]
         else:
             return [getattr(pyq, block.name)(qubit_support[0])]
     elif isinstance(block, tuple(single_qubit_gateset)):
         pyq_cls = getattr(pyq, block.name)
         if isinstance(block, ParametricBlock):
             if isinstance(block, U):
-                op = pyq_cls(qubit_support[0], *config.get_param_name(block))
+                op = pyq_cls(
+                    qubit_support[0],
+                    *config.get_param_name(block),
+                    noise=noise,
+                )
             else:
-                op = pyq_cls(qubit_support[0], extract_parameter(block, config))
+                param = extract_parameter(block, config)
+                op = pyq_cls(qubit_support[0], param, noise=noise)
         else:
-            op = pyq_cls(qubit_support[0])
+            op = pyq_cls(qubit_support[0], noise=noise)  # type: ignore [attr-defined]
         return [op]
     elif isinstance(block, tuple(two_qubit_gateset)):
         pyq_cls = getattr(pyq, block.name)
         if isinstance(block, ParametricBlock):
-            op = pyq_cls(qubit_support[0], qubit_support[1], extract_parameter(block, config))
+            op = pyq_cls(
+                qubit_support[0],
+                qubit_support[1],
+                extract_parameter(block, config),
+                noise=noise,
+            )
         else:
-            op = pyq_cls(qubit_support[0], qubit_support[1])
+            op = pyq_cls(
+                qubit_support[0], qubit_support[1], noise=noise  # type: ignore [attr-defined]
+            )
         return [op]
     elif isinstance(block, tuple(three_qubit_gateset) + tuple(multi_qubit_gateset)):
         block_name = block.name[1:] if block.name.startswith("M") else block.name
         pyq_cls = getattr(pyq, block_name)
         if isinstance(block, ParametricBlock):
-            op = pyq_cls(qubit_support[:-1], qubit_support[-1], extract_parameter(block, config))
+            op = pyq_cls(
+                qubit_support[:-1],
+                qubit_support[-1],
+                extract_parameter(block, config),
+                noise=noise,
+            )
         else:
             if "CSWAP" in block_name:
-                op = pyq_cls(qubit_support[:-2], qubit_support[-2:])
+                op = pyq_cls(
+                    qubit_support[:-2], qubit_support[-2:], noise=noise  # type: ignore [attr-defined]
+                )
             else:
-                op = pyq_cls(qubit_support[:-1], qubit_support[-1])
+                op = pyq_cls(
+                    qubit_support[:-1], qubit_support[-1], noise=noise  # type: ignore [attr-defined]
+                )
         return [op]
     else:
         raise NotImplementedError(
@@ -200,182 +351,43 @@ def convert_block(
         )
 
 
-class PyQTimeDependentEvolution(Module):
-    def __init__(
-        self,
-        qubit_support: Tuple[int, ...],
-        n_qubits: int,
-        block: TimeEvolutionBlock,
-        config: Configuration,
-    ):
-        super().__init__()
-        self.qubit_support = qubit_support
-        self.n_qubits = n_qubits
-        self.param_names = config.get_param_name(block)
-        self.block = block
-        self.hmat: Tensor
-        self.config = config
-
-        def _hamiltonian(self: PyQTimeDependentEvolution, values: dict[str, Tensor]) -> Tensor:
-            hmat = _block_to_tensor_embedded(
-                block.generator,  # type: ignore[arg-type]
-                values=values,
-                qubit_support=self.qubit_support,
-                use_full_support=False,
-                device=self.device,
-            )
-            return hmat.permute(1, 2, 0)
-
-        self._hamiltonian = _hamiltonian
-
-        self._time_evolution = lambda values: values[self.param_names[0]]
-        self._device: torch_device = (
-            self.hmat.device if hasattr(self, "hmat") else torch_device("cpu")
-        )
-        self._dtype: torch_dtype = self.hmat.dtype if hasattr(self, "hmat") else cdouble
+def convert_digital_noise(noise: NoiseHandler) -> pyq.noise.NoiseProtocol | None:
+    """Convert the digital noise into pyqtorch NoiseProtocol.
 
-    def _unitary(self, hamiltonian: Tensor, time_evolution: Tensor) -> Tensor:
-        self.batch_size = max(hamiltonian.size()[2], len(time_evolution))
-        diag_check = tensor(
-            [is_diag(hamiltonian[..., i]) for i in range(hamiltonian.size()[2])], device=self.device
-        )
-
-        def _evolve_diag_operator(hamiltonian: Tensor, time_evolution: Tensor) -> Tensor:
-            evol_operator = diagonal(hamiltonian) * (-1j * time_evolution).view((-1, 1))
-            evol_operator = diag_embed(exp(evol_operator))
-            return transpose(evol_operator, 0, -1)
-
-        def _evolve_matrixexp_operator(hamiltonian: Tensor, time_evolution: Tensor) -> Tensor:
-            evol_operator = transpose(hamiltonian, 0, -1) * (-1j * time_evolution).view((-1, 1, 1))
-            evol_operator = linalg.matrix_exp(evol_operator)
-            return transpose(evol_operator, 0, -1)
-
-        evolve_operator = (
-            _evolve_diag_operator if bool(prod(diag_check)) else _evolve_matrixexp_operator
-        )
-        return evolve_operator(hamiltonian, time_evolution)
-
-    def unitary(self, values: dict[str, Tensor]) -> Tensor:
-        """The evolved operator given current parameter values for generator and time evolution."""
-        return self._unitary(self._hamiltonian(self, values), self._time_evolution(values))
-
-    def jacobian_time(self, values: dict[str, Tensor]) -> Tensor:
-        """Approximate jacobian of the evolved operator with respect to time evolution."""
-        return finitediff(
-            lambda t: self._unitary(time_evolution=t, hamiltonian=self._hamiltonian(self, values)),
-            values[self.param_names[0]].reshape(-1, 1),
-            (0,),
-        )
-
-    def jacobian_generator(self, values: dict[str, Tensor]) -> Tensor:
-        """Approximate jacobian of the evolved operator with respect to generator parameter(s)."""
-        if len(self.param_names) > 2:
-            raise NotImplementedError(
-                "jacobian_generator does not support generators\
-                                        with more than 1 parameter."
-            )
+    Args:
+        noise (NoiseHandler): Noise to convert.
 
-        def _generator(val: Tensor) -> Tensor:
-            val_copy = values.copy()
-            val_copy[self.param_names[1]] = val
-            hmat = _block_to_tensor_embedded(
-                self.block.generator,  # type: ignore[arg-type]
-                values=val_copy,
-                qubit_support=self.qubit_support,
-                use_full_support=False,
-                device=self.device,
-            )
-            return hmat.permute(1, 2, 0)
-
-        return finitediff(
-            lambda v: self._unitary(
-                time_evolution=self._time_evolution(values), hamiltonian=_generator(v)
-            ),
-            values[self.param_names[1]].reshape(-1, 1),
-            (0,),
-        )
+    Returns:
+        pyq.noise.NoiseProtocol | None: Pyqtorch native noise protocol
+            if there are any digital noise protocols.
+    """
+    digital_part = noise.filter(NoiseProtocol.DIGITAL)
+    if digital_part is None:
+        return None
+    return pyq.noise.NoiseProtocol(
+        [
+            pyq.noise.NoiseProtocol(proto, option.get("error_probability"))
+            for proto, option in zip(digital_part.protocol, digital_part.options)
+        ]
+    )
 
-    def dagger(self, values: dict[str, Tensor]) -> Tensor:
-        """Dagger of the evolved operator given the current parameter values."""
-        return _dagger(self.unitary(values))
-
-    def _get_time_parameter(self) -> str:
-        # get unique time parameters
-        unique_time_params = set()
-        for p in parameters(self.block.generator):  # type: ignore [arg-type]
-            if getattr(p, "is_time", False):
-                unique_time_params.add(str(p))
-
-        if len(unique_time_params) > 1:
-            raise Exception("Only a single time parameter is supported.")
-
-        return unique_time_params.pop()
-
-    def forward(
-        self,
-        state: Tensor,
-        values: dict[str, Tensor] | ParameterDict = dict(),
-        embedding: Embedding | None = None,
-    ) -> Tensor:
-        def Ht(t: Tensor | float) -> Tensor:
-            # values dict has to change with new value of t
-            # initial value of a feature parameter inside generator block
-            # has to be inferred here
-            new_vals = dict()
-            for str_expr, val in values.items():
-                expr = sympy.sympify(str_expr)
-                t_symb = sympy.Symbol(self._get_time_parameter())
-                free_symbols = expr.free_symbols
-                if t_symb in free_symbols:
-                    # create substitution list for time and feature params
-                    subs_list = [(t_symb, t)]
-
-                    if len(free_symbols) > 1:
-                        # get feature param symbols
-                        feat_symbols = free_symbols.difference(set([t_symb]))
-
-                        # get feature param values
-                        feat_vals = values["orig_param_values"]
-
-                        # update substitution list with feature param values
-                        for fs in feat_symbols:
-                            subs_list.append((fs, feat_vals[str(fs)]))
-
-                    # evaluate expression with new time param value
-                    new_vals[str_expr] = torch.tensor(float(expr.subs(subs_list)))
-                else:
-                    # expression doesn't contain time parameter - copy it as is
-                    new_vals[str_expr] = val
-
-            # get matrix form of generator
-            hmat = _block_to_tensor_embedded(
-                self.block.generator,  # type: ignore[arg-type]
-                values=new_vals,
-                qubit_support=self.qubit_support,
-                use_full_support=False,
-                device=self.device,
-            ).squeeze(0)
-
-            return hmat
-
-        tsave = torch.linspace(0, self.block.duration, self.config.n_steps_hevo)  # type: ignore [attr-defined]
-        result = pyqify(
-            sesolve(Ht, unpyqify(state).T[:, 0:1], tsave, self.config.ode_solver).states[-1].T
-        )
 
-        return result
+def convert_readout_noise(n_qubits: int, noise: NoiseHandler) -> pyq.noise.ReadoutNoise | None:
+    """Convert the readout noise into pyqtorch ReadoutNoise.
 
-    @property
-    def device(self) -> torch_device:
-        return self._device
+    Args:
+        n_qubits (int): Number of qubits
+        noise (NoiseHandler):  Noise to convert.
 
-    @property
-    def dtype(self) -> torch_dtype:
-        return self._dtype
+    Returns:
+        pyq.noise.ReadoutNoise | None: Pyqtorch native ReadoutNoise instance
+            if readout is is noise.
+    """
+    readout_part = noise.filter(NoiseProtocol.READOUT)
+    if readout_part is None:
+        return None
 
-    def to(self, *args: Any, **kwargs: Any) -> PyQTimeDependentEvolution:
-        if hasattr(self, "hmat"):
-            self.hmat = self.hmat.to(*args, **kwargs)
-            self._device = self.hmat.device
-            self._dtype = self.hmat.dtype
-        return self
+    if readout_part.protocol[0] == NoiseProtocol.READOUT.INDEPENDENT:
+        return pyq.noise.ReadoutNoise(n_qubits, **readout_part.options[0])
+    else:
+        return pyq.noise.CorrelatedReadoutNoise(**readout_part.options[0])

qadence/backends/utils.py

@@ -10,6 +10,7 @@ import torch
 from numpy.typing import ArrayLike
 from pyqtorch.apply import apply_operator
 from pyqtorch.primitives import Parametric as PyQParametric
+from pyqtorch.utils import DensityMatrix
 from torch import (
     Tensor,
     cat,
@@ -121,7 +122,14 @@ def pyqify(state: Tensor, n_qubits: int = None) -> ArrayLike:
 
 
 def unpyqify(state: Tensor) -> Tensor:
-    """Convert a state of shape [2] * n_qubits + [batch_size] to (batch_size, 2**n_qubits)."""
+    """
+    Convert a state of shape [2] * n_qubits + [batch_size] to (batch_size, 2**n_qubits).
+
+    Convert a density matrix of shape (2**n_qubits, 2**n_qubits, batch_size)
+    to (batch_size, 2**n_qubits, 2**n_qubits)
+    """
+    if isinstance(state, DensityMatrix):
+        return torch.einsum("ijk->kij", state)
     return torch.flatten(state, start_dim=0, end_dim=-2).t()
 
 

qadence/blocks/abstract.py

@@ -263,7 +263,7 @@ class AbstractBlock(ABC):
 
     @classmethod
     def _from_json(cls, path: str | Path) -> AbstractBlock:
-        d: dict = {}
+        d: dict = dict()
         if isinstance(path, str):
             path = Path(path)
         try:

qadence/blocks/embedding.py

@@ -5,7 +5,7 @@ from typing import Callable, Iterable, List
 import sympy
 from numpy import array as nparray
 from numpy import cdouble as npcdouble
-from torch import tensor
+from torch import as_tensor, tensor
 
 from qadence.blocks import (
     AbstractBlock,
@@ -111,11 +111,13 @@ def embedding(
             angle: ArrayLike
             values = {}
             for symbol in expr.free_symbols:
-                if not symbol.is_time:
-                    if symbol.name in inputs:
-                        value = inputs[symbol.name]
-                    elif symbol.name in params:
-                        value = params[symbol.name]
+                if symbol.name in inputs:
+                    value = inputs[symbol.name]
+                elif symbol.name in params:
+                    value = params[symbol.name]
+                else:
+                    if symbol.is_time:
+                        value = tensor(1.0)
                     else:
                         msg_trainable = "Trainable" if symbol.trainable else "Non-trainable"
                         raise KeyError(
@@ -123,9 +125,7 @@ def embedding(
                             f"inputs list: {list(inputs.keys())} nor the "
                             f"params list: {list(params.keys())}."
                         )
-                    values[symbol.name] = value
-                else:
-                    values[symbol.name] = tensor(1.0)
+                values[symbol.name] = value
             angle = fn(**values)
             # do not reshape parameters which are multi-dimensional
             # tensors, such as for example generator matrices
@@ -142,8 +142,18 @@ def embedding(
                 gate_lvl_params[uuid] = embedded_params[e]
             return gate_lvl_params
         else:
-            out = {stringify(k): v for k, v in embedded_params.items()}
-            out.update({"orig_param_values": inputs})
+            embedded_params.update(inputs)
+            for k, v in params.items():
+                if k not in embedded_params:
+                    embedded_params[k] = v
+            out = {
+                stringify(k)
+                if not isinstance(k, str)
+                else k: as_tensor(v)[None]
+                if as_tensor(v).ndim == 0
+                else v
+                for k, v in embedded_params.items()
+            }
             return out
 
     params: ParamDictType