qadence 1.7.4__tar.gz → 1.7.6__tar.gz

qadence-1.7.6/.github/workflows/ISSUE_TEMPLATE/bug-report.yml

@@ -0,0 +1,52 @@
+name: Bug Report
+description: Report a bug
+labels: ["bug"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Please fill out the sections below to help everyone identify and fix the bug
+  - type: textarea
+    id: description
+    attributes:
+      label: Short description
+      placeholder: Describe here
+    validations:
+      required: true
+  - type: textarea
+    id: expected
+    attributes:
+      label: What is the expected result?
+      placeholder: Describe here
+  - type: textarea
+    id: actual
+    attributes:
+      label: What is the actual result?
+      placeholder: Describe here
+  - type: textarea
+    id: code_bug
+    attributes:
+      label: Steps/Code to reproduce
+      placeholder: |
+        from qadence import *
+    validations:
+      required: true
+  - type: textarea
+    id: texterror
+    attributes:
+      label: Tracebacks (optional)
+  - type: textarea
+    id: textenv
+    attributes:
+      label: Environment details (optional)
+      placeholder: Qadence version, Operating  system, Python version, PyTorch version
+  - type: dropdown
+    id: assign
+    attributes:
+      label: "Would you like to work on this issue?"
+      options:
+        - "Yes"
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for reporting this issue! We will get back to you as soon as possible.

qadence-1.7.6/.github/workflows/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: true
+contact_links:
+  - name: Contribution guidelines
+    url: https://pasqal-io.github.io/qadence/latest/getting_started/CONTRIBUTING/
+    about: How to contribute

qadence-1.7.6/.github/workflows/ISSUE_TEMPLATE/new-feature.yml

@@ -0,0 +1,36 @@
+name: New feature
+description: Suggest or request a new feature
+labels: ["feature"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Please fill out the sections below to properly describe the new feature you are suggesting.
+  - type: textarea
+    id: description
+    attributes:
+      label: Describe the feature
+      placeholder: I want ...
+    validations:
+      required: true
+  - type: textarea
+    id: rationale
+    attributes:
+      label: It should be implemented because
+      placeholder: It will allow ...
+  - type: textarea
+    id: context
+    attributes:
+      label: Additional context
+      placeholder: |
+        Add any other context or screenshots about the feature request here.
+  - type: dropdown
+    id: assign
+    attributes:
+      label: "Would you like to work on this issue?"
+      options:
+        - "Yes"
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for your suggestion! Let's see together if it can be implemented.

{qadence-1.7.4 → qadence-1.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qadence
-Version: 1.7.4
+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.3.2
+Requires-Dist: pyqtorch==1.4.4
 Requires-Dist: pyyaml
 Requires-Dist: rich
 Requires-Dist: scipy
@@ -45,7 +45,7 @@ Requires-Dist: nvidia-pyindex; extra == 'dlprof'
 Provides-Extra: horqrux
 Requires-Dist: einops; extra == 'horqrux'
 Requires-Dist: flax; extra == 'horqrux'
-Requires-Dist: horqrux==0.6.0; extra == 'horqrux'
+Requires-Dist: horqrux==0.6.2; extra == 'horqrux'
 Requires-Dist: jax; extra == 'horqrux'
 Requires-Dist: jaxopt; extra == 'horqrux'
 Requires-Dist: optax; extra == 'horqrux'
@@ -57,7 +57,7 @@ Requires-Dist: mlflow; extra == 'mlflow'
 Provides-Extra: protocols
 Requires-Dist: qadence-protocols; extra == 'protocols'
 Provides-Extra: pulser
-Requires-Dist: pasqal-cloud==0.11.1; extra == 'pulser'
+Requires-Dist: pasqal-cloud==0.11.3; extra == 'pulser'
 Requires-Dist: pulser-core==0.19.0; extra == 'pulser'
 Requires-Dist: pulser-simulation==0.19.0; extra == 'pulser'
 Provides-Extra: visualization

{qadence-1.7.4 → qadence-1.7.6}/pyproject.toml

@@ -25,7 +25,7 @@ authors = [
 ]
 requires-python = ">=3.9"
 license = { text = "Apache 2.0" }
-version = "1.7.4"
+version = "1.7.6"
 classifiers = [
     "License :: OSI Approved :: Apache Software License",
     "Programming Language :: Python",
@@ -49,7 +49,7 @@ dependencies = [
     "jsonschema",
     "nevergrad",
     "scipy",
-    "pyqtorch==1.3.2",
+    "pyqtorch==1.4.4",
     "pyyaml",
     "matplotlib",
     "Arpeggio==2.0.2",
@@ -63,7 +63,7 @@ allow-ambiguous-features = true
 pulser = [
     "pulser-core==0.19.0",
     "pulser-simulation==0.19.0",
-    "pasqal-cloud==0.11.1",
+    "pasqal-cloud==0.11.3",
 ]
 braket = ["amazon-braket-sdk<1.71.2"]
 visualization = [
@@ -73,7 +73,7 @@ visualization = [
     # "scour",
 ]
 horqrux = [
-    "horqrux==0.6.0",
+    "horqrux==0.6.2",
     "jax",
     "flax",
     "optax",
@@ -87,6 +87,7 @@ dlprof = ["nvidia-pyindex", "nvidia-dlprof[pytorch]"]
 mlflow = ["mlflow"]
 all = ["pulser", "braket", "visualization", "protocols", "libs", "mlflow"]
 
+
 [tool.hatch.envs.default]
 dependencies = [
     "flaky",
@@ -132,6 +133,7 @@ filterwarnings = [
 [tool.hatch.envs.docs]
 dependencies = [
     "mkdocs",
+    "mkdocs_autorefs<1.1.0",
     "mkdocs-material",
     "mkdocstrings",
     "mkdocstrings-python",

{qadence-1.7.4 → qadence-1.7.6}/qadence/analog/addressing.py

@@ -59,9 +59,13 @@ class AddressingPattern:
     ) -> dict:
         # augment weight dict if needed
         weights = {
-            i: Parameter(0.0)
-            if i not in weights
-            else (Parameter(weights[i]) if not isinstance(weights[i], Parameter) else weights[i])
+            i: (
+                Parameter(0.0)
+                if i not in weights
+                else (
+                    Parameter(weights[i]) if not isinstance(weights[i], Parameter) else weights[i]
+                )
+            )
             for i in range(self.n_qubits)
         }
 

{qadence-1.7.4 → qadence-1.7.6}/qadence/backends/api.py

@@ -3,6 +3,9 @@ from __future__ import annotations
 from qadence.backend import Backend, BackendConfiguration
 from qadence.engines.differentiable_backend import DifferentiableBackend
 from qadence.extensions import (
+    BackendNotFoundError,
+    ConfigNotFoundError,
+    EngineNotFoundError,
     import_backend,
     import_config,
     import_engine,
@@ -49,12 +52,9 @@ def backend_factory(
             diff_backend_cls = import_engine(backend_inst.engine)
             backend_inst = diff_backend_cls(backend=backend_inst, diff_mode=DiffMode(diff_mode))  # type: ignore[operator]
         return backend_inst
-    except Exception as e:
-        msg = f"The requested backend '{backend}' is either not installed\
-            or could not be imported due to {e}."
-        logger.error(msg)
-        raise Exception(msg)
-    # Set backend configurations which depend on the differentiation mode
+    except (BackendNotFoundError, EngineNotFoundError, ConfigNotFoundError) as e:
+        logger.error(e.msg)
+        raise e
 
 
 def config_factory(backend_name: BackendName | str, config: dict) -> BackendConfiguration:
@@ -62,6 +62,7 @@ def config_factory(backend_name: BackendName | str, config: dict) -> BackendConf
     try:
         BackendConfigCls = import_config(backend_name)
         cfg = BackendConfigCls(**config)  # type: ignore[operator]
-    except Exception as e:
-        logger.debug(f"Unable to import config for backend {backend_name} due to {e}.")
+    except ConfigNotFoundError as e:
+        logger.error(e.msg)
+        raise e
     return cfg

{qadence-1.7.4 → qadence-1.7.6}/qadence/backends/gpsr.py

@@ -11,13 +11,29 @@ from qadence.utils import _round_complex
 
 
 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-1.7.4 → qadence-1.7.6}/qadence/backends/horqrux/convert_ops.py

@@ -7,11 +7,11 @@ from operator import add
 from typing import Any, Callable, Dict
 
 import jax.numpy as jnp
-from horqrux.abstract import Primitive as Gate
 from horqrux.analog import _HamiltonianEvolution as NativeHorqHEvo
 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 jax import Array
 from jax.scipy.linalg import expm

{qadence-1.7.4 → qadence-1.7.6}/qadence/backends/pyqtorch/backend.py

@@ -71,19 +71,16 @@ class Backend(BackendInterface):
     def observable(self, observable: AbstractBlock, n_qubits: int) -> ConvertedObservable:
         # make sure only leaves, i.e. primitive blocks are scaled
         transpilations = [
-            lambda block: chain_single_qubit_ops(block)
-            if self.config.use_single_qubit_composition
-            else flatten(block),
+            lambda block: (
+                chain_single_qubit_ops(block)
+                if self.config.use_single_qubit_composition
+                else flatten(block)
+            ),
             scale_primitive_blocks_only,
         ]
         block = transpile(*transpilations)(observable)  # type: ignore[call-overload]
         operations = convert_block(block, n_qubits, self.config)
-        obs_cls = (
-            pyq.DiagonalObservable
-            if block._is_diag_pauli and not block.is_parametric
-            else pyq.Observable
-        )
-        native = obs_cls(n_qubits=n_qubits, operations=operations)
+        native = pyq.Observable(operations=operations)
         return ConvertedObservable(native=native, abstract=block, original=observable)
 
     def run(
@@ -140,7 +137,7 @@ class Backend(BackendInterface):
         )
         observable = observable if isinstance(observable, list) else [observable]
         _expectation = torch.hstack(
-            [obs.native(state, param_values).reshape(-1, 1) for obs in observable]
+            [obs.native.expectation(state, param_values).reshape(-1, 1) for obs in observable]
         )
         return _expectation
 
@@ -169,7 +166,7 @@ class Backend(BackendInterface):
         observables = observable if isinstance(observable, list) else [observable]
         for vals in to_list_of_dicts(param_values):
             wf = self.run(circuit, vals, state, endianness, pyqify_state=True, unpyqify_state=False)
-            exs = torch.cat([obs.native(wf, vals) for obs in observables], 0)
+            exs = torch.cat([obs.native.expectation(wf, vals) for obs in observables], 0)
             list_expvals.append(exs)
 
         batch_expvals = torch.vstack(list_expvals)

{qadence-1.7.4 → qadence-1.7.6}/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,31 +100,45 @@ 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.primitive.Primitive(block.matrix, block.qubit_support)]
+        return [pyq.primitives.Primitive(block.matrix, block.qubit_support)]
     elif isinstance(block, CompositeBlock):
         ops = list(flatten(*(convert_block(b, n_qubits, config) for b in block.blocks)))
         if isinstance(block, AddBlock):
@@ -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,61 +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,
-                self.n_qubits,
-                self.batch_size,
-            )
+        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
 
@@ -388,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-1.7.4 → qadence-1.7.6}/qadence/backends/utils.py

@@ -9,7 +9,7 @@ import pyqtorch as pyq
 import torch
 from numpy.typing import ArrayLike
 from pyqtorch.apply import apply_operator
-from pyqtorch.parametric import Parametric as PyQParametric
+from pyqtorch.primitives import Parametric as PyQParametric
 from torch import (
     Tensor,
     cat,

{qadence-1.7.4 → qadence-1.7.6}/qadence/blocks/composite.py

@@ -129,9 +129,11 @@ class CompositeBlock(AbstractBlock):
         from qadence.blocks.utils import _construct, tag
 
         blocks = [
-            getattr(operations, b["type"])._from_dict(b)
-            if hasattr(operations, b["type"])
-            else getattr(qadenceblocks, b["type"])._from_dict(b)
+            (
+                getattr(operations, b["type"])._from_dict(b)
+                if hasattr(operations, b["type"])
+                else getattr(qadenceblocks, b["type"])._from_dict(b)
+            )
             for b in d["blocks"]
         ]
         block = _construct(cls, blocks)  # type: ignore[arg-type]