qadence 1.7.7__py3-none-any.whl → 1.8.0__py3-none-any.whl

qadence/operations/control_ops.py

@@ -18,6 +18,7 @@ from qadence.blocks.utils import (
     chain,
     kron,
 )
+from qadence.noise import NoiseHandler
 from qadence.parameters import (
     Parameter,
     evaluate,
@@ -35,9 +36,9 @@ class CNOT(ControlBlock):
 
     name = OpName.CNOT
 
-    def __init__(self, control: int, target: int) -> None:
+    def __init__(self, control: int, target: int, noise: NoiseHandler | None = None) -> None:
         self.generator = kron(N(control), X(target) - I(target))
-        super().__init__((control,), X(target))
+        super().__init__((control,), X(target), noise=noise)
 
     @property
     def eigenvalues_generator(self) -> Tensor:
@@ -63,9 +64,11 @@ class CNOT(ControlBlock):
 class MCZ(ControlBlock):
     name = OpName.MCZ
 
-    def __init__(self, control: tuple[int, ...], target: int) -> None:
+    def __init__(
+        self, control: tuple[int, ...], target: int, noise: NoiseHandler | None = None
+    ) -> None:
         self.generator = kron(*[N(qubit) for qubit in control], Z(target) - I(target))
-        super().__init__(control, Z(target))
+        super().__init__(control, Z(target), noise=noise)
 
     @property
     def eigenvalues_generator(self) -> Tensor:
@@ -93,8 +96,8 @@ class CZ(MCZ):
 
     name = OpName.CZ
 
-    def __init__(self, control: int, target: int) -> None:
-        super().__init__((control,), target)
+    def __init__(self, control: int, target: int, noise: NoiseHandler | None = None) -> None:
+        super().__init__((control,), target, noise=noise)
 
 
 class MCRX(ParametricControlBlock):
@@ -105,9 +108,10 @@ class MCRX(ParametricControlBlock):
         control: tuple[int, ...],
         target: int,
         parameter: Parameter | TNumber | sympy.Expr | str,
+        noise: NoiseHandler | None = None,
     ) -> None:
         self.generator = kron(*[N(qubit) for qubit in control], X(target))
-        super().__init__(control, RX(target, parameter))
+        super().__init__(control, RX(target, parameter), noise=noise)
 
     @classmethod
     def num_parameters(cls) -> int:
@@ -136,8 +140,9 @@ class CRX(MCRX):
         control: int,
         target: int,
         parameter: Parameter | TNumber | sympy.Expr | str,
+        noise: NoiseHandler | None = None,
     ):
-        super().__init__((control,), target, parameter)
+        super().__init__((control,), target, parameter, noise=noise)
 
 
 class MCRY(ParametricControlBlock):
@@ -148,9 +153,10 @@ class MCRY(ParametricControlBlock):
         control: tuple[int, ...],
         target: int,
         parameter: Parameter | TNumber | sympy.Expr | str,
+        noise: NoiseHandler | None = None,
     ) -> None:
         self.generator = kron(*[N(qubit) for qubit in control], Y(target))
-        super().__init__(control, RY(target, parameter))
+        super().__init__(control, RY(target, parameter), noise=noise)
 
     @classmethod
     def num_parameters(cls) -> int:
@@ -175,12 +181,9 @@ class CRY(MCRY):
     name = OpName.CRY
 
     def __init__(
-        self,
-        control: int,
-        target: int,
-        parameter: TParameter,
+        self, control: int, target: int, parameter: TParameter, noise: NoiseHandler | None = None
     ):
-        super().__init__((control,), target, parameter)
+        super().__init__((control,), target, parameter, noise=noise)
 
 
 class MCRZ(ParametricControlBlock):
@@ -191,9 +194,10 @@ class MCRZ(ParametricControlBlock):
         control: tuple[int, ...],
         target: int,
         parameter: Parameter | TNumber | sympy.Expr | str,
+        noise: NoiseHandler | None = None,
     ) -> None:
         self.generator = kron(*[N(qubit) for qubit in control], Z(target))
