Majorana pool

tangelo/algorithms/variational/adapt_vqe_solver.py

@@ -53,7 +53,7 @@ class ADAPTSolver:
         pool (func): Function that returns a list of FermionOperator. Each
             element represents excitation/operator that has an effect of the
             total energy.
-        pool_args (tuple) : The arguments for the pool function given as a
+        pool_args (tuple or dict) : The arguments for the pool function given as a
             tuple.
         qubit_mapping (str): One of the supported qubit mapping identifiers.
         qubit_hamiltonian (QubitOperator-like): Self-explanatory.
@@ -174,7 +174,9 @@ def build(self):
             else:
                 raise KeyError('pool_args must be defined if using own pool function')
         # Check if pool function returns a QubitOperator or FermionOperator and populate variables
-        pool_list = self.pool(*self.pool_args)
+        if not isinstance(self.pool_args, (dict, tuple)):
+            raise ValueError("pool_args must be a tuple or a dictionary")
+        pool_list = self.pool(*self.pool_args) if isinstance(self.pool_args, tuple) else self.pool(**self.pool_args)
         if isinstance(pool_list[0], QubitOperator):
             self.pool_type = 'qubit'
             self.pool_operators = pool_list

tangelo/algorithms/variational/tests/test_adapt_vqe_solver.py

@@ -15,7 +15,9 @@
 import unittest
 
 from tangelo.algorithms.variational import ADAPTSolver
-from tangelo.molecule_library import mol_H2_sto3g
+from tangelo.molecule_library import mol_H2_sto3g, xyz_H4
+from tangelo.toolboxes.ansatz_generator._unitary_majorana_cc import majorana_uccgsd_list
+from tangelo.toolboxes.molecular_computation.molecule import SecondQuantizedMolecule
 
 
 class ADAPTSolverTest(unittest.TestCase):
@@ -54,6 +56,20 @@ def test_single_cycle_adapt(self):
                      "vqe_variational_parameters": 1}
         self.assertEqual(adapt_solver.get_resources(), resources)
 
+    def test_multiple_cycle_adapt_majorana_pool(self):
+        """Solve H4 with one frozen orbtial with ADAPTSolver using 4 cycles and a operators chosen
+        from a Majorana UCCGSD pool
+        """
+
+        mol = SecondQuantizedMolecule(xyz_H4, 0, 0, "sto-3g", frozen_orbitals=[0])
+        opt_dict = {"molecule": mol, "max_cycles": 4, "verbose": False, "pool": majorana_uccgsd_list,
+                    "pool_args": {"n_sos": mol.n_active_sos}}
+        adapt_solver = ADAPTSolver(opt_dict)
+        adapt_solver.build()
+        adapt_solver.simulate()
+
+        self.assertAlmostEqual(adapt_solver.optimal_energy, -1.8945, places=3)
+
 
 if __name__ == "__main__":
     unittest.main()

tangelo/toolboxes/ansatz_generator/_unitary_majorana_cc.py

@@ -0,0 +1,97 @@
+# Copyright 2021 Good Chemistry Company.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Utililty functions to generate pool of FermionOperators obtained from individual MajoranaOperators in
+unitary coupled cluster expansions."""
+
+from openfermion.transforms.opconversions.conversions import get_fermion_operator
+from openfermion import MajoranaOperator
+from numpy import integer
+
+from tangelo.toolboxes.molecular_computation.molecule import SecondQuantizedMolecule
+
+
+def majorana_uccsd_list(molecule: SecondQuantizedMolecule = None, n_electrons: int = None, n_sos: int = None):
+    """Construct a list of FermionOperator corresponding to the individual Majorana modes in the UCCSD ansatz
+
+    Args:
+        molecule (SecondQuantizedMolecule): The molecule to generate the Majorana pool from: Default None
+        n_electrons (int): The number of active electrons: Default None
+        n_sos (int): The number of active spin orbitals: Default None
+
+    Returns:
+        list: The list of FermionOperator for each Majorana operator in a UCCD pool"""
+
+    if molecule is not None:
+        n_active_electrons = molecule.n_active_electrons
+        n_active_sos = molecule.n_active_sos
+    elif isinstance(n_electrons, (int, integer)) and isinstance(n_sos, (int, integer)):
+        n_active_electrons = n_electrons
+        n_active_sos = n_sos
+    else:
+        raise ValueError("SecondQuantized mol or ints n_electrons/n_sos must be provided")
+
+    def majorana_uccsd_generator():
+        for i in range(n_active_electrons):
+            for k in range(n_active_electrons, n_active_sos):
+                yield (2*i, 2*k)
+                yield (2*i+1, 2*k+1)
+                for j in range(i+1, n_active_electrons):
+                    for l in range(k+1, n_active_sos):
+                        yield (2*i, 2*j+1, 2*k+1, 2*l+1)
+                        yield (2*i+1, 2*j, 2*k+1, 2*l+1)
+                        yield (2*i+1, 2*j+1, 2*k, 2*l+1)
+                        yield (2*i+1, 2*j+1, 2*k+1, 2*l)
+                        yield (2*i+1, 2*j, 2*k, 2*l)
+                        yield (2*i, 2*j+1, 2*k, 2*l)
+                        yield (2*i, 2*j, 2*k+1, 2*l)
+                        yield (2*i, 2*j, 2*k, 2*l+1)
+    pool_list = [get_fermion_operator(MajoranaOperator(term)) for term in majorana_uccsd_generator()]
+    return pool_list
+
+
+def majorana_uccgsd_list(molecule: SecondQuantizedMolecule = None, n_sos: int = None):
+    """Construct a list of FermionOperator corresponding to the individual Majorana modes in the UCCGSD ansatz
+
+    Args:
+        molecule (SecondQuantizedMolecule): The molecule to generate the Majorana pool from: Default None
+        n_sos (int): The number of active spin orbitals: Default None
+
+    Returns:
+        list: The list of FermionOperator for each Majorana operator in a UCCD pool"""
+
+    if molecule is not None:
+        n_active_sos = molecule.n_active_sos
+    elif isinstance(n_sos, (int, integer)):
+        n_active_sos = n_sos
+    else:
+        raise ValueError("SecondQuantized mol or int n_sos must be provided")
+
+    def majorana_uccgsd_generator():
+        for i in range(n_active_sos):
+            for j in range(i+1, n_active_sos):
+                yield (2*i, 2*j)
+                yield (2*i+1, 2*j+1)
+                for k in range(j+1, n_active_sos):
+                    for l in range(k+1, n_active_sos):
+                        yield (2*i, 2*j+1, 2*k+1, 2*l+1)
+                        yield (2*i+1, 2*j, 2*k+1, 2*l+1)
+                        yield (2*i+1, 2*j+1, 2*k, 2*l+1)
+                        yield (2*i+1, 2*j+1, 2*k+1, 2*l)
+                        yield (2*i+1, 2*j, 2*k, 2*l)
+                        yield (2*i, 2*j+1, 2*k, 2*l)
+                        yield (2*i, 2*j, 2*k+1, 2*l)
+                        yield (2*i, 2*j, 2*k, 2*l+1)
+    pool_list = [get_fermion_operator(MajoranaOperator(term)) for term in majorana_uccgsd_generator()]
+    return pool_list