qadence 1.9.2__tar.gz → 1.10.0__tar.gz

{qadence-1.9.2 → qadence-1.10.0}/.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
 -   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.5.0
+    rev: v5.0.0
     hooks:
       - id: trailing-whitespace
       - id: end-of-file-fixer
@@ -9,18 +9,18 @@ repos:
         args: ['--maxkb=600']
 
 -   repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: "v0.1.5"
+    rev: "v0.9.1"
     hooks:
       - id: ruff
-        args: [--fix, --show-fixes, --show-source, --exclude, examples/draw.py]
+        args: [--fix, --show-fixes, --show-files, --exclude, examples/draw.py]
 
 -   repo: https://github.com/ambv/black
-    rev: 23.11.0
+    rev: 24.10.0
     hooks:
       - id: black
 
 -   repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.9.0
+    rev: v1.14.1
     hooks:
       - id: mypy
         args: [--install-types, --non-interactive]

{qadence-1.9.2 → qadence-1.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qadence
-Version: 1.9.2
+Version: 1.10.0
 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>
 License: Apache 2.0
@@ -54,7 +54,7 @@ Requires-Dist: mlflow; extra == 'mlflow'
 Provides-Extra: protocols
 Requires-Dist: qadence-protocols; extra == 'protocols'
 Provides-Extra: pulser
-Requires-Dist: pasqal-cloud==0.12.6; extra == 'pulser'
+Requires-Dist: pasqal-cloud==0.12.7; extra == 'pulser'
 Requires-Dist: pulser-core==1.2.0; extra == 'pulser'
 Requires-Dist: pulser-simulation==1.2.0; extra == 'pulser'
 Provides-Extra: visualization

{qadence-1.9.2 → qadence-1.10.0}/mkdocs.yml

@@ -56,6 +56,7 @@ nav:
       - Custom quantum models: tutorials/advanced_tutorials/custom-models.md
       - Projector blocks: tutorials/advanced_tutorials/projectors.md
       - Profiling and debugging on CUDA devices: tutorials/advanced_tutorials/profiling-and-debugging.md
+      - Submission to Pasqal Cloud: tutorials/advanced_tutorials/cloud-submission.md
 
     - Realistic simulations:
       - tutorials/realistic_sims/index.md
@@ -83,6 +84,7 @@ nav:
     - Serialization: api/serialization.md
     - Types: api/types.md
     - Drawing: api/draw.md
+    - Pasqal Cloud Connection: api/pasqal_cloud_connection.md
 
     - Backends:
       - Abstract backend: api/backends/backend.md

{qadence-1.9.2 → qadence-1.10.0}/pyproject.toml

@@ -26,7 +26,7 @@ authors = [
 ]
 requires-python = ">=3.9"
 license = { text = "Apache 2.0" }
-version = "1.9.2"
+version = "1.10.0"
 classifiers = [
     "License :: OSI Approved :: Apache Software License",
     "Programming Language :: Python",
@@ -64,7 +64,7 @@ allow-ambiguous-features = true
 pulser = [
     "pulser-core==1.2.0",
     "pulser-simulation==1.2.0",
-    "pasqal-cloud==0.12.6",
+    "pasqal-cloud==0.12.7",
 ]
 visualization = [
     "graphviz",
@@ -96,6 +96,7 @@ dependencies = [
     "pytest-cov",
     "pytest-mypy",
     "pytest-xdist",
+    "pytest-mock",
     "types-PyYAML",
     "ipykernel",
     "pre-commit",
@@ -133,7 +134,7 @@ filterwarnings = [
 [tool.hatch.envs.docs]
 dependencies = [
     "mkdocs",
-    "mkdocs_autorefs<1.1.0",
+    "mkdocs_autorefs<1.3.1",
     "mkdocs-material",
     "mkdocstrings",
     "mkdocstrings-python",

{qadence-1.9.2 → qadence-1.10.0}/qadence/backends/api.py

@@ -42,9 +42,9 @@ def backend_factory(
 
         # Instantiate the backend
         backend_inst = BackendCls(  # type: ignore[operator]
-            config=configuration
-            if configuration is not None
-            else BackendCls.default_configuration()
+            config=(
+                configuration if configuration is not None else BackendCls.default_configuration()
+            )
         )
         set_backend_config(backend_inst, diff_mode)
         # Wrap the quantum Backend in a DifferentiableBackend if a diff_mode is passed.

{qadence-1.9.2 → qadence-1.10.0}/qadence/backends/horqrux/convert_ops.py

@@ -12,7 +12,7 @@ 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 inner
+from horqrux.utils import ControlQubits, TargetQubits, inner
 from jax import Array
 from jax.scipy.linalg import expm
 from jax.tree_util import register_pytree_node_class
@@ -102,6 +102,8 @@ def convert_observable(
 def convert_block(
     block: AbstractBlock, n_qubits: int = None, config: Configuration = Configuration()
 ) -> list:
+    control: ControlQubits
+    target: TargetQubits
     if n_qubits is None:
         n_qubits = max(block.qubit_support) + 1
     ops = []

{qadence-1.9.2 → qadence-1.10.0}/qadence/blocks/embedding.py

@@ -41,7 +41,10 @@ def unique(x: Iterable) -> List:
 
 def embedding(
     block: AbstractBlock, to_gate_params: bool = False, engine: Engine = Engine.TORCH
-) -> tuple[ParamDictType, Callable[[ParamDictType, ParamDictType], ParamDictType],]:
+) -> tuple[
+    ParamDictType,
+    Callable[[ParamDictType, ParamDictType], ParamDictType],
+]:
     """Construct embedding function which maps user-facing parameters to either *expression-level*.
 
     parameters or *gate-level* parameters. The constructed embedding function has the signature:
@@ -147,11 +150,9 @@ def embedding(
                 if k not in embedded_params:
                     embedded_params[k] = v
             out = {
-                stringify(k)
-                if not isinstance(k, str)
-                else k: as_tensor(v)[None]
-                if as_tensor(v).ndim == 0
-                else v
+                stringify(k) if not isinstance(k, str) else k: (
+                    as_tensor(v)[None] if as_tensor(v).ndim == 0 else v
+                )
                 for k, v in embedded_params.items()
             }
             return out

{qadence-1.9.2 → qadence-1.10.0}/qadence/blocks/utils.py

@@ -305,9 +305,11 @@ def uuid_to_eigen(
                     else:
                         result[uuid] = (
                             b.eigenvalues_generator * 2.0,
-                            1.0 / (b.eigenvalues_generator.item() * 2.0)
-                            if len(b.eigenvalues_generator) == 1
-                            else 1.0,
+                            (
+                                1.0 / (b.eigenvalues_generator.item() * 2.0)
+                                if len(b.eigenvalues_generator) == 1
+                                else 1.0
+                            ),
                         )
                 else:
                     result[uuid] = (b.eigenvalues_generator, 1.0)

{qadence-1.9.2 → qadence-1.10.0}/qadence/constructors/__init__.py

@@ -5,9 +5,9 @@ from .feature_maps import (
     exp_fourier_feature_map,
 )
 
-from .ansatze import hea, alt
-
-from .iia import identity_initialized_ansatz
+from .hea import hea
+from .ala import ala
+from .iia import identity_initialized_ansatz, iia
 
 from .daqc import daqc_transform
 
@@ -29,8 +29,9 @@ __all__ = [
     "feature_map",
     "exp_fourier_feature_map",
     "hea",
-    "alt",
+    "ala",
     "identity_initialized_ansatz",
+    "iia",
     "hamiltonian_factory",
     "ising_hamiltonian",
     "ObservableConfig",

qadence-1.10.0/qadence/constructors/ala.py

@@ -0,0 +1,270 @@
+from __future__ import annotations
+
+import itertools
+from typing import Any, Type, Union
+
+from qadence.blocks import AbstractBlock, chain, kron, tag
+from qadence.operations import CNOT, CPHASE, CRX, CRY, CRZ, CZ, RX, RY
+from qadence.types import Strategy
+
+DigitalEntanglers = Union[CNOT, CZ, CRZ, CRY, CRX]
+
+
+def ala(
+    n_qubits: int,
+    m_block_qubits: int,
+    depth: int = 1,
+    param_prefix: str = "theta",
+    support: tuple[int, ...] | None = None,
+    strategy: Strategy = Strategy.DIGITAL,
+    **strategy_args: Any,
+) -> AbstractBlock:
+    """
+    Factory function for the alternating layer ansatz (ala).
+
+    Args:
+        n_qubits: number of qubits in the circuit
+        m_block_qubits: number of qubits in the local entangling block
+        depth: number of layers of the alternating layer ansatz
+        param_prefix: the base name of the variational parameters
+        support: qubit indices where the ala is applied
+        strategy: Strategy for the ansatz. One of the Strategy variants.
+        **strategy_args: see below
+
+    Keyword Arguments:
+        operations (list): list of operations to cycle through in the
+            digital single-qubit rotations of each layer. Valid for
+            Digital .
+        entangler (AbstractBlock):
+            - Digital: 2-qubit entangling operation. Supports CNOT, CZ,
+            CRX, CRY, CRZ, CPHASE. Controlled rotations will have variational
+            parameters on the rotation angles.
+            - SDAQC | BDAQC: Hamiltonian generator for the analog entangling
+                layer. Must be an m-qubit operator where m is the size of the
+                local entangling block. Defaults to a ZZ interaction.
+
+    Returns:
+        The Alternating Layer Ansatz (ALA) circuit.
+    """
+
+    if support is None:
+        support = tuple(range(n_qubits))
+
+    ala_func_dict = {
+        Strategy.DIGITAL: ala_digital,
+        Strategy.SDAQC: ala_sDAQC,
+        Strategy.BDAQC: ala_bDAQC,
+        Strategy.ANALOG: ala_analog,
+    }
+
+    try:
+        ala_func = ala_func_dict[strategy]
+    except KeyError:
+        raise KeyError(f"Strategy {strategy} not recognized.")
+
+    ala_block: AbstractBlock = ala_func(
+        n_qubits=n_qubits,
+        m_block_qubits=m_block_qubits,
+        depth=depth,
+        param_prefix=param_prefix,
+        support=support,
+        **strategy_args,
+    )  # type: ignore
+
+    return ala_block
+
+
+#################
+## DIGITAL ALA ##
+#################
+
+
+def _rotations_digital(
+    n_qubits: int,
+    depth: int,
+    param_prefix: str = "theta",
+    support: tuple[int, ...] | None = None,
+    operations: list[Type[AbstractBlock]] = [RX, RY, RX],
+) -> list[AbstractBlock]:
+    """Creates the layers of single qubit rotations in an Alternating Layer Ansatz.
+
+    Args:
+        n_qubits: The number of qubits in the Alternating Layer Ansatz.
+        depth: The number of layers of rotations.
+        param_prefix: The prefix for the parameter names.
+        support: The qubits to apply the rotations to.
+        operations: The operations to apply the rotations with.
+
+    Returns:
+        A list of digital rotation layers for the Alternating Layer Ansatz.
+    """
+    if support is None:
+        support = tuple(range(n_qubits))
+    iterator = itertools.count()
+    rot_list: list[AbstractBlock] = []
+    for d in range(depth):
+        rots = [
+            kron(
+                gate(support[n], param_prefix + f"_{next(iterator)}")  # type: ignore [arg-type]
+                for n in range(n_qubits)
+            )
+            for gate in operations
+        ]
+        rot_list.append(chain(*rots))
+    return rot_list
+
+
+def _entangler(
+    control: int,
+    target: int,
+    param_str: str,
+    op: Type[DigitalEntanglers] = CNOT,
+) -> AbstractBlock:
+    """
+    Creates the entangler for a single qubit in an Alternating Layer Ansatz.
+
+    Args:
+        control: The control qubit.
+        target: The target qubit.
+        param_str: The parameter string.
+        op: The entangler to use.
+
+    Returns:
+        The 2-qubit digital entangler for the Alternating Layer Ansatz.
+    """
+    if op in [CNOT, CZ]:
+        return op(control, target)  # type: ignore
+    elif op in [CRZ, CRY, CRX, CPHASE]:
+        return op(control, target, param_str)  # type: ignore
+    else:
+        raise ValueError("Provided entangler not accepted for digital alternating layer ansatz")
+
+
+def _entanglers_ala_block_digital(
+    n_qubits: int,
+    m_block_qubits: int,
+    depth: int,
+    param_prefix: str = "theta",
+    support: tuple[int, ...] | None = None,
+    entangler: Type[DigitalEntanglers] = CNOT,
+) -> list[AbstractBlock]:
+    """
+    Creates the entanglers for an Alternating Layer Ansatz.
+
+    Args:
+        n_qubits: The number of qubits in the Alternating Layer Ansatz.
+        m_block_qubits: The number of qubits in each block.
+        depth: The number of layers of entanglers.
+        param_prefix: The prefix for the parameter names.
+        support (tuple): qubit indices where the HEA is applied.
+        entangler: The entangler to use.
+
+    Returns:
+        The entanglers for the Alternating Layer Ansatz.
+    """
+    if support is None:
+        support = tuple(range(n_qubits))
+    iterator = itertools.count()
+    ent_list: list[AbstractBlock] = []
+
+    for d in range(depth):
+        start_i = 0 if not d % 2 else -m_block_qubits // 2
+        ents = [
+            kron(
+                _entangler(
+                    control=support[i + j],
+                    target=support[i + j + 1],
+                    param_str=param_prefix + f"_ent_{next(iterator)}",
+                    op=entangler,
+                )
+                for j in range(start_j, m_block_qubits, 2)
+                for i in range(start_i, n_qubits, m_block_qubits)
+                if i + j + 1 < n_qubits and j + 1 < m_block_qubits and i + j >= 0
+            )
+            for start_j in [i for i in range(2) if m_block_qubits > 2 or i == 0]
+        ]
+
+        ent_list.append(chain(*ents))
+    return ent_list
+
+
+def ala_digital(
+    n_qubits: int,
+    m_block_qubits: int,
+    depth: int = 1,
+    param_prefix: str = "theta",
+    support: tuple[int, ...] | None = None,
+    operations: list[type[AbstractBlock]] = [RX, RY],
+    entangler: Type[DigitalEntanglers] = CNOT,
+) -> AbstractBlock:
+    """
+    Construct the digital alternating layer ansatz (ALA).
+
+    Args:
+        n_qubits (int): number of qubits in the circuit.
+        m_block_qubits (int): number of qubits in the local entangling block.
+        depth (int): number of layers of the ALA.
+        param_prefix (str): the base name of the variational parameters
+        support (tuple): qubit indices where the ALA is applied.
+        operations (list): list of operations to cycle through in the
+            digital single-qubit rotations of each layer.
+        entangler (AbstractBlock): 2-qubit entangling operation.
+            Supports CNOT, CZ, CRX, CRY, CRZ. Controlld rotations
+            will have variational parameters on the rotation angles.
+
+    Returns:
+        The digital Alternating Layer Ansatz (ALA) circuit.
+    """
+
+    try:
+        if entangler not in [CNOT, CZ, CRX, CRY, CRZ, CPHASE]:
+            raise ValueError(
+                "Please provide a valid two-qubit entangler operation for digital ALA."
+            )
+    except TypeError:
+        raise ValueError("Please provide a valid two-qubit entangler operation for digital ALA.")
+
+    rot_list = _rotations_digital(
+        n_qubits=n_qubits,
+        depth=depth,
+        support=support,
+        param_prefix=param_prefix,
+        operations=operations,
+    )
+
+    ent_list = _entanglers_ala_block_digital(
+        n_qubits,
+        m_block_qubits,
+        param_prefix=param_prefix + "_ent",
+        depth=depth,
+        support=support,
+        entangler=entangler,
+    )
+
+    layers = []
+    for d in range(depth):
+        layers.append(rot_list[d])
+        layers.append(ent_list[d])
+
+    return tag(chain(*layers), "ALA")
+
+
+#################
+## sdaqc ALA ##
+#################
+def ala_sDAQC(*args: Any, **kwargs: Any) -> Any:
+    raise NotImplementedError
+
+
+#################
+## bdaqc ALA ##
+#################
+def ala_bDAQC(*args: Any, **kwargs: Any) -> Any:
+    raise NotImplementedError
+
+
+#################
+## analog ALA ##
+#################
+def ala_analog(*args: Any, **kwargs: Any) -> Any:
+    raise NotImplementedError