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

qadence/constructors/{ansatze.py → hea.py}

@@ -4,11 +4,10 @@ import itertools
 from typing import Any, Type, Union
 
 from qadence.blocks import AbstractBlock, block_is_qubit_hamiltonian, chain, kron, tag
+from qadence.constructors.hamiltonians import hamiltonian_factory
 from qadence.operations import CNOT, CPHASE, CRX, CRY, CRZ, CZ, RX, RY, HamEvo
 from qadence.types import Interaction, Strategy
 
-from .hamiltonians import hamiltonian_factory
-
 DigitalEntanglers = Union[CNOT, CZ, CRZ, CRY, CRX]
 
 
@@ -16,7 +15,7 @@ def hea(
     n_qubits: int,
     depth: int = 1,
     param_prefix: str = "theta",
-    support: tuple[int, ...] = None,
+    support: tuple[int, ...] | None = None,
     strategy: Strategy = Strategy.DIGITAL,
     **strategy_args: Any,
 ) -> AbstractBlock:
@@ -24,11 +23,11 @@ def hea(
     Factory function for the Hardware Efficient Ansatz (HEA).
 
     Args:
-        n_qubits: number of qubits in the block
+        n_qubits: number of qubits in the circuit
         depth: number of layers of the HEA
         param_prefix: the base name of the variational parameters
-        support: qubit indexes where the HEA is applied
-        strategy: Strategy.Digital or Strategy.DigitalAnalog
+        support: qubit indices where the HEA is applied
+        strategy: Strategy for the ansatz. One of the Strategy variants.
         **strategy_args: see below
 
     Keyword Arguments:
@@ -42,10 +41,13 @@ def hea(
             - Digital: 2-qubit entangling operation. Supports CNOT, CZ,
             CRX, CRY, CRZ, CPHASE. Controlled rotations will have variational
             parameters on the rotation angles.
-            - DigitaAnalog | Analog: Hamiltonian generator for the
+            - SDAQC | Analog: Hamiltonian generator for the
             analog entangling layer. Defaults to global ZZ Hamiltonian.
             Time parameter is considered variational.
 
+    Returns:
+        The Hardware Efficient Ansatz (HEA) circuit.
+
     Examples:
     ```python exec="on" source="material-block" result="json"
     from qadence import RZ, RX
@@ -97,10 +99,21 @@ def _rotations_digital(
     n_qubits: int,
     depth: int,
     param_prefix: str = "theta",
-    support: tuple[int, ...] = None,
+    support: tuple[int, ...] | None = None,
     operations: list[Type[AbstractBlock]] = [RX, RY, RX],
 ) -> list[AbstractBlock]:
-    """Creates the layers of single qubit rotations in an HEA."""
+    """Creates the layers of single qubit rotations in an HEA.
+
+    Args:
+        n_qubits: The number of qubits in the HEA.
+        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 in the HEA.
+    """
     if support is None:
         support = tuple(range(n_qubits))
     iterator = itertools.count()
@@ -123,23 +136,50 @@ def _entangler(
     param_str: str,
     op: Type[DigitalEntanglers] = CNOT,
 ) -> AbstractBlock:
+    """
+    Create a 2-qubit operation for the digital HEA.
+
+    Args:
+        control (int): control qubit index
+        target (int): target qubit index
+        param_str (str): base for naming the variational parameter if parametric block
+        op (Type[DigitalEntanglers]): 2-qubit operation (CNOT, CZ, CRX, CRY, CRZ or CPHASE)
+
+    Returns:
+        The 2-qubit digital entangler for the HEA.
+    """
     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 HEA.")
+        raise ValueError("Provided entangler not accepted for digital ansatz")
 
 
 def _entanglers_digital(
     n_qubits: int,
     depth: int,
     param_prefix: str = "theta",
-    support: tuple[int, ...] = None,
+    support: tuple[int, ...] | None = None,
     periodic: bool = False,
     entangler: Type[DigitalEntanglers] = CNOT,
 ) -> list[AbstractBlock]:
-    """Creates the layers of digital entangling operations in an HEA."""
+    """Creates the layers of digital entangling operations in an HEA.
+
+    Args:
+        n_qubits (int): number of qubits in the block.
+        depth (int): number of layers of the HEA.
+        param_prefix (str): the base name of the variational parameters
+        support (tuple): qubit indices where the HEA is applied.
+        periodic (bool): if the qubits should be linked periodically.
+            periodic=False is not supported in emu-c.
+        entangler (AbstractBlock): 2-qubit entangling operation.
+            Supports CNOT, CZ, CRX, CRY, CRZ. Controlld rotations
+            will have variational parameters on the rotation angles.
+
+    Returns:
+        The entanglers for the digital Hardware Efficient Ansatz (HEA).
+    """
     if support is None:
         support = tuple(range(n_qubits))
     iterator = itertools.count()
@@ -179,26 +219,29 @@ def hea_digital(
     n_qubits: int,
     depth: int = 1,
     param_prefix: str = "theta",
+    support: tuple[int, ...] | None = None,
     periodic: bool = False,
     operations: list[type[AbstractBlock]] = [RX, RY, RX],
-    support: tuple[int, ...] = None,
     entangler: Type[DigitalEntanglers] = CNOT,
 ) -> AbstractBlock:
     """
     Construct the Digital Hardware Efficient Ansatz (HEA).
 
     Args:
-        n_qubits (int): number of qubits in the block.
+        n_qubits (int): number of qubits in the cricuit.
         depth (int): number of layers of the HEA.
         param_prefix (str): the base name of the variational parameters
+        support (tuple): qubit indices where the HEA is applied.
         periodic (bool): if the qubits should be linked periodically.
             periodic=False is not supported in emu-c.
         operations (list): list of operations to cycle through in the
             digital single-qubit rotations of each layer.
-        support (tuple): qubit indexes where the HEA is applied.
         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 Hardware Efficient Ansatz (HEA) circuit.
     """
     try:
         if entangler not in [CNOT, CZ, CRX, CRY, CRZ, CPHASE]:
@@ -242,15 +285,26 @@ def _entanglers_analog(
     param_prefix: str = "theta",
     entangler: AbstractBlock | None = None,
 ) -> list[AbstractBlock]:
-    return [HamEvo(entangler, param_prefix + f"_t_{d}") for d in range(depth)]
+    """
+    Creates the entanglers for the sDAQC.
+
+    Args:
+        depth: The number of layers of entanglers.
+        param_prefix: The prefix for the parameter names.
+        entangler: The entangler to use.
+
+    Returns:
+        A list of analog entanglers for sDAQC HEA.
+    """
+    return [HamEvo(entangler, param_prefix + f"_t_{d}") for d in range(depth)]  # type: ignore
 
 
 def hea_sDAQC(
     n_qubits: int,
     depth: int = 1,
     param_prefix: str = "theta",
+    support: tuple[int, ...] | None = None,
     operations: list[type[AbstractBlock]] = [RX, RY, RX],
-    support: tuple[int, ...] = None,
     entangler: AbstractBlock | None = None,
 ) -> AbstractBlock:
     """
@@ -259,15 +313,18 @@ def hea_sDAQC(
     It uses step-wise digital-analog computation.
 
     Args:
-        n_qubits (int): number of qubits in the block.
+        n_qubits (int): number of qubits in the circuit.
         depth (int): number of layers of the HEA.
         param_prefix (str): the base name of the variational parameters
+        support (tuple): qubit indices where the HEA is applied.
         operations (list): list of operations to cycle through in the
             digital single-qubit rotations of each layer.
-        support (tuple): qubit indexes where the HEA is applied.
         entangler (AbstractBlock): Hamiltonian generator for the
             analog entangling layer. Defaults to global ZZ Hamiltonian.
             Time parameter is considered variational.
+
+    Returns:
+        The step-wise digital-analog Hardware Efficient Ansatz (sDA HEA) circuit.
     """
 
     # TODO: Add qubit support
@@ -320,179 +377,3 @@ def hea_bDAQC(*args: Any, **kwargs: Any) -> Any:
 
 def hea_analog(*args: Any, **kwargs: Any) -> Any:
     raise NotImplementedError
-
-
-def alt(
-    n_qubits: int,
-    m_block_qubits: int,
-    depth: int = 1,
-    param_prefix: str = "theta",
-    support: tuple[int, ...] = None,
-    strategy: Strategy = Strategy.DIGITAL,
-    **strategy_args: Any,
-) -> AbstractBlock:
-    """
-    Factory function for the alternating layer ansatz (alt).
-
-    Args:
-        n_qubits: number of qubits in the block
-        m_block_qubits: number of qubits in the local entangling block
-        depth: number of layers of the alt
-        param_prefix: the base name of the variational parameters
-        support: qubit indexes where the alt is applied
-        strategy: Strategy.Digital or Strategy.DigitalAnalog
-        **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.
-    """
-
-    if support is None:
-        support = tuple(range(n_qubits))
-
-    alt_func_dict = {
-        Strategy.DIGITAL: alt_digital,
-        Strategy.SDAQC: alt_sDAQC,
-        Strategy.BDAQC: alt_bDAQC,
-        Strategy.ANALOG: alt_analog,
-    }
-
-    try:
-        alt_func = alt_func_dict[strategy]
-    except KeyError:
-        raise KeyError(f"Strategy {strategy} not recognized.")
-
-    hea_block: AbstractBlock = alt_func(
-        n_qubits=n_qubits,
-        m_block_qubits=m_block_qubits,
-        depth=depth,
-        param_prefix=param_prefix,
-        support=support,
-        **strategy_args,
-    )  # type: ignore
-
-    return hea_block
-
-
-#################
-## DIGITAL ALT ##
-#################
-
-
-def _entanglers_block_digital(
-    n_qubits: int,
-    m_block_qubits: int,
-    depth: int,
-    param_prefix: str = "theta",
-    support: tuple[int, ...] = None,
-    entangler: Type[DigitalEntanglers] = CNOT,
-) -> list[AbstractBlock]:
-    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 alt_digital(
-    n_qubits: int,
-    m_block_qubits: int,
-    depth: int = 1,
-    support: tuple[int, ...] = None,
-    param_prefix: str = "theta",
-    operations: list[type[AbstractBlock]] = [RX, RY],
-    entangler: Type[DigitalEntanglers] = CNOT,
-) -> AbstractBlock:
-    """
-    Construct the digital alternating layer ansatz (ALT).
-
-    Args:
-        n_qubits (int): number of qubits in the ansatz.
-        m_block_qubits (int): number of qubits in the local entangling block.
-        depth (int): number of layers of the ALT.
-        param_prefix (str): the base name of the variational parameters
-        operations (list): list of operations to cycle through in the
-            digital single-qubit rotations of each layer.
-        support (tuple): qubit indexes where the ALT is applied.
-        entangler (AbstractBlock): 2-qubit entangling operation.
-            Supports CNOT, CZ, CRX, CRY, CRZ. Controlld rotations
-            will have variational parameters on the rotation angles.
-    """
-
-    try:
-        if entangler not in [CNOT, CZ, CRX, CRY, CRZ, CPHASE]:
-            raise ValueError(
-                "Please provide a valid two-qubit entangler operation for digital ALT."
-            )
-    except TypeError:
-        raise ValueError("Please provide a valid two-qubit entangler operation for digital ALT.")
-
-    rot_list = _rotations_digital(
-        n_qubits=n_qubits,
-        depth=depth,
-        support=support,
-        param_prefix=param_prefix,
-        operations=operations,
-    )
-
-    ent_list = _entanglers_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), "ALT")
-
-
-#################
-## sdaqc ALT ##
-#################
-def alt_sDAQC(*args: Any, **kwargs: Any) -> Any:
-    raise NotImplementedError
-
-
-#################
-## bdaqc ALT ##
-#################
-def alt_bDAQC(*args: Any, **kwargs: Any) -> Any:
-    raise NotImplementedError
-
-
-#################
-## analog ALT ##
-#################
-def alt_analog(*args: Any, **kwargs: Any) -> Any:
-    raise NotImplementedError

qadence/constructors/iia.py

@@ -32,6 +32,16 @@ def _entangler_analog(
     param_str: str,
     generator: AbstractBlock | None = None,
 ) -> AbstractBlock:
+    """
+    Creates the analog entangler for identity initialized ansatz.
+
+    Args:
+        param_str: The parameter string.
+        generator: The Hamiltonian generator for the analog entangler.
+
+    Returns:
+        The analog entangler for the identity initialized ansatz.
+    """
     param = Parameter(name=param_str, value=0.0, trainable=True)
     return HamEvo(generator=generator, parameter=param)
 
@@ -44,6 +54,21 @@ def _rotations(
     values: list[float | torch.Tensor],
     ops: list[type[AbstractBlock]] = [RX, RY],
 ) -> list[KronBlock]:
+    """
+    Creates the digital rotation layers for the identity initialized ansatz.
+
+    Args:
+        n_qubits: The number of qubits in the identity initialized ansatz.
+        layer: The layer number.
+        side: The side of the a single layer the rotations are applied to.
+            Either 'left' or 'right'.
+        param_str: The parameter string.
+        values: The values of the rotation angles.
+        ops: The operations to apply the rotations with.
+
+    Returns:
+        The digital rotation layers for the identity initialized ansatz.
+    """
     if side == "left":
         idx = lambda x: x  # noqa: E731
     elif side == "right":
@@ -106,6 +131,9 @@ def identity_initialized_ansatz(
                 Time parameter is considered variational.
                 Defaults to a global NN Hamiltonain.
         periodic (bool): if the qubits should be linked periodically. Valid only for digital.
+
+    Returns:
+        The identity initialized ansatz circuit.
     """
     initialized_layers = []
     for layer in range(depth):
@@ -212,3 +240,6 @@ def identity_initialized_ansatz(
         initialized_layers.append(tag(chain(*krons), tag=f"BPMA-{layer}"))
 
     return chain(*initialized_layers)
+
+
+iia = identity_initialized_ansatz

qadence/extensions.py

@@ -15,20 +15,16 @@ EngineClsType = TypeVar("EngineClsType", bound=DifferentiableBackend)
 logger = getLogger(__name__)
 
 
-class ConfigNotFoundError(ModuleNotFoundError):
-    ...
+class ConfigNotFoundError(ModuleNotFoundError): ...
 
 
-class BackendNotFoundError(ModuleNotFoundError):
-    ...
+class BackendNotFoundError(ModuleNotFoundError): ...
 
 
-class EngineNotFoundError(ModuleNotFoundError):
-    ...
+class EngineNotFoundError(ModuleNotFoundError): ...
 
 
-class SupportedGatesNotFoundError(ModuleNotFoundError):
-    ...
+class SupportedGatesNotFoundError(ModuleNotFoundError): ...
 
 
 def import_config(backend_name: str | BackendName) -> BackendConfiguration:

qadence/measurements/shadow.py

@@ -6,7 +6,7 @@ from torch import Tensor
 
 from qadence.backend import Backend
 from qadence.backends.pyqtorch import Backend as PyQBackend
-from qadence.blocks import AbstractBlock, KronBlock, chain, kron
+from qadence.blocks import AbstractBlock, KronBlock, kron
 from qadence.blocks.block_to_tensor import HMAT, IMAT, SDAGMAT
 from qadence.blocks.composite import CompositeBlock
 from qadence.blocks.primitive import PrimitiveBlock
@@ -16,7 +16,7 @@ from qadence.engines.differentiable_backend import DifferentiableBackend
 from qadence.measurements.utils import get_qubit_indices_for_op
 from qadence.noise import NoiseHandler
 from qadence.operations import H, I, SDagger, X, Y, Z
-from qadence.types import Endianness
+from qadence.types import BackendName, Endianness
 
 pauli_gates = [X, Y, Z]
 pauli_rotations = [
@@ -134,20 +134,40 @@ def classical_shadow(
     shadow: list = list()
     all_rotations = extract_operators(unitary_ids, circuit.n_qubits)
 
-    for i in range(shadow_size):
-        if all_rotations[i]:
-            rotated_circuit = QuantumCircuit(
-                circuit.register, chain(circuit.block, all_rotations[i])
+    initial_state = state
+    backend_name = backend.name if hasattr(backend, "name") else backend.backend.name
+    if backend_name == BackendName.PYQTORCH:
+        # run the initial circuit without rotations
+        # to save computation time
+        conv_circ = backend.circuit(circuit)
+        initial_state = backend.run(
+            circuit=conv_circ,
+            param_values=param_values,
+            state=state,
+            endianness=endianness,
+        )
+        all_rotations = [
+            QuantumCircuit(circuit.n_qubits, rots) if rots else QuantumCircuit(circuit.n_qubits)
+            for rots in all_rotations
+        ]
+    else:
+        all_rotations = [
+            (
+                QuantumCircuit(circuit.n_qubits, circuit.block, rots)
+                if rots
+                else QuantumCircuit(circuit.n_qubits, circuit.block)
             )
-        else:
-            rotated_circuit = circuit
+            for rots in all_rotations
+        ]
+
+    for i in range(shadow_size):
         # Reverse endianness to get sample bitstrings in ILO.
-        conv_circ = backend.circuit(rotated_circuit)
+        conv_circ = backend.circuit(all_rotations[i])
         batch_samples = backend.sample(
             circuit=conv_circ,
             param_values=param_values,
             n_shots=1,
-            state=state,
+            state=initial_state,
             noise=noise,
             endianness=endianness,
         )

qadence/ml_tools/constructors.py

@@ -13,13 +13,13 @@ from qadence.constructors import (
     analog_feature_map,
     feature_map,
     hamiltonian_factory,
-    identity_initialized_ansatz,
+    iia,
     rydberg_feature_map,
     rydberg_hea,
     rydberg_tower_feature_map,
 )
-from qadence.constructors.ansatze import hea_digital, hea_sDAQC
 from qadence.constructors.hamiltonians import ObservableConfig, TDetuning
+from qadence.constructors.hea import hea_digital, hea_sDAQC
 from qadence.measurements import Measurements
 from qadence.noise import NoiseHandler
 from qadence.operations import CNOT, RX, RY, I, N, Z
@@ -107,7 +107,8 @@ def _encode_features_series_digital(
     )
 
     support_arrays = {
-        key: support for key, support in zip(config.inputs, support_arrays_list)  # type: ignore[union-attr, arg-type]
+        key: support
+        for key, support in zip(config.inputs, support_arrays_list)  # type: ignore[union-attr, arg-type]
     }
 
     num_uploads = {key: value + 1 for key, value in config.num_repeats.items()}  # type: ignore[union-attr]
@@ -163,7 +164,8 @@ def _encode_features_parallel_digital(
     )
 
     support_arrays = {
-        key: support for key, support in zip(config.inputs, support_arrays_list)  # type: ignore[union-attr, arg-type]
+        key: support
+        for key, support in zip(config.inputs, support_arrays_list)  # type: ignore[union-attr, arg-type]
     }
 
     num_uploads = {key: value + 1 for key, value in config.num_repeats.items()}  # type: ignore[union-attr]
@@ -412,7 +414,7 @@ def _create_iia_digital(
     entangler = config.strategy_args.get("entangler", CNOT)
     periodic = config.strategy_args.get("periodic", False)
 
-    return identity_initialized_ansatz(
+    return iia(
         n_qubits=num_qubits,
         depth=config.depth,
         param_prefix=config.param_prefix,
@@ -441,7 +443,7 @@ def _create_iia_sdaqc(
     entangler = config.strategy_args.get("entangler", CNOT)
     periodic = config.strategy_args.get("periodic", False)
 
-    return identity_initialized_ansatz(
+    return iia(
         n_qubits=num_qubits,
         depth=config.depth,
         param_prefix=config.param_prefix,

qadence/ml_tools/trainer.py

@@ -632,10 +632,12 @@ class Trainer(BaseTrainer):
 
     def build_optimize_result(
         self,
-        result: None
-        | tuple[torch.Tensor, dict[Any, Any]]
-        | list[tuple[torch.Tensor, dict[Any, Any]]]
-        | list[list[tuple[torch.Tensor, dict[Any, Any]]]],
+        result: (
+            None
+            | tuple[torch.Tensor, dict[Any, Any]]
+            | list[tuple[torch.Tensor, dict[Any, Any]]]
+            | list[list[tuple[torch.Tensor, dict[Any, Any]]]]
+        ),
     ) -> None:
         """
         Builds and stores the optimization result by calculating the average loss and metrics.

qadence/operations/control_ops.py

@@ -119,9 +119,7 @@ class MCRX(ParametricControlBlock):
 
     @property
     def eigenvalues_generator(self) -> Tensor:
-        return torch.cat(
-            (torch.zeros(2**self.n_qubits - 2), torch.tensor([1, -1], dtype=cdouble))
-        )
+        return torch.cat((torch.zeros(2**self.n_qubits - 2), torch.tensor([1, -1], dtype=cdouble)))
 
     @property
     def eigenvalues(self) -> Tensor:
@@ -164,9 +162,7 @@ class MCRY(ParametricControlBlock):
 
     @property
     def eigenvalues_generator(self) -> Tensor:
-        return torch.cat(
-            (torch.zeros(2**self.n_qubits - 2), torch.tensor([1, -1], dtype=cdouble))
-        )
+        return torch.cat((torch.zeros(2**self.n_qubits - 2), torch.tensor([1, -1], dtype=cdouble)))
 
     @property
     def eigenvalues(self) -> Tensor:
@@ -205,9 +201,7 @@ class MCRZ(ParametricControlBlock):
 
     @property
     def eigenvalues_generator(self) -> Tensor:
-        return torch.cat(
-            (torch.zeros(2**self.n_qubits - 2), torch.tensor([1, -1], dtype=cdouble))
-        )
+        return torch.cat((torch.zeros(2**self.n_qubits - 2), torch.tensor([1, -1], dtype=cdouble)))
 
     @property
     def eigenvalues(self) -> Tensor: