qadence 1.1.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

qadence/backends/pulser/backend.py

@@ -28,14 +28,14 @@ from qadence.noise.protocols import apply_noise
 from qadence.overlap import overlap_exact
 from qadence.register import Register
 from qadence.transpile import transpile
-from qadence.types import BackendName, Endianness
+from qadence.types import BackendName, DeviceType, Endianness
 
 from .channels import GLOBAL_CHANNEL, LOCAL_CHANNEL
 from .cloud import get_client
 from .config import Configuration
 from .convert_ops import convert_observable
-from .devices import Device, IdealDevice, RealisticDevice
-from .pulses import add_pulses
+from .devices import IdealDevice, RealisticDevice
+from .pulses import add_addressing_pattern, add_pulses
 
 logger = get_logger(__file__)
 
@@ -54,25 +54,33 @@ def create_register(register: Register) -> PulserRegister:
 
 
 def make_sequence(circ: QuantumCircuit, config: Configuration) -> Sequence:
-    if config.device_type == Device.IDEALIZED:
-        device = IdealDevice
-    elif config.device_type == Device.REALISTIC:
-        device = RealisticDevice
+    qadence_register = circ.register
+    device_specs = qadence_register.device_specs
+
+    if device_specs.type == DeviceType.IDEALIZED:
+        device = IdealDevice(
+            device_specs.rydberg_level, device_specs.max_detuning, device_specs.max_amp
+        )
+    elif device_specs.type == DeviceType.REALISTIC:
+        device = RealisticDevice(
+            device_specs.rydberg_level, device_specs.max_detuning, device_specs.max_amp
+        )
     else:
-        raise ValueError("Specified device is not supported.")
+        raise ValueError(
+            f"Specified device of type {device_specs.type} is not supported by the pulser backend."
+        )
 
     ########
     # FIXME: Remove the block below in V1.1.0
-    register = circ.register
     if config.spacing is not None:
         logger.warning(
             "Passing register spacing in the backend configuration is deprecated. "
             "Please pass it in the register directly, as detailed in the register tutorial."
         )
         # Rescales the register coordinates, as was done with the previous "spacing" argument.
-        register = register.rescale_coords(scaling=config.spacing)
+        qadence_register = qadence_register.rescale_coords(scaling=config.spacing)
     else:
-        if register.min_distance < 4.0:
+        if qadence_register.min_distance < 4.0:
             # Throws warning for minimum distance below 4 because the typical values used
             # for the standard pulser device parameters is ~7-8, so this likely means the user
             # forgot to set the spacing at register creation.
@@ -83,15 +91,14 @@ def make_sequence(circ: QuantumCircuit, config: Configuration) -> Sequence:
             )
     ########
 
-    pulser_register = create_register(register)
+    pulser_register = create_register(qadence_register)
 
     sequence = Sequence(pulser_register, device)
 
     sequence.declare_channel(GLOBAL_CHANNEL, "rydberg_global")
     sequence.declare_channel(LOCAL_CHANNEL, "rydberg_local", initial_target=0)
 
-    add_pulses(sequence, circ.block, config, circ.register)
-    sequence.measure()
+    add_pulses(sequence, circ.block, config, qadence_register)
 
     return sequence
 
@@ -192,7 +199,7 @@ class Backend(BackendInterface):
 
         return circuit.native.build(**numpy_param_values)
 
