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

tequila/ml/ml_api.py

@@ -1,29 +1,30 @@
 from .utils_ml import TequilaMLException
-from shutil import which
 from tequila.objective import Objective
-SUPPORTED_PLATFORMS = ['pytorch']
+
+SUPPORTED_PLATFORMS = ["pytorch"]
 CONVERTERS = {}
 
-#HAS_TORCH = which('torch') is not None or which('pytorch') is not None
+# HAS_TORCH = which('torch') is not None or which('pytorch') is not None
 HAS_TORCH = True
 try:
     import torch
-except:
+except Exception:
     HAS_TORCH = False
 
 if HAS_TORCH:
     from .interface_torch import TorchLayer
-    CONVERTERS['pytorch'] = TorchLayer
 
-def to_platform(objective: Objective, platform: str,
-                compile_args: dict = None, input_vars: list = None):
+    CONVERTERS["pytorch"] = TorchLayer
+
+
+def to_platform(objective: Objective, platform: str, compile_args: dict = None, input_vars: list = None):
     plat = platform.lower()
-    if plat == 'torch':
+    if plat == "torch":
         # common alias.
-        plat = 'pytorch'
+        plat = "pytorch"
 
     try:
         f = CONVERTERS[plat]
         return f(objective, compile_args, input_vars)
     except KeyError:
-        raise TequilaMLException('Desired ML platform {} either not supported, or not installed.'.format(plat))
+        raise TequilaMLException("Desired ML platform {} either not supported, or not installed.".format(plat))

tequila/ml/utils_ml.py

@@ -1,6 +1,5 @@
 from tequila.utils.exceptions import TequilaException
-from tequila.objective.objective import assign_variable, Objective,\
-    format_variable_dictionary, format_variable_list
+from tequila.objective.objective import assign_variable, Objective, format_variable_dictionary, format_variable_list
 import typing
 from tequila.simulators.simulator_api import compile
 from tequila.circuit.gradient import grad
@@ -29,12 +28,12 @@ def check_compiler_args(c_args: dict) -> typing.Dict:
     tequila.simulators.simulator_api.compile
     """
 
-    valid_keys=['backend', 'samples', 'noise', 'device', 'initial_values']
+    valid_keys = ["backend", "samples", "noise", "device", "initial_values"]
     if c_args is None:
-        return {k:None for k in valid_keys}
+        return {k: None for k in valid_keys}
     for k in c_args.keys():
         if k not in valid_keys:
-            raise TequilaException('improper keyword {} found in compilation kwargs dict; please try again.'.format(k))
+            raise TequilaException("improper keyword {} found in compilation kwargs dict; please try again.".format(k))
         else:
             pass
     for k in valid_keys:
@@ -64,8 +63,10 @@ def preamble(objective: Objective, compile_args: dict = None, input_vars: list =
         the compiled objective, it's compile arguments, its weight variables, dicts for the weight and input gradients,
         and a dictionary that links positions in an array to each variable (parses parameters).
     """
+
     def var_sorter(e):
         return hash(e.name)
+
     all_vars = objective.extract_variables()
     all_vars.sort(key=var_sorter)
     compile_args = check_compiler_args(compile_args)
