qadence 1.11.0__tar.gz → 1.11.2__tar.gz

{qadence-1.11.0 → qadence-1.11.2}/.github/workflows/test_fast.yml

@@ -22,7 +22,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.9", "3.10", "3.11"]
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"]
     steps:
     - name: Checkout Qadence
       uses: actions/checkout@v4

qadence-1.11.2/LICENSE

@@ -0,0 +1,13 @@
+PASQAL OPEN-SOURCE SOFTWARE LICENSE AGREEMENT (MIT-derived)
+
+The author of the License is:
+  Pasqal, a Société par Actions Simplifiée (Simplified Joint Stock Company) registered under number 849 441 522 at the Registre du commerce et des sociétés (Trade and Companies Register) of Evry – France, headquartered at 24 rue Émile Baudot – 91120 – Palaiseau – France, duly represented by its Président, M. Georges-Olivier REYMOND, Hereafter referred to as « the Licensor »
+
+- Permission is hereby granted, free of charge, to any person obtaining a copy of this software (the “Licensee”) and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. The Software is “as is”, without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and non-infringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise arising from, out of or in connection with the Software or the use or other dealings in the Software.
+
+- If use of the Software leads to the necessary use of any patent of the Licensor and/or any of its Affiliates (defined as a company owned or controlled by the Licensor), the Licensee is granted a royalty-free license, in any country where such patent is in force, to use the object of such patent; or use the process covered by such patent,
+
+- Such a patent license is granted for internal research or academic use of the Licensee's, which includes use by employees and students of the Licensee, acting on behalf of the Licensee, for research purposes only.
+
+- The License is governed by the laws of France. Any dispute relating to the License, notably its execution, performance and/or termination shall be brought to, heard and tried by the Tribunal Judiciaire de Paris, regardless of the rules of jurisdiction in the matter.

{qadence-1.11.0 → qadence-1.11.2}/PKG-INFO

@@ -1,17 +1,18 @@
 Metadata-Version: 2.4
 Name: qadence
-Version: 1.11.0
+Version: 1.11.2
 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>, Pim Venderbosch <pim.venderbosch@pasqal.com>, Manu Lahariya <manu.lahariya@pasqal.com>
-License: Apache 2.0
+License: PASQAL OPEN-SOURCE SOFTWARE LICENSE (MIT-derived)
 License-File: LICENSE
-Classifier: License :: OSI Approved :: Apache Software License
+Classifier: License :: Other/Proprietary License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.9
@@ -23,11 +24,11 @@ Requires-Dist: nevergrad
 Requires-Dist: numpy
 Requires-Dist: openfermion
 Requires-Dist: pasqal-cloud
-Requires-Dist: pyqtorch==1.7.1
+Requires-Dist: pyqtorch==1.7.5
 Requires-Dist: pyyaml
 Requires-Dist: rich
 Requires-Dist: scipy
-Requires-Dist: sympy<1.13
+Requires-Dist: sympy<1.13.4
 Requires-Dist: sympytorch>=0.1.2
 Requires-Dist: tensorboard>=2.12.0
 Requires-Dist: torch
@@ -43,7 +44,7 @@ Requires-Dist: nvidia-pyindex; extra == 'dlprof'
 Provides-Extra: horqrux
 Requires-Dist: einops; extra == 'horqrux'
 Requires-Dist: flax; extra == 'horqrux'
-Requires-Dist: horqrux==0.7.0; extra == 'horqrux'
+Requires-Dist: horqrux==0.8.0; extra == 'horqrux'
 Requires-Dist: jax; extra == 'horqrux'
 Requires-Dist: jaxopt; extra == 'horqrux'
 Requires-Dist: optax; extra == 'horqrux'
@@ -55,9 +56,9 @@ Requires-Dist: mlflow; extra == 'mlflow'
 Provides-Extra: protocols
 Requires-Dist: qadence-protocols; extra == 'protocols'
 Provides-Extra: pulser
-Requires-Dist: pasqal-cloud==0.13.0; extra == 'pulser'
-Requires-Dist: pulser-core==1.3.0; extra == 'pulser'
-Requires-Dist: pulser-simulation==1.3.0; extra == 'pulser'
+Requires-Dist: pasqal-cloud==0.20.2; extra == 'pulser'
+Requires-Dist: pulser-core==1.4.0; extra == 'pulser'
+Requires-Dist: pulser-simulation==1.4.0; extra == 'pulser'
 Provides-Extra: visualization
 Requires-Dist: graphviz; extra == 'visualization'
 Description-Content-Type: text/markdown
