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

qadence/model.py

@@ -24,7 +24,7 @@ from qadence.circuit import QuantumCircuit
 from qadence.engines.differentiable_backend import DifferentiableBackend
 from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
-from qadence.noise import Noise
+from qadence.noise import NoiseHandler
 from qadence.parameters import Parameter
 from qadence.types import DiffMode, Endianness
 
@@ -83,7 +83,7 @@ class QuantumModel(nn.Module):
         backend: BackendName | str = BackendName.PYQTORCH,
         diff_mode: DiffMode = DiffMode.AD,
         measurement: Measurements | None = None,
-        noise: Noise | None = None,
+        noise: NoiseHandler | None = None,
         mitigation: Mitigations | None = None,
         configuration: BackendConfiguration | dict | None = None,
     ):
@@ -249,7 +249,7 @@ class QuantumModel(nn.Module):
         values: dict[str, torch.Tensor] = {},
         n_shots: int = 1000,
         state: torch.Tensor | None = None,
-        noise: Noise | None = None,
+        noise: NoiseHandler | None = None,
         mitigation: Mitigations | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> list[Counter]:
@@ -287,7 +287,7 @@ class QuantumModel(nn.Module):
         observable: list[ConvertedObservable] | ConvertedObservable | None = None,
         state: Optional[Tensor] = None,
         measurement: Measurements | None = None,
-        noise: Noise | None = None,
+        noise: NoiseHandler | None = None,
         mitigation: Mitigations | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> Tensor:
@@ -415,7 +415,7 @@ class QuantumModel(nn.Module):
                 backend=qm_dict["backend"],
                 diff_mode=qm_dict["diff_mode"],
                 measurement=Measurements._from_dict(qm_dict["measurement"]),
-                noise=Noise._from_dict(qm_dict["noise"]),
+                noise=NoiseHandler._from_dict(qm_dict["noise"]),
                 configuration=config_factory(qm_dict["backend"], qm_dict["backend_configuration"]),
             )
 
@@ -514,7 +514,7 @@ class QuantumModel(nn.Module):
         if isinstance(file_path, str):
             file_path = Path(file_path)
         if os.path.isdir(file_path):
-            from qadence.ml_tools.saveload import get_latest_checkpoint_name
+            from qadence.ml_tools.callbacks.saveload import get_latest_checkpoint_name
 
             file_path = file_path / get_latest_checkpoint_name(file_path, "model")
 

qadence/noise/__init__.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from .protocols import Noise
+from .protocols import NoiseHandler
 
 # Modules to be automatically added to the qadence namespace
-__all__ = ["Noise"]
+__all__ = ["NoiseHandler"]

qadence/noise/protocols.py

@@ -1,54 +1,206 @@
 from __future__ import annotations
 
-import importlib
-from dataclasses import dataclass
-from typing import Callable, Counter, cast
+from itertools import compress
+from typing import Any
 