-        super().__init__(control, RZ(target, parameter))
+        super().__init__(control, RZ(target, parameter), noise=noise)
 
     @classmethod
     def num_parameters(cls) -> int:
@@ -222,8 +226,9 @@ class CRZ(MCRZ):
         control: int,
         target: int,
         parameter: Parameter | TNumber | sympy.Expr | str,
+        noise: NoiseHandler | None = None,
     ):
-        super().__init__((control,), target, parameter)
+        super().__init__((control,), target, parameter, noise=noise)
 
 
 class MCPHASE(ParametricControlBlock):
@@ -234,9 +239,10 @@ class MCPHASE(ParametricControlBlock):
         control: tuple[int, ...],
         target: int,
         parameter: Parameter | TNumber | sympy.Expr | str,
+        noise: NoiseHandler | None = None,
     ) -> None:
         self.generator = kron(*[N(qubit) for qubit in control], Z(target) - I(target))
-        super().__init__(control, PHASE(target, parameter))
+        super().__init__(control, PHASE(target, parameter), noise=noise)
 
     @classmethod
     def num_parameters(cls) -> int:
@@ -276,8 +282,9 @@ class CPHASE(MCPHASE):
         control: int,
         target: int,
         parameter: Parameter | TNumber | sympy.Expr | str,
+        noise: NoiseHandler | None = None,
     ):
-        super().__init__((control,), target, parameter)
+        super().__init__((control,), target, parameter, noise=noise)
 
 
 class CSWAP(ControlBlock):
@@ -285,7 +292,13 @@ class CSWAP(ControlBlock):
 
     name = OpName.CSWAP
 
-    def __init__(self, control: int | tuple[int, ...], target1: int, target2: int) -> None:
+    def __init__(
+        self,
+        control: int | tuple[int, ...],
+        target1: int,
+        target2: int,
+        noise: NoiseHandler | None = None,
+    ) -> None:
         if isinstance(control, tuple):
             control = control[0]
 
@@ -303,7 +316,7 @@ class CSWAP(ControlBlock):
             + kron(a00p, a21, a12)
         )
         self.generator = no_effect + swap_effect
-        super().__init__((control,), SWAP(target1, target2))
+        super().__init__((control,), SWAP(target1, target2), noise=noise)
 
     @property
     def eigenvalues_generator(self) -> Tensor:
@@ -321,9 +334,11 @@ class CSWAP(ControlBlock):
 class Toffoli(ControlBlock):
     name = OpName.TOFFOLI
 
-    def __init__(self, control: tuple[int, ...], target: int) -> None:
+    def __init__(
+        self, control: tuple[int, ...], target: int, noise: NoiseHandler | None = None
+    ) -> None:
         self.generator = kron(*[N(qubit) for qubit in control], X(target) - I(target))
-        super().__init__(control, X(target))
+        super().__init__(control, X(target), noise=noise)
 
     @property
     def n_qubits(self) -> int:

qadence/operations/ham_evo.py

@@ -104,6 +104,7 @@ class HamEvo(TimeEvolutionBlock):
             )
         ps = {"parameter": Parameter(parameter), **gen_exprs}
         self.parameters = ParamMap(**ps)
+        self.time_param = parameter
         self.generator = generator
         self.duration = duration
 

qadence/operations/parametric.py

@@ -15,6 +15,7 @@ from qadence.blocks.utils import (
     add,  # noqa
     chain,
 )
+from qadence.noise import NoiseHandler
 from qadence.parameters import (
     Parameter,
     ParamMap,
@@ -32,10 +33,15 @@ class PHASE(ParametricBlock):
 
     name = OpName.PHASE
 
-    def __init__(self, target: int, parameter: Parameter | TNumber | sympy.Expr | str):
+    def __init__(
+        self,
+        target: int,
+        parameter: Parameter | TNumber | sympy.Expr | str,
+        noise: NoiseHandler | None = None,
+    ) -> None:
         self.parameters = ParamMap(parameter=parameter)
         self.generator = I(target) - Z(target)
-        super().__init__((target,))
+        super().__init__((target,), noise=noise)
 
     @classmethod
     def num_parameters(cls) -> int:
@@ -56,13 +62,18 @@ class RX(ParametricBlock):
 
     name = OpName.RX
 
-    def __init__(self, target: int, parameter: Parameter | TParameter | ParamMap):
+    def __init__(
+        self,
+        target: int,
+        parameter: Parameter | TParameter | ParamMap,
+        noise: NoiseHandler | None = None,
+    ) -> None:
         # TODO: should we give them more meaningful names? like 'angle'?
         self.parameters = (
             parameter if isinstance(parameter, ParamMap) else ParamMap(parameter=parameter)
         )
         self.generator = X(target)
-        super().__init__((target,))
+        super().__init__((target,), noise=noise)
 
     @classmethod
     def num_parameters(cls) -> int:
@@ -84,12 +95,17 @@ class RY(ParametricBlock):
 
     name = OpName.RY
 
-    def __init__(self, target: int, parameter: Parameter | TParameter | ParamMap):
+    def __init__(
+        self,
+        target: int,
+        parameter: Parameter | TParameter | ParamMap,
+        noise: NoiseHandler | None = None,
+    ) -> None:
         self.parameters = (
             parameter if isinstance(parameter, ParamMap) else ParamMap(parameter=parameter)
         )
         self.generator = Y(target)
-        super().__init__((target,))
+        super().__init__((target,), noise=noise)
 
     @classmethod
     def num_parameters(cls) -> int:
@@ -111,12 +127,17 @@ class RZ(ParametricBlock):
 
     name = OpName.RZ
 
-    def __init__(self, target: int, parameter: Parameter | TParameter | ParamMap):
+    def __init__(
+        self,
+        target: int,
+        parameter: Parameter | TParameter | ParamMap,
+        noise: NoiseHandler | None = None,
+    ) -> None:
         self.parameters = (
             parameter if isinstance(parameter, ParamMap) else ParamMap(parameter=parameter)
         )
         self.generator = Z(target)
-        super().__init__((target,))
+        super().__init__((target,), noise=noise)
 
     @classmethod
     def num_parameters(cls) -> int:
@@ -147,10 +168,11 @@ class U(ParametricBlock):
         phi: Parameter | TParameter,
         theta: Parameter | TParameter,
         omega: Parameter | TParameter,
-    ):
+        noise: NoiseHandler | None = None,
+    ) -> None:
         self.parameters = ParamMap(phi=phi, theta=theta, omega=omega)
         self.generator = chain(Z(target), Y(target), Z(target))
-        super().__init__((target,))
+        super().__init__((target,), noise=noise)
 
     @classmethod
     def num_parameters(cls) -> int:

qadence/operations/primitive.py

@@ -18,6 +18,7 @@ from qadence.blocks.utils import (
     chain,
     kron,
 )
+from qadence.noise import NoiseHandler
 from qadence.parameters import (
     Parameter,
 )
@@ -31,8 +32,8 @@ class X(PrimitiveBlock):
 
     name = OpName.X
 
-    def __init__(self, target: int):
-        super().__init__((target,))
+    def __init__(self, target: int, noise: NoiseHandler | None = None) -> None:
+        super().__init__((target,), noise=noise)
 
     @property
     def generator(self) -> AbstractBlock:
@@ -52,8 +53,8 @@ class Y(PrimitiveBlock):
 
     name = OpName.Y
 
-    def __init__(self, target: int):
-        super().__init__((target,))
+    def __init__(self, target: int, noise: NoiseHandler | None = None) -> None:
+        super().__init__((target,), noise=noise)
 
     @property
     def generator(self) -> AbstractBlock:
@@ -73,8 +74,8 @@ class Z(PrimitiveBlock):
 
     name = OpName.Z
 
-    def __init__(self, target: int):
-        super().__init__((target,))
+    def __init__(self, target: int, noise: NoiseHandler | None = None) -> None:
+        super().__init__((target,), noise=noise)
 
     @property
     def generator(self) -> AbstractBlock:
