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

tequila/apps/_unary_state_prep_impl.py

@@ -1,4 +1,4 @@
-'''
+"""
 A program that can generate an arbitrary quantum state.
 
 Some conditions: if the number of states exceed the total number of bits,
@@ -8,8 +8,7 @@ Code by Maha Kesebi, Toronto 2019
 Implemented with OpenVQE structures
 
 Needs complete re-implementation at some point
-
-'''
+"""
 
 from tequila.circuit import QCircuit
 from tequila.circuit.gates import CNOT, Ry, X
@@ -33,10 +32,9 @@ class SympyVariable(Variable):
 
 
 class UnaryStatePrepImpl:
-
     def alphabet(self, i: int) -> str:
         return self.alphabets[i]
-        #return "angle_{i}".format(i=i)
+        # return "angle_{i}".format(i=i)
 
     def __init__(self):
         self.left_compressed = []
@@ -44,14 +42,41 @@ class UnaryStatePrepImpl:
 
         # currenyly needs one-character symbols
         # needs complete reimplementation
-        self.alphabets = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]
+        self.alphabets = [
+            "a",
+            "b",
+            "c",
+            "d",
+            "e",
+            "f",
+            "g",
+            "h",
+            "i",
+            "j",
+            "k",
+            "l",
+            "m",
+            "n",
+            "o",
+            "p",
+            "q",
+            "r",
+            "s",
+            "t",
+            "u",
+            "v",
+            "w",
+            "x",
+            "y",
+            "z",
+        ]
 
         self.silenced = True
 
         self.coefficients = []
         self.c_i = 0
 
-    '''
+    """
     Calculates the Hamming distance between two strings of binary numbers.
     notes: if one of the strings contains a symbol (compressed) at an index
     where the other string is not compressed, then the H_dist is incremented
@@ -65,32 +90,30 @@ class UnaryStatePrepImpl:
     returns a list where the first element is the distance, and the second
     element is a list of the different indices of which the two strings
     differ.
-    '''
+    """
 
     def calc_H_distance(self, s1, s2):
-
         distance = 0
         diff_indices = []
         for i in range(len(s1)):
             if s1[i] != s2[i]:
-                if (s1[i] != '0' and s1[i] != '1') or (s2[i] != '0' and s2[i] != '1'):
-                    if not ((s1[i] != '0' and s1[i] != '1') and (s2[i] != '0' and s2[i] != '1')):
+                if (s1[i] != "0" and s1[i] != "1") or (s2[i] != "0" and s2[i] != "1"):
+                    if not ((s1[i] != "0" and s1[i] != "1") and (s2[i] != "0" and s2[i] != "1")):
                         distance += 1
                 distance += 1
                 diff_indices.append(i)
 
         return [distance, diff_indices]  ### type [ int, list[int, int ...]]
 
-    '''
+    """
     This function find the H_dist between all different combination of pairs
     in s.
     
     Returns a dictionary where the keys represent the Hamming distance, and the
     values are a list containing lists of the different pairs that have that H_dist 
-    '''
+    """
 
     def get_pairs(self, s):
-
         # intialize dictionary according to length of s
         dt = {}
         for length in range(len(s[0]) + 2):
@@ -108,7 +131,7 @@ class UnaryStatePrepImpl:
 
             return dt
 
-        while (i < len(s) - 1):
+        while i < len(s) - 1:
             if j >= len(s) - 1 and i == len(s) - 2:
                 break
 
@@ -127,7 +150,7 @@ class UnaryStatePrepImpl:
 
         return dt  ### tpye dict{ key=int: value = list[ list[string, string],  list[str, str], ..] }
 
-    '''
+    """
     This function takes s (a list of the states) and 2 indices. It find all
     possible CNOT moves to be made 
     
@@ -135,7 +158,7 @@ class UnaryStatePrepImpl:
     and the value is a list of tuples, where the tuples hold possible control bit
     index for that target index, and the control type represented by '0' for anti
     and '1' for a normal control.
-    '''
+    """
 
     def get_CNOT_moves(self, s, i1, i2):
         targets = self.calc_H_distance(s[i1], s[i2])[1]
@@ -150,60 +173,68 @@ class UnaryStatePrepImpl:
             poss_moves[target] = []
 
             for index in range(len(s[i1])):  # index of a bit in the string that could possibly be a control.
-                if index != target and s[i1][index] != s[i2][index] and (
-                        s[i1][index] == '0' or s[i1][index] == '1') and (
-                        s[i2][index] == '0' or s[i2][index] == '1'):  # control != target & != other string & != 'a'
+                if (
+                    index != target
+                    and s[i1][index] != s[i2][index]
+                    and (s[i1][index] == "0" or s[i1][index] == "1")
+                    and (s[i2][index] == "0" or s[i2][index] == "1")
+                ):  # control != target & != other string & != 'a'
                     i = 0  # use i to loop through strings to check for control
                     flag = True
-                    while i < len(s_to_check) and flag == True:
+                    while i < len(s_to_check) and flag:
                         if s[i1][index] == s_to_check[i][index] or not (
-                                s_to_check[i][index] == '0' or s_to_check[i][index] == '1'):  # making sure its a 1 or 0
+                            s_to_check[i][index] == "0" or s_to_check[i][index] == "1"
+                        ):  # making sure its a 1 or 0
                             flag = False  # can't be used for control
                         i += 1
 
-                    if flag == True:
+                    if flag:
                         poss_moves[target].append((index, s[i1][index]))
 
                     ##check with s[i2]
                     flag = True
                     i = 0  # loop through strings and check for control
 
-                    while i < len(s_to_check) and flag == True:
+                    while i < len(s_to_check) and flag:
                         if s[i2][index] == s_to_check[i][index] or not (
-                                s_to_check[i][index] == '0' or s_to_check[i][index] == '1'):
+                            s_to_check[i][index] == "0" or s_to_check[i][index] == "1"
+                        ):
                             flag = False
                         i += 1
 
-                    if flag == True:
+                    if flag:
                         poss_moves[target].append((index, s[i2][index]))
 
         return poss_moves  # type  is  dict{key = int(taget bit's index):  value = list[ tuple( int(control bit index), str(control type)),  .. ] }
 
-    '''
+    """
     
-    '''
+    """
 
     def get_CNOT_move_non_opt(self, s, i1, i2, target_index):  # TODO: make this more opt
-
         for index in range(len(s[i1])):
-
-            if index != target_index and s[i1][index] != s[i2][index] and (
-                    s[i1][index] == '0' or s[i1][index] == '1') and (s[i2][index] == '0' or s[i2][index] == '1'):
+            if (
+                index != target_index
+                and s[i1][index] != s[i2][index]
+                and (s[i1][index] == "0" or s[i1][index] == "1")
+                and (s[i2][index] == "0" or s[i2][index] == "1")
+            ):
                 return index
 
-        raise Exception('index not found')
+        raise Exception("index not found")
 
-    '''
+    """
     
-    '''
+    """
 
     def get_a_compression(self, s, i1, i2):
-        global alph_index
         target_index = self.calc_H_distance(s[i1], s[i2])[1][
-            0]  # collect target index, the bit where they are different
+            0
+        ]  # collect target index, the bit where they are different
         move_param = None
 
-        if not self.silenced: print("compression of index {} in strings {} and {}".format(target_index, s[i1], s[i2]))
+        if not self.silenced:
+            print("compression of index {} in strings {} and {}".format(target_index, s[i1], s[i2]))
 
         string_changed = s[i1]
         string = s[i1]
@@ -220,14 +251,14 @@ class UnaryStatePrepImpl:
 
         s.remove(s[i2])
 
-        if not self.silenced: print(s)
+        if not self.silenced:
+            print(s)
 
         return [s, move_param]
 
     def get_0_rotation(self, s, i):
-
         for a_index in range(len(s[i])):
-            if not (s[i][a_index] == '0' or s[i][a_index] == '1'):
+            if not (s[i][a_index] == "0" or s[i][a_index] == "1"):
                 break
         target_index = a_index
 
@@ -240,14 +271,13 @@ class UnaryStatePrepImpl:
 
         for index in range(len(s[i])):
             if index != target_index:
-
                 flag = True
 
                 for string in s_to_check:
                     if string[index] == s[i][index]:
                         flag = False  # not a possible control
 
-                if flag == True:
+                if flag:
                     c_type = s[i][index]
 
                     possible_indicies.append([index, c_type])  # tpye  is a list[ int(index of control, str(c_type)]
@@ -261,14 +291,11 @@ class UnaryStatePrepImpl:
         return possible_indicies
 
     def make_move(self, s, i1, i2, move, m_type):
-
         move_param = None
-        if m_type == 'ROT':
-
+        if m_type == "ROT":
             i = 0  # will be used to loop through s
 
             while i < len(s) and i >= 0:
-
                 control_bit_value = s[i][move[0]]  # a string
                 control_type = move[2]  # a string
 
@@ -276,10 +303,9 @@ class UnaryStatePrepImpl:
                 target_bit_index = move[1]  # an int
 
                 if control_bit_value == control_type:  # control matches type -> make move
-
                     string = s[i]
                     string = list(string)
-                    string[target_bit_index] = '0'
+                    string[target_bit_index] = "0"
                     string = "".join(string)
                     s[i] = string
 
@@ -287,30 +313,28 @@ class UnaryStatePrepImpl:
                         s.remove(s[i])  # here should add coefficients
                         i -= 1
 
-                    if control_type == '0':
-                        c_type = 'anti'
+                    if control_type == "0":
+                        c_type = "anti"
                     else:
-                        c_type = 'positive'
+                        c_type = "positive"
 
                     # if not silenced: print('move: {} control rotation from control bit index = {} and target bit index = {}'.format(c_type, control_bit_index, target_bit_index))
-                    if c_type == 'anti':
-                        m_type = 'aCROT'
+                    if c_type == "anti":
+                        m_type = "aCROT"
                     else:
-                        m_type = 'CROT'
+                        m_type = "CROT"
 
                     move_param = [m_type, control_bit_index, target_bit_index]
-                    if not self.silenced: print(move_param)
+                    if not self.silenced:
+                        print(move_param)
 
                 i += 1
 
             return [s, move_param]
 
-
-        elif m_type == 'CNOT':
-
+        elif m_type == "CNOT":
             i = 0
             while i < len(s) and i >= 0:
-
                 control_bit_value = s[i][move[0]]  # a string
                 control_type = move[2]  # a string
 
@@ -318,19 +342,17 @@ class UnaryStatePrepImpl:
                 target_bit_index = move[1]  # an int
 
                 if control_bit_value == control_type:  # control matches type -> make move
-                    if s[i][target_bit_index] == '0':
-
+                    if s[i][target_bit_index] == "0":
                         string = s[i]
                         string = list(string)
-                        string[target_bit_index] = '1'
+                        string[target_bit_index] = "1"
                         string = "".join(string)
                         s[i] = string
 
-
                     else:
                         string = s[i]
                         string = list(string)
-                        string[target_bit_index] = '0'
+                        string[target_bit_index] = "0"
                         string = "".join(string)
                         s[i] = string
 
@@ -338,34 +360,34 @@ class UnaryStatePrepImpl:
                         s.remove(s[i])  # here should add coefficients
                         i -= 1
 
-                    if control_type == '0':
-                        c_type = 'anti'
+                    if control_type == "0":
+                        c_type = "anti"
                     else:
-                        c_type = 'positive'
+                        c_type = "positive"
 
                     # if not silenced: print('move: {} control NOT from control bit index = {} and target bit index = {}'.format(c_type, control_bit_index, target_bit_index))
-                    if c_type == 'anti':
-                        m_type = 'aCNOT'
+                    if c_type == "anti":
+                        m_type = "aCNOT"
                     move_param = [m_type, control_bit_index, target_bit_index]
 
-                    if not self.silenced: print(move_param)
+                    if not self.silenced:
+                        print(move_param)
                 i += 1
 
             return [s, move_param]
 
     def get_next_move(self, s, moves_list):
-
         # first_key = next(iter(d))
         strings = s
 
         if len(strings) == 1:  # done
-
             # add X gates to get '0000'
             for index in range(len(strings[0])):
-                if strings[0][index] == '1':
-                    move = ['X', None, index]
+                if strings[0][index] == "1":
+                    move = ["X", None, index]
                     moves_list.append(move)
-            if not self.silenced: print('DONE', ' s=', s)
+            if not self.silenced:
+                print("DONE", " s=", s)
             return
 
         d = self.get_pairs(strings)  # d is a dictionary returned from get_pairs fcn call
@@ -377,7 +399,7 @@ class UnaryStatePrepImpl:
         keys = list(d.keys())
         first_key = keys[i]
 
-        while found == False and i < len(keys) - 1:
+        while not found and i < len(keys) - 1:
             if len(d[first_key]) != 0:
                 found = True
             else:
@@ -394,7 +416,6 @@ class UnaryStatePrepImpl:
             self.get_next_move(strings)  # recursive call
 
         if first_key == 1:  # need a rot move
-
             strings = self.get_a_compression(strings, index1, index2)[0]
             ####TODO add moves hereeee
 
@@ -404,39 +425,41 @@ class UnaryStatePrepImpl:
                 control_bit_index = possible_rot_controls[0][0]
                 control_type = possible_rot_controls[0][1]
                 for a_index in range(len(strings[index1])):
-                    if not (strings[index1][a_index] == '0' or strings[index1][a_index] == '1'):
+                    if not (strings[index1][a_index] == "0" or strings[index1][a_index] == "1"):
                         break
                 target_bit_index = a_index
 
                 move = [control_bit_index, target_bit_index, control_type]  ###Type [int, int, str]
 
-                strings_moves = self.make_move(strings, index1, index2, move,
-                                               'ROT')  # fcn makes move and change all strings
+                strings_moves = self.make_move(
+                    strings, index1, index2, move, "ROT"
+                )  # fcn makes move and change all strings
                 strings = strings_moves[0]
                 moves_list.append(strings_moves[1])
 
-                if not self.silenced: print(strings)
+                if not self.silenced:
+                    print(strings)
 
             # recursively call fcn on new strings
             self.get_next_move(strings, moves_list)
 
-
         elif first_key >= 2:  # needs a CNOT move
-
             a_count1 = 0
             a_count2 = 0
             for index in range(len(strings[index1])):
-                if not (strings[index1][index] == '0' or strings[index1][index] == '1') and not (
-                        strings[index2][index] == '0' or strings[index2][index] == '1'):
+                if not (strings[index1][index] == "0" or strings[index1][index] == "1") and not (
+                    strings[index2][index] == "0" or strings[index2][index] == "1"
+                ):
                     a_count1 += 0
                     # basically do nothing
-                elif not (strings[index1][index] == '0' or strings[index1][index] == '1'):
+                elif not (strings[index1][index] == "0" or strings[index1][index] == "1"):
                     a_count1 += 1
-                elif not (strings[index2][index] == '0' or strings[index2][index] == '1'):
+                elif not (strings[index2][index] == "0" or strings[index2][index] == "1"):
                     a_count2 += 1
 
             if (
-                    a_count1 > 0 or a_count2 > 0):  # TODO: test if there will be problems if bth strings contain 'a' @ same position
+                a_count1 > 0 or a_count2 > 0
+            ):  # TODO: test if there will be problems if bth strings contain 'a' @ same position
                 if a_count1 > a_count2:
                     first_key -= a_count1
                 else:
@@ -452,34 +475,37 @@ class UnaryStatePrepImpl:
                         control_bit_index = possible_rot_controls[0][0]
                         control_type = possible_rot_controls[0][1]
                         for a_index in range(len(strings[index1])):
-                            if not (strings[index1][a_index] == '0' or strings[index1][a_index] == '1'):
+                            if not (strings[index1][a_index] == "0" or strings[index1][a_index] == "1"):
                                 break
                         target_bit_index = a_index
 
                         move = [control_bit_index, target_bit_index, control_type]  ###Type [int, int, str]
 
-                        strings_moves = self.make_move(strings, index1, index2, move,
-                                                       'ROT')  # fcn makes move and change all strings
+                        strings_moves = self.make_move(
+                            strings, index1, index2, move, "ROT"
+                        )  # fcn makes move and change all strings
                         strings = strings_moves[0]
                         moves_list.append(strings_moves[1])
 
-                        if not self.silenced: print(strings)
+                        if not self.silenced:
+                            print(strings)
 
                     # recursively call fcn on new strings
                     self.get_next_move(strings, moves_list)
-                    return 'Done'
+                    return "Done"
 
             poss_c_moves = self.get_CNOT_moves(strings, index1, index2)
             first_poss_move = next(iter(poss_c_moves))  # gets first key
             target_bit_index = first_poss_move
             if len(poss_c_moves[target_bit_index]) == 0:
-                if not self.silenced: print(target_bit_index)
+                if not self.silenced:
+                    print(target_bit_index)
                 # find a c-move where u will have to change another string with it
                 # tlater:  make this more optimal -> find the index in which the least # of states will be effected
 
                 control_bit_index = self.get_CNOT_move_non_opt(strings, index1, index2, target_bit_index)
 
-                if control_bit_index == None:
+                if control_bit_index is None:
                     # must be something with a rotation
                     string_to_rotate = self.left_compressed[0]
                     possible_rot_controls = self.get_0_rotation(strings, strings.index(string_to_rotate))
@@ -487,25 +513,30 @@ class UnaryStatePrepImpl:
                         control_bit_index = possible_rot_controls[0][0]
                         control_type = possible_rot_controls[0][1]
                         for a_index in range(len(strings[index1])):
-                            if not (strings[index1][a_index] == '0' or strings[index1][a_index] == '1'):
+                            if not (strings[index1][a_index] == "0" or strings[index1][a_index] == "1"):
                                 break
                         target_bit_index = a_index
 
                         move = [control_bit_index, target_bit_index, control_type]  ###Type [int, int, str]
 
-                        strings_moves = self.make_move(strings, index1, index2, move,
-                                                       'ROT')  # fcn makes move and change all strings
+                        strings_moves = self.make_move(
+                            strings, index1, index2, move, "ROT"
+                        )  # fcn makes move and change all strings
                         strings = strings_moves[0]
                         moves_list.append(strings_moves[1])
 
-                        if not self.silenced: print(strings)
+                        if not self.silenced:
+                            print(strings)
                         self.left_compressed.remove(strings.index(string_to_rotate))
                     # recursively call fcn on new strings
                     self.get_next_move(strings, moves_list)
-                    return 'Done'
+                    return "Done"
 
-                control_type = strings[index2][
-                    control_bit_index]  # can choose strings[index1] or [index2] -> make more optimal by checking which one doesn't affect a lot of other strings
+                control_type = strings[
+                    index2
+                ][
+                    control_bit_index
+                ]  # can choose strings[index1] or [index2] -> make more optimal by checking which one doesn't affect a lot of other strings
 
             else:
                 control_bit_index = poss_c_moves[target_bit_index][0][0]
@@ -513,11 +544,12 @@ class UnaryStatePrepImpl:
 
             move = [control_bit_index, target_bit_index, control_type]  ###Type [int, int, str]
 
-            strings_moves = self.make_move(strings, index1, index2, move, 'CNOT')
+            strings_moves = self.make_move(strings, index1, index2, move, "CNOT")
             strings = strings_moves[0]
             moves_list.append(strings_moves[1])
 
-            if not self.silenced: print(strings)
+            if not self.silenced:
+                print(strings)
 
             self.get_next_move(strings, moves_list)
 
@@ -561,12 +593,11 @@ class UnaryStatePrepImpl:
 
     #####
 
-    '''
+    """
     This function extracts the equations from the state and returns them
-    '''
+    """
 
     def get_equations(f_state):
-
         equations = []
 
         for s, v in f_state.state.items():
@@ -577,17 +608,19 @@ class UnaryStatePrepImpl:
     ### main ###
 
     def get_circuit(self, s):
-        '''
+        """
         s = []
         for counter in range(4):
             string = input("Enter your state: ")
             s.append(string)
         if not silenced: print(s)
-        '''
-        if not self.silenced: print("s on start=", s)
+        """
+        if not self.silenced:
+            print("s on start=", s)
         moves_list = []
         moves_list = self.get_next_move(s, moves_list)
-        if not self.silenced: print("last s=", s)
+        if not self.silenced:
+            print("last s=", s)
 
         circuit = QCircuit()
         for move in moves_list:

tequila/apps/adapt/__init__.py

@@ -1 +1,9 @@
-from .adapt import Adapt, AdaptPoolBase, ObjectiveFactoryBase, ObjectiveFactorySequentialExcitedState, MolecularPool, PseudoSingletMolecularPool, run_molecular_adapt
+from .adapt import (
+    Adapt,
+    AdaptPoolBase,
+    ObjectiveFactoryBase,
+    ObjectiveFactorySequentialExcitedState,
+    MolecularPool,
+    PseudoSingletMolecularPool,
+    run_molecular_adapt,
+)