qadence 1.9.1__py3-none-any.whl → 1.10.0__py3-none-any.whl

qadence/analog/device.py

@@ -5,6 +5,8 @@ from dataclasses import dataclass, fields
 from qadence.analog import AddressingPattern
 from qadence.types import PI, DeviceType, Interaction
 
+from .constants import C6_DICT
+
 
 @dataclass(frozen=True, eq=True)
 class RydbergDevice:
@@ -41,6 +43,11 @@ class RydbergDevice:
     type: DeviceType = DeviceType.IDEALIZED
     """DeviceType.IDEALIZED or REALISTIC to convert to the Pulser backend."""
 
+    @property
+    def coeff_ising(self) -> float:
+        """Value of C_6."""
+        return C6_DICT[self.rydberg_level]
+
     def __post_init__(self) -> None:
         # FIXME: Currently not supporting custom interaction functions.
         if self.interaction not in [Interaction.NN, Interaction.XY]:

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/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/backends/pulser/backend.py

@@ -259,7 +259,7 @@ class Backend(BackendInterface):
             for i, param_values_el in enumerate(vals):
                 sequence = self.assign_parameters(circuit, param_values_el)
                 sim_result: CoherentResults = simulate_sequence(sequence, self.config, state)
-                final_state = sim_result.get_final_state().data.toarray()
+                final_state = sim_result.get_final_state().data.to_array()
                 batched_dm[i] = np.flip(final_state)
             return torch.from_numpy(batched_dm)
 

qadence/backends/pyqtorch/convert_ops.py

@@ -264,7 +264,7 @@ def convert_block(
                 duration=duration,
                 solver=config.ode_solver,
                 steps=config.n_steps_hevo,
-                noise_operators=noise_operators,
+                noise=noise_operators if len(noise_operators) > 0 else None,
             )
         ]
 
@@ -351,22 +351,22 @@ def convert_block(
         )
 
 
-def convert_digital_noise(noise: NoiseHandler) -> pyq.noise.NoiseProtocol | None:
+def convert_digital_noise(noise: NoiseHandler) -> pyq.noise.DigitalNoiseProtocol | None:
     """Convert the digital noise into pyqtorch NoiseProtocol.
 
     Args:
         noise (NoiseHandler): Noise to convert.
 
     Returns:
-        pyq.noise.NoiseProtocol | None: Pyqtorch native noise protocol
+        pyq.noise.DigitalNoiseProtocol | None: Pyqtorch native noise protocol
             if there are any digital noise protocols.
     """
     digital_part = noise.filter(NoiseProtocol.DIGITAL)
     if digital_part is None:
         return None
-    return pyq.noise.NoiseProtocol(
+    return pyq.noise.DigitalNoiseProtocol(
         [
-            pyq.noise.NoiseProtocol(proto, option.get("error_probability"))
+            pyq.noise.DigitalNoiseProtocol(proto, option.get("error_probability"))
             for proto, option in zip(digital_part.protocol, digital_part.options)
         ]
     )

qadence/backends/utils.py

@@ -110,9 +110,23 @@ def to_list_of_dicts(param_values: ParamDictType) -> list[ParamDictType]:
 
 
 def pyqify(state: Tensor, n_qubits: int = None) -> ArrayLike:
-    """Convert a state of shape (batch_size, 2**n_qubits) to [2] * n_qubits + [batch_size]."""
+    """Convert a state of shape (batch_size, 2**n_qubits) to [2] * n_qubits + [batch_size].
+
+    Or set the batch_size of a density matrix as the last dimension for PyQTorch.
+    """
     if n_qubits is None:
         n_qubits = int(log2(state.shape[1]))
+    if isinstance(state, DensityMatrix):
+        if (
+            len(state.shape) != 3
+            or (state.shape[1] != 2**n_qubits)
+            or (state.shape[1] != state.shape[2])
+        ):
+            raise ValueError(
+                "The initial state must be composed of tensors/arrays of size "
+                f"(batch_size, 2**n_qubits, 2**n_qubits). Found: {state.shape = }."
+            )
+        return torch.einsum("kij->ijk", state)
     if len(state.shape) != 2 or (state.shape[1] != 2**n_qubits):
         raise ValueError(
             "The initial state must be composed of tensors/arrays of size "

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/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/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/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