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

tequila/simulators/test_spex_simulator.py

@@ -19,7 +19,7 @@ print("Test: Circuit und Hamiltonian mit Variablen (SPEX vs. Qulacs)")
 a = tq.Variable("a")
 b = tq.Variable("b")
 c = tq.Variable("c")
-variables = {"a": np.pi/3, "b": np.pi/4, "c": np.pi/6}
+variables = {"a": np.pi / 3, "b": np.pi / 4, "c": np.pi / 6}
 
 # --- Circuitaufbau ---
 # Erzeuge einen Circuit, der auf 3 Qubits operiert:
@@ -27,9 +27,7 @@ variables = {"a": np.pi/3, "b": np.pi/4, "c": np.pi/6}
 # - Eine Ry-Rotation auf Qubit 1 (Winkel "b")
 # - Eine Rz-Rotation auf Qubit 2 (Winkel "c")
 # - Zusätzlich eine parametrische exponentielle Pauli-Rotation (ExpPauli) auf Qubit 0 und 2 (Pauli-String "X(0)Z(2)")
-U = tq.gates.Rx(angle="a", target=(0,)) \
-    + tq.gates.Ry(angle="b", target=(1,)) \
-    + tq.gates.Rz(angle="c", target=(2,))
+U = tq.gates.Rx(angle="a", target=(0,)) + tq.gates.Ry(angle="b", target=(1,)) + tq.gates.Rz(angle="c", target=(2,))
 U += tq.gates.ExpPauli(angle="a", paulistring="X(0)Z(2)")
 
 print("\nCircuit U:")
@@ -47,15 +45,15 @@ E = tq.ExpectationValue(U=U, H=H)
 
 # --- Simulation mit SPEX ---
 start = time.time()
-wfn_spex = tq.simulate(U, variables, backend='spex')
-exp_spex = tq.simulate(E, variables, backend='spex')
+wfn_spex = tq.simulate(U, variables, backend="spex")
+exp_spex = tq.simulate(E, variables, backend="spex")
 end = time.time()
 time_spex = end - start
 
 # --- Simulation mit Qulacs ---
 start = time.time()
-wfn_qulacs = tq.simulate(U, variables, backend='qulacs')
-exp_qulacs = tq.simulate(E, variables, backend='qulacs')
+wfn_qulacs = tq.simulate(U, variables, backend="qulacs")
+exp_qulacs = tq.simulate(E, variables, backend="qulacs")
 end = time.time()
 time_qulacs = end - start
 