@@ -80,21 +81,22 @@ def preamble(objective: Objective, compile_args: dict = None, input_vars: list =
             if var not in input_vars:
                 weight_vars.append(assign_variable(var))
 
-    init_vals = compile_args['initial_values']
+    init_vals = compile_args["initial_values"]
     if init_vals is not None:
         for k in init_vals.keys():
             if assign_variable(k) in input_vars:
-                raise TequilaMLException('initial_values contained key {},'
-                                         'which is meant to be an input variable.'.format(k))
+                raise TequilaMLException(
+                    "initial_values contained key {},which is meant to be an input variable.".format(k)
+                )
         init_vals = format_variable_dictionary(init_vals)
-    compile_args.pop('initial_values')
+    compile_args.pop("initial_values")
 
     comped = compile(objective, **compile_args)
 
     gradients = get_gradients(objective, compile_args)
     w_grad, i_grad = separate_gradients(gradients, weight_vars=weight_vars, input_vars=input_vars)
     first, second = get_variable_orders(weight_vars, input_vars)
-    compile_args['initial_values']=init_vals
+    compile_args["initial_values"] = init_vals
     return comped, compile_args, input_vars, weight_vars, i_grad, w_grad, first, second
 
 
@@ -179,4 +181,3 @@ def get_variable_orders(weight_vars, input_vars):
     for j, v in enumerate(weight_vars):
         second[j] = v
     return first, second
-

tequila/objective/__init__.py

@@ -1,5 +1,10 @@
-from tequila.objective.objective import Objective,\
-    ExpectationValue, Variable, assign_variable, format_variable_list, \
-    format_variable_dictionary
+from tequila.objective.objective import (
+    Objective,
+    ExpectationValue,
+    Variable,
+    assign_variable,
+    format_variable_list,
+    format_variable_dictionary,
+)
 
 from tequila.objective.qtensor import QTensor, VectorObjective, vectorize

tequila/objective/braket.py

@@ -7,7 +7,8 @@ from tequila.hamiltonian import paulis
 
 import numpy as np
 
-def Fidelity(bra,ket,*args,**kwargs):
+
+def Fidelity(bra, ket, *args, **kwargs):
     """
 
     Convenience initialization of an tq.Objective that corresponds to the fidelity |<bra|ket>|^2 between two quantum states
@@ -41,9 +42,10 @@ def Fidelity(bra,ket,*args,**kwargs):
     P0 = paulis.Qp(qubits)
     return ExpectationValue(H=P0, U=U, *args, **kwargs)
 
-def Overlap(bra,ket,*args,**kwargs):
+
+def Overlap(bra, ket, *args, **kwargs):
     """
-    
+
     Convenience initialization of an tq.Objective that corresponds to the overlap <bra|ket>
     initialized by the circuits bra and ket
 
@@ -55,7 +57,7 @@ def Overlap(bra,ket,*args,**kwargs):
     ----------
     bra: QCircuit
     ket: QCircuit
-    
+
     Returns:
     ----------
     A tuple of tq.Objective that evaluates to the real and imaginary part of the overlap between the two states
@@ -64,8 +66,9 @@ def Overlap(bra,ket,*args,**kwargs):
 
     return BraKet(ket=ket, bra=bra, operator=None, *args, **kwargs)
 
+
 def BraKet(ket: QCircuit, bra: QCircuit = None, operator: QubitHamiltonian = None, *args, **kwargs) -> ExpectationValue:
-    """Function that allows to calculate different quantities 
+    """Function that allows to calculate different quantities
        depending on the passed parameters:
        1) If only ket is passed, returns the overlap with itself (1).
        2) If ket and bra are passed, returns the overlap between the two states.
@@ -75,23 +78,25 @@ def BraKet(ket: QCircuit, bra: QCircuit = None, operator: QubitHamiltonian = Non
        returns an instance of tq.Objective
 
     Args:
-        ket (QCircuit): QCircuit corresponding to a state. 
+        ket (QCircuit): QCircuit corresponding to a state.
         bra (QCircuit, optional): QCircuit corresponding to a second state.
                                   Defaults to None.
-        operator (QubitHamiltonian, optional): Operator of which we want to 
-                                               calculate the transition element. 
+        operator (QubitHamiltonian, optional): Operator of which we want to
+                                               calculate the transition element.
                                                Defaults to None.
 
     Returns:
         a tuple of tq.Objective representing the real and imaginary part of the BraKet
     """
-    
+
     # allow for some convenience
     if "H" in kwargs:
         if operator is None:
-            operator=kwargs["H"]
+            operator = kwargs["H"]
         else:
-            raise TequilaException("BraKet inconsistency between operator and kwargs[\"H\"] do not given H= ... and operator= ... in the same call")
+            raise TequilaException(
+                'BraKet inconsistency between operator and kwargs["H"] do not given H= ... and operator= ... in the same call'
+            )
         kwargs.pop("H")
 
     if bra is None:
@@ -99,86 +104,89 @@ def BraKet(ket: QCircuit, bra: QCircuit = None, operator: QubitHamiltonian = Non
 
     if id(ket) == id(bra):
         if operator is None:
-            return Objective()+1.0 , Objective() 
-        return ExpectationValue(H=operator, U=ket, *args, **kwargs) , Objective()
+            return Objective() + 1.0, Objective()
+        return ExpectationValue(H=operator, U=ket, *args, **kwargs), Objective()
     else:
         if operator is None:
-            return make_overlap(U0 = bra, U1 = ket, *args, **kwargs)
-        
-        return make_transition(U0 = bra, U1 = ket, H = operator, *args, **kwargs)
+            return make_overlap(U0=bra, U1=ket, *args, **kwargs)
+
+        return make_transition(U0=bra, U1=ket, H=operator, *args, **kwargs)
 
-def make_overlap(U0:QCircuit = None, U1:QCircuit = None, *args, **kwargs) -> ExpectationValue:
-    '''
+
+def make_overlap(U0: QCircuit = None, U1: QCircuit = None, *args, **kwargs) -> ExpectationValue:
+    """
     Function that calculates the overlap between two quantum states.
 
     Parameters
     ----------
     U0 : QCircuit tequila object, corresponding to the first state (will be the bra).
-         
+
     U1 : QCircuit tequila object, corresponding to the second state (will be the ket).
 
     Returns
     -------
     Real and imaginary Tequila objectives to be simulated or compiled.
 
-    '''
-    
+    """
+
     ctrl = find_unused_qubit(U0=U0, U1=U1)
-    
-    #print('Control qubit:',ctrl)
-    
-    U_a = U0.add_controls([ctrl]) #this add the control by modifying the previous circuit
-    U_b = U1.add_controls([ctrl]) #NonType object
-    
-    #bulding the circuit for the overlap evaluation
+
+    # print('Control qubit:',ctrl)
+
+    U_a = U0.add_controls([ctrl])  # this add the control by modifying the previous circuit
+    U_b = U1.add_controls([ctrl])  # NonType object
+
+    # bulding the circuit for the overlap evaluation
     circuit = H(target=ctrl)
     circuit += X(target=ctrl)
     circuit += U_a
     circuit += X(target=ctrl)
     circuit += U_b
-    
+
     x = paulis.X(ctrl)
     y = paulis.Y(ctrl)
     Ex = ExpectationValue(H=x, U=circuit, *args, **kwargs)
     Ey = ExpectationValue(H=y, U=circuit, *args, **kwargs)
-    
+
     return Ex, Ey
 
 
-def make_transition(U0:QCircuit = None, U1:QCircuit = None, H: QubitHamiltonian = None, *args, **kwargs) -> ExpectationValue:
-    '''
+def make_transition(
+    U0: QCircuit = None, U1: QCircuit = None, H: QubitHamiltonian = None, *args, **kwargs
+) -> ExpectationValue:
+    """
     Function that calculates the transition elements of an Hamiltonian operator
     between two different quantum states.
 
     Parameters
     ----------
     U0 : QCircuit tequila object, corresponding to the first state (will be the bra).
-         
+
     U1 : QCircuit tequila object, corresponding to the second state (will be the ket).
-    
+
     H : QubitHamiltonian tequila object
-        
+
     Returns
     -------
     Real and imaginary Tequila objectives to be simulated or compiled.
 
-    '''
-    
+    """
+
     # want to measure: <U1|H|U0> -> \sum_k c_k <U1|U_k|U0>
-    
+
     trans_real = 0
     trans_im = 0
-    
+
     for ps in H.paulistrings:
-        #print('string',ps)
+        # print('string',ps)
         c_k = ps.coeff
-        #print('coeff', c_k)
+        # print('coeff', c_k)
         U_k = PauliGate(ps)
-        objective_real, objective_im = make_overlap(U0=U0, U1=U1+U_k, *args, **kwargs)
-        
-        trans_real += c_k*objective_real
-        trans_im += c_k*objective_im
+        objective_real, objective_im = make_overlap(U0=U0, U1=U1 + U_k, *args, **kwargs)
+
+        trans_real += c_k * objective_real
+        trans_im += c_k * objective_im
+
+        # print('contribution', trans_real+trans_im)
 
-        #print('contribution', trans_real+trans_im)
-        
     return trans_real, trans_im

tequila/objective/objective.py

@@ -1,4 +1,6 @@
-import typing, copy, numbers
+import typing
+import copy
+import numbers
 from typing import Union
 from tequila.grouping.compile_groups import compile_commuting_parts
 from tequila import TequilaException
@@ -11,6 +13,7 @@ import collections
 
 # convenience
 
+
 class ExpectationValueImpl:
     """
     Implements the (uncompiled) Expectation Value as a class. Should not be called directly.
@@ -114,9 +117,12 @@ class ExpectationValueImpl:
         the ExpectationValueImpl structure with mapped qubits
 
         """
-        return ExpectationValueImpl(H=tuple([H.map_qubits(qubit_map=qubit_map) for H in self.H]),
-                                    U=self.U.map_qubits(qubit_map=qubit_map), contraction=self._contraction,
-                                    shape=self._shape)
+        return ExpectationValueImpl(
+            H=tuple([H.map_qubits(qubit_map=qubit_map) for H in self.H]),
+            U=self.U.map_qubits(qubit_map=qubit_map),
+            contraction=self._contraction,
+            shape=self._shape,
+        )
 
     def map_variables(self, variables: dict, *args, **kwargs):
         """
@@ -130,17 +136,25 @@ class ExpectationValueImpl:
         Circuit with changed variables
 
         """
-        return ExpectationValueImpl(H=self.H, U=self.U.map_variables(variables=variables, *args, **kwargs),
-                                    contraction=self._contraction, shape=self._shape)
+        return ExpectationValueImpl(
+            H=self.H,
+            U=self.U.map_variables(variables=variables, *args, **kwargs),
+            contraction=self._contraction,
+            shape=self._shape,
+        )
 
     def __call__(self, *args, **kwargs):
         raise TequilaException(
-            "Tried to call uncompiled ExpectationValueImpl, compile your objective before calling with tq.compile(objective) or evaluate with tq.simulate(objective)")
+            "Tried to call uncompiled ExpectationValueImpl, compile your objective before calling with tq.compile(objective) or evaluate with tq.simulate(objective)"
+        )
 
     def info(self, short=True, *args, **kwargs):
         if short:
-            print("Expectation Value with {qubits} active qubits and {paulis} paulistrings".format(
-                qubits=len(self.U.qubits), paulis=len(self.H)))
+            print(
+                "Expectation Value with {qubits} active qubits and {paulis} paulistrings".format(
+                    qubits=len(self.U.qubits), paulis=len(self.H)
+                )
+            )
         else:
             print("Hamiltonian:\n", str(self.H))
             print("\n", str(self.U))
@@ -257,7 +271,7 @@ class Objective:
         """
         variables = []
         for arg in self.args:
-            if hasattr(arg, 'extract_variables'):
+            if hasattr(arg, "extract_variables"):
                 variables += arg.extract_variables()
             else:
                 variables += []
@@ -304,7 +318,6 @@ class Objective:
 
     @property
     def args(self) -> typing.Tuple:
-
         if self._args is None:
             return tuple()
         else:
@@ -397,7 +410,7 @@ class Objective:
 
     def __invert__(self):
         new = Objective(args=[self])
-        return new ** -1
+        return new**-1
 
     @classmethod
     def unary_operator(cls, left, op):
@@ -418,8 +431,7 @@ class Objective:
             Objective representing op applied to objective left.
 
         """
-        return Objective(args=left.args,
-                         transformation=lambda *args: op(left.transformation(*args)))
+        return Objective(args=left.args, transformation=lambda *args: op(left.transformation(*args)))
 
     @classmethod
     def binary_operator(cls, left, right, op):
@@ -451,18 +463,23 @@ class Objective:
                 return cls.unary_operator(left=left, op=lambda E: op(E, right))
             else:
                 raise TequilaException(
-                    'BinaryOperator method called on types ' + str(type(left)) + ',' + str(type(right)))
+                    "BinaryOperator method called on types " + str(type(left)) + "," + str(type(right))
+                )
         elif isinstance(left, numbers.Number):
             if isinstance(right, Objective):
                 return cls.unary_operator(left=right, op=lambda E: op(left, E))
             else:
                 raise TequilaException(
-                    'BinaryOperator method called on types ' + str(type(left)) + ',' + str(type(right)))
+                    "BinaryOperator method called on types " + str(type(left)) + "," + str(type(right))
+                )
         else:
             split_at = len(left.args)
