def bravyi_kitaev(operator, n_qubits=None):
"""Apply the Bravyi-Kitaev transform and return qubit operator.
Args:
operator (fermilib.ops.FermionOperator):
A FermionOperator to transform.
n_qubits (int|None):
Can force the number of qubits in the resulting operator above the
number that appear in the input operator.
Returns:
transformed_operator: An instance of the QubitOperator class.
Raises:
ValueError: Invalid number of qubits specified.
"""
# Compute the number of qubits.
from fermilib.utils import count_qubits
if n_qubits is None:
n_qubits = count_qubits(operator)
if n_qubits < count_qubits(operator):
raise ValueError('Invalid number of qubits specified.')
# Build the Fenwick tree.
fenwick_tree = FenwickTree(n_qubits)
# Compute transformed operator.
transformed_terms = (
_transform_operator_term(term=term,
coefficient=operator.terms[term],
fenwick_tree=fenwick_tree)
for term in operator.terms
)
return inline_sum(seed=QubitOperator(), summands=transformed_terms)
def test_n_qubits(self):
self.assertEqual(self.n_qubits,
count_qubits(self.fermion_term))
self.assertEqual(self.n_qubits,
count_qubits(self.fermion_operator))
self.assertEqual(self.n_qubits,
count_qubits(self.qubit_operator))
self.assertEqual(self.n_qubits,
count_qubits(self.interaction_operator))
def jordan_wigner_interaction_op(iop, n_qubits=None):
"""Output InteractionOperator as QubitOperator class under JW transform.
One could accomplish this very easily by first mapping to fermions and
then mapping to qubits. We skip the middle step for the sake of speed.
Returns:
qubit_operator: An instance of the QubitOperator class.
"""
from fermilib.utils import count_qubits
if n_qubits is None:
n_qubits = count_qubits(iop)
if n_qubits < count_qubits(iop):
n_qubits = count_qubits(iop)
# Initialize qubit operator as constant.
qubit_operator = QubitOperator((), iop.constant)
# Loop through all indices.
for p in range(n_qubits):
for q in range(n_qubits):
# Handle one-body terms.
coefficient = complex(iop[p, q])
if coefficient and p >= q:
qubit_operator += coefficient * jordan_wigner_one_body(p, q)
# Keep looping for the two-body terms.
for r in range(n_qubits):
for s in range(n_qubits):
coefficient = complex(iop[p, q, r, s])
# Skip zero terms.
if (not coefficient) or (p == q) or (r == s):
continue
# Identify and skip one of the complex conjugates.
if [p, q, r, s] != [s, r, q, p]:
if len(set([p, q, r, s])) == 4:
if min(r, s) < min(p, q):
continue
elif p != r and q < p:
continue
# Handle the two-body terms.
transformed_term = jordan_wigner_two_body(p, q, r, s)
transformed_term *= coefficient
qubit_operator += transformed_term
return qubit_operator
def get_interaction_rdm(qubit_operator, n_qubits=None):
"""Build an InteractionRDM from measured qubit operators.
Returns: An InteractionRDM object.
"""
# Avoid circular import.
from fermilib.transforms import jordan_wigner
if n_qubits is None:
n_qubits = count_qubits(qubit_operator)
one_rdm = numpy.zeros((n_qubits, ) * 2, dtype=complex)
two_rdm = numpy.zeros((n_qubits, ) * 4, dtype=complex)
# One-RDM.
for i, j in itertools.product(range(n_qubits), repeat=2):
transformed_operator = jordan_wigner(FermionOperator(((i, 1), (j, 0))))
for term, coefficient in iteritems(transformed_operator.terms):
if term in qubit_operator.terms:
one_rdm[i, j] += coefficient * qubit_operator.terms[term]
# Two-RDM.
for i, j, k, l in itertools.product(range(n_qubits), repeat=4):
transformed_operator = jordan_wigner(
FermionOperator(((i, 1), (j, 1), (k, 0), (l, 0))))
for term, coefficient in iteritems(transformed_operator.terms):
if term in qubit_operator.terms:
two_rdm[i, j, k, l] += coefficient * qubit_operator.terms[term]
return InteractionRDM(one_rdm, two_rdm)
def test_jordan_wigner_dual_basis_jellium(self):
# Parameters.
grid = Grid(dimensions=2, length=3, scale=1.)
spinless = True
# Compute fermionic Hamiltonian. Include then subtract constant.
fermion_hamiltonian = dual_basis_jellium_model(grid,
spinless,
include_constant=True)
qubit_hamiltonian = jordan_wigner(fermion_hamiltonian)
qubit_hamiltonian -= QubitOperator((), 2.8372)
# Compute Jordan-Wigner Hamiltonian.
test_hamiltonian = jordan_wigner_dual_basis_jellium(grid, spinless)
# Make sure Hamiltonians are the same.
self.assertTrue(test_hamiltonian.isclose(qubit_hamiltonian))
# Check number of terms.
n_qubits = count_qubits(qubit_hamiltonian)
if spinless:
paper_n_terms = 1 - .5 * n_qubits + 1.5 * (n_qubits**2)
num_nonzeros = sum(1 for coeff in qubit_hamiltonian.terms.values()
if coeff != 0.0)
self.assertTrue(num_nonzeros <= paper_n_terms)
def test_jordan_wigner_position_jellium(self):
# Parameters.
n_dimensions = 2
grid_length = 3
length_scale = 1.
spinless = 1
# Compute fermionic Hamiltonian.
fermion_hamiltonian = jellium_model(
n_dimensions, grid_length, length_scale, spinless, 0)
qubit_hamiltonian = jordan_wigner(fermion_hamiltonian)
# Compute Jordan-Wigner Hamiltonian.
test_hamiltonian = jordan_wigner_position_jellium(
n_dimensions, grid_length, length_scale, spinless)
# Make sure Hamiltonians are the same.
self.assertTrue(test_hamiltonian.isclose(qubit_hamiltonian))
# Check number of terms.
n_qubits = count_qubits(qubit_hamiltonian)
if spinless:
paper_n_terms = 1 - .5 * n_qubits + 1.5 * (n_qubits ** 2)
else:
paper_n_terms = 1 - .5 * n_qubits + n_qubits ** 2
num_nonzeros = sum(1 for coeff in qubit_hamiltonian.terms.values() if
coeff != 0.0)
self.assertTrue(num_nonzeros <= paper_n_terms)
def get_sparse_operator(operator, n_qubits=None):
"""Map a Fermion, Qubit, or InteractionOperator to a SparseOperator."""
if isinstance(operator, InteractionOperator):
return get_sparse_interaction_operator(operator)
elif isinstance(operator, FermionOperator):
return jordan_wigner_sparse(operator)
elif isinstance(operator, QubitOperator):
if n_qubits is None:
n_qubits = count_qubits(operator)
return qubit_operator_sparse(operator, n_qubits)
def jordan_wigner_sparse(fermion_operator, n_qubits=None):
"""Initialize a SparseOperator from a FermionOperator.
Args:
fermion_operator(FermionOperator): instance of the FermionOperator
class.
n_qubits(int): Number of qubits.
Returns:
The corresponding SparseOperator.
"""
if n_qubits is None:
from fermilib.utils import count_qubits
n_qubits = count_qubits(fermion_operator)
# Create a list of raising and lowering operators for each orbital.
jw_operators = []
for tensor_factor in range(n_qubits):
jw_operators += [(jordan_wigner_ladder_sparse(n_qubits, tensor_factor,
0),
jordan_wigner_ladder_sparse(n_qubits, tensor_factor,
1))]
# Construct the SparseOperator.
n_hilbert = 2**n_qubits
values_list = [[]]
row_list = [[]]
column_list = [[]]
for term in fermion_operator.terms:
coefficient = fermion_operator.terms[term]
sparse_matrix = coefficient * scipy.sparse.identity(
2**n_qubits, dtype=complex, format='csc')
for ladder_operator in term:
sparse_matrix = sparse_matrix * jw_operators[ladder_operator[0]][
ladder_operator[1]]
if coefficient:
# Extract triplets from sparse_term.
sparse_matrix = sparse_matrix.tocoo(copy=False)
values_list.append(sparse_matrix.data)
(row, column) = sparse_matrix.nonzero()
row_list.append(row)
column_list.append(column)
values_list = numpy.concatenate(values_list)
row_list = numpy.concatenate(row_list)
column_list = numpy.concatenate(column_list)
sparse_operator = scipy.sparse.coo_matrix(
(values_list, (row_list, column_list)),
shape=(n_hilbert, n_hilbert)).tocsc(copy=False)
sparse_operator.eliminate_zeros()
return sparse_operator
def get_fermion_operator(interaction_operator):
"""Output InteractionOperator as instance of FermionOperator class.
Returns:
fermion_operator: An instance of the FermionOperator class.
"""
# Initialize with identity term.
fermion_operator = FermionOperator((), interaction_operator.constant)
n_qubits = count_qubits(interaction_operator)
# Add one-body terms.
for p, q in itertools.product(range(n_qubits), repeat=2):
fermion_operator += FermionOperator(
((p, 1), (q, 0)), coefficient=interaction_operator[p, q])
# Add two-body terms.
for p, q, r, s in itertools.product(range(n_qubits), repeat=4):
coefficient = interaction_operator[p, q, r, s]
fermion_operator += FermionOperator(((p, 1), (q, 1), (r, 0), (s, 0)),
coefficient)
return fermion_operator
def reverse_jordan_wigner(qubit_operator, n_qubits=None):
"""Transforms a QubitOperator into a FermionOperator using the
Jordan-Wigner transform.
Operators are mapped as follows:
Z_j -> I - 2 a^\dagger_j a_j
X_j -> (a^\dagger_j + a_j) Z_{j-1} Z_{j-2} .. Z_0
Y_j -> i (a^\dagger_j - a_j) Z_{j-1} Z_{j-2} .. Z_0
Args:
qubit_operator: the QubitOperator to be transformed.
n_qubits: the number of qubits term acts on. If not set, defaults
to the maximum qubit number acted on by term.
Returns:
transformed_term: An instance of the FermionOperator class.
Raises:
TypeError: Input must be a QubitOperator.
TypeError: Invalid number of qubits specified.
TypeError: Pauli operators must be X, Y or Z.
"""
if not isinstance(qubit_operator, QubitOperator):
raise TypeError('Input must be a QubitOperator.')
if n_qubits is None:
n_qubits = count_qubits(qubit_operator)
if n_qubits < count_qubits(qubit_operator):
raise TypeError('Invalid number of qubits specified')
# Loop through terms.
transformed_operator = FermionOperator()
for term in qubit_operator.terms:
transformed_term = FermionOperator(())
if term:
working_term = QubitOperator(term)
pauli_operator = term[-1]
while pauli_operator is not None:
# Handle Pauli Z.
if pauli_operator[1] == 'Z':
transformed_pauli = FermionOperator(
()) + number_operator(n_qubits, pauli_operator[0], -2.)
# Handle Pauli X and Y.
else:
raising_term = FermionOperator(((pauli_operator[0], 1), ))
lowering_term = FermionOperator(((pauli_operator[0], 0), ))
if pauli_operator[1] == 'Y':
raising_term *= 1.j
lowering_term *= -1.j
elif pauli_operator[1] != 'X':
raise TypeError('Pauli operators must be X, Y, or Z')
transformed_pauli = raising_term + lowering_term
# Account for the phase terms.
for j in reversed(range(pauli_operator[0])):
z_term = QubitOperator(((j, 'Z'), ))
working_term = z_term * working_term
term_key = list(working_term.terms)[0]
transformed_pauli *= working_term.terms[term_key]
working_term.terms[list(working_term.terms)[0]] = 1.
# Get next non-identity operator acting below 'working_qubit'.
assert len(working_term.terms) == 1
working_qubit = pauli_operator[0] - 1
for working_operator in reversed(list(working_term.terms)[0]):
if working_operator[0] <= working_qubit:
pauli_operator = working_operator
break
else:
pauli_operator = None
# Multiply term by transformed operator.
transformed_term *= transformed_pauli
# Account for overall coefficient
transformed_term *= qubit_operator.terms[term]
transformed_operator += transformed_term
return transformed_operator
def qubit_operator_sparse(qubit_operator, n_qubits):
"""Initialize a SparseOperator from a QubitOperator.
Args:
qubit_operator(QubitOperator): instance of the QubitOperator class.
n_qubits (int): Number of qubits.
Returns:
The corresponding SparseOperator.
"""
if n_qubits is None:
from fermilib.utils import count_qubits
n_qubits = count_qubits(fermion_operator)
# Construct the SparseOperator.
n_hilbert = 2**n_qubits
values_list = [[]]
row_list = [[]]
column_list = [[]]
# Loop through the terms.
for qubit_term in qubit_operator.terms:
tensor_factor = 0
coefficient = qubit_operator.terms[qubit_term]
sparse_operators = [coefficient]
for pauli_operator in qubit_term:
# Grow space for missing identity operators.
if pauli_operator[0] > tensor_factor:
identity_qubits = pauli_operator[0] - tensor_factor
identity = scipy.sparse.identity(2**identity_qubits,
dtype=complex,
format='csc')
sparse_operators += [identity]
# Add actual operator to the list.
sparse_operators += [pauli_matrix_map[pauli_operator[1]]]
tensor_factor = pauli_operator[0] + 1
# Grow space at end of string unless operator acted on final qubit.
if tensor_factor < n_qubits or not qubit_term:
identity_qubits = n_qubits - tensor_factor
identity = scipy.sparse.identity(2**identity_qubits,
dtype=complex,
format='csc')
sparse_operators += [identity]
# Extract triplets from sparse_term.
sparse_matrix = kronecker_operators(sparse_operators)
values_list.append(sparse_matrix.tocoo(copy=False).data)
(column, row) = sparse_matrix.nonzero()
column_list.append(column)
row_list.append(row)
# Create sparse operator.
values_list = numpy.concatenate(values_list)
row_list = numpy.concatenate(row_list)
column_list = numpy.concatenate(column_list)
sparse_operator = scipy.sparse.coo_matrix(
(values_list, (row_list, column_list)),
shape=(n_hilbert, n_hilbert)).tocsc(copy=False)
sparse_operator.eliminate_zeros()
return sparse_operator
def bravyi_kitaev(operator, n_qubits=None):
"""Apply the Bravyi-Kitaev transform and return qubit operator.
Args:
operator: A FermionOperator to transform.
Returns:
transformed_operator: An instance of the QubitOperator class.
Raises:
ValueError: Invalid number of qubits specified.
"""
# Compute the number of qubits.
from fermilib.utils import count_qubits
if n_qubits is None:
n_qubits = count_qubits(operator)
if n_qubits < count_qubits(operator):
raise ValueError('Invalid number of qubits specified.')
# Compute transformed operator.
transformed_operator = QubitOperator()
for term in operator.terms:
# Initialize identity matrix.
coefficient = operator.terms[term]
transformed_term = QubitOperator((), coefficient)
# Build the Fenwick Tree
fenwick_tree = FenwickTree(n_qubits)
# Build the Bravyi-Kitaev transformed operators.
for ladder_operator in term:
index = ladder_operator[0]
# Parity set. Set of nodes to apply Z to.
parity_set = [
node.index for node in fenwick_tree.get_parity_set(index)
]
# Update set. Set of ancestors to apply X to.
ancestors = [
node.index for node in fenwick_tree.get_update_set(index)
]
# The C(j) set.
ancestor_children = [
node.index for node in fenwick_tree.get_remainder_set(index)
]
# Switch between lowering/raising operators.
d_coefficient = .5j
if ladder_operator[1]:
d_coefficient *= -1.
# The fermion lowering operator is given by
# a = (c+id)/2 where c, d are the majoranas.
d_majorana_component = QubitOperator(
(((ladder_operator[0], 'Y'), ) + tuple(
(index, 'Z') for index in ancestor_children) + tuple(
(index, 'X') for index in ancestors)), d_coefficient)
c_majorana_component = QubitOperator(
(((ladder_operator[0], 'X'), ) + tuple(
(index, 'Z') for index in parity_set) + tuple(
(index, 'X') for index in ancestors)), 0.5)
# Update term.
transformed_term *= c_majorana_component + d_majorana_component
transformed_operator += transformed_term
return transformed_operator
def test_n_qubits_fermion_operator(self):
self.assertEqual(self.n_qubits, count_qubits(self.fermion_operator))
def get_interaction_operator(fermion_operator, n_qubits=None):
"""Convert a 2-body fermionic operator to InteractionOperator.
This function should only be called on fermionic operators which
consist of only a_p^\dagger a_q and a_p^\dagger a_q^\dagger a_r a_s
terms. The one-body terms are stored in a matrix, one_body[p, q], and
the two-body terms are stored in a tensor, two_body[p, q, r, s].
Returns:
interaction_operator: An instance of the InteractionOperator class.
Raises:
TypeError: Input must be a FermionOperator.
TypeError: FermionOperator does not map to InteractionOperator.
Warning:
Even assuming that each creation or annihilation operator appears
at most a constant number of times in the original operator, the
runtime of this method is exponential in the number of qubits.
"""
if not isinstance(fermion_operator, FermionOperator):
raise TypeError('Input must be a FermionOperator.')
if n_qubits is None:
n_qubits = count_qubits(fermion_operator)
if n_qubits < count_qubits(fermion_operator):
n_qubits = count_qubits(fermion_operator)
# Normal order the terms and initialize.
fermion_operator = normal_ordered(fermion_operator)
constant = 0.
one_body = numpy.zeros((n_qubits, n_qubits), complex)
two_body = numpy.zeros((n_qubits, n_qubits, n_qubits, n_qubits), complex)
# Loop through terms and assign to matrix.
for term in fermion_operator.terms:
coefficient = fermion_operator.terms[term]
# Handle constant shift.
if len(term) == 0:
constant = coefficient
elif len(term) == 2:
# Handle one-body terms.
if [operator[1] for operator in term] == [1, 0]:
p, q = [operator[0] for operator in term]
one_body[p, q] = coefficient
else:
raise InteractionOperatorError('FermionOperator does not map '
'to InteractionOperator.')
elif len(term) == 4:
# Handle two-body terms.
if [operator[1] for operator in term] == [1, 1, 0, 0]:
p, q, r, s = [operator[0] for operator in term]
two_body[p, q, r, s] = coefficient
else:
raise InteractionOperatorError('FermionOperator does not map '
'to InteractionOperator.')
else:
# Handle non-molecular Hamiltonian.
raise InteractionOperatorError('FermionOperator does not map '
'to InteractionOperator.')
# Form InteractionOperator and return.
interaction_operator = InteractionOperator(constant, one_body, two_body)
return interaction_operator
def test_n_qubits_single_fermion_term(self):
self.assertEqual(self.n_qubits, count_qubits(self.fermion_term))
def test_n_qubits_qubit_operator(self):
self.assertEqual(self.n_qubits, count_qubits(self.qubit_operator))
def test_n_qubits_bad_type(self):
with self.assertRaises(TypeError):
count_qubits('twelve')
def test_n_qubits_interaction_operator(self):
self.assertEqual(self.n_qubits,
count_qubits(self.interaction_operator))