-PROTOCOL_TO_MODULE = {
-    "readout": "qadence.noise.readout",
-}
+from qadence.types import NoiseEnum, NoiseProtocol
 
 
-@dataclass
-class Noise:
-    DEPHASING = "dephasing"
-    DEPOLARIZING = "depolarizing"
-    READOUT = "readout"
+class NoiseHandler:
+    """A container for multiple sources of noise.
 
-    def __init__(self, protocol: str, options: dict = dict()) -> None:
-        self.protocol: str = protocol
-        self.options: dict = options
+    Note `NoiseProtocol.ANALOG` and `NoiseProtocol.DIGITAL` sources cannot be both present.
+    Also `NoiseProtocol.READOUT` can only be present once as the last noise sources, and only
+    exclusively with `NoiseProtocol.DIGITAL` sources.
 
-    def get_noise_fn(self) -> Callable:
-        try:
-            module = importlib.import_module(PROTOCOL_TO_MODULE[self.protocol])
-        except KeyError:
-            ImportError(f"The module corresponding to the protocol {self.protocol} is not found.")
-        fn = getattr(module, "add_noise")
-        return cast(Callable, fn)
+    Args:
+        protocol: The protocol(s) applied. To be defined from `NoiseProtocol`.
+        options: A list of options defining the protocol.
+            For `NoiseProtocol.ANALOG`, options should contain a field `noise_probs`.
+            For `NoiseProtocol.DIGITAL`, options should contain a field `error_probability`.
+
+    Examples:
+    ```
+        from qadence import NoiseProtocol, NoiseHandler
+
+        analog_options = {"noise_probs": 0.1}
+        digital_options = {"error_probability": 0.1}
+        readout_options = {"error_probability": 0.1, "seed": 0}
+
+        # single noise sources
+        analog_noise = NoiseHandler(NoiseProtocol.ANALOG.DEPOLARIZING, analog_options)
+        digital_depo_noise = NoiseHandler(NoiseProtocol.DIGITAL.DEPOLARIZING, digital_options)
+        readout_noise = NoiseHandler(NoiseProtocol.READOUT, readout_options)
+
+        # init from multiple sources
+        protocols: list = [NoiseProtocol.DIGITAL.DEPOLARIZING, NoiseProtocol.READOUT]
+        options: list = [digital_options, readout_noise]
+        noise_combination = NoiseHandler(protocols, options)
+
+        # Appending noise sources
+        noise_combination = NoiseHandler(NoiseProtocol.DIGITAL.BITFLIP, digital_options)
+        noise_combination.append([digital_depo_noise, readout_noise])
+    ```
+    """
+
+    def __init__(
+        self,
+        protocol: NoiseEnum | list[NoiseEnum],
+        options: dict | list[dict] = dict(),
+    ) -> None:
+        self.protocol = protocol if isinstance(protocol, list) else [protocol]
+        self.options = options if isinstance(options, list) else [options] * len(self.protocol)
+        self.verify_all_protocols()
+
+    def _verify_single_protocol(self, protocol: NoiseEnum, option: dict) -> None:
+        if not isinstance(protocol, NoiseProtocol.READOUT):  # type: ignore[arg-type]
+            name_mandatory_option = (
+                "noise_probs" if isinstance(protocol, NoiseProtocol.ANALOG) else "error_probability"
+            )
+            noise_probs = option.get(name_mandatory_option, None)
+            if noise_probs is None:
+                error_txt = f"A `{name_mandatory_option}` option"
+                error_txt += f"should be passed for protocol {protocol}."
+                raise KeyError(error_txt)
+
+    def verify_all_protocols(self) -> None:
+        """Make sure all protocols are correct in terms and their combination too."""
+
+        if len(self.protocol) == 0:
+            raise ValueError("NoiseHandler should be specified with one valid configuration.")
+
+        if len(self.protocol) != len(self.options):
+            raise ValueError("Specify lists of same length when defining noises.")
+
+        for protocol, option in zip(self.protocol, self.options):
+            self._verify_single_protocol(protocol, option)
+
+        types = [type(p) for p in self.protocol]
+        unique_types = set(types)
+        if NoiseProtocol.DIGITAL in unique_types and NoiseProtocol.ANALOG in unique_types:
+            raise ValueError("Cannot define a config with both Digital and Analog noises.")
+
+        if NoiseProtocol.ANALOG in unique_types:
+            if NoiseProtocol.READOUT in unique_types:
+                raise ValueError("Cannot define a config with both READOUT and Analog noises.")
+            if types.count(NoiseProtocol.ANALOG) > 1:
+                raise ValueError("Multiple Analog Noises are not supported yet.")
+
+        if NoiseProtocol.READOUT in unique_types:
+            if (
+                not isinstance(self.protocol[-1], NoiseProtocol.READOUT)
+                or types.count(NoiseProtocol.READOUT) > 1
+            ):
+                raise ValueError("Only define a NoiseHandler with one READOUT as the last Noise.")
+
+    def __repr__(self) -> str:
+        return "\n".join(
+            [
+                f"Noise({protocol}, {str(option)})"
+                for protocol, option in zip(self.protocol, self.options)
+            ]
+        )
+
+    def append(self, other: NoiseHandler | list[NoiseHandler]) -> None:
+        """Append noises.
+
+        Args:
+            other (NoiseHandler | list[NoiseHandler]): The noises to add.
+        """
+        # To avoid overwriting the noise_sources list if an error is raised, make a copy
+        other_list = other if isinstance(other, list) else [other]
+        protocols = self.protocol[:]
+        options = self.options[:]
+
+        for noise in other_list:
+            protocols += noise.protocol
+            options += noise.options
+
+        # init may raise an error
+        temp_handler = NoiseHandler(protocols, options)
+        # if verify passes, replace protocols and options
+        self.protocol = temp_handler.protocol
+        self.options = temp_handler.options
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, NoiseHandler):
+            raise TypeError(f"Cant compare {type(self)} to {type(other)}")
+        if isinstance(other, type(self)):
+            protocols_equal = all([p1 == p2 for p1, p2 in zip(self.protocol, other.protocol)])
+            options_equal = all([o1 == o2 for o1, o2 in zip(self.options, other.options)])
+            return protocols_equal and options_equal
+
+        return False
 
     def _to_dict(self) -> dict:
-        return {"protocol": self.protocol, "options": self.options}
+        return {
+            "protocol": self.protocol,
+            "options": self.options,
+        }
 
     @classmethod
-    def _from_dict(cls, d: dict) -> Noise | None:
-        if d:
-            return cls(d["protocol"], **d["options"])
+    def _from_dict(cls, d: dict | None) -> NoiseHandler | None:
+        if d is not None and d.get("protocol", None):
+            return cls(d["protocol"], d["options"])
         return None
 
     @classmethod
     def list(cls) -> list:
         return list(filter(lambda el: not el.startswith("__"), dir(cls)))
 
+    def filter(self, protocol: NoiseEnum) -> NoiseHandler | None:
+        protocol_matches: list = [isinstance(p, protocol) for p in self.protocol]  # type: ignore[arg-type]
+
+        # if we have at least a match
+        if True in protocol_matches:
+            return NoiseHandler(
+                list(compress(self.protocol, protocol_matches)),
+                list(compress(self.options, protocol_matches)),
+            )
+        return None
+
+    def bitflip(self, *args: Any, **kwargs: Any) -> NoiseHandler:
+        self.append(NoiseHandler(NoiseProtocol.DIGITAL.BITFLIP, *args, **kwargs))
+        return self
+
+    def phaseflip(self, *args: Any, **kwargs: Any) -> NoiseHandler:
+        self.append(NoiseHandler(NoiseProtocol.DIGITAL.PHASEFLIP, *args, **kwargs))
+        return self
+
+    def digital_depolarizing(self, *args: Any, **kwargs: Any) -> NoiseHandler:
+        self.append(NoiseHandler(NoiseProtocol.DIGITAL.DEPOLARIZING, *args, **kwargs))
+        return self
+
+    def pauli_channel(self, *args: Any, **kwargs: Any) -> NoiseHandler:
+        self.append(NoiseHandler(NoiseProtocol.DIGITAL.PAULI_CHANNEL, *args, **kwargs))
+        return self
+
+    def amplitude_damping(self, *args: Any, **kwargs: Any) -> NoiseHandler:
+        self.append(NoiseHandler(NoiseProtocol.DIGITAL.AMPLITUDE_DAMPING, *args, **kwargs))
+        return self
+
+    def phase_damping(self, *args: Any, **kwargs: Any) -> NoiseHandler:
+        self.append(NoiseHandler(NoiseProtocol.DIGITAL.PHASE_DAMPING, *args, **kwargs))
+        return self
+
+    def generalized_amplitude_damping(self, *args: Any, **kwargs: Any) -> NoiseHandler:
+        self.append(
+            NoiseHandler(NoiseProtocol.DIGITAL.GENERALIZED_AMPLITUDE_DAMPING, *args, **kwargs)
+        )
+        return self
+
+    def analog_depolarizing(self, *args: Any, **kwargs: Any) -> NoiseHandler:
+        self.append(NoiseHandler(NoiseProtocol.ANALOG.DEPOLARIZING, *args, **kwargs))
+        return self
+
+    def dephasing(self, *args: Any, **kwargs: Any) -> NoiseHandler:
+        self.append(NoiseHandler(NoiseProtocol.ANALOG.DEPHASING, *args, **kwargs))
+        return self
+
+    def readout_independent(self, *args: Any, **kwargs: Any) -> NoiseHandler:
+        self.append(NoiseHandler(NoiseProtocol.READOUT.INDEPENDENT, *args, **kwargs))
+        return self
 
