qrunch.quantum.algorithms.pauli.vqes.adaptive_vqe

Implements the adaptive VQE framework.

Module Attributes

DEFAULT_OPTIONS

Default options for the Adaptive VQE.

Classes

`AdaptiveVqe`	Class for running adaptive VQE.
`AdaptiveVqeCreator`	Builder for the adaptive VQE algorithm.

class AdaptiveVqe

Bases: PauliAdaptiveVqeAlgorithm

Class for running adaptive VQE.

The adaptive VQE algorithm finds the optimal parameters that minimizes the expectation value of the observable.

In comparison to VQE, which has a frozen parametrized circuit, the adaptive VQE appends parametrized gates to the circuit in each iteration, until no improvement is found.

__init__(vqe: PauliBasicVqeAlgorithm, reminimizer_vqe: BasicVqe | None, gate_selector: GateSelector, options: IterativeVqeOptions = IterativeVqeOptions(max_iterations=5, gates_per_iteration=1, new_parameter_guess=0.0, force_all_iterations=False), data_persister_manager: DataPersisterManager | None = None, stopping_criterion: StoppingCriterion | None = None) → None

Initialize the adaptive VQE.

Parameters:

vqe (PauliBasicVqeAlgorithm) – The VQE object running the parameter optimization for each added gate.
reminimizer_vqe (BasicVqe | None) – The VQE object running the parameter re-optimization at the end of an adaptive run. If None, no reminimization step is performed.
gate_selector (GateSelector) – The GateSelector in charge of choosing the next gate from the gate pool.
options (IterativeVqeOptions) – Options for adaptive VQE
data_persister_manager (DataPersisterManager | None) – Manager to handle saving and loading heavy vqe optimizations.
stopping_criterion (StoppingCriterion | None) – The stopping criterion to use when performing early stopping.

Return type:

None

static build_circuit_to_optimize(iteration_data: AdaptiveIterationDataHandler, new_gates: list[GatePoolOperator], iteration_count: int) → Circuit

Build circuit to optimize.

The full unoptimized circuit with the new gates are provided.

Parameters:

iteration_data (AdaptiveIterationDataHandler) – The iteration data handler.
new_gates (list[GatePoolOperator]) – The new_gates to optimize.
iteration_count (int) – The iteration count.

Return type:

Circuit

static build_metadata(observable: HermitianPauliSum, initial_ansatz: Circuit) → Mapping[str, str | Mapping[str, str | NestedStrDict]]

Create meta-data that represent the input.

Parameters:

observable (HermitianPauliSum) – The observable whose expectation value should be minimized.
initial_ansatz (Circuit) – The starting ansatz circuit. Gates from the gate_pool is appended to this.

Return type:

Mapping[str, str | Mapping[str, str | NestedStrDict]]

clear_cache() → None

Clear the cache of the VQE.

Return type:: None

classmethod persistence_checkpoints() → list[str]

Define the persistence checkpoints used during the adaptive vqe.

These checkpoints specify computational stages where intermediate results can be saved and loaded to optimize computations and ensure reproducibility.

Return type:: list[str]

run(observable: HermitianPauliSum, gate_pool: GatePool, initial_ansatz: Circuit, callback: AdaptiveIterationCallback | None = None, input_result: PauliAdaptiveVqeResult | None = None) → PauliAdaptiveVqeResult

Run the adaptive VQE algorithm.

Parameters:

observable (int | float | complex | Expression[PauliOperators] | HermitianPauliSum) – The observable whose expectation value should be minimized.
gate_pool (GatePool) – The set of gates to choose from when building the ansatz.
initial_ansatz (Circuit) – The starting ansatz circuit. Gates from the gate_pool is appended to this.
callback (AdaptiveIterationCallback | None) – An optional callback function that is called at each minimizer iteration.
input_result (PauliAdaptiveVqeResult | None) – A prior results that should be refined.

Returns:

PauliAdaptiveVQEResult containing the optimal circuit that minimizes the expectation value.

Return type:

PauliAdaptiveVqeResult

class AdaptiveVqeCreator

Bases: object

Builder for the adaptive VQE algorithm.

__init__(checkpoints: list[str] | None = None) → None

Initialize builder for the adaptive VQE.

Parameters:: checkpoints (list[str] | None)
Return type:: None

choose_data_persister_manager() → DataPersisterManagerSubCreator[Self]

Choose the data persister manager to use and whether to save and/or load the data.

Return type:: DataPersisterManagerSubCreator[Self]

choose_minimizer() → MinimizerSubCreator[Self]

Chose minimizer to use for the adaptive VQE.

Return type:: MinimizerSubCreator[Self]

choose_reminimizer() → ReMinimizerSubCreator[Self]

Chose reminimizer to use for the adaptive VQE.

Return type:: ReMinimizerSubCreator[Self]

choose_stopping_criterion() → StoppingCriterionSubCreator[Self]

Choose the stopping criterion.

Return type:: StoppingCriterionSubCreator[Self]

create() → AdaptiveVqe

Create an instance of AdaptiveVqe an iterative VQE.

Return type:: AdaptiveVqe

with_analytical_beast_basic_vqe(*, active: bool = True) → Self

Choose to use the analytical basic vqe inside each adaptive iteration, which only works for BEAST.

Instead of having the minimizer call the estimator directly, the estimator is first called to make an analytical expression for the energy as a function of the gate parameter. This expression is then passed to the minimizer, requiring no more measurements.

Note: This feature only works with BEAST with last parameter optimization.

If a reminimizer is chosen, it will be paired with the normal Basic vqe since, only it, supports multiple parameters at once.

Parameters:: active (bool) – Whether to use the analytical beast basic vqe or not.
Return type:: Self

with_estimator(estimator: Estimator) → Self

Choose estimator to use for the adaptive VQE.

Parameters:: estimator (Estimator)
Return type:: Self

with_estimator_shots(shots: int | None) → Self

Choose the number of shots to use in the estimator.

Parameters:: shots (int | None)
Return type:: Self

with_gate_selector(gate_selector: GateSelector) → Self

Choose the gate selector to use for the adaptive VQE.

Parameters:: gate_selector (GateSelector)
Return type:: Self

with_options(options: IterativeVqeOptions) → Self

Choose the options to use for the adaptive VQE.

Parameters:

options (IterativeVqeOptions) – Options to use. Any dataclass with the attributes specified in the IterativeVqeOptions
settings (protocol can be used. To use defaults for some of the)
class. (use the DefaultIterativeVqeOptions)

Return type:

Self

DEFAULT_OPTIONS = IterativeVqeOptions(max_iterations=5, gates_per_iteration=1, new_parameter_guess=0.0, force_all_iterations=False): Default options for the Adaptive VQE.