-            return Objective(args=left.args + right.args,
-                             transformation=JoinedTransformation(left=left.transformation, right=right.transformation,
-                                                                 split=split_at, op=op))
+            return Objective(
+                args=left.args + right.args,
+                transformation=JoinedTransformation(
+                    left=left.transformation, right=right.transformation, split=split_at, op=op
+                ),
+            )
 
     def wrap(self, op):
         """
@@ -541,12 +558,14 @@ class Objective:
 
         unique = self.count_expectationvalues(unique=True)
         measurements = self.count_measurements()
-        return "Objective with {} unique expectation values\n" \
-               "total measurements = {}\n" \
-               "variables          = {}\n" \
-               "types              = {}".format(unique, measurements, variables, types)
-
-    def __call__(self, variables=None, initial_state = 0, *args, **kwargs):
+        return (
+            "Objective with {} unique expectation values\n"
+            "total measurements = {}\n"
+            "variables          = {}\n"
+            "types              = {}".format(unique, measurements, variables, types)
+        )
+
+    def __call__(self, variables=None, initial_state=0, *args, **kwargs):
         """
         Return the output of the calculation the objective represents.
 
@@ -568,14 +587,15 @@ class Objective:
         # failsafe
         check_variables = {k: k in variables for k in self.extract_variables()}
         if not all(list(check_variables.values())):
-            raise TequilaException("Objective did not receive all variables:\n"
-                                   "You gave\n"
-                                   " {}\n"
-                                   " but the objective depends on\n"
-                                   " {}\n"
-                                   " missing values for\n"
-                                   " {}".format(variables, self.extract_variables(),
-                                                [k for k, v in check_variables.items() if not v]))
+            raise TequilaException(
+                "Objective did not receive all variables:\n"
+                "You gave\n"
+                " {}\n"
+                " but the objective depends on\n"
+                " {}\n"
+                " missing values for\n"
+                " {}".format(variables, self.extract_variables(), [k for k, v in check_variables.items() if not v])
+            )
 
         # avoid multiple evaluations
         evaluated = {}
@@ -588,7 +608,7 @@ class Objective:
                 expval_result = evaluated[E]
             try:
                 expval_result = float(expval_result)
-            except:
+            except Exception:
                 pass  # allow array evaluation (non-standard operation)
             ev_array.append(expval_result)
         result = onp.asarray(self.transformation(*ev_array), dtype=float)
@@ -598,7 +618,7 @@ class Objective:
             return float(result[0])
         else:
             return result
-    
+
     def contract(self):
         """
         Exists only to be convient in optimizers, which all contract over VectrObjectives.
@@ -611,19 +631,20 @@ class Objective:
 
     def __len__(self):
         return 1
-    
+
     def is_translated(self):
         """
         check if the objective was already translated to a quantum backend
         """
         types = [type(E) for E in self.get_expectationvalues()]
         types = list(set(types))
-        if len(types)==0 or (ExpectationValueImpl in types and len(types)==1):
+        if len(types) == 0 or (ExpectationValueImpl in types and len(types) == 1):
             return False
         else:
             return True
 
-def ExpectationValue(U, H, optimize_measurements = False, *args, **kwargs) -> Objective:
+
+def ExpectationValue(U, H, optimize_measurements=False, *args, **kwargs) -> Objective:
     """
     Initialize an Objective which is just a single expectationvalue
     """
@@ -761,8 +782,10 @@ class Variable:
             new = Objective(args=[self, other], transformation=op)
         else:
             raise TequilaException(
-                "unknown type in left_helper of objective arithmetics with operation {}: {}".format(type(op),
-                                                                                                    type(other)))
+                "unknown type in left_helper of objective arithmetics with operation {}: {}".format(
+                    type(op), type(other)
+                )
+            )
         return new
 
     def _right_helper(self, op, other):
@@ -782,8 +805,10 @@ class Variable:
             new = Objective(args=[other, self], transformation=op)
         else:
             raise TequilaException(
-                "unknown type in left_helper of objective arithmetics with operation {}: {}".format(type(op),
-                                                                                                    type(other)))
+                "unknown type in left_helper of objective arithmetics with operation {}: {}".format(
+                    type(op), type(other)
+                )
+            )
         return new
 
     def __mul__(self, other):
@@ -799,7 +824,7 @@ class Variable:
         return self._left_helper(numpy.true_divide, other)
 
     def __neg__(self):
-        return Objective(args=[self], transformation=lambda v: numpy.multiply(v, -1.))
+        return Objective(args=[self], transformation=lambda v: numpy.multiply(v, -1.0))
 
     def __pow__(self, other):
         return self._left_helper(numpy.power, other)
@@ -818,7 +843,7 @@ class Variable:
 
     def __invert__(self):
         new = Objective(args=[self])
-        return new ** -1.0
+        return new**-1.0
 
     def __len__(self):
         return 1
@@ -830,7 +855,7 @@ class Variable:
             return True
 
     def apply(self, other):
-        assert (callable(other))
+        assert callable(other)
         return Objective(args=[self], transformation=other)
 
     def wrap(self, other):
@@ -841,6 +866,7 @@ class Variable:
 
     def toJson(self):
         import json
+
         return json.dumps(self, default=lambda o: o.__dict__)
 
 
@@ -860,15 +886,16 @@ class FixedVariable(float):
         return self
 
     def apply(self, other):
-        assert (callable(other))
+        assert callable(other)
         return Objective(args=[self], transformation=other)
 
     def wrap(self, other):
         return self.apply(other)
-    
+
     def map_variables(self, *args, **kwargs):
         return self
 
+
 def format_variable_list(variables: typing.List[typing.Hashable]) -> typing.List[Variable]:
     """
     Convenience functions to assign tequila variables.
@@ -888,8 +915,9 @@ def format_variable_list(variables: typing.List[typing.Hashable]) -> typing.List
         return [assign_variable(k) for k in variables]
 
 
-def format_variable_dictionary(variables: typing.Dict[typing.Hashable, typing.Any]) -> typing.Dict[
-    Variable, typing.Any]:
+def format_variable_dictionary(
+    variables: typing.Dict[typing.Hashable, typing.Any],
+) -> typing.Dict[Variable, typing.Any]:
     """
     Convenience function to assign tequila variables.
     Parameters
@@ -908,8 +936,9 @@ def format_variable_dictionary(variables: typing.Dict[typing.Hashable, typing.An
         return Variables(variables)
 
 
-def assign_variable(variable: typing.Union[typing.Hashable, numbers.Real, Variable, FixedVariable]) -> typing.Union[
-    Variable, FixedVariable]:
+def assign_variable(
+    variable: typing.Union[typing.Hashable, numbers.Real, Variable, FixedVariable],
+) -> typing.Union[Variable, FixedVariable]:
     """
     Convenience function; maps various objects into Variable, FixedVariable, or Variables, for easy duck-typing.
 
@@ -920,7 +949,7 @@ def assign_variable(variable: typing.Union[typing.Hashable, numbers.Real, Variab
 
     Raises
     ------
-    
+
     TequilaVariableException
 
 
@@ -945,8 +974,11 @@ def assign_variable(variable: typing.Union[typing.Hashable, numbers.Real, Variab
         return Variable(name=variable)
     else:
         raise TequilaVariableException(
-            "Only hashable types can be assigned to Variables. You passed down " + str(variable) + " type=" + str(
-                type(variable)))
+            "Only hashable types can be assigned to Variables. You passed down "
+            + str(variable)
+            + " type="
+            + str(type(variable))
+        )
 
 
 class Variables(collections.abc.MutableMapping):
@@ -988,5 +1020,5 @@ class Variables(collections.abc.MutableMapping):
         return result
 
     def __repr__(self):
-        xdict = {k:v for k,v in self.items()}
+        xdict = {k: v for k, v in self.items()}
         return xdict.__repr__()