@@ -94,8 +95,8 @@ class I(PrimitiveBlock):
 
     name = OpName.I
 
-    def __init__(self, target: int):
-        super().__init__((target,))
+    def __init__(self, target: int, noise: NoiseHandler | None = None) -> None:
+        super().__init__((target,), noise=noise)
 
     def __ixor__(self, other: AbstractBlock | int) -> AbstractBlock:
         if not isinstance(other, AbstractBlock):
@@ -113,7 +114,7 @@ class I(PrimitiveBlock):
 
     @property
     def generator(self) -> AbstractBlock:
-        return I(*self.qubit_support)
+        return I(self.qubit_support[0])
 
     @property
     def eigenvalues_generator(self) -> Tensor:
@@ -137,8 +138,9 @@ class Projector(ProjectorBlock):
         ket: str,
         bra: str,
         qubit_support: int | tuple[int, ...],
-    ):
-        super().__init__(ket=ket, bra=bra, qubit_support=qubit_support)
+        noise: NoiseHandler | None = None,
+    ) -> None:
+        super().__init__(ket=ket, bra=bra, qubit_support=qubit_support, noise=noise)
 
     @property
     def generator(self) -> None:
@@ -154,8 +156,13 @@ class N(Projector):
 
     name = OpName.N
 
-    def __init__(self, target: int, state: str = "1"):
-        super().__init__(ket=state, bra=state, qubit_support=(target,))
+    def __init__(
+        self,
+        target: int,
+        state: str = "1",
+        noise: NoiseHandler | None = None,
+    ) -> None:
+        super().__init__(ket=state, bra=state, qubit_support=(target,), noise=noise)
 
     @property
     def generator(self) -> None:
@@ -175,9 +182,13 @@ class S(PrimitiveBlock):
 
     name = OpName.S
 
-    def __init__(self, target: int):
+    def __init__(
+        self,
+        target: int,
+        noise: NoiseHandler | None = None,
+    ) -> None:
         self.generator = I(target) - Z(target)
-        super().__init__((target,))
+        super().__init__((target,), noise=noise)
 
     @property
     def eigenvalues_generator(self) -> Tensor:
@@ -188,7 +199,7 @@ class S(PrimitiveBlock):
         return tensor([1, 1j], dtype=cdouble)
 
     def dagger(self) -> SDagger:
-        return SDagger(*self.qubit_support)
+        return SDagger(self.qubit_support[0])
 
 
 class SDagger(PrimitiveBlock):
@@ -196,9 +207,13 @@ class SDagger(PrimitiveBlock):
 
     name = OpName.SDAGGER
 
-    def __init__(self, target: int):
+    def __init__(
+        self,
+        target: int,
+        noise: NoiseHandler | None = None,
+    ) -> None:
         self.generator = I(target) - Z(target)
-        super().__init__((target,))
+        super().__init__((target,), noise=noise)
 
     @property
     def eigenvalues_generator(self) -> Tensor:
@@ -209,7 +224,7 @@ class SDagger(PrimitiveBlock):
         return tensor([1, -1j], dtype=cdouble)
 
     def dagger(self) -> S:
-        return S(*self.qubit_support)
+        return S(self.qubit_support[0])
 
 
 class H(PrimitiveBlock):
@@ -217,9 +232,13 @@ class H(PrimitiveBlock):
 
     name = OpName.H
 
-    def __init__(self, target: int):
+    def __init__(
+        self,
+        target: int,
+        noise: NoiseHandler | None = None,
+    ) -> None:
         self.generator = (1 / np.sqrt(2)) * (X(target) + Z(target) - np.sqrt(2) * I(target))
-        super().__init__((target,))
+        super().__init__((target,), noise=noise)
 
     @property
     def eigenvalues_generator(self) -> Tensor:
@@ -275,9 +294,13 @@ class T(PrimitiveBlock):
 
     name = OpName.T
 
