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

qadence/blocks/analog.py

@@ -59,8 +59,8 @@ class AnalogBlock(AbstractBlock):
     @property
     def eigenvalues_generator(self) -> torch.Tensor:
         msg = (
-            "Eigenvalues of analog blocks can be computed via "
-            "`add_interaction(register, block).eigenvalues`"
+            "Eigenvalues of for generator of analog blocks can be computed via "
+            "`add_background_hamiltonian(block, register).eigenvalues_generator`. "
         )
         raise NotImplementedError(msg)
 
@@ -68,7 +68,7 @@ class AnalogBlock(AbstractBlock):
     def eigenvalues(self) -> torch.Tensor:
         msg = (
             "Eigenvalues of analog blocks can be computed via "
-            "`add_interaction(register, block).eigenvalues`"
+            "`add_background_hamiltonian(block, register).eigenvalues`. "
         )
         raise NotImplementedError(msg)
 
@@ -83,11 +83,19 @@ class AnalogBlock(AbstractBlock):
         return s
 
     def compute_eigenvalues_generator(
-        self, register: Register, block: AbstractBlock
+        self,
+        block: AbstractBlock,
+        register: Register,
     ) -> torch.Tensor:
-        from qadence import add_interaction
+        # FIXME: Revisit analog blocks eigenvalues
+        from qadence.analog import add_background_hamiltonian
+
+        return add_background_hamiltonian(block, register).eigenvalues_generator  # type: ignore [union-attr]
 
-        return add_interaction(register, block).eigenvalues_generator
+    def dagger(self) -> AbstractBlock:
+        raise NotImplementedError(
+            f"Hermitian adjoint of block type {type(self)} is not implemented yet."
+        )
 
 
 @dataclass(eq=False, repr=False)
@@ -108,8 +116,6 @@ class WaitBlock(AnalogBlock):
     with `nᵢ = (1-Zᵢ)/2`.
 
     To construct this block, use the [`wait`][qadence.operations.wait] function.
-
-    Can be used with `add_interaction`.
     """
 
     _eigenvalues_generator: torch.Tensor | None = None
@@ -117,6 +123,8 @@ class WaitBlock(AnalogBlock):
     parameters: ParamMap = ParamMap(duration=1000.0)  # ns
     qubit_support: QubitSupport = QubitSupport("global")
 
+    add_pattern: bool = True
+
     @property
     def eigenvalues_generator(self) -> torch.Tensor | None:
         return self._eigenvalues_generator
@@ -145,7 +153,6 @@ class ConstantAnalogRotation(AnalogBlock):
       [`AnalogRY`][qadence.operations.AnalogRY],
       [`AnalogRZ`][qadence.operations.AnalogRZ]
 
-    Can be used with `add_interaction`.
     WARNING: do not use `ConstantAnalogRotation` with `alpha` as differentiable parameter - use
     the convenience wrappers mentioned above.
     """
@@ -161,6 +168,8 @@ class ConstantAnalogRotation(AnalogBlock):
     )
     qubit_support: QubitSupport = QubitSupport("global")
 
+    add_pattern: bool = True
+
     @property
     def _block_title(self) -> str:
         a = self.parameters.alpha

qadence/blocks/block_to_tensor.py

@@ -15,8 +15,11 @@ from qadence.blocks import (
     PrimitiveBlock,
     ScaleBlock,
 )
+from qadence.blocks.primitive import ProjectorBlock
 from qadence.blocks.utils import chain, kron, uuid_to_expression
 from qadence.parameters import evaluate, stringify
+
+# from qadence.states import product_state
 from qadence.types import Endianness, TensorType, TNumber
 
 J = torch.tensor(1j)
