excitationsolve 1.1.0__py3-none-any.whl

excitationsolve/__init__.py

@@ -0,0 +1,3 @@
+from excitationsolve.info import __version__, HOMEPAGE
+from excitationsolve.excitation_solve import excitation_solve_step
+from excitationsolve.excitation_solve_qiskit import ExcitationSolveQiskit

excitationsolve/excitation_solve.py

@@ -0,0 +1,121 @@
+import logging
+import numpy as np
+from excitationsolve.trig_poly_utils import fourier_series_minimum
+
+
+def excitation_solve_step(
+    parameter_variations: list | np.ndarray,
+    energy_samples: list | np.ndarray,
+    return_coeffs=False,
+    non_exact=False,
+) -> tuple[float, float] | tuple[float, float, np.ndarray]:
+    """
+    Optimizes a single excitation parameter globally given the energies for five shifts of this parameters.
+    Recommended to use in a loop for all excitation parameters and perform multiple sweeps through the parameters (potentially shuffled) until convergence.
+
+    Args:
+        parameter_variations: list or np.ndarray
+            Five variations/shifts of a single excitation parameter.
+        energy_samples: list or np.ndarray
+            Five energy samples for a single excitation parameter varied.
+    Returns:
+        float, float
+            The optimized excitation parameter and the corresponding energy.
+    """
+
+    parameter_variations = np.array(parameter_variations).flatten()
+    energy_samples = np.array(energy_samples).flatten()
+    assert (
+        len(parameter_variations) >= 5
+    ), f"The number of parameter variations must be at least 5. Got {len(parameter_variations)}."
+    assert (
+        len(energy_samples) >= 5
+    ), f"The number of energy samples must be at least 5. Got {len(energy_samples)}."
+    assert len(parameter_variations) == len(
+        energy_samples
+    ), f"The number of parameter variations and energy samples must match. Got {len(parameter_variations)} and {len(energy_samples)}."
+    assert (
+        parameter_variations.max() - parameter_variations.min() <= 4 * np.pi
+    ), "The parameter variations must be within one period of the excitation operator (4*pi)."
+
+    # ### Fit second-order Fourier series / trigonometric polynomial to the energy samples: ###
+    # Determine linear equation system with N equations and 5 unknowns (N number of samples):
+    c1 = np.cos(parameter_variations / 2)
+    s1 = np.sin(parameter_variations / 2)
+    c2 = np.cos(parameter_variations)
+    s2 = np.sin(parameter_variations)
+    A = np.array([np.ones(len(energy_samples)), c1, s1, c2, s2]).T
+    b = np.array(energy_samples)
+    logging.debug("Linear equation system: \nA: \n%s \n b: %s", np.around(A, 3), b)
+
+    if len(parameter_variations) == 5:
+        # ## Exact reconstruction: ##
+        # solve the equation system:
+        coeffs = np.linalg.solve(A, b)
+    else:
+        # ## Fitted reconstruction (least squares fit) for potentially noisy energy values: ##
+        logging.debug(
+            "More than 5 parameter variations or energy samples provided. A least squares fit will be performed instead of an exact reconstruction."
+        )
+        coeffs, residuals, rank_A, s = np.linalg.lstsq(A, b)
+        logging.debug(
+            "Least-squares fit info:\n\tResiduals: %s \n\tRank of A: %i \n\tSingular values of A: %s",
+            residuals,
+            rank_A,
+            s,
+        )
+
+    logging.debug("Solved coefficients: %s", coeffs)
+
+    if non_exact:
+        # reconstructed energy function:
+        def energy_function(xs):
+            c1 = np.cos(xs / 2)
+            s1 = np.sin(xs / 2)
+            c2 = np.cos(xs)
+            s2 = np.sin(xs)
+            return (
+                coeffs[0]
+                + coeffs[1] * c1
+                + coeffs[2] * s1
+                + coeffs[3] * c2
+                + coeffs[4] * s2
+            )
+
+        ### Brute-force optimization of reconstruction
+        n_samples = int(1e3)
+        x_min, x_max = -2 * np.pi, 2 * np.pi
+        x = np.linspace(x_min, x_max, n_samples)
+        y = energy_function(x)  # Note, vectorized evaluation must be supported!
+        min_idx = np.argmin(y)
+        return x[min_idx], y[min_idx]
+
+    # ### Optimize parameter globally in reconstruction (companion matrix method)
+    a = [coeffs[0], *coeffs[1::2]]  # cosine coefficients
+    b = coeffs[2::2]  # sine coefficients
+    assert (
+        len(a) == len(b) + 1
+    ), f"The number of cosine coefficients must be one more than the number of sine coefficients. Got {len(a)} and {len(b)}."
+    min_x, min_y = fourier_series_minimum(a, b, return_y=True)
+    # rescale to original parameter range since the optimization was performed on the interval [pi, pi] with doubled frequencies instead of [-2*pi, 2*pi]:
+    min_x *= 2
+
+    if return_coeffs:
+        return min_x, min_y, coeffs
+    return min_x, min_y
+
+
+### Demo: ###
+if __name__ == "__main__":
+    np.random.seed(42)  # For reproducibility and because 42 is the answer to everything
+    logging.basicConfig(level=logging.INFO)  # Enable logging
+    # Example data:
+    parameter_variations_test = np.array([0, np.pi / 2, -np.pi / 2, np.pi, -np.pi])
+    energy_samples_test = np.random.rand(5)  # random energies for demonstration
+    # Optimize excitation parameter:
+    optimized_parameter, optimized_energy = excitation_solve_step(
+        parameter_variations_test, energy_samples_test
+    )
+    print(
+        f"Optimized excitation parameter: {optimized_parameter} \nOptimized energy: {optimized_energy}"
+    )

excitationsolve/excitation_solve_2d.py

@@ -0,0 +1,190 @@
+import numpy as np
+import logging
+import pennylane as qml
+import pennylane.numpy as pnp
+
+
+def excitation_solve_2d_step(
+    parameter_variations: list | np.ndarray,
+    energy_samples: list | np.ndarray,
+    return_coeffs=False,
+    non_exact=False,
+) -> tuple[float, float] | tuple[float, float, np.ndarray]:
+    """
+    Optimizes two excitation parameters globally given the energies for 25 shifts of this parameters.
+    Recommended to use in a loop for all excitation parameters and perform multiple sweeps through the parameters (potentially shuffled) until convergence.
+
+    Args:
+        parameter_variations: list or np.ndarray
+            25 variations/shifts of two excitation parameters. Shape: (25, 2)
+        energy_samples: list or np.ndarray
+            25 energy samples for two excitation parameters varied.
+    Returns:
+        float, float
+            The optimized excitation parameter and the corresponding energy.
+    """
+
+    parameter_variations = np.array(parameter_variations)
+    energy_samples = np.array(energy_samples).flatten()
+    assert parameter_variations.ndim == 2, f"The parameter variations must be a 2D array. Got {parameter_variations.ndim} dimensions."
+    assert len(parameter_variations) >= 5**2, f"The number of parameter variations must be at least 5. Got {len(parameter_variations)}."
+    assert parameter_variations.shape[1] == 2, f"The parameter variations must have two columns. Got {parameter_variations.shape[1]}."
+    assert len(energy_samples) >= 5**2, f"The number of energy samples must be at least 5. Got {len(energy_samples)}."
+    assert len(parameter_variations) == len(
+        energy_samples
+    ), f"The number of parameter variations and energy samples must match. Got {len(parameter_variations)} and {len(energy_samples)}."
+    assert (
+        parameter_variations[:, 0].max() - parameter_variations[:, 0].min() <= 4 * np.pi
+    ), "The variations of the first parameter must be within one period of the excitation operator (4*pi)."
+    assert (
+        parameter_variations[:, 1].max() - parameter_variations[:, 1].min() <= 4 * np.pi
+    ), "The variations of the second parameter must be within one period of the excitation operator (4*pi)."
+
+    # ### Fit second-order Fourier series / trigonometric polynomial to the energy samples: ###
+    # Determine linear equation system with N equations and 5**2 unknowns (N number of samples):
+    param_1_terms = [
+        np.ones(len(parameter_variations)),
+        np.cos(parameter_variations[:, 0] / 2),
+        np.sin(parameter_variations[:, 0] / 2),
+        np.cos(parameter_variations[:, 0]),
+        np.sin(parameter_variations[:, 0]),
+    ]
+    param_2_terms = [
+        np.ones(len(parameter_variations)),
+        np.cos(parameter_variations[:, 1] / 2),
+        np.sin(parameter_variations[:, 1] / 2),
+        np.cos(parameter_variations[:, 1]),
+        np.sin(parameter_variations[:, 1]),
+    ]
+    A = np.array([p1_term * p2_term for p1_term in param_1_terms for p2_term in param_2_terms]).T
+    b = np.array(energy_samples)
+    logging.debug("Linear equation system: \nA: \n%s \n b: %s", np.around(A, 3), b)
+
+    if len(parameter_variations) == 5**2:
+        # ## Exact reconstruction: ##
+        # solve the equation system:
+        coeffs = np.linalg.solve(A, b)
+    else:
+        raise NotImplementedError("Least squares fit not implemented for 2D parameter variations yet.")
+
+    logging.debug("Solved coefficients: %s", coeffs)
+
+    def energy_function(xs):
+        xs_1_terms = [
+            np.ones(len(xs)),
+            np.cos(xs[:, 0] / 2),
+            np.sin(xs[:, 0] / 2),
+            np.cos(xs[:, 0]),
+            np.sin(xs[:, 0]),
+        ]
+        xs_2_terms = [
+            np.ones(len(xs)),
+            np.cos(xs[:, 1] / 2),
+            np.sin(xs[:, 1] / 2),
+            np.cos(xs[:, 1]),
+            np.sin(xs[:, 1]),
+        ]
+        A = np.array([xs1_term * xs2_term for xs1_term in xs_1_terms for xs2_term in xs_2_terms]).T
+        ys = A @ coeffs
+        return ys
+
+    if non_exact:
+        # ### Optimize parameter globally in reconstruction (brute-force sampling method) ###
+        # sample in both directions of the parameter space:
+        n_samples_per_dim = int(1e3)
+        samples_one_dim = np.linspace(-2 * np.pi, 2 * np.pi, n_samples_per_dim)
+        samples = np.array([[x, y] for x in samples_one_dim for y in samples_one_dim])
+        sampled_energies = energy_function(samples)
+        min_idx = np.argmin(sampled_energies)
+        min_x, min_y = samples[min_idx], sampled_energies[min_idx]
+    else:
+        # ### Optimize parameter globally in reconstruction (Nyquist + gradient descent)
+        n_nyquist_samples_per_dim = 5
+        init_points = np.linspace(-2 * np.pi, 2 * np.pi, n_nyquist_samples_per_dim + 1)[:-1]
+
+        def energy_function_diffable(x):
+            xs_1_terms = [
+                1,
+                pnp.cos(x[0] / 2),
+                pnp.sin(x[0] / 2),
+                pnp.cos(x[0]),
+                pnp.sin(x[0]),
+            ]
+            xs_2_terms = [
+                1,
+                pnp.cos(x[1] / 2),
+                pnp.sin(x[1] / 2),
+                pnp.cos(x[1]),
+                pnp.sin(x[1]),
+            ]
+            A = pnp.array(
+                [xs1_term * xs2_term for xs1_term in xs_1_terms for xs2_term in xs_2_terms],
+                requires_grad=True,
+            ).T
+            ys = A @ pnp.array(coeffs)
+            return ys
+
+        min_x = None
+        min_y = np.infty
+        for x1 in init_points:
+            for x2 in init_points:
+                x = pnp.array([x1, x2], requires_grad=True)
+                max_iter = 1_000_000
+                # Use gradient descent with high constant step size that still guarantees convergence:
+                grad_fn = qml.grad(energy_function_diffable)
+                step_size = 1 / (np.sum(np.abs(coeffs)))  # 1/Lipschitz constant, could be improved by a better constant
+                for i in range(max_iter):
+                    # Use gradient descent
+                    grad = grad_fn(x)
+                    update = -grad
+                    x += step_size * update
+                    if np.linalg.norm(update) < 1e-10:
+                        if min_y > (y := energy_function_diffable(x.numpy())):
+                            min_x = x.numpy()
+                            min_y = y.numpy()
+                            # make sure x is in the range [-2*pi, 2*pi] using modulo operation:
+                            min_x = (min_x + 2 * np.pi) % (4 * np.pi) - 2 * np.pi
+                            assert np.isclose(energy_function_diffable(min_x), min_y)
+                        break
+                if i == max_iter - 1:
+                    logging.warning(
+                        "Gradient descent optimization did not converge for initial point %s, %s.",
+                        x1,
+                        x2,
+                    )
+                else:
+                    logging.debug(
+                        "Gradient descent optimization converged after %i iterations to point %s.",
+                        i,
+                        min_x,
+                    )
+
+    logging.debug("Returning point x=%s, y=%s.", min_x, min_y)
+
+    if return_coeffs:
+        return min_x, min_y, coeffs
+    return min_x, min_y
+
+
+### Demo: ###
+if __name__ == "__main__":
+    np.random.seed(42)  # For reproducibility and because 42 is the answer to everything
+    logging.basicConfig(level=logging.INFO)  # Enable logging
+    # Example data:
+    parameter_variations_test = np.linspace(-2 * np.pi, 2 * np.pi, 6)[:-1]  # 5 variations of the excitation parameter (for demonstration)
+    parameter_2d_variations_test = np.array([[x, y] for x in parameter_variations_test for y in parameter_variations_test])
+    energy_samples_test = np.random.rand(len(parameter_2d_variations_test))  # random energies for demonstration
+    print(parameter_2d_variations_test)
+    print(energy_samples_test)
+
+    # Optimize excitation parameter:
+    optimized_parameter, optimized_energy = excitation_solve_2d_step(parameter_2d_variations_test, energy_samples_test)
+    # Double-check with brute-force optimization:
+    optimized_parameter_check, optimized_energy_check = excitation_solve_2d_step(parameter_2d_variations_test, energy_samples_test, non_exact=True)
+    print(
+        f"Optimized excitation parameter: {optimized_parameter} \nOptimized energy: {optimized_energy}\n\n"
+        f"Optimized excitation parameter (brute-force): {optimized_parameter_check} \n"
+        f"Optimized energy (brute-force): {optimized_energy_check}"
+    )
+
+    assert optimized_energy <= optimized_energy_check, "Optimized energy is not minimal."

excitationsolve/excitation_solve_adapt.py

@@ -0,0 +1,160 @@
+# Copyright 2018-2022 Xanadu Quantum Technologies Inc.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Adaptive optimizer"""
+import copy
+from typing import Sequence, Callable
+
+# pylint: disable= no-value-for-parameter, protected-access, not-callable
+import pennylane as qml
+from pennylane import numpy as pnp
+from pennylane.tape import QuantumTape
+from pennylane import transform
+import excitation_solve
+
+
+@transform
+def append_gate(tape: QuantumTape, params, gates) -> (Sequence[QuantumTape], Callable):
+    """Append parameterized gates to an existing tape.
+
+    Args:
+        tape (QuantumTape or QNode or Callable): quantum circuit to transform by adding gates
+        params (array[float]): parameters of the gates to be added
+        gates (list[Operator]): list of the gates to be added
+
+    Returns:
+        qnode (QNode) or quantum function (Callable) or tuple[List[QuantumTape], function]: The transformed circuit as described in :func:`qml.transform <pennylane.transform>`.
+
+    """
+    new_operations = []
+
+    for i, g in enumerate(gates):
+        g = copy.copy(g)
+        new_params = (params[i], *g.data[1:])
+        g.data = new_params
+        new_operations.append(g)
+
+    new_tape = type(tape)(
+        tape.operations + new_operations, tape.measurements, shots=tape.shots
+    )
+
+    def null_postprocessing(results):
+        """A postprocesing function returned by a transform that only converts the batch of results
+        into a result for a single ``QuantumTape``.
+        """
+        return results[0]  # pragma: no cover
+
+    return [new_tape], null_postprocessing
+
+
+class ExcitationAdaptiveOptimizer:
+    r"""Optimizer for building fully trained quantum circuits by adding gates adaptively using ExcitationSolve."""
+
+    @staticmethod
+    def _circuit(params, gates, initial_circuit):
+        """Append parameterized gates to an existing circuit.
+
+        Args:
+            params (array[float]): parameters of the gates to be added
+            gates (list[Operator]): list of the gates to be added
+            initial_circuit (function): user-defined circuit that returns an expectation value
+
+        Returns:
+            function: user-defined circuit with appended gates
+        """
+        final_circuit = append_gate(initial_circuit, params, gates)
+
+        return final_circuit()
+
+    def step(self, circuit, operator_pool, params_zero=True):
+        r"""Update the circuit with one step of the optimizer.
+
+        Args:
+            circuit (.QNode): user-defined circuit returning an expectation value
+            operator_pool (list[Operator]): list of the gates to be used for adaptive optimization
+            params_zero (bool): flag to initiate circuit parameters at zero
+
+        Returns:
+            .QNode: the optimized circuit
+        """
+        return self.step_and_cost(circuit, operator_pool, params_zero=params_zero)[0]
+
+    def step_and_cost(
+        self, circuit, operator_pool, drain_pool=False, params_zero=False
+    ):
+        r"""Update the circuit with one step of the optimizer, return the corresponding
+        objective function value prior to the step, and return the maximum gradient
+
+        Args:
+            circuit (.QNode): user-defined circuit returning an expectation value
+            operator_pool (list[Operator]): list of the gates to be used for adaptive optimization
+            drain_pool (bool): flag to remove selected gates from the operator pool
+            params_zero (bool): flag to initiate circuit parameters at zero
+
+        Returns:
+            tuple[.QNode, float, float]: the optimized circuit, the objective function output prior
+            to the step, and the largest gradient
+        """
+        cost = circuit()
+        qnode = copy.copy(circuit)
+
+        if drain_pool:
+            operator_pool = [
+                gate
+                for gate in operator_pool
+                if all(
+                    gate.name != operation.name or gate.wires != operation.wires
+                    for operation in circuit.tape.operations
+                )
+            ]
+
+        params = pnp.array(
+            [gate.parameters[0] for gate in operator_pool], requires_grad=True
+        )
+        qnode.func = self._circuit
+
+        shifts = pnp.array([0, pnp.pi / 2, -pnp.pi / 2, pnp.pi, -pnp.pi])
+        energies = []
+        opt_params = []
+        # Select best operator to append based on ExcitationSolve
+        for param_to_vary, op in enumerate(operator_pool):
+            e_shifted = [
+                qnode(
+                    [shift],
+                    gates=[op],
+                    initial_circuit=circuit.func,
+                )
+                for shift in shifts
+            ]
+
+            opt_param, e_excsolve = excitation_solve.excitation_solve_step(
+                shifts, e_shifted
+            )
+            opt_params.append(opt_param)
+            energies.append(e_excsolve)
+        energies = pnp.array(energies)
+        selected_index = pnp.argmax(cost - energies)
+        selected_gates = [operator_pool[selected_index]]
+
+        # set parameter of appended op to its optimized value
+        if params_zero:
+            params = pnp.zeros(len(selected_gates))
+        else:
+            params = pnp.array(
+                [opt_params[selected_index]],
+                requires_grad=True,
+            )
+
+        qnode.func = append_gate(circuit.func, params, selected_gates)
+
+        return qnode, cost, max(abs(cost - energies))

