tequila-basic 1.9.8__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