def test_hermiticity(self):
n_orbitals = 5
# Real, no spin
iop = random_interaction_operator(n_orbitals, real=True)
ferm_op = get_fermion_operator(iop)
self.assertTrue(is_hermitian(ferm_op))
# Real, spin
iop = random_interaction_operator(n_orbitals,
expand_spin=True,
real=True)
ferm_op = get_fermion_operator(iop)
self.assertTrue(is_hermitian(ferm_op))
# Complex, no spin
iop = random_interaction_operator(n_orbitals, real=False)
ferm_op = get_fermion_operator(iop)
self.assertTrue(is_hermitian(ferm_op))
# Complex, spin
iop = random_interaction_operator(n_orbitals,
expand_spin=True,
real=False)
ferm_op = get_fermion_operator(iop)
self.assertTrue(is_hermitian(ferm_op))
def test_random_operators_are_reproducible(self):
op1 = random_diagonal_coulomb_hamiltonian(5, seed=5947)
op2 = random_diagonal_coulomb_hamiltonian(5, seed=5947)
numpy.testing.assert_allclose(op1.one_body, op2.one_body)
numpy.testing.assert_allclose(op1.two_body, op2.two_body)
op1 = random_interaction_operator(5, seed=8911)
op2 = random_interaction_operator(5, seed=8911)
numpy.testing.assert_allclose(op1.one_body_tensor, op2.one_body_tensor)
numpy.testing.assert_allclose(op1.two_body_tensor, op2.two_body_tensor)
op1 = random_quadratic_hamiltonian(5, seed=17711)
op2 = random_quadratic_hamiltonian(5, seed=17711)
numpy.testing.assert_allclose(op1.combined_hermitian_part,
op2.combined_hermitian_part)
numpy.testing.assert_allclose(op1.antisymmetric_part,
op2.antisymmetric_part)
op1 = random_antisymmetric_matrix(5, seed=24074)
op2 = random_antisymmetric_matrix(5, seed=24074)
numpy.testing.assert_allclose(op1, op2)
op1 = random_hermitian_matrix(5, seed=56753)
op2 = random_hermitian_matrix(5, seed=56753)
numpy.testing.assert_allclose(op1, op2)
op1 = random_unitary_matrix(5, seed=56486)
op2 = random_unitary_matrix(5, seed=56486)
numpy.testing.assert_allclose(op1, op2)
def test_hermiticity(self):
n_qubits = 5
# Real case
iop = random_interaction_operator(n_qubits, True)
ferm_op = get_fermion_operator(iop)
self.assertTrue(is_hermitian(ferm_op))
# Complex case
iop = random_interaction_operator(n_qubits, False)
ferm_op = get_fermion_operator(iop)
self.assertTrue(is_hermitian(ferm_op))
def test_symmetry(self):
n_orbitals = 5
# Real.
iop = random_interaction_operator(n_orbitals,
expand_spin=False,
real=True)
ferm_op = get_fermion_operator(iop)
self.assertTrue(is_hermitian(ferm_op))
two_body_coefficients = iop.two_body_tensor
for p, q, r, s in itertools.product(range(n_orbitals), repeat=4):
self.assertAlmostEqual(two_body_coefficients[p, q, r, s],
two_body_coefficients[r, q, p, s])
self.assertAlmostEqual(two_body_coefficients[p, q, r, s],
two_body_coefficients[p, s, r, q])
self.assertAlmostEqual(two_body_coefficients[p, q, r, s],
two_body_coefficients[s, r, q, p])
self.assertAlmostEqual(two_body_coefficients[p, q, r, s],
two_body_coefficients[q, p, s, r])
self.assertAlmostEqual(two_body_coefficients[p, q, r, s],
two_body_coefficients[r, s, p, q])
self.assertAlmostEqual(two_body_coefficients[p, q, r, s],
two_body_coefficients[s, p, q, r])
self.assertAlmostEqual(two_body_coefficients[p, q, r, s],
two_body_coefficients[q, r, s, p])
def test_consistency(self):
"""Test consistency with JW for FermionOperators."""
# Random interaction operator
n_qubits = 5
iop = random_interaction_operator(n_qubits, real=False)
op1 = jordan_wigner(iop)
op2 = jordan_wigner(get_fermion_operator(iop))
self.assertEqual(op1, op2)
# Interaction operator from molecule
geometry = [('Li', (0., 0., 0.)), ('H', (0., 0., 1.45))]
basis = 'sto-3g'
multiplicity = 1
filename = os.path.join(DATA_DIRECTORY, 'H1-Li1_sto-3g_singlet_1.45')
molecule = MolecularData(geometry,
basis,
multiplicity,
filename=filename)
molecule.load()
iop = molecule.get_molecular_hamiltonian()
op1 = jordan_wigner(iop)
op2 = jordan_wigner(get_fermion_operator(iop))
self.assertEqual(op1, op2)
def random_interaction_operator_term(
order: int,
real: bool = True,
seed: Optional[int] = None,
) -> openfermion.InteractionOperator:
"""Generates a random interaction operator with non-zero coefficients only
on terms corresponding to the given number of unique orbitals.
The number of orbitals is equal to the given order.
Args:
order: How many unique orbitals the non-zero terms should correspond to.
real: Whether or not the coefficients should be real. Defaults to True.
seed: The seed. If None (default), uses np.random.
"""
n_orbitals = order
if order > 4:
return openfermion.InteractionOperator.zero(order)
operator = random_interaction_operator(n_orbitals, real=real, seed=seed)
operator.constant = 0
for indices in itertools.product(range(n_orbitals), repeat=2):
if len(set(indices)) != order:
operator.one_body_tensor[indices] = 0
for indices in itertools.product(range(n_orbitals), repeat=4):
if len(set(indices)) != order:
operator.two_body_tensor[indices] = 0
return operator
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 benchmark_molecular_operator_jordan_wigner(n_qubits):
"""Test speed with which molecular operators transform to qubit operators.
Args:
n_qubits: The size of the molecular operator instance. Ideally, we
would be able to transform to a qubit operator for 50 qubit
instances in less than a minute. We are way too slow right now.
Returns:
runtime: The number of seconds required to make the conversion.
"""
# Get an instance of InteractionOperator.
molecular_operator = random_interaction_operator(n_qubits)
# Convert to a qubit operator.
start = time.time()
qubit_operator = jordan_wigner(molecular_operator)
end = time.time()
# Return runtime.
runtime = end - start
return runtime
def test_simulate_trotter_omit_final_swaps():
n_qubits = 5
qubits = cirq.LineQubit.range(n_qubits)
hamiltonian = openfermion.DiagonalCoulombHamiltonian(one_body=numpy.ones(
(n_qubits, n_qubits)),
two_body=numpy.ones(
(n_qubits,
n_qubits)))
time = 1.0
circuit_with_swaps = cirq.Circuit.from_ops(
simulate_trotter(qubits,
hamiltonian,
time,
order=0,
algorithm=LINEAR_SWAP_NETWORK))
circuit_without_swaps = cirq.Circuit.from_ops(
simulate_trotter(qubits,
hamiltonian,
time,
order=0,
algorithm=LINEAR_SWAP_NETWORK,
omit_final_swaps=True))
assert (circuit_with_swaps.to_text_diagram(transpose=True).strip() == (
circuit_without_swaps.to_text_diagram(transpose=True).strip() + """
│ ×ᶠ─────────×ᶠ ×ᶠ─────────×ᶠ
│ │ │ │ │
×ᶠ───────×ᶠ ×ᶠ─────────×ᶠ │
│ │ │ │ │
│ ×ᶠ─────────×ᶠ ×ᶠ─────────×ᶠ
│ │ │ │ │
×ᶠ───────×ᶠ ×ᶠ─────────×ᶠ │
│ │ │ │ │
│ ×ᶠ─────────×ᶠ ×ᶠ─────────×ᶠ
│ │ │ │ │
""").strip())
circuit_with_swaps = cirq.Circuit.from_ops(
simulate_trotter(qubits,
hamiltonian,
time,
order=1,
n_steps=3,
algorithm=SPLIT_OPERATOR),
strategy=cirq.InsertStrategy.NEW)
circuit_without_swaps = cirq.Circuit.from_ops(
simulate_trotter(qubits,
hamiltonian,
time,
order=1,
n_steps=3,
algorithm=SPLIT_OPERATOR,
omit_final_swaps=True),
strategy=cirq.InsertStrategy.NEW)
assert (circuit_with_swaps.to_text_diagram(transpose=True).strip() == (
circuit_without_swaps.to_text_diagram(transpose=True).strip() + """
│ │ │ ×────────────×
│ │ │ │ │
│ ×───────────× │ │
│ │ │ │ │
│ │ ×───────────× │
│ │ │ │ │
×─────────× │ │ │
│ │ │ │ │
│ │ │ ×────────────×
│ │ │ │ │
│ ×───────────× │ │
│ │ │ │ │
│ │ ×───────────× │
│ │ │ │ │
×─────────× │ │ │
│ │ │ │ │
│ │ │ ×────────────×
│ │ │ │ │
│ ×───────────× │ │
│ │ │ │ │
""").strip())
hamiltonian = random_interaction_operator(n_qubits, seed=0)
circuit_with_swaps = cirq.Circuit.from_ops(
simulate_trotter(qubits,
hamiltonian,
time,
order=0,
algorithm=LOW_RANK))
circuit_without_swaps = cirq.Circuit.from_ops(
simulate_trotter(qubits,
hamiltonian,
time,
order=0,
algorithm=LOW_RANK,
omit_final_swaps=True))
assert len(circuit_without_swaps) < len(circuit_with_swaps)