-def apply_noise(noise: Noise, samples: list[Counter]) -> list[Counter]:
-    """Apply noise to samples."""
-    error_fn = noise.get_noise_fn()
-    # Get the number of qubits from the sample keys.
-    n_qubits = len(list(samples[0].keys())[0])
-    # Get the number of shots from the sample values.
-    n_shots = sum(samples[0].values())
-    noisy_samples: list = error_fn(
-        counters=samples, n_qubits=n_qubits, options=noise.options, n_shots=n_shots
-    )
-    return noisy_samples
+    def readout_correlated(self, *args: Any, **kwargs: Any) -> NoiseHandler:
+        self.append(NoiseHandler(NoiseProtocol.READOUT.CORRELATED, *args, **kwargs))
+        return self

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

@@ -33,29 +33,59 @@ logger = getLogger(__name__)
 
 class HamEvo(TimeEvolutionBlock):
     """
-    A block implementing the Hamiltonian evolution operation H where:
+    The Hamiltonian evolution operator U(t).
 
-        H = exp(-iG, t)
-    where G represents a square generator and t represents the time parameter
-    which can be parametrized.
+    For time-independent Hamiltonians the solution is exact:
+
+        U(t) = exp(-iGt)
+
+    where G represents an Hermitian generator, or Hamiltonian and t represents the
+    time parameter. For time-dependent Hamiltonians, the solution is obtained by
+    numerical integration of the Schrodinger equation.
 
     Arguments:
-        generator: Either a AbstractBlock, torch.Tensor or numpy.ndarray.
-        parameter: A scalar or vector of numeric or torch.Tensor type.
-        qubit_support: The qubits on which the evolution will be performed on.
-        duration: duration of evolution in case of time-dependent generator
+        generator: Hamiltonian generator, either symbolic as an AbstractBlock,
+            or as a torch.Tensor or numpy.ndarray.
+        parameter: The time parameter for evolution operator. For the time-independent
+            case, it represents the actual value for which the evolution will be
+            evaluated. For the time-dependent case, it should be an instance of
+            TimeParameter to signal the solver the variable that will be integrated over.
+        qubit_support: The qubits on which the evolution will be performed on. Only
+            required for generators that are not a composition of blocks.
+        duration: (optional) duration of the evolution in case of time-dependent
+            generator. By default, a FeatureParameter with tag "duration" will
+            be initialized, and the value will then be required in the values dict.
+        noise_operators: (optional) the list of jump operators to use when using
+            a shrodinger solver, allowing to perform noisy simulations.
 
     Examples:
 
     ```python exec="on" source="material-block" result="json"
-    from qadence import RX, HamEvo, run, PI
+    from qadence import X, HamEvo, PI, add, run
+    from qadence import FeatureParameter, TimeParameter
     import torch
-    hevo = HamEvo(generator=RX(0, PI), parameter=torch.rand(2))
-    print(run(hevo))
-    # Now lets use a torch.Tensor as a generator, Now we have to pass the support
-    gen = torch.rand(2,2, dtype=torch.complex128)
-    hevo = HamEvo(generator=gen, parameter=torch.rand(2), qubit_support=(0,))
-    print(run(hevo))
+
+    n_qubits = 3
+
+    # Hamiltonian as a block composition
+    hamiltonian = add(X(i) for i in range(n_qubits))
+    hevo = HamEvo(hamiltonian, parameter=torch.rand(2))
+    state = run(hevo)
+
+    # Hamiltonian as a random matrix
+    hamiltonian = torch.rand(2, 2, dtype=torch.complex128)
+    hevo = HamEvo(hamiltonian, parameter=torch.rand(2), qubit_support=(0,))
+    state = run(hevo)
+
+    # Time-dependent Hamiltonian
+    t = TimeParameter("t")
+    hamiltonian = t * add(X(i) for i in range(n_qubits))
+    hevo = HamEvo(hamiltonian, parameter=t)
+    state = run(hevo, values = {"duration": torch.tensor(1.0)})
+
+    # Adding noise operators
+    noise_ops = [X(0)]
+    hevo = HamEvo(hamiltonian, parameter=t, noise_operators=noise_ops)
     ```
     """
 
