IQPE e evolução do estado de saída do VQE¶

Este notebook demonstra o uso de um estado resultante de saída do VQE como o estado inicial, de entrada, para evolução pelo algoritmo IQPE (Estimação de Fase Quântica Iterativa).

Isso é realizado primeiro rodando o VQE e depois preparando o estado inicial do IQPE usando a forma variacional como produzida pelo VQE mediante sua finalização.

[1]:

import numpy as np
from qiskit import BasicAer
from qiskit.aqua import aqua_globals, QuantumInstance
from qiskit.aqua.algorithms import VQE, NumPyMinimumEigensolver, IQPE
from qiskit.aqua.operators import I, X, Z
from qiskit.circuit.library import TwoLocal
from qiskit.aqua.components.optimizers import SPSA
from qiskit.aqua.components.initial_states.var_form_based import VarFormBased

Primeiro, criamos um operador de qubit para o VQE. Aqui, vamos usar o mesmo operador usado na introdução do algoritmo, que foi originalmente calculado pelo Qiskit Chemistry para uma molécula de H2.

[2]:

H2_op = (-1.052373245772859 * I ^ I) + \
        (0.39793742484318045 * I ^ Z) + \
        (-0.39793742484318045 * Z ^ I) + \
        (-0.01128010425623538 * Z ^ Z) + \
        (0.18093119978423156 * X ^ X)

Primeiro, vamos usar o NumPyMinimumEigensolver clássico para calcular o valor de referência da energia do estado fundamental, para que possamos depois comparar com o resultado do VQE primeiro, e então do IQPE.

[3]:

npme = NumPyMinimumEigensolver()
result = npme.compute_minimum_eigenvalue(operator=H2_op)
ref_value = result.eigenvalue.real
print(f'Reference value: {ref_value:.5f}')

Reference value: -1.85728

Tendo estabelecido a energia fundamental de referência, nós seguimos com o nosso experimento. Primeiro configuramos uma instância do algoritmo VQE. A ideia é que possamos configurar uma condição de finalização de tal forma que a instância do VQE retorne bastante rapidamente com uma estimativa aproximada.

[4]:

seed = 5
aqua_globals.random_seed = seed

var_form = TwoLocal(rotation_blocks=['ry', 'rz'], entanglement_blocks='cz', reps=3)
spsa = SPSA(maxiter=10)
backend = BasicAer.get_backend('qasm_simulator')
qi = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed)

vqe = VQE(var_form=var_form, optimizer=spsa, quantum_instance=qi)
result_vqe = vqe.compute_minimum_eigenvalue(operator=H2_op)

print(f'VQE estimated the ground energy to be {result_vqe.eigenvalue.real:.5f}')
print(f'Delta from reference energy value is {(result_vqe.eigenvalue.real - ref_value):.5f}')

VQE estimated the ground energy to be -1.74063
Delta from reference energy value is 0.11664

Como indicado anteriormente, o resultado da estimação da energia é bastante grosseiro-está longe de ser uma figura de estimação final aceitável. Mas, é próximo o suficiente para que a forma variacional acompanhante possa ser uma aproximação razoavelmente boa do autoestado fundamental, o que significa que a função de onda correspondente pode servir como estado inicial para a execução do IQPE depois. A seguir preparamos tal estado inicial.

[5]:

vqe_state = VarFormBased(var_form, result_vqe.optimal_parameters)

Com a função de onda quântica gerada pelo VQE preparada para o estado inicial, agora vamos em frente com a configuração e execução de uma instância IQPE.

[6]:

qi = QuantumInstance(backend, shots=100, seed_simulator=seed, seed_transpiler=seed)

iqpe = IQPE(state_in=vqe_state, num_time_slices=1, num_iterations=6,
            expansion_mode='suzuki', expansion_order=2, quantum_instance=qi)
result_iqpe = result_vqe = iqpe.compute_minimum_eigenvalue(operator=H2_op)

print(f"Continuing with VQE's result, IQPE estimated the ground energy to be {result_iqpe.eigenvalue.real:.5f}")
print(f'Delta from reference energy value is {(result_iqpe.eigenvalue.real - ref_value):.5f}')

Continuing with VQE's result, IQPE estimated the ground energy to be -1.84917
Delta from reference energy value is 0.00811

Como pode ser visto, a estimativa de energia do estado fundamental resultante, conforme produzido pelo IQPE, é muito mais precisa que o resultado intermediário produzido pelo VQE.

[7]:

import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright

Version Information

Qiskit Software	Version
Qiskit	0.23.0
Terra	0.16.0
Aer	0.7.0
Ignis	0.5.0
Aqua	0.8.0
IBM Q Provider	0.11.0
System information
Python	3.6.1 \|Continuum Analytics, Inc.\| (default, May 11 2017, 13:09:58) [GCC 4.4.7 20120313 (Red Hat 4.4.7-1)]
OS	Linux
CPUs	1
Memory (Gb)	5.827335357666016
Sat Nov 07 16:15:38 2020 EST

This code is a part of Qiskit

This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.

[ ]: