def test_number_sz_restricted_spectra_match_molecule(self):
hamiltonian_fop = get_fermion_operator(self.molecular_hamiltonian)
sparse_ham_number_sz_preserving = get_number_preserving_sparse_operator(
hamiltonian_fop,
self.molecule.n_qubits,
self.molecule.n_electrons,
spin_preserving=True)
sparse_ham = get_sparse_operator(hamiltonian_fop,
self.molecule.n_qubits)
sparse_ham_restricted_number_sz_preserving = jw_sz_restrict_operator(
sparse_ham,
0,
n_electrons=self.molecule.n_electrons,
n_qubits=self.molecule.n_qubits)
spectrum_from_new_sparse_method = sparse_eigenspectrum(
sparse_ham_number_sz_preserving)
spectrum_from_old_sparse_method = sparse_eigenspectrum(
sparse_ham_restricted_number_sz_preserving)
spectral_deviation = numpy.amax(
numpy.absolute(spectrum_from_new_sparse_method -
spectrum_from_old_sparse_method))
self.assertAlmostEqual(spectral_deviation, 0.)
def test_one_body_hf_energy(self):
one_body_part = self.molecular_hamiltonian
one_body_part.two_body_tensor = numpy.zeros_like(
one_body_part.two_body_tensor)
one_body_fop = get_fermion_operator(one_body_part)
one_body_regular_sparse_op = get_sparse_operator(one_body_fop)
make_hf_fop = FermionOperator(((3, 1), (2, 1), (1, 1), (0, 1)))
make_hf_sparse_op = get_sparse_operator(make_hf_fop, n_qubits=12)
hf_state = numpy.zeros((2**12))
hf_state[0] = 1.0
hf_state = make_hf_sparse_op.dot(hf_state)
regular_sparse_hf_energy = \
(hf_state.dot(one_body_regular_sparse_op.dot(hf_state))).real
one_body_sparse_op = get_number_preserving_sparse_operator(
one_body_fop,
self.molecule.n_qubits,
self.molecule.n_electrons,
spin_preserving=True)
space_size = one_body_sparse_op.shape[0]
reference = numpy.zeros((space_size))
reference[0] = 1.0
sparse_hf_energy = reference.dot(one_body_sparse_op.dot(reference))
assert numpy.linalg.norm(sparse_hf_energy -
regular_sparse_hf_energy) < 1E-9
def test_number_restricted_spectra_match_hubbard(self):
hamiltonian_fop = self.hubbard_hamiltonian
sparse_ham_number_preserving = get_number_preserving_sparse_operator(
hamiltonian_fop,
8,
4,
spin_preserving=False)
sparse_ham = get_sparse_operator(hamiltonian_fop,
8)
sparse_ham_restricted_number_preserving = jw_number_restrict_operator(
sparse_ham,
n_electrons=4,
n_qubits=8)
spectrum_from_new_sparse_method = sparse_eigenspectrum(
sparse_ham_number_preserving)
spectrum_from_old_sparse_method = sparse_eigenspectrum(
sparse_ham_restricted_number_preserving)
spectral_deviation = numpy.amax(numpy.absolute(
spectrum_from_new_sparse_method - spectrum_from_old_sparse_method))
self.assertAlmostEqual(spectral_deviation, 0.)
def test_full_ham_hermitian_non_spin_preserving(self):
hamiltonian_fop = get_fermion_operator(self.molecular_hamiltonian)
sparse_ham = get_number_preserving_sparse_operator(
hamiltonian_fop,
self.molecule.n_qubits,
self.molecule.n_electrons,
spin_preserving=False)
assert scipy.sparse.linalg.norm(sparse_ham - sparse_ham.getH()) < 1E-9
def test_singles_repeating_two_body_term_hermitian(self):
fop = FermionOperator(((3, 1), (1, 1), (5, 0), (1, 0)))
fop_conj = FermionOperator(((5, 1), (1, 1), (3, 0), (1, 0)))
sparse_op = get_number_preserving_sparse_operator(
fop,
self.molecule.n_qubits,
self.molecule.n_electrons,
spin_preserving=True,
excitation_level=1)
sparse_op_conj = get_number_preserving_sparse_operator(
fop_conj,
self.molecule.n_qubits,
self.molecule.n_electrons,
spin_preserving=True,
excitation_level=1)
assert scipy.sparse.linalg.norm(sparse_op - sparse_op_conj.getH()) < 1E-9
def test_number_on_reference(self):
sum_n_op = FermionOperator()
sum_sparse_n_op = get_number_preserving_sparse_operator(
sum_n_op,
self.molecule.n_qubits,
self.molecule.n_electrons,
spin_preserving=False)
space_size = sum_sparse_n_op.shape[0]
reference = numpy.zeros((space_size))
reference[0] = 1.0
for i in range(self.molecule.n_qubits):
n_op = FermionOperator(((i, 1), (i, 0)))
sum_n_op += n_op
sparse_n_op = get_number_preserving_sparse_operator(
n_op,
self.molecule.n_qubits,
self.molecule.n_electrons,
spin_preserving=False)
sum_sparse_n_op += sparse_n_op
expectation = reference.dot(sparse_n_op.dot(reference))
if i < self.molecule.n_electrons:
assert expectation == 1.0
else:
assert expectation == 0.0
convert_after_adding = get_number_preserving_sparse_operator(
sum_n_op,
self.molecule.n_qubits,
self.molecule.n_electrons,
spin_preserving=False)
assert scipy.sparse.linalg.norm(convert_after_adding -
sum_sparse_n_op) < 1E-9
assert reference.dot(sum_sparse_n_op.dot(reference)) - \
self.molecule.n_electrons < 1E-9
def test_singles_ham_hermitian(self):
hamiltonian_fop = get_fermion_operator(self.molecular_hamiltonian)
sparse_ham = get_number_preserving_sparse_operator(
hamiltonian_fop,
self.molecule.n_qubits,
self.molecule.n_electrons,
spin_preserving=True,
excitation_level=1)
assert scipy.sparse.linalg.norm(sparse_ham - sparse_ham.getH()) < 1E-9
def test_ground_state_energy(self):
hamiltonian_fop = get_fermion_operator(self.molecular_hamiltonian)
sparse_ham = get_number_preserving_sparse_operator(
hamiltonian_fop,
self.molecule.n_qubits,
self.molecule.n_electrons,
spin_preserving=True)
eig_val, _ = scipy.sparse.linalg.eigsh(sparse_ham, k=1, which='SA')
assert numpy.abs(eig_val[0] - self.molecule.fci_energy) < 1E-9
def test_cisd_energy_non_spin_preserving(self):
hamiltonian_fop = get_fermion_operator(self.molecular_hamiltonian)
sparse_ham = get_number_preserving_sparse_operator(
hamiltonian_fop,
self.molecule.n_qubits,
self.molecule.n_electrons,
spin_preserving=False,
excitation_level=2)
eig_val, _ = scipy.sparse.linalg.eigsh(sparse_ham, k=1, which='SA')
assert numpy.abs(eig_val[0] - self.molecule.cisd_energy) < 1E-9
def test_space_size_correct(self):
hamiltonian_fop = get_fermion_operator(self.molecular_hamiltonian)
sparse_ham = get_number_preserving_sparse_operator(
hamiltonian_fop,
self.molecule.n_qubits,
self.molecule.n_electrons,
spin_preserving=True)
space_size = sparse_ham.shape[0]
# Naive Hilbert space size is 2**12, or 4096.
assert space_size == 225
def test_cisd_matches_fci_energy_two_electron_hubbard(self):
hamiltonian_fop = self.hubbard_hamiltonian
sparse_ham_cisd = get_number_preserving_sparse_operator(
hamiltonian_fop, 8, 2, spin_preserving=True, excitation_level=2)
sparse_ham_fci = get_sparse_operator(hamiltonian_fop, n_qubits=8)
eig_val_cisd, _ = scipy.sparse.linalg.eigsh(sparse_ham_cisd,
k=1,
which='SA')
eig_val_fci, _ = scipy.sparse.linalg.eigsh(sparse_ham_fci,
k=1,
which='SA')
assert numpy.abs(eig_val_cisd[0] - eig_val_fci[0]) < 1E-9
def test_hf_energy(self):
hamiltonian_fop = get_fermion_operator(self.molecular_hamiltonian)
sparse_ham = get_number_preserving_sparse_operator(
hamiltonian_fop,
self.molecule.n_qubits,
self.molecule.n_electrons,
spin_preserving=True)
space_size = sparse_ham.shape[0]
reference = numpy.zeros((space_size))
reference[0] = 1.0
sparse_hf_energy = reference.dot(sparse_ham.dot(reference))
assert numpy.linalg.norm(sparse_hf_energy - self.molecule.hf_energy) < 1E-9
