def test_random_quadratic(self):
n_qubits = 5
quad_ham = random_quadratic_hamiltonian(n_qubits, True)
ferm_op = get_fermion_operator(quad_ham)
self.assertTrue(
normal_ordered(ferm_op) == normal_ordered(
get_fermion_operator(get_diagonal_coulomb_hamiltonian(
ferm_op))))
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_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 setUp(self):
geometry = [('H', (0., 0., 0.)), ('H', (0., 0., 0.7414))]
basis = 'sto-3g'
multiplicity = 1
filename = os.path.join(THIS_DIRECTORY, 'data',
'H2_sto-3g_singlet_0.7414')
self.molecule = MolecularData(geometry,
basis,
multiplicity,
filename=filename)
self.molecule.load()
# Get molecular Hamiltonian.
self.molecular_hamiltonian = self.molecule.get_molecular_hamiltonian()
# Get FCI RDM.
self.fci_rdm = self.molecule.get_molecular_rdm(use_fci=1)
# Get explicit coefficients.
self.nuclear_repulsion = self.molecular_hamiltonian.constant
self.one_body = self.molecular_hamiltonian.one_body_tensor
self.two_body = self.molecular_hamiltonian.two_body_tensor
# Get fermion Hamiltonian.
self.fermion_hamiltonian = normal_ordered(
get_fermion_operator(self.molecular_hamiltonian))
# Get qubit Hamiltonian.
self.qubit_hamiltonian = jordan_wigner(self.fermion_hamiltonian)
# Get the sparse matrix.
self.hamiltonian_matrix = get_sparse_operator(
self.molecular_hamiltonian)
def test_get_molecular_operator(self):
coefficient = 3.
operators = ((2, 1), (3, 0), (0, 0), (3, 1))
op = FermionOperator(operators, coefficient)
molecular_operator = get_interaction_operator(op)
fermion_operator = get_fermion_operator(molecular_operator)
fermion_operator = normal_ordered(fermion_operator)
self.assertTrue(normal_ordered(op) == fermion_operator)
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_get_fermion_operator_majorana_operator():
a = MajoranaOperator((0, 3), 2.0) + MajoranaOperator((1, 2, 3))
op = get_fermion_operator(a)
expected_op = (-2j * (FermionOperator(((0, 0), (1, 0))) - FermionOperator(
((0, 0), (1, 1))) + FermionOperator(
((0, 1), (1, 0))) - FermionOperator(
((0, 1), (1, 1)))) - 2 * FermionOperator(
((0, 0), (1, 1), (1, 0))) + 2 * FermionOperator(
((0, 1), (1, 1), (1, 0))) + FermionOperator(
(0, 0)) - FermionOperator((0, 1)))
assert normal_ordered(op) == normal_ordered(expected_op)
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_get_quadratic_hamiltonian_hermitian(self):
"""Test properly formed quadratic Hamiltonians."""
# Non-particle-number-conserving without chemical potential
quadratic_op = get_quadratic_hamiltonian(self.hermitian_op)
fermion_operator = get_fermion_operator(quadratic_op)
fermion_operator = normal_ordered(fermion_operator)
self.assertTrue(normal_ordered(self.hermitian_op) == fermion_operator)
# Non-particle-number-conserving chemical potential
quadratic_op = get_quadratic_hamiltonian(self.hermitian_op,
chemical_potential=3.)
fermion_operator = get_fermion_operator(quadratic_op)
fermion_operator = normal_ordered(fermion_operator)
self.assertTrue(normal_ordered(self.hermitian_op) == fermion_operator)
# Particle-number-conserving
quadratic_op = get_quadratic_hamiltonian(self.hermitian_op_pc)
fermion_operator = get_fermion_operator(quadratic_op)
fermion_operator = normal_ordered(fermion_operator)
self.assertTrue(
normal_ordered(self.hermitian_op_pc) == fermion_operator)
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_diagonal_coulomb_hamiltonian(self):
n_qubits = 5
one_body = random_hermitian_matrix(n_qubits, real=False)
two_body = random_hermitian_matrix(n_qubits, real=True)
constant = numpy.random.randn()
op = DiagonalCoulombHamiltonian(one_body, two_body, constant)
op1 = get_sparse_operator(op)
op2 = get_sparse_operator(jordan_wigner(get_fermion_operator(op)))
diff = op1 - op2
discrepancy = 0.
if diff.nnz:
discrepancy = max(abs(diff.data))
self.assertAlmostEqual(discrepancy, 0.)
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
def test_hubbard(self):
x_dim = 4
y_dim = 5
tunneling = 2.
coulomb = 3.
chemical_potential = 7.
magnetic_field = 11.
periodic = False
hubbard_model = fermi_hubbard(x_dim, y_dim, tunneling, coulomb,
chemical_potential, magnetic_field,
periodic)
self.assertTrue(
normal_ordered(hubbard_model) == normal_ordered(
get_fermion_operator(
get_diagonal_coulomb_hamiltonian(hubbard_model))))
def test_get_fermion_operator_wrong_type():
with pytest.raises(TypeError):
_ = get_fermion_operator(QubitOperator())