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

qadence/blocks/primitive.py

@@ -11,6 +11,7 @@ from rich.panel import Panel
 from rich.tree import Tree
 
 from qadence.blocks.abstract import AbstractBlock
+from qadence.noise import NoiseHandler
 from qadence.parameters import (
     Parameter,
     ParamMap,
@@ -33,13 +34,22 @@ class PrimitiveBlock(AbstractBlock):
 
     name = "PrimitiveBlock"
 
-    def __init__(self, qubit_support: tuple[int, ...]):
+    def __init__(
+        self,
+        qubit_support: tuple[int, ...],
+        noise: NoiseHandler | None = None,
+    ):
         self._qubit_support = qubit_support
+        self._noise = noise
 
     @property
     def qubit_support(self) -> Tuple[int, ...]:
         return self._qubit_support
 
+    @property
+    def noise(self) -> NoiseHandler | None:
+        return self._noise
+
     def digital_decomposition(self) -> AbstractBlock:
         """Decomposition into purely digital gates.
 
@@ -85,11 +95,12 @@ class PrimitiveBlock(AbstractBlock):
             "type": type(self).__name__,
             "qubit_support": self.qubit_support,
             "tag": self.tag,
+            "noise": self.noise._to_dict() if self.noise is not None else None,
         }
 
     @classmethod
     def _from_dict(cls, d: dict) -> PrimitiveBlock:
-        return cls(*d["qubit_support"])
+        return cls(*d["qubit_support"], NoiseHandler._from_dict(d.get("noise")))  # type: ignore[call-arg]
 
     def __hash__(self) -> int:
         return hash(self._to_json())
@@ -196,18 +207,19 @@ class ParametricBlock(PrimitiveBlock):
             "qubit_support": self.qubit_support,
             "tag": self.tag,
             "parameters": self.parameters._to_dict(),
+            "noise": self.noise._to_dict() if self.noise is not None else None,
         }
 
     @classmethod
     def _from_dict(cls, d: dict) -> ParametricBlock:
         params = ParamMap._from_dict(d["parameters"])
         target = d["qubit_support"][0]
-        return cls(target, params)  # type: ignore[call-arg]
+        return cls(target, params, NoiseHandler._from_dict(d.get("noise")))  # type: ignore[call-arg, arg-type]
 
     def dagger(self) -> ParametricBlock:
         exprs = self.parameters.expressions()
         params = tuple(-extract_original_param_entry(param) for param in exprs)
-        return type(self)(*self.qubit_support, *params)  # type: ignore[arg-type]
+        return type(self)(*self.qubit_support, *params, self.noise)  # type: ignore[call-arg, arg-type]
 
 
 class ScaleBlock(ParametricBlock):
@@ -357,14 +369,19 @@ class ControlBlock(PrimitiveBlock):
     control: tuple[int, ...]
     target: tuple[int, ...]
 
-    def __init__(self, control: tuple[int, ...], target_block: PrimitiveBlock) -> None:
+    def __init__(
+        self,
+        control: tuple[int, ...],
+        target_block: PrimitiveBlock,
+        noise: NoiseHandler | None = None,
+    ) -> 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, *self.target))  # target_block.qubit_support[0]))
+        super().__init__((*control, *self.target), noise=noise)  # target_block.qubit_support[0]))
 
     @property
     def n_controls(self) -> int:
@@ -395,13 +412,14 @@ class ControlBlock(PrimitiveBlock):
             "qubit_support": self.qubit_support,
             "tag": self.tag,
             "blocks": [b._to_dict() for b in self.blocks],
+            "noise": self.noise._to_dict() if self.noise is not None else None,
         }
 
     @classmethod
     def _from_dict(cls, d: dict) -> ControlBlock:
         control = d["qubit_support"][0]
         target = d["qubit_support"][1]
-        return cls(control, target)
+        return cls(control, target, NoiseHandler._from_dict(d.get("noise")))
 
     def dagger(self) -> ControlBlock:
         blk = deepcopy(self)
@@ -416,11 +434,16 @@ class ParametricControlBlock(ParametricBlock):
     control: tuple[int, ...] = ()
     blocks: tuple[ParametricBlock, ...]
 
-    def __init__(self, control: tuple[int, ...], target_block: ParametricBlock) -> None:
+    def __init__(
+        self,
+        control: tuple[int, ...],
+        target_block: ParametricBlock,
+        noise: NoiseHandler | None = None,
+    ) -> None:
         self.blocks = (target_block,)
         self.control = control
         self.parameters = target_block.parameters
-        super().__init__((*control, *target_block.qubit_support))
+        super().__init__((*control, *target_block.qubit_support), noise=noise)
 
     @property
     def n_controls(self) -> int:
@@ -450,6 +473,7 @@ class ParametricControlBlock(ParametricBlock):
             "qubit_support": self.qubit_support,
             "tag": self.tag,
             "blocks": [b._to_dict() for b in self.blocks],
+            "noise": self.noise._to_dict() if self.noise is not None else None,
         }
 
     @classmethod
@@ -460,7 +484,7 @@ class ParametricControlBlock(ParametricBlock):
         target = d["qubit_support"][1]
         targetblock = d["blocks"][0]
         expr = deserialize(targetblock["parameters"])
-        block = cls(control, target, expr)  # type: ignore[call-arg]
+        block = cls(control, target, NoiseHandler._from_dict(d.get("noise")), expr)  # type: ignore[call-arg]
         return block
 
     @property
@@ -497,6 +521,7 @@ class ProjectorBlock(PrimitiveBlock):
         ket: str,
         bra: str,
         qubit_support: int | tuple[int, ...],
+        noise: NoiseHandler | None = None,
     ) -> None:
         """
         Arguments:
@@ -522,4 +547,4 @@ class ProjectorBlock(PrimitiveBlock):
 
         self.ket = ket
         self.bra = bra
-        super().__init__(qubit_support)
+        super().__init__(qubit_support, noise=noise)

qadence/circuit.py

@@ -194,7 +194,7 @@ class QuantumCircuit:
     def _from_json(cls, path: str | Path) -> QuantumCircuit:
         import json
 
-        loaded_dict: dict = {}
+        loaded_dict: dict = dict()
         if isinstance(path, str):
             path = Path(path)
         try:

qadence/constructors/__init__.py

@@ -5,7 +5,7 @@ from .feature_maps import (
     exp_fourier_feature_map,
 )
 
-from .ansatze import hea
+from .ansatze import hea, alt
 
 from .iia import identity_initialized_ansatz
 
@@ -29,6 +29,7 @@ __all__ = [
     "feature_map",
     "exp_fourier_feature_map",
     "hea",
+    "alt",
     "identity_initialized_ansatz",
     "hamiltonian_factory",
     "ising_hamiltonian",

qadence/constructors/ansatze.py

@@ -320,3 +320,179 @@ def hea_bDAQC(*args: Any, **kwargs: Any) -> Any:
 
 def hea_analog(*args: Any, **kwargs: Any) -> Any:
     raise NotImplementedError
+
+
+def alt(
+    n_qubits: int,
+    m_block_qubits: int,
+    depth: int = 1,
+    param_prefix: str = "theta",
+    support: tuple[int, ...] = None,
+    strategy: Strategy = Strategy.DIGITAL,
+    **strategy_args: Any,
+) -> AbstractBlock:
+    """
+    Factory function for the alternating layer ansatz (alt).
+
+    Args:
+        n_qubits: number of qubits in the block
+        m_block_qubits: number of qubits in the local entangling block
+        depth: number of layers of the alt
+        param_prefix: the base name of the variational parameters
+        support: qubit indexes where the alt is applied
+        strategy: Strategy.Digital or Strategy.DigitalAnalog
+        **strategy_args: see below
+
+    Keyword Arguments:
+        operations (list): list of operations to cycle through in the
+            digital single-qubit rotations of each layer. Valid for
+            Digital .
+        entangler (AbstractBlock):
+            - Digital: 2-qubit entangling operation. Supports CNOT, CZ,
+            CRX, CRY, CRZ, CPHASE. Controlled rotations will have variational
+            parameters on the rotation angles.
+    """
+
+    if support is None:
+        support = tuple(range(n_qubits))
+
+    alt_func_dict = {
+        Strategy.DIGITAL: alt_digital,
+        Strategy.SDAQC: alt_sDAQC,
+        Strategy.BDAQC: alt_bDAQC,
+        Strategy.ANALOG: alt_analog,
+    }
+
+    try:
+        alt_func = alt_func_dict[strategy]
+    except KeyError:
+        raise KeyError(f"Strategy {strategy} not recognized.")
+
+    hea_block: AbstractBlock = alt_func(
+        n_qubits=n_qubits,
+        m_block_qubits=m_block_qubits,
+        depth=depth,
+        param_prefix=param_prefix,
+        support=support,
+        **strategy_args,
+    )  # type: ignore
+
+    return hea_block
+
+
+#################
+## DIGITAL ALT ##
+#################
+
+
+def _entanglers_block_digital(
+    n_qubits: int,
+    m_block_qubits: int,
+    depth: int,
+    param_prefix: str = "theta",
+    support: tuple[int, ...] = None,
+    entangler: Type[DigitalEntanglers] = CNOT,
+) -> list[AbstractBlock]:
+    if support is None:
+        support = tuple(range(n_qubits))
+    iterator = itertools.count()
+    ent_list: list[AbstractBlock] = []
+
+    for d in range(depth):
+        start_i = 0 if not d % 2 else -m_block_qubits // 2
+        ents = [
+            kron(
+                _entangler(
+                    control=support[i + j],
+                    target=support[i + j + 1],
+                    param_str=param_prefix + f"_ent_{next(iterator)}",
+                    op=entangler,
+                )
+                for j in range(start_j, m_block_qubits, 2)
+                for i in range(start_i, n_qubits, m_block_qubits)
+                if i + j + 1 < n_qubits and j + 1 < m_block_qubits and i + j >= 0
+            )
+            for start_j in [i for i in range(2) if m_block_qubits > 2 or i == 0]
+        ]
+
+        ent_list.append(chain(*ents))
+    return ent_list
+
+
+def alt_digital(
+    n_qubits: int,
+    m_block_qubits: int,
+    depth: int = 1,
+    support: tuple[int, ...] = None,
+    param_prefix: str = "theta",
+    operations: list[type[AbstractBlock]] = [RX, RY],
+    entangler: Type[DigitalEntanglers] = CNOT,
+) -> AbstractBlock:
+    """
+    Construct the digital alternating layer ansatz (ALT).
+
+    Args:
+        n_qubits (int): number of qubits in the ansatz.
+        m_block_qubits (int): number of qubits in the local entangling block.
+        depth (int): number of layers of the ALT.
+        param_prefix (str): the base name of the variational parameters
+        operations (list): list of operations to cycle through in the
+            digital single-qubit rotations of each layer.
+        support (tuple): qubit indexes where the ALT is applied.
+        entangler (AbstractBlock): 2-qubit entangling operation.
+            Supports CNOT, CZ, CRX, CRY, CRZ. Controlld rotations
+            will have variational parameters on the rotation angles.
+    """
+
+    try:
+        if entangler not in [CNOT, CZ, CRX, CRY, CRZ, CPHASE]:
+            raise ValueError(
+                "Please provide a valid two-qubit entangler operation for digital ALT."
+            )
+    except TypeError:
+        raise ValueError("Please provide a valid two-qubit entangler operation for digital ALT.")
+
+    rot_list = _rotations_digital(
+        n_qubits=n_qubits,
+        depth=depth,
+        support=support,
+        param_prefix=param_prefix,
+        operations=operations,
+    )
+
+    ent_list = _entanglers_block_digital(
+        n_qubits,
+        m_block_qubits,
+        param_prefix=param_prefix + "_ent",
+        depth=depth,
+        support=support,
+        entangler=entangler,
+    )
+
+    layers = []
+    for d in range(depth):
+        layers.append(rot_list[d])
+        layers.append(ent_list[d])
+
+    return tag(chain(*layers), "ALT")
+
+
+#################
+## sdaqc ALT ##
+#################
+def alt_sDAQC(*args: Any, **kwargs: Any) -> Any:
+    raise NotImplementedError
+
+
+#################
+## bdaqc ALT ##
+#################
+def alt_bDAQC(*args: Any, **kwargs: Any) -> Any:
+    raise NotImplementedError
+
+
+#################
+## analog ALT ##
+#################
+def alt_analog(*args: Any, **kwargs: Any) -> Any:
+    raise NotImplementedError

qadence/engines/differentiable_backend.py

@@ -11,7 +11,7 @@ from qadence.blocks.utils import uuid_to_block
 from qadence.circuit import QuantumCircuit
 from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
-from qadence.noise import Noise
+from qadence.noise import NoiseHandler
 from qadence.types import ArrayLike, DiffMode, Endianness, Engine, ParamDictType
 
 
@@ -40,7 +40,7 @@ class DifferentiableBackend(ABC):
         param_values: ParamDictType = {},
         n_shots: int = 100,
         state: ArrayLike | None = None,
-        noise: Noise | None = None,
+        noise: NoiseHandler | None = None,
         mitigation: Mitigations | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> list[Counter]:
@@ -89,7 +89,7 @@ class DifferentiableBackend(ABC):
         param_values: ParamDictType = {},
         state: ArrayLike | None = None,
         measurement: Measurements | None = None,
-        noise: Noise | None = None,
+        noise: NoiseHandler | None = None,
         mitigation: Mitigations | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> Any:

qadence/engines/jax/differentiable_backend.py

@@ -7,7 +7,7 @@ from qadence.engines.differentiable_backend import (
 from qadence.engines.jax.differentiable_expectation import DifferentiableExpectation
 from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
-from qadence.noise import Noise
+from qadence.noise import NoiseHandler
 from qadence.types import ArrayLike, DiffMode, Endianness, Engine, ParamDictType
 
 
@@ -36,7 +36,7 @@ class DifferentiableBackend(DifferentiableBackendInterface):
         param_values: ParamDictType = {},
         state: ArrayLike | None = None,
         measurement: Measurements | None = None,
-        noise: Noise | None = None,
+        noise: NoiseHandler | None = None,
         mitigation: Mitigations | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> ArrayLike:

qadence/engines/jax/differentiable_expectation.py

@@ -14,7 +14,7 @@ from qadence.backends.jax_utils import (
 from qadence.blocks.utils import uuid_to_eigen
 from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
-from qadence.noise import Noise
+from qadence.noise import NoiseHandler
 from qadence.types import Endianness, Engine, ParamDictType
 
 
@@ -34,7 +34,7 @@ class DifferentiableExpectation:
     param_values: ParamDictType
     state: Array | None = None
     measurement: Measurements | None = None
-    noise: Noise | None = None
+    noise: NoiseHandler | None = None
     mitigation: Mitigations | None = None
     endianness: Endianness = Endianness.BIG
     engine: Engine = Engine.JAX

qadence/engines/torch/differentiable_backend.py

@@ -11,7 +11,7 @@ from qadence.engines.torch.differentiable_expectation import DifferentiableExpec
 from qadence.extensions import get_gpsr_fns
 from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
-from qadence.noise import Noise
+from qadence.noise import NoiseHandler
 from qadence.types import ArrayLike, DiffMode, Endianness, Engine, ParamDictType
 
 
@@ -40,7 +40,7 @@ class DifferentiableBackend(DifferentiableBackendInterface):
         param_values: ParamDictType = {},
         state: ArrayLike | None = None,
         measurement: Measurements | None = None,
-        noise: Noise | None = None,
+        noise: NoiseHandler | None = None,
         mitigation: Mitigations | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> ArrayLike:

qadence/engines/torch/differentiable_expectation.py

@@ -19,7 +19,7 @@ from qadence.circuit import QuantumCircuit
 from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
 from qadence.ml_tools import promote_to_tensor
-from qadence.noise import Noise
+from qadence.noise import NoiseHandler
 from qadence.types import Endianness
 
 
@@ -95,7 +95,7 @@ class DifferentiableExpectation:
     param_values: dict[str, Tensor]
     state: Tensor | None = None
     measurement: Measurements | None = None
-    noise: Noise | None = None
+    noise: NoiseHandler | None = None
     mitigation: Mitigations | None = None
     endianness: Endianness = Endianness.BIG
 

qadence/execution.py

@@ -12,7 +12,7 @@ from qadence.blocks import AbstractBlock
 from qadence.circuit import QuantumCircuit
 from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
-from qadence.noise import Noise
+from qadence.noise import NoiseHandler
 from qadence.qubit_support import QubitSupport
 from qadence.register import Register
 from qadence.types import BackendName, DiffMode, Endianness
@@ -35,7 +35,7 @@ def _n_qubits_block(block: AbstractBlock) -> int:
 def run(
     x: Union[QuantumCircuit, AbstractBlock, Register, int],
     *args: Any,
-    values: dict = {},
+    values: Union[dict, None] = None,
     state: Tensor = None,
     backend: BackendName = BackendName.PYQTORCH,
     endianness: Endianness = Endianness.BIG,
@@ -65,7 +65,7 @@ def run(
 @run.register
 def _(
     circuit: QuantumCircuit,
-    values: dict = {},
+    values: Union[dict, None] = None,
     state: Tensor = None,
     backend: BackendName = BackendName.PYQTORCH,
     endianness: Endianness = Endianness.BIG,
@@ -79,7 +79,7 @@ def _(
     with no_grad():
         return bknd.run(
             circuit=conv.circuit,
-            param_values=conv.embedding_fn(conv.params, values),
+            param_values=conv.embedding_fn(conv.params, values or dict()),
             state=state,
             endianness=endianness,
         )
@@ -113,12 +113,12 @@ def _(circs: list, **kwargs: Any) -> Tensor:  # type: ignore[misc]
 def sample(
     x: Union[QuantumCircuit, AbstractBlock, Register, int],
     *args: Any,
-    values: dict = {},
+    values: Union[dict, None] = None,
     state: Union[Tensor, None] = None,
     n_shots: int = 100,
     backend: BackendName = BackendName.PYQTORCH,
     endianness: Endianness = Endianness.BIG,
-    noise: Union[Noise, None] = None,
+    noise: Union[NoiseHandler, None] = None,
     configuration: Union[BackendConfiguration, dict, None] = None,
 ) -> list[Counter]:
     """Convenience wrapper for the `QuantumModel.sample` method.
@@ -142,11 +142,11 @@ def sample(
 @sample.register
 def _(
     circuit: QuantumCircuit,
-    values: dict = {},
+    values: Union[dict, None] = None,
     state: Union[Tensor, None] = None,
     n_shots: int = 100,
     backend: BackendName = BackendName.PYQTORCH,
-    noise: Union[Noise, None] = None,
+    noise: Union[NoiseHandler, None] = None,
     endianness: Endianness = Endianness.BIG,
     configuration: Union[BackendConfiguration, dict, None] = None,
 ) -> list[Counter]:
@@ -157,7 +157,7 @@ def _(
     conv = bknd.convert(circuit)
     return bknd.sample(
         circuit=conv.circuit,
-        param_values=conv.embedding_fn(conv.params, values),
+        param_values=conv.embedding_fn(conv.params, values or dict()),
         n_shots=n_shots,
         state=state,
         noise=noise,
@@ -185,11 +185,11 @@ def _(block: AbstractBlock, **kwargs: Any) -> Tensor:
 def expectation(
     x: Union[QuantumCircuit, AbstractBlock, Register, int],
     observable: Union[list[AbstractBlock], AbstractBlock],
-    values: dict = {},
+    values: Union[dict, None] = None,
     state: Tensor = None,
     backend: BackendName = BackendName.PYQTORCH,
     diff_mode: Union[DiffMode, str, None] = None,
-    noise: Union[Noise, None] = None,
+    noise: Union[NoiseHandler, None] = None,
     endianness: Endianness = Endianness.BIG,
     configuration: Union[BackendConfiguration, dict, None] = None,
 ) -> Tensor:
@@ -237,12 +237,12 @@ def expectation(
 def _(
     circuit: QuantumCircuit,
     observable: Union[list[AbstractBlock], AbstractBlock],
-    values: dict = {},
+    values: Union[dict, None] = None,
     state: Tensor = None,
     backend: BackendName = BackendName.PYQTORCH,
     diff_mode: Union[DiffMode, str, None] = None,
     measurement: Measurements = None,
-    noise: Union[Noise, None] = None,
+    noise: Union[NoiseHandler, None] = None,
     mitigation: Mitigations = None,
     endianness: Endianness = Endianness.BIG,
     configuration: Union[BackendConfiguration, dict, None] = None,
@@ -257,7 +257,7 @@ def _(
         return bknd.expectation(
             circuit=conv.circuit,
             observable=conv.observable,  # type: ignore[arg-type]
-            param_values=conv.embedding_fn(conv.params, values),
+            param_values=conv.embedding_fn(conv.params, values or dict()),
             state=state,
             measurement=measurement,
             noise=noise,

qadence/extensions.py

@@ -138,7 +138,7 @@ def _set_backend_config(backend: Backend, diff_mode: DiffMode) -> None:
 
     _validate_diff_mode(backend, diff_mode)
 
-    # (1) When using PSR with any backend or (2) we use the backends Pulser or Braket,
+    # (1) When using PSR with any backend or (2) we use the backends Pulser,
     # we have to use gate-level parameters
 
     # We can use expression-level parameters for AD.

qadence/measurements/shadow.py

@@ -16,7 +16,7 @@ from qadence.blocks.primitive import PrimitiveBlock
 from qadence.blocks.utils import get_pauli_blocks, unroll_block_with_scaling
 from qadence.circuit import QuantumCircuit
 from qadence.engines.differentiable_backend import DifferentiableBackend
-from qadence.noise import Noise
+from qadence.noise import NoiseHandler
 from qadence.operations import X, Y, Z
 from qadence.types import Endianness
 from qadence.utils import P0_MATRIX, P1_MATRIX
@@ -117,8 +117,7 @@ def classical_shadow(
     param_values: dict,
     state: Tensor | None = None,
     backend: Backend | DifferentiableBackend = PyQBackend(),
-    # FIXME: Changed below from Little to Big, double-check when Roland is back
-    noise: Noise | None = None,
+    noise: NoiseHandler | None = None,
     endianness: Endianness = Endianness.BIG,
 ) -> list:
     shadow: list = []
@@ -249,7 +248,7 @@ def estimations(
     confidence: float = 0.1,
     state: Tensor | None = None,
     backend: Backend | DifferentiableBackend = PyQBackend(),
-    noise: Noise | None = None,
+    noise: NoiseHandler | None = None,
     endianness: Endianness = Endianness.BIG,
 ) -> Tensor:
     """Compute expectation values for all local observables using median of means."""
@@ -302,7 +301,7 @@ def compute_expectation(
     options: dict,
     state: Tensor | None = None,
     backend: Backend | DifferentiableBackend = PyQBackend(),
-    noise: Noise | None = None,
+    noise: NoiseHandler | None = None,
     endianness: Endianness = Endianness.BIG,
 ) -> Tensor:
     """

qadence/measurements/tomography.py

@@ -10,7 +10,7 @@ from qadence.blocks.utils import unroll_block_with_scaling
 from qadence.circuit import QuantumCircuit
 from qadence.engines.differentiable_backend import DifferentiableBackend
 from qadence.measurements.utils import iterate_pauli_decomposition
-from qadence.noise import Noise
+from qadence.noise import NoiseHandler
 from qadence.utils import Endianness
 
 
@@ -21,7 +21,7 @@ def compute_expectation(
     options: dict,
     state: Tensor | None = None,
     backend: Backend | DifferentiableBackend = PyQBackend(),
-    noise: Noise | None = None,
+    noise: NoiseHandler | None = None,
     endianness: Endianness = Endianness.BIG,
 ) -> Tensor:
     """Basic tomography protocol with rotations.

qadence/measurements/utils.py

@@ -14,7 +14,7 @@ from qadence.backends.pyqtorch import Backend as PyQBackend
 from qadence.blocks import AbstractBlock, PrimitiveBlock, chain
 from qadence.circuit import QuantumCircuit
 from qadence.engines.differentiable_backend import DifferentiableBackend
-from qadence.noise import Noise
+from qadence.noise import NoiseHandler
 from qadence.operations import H, SDagger, X, Y, Z
 from qadence.parameters import evaluate
 from qadence.utils import Endianness
@@ -128,7 +128,7 @@ def iterate_pauli_decomposition(
     n_shots: int,
     state: Tensor | None = None,
     backend: Backend | DifferentiableBackend = PyQBackend(),
-    noise: Noise | None = None,
+    noise: NoiseHandler | None = None,
     endianness: Endianness = Endianness.BIG,
 ) -> Tensor:
     """Estimate total expectation value by averaging all Pauli terms.