tequila-basic 1.9.9__py3-none-any.whl → 1.9.10__py3-none-any.whl

tequila/quantumchemistry/qc_base.py

@@ -6,16 +6,27 @@ from tequila.hamiltonian import QubitHamiltonian
 from tequila.hamiltonian.paulis import Sp, Sm, Zero
 
 from tequila.circuit import QCircuit, gates
-from tequila.objective.objective import Variable, Variables, ExpectationValue
+from tequila.objective.objective import Variable, Variables, ExpectationValue, Objective
+from tequila import QTensor
 
 from tequila.simulators.simulator_api import simulate
 from tequila.utils import to_float
-from .chemistry_tools import ActiveSpaceData, FermionicGateImpl, prepare_product_state, ClosedShellAmplitudes, \
-    Amplitudes, ParametersQC, NBodyTensor, IntegralManager
+from .chemistry_tools import (
+    ActiveSpaceData,
+    FermionicGateImpl,
+    prepare_product_state,
+    ClosedShellAmplitudes,
+    Amplitudes,
+    ParametersQC,
+    NBodyTensor,
+    IntegralManager,
+)
 
 from .encodings import known_encodings
 
-import typing, numpy, numbers
+import typing
+import numpy
+import numbers
 from itertools import product
 import tequila.grouping.fermionic_functions as ff
 
@@ -26,13 +37,16 @@ try:
     # otherwise replace with from openfermion.hamiltonians import MolecularData
     import openfermion
     from openfermion.chem import MolecularData
-except:
+except Exception:
     try:
         from openfermion.hamiltonians import MolecularData
     except Exception as E:
         raise Exception("{}\nIssue with Tequila Chemistry: Please update openfermion".format(str(E)))
 import warnings
+
 OPTIMIZED_ORDERING = "Optimized"
+
+
 class QuantumChemistryBase:
     """
     Base Class for tequila chemistry functionality
@@ -41,15 +55,18 @@ class QuantumChemistryBase:
     Derived classes interface specific backends (e.g. Psi4, PySCF and Madness). See PACKAGE_interface.py for more
     """
 
-    def __init__(self, parameters: ParametersQC,
-                 transformation: typing.Union[str, typing.Callable] = None,
-                 active_orbitals: list = None,
-                 frozen_orbitals: list = None,
-                 orbital_type: str = None,
-                 reference_orbitals: list = None,
-                 orbitals: list = None,
-                 *args,
-                 **kwargs):
+    def __init__(
+        self,
+        parameters: ParametersQC,
+        transformation: typing.Union[str, typing.Callable] = None,
+        active_orbitals: list = None,
+        frozen_orbitals: list = None,
+        orbital_type: str = None,
+        reference_orbitals: list = None,
+        orbitals: list = None,
+        *args,
+        **kwargs,
+    ):
         """
         Parameters
         ----------
@@ -64,14 +81,14 @@ class QuantumChemistryBase:
         """
 
         self.parameters = parameters
-        n_electrons = parameters.n_electrons
+        n_electrons = parameters.total_n_electrons
         if "n_electrons" in kwargs:
             n_electrons = kwargs["n_electrons"]
 
         if reference_orbitals is None:
             reference_orbitals = [i for i in range(n_electrons // 2)]
         self._reference_orbitals = reference_orbitals
-        
+
         if orbital_type is None:
             orbital_type = "unknown"
 
@@ -79,33 +96,36 @@ class QuantumChemistryBase:
         overriding_freeze_instruction = orbital_type is not None and orbital_type.lower() == "native"
         # determine frozen core automatically if set
         # only if molecule is computed from scratch and not passed down from above
-        overriding_freeze_instruction = overriding_freeze_instruction or n_electrons != parameters.n_electrons
+        overriding_freeze_instruction = overriding_freeze_instruction or n_electrons != parameters.total_n_electrons
         overriding_freeze_instruction = overriding_freeze_instruction or frozen_orbitals is not None
         if not overriding_freeze_instruction and self.parameters.frozen_core:
             n_core_electrons = self.parameters.get_number_of_core_electrons()
             if frozen_orbitals is None:
-                frozen_orbitals = [i for i in range(n_core_electrons//2)]
-            
+                frozen_orbitals = [i for i in range(n_core_electrons // 2)]
 
         # initialize integral manager
         if "integral_manager" in kwargs:
             self.integral_manager = kwargs["integral_manager"]
         else:
-            self.integral_manager = self.initialize_integral_manager(active_orbitals=active_orbitals,
-                                                                     reference_orbitals=reference_orbitals,
-                                                                     orbitals=orbitals, frozen_orbitals=frozen_orbitals, orbital_type=orbital_type, basis_name=self.parameters.basis_set, *args,
-                                                                     **kwargs)
-        
+            self.integral_manager = self.initialize_integral_manager(
+                active_orbitals=active_orbitals,
+                reference_orbitals=reference_orbitals,
+                orbitals=orbitals,
+                frozen_orbitals=frozen_orbitals,
+                orbital_type=orbital_type,
+                basis_name=self.parameters.basis_set,
+                *args,
+                **kwargs,
+            )
+
         if orbital_type is not None and orbital_type.lower() == "native":
             self.integral_manager.transform_to_native_orbitals()
 
-
         self.transformation = self._initialize_transformation(transformation=transformation, *args, **kwargs)
 
         self._rdm1 = None
         self._rdm2 = None
 
-
     @classmethod
     def from_tequila(cls, molecule, transformation=None, *args, **kwargs):
         c = molecule.integral_manager.constant_term
@@ -120,16 +140,20 @@ class QuantumChemistryBase:
         if transformation is None:
             transformation = molecule.transformation
         parameters = molecule.parameters
-        return cls(nuclear_repulsion=c,
-                   one_body_integrals=h1,
-                   two_body_integrals=h2,
-                   overlap_integrals = S,
-                   orbital_coefficients = molecule.integral_manager.orbital_coefficients,
-                   active_orbitals= active_orbitals,
-                   transformation=transformation,
-                   orbital_type=molecule.integral_manager._orbital_type,
-                   parameters=parameters,
-                   reference_orbitals= molecule.integral_manager.active_space.reference_orbitals,*args, **kwargs)
+        return cls(
+            nuclear_repulsion=c,
+            one_body_integrals=h1,
+            two_body_integrals=h2,
+            overlap_integrals=S,
+            orbital_coefficients=molecule.integral_manager.orbital_coefficients,
+            active_orbitals=active_orbitals,
+            transformation=transformation,
+            orbital_type=molecule.integral_manager._orbital_type,
+            parameters=parameters,
+            reference_orbitals=molecule.integral_manager.active_space.reference_orbitals,
+            *args,
+            **kwargs,
+        )
 
     def supports_ucc(self):
         """
@@ -156,8 +180,9 @@ class QuantumChemistryBase:
             transformation = "JordanWigner"
 
         # filter out arguments to the transformation
-        trafo_args = {k.split("__")[1]: v for k, v in kwargs.items() if
-                      (hasattr(k, "lower") and "transformation__" in k.lower())}
+        trafo_args = {
+            k.split("__")[1]: v for k, v in kwargs.items() if (hasattr(k, "lower") and "transformation__" in k.lower())
+        }
 
         trafo_args["n_electrons"] = self.n_electrons
         trafo_args["n_orbitals"] = self.n_orbitals
@@ -170,16 +195,21 @@ class QuantumChemistryBase:
                 transformation = encodings[transformation](**trafo_args)
             else:
                 raise TequilaException(
-                    "Unkown Fermion-to-Qubit encoding {}. Try something like: {}".format(transformation,
-                                                                                         list(encodings.keys())))
+                    "Unkown Fermion-to-Qubit encoding {}. Try something like: {}".format(
+                        transformation, list(encodings.keys())
+                    )
+                )
 
         return transformation
 
     @classmethod
-    def from_openfermion(cls, molecule: openfermion.MolecularData,
-                         transformation: typing.Union[str, typing.Callable] = None,
-                         *args,
-                         **kwargs):
+    def from_openfermion(
+        cls,
+        molecule: openfermion.MolecularData,
+        transformation: typing.Union[str, typing.Callable] = None,
+        *args,
+        **kwargs,
+    ):
         """
         Initialize direclty from openfermion MolecularData object
 
@@ -191,15 +221,19 @@ class QuantumChemistryBase:
         -------
             The Tequila molecule
         """
-        parameters = ParametersQC(basis_set=molecule.basis, geometry=molecule.geometry,
-                                  description=molecule.description, multiplicity=molecule.multiplicity,
-                                  charge=molecule.charge)
+        parameters = ParametersQC(
+            basis_set=molecule.basis,
+            geometry=molecule.geometry,
+            units="angstrom",
+            description=molecule.description,
+            multiplicity=molecule.multiplicity,
+            charge=molecule.charge,
+        )
         return cls(parameters=parameters, transformation=transformation, molecule=molecule, *args, **kwargs)
 
-    def make_excitation_generator(self,
-                                  indices: typing.Iterable[typing.Tuple[int, int]],
-                                  form: str = None,
-                                  remove_constant_term: bool = True) -> QubitHamiltonian:
+    def make_excitation_generator(
+        self, indices: typing.Iterable[typing.Tuple[int, int]], form: str = None, remove_constant_term: bool = True
+    ) -> QubitHamiltonian:
         """
         Notes
         ----------
@@ -226,17 +260,21 @@ class QuantumChemistryBase:
         """
 
         if not self.supports_ucc():
-            raise TequilaException("Molecule with transformation {} does not support general UCC operations".format(self.transformation))
+            raise TequilaException(
+                "Molecule with transformation {} does not support general UCC operations".format(self.transformation)
+            )
 
         # check indices and convert to list of tuples if necessary
         if len(indices) == 0:
             raise TequilaException("make_excitation_operator: no indices given")
         elif not isinstance(indices[0], typing.Iterable):
             if len(indices) % 2 != 0:
-                raise TequilaException("make_excitation_generator: unexpected input format of indices\n"
-                                       "use list of tuples as [(a_0, i_0),(a_1, i_1) ...]\n"
-                                       "or list as [a_0, i_0, a_1, i_1, ... ]\n"
-                                       "you gave: {}".format(indices))
+                raise TequilaException(
+                    "make_excitation_generator: unexpected input format of indices\n"
+                    "use list of tuples as [(a_0, i_0),(a_1, i_1) ...]\n"
+                    "or list as [a_0, i_0, a_1, i_1, ... ]\n"
+                    "you gave: {}".format(indices)
+                )
             converted = [(indices[2 * i], indices[2 * i + 1]) for i in range(len(indices) // 2)]
         else:
             converted = indices
@@ -249,15 +287,17 @@ class QuantumChemistryBase:
         ofi = []
         dag = []
         for pair in converted:
-            assert (len(pair) == 2)
-            ofi += [(int(pair[0]), 1),
-                    (int(pair[1]), 0)]  # openfermion does not take other types of integers like numpy.int64
+            assert len(pair) == 2
+            ofi += [
+                (int(pair[0]), 1),
+                (int(pair[1]), 0),
+            ]  # openfermion does not take other types of integers like numpy.int64
             dag += [(int(pair[0]), 0), (int(pair[1]), 1)]
 
-        op = openfermion.FermionOperator(tuple(ofi), 1.j)  # 1j makes it hermitian
-        op += openfermion.FermionOperator(tuple(reversed(dag)), -1.j)
+        op = openfermion.FermionOperator(tuple(ofi), 1.0j)  # 1j makes it hermitian
+        op += openfermion.FermionOperator(tuple(reversed(dag)), -1.0j)
 
-        if isinstance(form, str) and form.lower() != 'fermionic':
+        if isinstance(form, str) and form.lower() != "fermionic":
             # indices for all the Na operators
             Na = [x for pair in converted for x in [(pair[0], 1), (pair[0], 0)]]
             # indices for all the Ma operators (Ma = 1 - Na)
@@ -291,8 +331,7 @@ class QuantumChemistryBase:
                 op += openfermion.FermionOperator(Na + Mi, -1.0)
                 op += openfermion.FermionOperator(Ni + Ma, -1.0)
             else:
-                raise TequilaException(
-                    "Unknown generator form {}, supported are G, P+, P-, G+, G- and P0".format(form))
+                raise TequilaException("Unknown generator form {}, supported are G, P+, P-, G+, G- and P0".format(form))
 
         qop = self.transformation(op)
 
@@ -310,13 +349,17 @@ class QuantumChemistryBase:
         qop = qop.simplify()
 
         if len(qop) == 0:
-            warnings.warn("Excitation generator is a unit operator.\n"
-                          "Non-standard transformations might not work with general fermionic operators\n"
-                          "indices = " + str(indices), category=TequilaWarning)
+            warnings.warn(
+                "Excitation generator is a unit operator.\n"
+                "Non-standard transformations might not work with general fermionic operators\n"
+                "indices = " + str(indices),
+                category=TequilaWarning,
+            )
         return qop
 
-    def make_hardcore_boson_excitation_gate(self, indices, angle, control=None, assume_real=True,
-                                            compile_options="optimize"):
+    def make_hardcore_boson_excitation_gate(
+        self, indices, angle, control=None, assume_real=True, compile_options="optimize"
+    ):
         """
         Make excitation generator in the hardcore-boson approximation (all electrons are forced to spin-pairs)
         use only in combination with make_hardcore_boson_hamiltonian()
@@ -333,22 +376,32 @@ class QuantumChemistryBase:
         -------
 
         """
+        U = QCircuit()
         target = []
         for pair in indices:
             assert len(pair) == 2
-            target += [self.transformation.up(pair[0]), self.transformation.up(pair[1])]
+            if "TAPEREDBINARY" in self.transformation.name.upper() and self.n_orbitals - 1 in pair:
+                p = [i for i in pair if i != self.n_orbitals - 1]
+                U += gates.Ry(angle=angle, target=p, assume_real=assume_real, control=control)
+            else:
+                target += [self.transformation.up(pair[0]), self.transformation.up(pair[1])]
         if self.transformation.up_then_down:
             consistency = [x < self.n_orbitals for x in target]
         else:
-            consistency = [x % 2 == 0  for x in target]
+            consistency = [x % 2 == 0 for x in target]
         if not all(consistency):
             raise TequilaException(
                 "make_hardcore_boson_excitation_gate: Inconsistencies in indices={} for encoding: {}".format(
-                    indices, self.transformation))
-        return gates.QubitExcitation(angle=angle, target=target, assume_real=assume_real, control=control,
-                                     compile_options=compile_options)
-    
-    def UR(self,i,j,angle=None, label=None, control=None, assume_real=True, *args, **kwargs):
+                    indices, self.transformation
+                )
+            )
+        if len(target):
+            U += gates.QubitExcitation(
+                angle=angle, target=target, assume_real=assume_real, control=control, compile_options=compile_options
+            )
+        return U
+
+    def UR(self, i, j, angle=None, label=None, control=None, assume_real=True, *args, **kwargs):
         """
         Convenience function for orbital rotation circuit (rotating spatial orbital i and j) with standard naming of variables
         See arXiv:2207.12421 Eq.6 for UR(0,1)
@@ -368,22 +421,26 @@ class QuantumChemistryBase:
                 Assume that the wavefunction will always stay real.
                 Will reduce potential gradient costs by a factor of 2
         """
-        i,j = self.format_excitation_indices([(i,j)])[0]
+        i, j = self.format_excitation_indices([(i, j)])[0]
         if angle is None:
             if label is None:
-                angle = Variable(name=("R",i,j))*numpy.pi
+                angle = Variable(name=("R", i, j)) * numpy.pi
             else:
-                angle = Variable(name=("R",i,j,label))*numpy.pi
-            
-        circuit = self.make_excitation_gate(indices=[(2*i,2*j)], angle=angle, assume_real=assume_real, control=control, *args, **kwargs)
-        circuit+= self.make_excitation_gate(indices=[(2*i+1,2*j+1)], angle=angle, assume_real=assume_real, control=control, *args, **kwargs)
+                angle = Variable(name=("R", i, j, label)) * numpy.pi
+
+        circuit = self.make_excitation_gate(
+            indices=[(2 * i, 2 * j)], angle=angle, assume_real=assume_real, control=control, *args, **kwargs
+        )
+        circuit += self.make_excitation_gate(
+            indices=[(2 * i + 1, 2 * j + 1)], angle=angle, assume_real=assume_real, control=control, *args, **kwargs
+        )
         return circuit
-    
-    def UC(self,i,j,angle=None, label=None, control=None, assume_real=True, *args, **kwargs):
+
+    def UC(self, i, j, angle=None, label=None, control=None, assume_real=True, *args, **kwargs):
         """
         Convenience function for orbital correlator circuit (correlating spatial orbital i and j through a spin-paired double excitation) with standard naming of variables
         See arXiv:2207.12421 Eq.22 for UC(1,2)
-        
+
         Parameters:
         ----------
             indices:
@@ -400,22 +457,35 @@ class QuantumChemistryBase:
                 Assume that the wavefunction will always stay real.
                 Will reduce potential gradient costs by a factor of 2
         """
-        i,j = self.format_excitation_indices([(i,j)])[0]
+        i, j = self.format_excitation_indices([(i, j)])[0]
         if angle is None:
             if label is None:
-                angle = Variable(name=("C",i,j))*numpy.pi
+                angle = Variable(name=("C", i, j)) * numpy.pi
             else:
-                angle = Variable(name=("C",i,j,label))*numpy.pi
+                angle = Variable(name=("C", i, j, label)) * numpy.pi
         if "jordanwigner" in self.transformation.name.lower() and not self.transformation.up_then_down:
             # for JW we can use the optimized form shown in arXiv:2207.12421 Eq.22
-            return gates.QubitExcitation(target=[2*i,2*j,2*i+1,2*j+1], angle=angle, control=control, assume_real=assume_real, *args, **kwargs)
+            return gates.QubitExcitation(
+                target=[2 * i, 2 * j, 2 * i + 1, 2 * j + 1],
+                angle=angle,
+                control=control,
+                assume_real=assume_real,
+                *args,
+                **kwargs,
+            )
         else:
-            return self.make_excitation_gate(indices=[(2*i,2*j),(2*i+1,2*j+1)], angle=angle, control=control, assume_real=assume_real, *args, **kwargs)
-
-    def make_orbital_rotation_gate(self, indices:tuple, *args, **kwargs):
+            return self.make_excitation_gate(
+                indices=[(2 * i, 2 * j), (2 * i + 1, 2 * j + 1)],
+                angle=angle,
+                control=control,
+                assume_real=assume_real,
+                *args,
+                **kwargs,
+            )
+
+    def make_orbital_rotation_gate(self, indices: tuple, *args, **kwargs):
         # backward compatibility
-        return self.UR(indices[0],indices[1], *args, **kwargs)
-
+        return self.UR(indices[0], indices[1], *args, **kwargs)
 
     def make_excitation_gate(self, indices, angle, control=None, assume_real=True, **kwargs):
         """
@@ -441,20 +511,32 @@ class QuantumChemistryBase:
         """
 
         if not self.supports_ucc():
-            raise TequilaException("Molecule with transformation {} does not support general UCC operations".format(self.transformation))
+            raise TequilaException(
+                "Molecule with transformation {} does not support general UCC operations".format(self.transformation)
+            )
 
         generator = self.make_excitation_generator(indices=indices, remove_constant_term=control is None)
         p0 = self.make_excitation_generator(indices=indices, form="P0", remove_constant_term=control is None)
         if self.transformation.up_then_down:
             idx = []
             for pair in indices:
-                idx.append((pair[0]//2+(pair[0]%2)*self.n_orbitals,pair[1]//2+(pair[1]%2)*self.n_orbitals))
-        else:idx = indices
+                idx.append(
+                    (pair[0] // 2 + (pair[0] % 2) * self.n_orbitals, pair[1] // 2 + (pair[1] % 2) * self.n_orbitals)
+                )
+        else:
+            idx = indices
         return QCircuit.wrap_gate(
-            FermionicGateImpl(angle=angle, generator=generator, p0=p0,
-                              transformation=type(self.transformation).__name__.lower(), indices=idx,
-                              assume_real=assume_real,
-                              control=control, **kwargs))
+            FermionicGateImpl(
+                angle=angle,
+                generator=generator,
+                p0=p0,
+                transformation=type(self.transformation).__name__.lower(),
+                indices=idx,
+                assume_real=assume_real,
+                control=control,
+                **kwargs,
+            )
+        )
 
     def make_molecule(self, *args, **kwargs) -> MolecularData:
         """Creates a molecule in openfermion format by running psi4 and extracting the data
@@ -487,7 +569,7 @@ class QuantumChemistryBase:
         if do_compute:
             molecule = self.do_make_molecule(*args, **kwargs)
 
-        #molecule.save()
+        # molecule.save()
         return molecule
 
     def initialize_integral_manager(self, *args, **kwargs):
@@ -504,12 +586,12 @@ class QuantumChemistryBase:
         - result of self.get_integrals()
         """
 
-        n_electrons = self.parameters.n_electrons
+        n_electrons = self.parameters.total_n_electrons
         if "n_electrons" in kwargs:
             n_electrons = kwargs["n_electrons"]
 
-        assert ("one_body_integrals" in kwargs)
-        assert ("two_body_integrals" in kwargs)
+        assert "one_body_integrals" in kwargs
+        assert "two_body_integrals" in kwargs
         one_body_integrals = kwargs["one_body_integrals"]
         kwargs.pop("one_body_integrals")
         two_body_integrals = kwargs["two_body_integrals"]
@@ -534,7 +616,6 @@ class QuantumChemistryBase:
             kwargs.pop("nuclear_repulsion")
 
         if "active_space" not in kwargs:
-
             active_orbitals = [i for i in range(one_body_integrals.shape[0])]
             if "active_orbitals" in kwargs and kwargs["active_orbitals"] is not None:
                 active_orbitals = kwargs["active_orbitals"]
@@ -547,15 +628,21 @@ class QuantumChemistryBase:
             if "reference_orbitals" in kwargs and kwargs["reference_orbitals"] is not None:
                 reference_orbitals = kwargs["reference_orbitals"]
 
-            active_space = ActiveSpaceData(active_orbitals=sorted(active_orbitals),
-                                           reference_orbitals=sorted(reference_orbitals))
+            active_space = ActiveSpaceData(
+                active_orbitals=sorted(active_orbitals), reference_orbitals=sorted(reference_orbitals)
+            )
             kwargs["active_space"] = active_space
 
         if "basis_name" not in kwargs:
             kwargs["basis_name"] = self.parameters.basis_set
 
-        manager = IntegralManager(one_body_integrals=one_body_integrals, two_body_integrals=two_body_integrals,
-                                  constant_term=constant_part, *args, **kwargs)
+        manager = IntegralManager(
+            one_body_integrals=one_body_integrals,
+            two_body_integrals=two_body_integrals,
+            constant_term=constant_part,
+            *args,
+            **kwargs,
+        )
 
         return manager
 
@@ -581,30 +668,177 @@ class QuantumChemistryBase:
         if ignore_active_space:
             U = orbital_coefficients
         else:
-            for kk,k in enumerate(active_indices):
-                for ll,l in enumerate(active_indices):
+            for kk, k in enumerate(active_indices):
+                for ll, l in enumerate(active_indices):
                     U[k][l] = orbital_coefficients[kk][ll]
 
         # can not be an instance of a specific backend (otherwise we get inconsistencies with classical methods in the backend)
         integral_manager = copy.deepcopy(self.integral_manager)
         integral_manager.transform_orbitals(U=U, name=name)
-        result = QuantumChemistryBase(parameters=self.parameters, integral_manager=integral_manager, transformation=self.transformation)
+        result = QuantumChemistryBase(
+            parameters=self.parameters, integral_manager=integral_manager, transformation=self.transformation
+        )
         return result
-    
+
     def orthonormalize_basis_orbitals(self):
         # backward compatibility
         return self.use_native_orbitals()
-    
-    def use_native_orbitals(self, inplace=False):
+
+    def use_native_orbitals(self, inplace=False, core: list = None, *args, **kwargs):
         """
+        Parameters
+        ----------
+            inplace:
+                update current molecule or return a new instance
+            core:
+                list of core orbital indices (optional) — orbitals will be frozen and treated as doubly occupied. The orbitals correspond to
+                the currently used orbitals of the molecule (default is usually canonical HF), see mol.print_basis_info() if unsure. Providing core
+                orbitals is optional; the default is inherited from the active space set in self.integral_manager. If core is provided, the
+                corresponding active native orbitals will be chosen based on their overlap with the core orbitals.
+            active(in kwargs):
+                list the active orbital indices (optional, in kwargs) - on the Native Orbital schema. Default: All orbitals, if core (see above) is provided,
+                then the default is to automatically select the active orbitals based on their overlap with the provided core orbitals (selectint the N-|core|
+                orbitals that have smallest overlap with coree).
+                As an example, Assume the input geometry was H, He, H. active=[0,1,2] is selecting the (orthonormalized) atomic 1s (left H), 1s (He), 1s (right H).
+                If core=[0] and active is not set, then active=[0,2] will be selected automatically (as the 1s He atomic orbital will have the largest overlap
+                with the lowest energy HF orbital).
         Returns
         -------
         New molecule in the native (orthonormalized) basis given
         e.g. for standard basis sets the orbitals are orthonormalized Gaussian Basis Functions
         """
-        if not self.integral_manager.active_space_is_trivial():
-            warnings.warn("orthonormalize_basis_orbitals: active space is set and might lead to inconsistent behaviour", TequilaWarning)
+        c = copy.deepcopy(self.integral_manager.orbital_coefficients)
+        s = self.integral_manager.overlap_integrals
+        d = self.integral_manager.get_orthonormalized_orbital_coefficients()
+
+        def inner(a, b, s):
+            return numpy.sum(numpy.multiply(numpy.outer(a, b), s))
 
+        def orthogonalize(c, d, s):
+            """
+            :return: orthogonalized orbitals with core HF orbitals and active Orthongonalized Native orbitals.
+            """
+            ### Computing Core-Active overlap Matrix
+            # sbar_{ki} = \langle \phi_k | \varphi_i \rangle = \sum_{m,n} c_{nk}d_{mi}\langle \chi_n | \chi_m \rangle
+            # c_{nk} = HF coeffs, d_{mi} = nat orb coef s_{mn} = Atomic Overlap Matrix
+            # k \in active orbs, i \in core orbs, m,n \in basis coeffs
+            # sbar = np.einsum('nk,mi,nm->ki', c, d, s) #only works if active == to_active
+            c = c.T
+            d = d.T
+            sbar = numpy.zeros(shape=s.shape)
+            for k in active:
+                for i in core:
+                    sbar[i][to_active[k]] = inner(c[i], d[k], s)
+            ### Projecting out Core orbitals from the Native ones
+            # dbar_{ji} = d_{ji} - \sum_k sbar_{ki}c_{jk}
+            # k \in active, i \in core, j in basis coeffs
+            dbar = numpy.zeros(shape=s.shape)
+
+            for j in active:
+                dbar[to_active[j]] = d[j]
+                for i in core:
+                    temp = sbar[i][to_active[j]] * c[i]
+                    dbar[to_active[j]] -= temp
+            ### Projected-out Nat Orbs Normalization
+            for i in to_active.values():
+                norm = numpy.sqrt(numpy.sum(numpy.multiply(numpy.outer(dbar[i], dbar[i]), s.T)))
+                if not numpy.isclose(norm, 0):
+                    dbar[i] = dbar[i] / norm
+            ### Reintroducing the New Coeffs on the HF coeff matrix
+            for j in to_active.values():
+                c[j] = dbar[j]
+            ### Compute new orbital overlap matrix:
+            sprima = numpy.eye(len(c))
+            for idx, i in enumerate(to_active.values()):
+                for j in [*to_active.values()][idx:]:
+                    sprima[i][j] = inner(c[i], c[j], s)
+                    sprima[j][i] = sprima[i][j]
+            ### Symmetric orthonormalization
+            lam_s, l_s = numpy.linalg.eigh(sprima)
+            lam_s = lam_s * numpy.eye(len(lam_s))
+            lam_sqrt_inv = numpy.sqrt(numpy.linalg.inv(lam_s))
+            symm_orthog = numpy.dot(l_s, numpy.dot(lam_sqrt_inv, l_s.T))
+            return symm_orthog.dot(c).T
+
+        def get_active(core):
+            ov = numpy.zeros(shape=(len(self.integral_manager.orbitals)))
+            for i in core:
+                for j in range(len(d)):
+                    ov[j] += numpy.abs(inner(c.T[i], d.T[j], s))
+            act = []
+            for i in range(len(self.integral_manager.orbitals) - len(core)):
+                idx = numpy.argmin(ov)
+                act.append(idx)
+                ov[idx] = 1 * len(core)
+            act.sort()
+            return act
+
+        def get_core(active):
+            ov = numpy.zeros(shape=(len(self.integral_manager.orbitals)))
+            for i in active:
+                for j in range(len(d)):
+                    ov[j] += numpy.abs(inner(d.T[i], c.T[j], s))
+            co = []
+            for i in range(len(self.integral_manager.orbitals) - len(active)):
+                idx = numpy.argmin(ov)
+                co.append(idx)
+                ov[idx] = 1 * len(active)
+            co.sort()
+            return co
+
+        active = None
+        if not self.integral_manager.active_space_is_trivial() and core is None:
+            core = [i.idx_total for i in self.integral_manager.orbitals if i.idx is None]
+        if "active" in kwargs:
+            active = kwargs["active"]
+            kwargs.pop("active")
+            if core is None:
+                core = get_core(active)
+        else:
+            if active is None:
+                if core is None:
+                    core = []
+                    active = [i for i in range(len(self.integral_manager.orbitals))]
+                else:
+                    if isinstance(core, int):
+                        core = [core]
+                    active = get_active(core)
+        assert len(active) + len(core) == len(self.integral_manager.orbitals)
+        to_active = [i for i in range(len(self.integral_manager.orbitals)) if i not in core]
+        to_active = {active[i]: to_active[i] for i in range(len(active))}
+        if len(core):
+            coeff = orthogonalize(c, d, s)
+            if inplace:
+                self.integral_manager = self.initialize_integral_manager(
+                    one_body_integrals=self.integral_manager.one_body_integrals,
+                    two_body_integrals=self.integral_manager.two_body_integrals,
+                    constant_term=self.integral_manager.constant_term,
+                    active_orbitals=[*to_active.values()],
+                    reference_orbitals=[i.idx_total for i in self.integral_manager.reference_orbitals],
+                    frozen_orbitals=core,
+                    orbital_coefficients=coeff,
+                    overlap_integrals=s,
+                )
+                return self
+            else:
+                integral_manager = self.initialize_integral_manager(
+                    one_body_integrals=self.integral_manager.one_body_integrals,
+                    two_body_integrals=self.integral_manager.two_body_integrals,
+                    constant_term=self.integral_manager.constant_term,
+                    active_orbitals=[*to_active.values()],
+                    reference_orbitals=[i.idx_total for i in self.integral_manager.reference_orbitals],
+                    frozen_orbitals=core,
+                    orbital_coefficients=coeff,
+                    overlap_integrals=s,
+                )
+                parameters = copy.deepcopy(self.parameters)
+                result = QuantumChemistryBase(
+                    parameters=parameters,
+                    integral_manager=integral_manager,
+                    transformation=self.transformation,
+                    active_orbitals=[*to_active.values()],
+                )
+                return result
         # can not be an instance of a specific backend (otherwise we get inconsistencies with classical methods in the backend)
         if inplace:
             self.integral_manager.transform_to_native_orbitals()
@@ -612,10 +846,11 @@ class QuantumChemistryBase:
         else:
             integral_manager = copy.deepcopy(self.integral_manager)
             integral_manager.transform_to_native_orbitals()
-            result = QuantumChemistryBase(parameters=self.parameters, integral_manager=integral_manager, transformation=self.transformation)
+            result = QuantumChemistryBase(
+                parameters=self.parameters, integral_manager=integral_manager, transformation=self.transformation
+            )
             return result
 
-
     def do_make_molecule(self, *args, **kwargs):
         """
         Called by self.make_molecule with args and kwargs passed through
@@ -626,7 +861,7 @@ class QuantumChemistryBase:
         constant_term, one_body_integrals, two_body_integrals = self.integral_manager.get_integrals(ordering="of")
         two_body_integrals = two_body_integrals.reorder(to="of")
 
-        if ("n_orbitals" in kwargs):
+        if "n_orbitals" in kwargs:
             n_orbitals = kwargs["n_orbitals"]
         else:
             n_orbitals = one_body_integrals.shape[0]
@@ -679,8 +914,8 @@ class QuantumChemistryBase:
         Compute annihilation operator on spin-orbital in qubit representation
         Spin-orbital order is always (up,down,up,down,...)
         """
-        assert orbital<=self.n_orbitals*2
-        aop = openfermion.ops.FermionOperator(f'{orbital}', coefficient)
+        assert orbital <= self.n_orbitals * 2
+        aop = openfermion.ops.FermionOperator(f"{orbital}", coefficient)
         return self.transformation(aop)
 
     def make_creation_op(self, orbital, coefficient=1.0):
@@ -688,8 +923,8 @@ class QuantumChemistryBase:
         Compute creation operator on spin-orbital in qubit representation
         Spin-orbital order is always (up,down,up,down,...)
         """
-        assert orbital<=self.n_orbitals*2
-        cop = openfermion.ops.FermionOperator(f'{orbital}^', coefficient)
+        assert orbital <= self.n_orbitals * 2
+        cop = openfermion.ops.FermionOperator(f"{orbital}^", coefficient)
         return self.transformation(cop)
 
     def make_number_op(self, orbital):
@@ -699,7 +934,7 @@ class QuantumChemistryBase:
         """
         num_op = self.make_creation_op(orbital) * self.make_annihilation_op(orbital)
         return num_op
-    
+
     def make_sz_op(self):
         """
         Compute the spin_z operator of the molecule in qubit representation
@@ -707,8 +942,8 @@ class QuantumChemistryBase:
         sz = QubitHamiltonian()
         for i in range(0, self.n_orbitals * 2, 2):
             one = 0.5 * self.make_creation_op(i) * self.make_annihilation_op(i)
-            two = 0.5 * self.make_creation_op(i+1) * self.make_annihilation_op(i+1)
-            sz += (one - two)
+            two = 0.5 * self.make_creation_op(i + 1) * self.make_annihilation_op(i + 1)
+            sz += one - two
         return sz
 
     def make_sp_op(self):
@@ -717,7 +952,7 @@ class QuantumChemistryBase:
         """
         sp = QubitHamiltonian()
         for i in range(self.n_orbitals):
-            sp += self.make_creation_op(i*2) * self.make_annihilation_op(i*2 + 1)
+            sp += self.make_creation_op(i * 2) * self.make_annihilation_op(i * 2 + 1)
         return sp
 
     def make_sm_op(self):
@@ -726,7 +961,7 @@ class QuantumChemistryBase:
         """
         sm = QubitHamiltonian()
         for i in range(self.n_orbitals):
-            sm += self.make_creation_op(i*2 + 1) * self.make_annihilation_op(i*2)
+            sm += self.make_creation_op(i * 2 + 1) * self.make_annihilation_op(i * 2)
         return sm
 
     def make_s2_op(self):
@@ -751,7 +986,8 @@ class QuantumChemistryBase:
         # warnings for backward comp
         if "active_indices" in kwargs:
             warnings.warn(
-                "active space can't be changed in molecule. Will ignore active_orbitals passed to make_hamiltonian")
+                "active space can't be changed in molecule. Will ignore active_orbitals passed to make_hamiltonian"
+            )
 
         of_molecule = self.make_molecule()
         fop = of_molecule.get_molecular_hamiltonian()
@@ -781,7 +1017,7 @@ class QuantumChemistryBase:
         for p in range(n_orbitals):
             h[p, p] += 2 * obt[p, p]
             for q in range(n_orbitals):
-                h[p, q] += + tbt.elems[p, p, q, q]
+                h[p, q] += +tbt.elems[p, p, q, q]
                 if p != q:
                     g[p, q] += 2 * tbt.elems[p, q, q, p] - tbt.elems[p, q, p, q]
 
@@ -793,7 +1029,7 @@ class QuantumChemistryBase:
                 H += h[p, q] * Sm(up) * Sp(uq) + g[p, q] * Sm(up) * Sp(up) * Sm(uq) * Sp(uq)
 
         if not self.transformation.up_then_down and not condensed:
-            alpha_map = {k.idx:self.transformation.up(k.idx) for k in self.orbitals}
+            alpha_map = {k.idx: self.transformation.up(k.idx) for k in self.orbitals}
             H = H.map_qubits(alpha_map)
         return H
 
@@ -804,7 +1040,9 @@ class QuantumChemistryBase:
         Create a MolecularHamiltonian as openfermion Class
         (used internally here, not used in tequila)
         """
-        return self.make_molecule().get_molecular_hamiltonian(occupied_indices=occupied_indices, active_indices=active_indices)
+        return self.make_molecule().get_molecular_hamiltonian(
+            occupied_indices=occupied_indices, active_indices=active_indices
+        )
 
     def get_integrals(self, *args, **kwargs):
         """
@@ -825,7 +1063,7 @@ class QuantumChemistryBase:
         return self.integral_manager.get_integrals(*args, **kwargs)
 
     def compute_one_body_integrals(self):
-        """ convenience function """
+        """convenience function"""
         c, h1, h2 = self.get_integrals()
         return h1
 
@@ -902,7 +1140,9 @@ class QuantumChemistryBase:
             if not all(consistency):
                 warnings.warn(
                     "hcb_to_me: given circuit is not defined on all first {} qubits. Is this a HCB circuit?".format(
-                        self.n_orbitals))
+                        self.n_orbitals
+                    )
+                )
 
         # map to alpha qubits
         if condensed:
@@ -914,37 +1154,37 @@ class QuantumChemistryBase:
         UX = self.transformation.hcb_to_me()
         if UX is None:
             raise TequilaException(
-                "transformation={} has no hcb_to_me function implemented".format(self.transformation))
+                "transformation={} has no hcb_to_me function implemented".format(self.transformation)
+            )
         return alpha_U + UX
 
-    def get_pair_specific_indices(self,
-                                  pair_info: str = None,
-                                  include_singles: bool = True,
-                                  general_excitations: bool = True) -> list:
-        """
-        Assuming a pair-specific model, create a pair-specific index list
-        to be used in make_upccgsd_ansatz(indices = ... )
-        Excite from a set of references (i) to any pair coming from (i),
-        i.e. any (i,j)/(j,i). If general excitations are allowed, also
-        allow excitations from pairs to appendant pairs and reference.
-
-        Parameters
-        ----------
-        pair_info
-            file or list including information about pair structure
-            references single number, pair double
-            example: as file: "0,1,11,11,00,10" (hand over file name)
-                     in file, skip first row assuming some text with information
-                     as list:['0','1`','11','11','00','10']
-                     ~> two reference orbitals 0 and 1,
-                     then two orbitals from pair 11, one from 00, one mixed 10
-        include_singles
-            include single excitations
-        general_excitations
-            allow general excitations
-       Returns
-        -------
-            list of indices with pair-specific ansatz
+    def get_pair_specific_indices(
+        self, pair_info: str = None, include_singles: bool = True, general_excitations: bool = True
+    ) -> list:
+        """
+         Assuming a pair-specific model, create a pair-specific index list
+         to be used in make_upccgsd_ansatz(indices = ... )
+         Excite from a set of references (i) to any pair coming from (i),
+         i.e. any (i,j)/(j,i). If general excitations are allowed, also
+         allow excitations from pairs to appendant pairs and reference.
+
+         Parameters
+         ----------
+         pair_info
+             file or list including information about pair structure
+             references single number, pair double
+             example: as file: "0,1,11,11,00,10" (hand over file name)
+                      in file, skip first row assuming some text with information
+                      as list:['0','1`','11','11','00','10']
+                      ~> two reference orbitals 0 and 1,
+                      then two orbitals from pair 11, one from 00, one mixed 10
+         include_singles
+             include single excitations
+         general_excitations
+             allow general excitations
+        Returns
+         -------
+             list of indices with pair-specific ansatz
         """
 
         if pair_info is None:
@@ -962,12 +1202,13 @@ class QuantumChemistryBase:
         generalized = 0
         for idx, p in enumerate(pairs):
             if len(p) == 1:
-                connect[idx] = [i for i in range(len(pairs))
-                                if ((len(pairs[i]) == 2) and (str(idx) in pairs[i]))]
+                connect[idx] = [i for i in range(len(pairs)) if ((len(pairs[i]) == 2) and (str(idx) in pairs[i]))]
             elif (len(p) == 2) and general_excitations:
-                connect[idx] = [i for i in range(len(pairs))
-                                if (((p[0] in pairs[i]) or (p[1] in pairs[i]) or str(i) in p)
-                                    and not (i == idx))]
+                connect[idx] = [
+                    i
+                    for i in range(len(pairs))
+                    if (((p[0] in pairs[i]) or (p[1] in pairs[i]) or str(i) in p) and not (i == idx))
+                ]
             elif len(p) > 2:
                 raise TequilaException("Invalid reference of pair id.")
 
@@ -996,7 +1237,6 @@ class QuantumChemistryBase:
         return tuple(idx)
 
     def make_upccgsd_indices(self, key, reference_orbitals=None, *args, **kwargs):
-
         if reference_orbitals is None:
             reference_orbitals = [x.idx for x in self.reference_orbitals]
         indices = []
@@ -1006,8 +1246,12 @@ class QuantumChemistryBase:
             # ensures local connectivity
             indices = [[(n, n + 1)] for n in range(self.n_orbitals - 1)]
         elif hasattr(key, "lower") and "g" not in key.lower():
-            indices = [[(n, m)] for n in reference_orbitals for m in range(self.n_orbitals) if
-                       n < m and m not in reference_orbitals]
+            indices = [
+                [(n, m)]
+                for n in reference_orbitals
+                for m in range(self.n_orbitals)
+                if n < m and m not in reference_orbitals
+            ]
         elif hasattr(key, "lower") and "g" in key.lower():
             indices = [[(n, m)] for n in range(self.n_orbitals) for m in range(self.n_orbitals) if n < m]
         else:
@@ -1016,68 +1260,122 @@ class QuantumChemistryBase:
 
         return indices
 
-    def make_hardcore_boson_upccgd_layer(self,
-                                         indices: list = "UpCCGD",
-                                         label: str = None,
-                                         assume_real: bool = True,
-                                         *args, **kwargs):
-
+    def make_hardcore_boson_upccgd_layer(
+        self, indices: list = "UpCCGD", label: str = None, assume_real: bool = True, *args, **kwargs
+    ):
         if hasattr(indices, "lower"):
             indices = self.make_upccgsd_indices(key=indices.lower())
 
         UD = QCircuit()
         for idx in indices:
-            UD += self.make_hardcore_boson_excitation_gate(indices=idx, angle=(idx, "D", label),
-                                                           assume_real=assume_real)
+            UD += self.make_hardcore_boson_excitation_gate(
+                indices=idx, angle=(idx, "D", label), assume_real=assume_real
+            )
 
         return UD
-    
-    def make_spa_ansatz(self, edges, hcb=False,  use_units_of_pi=False, label=None, optimize=None, ladder=True):
+
+    def make_spa_ansatz(self, edges, hcb=False, use_units_of_pi=False, label=None, optimize=None, ladder=True):
         """
         Separable Pair Ansatz (SPA) for general molecules
-        see arxiv: 
+        see arxiv:
         edges: a list of tuples that contain the orbital indices for the specific pairs
                one example: edges=[(0,), (1,2,3), (4,5)] are three pairs, one with a single orbital [0], one with three orbitals [1,2,3] and one with two orbitals [4,5]
         hcb: spa ansatz in the hcb (hardcore-boson) space without transforming to current transformation (e.g. JordanWigner), use this for example in combination with the self.make_hardcore_boson_hamiltonian() and see the article above for more info
         use_units_of_pi: circuit angles in units of pi
         label: label the variables in the circuit
         optimize: optimize the circuit construction (see article). Results in shallow circuit from Ry and CNOT gates
-        ladder: if true the excitation pattern will be local. E.g. in the pair from orbitals (1,2,3) we will have the excitations 1->2 and 2->3, if set to false we will have standard coupled-cluster style excitations - in this case this would be 1->2 and 1->3 
+        ladder: if true the excitation pattern will be local. E.g. in the pair from orbitals (1,2,3) we will have the excitations 1->2 and 2->3, if set to false we will have standard coupled-cluster style excitations - in this case this would be 1->2 and 1->3
         """
+
+        def _make_spa_tappered(edges, hcb=False, use_units_of_pi=False, label=None, optimize=False, ladder=True):
+            U = QCircuit()
+            cedges = []
+            for edge in edges:
+                if self.n_orbitals - 1 in edge:
+                    cedge = [i for i in edge if i != self.n_orbitals - 1] + [self.n_orbitals - 1]
+                    cedges.append(cedge)
+                else:
+                    cedges.append(edge)
+            if optimize:
+                for edge_orbitals in cedges:
+                    edge_qubits = [self.transformation.up(i) for i in edge_orbitals]
+                    if not edge_qubits[0] == self.transformation.up(self.n_orbitals - 1):
+                        U += gates.X(edge_qubits[0])
+                    if len(edge_qubits) == 1:
+                        continue
+                    for i in range(1, len(edge_qubits)):
+                        q1 = edge_qubits[i]
+                        c = edge_qubits[i - 1]
+                        if not ladder:
+                            c = edge_qubits[0]
+                        angle = Variable(name=((edge_orbitals[i - 1], edge_orbitals[i]), "D", label))
+                        if use_units_of_pi:
+                            angle = angle * numpy.pi
+                        if (i - 1 == 0) and not (q1 == self.transformation.up(self.n_orbitals - 1)):
+                            U += gates.Ry(angle=angle, target=q1, control=None)
+                        elif (i - 1 == 0) and (q1 == self.transformation.up(self.n_orbitals - 1)):
+                            U += gates.Ry(angle=angle, target=c, control=None)
+                        else:
+                            U += gates.Ry(angle=angle, target=q1, control=c)
+                        if q1 != self.transformation.up(self.n_orbitals - 1):
+                            U += gates.CNOT(q1, c)
+                if not hcb:
+                    U += self.hcb_to_me()
+                return U
+            else:
+                return self.make_spa_ansatz(
+                    cedges, hcb=hcb, use_units_of_pi=use_units_of_pi, label=label, optimize=True, ladder=ladder
+                )
+
         if edges is None:
-            raise TequilaException("SPA ansatz within a standard orbital basis needs edges. Please provide with the keyword edges.\nExample: edges=[(0,1,2),(3,4)] would correspond to two edges created from orbitals (0,1,2) and (3,4), note that orbitals can only be assigned to a single edge")
-        
+            raise TequilaException(
+                "SPA ansatz within a standard orbital basis needs edges. Please provide with the keyword edges.\nExample: edges=[(0,1,2),(3,4)] would correspond to two edges created from orbitals (0,1,2) and (3,4), note that orbitals can only be assigned to a single edge"
+            )
+
         # sanity checks
         # current SPA implementation needs even number of electrons
         if self.n_electrons % 2 != 0:
-            raise TequilaException("need even number of electrons for SPA ansatz.\n{} active electrons".format(self.n_electrons))
+            raise TequilaException(
+                "need even number of electrons for SPA ansatz.\n{} active electrons".format(self.n_electrons)
+            )
         # making sure that enough edges are assigned
         n_edges = len(edges)
-        if len(edges) != self.n_electrons//2:
-            raise TequilaException("number of edges need to be equal to number of active electrons//2\n{} edges given\n{} active electrons\nfrozen core is {}".format(len(edges), self.n_electrons, self.parameters.frozen_core))
+        if len(edges) != self.n_electrons // 2:
+            raise TequilaException(
+                "number of edges need to be equal to number of active electrons//2\n{} edges given\n{} active electrons\nfrozen core is {}".format(
+                    len(edges), self.n_electrons, self.parameters.frozen_core
+                )
+            )
         # making sure that orbitals are uniquely assigned to edges
         for edge_qubits in edges:
             for q1 in edge_qubits:
                 for edge2 in edges:
-                    if edge2==edge_qubits:
+                    if edge2 == edge_qubits:
                         continue
                     elif q1 in edge2:
-                        raise TequilaException("make_spa_ansatz: faulty list of edges, orbitals are overlapping e.g. orbital {} is in edge {} and edge {}".format(q1, edge_qubits, edge2))
-        
+                        raise TequilaException(
+                            "make_spa_ansatz: faulty list of edges, orbitals are overlapping e.g. orbital {} is in edge {} and edge {}".format(
+                                q1, edge_qubits, edge2
+                            )
+                        )
+
         # auto assign if the circuit construction is optimized
         # depending on the current qubit encoding (if hcb_to_me is implemnented we can optimize)
         if optimize is None:
             try:
                 have_hcb_to_me = self.hcb_to_me() is not None
-            except:
+            except Exception:
                 have_hcb_to_me = False
-            if have_hcb_to_me: 
-                optimize=True
+            if have_hcb_to_me:
+                optimize = True
             else:
-                optimize=False
+                optimize = False
 
         U = QCircuit()
-        
+        if "TAPEREDBINARY" in self.transformation.name.upper():
+            return _make_spa_tappered(
+                edges=edges, hcb=hcb, use_units_of_pi=use_units_of_pi, label=label, optimize=optimize, ladder=ladder
+            )
         # construction of the optimized circuit
         if optimize:
             # circuit in HCB representation
@@ -1087,58 +1385,50 @@ class QuantumChemistryBase:
             for edge_orbitals in edges:
                 edge_qubits = [self.transformation.up(i) for i in edge_orbitals]
                 U += gates.X(edge_qubits[0])
-                if len(edge_qubits)==1:
+                if len(edge_qubits) == 1:
                     continue
-                for i in range(1,len(edge_qubits)):
-                    q1=edge_qubits[i]
-                    c=edge_qubits[i-1]
+                for i in range(1, len(edge_qubits)):
+                    q1 = edge_qubits[i]
+                    c = edge_qubits[i - 1]
                     if not ladder:
-                        c=edge_qubits[0]
-                    angle=Variable(name=((edge_orbitals[i-1], edge_orbitals[i]), "D" ,label))
+                        c = edge_qubits[0]
+                    angle = Variable(name=((edge_orbitals[i - 1], edge_orbitals[i]), "D", label))
                     if use_units_of_pi:
-                        angle=angle*numpy.pi
-                    if i-1 == 0:
+                        angle = angle * numpy.pi
+                    if i - 1 == 0:
                         U += gates.Ry(angle=angle, target=q1, control=None)
                     else:
                         U += gates.Ry(angle=angle, target=q1, control=c)
-                    U += gates.CNOT(q1,c)
-
+                    U += gates.CNOT(q1, c)
 
             if not hcb:
                 U += self.hcb_to_me()
         else:
-            # construction of the non-optimized circuit (UpCCD with paired doubles according to edges)
+            orbs = [edge[0] for edge in edges]
             if hcb:
-                U = self.prepare_hardcore_boson_reference()
+                U = gates.X([self.transformation.up(i) for i in orbs])
             else:
-                U = self.prepare_reference()
-            # will only work if the first orbitals in the edges are the reference orbitals
-            sane = True
-            reference_orbitals = self.reference_orbitals
-            for edge_qubits in edges:
-                if self.orbitals[edge_qubits[0]] not in reference_orbitals:
-                    sane=False
-                if len(edge_qubits)>1:
-                    for q1 in edge_qubits[1:]:
-                        if self.orbitals[q1] in reference_orbitals:
-                            sane=False
-            if not sane:
-                raise TequilaException("Non-Optimized SPA (e.g. with encodings that are not JW) will only work if the first orbitals of all SPA edges are occupied reference orbitals and all others are not. You gave edges={} and reference_orbitals are {}".format(edges, reference_orbitals))
-
+                state = [0] * 2 * self.n_orbitals
+                for i in orbs:
+                    state[2 * i] = 1
+                    state[2 * i + 1] = 1
+                U = self.prepare_reference(state)
             for edge_qubits in edges:
                 previous = edge_qubits[0]
-                if len(edge_qubits)>1:
+                if len(edge_qubits) > 1:
                     for q1 in edge_qubits[1:]:
                         c = previous
                         if not ladder:
                             c = edge_qubits[0]
-                        angle = Variable(name=((c,q1), "D" ,label))
+                        angle = Variable(name=((c, q1), "D", label))
                         if use_units_of_pi:
-                            angle=angle*numpy.pi
+                            angle = angle * numpy.pi
                         if hcb:
-                            U += self.make_hardcore_boson_excitation_gate(indices=[(q1,c)],angle=angle)
+                            U += self.make_hardcore_boson_excitation_gate(indices=[(q1, c)], angle=angle)
                         else:
-                            U += self.make_excitation_gate(indices=[(2*c,2*q1),(2*c+1,2*q1+1)], angle=angle)
+                            U += self.make_excitation_gate(
+                                indices=[(2 * c, 2 * q1), (2 * c + 1, 2 * q1 + 1)], angle=angle
+                            )
                         previous = q1
         return U
 
@@ -1167,8 +1457,10 @@ class QuantumChemistryBase:
             if "label" in kwargs:
                 label = kwargs["label"]
                 kwargs.pop("label")
-            for i,subpart in enumerate(subparts[1:]):
-                U += self.make_ansatz(name=subpart, *args, label=(label,i), include_reference=False, hcb_optimization=False, **kwargs)
+            for i, subpart in enumerate(subparts[1:]):
+                U += self.make_ansatz(
+                    name=subpart, *args, label=(label, i), include_reference=False, hcb_optimization=False, **kwargs
+                )
             return U
 
         if name == "uccsd":
@@ -1178,24 +1470,27 @@ class QuantumChemistryBase:
                 hcb = False
                 if "hcb" in name.lower():
                     hcb = True
-                kwargs["hcb"]=hcb
+                kwargs["hcb"] = hcb
             return self.make_spa_ansatz(*args, **kwargs)
         elif "d" in name or "s" in name:
             return self.make_upccgsd_ansatz(name=name, *args, **kwargs)
         else:
             raise TequilaException("unknown ansatz with name={}".format(name))
 
-    def make_upccgsd_ansatz(self,
-                            include_reference: bool = True,
-                            name: str = "UpCCGSD",
-                            label: str = None,
-                            order: int = None,
-                            assume_real: bool = True,
-                            hcb_optimization: bool = None,
-                            spin_adapt_singles: bool = True,
-                            neglect_z: bool = False,
-                            mix_sd: bool = False,
-                            *args, **kwargs):
+    def make_upccgsd_ansatz(
+        self,
+        include_reference: bool = True,
+        name: str = "UpCCGSD",
+        label: str = None,
+        order: int = None,
+        assume_real: bool = True,
+        hcb_optimization: bool = None,
+        spin_adapt_singles: bool = True,
+        neglect_z: bool = False,
+        mix_sd: bool = False,
+        *args,
+        **kwargs,
+    ):
         """
         UpGCCSD Ansatz similar as described by Lee et. al.
 
@@ -1241,7 +1536,7 @@ class QuantumChemistryBase:
                     order = int(name.split("-")[0])
                 else:
                     order = 1
-            except:
+            except Exception:
                 order = 1
 
         indices = self.make_upccgsd_indices(key=name)
@@ -1251,9 +1546,8 @@ class QuantumChemistryBase:
         try:
             if self.transformation.hcb_to_me() is None:
                 have_hcb_trafo = False
-        except:
+        except Exception:
             have_hcb_trafo = False
-        
 
         # consistency checks for optimization
         if have_hcb_trafo and hcb_optimization is None and include_reference:
@@ -1262,13 +1556,17 @@ class QuantumChemistryBase:
             hcb_optimization = True
         if hcb_optimization and not have_hcb_trafo and "HCB" not in name:
             raise TequilaException(
-                "use_hcb={} but transformation={} has no \'hcb_to_me\' function. Try transformation=\'ReorderedJordanWigner\'".format(
-                    hcb_optimization, self.transformation))
+                "use_hcb={} but transformation={} has no 'hcb_to_me' function. Try transformation='ReorderedJordanWigner'".format(
+                    hcb_optimization, self.transformation
+                )
+            )
         if "S" in name and "HCB" in name:
             if "HCB" in name and "S" in name:
                 raise Exception(
                     "name={}, Singles can't be realized without mapping back to the standard encoding leave S or HCB out of the name".format(
-                        name))
+                        name
+                    )
+                )
         if hcb_optimization and mix_sd:
             raise TequilaException("Mixed SD can not be employed together with HCB Optimization")
         # convenience