-    def __init__(self, target: int):
+    def __init__(
+        self,
+        target: int,
+        noise: NoiseHandler | None = None,
+    ) -> None:
         self.generator = I(target) - Z(target)
-        super().__init__((target,))
+        super().__init__((target,), noise)
 
     @property
     def eigenvalues_generator(self) -> Tensor:
@@ -292,7 +315,7 @@ class T(PrimitiveBlock):
         return 1
 
     def dagger(self) -> TDagger:
-        return TDagger(*self.qubit_support)
+        return TDagger(self.qubit_support[0])
 
 
 class TDagger(PrimitiveBlock):
@@ -301,9 +324,13 @@ class TDagger(PrimitiveBlock):
     # FIXME: this gate is not support by any backend
     name = "T_dagger"
 
-    def __init__(self, target: int):
+    def __init__(
+        self,
+        target: int,
+        noise: NoiseHandler | None = None,
+    ) -> None:
         self.generator = I(target) - Z(target)
-        super().__init__((target,))
+        super().__init__((target,), noise)
 
     @property
     def eigenvalues_generator(self) -> Tensor:
@@ -318,7 +345,7 @@ class TDagger(PrimitiveBlock):
         return 1
 
     def dagger(self) -> T:
-        return T(*self.qubit_support)
+        return T(self.qubit_support[0])
 
 
 class SWAP(PrimitiveBlock):
@@ -326,7 +353,12 @@ class SWAP(PrimitiveBlock):
 
     name = OpName.SWAP
 
-    def __init__(self, control: int, target: int) -> None:
+    def __init__(
+        self,
+        control: int,
+        target: int,
+        noise: NoiseHandler | None = None,
+    ) -> None:
         a11 = 0.5 * (Z(control) - I(control))
         a22 = -0.5 * (Z(target) + I(target))
         a12 = 0.5 * (chain(X(control), Z(control)) + X(control))
@@ -334,7 +366,7 @@ class SWAP(PrimitiveBlock):
         self.generator = (
             kron(-1.0 * a22, a11) + kron(-1.0 * a11, a22) + kron(a12, a21) + kron(a21, a12)
         )
-        super().__init__((control, target))
+        super().__init__((control, target), noise=noise)
 
     @property
     def eigenvalues_generator(self) -> Tensor:

qadence/overlap.py

