# PVQD

*class *`qiskit.algorithms.PVQD(fidelity, ansatz, initial_parameters, estimator=None, optimizer=None, num_timesteps=None, evolution=None, use_parameter_shift=True, initial_guess=None)`

Bases: `RealTimeEvolver`

The projected Variational Quantum Dynamics (p-VQD) Algorithm.

In each timestep, this algorithm computes the next state with a Trotter formula (specified by the `evolution`

argument) and projects the timestep onto a variational form (`ansatz`

). The projection is determined by maximizing the fidelity of the Trotter-evolved state and the ansatz, using a classical optimization routine. See Ref. [1] for details.

The following attributes can be set via the initializer but can also be read and updated once the PVQD object has been constructed.

### ansatz

### initial_parameters

The parameters of the ansatz at time 0.

**Type**

np.ndarray

### optimizer

The classical optimization routine used to maximize the fidelity of the Trotter step and ansatz.

**Type**

### num_timesteps

The number of timesteps to take. If None, it is automatically selected to achieve a timestep of approximately 0.01.

**Type**

Optional[int(opens in a new tab)]

### evolution

The method to perform the Trotter step. Defaults to first-order Lie-Trotter evolution.

**Type**

Optional[EvolutionSynthesis]

### use_parameter_shift

If True, use the parameter shift rule for loss function gradients (if the ansatz supports).

**Type**

### initial_guess

The starting point for the first classical optimization run, at time 0. Defaults to random values in $[-0.01, 0.01]$.

**Type**

Optional[np.ndarray]

**Example**

This snippet computes the real time evolution of a quantum Ising model on two neighboring sites and keeps track of the magnetization.

```
import numpy as np
from qiskit.algorithms.state_fidelities import ComputeUncompute
from qiskit.algorithms.time_evolvers import TimeEvolutionProblem, PVQD
from qiskit.primitives import Estimator, Sampler
from qiskit.circuit.library import EfficientSU2
from qiskit.quantum_info import SparsePauliOp, Pauli
from qiskit.algorithms.optimizers import L_BFGS_B
sampler = Sampler()
fidelity = ComputeUncompute(sampler)
estimator = Estimator()
hamiltonian = 0.1 * SparsePauliOp(["ZZ", "IX", "XI"])
observable = Pauli("ZZ")
ansatz = EfficientSU2(2, reps=1)
initial_parameters = np.zeros(ansatz.num_parameters)
time = 1
optimizer = L_BFGS_B()
# setup the algorithm
pvqd = PVQD(
fidelity,
ansatz,
initial_parameters,
estimator,
num_timesteps=100,
optimizer=optimizer,
)
# specify the evolution problem
problem = TimeEvolutionProblem(
hamiltonian, time, aux_operators=[hamiltonian, observable]
)
# and evolve!
result = pvqd.evolve(problem)
```

**References**

**[1] Stefano Barison, Filippo Vicentini, and Giuseppe Carleo (2021), An efficient**

quantum algorithm for the time evolution of parameterized circuits, Quantum 5, 512(opens in a new tab).

**Parameters**

**fidelity**(*BaseStateFidelity*) – A fidelity primitive used by the algorithm.**ansatz**(*QuantumCircuit*) – A parameterized circuit preparing the variational ansatz to model the time evolved quantum state.**initial_parameters**(*np.ndarray*) – The initial parameters for the ansatz. Together with the ansatz, these define the initial state of the time evolution.**estimator**(*BaseEstimator**| None*) – An estimator primitive used for calculating expected values of auxiliary operators (if provided via the problem).**optimizer**(*Optimizer**|**Minimizer**| None*) – The classical optimizers used to minimize the overlap between Trotterization and ansatz. Can be either a`Optimizer`

or a callable using the`Minimizer`

protocol. This argument is optional since it is not required for`get_loss()`

, but it has to be set before`evolve()`

is called.**num_timesteps**(*int*(opens in a new tab)*| None*) – The number of time steps. If`None`

it will be set such that the timestep is close to 0.01.**evolution**(*EvolutionSynthesis**| None*) – The evolution synthesis to use for the construction of the Trotter step. Defaults to first-order Lie-Trotter decomposition, see also`evolution`

for different options.**use_parameter_shift**(*bool*(opens in a new tab)) – If True, use the parameter shift rule to compute gradients. If False, the optimizer will not be passed a gradient callable. In that case, Qiskit optimizers will use a finite difference rule to approximate the gradients.**initial_guess**(*np.ndarray | None*) – The initial guess for the first VQE optimization. Afterwards the previous iteration result is used as initial guess. If None, this is set to a random vector with elements in the interval $[-0.01, 0.01]$.

## Methods

### evolve

`evolve(evolution_problem)`

Perform real time evolution $\exp(-i t H)|\Psi\rangle$.

Evolves an initial state $|\Psi\rangle$ for a time $t$ under a Hamiltonian $H$, as provided in the `evolution_problem`

.

**Parameters**

**evolution_problem** (*TimeEvolutionProblem*) – The evolution problem containing the hamiltonian, total evolution time and observables to evaluate.

**Returns**

A result object containing the evolution information and evaluated observables.

**Raises**

**ValueError**(opens in a new tab) – If`aux_operators`

provided in the time evolution problem but no estimator provided to the algorithm.**NotImplementedError**(opens in a new tab) – If the evolution problem contains an initial state.

**Return type**

### get_loss

`get_loss(hamiltonian, ansatz, dt, current_parameters)`

Get a function to evaluate the infidelity between Trotter step and ansatz.

**Parameters**

**hamiltonian**(*BaseOperator |**PauliSumOp*) – The Hamiltonian under which to evolve.**ansatz**(*QuantumCircuit*) – The parameterized quantum circuit which attempts to approximate the time-evolved state.**dt**(*float*(opens in a new tab)) – The time step.**current_parameters**(*np.ndarray*) – The current parameters.

**Returns**

**A callable to evaluate the infidelity and, if gradients are supported and required,**

a second callable to evaluate the gradient of the infidelity.

**Return type**

tuple(opens in a new tab)[Callable[[np.ndarray], float(opens in a new tab)], Callable[[np.ndarray], np.ndarray]] | None

### step

`step(hamiltonian, ansatz, theta, dt, initial_guess)`

Perform a single time step.

**Parameters**

**hamiltonian**(*BaseOperator |**PauliSumOp*) – The Hamiltonian under which to evolve.**ansatz**(*QuantumCircuit*) – The parameterized quantum circuit which attempts to approximate the time-evolved state.**theta**(*np.ndarray*) – The current parameters.**dt**(*float*(opens in a new tab)) – The time step.**initial_guess**(*np.ndarray*) – The initial guess for the classical optimization of the fidelity between the next variational state and the Trotter-evolved last state. If None, this is set to a random vector with elements in the interval $[-0.01, 0.01]$.

**Returns**

A tuple consisting of the next parameters and the fidelity of the optimization.

**Return type**

tuple(opens in a new tab)[np.ndarray, float(opens in a new tab)]