@@ -1280,36 +1578,67 @@ class QuantumChemistryBase:
             U = QCircuit()
             if include_reference:
                 U = self.prepare_reference()
-            U += self.make_upccgsd_layer(include_singles=S, include_doubles=D, indices=indices, assume_real=assume_real,
-                                         label=(label, 0), mix_sd=mix_sd, spin_adapt_singles=spin_adapt_singles, *args,
-                                         **kwargs)
+            U += self.make_upccgsd_layer(
+                include_singles=S,
+                include_doubles=D,
+                indices=indices,
+                assume_real=assume_real,
+                label=(label, 0),
+                mix_sd=mix_sd,
+                spin_adapt_singles=spin_adapt_singles,
+                *args,
+                **kwargs,
+            )
         else:
             U = QCircuit()
             if include_reference:
                 U = self.prepare_hardcore_boson_reference()
             if D:
-                U += self.make_hardcore_boson_upccgd_layer(indices=indices, assume_real=assume_real, label=(label, 0),
-                                                           *args, **kwargs)
+                U += self.make_hardcore_boson_upccgd_layer(
+                    indices=indices, assume_real=assume_real, label=(label, 0), *args, **kwargs
+                )
 
             if "HCB" not in name and (include_reference or D):
                 U = self.hcb_to_me(U=U)
 
             if S:
-                U += self.make_upccgsd_singles(indices=indices, assume_real=assume_real, label=(label, 0),
-                                               spin_adapt_singles=spin_adapt_singles, neglect_z=neglect_z, *args,
-                                               **kwargs)
+                U += self.make_upccgsd_singles(
+                    indices=indices,
+                    assume_real=assume_real,
+                    label=(label, 0),
+                    spin_adapt_singles=spin_adapt_singles,
+                    neglect_z=neglect_z,
+                    *args,
+                    **kwargs,
+                )
 
         for k in range(1, order):
-            U += self.make_upccgsd_layer(include_singles=S, include_doubles=D, indices=indices, label=(label, k),
-                                         spin_adapt_singles=spin_adapt_singles, neglect_z=neglect_z, mix_sd=mix_sd)
+            U += self.make_upccgsd_layer(
+                include_singles=S,
+                include_doubles=D,
+                indices=indices,
+                label=(label, k),
+                spin_adapt_singles=spin_adapt_singles,
+                neglect_z=neglect_z,
+                mix_sd=mix_sd,
+            )
 
         return U
 
-    def make_upccgsd_layer(self, indices, include_singles: bool = True, include_doubles: bool = True,
-                           assume_real: bool = True, label=None,
-                           spin_adapt_singles: bool = True, angle_transform=None, mix_sd: bool = False,
-                           neglect_z: bool = False, *args,
-                           **kwargs):
+    def make_upccgsd_layer(
+        self,
+        indices,
+        include_singles: bool = True,
+        include_doubles: bool = True,
+        assume_real: bool = True,
+        label=None,
+        spin_adapt_singles: bool = True,
+        angle_transform=None,
+        mix_sd: bool = False,
+        neglect_z: bool = False,
+        *args,
+        **kwargs,
+    ):
         U = QCircuit()
         for idx in indices:
             assert len(idx) == 1