-    def run(
+    def _run(
         self,
         circuit: ConvertedCircuit,
         param_values: dict[str, Tensor] = {},
@@ -213,6 +220,10 @@ class Backend(BackendInterface):
 
         for i, param_values_el in enumerate(vals):
             sequence = self.assign_parameters(circuit, param_values_el)
+            pattern = circuit.original.register.device_specs.pattern
+            if pattern is not None:
+                add_addressing_pattern(sequence, pattern)
+            sequence.measure()
             sim_result = simulate_sequence(sequence, self.config, state, n_shots=None)
             wf = (
                 sim_result.get_final_state(  # type:ignore [union-attr]
@@ -281,6 +292,10 @@ class Backend(BackendInterface):
         samples = []
         for param_values_el in vals:
             sequence = self.assign_parameters(circuit, param_values_el)
+            pattern = circuit.original.register.device_specs.pattern
+            if pattern is not None:
+                add_addressing_pattern(sequence, pattern)
+            sequence.measure()
             sample = simulate_sequence(sequence, self.config, state, n_shots=n_shots)
             samples.append(sample)
         if endianness != self.native_endianness:

qadence/backends/pulser/config.py

@@ -8,9 +8,7 @@ from pasqal_cloud.device import EmulatorType
 from pulser_simulation.simconfig import SimConfig
 
 from qadence.backend import BackendConfiguration
-from qadence.blocks.analog import Interaction
-
-from .devices import Device
+from qadence.types import DeviceType, Interaction
 
 DEFAULT_CLOUD_ENV = "prod"
 
@@ -27,12 +25,11 @@ class CloudConfiguration:
 
 @dataclass
 class Configuration(BackendConfiguration):
-    device_type: Device = Device.IDEALIZED
+    device_type: DeviceType = DeviceType.IDEALIZED
     """The type of quantum Device to use in the simulations.
 
-    Choose
-    between IDEALIZED and REALISTIC. This influences pulse duration, max
-    amplitude, minimum atom spacing and other properties of the system
+    FIXME: This is deprecated, the device_type is now controlled in the
+    Qadence Device, as detailed in the documentation.
     """
 
     sampling_rate: float = 1.0
@@ -67,19 +64,31 @@ class Configuration(BackendConfiguration):
     """
 
     amplitude_local: Optional[float] = None
-    """Default pulse amplitude on local channel."""
+    """Default pulse amplitude on local channel.
+
+    FIXME: To be deprecated.
+    """
 
     amplitude_global: Optional[float] = None
-    """Default pulse amplitude on global channel."""
+    """Default pulse amplitude on global channel.
+
+    FIXME: To be deprecated.
+    """
 
     detuning: Optional[float] = None
-    """Default value for the detuning pulses."""
+    """Default value for the detuning pulses.
+
+    FIXME: To be deprecated.
+    """
 
     interaction: Interaction = Interaction.NN
     """Type of interaction introduced in the Hamiltonian.
 
     Currently, only
     NN interaction is support. XY interaction is possible but not implemented
+
+    FIXME: This is deprecated, the interaction is now controlled in the
+    Qadence Device, as detailed in the documentation.
     """
 
     # configuration for cloud simulations

qadence/backends/pulser/devices.py

@@ -3,75 +3,69 @@ from __future__ import annotations
 from numpy import pi
 from pulser.channels.channels import Rydberg
 from pulser.channels.eom import RydbergBeam, RydbergEOM
-from pulser.devices._device_datacls import Device as PulserDevice
 from pulser.devices._device_datacls import VirtualDevice
 
-from qadence.types import StrEnum
 
 # Idealized virtual device
-IdealDevice = VirtualDevice(
-    name="IdealizedDevice",
-    dimensions=2,
-    rydberg_level=60,
-    max_atom_num=100,
-    max_radial_distance=100,
-    min_atom_distance=0,
-    channel_objects=(
-        Rydberg.Global(max_abs_detuning=2 * pi * 4, max_amp=2 * pi * 3),
-        Rydberg.Local(max_targets=1000, max_abs_detuning=2 * pi * 4, max_amp=2 * pi * 3),
-    ),
-)
+def IdealDevice(
+    rydberg_level: int = 60, max_abs_detuning: float = 2 * pi * 4, max_amp: float = 2 * pi * 3
+) -> VirtualDevice:
+    return VirtualDevice(
+        name="IdealizedDevice",
+        dimensions=2,
+        rydberg_level=rydberg_level,
+        max_atom_num=100,
+        max_radial_distance=100,
+        min_atom_distance=0,
+        channel_objects=(
+            Rydberg.Global(max_abs_detuning=max_abs_detuning, max_amp=max_amp),
+            Rydberg.Local(max_targets=1000, max_abs_detuning=max_abs_detuning, max_amp=max_amp),
+        ),
+    )
 
 
-# device with realistic specs with local channels and custom bandwith.
-RealisticDevice = PulserDevice(
-    name="RealisticDevice",
-    dimensions=2,
-    rydberg_level=60,
-    max_atom_num=100,
-    max_radial_distance=60,
-    min_atom_distance=5,
-    channel_objects=(
-        Rydberg.Global(
-            max_abs_detuning=2 * pi * 4,
-            max_amp=2 * pi * 1.5,
-            clock_period=4,
-            min_duration=16,
-            max_duration=4000,
-            mod_bandwidth=16,
-            eom_config=RydbergEOM(
-                limiting_beam=RydbergBeam.RED,
-                max_limiting_amp=40 * 2 * pi,
-                intermediate_detuning=700 * 2 * pi,
-                mod_bandwidth=24,
-                controlled_beams=(RydbergBeam.BLUE,),
+# Device with realistic specs with local channels and custom bandwith.
+def RealisticDevice(
+    rydberg_level: int = 60, max_abs_detuning: float = 2 * pi * 4, max_amp: float = 2 * pi * 3
+) -> VirtualDevice:
+    return VirtualDevice(
+        name="RealisticDevice",
+        dimensions=2,
+        rydberg_level=rydberg_level,
+        max_atom_num=100,
+        max_radial_distance=60,
+        min_atom_distance=5,
+        channel_objects=(
+            Rydberg.Global(
+                max_abs_detuning=max_abs_detuning,
+                max_amp=max_amp * 0.5,
+                clock_period=4,
+                min_duration=16,
+                max_duration=4000,
+                mod_bandwidth=16,
+                eom_config=RydbergEOM(
+                    limiting_beam=RydbergBeam.RED,
+                    max_limiting_amp=40 * 2 * pi,
+                    intermediate_detuning=700 * 2 * pi,
+                    mod_bandwidth=24,
+                    controlled_beams=(RydbergBeam.BLUE,),
+                ),
             ),
-        ),
-        Rydberg.Local(
-            max_targets=20,
-            max_abs_detuning=2 * pi * 4,
-            max_amp=2 * pi * 3,
-            clock_period=4,
-            min_duration=16,
-            max_duration=2**26,
-            mod_bandwidth=16,
-            eom_config=RydbergEOM(
-                limiting_beam=RydbergBeam.RED,
-                max_limiting_amp=40 * 2 * pi,
-                intermediate_detuning=700 * 2 * pi,
-                mod_bandwidth=24,
-                controlled_beams=(RydbergBeam.BLUE,),
+            Rydberg.Local(
+                max_targets=20,
+                max_abs_detuning=max_abs_detuning,
+                max_amp=max_amp,
+                clock_period=4,
+                min_duration=16,
+                max_duration=2**26,
+                mod_bandwidth=16,
+                eom_config=RydbergEOM(
+                    limiting_beam=RydbergBeam.RED,
+                    max_limiting_amp=40 * 2 * pi,
+                    intermediate_detuning=700 * 2 * pi,
+                    mod_bandwidth=24,
+                    controlled_beams=(RydbergBeam.BLUE,),
+                ),
             ),
         ),
-    ),
-)
-
-
-class Device(StrEnum):
-    """Supported types of devices for Pulser backend."""
-
-    IDEALIZED = IdealDevice
-    """Idealized device, least realistic."""
-
-    REALISTIC = RealisticDevice
-    """Device with realistic specs."""
+    )

qadence/backends/pulser/pulses.py

@@ -11,6 +11,7 @@ from pulser.sequence.sequence import Sequence
 from pulser.waveforms import CompositeWaveform, ConstantWaveform, RampWaveform
 
 from qadence import Register
+from qadence.analog import AddressingPattern
 from qadence.blocks import AbstractBlock, CompositeBlock
 from qadence.blocks.analog import (
     AnalogBlock,
@@ -19,6 +20,7 @@ from qadence.blocks.analog import (
     Interaction,
     WaitBlock,
 )
+from qadence.logger import get_logger
 from qadence.operations import RX, RY, RZ, AnalogEntanglement, OpName
 from qadence.parameters import evaluate
 
@@ -26,6 +28,8 @@ from .channels import GLOBAL_CHANNEL, LOCAL_CHANNEL
 from .config import Configuration
 from .waveforms import SquareWaveform
 
+logger = get_logger(__file__)
+
 TVar = Union[Variable, VariableItem]
 
 supported_gates = [
@@ -42,6 +46,53 @@ supported_gates = [
 ]
 
 
+def add_addressing_pattern(
+    sequence: Sequence,
+    pattern: AddressingPattern,
+) -> None:
+    total_duration = sequence.get_duration()
+    n_qubits = len(sequence.register.qubits)
+
+    support = tuple(range(n_qubits))
+
+    amp = pattern.amp
+    det = pattern.det
+    weights_amp = pattern.weights_amp
+    weights_det = pattern.weights_det
+    local_constr_amp = pattern.local_constr_amp
+    local_constr_det = pattern.local_constr_det
+    global_constr_amp = pattern.global_constr_amp
+    global_constr_det = pattern.global_constr_det
+
+    for i in support:
+        # declare separate local channel for each qubit
+        sequence.declare_channel(f"ch_q{i}", "rydberg_local", initial_target=0)
+
+    # add amplitude and detuning patterns
+    for i in support:
+        if weights_amp[i].is_number:  # type: ignore [union-attr]
+            w_amp = evaluate(weights_amp[i], as_torch=True) * local_constr_amp[i]
+        else:
+            raise ValueError(
+                "Pulser backend currently doesn't support parametrized amplitude pattern weights."
+            )
+
+        if weights_det[i].is_number:  # type: ignore [union-attr]
+            w_det = evaluate(weights_det[i], as_torch=True) * local_constr_det[i]
+        else:
+            raise ValueError(
+                "Pulser backend currently doesn't support parametrized detuning pattern weights."
+            )
+
+        omega = global_constr_amp * amp * w_amp
+        detuning = global_constr_det * det * w_det
+        pulse = Pulse.ConstantPulse(
+            duration=total_duration, amplitude=omega, detuning=detuning, phase=0
+        )
+        sequence.target(i, f"ch_q{i}")
+        sequence.add(pulse, f"ch_q{i}", protocol="no-delay")
+
+
 def add_pulses(
     sequence: Sequence,
     block: AbstractBlock,
@@ -58,7 +109,7 @@ def add_pulses(
     if not isinstance(qubit_support[0], int):
         qubit_support = tuple(range(n_qubits))
 
-    if isinstance(block, AnalogBlock) and config.interaction != Interaction.NN:
+    if isinstance(block, AnalogBlock) and qc_register.device_specs.interaction != Interaction.NN:
         raise ValueError(f"Pulser does not support other interactions than '{Interaction.NN}'")
 
     local_channel = sequence.device.channels["rydberg_local"]
@@ -70,6 +121,11 @@ def add_pulses(
 
     # TODO: lets move those to `@singledipatch`ed functions
     if isinstance(block, WaitBlock):
+        if not block.add_pattern:
+            logger.warning(
+                "Found block with `add_pattern = False`. This is not yet supported in the Pulser "
+                "backend. If an addressing pattern is specified, it will be added to all blocks."
+            )
         # wait if its a global wait
         if block.qubit_support.is_global:
             (uuid, duration) = block.parameters.uuid_param("duration")
@@ -85,25 +141,30 @@ def add_pulses(
                 raise ValueError("Trying to wait on qubits outside of support.")
 
     elif isinstance(block, ConstantAnalogRotation):
+        if not block.add_pattern:
+            logger.warning(
+                "Found block with `add_pattern = False`. This is not yet supported in the Pulser "
+                "backend. If an addressing pattern is specified, it will be added to all blocks."
+            )
         ps = block.parameters
-        (a_uuid, alpha) = ps.uuid_param("alpha")
+        (t_uuid, duration) = ps.uuid_param("duration")
         (w_uuid, omega) = ps.uuid_param("omega")
         (p_uuid, phase) = ps.uuid_param("phase")
         (d_uuid, detuning) = ps.uuid_param("delta")
 
-        a = evaluate(alpha) if alpha.is_number else sequence.declare_variable(a_uuid)
+        t = evaluate(duration) if duration.is_number else sequence.declare_variable(t_uuid)
         w = evaluate(omega) if omega.is_number else sequence.declare_variable(w_uuid)
         p = evaluate(phase) if phase.is_number else sequence.declare_variable(p_uuid)
         d = evaluate(detuning) if detuning.is_number else sequence.declare_variable(d_uuid)
 
         # calculate generator eigenvalues
-        block.eigenvalues_generator = block.compute_eigenvalues_generator(qc_register, block)
+        block.eigenvalues_generator = block.compute_eigenvalues_generator(block, qc_register)
 
         if block.qubit_support.is_global:
-            pulse = analog_rot_pulse(a, w, p, d, global_channel, config)
+            pulse = analog_rot_pulse(t, w, p, d, global_channel, config)
             sequence.add(pulse, GLOBAL_CHANNEL, protocol="wait-for-all")
         else:
-            pulse = analog_rot_pulse(a, w, p, d, local_channel, config)
+            pulse = analog_rot_pulse(t, w, p, d, local_channel, config)
             sequence.target(qubit_support, LOCAL_CHANNEL)
             sequence.add(pulse, LOCAL_CHANNEL, protocol="wait-for-all")
 
@@ -136,7 +197,7 @@ def add_pulses(
 
 
 def analog_rot_pulse(
-    alpha: TVar | float,
+    duration: TVar | float,
     omega: TVar | float,
     phase: TVar | float,
     detuning: TVar | float,
@@ -154,12 +215,9 @@ def analog_rot_pulse(
         max_amp = omega
         max_det = detuning
 
-    # get pulse duration in ns
-    duration = 1000 * abs(alpha) / np.sqrt(omega**2 + detuning**2)
-
     # create amplitude waveform
     amp_wf = SquareWaveform.from_duration(
-        duration=duration,  # type: ignore
+        duration=abs(duration),  # type: ignore
         max_amp=max_amp,  # type: ignore[arg-type]
         duration_steps=channel.clock_period,  # type: ignore[attr-defined]
         min_duration=channel.min_duration,
@@ -167,7 +225,7 @@ def analog_rot_pulse(
 
     # create detuning waveform
     det_wf = SquareWaveform.from_duration(
-        duration=duration,  # type: ignore
+        duration=abs(duration),  # type: ignore
         max_amp=max_det,  # type: ignore[arg-type]
         duration_steps=channel.clock_period,  # type: ignore[attr-defined]
         min_duration=channel.min_duration,

qadence/backends/pyqtorch/backend.py

@@ -11,7 +11,6 @@ from torch import Tensor
 from qadence.backend import Backend as BackendInterface
 from qadence.backend import ConvertedCircuit, ConvertedObservable
 from qadence.backends.utils import (
-    infer_batchsize,
     pyqify,
     to_list_of_dicts,
     unpyqify,
@@ -32,7 +31,7 @@ from qadence.transpile import (
     transpile,
 )
 from qadence.types import BackendName, Endianness
-from qadence.utils import int_to_basis
+from qadence.utils import infer_batchsize, int_to_basis
 
 from .config import Configuration, default_passes
 from .convert_ops import convert_block, convert_observable
@@ -80,7 +79,7 @@ class Backend(BackendInterface):
         (native,) = convert_observable(block, n_qubits=n_qubits, config=self.config)
         return ConvertedObservable(native=native, abstract=block, original=observable)
 
-    def run(
+    def _run(
         self,
         circuit: ConvertedCircuit,
         param_values: dict[str, Tensor] = {},

qadence/backends/pyqtorch/config.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Callable
 
-from qadence.analog import add_interaction
+from qadence.analog import add_background_hamiltonian
 from qadence.backend import BackendConfiguration
 from qadence.logger import get_logger
 from qadence.transpile import (
@@ -12,19 +12,28 @@ from qadence.transpile import (
     flatten,
     scale_primitive_blocks_only,
 )
-from qadence.types import AlgoHEvo, Interaction
+from qadence.types import AlgoHEvo
 
 logger = get_logger(__name__)
 
 
 def default_passes(config: Configuration) -> list[Callable]:
-    return [
-        lambda circ: add_interaction(circ, interaction=config.interaction),
-        lambda circ: blockfn_to_circfn(chain_single_qubit_ops)(circ)
-        if config.use_single_qubit_composition
-        else blockfn_to_circfn(flatten)(circ),
-        blockfn_to_circfn(scale_primitive_blocks_only),
-    ]
+    passes: list = []
+
+    # Replaces AnalogBlocks with respective HamEvo in the circuit block tree:
+    passes.append(add_background_hamiltonian)
+
+    if config.use_single_qubit_composition:
+        # Composes chains of single-qubit gates into a single unitary before applying to the state:
+        passes.append(lambda circ: blockfn_to_circfn(chain_single_qubit_ops)(circ))
+    else:
+        # Flattens nested composed blocks:
+        passes.append(lambda circ: blockfn_to_circfn(flatten)(circ))
+
+    # Pushes block scales into the leaves of the block tree:
+    passes.append(blockfn_to_circfn(scale_primitive_blocks_only))
+
+    return passes
 
 
 @dataclass
@@ -44,9 +53,6 @@ class Configuration(BackendConfiguration):
     use_single_qubit_composition: bool = False
     """Composes chains of single qubit gates into a single matmul if possible."""
 
-    interaction: Callable | Interaction | str = Interaction.NN
-    """Digital-analog emulation interaction that is used for `AnalogBlock`s."""
-
     loop_expectation: bool = False
     """When computing batches of expectation values, only allocate one wavefunction.
 

qadence/backends/pyqtorch/convert_ops.py

@@ -29,7 +29,6 @@ from torch.nn import Module
 
 from qadence.backends.utils import (
     finitediff,
-    infer_batchsize,
     pyqify,
     unpyqify,
 )
@@ -49,6 +48,7 @@ from qadence.blocks.block_to_tensor import (
     block_to_diagonal,
     block_to_tensor,
 )
+from qadence.blocks.primitive import ProjectorBlock
 from qadence.operations import (
     OpName,
     U,
@@ -58,6 +58,7 @@ from qadence.operations import (
     three_qubit_gateset,
     two_qubit_gateset,
 )
+from qadence.utils import infer_batchsize
 
 from .config import Configuration
 
@@ -127,7 +128,14 @@ def convert_block(
             # which would be wrong.
             return [pyq.QuantumCircuit(n_qubits, ops)]
     elif isinstance(block, tuple(non_unitary_gateset)):
-        return [getattr(pyq, block.name)(qubit_support[0])]
+        if isinstance(block, ProjectorBlock):
+            projector = getattr(pyq, block.name)
+            if block.name == OpName.N:
+                return [projector(target=qubit_support)]
+            else:
+                return [projector(qubit_support=qubit_support, ket=block.ket, bra=block.bra)]
+        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):
@@ -156,8 +164,8 @@ def convert_block(
     else:
         raise NotImplementedError(
             f"Non supported operation of type {type(block)}. "
-            "In case you are trying to run an `AnalogBlock`, try converting it "
-            "with `add_interaction` first."
+            "In case you are trying to run an `AnalogBlock`, make sure you "
+            "specify the `device_specs` in your `Register` first."
         )
 
 

qadence/backends/pytorch_wrapper.py

@@ -13,7 +13,7 @@ from torch.nn import Module
 from qadence.backend import Backend as QuantumBackend
 from qadence.backend import Converted, ConvertedCircuit, ConvertedObservable
 from qadence.backends.adjoint import AdjointExpectation
-from qadence.backends.utils import infer_batchsize, is_pyq_shape, param_dict, pyqify, validate_state
+from qadence.backends.utils import is_pyq_shape, param_dict, pyqify, validate_state
 from qadence.blocks.abstract import AbstractBlock
 from qadence.blocks.primitive import PrimitiveBlock
 from qadence.blocks.utils import uuid_to_block, uuid_to_eigen
@@ -24,6 +24,7 @@ from qadence.mitigations import Mitigations
 from qadence.ml_tools import promote_to_tensor
 from qadence.noise import Noise
 from qadence.types import DiffMode, Endianness
+from qadence.utils import infer_batchsize
 
 
 class PSRExpectation(Function):

qadence/backends/utils.py

@@ -19,7 +19,7 @@ from torch import (
 )
 from torch import flatten as torchflatten
 
-from qadence.utils import Endianness, int_to_basis
+from qadence.utils import Endianness, int_to_basis, is_qadence_shape
 
 FINITE_DIFF_EPS = 1e-06
 # Dict of NumPy dtype -> torch dtype (when the correspondence exists)
@@ -126,10 +126,6 @@ def is_pyq_shape(state: Tensor, n_qubits: int) -> bool:
     return state.size()[:-1] == [2] * n_qubits  # type: ignore[no-any-return]
 
 
-def is_qadence_shape(state: Tensor, n_qubits: int) -> bool:
-    return state.shape[1] == 2**n_qubits  # type: ignore[no-any-return]
-
-
 def validate_state(state: Tensor, n_qubits: int) -> None:
     """Check if a custom initial state conforms to the qadence or the pyqtorch format."""
     if state.dtype != complex128:
@@ -145,11 +141,6 @@ def validate_state(state: Tensor, n_qubits: int) -> None:
         )
 
 
-def infer_batchsize(param_values: dict[str, Tensor] = None) -> int:
-    """Infer the batch_size through the length of the parameter tensors."""
-    return max([len(tensor) for tensor in param_values.values()]) if param_values else 1
-
-
 # The following functions can be used to compute potentially higher order gradients using pyqtorch's
 # native 'jacobian' methods.
 

qadence/blocks/abstract.py

@@ -5,7 +5,7 @@ from abc import ABC, abstractmethod, abstractproperty
 from dataclasses import dataclass
 from functools import cached_property
 from pathlib import Path
-from typing import ClassVar, Iterable, Tuple, Union, get_args
+from typing import ClassVar, Iterable, Tuple, TypeVar, Union, get_args
 
 import sympy
 import torch
@@ -287,6 +287,7 @@ class AbstractBlock(ABC):
     def __hash__(self) -> int:
         return hash(self._to_json())
 
+    @abstractmethod
     def dagger(self) -> AbstractBlock:
         raise NotImplementedError(
             f"Hermitian adjoint of the Block '{type(self)}' is not implemented yet!"
@@ -333,3 +334,6 @@ class AbstractBlock(ABC):
         elif isinstance(self, PrimitiveBlock):
             return self.name == "I"
         return False
+
+
+TAbstractBlock = TypeVar("TAbstractBlock", bound=AbstractBlock)