qadence 1.7.8__tar.gz → 1.8.0__tar.gz

{qadence-1.7.8 → qadence-1.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qadence
-Version: 1.7.8
+Version: 1.8.0
 Summary: Pasqal interface for circuit-based quantum computing SDKs
 Author-email: Aleksander Wennersteen <aleksander.wennersteen@pasqal.com>, Gert-Jan Both <gert-jan.both@pasqal.com>, Niklas Heim <niklas.heim@pasqal.com>, Mario Dagrada <mario.dagrada@pasqal.com>, Vincent Elfving <vincent.elfving@pasqal.com>, Dominik Seitz <dominik.seitz@pasqal.com>, Roland Guichard <roland.guichard@pasqal.com>, "Joao P. Moutinho" <joao.moutinho@pasqal.com>, Vytautas Abramavicius <vytautas.abramavicius@pasqal.com>, Gergana Velikova <gergana.velikova@pasqal.com>, Eduardo Maschio <eduardo.maschio@pasqal.com>, Smit Chaudhary <smit.chaudhary@pasqal.com>, Ignacio Fernández Graña <ignacio.fernandez-grana@pasqal.com>, Charles Moussa <charles.moussa@pasqal.com>, Giorgio Tosti Balducci <giorgio.tosti-balducci@pasqal.com>, Daniele Cucurachi <daniele.cucurachi@pasqal.com>
 License: Apache 2.0
@@ -22,7 +22,7 @@ Requires-Dist: matplotlib
 Requires-Dist: nevergrad
 Requires-Dist: numpy
 Requires-Dist: openfermion
-Requires-Dist: pyqtorch==1.4.9
+Requires-Dist: pyqtorch==1.5.1
 Requires-Dist: pyyaml
 Requires-Dist: rich
 Requires-Dist: scipy
@@ -31,14 +31,11 @@ Requires-Dist: sympytorch>=0.1.2
 Requires-Dist: tensorboard>=2.12.0
 Requires-Dist: torch
 Provides-Extra: all
-Requires-Dist: braket; extra == 'all'
 Requires-Dist: libs; extra == 'all'
 Requires-Dist: mlflow; extra == 'all'
 Requires-Dist: protocols; extra == 'all'
 Requires-Dist: pulser; extra == 'all'
 Requires-Dist: visualization; extra == 'all'
-Provides-Extra: braket
-Requires-Dist: amazon-braket-sdk<1.71.2; extra == 'braket'
 Provides-Extra: dlprof
 Requires-Dist: nvidia-dlprof[pytorch]; extra == 'dlprof'
 Requires-Dist: nvidia-pyindex; extra == 'dlprof'
@@ -57,9 +54,9 @@ Requires-Dist: mlflow; extra == 'mlflow'
 Provides-Extra: protocols
 Requires-Dist: qadence-protocols; extra == 'protocols'
 Provides-Extra: pulser
-Requires-Dist: pasqal-cloud==0.12.2; extra == 'pulser'
-Requires-Dist: pulser-core==0.19.0; extra == 'pulser'
-Requires-Dist: pulser-simulation==0.19.0; extra == 'pulser'
+Requires-Dist: pasqal-cloud==0.12.4; extra == 'pulser'
+Requires-Dist: pulser-core==1.1.1; extra == 'pulser'
+Requires-Dist: pulser-simulation==1.1.1; extra == 'pulser'
 Provides-Extra: visualization
 Requires-Dist: graphviz; extra == 'visualization'
 Description-Content-Type: text/markdown

{qadence-1.7.8 → qadence-1.8.0}/mkdocs.yml

@@ -72,6 +72,7 @@ nav:
     - QuantumCircuit: api/quantumcircuit.md
     - Parameters: api/parameters.md
     - State preparation: api/states.md
+    - Noise: api/noise.md
     - Constructors: api/constructors.md
     - Transpilation: api/transpile.md
     - Execution: api/execution.md

{qadence-1.7.8 → qadence-1.8.0}/pyproject.toml

@@ -26,7 +26,7 @@ authors = [
 ]
 requires-python = ">=3.9"
 license = { text = "Apache 2.0" }
-version = "1.7.8"
+version = "1.8.0"
 classifiers = [
     "License :: OSI Approved :: Apache Software License",
     "Programming Language :: Python",
@@ -50,7 +50,7 @@ dependencies = [
     "jsonschema",
     "nevergrad",
     "scipy",
-    "pyqtorch==1.4.9",
+    "pyqtorch==1.5.1",
     "pyyaml",
     "matplotlib",
     "Arpeggio==2.0.2",
@@ -62,11 +62,10 @@ allow-ambiguous-features = true
 
 [project.optional-dependencies]
 pulser = [
-    "pulser-core==0.19.0",
-    "pulser-simulation==0.19.0",
-    "pasqal-cloud==0.12.2",
+    "pulser-core==1.1.1",
+    "pulser-simulation==1.1.1",
+    "pasqal-cloud==0.12.4",
 ]
-braket = ["amazon-braket-sdk<1.71.2"]
 visualization = [
     "graphviz",
     # FIXME: will be needed once we support latex labels
@@ -86,7 +85,7 @@ protocols = ["qadence-protocols"]
 libs = ["qadence-libs"]
 dlprof = ["nvidia-pyindex", "nvidia-dlprof[pytorch]"]
 mlflow = ["mlflow"]
-all = ["pulser", "braket", "visualization", "protocols", "libs", "mlflow"]
+all = ["pulser", "visualization", "protocols", "libs", "mlflow"]
 
 
 [tool.hatch.envs.default]
@@ -105,7 +104,7 @@ dependencies = [
     "ruff",
     "pydocstringformatter",
 ]
-features = ["pulser", "braket", "visualization", "horqrux", "mlflow"]
+features = ["pulser", "visualization", "horqrux", "mlflow"]
 
 [tool.hatch.envs.default.scripts]
 test = "pytest -n auto --cov-report lcov --cov-config=pyproject.toml --cov=qadence --cov=tests --ignore=./tests/test_examples.py {args}"
@@ -143,7 +142,7 @@ dependencies = [
     "markdown-exec",
     "mike",
 ]
-features = ["pulser", "braket", "horqrux", "visualization", "mlflow"]
+features = ["pulser", "horqrux", "visualization", "mlflow"]
 
 [tool.hatch.envs.docs.scripts]
 build = "mkdocs build --clean --strict"

{qadence-1.7.8 → qadence-1.8.0}/qadence/analog/device.py

@@ -49,7 +49,7 @@ class RydbergDevice:
             )
 
     def _to_dict(self) -> dict:
-        device_dict = {}
+        device_dict = dict()
         for field in fields(self):
             if field.name != "pattern":
                 device_dict[field.name] = getattr(self, field.name)

{qadence-1.7.8 → qadence-1.8.0}/qadence/backend.py

@@ -23,7 +23,7 @@ from qadence.blocks.analog import ConstantAnalogRotation, InteractionBlock
 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.parameters import stringify
 from qadence.types import ArrayLike, BackendName, DiffMode, Endianness, Engine, ParamDictType
 
@@ -240,7 +240,7 @@ class Backend(ABC):
         param_values: dict[str, Tensor] = {},
         n_shots: int = 1000,
         state: ArrayLike | None = None,
-        noise: Noise | None = None,
+        noise: NoiseHandler | None = None,
         mitigation: Mitigations | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> list[Counter]:
@@ -290,7 +290,7 @@ class Backend(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,
     ) -> ArrayLike:

{qadence-1.7.8 → qadence-1.8.0}/qadence/backends/horqrux/backend.py

@@ -21,7 +21,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.transpile import flatten, scale_primitive_blocks_only, transpile
 from qadence.types import BackendName, Endianness, Engine, ParamDictType
 from qadence.utils import int_to_basis
@@ -114,7 +114,7 @@ class Backend(BackendInterface):
         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:
@@ -163,7 +163,7 @@ class Backend(BackendInterface):
         param_values: ParamDictType = {},
         n_shots: int = 1,
         state: ArrayLike | None = None,
-        noise: Noise | None = None,
+        noise: NoiseHandler | None = None,
         mitigation: Mitigations | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> list[Counter]:

{qadence-1.7.8 → qadence-1.8.0}/qadence/backends/pulser/backend.py

@@ -24,12 +24,12 @@ from qadence.circuit import QuantumCircuit
 from qadence.measurements import Measurements
 from qadence.mitigations import Mitigations
 from qadence.mitigations.protocols import apply_mitigation
-from qadence.noise import Noise
-from qadence.noise.protocols import apply_noise
+from qadence.noise import NoiseHandler
+from qadence.noise.protocols import apply_readout_noise
 from qadence.overlap import overlap_exact
 from qadence.register import Register
 from qadence.transpile import transpile
-from qadence.types import BackendName, DeviceType, Endianness, Engine
+from qadence.types import BackendName, DeviceType, Endianness, Engine, NoiseProtocol
 
 from .channels import GLOBAL_CHANNEL, LOCAL_CHANNEL
 from .cloud import get_client
@@ -187,7 +187,7 @@ class Backend(BackendInterface):
         param_values: dict[str, Tensor] = {},
         state: Tensor | None = None,
         endianness: Endianness = Endianness.BIG,
-        noise: Noise | None = None,
+        noise: NoiseHandler | None = None,
     ) -> Tensor:
         vals = to_list_of_dicts(param_values)
 
@@ -235,27 +235,26 @@ class Backend(BackendInterface):
     def _run_noisy(
         self,
         circuit: ConvertedCircuit,
-        noise: Noise,
+        noise: NoiseHandler,
         param_values: dict[str, Tensor] = dict(),
         state: Tensor | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> Tensor:
         vals = to_list_of_dicts(param_values)
-        noise_probs = noise.options.get("noise_probs", None)
-        if noise_probs is None:
-            KeyError("A `noise probs` option should be passed to the <class QuantumModel>.")
-        if not (isinstance(noise_probs, float) or isinstance(noise_probs, Iterable)):
-            KeyError(
-                "A single or a range of noise probabilities"
-                " should be passed. Got {type(noise_probs)}."
-            )
+        if not isinstance(noise.protocol[-1], NoiseProtocol.ANALOG):
+            raise TypeError("Noise must be of type `NoiseProtocol.ANALOG`.")
+        noise_probs = noise.options[-1].get("noise_probs", None)
 
         def run_noisy_sim(noise_prob: float) -> Tensor:
             batched_dm = np.zeros(
                 (len(vals), 2**circuit.abstract.n_qubits, 2**circuit.abstract.n_qubits),
                 dtype=np.complex128,
             )
-            sim_config = {"noise": noise.protocol, noise.protocol + "_rate": noise_prob}
+            # pulser requires lower letters
+            sim_config = {
+                "noise": noise.protocol[-1].lower(),
+                noise.protocol[-1].lower() + "_rate": noise_prob,
+            }
             self.config.sim_config = SimConfig(**sim_config)
 
             for i, param_values_el in enumerate(vals):
@@ -289,7 +288,7 @@ class Backend(BackendInterface):
         param_values: dict[str, Tensor] = {},
         n_shots: int = 1,
         state: Tensor | None = None,
-        noise: Noise | None = None,
+        noise: NoiseHandler | None = None,
         mitigation: Mitigations | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> list[Counter]:
@@ -313,7 +312,7 @@ class Backend(BackendInterface):
 
             samples = invert_endianness(samples)
         if noise is not None:
-            samples = apply_noise(noise=noise, samples=samples)
+            samples = apply_readout_noise(noise=noise, samples=samples)
         if mitigation is not None:
             logger.warning(
                 "Mitigation protocol is deprecated. Use qadence-protocols instead.",
@@ -329,7 +328,7 @@ class Backend(BackendInterface):
         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,
     ) -> Tensor:

{qadence-1.7.8 → qadence-1.8.0}/qadence/backends/pulser/convert_ops.py

@@ -5,7 +5,7 @@ from typing import Sequence
 import torch
 from torch.nn import Module
 
-from qadence import Noise
+from qadence import NoiseHandler
 from qadence.blocks import (
     AbstractBlock,
 )
@@ -40,7 +40,7 @@ class PulserObservable(Module):
         state: torch.Tensor,
         values: dict[str, torch.Tensor] = dict(),
         qubit_support: tuple | None = None,
-        noise: Noise | None = None,
+        noise: NoiseHandler | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> torch.Tensor:
         if not self.block.is_parametric:

{qadence-1.7.8 → qadence-1.8.0}/qadence/backends/pyqtorch/backend.py

@@ -22,8 +22,8 @@ from qadence.blocks import AbstractBlock
 from qadence.circuit import QuantumCircuit
 from qadence.measurements import Measurements
 from qadence.mitigations.protocols import Mitigations, apply_mitigation
-from qadence.noise import Noise
-from qadence.noise.protocols import apply_noise
+from qadence.noise import NoiseHandler
+from qadence.noise.protocols import apply_readout_noise
 from qadence.transpile import (
     chain_single_qubit_ops,
     flatten,
@@ -113,7 +113,7 @@ class Backend(BackendInterface):
         param_values: dict[str, Tensor] = {},
         state: Tensor | None = None,
         measurement: Measurements | None = None,
-        noise: Noise | None = None,
+        noise: NoiseHandler | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> Tensor:
         state = self.run(
@@ -138,7 +138,7 @@ class Backend(BackendInterface):
         param_values: dict[str, Tensor] = {},
         state: Tensor | None = None,
         measurement: Measurements | None = None,
-        noise: Noise | None = None,
+        noise: NoiseHandler | None = None,
         endianness: Endianness = Endianness.BIG,
     ) -> Tensor:
         if state is None:
@@ -169,7 +169,7 @@ class Backend(BackendInterface):
         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,
     ) -> Tensor:
@@ -196,7 +196,7 @@ class Backend(BackendInterface):
         param_values: dict[str, Tensor] = {},
         n_shots: int = 1,
         state: Tensor | None = None,
-        noise: Noise | None = None,
+        noise: NoiseHandler | None = None,
         mitigation: Mitigations | None = None,
         endianness: Endianness = Endianness.BIG,
         pyqify_state: bool = True,
@@ -211,7 +211,7 @@ class Backend(BackendInterface):
         )
         samples = invert_endianness(samples) if endianness != Endianness.BIG else samples
         if noise is not None:
-            samples = apply_noise(noise=noise, samples=samples)
+            samples = apply_readout_noise(noise=noise, samples=samples)
         if mitigation is not None:
             logger.warning(
                 "Mitigation protocol is deprecated. Use qadence-protocols instead.",

qadence-1.8.0/qadence/backends/pyqtorch/convert_ops.py

@@ -0,0 +1,332 @@
+from __future__ import annotations
+
+import re
+from functools import partial, reduce
+from itertools import chain as flatten
+from typing import Any, Callable, Sequence
+
+import pyqtorch as pyq
+import sympy
+import torch
+from pyqtorch.embed import ConcretizedCallable
+from torch import (
+    Tensor,
+    cdouble,
+    complex64,
+    float64,
+    tensor,
+)
+from torch.nn import Module
+
+from qadence.blocks import (
+    AbstractBlock,
+    AddBlock,
+    ChainBlock,
+    CompositeBlock,
+    MatrixBlock,
+    ParametricBlock,
+    PrimitiveBlock,
+    ScaleBlock,
+    TimeEvolutionBlock,
+)
+from qadence.blocks.primitive import ProjectorBlock
+from qadence.noise import NoiseHandler
+from qadence.operations import (
+    U,
+    multi_qubit_gateset,
+    non_unitary_gateset,
+    single_qubit_gateset,
+    three_qubit_gateset,
+    two_qubit_gateset,
+)
+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.
+
+Tdagger is currently not supported.
+"""
+
+
+def is_single_qubit_chain(block: AbstractBlock) -> bool:
+    return (
+        isinstance(block, (ChainBlock))
+        and block.n_supports == 1
+        and all([isinstance(b, (ParametricBlock, PrimitiveBlock)) for b in block])
+        and not any([isinstance(b, (ScaleBlock, U)) for b in block])
+    )
+
+
+def extract_parameter(block: ScaleBlock | ParametricBlock, config: Configuration) -> str | Tensor:
+    """Extract the parameter as string or its tensor value.
+
+    Args:
+        block (ScaleBlock | ParametricBlock): Block to extract parameter from.
+        config (Configuration): Configuration instance.
+
+    Returns:
+        str | Tensor: Parameter value or symbol.
+    """
+    if not block.is_parametric:
+        tensor_val = tensor([block.parameters.parameter], dtype=complex64)
+        return (
+            tensor([block.parameters.parameter], dtype=float64)
+            if torch.all(tensor_val.imag == 0)
+            else tensor_val
+        )
+
+    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
+) -> Sequence[Module | Tensor | str | sympy.Expr]:
+    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
+        return [block]
+    qubit_support = block.qubit_support
+    if n_qubits is None:
+        n_qubits = max(qubit_support) + 1
+
+    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=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):
+        if getattr(block.generator, "is_time_dependent", False):
+            config._use_gate_params = False
+            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,
+                    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(
+                qubit_support=qubit_support,
+                generator=generator,
+                time=time_param,
+                cache_length=0,
+            )
+        ]
+
+    elif isinstance(block, MatrixBlock):
+        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):
+            return [pyq.Add(ops)]  # add
+        elif is_single_qubit_chain(block) and config.use_single_qubit_composition:
+            return [pyq.Merge(ops)]  # for chains of single qubit ops on the same qubit
+        else:
+            return [pyq.Sequence(ops)]  # for kron and chain
+    elif isinstance(block, tuple(non_unitary_gateset)):
+        if isinstance(block, ProjectorBlock):
+            projector = getattr(pyq, block.name)
+            if block.name == OpName.N:
+                return [projector(target=qubit_support, noise=noise)]
+            else:
+                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),
+                    noise=noise,
+                )
+            else:
+                param = extract_parameter(block, config)
+                op = pyq_cls(qubit_support[0], param, noise=noise)
+        else:
+            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),
+                noise=noise,
+            )
+        else:
+            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),
+                noise=noise,
+            )
+        else:
+            if "CSWAP" in block_name:
+                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], noise=noise  # type: ignore [attr-defined]
+                )
+        return [op]
+    else:
+        raise NotImplementedError(
+            f"Non supported operation of type {type(block)}. "
+            "In case you are trying to run an `AnalogBlock`, make sure you "
+            "specify the `device_specs` in your `Register` first."
+        )
+
+
+def convert_digital_noise(noise: NoiseHandler) -> pyq.noise.NoiseProtocol:
+    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)
+        ]
+    )