@@ -1318,29 +1647,56 @@ class QuantumChemistryBase:
             if include_doubles:
                 if "jordanwigner" in self.transformation.name.lower() and not self.transformation.up_then_down:
                     # we can optimize with qubit excitations for the JW representation
-                    target = [self.transformation.up(idx[0]), self.transformation.up(idx[1]),
-                              self.transformation.down(idx[0]), self.transformation.down(idx[1])]
+                    target = [
+                        self.transformation.up(idx[0]),
+                        self.transformation.up(idx[1]),
+                        self.transformation.down(idx[0]),
+                        self.transformation.down(idx[1]),
+                    ]
                     U += gates.QubitExcitation(angle=angle, target=target, assume_real=assume_real, **kwargs)
                 else:
-                    U += self.make_excitation_gate(angle=angle,
-                                                   indices=((2 * idx[0], 2 * idx[1]), (2 * idx[0] + 1, 2 * idx[1] + 1)),
-                                                   assume_real=assume_real, **kwargs)
+                    U += self.make_excitation_gate(
+                        angle=angle,
+                        indices=((2 * idx[0], 2 * idx[1]), (2 * idx[0] + 1, 2 * idx[1] + 1)),
+                        assume_real=assume_real,
+                        **kwargs,
+                    )
             if include_singles and mix_sd:
-                U += self.make_upccgsd_singles(indices=[(idx,)], assume_real=assume_real, label=label,
-                                               spin_adapt_singles=spin_adapt_singles, angle_transform=angle_transform,
-                                               neglect_z=neglect_z)
+                U += self.make_upccgsd_singles(
+                    indices=[(idx,)],
+                    assume_real=assume_real,
+                    label=label,
+                    spin_adapt_singles=spin_adapt_singles,
+                    angle_transform=angle_transform,
+                    neglect_z=neglect_z,
+                )
 
         if include_singles and not mix_sd:
-            U += self.make_upccgsd_singles(indices=indices, assume_real=assume_real, label=label,
-                                           spin_adapt_singles=spin_adapt_singles, angle_transform=angle_transform,
-                                           neglect_z=neglect_z)
+            U += self.make_upccgsd_singles(
+                indices=indices,
+                assume_real=assume_real,
+                label=label,
+                spin_adapt_singles=spin_adapt_singles,
+                angle_transform=angle_transform,
+                neglect_z=neglect_z,
+            )
         return U
 
-    def make_upccgsd_singles(self, indices="UpCCGSD", spin_adapt_singles=True, label=None, angle_transform=None,
-                             assume_real=True, neglect_z=False, *args, **kwargs):
+    def make_upccgsd_singles(
+        self,
+        indices="UpCCGSD",
+        spin_adapt_singles=True,
+        label=None,
+        angle_transform=None,
+        assume_real=True,
+        neglect_z=False,
+        *args,
+        **kwargs,
+    ):
         if neglect_z and "jordanwigner" not in self.transformation.name.lower():
             raise TequilaException(
-                "neglegt-z approximation in UpCCGSD singles needs the (Reversed)JordanWigner representation")
+                "neglegt-z approximation in UpCCGSD singles needs the (Reversed)JordanWigner representation"
+            )
         if hasattr(indices, "lower"):
             indices = self.make_upccgsd_indices(key=indices)
 