@@ -67,21 +97,31 @@ class HamEvo(TimeEvolutionBlock):
         generator: Union[TGenerator, AbstractBlock],
         parameter: TParameter,
         qubit_support: tuple[int, ...] = None,
-        duration: float | None = None,
+        duration: TParameter | None = None,
+        noise_operators: list[AbstractBlock] = list(),
     ):
-        gen_exprs = {}
+        params = {}
         if qubit_support is None and not isinstance(generator, AbstractBlock):
             raise ValueError("You have to supply a qubit support for non-block generators.")
         super().__init__(qubit_support if qubit_support else generator.qubit_support)
         if isinstance(generator, AbstractBlock):
             qubit_support = generator.qubit_support
             if generator.is_parametric:
-                gen_exprs = {str(e): e for e in expressions(generator)}
-
-                if generator.is_time_dependent and duration is None:
-                    raise ValueError("For time-dependent generators, a duration must be specified.")
-
+                params = {str(e): e for e in expressions(generator)}
+            if generator.is_time_dependent:
+                if isinstance(duration, str):
+                    duration = Parameter(duration, trainable=False)
+                elif duration is None:
+                    duration = Parameter("duration", trainable=False)
+            if not generator.is_time_dependent and duration is not None:
+                raise TypeError(
+                    "Duration argument is only supported for time-dependent generators."
+                )
         elif isinstance(generator, torch.Tensor):
+            if duration is not None:
+                raise TypeError(
+                    "Duration argument is only supported for time-dependent generators."
+                )
             msg = "Please provide a square generator."
             if len(generator.shape) == 2:
                 assert generator.shape[0] == generator.shape[1], msg
@@ -94,19 +134,41 @@ class HamEvo(TimeEvolutionBlock):
                                 In case of a 3D generator, the batch dim\
                                 is expected to be at dim 0."
                 )
-            gen_exprs = {str(generator.__hash__()): generator}
+            params = {str(generator.__hash__()): generator}
         elif isinstance(generator, (sympy.Basic, sympy.Array)):
-            gen_exprs = {str(generator): generator}
+            if duration is not None:
+                raise TypeError(
+                    "Duration argument is only supported for time-dependent generators."
+                )
+            params = {str(generator): generator}
         else:
             raise TypeError(
                 f"Generator of type {type(generator)} not supported.\
                             If you're using a numpy.ndarray, please cast it to a torch tensor."
             )
-        ps = {"parameter": Parameter(parameter), **gen_exprs}
-        self.parameters = ParamMap(**ps)
+        if duration is not None:
+            params = {"duration": Parameter(duration), **params}
+        params = {"parameter": Parameter(parameter), **params}
+        self.parameters = ParamMap(**params)
+        self.time_param = parameter
         self.generator = generator
         self.duration = duration
 
+        if len(noise_operators) > 0:
+            if not all(
+                [
+                    len(set(op.qubit_support + self.qubit_support) - set(self.qubit_support)) == 0
+                    for op in noise_operators
+                ]
+            ):
+                raise ValueError(
+                    "Noise operators should be defined"
+                    " over the same or a subset of the qubit support"
+                )
+            if True in [op.is_parametric for op in noise_operators]:
+                raise ValueError("Parametric operators are not supported")
+        self.noise_operators = noise_operators
+
     @classmethod
     def num_parameters(cls) -> int:
         return 2