qadence 1.7.5__py3-none-any.whl → 1.7.6__py3-none-any.whl

qadence/backends/gpsr.py

@@ -10,14 +10,30 @@ from qadence.types import PI
 from qadence.utils import _round_complex
 
 
-def general_psr(spectrum: Tensor, shift_prefac: float = 0.5) -> Callable:
+def general_psr(spectrum: Tensor, n_eqs: int | None = None, shift_prefac: float = 0.5) -> Callable:
+    """Define whether single_gap_psr or multi_gap_psr is used.
+
+    Args:
+        spectrum (Tensor): Spectrum of the operation we apply PSR onto.
+        n_eqs (int | None, optional): Number of equations. Defaults to None.
+            If provided, we keep the n_eqs higher spectral gaps.
+        shift_prefac (float, optional): Shift prefactor. Defaults to 0.5.
+
+    Returns:
+        Callable: single_gap_psr or multi_gap_psr function for
+            concerned operation.
+    """
     diffs = _round_complex(spectrum - spectrum.reshape(-1, 1))
     sorted_unique_spectral_gaps = torch.unique(torch.abs(torch.tril(diffs)))
 
     # We have to filter out zeros
     sorted_unique_spectral_gaps = sorted_unique_spectral_gaps[sorted_unique_spectral_gaps > 0]
-    n_eqs = len(sorted_unique_spectral_gaps)
-    sorted_unique_spectral_gaps = torch.tensor(list(sorted_unique_spectral_gaps))
+    n_eqs = (
+        len(sorted_unique_spectral_gaps)
+        if n_eqs is None
+        else min(n_eqs, len(sorted_unique_spectral_gaps))
+    )
+    sorted_unique_spectral_gaps = torch.tensor(list(sorted_unique_spectral_gaps)[:n_eqs])
 
     if n_eqs == 1:
         return single_gap_psr

qadence/backends/pyqtorch/convert_ops.py

@@ -7,7 +7,6 @@ from typing import Any, Sequence, Tuple
 import pyqtorch as pyq
 import sympy
 import torch
-from pyqtorch.apply import apply_operator
 from pyqtorch.embed import Embedding
 from pyqtorch.matrices import _dagger
 from pyqtorch.time_dependent.sesolve import sesolve
@@ -45,7 +44,6 @@ from qadence.blocks import (
 )
 from qadence.blocks.block_to_tensor import (
     _block_to_tensor_embedded,
-    block_to_tensor,
 )
 from qadence.blocks.primitive import ProjectorBlock
 from qadence.blocks.utils import parameters
@@ -78,6 +76,14 @@ def is_single_qubit_chain(block: AbstractBlock) -> bool:
     )
 
 
+def extract_parameter(block: ScaleBlock | ParametricBlock, config: Configuration) -> str | Tensor:
+    return (
+        tensor([block.parameters.parameter], dtype=float64)
+        if not block.is_parametric
+        else config.get_param_name(block)[0]
+    )
+
+
 def convert_block(
     block: AbstractBlock, n_qubits: int = None, config: Configuration = None
 ) -> Sequence[Module | Tensor | str | sympy.Expr]:
@@ -94,29 +100,43 @@ def convert_block(
 
     if isinstance(block, ScaleBlock):
         scaled_ops = convert_block(block.block, n_qubits, config)
-        scale = (
-            tensor([block.parameters.parameter], dtype=float64)
-            if not block.is_parametric
-            else config.get_param_name(block)[0]
-        )
+        scale = extract_parameter(block, config)
         return [pyq.Scale(pyq.Sequence(scaled_ops), scale)]
 
     elif isinstance(block, TimeEvolutionBlock):
-        # TODO add native pyq hamevo
-        # generator = convert_block(block.generator, n_qubits, config)[0]  # type: ignore[arg-type]
-        # time_param = config.get_param_name(block)[0]
-        # is_parametric = (
-        #     block.generator.is_parametric if isinstance(block.generator, AbstractBlock) else False
-        # )
-        # return [
-        #     pyq.HamiltonianEvolution(
-        #         qubit_support=qubit_support,
-        #         generator=generator,
-        #         time=time_param,
-        #         generator_parametric=is_parametric,  # type: ignore[union-attr]
-        #     )
-        # ]
-        return [PyQHamiltonianEvolution(qubit_support, n_qubits, block, config)]
+        if getattr(block.generator, "is_time_dependent", False):
+            return [PyQTimeDependentEvolution(qubit_support, n_qubits, block, config)]
+        else:
+            if isinstance(block.generator, sympy.Basic):
+                generator = config.get_param_name(block)[1]
+            elif isinstance(block.generator, Tensor):
+                m = block.generator.to(dtype=cdouble)
+                generator = convert_block(
+                    MatrixBlock(
+                        m,
+                        qubit_support=qubit_support,
+                        check_unitary=False,
+                        check_hermitian=True,
+                    )
+                )[0]
+            else:
+                generator = convert_block(block.generator, n_qubits, config)[0]  # type: ignore[arg-type]
+            time_param = config.get_param_name(block)[0]
+            is_parametric = (
+                block.generator.is_parametric
+                if isinstance(block.generator, AbstractBlock)
+                else False
+            )
+            return [
+                pyq.HamiltonianEvolution(
+                    qubit_support=qubit_support,
+                    generator=generator,
+                    time=time_param,
+                    generator_parametric=is_parametric,  # type: ignore[union-attr]
+                    cache_length=0,
+                )
+            ]
+
     elif isinstance(block, MatrixBlock):
         return [pyq.primitives.Primitive(block.matrix, block.qubit_support)]
     elif isinstance(block, CompositeBlock):
@@ -142,14 +162,14 @@ def convert_block(
             if isinstance(block, U):
                 op = pyq_cls(qubit_support[0], *config.get_param_name(block))
             else:
-                op = pyq_cls(qubit_support[0], config.get_param_name(block)[0])
+                op = pyq_cls(qubit_support[0], extract_parameter(block, config))
         else:
             op = pyq_cls(qubit_support[0])
         return [op]
     elif isinstance(block, tuple(two_qubit_gateset)):
         pyq_cls = getattr(pyq, block.name)
         if isinstance(block, ParametricBlock):
-            op = pyq_cls(qubit_support[0], qubit_support[1], config.get_param_name(block)[0])
+            op = pyq_cls(qubit_support[0], qubit_support[1], extract_parameter(block, config))
         else:
             op = pyq_cls(qubit_support[0], qubit_support[1])
         return [op]
@@ -157,7 +177,7 @@ def convert_block(
         block_name = block.name[1:] if block.name.startswith("M") else block.name
         pyq_cls = getattr(pyq, block_name)
         if isinstance(block, ParametricBlock):
-            op = pyq_cls(qubit_support[:-1], qubit_support[-1], config.get_param_name(block)[0])
+            op = pyq_cls(qubit_support[:-1], qubit_support[-1], extract_parameter(block, config))
         else:
             if "CSWAP" in block_name:
                 op = pyq_cls(qubit_support[:-2], qubit_support[-2:])
@@ -172,7 +192,7 @@ def convert_block(
         )
 
 
-class PyQHamiltonianEvolution(Module):
+class PyQTimeDependentEvolution(Module):
     def __init__(
         self,
         qubit_support: Tuple[int, ...],
@@ -188,50 +208,17 @@ class PyQHamiltonianEvolution(Module):
         self.hmat: Tensor
         self.config = config
 
-        if isinstance(block.generator, AbstractBlock) and not block.generator.is_parametric:
-            hmat = block_to_tensor(
-                block.generator,
-                qubit_support=self.qubit_support,
-                use_full_support=False,
-            )
-            hmat = hmat.permute(1, 2, 0)
-            self.register_buffer("hmat", hmat)
-            self._hamiltonian = lambda self, values: self.hmat
-
-        elif isinstance(block.generator, Tensor):
-            m = block.generator.to(dtype=cdouble)
-            hmat = block_to_tensor(
-                MatrixBlock(
-                    m,
-                    qubit_support=block.qubit_support,
-                    check_unitary=False,
-                    check_hermitian=True,
-                ),
+        def _hamiltonian(self: PyQTimeDependentEvolution, values: dict[str, Tensor]) -> Tensor:
+            hmat = _block_to_tensor_embedded(
+                block.generator,  # type: ignore[arg-type]
+                values=values,
                 qubit_support=self.qubit_support,
                 use_full_support=False,
+                device=self.device,
             )
-            hmat = hmat.permute(1, 2, 0)
-            self.register_buffer("hmat", hmat)
-            self._hamiltonian = lambda self, values: self.hmat
-
-        elif isinstance(block.generator, sympy.Basic):
-            self._hamiltonian = (
-                lambda self, values: values[self.param_names[1]].squeeze(3).permute(1, 2, 0)
-            )
-            # FIXME Why are we squeezing
-        else:
-
-            def _hamiltonian(self: PyQHamiltonianEvolution, values: dict[str, Tensor]) -> Tensor:
-                hmat = _block_to_tensor_embedded(
-                    block.generator,  # type: ignore[arg-type]
-                    values=values,
-                    qubit_support=self.qubit_support,
-                    use_full_support=False,
-                    device=self.device,
-                )
-                return hmat.permute(1, 2, 0)
+            return hmat.permute(1, 2, 0)
 
-            self._hamiltonian = _hamiltonian
+        self._hamiltonian = _hamiltonian
 
         self._time_evolution = lambda values: values[self.param_names[0]]
         self._device: torch_device = (
@@ -322,59 +309,51 @@ class PyQHamiltonianEvolution(Module):
         values: dict[str, Tensor] | ParameterDict = dict(),
         embedding: Embedding | None = None,
     ) -> Tensor:
-        if getattr(self.block.generator, "is_time_dependent", False):  # type: ignore [union-attr]
-
-            def Ht(t: Tensor | float) -> Tensor:
-                # values dict has to change with new value of t
-                # initial value of a feature parameter inside generator block
-                # has to be inferred here
-                new_vals = dict()
-                for str_expr, val in values.items():
-                    expr = sympy.sympify(str_expr)
-                    t_symb = sympy.Symbol(self._get_time_parameter())
-                    free_symbols = expr.free_symbols
-                    if t_symb in free_symbols:
-                        # create substitution list for time and feature params
-                        subs_list = [(t_symb, t)]
-
-                        if len(free_symbols) > 1:
-                            # get feature param symbols
-                            feat_symbols = free_symbols.difference(set([t_symb]))
-
-                            # get feature param values
-                            feat_vals = values["orig_param_values"]
-
-                            # update substitution list with feature param values
-                            for fs in feat_symbols:
-                                subs_list.append((fs, feat_vals[str(fs)]))
-
-                        # evaluate expression with new time param value
-                        new_vals[str_expr] = torch.tensor(float(expr.subs(subs_list)))
-                    else:
-                        # expression doesn't contain time parameter - copy it as is
-                        new_vals[str_expr] = val
-
-                # get matrix form of generator
-                hmat = _block_to_tensor_embedded(
-                    self.block.generator,  # type: ignore[arg-type]
-                    values=new_vals,
-                    qubit_support=self.qubit_support,
-                    use_full_support=False,
-                    device=self.device,
-                ).squeeze(0)
-
-                return hmat
-
-            tsave = torch.linspace(0, self.block.duration, self.config.n_steps_hevo)  # type: ignore [attr-defined]
-            result = pyqify(
-                sesolve(Ht, unpyqify(state).T[:, 0:1], tsave, self.config.ode_solver).states[-1].T
-            )
-        else:
-            result = apply_operator(
-                state,
-                self.unitary(values),
-                self.qubit_support,
-            )
+        def Ht(t: Tensor | float) -> Tensor:
+            # values dict has to change with new value of t
+            # initial value of a feature parameter inside generator block
+            # has to be inferred here
+            new_vals = dict()
+            for str_expr, val in values.items():
+                expr = sympy.sympify(str_expr)
+                t_symb = sympy.Symbol(self._get_time_parameter())
+                free_symbols = expr.free_symbols
+                if t_symb in free_symbols:
+                    # create substitution list for time and feature params
+                    subs_list = [(t_symb, t)]
+
+                    if len(free_symbols) > 1:
+                        # get feature param symbols
+                        feat_symbols = free_symbols.difference(set([t_symb]))
+
+                        # get feature param values
+                        feat_vals = values["orig_param_values"]
+
+                        # update substitution list with feature param values
+                        for fs in feat_symbols:
+                            subs_list.append((fs, feat_vals[str(fs)]))
+
+                    # evaluate expression with new time param value
+                    new_vals[str_expr] = torch.tensor(float(expr.subs(subs_list)))
+                else:
+                    # expression doesn't contain time parameter - copy it as is
+                    new_vals[str_expr] = val
+
+            # get matrix form of generator
+            hmat = _block_to_tensor_embedded(
+                self.block.generator,  # type: ignore[arg-type]
+                values=new_vals,
+                qubit_support=self.qubit_support,
+                use_full_support=False,
+                device=self.device,
+            ).squeeze(0)
+
+            return hmat
+
+        tsave = torch.linspace(0, self.block.duration, self.config.n_steps_hevo)  # type: ignore [attr-defined]
+        result = pyqify(
+            sesolve(Ht, unpyqify(state).T[:, 0:1], tsave, self.config.ode_solver).states[-1].T
+        )
 
         return result
 
@@ -386,7 +365,7 @@ class PyQHamiltonianEvolution(Module):
     def dtype(self) -> torch_dtype:
         return self._dtype
 
-    def to(self, *args: Any, **kwargs: Any) -> PyQHamiltonianEvolution:
+    def to(self, *args: Any, **kwargs: Any) -> PyQTimeDependentEvolution:
         if hasattr(self, "hmat"):
             self.hmat = self.hmat.to(*args, **kwargs)
             self._device = self.hmat.device

qadence/engines/torch/differentiable_expectation.py

@@ -231,8 +231,15 @@ class DifferentiableExpectation:
             if shift_factor == 1:
                 param_to_psr[param_id] = psr_fn(eigenvalues, **psr_args)
             else:
-                psr_args_factor = {k: v * shift_factor for k, v in psr_args.items()}
-                param_to_psr[param_id] = psr_fn(eigenvalues, **psr_args)
+                psr_args_factor = psr_args.copy()
+                if "shift_prefac" in psr_args_factor:
+                    if psr_args_factor["shift_prefac"] is not None:
+                        psr_args_factor["shift_prefac"] = (
+                            shift_factor * psr_args_factor["shift_prefac"]
+                        )
+                else:
+                    psr_args_factor["shift_prefac"] = shift_factor
+                param_to_psr[param_id] = psr_fn(eigenvalues, **psr_args_factor)
         for obs in observable:
             for param_id, _ in uuid_to_eigen(obs).items():
                 # We need the embedded fixed params of the observable in the param_values dict

{qadence-1.7.5.dist-info → qadence-1.7.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qadence
-Version: 1.7.5
+Version: 1.7.6
 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>
 License: Apache 2.0
@@ -22,7 +22,7 @@ Requires-Dist: matplotlib
 Requires-Dist: nevergrad
 Requires-Dist: numpy
 Requires-Dist: openfermion
-Requires-Dist: pyqtorch==1.4.3
+Requires-Dist: pyqtorch==1.4.4
 Requires-Dist: pyyaml
 Requires-Dist: rich
 Requires-Dist: scipy

{qadence-1.7.5.dist-info → qadence-1.7.6.dist-info}/RECORD

@@ -28,7 +28,7 @@ qadence/analog/hamiltonian_terms.py,sha256=9LKidqqEMJTTdXeaxkxP_otTmcv9i4yeJ-JKC
 qadence/analog/parse_analog.py,sha256=ppvMZtsKXOIkIehCgjbdmG9n232DIycSanyuyVth5Wg,4223
 qadence/backends/__init__.py,sha256=ibm7wmZxuIoMYAQxgAx0MsfLYWOVHNWgLwyS1HjMuuI,215
 qadence/backends/api.py,sha256=NPrvtZQ4klUBabUWJ5hbTUCVoaoW9-sHVbiXxAnTt3A,2643
-qadence/backends/gpsr.py,sha256=dTmXcOKm_kJywl2EPJbUIjkylRh3J7hfWQyhLDLXYZQ,4758
+qadence/backends/gpsr.py,sha256=3lcOHgt0soCiDXAyZ8DVyS8dMgUypIPwkDADds2boSE,5371
 qadence/backends/jax_utils.py,sha256=VfKhqCKknHDWZO21UFipWH_Lkiq175Z5GkP49gWjbyw,5038
 qadence/backends/utils.py,sha256=7gWiV_yJH3yyGFxwt-AQLEMLYkBX8aThvmFUlF0M2R0,8302
 qadence/backends/braket/__init__.py,sha256=eruyDZKMqkh1LE7eJ980vcrLJbia35uUX6krAP78clI,121
@@ -51,7 +51,7 @@ qadence/backends/pulser/waveforms.py,sha256=0uz95b7rUaUUtN0tuHBZmJ0H6UBmfHST_59o
 qadence/backends/pyqtorch/__init__.py,sha256=0OdVy6cq0oQggV48LO1WXdaZuSkDkz7OYNEPIkNAmfk,140
 qadence/backends/pyqtorch/backend.py,sha256=ITJ52hFAK0jfXo2-2QyIZ1Mt0NcxrwjJqVuT7dyR8hg,9178
 qadence/backends/pyqtorch/config.py,sha256=jK-if0OF6L_inP-oZhWI4-b8wcrOiK8-EVv3NYDOfBM,2056
-qadence/backends/pyqtorch/convert_ops.py,sha256=zDV9lj72K59YsJyky0Q7Je3NweZHrk5IO0uyMggLyKI,15097
+qadence/backends/pyqtorch/convert_ops.py,sha256=gOETCypdCzecpvYy-5ROoCIML4HBy1Fq1NiqriD3tGc,14127
 qadence/blocks/__init__.py,sha256=H6jEA_CptkE-eoB4UfSbUiDszbxxhZwECV_TgoZWXoU,960
 qadence/blocks/abstract.py,sha256=QFwKPagbTrn3V4c2DHpBd-QL_mVIUXfbvyBLUdD6zw4,12023
 qadence/blocks/analog.py,sha256=ymnnlSVoW1XL05ZvnnHCqRTHuOXIEY_7E9M0PNKJZy4,10812
@@ -90,7 +90,7 @@ qadence/engines/jax/differentiable_backend.py,sha256=W5rDA8wb-ECnFWoLj4dVugF9v1l
 qadence/engines/jax/differentiable_expectation.py,sha256=poI--yV3srG3wndTcg6hk1lV63RYPJEQjypiWGzwqsk,3680
 qadence/engines/torch/__init__.py,sha256=iZFdD32ot0B0CVyC-f5dVViOBnqoalxa6M9Lj4WQuPE,160
 qadence/engines/torch/differentiable_backend.py,sha256=AWthwvKE8pCOih4dZ3tXxQX4W1ps9mBcvo7n4V9V24Y,3553
-qadence/engines/torch/differentiable_expectation.py,sha256=sN21wa5AbdlXTDRNK5FonYbmfXWbLDQ-ESHrn17Ruso,9946
+qadence/engines/torch/differentiable_expectation.py,sha256=iaWpd4Y3e_rGKt-S0TNXqqSFg5z6I_5_ZIJxjQxd7Ow,10290
 qadence/exceptions/__init__.py,sha256=BU6vWrI9mshzr1aTPm1Ticr_o_42GjTrWI4OZXhThsI,203
 qadence/exceptions/exceptions.py,sha256=4j_VJpx2sZ2Mir5BJUWu4nwb131FY1ygO4q8-XlyfRc,190
 qadence/measurements/__init__.py,sha256=RIjG9tVJMqhNzyj7maZI250Um0KgHl2PizDcKJag-JU,161
@@ -133,7 +133,7 @@ qadence/transpile/digitalize.py,sha256=iWRwYAYQsD2INHj0HNbGJriv_3fRCuBW1nDBrwtKS
 qadence/transpile/flatten.py,sha256=EdhSG5WyF56nbnxINNLqrHgY84MRM1YFjT3fR4aph5Q,3427
 qadence/transpile/invert.py,sha256=KAefHTG2AWr39aengVhXrzCtJPhrZC-ZnL6vYvmbnY0,4867
 qadence/transpile/transpile.py,sha256=6MRRkk1OS279L1fwUQjazA6qlfpbd-T_EJMKT8hAhOU,2721
-qadence-1.7.5.dist-info/METADATA,sha256=fh8IjATKiYFEPkpPXOzirL9PCYnXk-YaLARmUmxoQP0,9936
-qadence-1.7.5.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-qadence-1.7.5.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-qadence-1.7.5.dist-info/RECORD,,
+qadence-1.7.6.dist-info/METADATA,sha256=Q0bt-7eH8L7b3QffCuD68-vjWa3F6kXBdZHarDsnC5c,9936
+qadence-1.7.6.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+qadence-1.7.6.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+qadence-1.7.6.dist-info/RECORD,,