@@ -70,11 +68,10 @@ print("\nErwartungswert (SPEX backend):", exp_spex, f"(Simulationszeit: {time_sp
 print("Erwartungswert (Qulacs backend):", exp_qulacs, f"(Simulationszeit: {time_qulacs:.3f}s)")
 
 # Optional: Vergleiche das innere Produkt der beiden Wavefunctions (Quadrat des Betrags)
-inner_prod = np.abs(wfn_spex.inner(wfn_qulacs))**2
+inner_prod = np.abs(wfn_spex.inner(wfn_qulacs)) ** 2
 print("\nInneres Produkt (Quadrat) zwischen SPEX und Qulacs:", inner_prod)
 
 
-
 """
 print("\nTest: 1")
 U = tq.gates.ExpPauli(paulistring=PauliString({0: "X", 1: "Z"}), angle=np.pi / 2)
@@ -208,4 +205,4 @@ for n in range(1, 15):
     
     E_qulacs = None
 
-"""
+"""

tequila/tools/convenience.py

@@ -12,7 +12,7 @@ def list_assignment(o):
     """
     if o is None:
         return []
-    elif isinstance(o,tuple):
+    elif isinstance(o, tuple):
         return o
     elif hasattr(o, "__get_item__"):
         return list(o)
@@ -22,14 +22,14 @@ def list_assignment(o):
         return [o]
 
 
-def number_to_string(number: complex, precision: int = 4, threshold: float = 1.e-6) -> str:
+def number_to_string(number: complex, precision: int = 4, threshold: float = 1.0e-6) -> str:
     if not isinstance(number, numbers.Number):
         return str(number)
 
     number = complex(number)
     real = number.real
     imag = number.imag
-    prec = '{:+.' + str(precision) + 'f}'
+    prec = "{:+." + str(precision) + "f}"
 
     if isclose(real, 0.0, atol=threshold):
         return prec.format(imag) + "i"
@@ -37,7 +37,7 @@ def number_to_string(number: complex, precision: int = 4, threshold: float = 1.e
         return prec.format(real)
     else:
         r, theta = polar(number)
-        return prec.format(r) + ('e^(' + prec).format(theta / pi) + 'πi)'
+        return prec.format(r) + ("e^(" + prec).format(theta / pi) + "πi)"
 
 
 if __name__ == "__main__":

tequila/tools/qng.py

@@ -5,15 +5,19 @@ from tequila.circuit.circuit import QCircuit
 from tequila.simulators.simulator_api import compile_objective
 from tequila.circuit.gradient import __grad_inner
 from tequila.autograd_imports import jax
-from tequila.circuit.compiler import compile_controlled_rotation, compile_power_gate, \
-    compile_trotterized_gate, compile_controlled_phase, compile_multitarget
+from tequila.circuit.compiler import (
+    compile_controlled_rotation,
+    compile_power_gate,
+    compile_trotterized_gate,
+    compile_controlled_phase,
+    compile_multitarget,
+)
 import typing
 import numpy
 import copy
 
 
 class QngMatrix:
-
     """
     A callable class which is meant to be used for calculating the inverse qgt of an expectationvalue.
 
@@ -40,18 +44,18 @@ class QngMatrix:
         d = 0
         for block in self.blocks:
             d += len(block)
-        return (d,d)
+        return (d, d)
 
-    def __init__(self,blocks):
+    def __init__(self, blocks):
         """
         Parameters
         ----------
         blocks: list:
             list of list of lists. the blocks of the qgt.
         """
-        self.blocks= blocks
+        self.blocks = blocks
 
-    def __call__(self, variables,samples=None) -> numpy.ndarray:
+    def __call__(self, variables, samples=None) -> numpy.ndarray:
         """
         from the blocks provided, evaluate all qgt terms, then calculate the pseudo-inverse, and return it.
         Parameters
@@ -71,22 +75,21 @@ class QngMatrix:
         # displace our running index of position, as we enumerate through a block
         # d_v does this. If you only provide one block (the whole QGT), this won't matter
         for block in self.blocks:
-
-            d_v_temp = 0 # how much to increment d_v by when done with the block at hand.
+            d_v_temp = 0  # how much to increment d_v by when done with the block at hand.
             for i, row in enumerate(block):
                 for j, term in enumerate(row):
                     if i <= j:
                         # if its an objective, call it. Else, it is a float.
                         try:
-                            output[i + d_v][j + d_v] = term(variables=variables,samples=samples)
-                        except:
+                            output[i + d_v][j + d_v] = term(variables=variables, samples=samples)
+                        except Exception:
                             output[i + d_v][j + d_v] = term
                     else:
                         output[i + d_v][j + d_v] = output[j + d_v][i + d_v]
                 d_v_temp += 1
             d_v += d_v_temp
 
-        back = numpy.linalg.pinv(output) # return the pseudo_inverse of the matrix!
+        back = numpy.linalg.pinv(output)  # return the pseudo_inverse of the matrix!
         return back
 
 
@@ -104,7 +107,7 @@ class CallableVector:
     def dim(self):
         return (len(self._vector),)
 
-    def __init__(self,vector):
+    def __init__(self, vector):
         """
         init.
         Parameters
@@ -133,7 +136,7 @@ class CallableVector:
 
         output = numpy.empty(self.dim)
         for i, entry in enumerate(self._vector):
-            if hasattr(entry, '__call__'):
+            if hasattr(entry, "__call__"):
                 output[i] = entry(variables, samples=samples)
             else:
                 output[i] = entry
@@ -155,24 +158,23 @@ def get_generator(gate) -> paulis.QubitHamiltonian:
 
     """
 
-    if gate.name.lower() == 'rx':
+    if gate.name.lower() == "rx":
         gen = paulis.X(gate.target[0])
-    elif gate.name.lower() == 'ry':
+    elif gate.name.lower() == "ry":
         gen = paulis.Y(gate.target[0])
-    elif gate.name.lower() == 'rz':
+    elif gate.name.lower() == "rz":
         gen = paulis.Z(gate.target[0])
-    elif gate.name.lower() == 'phase':
+    elif gate.name.lower() == "phase":
         gen = paulis.Qm(gate.target[0])
     else:
         print(gate.name.lower())
-        raise TequilaException('cant get the generator of a non Gaussian gate, you fool!')
+        raise TequilaException("cant get the generator of a non Gaussian gate, you fool!")
     return gen
 
 
-def stokes_block(expectation, initial_values=None, samples=None, device=None,
-                 backend=None,
-                 noise=None) -> typing.List[typing.List[typing.List[typing.Union[float,Objective]]]]:
-
+def stokes_block(
+    expectation, initial_values=None, samples=None, device=None, backend=None, noise=None
+) -> typing.List[typing.List[typing.List[typing.Union[float, Objective]]]]:
     """
     returns the blocks of the layerwise block-diagonal approximation to the qgt.
     The default for all qng-based optimizations, as a method for obtaining the qgt.
@@ -207,7 +209,7 @@ def stokes_block(expectation, initial_values=None, samples=None, device=None,
     # rebuild the sub circuits used in the expectation values that populate the QGT
     sub = [QCircuit.from_moments(moments[:i]) for i in range(1, len(moments), 2)]
     # this is the list of just the moments which are parametrized.
-    parametric_moms = [moments[i] for i in range(1, len(moments)+1, 2)]
+    parametric_moms = [moments[i] for i in range(1, len(moments) + 1, 2)]
     generators = []
     # generators is a list of lists, ultimately, where each sublist is all the generators in order
     # for a given parametric layer (if said layer is
@@ -238,13 +240,15 @@ def stokes_block(expectation, initial_values=None, samples=None, device=None,
                 for q, gen2 in enumerate(g_set):
                     ### make sure you compile the objectives! otherwise this bad boy will not run
                     if k == q:
-                        arg = (ExpectationValue(U=sub[i], H=gen1 * gen1) - ExpectationValue(U=sub[i], H=gen1)**2)/4
+                        arg = (ExpectationValue(U=sub[i], H=gen1 * gen1) - ExpectationValue(U=sub[i], H=gen1) ** 2) / 4
                     else:
-                        arg = (ExpectationValue(U=sub[i], H=gen1 * gen2) - ExpectationValue(U=sub[i], H=gen1) *
-                               ExpectationValue(U=sub[i], H=gen2)) / 4
-                    block[k][q] = compile_objective(arg, variables=initial_values, samples=samples,
-                                                    backend=backend, device=device,
-                                                    noise=noise)
+                        arg = (
+                            ExpectationValue(U=sub[i], H=gen1 * gen2)
+                            - ExpectationValue(U=sub[i], H=gen1) * ExpectationValue(U=sub[i], H=gen2)
+                        ) / 4
+                    block[k][q] = compile_objective(
+                        arg, variables=initial_values, samples=samples, backend=backend, device=device, noise=noise
+                    )
             blocks.append(block)
     return blocks
 
@@ -270,18 +274,18 @@ def qng_circuit_grad(E: ExpectationValueImpl) -> typing.List[Objective]:
     unitary = E.U
 
     # fast return if possible
-    out=[]
+    out = []
     for i, g in enumerate(unitary.gates):
-        if g.is_parametrized():
+        if g.is_parameterized():
             if g.is_controlled():
                 raise TequilaException("controlled gate in qng circuit gradient: Compiler was not called")
             if hasattr(g, "eigenvalues_magnitude"):
-                if hasattr(g._parameter,'extract_variables'):
+                if hasattr(g._parameter, "extract_variables"):
                     shifter = qng_grad_gaussian(unitary, g, i, hamiltonian)
                     out.append(shifter)
             else:
                 print(g, type(g))
-                raise TequilaException('No shift found for gate {}'.format(g))
+                raise TequilaException("No shift found for gate {}".format(g))
     if out is None:
         raise TequilaException("caught a dead circuit in qng gradient")
     return out
@@ -336,8 +340,9 @@ def qng_grad_gaussian(unitary, g, i, hamiltonian) -> Objective:
     return dOinc
 
 
-def subvector_procedure(e_val, initial_values=None, samples=None, device=None,
-                        backend=None, noise=None) -> CallableVector:
+def subvector_procedure(
+    e_val, initial_values=None, samples=None, device=None, backend=None, noise=None
+) -> CallableVector:
     """
     take an expectation value and return its (qng style) gradient as a CallableVector.
 
@@ -364,9 +369,11 @@ def subvector_procedure(e_val, initial_values=None, samples=None, device=None,
     vect = qng_circuit_grad(e_val)
     out = []
     for entry in vect:
-        out.append(compile_objective(entry, variables=initial_values, samples=samples, device=device,
-                                     backend=backend,
-                                     noise=noise))
+        out.append(
+            compile_objective(
+                entry, variables=initial_values, samples=samples, device=device, backend=backend, noise=noise
+            )
+        )
     return CallableVector(out)
 
 
@@ -384,10 +391,10 @@ def get_self_pars(U) -> typing.List:
         list eg. of Objectives and Variables; the self-parameters of a circuit.
     """
 
-    out=[]
+    out = []
     for g in U.gates:
-        if g.is_parametrized():
-            if hasattr(g._parameter,'extract_variables'):
+        if g.is_parameterized():
+            if hasattr(g._parameter, "extract_variables"):
                 out.append(g._parameter)
     return out
 
@@ -416,13 +423,12 @@ def qng_dict(argument, matrix, subvector, mapping, positional) -> typing.Dict:
         dict containing information used to obtain the qng of some argument of an objective.
 
     """
-    return {'arg': argument, 'matrix': matrix, 'vector': subvector, 'mapping': mapping, 'positional': positional}
-
+    return {"arg": argument, "matrix": matrix, "vector": subvector, "mapping": mapping, "positional": positional}
 
-def get_qng_combos(objective, func=stokes_block,
-                   initial_values=None, samples=None,
-                   backend=None, device=None, noise=None) -> typing.List[typing.Dict]:
 
+def get_qng_combos(
+    objective, func=stokes_block, initial_values=None, samples=None, backend=None, device=None, noise=None
+) -> typing.List[typing.Dict]:
     """
     get all the objects needed to evaluate the qng for some objective; return them in a list of dictionaries.
 
@@ -459,7 +465,7 @@ def get_qng_combos(objective, func=stokes_block,
     compiled = compile_power_gate(gate=compiled)
     compiled = compile_controlled_phase(gate=compiled)
     compiled = compile_controlled_rotation(gate=compiled)
-    for i,arg in enumerate(compiled.args):
+    for i, arg in enumerate(compiled.args):
         if not isinstance(arg, ExpectationValueImpl):
             # this is a variable, no QNG involved
             mat = QngMatrix([[[1]]])
@@ -467,13 +473,15 @@ def get_qng_combos(objective, func=stokes_block,
             mapping = {0: {v: __grad_inner(arg, v) for v in var_list}}
         else:
             # if the arg is an expectationvalue, we need to build some qngs and mappings!
-            blocks = func(arg, initial_values=initial_values, samples=samples, device=device,
-                          backend=backend, noise=noise)
+            blocks = func(
+                arg, initial_values=initial_values, samples=samples, device=device, backend=backend, noise=noise
+            )
 
             mat = QngMatrix(blocks)
 
-            vec = subvector_procedure(arg, initial_values=initial_values, samples=samples, device=device,
-                                      backend=backend, noise=noise)
+            vec = subvector_procedure(
+                arg, initial_values=initial_values, samples=samples, device=device, backend=backend, noise=noise
+            )
 
             mapping = {}
             self_pars = get_self_pars(arg.U)
@@ -482,25 +490,25 @@ def get_qng_combos(objective, func=stokes_block,
                 for v in p.extract_variables():
                     gi = __grad_inner(p, v)
                     if isinstance(gi, Objective):
-                        g = compile_objective(gi, variables=initial_values, samples=samples, device=device,
-                                              backend=backend, noise=noise)
+                        g = compile_objective(
+                            gi, variables=initial_values, samples=samples, device=device, backend=backend, noise=noise
+                        )
                     else:
                         g = gi
                     indict[v] = g
                 mapping[j] = indict
 
-
         pos_arg = jax.grad(compiled.transformation, i)
         p = Objective(compiled.args, transformation=pos_arg)
 
-        pos = compile_objective(p, variables=initial_values, samples=samples, device=device,
-                                backend=backend, noise=noise)
+        pos = compile_objective(
+            p, variables=initial_values, samples=samples, device=device, backend=backend, noise=noise
+        )
         combos.append(qng_dict(arg, mat, vec, mapping, pos))
     return combos
 
 
 def evaluate_qng(combos, variables, samples=None) -> list:
-
     """
     actually evaluate the terms of a qng.
     Parameters
@@ -520,17 +528,17 @@ def evaluate_qng(combos, variables, samples=None) -> list:
     """
     gd = {v: 0 for v in variables.keys()}
     for c in combos:
-        qgt = c['matrix']
-        vec = c['vector']
-        m = c['mapping']
-        pos = c['positional']
+        qgt = c["matrix"]
+        vec = c["vector"]
+        m = c["mapping"]
+        pos = c["positional"]
         marco = qgt(variables, samples=samples)
         polo = vec(variables, samples=samples)
         ev = numpy.dot(marco, polo)
         for i, val in enumerate(ev):
             maps = m[i]
             for k in maps.keys():
-                gd[k] += (val*maps[k]*pos)(variables=variables, samples=samples)
+                gd[k] += (val * maps[k] * pos)(variables=variables, samples=samples)
 
     out = [v for v in gd.values()]
     return out
@@ -547,7 +555,7 @@ class QNGVector:
 
     """
 
-    def __init__(self,combos):
+    def __init__(self, combos):
         """
         init.
         Parameters

tequila/tools/random_generators.py

@@ -4,8 +4,10 @@ from tequila.circuit.circuit import QCircuit
 from tequila.hamiltonian.qubit_hamiltonian import QubitHamiltonian
 from scipy.stats import unitary_group, ortho_group
 
-def make_random_circuit(n_qubits: int, rotation_gates: list=['rx', 'ry', 'rz'], n_rotations: int=None,
-                        enable_controls: bool=None) -> QCircuit:
+
+def make_random_circuit(
+    n_qubits: int, rotation_gates: list = ["rx", "ry", "rz"], n_rotations: int = None, enable_controls: bool = None
+) -> QCircuit:
     """Function that creates a circuit with random rotations or random control rotations.
 
     Args:
@@ -15,37 +17,38 @@ def make_random_circuit(n_qubits: int, rotation_gates: list=['rx', 'ry', 'rz'],
         enable_controls (bool): Boolean that switch on controls. Default to None.
 
     Returns:
-        QCircuit: Random quantum circuit consiting of the given rotations gates 
+        QCircuit: Random quantum circuit consiting of the given rotations gates
         and their controlled versions
     """
     if n_rotations is None:
-        n_rotations = np.random.randint(n_qubits, high=n_qubits*3)
+        n_rotations = np.random.randint(n_qubits, high=n_qubits * 3)
 
     gates_list = [np.random.choice(rotation_gates) for i in range(n_rotations)]
-    
-    angles = 2*np.pi * np.random.rand(n_rotations)
-    
+
+    angles = 2 * np.pi * np.random.rand(n_rotations)
+
     circ = QCircuit()
     for i, angle in enumerate(angles):
-        target = i%n_qubits
+        target = i % n_qubits
         if enable_controls:
             controls = [i for i in circ.qubits if i != target]
             control = np.random.choice(controls + [None])
-        else: 
+        else:
             control = None
 
-        if gates_list[i]=='rx':
+        if gates_list[i] == "rx":
             circ += gates.Rx(angle=angle, target=target, control=control)
-        
-        elif gates_list[i]=='ry':
+
+        elif gates_list[i] == "ry":
             circ += gates.Ry(angle=angle, target=target, control=control)
-            
-        elif gates_list[i]=='rz':
+
+        elif gates_list[i] == "rz":
             circ += gates.Rz(angle=angle, target=target, control=control)
-        
+
     return circ
 
-def make_random_hamiltonian(n_qubits: int , paulis: list=['X','Y','Z'], n_ps: int = None) -> QubitHamiltonian:
+
+def make_random_hamiltonian(n_qubits: int, paulis: list = ["X", "Y", "Z"], n_ps: int = None) -> QubitHamiltonian:
     """Function that creates a random Hamiltonian, given the list
        of Pauli ops. to use and the number of Pauli strings.
 
@@ -58,27 +61,28 @@ def make_random_hamiltonian(n_qubits: int , paulis: list=['X','Y','Z'], n_ps: in
         tq.QubitHamiltonian: Random Hamiltonian
     """
     if n_ps is None:
-        n_ps = np.random.randint(1, high=2*n_qubits+1)
-    
-    ham = ''
+        n_ps = np.random.randint(1, high=2 * n_qubits + 1)
+
+    ham = ""
     for ps in range(n_ps):
-        coeff = '{}*'.format(round(np.random.sample(),2))
-        pauli_str = ''
+        coeff = "{}*".format(round(np.random.sample(), 2))
+        pauli_str = ""
         for qb in range(n_qubits):
-            pauli_str += '{}({})'.format(np.random.choice(paulis), qb)
-        
-        if ps < n_ps-1:
-            pauli_str += '+'
-                
-        ham += coeff+pauli_str
-    
-    #print(ham)
-    
+            pauli_str += "{}({})".format(np.random.choice(paulis), qb)
+
+        if ps < n_ps - 1:
+            pauli_str += "+"
+
+        ham += coeff + pauli_str
+
+    # print(ham)
+
     H = QubitHamiltonian(ham)
     return H
 
-def generate_random_unitary(size, complex = False):
-    '''
+
+def generate_random_unitary(size, complex=False):
+    """
     Generates a random unitary (or furthermore orthogonal if complex is False) matrix of a specified size.
 
     Parameters:
@@ -87,8 +91,8 @@ def generate_random_unitary(size, complex = False):
 
     Returns:
     - numpy.ndarray: A randomly generated unitary matrix.
-    '''
+    """
     if complex:
         return unitary_group.rvs(size)
     else:
-        return ortho_group.rvs(size)
+        return ortho_group.rvs(size)

tequila/utils/bitstrings.py

@@ -43,14 +43,14 @@ class BitString:
     @property
     def binary(self):
         if self.numbering is BitNumbering.MSB:
-            return format(self._value, 'b').zfill(self.nbits)
+            return format(self._value, "b").zfill(self.nbits)
         else:
-            return format(self._value, 'b').zfill(self.nbits)[::-1]
+            return format(self._value, "b").zfill(self.nbits)[::-1]
 
     @binary.setter
     def binary(self, other: str):
-        assert (isinstance(other, str))
-        if other.startswith('0b'):
+        assert isinstance(other, str)
+        if other.startswith("0b"):
             other = other[2:]
         if self.numbering == BitNumbering.LSB:
             self._value = int(other[::-1], 2)
@@ -178,7 +178,6 @@ class BitString:
 
 
 class BitStringLSB(BitString):
-
     @property
     def numbering(self) -> BitNumbering:
         return BitNumbering.LSB
@@ -197,8 +196,9 @@ def reverse_int_bits(x: int, nbits: int) -> int:
     return x >> (32 - nbits)
 
 
-def initialize_bitstring(integer: int, nbits: int = None, numbering_in: BitNumbering = BitNumbering.MSB,
-                         numbering_out: BitNumbering = None):
+def initialize_bitstring(
+    integer: int, nbits: int = None, numbering_in: BitNumbering = BitNumbering.MSB, numbering_out: BitNumbering = None
+):
     if numbering_out is None:
         numbering_out = numbering_in
 

tequila/utils/exceptions.py

@@ -31,9 +31,16 @@ class TequilaParameterError(TequilaException):
     """
 
     def __init__(self, parameter_name, parameter_class, parameter_value, called_from=""):
-        self.message = "OpenVQE ParameterError:" + called_from + " unknown parameter value: " + str(
-            parameter_name) + "=" + str(
-            parameter_value) + " for " + str(parameter_class)
+        self.message = (
+            "OpenVQE ParameterError:"
+            + called_from
+            + " unknown parameter value: "
+            + str(parameter_name)
+            + "="
+            + str(parameter_value)
+            + " for "
+            + str(parameter_class)
+        )
 
 
 class TequilaTypeError(TequilaException):
@@ -42,5 +49,12 @@ class TequilaTypeError(TequilaException):
     """
 
     def __init__(self, attr, type, expected):
-        self.message = "OpenVQE TypeError: " + "excpected type: " + str(expected) + " but got type " + str(
-            type) + " for attribute " + str(attr)
+        self.message = (
+            "OpenVQE TypeError: "
+            + "excpected type: "
+            + str(expected)
+            + " but got type "
+            + str(type)
+            + " for attribute "
+            + str(attr)
+        )

tequila/utils/joined_transformation.py

@@ -1,12 +1,12 @@
 class JoinedTransformation:
-    '''
+    """
     class structure used to construct,track, and permit differentiation of the computation required
     by mathematical operations on ExpectationValues,Variables and Objectives thereof.
     JoinedTransformations allow operations to be combined.
-    '''
+    """
 
     def __init__(self, left, right, split, op):
-        '''
+        """
         :param left: Callable: the lefthand operation, one level down
         :param right: Callable: the righthand operation, one level down
         :param split: Int: the position in the call method, at which lefthand and righthand arguments split
@@ -15,21 +15,21 @@ class JoinedTransformation:
         Example: split 2, left = numpy.add, right= numpy.subtract, op = numpy.multiply, call on list of length 4:
         then the Joined Transform performs the following computation when called:
         np.Multiply(np.add(arg_0,arg_1),np.subtract(arg_2,arg_3))
-        '''
+        """
         self.split = split
         self.left = left
         self.right = right
         self.op = op
 
     def __call__(self, *args, **kwargs):
-        '''
+        """
 
         :param args: iter: the arguments to the transformation.
         :param kwargs: dict: keyword arguments to the transformation. Must be uniform.
         :return: a number, the result of the calculation.
-        '''
-        E_left = args[:self.split]
-        E_right = args[self.split:]
+        """
+        E_left = args[: self.split]
+        E_right = args[self.split :]
         if self.op is None:
             if len(args) == 1:
                 return args[0]
@@ -39,13 +39,11 @@ class JoinedTransformation:
                 print(len(args))
                 return self.op(*args)
             else:
-
                 return self.op(self.left(*E_left, **kwargs), *E_right)
         if self.left is None:
             if self.right is None:
                 return self.op(*args)
             else:
-
                 return self.op(*E_left, self.right(*E_right, **kwargs))
         else:
             return self.op(self.left(*E_left, **kwargs), self.right(*E_right, **kwargs))