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

qadence/__init__.py

@@ -34,7 +34,7 @@ logger.setLevel(LOG_LEVEL)
 [
     h.setLevel(LOG_LEVEL)  # type: ignore[func-returns-value]
     for h in logger.handlers
-    if h.get_name() == "console"
+    if h.get_name() == "console" or h.get_name() == "richconsole"
 ]
 logger.debug(f"Qadence logger successfully setup with log level {LOG_LEVEL}")
 

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/analog/parse_analog.py

@@ -78,9 +78,8 @@ def _build_rot_ham_evo(
     if block.add_pattern and h_addr is not None:
         h_block += h_addr
     duration = block.parameters.duration
-    h_norm = block.parameters.h_norm
     h_block += h_drive
-    return HamEvo(h_block / h_norm, duration * h_norm / 1000)
+    return HamEvo(h_block, duration / 1000)
 
 
 def _analog_to_hevo(

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/backends/gpsr.py

@@ -36,7 +36,11 @@ def general_psr(spectrum: Tensor, n_eqs: int | None = None, shift_prefac: float
     sorted_unique_spectral_gaps = torch.tensor(list(sorted_unique_spectral_gaps)[:n_eqs])
 
     if n_eqs == 1:
-        return single_gap_psr
+        return partial(
+            single_gap_psr,
+            spectral_gap=sorted_unique_spectral_gaps,
+            shift=shift_prefac * torch.tensor([PI / 2], dtype=torch.get_default_dtype()),
+        )
     else:
         return partial(
             multi_gap_psr,
@@ -110,7 +114,9 @@ def multi_gap_psr(
     batch_size = max(t.size(0) for t in param_dict.values())
 
     # get shift values
-    shifts = shift_prefac * torch.linspace(PI / 2 - PI / 5, PI / 2 + PI / 5, n_eqs)
+    shifts = shift_prefac * torch.linspace(
+        PI / 2 - PI / 4, PI / 2 + PI / 5, n_eqs
+    )  # breaking the symmetry of sampling range around PI/2
     device = torch.device("cpu")
     try:
         device = [v.device for v in param_dict.values()][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/backends/pulser/backend.py

@@ -24,12 +24,11 @@ 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.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 +186,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 +234,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 +287,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]:
@@ -312,8 +310,6 @@ class Backend(BackendInterface):
             from qadence.transpile import invert_endianness
 
             samples = invert_endianness(samples)
-        if noise is not None:
-            samples = apply_noise(noise=noise, samples=samples)
         if mitigation is not None:
             logger.warning(
                 "Mitigation protocol is deprecated. Use qadence-protocols instead.",
@@ -329,7 +325,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:
@@ -355,27 +351,14 @@ class Backend(BackendInterface):
                     noise=noise,
                 )
                 support = sorted(list(circuit.abstract.register.support))
-                # TODO: There should be a better check for batched density matrices.
-                if dms.size()[0] > 1:
-                    res_list = [
-                        [
-                            obs.native(
-                                dm.squeeze(), param_values, qubit_support=support, noise=noise
-                            )
-                            for dm in dms
-                        ]
-                        for obs in observable
-                    ]
-                    res = torch.stack(
-                        [torch.transpose(torch.stack(res), 0, -1) for res in res_list]
-                    )
-
-                else:
-                    res_list = [
-                        obs.native(dms, param_values, qubit_support=support) for obs in observable
+                res_list = [
+                    [
+                        obs.native(dm.squeeze(), param_values, qubit_support=support, noise=noise)
+                        for dm in dms
                     ]
-                    res = torch.transpose(torch.stack(res_list), 0, 1)
-                res = res if len(res.shape) > 0 else res.reshape(1)
+                    for obs in observable
+                ]
+                res = torch.stack([torch.transpose(torch.stack(res), 0, -1) for res in res_list])
                 return res.real
         elif mitigation is not None:
             logger.warning(

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/backends/pyqtorch/backend.py

@@ -22,23 +22,63 @@ 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.transpile import (
     chain_single_qubit_ops,
     flatten,
     invert_endianness,
     scale_primitive_blocks_only,
+    set_noise,
     transpile,
 )
 from qadence.types import BackendName, Endianness, Engine
 
 from .config import Configuration, default_passes
-from .convert_ops import convert_block
+from .convert_ops import convert_block, convert_readout_noise
 
 logger = getLogger(__name__)
 
 
+def set_noise_abstract_to_native(circuit: ConvertedCircuit, config: Configuration) -> None:
+    """Set noise in native blocks from the abstract ones with noise.
+
+    Args:
+        circuit (ConvertedCircuit): Input converted circuit.
+    """
+    ops = convert_block(circuit.abstract.block, n_qubits=circuit.native.n_qubits, config=config)
+    circuit.native = pyq.QuantumCircuit(circuit.native.n_qubits, ops, circuit.native.readout_noise)
+
+
+def set_readout_noise(circuit: ConvertedCircuit, noise: NoiseHandler) -> None:
+    """Set readout noise in place in native.
+
+    Args:
+        circuit (ConvertedCircuit):  Input converted circuit.
+        noise (NoiseHandler | None): Noise.
+    """
+    readout = convert_readout_noise(circuit.abstract.n_qubits, noise)
+    if readout:
+        circuit.native.readout_noise = readout
+
+
+def set_block_and_readout_noises(
+    circuit: ConvertedCircuit, noise: NoiseHandler | None, config: Configuration
+) -> None:
+    """Add noise on blocks and readout on circuit.
+
+    We first start by adding noise to the abstract blocks. Then we do a conversion to their
+    native representation. Finally, we add readout.
+
+    Args:
+        circuit (ConvertedCircuit): Input circuit.
+        noise (NoiseHandler | None): Noise to add.
+    """
+    if noise:
+        set_noise(circuit, noise)
+        set_noise_abstract_to_native(circuit, config)
+        set_readout_noise(circuit, noise)
+
+
 @dataclass(frozen=True, eq=True)
 class Backend(BackendInterface):
     """PyQTorch backend."""
@@ -56,6 +96,17 @@ class Backend(BackendInterface):
     logger.debug("Initialised")
 
     def circuit(self, circuit: QuantumCircuit) -> ConvertedCircuit:
+        """Return the converted circuit.
+
+        Note that to get a representation with noise, noise
+        should be passed within the config.
+
+        Args:
+            circuit (QuantumCircuit): Original circuit
+
+        Returns:
+            ConvertedCircuit: ConvertedCircuit instance for backend.
+        """
         passes = self.config.transpilation_passes
         if passes is None:
             passes = default_passes(self.config)
@@ -63,9 +114,30 @@ class Backend(BackendInterface):
         original_circ = circuit
         if len(passes) > 0:
             circuit = transpile(*passes)(circuit)
+        # Setting noise in the circuit.
+        if self.config.noise:
+            set_noise(circuit, self.config.noise)
 
         ops = convert_block(circuit.block, n_qubits=circuit.n_qubits, config=self.config)
-        native = pyq.QuantumCircuit(circuit.n_qubits, ops)
+        readout_noise = (
+            convert_readout_noise(circuit.n_qubits, self.config.noise)
+            if self.config.noise
+            else None
+        )
+        if self.config.dropout_probability == 0:
+            native = pyq.QuantumCircuit(
+                circuit.n_qubits,
+                ops,
+                readout_noise,
+            )
+        else:
+            native = pyq.DropoutQuantumCircuit(
+                circuit.n_qubits,
+                ops,
+                readout_noise,
+                dropout_prob=self.config.dropout_probability,
+                dropout_mode=self.config.dropout_mode,
+            )
         return ConvertedCircuit(native=native, abstract=circuit, original=original_circ)
 
     def observable(self, observable: AbstractBlock, n_qubits: int) -> ConvertedObservable:
@@ -113,9 +185,10 @@ 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:
+        set_block_and_readout_noises(circuit, noise, self.config)
         state = self.run(
             circuit,
             param_values=param_values,
@@ -138,7 +211,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:
@@ -152,6 +225,9 @@ class Backend(BackendInterface):
                 "Looping expectation does not make sense with batched initial state. "
                 "Define your initial state with `batch_size=1`"
             )
+
+        set_block_and_readout_noises(circuit, noise, self.config)
+
         list_expvals = []
         observables = observable if isinstance(observable, list) else [observable]
         for vals in to_list_of_dicts(param_values):
@@ -169,7 +245,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 +272,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,
@@ -206,12 +282,11 @@ class Backend(BackendInterface):
         elif state is not None and pyqify_state:
             n_qubits = circuit.abstract.n_qubits
             state = pyqify(state, n_qubits) if pyqify_state else state
+        set_block_and_readout_noises(circuit, noise, self.config)
         samples: list[Counter] = circuit.native.sample(
             state=state, values=param_values, n_shots=n_shots
         )
         samples = invert_endianness(samples) if endianness != Endianness.BIG else samples
-        if noise is not None:
-            samples = apply_noise(noise=noise, samples=samples)
         if mitigation is not None:
             logger.warning(
                 "Mitigation protocol is deprecated. Use qadence-protocols instead.",

qadence/backends/pyqtorch/config.py

@@ -4,17 +4,16 @@ from dataclasses import dataclass
 from logging import getLogger
 from typing import Callable
 
-from pyqtorch.utils import SolverType
-
 from qadence.analog import add_background_hamiltonian
 from qadence.backend import BackendConfiguration
+from qadence.noise import NoiseHandler
 from qadence.transpile import (
     blockfn_to_circfn,
     chain_single_qubit_ops,
     flatten,
     scale_primitive_blocks_only,
 )
-from qadence.types import AlgoHEvo
+from qadence.types import AlgoHEvo, DropoutMode, SolverType
 
 logger = getLogger(__name__)
 
@@ -63,3 +62,11 @@ class Configuration(BackendConfiguration):
 
     Loop over the batch of parameters to only allocate a single wavefunction at any given time.
     """
+
+    noise: NoiseHandler | None = None
+    """NoiseHandler containing readout noise applied in backend."""
+
+    dropout_probability: float = 0.0
+    """Quantum dropout probability (0 means no dropout)."""
+    dropout_mode: DropoutMode = DropoutMode.ROTATIONAL
+    """Type of quantum dropout to perform."""