@@ -1358,10 +1714,12 @@ class QuantumChemistryBase:
                     U += gates.QubitExcitation(angle=angle, target=targeta, assume_real=assume_real, **kwargs)
                     U += gates.QubitExcitation(angle=angle, target=targetb, assume_real=assume_real, **kwargs)
                 else:
-                    U += self.make_excitation_gate(angle=angle, indices=[(2 * idx[0], 2 * idx[1])],
-                                                   assume_real=assume_real, **kwargs)
-                    U += self.make_excitation_gate(angle=angle, indices=[(2 * idx[0] + 1, 2 * idx[1] + 1)],
-                                                   assume_real=assume_real, **kwargs)
+                    U += self.make_excitation_gate(
+                        angle=angle, indices=[(2 * idx[0], 2 * idx[1])], assume_real=assume_real, **kwargs
+                    )
+                    U += self.make_excitation_gate(
+                        angle=angle, indices=[(2 * idx[0] + 1, 2 * idx[1] + 1)], assume_real=assume_real, **kwargs
+                    )
             else:
                 angle1 = (idx, "SU", label)
                 angle2 = (idx, "SD", label)
@@ -1374,21 +1732,27 @@ class QuantumChemistryBase:
                     U += gates.QubitExcitation(angle=angle1, target=targeta, assume_real=assume_real, *kwargs)
                     U += gates.QubitExcitation(angle=angle2, target=targetb, assume_real=assume_real, *kwargs)
                 else:
-                    U += self.make_excitation_gate(angle=angle1, indices=[(2 * idx[0], 2 * idx[1])],
-                                                   assume_real=assume_real, **kwargs)
-                    U += self.make_excitation_gate(angle=angle2, indices=[(2 * idx[0] + 1, 2 * idx[1] + 1)],
-                                                   assume_real=assume_real, **kwargs)
+                    U += self.make_excitation_gate(
+                        angle=angle1, indices=[(2 * idx[0], 2 * idx[1])], assume_real=assume_real, **kwargs
+                    )
+                    U += self.make_excitation_gate(
+                        angle=angle2, indices=[(2 * idx[0] + 1, 2 * idx[1] + 1)], assume_real=assume_real, **kwargs
+                    )
 
         return U
 
-    def make_uccsd_ansatz(self, trotter_steps: int = 1,
-                          initial_amplitudes: typing.Union[str, Amplitudes, ClosedShellAmplitudes] = None,
-                          include_reference_ansatz=True,
-                          parametrized=True,
-                          threshold=1.e-8,
-                          add_singles=None,
-                          screening=True,
-                          *args, **kwargs) -> QCircuit:
+    def make_uccsd_ansatz(
+        self,
+        trotter_steps: int = 1,
+        initial_amplitudes: typing.Union[str, Amplitudes, ClosedShellAmplitudes] = None,
+        include_reference_ansatz=True,
+        parametrized=True,
+        threshold=1.0e-8,
+        add_singles=None,
+        screening=True,
+        *args,
+        **kwargs,
+    ) -> QCircuit:
         """
 
         Parameters
@@ -1420,8 +1784,9 @@ class QuantumChemistryBase:
             if initial_amplitudes.lower() == "mp2" and add_singles is None:
                 add_singles = True
         elif initial_amplitudes is not None and add_singles is not None:
-            warnings.warn("make_uccsd_anstatz: add_singles has no effect when explicit amplitudes are passed down",
-                          TequilaWarning)
+            warnings.warn(
+                "make_uccsd_anstatz: add_singles has no effect when explicit amplitudes are passed down", TequilaWarning
+            )
         elif add_singles is None:
             add_singles = True
 
@@ -1446,13 +1811,13 @@ class QuantumChemistryBase:
                     amplitudes = self.compute_amplitudes(method=initial_amplitudes.lower())
                 except Exception as exc:
                     raise TequilaException(
-                        "{}\nDon't know how to initialize \'{}\' amplitudes".format(exc, initial_amplitudes))
+                        "{}\nDon't know how to initialize '{}' amplitudes".format(exc, initial_amplitudes)
+                    )
         if amplitudes is None:
             tia = None
-            if add_singles: tia = numpy.zeros(shape=[nocc, nvirt])
-            amplitudes = ClosedShellAmplitudes(
-                tIjAb=numpy.zeros(shape=[nocc, nocc, nvirt, nvirt]),
-                tIA=tia)
+            if add_singles:
+                tia = numpy.zeros(shape=[nocc, nvirt])
+            amplitudes = ClosedShellAmplitudes(tIjAb=numpy.zeros(shape=[nocc, nocc, nvirt, nvirt]), tIA=tia)
             screening = False
 
         closed_shell = isinstance(amplitudes, ClosedShellAmplitudes)
@@ -1465,10 +1830,9 @@ class QuantumChemistryBase:
             amplitudes = amplitudes.make_parameter_dictionary(threshold=threshold, screening=screening)
             amplitudes = dict(sorted(amplitudes.items(), key=lambda x: numpy.fabs(x[1]), reverse=True))
         for key, t in amplitudes.items():
-            assert (len(key) % 2 == 0)
+            assert len(key) % 2 == 0
             if not numpy.isclose(t, 0.0, atol=threshold) or not screening:
                 if closed_shell:
-
                     if len(key) == 2 and add_singles:
                         # singles
                         angle = 2.0 * t
@@ -1503,8 +1867,12 @@ class QuantumChemistryBase:
             for idx, angle in indices.items():
                 converted = [(idx[2 * i], idx[2 * i + 1]) for i in range(len(idx) // 2)]
                 UCCSD += self.make_excitation_gate(indices=converted, angle=factor * angle)
-        if hasattr(initial_amplitudes,
-                   "lower") and initial_amplitudes.lower() == "mp2" and parametrized and add_singles:
+        if (
+            hasattr(initial_amplitudes, "lower")
+            and initial_amplitudes.lower() == "mp2"
+            and parametrized
+            and add_singles
+        ):
             # mp2 has no singles, need to initialize them here (if not parametrized initializling as 0.0 makes no sense though)
             UCCSD += self.make_upccgsd_layer(indices="upccsd", include_singles=True, include_doubles=False)
         return Uref + UCCSD
@@ -1559,16 +1927,23 @@ class QuantumChemistryBase:
                 H = self.make_hamiltonian()
             E = ExpectationValue(H=H, U=U)
             from tequila import minimize
+
             return minimize(objective=E, *args, **kwargs).energy
         else:
             from tequila.quantumchemistry import INSTALLED_QCHEMISTRY_BACKENDS
+
             if "pyscf" not in INSTALLED_QCHEMISTRY_BACKENDS:
                 raise TequilaException(
-                    "PySCF needs to be installed to compute {}/{}".format(method, self.parameters.basis_set))
+                    "PySCF needs to be installed to compute {}/{}".format(method, self.parameters.basis_set)
+                )
             else:
                 from tequila.quantumchemistry import QuantumChemistryPySCF
+
                 molx = QuantumChemistryPySCF.from_tequila(self)
-                return molx.compute_energy(method=method)
+                return molx.compute_energy(method=method, **kwargs)
+
+    def compute_fci(self, *args, **kwargs):
+        raise NotImplementedError("compute_fci only implemented for the 'pyscf' backend")
 
     def compute_fock_matrix(self):
         c, h, g = self.get_integrals()
@@ -1579,10 +1954,10 @@ class QuantumChemistryBase:
         F = numpy.zeros(shape=h.shape)
         for k in range(F.shape[0]):
             for l in range(F.shape[1]):
-                tmp = h[k,l]
+                tmp = h[k, l]
                 for ii in self.reference_orbitals:
                     i = ii.idx
-                    tmp += (2.0*g.elems[k, i, l, i] - g.elems[k, i, i, l])
+                    tmp += 2.0 * g.elems[k, i, l, i] - g.elems[k, i, i, l]
                 F[k, l] = tmp
         return F
 
@@ -1603,7 +1978,7 @@ class QuantumChemistryBase:
         -------
 
         """
-        c,h,g = self.get_integrals()
+        c, h, g = self.get_integrals()
         fi = self.compute_fock_matrix()
         self.is_canonical(verify=True, fock_matrix=fi)
         fi = numpy.diag(fi)
@@ -1612,13 +1987,18 @@ class QuantumChemistryBase:
         ei = fi[:nocc]
         ai = fi[nocc:]
         abgij = g.elems[nocc:, nocc:, :nocc, :nocc]
-        amplitudes = abgij * 1.0 / (
-                ei.reshape(1, 1, -1, 1) + ei.reshape(1, 1, 1, -1) - ai.reshape(-1, 1, 1, 1) - ai.reshape(1, -1, 1, 1))
+        amplitudes = (
+            abgij
+            * 1.0
+            / (ei.reshape(1, 1, -1, 1) + ei.reshape(1, 1, 1, -1) - ai.reshape(-1, 1, 1, 1) - ai.reshape(1, -1, 1, 1))
+        )
 
-        result = ClosedShellAmplitudes(tIjAb=numpy.einsum('abij -> ijab', amplitudes, optimize='greedy'))
+        result = ClosedShellAmplitudes(tIjAb=numpy.einsum("abij -> ijab", amplitudes, optimize="greedy"))
 
         if return_energy:
-            E = 2.0 * numpy.einsum('abij,abij->', amplitudes, abgij) - numpy.einsum('abji,abij', amplitudes, abgij,optimize='greedy')
+            E = 2.0 * numpy.einsum("abij,abij->", amplitudes, abgij) - numpy.einsum(
+                "abji,abij", amplitudes, abgij, optimize="greedy"
+            )
             return result, E
         else:
             return result
@@ -1632,6 +2012,7 @@ class QuantumChemistryBase:
         @dataclass
         class ResultCIS:
             """ """
+
             omegas: typing.List[numbers.Real]  # excitation energies [omega0, ...]
             amplitudes: typing.List[ClosedShellAmplitudes]  # corresponding amplitudes [x_{ai}_0, ...]
 
@@ -1693,7 +2074,9 @@ class QuantumChemistryBase:
         if fock_matrix is None:
             fock_matrix = self.compute_fock_matrix()
 
-        is_diagonal = numpy.isclose(numpy.linalg.norm(fock_matrix - numpy.diag(numpy.diag(fock_matrix))), 0.0, atol=1.e-4)
+        is_diagonal = numpy.isclose(
+            numpy.linalg.norm(fock_matrix - numpy.diag(numpy.diag(fock_matrix))), 0.0, atol=1.0e-4
+        )
 
         if not is_diagonal:
             canonical = False
@@ -1707,14 +2090,17 @@ class QuantumChemistryBase:
                 canonical = False
 
         if verify and not canonical:
-            data={"reference_orbitals":refo, "fock_matrix":fock_matrix}
+            data = {"reference_orbitals": refo, "fock_matrix": fock_matrix}
             raise TequilaException(
-                "orbitals are not canonical or can not be verified as such -> implemented method only works for standard orbitals (preferably from psi4)\n{}".format(data))
+                "orbitals are not canonical or can not be verified as such -> implemented method only works for standard orbitals (preferably from psi4)\n{}".format(
+                    data
+                )
+            )
         return canonical
 
     @property
     def rdm1(self):
-        """ 
+        """
         Returns RMD1 if computed with compute_rdms function before
         """
         if self._rdm1 is not None:
@@ -1735,9 +2121,18 @@ class QuantumChemistryBase:
             print("2-RDM has not been computed. Return None for 2-RDM.")
             return None
 
-    def compute_rdms(self, U: QCircuit = None, variables: Variables = None, spin_free: bool = True,
-                     get_rdm1: bool = True, get_rdm2: bool = True, ordering="dirac", use_hcb: bool = False,
-                     rdm_trafo: QubitHamiltonian = None, evaluate=True):
+    def compute_rdms(
+        self,
+        U: QCircuit = None,
+        variables: Variables = None,
+        spin_free: bool = True,
+        get_rdm1: bool = True,
+        get_rdm2: bool = True,
+        ordering="dirac",
+        use_hcb: bool = False,
+        rdm_trafo: QubitHamiltonian = None,
+        evaluate=True,
+    ):
         """
         Computes the one- and two-particle reduced density matrices (rdm1 and rdm2) given
         a unitary U. This method uses the standard ordering in physics as denoted below.
@@ -1777,45 +2172,54 @@ class QuantumChemistryBase:
         """
         # Check whether unitary circuit is not 0
         if U is None:
-            raise TequilaException('Need to specify a Quantum Circuit.')
+            raise TequilaException("Need to specify a Quantum Circuit.")
         # Check whether transformation is BKSF.
         # Issue here: when a single operator acts only on a subset of qubits, BKSF might not yield the correct
         # transformation, because it computes the number of qubits incorrectly in this case.
         # A hotfix such as for symmetry_conserving_bravyi_kitaev would require deeper changes, thus omitted for now
         if type(self.transformation).__name__ == "BravyiKitaevFast":
             raise TequilaException(
-                "The Bravyi-Kitaev-Superfast transformation does not support general FermionOperators yet.")
+                "The Bravyi-Kitaev-Superfast transformation does not support general FermionOperators yet."
+            )
         # Set up number of spin-orbitals and molecular orbitals respectively
         n_SOs = 2 * self.n_orbitals
         n_MOs = self.n_orbitals
 
         # Check whether unitary circuit is not 0
         if U is None:
-            raise TequilaException('Need to specify a Quantum Circuit.')
+            raise TequilaException("Need to specify a Quantum Circuit.")
 
         def _get_hcb_op(op_tuple):
-            '''Build the hardcore boson operators: b^\dagger_ib_j + h.c. in qubit encoding '''
-            if (len(op_tuple) == 2):
+            """Build the hardcore boson operators: b^\dagger_ib_j + h.c. in qubit encoding"""
+            if len(op_tuple) == 2:
                 return 2 * Sm(op_tuple[0][0]) * Sp(op_tuple[1][0])
-            elif (len(op_tuple) == 4):
-                if ((op_tuple[0][0] == op_tuple[1][0]) and (op_tuple[2][0] == op_tuple[3][0])):  # iijj uddu+duud
+            elif len(op_tuple) == 4:
+                if (op_tuple[0][0] == op_tuple[1][0]) and (op_tuple[2][0] == op_tuple[3][0]):  # iijj uddu+duud
                     return Sm(op_tuple[0][0]) * Sp(op_tuple[2][0]) + Sm(op_tuple[2][0]) * Sp(op_tuple[0][0])
-                if ((op_tuple[0][0] == op_tuple[2][0]) and (op_tuple[1][0] == op_tuple[3][0]) and (
-                        op_tuple[0][0] != op_tuple[1][0]) and (op_tuple[2][0] != op_tuple[3][0])):  # ijij uuuu+dddd
+                if (
+                    (op_tuple[0][0] == op_tuple[2][0])
+                    and (op_tuple[1][0] == op_tuple[3][0])
+                    and (op_tuple[0][0] != op_tuple[1][0])
+                    and (op_tuple[2][0] != op_tuple[3][0])
+                ):  # ijij uuuu+dddd
                     return 4 * Sm(op_tuple[0][0]) * Sm(op_tuple[1][0]) * Sp(op_tuple[2][0]) * Sp(op_tuple[3][0])
-                if ((op_tuple[0][0] == op_tuple[3][0]) and (op_tuple[1][0] == op_tuple[2][0]) and (
-                        op_tuple[0][0] != op_tuple[1][0]) and (op_tuple[2][0] != op_tuple[3][0])):  # ijji abba
+                if (
+                    (op_tuple[0][0] == op_tuple[3][0])
+                    and (op_tuple[1][0] == op_tuple[2][0])
+                    and (op_tuple[0][0] != op_tuple[1][0])
+                    and (op_tuple[2][0] != op_tuple[3][0])
+                ):  # ijji abba
                     return -2 * Sm(op_tuple[0][0]) * Sm(op_tuple[1][0]) * Sp(op_tuple[2][0]) * Sp(op_tuple[3][0])
             else:
                 return Zero()
 
         def _get_of_op(operator_tuple):
-            """ Returns operator given by a operator tuple as OpenFermion - Fermion operator """
+            """Returns operator given by a operator tuple as OpenFermion - Fermion operator"""
             op = openfermion.FermionOperator(operator_tuple)
             return op
 
         def _get_qop_hermitian(of_operator) -> QubitHamiltonian:
-            """ Returns Hermitian part of Fermion operator as QubitHamiltonian """
+            """Returns Hermitian part of Fermion operator as QubitHamiltonian"""
             qop = self.transformation(of_operator)
             # qop = QubitHamiltonian(self.transformation(of_operator))
             real, imag = qop.split(hermitian=True)
@@ -1823,10 +2227,11 @@ class QuantumChemistryBase:
                 return real
             elif not real:
                 raise TequilaException(
-                    "Qubit Hamiltonian does not have a Hermitian part. Operator ={}".format(of_operator))
+                    "Qubit Hamiltonian does not have a Hermitian part. Operator ={}".format(of_operator)
+                )
 
         def _build_1bdy_operators_spinful() -> list:
-            """ Returns spinful one-body operators as a symmetry-reduced list of QubitHamiltonians """
+            """Returns spinful one-body operators as a symmetry-reduced list of QubitHamiltonians"""
             # Exploit symmetry pq = qp
             ops = []
             for p in range(n_SOs):
@@ -1838,7 +2243,7 @@ class QuantumChemistryBase:
             return ops
 
         def _build_2bdy_operators_spinful() -> list:
-            """ Returns spinful two-body operators as a symmetry-reduced list of QubitHamiltonians """
+            """Returns spinful two-body operators as a symmetry-reduced list of QubitHamiltonians"""
             # Exploit symmetries pqrs = -pqsr = -qprs = qpsr
             #                and      =  rspq
             ops = []
@@ -1854,7 +2259,7 @@ class QuantumChemistryBase:
             return ops
 
         def _build_1bdy_operators_spinfree() -> list:
-            """ Returns spinfree one-body operators as a symmetry-reduced list of QubitHamiltonians """
+            """Returns spinfree one-body operators as a symmetry-reduced list of QubitHamiltonians"""
             # Exploit symmetry pq = qp (not changed by spin-summation)
             ops = []
             for p in range(n_MOs):
@@ -1870,26 +2275,35 @@ class QuantumChemistryBase:
             return ops
 
         def _build_2bdy_operators_spinfree() -> list:
-            """ Returns spinfree two-body operators as a symmetry-reduced list of QubitHamiltonians """
+            """Returns spinfree two-body operators as a symmetry-reduced list of QubitHamiltonians"""
             # Exploit symmetries pqrs = qpsr (due to spin summation, '-pqsr = -qprs' drops out)
             #                and      = rspq
             ops = []
             for p, q, r, s in product(range(n_MOs), repeat=4):
                 if p * n_MOs + q >= r * n_MOs + s and (p >= q or r >= s):
                     # Spin aaaa
-                    op_tuple = ((2 * p, 1), (2 * q, 1), (2 * s, 0), (2 * r, 0)) if (p != q and r != s) else '0.0 []'
+                    op_tuple = ((2 * p, 1), (2 * q, 1), (2 * s, 0), (2 * r, 0)) if (p != q and r != s) else "0.0 []"
                     op = _get_of_op(op_tuple)
                     # Spin abab
-                    op_tuple = ((2 * p, 1), (2 * q + 1, 1), (2 * s + 1, 0), (2 * r, 0)) if (
-                            2 * p != 2 * q + 1 and 2 * r != 2 * s + 1) else '0.0 []'
+                    op_tuple = (
+                        ((2 * p, 1), (2 * q + 1, 1), (2 * s + 1, 0), (2 * r, 0))
+                        if (2 * p != 2 * q + 1 and 2 * r != 2 * s + 1)
+                        else "0.0 []"
+                    )
                     op += _get_of_op(op_tuple)
                     # Spin baba
-                    op_tuple = ((2 * p + 1, 1), (2 * q, 1), (2 * s, 0), (2 * r + 1, 0)) if (
-                            2 * p + 1 != 2 * q and 2 * r + 1 != 2 * s) else '0.0 []'
+                    op_tuple = (
+                        ((2 * p + 1, 1), (2 * q, 1), (2 * s, 0), (2 * r + 1, 0))
+                        if (2 * p + 1 != 2 * q and 2 * r + 1 != 2 * s)
+                        else "0.0 []"
+                    )
                     op += _get_of_op(op_tuple)
                     # Spin bbbb
-                    op_tuple = ((2 * p + 1, 1), (2 * q + 1, 1), (2 * s + 1, 0), (2 * r + 1, 0)) if (
-                            p != q and r != s) else '0.0 []'
+                    op_tuple = (
+                        ((2 * p + 1, 1), (2 * q + 1, 1), (2 * s + 1, 0), (2 * r + 1, 0))
+                        if (p != q and r != s)
+                        else "0.0 []"
+                    )
                     op += _get_of_op(op_tuple)
                     ops += [op]
             return ops
@@ -1913,7 +2327,7 @@ class QuantumChemistryBase:
             return rdm1
 
         def _assemble_rdm2_spinful(evals, rdm2=None) -> numpy.ndarray:
-            """ Returns spin-ful two-particle RDM built by symmetry conditions """
+            """Returns spin-ful two-particle RDM built by symmetry conditions"""
             ctr: int = 0
             if rdm2 is None:
                 rdm2 = numpy.zeros([n_SOs, n_SOs, n_SOs, n_SOs])
@@ -1939,7 +2353,7 @@ class QuantumChemistryBase:
             return rdm2
 
         def _assemble_rdm2_spinfree(evals, rdm2=None) -> numpy.ndarray:
-            """ Returns spin-free two-particle RDM built by symmetry conditions """
+            """Returns spin-free two-particle RDM built by symmetry conditions"""
             ctr: int = 0
             if rdm2 is None:
                 rdm2 = numpy.zeros([n_MOs, n_MOs, n_MOs, n_MOs])
@@ -1958,13 +2372,13 @@ class QuantumChemistryBase:
             return rdm2
 
         def _build_1bdy_operators_hcb() -> list:
-            """ Returns hcb one-body operators as a symmetry-reduced list of QubitHamiltonians """
+            """Returns hcb one-body operators as a symmetry-reduced list of QubitHamiltonians"""
             # Exploit symmetry pq = qp (not changed by spin-summation)
             ops = []
             for p in range(n_MOs):
                 for q in range(p + 1):
-                    if (p == q):
-                        if (self.transformation.up_then_down):
+                    if p == q:
+                        if self.transformation.up_then_down:
                             op_tuple = ((p, 1), (p, 0))
                             op = _get_hcb_op(op_tuple)
                         else:
@@ -1976,7 +2390,7 @@ class QuantumChemistryBase:
             return ops
 
         def _build_2bdy_operators_hcb() -> list:
-            """ Returns hcb two-body operators as a symmetry-reduced list of QubitHamiltonians """
+            """Returns hcb two-body operators as a symmetry-reduced list of QubitHamiltonians"""
             # Exploit symmetries pqrs = qpsr (due to spin summation, '-pqsr = -qprs' drops out)
             #                and      = rspq
             ops = []
@@ -1986,16 +2400,25 @@ class QuantumChemistryBase:
             for p, q, r, s in product(range(n_MOs), repeat=4):
                 if p * n_MOs + q >= r * n_MOs + s and (p >= q or r >= s):
                     # Spin abba+ baab allow p=q=r=s orb iijj
-                    op_tuple = ((scale * p, 1), (scale * q, 1), (scale * r, 0), (scale * s, 0)) if (
-                            p == q and s == r) else '0.0 []'
+                    op_tuple = (
+                        ((scale * p, 1), (scale * q, 1), (scale * r, 0), (scale * s, 0))
+                        if (p == q and s == r)
+                        else "0.0 []"
+                    )
                     op = _get_hcb_op(op_tuple)
                     # Spin abba+ baab dont allow p=q=r=s orb ijij
-                    op_tuple = ((scale * p, 1), (scale * q, 1), (scale * r, 0), (scale * s, 0)) if (
-                            p != q and r != s and p == r and s == q) else '0.0 []'
+                    op_tuple = (
+                        ((scale * p, 1), (scale * q, 1), (scale * r, 0), (scale * s, 0))
+                        if (p != q and r != s and p == r and s == q)
+                        else "0.0 []"
+                    )
                     op += _get_hcb_op(op_tuple)
                     # Spin aaaa+ bbbb dont allow p=q=r=s  orb ijji
-                    op_tuple = ((scale * p, 1), (scale * q, 1), (scale * r, 0), (scale * s, 0)) if (
-                            p != q and r != s and p == s and q == r) else '0.0 []'
+                    op_tuple = (
+                        ((scale * p, 1), (scale * q, 1), (scale * r, 0), (scale * s, 0))
+                        if (p != q and r != s and p == s and q == r)
+                        else "0.0 []"
+                    )
                     op += _get_hcb_op(op_tuple)
                     ops += [op]
             return ops
@@ -2011,29 +2434,31 @@ class QuantumChemistryBase:
         else:
             if use_hcb:
                 raise TequilaException(
-                    "compute_rdms: spin_free={} and use_hcb={} are not compatible".format(spin_free, use_hcb))
+                    "compute_rdms: spin_free={} and use_hcb={} are not compatible".format(spin_free, use_hcb)
+                )
             qops += _build_1bdy_operators_spinful() if get_rdm1 else []
             qops += _build_2bdy_operators_spinful() if get_rdm2 else []
 
         # Transform operator lists to QubitHamiltonians
-        if (not use_hcb):
+        if not use_hcb:
             qops = [_get_qop_hermitian(op) for op in qops]
 
         # Compute expected values
         rdm1 = None
         rdm2 = None
         from tequila import QTensor
+
         if evaluate:
             if rdm_trafo is None:
                 evals = simulate(ExpectationValue(H=qops, U=U, shape=[len(qops)]), variables=variables)
             else:
-                qops = [rdm_trafo.dagger()*qops[i]*rdm_trafo for i in range(len(qops))]
+                qops = [rdm_trafo.dagger() * qops[i] * rdm_trafo for i in range(len(qops))]
                 evals = simulate(ExpectationValue(H=qops, U=U, shape=[len(qops)]), variables=variables)
         else:
             if rdm_trafo is None:
                 evals = [ExpectationValue(H=x, U=U) for x in qops]
                 N = n_MOs if spin_free else n_SOs
-                rdm1 = QTensor(shape=[N,N])
+                rdm1 = QTensor(shape=[N, N])
                 rdm2 = QTensor(shape=[N, N, N, N])
             else:
                 raise TequilaException("compute_rdms: rdm_trafo was set but evaluate flag is False (not supported)")
@@ -2133,9 +2558,15 @@ class QuantumChemistryBase:
 
         return rdm1_spinsum, rdm2_spinsum
 
-    def perturbative_f12_correction(self, rdm1: numpy.ndarray = None, rdm2: numpy.ndarray = None,
-                                    gamma: float = 1.4, n_ri: int = None,
-                                    external_info: dict = None, **kwargs) -> float:
+    def perturbative_f12_correction(
+        self,
+        rdm1: numpy.ndarray = None,
+        rdm2: numpy.ndarray = None,
+        gamma: float = 1.4,
+        n_ri: int = None,
+        external_info: dict = None,
+        **kwargs,
+    ) -> float:
         """
         Computes the spin-free [2]_R12 correction, needing only the 1- and 2-RDM of a reference method
         Requires either 1-RDM, 2-RDM or information to compute them in kwargs