@@ -102,9 +102,6 @@ def _select_overlap_method(
             return overlap
 
     elif method == OverlapMethod.SWAP_TEST:
-        if backend == BackendName.BRAKET:
-            raise ValueError("SWAP test method is not supported by the Braket backend.")
-
         n_qubits = bra_circuit.n_qubits
 
         # shift qubit support of bra and ket circuit blocks
@@ -128,9 +125,6 @@ def _select_overlap_method(
             return overlap
 
     elif method == OverlapMethod.HADAMARD_TEST:
-        if backend == BackendName.BRAKET:
-            raise ValueError("Hadamard test method is not supported by the Braket backend.")
-
         n_qubits = bra_circuit.n_qubits
 
         # construct controlled bra and ket blocks

qadence/parameters.py

@@ -228,7 +228,7 @@ def sympy_to_numeric(expr: Basic) -> TNumber:
         return float(expr)
 
 
-def evaluate(expr: Expr, values: dict = {}, as_torch: bool = False) -> TNumber | Tensor:
+def evaluate(expr: Expr, values: dict | None = None, as_torch: bool = False) -> TNumber | Tensor:
     """
     Arguments:
 
@@ -260,7 +260,8 @@ def evaluate(expr: Expr, values: dict = {}, as_torch: bool = False) -> TNumber |
     """
     res: Basic
     res_value: TNumber | Tensor
-    query: dict[Parameter, TNumber | Tensor] = {}
+    query: dict[Parameter, TNumber | Tensor] = dict()
+    values = values or dict()
     if isinstance(expr, Array):
         return Tensor(expr.tolist())
     else:

qadence/transpile/__init__.py

@@ -12,6 +12,7 @@ from .circuit import fill_identities
 from .digitalize import digitalize
 from .flatten import flatten
 from .invert import invert_endianness, reassign
+from .noise import set_noise
 from .transpile import blockfn_to_circfn, transpile
 
-__all__ = ["set_trainable", "invert_endianness"]
+__all__ = ["set_trainable", "invert_endianness", "set_noise"]

qadence/transpile/noise.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from qadence.blocks.abstract import AbstractBlock
+from qadence.circuit import QuantumCircuit
+from qadence.noise.protocols import NoiseHandler
+
+from .apply_fn import apply_fn_to_blocks
+
+
+def _set_noise(
+    block: AbstractBlock,
+    noise: NoiseHandler | None,
+    target_class: type[AbstractBlock] | None = None,
+) -> AbstractBlock:
+    """Changes the noise protocol of a given block in place."""
+    if target_class is not None:
+        if isinstance(block, target_class):
+            block._noise = noise  # type: ignore [attr-defined]
+    else:
+        block._noise = noise  # type: ignore [attr-defined]
+
+    return block
+
+
+def set_noise(
+    circuit: QuantumCircuit | AbstractBlock,
+    noise: NoiseHandler | None,
+    target_class: AbstractBlock | None = None,
+) -> QuantumCircuit | AbstractBlock:
+    """
+    Parses a `QuantumCircuit` or `CompositeBlock` to add noise to specific gates.
+
+    Changes the input in place.
+
+    Arguments:
+        circuit: the circuit or block to parse.
+        noise: the NoiseHandler protocol to change to, or `None` to remove the noise.
+        target_class: optional class to selectively add noise to.
+    """
+    is_circuit_input = isinstance(circuit, QuantumCircuit)
+
+    input_block: AbstractBlock = circuit.block if is_circuit_input else circuit  # type: ignore
+
+    output_block = apply_fn_to_blocks(input_block, _set_noise, noise, target_class)
+
+    return circuit

qadence/types.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import importlib
+from dataclasses import dataclass
 from enum import Enum
 from typing import Callable, Iterable, Tuple, Union
 
@@ -8,6 +9,7 @@ import numpy as np
 import sympy
 from matplotlib.figure import Figure
 from numpy.typing import ArrayLike
+from pyqtorch.noise import NoiseType as DigitalNoise
 from pyqtorch.utils import SolverType
 from torch import Tensor, pi
 from torch.nn import Module
@@ -26,6 +28,7 @@ TArray = Union[Iterable, Tensor, np.ndarray]
 TGenerator = Union[Tensor, sympy.Array, sympy.Basic]
 """Union of torch tensors and numpy arrays."""
 
+
 PI = pi
 
 # Modules to be automatically added to the qadence namespace
@@ -51,6 +54,7 @@ __all__ = [
     "SerializationFormat",
     "PI",
     "SolverType",
+    "NoiseProtocol",
 ]  # type: ignore
 
 
@@ -221,8 +225,6 @@ class _BackendName(StrEnum):
 
     PYQTORCH = "pyqtorch"
     """The Pyqtorch backend."""
-    BRAKET = "braket"
-    """The Braket backend."""
     PULSER = "pulser"
     """The Pulser backend."""
     HORQRUX = "horqrux"
@@ -457,3 +459,25 @@ class ExperimentTrackingTool(StrEnum):
 
 
 LoggablePlotFunction = Callable[[Module, int], tuple[str, Figure]]
+
+
+class AnalogNoise(StrEnum):
+    """Type of noise protocol."""
+
+    DEPOLARIZING = "Depolarizing"
+    DEPHASING = "Dephasing"
+
+
+@dataclass
+class NoiseProtocol:
+    """Type of noise protocol."""
+
+    ANALOG = AnalogNoise
+    """Noise applied in analog blocks."""
+    READOUT = "Readout"
+    """Noise applied on outputs of quantum programs."""
+    DIGITAL = DigitalNoise
+    """Noise applied to digital blocks."""
+
+
+NoiseEnum = Union[DigitalNoise, AnalogNoise, str]