def get_sparse_operator(operator, n_qubits=None, trunc=None, hbar=1.):
r"""Map an operator to a sparse matrix.
If the input is not a QubitOperator, the Jordan-Wigner Transform is used.
Args:
operator: Currently supported operators include:
FermionOperator, QubitOperator, DiagonalCoulombHamiltonian,
PolynomialTensor, BosonOperator, QuadOperator.
n_qubits(int): Number qubits in the system Hilbert space.
Applicable only to fermionic systems.
trunc (int): The size at which the Fock space should be truncated.
Applicable only to bosonic systems.
hbar (float): the value of hbar to use in the definition of the
canonical commutation relation [q_i, p_j] = \delta_{ij} i hbar.
Applicable only to the QuadOperator.
"""
if isinstance(operator, (DiagonalCoulombHamiltonian, PolynomialTensor)):
return jordan_wigner_sparse(get_fermion_operator(operator))
elif isinstance(operator, FermionOperator):
return jordan_wigner_sparse(operator, n_qubits)
elif isinstance(operator, QubitOperator):
return qubit_operator_sparse(operator, n_qubits)
elif isinstance(operator, (BosonOperator, QuadOperator)):
return boson_operator_sparse(operator, trunc, hbar)
else:
raise TypeError('Failed to convert a {} to a sparse matrix.'.format(
type(operator).__name__))
def get_sparse_operator(operator, n_qubits=None):
"""Map an operator to a sparse matrix.
If the input is not a QubitOperator, the Jordan-Wigner Transform is used.
"""
if isinstance(operator, (DiagonalCoulombHamiltonian, PolynomialTensor)):
return jordan_wigner_sparse(get_fermion_operator(operator))
elif isinstance(operator, FermionOperator):
return jordan_wigner_sparse(operator, n_qubits)
elif isinstance(operator, QubitOperator):
return qubit_operator_sparse(operator, n_qubits)
else:
raise TypeError('Failed to convert a {} to a sparse matrix.'.format(
type(operator).__name__))
def get_sparse_operator(operator, n_qubits=None):
"""Map a FermionOperator, QubitOperator, or PolyomialTensor to a
sparse matrix."""
if isinstance(operator, PolynomialTensor):
return polynomial_tensor_sparse(operator)
elif isinstance(operator, FermionOperator):
return jordan_wigner_sparse(operator, n_qubits)
elif isinstance(operator, QubitOperator):
return qubit_operator_sparse(operator, n_qubits)
def get_sparse_operator(operator, n_qubits=None):
"""Map a Fermion, Qubit, or InteractionOperator to a SparseOperator."""
if isinstance(operator, PolynomialTensor):
return get_sparse_polynomial_tensor(operator)
elif isinstance(operator, FermionOperator):
return jordan_wigner_sparse(operator, n_qubits)
elif isinstance(operator, QubitOperator):
if n_qubits is None:
n_qubits = count_qubits(operator)
return qubit_operator_sparse(operator, n_qubits)
def benchmark_jordan_wigner_sparse(n_qubits):
"""Benchmark the speed at which a FermionOperator is mapped to a matrix.
Args:
n_qubits: The number of qubits in the example.
Returns:
runtime: The time in seconds that the benchmark took.
"""
# Initialize a random FermionOperator.
molecular_operator = random_interaction_operator(n_qubits)
fermion_operator = get_fermion_operator(molecular_operator)
# Map to SparseOperator class.
start_time = time.time()
sparse_operator = jordan_wigner_sparse(fermion_operator)
runtime = time.time() - start_time
return runtime
def get_sparse_polynomial_tensor(polynomial_tensor):
fermion_operator = get_fermion_operator(polynomial_tensor)
sparse_operator = jordan_wigner_sparse(fermion_operator)
return sparse_operator
def get_sparse_interaction_operator(interaction_operator):
fermion_operator = get_fermion_operator(interaction_operator)
sparse_operator = jordan_wigner_sparse(fermion_operator)
return sparse_operator
def test_ucc_h2_singlet(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)
# Test UCCSD for accuracy against FCI using loaded t amplitudes.
ucc_operator = uccsd_generator(self.molecule.ccsd_single_amps,
self.molecule.ccsd_double_amps)
hf_state = jw_hartree_fock_state(self.molecule.n_electrons,
count_qubits(self.qubit_hamiltonian))
uccsd_sparse = jordan_wigner_sparse(ucc_operator)
uccsd_state = scipy.sparse.linalg.expm_multiply(uccsd_sparse, hf_state)
expected_uccsd_energy = expectation(self.hamiltonian_matrix,
uccsd_state)
self.assertAlmostEqual(expected_uccsd_energy,
self.molecule.fci_energy,
places=4)
print("UCCSD ENERGY: {}".format(expected_uccsd_energy))
# Test CCSD singlet for precise match against FCI using loaded t
# amplitudes
packed_amplitudes = uccsd_singlet_get_packed_amplitudes(
self.molecule.ccsd_single_amps, self.molecule.ccsd_double_amps,
self.molecule.n_qubits, self.molecule.n_electrons)
ccsd_operator = uccsd_singlet_generator(packed_amplitudes,
self.molecule.n_qubits,
self.molecule.n_electrons,
anti_hermitian=False)
ccsd_sparse_r = jordan_wigner_sparse(ccsd_operator)
ccsd_sparse_l = jordan_wigner_sparse(
-hermitian_conjugated(ccsd_operator))
ccsd_state_r = scipy.sparse.linalg.expm_multiply(
ccsd_sparse_r, hf_state)
ccsd_state_l = scipy.sparse.linalg.expm_multiply(
ccsd_sparse_l, hf_state)
expected_ccsd_energy = ccsd_state_l.conjugate().dot(
self.hamiltonian_matrix.dot(ccsd_state_r))
self.assertAlmostEqual(expected_ccsd_energy, self.molecule.fci_energy)