excitationsolve/excitation_solve_pennylane.py

@@ -0,0 +1,57 @@
+from excitationsolve import excitation_solve_step
+import numpy as np
+import pennylane as qml
+
+
+def excitationsolve_pennylane(
+    circuit: qml.QNode,
+    params_excsolve: np.ndarray,
+    params_to_vary: list | None = None,
+    num_samples=5,
+) -> tuple[np.ndarray, list]:
+    """Optimizes all parameters once in the given pennylane quantum circuit.
+
+    Args:
+        circuit (QNode): Quantum circuit that takes the parameters params_excsolve
+                         and returns a scalar value which should be optimized
+        params_excsolve (pennylane.numpy.tensor): Tensor holding the parameters to be optimized.
+        params_to_vary (list | None): List of indices or None. If list then only
+                                      parameters with indices in that list are optimized.
+                                      If None all parameters are optimized. Defaults to None.
+        num_samples (int, optional): Number of different parameter shifts used to reconstruct
+                                     the energy function. Has to be equal or greater than 5.
+                                     If no noise is present values greater than five do not
+                                     improve the optimization. Defaults to 5.
+
+    Returns:
+        tuple(pennylane.numpy.tensor, list): Optimized parameters and energies
+                                             after optimizing each parameter
+    """
+    if params_to_vary is None:
+        params_to_vary = range(len(params_excsolve))
+
+    param_dist = 4 * np.pi / num_samples
+    shifts = (np.arange(num_samples) - num_samples // 2) * param_dist
+
+    e_excsolve_list = []
+
+    for param_to_vary in params_to_vary:
+        e_shifted = [
+            circuit(
+                np.array(
+                    [
+                        (shift + param if i == param_to_vary else param)
+                        for i, param in enumerate(params_excsolve)
+                    ]
+                )
+            )
+            for shift in shifts
+        ]
+        param_variations = shifts + params_excsolve[param_to_vary]
+        params_excsolve[param_to_vary], e_excsolve = excitation_solve_step(
+            param_variations, e_shifted
+        )
+
+        e_excsolve_list.append(e_excsolve)
+
+    return params_excsolve, e_excsolve_list

excitationsolve/excitation_solve_qiskit.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+from collections.abc import Callable
+import numpy as np
+from qiskit_algorithms.optimizers import (
+    Optimizer,
+    OptimizerSupportLevel,
+    OptimizerResult,
+)
+from qiskit_algorithms.optimizers.optimizer import POINT
+from excitationsolve import excitation_solve_step
+
+
+class ExcitationSolveQiskit(Optimizer):
+    def __init__(self, maxiter, tol=1e-12, num_samples=5, hf_energy=None, save_parameters=False):
+        """The ExcitationSolve optimizer.
+        Note that this optimizer never needs to evaluate the ansatz circuit
+        at the (current) optimal parameters, unless the optimal parameters fall onto
+        the sample points used to reconstruct the energy function.
+        Therefore, when used with a qiskit VQE object, the energies transmitted
+        to a VQE callback function, do not seem to improve or converge. Nevertheless,
+        the determined optimal energy and parameters are still returned.
+
+        Args:
+            maxiter (int): Maximum number of VQE iterations (maximum number of times to optimize all parameters)
+            tol: Threshold of energy difference after subsequent VQE iterations defining convergence
+            num_samples (int, optional): Number of different parameter values at which to sample
+                the energy to reconstruct the energy function in one parameter.
+                Must be greater or equal to 5. Defaults to 5.
+            hf_energy (float | None, optional): The Hartree-Fock energy, i.e. the energy of the
+                system where all parameters in the circuit are zero. If none, this will be
+                calculated by evaluating the energy of the ansatz with all parameters set to zero.
+                If this energy is known from a prior classical calculation, e.g. a Hartree-Fock
+                calculation, one energy evaluation is saved. Defaults to None.
+            save_parameters (bool, optional) If True, params member variable contains
+                all optimal parameter values after each optimization step,
+                i.e. after optimizing each single parameter. Defaults to False.
+        """
+        super().__init__()
+
+        self.maxiter = maxiter
+        self.tol = tol
+        assert num_samples >= 5, f"Number of samples needs to be greater or equal to 5 but is {num_samples}!"
+        self.num_samples = num_samples
+        self.hf_energy = hf_energy
+        self.save_parameters = save_parameters
+
+        self.energies = []
+        self.nfevs = []
+        self.params = []
+
+    def get_support_level(self):
+        """Return support level dictionary"""
+        return {
+            "gradient": OptimizerSupportLevel.ignored,
+            "bounds": OptimizerSupportLevel.ignored,
+            "initial_point": OptimizerSupportLevel.required,
+        }
+
+    def minimize(
+        self,
+        fun: Callable[[POINT], float],
+        x0: POINT,
+        jac: Callable[[POINT], POINT] | None = None,
+        bounds: list[tuple[float, float]] | None = None,
+    ) -> OptimizerResult:
+        self.energies = []
+        self.nfevs = []
+        self.params = []
+
+        param_dist = 4 * np.pi / self.num_samples
+        shifts = (np.arange(self.num_samples) - self.num_samples // 2) * param_dist
+
+        params_excsolve = np.array(x0.copy())
+        num_params = len(params_excsolve)
+
+        # qiskit excitation parameters result in excitation operators being \pi periodic
+        # ExcitationSolve expects them to be 2\pi periodic. Therefore, we rescale
+        # the parameters
+        param_scaling = 1 / 2
+
+        energies_once = [np.inf]
+        energy_at_zero = None
+        if self.hf_energy is not None:
+            energy_at_zero = self.hf_energy
+            self.energies = [self.hf_energy]
+            self.nfevs = [0]
+
+        nfev = 0
+        for n_iter in range(self.maxiter):
+            for param_to_vary in range(num_params):
+                e_shifted = []
+                for shift in shifts:
+                    if shift == 0.0 and energy_at_zero is not None:
+                        e_shifted.append(energy_at_zero)
+                        continue
+                    energy_tmp = fun(
+                        np.array(
+                            [
+                                ((shift + params_excsolve[i]) * param_scaling if i == param_to_vary else params_excsolve[i] * param_scaling)
+                                for i in range(num_params)
+                            ]
+                        )
+                    )
+                    e_shifted.append(energy_tmp)
+                    if shift == 0.0 and energy_at_zero is None:
+                        # Save Hartree-Fock (HF) energy as first energy with 0 as corresponding number of circuit evaluations needed
+                        # since the HF energy can be known before any circuit execution by performing a classical HF calculation.
+                        self.energies = [energy_tmp]
+                        self.nfevs = [0]
+                    nfev += 1
+
+                params_excsolve[param_to_vary], current_energy_excsolve = excitation_solve_step(
+                    shifts + params_excsolve[param_to_vary],
+                    e_shifted,
+                )
+                energy_at_zero = current_energy_excsolve
+
+                # Energy at current optimal parameters (not necessary to evaluate,
+                #   since we already know it from the excitation_solve_step function)
+                # Nevertheless we could (unnecessarily) execute the circuit at the
+                # current optimal parameters so that a VQE callback function gets information
+                # about the optimization progress/convergence
+                # fun(params_excsolve * param_scaling)
+
+                # The optimal energies at each step are saved in the self.energies list
+                self.energies.append(current_energy_excsolve)
+                self.nfevs.append(nfev)
+                if self.save_parameters:
+                    self.params.append(params_excsolve * param_scaling)
+
+            energies_once.append(current_energy_excsolve)
+            if np.abs(energies_once[-1] - energies_once[-2]) <= self.tol:
+                break
+
+        result = OptimizerResult()
+        result.x = params_excsolve * param_scaling
+        result.fun = current_energy_excsolve
+        result.nfev = nfev
+        result.njev = None
+        result.nit = n_iter + 1
+
+        self.energies = np.array(self.energies)
+        self.nfevs = np.array(self.nfevs)
+        self.params = np.array(self.params)
+
+        return result

excitationsolve/info.py

@@ -0,0 +1,3 @@
+__version__ = "1.1.0"  # MAJOR.MINOR.PATCH, like in https://semver.org/
+
+HOMEPAGE = "https://github.com/dlr-wf/ExcitationSolve"  # GitHub page