@@ -84,7 +85,7 @@ programs** with tunable qubit interactions and arbitrary register topologies rea
 [![Tests](https://github.com/pasqal-io/qadence/actions/workflows/test_fast.yml/badge.svg)](https://github.com/pasqal-io/qadence/actions/workflows/test_fast.yml)
 [![Documentation](https://github.com/pasqal-io/qadence/actions/workflows/build_docs.yml/badge.svg)](https://pasqal-io.github.io/qadence/latest)
 [![Pypi](https://badge.fury.io/py/qadence.svg)](https://pypi.org/project/qadence/)
-[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+[![License](https://img.shields.io/badge/License-MIT--derived-yellow.svg)](https://opensource.org/licenses/MIT)
 ![Coverage](https://img.shields.io/codecov/c/github/pasqal-io/qadence?style=flat-square)
 
 
@@ -215,4 +216,4 @@ doi = {10.1109/MS.2025.3536607}
 ```
 
 ## License
-Qadence is a free and open source software package, released under the Apache License, Version 2.0.
+Qadence is a free and open source software package, released under the PASQAL OPEN-SOURCE SOFTWARE LICENSE (MIT-derived).

{qadence-1.11.0 → qadence-1.11.2}/README.md

@@ -20,7 +20,7 @@ programs** with tunable qubit interactions and arbitrary register topologies rea
 [![Tests](https://github.com/pasqal-io/qadence/actions/workflows/test_fast.yml/badge.svg)](https://github.com/pasqal-io/qadence/actions/workflows/test_fast.yml)
 [![Documentation](https://github.com/pasqal-io/qadence/actions/workflows/build_docs.yml/badge.svg)](https://pasqal-io.github.io/qadence/latest)
 [![Pypi](https://badge.fury.io/py/qadence.svg)](https://pypi.org/project/qadence/)
-[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+[![License](https://img.shields.io/badge/License-MIT--derived-yellow.svg)](https://opensource.org/licenses/MIT)
 ![Coverage](https://img.shields.io/codecov/c/github/pasqal-io/qadence?style=flat-square)
 
 
@@ -151,4 +151,4 @@ doi = {10.1109/MS.2025.3536607}
 ```
 
 ## License
-Qadence is a free and open source software package, released under the Apache License, Version 2.0.
+Qadence is a free and open source software package, released under the PASQAL OPEN-SOURCE SOFTWARE LICENSE (MIT-derived).

{qadence-1.11.0 → qadence-1.11.2}/mkdocs.yml

@@ -45,6 +45,7 @@ nav:
       - tutorials/qml/index.md
       - Configuring a QNN: tutorials/qml/config_qnn.md
       - Quantum circuit learning: tutorials/qml/qcl.md
+      - Classification with QNN: tutorials/qml/classification.md
       - Solving MaxCut with QAOA: tutorials/qml/qaoa.md
       - Solving a 1D ODE: tutorials/qml/dqc_1d.md
 

{qadence-1.11.0 → qadence-1.11.2}/pyproject.toml

@@ -27,16 +27,17 @@ authors = [
     { name = "Manu Lahariya", email = "manu.lahariya@pasqal.com" },
 ]
 requires-python = ">=3.9"
-license = { text = "Apache 2.0" }
-version = "1.11.0"
+license = { text = "PASQAL OPEN-SOURCE SOFTWARE LICENSE (MIT-derived)" }
+version = "1.11.2"
 classifiers = [
-    "License :: OSI Approved :: Apache Software License",
+    "License :: Other/Proprietary License",
     "Programming Language :: Python",
     "Programming Language :: Python :: 3",
     "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: Implementation :: CPython",
     "Programming Language :: Python :: Implementation :: PyPy",
 ]
@@ -44,7 +45,7 @@ dependencies = [
     "numpy",
     "torch",
     "openfermion",
-    "sympy<1.13",
+    "sympy<1.13.4",
     "sympytorch>=0.1.2",
     "rich",
     "tensorboard>=2.12.0",
@@ -52,7 +53,7 @@ dependencies = [
     "jsonschema",
     "nevergrad",
     "scipy",
-    "pyqtorch==1.7.1",
+    "pyqtorch==1.7.5",
     "pyyaml",
     "matplotlib",
     "Arpeggio==2.0.2",
@@ -65,9 +66,9 @@ allow-ambiguous-features = true
 
 [project.optional-dependencies]
 pulser = [
-    "pulser-core==1.3.0",
-    "pulser-simulation==1.3.0",
-    "pasqal-cloud==0.13.0",
+    "pulser-core==1.4.0",
+    "pulser-simulation==1.4.0",
+    "pasqal-cloud==0.20.2",
 ]
 visualization = [
     "graphviz",
@@ -76,7 +77,7 @@ visualization = [
     # "scour",
 ]
 horqrux = [
-    "horqrux==0.7.0",
+    "horqrux==0.8.0",
     "jax",
     "flax",
     "optax",

{qadence-1.11.0 → qadence-1.11.2}/qadence/backend.py

@@ -54,11 +54,18 @@ class BackendConfiguration:
         conf_msg = ""
         for _field in fields(self):
             if not _field.name.startswith("_"):
-                conf_msg += (
-                    f"Name: {_field.name} - Type: {_field.type} - Default value: {_field.default}\n"
-                )
+                conf_msg += f"Name: {_field.name} - Type: {_field.type} - Current value: {getattr(self, _field.name)} - Default value: {_field.default}\n"
         return conf_msg
 
+    def change_config(self, new_config: dict) -> None:
+        """Change configuration with the input."""
+
+        for key, value in new_config.items():
+            if hasattr(self, key):
+                setattr(self, key, value)
+            else:
+                raise ValueError(f"Warning: '{key}' is not a valid configuration attribute.")
+
     @classmethod
     def from_dict(cls, values: dict) -> BackendConfiguration:
         field_names = {field.name for field in fields(cls)}

qadence-1.11.2/qadence/backends/agpsr_utils.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+from functools import lru_cache
+from typing import Callable
+
+import numpy as np
+import torch
+from scipy.optimize import minimize
+from torch import Tensor
+
+
+def variance(shifts: Tensor, spectral_gaps: Tensor) -> Tensor:
+    """Calculate the exact variance of deirivative estimation using aGPSR.
+
+    Args:
+        shifts (Tensor): shifts to apply for each spectral gap
+        spectral_gaps (Tensor): tensor containing spectral gap values
+
+    Returns:
+        Tensor: variance tensor
+    """
+
+    # calculate inverse of M (see: https://arxiv.org/pdf/2108.01218.pdf on p. 4 for definitions)
+    M = 4 * torch.sin(torch.outer(torch.as_tensor(shifts), spectral_gaps) / 2)
+    try:
+        # calculate the variance of derivative estimation by solving a linear equation system
+        a = torch.linalg.solve(M, spectral_gaps.reshape(-1, 1))
+        var = 2 * torch.matmul(a.T, a)
+    except RuntimeError:  # matrix M is singulkar
+        # fallback method of variance calculation using inverse matrix
+        M_inv = torch.linalg.pinv(M)
+        a = torch.matmul(spectral_gaps.reshape(1, -1), M_inv)
+        var = 2 * torch.matmul(a, a.T)
+
+    return var
+
+
+@lru_cache
+def calculate_optimal_shifts(
+    n_eqs: int,
+    spectral_gaps: Tensor,
+    lb: float,
+    ub: float,
+) -> Tensor:
+    """Calculates optimal shift values for GPSR algorithm.
+
+    Args:
+        n_eqs (int): number of equations in linear equation system for derivative estimation
+        spectral_gaps (Tensor): tensor containing spectral gap values
+        lb (float): lower bound of optimal shift value search interval
+        ub (float): upper bound of optimal shift value search interval
+
+    Returns:
+        Tensor: optimal shift values
+    """
+    if not (lb and ub):
+        raise ValueError("Both lower and upper bounds of optimization interval must be given.")
+
+    constraints = []
+
+    # specify solution bound constraints
+    for i in range(n_eqs):
+
+        def fn_lb(x, i=i):  # type: ignore [no-untyped-def]
+            return x[i] - lb
+
+        def fn_ub(x, i=i):  # type: ignore [no-untyped-def]
+            return ub - x[i]
+
+        constraints.append({"type": "ineq", "fun": fn_lb})
+        constraints.append({"type": "ineq", "fun": fn_ub})
+
+    # specify constraints for solutions to be unique
+    for i in range(n_eqs - 1, 0, -1):
+        for j in range(i):
+
+            def fn(x, i=i, j=j):  # type: ignore [no-untyped-def]
+                return np.abs(x[i] - x[j]) - 0.02
+
+            constraints.append({"type": "ineq", "fun": fn})
+
+    init_guess = torch.linspace(lb, ub, n_eqs)
+
+    def minimize_variance(
+        var_fn: Callable[[Tensor, Tensor], Tensor],
+    ) -> Tensor:
+        res = minimize(
+            fun=var_fn,
+            x0=init_guess,
+            args=(spectral_gaps,),
+            method="COBYLA",
+            constraints=constraints,
+        )
+        return torch.as_tensor(res.x)
+
+    return minimize_variance(variance)

{qadence-1.11.0 → qadence-1.11.2}/qadence/backends/api.py

@@ -50,7 +50,14 @@ def backend_factory(
         # Wrap the quantum Backend in a DifferentiableBackend if a diff_mode is passed.
         if diff_mode is not None:
             diff_backend_cls = import_engine(backend_inst.engine)
-            backend_inst = diff_backend_cls(backend=backend_inst, diff_mode=DiffMode(diff_mode))  # type: ignore[operator]
+            psr_args = {
+                "n_eqs": configuration.n_eqs,  # type: ignore [attr-defined]
+                "shift_prefac": configuration.shift_prefac,  # type: ignore [attr-defined]
+                "gap_step": configuration.gap_step,  # type: ignore [attr-defined]
+                "lb": configuration.lb,  # type: ignore [attr-defined]
+                "ub": configuration.ub,  # type: ignore [attr-defined]
+            }
+            backend_inst = diff_backend_cls(backend=backend_inst, diff_mode=DiffMode(diff_mode), **psr_args)  # type: ignore[operator]
         return backend_inst
     except (BackendNotFoundError, EngineNotFoundError, ConfigNotFoundError) as e:
         logger.error(e.msg)

{qadence-1.11.0 → qadence-1.11.2}/qadence/backends/horqrux/backend.py

@@ -7,7 +7,7 @@ from typing import Any
 
 import jax
 import jax.numpy as jnp
-from horqrux.utils import zero_state
+from horqrux.utils.operator_utils import zero_state
 from jax.typing import ArrayLike
 
 from qadence.backend import Backend as BackendInterface
@@ -27,7 +27,8 @@ from qadence.types import BackendName, Endianness, Engine, ParamDictType
 from qadence.utils import int_to_basis
 
 from .config import Configuration, default_passes
-from .convert_ops import HorqruxCircuit, convert_block, convert_observable
+from .convert_ops import convert_block, convert_observable
+from horqrux.circuit import QuantumCircuit as HorqruxCircuit
 
 logger = getLogger(__name__)
 
@@ -58,7 +59,7 @@ class Backend(BackendInterface):
             circuit = transpile(*passes)(circuit)
         ops = convert_block(circuit.block, n_qubits=circuit.n_qubits, config=self.config)
         return ConvertedCircuit(
-            native=HorqruxCircuit(ops), abstract=circuit, original=original_circ
+            native=HorqruxCircuit(circuit.n_qubits, ops), abstract=circuit, original=original_circ
         )
 
     def observable(self, observable: AbstractBlock, n_qubits: int) -> ConvertedObservable:
@@ -97,7 +98,7 @@ class Backend(BackendInterface):
             state = zero_state(n_qubits)
         else:
             state = horqify(state) if horqify_state else state
-        state = circuit.native.forward(state, param_values)
+        state = circuit.native(state, param_values)
         if endianness != self.native_endianness:
             state = jnp.reshape(state, (1, 2**n_qubits))  # batch_size is always 1
             ls = list(range(2**n_qubits))
@@ -141,7 +142,7 @@ class Backend(BackendInterface):
             out_state = self.run(
                 circuit, params, state, endianness, horqify_state=True, unhorqify_state=False
             )
-            return jnp.array([o.native.forward(out_state, params) for o in observable])
+            return jnp.array([o.native(out_state, params) for o in observable])
 
         if batch_size > 1:  # We vmap for batch_size > 1
             expvals = jax.vmap(_expectation, in_axes=({k: 0 for k in param_values.keys()},))(

{qadence-1.11.0 → qadence-1.11.2}/qadence/backends/horqrux/config.py

@@ -32,4 +32,20 @@ def default_passes(config: Configuration) -> list[Callable]:
 
 @dataclass
 class Configuration(BackendConfiguration):
-    pass
+    n_eqs: int | None = None
+    """Number of equations to use in aGPSR calculations."""
+
+    shift_prefac: float = 0.5
+    """Prefactor governing the magnitude of parameter shift values.
+
+    Select smaller value if spectral gaps are large.
+    """
+
+    gap_step: float = 1.0
+    """Step between generated pseudo-gaps when using aGPSR algorithm."""
+
+    lb: float | None = None
+    """Lower bound of optimal shift value search interval."""
+
+    ub: float | None = None
+    """Upper bound of optimal shift value search interval."""

{qadence-1.11.0 → qadence-1.11.2}/qadence/backends/horqrux/convert_ops.py

@@ -8,11 +8,15 @@ from typing import Any, Callable, Dict
 
 import jax.numpy as jnp
 from horqrux.analog import _HamiltonianEvolution as NativeHorqHEvo
-from horqrux.apply import apply_gate
-from horqrux.parametric import RX, RY, RZ
-from horqrux.primitive import NOT, SWAP, H, I, X, Y, Z
-from horqrux.primitive import Primitive as Gate
-from horqrux.utils import ControlQubits, TargetQubits, inner
+from horqrux.apply import apply_gates
+from horqrux.primitives.parametric import RX, RY, RZ
+from horqrux.primitives.primitive import NOT, SWAP, H, I, X, Y, Z
+from horqrux.primitives.primitive import Primitive as Gate
+from horqrux.composite.sequence import OpSequence as HorqruxSequence
+from horqrux.composite.compose import Scale as HorqScaleGate
+from horqrux.composite.compose import Add as HorqAddGate
+from horqrux.composite.compose import Observable as HorqruxObservable
+from horqrux.utils.operator_utils import ControlQubits, TargetQubits
 from jax import Array
 from jax.scipy.linalg import expm
 from jax.tree_util import register_pytree_node_class
@@ -36,6 +40,7 @@ from qadence.operations import (
     MCRY,
     MCRZ,
     MCZ,
+    CZ,
 )
 from qadence.operations import SWAP as QDSWAP
 from qadence.types import OpName, ParamDictType
@@ -53,6 +58,7 @@ ops_map: Dict[str, Callable] = {
     OpName.CRX: RX,
     OpName.CRY: RY,
     OpName.CRZ: RZ,
+    OpName.CZ: Z,
     OpName.CNOT: NOT,
     OpName.I: I,
     OpName.SWAP: SWAP,
@@ -61,37 +67,6 @@ ops_map: Dict[str, Callable] = {
 supported_gates = list(set(list(ops_map.keys())))
 
 
-@register_pytree_node_class
-@dataclass
-class HorqruxCircuit:
-    operators: list[Gate] = field(default_factory=list)
-
-    def tree_flatten(self) -> tuple[tuple[list[Any]], tuple[()]]:
-        children = (self.operators,)
-        aux_data = ()
-        return (children, aux_data)
-
-    @classmethod
-    def tree_unflatten(cls, aux_data: Any, children: Any) -> Any:
-        return cls(*children, *aux_data)
-
-    def _forward(self, state: Array, values: ParamDictType) -> Array:
-        return reduce(lambda state, gate: gate.forward(state, values), self.operators, state)
-
-    def forward(self, state: Array, values: ParamDictType) -> Array:
-        return self._forward(state, values)
-
-
-@register_pytree_node_class
-@dataclass
-class HorqruxObservable(HorqruxCircuit):
-    def __init__(self, operators: list[Gate]):
-        super().__init__(operators=operators)
-
-    def forward(self, state: Array, values: ParamDictType) -> Array:
-        return jnp.real(inner(state, self._forward(state, values)))
-
-
 def convert_observable(
     block: AbstractBlock, n_qubits: int, config: Configuration
 ) -> HorqruxObservable:
@@ -109,7 +84,7 @@ def convert_block(
     ops = []
     if isinstance(block, CompositeBlock):
         ops = list(flatten(*(convert_block(b, n_qubits, config) for b in block.blocks)))
-        ops = [HorqAddGate(ops)] if isinstance(block, AddBlock) else [HorqruxCircuit(ops)]
+        ops = [HorqAddGate(ops)] if isinstance(block, AddBlock) else [HorqruxSequence(ops)]
     elif isinstance(block, ScaleBlock):
         op = convert_block(block.block, n_qubits, config=config)[0]
         param_name = config.get_param_name(block)[0]
@@ -118,7 +93,7 @@ def convert_block(
         native_op_fn = ops_map[block.name]
         target, control = (
             (block.qubit_support[1], block.qubit_support[0])
-            if isinstance(block, (CNOT, CRX, CRY, CRZ, QDSWAP))
+            if isinstance(block, (CZ, CNOT, CRX, CRY, CRZ, QDSWAP))
             else (block.qubit_support[0], (None,))
         )
         native_gate: Gate
@@ -133,7 +108,7 @@ def convert_block(
                 native_gate = native_op_fn(block.qubit_support[::-1])
             else:
                 native_gate = native_op_fn(target=target, control=control)
-        ops = [HorqOperation(native_gate)]
+        ops = [native_gate]
 
     elif isinstance(block, (MCRX, MCRY, MCRZ, MCZ)):
         block_name = block.name[2:] if block.name.startswith("M") else block.name
@@ -146,7 +121,7 @@ def convert_block(
             native_gate = native_op_fn(param=param, target=target, control=control)
         else:
             native_gate = native_op_fn(target, control)
-        ops = [HorqOperation(native_gate)]
+        ops = [native_gate]
     elif isinstance(block, TimeEvolutionBlock):
         ops = [HorqHamiltonianEvolution(block, config)]
     else:
@@ -155,58 +130,6 @@ def convert_block(
     return ops
 
 
-@register_pytree_node_class
-class HorqAddGate(HorqruxCircuit):
-    def __init__(self, operations: list[Gate]):
-        self.operators = operations
-        self.name = "Add"
-
-    def forward(self, state: Array, values: ParamDictType = {}) -> Array:
-        return reduce(add, (gate.forward(state, values) for gate in self.operators))
-
-    def __repr__(self) -> str:
-        return self.name + f"({self.operators})"
-
-
-@register_pytree_node_class
-@dataclass
-class HorqOperation:
-    def __init__(self, native_gate: Gate):
-        self.native_gate = native_gate
-
-    def forward(self, state: Array, values: ParamDictType) -> Array:
-        return apply_gate(state, self.native_gate, values)
-
-    def tree_flatten(self) -> tuple[tuple[Gate], tuple[()]]:
-        children = (self.native_gate,)
-        aux_data = ()
-        return (children, aux_data)
-
-    @classmethod
-    def tree_unflatten(cls, aux_data: Any, children: Any) -> Any:
-        return cls(*children, *aux_data)
-
-
-@register_pytree_node_class
-@dataclass
-class HorqScaleGate:
-    def __init__(self, gate: HorqOperation, parameter_name: str):
-        self.gate = gate
-        self.parameter: str = parameter_name
-
-    def forward(self, state: Array, values: ParamDictType) -> Array:
-        return jnp.array(values[self.parameter]) * self.gate.forward(state, values)
-
-    def tree_flatten(self) -> tuple[tuple[HorqOperation], tuple[str]]:
-        children = (self.gate,)
-        aux_data = (self.parameter,)
-        return (children, aux_data)
-
-    @classmethod
-    def tree_unflatten(cls, aux_data: Any, children: Any) -> Any:
-        return cls(*children, *aux_data)
-
-
 @register_pytree_node_class
 @dataclass
 class HorqHamiltonianEvolution(NativeHorqHEvo):
@@ -216,7 +139,7 @@ class HorqHamiltonianEvolution(NativeHorqHEvo):
         config: Configuration,
     ):
         super().__init__("I", block.qubit_support, (None,))
-        self.qubit_support = block.qubit_support
+        self._qubit_support = block.qubit_support
         self.param_names = config.get_param_name(block)
         self.block = block
         self.hmat: Array
@@ -224,7 +147,7 @@ class HorqHamiltonianEvolution(NativeHorqHEvo):
         if isinstance(block.generator, AbstractBlock) and not block.generator.is_parametric:
             hmat = block_to_jax(
                 block.generator,
-                qubit_support=self.qubit_support,
+                qubit_support=self._qubit_support,
                 use_full_support=False,
             )
             self.hmat = hmat
@@ -236,7 +159,7 @@ class HorqHamiltonianEvolution(NativeHorqHEvo):
                 hmat = block_to_jax(
                     block.generator,  # type: ignore[arg-type]
                     values=values,
-                    qubit_support=self.qubit_support,
+                    qubit_support=self._qubit_support,
                     use_full_support=False,
                 )
                 return hmat
@@ -249,12 +172,12 @@ class HorqHamiltonianEvolution(NativeHorqHEvo):
         """The evolved operator given current parameter values for generator and time evolution."""
         return expm(self._hamiltonian(self, values) * (-1j * self._time_evolution(values)))
 
-    def forward(
+    def __call__(
         self,
         state: Array,
         values: dict[str, Array],
     ) -> Array:
-        return apply_gate(state, self, values)
+        return apply_gates(state, self, values)
 
     def tree_flatten(self) -> tuple[tuple[NativeHorqHEvo], tuple]:
         children = (self,)