def _build_operator(
self, func_dict: Dict[Union[int, Tuple[int, int]],
int]) -> QuantumCircuit:
"""Creates a circuit for the state preparation operator.
Args:
func_dict: Representation of the QUBO problem. The keys should be subscripts of the
coefficients (e.g. x_1 -> 1), with the constant (if present) being represented with
a key of -1 (i.e. d[-1] = constant). Quadratic coefficients should use a tuple for
the key, with the corresponding subscripts inside (e.g. 2*x_1*x_2 -> d[(1,2)]=2).
Returns:
Circuit object describing the state preparation operator.
"""
# Build initial circuit.
key_val = QuantumRegister(self._num_key + self._num_value, "key_value")
circuit = QuantumCircuit(key_val)
if self._measurement:
measure = ClassicalRegister(self._num_key + self._num_value)
circuit.add_register(measure)
circuit.h(key_val)
# Linear Coefficients.
for i in range(self._num_value):
if func_dict.get(-1, 0) != 0:
circuit.u1(
1 / 2**self._num_value * 2 * np.pi * 2**i * func_dict[-1],
key_val[self._num_key + i])
for j in range(self._num_key):
if func_dict.get(j, 0) != 0:
circuit.cu1(
1 / 2**self._num_value * 2 * np.pi * 2**i *
func_dict[j], key_val[j], key_val[self._num_key + i])
# Quadratic Coefficients.
for i in range(self._num_value):
for k, v in func_dict.items():
if isinstance(k, tuple):
circuit.mcu1(1 / 2**self._num_value * 2 * np.pi * 2**i * v,
[key_val[k[0]], key_val[k[1]]],
key_val[self._num_key + i])
# Add IQFT.
iqft = IQFT(self._num_value)
value = [
key_val[v]
for v in range(self._num_key, self._num_key + self._num_value)
]
iqft.construct_circuit(qubits=value, circuit=circuit)
return circuit
def test_qae_circuit(self, efficient_circuit):
"""Test circuits resulting from canonical amplitude estimation.
Build the circuit manually and from the algorithm and compare the resulting unitaries.
"""
prob = 0.5
for m in range(2, 7):
qae = AmplitudeEstimation(m, a_factory=BernoulliAFactory(prob))
angle = 2 * np.arcsin(np.sqrt(prob))
# manually set up the inefficient AE circuit
q_ancilla = QuantumRegister(m, 'a')
q_objective = QuantumRegister(1, 'q')
circuit = QuantumCircuit(q_ancilla, q_objective)
# initial Hadamard gates
for i in range(m):
circuit.h(q_ancilla[i])
# A operator
circuit.ry(angle, q_objective)
if efficient_circuit:
qae.q_factory = BernoulliQFactory(qae.a_factory)
for power in range(m):
circuit.cry(2 * 2**power * angle, q_ancilla[power],
q_objective[0])
else:
q_factory = QFactory(qae.a_factory, i_objective=0)
for power in range(m):
for _ in range(2**power):
q_factory.build_controlled(circuit, q_objective,
q_ancilla[power])
# fourier transform
iqft = Standard(m)
circuit = iqft.construct_circuit(qubits=q_ancilla,
circuit=circuit,
do_swaps=False)
expected_unitary = self._unitary.execute(circuit).get_unitary()
actual_circuit = qae.construct_circuit(measurement=False)
actual_unitary = self._unitary.execute(
actual_circuit).get_unitary()
diff = np.sum(np.abs(actual_unitary - expected_unitary))
self.assertAlmostEqual(diff, 0)
def __init__(self,
num_eval_qubits: int,
a_factory: Optional[CircuitFactory] = None,
q_factory: Optional[CircuitFactory] = None,
i_objective: Optional[int] = None,
iqft: Optional[IQFT] = None) -> None:
r"""
Args:
num_eval_qubits: Number of evaluation qubits, has a min. value of 1.
a_factory: The CircuitFactory subclass object representing the problem unitary.
q_factory: The CircuitFactory subclass object representing an amplitude estimation
sample (based on a_factory).
i_objective: The index of the objective qubit, i.e. the qubit marking 'good' solutions
with the state \|1> and 'bad' solutions with the state \|0>.
iqft: The Inverse Quantum Fourier Transform component, defaults to using a standard IQFT
when None
"""
validate_min('num_eval_qubits', num_eval_qubits, 1)
super().__init__(a_factory, q_factory, i_objective)
# get parameters
self._m = num_eval_qubits
self._M = 2**num_eval_qubits
if iqft is None:
iqft = Standard(self._m)
self._iqft = iqft
self._circuit = None
self._ret = {}
def __init__(self, num_eval_qubits: int,
a_factory: Optional[CircuitFactory] = None,
i_objective: Optional[int] = None,
q_factory: Optional[CircuitFactory] = None,
iqft: Optional[IQFT] = None) -> None:
"""
Args:
num_eval_qubits: number of evaluation qubits, has a min. value of 1.
a_factory: the CircuitFactory subclass object representing
the problem unitary
i_objective: i objective
q_factory: the CircuitFactory subclass object representing an
amplitude estimation sample (based on a_factory)
iqft: the Inverse Quantum Fourier Transform component,
defaults to using a standard iqft when None
"""
validate_min('num_eval_qubits', num_eval_qubits, 1)
super().__init__(a_factory, q_factory, i_objective)
# get parameters
self._m = num_eval_qubits
self._M = 2 ** num_eval_qubits
if iqft is None:
iqft = Standard(self._m)
self._iqft = iqft
self._circuit = None
self._ret = {}
def test_deprecated_qft(self):
"""Test the QPE algorithm on the deprecated QFT component."""
qubit_op = self._dict['QUBIT_OP_SIMPLE']
exact_eigensolver = NumPyMinimumEigensolver(qubit_op)
results = exact_eigensolver.run()
ref_eigenval = results.eigenvalue
ref_eigenvec = results.eigenstate
state_in = Custom(qubit_op.num_qubits, state_vector=ref_eigenvec)
warnings.filterwarnings('ignore', category=DeprecationWarning)
iqft = Standard(5)
qpe = QPE(qubit_op,
state_in,
iqft,
num_time_slices=1,
num_ancillae=5,
expansion_mode='suzuki',
expansion_order=2,
shallow_circuit_concat=True)
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend,
shots=100,
seed_transpiler=1,
seed_simulator=1)
# run qpe
result = qpe.run(quantum_instance)
warnings.filterwarnings('always', category=DeprecationWarning)
self.assertAlmostEqual(result.eigenvalue.real,
ref_eigenval.real,
delta=2e-2)
def __init__(self,
num_eval_qubits,
a_factory=None,
i_objective=None,
q_factory=None,
iqft=None):
"""
Args:
num_eval_qubits (int): number of evaluation qubits
a_factory (CircuitFactory): the CircuitFactory subclass object representing
the problem unitary
i_objective (int): i objective
q_factory (CircuitFactory): the CircuitFactory subclass object representing an
amplitude estimation sample (based on a_factory)
iqft (IQFT): the Inverse Quantum Fourier Transform component,
defaults to using a standard iqft when None
"""
validate(locals(), self._INPUT_SCHEMA)
super().__init__(a_factory, q_factory, i_objective)
# get parameters
self._m = num_eval_qubits
self._M = 2**num_eval_qubits
if iqft is None:
iqft = Standard(self._m)
self._iqft = iqft
self._circuit = None
self._ret = {}
def execute_qpe_circuit(self,
num_ancillae: int = 1,
backend: BaseBackend = None,
shots: int = 1024,
print_eig: bool = False) -> Result:
"""Runs the QPE algorithm by constructing the circuit explicitly.
Args:
num_ancillae (int, optional): ancillary qubit number, the higher the more accurate, but use more computing resources. Defaults to 1.
backend (BaseBackend, optional): Choose the backend to run this algorithm. Defaults to None.
shots (int, optional): Indicate how many shots to take. Defaults to 1024.
print_eig (bool, optional): whether or not print the eigenvalue. Defaults to False.
Returns:
Result: returns a Qiskit.result object. Use get_counts() to get a dictionary for the qubits' probabilities.
"""
if backend is None: # Default backend to Aer.get_backend('qasm_simulator').
backend = Aer.get_backend('qasm_simulator')
# QPE Circuit
m, n = self.matrix.shape
qpe = QPE(operator=MatrixOperator(matrix=self.matrix),
state_in=Custom(m),
iqft=Standard(num_ancillae),
num_time_slices=50,
num_ancillae=num_ancillae,
expansion_mode='suzuki',
expansion_order=2,
shallow_circuit_concat=True)
results = execute(qpe.construct_circuit(measurement=True),
backend=backend).result()
if print_eig: print(results.get_counts())
return results
def test_qpe(self, distance):
self.algorithm = 'QPE'
self.log.debug('Testing End-to-End with QPE on H2 with inter-atomic distance {}.'.format(distance))
try:
driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 {}'.format(distance),
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis='sto3g')
except QiskitChemistryError:
self.skipTest('PYSCF driver does not appear to be installed')
self.molecule = driver.run()
qubit_mapping = 'parity'
fer_op = FermionicOperator(
h1=self.molecule.one_body_integrals, h2=self.molecule.two_body_integrals)
self.qubit_op = fer_op.mapping(map_type=qubit_mapping,
threshold=1e-10).two_qubit_reduced_operator(2)
exact_eigensolver = ExactEigensolver(self.qubit_op, k=1)
results = exact_eigensolver.run()
self.reference_energy = results['energy']
self.log.debug(
'The exact ground state energy is: {}'.format(results['energy']))
num_particles = self.molecule.num_alpha + self.molecule.num_beta
two_qubit_reduction = True
num_orbitals = self.qubit_op.num_qubits + \
(2 if two_qubit_reduction else 0)
num_time_slices = 50
n_ancillae = 9
state_in = HartreeFock(self.qubit_op.num_qubits, num_orbitals,
num_particles, qubit_mapping, two_qubit_reduction)
iqft = Standard(n_ancillae)
qpe = QPE(self.qubit_op, state_in, iqft, num_time_slices, n_ancillae,
expansion_mode='suzuki',
expansion_order=2, shallow_circuit_concat=True)
backend = qiskit.Aer.get_backend('qasm_simulator')
run_config = RunConfig(shots=100, max_credits=10, memory=False)
quantum_instance = QuantumInstance(backend, run_config, pass_manager=PassManager())
result = qpe.run(quantum_instance)
self.log.debug('eigvals: {}'.format(result['eigvals']))
self.log.debug('top result str label: {}'.format(result['top_measurement_label']))
self.log.debug('top result in decimal: {}'.format(result['top_measurement_decimal']))
self.log.debug('stretch: {}'.format(result['stretch']))
self.log.debug('translation: {}'.format(result['translation']))
self.log.debug('final energy from QPE: {}'.format(result['energy']))
self.log.debug('reference energy: {}'.format(self.reference_energy))
self.log.debug('ref energy (transformed): {}'.format(
(self.reference_energy + result['translation']) * result['stretch']))
self.log.debug('ref binary str label: {}'.format(decimal_to_binary((self.reference_energy + result['translation']) * result['stretch'],
max_num_digits=n_ancillae + 3,
fractional_part_only=True)))
np.testing.assert_approx_equal(
result['energy'], self.reference_energy, significant=2)
def __init__(self, num_eval_qubits, a_factory, q_factory=None, iqft=None):
"""
Constructor.
Args:
num_eval_qubits (int): number of evaluation qubits
a_factory (CircuitFactory): the CircuitFactory subclass object representing the problem unitary
q_factory (CircuitFactory): the CircuitFactory subclass object representing an amplitude estimation sample (based on a_factory)
iqft (IQFT): the Inverse Quantum Fourier Transform pluggable component, defaults to using a standard iqft when None
"""
self.validate(locals())
super().__init__()
# get/construct A/Q operator
self.a_factory = a_factory
if q_factory is None:
self.q_factory = QFactory(a_factory)
else:
self.q_factory = q_factory
# get parameters
self._m = num_eval_qubits
self._M = 2**num_eval_qubits
# determine number of ancillas
self._num_ancillas = self.q_factory.required_ancillas_controlled()
self._num_qubits = self.a_factory.num_target_qubits + self._m + self._num_ancillas
if iqft is None:
iqft = Standard(self._m)
self._iqft = iqft
self._circuit = None
self._ret = {}
def run_qpe_algo(self,
num_ancillae: int = 1,
backend: BaseBackend = None,
print_eig: bool = False,
shots: int = 1024) -> dict:
""" Runs the QPE algorithm directly.
Args:
num_ancillae (int, optional): ancillary qubit number, the higher the more accurate, but use more computing resources. Defaults to 1.
backend (BaseBackend, optional): Choose the backend to run this algorithm. Defaults to None.
print_eig (bool, optional): whether or not print the eigenvalue. Defaults to False.
shots (int, optional): Indicate how many shots to take. Defaults to 1024.
Returns:
dict: returns the results dictionary of the QPE algorithm. Use the 'energy' key to get the eigenvalue.
"""
if backend is None: # Default backend to Aer.get_backend('qasm_simulator').
backend = Aer.get_backend('qasm_simulator')
# QPE
m, n = self.matrix.shape
qpe = QPE(operator=MatrixOperator(matrix=self.matrix),
state_in=Custom(m),
iqft=Standard(num_ancillae),
num_time_slices=50,
num_ancillae=num_ancillae,
expansion_mode='suzuki',
expansion_order=2,
shallow_circuit_concat=True)
results = qpe.run(
QuantumInstance(backend=backend,
skip_qobj_validation=False,
shots=shots))
if print_eig: print("ENERGY:", results['energy'])
return results
def test_qpe(self, distance):
""" qpe test """
self.log.debug('Testing End-to-End with QPE on '
'H2 with inter-atomic distance %s.', distance)
try:
driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 {}'.format(distance),
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis='sto3g')
except QiskitChemistryError:
self.skipTest('PYSCF driver does not appear to be installed')
molecule = driver.run()
qubit_mapping = 'parity'
fer_op = FermionicOperator(
h1=molecule.one_body_integrals, h2=molecule.two_body_integrals)
qubit_op = fer_op.mapping(map_type=qubit_mapping, threshold=1e-10)
qubit_op = Z2Symmetries.two_qubit_reduction(qubit_op, 2)
exact_eigensolver = ExactEigensolver(qubit_op, k=1)
results = exact_eigensolver.run()
reference_energy = results['energy']
self.log.debug('The exact ground state energy is: %s', results['energy'])
num_particles = molecule.num_alpha + molecule.num_beta
two_qubit_reduction = True
num_orbitals = qubit_op.num_qubits + \
(2 if two_qubit_reduction else 0)
num_time_slices = 1
n_ancillae = 6
state_in = HartreeFock(qubit_op.num_qubits, num_orbitals,
num_particles, qubit_mapping, two_qubit_reduction)
iqft = Standard(n_ancillae)
qpe = QPE(qubit_op, state_in, iqft, num_time_slices, n_ancillae,
expansion_mode='suzuki',
expansion_order=2, shallow_circuit_concat=True)
backend = qiskit.BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=100)
result = qpe.run(quantum_instance)
self.log.debug('eigvals: %s', result['eigvals'])
self.log.debug('top result str label: %s', result['top_measurement_label'])
self.log.debug('top result in decimal: %s', result['top_measurement_decimal'])
self.log.debug('stretch: %s', result['stretch'])
self.log.debug('translation: %s', result['translation'])
self.log.debug('final energy from QPE: %s', result['energy'])
self.log.debug('reference energy: %s', reference_energy)
self.log.debug('ref energy (transformed): %s',
(reference_energy + result['translation']) * result['stretch'])
self.log.debug('ref binary str label: %s',
decimal_to_binary(
(reference_energy + result['translation']) * result['stretch'],
max_num_digits=n_ancillae + 3, fractional_part_only=True))
np.testing.assert_approx_equal(result['energy'], reference_energy, significant=2)
def test_qpe(self, qubit_op, simulator, num_time_slices, n_ancillae):
""" QPE test """
self.log.debug('Testing QPE')
tmp_qubit_op = qubit_op.copy()
exact_eigensolver = ExactEigensolver(qubit_op, k=1)
results = exact_eigensolver.run()
ref_eigenval = results['eigvals'][0]
ref_eigenvec = results['eigvecs'][0]
self.log.debug('The exact eigenvalue is: %s', ref_eigenval)
self.log.debug('The corresponding eigenvector: %s', ref_eigenvec)
state_in = Custom(qubit_op.num_qubits, state_vector=ref_eigenvec)
iqft = Standard(n_ancillae)
qpe = QPE(qubit_op,
state_in,
iqft,
num_time_slices,
n_ancillae,
expansion_mode='suzuki',
expansion_order=2,
shallow_circuit_concat=True)
backend = BasicAer.get_backend(simulator)
quantum_instance = QuantumInstance(backend, shots=100)
# run qpe
result = qpe.run(quantum_instance)
# report result
self.log.debug('top result str label: %s',
result['top_measurement_label'])
self.log.debug('top result in decimal: %s',
result['top_measurement_decimal'])
self.log.debug('stretch: %s', result['stretch'])
self.log.debug('translation: %s',
result['translation'])
self.log.debug('final eigenvalue from QPE: %s', result['energy'])
self.log.debug('reference eigenvalue: %s', ref_eigenval)
self.log.debug('ref eigenvalue (transformed): %s',
(ref_eigenval + result['translation']) *
result['stretch'])
self.log.debug(
'reference binary str label: %s',
decimal_to_binary((ref_eigenval.real + result['translation']) *
result['stretch'],
max_num_digits=n_ancillae + 3,
fractional_part_only=True))
np.testing.assert_approx_equal(result['energy'],
ref_eigenval.real,
significant=2)
self.assertEqual(tmp_qubit_op, qubit_op,
"Operator is modified after QPE.")
def test_qpe(self, qubit_op, simulator, num_time_slices, n_ancillae, use_circuit_library):
""" QPE test """
self.log.debug('Testing QPE')
qubit_op = self._dict[qubit_op]
exact_eigensolver = NumPyMinimumEigensolver(qubit_op)
results = exact_eigensolver.run()
ref_eigenval = results.eigenvalue
ref_eigenvec = results.eigenstate
self.log.debug('The exact eigenvalue is: %s', ref_eigenval)
self.log.debug('The corresponding eigenvector: %s', ref_eigenvec)
state_in = Custom(qubit_op.num_qubits, state_vector=ref_eigenvec)
if use_circuit_library:
iqft = QFT(n_ancillae).inverse()
else:
# ignore deprecation warnings from QFTs
warnings.filterwarnings(action="ignore", category=DeprecationWarning)
iqft = Standard(n_ancillae)
qpe = QPE(qubit_op, state_in, iqft, num_time_slices, n_ancillae,
expansion_mode='suzuki', expansion_order=2,
shallow_circuit_concat=True)
backend = BasicAer.get_backend(simulator)
quantum_instance = QuantumInstance(backend, shots=100)
# run qpe
result = qpe.run(quantum_instance)
# report result
self.log.debug('top result str label: %s', result.top_measurement_label)
self.log.debug('top result in decimal: %s', result.top_measurement_decimal)
self.log.debug('stretch: %s', result.stretch)
self.log.debug('translation: %s', result.translation)
self.log.debug('final eigenvalue from QPE: %s', result.eigenvalue)
self.log.debug('reference eigenvalue: %s', ref_eigenval)
self.log.debug('ref eigenvalue (transformed): %s',
(ref_eigenval + result.translation) * result.stretch)
self.log.debug('reference binary str label: %s', decimal_to_binary(
(ref_eigenval.real + result.translation) * result.stretch,
max_num_digits=n_ancillae + 3,
fractional_part_only=True
))
np.testing.assert_approx_equal(result.eigenvalue.real, ref_eigenval.real, significant=2)
if not use_circuit_library:
warnings.filterwarnings(action="always", category=DeprecationWarning)
def test_deprecated_qft(self):
"""Test running QAE on the deprecated QFT."""
prob = 0.2
a_factory = BernoulliAFactory(prob)
q_factory = BernoulliQFactory(a_factory)
warnings.filterwarnings('ignore', category=DeprecationWarning)
iqft = Standard(2)
qae = AmplitudeEstimation(2,
a_factory=a_factory,
q_factory=q_factory,
iqft=iqft)
result = qae.run(self._statevector)
warnings.filterwarnings('always', category=DeprecationWarning)
expected = {'estimation': 0.5, 'mle': 0.2}
for key, value in expected.items():
self.assertAlmostEqual(value,
result[key],
places=3,
msg="estimate `{}` failed".format(key))
def test_qpe(self, qubit_op, simulator, num_time_slices, n_ancillae):
""" QPE test """
self.log.debug('Testing QPE')
tmp_qubit_op = qubit_op.copy()
exact_eigensolver = ExactEigensolver(qubit_op, k=1)
results = exact_eigensolver.run()
ref_eigenval = results['eigvals'][0]
ref_eigenvec = results['eigvecs'][0]
self.log.debug('The exact eigenvalue is: %s', ref_eigenval)
self.log.debug('The corresponding eigenvector: %s', ref_eigenvec)
state_in = Custom(qubit_op.num_qubits, state_vector=ref_eigenvec)
iqft = Standard(n_ancillae)
qpe = QPE(qubit_op, iqft, state_in=state_in, num_time_slices=num_time_slices, num_ancillae=n_ancillae,
expansion_mode='suzuki', expansion_order=2,
shallow_circuit_concat=True)
backend = BasicAer.get_backend(simulator)
quantum_instance = QuantumInstance(backend, shots=100)
# run qpe
result = qpe.run(quantum_instance)
# report result
self.log.debug('top result str label: %s', result['top_measurement_label'])
self.log.debug('top result in decimal: %s', result['top_measurement_decimal'])
self.log.debug('stretch: %s', result['stretch'])
self.log.debug('translation: %s', result['translation'])
self.log.debug('final eigenvalue from QPE: %s', result['energy'])
self.log.debug('reference eigenvalue: %s', ref_eigenval)
self.log.debug('ref eigenvalue (transformed): %s',
(ref_eigenval + result['translation']) * result['stretch'])
self.log.debug('reference binary str label: %s', decimal_to_binary(
(ref_eigenval.real + result['translation']) * result['stretch'],
max_num_digits=n_ancillae + 3,
fractional_part_only=True
))
np.testing.assert_approx_equal(result['energy'], ref_eigenval.real, significant=2)
self.assertEqual(tmp_qubit_op, qubit_op, "Operator is modified after QPE.")
#Re-run, now with state_in_circuit_factory
superpose_state_and_flip = FlipSuperposition(state_in)
qpe = QPE(qubit_op, iqft, state_in_circuit_factory=superpose_state_and_flip, num_time_slices=num_time_slices, num_ancillae=n_ancillae, expansion_mode='suzuki', expansion_order=2, shallow_circuit_concat=True)
backend = BasicAer.get_backend(simulator)
quantum_instance = QuantumInstance(backend, shots=100)
# run qpe
result = qpe.run(quantum_instance)
ancilla_counts = result["ancilla_counts"]
if simulator=="qasm_simulator":
self.assertEqual(result['top_measurement_label'], sorted([(ancilla_counts[k], k) for k in ancilla_counts])[::-1][0][-1][::-1])
else:
self.assertEqual(len(ancilla_counts), 1<<n_ancillae)
self.assertEqual(len(result["aux_counts"]), 1<<superpose_state_and_flip.required_ancillas())
def test_qpe(self, qubitOp, simulator):
self.algorithm = 'QPE'
self.log.debug('Testing QPE')
self.qubitOp = qubitOp
exact_eigensolver = ExactEigensolver(self.qubitOp, k=1)
results = exact_eigensolver.run()
w = results['eigvals']
v = results['eigvecs']
self.qubitOp.to_matrix()
np.testing.assert_almost_equal(self.qubitOp._matrix @ v[0],
w[0] * v[0])
np.testing.assert_almost_equal(
expm(-1.j * sparse.csc_matrix(self.qubitOp._matrix)) @ v[0],
np.exp(-1.j * w[0]) * v[0])
self.ref_eigenval = w[0]
self.ref_eigenvec = v[0]
self.log.debug('The exact eigenvalue is: {}'.format(
self.ref_eigenval))
self.log.debug('The corresponding eigenvector: {}'.format(
self.ref_eigenvec))
num_time_slices = 50
n_ancillae = 6
state_in = Custom(self.qubitOp.num_qubits,
state_vector=self.ref_eigenvec)
iqft = Standard(n_ancillae)
qpe = QPE(self.qubitOp,
state_in,
iqft,
num_time_slices,
n_ancillae,
expansion_mode='suzuki',
expansion_order=2,
shallow_circuit_concat=True)
backend = BasicAer.get_backend(simulator)
quantum_instance = QuantumInstance(backend,
shots=100,
pass_manager=PassManager())
# run qpe
result = qpe.run(quantum_instance)
# self.log.debug('transformed operator paulis:\n{}'.format(self.qubitOp.print_operators('paulis')))
# report result
self.log.debug('top result str label: {}'.format(
result['top_measurement_label']))
self.log.debug('top result in decimal: {}'.format(
result['top_measurement_decimal']))
self.log.debug('stretch: {}'.format(
result['stretch']))
self.log.debug('translation: {}'.format(
result['translation']))
self.log.debug('final eigenvalue from QPE: {}'.format(
result['energy']))
self.log.debug('reference eigenvalue: {}'.format(
self.ref_eigenval))
self.log.debug('ref eigenvalue (transformed): {}'.format(
(self.ref_eigenval + result['translation']) * result['stretch']))
self.log.debug('reference binary str label: {}'.format(
decimal_to_binary(
(self.ref_eigenval.real + result['translation']) *
result['stretch'],
max_num_digits=n_ancillae + 3,
fractional_part_only=True)))
np.testing.assert_approx_equal(result['energy'],
self.ref_eigenval.real,
significant=2)
print('The exact ground state energy is: {} eV'.format(result_ee['energy'] *
27.21138506))
num_particles = molecule.num_alpha + molecule.num_beta
two_qubit_reduction = (qubit_mapping == 'parity')
num_orbitals = qubit_op.num_qubits + (2 if two_qubit_reduction else 0)
print('Number of qubits: ', qubit_op.num_qubits)
num_time_slices = 50
n_ancillae = 8
print('Number of ancillae:', n_ancillae)
state_in = HartreeFock(qubit_op.num_qubits, num_orbitals, num_particles,
qubit_mapping, two_qubit_reduction)
iqft = Standard(n_ancillae)
qpe = QPE(qubit_op,
state_in,
iqft,
num_time_slices,
n_ancillae,
expansion_mode='trotter',
expansion_order=2,
shallow_circuit_concat=True)
# backend
#backend = Aer.get_backend('qasm_simulator')
# IBM Q
from qiskit import IBMQ
