qadence 1.5.2__py3-none-any.whl → 1.6.1__py3-none-any.whl

qadence/backends/pyqtorch/convert_ops.py

@@ -4,7 +4,7 @@ from functools import reduce
 from itertools import chain as flatten
 from math import prod
 from operator import add
-from typing import Any, Sequence, Tuple
+from typing import Any, Iterable, Sequence, Tuple
 
 import pyqtorch as pyq
 import sympy
@@ -203,20 +203,36 @@ class PyQComposedBlock(pyq.QuantumCircuit):
         n_qubits: int,
         config: Configuration = None,
     ):
-        """Compose a chain of single qubit operations on the same qubit into a single.
+        """
+        Merge operations that are adjacent and have identical qubit_support.
 
-        call to _apply_batch_gate.
+        It results in fewer call of apply_operator
         """
         super().__init__(n_qubits, ops)
         self.qubits = qubits
+        self.merged_qubits_support = [
+            grouped_op[-1].qubit_support for grouped_op in self.grouped_operations()
+        ]
 
-    def forward(self, state: Tensor, values: dict[str, Tensor] | None = None) -> Tensor:
-        batch_size = infer_batchsize(values)
-        return apply_operator(
-            state, self.unitary(values, batch_size), self.qubits, self.n_qubits, batch_size
-        )
+    def grouped_operations(self) -> list[list[Module]]:
+        # takes a list of operations and group adjacent operations into sublist
+        # if those operations have the same control qubits
+        def _sublist_grouper(x: Iterable[list[Module]], y: Module) -> list[list[Module]]:
+            # Appends the element y with the last sublist in the list x
+            # if they have the same qubit_support.
+            # Appends the element y as a new sublist to x if it has different qubit_domain
+            x = list(x)
+            if y.qubit_support == x[-1][-1].qubit_support:
+                x[-1].append(y)
+                return x
+            else:
+                x.append([y])
+                return x
 
-    def unitary(self, values: dict[str, Tensor] | None, batch_size: int) -> Tensor:
+        return list(reduce(_sublist_grouper, iter(self.operations[1:]), [[self.operations[0]]]))
+
+    def merged_unitary(self, values: dict[str, Tensor] | None, batch_size: int) -> list[Tensor]:
+        # compute the tensor multiplication of each group of operations
         batch_first_perm = (2, 0, 1)
         undo_perm = tuple(argsort(tensor(batch_first_perm)))
 
@@ -225,7 +241,7 @@ class PyQComposedBlock(pyq.QuantumCircuit):
                 m = m.unsqueeze(2).repeat(
                     1, 1, batch_size
                 )  # Primitive gates are 2D, so we expand them.
-            elif m.shape != (2, 2, batch_size):
+            elif m.shape != (2, 2, batch_size) and m.shape != (4, 4, batch_size):
                 m = m.repeat(1, 1, batch_size)  # In case a tensor is 3D doesnt have batch_size.
             return m
 
@@ -237,13 +253,21 @@ class PyQComposedBlock(pyq.QuantumCircuit):
                 m, undo_perm
             )  # We need to undo the permute since PyQ expects (2, 2, batch_size).
 
-        # We reverse the list of tensors here since matmul is not commutative.
+        def _list_wise_bmm(ops: list[Module]) -> Tensor:
+            # Takes a list of operations and apply torch.bmm to all the unitaries of the list
+            return _batch_last(
+                reduce(bmm, [_batch_first(_expand(op.unitary(values))) for op in reversed(ops)])
+            )  # We reverse the list of tensors here since matmul is not commutative.
 
-        return _batch_last(
-            reduce(
-                bmm,
-                (_batch_first(_expand(op.unitary(values))) for op in reversed(self.operations)),
-            )
+        return list(map(_list_wise_bmm, reversed(self.grouped_operations())))[::-1]
+
+    def forward(self, state: Tensor, values: dict[str, Tensor] | None = None) -> Tensor:
+        # compute evolution of the state by the list of operations
+        batch_size = infer_batchsize(values)
+        return reduce(
+            lambda y, x: apply_operator(state=y, operator=x[0], qubits=x[1]),
+            zip(self.merged_unitary(values, batch_size), self.merged_qubits_support),
+            state,
         )
 
 

qadence/blocks/block_to_tensor.py

@@ -62,7 +62,7 @@ def _fill_identities(
     full_qubit_support: tuple | list,
     diag_only: bool = False,
     endianness: Endianness = Endianness.BIG,
-    device: torch.device = torch.device("cpu"),
+    device: torch.device | None = None,
 ) -> torch.Tensor:
     """Returns a Kronecker product of a block matrix with identities.
 
@@ -181,12 +181,13 @@ def _controlled_block_with_params(
         AbstractBlock: redefined controlled rotation block
         dict with new parameters which are added
     """
-    from qadence.operations import I, Z
+    from qadence.operations import I
+    from qadence.utils import P1
 
     # redefine controlled rotation block in a way suitable for matrix evaluation
     control = block.qubit_support[:-1]
     target = block.qubit_support[-1]
-    p1 = kron(0.5 * I(qubit) + (-0.5) * Z(qubit) for qubit in control)
+    p1 = kron(P1(qubit) for qubit in control)
     p0 = I(control[0]) - p1
     c_block = kron(p0, I(target)) + kron(p1, block.blocks[0])
 
@@ -265,7 +266,7 @@ def block_to_diagonal(
     qubit_support: tuple | list | None = None,
     use_full_support: bool = True,
     endianness: Endianness = Endianness.BIG,
-    device: torch.device = torch.device("cpu"),
+    device: torch.device = None,
 ) -> torch.Tensor:
     if block.is_parametric:
         raise TypeError("Sparse observables cant be parametric.")
@@ -310,7 +311,7 @@ def block_to_tensor(
     use_full_support: bool = True,
     tensor_type: TensorType = TensorType.DENSE,
     endianness: Endianness = Endianness.BIG,
-    device: torch.device = torch.device("cpu"),
+    device: torch.device = None,
 ) -> torch.Tensor:
     """
     Convert a block into a torch tensor.
@@ -369,7 +370,7 @@ def _block_to_tensor_embedded(
     qubit_support: tuple | None = None,
     use_full_support: bool = True,
     endianness: Endianness = Endianness.BIG,
-    device: torch.device = torch.device("cpu"),
+    device: torch.device = None,
 ) -> torch.Tensor:
     from qadence.blocks import MatrixBlock
     from qadence.operations import CSWAP, SWAP, HamEvo

qadence/blocks/matrix.py

@@ -1,15 +1,15 @@
 from __future__ import annotations
 
 from functools import cached_property
+from logging import getLogger
 
 import numpy as np
 import torch
 from torch.linalg import eigvals
 
 from qadence.blocks import PrimitiveBlock
-from qadence.logger import get_logger
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 class MatrixBlock(PrimitiveBlock):

qadence/blocks/primitive.py

@@ -20,7 +20,6 @@ from qadence.parameters import (
     stringify,
 )
 from qadence.types import TParameter
-from qadence.utils import format_parameter
 
 
 class PrimitiveBlock(AbstractBlock):
@@ -258,6 +257,8 @@ class ScaleBlock(ParametricBlock):
 
     @property
     def _block_title(self) -> str:
+        from qadence.utils import format_parameter
+
         (scale,) = self.parameters.expressions()
         s = rf"\[mul: {format_parameter(scale)}] "
         return s

qadence/blocks/utils.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import typing
 from enum import Enum
 from itertools import chain as _flatten
+from logging import getLogger
 from typing import Generator, List, Type, TypeVar, Union, get_args
 
 from sympy import Array, Basic, Expr
@@ -29,10 +30,9 @@ from qadence.blocks.analog import (
 from qadence.blocks.analog import chain as analog_chain
 from qadence.blocks.analog import kron as analog_kron
 from qadence.exceptions import NotPauliBlockError
-from qadence.logger import get_logger
 from qadence.parameters import Parameter
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 TPrimitiveBlock = TypeVar("TPrimitiveBlock", bound=PrimitiveBlock)

qadence/circuit.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from itertools import chain as flatten
+from logging import getLogger
 from pathlib import Path
 from typing import Iterable
 
@@ -15,6 +16,8 @@ from qadence.register import Register
 # Modules to be automatically added to the qadence namespace
 __all__ = ["QuantumCircuit"]
 
+logger = getLogger(__name__)
+
 
 @dataclass(eq=False)  # Avoid unhashability errors due to mutable attributes.
 class QuantumCircuit:
@@ -167,7 +170,7 @@ class QuantumCircuit:
                 with open(path, "w") as file:
                     file.write(qc_dumped)
             except Exception as e:
-                print(f"Unable to write QuantumCircuit to disk due to {e}")
+                logger.error(f"Unable to write QuantumCircuit to disk due to {e}")
 
         return qc_dumped
 
@@ -199,6 +202,6 @@ class QuantumCircuit:
                 loaded_dict = json.load(file)
 
         except Exception as e:
-            print(f"Unable to load QuantumCircuit due to {e}")
+            logger.error(f"Unable to load QuantumCircuit due to {e}")
 
         return QuantumCircuit._from_dict(loaded_dict)

qadence/constructors/__init__.py

@@ -2,13 +2,10 @@
 
 from .feature_maps import (
     feature_map,
-    chebyshev_feature_map,
-    fourier_feature_map,
-    tower_feature_map,
     exp_fourier_feature_map,
 )
 
-from .ansatze import hea, build_qnn
+from .ansatze import hea
 
 from .iia import identity_initialized_ansatz
 
@@ -17,7 +14,6 @@ from .daqc import daqc_transform
 from .hamiltonians import (
     hamiltonian_factory,
     ising_hamiltonian,
-    single_z,
     total_magnetization,
     zz_hamiltonian,
 )
@@ -30,16 +26,11 @@ from .qft import qft
 # Modules to be automatically added to the qadence namespace
 __all__ = [
     "feature_map",
-    "chebyshev_feature_map",
-    "fourier_feature_map",
-    "tower_feature_map",
     "exp_fourier_feature_map",
     "hea",
     "identity_initialized_ansatz",
-    "build_qnn",
     "hamiltonian_factory",
     "ising_hamiltonian",
-    "single_z",
     "total_magnetization",
     "zz_hamiltonian",
     "qft",

qadence/constructors/ansatze.py

@@ -1,15 +1,13 @@
 from __future__ import annotations
 
 import itertools
-import warnings
-from typing import Any, Optional, Type, Union
+from typing import Any, Type, Union
 
 from qadence.blocks import AbstractBlock, block_is_qubit_hamiltonian, chain, kron, tag
 from qadence.operations import CNOT, CPHASE, CRX, CRY, CRZ, CZ, RX, RY, HamEvo
 from qadence.types import Interaction, Strategy
 
 from .hamiltonians import hamiltonian_factory
-from .utils import build_idx_fms
 
 DigitalEntanglers = Union[CNOT, CZ, CRZ, CRY, CRX]
 
@@ -322,65 +320,3 @@ def hea_bDAQC(*args: Any, **kwargs: Any) -> Any:
 
 def hea_analog(*args: Any, **kwargs: Any) -> Any:
     raise NotImplementedError
-
-
-#########
-## QNN ##
-#########
-
-
-# FIXME: Remove in v1.5.0
-def build_qnn(
-    n_qubits: int,
-    n_features: int,
-    depth: int = None,
-    ansatz: Optional[AbstractBlock] = None,
-    fm_pauli: Type[RY] = RY,
-    spectrum: str = "simple",
-    basis: str = "fourier",
-    fm_strategy: str = "parallel",
-) -> list[AbstractBlock]:
-    """Helper function to build a qadence QNN quantum circuit.
-
-    Args:
-        n_qubits (int): The number of qubits.
-        n_features (int): The number of input dimensions.
-        depth (int): The depth of the ansatz.
-        ansatz (Optional[AbstractBlock]):  An optional argument to pass a custom qadence ansatz.
-        fm_pauli (str): The type of Pauli gate for the feature map. Must be one of 'RX',
-            'RY', or 'RZ'.
-        spectrum (str): The desired spectrum of the feature map generator. The options simple,
-            tower and exponential produce a spectrum with linear, quadratic and exponential
-            eigenvalues with respect to the number of qubits.
-        basis (str): The encoding function. The options fourier and chebyshev correspond to Φ(x)=x
-            and arcos(x) respectively.
-        fm_strategy (str): The feature map encoding strategy. If "parallel", the features
-            are encoded in one block of rotation gates, with each feature given
-            an equal number of qubits. If "serial", the features are encoded
-            sequentially, with a HEA block between.
-
-    Returns:
-        A list of Abstract blocks to be used for constructing a quantum circuit
-    """
-
-    warnings.warn("Function build_qnn is deprecated and will be removed in v1.5.0.", FutureWarning)
-
-    depth = n_qubits if depth is None else depth
-
-    idx_fms = build_idx_fms(basis, fm_pauli, fm_strategy, n_features, n_qubits, spectrum)
-
-    if fm_strategy == "parallel":
-        _fm = kron(*idx_fms)
-        fm = tag(_fm, tag="FM")
-
-    elif fm_strategy == "serial":
-        fm_components: list[AbstractBlock] = []
-        for j, fm_idx in enumerate(idx_fms[:-1]):
-            fm_idx = tag(fm_idx, tag=f"FM{j}")  # type: ignore[assignment]
-            fm_component = (fm_idx, hea(n_qubits, 1, f"theta_{j}"))
-            fm_components.extend(fm_component)
-        fm_components.append(tag(idx_fms[-1], tag=f"FM{len(idx_fms) - 1}"))
-        fm = chain(*fm_components)  # type: ignore[assignment]
-
-    ansatz = hea(n_qubits, depth=depth) if ansatz is None else ansatz
-    return [fm, ansatz]

qadence/constructors/daqc/daqc.py

@@ -1,18 +1,19 @@
 from __future__ import annotations
 
+from logging import getLogger
+
 import torch
 
 from qadence.blocks import AbstractBlock, add, chain, kron
 from qadence.blocks.utils import block_is_qubit_hamiltonian
 from qadence.constructors.hamiltonians import hamiltonian_factory
-from qadence.logger import get_logger
 from qadence.operations import HamEvo, I, N, X
 from qadence.types import GenDAQC, Interaction, Strategy
 
 from .gen_parser import _check_compatibility, _parse_generator
 from .utils import _build_matrix_M, _ix_map
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 def daqc_transform(

qadence/constructors/daqc/gen_parser.py

@@ -1,17 +1,18 @@
 from __future__ import annotations
 
+from logging import getLogger
+
 import torch
 
 from qadence.blocks import AbstractBlock, KronBlock
 from qadence.blocks.utils import unroll_block_with_scaling
-from qadence.logger import get_logger
 from qadence.operations import N, Z
 from qadence.parameters import Parameter, evaluate
 from qadence.types import GenDAQC
 
 from .utils import _ix_map
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 def _parse_generator(

qadence/constructors/daqc/utils.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
-import torch
+from logging import getLogger
 
-from qadence.logger import get_logger
+import torch
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 def _k_d(a: int, b: int) -> int:

qadence/constructors/feature_maps.py

@@ -1,19 +1,18 @@
 from __future__ import annotations
 
-import warnings
 from collections.abc import Callable
+from logging import getLogger
 from math import isclose
 from typing import Union
 
 from sympy import Basic, acos
 
 from qadence.blocks import AbstractBlock, KronBlock, chain, kron, tag
-from qadence.logger import get_logger
 from qadence.operations import PHASE, RX, RY, RZ, H
 from qadence.parameters import FeatureParameter, Parameter, VariationalParameter
 from qadence.types import PI, BasisSet, ReuploadScaling, TParameter
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 ROTATIONS = [RX, RY, RZ, PHASE]
 RotationTypes = type[Union[RX, RY, RZ, PHASE]]
@@ -35,28 +34,6 @@ RS_FUNC_DICT = {
 }
 
 
-# FIXME: Remove in v1.5.0
-def backwards_compatibility(
-    fm_type: BasisSet | Callable | str,
-    reupload_scaling: ReuploadScaling | Callable | str,
-) -> tuple:
-    if fm_type in ("fourier", "chebyshev", "tower"):
-        logger.warning(
-            "Selecting `fm_type` as 'fourier', 'chebyshev' or 'tower' is deprecated. "
-            "Please use the respective enumerations: 'fm_type = BasisSet.FOURIER', "
-            "'fm_type = BasisSet.CHEBYSHEV' or 'reupload_scaling = ReuploadScaling.TOWER'."
-        )
-        if fm_type == "fourier":
-            fm_type = BasisSet.FOURIER
-        elif fm_type == "chebyshev":
-            fm_type = BasisSet.CHEBYSHEV
-        elif fm_type == "tower":
-            fm_type = BasisSet.CHEBYSHEV
-            reupload_scaling = ReuploadScaling.TOWER
-
-    return fm_type, reupload_scaling
-
-
 def fm_parameter_scaling(
     fm_type: BasisSet | Callable | str,
     param: Parameter | str = "phi",
@@ -195,9 +172,6 @@ def feature_map(
             f"Please provide one from {[rot.__name__ for rot in ROTATIONS]}."
         )
 
-    # Backwards compatibility
-    fm_type, reupload_scaling = backwards_compatibility(fm_type, reupload_scaling)
-
     scaled_fparam = fm_parameter_scaling(
         fm_type, param, feature_range=feature_range, target_range=target_range
     )
@@ -225,68 +199,6 @@ def feature_map(
     return fm
 
 
-# FIXME: Remove in v1.5.0
-def fourier_feature_map(
-    n_qubits: int, support: tuple[int, ...] = None, param: str = "phi", op: RotationTypes = RX
-) -> AbstractBlock:
-    """Construct a Fourier feature map.
-
-    Args:
-        n_qubits: number of qubits across which the FM is created
-        param: The base name for the feature `Parameter`
-    """
-    warnings.warn(
-        "Function 'fourier_feature_map' is deprecated. Please use 'feature_map' directly.",
-        FutureWarning,
-    )
-    fm = feature_map(n_qubits, support=support, param=param, op=op, fm_type=BasisSet.FOURIER)
-    return fm
-
-
-# FIXME: Remove in v1.5.0
-def chebyshev_feature_map(
-    n_qubits: int, support: tuple[int, ...] = None, param: str = "phi", op: RotationTypes = RX
-) -> AbstractBlock:
-    """Construct a Chebyshev feature map.
-
-    Args:
-        n_qubits: number of qubits across which the FM is created
-        support (Iterable[int]): The qubit support
-        param: The base name for the feature `Parameter`
-    """
-    warnings.warn(
-        "Function 'chebyshev_feature_map' is deprecated. Please use 'feature_map' directly.",
-        FutureWarning,
-    )
-    fm = feature_map(n_qubits, support=support, param=param, op=op, fm_type=BasisSet.CHEBYSHEV)
-    return fm
-
-
-# FIXME: Remove in v1.5.0
-def tower_feature_map(
-    n_qubits: int, support: tuple[int, ...] = None, param: str = "phi", op: RotationTypes = RX
-) -> AbstractBlock:
-    """Construct a Chebyshev tower feature map.
-
-    Args:
-        n_qubits: number of qubits across which the FM is created
-        param: The base name for the feature `Parameter`
-    """
-    warnings.warn(
-        "Function 'tower_feature_map' is deprecated. Please use feature_map directly.",
-        FutureWarning,
-    )
-    fm = feature_map(
-        n_qubits,
-        support=support,
-        param=param,
-        op=op,
-        fm_type=BasisSet.CHEBYSHEV,
-        reupload_scaling=ReuploadScaling.TOWER,
-    )
-    return fm
-
-
 def exp_fourier_feature_map(
     n_qubits: int,
     support: tuple[int, ...] = None,

qadence/constructors/hamiltonians.py

@@ -1,17 +1,17 @@
 from __future__ import annotations
 
+from logging import getLogger
 from typing import Callable, List, Type, Union
 
 import numpy as np
 from torch import Tensor, double, ones, rand
 
 from qadence.blocks import AbstractBlock, add, block_is_qubit_hamiltonian
-from qadence.logger import get_logger
 from qadence.operations import N, X, Y, Z
 from qadence.register import Register
 from qadence.types import Interaction, TArray
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 
 def interaction_zz(i: int, j: int) -> AbstractBlock:
@@ -207,10 +207,6 @@ def total_magnetization(n_qubits: int, z_terms: np.ndarray | list | None = None)
     return hamiltonian_factory(n_qubits, detuning=Z, detuning_strength=z_terms)
 
 
-def single_z(qubit: int = 0, z_coefficient: float = 1.0) -> AbstractBlock:
-    return Z(qubit) * z_coefficient
-
-
 def zz_hamiltonian(
     n_qubits: int,
     z_terms: np.ndarray | None = None,

qadence/constructors/rydberg_feature_maps.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from logging import getLogger
 from typing import Callable
 
 import numpy as np
@@ -7,12 +8,11 @@ from sympy import Basic
 
 from qadence.blocks import AnalogBlock, KronBlock, kron
 from qadence.constructors.feature_maps import fm_parameter_func, fm_parameter_scaling
-from qadence.logger import get_logger
 from qadence.operations import AnalogRot, AnalogRX, AnalogRY, AnalogRZ
 from qadence.parameters import FeatureParameter, Parameter, VariationalParameter
 from qadence.types import PI, BasisSet, ReuploadScaling, TParameter
 
-logger = get_logger(__file__)
+logger = getLogger(__name__)
 
 AnalogRotationTypes = [AnalogRX, AnalogRY, AnalogRZ]
 

qadence/decompose.py

@@ -2,20 +2,20 @@ from __future__ import annotations
 
 import itertools
 from enum import Enum
+from logging import getLogger
 from typing import Any, List, Tuple, Union
 
 import sympy
 
 from qadence.blocks import AbstractBlock
 from qadence.blocks.utils import get_pauli_blocks, unroll_block_with_scaling
-from qadence.logger import get_logger
 from qadence.parameters import Parameter, evaluate
 
 # from qadence.types import TNumber, TParameter
 from qadence.types import PI
 from qadence.types import LTSOrder as Order
 
-logger = get_logger(__name__)
+logger = getLogger(__name__)
 
 # flatten a doubly-nested list
 flatten = lambda a: list(itertools.chain(*a))  # noqa: E731

qadence/engines/torch/differentiable_expectation.py

@@ -45,6 +45,13 @@ class PSRExpectation(Function):
         expectation_values = expectation_fn(param_values=param_dict(param_keys, param_values))  # type: ignore[call-arg] # noqa: E501
         # Stack batches of expectations if so.
         if isinstance(expectation_values, list):
+            # Check for first element being a list in case of noisy simulations in Pulser.
+            if isinstance(expectation_values[0], list):
+                exp_vals: list = []
+                for expectation_value in expectation_values:
+                    res = list(map(lambda x: x.get_final_state().data.toarray(), expectation_value))
+                    exp_vals.append(torch.tensor(res))
+                expectation_values = exp_vals
             return torch.stack(expectation_values)
         else:
             return expectation_values