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

tequila/apps/adapt/adapt.py

@@ -1,7 +1,18 @@
 # Generalized Adaptive Solvers
 # as described in Kottmann, Anand, Aspuru-Guzik: https://doi.org/10.1039/D0SC06627C
 
-from tequila import QCircuit, QubitHamiltonian, gates, paulis, grad, simulate, TequilaWarning, TequilaException, minimize, ExpectationValue
+from tequila import (
+    QCircuit,
+    QubitHamiltonian,
+    gates,
+    paulis,
+    grad,
+    simulate,
+    TequilaWarning,
+    TequilaException,
+    minimize,
+    ExpectationValue,
+)
 import numpy
 import dataclasses
 import warnings
@@ -10,32 +21,39 @@ from itertools import combinations
 
 @dataclasses.dataclass
 class AdaptParameters:
-
-    optimizer_args: dict = dataclasses.field(default_factory=lambda : {"method":"bfgs", "silent":True, "method_options":{"gtol":1.e-5}})
-    compile_args: dict = dataclasses.field(default_factory=lambda : {})
-    maxiter:int = 100
+    optimizer_args: dict = dataclasses.field(
+        default_factory=lambda: {"method": "bfgs", "silent": True, "method_options": {"gtol": 1.0e-5}}
+    )
+    compile_args: dict = dataclasses.field(default_factory=lambda: {})
+    maxiter: int = 100
     batch_size = 1
     energy_convergence: float = None
-    gradient_convergence: float = 1.e-3
-    max_gradient_convergence: float = 5.e-4
-    degeneracy_threshold: float = 5.e-4
+    gradient_convergence: float = 1.0e-3
+    max_gradient_convergence: float = 5.0e-4
+    degeneracy_threshold: float = 5.0e-4
     silent: bool = False
-    
+
     def __post_init__(self):
         # avoid stacking of same operator-types in a row
         if "method_options" in self.optimizer_args:
             if "gtol" in self.optimizer_args["method_options"]:
-                gtol=self.optimizer_args["method_options"]["gtol"] 
+                gtol = self.optimizer_args["method_options"]["gtol"]
                 if gtol > self.max_gradient_convergence:
-                    warnings.warn("you specified screening threshold max_gradient_convergence={} but optimizer theshold gtol={}. This will lead to accumulation of the same operator, will set max_gradient_convergence={}".format(self.max_gradient_convergence, gtol, gtol*2),TequilaWarning)
-                    self.max_gradient_convergence = gtol*2.0
-                
+                    warnings.warn(
+                        "you specified screening threshold max_gradient_convergence={} but optimizer theshold gtol={}. This will lead to accumulation of the same operator, will set max_gradient_convergence={}".format(
+                            self.max_gradient_convergence, gtol, gtol * 2
+                        ),
+                        TequilaWarning,
+                    )
+                    self.max_gradient_convergence = gtol * 2.0
+
     def __str__(self):
         info = ""
-        for k,v in self.__dict__.items():
+        for k, v in self.__dict__.items():
             info += "{:30} : {}\n".format(k, v)
         return info
 
+
 class AdaptPoolBase:
     """
     Standard class for operator pools in Adapt
@@ -44,11 +62,11 @@ class AdaptPoolBase:
 
     generators: list = None
 
-    __n: int = 0 # for iterator, don't touch
+    __n: int = 0  # for iterator, don't touch
 
     def __init__(self, generators, trotter_steps=1):
         self.generators = generators
-        self.trotter_steps=1
+        self.trotter_steps = 1
 
     def make_unitary(self, k, label) -> QCircuit:
         return gates.Trotterized(generators=[self.generators[k]], angles=[(str(k), label)], steps=self.trotter_steps)
@@ -60,7 +78,7 @@ class AdaptPoolBase:
     def __next__(self):
         if self.__n < len(self.generators):
             result = self.__n
-            self.__n +=1
+            self.__n += 1
             return result
         else:
             raise StopIteration
@@ -68,6 +86,7 @@ class AdaptPoolBase:
     def __str__(self):
         return "{} with {} Generators".format(type(self).__name__, len(self.generators))
 
+
 class ObjectiveFactoryBase:
     """
     Default class to create the objective in the Adapt solver
@@ -75,9 +94,9 @@ class ObjectiveFactoryBase:
     and U will be the circuit that is adaptively constructed
     """
 
-    Upre: QCircuit=QCircuit()
-    Upost: QCircuit=QCircuit()
-    H : QubitHamiltonian=None
+    Upre: QCircuit = QCircuit()
+    Upost: QCircuit = QCircuit()
+    H: QubitHamiltonian = None
 
     def __init__(self, H=None, Upre=None, Upost=None, *args, **kwargs):
         if H is None:
@@ -102,19 +121,18 @@ class ObjectiveFactoryBase:
     def __str__(self):
         return "{}".format(type(self).__name__)
 
-class Adapt:
 
+class Adapt:
     operator_pool: AdaptPoolBase = None
     objective_factory = None
     parameters: AdaptParameters = AdaptParameters()
 
-
     def make_objective(self, U, variables=None, *args, **kwargs):
         return self.objective_factory(U=U, variables=variables, *args, **{**self.parameters.compile_args, **kwargs})
 
     def __init__(self, operator_pool, H=None, objective_factory=None, *args, **kwargs):
         """
-        For the Default Adaptive Solver kwargs can contain Upre and Upost as described in: 
+        For the Default Adaptive Solver kwargs can contain Upre and Upost as described in:
         See out online tutorial for more information: https://github.com/tequilahub/tequila-tutorials
         Better code-documentation will be there at some point ....
         """
@@ -126,11 +144,14 @@ class Adapt:
 
         filtered = {k: v for k, v in kwargs.items() if k in self.parameters.__dict__}
         self.parameters = AdaptParameters(*args, **filtered)
-        if self.parameters.silent and not self.parameters.optimizer_args is None and "silent" not in self.parameters.optimizer_args:
+        if (
+            self.parameters.silent
+            and self.parameters.optimizer_args is not None
+            and "silent" not in self.parameters.optimizer_args
+        ):
             self.parameters.optimizer_args["silent"] = True
 
-    def __call__(self, static_variables = None, mp_pool=None, label=None, variables=None, *args, **kwargs):
-        
+    def __call__(self, static_variables=None, mp_pool=None, label=None, variables=None, *args, **kwargs):
         if not self.parameters.silent:
             print("Starting Adaptive Solver")
             print(self)
@@ -155,28 +176,29 @@ class Adapt:
         elif hasattr(self.operator_pool, "initialize_circuit"):
             U = self.operator_pool.initialize_circuit()
 
-        initial_objective = self.make_objective(U, variables = variables)
+        initial_objective = self.make_objective(U, variables=variables)
         for k in initial_objective.extract_variables():
             if k not in variables:
-                warnings.warn("variable {} of initial objective not given, setting to 0.0 and activate optimization".format(k), TequilaWarning)
+                warnings.warn(
+                    "variable {} of initial objective not given, setting to 0.0 and activate optimization".format(k),
+                    TequilaWarning,
+                )
                 variables[k] = 0.0
 
-        if len(initial_objective.extract_variables())>0:
+        if len(initial_objective.extract_variables()) > 0:
             active_variables = [k for k in variables if k not in static_variables]
-            if len(active_variables)>0:
+            if len(active_variables) > 0:
                 if not self.parameters.silent:
                     print("initial optimization")
-                margs = {"initial_values":variables}
-                margs = {**margs,**self.parameters.compile_args,**self.parameters.optimizer_args}
-                result = minimize(objective=initial_objective,
-                                  variables=active_variables,
-                                  **margs)
+                margs = {"initial_values": variables}
+                margs = {**margs, **self.parameters.compile_args, **self.parameters.optimizer_args}
+                result = minimize(objective=initial_objective, variables=active_variables, **margs)
 
                 variables = result.variables
 
         energy = simulate(initial_objective, variables=variables)
         for iter in range(self.parameters.maxiter):
-            current_label = (iter,0)
+            current_label = (iter, 0)
             if label is not None:
                 current_label = (iter, label)
 
@@ -192,24 +214,35 @@ class Adapt:
                 break
             if numpy.abs(max_grad) < self.parameters.max_gradient_convergence:
                 if not self.parameters.silent:
-                    print("max pool gradient is {:+2.8f}, convergence criterion |max(grad)|<{} met".format(max_grad, self.parameters.max_gradient_convergence))
+                    print(
+                        "max pool gradient is {:+2.8f}, convergence criterion |max(grad)|<{} met".format(
+                            max_grad, self.parameters.max_gradient_convergence
+                        )
+                    )
                 break
 
             batch_size = self.parameters.batch_size
 
             # detect degeneracies
-            degeneracies = [k for k in range(batch_size, len(grad_values))
-                            if numpy.isclose(grad_values[batch_size-1],grad_values[k], rtol=self.parameters.degeneracy_threshold) ]
+            degeneracies = [
+                k
+                for k in range(batch_size, len(grad_values))
+                if numpy.isclose(grad_values[batch_size - 1], grad_values[k], rtol=self.parameters.degeneracy_threshold)
+            ]
 
             if len(degeneracies) > 0:
                 batch_size += len(degeneracies)
                 if not self.parameters.silent:
-                    print("detected degeneracies: increasing batch size temporarily from {} to {}".format(self.parameters.batch_size, batch_size))
+                    print(
+                        "detected degeneracies: increasing batch size temporarily from {} to {}".format(
+                            self.parameters.batch_size, batch_size
+                        )
+                    )
 
             count = 0
-           
-            op_names=[]
-            for k,v in gradients.items():
+
+            op_names = []
+            for k, v in gradients.items():
                 Ux = self.operator_pool.make_unitary(k, label=current_label)
                 U += Ux
                 op_names.append(Ux.extract_variables())
@@ -217,21 +250,19 @@ class Adapt:
                 if count >= batch_size:
                     break
 
-            variables = {**variables, **{k:0.0 for k in U.extract_variables() if k not in variables}}
+            variables = {**variables, **{k: 0.0 for k in U.extract_variables() if k not in variables}}
             active_variables = [k for k in variables if k not in static_variables]
 
             objective = self.make_objective(U, variables=variables)
-            margs = {"initial_values":variables}
-            margs = {**margs,**self.parameters.compile_args,**self.parameters.optimizer_args}
-            result = minimize(objective=objective,
-                              variables=active_variables,
-                              **margs)
-            
+            margs = {"initial_values": variables}
+            margs = {**margs, **self.parameters.compile_args, **self.parameters.optimizer_args}
+            result = minimize(objective=objective, variables=active_variables, **margs)
+
             niter = len(result.history.energies)
             diff = energy - result.energy
             energy = result.energy
             variables = result.variables
-            
+
             if not self.parameters.silent:
                 print("-------------------------------------")
                 print("Finished iteration {}".format(iter))
@@ -245,10 +276,10 @@ class Adapt:
                 print("opt-iterations : {}".format(niter))
 
             screening_cycles += 1
-            mini_iter=len(result.history.extract_energies())
+            mini_iter = len(result.history.extract_energies())
             gradient_expval = sum([v.count_expectationvalues() for k, v in grad(objective).items()])
-            objective_expval_evaluations += mini_iter*objective.count_expectationvalues()
-            gradient_expval_evaluations += mini_iter*gradient_expval
+            objective_expval_evaluations += mini_iter * objective.count_expectationvalues()
+            gradient_expval_evaluations += mini_iter * gradient_expval
             histories.append(result.history)
 
             if self.parameters.energy_convergence is not None and numpy.abs(diff) < self.parameters.energy_convergence:
@@ -263,26 +294,27 @@ class Adapt:
 
         @dataclasses.dataclass
         class AdaptReturn:
-            U:QCircuit=None
-            objective_factory:ObjectiveFactoryBase=None
-            variables:dict=None
+            U: QCircuit = None
+            objective_factory: ObjectiveFactoryBase = None
+            variables: dict = None
             energy: float = None
             histories: list = None
             screening_cycles: int = None
-            objective_expval_evaluations: int =None
-            gradient_expval_evaluations: int =None
-
-        return AdaptReturn(U=U,
-                           variables=variables,
-                           objective_factory=self.objective_factory,
-                           energy=energy,
-                           histories=histories,
-                           screening_cycles = screening_cycles,
-                           objective_expval_evaluations=objective_expval_evaluations,
-                           gradient_expval_evaluations=gradient_expval_evaluations)
+            objective_expval_evaluations: int = None
+            gradient_expval_evaluations: int = None
+
+        return AdaptReturn(
+            U=U,
+            variables=variables,
+            objective_factory=self.objective_factory,
+            energy=energy,
+            histories=histories,
+            screening_cycles=screening_cycles,
+            objective_expval_evaluations=objective_expval_evaluations,
+            gradient_expval_evaluations=gradient_expval_evaluations,
+        )
 
     def screen_gradients(self, U, variables, mp_pool=None):
-
         args = []
         for k in self.operator_pool:
             arg = {}
@@ -306,13 +338,14 @@ class Adapt:
         variables = {**arg["variables"]}
         objective = self.make_objective(Utmp, screening=True, variables=variables)
 
-
         dEs = []
         for k in Ux.extract_variables():
             variables[k] = 0.0
             dEs.append(grad(objective, k))
 
-        gradients=[numpy.abs(simulate(objective=dE, variables=variables, **self.parameters.compile_args)) for dE in dEs]
+        gradients = [
+            numpy.abs(simulate(objective=dE, variables=variables, **self.parameters.compile_args)) for dE in dEs
+        ]
 
         return arg["k"], sum(gradients)
 
@@ -322,9 +355,9 @@ class Adapt:
         result += str("{:30} : {}\n".format("objective factory : ", self.objective_factory))
         return result
 
-class MolecularPool(AdaptPoolBase):
 
-    def __init__(self, molecule, indices:str):
+class MolecularPool(AdaptPoolBase):
+    def __init__(self, molecule, indices: str):
         """
 
         Parameters
@@ -340,8 +373,12 @@ class MolecularPool(AdaptPoolBase):
         self.molecule = molecule
 
         if isinstance(indices, str):
-            if not "CC" in indices.upper():
-                raise TequilaException("Pool of type {} not yet supported.\nCreate your own by passing the initialized indices".format(indices))
+            if "CC" not in indices.upper():
+                raise TequilaException(
+                    "Pool of type {} not yet supported.\nCreate your own by passing the initialized indices".format(
+                        indices
+                    )
+                )
 
             generalized = True if "G" in indices.upper() else False
             paired = True if "P" in indices.upper() else False
@@ -349,42 +386,43 @@ class MolecularPool(AdaptPoolBase):
             doubles = True if "D" in indices.upper() else False
 
             indices = []
-            if doubles: indices += self.make_indices_doubles(generalized=generalized, paired=paired)
-            if singles: indices += self.make_indices_singles(generalized=generalized)
+            if doubles:
+                indices += self.make_indices_doubles(generalized=generalized, paired=paired)
+            if singles:
+                indices += self.make_indices_singles(generalized=generalized)
 
         indices = [tuple(k) for k in indices]
         super().__init__(generators=indices)
 
-
     def make_indices_singles(self, generalized=False):
         indices = []
-        for p in range(self.molecule.n_electrons//2):
-            for q in range(self.molecule.n_electrons//2, self.molecule.n_orbitals):
-                indices.append([(2*p, 2*q)])
-                indices.append([(2*p+1, 2*q+1)])
+        for p in range(self.molecule.n_electrons // 2):
+            for q in range(self.molecule.n_electrons // 2, self.molecule.n_orbitals):
+                indices.append([(2 * p, 2 * q)])
+                indices.append([(2 * p + 1, 2 * q + 1)])
         if not generalized:
             return indices
 
         for p in range(self.molecule.n_orbitals):
-            for q in range(p+1, self.molecule.n_orbitals):
-                if [(2*p, 2*q)] in indices:
+            for q in range(p + 1, self.molecule.n_orbitals):
+                if [(2 * p, 2 * q)] in indices:
                     continue
-                indices.append([(2*p, 2*q)])
-                indices.append([(2*p+1, 2*q+1)])
+                indices.append([(2 * p, 2 * q)])
+                indices.append([(2 * p + 1, 2 * q + 1)])
         return self.sort_and_filter_unique_indices(indices)
 
     def make_indices_doubles(self, generalized=False, paired=True):
         indices = []
-        for p in range(self.molecule.n_electrons//2):
-            for q in range(self.molecule.n_electrons//2, self.molecule.n_orbitals):
-                indices.append([(2*p, 2*q),(2*p+1, 2*q+1)])
+        for p in range(self.molecule.n_electrons // 2):
+            for q in range(self.molecule.n_electrons // 2, self.molecule.n_orbitals):
+                indices.append([(2 * p, 2 * q), (2 * p + 1, 2 * q + 1)])
 
         if not generalized:
             return indices
 
         for p in range(self.molecule.n_orbitals):
-            for q in range(p+1, self.molecule.n_orbitals):
-                idx = [(2*p, 2*q),(2*p+1, 2*q+1)]
+            for q in range(p + 1, self.molecule.n_orbitals):
+                idx = [(2 * p, 2 * q), (2 * p + 1, 2 * q + 1)]
                 if idx in indices:
                     continue
                 indices.append(idx)
@@ -405,29 +443,34 @@ class MolecularPool(AdaptPoolBase):
         # sort as: [[(a,b),(c,d),(e,f)...],...]with a<c, a<b, c<d
         sorted_indices = []
         for idx in indices:
-            idx = tuple([tuple(sorted(pair)) for pair in idx]) # sort internal pairs (a<b, c<d, etc)
+            idx = tuple([tuple(sorted(pair)) for pair in idx])  # sort internal pairs (a<b, c<d, etc)
             # avoid having orbitals show up multiple times in excitatin strings
-            idx = tuple([pair for pair in idx if sum([1 for pair2 in idx if pair[0] in pair2 or pair[1] in pair2 ])==1 ])
+            idx = tuple(
+                [pair for pair in idx if sum([1 for pair2 in idx if pair[0] in pair2 or pair[1] in pair2]) == 1]
+            )
             if len(idx) == 0:
                 continue
-            idx = tuple(list(set(idx))) # avoid repetitions (like ((0,2),(0,2)))
-            idx = tuple(sorted(idx, key=lambda x:x[0])) # sort pairs by first entry (a<c)
+            idx = tuple(list(set(idx)))  # avoid repetitions (like ((0,2),(0,2)))
+            idx = tuple(sorted(idx, key=lambda x: x[0]))  # sort pairs by first entry (a<c)
             sorted_indices.append(idx)
         return list(set(sorted_indices))
 
-
-
     def make_unitary(self, k, label):
-        return self.molecule.make_excitation_gate(indices=self.generators[k], angle=(self.generators[k], label), assume_real=True)
+        return self.molecule.make_excitation_gate(
+            indices=self.generators[k], angle=(self.generators[k], label), assume_real=True
+        )
 
-class PseudoSingletMolecularPool(MolecularPool):
 
+class PseudoSingletMolecularPool(MolecularPool):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         indices = []
         for idx in self.generators:
             if len(idx) == 1:
-                combined = ( ((idx[0][0]//2*2, idx[0][1]//2*2)), ((idx[0][0]//2*2+1, idx[0][1]//2*2+1)) )
+                combined = (
+                    ((idx[0][0] // 2 * 2, idx[0][1] // 2 * 2)),
+                    ((idx[0][0] // 2 * 2 + 1, idx[0][1] // 2 * 2 + 1)),
+                )
                 if combined not in indices:
                     indices.append(combined)
             else:
@@ -439,47 +482,45 @@ class PseudoSingletMolecularPool(MolecularPool):
         U = QCircuit()
         for idx in self.generators[k]:
             combined_variable = self.generators[k][0]
-            U += self.molecule.make_excitation_gate(indices=idx, angle=(combined_variable,label))
+            U += self.molecule.make_excitation_gate(indices=idx, angle=(combined_variable, label))
         return U
 
-class ObjectiveFactorySequentialExcitedState(ObjectiveFactoryBase):
 
+class ObjectiveFactorySequentialExcitedState(ObjectiveFactoryBase):
     def __init__(self, H, circuits: list, factors: list, *args, **kwargs):
         self.circuits = circuits
         self.factors = factors
         super().__init__(H=H, *args, **kwargs)
 
-    def __call__(self, U,  *args, **kwargs):
+    def __call__(self, U, *args, **kwargs):
         circuit = self.Upre + U + self.Upost
         objective = ExpectationValue(H=self.H, U=circuit)
         Qp = paulis.Qp(U.qubits)
         # get all overlaps
-        for i,Ux in enumerate(self.circuits):
-            S2 = ExpectationValue(H=Qp, U=circuit+Ux.dagger())
-            objective += numpy.abs(self.factors[i])*S2
+        for i, Ux in enumerate(self.circuits):
+            S2 = ExpectationValue(H=Qp, U=circuit + Ux.dagger())
+            objective += numpy.abs(self.factors[i]) * S2
         return objective
 
-def run_molecular_adapt(molecule, operator_pool: str = None, Upre=None , Upost=None, *args, **kwargs):
 
+def run_molecular_adapt(molecule, operator_pool: str = None, Upre=None, Upost=None, *args, **kwargs):
     if operator_pool is None:
         operator_pool = "UCCGSD"
 
     # auto-detect if we have an molecular pool
     # initialized by keyword
     # e.g. U(p)CC(G)(S)(D)
-    ucc_signals=["u", "cc", "s", "d", "g"]
+    ucc_signals = ["u", "cc", "s", "d", "g"]
     if hasattr(operator_pool, "lower"):
         if any([s in operator_pool.lower() for s in ucc_signals]):
-            operator_pool = MolecularPool(molecule=molecule, indices=operator_pool)            
-    
+            operator_pool = MolecularPool(molecule=molecule, indices=operator_pool)
+
     if Upre is None:
         Upre = molecule.prepare_reference()
 
     H = molecule.make_hamiltonian()
     solver = Adapt(operator_pool=operator_pool, H=H, Upre=Upre, Upost=Upost, *args, **kwargs)
-    
+
     result = solver()
 
     return result
-
-

tequila/apps/krylov/__init__.py

@@ -1 +1 @@
-from .krylov import krylov_method
+from .krylov import krylov_method

tequila/apps/krylov/krylov.py

@@ -1,20 +1,22 @@
 import copy
 import scipy
-from tequila import braket, QTensor, simulate
+from tequila import BraKet, QTensor, simulate
 from tequila.hamiltonian.qubit_hamiltonian import QubitHamiltonian
 
 
-def krylov_method(krylov_circs:list, H:QubitHamiltonian, variables:dict=None, assume_real:bool=False, *args, **kwargs)->tuple:
+def krylov_method(
+    krylov_circs: list, H: QubitHamiltonian, variables: dict = None, assume_real: bool = False, *args, **kwargs
+) -> tuple:
     """Function that applies Krylov method to an Hamiltonian operator,
-    given the list of Krylov quantum circuits. If the circuits are parametrized 
-    also the variables need to be passed. The method returns the ground state energy 
+    given the list of Krylov quantum circuits. If the circuits are parametrized
+    also the variables need to be passed. The method returns the ground state energy
     and the array of coefficients allowing to obtain an approximation of the ground state.
     Optional function arguments (*args, **kwargs) allows to change simulation options.
 
     Args:
         krylov_circs (list): List of Krylov circuits.
         H (QubitHamiltonian): Hamiltonian on which we want to apply Krylov method
-        variables (dict, optional): Dicitionary containing possible variables to be stored in the Krylov circuits. 
+        variables (dict, optional): Dicitionary containing possible variables to be stored in the Krylov circuits.
         Defaults to None.
         assume_real (bool): If set to True the function does not compute the imaginary part.
         Default to False.
@@ -22,32 +24,32 @@ def krylov_method(krylov_circs:list, H:QubitHamiltonian, variables:dict=None, as
     Returns:
         tuple(np.ndarray, np.ndarray): array of energies, array of krylov coefficients corresponding to the energies
     """
-    
+
     n_krylov_states = len(krylov_circs)
-    HM = QTensor(shape=[n_krylov_states,n_krylov_states])
-    SM = QTensor(shape=[n_krylov_states,n_krylov_states])
-    
+    HM = QTensor(shape=[n_krylov_states, n_krylov_states])
+    SM = QTensor(shape=[n_krylov_states, n_krylov_states])
+
     if variables is not None:
-        krylov_circs_x = [U.map_variables(variables) for U in krylov_circs] 
+        krylov_circs_x = [U.map_variables(variables) for U in krylov_circs]
     else:
         krylov_circs_x = copy.deepcopy(krylov_circs)
 
     for i in range(n_krylov_states):
-        for j in range(i,n_krylov_states):
+        for j in range(i, n_krylov_states):
             if assume_real:
-                h_real = braket(bra=krylov_circs_x[i], ket=krylov_circs_x[j], operator=H)[0]
+                h_real = BraKet(bra=krylov_circs_x[i], ket=krylov_circs_x[j], operator=H)[0]
                 h_im = 0
             else:
-                h_real, h_im = braket(bra=krylov_circs_x[i], ket=krylov_circs_x[j], operator=H)
-            HM[i,j] = h_real + 1j*h_im
-            HM[j,i] = h_real - 1j*h_im
-            s_real, s_im = braket(bra=krylov_circs_x[i], ket=krylov_circs_x[j])
-            SM[i,j] = s_real + 1j*s_im
-            SM[j,i] = s_real - 1j*s_im
-
-    h = simulate(HM, *args, **kwargs) 
+                h_real, h_im = BraKet(bra=krylov_circs_x[i], ket=krylov_circs_x[j], operator=H)
+            HM[i, j] = h_real + 1j * h_im
+            HM[j, i] = h_real - 1j * h_im
+            s_real, s_im = BraKet(bra=krylov_circs_x[i], ket=krylov_circs_x[j])
+            SM[i, j] = s_real + 1j * s_im
+            SM[j, i] = s_real - 1j * s_im
+
+    h = simulate(HM, *args, **kwargs)
     s = simulate(SM, *args, **kwargs)
 
-    v,vv = scipy.linalg.eigh(h,s)
+    v, vv = scipy.linalg.eigh(h, s)
 
     return v, vv

tequila/apps/robustness/helpers.py

@@ -25,16 +25,16 @@ class PauliClique:
         -------
         """
         n_qubits = self.n_qubits
-        eig = np.asarray([0.0 for n in range(2 ** n_qubits)], dtype=float)
+        eig = np.asarray([0.0 for n in range(2**n_qubits)], dtype=float)
         for ps in self.paulistrings:
-            x = np.asarray([1.0 for n in range(2 ** n_qubits)], dtype=int)
+            x = np.asarray([1.0 for n in range(2**n_qubits)], dtype=int)
             paulis = [[1, 1]] * n_qubits
             for d in ps.keys():
                 try:
                     paulis[d] = [1, -1]
-                except:
+                except Exception:
                     raise Exception("weird {} with len={} with d={}".format(paulis, len(paulis), d))
-            for i in range(2 ** n_qubits):
+            for i in range(2**n_qubits):
                 binary_array = BitString.from_int(integer=i, nbits=n_qubits).array
                 for j, k in enumerate(binary_array):
                     x[i] *= paulis[j][k]
@@ -60,8 +60,12 @@ class PauliClique:
         for ps in self.paulistrings:
             normalized_ps.append(PauliString(coeff=ps.coeff / highest_abs, data=ps._data))
 
-        return PauliClique(coeff=self.coeff * highest_abs, H=QubitHamiltonian.from_paulistrings(normalized_ps),
-                           U=self.U, n_qubits=self.n_qubits)
+        return PauliClique(
+            coeff=self.coeff * highest_abs,
+            H=QubitHamiltonian.from_paulistrings(normalized_ps),
+            U=self.U,
+            n_qubits=self.n_qubits,
+        )
 
     def naked(self):
         return PauliClique(coeff=1.0, H=self.H, U=self.U, n_qubits=self.n_qubits)