def test_tapering_qubits_manual_input(self):
"""
Test taper_off_qubits function using LiH Hamiltonian.
Checks different qubits inputs to remove manually.
Test the lowest eigenvalue against the full Hamiltonian,
and the full spectrum between them.
"""
hamiltonian, spectrum = lih_hamiltonian()
qubit_hamiltonian = jordan_wigner(hamiltonian)
stab1 = QubitOperator('Z0 Z2', -1.0)
stab2 = QubitOperator('Z1 Z3', -1.0)
tapered_ham_0_3 = taper_off_qubits(qubit_hamiltonian, [stab1, stab2],
manual_input=True,
fixed_positions=[0, 3])
tapered_ham_2_1 = taper_off_qubits(qubit_hamiltonian, [stab1, stab2],
manual_input=True,
fixed_positions=[2, 1])
tapered_spectrum_0_3 = eigenspectrum(tapered_ham_0_3)
tapered_spectrum_2_1 = eigenspectrum(tapered_ham_2_1)
self.assertAlmostEqual(spectrum[0], tapered_spectrum_0_3[0])
self.assertAlmostEqual(spectrum[0], tapered_spectrum_2_1[0])
self.assertTrue(
numpy.allclose(tapered_spectrum_0_3, tapered_spectrum_2_1))
def test_one_body_square_decomposition(self):
# Initialize H2 InteractionOperator.
n_qubits = 4
filename = os.path.join(THIS_DIRECTORY, 'data',
'H2_sto-3g_singlet_0.7414')
molecule = MolecularData(filename=filename)
molecule_interaction = molecule.get_molecular_hamiltonian()
get_fermion_operator(molecule_interaction)
two_body_coefficients = molecule_interaction.two_body_tensor
# Decompose.
eigenvalues, one_body_squares, _, _ = (low_rank_two_body_decomposition(
two_body_coefficients, truncation_threshold=0))
rank = eigenvalues.size
for l in range(rank):
one_body_operator = FermionOperator()
for p, q in itertools.product(range(n_qubits), repeat=2):
term = ((p, 1), (q, 0))
coefficient = one_body_squares[l, p, q]
one_body_operator += FermionOperator(term, coefficient)
one_body_squared = one_body_operator**2
# Get the squared one-body operator via one-body decomposition.
if abs(eigenvalues[l]) < 1e-6:
with self.assertRaises(ValueError):
prepare_one_body_squared_evolution(one_body_squares[l])
continue
else:
density_density_matrix, basis_transformation_matrix = (
prepare_one_body_squared_evolution(one_body_squares[l]))
two_body_operator = FermionOperator()
for p, q in itertools.product(range(n_qubits), repeat=2):
term = ((p, 1), (p, 0), (q, 1), (q, 0))
coefficient = density_density_matrix[p, q]
two_body_operator += FermionOperator(term, coefficient)
# Confirm that the rotations diagonalize the one-body squares.
hopefully_diagonal = basis_transformation_matrix.dot(
numpy.dot(
one_body_squares[l],
numpy.transpose(
numpy.conjugate(basis_transformation_matrix))))
diagonal = numpy.diag(hopefully_diagonal)
difference = hopefully_diagonal - numpy.diag(diagonal)
self.assertAlmostEqual(0., numpy.amax(numpy.absolute(difference)))
density_density_alternative = numpy.outer(diagonal, diagonal)
difference = density_density_alternative - density_density_matrix
self.assertAlmostEqual(0., numpy.amax(numpy.absolute(difference)))
# Test spectra.
one_body_squared_spectrum = eigenspectrum(one_body_squared)
two_body_spectrum = eigenspectrum(two_body_operator)
difference = two_body_spectrum - one_body_squared_spectrum
self.assertAlmostEqual(0., numpy.amax(numpy.absolute(difference)))
def test_energy_reduce_symmetry_qubits(self):
# Generate the fermionic Hamiltonians,
# number of orbitals and number of electrons.
lih_sto_hamil, lih_sto_numorb, lih_sto_numel = LiH_sto3g()
# Use test function to reduce the qubits.
lih_sto_qbt = (symmetry_conserving_bravyi_kitaev(
lih_sto_hamil, lih_sto_numorb, lih_sto_numel))
self.assertAlmostEqual(
eigenspectrum(lih_sto_qbt)[0],
eigenspectrum(lih_sto_hamil)[0])
def test_eigenspectrum(self):
fermion_eigenspectrum = eigenspectrum(self.fermion_operator)
qubit_eigenspectrum = eigenspectrum(self.qubit_operator)
interaction_eigenspectrum = eigenspectrum(self.interaction_operator)
for i in range(2**self.n_qubits):
self.assertAlmostEqual(fermion_eigenspectrum[i],
qubit_eigenspectrum[i])
self.assertAlmostEqual(fermion_eigenspectrum[i],
interaction_eigenspectrum[i])
with self.assertRaises(TypeError):
_ = eigenspectrum(BosonOperator())
with self.assertRaises(TypeError):
_ = eigenspectrum(QuadOperator())
def lih_hamiltonian():
"""
Generate test Hamiltonian from LiH.
Args:
None
Return:
hamiltonian: FermionicOperator
spectrum: List of energies.
"""
geometry = [('Li', (0., 0., 0.)), ('H', (0., 0., 1.45))]
active_space_start = 1
active_space_stop = 3
molecule = MolecularData(geometry, 'sto-3g', 1, description="1.45")
molecule.load()
molecular_hamiltonian = molecule.get_molecular_hamiltonian(
occupied_indices=range(active_space_start),
active_indices=range(active_space_start, active_space_stop))
hamiltonian = get_fermion_operator(molecular_hamiltonian)
spectrum = eigenspectrum(hamiltonian)
return hamiltonian, spectrum
def test_reduce_terms_auxiliar_functions_manual_input(self):
"""Test reduce_terms function using LiH Hamiltonian."""
hamiltonian, spectrum = lih_hamiltonian()
qubit_ham = jordan_wigner(hamiltonian)
stab1 = QubitOperator('Z0 Z2', -1.0)
stab2 = QubitOperator('Z1 Z3', -1.0)
red_ham1, _ = _reduce_terms(terms=qubit_ham,
stabilizer_list=[stab1, stab2],
manual_input=True,
fixed_positions=[0, 1])
red_ham2, _ = _reduce_terms_keep_length(terms=qubit_ham,
stabilizer_list=[stab1, stab2],
manual_input=True,
fixed_positions=[0, 1])
red_eigspct1 = eigenspectrum(red_ham1)
red_eigspct2 = eigenspectrum(red_ham2)
self.assertAlmostEqual(spectrum[0], red_eigspct1[0])
self.assertAlmostEqual(spectrum[0], red_eigspct2[0])
def test_reduce_terms(self):
"""Test reduce_terms function using LiH Hamiltonian."""
hamiltonian, spectrum = lih_hamiltonian()
qubit_hamiltonian = jordan_wigner(hamiltonian)
stab1 = QubitOperator('Z0 Z2', -1.0)
stab2 = QubitOperator('Z1 Z3', -1.0)
red_eigenspectrum = eigenspectrum(
reduce_number_of_terms(qubit_hamiltonian, stab1 + stab2))
self.assertAlmostEqual(spectrum[0], red_eigenspectrum[0])
def test_reduce_terms_manual_input(self):
"""Test reduce_terms function using LiH Hamiltonian."""
hamiltonian, spectrum = lih_hamiltonian()
qubit_hamiltonian = jordan_wigner(hamiltonian)
stab1 = QubitOperator('Z0 Z2', -1.0)
stab2 = QubitOperator('Z1 Z3', -1.0)
red_eigenspectrum = eigenspectrum(
reduce_number_of_terms(qubit_hamiltonian, [stab1, stab2],
manual_input=True,
fixed_positions=[0, 1]))
self.assertAlmostEqual(spectrum[0], red_eigenspectrum[0])
def test_tapering_qubits_manual_input_false(self):
"""Test taper_off_qubits function using LiH Hamiltonian."""
hamiltonian, spectrum = lih_hamiltonian()
qubit_hamiltonian = jordan_wigner(hamiltonian)
stab1 = QubitOperator('Z0 Z2', -1.0)
stab2 = QubitOperator('Z1 Z3', -1.0)
tapered_hamiltonian = taper_off_qubits(operator=qubit_hamiltonian,
stabilizers=[stab1, stab2],
manual_input=False,
fixed_positions=[0, 3])
tapered_spectrum = eigenspectrum(tapered_hamiltonian)
self.assertAlmostEqual(spectrum[0], tapered_spectrum[0])
def test_hubbard_reduce_symmetry_qubits(self):
for i in range(4):
n_sites = i + 2
n_ferm = n_sites
hub_hamil, n_orb = set_1D_hubbard(n_sites)
# Use test function to reduce the qubits.
hub_qbt = (symmetry_conserving_bravyi_kitaev(
hub_hamil, n_orb, n_ferm))
sparse_op = get_sparse_operator(hub_hamil)
ground_energy, _ = jw_get_ground_state_at_particle_number(
sparse_op, n_ferm)
self.assertAlmostEqual(eigenspectrum(hub_qbt)[0], ground_energy)