@@ -463,6 +466,14 @@ def _block_to_tensor_embedded(
         # add missing identities on unused qubits
         mat = _fill_identities(block_mat, block.qubit_support, qubit_support, endianness=endianness)
 
+    elif isinstance(block, ProjectorBlock):
+        from qadence.states import product_state
+
+        bra = product_state(block.bra)
+        ket = product_state(block.ket)
+
+        mat = torch.kron(ket, bra.T)
+
     else:
         raise TypeError(f"Conversion for block type {type(block)} not supported.")
 

qadence/blocks/primitive.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from abc import abstractmethod
+from copy import deepcopy
 from typing import Any, Iterable, Tuple
 
 import sympy
@@ -13,6 +14,7 @@ from qadence.blocks.abstract import AbstractBlock
 from qadence.parameters import (
     Parameter,
     ParamMap,
+    dagger_expression,
     evaluate,
     extract_original_param_entry,
     stringify,
@@ -101,6 +103,9 @@ class PrimitiveBlock(AbstractBlock):
     def n_supports(self) -> int:
         return len(self.qubit_support)
 
+    def dagger(self) -> PrimitiveBlock:
+        return self
+
 
 class ParametricBlock(PrimitiveBlock):
     """Parameterized primitive blocks."""
@@ -200,11 +205,10 @@ class ParametricBlock(PrimitiveBlock):
         target = d["qubit_support"][0]
         return cls(target, params)  # type: ignore[call-arg]
 
-    def dagger(self) -> ParametricBlock:  # type: ignore[override]
+    def dagger(self) -> ParametricBlock:
         exprs = self.parameters.expressions()
-        args = tuple(-extract_original_param_entry(param) for param in exprs)
-        args = args if -1 in self.qubit_support else (*self.qubit_support, *args)
-        return self.__class__(*args)  # type: ignore[arg-type]
+        params = tuple(-extract_original_param_entry(param) for param in exprs)
+        return type(self)(*self.qubit_support, *params)  # type: ignore[arg-type]
 
 
 class ScaleBlock(ParametricBlock):
@@ -304,9 +308,8 @@ class ScaleBlock(ParametricBlock):
             )
 
     def dagger(self) -> ScaleBlock:
-        return self.__class__(
-            self.block, Parameter(-extract_original_param_entry(self.parameters.parameter))
-        )
+        p = list(self.parameters.expressions())[0]
+        return self.__class__(self.block.dagger(), dagger_expression(p))
 
     def _to_dict(self) -> dict:
         return {
@@ -350,13 +353,25 @@ class ControlBlock(PrimitiveBlock):
     """The abstract ControlBlock."""
 
     name = "Control"
+    control: tuple[int, ...]
+    target: tuple[int, ...]
 
     def __init__(self, control: tuple[int, ...], target_block: PrimitiveBlock) -> None:
+        self.control = control
         self.blocks = (target_block,)
+        self.target = target_block.qubit_support
 
         # using tuple expansion because some control operations could
         # have multiple targets, e.g. CSWAP
-        super().__init__((*control, *target_block.qubit_support))  # target_block.qubit_support[0]))
+        super().__init__((*control, *self.target))  # target_block.qubit_support[0]))
+
+    @property
+    def n_controls(self) -> int:
+        return len(self.control)
+
+    @property
+    def n_targets(self) -> int:
+        return len(self.target)
 
     @property
     def _block_title(self) -> str:
@@ -391,16 +406,28 @@ class ControlBlock(PrimitiveBlock):
         target = d["qubit_support"][1]
         return cls(control, target)
 
+    def dagger(self) -> ControlBlock:
+        blk = deepcopy(self)
+        blk.blocks = (self.blocks[0].dagger(),)
+        return blk
+
 
 class ParametricControlBlock(ParametricBlock):
     """The abstract parametrized ControlBlock."""
 
     name = "ParameterizedControl"
+    control: tuple[int, ...] = ()
+    blocks: tuple[ParametricBlock, ...]
 
     def __init__(self, control: tuple[int, ...], target_block: ParametricBlock) -> None:
         self.blocks = (target_block,)
+        self.control = control
         self.parameters = target_block.parameters
-        super().__init__((*control, target_block.qubit_support[0]))
+        super().__init__((*control, *target_block.qubit_support))
+
+    @property
+    def n_controls(self) -> int:
+        return len(self.control)
 
     @property
     def eigenvalues_generator(self) -> torch.Tensor:
@@ -454,3 +481,48 @@ class ParametricControlBlock(ParametricBlock):
 
         s += rf" \[params: {params_str}]"
         return s if self.tag is None else (s + rf" \[tag: {self.tag}]")
+
+    def dagger(self) -> ParametricControlBlock:
+        blk = deepcopy(self)
+        blocks = tuple(b.dagger() for b in blk.blocks)
+        blk.blocks = blocks
+        blk.parameters = blocks[0].parameters
+        return blk
+
+
+class ProjectorBlock(PrimitiveBlock):
+    """The abstract ProjectorBlock."""
+
+    name = "ProjectorBlock"
+
+    def __init__(
+        self,
+        ket: str,
+        bra: str,
+        qubit_support: int | tuple[int, ...],
+    ) -> None:
+        """
+        Arguments:
+
+            ket (str): The ket given as a bitstring.
+            bra (str): The bra given as a bitstring.
+            qubit_support (int | tuple[int]): The qubit_support of the block.
+        """
+        if isinstance(qubit_support, int):
+            qubit_support = (qubit_support,)
+        if len(bra) != len(ket):
+            raise ValueError(
+                "Bra and ket must be bitstrings of same length in the 'Projector' definition."
+            )
+        elif len(bra) != len(qubit_support):
+            raise ValueError("Bra or ket must be of same length as the 'qubit_support'")
+        for wf in [bra, ket]:
+            if not all(int(item) == 0 or int(item) == 1 for item in wf):
+                raise ValueError(
+                    "All qubits must be either in the '0' or '1' state"
+                    " in the 'ProjectorBlock' definition."
+                )
+
+        self.ket = ket
+        self.bra = bra
+        super().__init__(qubit_support)

qadence/constructors/__init__.py

@@ -23,6 +23,7 @@ from .hamiltonians import (
 )
 
 from .rydberg_hea import rydberg_hea, rydberg_hea_layer
+from .rydberg_feature_maps import rydberg_feature_map, analog_feature_map, rydberg_tower_feature_map
 
 from .qft import qft
 
@@ -45,4 +46,7 @@ __all__ = [
     "daqc_transform",
     "rydberg_hea",
     "rydberg_hea_layer",
+    "rydberg_feature_map",
+    "analog_feature_map",
+    "rydberg_tower_feature_map",
 ]

qadence/constructors/feature_maps.py

@@ -6,7 +6,7 @@ from collections.abc import Callable
 from math import isclose, pi
 from typing import Union
 
-from sympy import Function, acos
+from sympy import Basic, Function, acos
 
 from qadence.blocks import AbstractBlock, KronBlock, chain, kron, tag
 from qadence.logger import get_logger
@@ -36,65 +36,12 @@ RS_FUNC_DICT = {
 }
 
 
-def feature_map(
-    n_qubits: int,
-    support: tuple[int, ...] | None = None,
+def fm_parameter(
+    fm_type: BasisSet | type[Function] | str,
     param: Parameter | str = "phi",
-    op: RotationTypes = RX,
-    fm_type: BasisSet | type[Function] | str = BasisSet.FOURIER,
-    reupload_scaling: ReuploadScaling | Callable | str = ReuploadScaling.CONSTANT,
     feature_range: tuple[float, float] | None = None,
     target_range: tuple[float, float] | None = None,
-    multiplier: Parameter | TParameter | None = None,
-) -> KronBlock:
-    """Construct a feature map of a given type.
-
-    Arguments:
-        n_qubits: Number of qubits the feature map covers. Results in `support=range(n_qubits)`.
-        support: Puts one feature-encoding rotation gate on every qubit in `support`. n_qubits in
-            this case specifies the total overall qubits of the circuit, which may be wider than the
-            support itself, but not narrower.
-        param: Parameter of the feature map; you can pass a string or Parameter;
-            it will be set as non-trainable (FeatureParameter) regardless.
-        op: Rotation operation of the feature map; choose from RX, RY, RZ or PHASE.
-        fm_type: Basis set for data encoding; choose from `BasisSet.FOURIER` for Fourier
-            encoding, or `BasisSet.CHEBYSHEV` for Chebyshev polynomials of the first kind.
-        reupload_scaling: how the feature map scales the data that is re-uploaded for each qubit.
-            choose from `ReuploadScaling` enumeration or provide your own function with a single
-            int as input and int or float as output.
-        feature_range: range of data that the input data is assumed to come from.
-        target_range: range of data the data encoder assumes as the natural range. For example,
-            in Chebyshev polynomials it is (-1, 1), while for Fourier it may be chosen as (0, 2*pi).
-        multiplier: overall multiplier; this is useful for reuploading the feature map serially with
-            different scalings; can be a number or parameter/expression.
-
-    Example:
-    ```python exec="on" source="material-block" result="json"
-    from qadence import feature_map, BasisSet, ReuploadScaling
-
-    fm = feature_map(3, fm_type=BasisSet.FOURIER)
-    print(f"{fm = }")
-
-    fm = feature_map(3, fm_type=BasisSet.CHEBYSHEV)
-    print(f"{fm = }")
-
-    fm = feature_map(3, fm_type=BasisSet.FOURIER, reupload_scaling = ReuploadScaling.TOWER)
-    print(f"{fm = }")
-    ```
-    """
-
-    # Process input
-    if support is None:
-        support = tuple(range(n_qubits))
-    elif len(support) != n_qubits:
-        raise ValueError("Wrong qubit support supplied")
-
-    if op not in ROTATIONS:
-        raise ValueError(
-            f"Operation {op} not supported. "
-            f"Please provide one from {[rot.__name__ for rot in ROTATIONS]}."
-        )
-
+) -> Parameter | Basic:
     # Backwards compatibility
     if fm_type in ("fourier", "chebyshev", "tower"):
         logger.warning(
@@ -108,7 +55,6 @@ def feature_map(
             fm_type = BasisSet.CHEBYSHEV
         elif fm_type == "tower":
             fm_type = BasisSet.CHEBYSHEV
-            reupload_scaling = ReuploadScaling.TOWER
 
     if isinstance(param, Parameter):
         fparam = param
@@ -144,8 +90,12 @@ def feature_map(
             "the given feature parameter with."
         )
 
-    basis_tag = fm_type.value if isinstance(fm_type, BasisSet) else str(fm_type)
+    return transformed_feature
+
 
+def fm_reupload_scaling_fn(
+    reupload_scaling: ReuploadScaling | Callable | str = ReuploadScaling.CONSTANT,
+) -> tuple[Callable, str]:
     # Set reupload scaling function
     if callable(reupload_scaling):
         rs_func = reupload_scaling
@@ -163,8 +113,82 @@ def feature_map(
         else:
             rs_tag = reupload_scaling
 
+    return rs_func, rs_tag
+
+
+def feature_map(
+    n_qubits: int,
+    support: tuple[int, ...] | None = None,
+    param: Parameter | str = "phi",
+    op: RotationTypes = RX,
+    fm_type: BasisSet | type[Function] | str = BasisSet.FOURIER,
+    reupload_scaling: ReuploadScaling | Callable | str = ReuploadScaling.CONSTANT,
+    feature_range: tuple[float, float] | None = None,
+    target_range: tuple[float, float] | None = None,
+    multiplier: Parameter | TParameter | None = None,
+) -> KronBlock:
+    """Construct a feature map of a given type.
+
+    Arguments:
+        n_qubits: Number of qubits the feature map covers. Results in `support=range(n_qubits)`.
+        support: Puts one feature-encoding rotation gate on every qubit in `support`. n_qubits in
+            this case specifies the total overall qubits of the circuit, which may be wider than the
+            support itself, but not narrower.
+        param: Parameter of the feature map; you can pass a string or Parameter;
+            it will be set as non-trainable (FeatureParameter) regardless.
+        op: Rotation operation of the feature map; choose from RX, RY, RZ or PHASE.
+        fm_type: Basis set for data encoding; choose from `BasisSet.FOURIER` for Fourier
+            encoding, or `BasisSet.CHEBYSHEV` for Chebyshev polynomials of the first kind.
+        reupload_scaling: how the feature map scales the data that is re-uploaded for each qubit.
+            choose from `ReuploadScaling` enumeration or provide your own function with a single
+            int as input and int or float as output.
+        feature_range: range of data that the input data is assumed to come from.
+        target_range: range of data the data encoder assumes as the natural range. For example,
+            in Chebyshev polynomials it is (-1, 1), while for Fourier it may be chosen as (0, 2*pi).
+        multiplier: overall multiplier; this is useful for reuploading the feature map serially with
+            different scalings; can be a number or parameter/expression.
+
+    Example:
+    ```python exec="on" source="material-block" result="json"
+    from qadence import feature_map, BasisSet, ReuploadScaling
+
+    fm = feature_map(3, fm_type=BasisSet.FOURIER)
+    print(f"{fm = }")
+
+    fm = feature_map(3, fm_type=BasisSet.CHEBYSHEV)
+    print(f"{fm = }")
+
+    fm = feature_map(3, fm_type=BasisSet.FOURIER, reupload_scaling = ReuploadScaling.TOWER)
+    print(f"{fm = }")
+    ```
+    """
+
+    # Process input
+    if support is None:
+        support = tuple(range(n_qubits))
+    elif len(support) != n_qubits:
+        raise ValueError("Wrong qubit support supplied")
+
+    if op not in ROTATIONS:
+        raise ValueError(
+            f"Operation {op} not supported. "
+            f"Please provide one from {[rot.__name__ for rot in ROTATIONS]}."
+        )
+
+    transformed_feature = fm_parameter(
+        fm_type, param, feature_range=feature_range, target_range=target_range
+    )
+
+    # Backwards compatibility
+    if fm_type == "tower":
+        logger.warning("Forcing reupload scaling strategy to TOWER")
+        reupload_scaling = ReuploadScaling.TOWER
+
+    basis_tag = fm_type.value if isinstance(fm_type, BasisSet) else str(fm_type)
+    rs_func, rs_tag = fm_reupload_scaling_fn(reupload_scaling)
+
     # Set overall multiplier
-    multiplier = 1 if multiplier is None else multiplier
+    multiplier = 1 if multiplier is None else Parameter(multiplier)
 
     # Build feature map
     op_list = []

qadence/constructors/hamiltonians.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
-import warnings
-from typing import List, Tuple, Type, Union
+from typing import List, Type, Union
 
 import numpy as np
 from torch import Tensor, double, ones, rand
@@ -57,8 +56,7 @@ def hamiltonian_factory(
     interaction_strength: TArray | str | None = None,
     detuning_strength: TArray | str | None = None,
     random_strength: bool = False,
-    force_update: bool = False,
-    use_complete_graph: bool = False,
+    use_all_node_pairs: bool = False,
 ) -> AbstractBlock:
     """
     General Hamiltonian creation function.
@@ -80,9 +78,8 @@ def hamiltonian_factory(
             Alternatively, some string "x" can be passed, which will create a parameterized
             detuning for each qubit, each labelled as `"x_i"`.
         random_strength: set random interaction and detuning strengths between -1 and 1.
-        force_update: force override register detuning and interaction strengths.
-        use_complete_graph: computes an interaction for every edge in a complete graph,
-            independent of the edges in the register. Useful for defining Hamiltonians
+        use_all_node_pairs: computes an interaction term for every pair of nodes in the graph,
+            independent of the edge topology in the register. Useful for defining Hamiltonians
             where the interaction strength decays with the distance.
 
     Examples:
@@ -121,12 +118,9 @@ def hamiltonian_factory(
     register = Register(register) if isinstance(register, int) else register
 
     # Get interaction function
-    try:
-        int_fn = INTERACTION_DICT[interaction]  # type: ignore [index]
-    except (KeyError, ValueError) as error:
-        if interaction is None:
-            pass
-        else:
+    if interaction is not None:
+        int_fn = INTERACTION_DICT.get(interaction, None)
+        if int_fn is None:
             raise KeyError(f"Interaction {interaction} not supported.")
 
     # Check single-qubit detuning
@@ -134,37 +128,27 @@ def hamiltonian_factory(
         raise TypeError(f"Detuning of type {type(detuning)} not supported.")
 
     # Pre-process detuning and interaction strengths and update register
-    has_detuning_strength, detuning_strength = _preprocess_strengths(
-        register, detuning_strength, "nodes", force_update, random_strength
+    detuning_strength_array = _preprocess_strengths(
+        register, detuning_strength, "nodes", random_strength
     )
 
-    edge_str = "all_edges" if use_complete_graph else "edges"
-    has_interaction_strength, interaction_strength = _preprocess_strengths(
-        register, interaction_strength, edge_str, force_update, random_strength
+    edge_str = "all_node_pairs" if use_all_node_pairs else "edges"
+    interaction_strength_array = _preprocess_strengths(
+        register, interaction_strength, edge_str, random_strength
     )
 
-    if (not has_detuning_strength) or force_update:
-        register = _update_detuning_strength(register, detuning_strength)
-
-    if (not has_interaction_strength) or force_update:
-        register = _update_interaction_strength(register, interaction_strength, use_complete_graph)
-
     # Create single-qubit detunings:
     single_qubit_terms: List[AbstractBlock] = []
     if detuning is not None:
-        for node in register.nodes:
-            block_sq = detuning(node)  # type: ignore [operator]
-            strength_sq = register.nodes[node]["strength"]
-            single_qubit_terms.append(strength_sq * block_sq)
+        for strength, node in zip(detuning_strength_array, register.nodes):
+            single_qubit_terms.append(strength * detuning(node))
 
     # Create two-qubit interactions:
     two_qubit_terms: List[AbstractBlock] = []
-    edge_data = register.all_edges if use_complete_graph else register.edges
-    if interaction is not None:
-        for edge in edge_data:
-            block_tq = int_fn(*edge)  # type: ignore [operator]
-            strength_tq = edge_data[edge]["strength"]
-            two_qubit_terms.append(strength_tq * block_tq)
+    edge_data = register.all_node_pairs if use_all_node_pairs else register.edges
+    if interaction is not None and int_fn is not None:
+        for strength, edge in zip(interaction_strength_array, edge_data):
+            two_qubit_terms.append(strength * int_fn(*edge))
 
     return add(*single_qubit_terms, *two_qubit_terms)
 
@@ -173,22 +157,13 @@ def _preprocess_strengths(
     register: Register,
     strength: TArray | str | None,
     nodes_or_edges: str,
-    force_update: bool,
     random_strength: bool,
-) -> Tuple[bool, Union[TArray | str]]:
+) -> Tensor | list:
     data = getattr(register, nodes_or_edges)
 
     # Useful for error messages:
     strength_target = "detuning" if nodes_or_edges == "nodes" else "interaction"
 
-    # First we check if strength values already exist in the register
-    has_strength = any(["strength" in data[i] for i in data])
-    if has_strength and not force_update:
-        if strength is not None:
-            logger.warning(
-                "Register already includes " + strength_target + " strengths. "
-                "Skipping update. Use `force_update = True` to override them."
-            )
     # Next we process the strength given in the input arguments
     if strength is None:
         if random_strength:
@@ -202,8 +177,11 @@ def _preprocess_strengths(
             message = "Array of " + strength_target + " strengths has incorrect size."
             raise ValueError(message)
     elif isinstance(strength, str):
-        # Any string will be used as a prefix to variational parameters
-        pass
+        prefix = strength
+        if nodes_or_edges == "nodes":
+            strength = [prefix + f"_{node}" for node in data]
+        if nodes_or_edges in ["edges", "all_node_pairs"]:
+            strength = [prefix + f"_{edge[0]}{edge[1]}" for edge in data]
     else:
         # If not of the accepted types ARRAYS or str, we error out
         raise TypeError(
@@ -212,69 +190,27 @@ def _preprocess_strengths(
             "parameterized " + strength_target + "s."
         )
 
-    return has_strength, strength
-
-
-def _update_detuning_strength(register: Register, detuning_strength: TArray | str) -> Register:
-    for node in register.nodes:
-        if isinstance(detuning_strength, str):
-            register.nodes[node]["strength"] = detuning_strength + f"_{node}"
-        elif isinstance(detuning_strength, ARRAYS):
-            register.nodes[node]["strength"] = detuning_strength[node]
-    return register
-
-
-def _update_interaction_strength(
-    register: Register, interaction_strength: TArray | str, use_complete_graph: bool
-) -> Register:
-    edge_data = register.all_edges if use_complete_graph else register.edges
-    for idx, edge in enumerate(edge_data):
-        if isinstance(interaction_strength, str):
-            edge_data[edge]["strength"] = interaction_strength + f"_{edge[0]}{edge[1]}"
-        elif isinstance(interaction_strength, ARRAYS):
-            edge_data[edge]["strength"] = interaction_strength[idx]
-    return register
-
+    return strength
 
-# FIXME: Previous hamiltonian / observable functions, now refactored, to be deprecated:
 
-DEPRECATION_MESSAGE = "This function will be removed in the future. "
+def total_magnetization(n_qubits: int, z_terms: np.ndarray | list | None = None) -> AbstractBlock:
+    return hamiltonian_factory(n_qubits, detuning=Z, detuning_strength=z_terms)
 
 
 def single_z(qubit: int = 0, z_coefficient: float = 1.0) -> AbstractBlock:
-    message = DEPRECATION_MESSAGE + "Please use `z_coefficient * Z(qubit)` directly."
-    warnings.warn(message, FutureWarning)
     return Z(qubit) * z_coefficient
 
 
-def total_magnetization(n_qubits: int, z_terms: np.ndarray | list | None = None) -> AbstractBlock:
-    message = (
-        DEPRECATION_MESSAGE
-        + "Please use `hamiltonian_factory(n_qubits, detuning=Z, node_coeff=z_terms)`."
-    )
-    warnings.warn(message, FutureWarning)
-    return hamiltonian_factory(n_qubits, detuning=Z, detuning_strength=z_terms)
-
-
 def zz_hamiltonian(
     n_qubits: int,
     z_terms: np.ndarray | None = None,
     zz_terms: np.ndarray | None = None,
 ) -> AbstractBlock:
-    message = (
-        DEPRECATION_MESSAGE
-        + """
-Please use `hamiltonian_factory(n_qubits, Interaction.ZZ, Z, interaction_strength, z_terms)`. \
-Note that the argument `zz_terms` in this function is a 2D array of size `(n_qubits, n_qubits)`, \
-while `interaction_strength` is expected as a 1D array of size `0.5 * n_qubits * (n_qubits - 1)`."""
-    )
-    warnings.warn(message, FutureWarning)
     if zz_terms is not None:
         register = Register(n_qubits)
         interaction_strength = [zz_terms[edge[0], edge[1]] for edge in register.edges]
     else:
         interaction_strength = None
-
     return hamiltonian_factory(n_qubits, Interaction.ZZ, Z, interaction_strength, z_terms)
 
 
@@ -284,13 +220,6 @@ def ising_hamiltonian(
     z_terms: np.ndarray | None = None,
     zz_terms: np.ndarray | None = None,
 ) -> AbstractBlock:
-    message = (
-        DEPRECATION_MESSAGE
-        + """
-You can build a general transverse field ising model with the `hamiltonian_factory` function. \
-Check the hamiltonian construction tutorial in the documentation for more information."""
-    )
-    warnings.warn(message, FutureWarning)
     zz_ham = zz_hamiltonian(n_qubits, z_terms=z_terms, zz_terms=zz_terms)
     x_ham = hamiltonian_factory(n_qubits, detuning=X, detuning_strength=x_terms)
     return zz_ham + x_ham