Cleanup a few methods that aggregate FermionOperators (#40)

* Add annihilate_create factory method to FermionOperator

* Drop annihilate_create

Author: Strilanc

src/fermilib/ops/_fermion_operator_test.py

@@ -427,7 +427,7 @@ def test_add(self):
     def test_add_bad_addend(self):
         op = FermionOperator((), 1.0)
         with self.assertRaises(TypeError):
-            op = op + "0.5"
+            _ = op + "0.5"
 
     def test_sub(self):
         term_a = ((1, 1), (3, 1), (8, 1))
@@ -446,7 +446,7 @@ def test_sub(self):
     def test_sub_bad_subtrahend(self):
         op = FermionOperator((), 1.0)
         with self.assertRaises(TypeError):
-            op = op - "0.5"
+            _ = op - "0.5"
 
     def test_isub_different_term(self):
         term_a = ((1, 1), (3, 1), (8, 0))
@@ -468,7 +468,7 @@ def test_isub_bad_addend(self):
 
     def test_neg(self):
         op = FermionOperator(((1, 1), (3, 1), (8, 1)), 0.5)
-        -op
+        _ = -op
         # out of place
         self.assertTrue(op.isclose(FermionOperator(((1, 1), (3, 1), (8, 1)),
                                                    0.5)))

src/fermilib/transforms/_conversion.py

@@ -12,24 +12,22 @@
 
 """Transformations acting on operators and RDMs."""
 from __future__ import absolute_import
-from future.utils import iteritems
 
-import copy
 import itertools
+
 import numpy
+from future.utils import iteritems
+from projectq.ops import QubitOperator
 
 from fermilib.ops import (FermionOperator,
                           normal_ordered,
-                          number_operator,
                           InteractionOperator,
                           InteractionRDM)
 from fermilib.ops._interaction_operator import InteractionOperatorError
 from fermilib.utils import (count_qubits,
                             jordan_wigner_sparse,
                             qubit_operator_sparse)
 
-from projectq.ops import QubitOperator
-
 
 def get_sparse_operator(operator, n_qubits=None):
     """Map a Fermion, Qubit, or InteractionOperator to a SparseOperator."""
@@ -161,17 +159,15 @@ def get_fermion_operator(interaction_operator):
     n_qubits = count_qubits(interaction_operator)
 
     # Add one-body terms.
-    for p in range(n_qubits):
-        for q in range(n_qubits):
-            coefficient = interaction_operator[p, q]
-            fermion_operator += FermionOperator(((p, 1), (q, 0)), coefficient)
-
-            # Add two-body terms.
-            for r in range(n_qubits):
-                for s in range(n_qubits):
-                    coefficient = interaction_operator[p, q, r, s]
-                    fermion_operator += FermionOperator(((p, 1), (q, 1),
-                                                         (r, 0), (s, 0)),
-                                                        coefficient)
+    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

src/fermilib/utils/_unitary_cc.py

@@ -60,11 +60,11 @@ def uccsd_operator(single_amplitudes, double_amplitudes, anti_hermitian=True):
     for i, j in itertools.product(range(n_orbitals), repeat=2):
         if single_amplitudes[i, j] == 0.:
             continue
-        uccsd_generator += FermionOperator(
-            ((i, 1), (j, 0)), single_amplitudes[i, j])
-        if (anti_hermitian):
-            uccsd_generator += FermionOperator(
-                ((j, 1), (i, 0)), -single_amplitudes[i, j])
+        uccsd_generator += FermionOperator(((i, 1), (j, 0)),
+                                           single_amplitudes[i, j])
+        if anti_hermitian:
+            uccsd_generator += FermionOperator(((j, 1), (i, 0)),
+                                               -single_amplitudes[i, j])
 
         # Add double excitations
     for i, j, k, l in itertools.product(range(n_orbitals), repeat=4):
@@ -73,11 +73,10 @@ def uccsd_operator(single_amplitudes, double_amplitudes, anti_hermitian=True):
         uccsd_generator += FermionOperator(
             ((i, 1), (j, 0), (k, 1), (l, 0)),
             double_amplitudes[i, j, k, l])
-        if (anti_hermitian):
+        if anti_hermitian:
             uccsd_generator += FermionOperator(
                 ((l, 1), (k, 0), (j, 1), (i, 0)),
                 -double_amplitudes[i, j, k, l])
-
     return uccsd_generator
 
 
@@ -126,7 +125,6 @@ def uccsd_singlet_operator(packed_amplitudes,
     n_occupied = int(numpy.ceil(n_electrons / 2.))
     n_virtual = int(n_qubits / 2 - n_occupied)  # Virtual Spatial Orbitals
     n_t1 = int(n_occupied * n_virtual)
-    n_t2 = int(n_t1 ** 2)
 
     t1 = packed_amplitudes[:n_t1]
     t2 = packed_amplitudes[n_t1:]
@@ -142,38 +140,38 @@ def t2_ind(i, j, k, l):
 
     uccsd_generator = FermionOperator()
 
-    for i in range(n_virtual):
-        for j in range(n_occupied):
-            for s1 in range(2):
-                uccsd_generator += FermionOperator((
-                    (2 * (i + n_occupied) + s1, 1),
-                    (2 * j + s1, 0)),
-                    t1[t1_ind(i, j)])
-
-                uccsd_generator += FermionOperator((
-                    (2 * j + s1, 1),
-                    (2 * (i + n_occupied) + s1, 0)),
-                    -t1[t1_ind(i, j)])
-
-    for i in range(n_virtual):
-        for j in range(n_occupied):
-            for s1 in range(2):
-                for k in range(n_virtual):
-                    for l in range(n_occupied):
-                        for s2 in range(2):
-                            uccsd_generator += FermionOperator((
-                                (2 * (i + n_occupied) + s1, 1),
-                                (2 * j + s1, 0),
-                                (2 * (k + n_occupied) + s2, 1),
-                                (2 * l + s2, 0)),
-                                t2[t2_ind(i, j, k, l)])
-
-                            uccsd_generator += FermionOperator((
-                                (2 * l + s2, 1),
-                                (2 * (k + n_occupied) + s2, 0),
-                                (2 * j + s1, 1),
-                                (2 * (i + n_occupied) + s1, 0)),
-                                -t2[t2_ind(i, j, k, l)])
+    spaces = range(n_virtual), range(n_occupied), range(2)
+
+    for i, j, s in itertools.product(*spaces):
+        uccsd_generator += FermionOperator(
+            (
+                (2 * (i + n_occupied) + s, 1),
+                (2 * j + s, 0),
+            ),
+            coefficient=t1[t1_ind(i, j)])
+
+        uccsd_generator += FermionOperator(
+            (
+                (2 * j + s, 1),
+                (2 * (i + n_occupied) + s, 0),
+            ),
+            coefficient=-t1[t1_ind(i, j)])
+
+    for i, j, s, i2, j2, s2 in itertools.product(*spaces, repeat=2):
+        uccsd_generator += FermionOperator((
+            (2 * (i + n_occupied) + s, 1),
+            (2 * j + s, 0),
+            (2 * (i2 + n_occupied) + s2, 1),
+            (2 * j2 + s2, 0)),
+            t2[t2_ind(i, j, i2, j2)])
+
+        uccsd_generator += FermionOperator((
+            (2 * j2 + s2, 1),
+            (2 * (i2 + n_occupied) + s2, 0),
+            (2 * j + s, 1),
+            (2 * (i + n_occupied) + s, 0)),
+            -t2[t2_ind(i, j, i2, j2)])
+
     return uccsd_generator