qadence 1.11.1__py3-none-any.whl → 1.11.2__py3-none-any.whl

qadence/ml_tools/callbacks/callbackmanager.py

@@ -115,8 +115,10 @@ class CallbacksManager:
             self.add_callback("PlotMetrics", "train_end")
         # only save the last checkpoint if not checkpoint_best_only
         if not self.config.checkpoint_best_only:
-            self.add_callback("SaveCheckpoint", "train_end")
-        self.add_callback("WriteMetrics", "train_end")
+            if self.config.checkpoint_every != 0:
+                self.add_callback("SaveCheckpoint", "train_end")
+        if self.config.write_every != 0:
+            self.add_callback("WriteMetrics", "train_end")
 
     def add_callback(
         self, callback: str | Callback, on: str | TrainingStage, called_every: int = 1

qadence/ml_tools/constructors.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Callable
+from typing import Any, Callable
 import numpy as np
 from sympy import Basic
 
@@ -8,7 +8,8 @@ from qadence.backend import BackendConfiguration
 from qadence.blocks import chain, kron
 from qadence.blocks.abstract import AbstractBlock
 from qadence.blocks.composite import ChainBlock, KronBlock
-from qadence.blocks.utils import add, tag
+from qadence.blocks.utils import tag, add
+from qadence.parameters import Parameter
 from qadence.circuit import QuantumCircuit
 from qadence.constructors import (
     analog_feature_map,
@@ -24,7 +25,7 @@ from qadence.constructors.hea import hea_digital, hea_sDAQC
 from qadence.constructors.iia import iia
 from qadence.measurements import Measurements
 from qadence.noise import NoiseHandler
-from qadence.operations import CNOT, RX, RY, I, N, Z
+from qadence.operations import CNOT, RX, RY, RZ, I
 from qadence.register import Register
 from qadence.types import (
     AnsatzType,
@@ -733,7 +734,6 @@ def create_observable(
         interaction=config.interaction,
         detuning=config.detuning,
     )
-
     obs: AbstractBlock = add(shifting_term, detuning_hamiltonian)
 
     if isinstance(config.tag, str):
@@ -801,6 +801,7 @@ def build_qnn_from_configs(
         if isinstance(observable_config, list)
         else create_observable(register=register, config=observable_config)
     )
+
     ufa = QNN(
         circ,
         observable,
@@ -814,3 +815,262 @@ def build_qnn_from_configs(
     )
 
     return ufa
+
+
+def _create_feature_map_qcnn(
+    n_qubits: int,
+    n_inputs: int,
+    fm_type: str = "Fourier",
+    op: Any = RX,
+) -> Any:
+    """
+    Creates a feature map (FM) by dividing qubits among inputs and applying.
+
+    the specified feature map type.
+
+    Args:
+        n_qubits (int): Total number of qubits.
+        n_inputs (int): Number of inputs.
+        fm_type (str): Type of feature map to use (e.g., "Fourier").
+        op (Any): Quantum operation to use in the feature map (e.g., RX).
+
+    Returns:
+        Any: The combined feature map as a kronecker product
+        of individual feature maps.
+    """
+    fm_temp = []
+    qubits_per_input = n_qubits // n_inputs  # Base number of qubits per input
+    exceeding_qubits = n_qubits % n_inputs  # Number of exceeding qubits
+    start = 0  # Track current qubit index
+
+    for i in range(n_inputs):
+        # Assign base qubits + 1 extra if input has exceeding qubits
+        num_qubits = qubits_per_input + 1 if i < exceeding_qubits else qubits_per_input
+        end = start + num_qubits
+
+        # Create FM for this input
+        fm_temp.append(
+            feature_map(
+                n_qubits=num_qubits,
+                param=f"\u03C6_{i}",  # Use phi_i as the parameter
+                op=op,
+                fm_type=fm_type,
+                support=tuple(range(start, end)),
+            )
+        )
+        start = end  # Update starting index for next FM
+
+    # Combine all feature maps using kronecker product
+    return kron(*fm_temp)
+
+
+def _get_block_params(
+    params: dict,
+    layer: int,
+    rep: int,
+    pos: int,
+    is_corr: bool = False,
+) -> Any:
+    """
+    Retrieves the parameter for a given operation.
+
+    Args:
+        params (dict): Dictionary to store and retrieve parameters.
+        layer (int): The index of the current layer.
+        rep (int): The index of the current repetition in the layer.
+        pos (int): Position of the qubit in the layer.
+        is_corr (bool): If True, uses correlated parameters for corresponding gates in W^opt_ij.
+
+    Returns:
+        Parameter: the retrieved parameter.
+    """
+    if is_corr:
+        # Cycle pos from 0 to 8
+        key = f"θ_{layer}_{pos % 9}"
+    else:
+        key = f"θ_{layer}_{rep}_{pos}"
+
+    if key not in params:
+        params[key] = Parameter(key)
+    return params[key]
+
+
+def _create_single_W(
+    params: dict,
+    operations: list[Any],
+    entangler: Any,
+    layer: int,
+    rep: int,
+    max_reps: int,
+    control: int,
+    target: int,
+    spacing: int,
+    n_qubits: int,
+    is_corr: bool = False,
+) -> ChainBlock:
+    """Creates a single convolutional cell W_ij."""
+    pad = [
+        I(q)
+        for q in range(control - spacing, control + spacing + 1)
+        if q != control and q != target and 0 <= q < n_qubits
+    ]
+    gates = []
+
+    # Track per-layer repetition index for proper parameter continuity
+    key_param_counter = f"param_index_{layer}_{rep}"
+    if key_param_counter not in params:
+        params[key_param_counter] = 0  # Initialize if first time
+
+    param_index = params[key_param_counter]  # Load index
+    single_params = {}  # Store params for single RZ/RY gates
+
+    # Apply the first sequence of operations
+    for _, op in enumerate(operations):
+        param_control = _get_block_params(params, layer, rep, param_index, is_corr)
+        param_index += 1
+        param_target = _get_block_params(params, layer, rep, param_index, is_corr)
+        param_index += 1
+        gates.append(
+            kron(
+                *pad,
+                op(control, param_control),
+                op(target, param_target),
+            )
+        )
+    # entangling gate
+    gates.append(entangler(target, control))
+
+    # Apply RZ, RY and entangling gates for intermediate step
+    single_params["control_rz"] = _get_block_params(params, layer, rep, param_index, is_corr)
+    param_index += 1
+    single_params["target_ry"] = _get_block_params(params, layer, rep, param_index, is_corr)
+    param_index += 1
+    gates.append(
+        kron(
+            *pad,
+            RZ(control, single_params["control_rz"]),
+            RY(target, single_params["target_ry"]),
+        )
+    )
+    # entangling gate
+    gates.append(entangler(control, target))
+
+    intermediate_ry = _get_block_params(params, layer, rep, param_index, is_corr)
+    param_index += 1
+    gates.append(
+        kron(
+            *pad,
+            I(control),
+            RY(target, intermediate_ry),
+        )
+    )
+    # entangling gate
+    gates.append(entangler(target, control))
+
+    # Apply the first sequence of operations
+    for _, op in enumerate(operations):
+        param_control = _get_block_params(params, layer, rep, param_index, is_corr)
+        param_index += 1
+        param_target = _get_block_params(params, layer, rep, param_index, is_corr)
+        param_index += 1
+        gates.append(
+            kron(
+                *pad,
+                op(control, param_control),
+                op(target, param_target),
+            )
+        )
+    # Add final entangling gate (control -> target)
+    if rep == int(max_reps - 1):
+        gates.append(entangler(control, target))
+
+    # Update params dict with the last used index
+    params[key_param_counter] = param_index
+
+    return chain(*gates)
+
+
+def _create_conv_layer(
+    layer_index: int,
+    max_reps: int,
+    current_indices: list[int],
+    params: dict,
+    operations: list[Any],
+    entangler: Any,
+    n_qubits: int,
+    is_corr: bool,
+) -> tuple[AbstractBlock, list[int]]:
+    """
+    Function to create a single convolutional layer.
+
+    Args:
+        layer_index (int): The index of the current layer.
+        reps (int): Number of repetitions for this layer.
+        current_indices (List[int]): Indices of qubits for the current layer.
+        params (dict): Dictionary to store and retrieve parameters.
+        operations (List[Any]): List of quantum operations to apply in the gates.
+        entangler (Any): Entangling operation, such as CZ.
+        n_qubits (int): Total number of qubits.
+
+    Returns:
+        Tuple[AbstractBlock, List[int]]: A tuple containing the quantum block
+        for the layer and the target indices for the next layer.
+    """
+    current_layer = []
+    next_indices = []
+    spacing = layer_index
+
+    if layer_index in [0, 1]:  # Special behavior for first two layers
+        layer_reps = []
+        for rep in range(max_reps):
+            rep_kron = []
+            # Define qubit pairs based on odd/even repetition
+            if rep % 2 == 0:  # Even d: regular behavior
+                pairs = zip(current_indices[::2], current_indices[1::2])
+            else:  # Odd d: shift downward, leaving qubits 0 and 7 free
+                pairs = zip(current_indices[1:-1:2], current_indices[2:-1:2])
+
+            # Build the gate sequence for each pair
+            for control, target in pairs:
+                W_pairs = _create_single_W(
+                    params,
+                    operations,
+                    entangler,
+                    layer_index,
+                    rep,
+                    max_reps,
+                    control,
+                    target,
+                    spacing,
+                    n_qubits,
+                    is_corr,
+                )
+                tag(W_pairs, f"W{control,target}")
+                rep_kron.append(W_pairs)
+
+            layer_reps.append(kron(*rep_kron))
+
+        # Combine all repetitions using `chain`
+        current_layer.append(chain(*layer_reps))
+
+    else:  # Original behavior for other layers
+        for rep in range(max_reps):
+            for control, target in zip(current_indices[::2], current_indices[1::2]):
+                W_pairs = _create_single_W(
+                    params,
+                    operations,
+                    entangler,
+                    layer_index,
+                    rep,
+                    max_reps,
+                    control,
+                    target,
+                    spacing,
+                    n_qubits,
+                    is_corr,
+                )
+                current_layer.append(W_pairs)
+
+    # Update `next_indices` with the **targets** of the current layer
+    next_indices = current_indices[1::2]
+    return chain(*current_layer), next_indices

qadence/ml_tools/qcnn_model.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+from typing import Any, Callable
+from qadence.blocks import chain
+from qadence.parameters import Parameter
+from qadence.blocks.utils import add, tag
+from qadence.operations import Z, RX, CZ
+from qadence.circuit import QuantumCircuit
+from qadence.types import BackendName, DiffMode
+from qadence.blocks.abstract import AbstractBlock
+
+from .models import QNN
+from qadence.ml_tools.constructors import _create_conv_layer, _create_feature_map_qcnn
+
+
+class QCNN(QNN):
+    def __init__(
+        self,
+        n_inputs: int,
+        n_qubits: int,
+        depth: list[int],
+        operations: list[Any],
+        entangler: Any = CZ,
+        random_meas: bool = True,
+        fm_basis: str = "Fourier",
+        fm_gate: Any = RX,
+        is_corr: bool = False,
+        **kwargs: Any,
+    ) -> None:
+        """
+        Creates a QCNN model.
+
+        Args:
+            n_inputs (int): Number of input features.
+            n_qubits (int): Total number of qubits.
+            depth (list[int]): List defining the depth (repetitions) of each layer.
+            operations (list[Any]): List of quantum operations to apply
+                in the gates (e.g., [RX, RZ]).
+            entangler (Any): Entangling operation, such as CZ.
+            random_meas (bool): If True, applies random weighted measurements.
+            fm_basis (str): feature map basis.
+            fm_gate (Any): gate employed in the fm, such as.
+            **kwargs (Any): Additional keyword arguments for the parent QNN class.
+        """
+        self.n_inputs = n_inputs
+        self.n_qubits = n_qubits
+        self.depth = depth
+        self.operations = operations
+        self.entangler = entangler
+        self.random_meas = random_meas
+        self.fm_basis = fm_basis
+        self.fm_gate = fm_gate
+        self.is_corr = is_corr
+
+        circuit = self.qcnn_circuit(
+            self.n_inputs,
+            self.n_qubits,
+            self.depth,
+            self.operations,
+            self.entangler,
+            self.fm_basis,
+            self.fm_gate,
+            self.is_corr,
+        )
+
+        obs = self.qcnn_deferred_obs(self.n_qubits, self.random_meas)
+
+        super().__init__(
+            circuit=circuit,
+            observable=obs,
+            backend=BackendName.PYQTORCH,
+            diff_mode=DiffMode.AD,
+            inputs=[f"\u03C6_{i}" for i in range(self.n_inputs)],
+            **kwargs,
+        )
+
+    def qcnn_circuit(
+        self,
+        n_inputs: int,
+        n_qubits: int,
+        depth: list[int],
+        operations: list[Any],
+        entangler: AbstractBlock,
+        fm_basis: str,
+        fm_gate: AbstractBlock,
+        is_corr: bool,
+    ) -> QuantumCircuit:
+        """Defines the QCNN circuit."""
+        # Validate qubit count
+        if n_qubits < 4:
+            raise ValueError(
+                f"Invalid number of qubits: {n_qubits}. " "At least 4 qubits are required."
+            )
+        if n_qubits % 2 != 0:
+            raise ValueError(
+                f"Invalid number of qubits: {n_qubits}. " "The number of qubits must be even."
+            )
+
+        # Validate that all values in `depth` are odd
+        even_depths = [d for d in depth if d % 2 == 0]
+        if even_depths:
+            raise ValueError(
+                f"Invalid depth values: '{even_depths[0]}'. " "All the conv layer 'r's must be odd."
+            )
+
+        # Feature map (FM)
+        fm = _create_feature_map_qcnn(n_qubits, n_inputs, fm_basis, fm_gate)
+        tag(fm, "FM")
+
+        # Conv and Pool layer definition
+        conv_layers = []
+        params: dict[str, Parameter] = {}
+
+        # Define layer all the 2-qubit patterns based on depth
+        layer_patterns = [(2**layer_index, depth[layer_index]) for layer_index in range(len(depth))]
+
+        # Initialize all qubits for the current layer
+        current_indices = list(range(n_qubits))
+
+        # Build the circuit layer by layer using the helper
+        for layer_index, (_, reps) in enumerate(layer_patterns):
+            if reps == 0:
+                raise ValueError(f"Invalid layer {layer_index}: zero repetitions (reps = {reps}).")
+            if len(current_indices) < 2:
+                raise RuntimeError(
+                    f"Layer {layer_index} requires at least 2 qubits, "
+                    f"but found {len(current_indices)}."
+                )
+
+            layer_block, next_indices = _create_conv_layer(
+                layer_index, reps, current_indices, params, operations, entangler, n_qubits, is_corr
+            )
+            tag(layer_block, f"C+P layer {layer_index}")
+            conv_layers.append(layer_block)
+
+            # Update `current_indices` for the next layer
+            current_indices = next_indices
+
+        # Combine all layers for the final ansatz
+        ansatz = chain(*conv_layers)
+
+        return QuantumCircuit(n_qubits, fm, ansatz)
+
+    def qcnn_deferred_obs(
+        self, n_qubits: int, random_meas: bool
+    ) -> AbstractBlock | list[AbstractBlock]:
+        """
+        Defines the measurements to be performedthe traced out.
+
+        and remaining qubits.
+        """
+        if random_meas:
+            w1 = [Parameter(f"w{i}") for i in range(n_qubits)]
+            obs = add(Z(i) * w for i, w in zip(range(n_qubits), w1))
+        else:
+            obs = add(Z(i) for i in range(n_qubits))
+
+        return obs

qadence/model.py

@@ -154,6 +154,11 @@ class QuantumModel(nn.Module):
         """Variational parameters."""
         return OrderedDict({k: v.data for k, v in self._params.items() if v.requires_grad})
 
+    @property
+    def params(self) -> OrderedDict:
+        """All parameters."""
+        return OrderedDict({k: v.data for k, v in self._params.items()})
+
     @property
     def vals_vparams(self) -> Tensor:
         """Dictionary with parameters which are actually updated during optimization."""
@@ -176,6 +181,19 @@ class QuantumModel(nn.Module):
         """The number of variational parameters."""
         return len(self.vals_vparams)
 
+    @property
+    def show_config(self) -> str:
+        """Attain current quantum model configurations."""
+        if isinstance(self.backend, DifferentiableBackend):
+            current_config = self.backend.backend.config
+        return BackendConfiguration.available_options(current_config)
+
+    def change_config(self, new_config: dict) -> None:
+        """Change configuration with the input."""
+        if isinstance(self.backend, DifferentiableBackend):
+            current_config = self.backend.backend.config
+        BackendConfiguration.change_config(current_config, new_config)
+
     def circuit(self, circuit: QuantumCircuit) -> ConvertedCircuit:
         """Get backend-converted circuit.
 
@@ -520,7 +538,7 @@ class QuantumModel(nn.Module):
             file_path = file_path / get_latest_checkpoint_name(file_path, "model")
 
         try:
-            qm_pt = torch.load(file_path, map_location=map_location)
+            qm_pt = torch.load(file_path, map_location=map_location, weights_only=False)
         except Exception as e:
             logger.error(f"Unable to load QuantumModel due to {e}")
         return cls._from_dict(qm_pt, as_torch)

qadence/parameters.py

@@ -225,6 +225,8 @@ def sympy_to_numeric(expr: Basic) -> TNumber:
     if expr.as_real_imag()[1] != 0:
         return complex(expr)
     else:
+        if expr.is_Integer:
+            return int(expr)
         return float(expr)
 
 

qadence/serialization.py

@@ -226,7 +226,7 @@ def save_json(d: dict, file_path: str | Path) -> None:
 
 
 def load_pt(file_path: str | Path, map_location: str) -> Any:
-    return torch.load(file_path, map_location=map_location)
+    return torch.load(file_path, map_location=map_location, weights_only=False)
 
 
 def load_json(file_path: str | Path, map_location: str) -> Any:

qadence/types.py

@@ -180,7 +180,7 @@ class AnsatzType(StrEnum):
     """Alternating Layer Ansatz."""
 
 
-class _DiffMode(StrEnum):
+class DiffMode(StrEnum):
     """Differentiation modes to choose from."""
 
     GPSR = "gpsr"
@@ -246,11 +246,9 @@ class _Engine(StrEnum):
 try:
     module = importlib.import_module("qadence_extensions.types")
     BackendName = getattr(module, "BackendName")
-    DiffMode = getattr(module, "DiffMode")
     Engine = getattr(module, "Engine")
 except ModuleNotFoundError:
     BackendName = _BackendName
-    DiffMode = _DiffMode
     Engine = _Engine
 
 

qadence/utils.py

@@ -318,14 +318,23 @@ def block_to_mathematical_expression(block: Tree | AbstractBlock) -> str:
             [block_to_mathematical_expression(block_child) for block_child in block_tree.children]
         )
     if "mul" in block_title:
-        block_title = re.findall("\d+\.\d+", block_title)[0]
-        coeff = float(block_title)
-        if coeff == 0:
-            block_title = ""
-        elif coeff == 1:
-            block_title = block_to_mathematical_expression(block_tree.children[0])
-        else:
+        block_title = re.findall("\[mul:\s*(.+?)\]", block_title)[0]
+
+        try:
+            if "." in block_title:
+                coeff = float(block_title)
+            else:
+                coeff = int(block_title)
+            if coeff == 0:
+                block_title = ""
+            elif coeff == 1:
+                block_title = block_to_mathematical_expression(block_tree.children[0])
+            else:
+                block_title += " * " + block_to_mathematical_expression(block_tree.children[0])
+
+        except ValueError:  # In case block_title is a non-numeric str (e.g. parameter name)
             block_title += " * " + block_to_mathematical_expression(block_tree.children[0])
+
     first_part = block_title[:3]
     if first_part in [" + ", " ⊗ ", " * "]:
         block_title = block_title[3:]

{qadence-1.11.1.dist-info → qadence-1.11.2.dist-info}/METADATA

@@ -1,17 +1,18 @@
 Metadata-Version: 2.4
 Name: qadence
-Version: 1.11.1
+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.2
+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'
@@ -56,8 +57,8 @@ Provides-Extra: protocols
 Requires-Dist: qadence-protocols; extra == 'protocols'
 Provides-Extra: pulser
 Requires-Dist: pasqal-cloud==0.20.2; extra == 'pulser'
-Requires-Dist: pulser-core==1.3.0; extra == 'pulser'
-Requires-Dist: pulser-simulation==1.3.0; 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).