@@ -2165,12 +2596,14 @@ class QuantumChemistryBase:
             the f12 correction for the energy
         """
         from .f12_corrections._f12_correction_base import ExplicitCorrelationCorrection
-        correction = ExplicitCorrelationCorrection(mol=self, rdm1=rdm1, rdm2=rdm2, gamma=gamma,
-                                                   n_ri=n_ri, external_info=external_info, **kwargs)
+
+        correction = ExplicitCorrelationCorrection(
+            mol=self, rdm1=rdm1, rdm2=rdm2, gamma=gamma, n_ri=n_ri, external_info=external_info, **kwargs
+        )
         return correction.compute()
 
     def n_rotation(self, i, phi):
-        '''
+        """
         Creates a quantum circuit that applies a phase rotation based on phi to both components (up and down) of a given qubit.
 
         Parameters:
@@ -2179,21 +2612,21 @@ class QuantumChemistryBase:
 
         Returns:
         - QCircuit: A quantum circuit object containing the sequence of rotations applied to the up and down components of the specified qubit.
-        '''
+        """
 
         # Generate number operators for the up and down components of the qubit.
-        n_up = self.make_number_op(2*i)
-        n_down = self.make_number_op(2*i+1)
+        n_up = self.make_number_op(2 * i)
+        n_down = self.make_number_op(2 * i + 1)
 
         # Start a new circuit and apply rotations to each component.
-        circuit = gates.GeneralizedRotation(generator = n_up, angle=-2*phi)
-        circuit += gates.GeneralizedRotation(generator = n_down, angle=-2*phi)
+        circuit = gates.GeneralizedRotation(generator=n_up, angle=-2 * phi)
+        circuit += gates.GeneralizedRotation(generator=n_down, angle=-2 * phi)
         return circuit
-        
-    def get_givens_circuit(self, unitary, tol = 1e-12, ordering = OPTIMIZED_ORDERING):
-        '''
+
+    def get_givens_circuit(self, unitary, tol=1e-12, ordering=OPTIMIZED_ORDERING):
+        """
         Constructs a quantum circuit from a given real unitary matrix using Givens rotations.
-        
+
         This method decomposes a unitary matrix into a series of Givens and Rz (phase) rotations,
         then constructs and returns a quantum circuit that implements this sequence of rotations.
 
@@ -2204,7 +2637,7 @@ class QuantumChemistryBase:
 
         Returns:
         - QCircuit: A quantum circuit implementing the series of rotations decomposed from the unitary.
-        '''
+        """
         # Decompose the unitary matrix into Givens and phase (Rz) rotations.
         theta_list, phi_list = get_givens_decomposition(unitary, tol, ordering)
 
@@ -2217,11 +2650,10 @@ class QuantumChemistryBase:
 
         # Add all Givens rotations to the circuit.
         for theta in reversed(theta_list):
-            circuit += self.UR(theta[1], theta[2], theta[0]*2)
+            circuit += self.UR(theta[1], theta[2], theta[0] * 2)
 
         return circuit
 
-
     def print_basis_info(self):
         return self.integral_manager.print_basis_info()
 
@@ -2242,11 +2674,12 @@ class QuantumChemistryBase:
 
         return result
 
+
 def givens_matrix(n, p, q, theta):
-    '''
+    """
     Construct a complex Givens rotation matrix of dimension n by theta between rows/columns p and q.
-    '''
-    '''
+    """
+    """
     Generates a Givens rotation matrix of size n x n to rotate by angle theta in the (p, q) plane. This matrix can be complex
 
     Parameters:
@@ -2257,10 +2690,14 @@ def givens_matrix(n, p, q, theta):
 
     Returns:
     - numpy.array: The Givens rotation matrix.
-    '''
-    matrix = numpy.eye(n)  # Matrix to hold complex numbers
-    cos_theta = numpy.cos(theta)
-    sin_theta = numpy.sin(theta)
+    """
+    matrix = QTensor(shape=(n, n), objective_list=numpy.eye(n).reshape(n * n))  # Matrix to hold complex numbers
+    if isinstance(theta, (Variable, Objective)):
+        cos_theta = theta.apply(numpy.cos)
+        sin_theta = theta.apply(numpy.sin)
+    else:
+        cos_theta = numpy.cos(theta)
+        sin_theta = numpy.sin(theta)
 
     # Directly assign cosine and sine without complex phase adjustment
     matrix[p, p] = cos_theta
@@ -2270,8 +2707,9 @@ def givens_matrix(n, p, q, theta):
 
     return matrix
 
-def get_givens_decomposition(unitary, tol = 1e-12, ordering = OPTIMIZED_ORDERING, return_diagonal = False):
-    '''
+
+def get_givens_decomposition(unitary, tol=1e-12, ordering=OPTIMIZED_ORDERING, return_diagonal=False):
+    """
     Decomposes a real unitary matrix into Givens rotations (theta) and Rz rotations (phi).
 
     Parameters:
@@ -2284,9 +2722,9 @@ def get_givens_decomposition(unitary, tol = 1e-12, ordering = OPTIMIZED_ORDERING
     - list: A list of tuples, each representing a Givens rotation. Each tuple contains the rotation angle theta and indices (i,j) of the rotation.
     - list: A list of tuples, each representing an Rz rotation. Each tuple contains the rotation angle phi and the index (i) of the rotation.
     - numpy.array (optional): The diagonal matrix after applying all Givens rotations, returned if return_diagonal is True.
-    '''
-    U = unitary # no need to copy as we don't modify the original
-    U[abs(U) < tol] = 0 # Zeroing out the small elements as per the tolerance level.
+    """
+    U = unitary  # no need to copy as we don't modify the original
+    # U[abs(U) < tol] = 0 # Zeroing out the small elements as per the tolerance level. #comented out, its being considered latter again
     n = U.shape[0]
 
     # Determine optimized ordering if specified.
@@ -2297,48 +2735,53 @@ def get_givens_decomposition(unitary, tol = 1e-12, ordering = OPTIMIZED_ORDERING
     phi_list = []
 
     def calcTheta(U, c, r):
-        '''Calculate and apply the Givens rotation for a specific matrix element.'''
-        t = numpy.arctan2(-U[r,c], U[r-1,c])
-        theta_list.append((t, r, r-1))
-        g = givens_matrix(n,r,r-1,t)
-        U = numpy.dot(g, U)
-
+        """Calculate and apply the Givens rotation for a specific matrix element."""
+        t = arctan2(-U[r, c], U[r - 1, c])
+        theta_list.append((t, r, r - 1))
+        g = givens_matrix(n, r, r - 1, t)  # is a QTensor
+        U = g.dot(U)
         return U
 
     # Apply and store Givens rotations as per the given or computed ordering.
     if ordering is None:
         for c in range(n):
-            for r in range(n-1, c, -1):
+            for r in range(n - 1, c, -1):
                 U = calcTheta(U, c, r)
     else:
         for r, c in ordering:
             U = calcTheta(U, c, r)
-    
     # Calculating the Rz rotations based on the phases of the diagonal elements.
     # For real elements this means a 180 degree shift, i.e. a sign change.
     for i in range(n):
-        ph = numpy.angle(U[i,i])
-        phi_list.append((ph, i))
-
+        if isinstance(U[i, i], (Variable, Objective)):
+            if len(U[i, i].args):
+                phi_list.append((U[i, i].apply(numpy.angle), i))
+        else:
+            phi_list.append((numpy.angle(U[i, i]), i))
     # Filtering out rotations without significance.
     theta_list_new = []
     for i, theta in enumerate(theta_list):
-        if abs(theta[0] % (2*numpy.pi)) > tol:
+        if isinstance(theta[0], (Variable, Objective)):
+            if len(theta[0].args):
+                theta_list_new.append(theta)
+        elif abs(theta[0] % (2 * numpy.pi)) > tol:
             theta_list_new.append(theta)
-    
     phi_list_new = []
     for i, phi in enumerate(phi_list):
-        if abs(phi[0]) > tol:
+        if isinstance(phi[0], (Variable, Objective)):
+            if len(phi[0].args):
+                phi_list_new.append(phi)
+        elif abs(phi[0]) > tol:
             phi_list_new.append(phi)
-        
     if return_diagonal:
         # Optionally return the resulting diagonal
         return theta_list_new, phi_list_new, U
     else:
         return theta_list_new, phi_list_new
-    
-def reconstruct_matrix_from_givens(n, theta_list, phi_list, to_real_if_possible = True, tol = 1e-12):
-    '''
+
+
+def reconstruct_matrix_from_givens(n, theta_list, phi_list, to_real_if_possible=True, tol=1e-12):
+    """
     Reconstructs a matrix from given Givens rotations and Rz diagonal rotations.
     This function is effectively an inverse of get_givens_decomposition, and therefore only works with data in the same format as its output.
 
@@ -2351,10 +2794,10 @@ def reconstruct_matrix_from_givens(n, theta_list, phi_list, to_real_if_possible
 
     Returns:
     - numpy.ndarray: The reconstructed complex or real matrix, depending on the `to_real_if_possible` flag and matrix composition.
-    '''
+    """
     # Start with an identity matrix
     reconstructed = numpy.eye(n, dtype=complex)
-    
+
     # Apply Rz rotations for diagonal elements
     for phi in phi_list:
         angle, i = phi
@@ -2363,12 +2806,12 @@ def reconstruct_matrix_from_givens(n, theta_list, phi_list, to_real_if_possible
             reconstructed[i, i] *= -1
         else:
             reconstructed[i, i] *= numpy.exp(1j * angle)
-        
+
     # Apply Givens rotations in reverse order
     for theta in reversed(theta_list):
         angle, i, j = theta
         g = givens_matrix(n, i, j, angle)
-        reconstructed = numpy.dot(g.conj().T, reconstructed) # Transpose of Givens matrix applied to the left
+        reconstructed = numpy.dot(g.conj().T, reconstructed)  # Transpose of Givens matrix applied to the left
 
     # Convert matrix to real if its imaginary part is negligible unless disabled via to_real_if_possible
     if to_real_if_possible:
@@ -2378,3 +2821,12 @@ def reconstruct_matrix_from_givens(n, theta_list, phi_list, to_real_if_possible
             reconstructed = reconstructed.real
 
     return reconstructed
+
+
+def arctan2(x1, x2, *args, **kwargs):
+    if isinstance(x1, (Variable, Objective)) or isinstance(x2, (Variable, Objective)):
+        return Objective().binary_operator(left=1 * x1, right=1 * x2, op=numpy.arctan2)
+    elif not isinstance(x1, numbers.Complex) and not isinstance(x2, numbers.Complex):
+        return numpy.arctan2(x1, x2)
+    else:
+        return numpy.arctan2(x1.imag, x2.imag) + numpy.arctan2(x1.real, x2.real)