From 185fe85acf14ad8b2f6fa2d2aecf422dd5a67c9f Mon Sep 17 00:00:00 2001
From: ssmaddila <siva-sri-prasanna.maddila@inrae.fr>
Date: Mon, 14 Oct 2024 15:22:42 +0200
Subject: [PATCH 01/13] Simplified definition of `NFG.generate_joint_actions`

---
 gtnash/game/normalformgame.py | 245 +++++++++++++++++-----------------
 1 file changed, 122 insertions(+), 123 deletions(-)

diff --git a/gtnash/game/normalformgame.py b/gtnash/game/normalformgame.py
index e9790b6..783caac 100644
--- a/gtnash/game/normalformgame.py
+++ b/gtnash/game/normalformgame.py
@@ -34,7 +34,7 @@ class NFG(AbstractGame):
         else:
             self.index_to_player = index_to_player
 
-    def generate_joint_actions(self, players_actions):
+    def generate_joint_actions(self, players_actions=None):
         """Generates all the possible joint strategies.
 
         :param list of lists players_actions: The list of all
@@ -43,21 +43,9 @@ class NFG(AbstractGame):
         :returns: A matrix which rows are the joint strategies.
         :rtype: np.matrix of int.
         """
-        matA = np.mat([])
-        for p_a in reversed(players_actions):
-            p_i = np.mat(p_a)
-            p_i = p_i.transpose()
-            if matA.size == 0:
-                matA = p_i
-            else:
-                one_vec = np.ones((matA.shape[0], 1))
-                mat = np.concatenate((int(p_i[0]) * one_vec, matA), axis=1)
-                for action_i in p_i[1:]:
-                    mati = np.concatenate((int(action_i) * one_vec, matA),
-                                          axis=1)
-                    mat = np.concatenate((mat, mati), axis=0)
-                matA = mat
-        return matA.astype(int)
+        if players_actions is None:
+            players_actions = self.players_actions
+        return np.matrix([jaction for jaction in itertools.product(*players_actions)])
 
     def all_response_of_player(self, player_ind, action):
         """Generates all the possible joint strategies obtained by
@@ -88,8 +76,9 @@ class NFG(AbstractGame):
             excluding player *player_ind*'s action.
         :rtype: np.matrix.
         """
-        action_in_use = [act for i, act in enumerate(self.players_actions)
-                         if (i != player_ind)]
+        action_in_use = [
+            act for i, act in enumerate(self.players_actions) if (i != player_ind)
+        ]
         return self.generate_joint_actions(action_in_use)
 
     def get_sub_jointact_of_n(self, player_ind):
@@ -110,15 +99,14 @@ class NFG(AbstractGame):
                 tmp_act = list(tmp_jact)
                 tmp_act.insert(player_ind, i)
                 tmp_index_of_alt += [
-                    np.where(
-                        (self.joint_actions == np.array(tmp_act)
-                         ).all(1))[0][0]]
+                    np.where((self.joint_actions == np.array(tmp_act)).all(1))[0][0]
+                ]
             tmp_index_of_all += [tmp_index_of_alt]
         return tmp_index_of_all
 
     def transform_utilities(self):
         """Computes the disutility matrix of the utility
-         matrix of the considered game.
+        matrix of the considered game.
 
         """
         for i in range(self.n_players):
@@ -137,8 +125,9 @@ class NFG(AbstractGame):
         :returns: rows' indices of the joint strategies list.
         :rtype: list of integers.
         """
-        return np.where(action_value == np.array(
-            self.joint_actions[:, player_id]).flatten())[0]
+        return np.where(
+            action_value == np.array(self.joint_actions[:, player_id]).flatten()
+        )[0]
 
     def disutil_of_row(self, player_id, action_value):
         """Returns the disutility of joint strategies where the
@@ -152,8 +141,7 @@ class NFG(AbstractGame):
         :rtype: list.
         """
         ind_row = self.row_where_p_is_i(player_id, action_value)
-        return np.array(self.disutilities[ind_row, player_id]
-                        ).flatten().astype(int)
+        return np.array(self.disutilities[ind_row, player_id]).flatten().astype(int)
 
     def util_of_row(self, player_id, action_value):
         """Returns the utility of joint strategies where the
@@ -166,8 +154,11 @@ class NFG(AbstractGame):
         :rtype: list.
         """
         ind_row = self.row_where_p_is_i(player_id, action_value)
-        return np.array([self.utilities[player_id][tmp_ind]
-                         for tmp_ind in ind_row]).flatten().astype(object)
+        return (
+            np.array([self.utilities[player_id][tmp_ind] for tmp_ind in ind_row])
+            .flatten()
+            .astype(object)
+        )
 
     def util_of_joint_action(self, player_id, jact):
         """Returns the utility of joint action *jact* for
@@ -217,19 +208,16 @@ class NFG(AbstractGame):
                 prob_nbis = mixed_joint_strat[nbis]
                 if not (nbis == n):
                     for j, prob_nbis_j in enumerate(prob_nbis):
-                        index_nbis_j = \
-                            self.row_where_p_is_i(
-                                nbis,
-                                self.players_actions[nbis][j])
+                        index_nbis_j = self.row_where_p_is_i(
+                            nbis, self.players_actions[nbis][j]
+                        )
                         for ind_nbis in index_nbis_j:
-                            util_of_n[ind_nbis] = \
-                                util_of_n[ind_nbis] * prob_nbis_j
+                            util_of_n[ind_nbis] = util_of_n[ind_nbis] * prob_nbis_j
             # Get the expected utility of each action
             value_all_i = []
             for i in range(len(prob_n)):
                 value_i = 0
-                index_n_i = self.row_where_p_is_i(n,
-                                                  self.players_actions[n][i])
+                index_n_i = self.row_where_p_is_i(n, self.players_actions[n][i])
                 for ind_n in index_n_i:
                     value_i += util_of_n[ind_n]
                 value_all_i += [value_i]
@@ -258,19 +246,16 @@ class NFG(AbstractGame):
             prob_nbis = mixed_joint_strat[nbis]
             if not (nbis == n):
                 for j, prob_nbis_j in enumerate(prob_nbis):
-                    index_nbis_j = \
-                        self.row_where_p_is_i(
-                            nbis,
-                            self.players_actions[nbis][j])
+                    index_nbis_j = self.row_where_p_is_i(
+                        nbis, self.players_actions[nbis][j]
+                    )
                     for ind_nbis in index_nbis_j:
-                        util_of_n[ind_nbis] = \
-                            util_of_n[ind_nbis] * prob_nbis_j
+                        util_of_n[ind_nbis] = util_of_n[ind_nbis] * prob_nbis_j
         # Get the expected utility of each action
         value_all_i = []
         for i in range(len(prob_n)):
             value_i = 0
-            index_n_i = self.row_where_p_is_i(n,
-                                              self.players_actions[n][i])
+            index_n_i = self.row_where_p_is_i(n, self.players_actions[n][i])
             for ind_n in index_n_i:
                 value_i += util_of_n[ind_n]
             value_all_i += [value_i]
@@ -315,18 +300,21 @@ class NFG(AbstractGame):
             Nash equilibrium and *False* if not.
         :rtype: boolean.
         """
-        expected_util_of_mixed_joint_strategy = \
-            self.expected_utilities(mixed_joint_strategy)
+        expected_util_of_mixed_joint_strategy = self.expected_utilities(
+            mixed_joint_strategy
+        )
         for play in range(self.n_players):
             for ai in range(len(self.players_actions[play])):
                 other_strategy = mixed_joint_strategy.copy()
-                other_strategy[play] = \
-                    np.zeros(len(mixed_joint_strategy[play]))
+                other_strategy[play] = np.zeros(len(mixed_joint_strategy[play]))
                 other_strategy[play][ai] = 1
-                expected_util_of_other = \
-                    self.expected_utilities_of_n(play, other_strategy)
-                if not (expected_util_of_other <=
-                        expected_util_of_mixed_joint_strategy[play] + gap):
+                expected_util_of_other = self.expected_utilities_of_n(
+                    play, other_strategy
+                )
+                if not (
+                    expected_util_of_other
+                    <= expected_util_of_mixed_joint_strategy[play] + gap
+                ):
                     return False
         return True
 
@@ -335,8 +323,7 @@ class NFG(AbstractGame):
             alt_jact = self.all_response_of_player(n, pure_joint_strategy)
             currentutil = self.util_of_joint_action(n, pure_joint_strategy)
             for tmp_jact in alt_jact:
-                if not (self.util_of_joint_action(n, tmp_jact) <=
-                        currentutil+gap):
+                if not (self.util_of_joint_action(n, tmp_jact) <= currentutil + gap):
                     return False
         return True
 
@@ -355,18 +342,18 @@ class NFG(AbstractGame):
         """
         all_valuediff = []
         for play in range(self.n_players):
-            expected_util_of_mixed_joint_strategy = \
-                self.expected_utilities(mixed_joint_strategy)
+            expected_util_of_mixed_joint_strategy = self.expected_utilities(
+                mixed_joint_strategy
+            )
             for ai in range(len(self.players_actions[play])):
                 other_strategy = mixed_joint_strategy.copy()
-                other_strategy[play] = np.zeros(
-                    len(mixed_joint_strategy[play]))
+                other_strategy[play] = np.zeros(len(mixed_joint_strategy[play]))
                 other_strategy[play][ai] = 1
-                expected_util_of_other =\
-                    self.expected_utilities(other_strategy)
-                all_valuediff += \
-                    [expected_util_of_other[play] -
-                     expected_util_of_mixed_joint_strategy[play]]
+                expected_util_of_other = self.expected_utilities(other_strategy)
+                all_valuediff += [
+                    expected_util_of_other[play]
+                    - expected_util_of_mixed_joint_strategy[play]
+                ]
         return max(all_valuediff)
 
     def get_all_PNE(self):
@@ -381,9 +368,13 @@ class NFG(AbstractGame):
         all_pne = []
         all_pure_strat = list(itertools.product(*self.players_actions))
         for pure_strat in all_pure_strat:
-            tmp_dic_strat = {i: [1 if self.players_actions[i][s_i] == s else 0
-                                 for s_i in range(len(self.players_actions[i]))
-                                 ] for i, s in enumerate(pure_strat)}
+            tmp_dic_strat = {
+                i: [
+                    1 if self.players_actions[i][s_i] == s else 0
+                    for s_i in range(len(self.players_actions[i]))
+                ]
+                for i, s in enumerate(pure_strat)
+            }
             pure_stratbis = list(pure_strat)
             if self.is_pure_equilibrium(pure_stratbis):
                 all_pne += [tmp_dic_strat]
@@ -415,9 +406,12 @@ class NFG(AbstractGame):
         all_pure_strat = list(itertools.product(*self.players_actions))
         for pure_strat in all_pure_strat:
             tmp_dic_strat = {
-                i: [1 if self.players_actions[i][s_i] == s else 0
-                    for s_i in range(len(self.players_actions[i]))]
-                for i, s in enumerate(pure_strat)}
+                i: [
+                    1 if self.players_actions[i][s_i] == s else 0
+                    for s_i in range(len(self.players_actions[i]))
+                ]
+                for i, s in enumerate(pure_strat)
+            }
             pure_stratbis = list(pure_strat)
             if self.is_pure_equilibrium(pure_stratbis):
                 return tmp_dic_strat
@@ -435,20 +429,19 @@ class NFG(AbstractGame):
         """
         n_players = self.n_players
         players_actions = deepcopy(self.players_actions)
-        joint_actions_before = self.generate_joint_actions(
-            self.players_actions)
+        joint_actions_before = self.generate_joint_actions(self.players_actions)
         for n in partial_mixed_strategy.keys():
             players_actions[n] = [-1]
         joint_actions_after = self.generate_joint_actions(players_actions)
-        utilities = [[0 for a in range(len(joint_actions_after))]
-                     for n in range(n_players)]
+        utilities = [
+            [0 for a in range(len(joint_actions_after))] for n in range(n_players)
+        ]
         for aa in range(len(joint_actions_after)):
             for ab in range(len(joint_actions_before)):
                 are_equal = True
                 for n in range(n_players):
                     if n not in partial_mixed_strategy.keys():
-                        if joint_actions_after[aa, n] !=\
-                                joint_actions_before[ab, n]:
+                        if joint_actions_after[aa, n] != joint_actions_before[ab, n]:
                             are_equal = False
                             break
                 if are_equal:
@@ -456,7 +449,8 @@ class NFG(AbstractGame):
                         local_proba = 1
                         for m in partial_mixed_strategy.keys():
                             local_proba *= partial_mixed_strategy[m][
-                                joint_actions_before[ab, m]]
+                                joint_actions_before[ab, m]
+                            ]
                         utilities[n][aa] += local_proba * self.utilities[n][ab]
         nfg_out = NFG(players_actions, utilities)
         return nfg_out
@@ -480,8 +474,7 @@ class NFG(AbstractGame):
         # For each actions gives its probability
         dict_actions_proba = {}
         for j, proba_k_j in enumerate(proba_k):
-            dict_actions_index[j] = self.row_where_p_is_i(
-                self.n_players - 1, j)
+            dict_actions_index[j] = self.row_where_p_is_i(self.n_players - 1, j)
             dict_actions_proba[j] = proba_k_j
         new_util = []
         new_players_action = []
@@ -495,9 +488,9 @@ class NFG(AbstractGame):
                 new_util_i = 0
                 # Compute the new utility given the probability
                 for j in range(len(proba_k)):
-                    new_util_i += util_of_n[
-                        dict_actions_index[j][i]
-                    ] * dict_actions_proba[j]
+                    new_util_i += (
+                        util_of_n[dict_actions_index[j][i]] * dict_actions_proba[j]
+                    )
                 new_util_of_n += [new_util_i]
             new_players_action += [new_players_action_of_n]
             new_util += [new_util_of_n]
@@ -571,15 +564,15 @@ class NFG(AbstractGame):
             tmp_n_act = []
             for a_i, a in enumerate(act_n):
                 if played_strat[n][a_i] == 1:
-                    tmp_n_set = tmp_n_set.union(
-                        list(self.row_where_p_is_i(n, a))
-                    )
+                    tmp_n_set = tmp_n_set.union(list(self.row_where_p_is_i(n, a)))
                     tmp_n_act += [a]
             valid_row = valid_row.intersection(tmp_n_set)
             new_player_actions += [tmp_n_act]
         list_row = sorted(valid_row)
-        new_util = [[self.utilities[n][i] for i in list_row]
-                    for n in range(len(new_player_actions))]
+        new_util = [
+            [self.utilities[n][i] for i in list_row]
+            for n in range(len(new_player_actions))
+        ]
         return NFG(new_player_actions, new_util)
 
     @classmethod
@@ -600,27 +593,26 @@ class NFG(AbstractGame):
         """
 
         # Read file
-        file_read = open(file_path, 'r')
+        file_read = open(file_path, "r")
         content = file_read.read()
         # List of content (3 String: NFG, string and rest)
         content_list = content.split('"', 2)
         game_info = content_list[2]
         file_read.close()
-        iterTest = re.finditer('{(.*?)}', game_info)
+        iterTest = re.finditer("{(.*?)}", game_info)
         p_actions = []
         # Get the name and actions of the players
         for i, s in enumerate(iterTest):
             if i > 0:
-                p_actions = [int(str_int)
-                             for str_int in shlex.split(s.group(1))]
+                p_actions = [int(str_int) for str_int in shlex.split(s.group(1))]
         payoff_value = []
-        iterTest = re.finditer('\n{1,}(.*?)\n', game_info)
+        iterTest = re.finditer("\n{1,}(.*?)\n", game_info)
         # Get the string of payoff, an iterator is use
         # but there is only 1 element to iterate on
         for s in iterTest:
-            payoff_value = [int(sub_int)
-                            for sub_int in s.group(0).strip('\n').split(" ")
-                            if sub_int]
+            payoff_value = [
+                int(sub_int) for sub_int in s.group(0).strip("\n").split(" ") if sub_int
+            ]
         n_players = len(p_actions)
         # Initialize the list of utility
         u = [[] for i in range(n_players)]
@@ -635,8 +627,9 @@ class NFG(AbstractGame):
         p_actions.reverse()
         # Generate list of actions like [[0,1,2][0,1][0,1,2,4]]
         # (for 3 player where one they have 3,2 and 4 actions)
-        players_actions = [[j for j in range(p_actions[i])]
-                           for i in range(len(p_actions))]
+        players_actions = [
+            [j for j in range(p_actions[i])] for i in range(len(p_actions))
+        ]
         return NFG(players_actions, u)
 
     def writeNFGpayoff(self, file_path):
@@ -660,8 +653,11 @@ class NFG(AbstractGame):
         jact = self.joint_actions
         # Get the utilities as a list
         util_list = self.utilities
-        payoffwrite = [util_list[n][i] for i in range(len(jact))
-                       for n in reversed(range(n_players))]
+        payoffwrite = [
+            util_list[n][i]
+            for i in range(len(jact))
+            for n in reversed(range(n_players))
+        ]
         # Reverse the order of the actions
         p_actions.reverse()
         # Create a string that correspond to the
@@ -699,7 +695,7 @@ class NFG(AbstractGame):
         :rtype: list of lists of integers.
         """
         # Read file
-        my_file = open(file_path, 'r')
+        my_file = open(file_path, "r")
         content = my_file.read()
         # List of content (3 String: NFG, string and rest)
         content_list = content.split('"', 2)
@@ -710,16 +706,16 @@ class NFG(AbstractGame):
         # Get actions of the players
         for i, s in enumerate(iterTest):
             p_actions += [len(shlex.split(s.group(0)))]
-        iterTest = re.finditer('{(.*?)}',
-                               (game_info.split("\n\n")[2]).replace(',', ''))
+        iterTest = re.finditer("{(.*?)}", (game_info.split("\n\n")[2]).replace(",", ""))
         payoff_value = []
         # Get Payoff, write it in a list as if it were written
         # like in the nfg payoff version
         for i, s in enumerate(iterTest):
-            payoff_value += [int(sub_int)
-                             for sub_ind, sub_int in
-                             enumerate(shlex.split(s.group(1)))
-                             if sub_ind != 0]
+            payoff_value += [
+                int(sub_int)
+                for sub_ind, sub_int in enumerate(shlex.split(s.group(1)))
+                if sub_ind != 0
+            ]
         # payoff_value=[int(sub_int) for sub_ind,sub_int in
         # enumerate(shlex.split(s.group(1))) if sub_ind!=0 for i,s
         # in enumerate(iterTest)]
@@ -731,8 +727,9 @@ class NFG(AbstractGame):
             u[i % n_players] += [pay]
         u.reverse()
         p_actions.reverse()
-        players_actions = [[j for j in range(p_actions[i])]
-                           for i in range(len(p_actions))]
+        players_actions = [
+            [j for j in range(p_actions[i])] for i in range(len(p_actions))
+        ]
         self.players_actions = players_actions
         self.utilities = u
         util_table = NFG(self.players_actions, self.utilities)
@@ -788,11 +785,11 @@ class NFG(AbstractGame):
             str_payoff += '{ ""'
             for n, p_n in enumerate(p):
                 if n < len(p_actions) - 1:
-                    str_payoff += f' {p_n},'
+                    str_payoff += f" {p_n},"
                 else:
-                    str_payoff += f' {p_n}'
-            str_payoff += ' }\n'
-        str_payoff += '}\n'
+                    str_payoff += f" {p_n}"
+            str_payoff += " }\n"
+        str_payoff += "}\n"
         str_jact = [str(i + 1) for i in range(len(jact))]
         str_payoff += " ".join(str_jact) + "\n"
         gamedescript = "nothing"
@@ -826,14 +823,14 @@ class NFG(AbstractGame):
         :returns: utilities table.
         :rtype: list of lists of integers.
         """
-        file_read = open(file_path, 'r')
+        file_read = open(file_path, "r")
         text = file_read.readlines()
         number_of_line = len(text)
         if number_of_line == 3:
-            print('Payoff nfg file.')
+            print("Payoff nfg file.")
             util_table = NFG.readNFGpayoff(self, file_path)
         else:
-            print('Outcome nfg file.')
+            print("Outcome nfg file.")
             util_table = NFG.readNFGoutcome(self, file_path)
         return util_table
 
@@ -851,10 +848,10 @@ class NFG(AbstractGame):
 
         """
         if isinstance(self, NFG):
-            file_path = file_path + '.nfg'
+            file_path = file_path + ".nfg"
             NFG.writeNFGpayoff(self, file_path)
         else:
-            print('Unrecognized')
+            print("Unrecognized")
 
     def __str__(self):
         """
@@ -862,14 +859,16 @@ class NFG(AbstractGame):
         """
         label = []
         for i in range(len(self.players_actions)):
-            label.append('Ax'.replace("x", str(i)))
-        for i in range(len(self.players_actions),
-                       2 * (len(self.players_actions))):
-            label.append('Ux'.replace("x", str(i - len(self.players_actions))))
+            label.append("Ax".replace("x", str(i)))
+        for i in range(len(self.players_actions), 2 * (len(self.players_actions))):
+            label.append("Ux".replace("x", str(i - len(self.players_actions))))
         mat_utilities = np.transpose(self.utilities)
         mat_utilities = mat_utilities.astype(str)
         tableau_final = np.concatenate(
-            (np.mat(label),
-             np.concatenate((self.joint_actions, mat_utilities), axis=1)),
-            axis=0)
+            (
+                np.mat(label),
+                np.concatenate((self.joint_actions, mat_utilities), axis=1),
+            ),
+            axis=0,
+        )
         return str(tableau_final)
-- 
GitLab


From 7cef5ad7a65c98deca7d37d9cbec1afb8a12d5d5 Mon Sep 17 00:00:00 2001
From: ssmaddila <siva-sri-prasanna.maddila@inrae.fr>
Date: Mon, 14 Oct 2024 15:27:49 +0200
Subject: [PATCH 02/13] minor rewrites for conciseness

---
 gtnash/game/normalformgame.py | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/gtnash/game/normalformgame.py b/gtnash/game/normalformgame.py
index 783caac..68bb9d9 100644
--- a/gtnash/game/normalformgame.py
+++ b/gtnash/game/normalformgame.py
@@ -154,10 +154,10 @@ class NFG(AbstractGame):
         :rtype: list.
         """
         ind_row = self.row_where_p_is_i(player_id, action_value)
-        return (
-            np.array([self.utilities[player_id][tmp_ind] for tmp_ind in ind_row])
-            .flatten()
-            .astype(object)
+        return list(
+            np.array(
+                [self.utilities[player_id][tmp_ind] for tmp_ind in ind_row]
+            ).flatten()
         )
 
     def util_of_joint_action(self, player_id, jact):
@@ -387,8 +387,7 @@ class NFG(AbstractGame):
             and *False* if not.
         :rtype: boolean.
         """
-        all_pure_strat = list(itertools.product(*self.players_actions))
-        for pure_strat in all_pure_strat:
+        for pure_strat in self.generate_joint_actions():
             pure_stratbis = list(pure_strat)
             if self.is_pure_equilibrium(pure_stratbis):
                 return True
-- 
GitLab


From 8cb1605a89b15994ed944b10cd11a4edafd4b857 Mon Sep 17 00:00:00 2001
From: ssmaddila <siva-sri-prasanna.maddila@inrae.fr>
Date: Mon, 14 Oct 2024 15:37:00 +0200
Subject: [PATCH 03/13] added gitignore

---
 .gitignore | 173 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 173 insertions(+)
 create mode 100644 .gitignore

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..38a0e6b
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,173 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+.ipynb*
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+#env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Vim specific swap files
+*.swp
+\\
+
+# Ctags files
+tags
+
+*.zip
+
+# Documentation artifacts
+public/
-- 
GitLab


From 6ca26b64d8e0597d2e353a0354cf69823e4d147d Mon Sep 17 00:00:00 2001
From: Prasanna Maddila <maddilaprasanna10@gmail.com>
Date: Wed, 13 Nov 2024 08:40:40 +0100
Subject: [PATCH 04/13] moved to pyproject.toml format

---
 pyproject.toml | 70 ++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 70 insertions(+)
 create mode 100644 pyproject.toml

diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..40013a7
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,70 @@
+[build-system]
+requires = ["setuptools", "setuptools-scm"]
+build-backend = "setuptools.build_meta"
+
+[project]
+    name = 'gtnash'
+    version = '1.0.0'
+    authors=[
+      {name = "Regis Sabbadin", email = "regis.sabbadin@inrae.fr"}
+    ]
+    description = "Python Nash Equilibrium Computation Utilities"
+    readme = 'README.md'
+    dependencies = ['numpy']
+
+[tool.setuptools]
+    packages = ['gtnash']
+
+[project.urls]
+    Documentation = "https://game-theory-tools-group.pages.mia.inra.fr/gtnash/main"
+    Repository = "https://forgemia.inra.fr/game-theory-tools-group/gtnash/"
+    Issues = "https://forgemia.inra.fr/game-theory-tools-group/gtnash/-/issues"
+
+[project.optional-dependencies]
+    code = ['pylint', 'black', 'pytest', 'coverage', 'pre-commit']
+    docs=['sphinx','sphinx-rtd-theme','gitpython','myst_parser']
+
+[tool.black]
+    line-length = 79
+    target-version = ['py38']
+
+[tool.pytest.ini_options]
+    minversion = '6.0'
+    addopts = '-ra -q -W ignore::DeprecationWarning'
+    testpaths = ['tests/']
+
+[tool.pylint.main]
+    fail-under = 8
+    ignore-patterns = ["^\\.#"]
+    jobs = 0
+    persistent = true
+    py-version = "3.8"
+    recursive = true
+    suggestion-mode = true
+    ignore = [".venv"]
+    disable = ["W0223", "E0401", "R0801"]
+
+[tool.pylint.format]
+    ignore-long-lines = "^\\s*(# )?<?https?://\\S+>?$"
+    indent-after-paren = 4
+    indent-string = "    "
+    max-line-length = 79
+    max-module-lines = 1000
+
+[tool.pylint.imports]
+    allow-any-import-level = true
+    allow-reexport-from-package = true
+
+[tool.pylint.miscellaneous]
+    notes = ["FIXME", "XXX", "TODO"]
+
+[tool.pylint.refactoring]
+    max-nested-blocks = 5
+    never-returning-functions = ["sys.exit", "argparse.parse_error"]
+
+[tool.coverage.run]
+omit = [
+    "examples/*",
+    "*test*",
+    "*__init__*",
+    ]
-- 
GitLab


From 1bb1020e4b528e5835170c3501e6caf7f6821ed1 Mon Sep 17 00:00:00 2001
From: Prasanna Maddila <maddilaprasanna10@gmail.com>
Date: Wed, 13 Nov 2024 08:46:07 +0100
Subject: [PATCH 05/13] NFG.expected_utilities using
 NFG.expected_utilities_of_n + Reformatted with default black

---
 gtnash/game/abstractgame.py                |   4 +-
 gtnash/game/bayesian_hypergraphicalgame.py | 318 +++++++++--------
 gtnash/game/bayesiangame.py                | 243 ++++++-------
 gtnash/game/graphicalgame.py               |  80 +++--
 gtnash/game/hypergraphicalgame.py          | 381 ++++++++++++---------
 gtnash/game/normalformgame.py              |  32 +-
 gtnash/game/polymatrixgame.py              |  13 +-
 7 files changed, 585 insertions(+), 486 deletions(-)

diff --git a/gtnash/game/abstractgame.py b/gtnash/game/abstractgame.py
index 93bd2ba..76eb5b5 100644
--- a/gtnash/game/abstractgame.py
+++ b/gtnash/game/abstractgame.py
@@ -2,8 +2,8 @@ from abc import ABC, abstractmethod
 
 
 class AbstractGame(ABC):
-    """This is the abstract game class from which all other classes derive.
-    """
+    """This is the abstract game class from which all other classes derive."""
+
     @property
     def n_players(self):
         """Number of players of input game (@property).
diff --git a/gtnash/game/bayesian_hypergraphicalgame.py b/gtnash/game/bayesian_hypergraphicalgame.py
index 6454c24..6fc0089 100644
--- a/gtnash/game/bayesian_hypergraphicalgame.py
+++ b/gtnash/game/bayesian_hypergraphicalgame.py
@@ -30,8 +30,15 @@ class BHGG(AbstractGame):
 
     """
 
-    def __init__(self, players_actions, utilities, hypergraph,
-                 theta, p, index_to_player={}):
+    def __init__(
+        self,
+        players_actions,
+        utilities,
+        hypergraph,
+        theta,
+        p,
+        index_to_player={},
+    ):
         """Hypergraphical bayesian game constructor"""
         self.n_players = len(players_actions)
         self.players_actions = players_actions
@@ -39,8 +46,10 @@ class BHGG(AbstractGame):
         self.utilities = utilities
         self.theta = theta
         self.p_unorm = p
-        self.p = [[Fraction(p_t, sum(sub_p_unorm))
-                   for p_t in sub_p_unorm]for sub_p_unorm in p]
+        self.p = [
+            [Fraction(p_t, sum(sub_p_unorm)) for p_t in sub_p_unorm]
+            for sub_p_unorm in p
+        ]
         self.local_bayesiangames = []
         for i_e, e in enumerate(hypergraph):
             self.local_bayesiangames += [self.generate_local_bayesiangame(i_e)]
@@ -57,18 +66,21 @@ class BHGG(AbstractGame):
         :returns: *bayesian_local_game*, the corresponding bayesian local game.
         :rtype: BG
         """
-        player_action_local = [self.players_actions[
-            self.hypergraph[index_game][n]]
-            for n in
-            range(len(self.hypergraph[index_game]))]
-        player_theta_local = [self.theta[self.hypergraph[index_game][n]]
-                              for n in range(len(self.hypergraph[index_game]))]
+        player_action_local = [
+            self.players_actions[self.hypergraph[index_game][n]]
+            for n in range(len(self.hypergraph[index_game]))
+        ]
+        player_theta_local = [
+            self.theta[self.hypergraph[index_game][n]]
+            for n in range(len(self.hypergraph[index_game]))
+        ]
         player_p_local = self.p[index_game]
         bayesian_local_game = BG(
             player_action_local,
             self.utilities[index_game],
             player_theta_local,
-            player_p_local)
+            player_p_local,
+        )
         return bayesian_local_game
 
     def expected_utilities(self, bayes_mixed_joint_strat):
@@ -92,22 +104,21 @@ class BHGG(AbstractGame):
             for n_local, n in enumerate(hyper_edge):
                 for t_n in local_bayesiangame.theta[n_local]:
                     local_couple_to_global[(n_local, t_n)] = (n, t_n)
-                    local_mixed_strat[(n_local, t_n)
-                                      ] = bayes_mixed_joint_strat[(n, t_n)]
+                    local_mixed_strat[(n_local, t_n)] = bayes_mixed_joint_strat[
+                        (n, t_n)
+                    ]
             expected_util_local = local_bayesiangame.expected_utilities(
-                local_mixed_strat)
-            for (n_local, t_n) in local_couple_to_global.keys():
+                local_mixed_strat
+            )
+            for n_local, t_n in local_couple_to_global.keys():
                 (n_global, t_n) = local_couple_to_global[(n_local, t_n)]
                 if (n_global, t_n) in expect_util:
-                    expect_util[(n_global, t_n)
-                                ] += expected_util_local[(n_local, t_n)]
+                    expect_util[(n_global, t_n)] += expected_util_local[(n_local, t_n)]
                 else:
-                    expect_util[(n_global, t_n)
-                                ] = expected_util_local[(n_local, t_n)]
+                    expect_util[(n_global, t_n)] = expected_util_local[(n_local, t_n)]
         return expect_util
 
-    def expected_utilities_of_n_t(self, current_n, current_t,
-                                  bayes_mixed_joint_strat):
+    def expected_utilities_of_n_t(self, current_n, current_t, bayes_mixed_joint_strat):
         expect_util = 0
         for index_hyper_edge, hyper_edge in enumerate(self.hypergraph):
             local_mixed_strat = {}
@@ -120,11 +131,12 @@ class BHGG(AbstractGame):
                         if n == current_n and t_n == current_t:
                             (curr_n_loc, curr_t_loc) = (n, t_n)
                         local_couple_to_global[(n_local, t_n)] = (n, t_n)
-                        local_mixed_strat[(n_local, t_n)] = \
-                            bayes_mixed_joint_strat[(n, t_n)]
-                expected_util_local_of_n_t = \
-                    loc_bg.expected_utilities_of_n_t(curr_n_loc, curr_t_loc,
-                                                     local_mixed_strat)
+                        local_mixed_strat[(n_local, t_n)] = bayes_mixed_joint_strat[
+                            (n, t_n)
+                        ]
+                expected_util_local_of_n_t = loc_bg.expected_utilities_of_n_t(
+                    curr_n_loc, curr_t_loc, local_mixed_strat
+                )
                 expect_util += expected_util_local_of_n_t
         return expect_util
 
@@ -135,29 +147,38 @@ class BHGG(AbstractGame):
                 label = []
                 players_id = self.hypergraph[j]
                 for i in range(len(players_id)):
-                    label.append(
-                        'Ax'.replace(
-                            "x", str(
-                                players_id[i])))  # 'A _i'
+                    label.append("Ax".replace("x", str(players_id[i])))  # 'A _i'
                 for i in range(len(players_id), 2 * (len(players_id))):
-                    label.append('Ux'.replace(
-                        "x", str(players_id[i - len(players_id)])))
-                mat_utilities = np.transpose(
-                    self.local_bayesiangames[j].utilities[t])
+                    label.append(
+                        "Ux".replace("x", str(players_id[i - len(players_id)]))
+                    )
+                mat_utilities = np.transpose(self.local_bayesiangames[j].utilities[t])
                 mat_utilities = mat_utilities.astype(str)
-                joint_actions = np.copy(
-                    self.local_bayesiangames[j].joint_actions)
-                joint_actions = \
-                    self.local_bayesiangames[j].joint_actions.astype(str)
+                joint_actions = np.copy(self.local_bayesiangames[j].joint_actions)
+                joint_actions = self.local_bayesiangames[j].joint_actions.astype(str)
                 tableau_final = np.concatenate(
-                    (np.mat(label), np.concatenate(
-                        (joint_actions, mat_utilities), axis=1)), axis=0)
-                print('Theta', t, '=',
-                      self.local_bayesiangames[j].joint_theta[t],
-                      'and P(Theta', j, ') =', self.p[j][t], '\n',
-                      tableau_final, '\n')
-        return '\n Hypergraph: \n' + \
-            str(self.hypergraph) + '\n Type: \n' + str(self.theta)
+                    (
+                        np.mat(label),
+                        np.concatenate((joint_actions, mat_utilities), axis=1),
+                    ),
+                    axis=0,
+                )
+                print(
+                    "Theta",
+                    t,
+                    "=",
+                    self.local_bayesiangames[j].joint_theta[t],
+                    "and P(Theta",
+                    j,
+                    ") =",
+                    self.p[j][t],
+                    "\n",
+                    tableau_final,
+                    "\n",
+                )
+        return (
+            "\n Hypergraph: \n" + str(self.hypergraph) + "\n Type: \n" + str(self.theta)
+        )
 
     def is_equilibrium(self, bayes_mixed_join_strat, gap=0.0001):
         """Checks whether *bayes_mixed_join_strat* \
@@ -172,19 +193,21 @@ class BHGG(AbstractGame):
         :rtype: boolean.
         """
         expected_util_of_bayes_joint_strategy = self.expected_utilities(
-            bayes_mixed_join_strat)
+            bayes_mixed_join_strat
+        )
         for n in range(self.n_players):
             for t_n in range(len(self.theta[n])):
                 for a_n in range(len(self.players_actions[n])):
                     other_strategy = bayes_mixed_join_strat.copy()
-                    other_strategy[(n, t_n)] = np.zeros(
-                        len(self.players_actions[n]))
+                    other_strategy[(n, t_n)] = np.zeros(len(self.players_actions[n]))
                     other_strategy[(n, t_n)][a_n] = 1
-                    expected_util_of_other = \
-                        self.expected_utilities_of_n_t(n, t_n, other_strategy)
-                    if expected_util_of_other \
-                            > expected_util_of_bayes_joint_strategy[(n, t_n)] \
-                            + gap:
+                    expected_util_of_other = self.expected_utilities_of_n_t(
+                        n, t_n, other_strategy
+                    )
+                    if (
+                        expected_util_of_other
+                        > expected_util_of_bayes_joint_strategy[(n, t_n)] + gap
+                    ):
                         return False
         return True
 
@@ -231,17 +254,20 @@ class BHGG(AbstractGame):
                 new_util = tmp_hgg.local_normalformgames[index_e].utilities
                 for e_n in e:
                     (n_local, t_local) = local_index_to_player[e_n]
-                    new_n_index = player_to_new_index[(
-                        bg_hyper[n_local], t_local)]
+                    new_n_index = player_to_new_index[(bg_hyper[n_local], t_local)]
                     new_e += [new_n_index]
                 local_hyper += [new_e]
                 util += [new_util]
             new_hypergraphe += local_hyper
         if max([len(e) for e in self.hypergraph]) == 2:
-            return PMG(new_players_actions, util,
-                       new_hypergraphe), index_to_old_player
-        return HGG(new_players_actions, util,
-                   new_hypergraphe), index_to_old_player
+            return (
+                PMG(new_players_actions, util, new_hypergraphe),
+                index_to_old_player,
+            )
+        return (
+            HGG(new_players_actions, util, new_hypergraphe),
+            index_to_old_player,
+        )
 
     def convert_to_NFG(self):
         """
@@ -254,8 +280,9 @@ class BHGG(AbstractGame):
         return hgg.convert_to_NFG()
 
     @classmethod
-    def random_bayesian_hyper(cls, n_players, n_actions, n_type,
-                              size_edges, connect, u_max):
+    def random_bayesian_hyper(
+        cls, n_players, n_actions, n_type, size_edges, connect, u_max
+    ):
         """ Random bayesian hypergraphical game generation.
 
         :param int n_players: Number of players of the BHGG.
@@ -272,13 +299,14 @@ class BHGG(AbstractGame):
         """
         # players_actions = [list(range(n_actions)) for n in range(n_players)]
         # players_theta = [list(range(n_type)) for n in range(n_players)]
-        nb_edge = int(connect *
-                      (math.factorial(n_players) /
-                       (math.factorial(size_edges) *
-                        math.factorial(n_players -
-                                       size_edges))))
-        all_poss_edges = list(
-            map(list, combinations(range(n_players), size_edges)))
+        nb_edge = int(
+            connect
+            * (
+                math.factorial(n_players)
+                / (math.factorial(size_edges) * math.factorial(n_players - size_edges))
+            )
+        )
+        all_poss_edges = list(map(list, combinations(range(n_players), size_edges)))
         hypergraph = []
         np.random.shuffle(all_poss_edges)
         all_players = range(n_players)
@@ -286,8 +314,7 @@ class BHGG(AbstractGame):
         while players_left or len(hypergraph) < nb_edge:
             e = all_poss_edges.pop()
             hypergraph += [e]
-            players_left = set(all_players).difference(
-                set().union(*hypergraph))
+            players_left = set(all_players).difference(set().union(*hypergraph))
             if len(hypergraph) == nb_edge and players_left:
                 np.random.shuffle(hypergraph)
                 e_remove = hypergraph.pop()
@@ -312,37 +339,32 @@ class BHGG(AbstractGame):
         :rtype: BHGG.
         """
 
-        file_read = open(file_path, 'r')
+        file_read = open(file_path, "r")
         content = file_read.read()
         content_list = content.split('"', 2)
-        if content_list[0] != 'BHGG 0 R ':
-            print('Ce fichier n est pas reconnu')
+        if content_list[0] != "BHGG 0 R ":
+            print("Ce fichier n est pas reconnu")
         else:
             game_info = content_list[2]
-            game_info_bis = (
-                game_info.split(
-                    game_info.split('\n{')[0])[1]).split('\n\n')
-            list_util_e = [txt_e_util.split('}\n')[-1]
-                           for txt_e_util in game_info_bis]
+            game_info_bis = (game_info.split(game_info.split("\n{")[0])[1]).split(
+                "\n\n"
+            )
+            list_util_e = [txt_e_util.split("}\n")[-1] for txt_e_util in game_info_bis]
             file_read.close()
-            iterTest = re.finditer('{(.*?)}', game_info)
+            iterTest = re.finditer("{(.*?)}", game_info)
             p_actions = []
             p_theta = []
             e_hyper = []
             p_unorm = []
             for i, s in enumerate(iterTest):
                 if i == 1:
-                    p_actions = [int(str_int)
-                                 for str_int in shlex.split(s.group(1))]
+                    p_actions = [int(str_int) for str_int in shlex.split(s.group(1))]
                 elif i == 2:
-                    p_theta = [int(str_int)
-                               for str_int in shlex.split(s.group(1))]
-                elif (i >= 3 and not i % 2 == 0):
-                    e_hyper += [[int(str_int)
-                                 for str_int in shlex.split(s.group(1))]]
+                    p_theta = [int(str_int) for str_int in shlex.split(s.group(1))]
+                elif i >= 3 and not i % 2 == 0:
+                    e_hyper += [[int(str_int) for str_int in shlex.split(s.group(1))]]
                 elif i >= 3:
-                    p_unorm += [[int(str_int)
-                                 for str_int in shlex.split(s.group(1))]]
+                    p_unorm += [[int(str_int) for str_int in shlex.split(s.group(1))]]
             util_glob = []
             p_unorm_glob = []
             for e_i, e in enumerate(e_hyper):
@@ -350,52 +372,63 @@ class BHGG(AbstractGame):
                 # p_actions_loc = [p_a for p_ai,
                 #                  p_a in enumerate(p_actions) if p_ai in e]
                 # n_actions_loc = np.prod(p_actions_loc)
-                p_theta_loc = [p_t for p_ti,
-                               p_t in enumerate(p_theta) if p_ti in e]
+                p_theta_loc = [p_t for p_ti, p_t in enumerate(p_theta) if p_ti in e]
                 n_theta_loc = np.prod(p_theta_loc)
                 util_local = [
-                    [[] for nt_np in range(n_player_loc)]
-                    for nt in range(n_theta_loc)]
-                tmpg_game_info = list_util_e[e_i].split('\n')
-                payoff_value = [[int(v_u) for v_u in st_util.split(
-                    " ")[:-1] if v_u] for st_util in tmpg_game_info]
+                    [[] for nt_np in range(n_player_loc)] for nt in range(n_theta_loc)
+                ]
+                tmpg_game_info = list_util_e[e_i].split("\n")
+                payoff_value = [
+                    [int(v_u) for v_u in st_util.split(" ")[:-1] if v_u]
+                    for st_util in tmpg_game_info
+                ]
                 for tu_i, tu in enumerate(payoff_value):
                     for i, pay in enumerate(tu):
                         util_local[tu_i][i % n_player_loc] += [pay]
                 for i in range(n_theta_loc):
                     util_local[i].reverse()
                 dico_p = {}
-                theta_loc = [[j for j in range(p_theta_loc[i])]
-                             for i in range(len(p_theta_loc))]
+                theta_loc = [
+                    [j for j in range(p_theta_loc[i])] for i in range(len(p_theta_loc))
+                ]
                 tmp_bg = BG([], [], [], [])
                 joint_theta_mat = tmp_bg.generate_joint_matrix(theta_loc)
                 joint_theta = []
                 for i in range(n_player_loc):
-                    sub_joint_theta = [joint_theta_mat[j, i]
-                                       for j in
-                                       range(joint_theta_mat.shape[0])]
+                    sub_joint_theta = [
+                        joint_theta_mat[j, i] for j in range(joint_theta_mat.shape[0])
+                    ]
                     joint_theta.append(sub_joint_theta)
                 for i in range(n_theta_loc):
-                    dico_p[tuple(joint_theta[j][i]
-                                 for j in range(n_player_loc))] \
-                        = p_unorm[e_i][i]
+                    dico_p[tuple(joint_theta[j][i] for j in range(n_player_loc))] = (
+                        p_unorm[e_i][i]
+                    )
                 joint_theta.reverse()
-                tmp_p = [dico_p[tuple(reversed(np.array(joint_theta)[:, i]))]
-                         for i in range(n_theta_loc)]
+                tmp_p = [
+                    dico_p[tuple(reversed(np.array(joint_theta)[:, i]))]
+                    for i in range(n_theta_loc)
+                ]
                 p_unorm_glob += [tmp_p]
                 util_glob += [util_local]
         p_actions.reverse()
         p_theta.reverse()
         players_actions = [
-            [j for j in range(p_actions[i])] for i in range(len(p_actions))]
-        players_theta = [[j for j in range(p_theta[i])]
-                         for i in range(len(p_theta))]
-        old_player_to_old = {i: list(reversed(range(len(p_actions))))[i]
-                             for i in range(len(p_actions))}
-        new_hypergraph = [sorted([old_player_to_old[e_n]
-                                 for e_n in e]) for e in e_hyper]
-        test_bhgg = BHGG(players_actions, util_glob, new_hypergraph,
-                         players_theta, p_unorm_glob)
+            [j for j in range(p_actions[i])] for i in range(len(p_actions))
+        ]
+        players_theta = [[j for j in range(p_theta[i])] for i in range(len(p_theta))]
+        old_player_to_old = {
+            i: list(reversed(range(len(p_actions))))[i] for i in range(len(p_actions))
+        }
+        new_hypergraph = [
+            sorted([old_player_to_old[e_n] for e_n in e]) for e in e_hyper
+        ]
+        test_bhgg = BHGG(
+            players_actions,
+            util_glob,
+            new_hypergraph,
+            players_theta,
+            p_unorm_glob,
+        )
         return test_bhgg
 
     def write_GameFile(self, file_path):
@@ -411,8 +444,10 @@ class BHGG(AbstractGame):
 
         """
         p_actions = [len(subl) for subl in self.players_actions]
-        jact = [self.local_bayesiangames[i].joint_actions for i in range(
-            len(self.hypergraph))]
+        jact = [
+            self.local_bayesiangames[i].joint_actions
+            for i in range(len(self.hypergraph))
+        ]
         theta = [len(subl) for subl in self.theta]
         current_p = self.p_unorm
         # Get hypergraph
@@ -426,20 +461,22 @@ class BHGG(AbstractGame):
             n_players_involved = len(hyperg[k])
             for k_t in range(len(self.utilities[k])):
                 util_list_k.append(self.utilities[k][k_t])
-            payoffwrite.append([[util_list[k][k_t][n][i]
-                                 for i in range(len(jact[k]))
-                                 for n in reversed(range(n_players_involved))]
-                                for k_t in range(len(self.utilities[k]))])
+            payoffwrite.append(
+                [
+                    [
+                        util_list[k][k_t][n][i]
+                        for i in range(len(jact[k]))
+                        for n in reversed(range(n_players_involved))
+                    ]
+                    for k_t in range(len(self.utilities[k]))
+                ]
+            )
         p_actions.reverse()
         theta.reverse()
         old_player_to_old = {
-            i: list(
-                reversed(
-                    range(
-                        self.n_players)))[i] for i in range(
-                self.n_players)}
-        new_hypergraph = [sorted([old_player_to_old[e_n]
-                                 for e_n in e]) for e in hyperg]
+            i: list(reversed(range(self.n_players)))[i] for i in range(self.n_players)
+        }
+        new_hypergraph = [sorted([old_player_to_old[e_n] for e_n in e]) for e in hyperg]
         gamedescript = "nothing"
         playernames = "{"
         nb_actions = "{"
@@ -457,22 +494,23 @@ class BHGG(AbstractGame):
             dico_p = {}
             joint_theta = []
             for i in range(e.n_players):
-                sub_joint_theta = [e.joint_theta[j, i]
-                                   for j in range(e.n_theta)]
+                sub_joint_theta = [e.joint_theta[j, i] for j in range(e.n_theta)]
                 joint_theta.append(sub_joint_theta)
             for i in range(e.n_theta):
-                dico_p[tuple(joint_theta[j][i]
-                             for j in range(e.n_players))] = current_p[e_i][i]
+                dico_p[tuple(joint_theta[j][i] for j in range(e.n_players))] = (
+                    current_p[e_i][i]
+                )
             joint_theta.reverse()
-            tmp_p = [dico_p[tuple(reversed(np.array(joint_theta)[:, i]))]
-                     for i in range(e.n_theta)]
+            tmp_p = [
+                dico_p[tuple(reversed(np.array(joint_theta)[:, i]))]
+                for i in range(e.n_theta)
+            ]
             proba = "{"
             for i in range(len(tmp_p)):
                 proba += f" {tmp_p[i]}"
             proba += " }"
             all_local_p += [proba]
-        writeligne = \
-            f'BHGG 0 R "{gamedescript}" {playernames} {nb_actions} {typ}'
+        writeligne = f'BHGG 0 R "{gamedescript}" {playernames} {nb_actions} {typ}'
         if not file_path[-5:] == ".bhgg":
             file_path += ".bhgg"
         fileTestwrite = open(file_path, "w+")
@@ -480,14 +518,14 @@ class BHGG(AbstractGame):
         for index_hyper_edge, hyper_edge in enumerate(new_hypergraph):
             str_hyper_edge = "{"
             for play in hyper_edge:
-                str_hyper_edge += f' {play}'
-            str_hyper_edge += ' }\n'
+                str_hyper_edge += f" {play}"
+            str_hyper_edge += " }\n"
             fileTestwrite.write(str_hyper_edge)
             fileTestwrite.write(all_local_p[index_hyper_edge] + "\n")
             str_utilities = ""
-            for uti in (payoffwrite[index_hyper_edge]):
+            for uti in payoffwrite[index_hyper_edge]:
                 for uti_t in uti:
-                    str_utilities += f'{int(uti_t)} '
+                    str_utilities += f"{int(uti_t)} "
                 str_utilities += "\n"
             fileTestwrite.write(str_utilities + "\n")
         fileTestwrite.close()
diff --git a/gtnash/game/bayesiangame.py b/gtnash/game/bayesiangame.py
index 70b4b04..0ac0ce1 100644
--- a/gtnash/game/bayesiangame.py
+++ b/gtnash/game/bayesiangame.py
@@ -37,15 +37,15 @@ class BG(AbstractGame):
             self.n_theta = 1  # len(theta[0])*len(theta[1])
             for i in range(self.n_players):
                 self.n_theta = self.n_theta * len(theta[i])
-        hypergraph_temp = [[j for j in range(self.n_players)]
-                           for i in range(self.n_theta)]
+        hypergraph_temp = [
+            [j for j in range(self.n_players)] for i in range(self.n_theta)
+        ]
         self.joint_theta = self.generate_joint_matrix(theta)
         self.local_normalformgames = []
         for index_hyper_edge in range(self.n_theta):
             self.local_normalformgames.append(
-                self.generate_local_normalformgame(
-                    hypergraph_temp,
-                    index_hyper_edge))
+                self.generate_local_normalformgame(hypergraph_temp, index_hyper_edge)
+            )
         self.joint_actions = self.generate_joint_matrix(players_actions)
 
     def generate_joint_matrix(self, into_mat):
@@ -69,8 +69,7 @@ class BG(AbstractGame):
                 one_vec = np.ones((matA.shape[0], 1))
                 mat = np.concatenate((int(p_i[0]) * one_vec, matA), axis=1)
                 for action_i in p_i[1:]:
-                    mati = np.concatenate((int(action_i) * one_vec, matA),
-                                          axis=1)
+                    mati = np.concatenate((int(action_i) * one_vec, matA), axis=1)
                     mat = np.concatenate((mat, mati), axis=0)
                 matA = mat
         return matA.astype(int)
@@ -88,12 +87,14 @@ class BG(AbstractGame):
         if len(self.players_actions) == 0:
             return NFG([], [])
         else:
-            players_action_involved = \
-                [self.players_actions[hypergraph_temp[index_hyper_edge][x]]
-                 for x in range(len(hypergraph_temp[index_hyper_edge]))]
-            normal_forme_game = \
-                NFG(players_action_involved,
-                    np.array(self.utilities[index_hyper_edge]))
+            players_action_involved = [
+                self.players_actions[hypergraph_temp[index_hyper_edge][x]]
+                for x in range(len(hypergraph_temp[index_hyper_edge]))
+            ]
+            normal_forme_game = NFG(
+                players_action_involved,
+                np.array(self.utilities[index_hyper_edge]),
+            )
             return normal_forme_game
 
     def proba_type(self):
@@ -118,8 +119,7 @@ class BG(AbstractGame):
         :returns: The index of the joint type.
         :rtype: int.
         """
-        return np.where(np.all(type_theta
-                               == np.array(self.joint_theta), axis=1))[0][0]
+        return np.where(np.all(type_theta == np.array(self.joint_theta), axis=1))[0][0]
         # return np.where(np.array(type_theta)==np.array(self.joint_theta))
 
     # np.where(action_value ==
@@ -142,8 +142,11 @@ class BG(AbstractGame):
         prob_type = 0
         # tmp_theta=[t_e for n,t_e in enumerate(self.theta)
         # if n!=known_player ]
-        tmp_theta_alt = [t_e for t_e in np.array(self.joint_theta)
-                         if t_e[known_player] == type_known_player]
+        tmp_theta_alt = [
+            t_e
+            for t_e in np.array(self.joint_theta)
+            if t_e[known_player] == type_known_player
+        ]
         for t_e in tmp_theta_alt:
             prob_type += dico_p[self.get_index_of_type(t_e)]
         for t_e in tmp_theta_alt:
@@ -186,22 +189,21 @@ class BG(AbstractGame):
                 dico_cond = self.conditional_probabilities(n, t_n)
                 # t_n_mixed = bayes_mixed_joint_strat[(n, t_n)]
                 somme_util_type_n = 0
-                for tmp_type in [t_e for t_e in np.array(self.joint_theta)
-                                 if t_e[n] == t_n]:
+                for tmp_type in [
+                    t_e for t_e in np.array(self.joint_theta) if t_e[n] == t_n
+                ]:
                     somme_util_type_joint = 0
-                    proba_cond_type = \
-                        dico_cond[self.get_index_of_type(tmp_type)]
-                    current_game = \
-                        dico_of_games[self.get_index_of_type(tmp_type)]
-                    current_strat = \
-                        [bayes_mixed_joint_strat[(n_p, tmp_type[n_p])]
-                         for n_p in range(self.n_players)]
+                    proba_cond_type = dico_cond[self.get_index_of_type(tmp_type)]
+                    current_game = dico_of_games[self.get_index_of_type(tmp_type)]
+                    current_strat = [
+                        bayes_mixed_joint_strat[(n_p, tmp_type[n_p])]
+                        for n_p in range(self.n_players)
+                    ]
                     for i_ja, ja in enumerate(np.array(self.joint_actions)):
                         current_proba = 1
                         for n_a, ja_a in enumerate(list(ja)):
                             current_proba *= current_strat[n_a][ja_a]
-                        somme_util_type_joint += \
-                            current_game[n][i_ja] * current_proba
+                        somme_util_type_joint += current_game[n][i_ja] * current_proba
                     somme_util_type_joint *= proba_cond_type
                     somme_util_type_n += somme_util_type_joint
                 expected_util[(n, t_n)] = somme_util_type_n
@@ -212,22 +214,19 @@ class BG(AbstractGame):
         dico_cond = self.conditional_probabilities(n, t_n)
         # t_n_mixed = bayes_mixed_joint_strat[(n, t_n)]
         somme_util_type_n = 0
-        for tmp_type in [t_e for t_e in np.array(self.joint_theta)
-                         if t_e[n] == t_n]:
+        for tmp_type in [t_e for t_e in np.array(self.joint_theta) if t_e[n] == t_n]:
             somme_util_type_joint = 0
-            proba_cond_type = \
-                dico_cond[self.get_index_of_type(tmp_type)]
-            current_game = \
-                dico_of_games[self.get_index_of_type(tmp_type)]
-            current_strat = \
-                [bayes_mixed_joint_strat[(n_p, tmp_type[n_p])]
-                 for n_p in range(self.n_players)]
+            proba_cond_type = dico_cond[self.get_index_of_type(tmp_type)]
+            current_game = dico_of_games[self.get_index_of_type(tmp_type)]
+            current_strat = [
+                bayes_mixed_joint_strat[(n_p, tmp_type[n_p])]
+                for n_p in range(self.n_players)
+            ]
             for i_ja, ja in enumerate(np.array(self.joint_actions)):
                 current_proba = 1
                 for n_a, ja_a in enumerate(list(ja)):
                     current_proba *= current_strat[n_a][ja_a]
-                somme_util_type_joint += \
-                    current_game[n][i_ja] * current_proba
+                somme_util_type_joint += current_game[n][i_ja] * current_proba
             somme_util_type_joint *= proba_cond_type
             somme_util_type_n += somme_util_type_joint
         return somme_util_type_n
@@ -250,14 +249,12 @@ class BG(AbstractGame):
             for type_n in range(len(self.theta[n])):
                 for a_i in range(len(self.players_actions[n])):
                     other_strategy = bayes_mixed_joint_strat.copy()
-                    other_strategy[(n, type_n)] = \
-                        np.zeros(len(self.players_actions[n]))
+                    other_strategy[(n, type_n)] = np.zeros(len(self.players_actions[n]))
                     other_strategy[(n, type_n)][a_i] = 1
-                    expected_util_of_other = \
-                        self.expected_utilities_of_n_t(n, type_n,
-                                                       other_strategy)
-                    if expected_util_of_other \
-                            > current_exp_util[(n, type_n)] + gap:
+                    expected_util_of_other = self.expected_utilities_of_n_t(
+                        n, type_n, other_strategy
+                    )
+                    if expected_util_of_other > current_exp_util[(n, type_n)] + gap:
                         return False
         return True
 
@@ -292,18 +289,21 @@ class BG(AbstractGame):
             for n, n_type in enumerate(t_joint):
                 local_player += [player_to_new_index[(n, n_type)]]
                 current_prob = cond_proba[player_to_new_index[(n, n_type)]][
-                    self.get_index_of_type(list(t_joint))]
+                    self.get_index_of_type(list(t_joint))
+                ]
                 local_game += [[current_prob * u for u in tmp_current_util[n]]]
             hypergraph += [local_player]
             util += [local_game]
         if self.n_players == 2:
-            return PMG(new_players_actions, util, hypergraph), \
-                index_to_old_player
+            return (
+                PMG(new_players_actions, util, hypergraph),
+                index_to_old_player,
+            )
         return HGG(new_players_actions, util, hypergraph), index_to_old_player
 
     @classmethod
     def random_game(cls, n_players, n_actions, n_type, u_max):
-        """ Random bayesian game generation.
+        """Random bayesian game generation.
 
         .. WARNING::
 
@@ -318,7 +318,7 @@ class BG(AbstractGame):
         for t_e in range(n_type_joint):
             tmp_t_e1 = []
             for n in range(n_players):
-                tmp_t_e1 += [list(np.random.randint(0, u_max, n_actions ** 2))]
+                tmp_t_e1 += [list(np.random.randint(0, u_max, n_actions**2))]
             util += [tmp_t_e1]
             prob_p += [Fraction(1, n_type_joint)]
 
@@ -326,7 +326,7 @@ class BG(AbstractGame):
 
     @classmethod
     def random_bayesian(cls, n_player, n_action, n_type, u_max):
-        """ Random bayesian game generation.
+        """Random bayesian game generation.
 
         .. WARNING::
 
@@ -335,11 +335,13 @@ class BG(AbstractGame):
         """
         player_actions = []
         player_thetas = []
-        nb_theta = n_type ** n_player
-        nb_actions = n_action ** n_player
+        nb_theta = n_type**n_player
+        nb_actions = n_action**n_player
         theta_p = np.random.dirichlet([1 for i in range(nb_theta)])
-        util = [[list(np.random.randint(0, u_max, nb_actions))
-                 for n in range(n_player)] for j_type in range(nb_theta)]
+        util = [
+            [list(np.random.randint(0, u_max, nb_actions)) for n in range(n_player)]
+            for j_type in range(nb_theta)
+        ]
         for n in range(n_player):
             player_actions += [[n_a for n_a in range(n_action)]]
             player_thetas += [[n_t for n_t in range(n_type)]]
@@ -361,37 +363,33 @@ class BG(AbstractGame):
         :rtype: list of lists of lists of integers.
         """
 
-        file_read = open(file_path, 'r')
+        file_read = open(file_path, "r")
         content = file_read.read()
         content_list = content.split('"', 2)
-        if content_list[0] != 'BG 0 R ':
-            print('Ce fichier n est pas reconnu')
+        if content_list[0] != "BG 0 R ":
+            print("Ce fichier n est pas reconnu")
             util_table = None
         else:
             game_info = content_list[2]
-            game_info_bis = game_info.split(game_info.split('}\n')[1])[1]
+            game_info_bis = game_info.split(game_info.split("}\n")[1])[1]
             file_read.close()
-            iterTest = re.finditer('{(.*?)}', game_info)
+            iterTest = re.finditer("{(.*?)}", game_info)
             p_actions = []
             p_theta = []
             p_unorm = []
             for i, s in enumerate(iterTest):
                 if i == 1:
-                    p_actions = [int(str_int)
-                                 for str_int in shlex.split(s.group(1))]
+                    p_actions = [int(str_int) for str_int in shlex.split(s.group(1))]
                 if i == 2:
-                    p_theta = [int(str_int)
-                               for str_int in shlex.split(s.group(1))]
+                    p_theta = [int(str_int) for str_int in shlex.split(s.group(1))]
                 if i == 3:
-                    p_unorm = [int(str_int)
-                               for str_int in shlex.split(s.group(1))]
+                    p_unorm = [int(str_int) for str_int in shlex.split(s.group(1))]
             utilities = []
             # payoff_value = []
             # iterTest = re.finditer('\d(.*?)\n', game_info_bis)
             payoff_str = game_info_bis.split("\n")[1:-1]
             for s in payoff_str:
-                payoff_value = [int(sub_int) for sub_int in s.split(" ")
-                                if sub_int]
+                payoff_value = [int(sub_int) for sub_int in s.split(" ") if sub_int]
                 n_players = len(p_actions)
                 # Initialize the list of utility
                 sublist_utilites = [[] for i in range(n_players)]
@@ -412,23 +410,25 @@ class BG(AbstractGame):
             p_theta.reverse()
             # Reverse proba
             dico_p = {}
-            theta = [[j for j in range(p_theta[i])]
-                     for i in range(len(p_theta))]
+            theta = [[j for j in range(p_theta[i])] for i in range(len(p_theta))]
             tmp_bg = BG([], [], [], [])
             joint_theta_mat = tmp_bg.generate_joint_matrix(theta)
             joint_theta = []
             for i in range(n_players):
-                sub_joint_theta = [joint_theta_mat[j, i]
-                                   for j in range(joint_theta_mat.shape[0])]
+                sub_joint_theta = [
+                    joint_theta_mat[j, i] for j in range(joint_theta_mat.shape[0])
+                ]
                 joint_theta.append(sub_joint_theta)
             for i in range(n_theta):
-                dico_p[tuple(joint_theta[j][i]
-                             for j in range(n_players))] = p_unorm[i]
+                dico_p[tuple(joint_theta[j][i] for j in range(n_players))] = p_unorm[i]
             joint_theta.reverse()
-            tmp_p = [dico_p[tuple(reversed(np.array(joint_theta)[:, i]))]
-                     for i in range(n_theta)]
-            players_actions = [[j for j in range(p_actions[i])]
-                               for i in range(len(p_actions))]
+            tmp_p = [
+                dico_p[tuple(reversed(np.array(joint_theta)[:, i]))]
+                for i in range(n_theta)
+            ]
+            players_actions = [
+                [j for j in range(p_actions[i])] for i in range(len(p_actions))
+            ]
             util_table = BG(players_actions, utilities, theta, tmp_p)
             return util_table
 
@@ -451,8 +451,9 @@ class BG(AbstractGame):
         p_actions = [len(subl) for subl in self.players_actions]
         # t_type = [len(subl) for subl in self.theta]
         # Get all the joint actions
-        jact = [self.local_normalformgames[i].joint_actions
-                for i in range(self.n_theta)]
+        jact = [
+            self.local_normalformgames[i].joint_actions for i in range(self.n_theta)
+        ]
         # Get theta
         theta = [len(subl) for subl in self.theta]
         # Get p
@@ -463,9 +464,12 @@ class BG(AbstractGame):
         for k in range(len(self.utilities)):
             util_list.append(self.utilities[k])
             payoffwrite.append(
-                [util_list[k][n][i]
-                 for i in range(len(jact[k]))
-                 for n in reversed(range(self.n_players))])
+                [
+                    util_list[k][n][i]
+                    for i in range(len(jact[k]))
+                    for n in reversed(range(self.n_players))
+                ]
+            )
         # Reverse the order of the actions
         p_actions.reverse()
         theta.reverse()
@@ -479,7 +483,7 @@ class BG(AbstractGame):
             playernames += f' "Player {n_p}"'
             nb_actions += f" {n_act}"
             typ += f" {theta[n_p]}"
-            if (n_p == len(p_actions) - 1):
+            if n_p == len(p_actions) - 1:
                 playernames += " }"
                 nb_actions += " }"
                 typ += " }"
@@ -487,32 +491,33 @@ class BG(AbstractGame):
         dico_p = {}
         joint_theta = []
         for i in range(self.n_players):
-            sub_joint_theta = [self.joint_theta[j, i]
-                               for j in range(self.n_theta)]
+            sub_joint_theta = [self.joint_theta[j, i] for j in range(self.n_theta)]
             joint_theta.append(sub_joint_theta)
         for i in range(self.n_theta):
-            dico_p[tuple(joint_theta[j][i]
-                         for j in range(self.n_players))] = current_p[i]
+            dico_p[tuple(joint_theta[j][i] for j in range(self.n_players))] = current_p[
+                i
+            ]
         joint_theta.reverse()
-        tmp_p = [dico_p[tuple(reversed(np.array(joint_theta)[:, i]))]
-                 for i in range(self.n_theta)]
+        tmp_p = [
+            dico_p[tuple(reversed(np.array(joint_theta)[:, i]))]
+            for i in range(self.n_theta)
+        ]
         proba = "{"
         for i in range(len(tmp_p)):
             proba += f" {tmp_p[i]}"
         proba += " }"
         # Create the prolog of the file
-        writeligne = \
-            f'BG 0 R "{gamedescript}" {playernames} {nb_actions} {typ}'
-        if not file_path[-3:] == '.bg':
-            file_path += '.bg'
+        writeligne = f'BG 0 R "{gamedescript}" {playernames} {nb_actions} {typ}'
+        if not file_path[-3:] == ".bg":
+            file_path += ".bg"
         fileTestwrite = open(file_path, "w+")
         fileTestwrite.write(writeligne + "\n\n")
         fileTestwrite.write(proba + "\n")
         # Create the rest
         for i in range(len(payoffwrite)):
             str_utilities = ""
-            for uti in (payoffwrite[i]):
-                str_utilities += f'{int(uti)} '
+            for uti in payoffwrite[i]:
+                str_utilities += f"{int(uti)} "
             fileTestwrite.write(str_utilities + "\n")
         fileTestwrite.close()
 
@@ -524,23 +529,31 @@ class BG(AbstractGame):
             label = []
             players_id = [i for i in range(self.n_players)]
             for i in range(len(players_id)):
-                label.append('Ax'.replace("x", str(players_id[i])))  # 'A _i'
+                label.append("Ax".replace("x", str(players_id[i])))  # 'A _i'
             for i in range(len(players_id), 2 * (len(players_id))):
-                label.append('Ux'.replace(
-                    "x", str(players_id[i - len(players_id)])))
-            mat_utilities = \
-                np.transpose(self.local_normalformgames[j].utilities)
+                label.append("Ux".replace("x", str(players_id[i - len(players_id)])))
+            mat_utilities = np.transpose(self.local_normalformgames[j].utilities)
             mat_utilities = mat_utilities.astype(str)
-            joint_actions = \
-                np.copy(self.local_normalformgames[j].joint_actions)
-            joint_actions = \
-                self.local_normalformgames[j].joint_actions.astype(str)
-            tableau_final = np.concatenate((np.mat(label),
-                                            np.concatenate((joint_actions,
-                                                            mat_utilities),
-                                                           axis=1)),
-                                           axis=0)
-            print('Theta', j, '=', self.joint_theta[j],
-                  'and P(Theta', j, ') =',
-                  self.p[j], '\n', tableau_final, '\n')
-        return '\n Type: \n' + str(self.theta)
+            joint_actions = np.copy(self.local_normalformgames[j].joint_actions)
+            joint_actions = self.local_normalformgames[j].joint_actions.astype(str)
+            tableau_final = np.concatenate(
+                (
+                    np.mat(label),
+                    np.concatenate((joint_actions, mat_utilities), axis=1),
+                ),
+                axis=0,
+            )
+            print(
+                "Theta",
+                j,
+                "=",
+                self.joint_theta[j],
+                "and P(Theta",
+                j,
+                ") =",
+                self.p[j],
+                "\n",
+                tableau_final,
+                "\n",
+            )
+        return "\n Type: \n" + str(self.theta)
diff --git a/gtnash/game/graphicalgame.py b/gtnash/game/graphicalgame.py
index fa77ce4..c128ec3 100644
--- a/gtnash/game/graphicalgame.py
+++ b/gtnash/game/graphicalgame.py
@@ -34,7 +34,7 @@ class GG(HGG):
         if HGG.is_GG(HGG(players_actions, utilities, hypergraph)):
             super().__init__(players_actions, utilities, hypergraph)
         else:
-            print('It is not a graphical game, please used HGG class')
+            print("It is not a graphical game, please used HGG class")
 
     def read_GameFile(self, file_path):
         """
@@ -56,42 +56,46 @@ class GG(HGG):
 
         """
         # Read file
-        file_read = open(file_path, 'r')
+        file_read = open(file_path, "r")
         content = file_read.read()
         content_list = content.split('"', 2)
-        if content_list[0] != 'GG 0 R ':
-            print('Ce fichier n est pas reconnu')
+        if content_list[0] != "GG 0 R ":
+            print("Ce fichier n est pas reconnu")
         else:
             game_info = content_list[2]
-            game_info_bis = game_info.split(game_info.split('\n{')[0])[1]
+            game_info_bis = game_info.split(game_info.split("\n{")[0])[1]
             file_read.close()
-            iterTest = re.finditer('{(.*?)}', game_info)
+            iterTest = re.finditer("{(.*?)}", game_info)
             p_actions = []
             # Get the name and actions of the players
             for i, s in enumerate(iterTest):
                 # Pas très sur du calcul de p_actions
                 if i == 1:
-                    p_actions = [int(str_int) for str_int in
-                                 shlex.split(s.group(1))]
+                    p_actions = [int(str_int) for str_int in shlex.split(s.group(1))]
             # Création de la liste de liste hypergraph
-            iterTest = re.finditer('\n{1,}{(.*?)}',
-                                   (game_info.split("\n{1,}")[0]).replace(',',
-                                                                          ''))
+            iterTest = re.finditer(
+                "\n{1,}{(.*?)}",
+                (game_info.split("\n{1,}")[0]).replace(",", ""),
+            )
             hypergraph = []
             for i, s in enumerate(iterTest):
-                sublist_hypergraph = [int(sub_int) for sub_int in
-                                      s.group(1).strip('\n').split(" ") if
-                                      sub_int]
+                sublist_hypergraph = [
+                    int(sub_int)
+                    for sub_int in s.group(1).strip("\n").split(" ")
+                    if sub_int
+                ]
                 hypergraph.append(sublist_hypergraph)
                 # Création de la liste de liste de liste des utilités
             utilities = []
-            iterTest = re.finditer('}\n(.*?)\n', game_info_bis)
+            iterTest = re.finditer("}\n(.*?)\n", game_info_bis)
             # Get the string of payoff, an iterator is use but there
             # is only 1 element to iterate on
             for i, s in enumerate(iterTest):
-                sublist_utilites = [int(sub_int) for sub_int in
-                                    s.group(1).strip('\n').split(" ") if
-                                    sub_int]
+                sublist_utilites = [
+                    int(sub_int)
+                    for sub_int in s.group(1).strip("\n").split(" ")
+                    if sub_int
+                ]
                 n_players = len(hypergraph[i])
                 # Initialize the list of utility
                 subsublist_utilities = []
@@ -100,7 +104,8 @@ class GG(HGG):
                         subsublist_utilities.append(sublist_utilites)
                     else:
                         subsublist_utilities.append(
-                            list(np.zeros(len(sublist_utilites))))
+                            list(np.zeros(len(sublist_utilites)))
+                        )
                 # According to the way the utility are written
                 # in the nfg file get for each player their utility
                 utilities.append(subsublist_utilities)
@@ -110,13 +115,13 @@ class GG(HGG):
             p_actions.reverse()
             # Generate list of actions like [[0,1,2][0,1][0,1,2,4]]
             # (for 3 player where one they have 3,2 and 4 actions)
-            players_actions = [[j for j in range(p_actions[i])] for i in
-                               range(len(p_actions))]
+            players_actions = [
+                [j for j in range(p_actions[i])] for i in range(len(p_actions))
+            ]
             self.players_actions = players_actions
             self.utilities = utilities
             self.hypergraph = hypergraph
-            util_table = GG(self.players_actions, self.utilities,
-                            self.hypergraph)
+            util_table = GG(self.players_actions, self.utilities, self.hypergraph)
             return util_table
 
     def write_GameFile(self, file_path):
@@ -132,8 +137,10 @@ class GG(HGG):
         # n_players = len(self.players_actions)
         p_actions = [len(subl) for subl in self.players_actions]
         # Get all the joint actions
-        jact = [self.local_normalformgames[i].joint_actions for i in
-                range(len(self.hypergraph))]
+        jact = [
+            self.local_normalformgames[i].joint_actions
+            for i in range(len(self.hypergraph))
+        ]
         # Get hypergraph
         hyperg = self.hypergraph
         # Get the utilities as a list
@@ -142,8 +149,13 @@ class GG(HGG):
         for k in range(len(hyperg)):
             util_list.append(self.utilities[k])
             n_players_involved = len(hyperg[k])
-            payoffwrite.append([util_list[k][n][i] for i in range(len(jact[k]))
-                                for n in reversed(range(n_players_involved))])
+            payoffwrite.append(
+                [
+                    util_list[k][n][i]
+                    for i in range(len(jact[k]))
+                    for n in reversed(range(n_players_involved))
+                ]
+            )
         # Reverse the order of the actions
         p_actions.reverse()
         # Create a string that correspond to the utility of
@@ -159,23 +171,25 @@ class GG(HGG):
                 nb_actions += " }"
         # Create the prologue of the file
         writeligne = f'GG 0 R "{gamedescript}" {playernames} {nb_actions}'
-        fileTestwrite = open(file_path + '.gg', "w+")
+        fileTestwrite = open(file_path + ".gg", "w+")
         fileTestwrite.write(writeligne + "\n")
         # Create the rest
         for index_hyper_edge, hyper_edge in enumerate(hyperg):
             str_hyper_edge = "{"
             for play in hyper_edge:
-                str_hyper_edge += f' {play}'
-            str_hyper_edge += ' }\n'
+                str_hyper_edge += f" {play}"
+            str_hyper_edge += " }\n"
             fileTestwrite.write(str_hyper_edge)
             str_utilities = ""
             for j in range(len(hyperg[index_hyper_edge])):
                 if hyperg[index_hyper_edge][j] == index_hyper_edge:
                     index_begin = len(hyperg[index_hyper_edge]) - j - 1
             for index_uti in range(
-                    len(payoffwrite[index_hyper_edge]) // len(hyper_edge)):
+                len(payoffwrite[index_hyper_edge]) // len(hyper_edge)
+            ):
                 uti = payoffwrite[index_hyper_edge][
-                    index_uti * len(hyper_edge) + index_begin]
-                str_utilities += f'{int(uti)} '
+                    index_uti * len(hyper_edge) + index_begin
+                ]
+                str_utilities += f"{int(uti)} "
             fileTestwrite.write(str_utilities + "\n")
         fileTestwrite.close()
diff --git a/gtnash/game/hypergraphicalgame.py b/gtnash/game/hypergraphicalgame.py
index f323418..b23a7cd 100644
--- a/gtnash/game/hypergraphicalgame.py
+++ b/gtnash/game/hypergraphicalgame.py
@@ -1,4 +1,3 @@
-
 from gtnash.game.abstractgame import AbstractGame
 from gtnash.game.normalformgame import NFG
 from itertools import combinations
@@ -26,10 +25,8 @@ class HGG(AbstractGame):
 
     """
 
-    def __init__(self, players_actions, utilities, hypergraph,
-                 index_to_player={}):
-        """Hypergraphical game constructor.
-        """
+    def __init__(self, players_actions, utilities, hypergraph, index_to_player={}):
+        """Hypergraphical game constructor."""
         self.n_players = len(players_actions)
         self.players_actions = players_actions
         self.hypergraph = hypergraph
@@ -37,7 +34,8 @@ class HGG(AbstractGame):
         self.local_normalformgames = []
         for index_hyper_edge, hyper_edge in enumerate(hypergraph):
             self.local_normalformgames.append(
-                self.generate_local_normalformgame(index_hyper_edge))
+                self.generate_local_normalformgame(index_hyper_edge)
+            )
         if not index_to_player:
             self.index_to_player = {i: i for i in range(self.n_players)}
         else:
@@ -59,8 +57,7 @@ class HGG(AbstractGame):
         :rtype: HGG.
         """
         players_actions = [list(range(nactions)) for n in range(nplayers)]
-        all_poss_edges = list(map(list, combinations(range(nplayers),
-                                                     size_edges)))
+        all_poss_edges = list(map(list, combinations(range(nplayers), size_edges)))
         hypergraph = []
         np.random.shuffle(all_poss_edges)
         players_left = set(range(nplayers))
@@ -72,8 +69,9 @@ class HGG(AbstractGame):
         for e in hypergraph:
             local_utility = []
             for n in e:
-                local_utility.append(list(np.random.randint(0, utilmax,
-                                                            nactions**len(e))))
+                local_utility.append(
+                    list(np.random.randint(0, utilmax, nactions ** len(e)))
+                )
             utilities.append(local_utility)
         shifted_utilities = deepcopy(utilities)
         for g in range(len(utilities)):
@@ -83,15 +81,16 @@ class HGG(AbstractGame):
         return HGG(players_actions, shifted_utilities, hypergraph)
 
     @classmethod
-    def random_hyperconnect(cls, n_players, n_actions,
-                            size_edges, connect, u_max):
+    def random_hyperconnect(cls, n_players, n_actions, size_edges, connect, u_max):
         players_actions = [list(range(n_actions)) for n in range(n_players)]
-        nb_edge = int(connect *
-                      (math.factorial(n_players) /
-                       (math.factorial(size_edges) *
-                        math.factorial(n_players - size_edges))))
-        all_poss_edges = list(map(list, combinations(range(n_players),
-                                                     size_edges)))
+        nb_edge = int(
+            connect
+            * (
+                math.factorial(n_players)
+                / (math.factorial(size_edges) * math.factorial(n_players - size_edges))
+            )
+        )
+        all_poss_edges = list(map(list, combinations(range(n_players), size_edges)))
         hypergraph = []
         np.random.shuffle(all_poss_edges)
         all_players = range(n_players)
@@ -99,15 +98,16 @@ class HGG(AbstractGame):
         while players_left or len(hypergraph) < nb_edge:
             e = all_poss_edges.pop()
             hypergraph += [e]
-            players_left = set(all_players).difference(
-                set().union(*hypergraph))
+            players_left = set(all_players).difference(set().union(*hypergraph))
             if len(hypergraph) == nb_edge and players_left:
                 np.random.shuffle(hypergraph)
                 e_remove = hypergraph.pop()
                 all_poss_edges.insert(-1, e_remove)
                 np.random.shuffle(all_poss_edges)
-        utilities = [[list(np.random.randint(0, u_max, n_actions**len(e)))
-                      for n in e]for e in hypergraph]
+        utilities = [
+            [list(np.random.randint(0, u_max, n_actions ** len(e))) for n in e]
+            for e in hypergraph
+        ]
         return HGG(players_actions, utilities, hypergraph)
 
     def generate_local_normalformgame(self, index_hyper_edge):
@@ -120,12 +120,13 @@ class HGG(AbstractGame):
         :returns: Normal-form game *normal_forme_game*.
         :rtype: NFG.
         """
-        players_action_involved = [self.players_actions[
-            self.hypergraph[index_hyper_edge][x]]
-            for x in range(len(self.hypergraph[
-                index_hyper_edge]))]
-        normal_form_game = NFG(players_action_involved,
-                               self.utilities[index_hyper_edge])
+        players_action_involved = [
+            self.players_actions[self.hypergraph[index_hyper_edge][x]]
+            for x in range(len(self.hypergraph[index_hyper_edge]))
+        ]
+        normal_form_game = NFG(
+            players_action_involved, self.utilities[index_hyper_edge]
+        )
         return normal_form_game
 
     def joint_action_except_i(self, player_ind):
@@ -146,8 +147,10 @@ class HGG(AbstractGame):
                     i = i + 1
                 player_ind_joint = i
                 list_joint_action_except_i.append(
-                    self.local_normalformgames[index_hyper_edge]
-                        .joint_action_except_i(player_ind_joint))
+                    self.local_normalformgames[index_hyper_edge].joint_action_except_i(
+                        player_ind_joint
+                    )
+                )
             else:
                 list_joint_action_except_i.append([])
         return list_joint_action_except_i
@@ -165,20 +168,23 @@ class HGG(AbstractGame):
         """
         somme_expected_util = [0 for i in range(self.n_players)]
         for index_hyper_edge, hyper_edge in enumerate(self.hypergraph):
-            mixed_joint_strat_involved = {i: mixed_joint_strat[n]
-                                          for i, n in enumerate(hyper_edge)}
+            mixed_joint_strat_involved = {
+                i: mixed_joint_strat[n] for i, n in enumerate(hyper_edge)
+            }
             local_normalgame = self.local_normalformgames[index_hyper_edge]
-            expected_util_local = \
-                local_normalgame.expected_utilities(mixed_joint_strat_involved)
+            expected_util_local = local_normalgame.expected_utilities(
+                mixed_joint_strat_involved
+            )
             compteur = 0
             expected_util = [0 for i in range(self.n_players)]
             for play in range(self.n_players):
                 if play in hyper_edge:
                     expected_util[play] = expected_util_local[compteur]
                     compteur = compteur + 1
-            somme_expected_util = \
-                [exputil + expected_util[n]
-                 for n, exputil in enumerate(somme_expected_util)]
+            somme_expected_util = [
+                exputil + expected_util[n]
+                for n, exputil in enumerate(somme_expected_util)
+            ]
         return somme_expected_util
 
     def expected_utilities_of_n(self, n, mixed_joint_strat):
@@ -194,15 +200,17 @@ class HGG(AbstractGame):
         """
         somme_expected_util = 0
         for index_hyper_edge, hyper_edge in enumerate(self.hypergraph):
-            mixed_joint_strat_involved = {i: mixed_joint_strat[n]
-                                          for i, n in enumerate(hyper_edge)}
+            mixed_joint_strat_involved = {
+                i: mixed_joint_strat[n] for i, n in enumerate(hyper_edge)
+            }
             local_normalgame = self.local_normalformgames[index_hyper_edge]
             # expected_util_local = \
             # local_normalgame.expected_utilities(mixed_joint_strat_involved)
             if n in hyper_edge:
                 n_loc = hyper_edge.index(n)
                 exp_util = local_normalgame.expected_utilities_of_n(
-                    n_loc, mixed_joint_strat_involved)
+                    n_loc, mixed_joint_strat_involved
+                )
             else:
                 exp_util = 0
             # compteur = 0
@@ -216,7 +224,7 @@ class HGG(AbstractGame):
         return somme_expected_util
 
     def util_of_joint_action(self, n, jact):
-        """ Return the utility of the player n for a given joint action
+        """Return the utility of the player n for a given joint action
 
         :param int n: Index of the player whose utility is computed
         :param list jact: List of the actions played
@@ -231,7 +239,8 @@ class HGG(AbstractGame):
                 n_in_local = hyper_edge.index(n)
                 sub_jact = [jact[ne] for ne in hyper_edge]
                 somme_util += local_normalgame.util_of_joint_action(
-                    n_in_local, sub_jact)
+                    n_in_local, sub_jact
+                )
         return somme_util
 
     def is_equilibrium(self, mixed_joint_strategy, gap=0.0001):
@@ -245,18 +254,21 @@ class HGG(AbstractGame):
             equilibrium and *False* if not.
         :rtype: boolean.
         """
-        expected_util_of_mixed_joint_strategy =\
-            self.expected_utilities(mixed_joint_strategy)
+        expected_util_of_mixed_joint_strategy = self.expected_utilities(
+            mixed_joint_strategy
+        )
         for play in range(self.n_players):
             for ai in range(len(self.players_actions[play])):
                 other_strategy = mixed_joint_strategy.copy()
-                other_strategy[play] = np.zeros(len(
-                    mixed_joint_strategy[play]))
+                other_strategy[play] = np.zeros(len(mixed_joint_strategy[play]))
                 other_strategy[play][ai] = 1
                 expected_util_of_other = self.expected_utilities_of_n(
-                    play, other_strategy)
-                if not (expected_util_of_other <=
-                        expected_util_of_mixed_joint_strategy[play] + gap):
+                    play, other_strategy
+                )
+                if not (
+                    expected_util_of_other
+                    <= expected_util_of_mixed_joint_strategy[play] + gap
+                ):
                     return False
         return True
 
@@ -276,8 +288,7 @@ class HGG(AbstractGame):
             alt_jact = tmp_nfg.all_response_of_player(n, pure_joint_strategy)
             currentutil = self.util_of_joint_action(n, pure_joint_strategy)
             for tmp_jact in alt_jact.tolist():
-                if not (self.util_of_joint_action(n, tmp_jact) <=
-                        currentutil + gap):
+                if not (self.util_of_joint_action(n, tmp_jact) <= currentutil + gap):
                     return False
         return True
 
@@ -293,10 +304,13 @@ class HGG(AbstractGame):
         all_pne = []
         all_pure_strat = list(itertools.product(*self.players_actions))
         for pure_strat in all_pure_strat:
-            tmp_dic_strat = {i: [1 if self.players_actions[i][s_i] == s else 0
-                                 for s_i in
-                                 range(len(self.players_actions[i]))]
-                             for i, s in enumerate(pure_strat)}
+            tmp_dic_strat = {
+                i: [
+                    1 if self.players_actions[i][s_i] == s else 0
+                    for s_i in range(len(self.players_actions[i]))
+                ]
+                for i, s in enumerate(pure_strat)
+            }
             if self.is_pure_equilibrium(list(pure_strat)):
                 all_pne += [tmp_dic_strat]
         return all_pne
@@ -326,9 +340,12 @@ class HGG(AbstractGame):
         all_pure_strat = list(itertools.product(*self.players_actions))
         for pure_strat in all_pure_strat:
             tmp_dic_strat = {
-                i: [1 if self.players_actions[i][s_i] == s else 0
-                    for s_i in range(len(self.players_actions[i]))] for
-                i, s in enumerate(pure_strat)}
+                i: [
+                    1 if self.players_actions[i][s_i] == s else 0
+                    for s_i in range(len(self.players_actions[i]))
+                ]
+                for i, s in enumerate(pure_strat)
+            }
             if self.is_pure_equilibrium(list(pure_strat)):
                 return tmp_dic_strat
         return {}
@@ -351,9 +368,9 @@ class HGG(AbstractGame):
                 while player != hyper_edge[i]:
                     i = i + 1
                 player_ind_joint = i
-                util[index_hyper_edge] =\
-                    self.local_normalformgames[
-                        index_hyper_edge].utilities[player_ind_joint]
+                util[index_hyper_edge] = self.local_normalformgames[
+                    index_hyper_edge
+                ].utilities[player_ind_joint]
         return util
 
     def build_subgame(self, partial_mixed_strategy):
@@ -379,8 +396,7 @@ class HGG(AbstractGame):
                 for s in set_s:
                     t = self.index_of_player_in_local(s)[e]
                     local_partial_mixed_strategy[t] = partial_mixed_strategy[s]
-                localsubgame = localgame.build_subgame(
-                    local_partial_mixed_strategy)
+                localsubgame = localgame.build_subgame(local_partial_mixed_strategy)
                 utilities[e] = localsubgame.utilities
             else:
                 utilities[e] = self.utilities[e]
@@ -427,16 +443,20 @@ class HGG(AbstractGame):
         :returns: Reduced hypergraphical game.
         :rtype: HGG.
         """
-        new_player_actions = [[n_act_a
-                               for n_act_i, n_act_a in enumerate(n_act)
-                               if played_strat[n][n_act_i] == 1]
-                              for n, n_act in enumerate(self.players_actions)]
+        new_player_actions = [
+            [
+                n_act_a
+                for n_act_i, n_act_a in enumerate(n_act)
+                if played_strat[n][n_act_i] == 1
+            ]
+            for n, n_act in enumerate(self.players_actions)
+        ]
         new_util = []
         for i_e, e in enumerate(self.hypergraph):
-            local_played_strat = {n_loc: played_strat[n]
-                                  for n_loc, n in enumerate(e)}
-            local_nfg = self.local_normalformgames[i_e].\
-                get_subgame_fixed_strat(local_played_strat)
+            local_played_strat = {n_loc: played_strat[n] for n_loc, n in enumerate(e)}
+            local_nfg = self.local_normalformgames[i_e].get_subgame_fixed_strat(
+                local_played_strat
+            )
             new_util += [local_nfg.utilities]
         return HGG(new_player_actions, new_util, self.hypergraph)
 
@@ -490,8 +510,9 @@ class HGG(AbstractGame):
         local_ind = self.local_game_of_player_n(player_ind)
         index_game_to_local_index_player = {}
         for ind in local_ind:
-            index_game_to_local_index_player[ind] = \
-                self.hypergraph[ind].index(player_ind)
+            index_game_to_local_index_player[ind] = self.hypergraph[ind].index(
+                player_ind
+            )
         return index_game_to_local_index_player
 
     def get_subgame_level(self, proba):
@@ -509,13 +530,13 @@ class HGG(AbstractGame):
         new_sub_util = []
         for i, subli in enumerate(self.hypergraph):
             if i in local_ind:
-                local_prob = [proba[sub_player_ind]
-                              for sub_player_ind in self.hypergraph[i]]
+                local_prob = [
+                    proba[sub_player_ind] for sub_player_ind in self.hypergraph[i]
+                ]
                 local_game = self.local_normalformgames[i]
                 new_g = local_game.get_subgame_level(local_prob)
                 new_sub_util += [new_g.utilities]
-                new_sub_hyper += [[p for p in subli if p !=
-                                   self.n_players - 1]]
+                new_sub_hyper += [[p for p in subli if p != self.n_players - 1]]
             else:
                 new_sub_util += [self.utilities[i]]
                 new_sub_hyper += [subli]
@@ -547,21 +568,24 @@ class HGG(AbstractGame):
                 new_index_to_player_id[p] = p
         for i, subli in enumerate(self.hypergraph):
             if i in local_ind:
-                local_prob = [proba[sub_player_ind]
-                              for sub_player_ind in self.hypergraph[i]]
+                local_prob = [
+                    proba[sub_player_ind] for sub_player_ind in self.hypergraph[i]
+                ]
                 local_game = self.local_normalformgames[i]
-                new_g = local_game.get_subgame_without_n(local_prob,
-                                                         ind_in_local[i])
+                new_g = local_game.get_subgame_without_n(local_prob, ind_in_local[i])
                 new_sub_util += [new_g.utilities]
-                new_sub_hyper += [[old_playerindex_to_new[p]
-                                   for p in subli if p != player_ind]]
+                new_sub_hyper += [
+                    [old_playerindex_to_new[p] for p in subli if p != player_ind]
+                ]
             else:
                 new_sub_util += [self.utilities[i]]
                 new_sub_hyper += [[old_playerindex_to_new[p] for p in subli]]
-        return HGG([p_act
-                    for i, p_act in enumerate(self.players_actions)
-                    if i != player_ind],
-                   new_sub_util, new_sub_hyper, new_index_to_player_id)
+        return HGG(
+            [p_act for i, p_act in enumerate(self.players_actions) if i != player_ind],
+            new_sub_util,
+            new_sub_hyper,
+            new_index_to_player_id,
+        )
 
     def get_player_interact(self, player_index):
         """
@@ -628,16 +652,25 @@ class HGG(AbstractGame):
             return False
         else:
             for index_hyper_edge in range(len(self.hypergraph)):
-                for index_play in range(self.local_normalformgames
-                                        [index_hyper_edge].n_players):
-                    if self.hypergraph[index_hyper_edge][index_play] ==\
-                            index_hyper_edge:
-                        if (self.local_normalformgames[index_hyper_edge].
-                                utilities[index_play]).any() == 0:
+                for index_play in range(
+                    self.local_normalformgames[index_hyper_edge].n_players
+                ):
+                    if (
+                        self.hypergraph[index_hyper_edge][index_play]
+                        == index_hyper_edge
+                    ):
+                        if (
+                            self.local_normalformgames[index_hyper_edge].utilities[
+                                index_play
+                            ]
+                        ).any() == 0:
                             return False
                     else:
-                        if (self.local_normalformgames[index_hyper_edge].
-                                utilities[index_play]).all() != 0:
+                        if (
+                            self.local_normalformgames[index_hyper_edge].utilities[
+                                index_play
+                            ]
+                        ).all() != 0:
                             return False
             return True
 
@@ -665,8 +698,10 @@ class HGG(AbstractGame):
         for n in range(self.n_players):
             nb_actglob *= len(self.players_actions[n])
             tmp_util += [[]]
-        tmp_nfg = NFG(self.players_actions, [[0 for j in range(nb_actglob)]
-                                             for n in range(self.n_players)])
+        tmp_nfg = NFG(
+            self.players_actions,
+            [[0 for j in range(nb_actglob)] for n in range(self.n_players)],
+        )
         for i in range(nb_actglob):
             jact_i = list(np.array(tmp_nfg.joint_actions[i])[0])
             prob_jact_i = {}
@@ -697,8 +732,9 @@ class HGG(AbstractGame):
         """
         if isinstance(nfgame, NFG):
             hypergraph = [[play for play in range(nfgame.n_players)]]
-            hypergraphical_game = HGG(nfgame.players_actions,
-                                      [nfgame.utilities], hypergraph)
+            hypergraphical_game = HGG(
+                nfgame.players_actions, [nfgame.utilities], hypergraph
+            )
         else:
             hypergraphical_game, index_to_old_player = nfgame.convert_to_HGG()
 
@@ -726,16 +762,21 @@ class HGG(AbstractGame):
             for n_i, n in enumerate(e):
                 u_p = local_util[n_i]
                 player_to_list_denom[n].update(
-                    [f_val.denominator if isinstance(f_val, Fraction) else 1
-                     for f_val in u_p])
-        player_to_lcm = {n: np.lcm.reduce(list(player_to_list_denom[n]))
-                         for n in range(self.n_players)}
+                    [
+                        f_val.denominator if isinstance(f_val, Fraction) else 1
+                        for f_val in u_p
+                    ]
+                )
+        player_to_lcm = {
+            n: np.lcm.reduce(list(player_to_list_denom[n]))
+            for n in range(self.n_players)
+        }
         for e_i, e in enumerate(self.hypergraph):
             local_util = self.utilities[e_i]
             empty_local = []
             for n_i, n in enumerate(e):
                 util_e_ni = np.array(local_util[n_i])
-                u_p0 = (util_e_ni * player_to_lcm[n]).astype('int')
+                u_p0 = (util_e_ni * player_to_lcm[n]).astype("int")
                 empty_local += [list(u_p0)]
             util_int += [empty_local]
         return HGG(self.players_actions, util_int, self.hypergraph)
@@ -755,37 +796,36 @@ class HGG(AbstractGame):
         :rtype: HGG.
         """
         # Read file
-        file_read = open(file_path, 'r')
+        file_read = open(file_path, "r")
         content = file_read.read()
         # List of content (3 String: NFG, string and rest)
         content_list = content.split('"', 2)
         game_info = content_list[2]
-        game_info_bis = game_info.split(game_info.split('\n{')[0])[1]
+        game_info_bis = game_info.split(game_info.split("\n{")[0])[1]
         file_read.close()
-        iterTest = re.finditer('{(.*?)}', game_info)
+        iterTest = re.finditer("{(.*?)}", game_info)
         p_actions = []
         # Get the name and actions of the players
         for i, s in enumerate(iterTest):
             if i == 1:
-                p_actions = [int(str_int)
-                             for str_int in shlex.split(s.group(1))]
-        iterTest = re.finditer('\n{1,}{(.*?)}',
-                               (game_info.split("\n{1,}")[0]).replace(',', ''))
+                p_actions = [int(str_int) for str_int in shlex.split(s.group(1))]
+        iterTest = re.finditer(
+            "\n{1,}{(.*?)}", (game_info.split("\n{1,}")[0]).replace(",", "")
+        )
         hypergraph = []
         for i, s in enumerate(iterTest):
-            sublist_hypergraph = [int(sub_int)
-                                  for sub_int in
-                                  s.group(1).strip('\n').split(" ") if sub_int]
+            sublist_hypergraph = [
+                int(sub_int) for sub_int in s.group(1).strip("\n").split(" ") if sub_int
+            ]
             hypergraph.append(sublist_hypergraph)
         utilities = []
-        iterTest = re.finditer('}\n(.*?)\n', game_info_bis)
+        iterTest = re.finditer("}\n(.*?)\n", game_info_bis)
         # Get the string of payoff, an iterator is used
         # but there is only 1 element to iterate on
         for i, s in enumerate(iterTest):
-            sublist_utilites = [int(sub_int)
-                                for sub_int in
-                                s.group(1).strip('\n').split(" ")
-                                if sub_int]
+            sublist_utilites = [
+                int(sub_int) for sub_int in s.group(1).strip("\n").split(" ") if sub_int
+            ]
             n_players = len(hypergraph[i])
             # Initialize the list of utility
             subsublist_utilities = [[] for i in range(n_players)]
@@ -802,12 +842,15 @@ class HGG(AbstractGame):
         p_actions.reverse()
         # Generate list of actions like [[0,1,2][0,1][0,1,2,4]]
         # (for 3 player where one they have 3,2 and 4 actions)
-        players_actions = [[j for j in range(p_actions[i])]
-                           for i in range(len(p_actions))]
-        old_player_to_old = {i: list(reversed(range(len(p_actions))))[i]
-                             for i in range(len(p_actions))}
-        new_hypergraph = [sorted([old_player_to_old[e_n] for e_n in e])
-                          for e in hypergraph]
+        players_actions = [
+            [j for j in range(p_actions[i])] for i in range(len(p_actions))
+        ]
+        old_player_to_old = {
+            i: list(reversed(range(len(p_actions))))[i] for i in range(len(p_actions))
+        }
+        new_hypergraph = [
+            sorted([old_player_to_old[e_n] for e_n in e]) for e in hypergraph
+        ]
         return HGG(players_actions, utilities, new_hypergraph)
 
     def write_GameFile(self, file_path):
@@ -826,8 +869,10 @@ class HGG(AbstractGame):
         n_players = len(self.players_actions)
         p_actions = [len(subl) for subl in self.players_actions]
         # Get all the joint actions
-        jact = [self.local_normalformgames[i].joint_actions
-                for i in range(len(self.hypergraph))]
+        jact = [
+            self.local_normalformgames[i].joint_actions
+            for i in range(len(self.hypergraph))
+        ]
         # Get hypergraph
         hyperg = self.hypergraph
         # Get the utilities as a list
@@ -836,14 +881,19 @@ class HGG(AbstractGame):
         for k in range(len(hyperg)):
             util_list.append(self.utilities[k])
             n_players_involved = len(hyperg[k])
-            payoffwrite.append([util_list[k][n][i] for i in range(len(jact[k]))
-                                for n in reversed(range(n_players_involved))])
+            payoffwrite.append(
+                [
+                    util_list[k][n][i]
+                    for i in range(len(jact[k]))
+                    for n in reversed(range(n_players_involved))
+                ]
+            )
         # Reverse the order of the actions
         p_actions.reverse()
-        old_player_to_old = {i: list(reversed(range(n_players)))[i]
-                             for i in range(n_players)}
-        new_hypergraph = [sorted([old_player_to_old[e_n] for e_n in e])
-                          for e in hyperg]
+        old_player_to_old = {
+            i: list(reversed(range(n_players)))[i] for i in range(n_players)
+        }
+        new_hypergraph = [sorted([old_player_to_old[e_n] for e_n in e]) for e in hyperg]
         # Create a string that correspond to the utility
         # of the player to write in the hgg file
         gamedescript = "nothing"
@@ -866,12 +916,12 @@ class HGG(AbstractGame):
         for index_hyper_edge, hyper_edge in enumerate(new_hypergraph):
             str_hyper_edge = "{"
             for play in hyper_edge:
-                str_hyper_edge += f' {play}'
-            str_hyper_edge += ' }\n'
+                str_hyper_edge += f" {play}"
+            str_hyper_edge += " }\n"
             fileTestwrite.write(str_hyper_edge)
             str_utilities = ""
-            for uti in (payoffwrite[index_hyper_edge]):
-                str_utilities += f'{int(uti)} '
+            for uti in payoffwrite[index_hyper_edge]:
+                str_utilities += f"{int(uti)} "
             fileTestwrite.write(str_utilities + "\n")
         fileTestwrite.close()
 
@@ -883,24 +933,22 @@ class HGG(AbstractGame):
             label = []
             players_id = self.hypergraph[j]
             for i in range(len(players_id)):
-                label.append('Ax'.replace("x", str(players_id[i])))
+                label.append("Ax".replace("x", str(players_id[i])))
             for i in range(len(players_id), 2 * (len(players_id))):
-                label.append('Ux'.replace(
-                    "x", str(players_id[i - len(players_id)])))
-            mat_utilities = \
-                np.transpose(self.local_normalformgames[j].utilities)
+                label.append("Ux".replace("x", str(players_id[i - len(players_id)])))
+            mat_utilities = np.transpose(self.local_normalformgames[j].utilities)
             mat_utilities = mat_utilities.astype(str)
-            joint_actions = \
-                np.copy(self.local_normalformgames[j].joint_actions)
-            joint_actions = \
-                self.local_normalformgames[j].joint_actions.astype(str)
-            tableau_final = \
-                np.concatenate(
-                    (np.mat(label),
-                     np.concatenate((joint_actions, mat_utilities), axis=1)),
-                    axis=0)
-            print('Local game ', j, ': \n', tableau_final)
-        return '\n Hypergraph: \n' + str(self.hypergraph)
+            joint_actions = np.copy(self.local_normalformgames[j].joint_actions)
+            joint_actions = self.local_normalformgames[j].joint_actions.astype(str)
+            tableau_final = np.concatenate(
+                (
+                    np.mat(label),
+                    np.concatenate((joint_actions, mat_utilities), axis=1),
+                ),
+                axis=0,
+            )
+            print("Local game ", j, ": \n", tableau_final)
+        return "\n Hypergraph: \n" + str(self.hypergraph)
 
     def normalize_utilities(self):
         new_util = []
@@ -908,21 +956,28 @@ class HGG(AbstractGame):
         for i_e, e in enumerate(self.hypergraph):
             util_e = self.utilities[i_e]
             for e_n, util_e_n in enumerate(util_e):
-                player_to_list_denom[e[e_n]].update([
-                    f_val.denominator if isinstance(f_val, Fraction)
-                    else 1 for f_val in util_e_n])
-        player_to_lcm = {n: np.lcm.reduce(list(player_to_list_denom[n]))
-                         for n
-                         in range(self.n_players)}
+                player_to_list_denom[e[e_n]].update(
+                    [
+                        f_val.denominator if isinstance(f_val, Fraction) else 1
+                        for f_val in util_e_n
+                    ]
+                )
+        player_to_lcm = {
+            n: np.lcm.reduce(list(player_to_list_denom[n]))
+            for n in range(self.n_players)
+        }
         for i_e, e in enumerate(self.hypergraph):
             util_e = np.array(deepcopy(self.utilities[i_e]))
             tmp_new_e = []
             for n_i, n in enumerate(e):
-                tmp_new_e_n = list(
-                    (util_e[n_i] * player_to_lcm[n]).astype('int'))
+                tmp_new_e_n = list((util_e[n_i] * player_to_lcm[n]).astype("int"))
                 player_to_list_denom[n].update(
-                    [f_val.denominator for f_val in tmp_new_e_n if
-                     isinstance(f_val, Fraction)])
+                    [
+                        f_val.denominator
+                        for f_val in tmp_new_e_n
+                        if isinstance(f_val, Fraction)
+                    ]
+                )
                 tmp_new_e += [tmp_new_e_n]
             new_util += [tmp_new_e]
         return HGG(self.players_actions, new_util, self.hypergraph)
diff --git a/gtnash/game/normalformgame.py b/gtnash/game/normalformgame.py
index 68bb9d9..34f48dc 100644
--- a/gtnash/game/normalformgame.py
+++ b/gtnash/game/normalformgame.py
@@ -198,33 +198,10 @@ class NFG(AbstractGame):
         :rtype: list of floats.
         """
 
-        expected_util = []
-        for n in mixed_joint_strat.keys():
-            prob_n = mixed_joint_strat[n]
-            util_of_n = np.copy(self.utilities[n][:]).tolist()
-            # Use the strategy of the other player to get the
-            # possible expected utility of every joint action
-            for nbis in mixed_joint_strat.keys():
-                prob_nbis = mixed_joint_strat[nbis]
-                if not (nbis == n):
-                    for j, prob_nbis_j in enumerate(prob_nbis):
-                        index_nbis_j = self.row_where_p_is_i(
-                            nbis, self.players_actions[nbis][j]
-                        )
-                        for ind_nbis in index_nbis_j:
-                            util_of_n[ind_nbis] = util_of_n[ind_nbis] * prob_nbis_j
-            # Get the expected utility of each action
-            value_all_i = []
-            for i in range(len(prob_n)):
-                value_i = 0
-                index_n_i = self.row_where_p_is_i(n, self.players_actions[n][i])
-                for ind_n in index_n_i:
-                    value_i += util_of_n[ind_n]
-                value_all_i += [value_i]
-            # The expected utility of the strategy
-            max_proba = np.array(value_all_i).dot(prob_n)
-            expected_util.append(max_proba)
-        return expected_util
+        return [
+            self.expected_utilities_of_n(n, mixed_joint_strat)
+            for n in mixed_joint_strat.keys()
+        ]
 
     def expected_utilities_of_n(self, n, mixed_joint_strat):
         """Returns the expected utilities of *mixed_joint_strategy*
@@ -238,6 +215,7 @@ class NFG(AbstractGame):
             of *mixed_joint_strategy*.
         :rtype: list of floats.
         """
+        breakpoint()
         prob_n = mixed_joint_strat[n]
         util_of_n = np.copy(self.utilities[n][:]).tolist()
         # Use the strategy of the other player to get the
diff --git a/gtnash/game/polymatrixgame.py b/gtnash/game/polymatrixgame.py
index d738486..2fa54a7 100644
--- a/gtnash/game/polymatrixgame.py
+++ b/gtnash/game/polymatrixgame.py
@@ -17,12 +17,11 @@ class PMG(HGG):
     """
 
     def __init__(self, players_actions, utilities, hypergraph):
-        """Polymatrix game constructor.
-        """
+        """Polymatrix game constructor."""
         if HGG.is_PMG(HGG(players_actions, utilities, hypergraph)):
             super().__init__(players_actions, utilities, hypergraph)
         else:
-            print('It is not a polymatrix game, please use HGG class')
+            print("It is not a polymatrix game, please use HGG class")
 
     def read_GameFile(self, file_path):
         """Using a .hgg game file (polymatrix games are specific
@@ -40,7 +39,9 @@ class PMG(HGG):
         :rtype: list of lists of integers.
         """
         util_table_hgg = HGG.read_GameFile(self, file_path)
-        util_table = PMG(util_table_hgg.players_actions,
-                         util_table_hgg.utilities,
-                         util_table_hgg.hypergraph)
+        util_table = PMG(
+            util_table_hgg.players_actions,
+            util_table_hgg.utilities,
+            util_table_hgg.hypergraph,
+        )
         return util_table
-- 
GitLab


From e9155013b8a565302dc3e16758186d2c123ec135 Mon Sep 17 00:00:00 2001
From: Prasanna Maddila <maddilaprasanna10@gmail.com>
Date: Wed, 13 Nov 2024 09:08:18 +0100
Subject: [PATCH 06/13] Refactored NFG.expected_utilities to use numpy
 operations

---
 gtnash/game/normalformgame.py | 33 ++++++++-------------------------
 1 file changed, 8 insertions(+), 25 deletions(-)

diff --git a/gtnash/game/normalformgame.py b/gtnash/game/normalformgame.py
index 34f48dc..8cbf0cb 100644
--- a/gtnash/game/normalformgame.py
+++ b/gtnash/game/normalformgame.py
@@ -215,31 +215,14 @@ class NFG(AbstractGame):
             of *mixed_joint_strategy*.
         :rtype: list of floats.
         """
-        breakpoint()
-        prob_n = mixed_joint_strat[n]
-        util_of_n = np.copy(self.utilities[n][:]).tolist()
-        # Use the strategy of the other player to get the
-        # possible expected utility of every joint action
-        for nbis in mixed_joint_strat.keys():
-            prob_nbis = mixed_joint_strat[nbis]
-            if not (nbis == n):
-                for j, prob_nbis_j in enumerate(prob_nbis):
-                    index_nbis_j = self.row_where_p_is_i(
-                        nbis, self.players_actions[nbis][j]
-                    )
-                    for ind_nbis in index_nbis_j:
-                        util_of_n[ind_nbis] = util_of_n[ind_nbis] * prob_nbis_j
-        # Get the expected utility of each action
-        value_all_i = []
-        for i in range(len(prob_n)):
-            value_i = 0
-            index_n_i = self.row_where_p_is_i(n, self.players_actions[n][i])
-            for ind_n in index_n_i:
-                value_i += util_of_n[ind_n]
-            value_all_i += [value_i]
-        # The expected utility of the strategy
-        max_proba = np.array(value_all_i).dot(prob_n)
-        return max_proba
+        # ravel(outer(a, b)) -> ravel([ a_i b_j ]_{n \times m}) -> [a_i b_j]_{nm \times 1}
+        joint_prob = None
+        for strat in mixed_joint_strat.values():
+            if joint_prob is None:
+                joint_prob = np.array(strat)
+            else:
+                joint_prob = np.ravel(np.outer(joint_prob, strat))
+        return np.dot(joint_prob, self.utilities[n])
 
     # def is_equilibrium(self, mixed_joint_strategy, gap=0.0001):
     #     """Checks whether *mixed_joint_strategy* is a Nash equilibrium.
-- 
GitLab


From 661183cf0d5f72039774ca12bc02d5f98821ec62 Mon Sep 17 00:00:00 2001
From: Prasanna Maddila <maddilaprasanna10@gmail.com>
Date: Wed, 13 Nov 2024 09:37:12 +0100
Subject: [PATCH 07/13] Cleanup

---
 docs/source/conf.py                           |   35 +-
 gtnash/solver/lemkehowson_polymatrix.py       |  115 +-
 gtnash/solver/pns.py                          |   46 +-
 gtnash/solver/wilsonalgorithm.py              |  352 +--
 gtnash/util/irda.py                           |   32 +-
 .../util/polynomial_complementary_problem.py  |  117 +-
 pyproject.toml                                |   53 +-
 setup.py                                      |   11 -
 test/test_bayesian_hypergraphicalgame.py      |  768 +++++--
 test/test_bayesiangame.py                     |  575 +++--
 test/test_hypergraphicalgame.py               | 1892 +++++++++++++----
 test/test_irda.py                             |  285 ++-
 test/test_lh_polymatrix.py                    |  215 +-
 test/test_normalformgame.py                   |  508 +++--
 test/test_pns.py                              |  524 +++--
 test/test_polynomial_complementary_problem.py |  791 ++++---
 test/test_wilson_algorithm.py                 |  222 +-
 17 files changed, 4576 insertions(+), 1965 deletions(-)
 delete mode 100644 setup.py

diff --git a/docs/source/conf.py b/docs/source/conf.py
index ad753f2..2310215 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -12,22 +12,23 @@
 #
 import os
 import sys
-sys.path.insert(0, os.path.abspath('../../gtnash/game'))
-sys.path.insert(0, os.path.abspath('../../gtnash/solver'))
-sys.path.insert(0, os.path.abspath('../../gtnash/util'))
-sys.path.insert(0, os.path.abspath('../../gtnash/notebook'))
-sys.path.insert(0, os.path.abspath('../../gtnash'))
-sys.path.insert(0, os.path.abspath('../..'))
+
+sys.path.insert(0, os.path.abspath("../../gtnash/game"))
+sys.path.insert(0, os.path.abspath("../../gtnash/solver"))
+sys.path.insert(0, os.path.abspath("../../gtnash/util"))
+sys.path.insert(0, os.path.abspath("../../gtnash/notebook"))
+sys.path.insert(0, os.path.abspath("../../gtnash"))
+sys.path.insert(0, os.path.abspath("../.."))
 
 
 # -- Project information -----------------------------------------------------
 
-project = 'GTNash'
-copyright = '2022, Paul Jourdan, Régis Sabbadin'
-author = 'Paul Jourdan, Régis Sabbadin'
+project = "GTNash"
+copyright = "2022, Paul Jourdan, Régis Sabbadin"
+author = "Paul Jourdan, Régis Sabbadin"
 
 # The full version, including alpha/beta/rc tags
-release = '0.1'
+release = "0.1"
 
 
 # -- General configuration ---------------------------------------------------
@@ -38,7 +39,7 @@ release = '0.1'
 extensions = ["sphinx.ext.autodoc", "sphinx_rtd_theme", "sphinx_multiversion"]
 
 # Add any paths that contain templates here, relative to this directory.
-templates_path = ['_templates']
+templates_path = ["_templates"]
 
 # List of patterns, relative to source directory, that match files and
 # directories to ignore when looking for source files.
@@ -51,13 +52,13 @@ exclude_patterns = []
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
 #
-html_theme = 'sphinx_rtd_theme'
+html_theme = "sphinx_rtd_theme"
 
 
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
+html_static_path = ["_static"]
 
 autodoc_mock_imports = ["numpy", "sage"]
 
@@ -66,8 +67,8 @@ autodoc_mock_imports = ["numpy", "sage"]
 # https://github.com/Holzhaus/sphinx-multiversion
 # https://blog.stephane-robert.info/post/sphinx-documentation-multi-version/
 
-smv_tag_whitelist = r'^v\d+\.\d+.*$|latest'  # tags of form v*.*.x and latest
+smv_tag_whitelist = r"^v\d+\.\d+.*$|latest"  # tags of form v*.*.x and latest
 # Whitelist pattern for branches (set to '' to ignore all branches)
-smv_branch_whitelist = 'main'
-smv_released_pattern = r'^tags/.*$'
-smv_remote_whitelist = r'^.*$'
+smv_branch_whitelist = "main"
+smv_released_pattern = r"^tags/.*$"
+smv_remote_whitelist = r"^.*$"
diff --git a/gtnash/solver/lemkehowson_polymatrix.py b/gtnash/solver/lemkehowson_polymatrix.py
index 8652fb7..2df44cd 100644
--- a/gtnash/solver/lemkehowson_polymatrix.py
+++ b/gtnash/solver/lemkehowson_polymatrix.py
@@ -19,7 +19,6 @@ import numpy as np
 import math
 
 
-
 class LHpolymatrix:
     """
     Polymatrix game solver using Howson algorithm
@@ -54,6 +53,7 @@ class LHpolymatrix:
         Tucker scheme of the current game.
 
     """
+
     def __init__(self, game):
         self.n_players = game.n_players
         self.players_actions = game.players_actions
@@ -70,16 +70,24 @@ class LHpolymatrix:
             # player_to_list_denom[e[0]].update([f_val.denominator
             # for f_val in u_p0 if type(f_val) == Fraction])
             player_to_list_denom[e[0]].update(
-                [f_val.denominator if isinstance(f_val, Fraction)
-                 else 1 for f_val in u_p0])
+                [
+                    f_val.denominator if isinstance(f_val, Fraction) else 1
+                    for f_val in u_p0
+                ]
+            )
             u_p1 = util_e[1]
             # player_to_list_denom[e[1]].update([f_val.denominator
             # for f_val in u_p1 if type(f_val) == Fraction])
             player_to_list_denom[e[1]].update(
-                [f_val.denominator if isinstance(f_val, Fraction)
-                 else 1 for f_val in u_p1])
-        player_to_lcm = {n: np.lcm.reduce(list(player_to_list_denom[n])) for n
-                         in range(self.n_players)}
+                [
+                    f_val.denominator if isinstance(f_val, Fraction) else 1
+                    for f_val in u_p1
+                ]
+            )
+        player_to_lcm = {
+            n: np.lcm.reduce(list(player_to_list_denom[n]))
+            for n in range(self.n_players)
+        }
         # player_to_lcm = {n: np.lcm.reduce(np.array(list(player_to_list_denom[n]), dtype=np.int64)) for n
         #                  in range(self.n_players)}
         for i_e, e in enumerate(game.hypergraph):
@@ -89,13 +97,16 @@ class LHpolymatrix:
             u_p0 = (util_e[0] * player_to_lcm[e[0]]).astype(np.int64)
             self.maxu_of_p[e[0]] = max(self.maxu_of_p[e[0]], max(u_p0))
             player_to_list_denom[e[0]].update(
-                [f_val.denominator for f_val in u_p0 if
-                 isinstance(f_val, Fraction)])
+                [f_val.denominator for f_val in u_p0 if isinstance(f_val, Fraction)]
+            )
             u_p1 = (util_e[1] * player_to_lcm[e[1]]).astype(np.int64)
             self.maxu_of_p[e[1]] = max(self.maxu_of_p[e[1]], max(u_p1))
             player_to_list_denom[e[1]].update(
-                [f_val.denominator if isinstance(f_val, Fraction)
-                 else 1 for f_val in u_p1])
+                [
+                    f_val.denominator if isinstance(f_val, Fraction) else 1
+                    for f_val in u_p1
+                ]
+            )
             # nb_p0 = len(game.players_actions[e[0]])
             nb_p1 = len(game.players_actions[e[1]])
             new_util_p0 = []
@@ -116,8 +127,9 @@ class LHpolymatrix:
         # self.var_of_p = {}
         self.col_var_by_index = {}
         self.row_var_by_index = {}
-        self.tucker = np.zeros((self.m_action + self.n_players,
-                                1 + self.m_action + self.n_players))
+        self.tucker = np.zeros(
+            (self.m_action + self.n_players, 1 + self.m_action + self.n_players)
+        )
 
     def inverse_utilities(self):
         """
@@ -152,7 +164,8 @@ it is involved in.
         mj = len(util_of_n_e[0])
         matrixE = np.ones((len(util_of_n_e), mj)).astype(np.int64).astype(object)
         newMatrix = util_of_n_e - (
-            (self.maxu_of_p[current_n] + Fraction(1, 1)) * matrixE)
+            (self.maxu_of_p[current_n] + Fraction(1, 1)) * matrixE
+        )
         newMatrix = -newMatrix
         return newMatrix
 
@@ -181,29 +194,28 @@ it is involved in.
                 actions_nbis = len(self.players_actions[nbis])
                 if n == nbis:
                     schema[
-                        current_i:current_i + actions_n,
-                        current_j:current_j + actions_n] =\
-                        np.zeros((actions_n, actions_n))
+                        current_i : current_i + actions_n,
+                        current_j : current_j + actions_n,
+                    ] = np.zeros((actions_n, actions_n))
                     for k in range(current_j, current_j + actions_n):
                         # self.var_of_p[n] +=
                         # [nonbasic_str + str(k - current_j)]
                         self.col_var[nonbasic_str + str(k - current_j)] = k + 1
-                    matrixu[n, current_j:current_j + actions_n] = np.ones(
-                        actions_n)
+                    matrixu[n, current_j : current_j + actions_n] = np.ones(actions_n)
                     self.col_var["v" + str(n)] = self.m_action + n + 1
                     # self.var_of_p[n] += ["v" + str(n)]
                     current_j = current_j + actions_n
                 else:
                     if nbis in list(util_of_n.keys()):
                         schema[
-                            current_i:current_i + actions_n,
-                            current_j:current_j + actions_nbis] =\
-                            util_of_n[nbis]
+                            current_i : current_i + actions_n,
+                            current_j : current_j + actions_nbis,
+                        ] = util_of_n[nbis]
                     current_j = current_j + actions_nbis
             for r in range(current_i, current_i + actions_n):
                 self.row_var[basic_str + str(r - current_i)] = r
                 # self.var_of_p[n] += [basic_str + str(r - current_i)]
-            matrixv[current_i:current_i + actions_n, n] = -np.ones(actions_n)
+            matrixv[current_i : current_i + actions_n, n] = -np.ones(actions_n)
             self.row_var["u" + str(n)] = self.m_action + n
             # self.var_of_p[n] += ["u" + str(n)]
             current_i = current_i + actions_n
@@ -231,26 +243,32 @@ Lemke-Howson's algorithm.
         self.block_pivot(list_action)
         # Need to adjust value according to variable number
         epsilon = Fraction(1, 1000)
-        column_epsilon = (np.ones((self.m_action + self.n_players, 1)).astype(
-            np.int64).astype(object)) * epsilon
+        column_epsilon = (
+            np.ones((self.m_action + self.n_players, 1)).astype(np.int64).astype(object)
+        ) * epsilon
         for i in range(self.m_action + self.n_players):
             column_epsilon[i] = column_epsilon[i] ** (i + 1)
         self.tucker = np.block([self.tucker, column_epsilon])
         p = 0
         while True:  # Until a solution is returned
-            index_col_v = self.col_var[
-                "v" + str(p)]  # Step 2: Get the current v^p
+            index_col_v = self.col_var["v" + str(p)]  # Step 2: Get the current v^p
             outbase = self.enter_in_base(index_col_v)
             # Step3: Pivot until
             while not self.complementary_of_p(p, list_action[p]):
                 outvar_str = outbase[1:]
-                next_var_in = [s for s in list(self.col_var.keys()) if
-                               s[1:] == outvar_str and s != outbase]
-                outbase = self.enter_in_base(self.col_var[next_var_in[0]],p)
+                next_var_in = [
+                    s
+                    for s in list(self.col_var.keys())
+                    if s[1:] == outvar_str and s != outbase
+                ]
+                outbase = self.enter_in_base(self.col_var[next_var_in[0]], p)
                 while outbase[0] == "v":  # Step 5: Decrement p and
                     p = p - 1
-                    var_of_p = [s for s in list(self.col_var.keys()) if
-                                s[1:] == str(p) + "_" + str(list_action[p])][0]
+                    var_of_p = [
+                        s
+                        for s in list(self.col_var.keys())
+                        if s[1:] == str(p) + "_" + str(list_action[p])
+                    ][0]
                     outbase = self.enter_in_base(self.col_var[var_of_p])
             # Step 4: If p== number of players then the solution is
             # found otherwise increment p and go back to step 2
@@ -272,7 +290,7 @@ Lemke-Howson's algorithm.
         for i in range(self.n_players):
             x_of_i = "x" + str(i)
             var_base = list(self.row_var.keys())
-            strat_used = [s for s in var_base if s[:1 + len(str(i))] == x_of_i]
+            strat_used = [s for s in var_base if s[: 1 + len(str(i))] == x_of_i]
             strat_i = []
             for j in range(len(self.players_actions[i])):
                 xij = x_of_i + "_" + str(j)
@@ -299,7 +317,7 @@ complementary.
         for s in var_base:
             s_size = len(s)
             n_size = len(str(n))
-            tmp_split = s[1:].split('_')
+            tmp_split = s[1:].split("_")
             # if s_size == 2+n_size+act_size and
             # int(s[1:s_size - act_size-1]) == n:
             if np.int64(tmp_split[0]) == n and s_size > (1 + n_size):
@@ -327,10 +345,12 @@ this variable with the correct row.
         for i in range(self.n_players):
             varx = "x" + str(i) + "_" + str(col[i])
             index_piv_col += [self.col_var[varx]]
-        index_nopiv_col = [x for x in self.col_var_by_index.keys() if
-                           x not in index_piv_col]
-        index_nopiv_row = [x for x in self.row_var_by_index.keys() if
-                           x not in index_piv_row]
+        index_nopiv_col = [
+            x for x in self.col_var_by_index.keys() if x not in index_piv_col
+        ]
+        index_nopiv_row = [
+            x for x in self.row_var_by_index.keys() if x not in index_piv_row
+        ]
         # Init position of the var before the pivot
         allcol = index_piv_col + index_nopiv_col
         allrow = index_piv_row + index_nopiv_row
@@ -345,15 +365,18 @@ this variable with the correct row.
         m22 = self.tucker[np.ix_(index_nopiv_row, index_nopiv_col)]
         # Block Pivot
         invm11 = np.linalg.inv(m11)
-        blockPiv = np.block([[invm11, -invm11.dot(m12)], [m21.dot(invm11),
-                                                          m22 - (m21.dot(
-                                                              invm11.dot(
-                                                                  m12)))]])
+        blockPiv = np.block(
+            [
+                [invm11, -invm11.dot(m12)],
+                [m21.dot(invm11), m22 - (m21.dot(invm11.dot(m12)))],
+            ]
+        )
         # Updating the variable position to keep track of the index
         self.update_var_position(new_col_var_by_index, new_row_var_by_index)
         self.tucker = blockPiv
         self.tucker = self.tucker.astype(
-            np.int64)  # mauvaise valeur lorsque float/fraction
+            np.int64
+        )  # mauvaise valeur lorsque float/fraction
         self.tucker = self.tucker.astype(object)
 
     def update_var_position(self, new_col_var_by_index, new_row_var_by_index):
@@ -377,7 +400,7 @@ this variable with the correct row.
         self.col_var = new_col_var
         self.row_var = new_row_var
 
-    def enter_in_base(self, index_col,p=math.inf):
+    def enter_in_base(self, index_col, p=math.inf):
         """
         Given a column index, returns the variable corresponding to the \
 row that allows to pivot while respecting the positivity constraint \
@@ -392,7 +415,9 @@ and does this operation.
         # Get all possible pivot S={j,a_j<0}
         index_value_col = []
         for j in range(len(col_enter)):
-            if col_enter[j] != 0 : # and int(self.row_var_by_index[j][1])<=p : can pivot for variable above current level Do more test for validation
+            if (
+                col_enter[j] != 0
+            ):  # and int(self.row_var_by_index[j][1])<=p : can pivot for variable above current level Do more test for validation
                 index_value_col += [j]
         # Get max ratio (q+epsilon)/a_j
         max_row_index = self.max_coefEpsilon(col_q, col_enter, index_value_col)
diff --git a/gtnash/solver/pns.py b/gtnash/solver/pns.py
index 86ff016..d6d8c16 100644
--- a/gtnash/solver/pns.py
+++ b/gtnash/solver/pns.py
@@ -38,8 +38,10 @@ Detailed description of classes and methods:
 """
 
 from gtnash.util.irda import irda
-from gtnash.util.polynomial_complementary_problem import\
-    PolynomialComplementaryProblem, Subsystem
+from gtnash.util.polynomial_complementary_problem import (
+    PolynomialComplementaryProblem,
+    Subsystem,
+)
 from sage.all import Subsets, OrderedPartitions, QQbar
 from gtnash.game.normalformgame import NFG
 from gtnash.game.hypergraphicalgame import HGG
@@ -83,8 +85,7 @@ class PNS_solver:
         for support_i, current_support in enumerate(self.all_ordered_support):
             self.nb_of_support_enumerated += 1
             support_strat = self.support_to_strategy(current_support)
-            support_size = sum(
-                [sum(support_strat[n]) for n in range(self.n_players)])
+            support_size = sum([sum(support_strat[n]) for n in range(self.n_players)])
             if support_size == self.n_players:
                 supportaslist = [list(k)[0] for k in current_support]
                 if self.game_hgg.is_pure_equilibrium(supportaslist):
@@ -96,8 +97,9 @@ class PNS_solver:
                 if not z_excluded:
                     set_w = self.create_W_from_support_strat(support_strat)
                     set_wb = self.create_Wb_from_support_strat(support_strat)
-                    sub_sys = Subsystem(self.game_pcp, set_wb, set_w,
-                                        self.n_players - 1, {})
+                    sub_sys = Subsystem(
+                        self.game_pcp, set_wb, set_w, self.n_players - 1, {}
+                    )
                     self.nb_of_subsys_computed += 1
                     if len(sub_sys.solutions) > 0:
                         self.found_support_size = support_size
@@ -137,9 +139,12 @@ class PNS_solver:
         :returns: List of pairs *(n,n_a)* belonging to *W*.
         :rtype: List of tuples.
         """
-        return [(n, n_a) for n in range(self.n_players)
-                for n_i, n_a in enumerate(self.players_actions[n])
-                if support_strat[n][n_i] == 1]
+        return [
+            (n, n_a)
+            for n in range(self.n_players)
+            for n_i, n_a in enumerate(self.players_actions[n])
+            if support_strat[n][n_i] == 1
+        ]
 
     def create_Wb_from_support_strat(self, support_strat):
         """Given the support of a strategy, returns the list of pairs \
@@ -151,9 +156,12 @@ class PNS_solver:
         :returns: List of pairs *(n,n_a)* belonging to *Z*=*Wbar*.
         :rtype: List of tuples.
         """
-        return [(n, n_a) for n in range(self.n_players)
-                for n_i, n_a in enumerate(self.players_actions[n])
-                if support_strat[n][n_i] == 0]
+        return [
+            (n, n_a)
+            for n in range(self.n_players)
+            for n_i, n_a in enumerate(self.players_actions[n])
+            if support_strat[n][n_i] == 0
+        ]
 
     def support_to_strategy(self, support):
         """Changes the representation of the support of a strategy.
@@ -164,8 +172,10 @@ support of player *n*.
         :returns: Dictionary of lists of 0 and 1 (1 iff action in the support).
         :rtype: dict.
         """
-        return {n: [1 if n_act_i in support[n] else 0 for n_act_i in n_act]
-                for n, n_act in enumerate(self.players_actions)}
+        return {
+            n: [1 if n_act_i in support[n] else 0 for n_act_i in n_act]
+            for n, n_act in enumerate(self.players_actions)
+        }
 
 
 def balancedpartitions(n, total):
@@ -179,8 +189,7 @@ def balancedpartitions(n, total):
     k_1+...+k_n=total and [k_i-k_j]<=1, for all i,j.
     :rtype: List of lists of integers.
     """
-    return [part for part in OrderedPartitions(total, n)
-            if max(part) - min(part) <= 1]
+    return [part for part in OrderedPartitions(total, n) if max(part) - min(part) <= 1]
 
 
 def unbalance_partitions(n, total, m):
@@ -195,8 +204,7 @@ def unbalance_partitions(n, total, m):
     k_1+...+k_n=total and [k_i-k_j]=m, for all i,j.
     :rtype: List of lists of integers.
     """
-    return [part for part in OrderedPartitions(total, n)
-            if max(part) - min(part) == m]
+    return [part for part in OrderedPartitions(total, n) if max(part) - min(part) == m]
 
 
 def allbalancedpartitions(n, total):
@@ -217,7 +225,7 @@ def allbalancedpartitions(n, total):
 
 
 def supports(domains, sizes):
-    """ Computes all supports of given sizes of a list of domains.
+    """Computes all supports of given sizes of a list of domains.
 
     :param list of lists domains: the list of full supports of all strategies.
     :param list of int sizes: the sizes of the partial supports.
diff --git a/gtnash/solver/wilsonalgorithm.py b/gtnash/solver/wilsonalgorithm.py
index 7e09206..ad604b8 100644
--- a/gtnash/solver/wilsonalgorithm.py
+++ b/gtnash/solver/wilsonalgorithm.py
@@ -41,8 +41,10 @@ Detailed description of classes and methods
 from gtnash.game.hypergraphicalgame import HGG
 from gtnash.game.normalformgame import NFG
 from gtnash.game.bayesiangame import BG
-from gtnash.util.polynomial_complementary_problem import \
-    PolynomialComplementaryProblem, Subsystem
+from gtnash.util.polynomial_complementary_problem import (
+    PolynomialComplementaryProblem,
+    Subsystem,
+)
 from gtnash.util.irda import irda
 from sage.all import QQbar
 from copy import deepcopy
@@ -54,6 +56,7 @@ class WilsonError(Exception):
     Error ``WilsonError`` is returned when the program fails for an unknown \
 reason.
     """
+
     pass
 
 
@@ -71,13 +74,18 @@ of xni.
     :rtype: list of ``Node``.
 
     """
-    x_values_level_0 = {pcp.couple_to_x[(n, i)]: xpairs_val[(n, i)] for (n, i)
-                        in pcp.couple_to_x.keys() if n > 0}
+    x_values_level_0 = {
+        pcp.couple_to_x[(n, i)]: xpairs_val[(n, i)]
+        for (n, i) in pcp.couple_to_x.keys()
+        if n > 0
+    }
     subpcp = pcp.substitute(x_values_level_0, 0)
-    minval = min(
-        [sum(v.coefficients()) for v in subpcp.couple_to_poly.values()])
-    set_w = [(n, i) for (n, i) in subpcp.couple_to_poly.keys() if
-             sum(subpcp.couple_to_poly[(n, i)].coefficients()) == minval]
+    minval = min([sum(v.coefficients()) for v in subpcp.couple_to_poly.values()])
+    set_w = [
+        (n, i)
+        for (n, i) in subpcp.couple_to_poly.keys()
+        if sum(subpcp.couple_to_poly[(n, i)].coefficients()) == minval
+    ]
     level = 0
     sys_s = []
     nextnodeslist = []
@@ -86,14 +94,16 @@ of xni.
         print("Several pairs can be added to W: ", set_w)
     if len(set_w) == 0:
         raise WilsonError(
-            "Ouch! No almost complementary point at level 0, that's strange!")
-    for (m, j) in set_w:
+            "Ouch! No almost complementary point at level 0, that's strange!"
+        )
+    for m, j in set_w:
         # if (len(set_w)==1):
-        set_z = [(n, i) for (n, i) in subpcp.couple_to_poly.keys() if
-                 (n, i) != (m, j)]  # not in set_w]
+        set_z = [
+            (n, i) for (n, i) in subpcp.couple_to_poly.keys() if (n, i) != (m, j)
+        ]  # not in set_w]
         sols = {}
         sols[pcp.ring(pcp.couple_to_x[(m, j)])] = 1
-        for (n, i) in set_z:
+        for n, i in set_z:
             sols[pcp.ring(pcp.couple_to_x[(n, i)])] = 0
         node0 = Node(subpcp, set_z, [(m, j)], level, xpairs_val, sys_s, sols)
         node0.check_complementarity()
@@ -196,10 +206,12 @@ def gen_only_omega_to_used(game):
 
     """
     print(game.players_actions)
-    all_joint_actions = list(itertools.product(
-        *[[game.players_actions[0][0]]] + [pact for n, pact in
-                                           enumerate(game.players_actions) if
-                                           not n == 0]))
+    all_joint_actions = list(
+        itertools.product(
+            *[[game.players_actions[0][0]]]
+            + [pact for n, pact in enumerate(game.players_actions) if not n == 0]
+        )
+    )
     all_dict_joint_actions = []
     for ja in all_joint_actions:
         joint_act_dic = {}
@@ -219,7 +231,7 @@ def wilson_loop(pcpglobal):
 
     """
     xpairs_val = {}
-    for (n, i) in pcpglobal.couple_to_x.keys():
+    for n, i in pcpglobal.couple_to_x.keys():
         if pcpglobal.omega0[n] == i:
             xpairs_val[(n, i)] = 1
         else:
@@ -243,29 +255,32 @@ def wilson_loop(pcpglobal):
             nextnode = opennodes.pop(last_var)
         currentnode = nextnode
         visitednodes.append(currentnode)
-        if currentnode.is_complementary and \
-                currentnode.level == pcpglobal.game.n_players - 1:
+        if (
+            currentnode.is_complementary
+            and currentnode.level == pcpglobal.game.n_players - 1
+        ):
             break  # we are done
         if currentnode.is_complementary and (
-                currentnode.level == 0 or
-                currentnode.level >= currentnode.prev_node.level):
+            currentnode.level == 0 or currentnode.level >= currentnode.prev_node.level
+        ):
             nextnodeslist = currentnode.lift(pcpglobal, xpairs_val)
-        elif currentnode.is_initial and \
-                currentnode.level <= currentnode.prev_node.level:
+        elif (
+            currentnode.is_initial and currentnode.level <= currentnode.prev_node.level
+        ):
             nextnodeslist = currentnode.descend(currentnode.pcp, xpairs_val)
             # Update xpairs_val
             level = currentnode.level
-            xpairs_val[
-                (level, pcpglobal.omega0[level])] = currentnode.coordinates[
-                pcpglobal.couple_to_x[(level, pcpglobal.omega0[level])]]
+            xpairs_val[(level, pcpglobal.omega0[level])] = currentnode.coordinates[
+                pcpglobal.couple_to_x[(level, pcpglobal.omega0[level])]
+            ]
         else:
-            nextnodeslist = currentnode.traverse(currentnode.prev_node,
-                                                 xpairs_val)
+            nextnodeslist = currentnode.traverse(currentnode.prev_node, xpairs_val)
             # Deal with degeneracy, cycles or impossible pivots.
         if len(nextnodeslist) == 0:
             print(
                 "Current path in Wilson's algorithm leads nowhere."
-                " We have to backtrack.")
+                " We have to backtrack."
+            )
         else:
             if len(nextnodeslist) > 1:
                 print("Current node is degenerate.")
@@ -298,8 +313,7 @@ algorithm, as well as some statistics about this path.
     """
 
     def __init__(self, n_player):
-        """Node path data constructor.
-        """
+        """Node path data constructor."""
         self.listZW = []
         self.level_to_number_of_node = {n: 0 for n in range(n_player)}
         self.level_to_number_of_comp = {n: 0 for n in range(n_player)}
@@ -379,13 +393,14 @@ algorithm, as well as some statistics about this path.
     def __str__(self):
         res_str = "PathData\n"
         res_str += f"Number of node by level: {self.level_to_number_of_node}\n"
-        res_str += \
-            f"Number of complementary node by level:" \
+        res_str += (
+            f"Number of complementary node by level:"
             f" {self.level_to_number_of_comp}\n"
-        res_str += f"Number of initial node by level:" \
-                   f" {self.level_to_number_of_init}\n"
-        res_str += f"Max number of polynomials in the system:" \
-                   f" {self.max_size_W}\n"
+        )
+        res_str += (
+            f"Number of initial node by level:" f" {self.level_to_number_of_init}\n"
+        )
+        res_str += f"Max number of polynomials in the system:" f" {self.max_size_W}\n"
         res_str += f"Is degenerate: {self.degen_encount}"
         return res_str
 
@@ -425,8 +440,7 @@ class Node:
 
     """
 
-    def __init__(self, pcp, set_z, set_w, level, xpairs_val, sys_S,
-                 coordinates):
+    def __init__(self, pcp, set_z, set_w, level, xpairs_val, sys_S, coordinates):
         """
         Creates a complementary node at level 0, from an input PCP.
 
@@ -455,8 +469,9 @@ class Node:
         strnode += "\n"
         for n in range(self.level + 1, self.pcp.game.n_players):
             for i in self.pcp.game.players_actions[n]:
-                strnode += "xpairs_val[({0},{1})] = {2}\n".\
-                    format(n, i, self.xpairs_val[(n, i)])
+                strnode += "xpairs_val[({0},{1})] = {2}\n".format(
+                    n, i, self.xpairs_val[(n, i)]
+                )
         strnode += "set_z: {0}\n".format(self.set_z)
         strnode += "set_w:{0}\n".format(self.set_w)
         strnode += "System defining the node:\n"
@@ -475,7 +490,8 @@ or initial.
         set_z = set(self.set_z)
         set_w = set(self.set_w)
         all_couples = set(
-            [(n, i) for (n, i) in self.pcp.couple_to_x.keys() if n <= level])
+            [(n, i) for (n, i) in self.pcp.couple_to_x.keys() if n <= level]
+        )
         z_union_w = set_z.union(set_w)
         card = len(set_z) + len(set_w)
         is_initial = False
@@ -485,12 +501,13 @@ or initial.
             if z_union_w == all_couples:
                 is_complementary = True
             if all_couples.difference(z_union_w).issubset(
-                    set([(level, self.pcp.omega0[level])])):
+                set([(level, self.pcp.omega0[level])])
+            ):
                 is_almost_complementary = True
             if is_complementary or is_almost_complementary:
                 if (level, omega0level) not in set_z:
                     is_initial = True
-                    for (n, i) in all_couples:
+                    for n, i in all_couples:
                         if n == level and i != omega0level:
                             if (n, i) not in set_z:
                                 is_initial = False
@@ -518,22 +535,27 @@ or [] if it was a z that entered.
         """
         # Try pairs to enter z:
         new_binding_z = entering_z
-        possible_z = [(n, i) for (n, i) in self.pcp.couple_to_x.keys()
-                      if n <= self.level and (n, i) not in set(
-            self.set_z).difference(set(entering_z))]
-        for (n, i) in possible_z:
+        possible_z = [
+            (n, i)
+            for (n, i) in self.pcp.couple_to_x.keys()
+            if n <= self.level
+            and (n, i) not in set(self.set_z).difference(set(entering_z))
+        ]
+        for n, i in possible_z:
             if (n, i) not in new_binding_z:
                 if self.coordinates[self.pcp.couple_to_x[(n, i)]] == 0:
                     new_binding_z.append((n, i))
         # Try pairs to enter w:
         new_binding_w = entering_w
-        possible_w = [(n, i) for (n, i) in self.pcp.couple_to_poly.keys()
-                      if n <= self.level and (n, i) not in set(
-            self.set_w).difference(set(entering_w))]
-        for (n, i) in possible_w:
+        possible_w = [
+            (n, i)
+            for (n, i) in self.pcp.couple_to_poly.keys()
+            if n <= self.level
+            and (n, i) not in set(self.set_w).difference(set(entering_w))
+        ]
+        for n, i in possible_w:
             if (n, i) not in new_binding_w:
-                pol = self.pcp.couple_to_poly[(n, i)].substitute(
-                    self.coordinates)
+                pol = self.pcp.couple_to_poly[(n, i)].substitute(self.coordinates)
                 if pol == 0:
                     new_binding_w.append((n, i))
         if len(new_binding_z) + len(new_binding_w) > 1:
@@ -591,17 +613,22 @@ at the above level (singleton except in case of degeneracy).
         if not self.is_complementary:
             raise WilsonError("Can only lift a complementary node.")
         level = self.level + 1
-        x_values_level = {pcp.couple_to_x[(n, i)]: xpairs_val[(n, i)] for
-                          (n, i) in pcp.couple_to_x.keys() if n > level}
+        x_values_level = {
+            pcp.couple_to_x[(n, i)]: xpairs_val[(n, i)]
+            for (n, i) in pcp.couple_to_x.keys()
+            if n > level
+        }
         subpcp = pcp.substitute(x_values_level, level)
         set_w = deepcopy(self.set_w)
         set_z = deepcopy(self.set_z)
-        set_z += [(n, i) for (n, i) in subpcp.couple_to_x.keys() if
-                  (n == level) and (i != subpcp.omega0[n])]
+        set_z += [
+            (n, i)
+            for (n, i) in subpcp.couple_to_x.keys()
+            if (n == level) and (i != subpcp.omega0[n])
+        ]
         # Try to find w entering set_w
         # Change lift to skip couple of previous level
-        possible_next_w = [(n, i) for (n, i) in subpcp.couple_to_x.keys() if
-                           n == level]
+        possible_next_w = [(n, i) for (n, i) in subpcp.couple_to_x.keys() if n == level]
         no_sol_found = True
         while len(possible_next_w) > 0 and no_sol_found:
             w = possible_next_w.pop(0)
@@ -609,11 +636,17 @@ at the above level (singleton except in case of degeneracy).
             subsys = Subsystem(subpcp, set_z, loc_set_w, level, xpairs_val)
             if len(subsys.solutions) > 0:
                 no_sol_found = False
-                tentativenode = Node(subpcp, set_z, loc_set_w, level,
-                                     xpairs_val, subsys, subsys.solutions[0])
+                tentativenode = Node(
+                    subpcp,
+                    set_z,
+                    loc_set_w,
+                    level,
+                    xpairs_val,
+                    subsys,
+                    subsys.solutions[0],
+                )
                 tentativenode.prev_node = self
-                list_added_z, list_added_w = \
-                    tentativenode.check_degeneracy([], [w])
+                list_added_z, list_added_w = tentativenode.check_degeneracy([], [w])
         # Compute next nodes' list
         if no_sol_found:  # No node found after lifting
             nextnodeslist = []
@@ -624,15 +657,29 @@ at the above level (singleton except in case of degeneracy).
                 degenerated = True
             for z in list_added_z:
                 loc_set_z = set_z + [z]
-                tentativenode = Node(subpcp, loc_set_z, set_w, level,
-                                     xpairs_val, subsys, subsys.solutions[0])
+                tentativenode = Node(
+                    subpcp,
+                    loc_set_z,
+                    set_w,
+                    level,
+                    xpairs_val,
+                    subsys,
+                    subsys.solutions[0],
+                )
                 tentativenode.prev_node = self
                 tentativenode.is_degenerate = degenerated
                 nextnodeslist += [tentativenode]
             for w in list_added_w:
                 loc_set_w = set_w + [w]
-                tentativenode = Node(subpcp, set_z, loc_set_w, level,
-                                     xpairs_val, subsys, subsys.solutions[0])
+                tentativenode = Node(
+                    subpcp,
+                    set_z,
+                    loc_set_w,
+                    level,
+                    xpairs_val,
+                    subsys,
+                    subsys.solutions[0],
+                )
                 tentativenode.prev_node = self
                 tentativenode.is_degenerate = degenerated
                 nextnodeslist += [tentativenode]
@@ -652,21 +699,29 @@ nodes at the level below (singleton except in case of degeneracy).
         """
         if not self.is_initial:
             raise WilsonError("Can only descend from an initial node.")
-        x_values_level = {pcp.couple_to_x[(n, i)]: xpairs_val[(n, i)] for
-                          (n, i) in pcp.couple_to_x.keys()
-                          if n >= self.level}
+        x_values_level = {
+            pcp.couple_to_x[(n, i)]: xpairs_val[(n, i)]
+            for (n, i) in pcp.couple_to_x.keys()
+            if n >= self.level
+        }
         subpcp = pcp.substitute(x_values_level, self.level)
         new_set_z = [(n, i) for (n, i) in self.set_z if n < self.level]
         new_set_w = [(n, i) for (n, i) in self.set_w if n < self.level]
         level = self.level - 1
-        if not set(new_set_z).intersection(
-                set(new_set_w)):  # Empty intersection
+        if not set(new_set_z).intersection(set(new_set_w)):  # Empty intersection
             subsys = Subsystem(subpcp, new_set_z, new_set_w, level, xpairs_val)
             if not subsys.solutions:
                 tentativenode = None
             else:
-                tentativenode = Node(subpcp, new_set_z, new_set_w, level,
-                                     xpairs_val, subsys, subsys.solutions[0])
+                tentativenode = Node(
+                    subpcp,
+                    new_set_z,
+                    new_set_w,
+                    level,
+                    xpairs_val,
+                    subsys,
+                    subsys.solutions[0],
+                )
                 tentativenode.prev_node = self
         else:  # Singleton intersection
             m_j = set(new_set_z).intersection(set(new_set_w))
@@ -675,24 +730,35 @@ nodes at the level below (singleton except in case of degeneracy).
             (m, j) = m_j.pop()
             local_set_z = deepcopy(new_set_z)
             local_set_z.remove((m, j))
-            subsys = Subsystem(subpcp, local_set_z, new_set_w, level,
-                               xpairs_val)
+            subsys = Subsystem(subpcp, local_set_z, new_set_w, level, xpairs_val)
             # (m,j) should be removed from new_set_w, instead.
             if not subsys.solutions:
                 local_set_w = deepcopy(new_set_w)
                 local_set_w.remove((m, j))
-                subsys = Subsystem(subpcp, new_set_z, local_set_w, level,
-                                   xpairs_val)
+                subsys = Subsystem(subpcp, new_set_z, local_set_w, level, xpairs_val)
                 if not subsys.solutions:
                     tentativenode = None
                 else:
-                    tentativenode = Node(subpcp, new_set_z, local_set_w, level,
-                                         xpairs_val, subsys,
-                                         subsys.solutions[0])
+                    tentativenode = Node(
+                        subpcp,
+                        new_set_z,
+                        local_set_w,
+                        level,
+                        xpairs_val,
+                        subsys,
+                        subsys.solutions[0],
+                    )
                     tentativenode.prev_node = self
             else:
-                tentativenode = Node(subpcp, local_set_z, new_set_w, level,
-                                     xpairs_val, subsys, subsys.solutions[0])
+                tentativenode = Node(
+                    subpcp,
+                    local_set_z,
+                    new_set_w,
+                    level,
+                    xpairs_val,
+                    subsys,
+                    subsys.solutions[0],
+                )
                 tentativenode.prev_node = self
         # Check degeneracy of node after descent
         if tentativenode is None:
@@ -716,18 +782,21 @@ nodes at the level below (singleton except in case of degeneracy).
             if prev_node.is_complementary:
                 # Current node results from lift().
                 # If almost complementary, Z was unchanged.
-                arc_set_z = [(n, i) for (n, i) in self.set_z if
-                             not (n, i) in self.set_w]
+                arc_set_z = [
+                    (n, i) for (n, i) in self.set_z if not (n, i) in self.set_w
+                ]
                 arc_set_w = deepcopy(self.set_w)
             else:
                 raise WilsonError(
                     "Should not try to traverse an initial"
-                    " node reached from the same level!")
+                    " node reached from the same level!"
+                )
         elif self.is_complementary:
             if not prev_node.level > self.level:
                 raise WilsonError(
                     "Normally, a complementary node should"
-                    " not be traversed in any directions.")
+                    " not be traversed in any directions."
+                )
             # We have to find the unique bounded
             # arc leaving current complementary node:
             else:
@@ -747,24 +816,27 @@ nodes at the level below (singleton except in case of degeneracy).
             (m, j) = z_inter_w.pop()
             if len(z_inter_w) > 0:
                 raise WilsonError(
-                    "This should not happen with "
-                    "an almost-complementary node.")
+                    "This should not happen with " "an almost-complementary node."
+                )
             if (m, j) in prev_node.set_w:
                 arc_set_z = deepcopy(self.set_z)
-                arc_set_w = [(n, i) for (n, i) in self.set_w if
-                             not (n, i) in self.set_z]
+                arc_set_w = [
+                    (n, i) for (n, i) in self.set_w if not (n, i) in self.set_z
+                ]
             elif (m, j) in prev_node.set_z:
-                arc_set_z = [(n, i) for (n, i) in self.set_z if
-                             not (n, i) in self.set_w]
+                arc_set_z = [
+                    (n, i) for (n, i) in self.set_z if not (n, i) in self.set_w
+                ]
                 arc_set_w = deepcopy(self.set_w)
             else:
                 raise WilsonError(
-                    "Two consecutive nodes should"
-                    " have identical z or identical w ")
+                    "Two consecutive nodes should" " have identical z or identical w "
+                )
         else:
             raise WilsonError(
                 "If the node is not almost-complementary,"
-                " we should not encounter it!")
+                " we should not encounter it!"
+            )
         if arc_set_z is None:
             arc_set_z = []
         if arc_set_w is None:
@@ -786,13 +858,12 @@ nodes at the same level (singleton except in case of degeneracy).
         nodepcp = self.pcp
         level = self.level
         all_couples = set(
-            [(n, i) for (n, i) in nodepcp.couple_to_x.keys() if n <= level])
+            [(n, i) for (n, i) in nodepcp.couple_to_x.keys() if n <= level]
+        )
         # Compute the next arc:
         (arc_set_z, arc_set_w) = self.compute_arc(prev_node)
-        poss_new_z = [(m, j) for (m, j) in
-                      all_couples.difference(set(self.set_z))]
-        poss_new_w = [(m, j) for (m, j) in
-                      all_couples.difference(set(self.set_w))]
+        poss_new_z = [(m, j) for (m, j) in all_couples.difference(set(self.set_z))]
+        poss_new_w = [(m, j) for (m, j) in all_couples.difference(set(self.set_w))]
 
         nextnodeslist = []
         no_sol_found = True
@@ -800,11 +871,17 @@ nodes at the same level (singleton except in case of degeneracy).
             z = poss_new_z.pop(0)
             loc_set_z = arc_set_z + [z]
             loc_set_w = arc_set_w
-            subsys = Subsystem(nodepcp, loc_set_z, loc_set_w, level,
-                               xpairs_val)
+            subsys = Subsystem(nodepcp, loc_set_z, loc_set_w, level, xpairs_val)
             if len(subsys.solutions) > 0:
-                tentativenode = Node(nodepcp, loc_set_z, loc_set_w, level,
-                                     xpairs_val, subsys, subsys.solutions[0])
+                tentativenode = Node(
+                    nodepcp,
+                    loc_set_z,
+                    loc_set_w,
+                    level,
+                    xpairs_val,
+                    subsys,
+                    subsys.solutions[0],
+                )
                 tentativenode.prev_node = self
                 nextnodeslist += [tentativenode]
                 no_sol_found = False
@@ -812,11 +889,17 @@ nodes at the same level (singleton except in case of degeneracy).
             w = poss_new_w.pop(0)
             loc_set_z = arc_set_z
             loc_set_w = arc_set_w + [w]
-            subsys = Subsystem(nodepcp, loc_set_z, loc_set_w, level,
-                               xpairs_val)
+            subsys = Subsystem(nodepcp, loc_set_z, loc_set_w, level, xpairs_val)
             if len(subsys.solutions) > 0:
-                tentativenode = Node(nodepcp, loc_set_z, loc_set_w, level,
-                                     xpairs_val, subsys, subsys.solutions[0])
+                tentativenode = Node(
+                    nodepcp,
+                    loc_set_z,
+                    loc_set_w,
+                    level,
+                    xpairs_val,
+                    subsys,
+                    subsys.solutions[0],
+                )
                 tentativenode.prev_node = self
                 nextnodeslist += [tentativenode]
                 no_sol_found = False
@@ -833,15 +916,29 @@ nodes at the same level (singleton except in case of degeneracy).
                 degenerated = True
             for z in list_added_z:
                 loc_set_z = arc_set_z + [z]
-                tentativenode = Node(nodepcp, loc_set_z, arc_set_w, level,
-                                     xpairs_val, subsys, subsys.solutions[0])
+                tentativenode = Node(
+                    nodepcp,
+                    loc_set_z,
+                    arc_set_w,
+                    level,
+                    xpairs_val,
+                    subsys,
+                    subsys.solutions[0],
+                )
                 tentativenode.prev_node = self
                 tentativenode.is_degenerate = degenerated
                 nextnodeslist += [tentativenode]
             for w in list_added_w:
                 loc_set_w = arc_set_w + [w]
-                tentativenode = Node(nodepcp, arc_set_z, loc_set_w, level,
-                                     xpairs_val, subsys, subsys.solutions[0])
+                tentativenode = Node(
+                    nodepcp,
+                    arc_set_z,
+                    loc_set_w,
+                    level,
+                    xpairs_val,
+                    subsys,
+                    subsys.solutions[0],
+                )
                 tentativenode.prev_node = self
                 tentativenode.is_degenerate = degenerated
                 nextnodeslist += [tentativenode]
@@ -862,18 +959,19 @@ nodes at the same level (singleton except in case of degeneracy).
             #     if not (set(self.set_z).difference(node.set_z))
             #     and not (set(self.set_w).difference(node.set_w)):
             #         return True
-            if len(self.set_z) == len(node.set_z) and\
-                    len(self.set_w) == len(node.set_w):
-                if not (set(self.set_z).difference(node.set_z)) and\
-                        not (set(self.set_w).difference(node.set_w)):
-                    if len(self.prev_node.set_z) ==\
-                            len(node.prev_node.set_z) and\
-                            len(self.prev_node.set_w) ==\
-                            len(node.prev_node.set_w):
+            if len(self.set_z) == len(node.set_z) and len(self.set_w) == len(
+                node.set_w
+            ):
+                if not (set(self.set_z).difference(node.set_z)) and not (
+                    set(self.set_w).difference(node.set_w)
+                ):
+                    if len(self.prev_node.set_z) == len(node.prev_node.set_z) and len(
+                        self.prev_node.set_w
+                    ) == len(node.prev_node.set_w):
                         if not (
-                                set(self.prev_node.set_z).difference(
-                                    node.prev_node.set_z)) and \
-                                not (set(self.prev_node.set_w).difference(
-                                    node.prev_node.set_w)):
+                            set(self.prev_node.set_z).difference(node.prev_node.set_z)
+                        ) and not (
+                            set(self.prev_node.set_w).difference(node.prev_node.set_w)
+                        ):
                             return True
         return False
diff --git a/gtnash/util/irda.py b/gtnash/util/irda.py
index b777219..9eea63e 100644
--- a/gtnash/util/irda.py
+++ b/gtnash/util/irda.py
@@ -28,9 +28,11 @@ Detailed description of methods
 -------------------------------
 
 """
+
 from sage.all import MixedIntegerLinearProgram, QQ, QQbar  # noqa
 from gtnash.game.hypergraphicalgame import HGG
 import numpy as np
+
 # from copy import *
 from copy import deepcopy
 
@@ -51,9 +53,12 @@ in 'subgame'.
     """
     player_in_subgame = hgg.hypergraph[subgame].index(player)
     utility_of_player_in_subgame = hgg.utilities[subgame][player_in_subgame]
-    return [utility_of_player_in_subgame[i] for i in
-            hgg.local_normalformgames[subgame].row_where_p_is_i(
-                player_in_subgame, action)]
+    return [
+        utility_of_player_in_subgame[i]
+        for i in hgg.local_normalformgames[subgame].row_where_p_is_i(
+            player_in_subgame, action
+        )
+    ]
 
 
 def local_difference(hgg, player, action1, action2, subgame):
@@ -72,15 +77,16 @@ def local_difference(hgg, player, action1, action2, subgame):
     :rtype: Numpy array.
 
     """
-    return np.array(
-        subutilities_player(hgg, player, action1, subgame)) - np.array(
-        subutilities_player(hgg, player, action2, subgame))
+    return np.array(subutilities_player(hgg, player, action1, subgame)) - np.array(
+        subutilities_player(hgg, player, action2, subgame)
+    )
 
 
 ############################################################################
 # Functions to compute a BILP to determine whether a strategy is dominated.
 ############################################################################
 
+
 def nondominated(hgg, player, action1, action2):
     """
     Determines whether action1 of player is nondominated by action2 in hgg.
@@ -109,7 +115,8 @@ def nondominated(hgg, player, action1, action2):
             # print(a_e_i)
             number_of_k = np.size(a_e_i, 0)  # Number of rows in a_e_i
             bilp.add_constraint(
-                bilp.sum(b[player, e, k] for k in range(number_of_k)) == 1)
+                bilp.sum(b[player, e, k] for k in range(number_of_k)) == 1
+            )
 
     # Second set of constraints:
     for e1 in range(len(hypergraph)):
@@ -133,7 +140,8 @@ def nondominated(hgg, player, action1, action2):
                                 break
                         if add_c:
                             bilp.add_constraint(
-                                b[player, e1, k1] + b[player, e2, k2] <= 1)
+                                b[player, e1, k1] + b[player, e2, k2] <= 1
+                            )
 
     # Linear utility function:
     temp_list = []
@@ -144,8 +152,7 @@ def nondominated(hgg, player, action1, action2):
             for k in range(len(ld[e])):
                 temp_list.append((e, k))
 
-    bilp.set_objective(sum(b[player, e, k] * QQ(ld[e][k])
-                       for e, k in temp_list))
+    bilp.set_objective(sum(b[player, e, k] * QQ(ld[e][k]) for e, k in temp_list))
     # bilp.show()
     # print("Solution value: ",bilp.solve())
     return bilp.solve() >= 0
@@ -217,8 +224,9 @@ of player j has been removed.
             joint_acts = subgame.joint_actions
             # Index of player j in subgame e
             idx = hypergraph[e].index(j)
-            to_remove = [il for il in range(joint_acts.shape[0]) if
-                         joint_acts[il, idx] == aj]
+            to_remove = [
+                il for il in range(joint_acts.shape[0]) if joint_acts[il, idx] == aj
+            ]
             for r in sorted(to_remove, reverse=True):
                 for i in range(len(hypergraph[e])):
                     del utilities[e][i][r]
diff --git a/gtnash/util/polynomial_complementary_problem.py b/gtnash/util/polynomial_complementary_problem.py
index a44ac64..ac76c73 100644
--- a/gtnash/util/polynomial_complementary_problem.py
+++ b/gtnash/util/polynomial_complementary_problem.py
@@ -17,6 +17,7 @@ Detailed description of the classes
 -----------------------------------
 
 """
+
 import numpy as np
 from sage.all import QQ, QQbar, PolynomialRing, ideal, prod
 from gtnash.game.hypergraphicalgame import HGG
@@ -69,7 +70,7 @@ x_omega0[(n,i)]=0 if i!=omega0[n], for all players n.
             self.gen_var_y()
         # Ring:
         var_xy = self.set_x + self.set_y
-        self.ring = PolynomialRing(QQbar, var_xy, order='lex')
+        self.ring = PolynomialRing(QQbar, var_xy, order="lex")
         self.couple_to_poly = {}
         self.generate_poly(fact_y)
         self.couple_to_poly_y = {}
@@ -78,8 +79,7 @@ x_omega0[(n,i)]=0 if i!=omega0[n], for all players n.
         if not omega0:
             # self.gen_omega0()
             self.omega0 = {}
-            for n in range(self.game.n_players - 1, -1,
-                           -1):  # players in reverse order
+            for n in range(self.game.n_players - 1, -1, -1):  # players in reverse order
                 self.omega0[n] = min([i for i in self.game.players_actions[n]])
         else:
             self.omega0 = omega0
@@ -160,7 +160,7 @@ and updates ``self`` attribute ``couple_to_x``.
         # Generate all the variable x used in the pcp
         for n in range(self.game.n_players):
             for j in self.game.players_actions[n]:
-                var_x = f'x{n}_{j}'
+                var_x = f"x{n}_{j}"
                 self.set_x += [var_x]
                 self.couple_to_x[(n, j)] = var_x
 
@@ -176,7 +176,7 @@ and updates ``self`` attribute ``couple_to_y``.
         for n in range(self.game.n_players):
             for g in range(len(hypergraph)):
                 # if n not in hypergraph[g]:
-                var_y = f'y{n}_{g}'
+                var_y = f"y{n}_{g}"
                 self.set_y += [var_y]
                 self.couple_to_y[(n, g)] = var_y
 
@@ -195,10 +195,10 @@ and updates ``self`` attribute ``couple_to_y``.
         # To improve, by using a reduced_dico n<level
         # an poly.subs(reduced_dico)
         sub_pcp = deepcopy(self)
-        for (n, i) in self.couple_to_poly.keys():
+        for n, i in self.couple_to_poly.keys():
             poly = self.couple_to_poly[(n, i)]
             for variab, valu in x_values.items():
-                poly = eval('poly.subs(' + str(variab) + '=valu)')
+                poly = eval("poly.subs(" + str(variab) + "=valu)")
             if n <= level:
                 sub_pcp.couple_to_poly[(n, i)] = poly
             else:
@@ -222,9 +222,9 @@ and updates ``self`` attribute ``couple_to_y``.
             if max_of_n >= 0:
                 e_to_index = self.game.index_of_player_in_local(n)
                 for e_i in e_to_index.keys():
-                    copy_util[e_i][e_to_index[e_i]] = [val - (max_of_n + 1) for
-                                                       val in copy_util[e_i][
-                                                           e_to_index[e_i]]]
+                    copy_util[e_i][e_to_index[e_i]] = [
+                        val - (max_of_n + 1) for val in copy_util[e_i][e_to_index[e_i]]
+                    ]
                     # copy_util[e_i, e_to_index[e_i]]=[val -(max_of_n+1)
                     # for val in copy_util[e_i,e_to_index[e_i]]]
                     # copy_util[e_i,e_to_index[e_i]]-=(max_of_n+1)
@@ -265,9 +265,12 @@ and creates Q[g] = y^N_g. New version (correct).
             sys_S = []
             for n in range(nplayers):
                 if n not in self.game.hypergraph[g]:
-                    sys_S.append(sum(
-                        self.ring(self.couple_to_x[(n, i)]) for i in
-                        self.game.players_actions[n]))
+                    sys_S.append(
+                        sum(
+                            self.ring(self.couple_to_x[(n, i)])
+                            for i in self.game.players_actions[n]
+                        )
+                    )
             poly_Q[g] = prod(sys_S)
         return poly_Q
 
@@ -292,24 +295,31 @@ any local game g involving player n and action i of n (see documentation).
                 for g in range(nlocgames):
                     if n in hypergraph[g]:
                         index_n = hypergraph[g].index(n)
-                        locgame_players_actions = \
-                            self.game.local_normalformgames[g].joint_actions
+                        locgame_players_actions = self.game.local_normalformgames[
+                            g
+                        ].joint_actions
                         locgame_utilities = negative_util[g]
                         sys_s = []
                         for index_w in range(locgame_players_actions.shape[0]):
-                            w = [locgame_players_actions[index_w, k] for k in
-                                 range(locgame_players_actions.shape[1])]
+                            w = [
+                                locgame_players_actions[index_w, k]
+                                for k in range(locgame_players_actions.shape[1])
+                            ]
                             if w[index_n] == i:
                                 pw = QQ(locgame_utilities[index_n][index_w])
                                 for index_nu in range(len(hypergraph[g])):
                                     if index_nu != index_n:
                                         nu = hypergraph[g][index_nu]
-                                        pw *= \
-                                            self.ring(
-                                                self.couple_to_x[(
+                                        pw *= self.ring(
+                                            self.couple_to_x[
+                                                (
                                                     nu,
                                                     locgame_players_actions[
-                                                        index_w, index_nu])])
+                                                        index_w, index_nu
+                                                    ],
+                                                )
+                                            ]
+                                        )
                                 sys_s.append(pw)
                         poly_r[(n, i, g)] = sum(sys_s)
         return poly_r
@@ -337,8 +347,7 @@ any local game g involving player n and action i of n (see documentation).
                     couple_to_poly[(n, i)] = 0
                     for g in range(nlocgames):
                         if n in hypergraph[g]:
-                            couple_to_poly[(n, i)] -=\
-                                poly_q[g] * poly_r[(n, i, g)]
+                            couple_to_poly[(n, i)] -= poly_q[g] * poly_r[(n, i, g)]
                     couple_to_poly[(n, i)] -= 1
         else:
             poly_q = self.generate_poly_fact()
@@ -347,8 +356,7 @@ any local game g involving player n and action i of n (see documentation).
                     couple_to_poly[(n, i)] = 0
                     for g in range(nlocgames):
                         if n in hypergraph[g]:
-                            couple_to_poly[(n, i)] -=\
-                                (poly_q[g]) * poly_r[(n, i, g)]
+                            couple_to_poly[(n, i)] -= (poly_q[g]) * poly_r[(n, i, g)]
                     couple_to_poly[(n, i)] -= 1
         self.couple_to_poly = couple_to_poly
 
@@ -375,16 +383,20 @@ Useful only for hypergraphical games.
                     else:
                         couple_to_poly_y[(n, g)] = polyloc - sum(
                             self.ring(self.couple_to_x[(n, i)])
-                            for i in self.game.players_actions[n])
+                            for i in self.game.players_actions[n]
+                        )
                 else:
                     if n in hypergraph[g]:
                         couple_to_poly_y[(n, g)] = polyloc - self.ring(
-                            self.couple_to_y[(n - 1, g)])
+                            self.couple_to_y[(n - 1, g)]
+                        )
                     else:
                         couple_to_poly_y[(n, g)] = polyloc - self.ring(
-                            self.couple_to_y[(n - 1, g)]) * sum(
-                            self.ring(self.couple_to_x[(n, i)]) for i in
-                            self.game.players_actions[n])
+                            self.couple_to_y[(n - 1, g)]
+                        ) * sum(
+                            self.ring(self.couple_to_x[(n, i)])
+                            for i in self.game.players_actions[n]
+                        )
         self.couple_to_poly_y = couple_to_poly_y
 
     def generate_poly_fact(self):
@@ -419,7 +431,8 @@ Useful only for hypergraphical games.
                 else:
                     couple_to_poly_fact[g] = couple_to_poly_fact[g] * sum(
                         self.ring(self.couple_to_x[(n, i)])
-                        for i in self.game.players_actions[n])
+                        for i in self.game.players_actions[n]
+                    )
         return couple_to_poly_fact
 
 
@@ -453,8 +466,7 @@ if of dimension 0. Else, empty.
         # Equations:
         self.equations = self.generate_equations(pcp, z, w, level, xpairs_val)
         # Inequations:
-        self.inequations = self.generate_inequations(pcp, z, w, level,
-                                                     xpairs_val)
+        self.inequations = self.generate_inequations(pcp, z, w, level, xpairs_val)
         # Ideal of the equations
         self.ideal = self.compute_ideal()
         self.idealdimension = self.ideal.dimension()
@@ -480,12 +492,11 @@ if of dimension 0. Else, empty.
         niceprint += "Inequations:\n"
         for e in range(len(self.inequations)):
             niceprint += str(self.inequations[e]) + " >=0\n"
-        niceprint += "Dimension of the ideal: " + str(
-            self.idealdimension) + "\n"
+        niceprint += "Dimension of the ideal: " + str(self.idealdimension) + "\n"
         niceprint += "Variety: " + str(self.variety) + "\n"
         niceprint += "Number of solutions: " + str(self.nbsols) + "\n"
         niceprint += "Solutions: " + str(self.solutions) + "\n"
-        return (niceprint)
+        return niceprint
 
     def generate_equations(self, pcp, z, w, level, xpairs_val):
         """
@@ -503,21 +514,23 @@ variables set to 0) that are in the subsystem.
         :rtype: list.
 
         """
-        equations = [pcp.ring(pcp.couple_to_x[(n, i)]) for (n, i) in
-                     z]  # was self.ring
+        equations = [pcp.ring(pcp.couple_to_x[(n, i)]) for (n, i) in z]  # was self.ring
         dico = {}
         for e in range(len(equations)):
             dico[equations[e]] = 0
         subpcp = pcp.substitute(dico, level)
         # Zero polynomials equation:
-        equations += [subpcp.couple_to_poly[(n, i)] for (n, i) in w if
-                      n <= level]
+        equations += [subpcp.couple_to_poly[(n, i)] for (n, i) in w if n <= level]
         # Add equations defining the y
-        equations += [pcp.couple_to_poly_y[(n, g)] for (n, g) in
-                      pcp.couple_to_poly_y.keys()]
+        equations += [
+            pcp.couple_to_poly_y[(n, g)] for (n, g) in pcp.couple_to_poly_y.keys()
+        ]
         # Add fixed variables values for n>level
-        equations += [pcp.ring(pcp.couple_to_x[(n, i)]) - xpairs_val[(n, i)]
-                      for (n, i) in pcp.couple_to_x.keys() if n > level]
+        equations += [
+            pcp.ring(pcp.couple_to_x[(n, i)]) - xpairs_val[(n, i)]
+            for (n, i) in pcp.couple_to_x.keys()
+            if n > level
+        ]
         # That's it for equations
         return equations
 
@@ -538,17 +551,19 @@ variables >= 0) that are in the subsystem.
 
         """
         x_values = {}
-        for (n, i) in pcp.couple_to_x.keys():
+        for n, i in pcp.couple_to_x.keys():
             if (n, i) in z:
-                x_values[
-                    self.ring(pcp.couple_to_x[(n, i)])] = 0  # was pcp.ring
+                x_values[self.ring(pcp.couple_to_x[(n, i)])] = 0  # was pcp.ring
             # if n>level:
             #    x_values[pcp.ring(pcp.couple_to_x[(n,i)])] = xpairs_val[(n,i)]
         subpcp = pcp.substitute(x_values, level)
-        inequations = [subpcp.couple_to_poly[(n, i)] for (n, i) in
-                       set(pcp.couple_to_x.keys()).intersection(
-                           set(subpcp.couple_to_poly.keys())) if
-                       (n, i) not in w]
+        inequations = [
+            subpcp.couple_to_poly[(n, i)]
+            for (n, i) in set(pcp.couple_to_x.keys()).intersection(
+                set(subpcp.couple_to_poly.keys())
+            )
+            if (n, i) not in w
+        ]
         return inequations
 
     def compute_ideal(self):
diff --git a/pyproject.toml b/pyproject.toml
index 40013a7..db50e2e 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -12,59 +12,14 @@ build-backend = "setuptools.build_meta"
     readme = 'README.md'
     dependencies = ['numpy']
 
-[tool.setuptools]
-    packages = ['gtnash']
-
 [project.urls]
     Documentation = "https://game-theory-tools-group.pages.mia.inra.fr/gtnash/main"
     Repository = "https://forgemia.inra.fr/game-theory-tools-group/gtnash/"
     Issues = "https://forgemia.inra.fr/game-theory-tools-group/gtnash/-/issues"
 
+[tool.setuptools]
+    packages = ['gtnash']
+
 [project.optional-dependencies]
-    code = ['pylint', 'black', 'pytest', 'coverage', 'pre-commit']
+    code = ['pylint', 'black', 'pytest']
     docs=['sphinx','sphinx-rtd-theme','gitpython','myst_parser']
-
-[tool.black]
-    line-length = 79
-    target-version = ['py38']
-
-[tool.pytest.ini_options]
-    minversion = '6.0'
-    addopts = '-ra -q -W ignore::DeprecationWarning'
-    testpaths = ['tests/']
-
-[tool.pylint.main]
-    fail-under = 8
-    ignore-patterns = ["^\\.#"]
-    jobs = 0
-    persistent = true
-    py-version = "3.8"
-    recursive = true
-    suggestion-mode = true
-    ignore = [".venv"]
-    disable = ["W0223", "E0401", "R0801"]
-
-[tool.pylint.format]
-    ignore-long-lines = "^\\s*(# )?<?https?://\\S+>?$"
-    indent-after-paren = 4
-    indent-string = "    "
-    max-line-length = 79
-    max-module-lines = 1000
-
-[tool.pylint.imports]
-    allow-any-import-level = true
-    allow-reexport-from-package = true
-
-[tool.pylint.miscellaneous]
-    notes = ["FIXME", "XXX", "TODO"]
-
-[tool.pylint.refactoring]
-    max-nested-blocks = 5
-    never-returning-functions = ["sys.exit", "argparse.parse_error"]
-
-[tool.coverage.run]
-omit = [
-    "examples/*",
-    "*test*",
-    "*__init__*",
-    ]
diff --git a/setup.py b/setup.py
deleted file mode 100644
index 071aa0f..0000000
--- a/setup.py
+++ /dev/null
@@ -1,11 +0,0 @@
-import setuptools
-
-setuptools.setup(
-    name="gtnash",
-    description="Python Nash Equilibrium Computation Utilities",
-    version="1.0.0",
-    author="Régis Sabbadin",
-    author_email="regis.sabbadin@inrae.fr",
-    url="https://forgemia.inra.fr/game-theory-tools-group/gtnash/",
-    packages=setuptools.find_packages()
-)
diff --git a/test/test_bayesian_hypergraphicalgame.py b/test/test_bayesian_hypergraphicalgame.py
index 79b3cae..dd72787 100644
--- a/test/test_bayesian_hypergraphicalgame.py
+++ b/test/test_bayesian_hypergraphicalgame.py
@@ -9,301 +9,552 @@ from fractions import Fraction
 def bayesian_polymatrix():
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
     theta = [[0, 1], [0, 1], [0, 1], [0, 1]]
-    same_game = [[[3, 0, 0, 2], [3, 0, 0, 2]], [[3, 0, 0, 2], [1, 0, 0, 2]],
-                 [[1, 0, 0, 2], [3, 0, 0, 2]], [[1, 0, 0, 2], [1, 0, 0, 2]]]
+    same_game = [
+        [[3, 0, 0, 2], [3, 0, 0, 2]],
+        [[3, 0, 0, 2], [1, 0, 0, 2]],
+        [[1, 0, 0, 2], [3, 0, 0, 2]],
+        [[1, 0, 0, 2], [1, 0, 0, 2]],
+    ]
     same_p = [4, 1, 1, 4]
     hypergr = [[0, 1], [1, 2], [2, 3], [0, 3]]
-    return BHGG(players_actions, [same_game, same_game, same_game, same_game],
-                hypergr, theta, [same_p, same_p, same_p, same_p])
+    return BHGG(
+        players_actions,
+        [same_game, same_game, same_game, same_game],
+        hypergr,
+        theta,
+        [same_p, same_p, same_p, same_p],
+    )
 
 
 # ADD a 4 player hypergraphe with edge size 3
 
+
 @pytest.fixture
 def bayesian_hgg1():
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
     theta = [[0, 1], [0, 1], [0, 1], [0, 1]]
-    utilities = [[[[39, 19, 95, 0, 32, 97, 65, 69],
-                   [22, 40, 67, 14, 100, 60, 5, 34],
-                   [46, 27, 72, 45, 18, 84, 100, 33]],
-                  [[61, 96, 22, 34, 34, 35, 39, 54],
-                   [39, 42, 77, 76, 27, 45, 56, 0],
-                   [21, 94, 80, 74, 100, 20, 55, 65]],
-                  [[34, 47, 56, 73, 55, 59, 31, 17],
-                   [57, 43, 0, 23, 41, 100, 73, 86],
-                   [24, 53, 95, 45, 38, 17, 28, 76]],
-                  [[47, 37, 100, 6, 20, 16, 17, 59],
-                   [40, 44, 64, 13, 0, 73, 76, 71],
-                   [23, 52, 19, 70, 41, 43, 30, 28]],
-                  [[53, 38, 44, 33, 9, 71, 31, 82],
-                   [62, 100, 70, 65, 74, 22, 47, 59],
-                   [66, 82, 20, 0, 15, 3, 57, 60]],
-                  [[46, 33, 0, 31, 50, 50, 35, 50],
-                   [26, 77, 56, 47, 37, 51, 56, 57],
-                   [28, 27, 100, 21, 29, 26, 83, 25]],
-                  [[70, 88, 0, 15, 7, 34, 100, 58],
-                   [53, 68, 17, 17, 16, 26, 84, 61],
-                   [63, 80, 10, 15, 11, 43, 84, 50]],
-                  [[91, 49, 99, 85, 62, 38, 21, 87],
-                   [18, 36, 74, 84, 40, 45, 39, 88],
-                   [63, 54, 57, 100, 45, 20, 0, 76]]],
-                 [[[72, 67, 47, 94, 73, 92, 80, 81],
-                   [55, 66, 45, 62, 78, 91, 55, 53],
-                   [54, 75, 47, 42, 0, 52, 47, 100]],
-                  [[64, 79, 39, 7, 43, 22, 68, 26],
-                   [48, 67, 62, 5, 74, 82, 77, 65],
-                   [40, 65, 38, 0, 59, 69, 100, 86]],
-                  [[44, 53, 46, 82, 44, 89, 69, 97],
-                   [61, 96, 88, 93, 70, 20, 100, 46],
-                   [31, 89, 0, 61, 48, 77, 84, 46]],
-                  [[59, 74, 63, 100, 34, 31, 38, 45],
-                   [55, 52, 83, 74, 10, 65, 5, 50],
-                   [74, 64, 65, 96, 19, 70, 0, 38]],
-                  [[32, 100, 0, 54, 5, 37, 45, 66],
-                   [2, 23, 49, 3, 62, 21, 23, 44],
-                   [11, 54, 67, 8, 37, 69, 83, 27]],
-                  [[41, 67, 72, 12, 65, 74, 65, 53],
-                   [68, 68, 57, 49, 0, 91, 80, 61],
-                   [97, 78, 86, 100, 34, 62, 57, 87]],
-                  [[52, 54, 63, 18, 37, 67, 75, 73],
-                   [47, 65, 93, 91, 59, 60, 0, 43],
-                   [82, 76, 49, 91, 100, 82, 95, 50]],
-                  [[39, 19, 95, 0, 32, 97, 65, 69],
-                   [22, 40, 67, 14, 100, 60, 5, 34],
-                   [46, 27, 72, 45, 18, 84, 100, 33]]]]
+    utilities = [
+        [
+            [
+                [39, 19, 95, 0, 32, 97, 65, 69],
+                [22, 40, 67, 14, 100, 60, 5, 34],
+                [46, 27, 72, 45, 18, 84, 100, 33],
+            ],
+            [
+                [61, 96, 22, 34, 34, 35, 39, 54],
+                [39, 42, 77, 76, 27, 45, 56, 0],
+                [21, 94, 80, 74, 100, 20, 55, 65],
+            ],
+            [
+                [34, 47, 56, 73, 55, 59, 31, 17],
+                [57, 43, 0, 23, 41, 100, 73, 86],
+                [24, 53, 95, 45, 38, 17, 28, 76],
+            ],
+            [
+                [47, 37, 100, 6, 20, 16, 17, 59],
+                [40, 44, 64, 13, 0, 73, 76, 71],
+                [23, 52, 19, 70, 41, 43, 30, 28],
+            ],
+            [
+                [53, 38, 44, 33, 9, 71, 31, 82],
+                [62, 100, 70, 65, 74, 22, 47, 59],
+                [66, 82, 20, 0, 15, 3, 57, 60],
+            ],
+            [
+                [46, 33, 0, 31, 50, 50, 35, 50],
+                [26, 77, 56, 47, 37, 51, 56, 57],
+                [28, 27, 100, 21, 29, 26, 83, 25],
+            ],
+            [
+                [70, 88, 0, 15, 7, 34, 100, 58],
+                [53, 68, 17, 17, 16, 26, 84, 61],
+                [63, 80, 10, 15, 11, 43, 84, 50],
+            ],
+            [
+                [91, 49, 99, 85, 62, 38, 21, 87],
+                [18, 36, 74, 84, 40, 45, 39, 88],
+                [63, 54, 57, 100, 45, 20, 0, 76],
+            ],
+        ],
+        [
+            [
+                [72, 67, 47, 94, 73, 92, 80, 81],
+                [55, 66, 45, 62, 78, 91, 55, 53],
+                [54, 75, 47, 42, 0, 52, 47, 100],
+            ],
+            [
+                [64, 79, 39, 7, 43, 22, 68, 26],
+                [48, 67, 62, 5, 74, 82, 77, 65],
+                [40, 65, 38, 0, 59, 69, 100, 86],
+            ],
+            [
+                [44, 53, 46, 82, 44, 89, 69, 97],
+                [61, 96, 88, 93, 70, 20, 100, 46],
+                [31, 89, 0, 61, 48, 77, 84, 46],
+            ],
+            [
+                [59, 74, 63, 100, 34, 31, 38, 45],
+                [55, 52, 83, 74, 10, 65, 5, 50],
+                [74, 64, 65, 96, 19, 70, 0, 38],
+            ],
+            [
+                [32, 100, 0, 54, 5, 37, 45, 66],
+                [2, 23, 49, 3, 62, 21, 23, 44],
+                [11, 54, 67, 8, 37, 69, 83, 27],
+            ],
+            [
+                [41, 67, 72, 12, 65, 74, 65, 53],
+                [68, 68, 57, 49, 0, 91, 80, 61],
+                [97, 78, 86, 100, 34, 62, 57, 87],
+            ],
+            [
+                [52, 54, 63, 18, 37, 67, 75, 73],
+                [47, 65, 93, 91, 59, 60, 0, 43],
+                [82, 76, 49, 91, 100, 82, 95, 50],
+            ],
+            [
+                [39, 19, 95, 0, 32, 97, 65, 69],
+                [22, 40, 67, 14, 100, 60, 5, 34],
+                [46, 27, 72, 45, 18, 84, 100, 33],
+            ],
+        ],
+    ]
     p = [[6, 9, 8, 6, 6, 4, 3, 3], [1, 7, 9, 1, 7, 3, 6, 9]]
     hypergraph = [[0, 1, 2], [0, 2, 3]]
     return BHGG(players_actions, utilities, hypergraph, theta, p)
 
 
 def test_joint_actions1(bayesian_polymatrix):
-    assert (bayesian_polymatrix.local_bayesiangames[0].joint_actions == np.mat(
-        [[0, 0], [0, 1], [1, 0], [1, 1]])).all()
+    assert (
+        bayesian_polymatrix.local_bayesiangames[0].joint_actions
+        == np.mat([[0, 0], [0, 1], [1, 0], [1, 1]])
+    ).all()
 
 
 def test_joint_actions2(bayesian_polymatrix):
-    assert (bayesian_polymatrix.local_bayesiangames[1].joint_actions == np.mat(
-        [[0, 0], [0, 1], [1, 0], [1, 1]])).all()
+    assert (
+        bayesian_polymatrix.local_bayesiangames[1].joint_actions
+        == np.mat([[0, 0], [0, 1], [1, 0], [1, 1]])
+    ).all()
 
 
 def test_joint_actions3(bayesian_polymatrix):
-    assert (bayesian_polymatrix.local_bayesiangames[2].joint_actions == np.mat(
-        [[0, 0], [0, 1], [1, 0], [1, 1]])).all()
+    assert (
+        bayesian_polymatrix.local_bayesiangames[2].joint_actions
+        == np.mat([[0, 0], [0, 1], [1, 0], [1, 1]])
+    ).all()
 
 
 def test_joint_actions4(bayesian_polymatrix):
-    assert (bayesian_polymatrix.local_bayesiangames[3].joint_actions == np.mat(
-        [[0, 0], [0, 1], [1, 0], [1, 1]])).all()
+    assert (
+        bayesian_polymatrix.local_bayesiangames[3].joint_actions
+        == np.mat([[0, 0], [0, 1], [1, 0], [1, 1]])
+    ).all()
 
 
 def test_joint_actions5(bayesian_hgg1):
-    assert (bayesian_hgg1.local_bayesiangames[0].joint_actions == np.mat(
-        [[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1],
-         [1, 0, 0], [1, 0, 1], [1, 1, 0], [1, 1, 1]])).all()
+    assert (
+        bayesian_hgg1.local_bayesiangames[0].joint_actions
+        == np.mat(
+            [
+                [0, 0, 0],
+                [0, 0, 1],
+                [0, 1, 0],
+                [0, 1, 1],
+                [1, 0, 0],
+                [1, 0, 1],
+                [1, 1, 0],
+                [1, 1, 1],
+            ]
+        )
+    ).all()
 
 
 def test_joint_actions6(bayesian_hgg1):
-    assert (bayesian_hgg1.local_bayesiangames[1].joint_actions == np.mat(
-        [[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1],
-         [1, 0, 0], [1, 0, 1], [1, 1, 0], [1, 1, 1]])).all()
+    assert (
+        bayesian_hgg1.local_bayesiangames[1].joint_actions
+        == np.mat(
+            [
+                [0, 0, 0],
+                [0, 0, 1],
+                [0, 1, 0],
+                [0, 1, 1],
+                [1, 0, 0],
+                [1, 0, 1],
+                [1, 1, 0],
+                [1, 1, 1],
+            ]
+        )
+    ).all()
 
 
 def test_joint_type1(bayesian_polymatrix):
-    assert (bayesian_polymatrix.local_bayesiangames[0].joint_theta == np.mat(
-        [[0, 0], [0, 1], [1, 0], [1, 1]])).all()
+    assert (
+        bayesian_polymatrix.local_bayesiangames[0].joint_theta
+        == np.mat([[0, 0], [0, 1], [1, 0], [1, 1]])
+    ).all()
 
 
 def test_joint_type2(bayesian_polymatrix):
-    assert (bayesian_polymatrix.local_bayesiangames[1].joint_theta == np.mat(
-        [[0, 0], [0, 1], [1, 0], [1, 1]])).all()
+    assert (
+        bayesian_polymatrix.local_bayesiangames[1].joint_theta
+        == np.mat([[0, 0], [0, 1], [1, 0], [1, 1]])
+    ).all()
 
 
 def test_joint_type3(bayesian_polymatrix):
-    assert (bayesian_polymatrix.local_bayesiangames[2].joint_theta == np.mat(
-        [[0, 0], [0, 1], [1, 0], [1, 1]])).all()
+    assert (
+        bayesian_polymatrix.local_bayesiangames[2].joint_theta
+        == np.mat([[0, 0], [0, 1], [1, 0], [1, 1]])
+    ).all()
 
 
 def test_joint_type4(bayesian_polymatrix):
-    assert (bayesian_polymatrix.local_bayesiangames[3].joint_theta == np.mat(
-        [[0, 0], [0, 1], [1, 0], [1, 1]])).all()
+    assert (
+        bayesian_polymatrix.local_bayesiangames[3].joint_theta
+        == np.mat([[0, 0], [0, 1], [1, 0], [1, 1]])
+    ).all()
 
 
 def test_joint_type5(bayesian_hgg1):
-    assert (bayesian_hgg1.local_bayesiangames[0].joint_theta == np.mat(
-        [[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1],
-         [1, 0, 0], [1, 0, 1], [1, 1, 0], [1, 1, 1]])).all()
+    assert (
+        bayesian_hgg1.local_bayesiangames[0].joint_theta
+        == np.mat(
+            [
+                [0, 0, 0],
+                [0, 0, 1],
+                [0, 1, 0],
+                [0, 1, 1],
+                [1, 0, 0],
+                [1, 0, 1],
+                [1, 1, 0],
+                [1, 1, 1],
+            ]
+        )
+    ).all()
 
 
 def test_joint_type6(bayesian_hgg1):
-    assert (bayesian_hgg1.local_bayesiangames[1].joint_theta == np.mat(
-        [[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1],
-         [1, 0, 0], [1, 0, 1], [1, 1, 0], [1, 1, 1]])).all()
+    assert (
+        bayesian_hgg1.local_bayesiangames[1].joint_theta
+        == np.mat(
+            [
+                [0, 0, 0],
+                [0, 0, 1],
+                [0, 1, 0],
+                [0, 1, 1],
+                [1, 0, 0],
+                [1, 0, 1],
+                [1, 1, 0],
+                [1, 1, 1],
+            ]
+        )
+    ).all()
 
 
 def test_local_utilities1(bayesian_polymatrix):
     assert bayesian_polymatrix.local_bayesiangames[0].utilities == [
-        [[3, 0, 0, 2], [3, 0, 0, 2]], [[3, 0, 0, 2], [1, 0, 0, 2]],
-        [[1, 0, 0, 2], [3, 0, 0, 2]], [[1, 0, 0, 2], [1, 0, 0, 2]]]
+        [[3, 0, 0, 2], [3, 0, 0, 2]],
+        [[3, 0, 0, 2], [1, 0, 0, 2]],
+        [[1, 0, 0, 2], [3, 0, 0, 2]],
+        [[1, 0, 0, 2], [1, 0, 0, 2]],
+    ]
 
 
 def test_local_utilities2(bayesian_polymatrix):
     assert bayesian_polymatrix.local_bayesiangames[1].utilities == [
-        [[3, 0, 0, 2], [3, 0, 0, 2]], [[3, 0, 0, 2], [1, 0, 0, 2]],
-        [[1, 0, 0, 2], [3, 0, 0, 2]], [[1, 0, 0, 2], [1, 0, 0, 2]]]
+        [[3, 0, 0, 2], [3, 0, 0, 2]],
+        [[3, 0, 0, 2], [1, 0, 0, 2]],
+        [[1, 0, 0, 2], [3, 0, 0, 2]],
+        [[1, 0, 0, 2], [1, 0, 0, 2]],
+    ]
 
 
 def test_local_utilities3(bayesian_polymatrix):
     assert bayesian_polymatrix.local_bayesiangames[2].utilities == [
-        [[3, 0, 0, 2], [3, 0, 0, 2]], [[3, 0, 0, 2], [1, 0, 0, 2]],
-        [[1, 0, 0, 2], [3, 0, 0, 2]], [[1, 0, 0, 2], [1, 0, 0, 2]]]
+        [[3, 0, 0, 2], [3, 0, 0, 2]],
+        [[3, 0, 0, 2], [1, 0, 0, 2]],
+        [[1, 0, 0, 2], [3, 0, 0, 2]],
+        [[1, 0, 0, 2], [1, 0, 0, 2]],
+    ]
 
 
 def test_local_utilities4(bayesian_polymatrix):
     assert bayesian_polymatrix.local_bayesiangames[3].utilities == [
-        [[3, 0, 0, 2], [3, 0, 0, 2]], [[3, 0, 0, 2], [1, 0, 0, 2]],
-        [[1, 0, 0, 2], [3, 0, 0, 2]], [[1, 0, 0, 2], [1, 0, 0, 2]]]
+        [[3, 0, 0, 2], [3, 0, 0, 2]],
+        [[3, 0, 0, 2], [1, 0, 0, 2]],
+        [[1, 0, 0, 2], [3, 0, 0, 2]],
+        [[1, 0, 0, 2], [1, 0, 0, 2]],
+    ]
 
 
 def test_local_utilities5(bayesian_hgg1):
     assert bayesian_hgg1.local_bayesiangames[0].utilities == [
-        [[39, 19, 95, 0, 32, 97, 65, 69], [22, 40, 67, 14, 100, 60, 5, 34],
-         [46, 27, 72, 45, 18, 84, 100, 33]],
-        [[61, 96, 22, 34, 34, 35, 39, 54], [39, 42, 77, 76, 27, 45, 56, 0],
-         [21, 94, 80, 74, 100, 20, 55, 65]],
-        [[34, 47, 56, 73, 55, 59, 31, 17], [57, 43, 0, 23, 41, 100, 73, 86],
-         [24, 53, 95, 45, 38, 17, 28, 76]],
-        [[47, 37, 100, 6, 20, 16, 17, 59], [40, 44, 64, 13, 0, 73, 76, 71],
-         [23, 52, 19, 70, 41, 43, 30, 28]],
-        [[53, 38, 44, 33, 9, 71, 31, 82], [62, 100, 70, 65, 74, 22, 47, 59],
-         [66, 82, 20, 0, 15, 3, 57, 60]],
-        [[46, 33, 0, 31, 50, 50, 35, 50], [26, 77, 56, 47, 37, 51, 56, 57],
-         [28, 27, 100, 21, 29, 26, 83, 25]],
-        [[70, 88, 0, 15, 7, 34, 100, 58], [53, 68, 17, 17, 16, 26, 84, 61],
-         [63, 80, 10, 15, 11, 43, 84, 50]],
-        [[91, 49, 99, 85, 62, 38, 21, 87], [18, 36, 74, 84, 40, 45, 39, 88],
-         [63, 54, 57, 100, 45, 20, 0, 76]]]
+        [
+            [39, 19, 95, 0, 32, 97, 65, 69],
+            [22, 40, 67, 14, 100, 60, 5, 34],
+            [46, 27, 72, 45, 18, 84, 100, 33],
+        ],
+        [
+            [61, 96, 22, 34, 34, 35, 39, 54],
+            [39, 42, 77, 76, 27, 45, 56, 0],
+            [21, 94, 80, 74, 100, 20, 55, 65],
+        ],
+        [
+            [34, 47, 56, 73, 55, 59, 31, 17],
+            [57, 43, 0, 23, 41, 100, 73, 86],
+            [24, 53, 95, 45, 38, 17, 28, 76],
+        ],
+        [
+            [47, 37, 100, 6, 20, 16, 17, 59],
+            [40, 44, 64, 13, 0, 73, 76, 71],
+            [23, 52, 19, 70, 41, 43, 30, 28],
+        ],
+        [
+            [53, 38, 44, 33, 9, 71, 31, 82],
+            [62, 100, 70, 65, 74, 22, 47, 59],
+            [66, 82, 20, 0, 15, 3, 57, 60],
+        ],
+        [
+            [46, 33, 0, 31, 50, 50, 35, 50],
+            [26, 77, 56, 47, 37, 51, 56, 57],
+            [28, 27, 100, 21, 29, 26, 83, 25],
+        ],
+        [
+            [70, 88, 0, 15, 7, 34, 100, 58],
+            [53, 68, 17, 17, 16, 26, 84, 61],
+            [63, 80, 10, 15, 11, 43, 84, 50],
+        ],
+        [
+            [91, 49, 99, 85, 62, 38, 21, 87],
+            [18, 36, 74, 84, 40, 45, 39, 88],
+            [63, 54, 57, 100, 45, 20, 0, 76],
+        ],
+    ]
 
 
 def test_local_utilities6(bayesian_hgg1):
     assert bayesian_hgg1.local_bayesiangames[1].utilities == [
-        [[72, 67, 47, 94, 73, 92, 80, 81], [55, 66, 45, 62, 78, 91, 55, 53],
-         [54, 75, 47, 42, 0, 52, 47, 100]],
-        [[64, 79, 39, 7, 43, 22, 68, 26], [48, 67, 62, 5, 74, 82, 77, 65],
-         [40, 65, 38, 0, 59, 69, 100, 86]],
-        [[44, 53, 46, 82, 44, 89, 69, 97], [61, 96, 88, 93, 70, 20, 100, 46],
-         [31, 89, 0, 61, 48, 77, 84, 46]],
-        [[59, 74, 63, 100, 34, 31, 38, 45], [55, 52, 83, 74, 10, 65, 5, 50],
-         [74, 64, 65, 96, 19, 70, 0, 38]],
-        [[32, 100, 0, 54, 5, 37, 45, 66], [2, 23, 49, 3, 62, 21, 23, 44],
-         [11, 54, 67, 8, 37, 69, 83, 27]],
-        [[41, 67, 72, 12, 65, 74, 65, 53], [68, 68, 57, 49, 0, 91, 80, 61],
-         [97, 78, 86, 100, 34, 62, 57, 87]],
-        [[52, 54, 63, 18, 37, 67, 75, 73], [47, 65, 93, 91, 59, 60, 0, 43],
-         [82, 76, 49, 91, 100, 82, 95, 50]],
-        [[39, 19, 95, 0, 32, 97, 65, 69], [22, 40, 67, 14, 100, 60, 5, 34],
-         [46, 27, 72, 45, 18, 84, 100, 33]]]
+        [
+            [72, 67, 47, 94, 73, 92, 80, 81],
+            [55, 66, 45, 62, 78, 91, 55, 53],
+            [54, 75, 47, 42, 0, 52, 47, 100],
+        ],
+        [
+            [64, 79, 39, 7, 43, 22, 68, 26],
+            [48, 67, 62, 5, 74, 82, 77, 65],
+            [40, 65, 38, 0, 59, 69, 100, 86],
+        ],
+        [
+            [44, 53, 46, 82, 44, 89, 69, 97],
+            [61, 96, 88, 93, 70, 20, 100, 46],
+            [31, 89, 0, 61, 48, 77, 84, 46],
+        ],
+        [
+            [59, 74, 63, 100, 34, 31, 38, 45],
+            [55, 52, 83, 74, 10, 65, 5, 50],
+            [74, 64, 65, 96, 19, 70, 0, 38],
+        ],
+        [
+            [32, 100, 0, 54, 5, 37, 45, 66],
+            [2, 23, 49, 3, 62, 21, 23, 44],
+            [11, 54, 67, 8, 37, 69, 83, 27],
+        ],
+        [
+            [41, 67, 72, 12, 65, 74, 65, 53],
+            [68, 68, 57, 49, 0, 91, 80, 61],
+            [97, 78, 86, 100, 34, 62, 57, 87],
+        ],
+        [
+            [52, 54, 63, 18, 37, 67, 75, 73],
+            [47, 65, 93, 91, 59, 60, 0, 43],
+            [82, 76, 49, 91, 100, 82, 95, 50],
+        ],
+        [
+            [39, 19, 95, 0, 32, 97, 65, 69],
+            [22, 40, 67, 14, 100, 60, 5, 34],
+            [46, 27, 72, 45, 18, 84, 100, 33],
+        ],
+    ]
 
 
 def test_local_proba1(bayesian_polymatrix):
-    assert bayesian_polymatrix.local_bayesiangames[0].p == [Fraction(4, 10),
-                                                            Fraction(1, 10),
-                                                            Fraction(1, 10),
-                                                            Fraction(4, 10)]
+    assert bayesian_polymatrix.local_bayesiangames[0].p == [
+        Fraction(4, 10),
+        Fraction(1, 10),
+        Fraction(1, 10),
+        Fraction(4, 10),
+    ]
 
 
 def test_local_proba2(bayesian_polymatrix):
-    assert bayesian_polymatrix.local_bayesiangames[1].p == [Fraction(4, 10),
-                                                            Fraction(1, 10),
-                                                            Fraction(1, 10),
-                                                            Fraction(4, 10)]
+    assert bayesian_polymatrix.local_bayesiangames[1].p == [
+        Fraction(4, 10),
+        Fraction(1, 10),
+        Fraction(1, 10),
+        Fraction(4, 10),
+    ]
 
 
 def test_local_proba3(bayesian_polymatrix):
-    assert bayesian_polymatrix.local_bayesiangames[2].p == [Fraction(4, 10),
-                                                            Fraction(1, 10),
-                                                            Fraction(1, 10),
-                                                            Fraction(4, 10)]
+    assert bayesian_polymatrix.local_bayesiangames[2].p == [
+        Fraction(4, 10),
+        Fraction(1, 10),
+        Fraction(1, 10),
+        Fraction(4, 10),
+    ]
 
 
 def test_local_proba4(bayesian_polymatrix):
-    assert bayesian_polymatrix.local_bayesiangames[3].p == [Fraction(4, 10),
-                                                            Fraction(1, 10),
-                                                            Fraction(1, 10),
-                                                            Fraction(4, 10)]
+    assert bayesian_polymatrix.local_bayesiangames[3].p == [
+        Fraction(4, 10),
+        Fraction(1, 10),
+        Fraction(1, 10),
+        Fraction(4, 10),
+    ]
 
 
 def test_local_proba5(bayesian_hgg1):
-    assert bayesian_hgg1.local_bayesiangames[0].p == [Fraction(6, 45),
-                                                      Fraction(1, 5),
-                                                      Fraction(8, 45),
-                                                      Fraction(6, 45),
-                                                      Fraction(6, 45),
-                                                      Fraction(4, 45),
-                                                      Fraction(1, 15),
-                                                      Fraction(1, 15)]
+    assert bayesian_hgg1.local_bayesiangames[0].p == [
+        Fraction(6, 45),
+        Fraction(1, 5),
+        Fraction(8, 45),
+        Fraction(6, 45),
+        Fraction(6, 45),
+        Fraction(4, 45),
+        Fraction(1, 15),
+        Fraction(1, 15),
+    ]
 
 
 def test_local_proba6(bayesian_hgg1):
-    assert bayesian_hgg1.local_bayesiangames[1].p == [Fraction(1, 43),
-                                                      Fraction(7, 43),
-                                                      Fraction(9, 43),
-                                                      Fraction(1, 43),
-                                                      Fraction(7, 43),
-                                                      Fraction(3, 43),
-                                                      Fraction(6, 43),
-                                                      Fraction(9, 43)]
+    assert bayesian_hgg1.local_bayesiangames[1].p == [
+        Fraction(1, 43),
+        Fraction(7, 43),
+        Fraction(9, 43),
+        Fraction(1, 43),
+        Fraction(7, 43),
+        Fraction(3, 43),
+        Fraction(6, 43),
+        Fraction(9, 43),
+    ]
 
 
 def test_expected_utilities1(bayesian_polymatrix):
     assert bayesian_polymatrix.expected_utilities(
-        {(0, 0): [1, 0], (0, 1): [1, 0], (1, 0): [1, 0], (1, 1): [1, 0],
-         (2, 0): [1, 0], (2, 1): [1, 0], (3, 0): [1, 0], (3, 1): [1, 0]}) == {
-               (0, 0): Fraction(6, 1), (0, 1): Fraction(2, 1),
-               (1, 0): Fraction(6, 1), (1, 1): Fraction(2, 1),
-               (2, 0): Fraction(6, 1), (2, 1): Fraction(2, 1),
-               (3, 0): Fraction(6, 1), (3, 1): Fraction(2, 1)}
+        {
+            (0, 0): [1, 0],
+            (0, 1): [1, 0],
+            (1, 0): [1, 0],
+            (1, 1): [1, 0],
+            (2, 0): [1, 0],
+            (2, 1): [1, 0],
+            (3, 0): [1, 0],
+            (3, 1): [1, 0],
+        }
+    ) == {
+        (0, 0): Fraction(6, 1),
+        (0, 1): Fraction(2, 1),
+        (1, 0): Fraction(6, 1),
+        (1, 1): Fraction(2, 1),
+        (2, 0): Fraction(6, 1),
+        (2, 1): Fraction(2, 1),
+        (3, 0): Fraction(6, 1),
+        (3, 1): Fraction(2, 1),
+    }
 
 
 def test_expected_utilities2(bayesian_polymatrix):
     assert bayesian_polymatrix.expected_utilities(
-        {(0, 0): [0, 1], (0, 1): [0, 1], (1, 0): [0, 1], (1, 1): [0, 1],
-         (2, 0): [0, 1], (2, 1): [0, 1], (3, 0): [0, 1],
-         (3, 1): [0, 1]}) == {(0, 0): Fraction(4, 1), (0, 1): Fraction(4, 1),
-                              (1, 0): Fraction(4, 1), (1, 1): Fraction(4, 1),
-                              (2, 0): Fraction(4, 1), (2, 1): Fraction(4, 1),
-                              (3, 0): Fraction(4, 1),
-                              (3, 1): Fraction(4, 1)}
+        {
+            (0, 0): [0, 1],
+            (0, 1): [0, 1],
+            (1, 0): [0, 1],
+            (1, 1): [0, 1],
+            (2, 0): [0, 1],
+            (2, 1): [0, 1],
+            (3, 0): [0, 1],
+            (3, 1): [0, 1],
+        }
+    ) == {
+        (0, 0): Fraction(4, 1),
+        (0, 1): Fraction(4, 1),
+        (1, 0): Fraction(4, 1),
+        (1, 1): Fraction(4, 1),
+        (2, 0): Fraction(4, 1),
+        (2, 1): Fraction(4, 1),
+        (3, 0): Fraction(4, 1),
+        (3, 1): Fraction(4, 1),
+    }
 
 
 def test_expected_utilities3(bayesian_hgg1):
-    assert bayesian_hgg1.expected_utilities({(0, 0): [1, 0], (0, 1): [1, 0],
-                                             (1, 0): [1, 0], (1, 1): [1, 0],
-                                             (2, 0): [1, 0], (2, 1): [1, 0],
-                                             (3, 0): [1, 0],
-                                             (3, 1): [1, 0]}) == {
-               (0, 0): Fraction(17447, 174), (0, 1): Fraction(8157, 80),
-               (1, 0): Fraction(959, 25), (1, 1): Fraction(909, 20),
-               (2, 0): Fraction(10987, 138), (2, 1): Fraction(19774, 275),
-               (3, 0): Fraction(902, 23), (3, 1): Fraction(1059, 20)}
+    assert bayesian_hgg1.expected_utilities(
+        {
+            (0, 0): [1, 0],
+            (0, 1): [1, 0],
+            (1, 0): [1, 0],
+            (1, 1): [1, 0],
+            (2, 0): [1, 0],
+            (2, 1): [1, 0],
+            (3, 0): [1, 0],
+            (3, 1): [1, 0],
+        }
+    ) == {
+        (0, 0): Fraction(17447, 174),
+        (0, 1): Fraction(8157, 80),
+        (1, 0): Fraction(959, 25),
+        (1, 1): Fraction(909, 20),
+        (2, 0): Fraction(10987, 138),
+        (2, 1): Fraction(19774, 275),
+        (3, 0): Fraction(902, 23),
+        (3, 1): Fraction(1059, 20),
+    }
 
 
 def test_is_equilibrium1(bayesian_polymatrix):
     assert bayesian_polymatrix.is_equilibrium(
-        {(0, 0): [0, 1], (0, 1): [0, 1], (1, 0): [0, 1], (1, 1): [0, 1],
-         (2, 0): [0, 1], (2, 1): [0, 1], (3, 0): [0, 1],
-         (3, 1): [0, 1]})
+        {
+            (0, 0): [0, 1],
+            (0, 1): [0, 1],
+            (1, 0): [0, 1],
+            (1, 1): [0, 1],
+            (2, 0): [0, 1],
+            (2, 1): [0, 1],
+            (3, 0): [0, 1],
+            (3, 1): [0, 1],
+        }
+    )
 
 
 def test_is_equilibrium2(bayesian_polymatrix):
     assert bayesian_polymatrix.is_equilibrium(
-        {(0, 0): [1, 0], (0, 1): [1, 0], (1, 0): [1, 0], (1, 1): [1, 0],
-         (2, 0): [1, 0], (2, 1): [1, 0], (3, 0): [1, 0], (3, 1): [1, 0]})
+        {
+            (0, 0): [1, 0],
+            (0, 1): [1, 0],
+            (1, 0): [1, 0],
+            (1, 1): [1, 0],
+            (2, 0): [1, 0],
+            (2, 1): [1, 0],
+            (3, 0): [1, 0],
+            (3, 1): [1, 0],
+        }
+    )
 
 
 def test_is_equilibrium3(bayesian_polymatrix):
     assert bayesian_polymatrix.is_equilibrium(
-        {(0, 0): [1, 0], (0, 1): [0, 1], (1, 0): [1, 0], (1, 1): [0, 1],
-         (2, 0): [1, 0], (2, 1): [0, 1], (3, 0): [1, 0], (3, 1): [0, 1]})
+        {
+            (0, 0): [1, 0],
+            (0, 1): [0, 1],
+            (1, 0): [1, 0],
+            (1, 1): [0, 1],
+            (2, 0): [1, 0],
+            (2, 1): [0, 1],
+            (3, 0): [1, 0],
+            (3, 1): [0, 1],
+        }
+    )
 
 
 def test_read_GameFile():
@@ -313,15 +564,22 @@ def test_read_GameFile():
     assert read_bhgg.hypergraph == [[1, 2], [0, 1]]
     assert read_bhgg.p == [
         [Fraction(7, 19), Fraction(1, 19), Fraction(2, 19), Fraction(9, 19)],
-        [Fraction(1, 17), Fraction(4, 17), Fraction(5, 17), Fraction(7, 17)]]
-    assert read_bhgg.utilities == [[[[15, 41, 0, 7], [14, 23, 65, 100]],
-                                    [[0, 41, 58, 92], [100, 51, 72, 93]],
-                                    [[56, 38, 0, 14], [100, 95, 43, 0]],
-                                    [[53, 69, 17, 15], [98, 12, 100, 0]]],
-                                   [[[39, 12, 42, 50], [0, 78, 38, 100]],
-                                    [[0, 7, 100, 58], [15, 10, 66, 78]],
-                                    [[74, 100, 96, 76], [0, 29, 98, 35]],
-                                    [[52, 21, 10, 100], [0, 43, 81, 56]]]]
+        [Fraction(1, 17), Fraction(4, 17), Fraction(5, 17), Fraction(7, 17)],
+    ]
+    assert read_bhgg.utilities == [
+        [
+            [[15, 41, 0, 7], [14, 23, 65, 100]],
+            [[0, 41, 58, 92], [100, 51, 72, 93]],
+            [[56, 38, 0, 14], [100, 95, 43, 0]],
+            [[53, 69, 17, 15], [98, 12, 100, 0]],
+        ],
+        [
+            [[39, 12, 42, 50], [0, 78, 38, 100]],
+            [[0, 7, 100, 58], [15, 10, 66, 78]],
+            [[74, 100, 96, 76], [0, 29, 98, 35]],
+            [[52, 21, 10, 100], [0, 43, 81, 56]],
+        ],
+    ]
 
 
 def test_read_GameFile2(bayesian_hgg1):
@@ -380,43 +638,99 @@ def test_write_GameFile2(bayesian_hgg1):
 
 def test_convert_to_HGG(bayesian_polymatrix):
     pmg, index_old = bayesian_polymatrix.convert_to_HGG()
-    assert pmg.players_actions == [[0, 1], [0, 1], [0, 1], [0, 1],
-                                   [0, 1], [0, 1], [0, 1], [0, 1]]
+    assert pmg.players_actions == [
+        [0, 1],
+        [0, 1],
+        [0, 1],
+        [0, 1],
+        [0, 1],
+        [0, 1],
+        [0, 1],
+        [0, 1],
+    ]
     for couple in pmg.hypergraph:
-        assert couple in [[0, 2], [0, 3], [1, 2], [1, 3], [2, 4], [2, 5],
-                          [3, 4], [3, 5], [4, 6], [4, 7], [5, 6], [5, 7],
-                          [0, 6], [0, 7], [1, 6], [1, 7]]
+        assert couple in [
+            [0, 2],
+            [0, 3],
+            [1, 2],
+            [1, 3],
+            [2, 4],
+            [2, 5],
+            [3, 4],
+            [3, 5],
+            [4, 6],
+            [4, 7],
+            [5, 6],
+            [5, 7],
+            [0, 6],
+            [0, 7],
+            [1, 6],
+            [1, 7],
+        ]
     # assert pmg.utilities ==[]
     assert pmg.utilities == [
-        [[Fraction(12, 5), 0, 0, Fraction(8, 5)],
-         [Fraction(12, 5), 0, 0, Fraction(8, 5)]],
-        [[Fraction(3, 5), 0, 0, Fraction(2, 5)],
-         [Fraction(1, 5), 0, 0, Fraction(2, 5)]],
-        [[Fraction(1, 5), 0, 0, Fraction(2, 5)],
-         [Fraction(3, 5), 0, 0, Fraction(2, 5)]],
-        [[Fraction(4, 5), 0, 0, Fraction(8, 5)],
-         [Fraction(4, 5), 0, 0, Fraction(8, 5)]],
-        [[Fraction(12, 5), 0, 0, Fraction(8, 5)],
-         [Fraction(12, 5), 0, 0, Fraction(8, 5)]],
-        [[Fraction(3, 5), 0, 0, Fraction(2, 5)],
-         [Fraction(1, 5), 0, 0, Fraction(2, 5)]],
-        [[Fraction(1, 5), 0, 0, Fraction(2, 5)],
-         [Fraction(3, 5), 0, 0, Fraction(2, 5)]],
-        [[Fraction(4, 5), 0, 0, Fraction(8, 5)],
-         [Fraction(4, 5), 0, 0, Fraction(8, 5)]],
-        [[Fraction(12, 5), 0, 0, Fraction(8, 5)],
-         [Fraction(12, 5), 0, 0, Fraction(8, 5)]],
-        [[Fraction(3, 5), 0, 0, Fraction(2, 5)],
-         [Fraction(1, 5), 0, 0, Fraction(2, 5)]],
-        [[Fraction(1, 5), 0, 0, Fraction(2, 5)],
-         [Fraction(3, 5), 0, 0, Fraction(2, 5)]],
-        [[Fraction(4, 5), 0, 0, Fraction(8, 5)],
-         [Fraction(4, 5), 0, 0, Fraction(8, 5)]],
-        [[Fraction(12, 5), 0, 0, Fraction(8, 5)],
-         [Fraction(12, 5), 0, 0, Fraction(8, 5)]],
-        [[Fraction(3, 5), 0, 0, Fraction(2, 5)],
-         [Fraction(1, 5), 0, 0, Fraction(2, 5)]],
-        [[Fraction(1, 5), 0, 0, Fraction(2, 5)],
-         [Fraction(3, 5), 0, 0, Fraction(2, 5)]],
-        [[Fraction(4, 5), 0, 0, Fraction(8, 5)],
-         [Fraction(4, 5), 0, 0, Fraction(8, 5)]]]
+        [
+            [Fraction(12, 5), 0, 0, Fraction(8, 5)],
+            [Fraction(12, 5), 0, 0, Fraction(8, 5)],
+        ],
+        [
+            [Fraction(3, 5), 0, 0, Fraction(2, 5)],
+            [Fraction(1, 5), 0, 0, Fraction(2, 5)],
+        ],
+        [
+            [Fraction(1, 5), 0, 0, Fraction(2, 5)],
+            [Fraction(3, 5), 0, 0, Fraction(2, 5)],
+        ],
+        [
+            [Fraction(4, 5), 0, 0, Fraction(8, 5)],
+            [Fraction(4, 5), 0, 0, Fraction(8, 5)],
+        ],
+        [
+            [Fraction(12, 5), 0, 0, Fraction(8, 5)],
+            [Fraction(12, 5), 0, 0, Fraction(8, 5)],
+        ],
+        [
+            [Fraction(3, 5), 0, 0, Fraction(2, 5)],
+            [Fraction(1, 5), 0, 0, Fraction(2, 5)],
+        ],
+        [
+            [Fraction(1, 5), 0, 0, Fraction(2, 5)],
+            [Fraction(3, 5), 0, 0, Fraction(2, 5)],
+        ],
+        [
+            [Fraction(4, 5), 0, 0, Fraction(8, 5)],
+            [Fraction(4, 5), 0, 0, Fraction(8, 5)],
+        ],
+        [
+            [Fraction(12, 5), 0, 0, Fraction(8, 5)],
+            [Fraction(12, 5), 0, 0, Fraction(8, 5)],
+        ],
+        [
+            [Fraction(3, 5), 0, 0, Fraction(2, 5)],
+            [Fraction(1, 5), 0, 0, Fraction(2, 5)],
+        ],
+        [
+            [Fraction(1, 5), 0, 0, Fraction(2, 5)],
+            [Fraction(3, 5), 0, 0, Fraction(2, 5)],
+        ],
+        [
+            [Fraction(4, 5), 0, 0, Fraction(8, 5)],
+            [Fraction(4, 5), 0, 0, Fraction(8, 5)],
+        ],
+        [
+            [Fraction(12, 5), 0, 0, Fraction(8, 5)],
+            [Fraction(12, 5), 0, 0, Fraction(8, 5)],
+        ],
+        [
+            [Fraction(3, 5), 0, 0, Fraction(2, 5)],
+            [Fraction(1, 5), 0, 0, Fraction(2, 5)],
+        ],
+        [
+            [Fraction(1, 5), 0, 0, Fraction(2, 5)],
+            [Fraction(3, 5), 0, 0, Fraction(2, 5)],
+        ],
+        [
+            [Fraction(4, 5), 0, 0, Fraction(8, 5)],
+            [Fraction(4, 5), 0, 0, Fraction(8, 5)],
+        ],
+    ]
diff --git a/test/test_bayesiangame.py b/test/test_bayesiangame.py
index 6f9973f..54bfc7d 100644
--- a/test/test_bayesiangame.py
+++ b/test/test_bayesiangame.py
@@ -8,12 +8,14 @@ from fractions import Fraction
 @pytest.fixture
 def bimat_bg():
     players_actions = [[0, 1, 2], [0, 1]]
-    utilities = [[[-3, -7, -10, -1, -5, -9], [-3, -7, -1, -5, -10, -9]],
-                 [[-2, -6, -9, -1, -4, -8], [-2, -6, -1, -4, -9, -8]],
-                 [[-2, -5, -8, -1, -3, -7], [-2, -5, -1, -3, -8, -7]],
-                 [[-2, -4, -7, -1, -3, -6], [-2, -4, -1, -3, -7, -6]],
-                 [[-2, -4, -6, -1, -3, -5], [-2, -4, -1, -3, -6, -5]],
-                 [[-3, -7, -1, -5, -10, -9], [-3, -7, -10, -1, -5, -9]]]
+    utilities = [
+        [[-3, -7, -10, -1, -5, -9], [-3, -7, -1, -5, -10, -9]],
+        [[-2, -6, -9, -1, -4, -8], [-2, -6, -1, -4, -9, -8]],
+        [[-2, -5, -8, -1, -3, -7], [-2, -5, -1, -3, -8, -7]],
+        [[-2, -4, -7, -1, -3, -6], [-2, -4, -1, -3, -7, -6]],
+        [[-2, -4, -6, -1, -3, -5], [-2, -4, -1, -3, -6, -5]],
+        [[-3, -7, -1, -5, -10, -9], [-3, -7, -10, -1, -5, -9]],
+    ]
     theta = [[0, 1], [0, 1, 2]]
     p = [2, 4, 4, 4, 2, 4]
     return BG(players_actions, utilities, theta, p)
@@ -22,8 +24,7 @@ def bimat_bg():
 @pytest.fixture
 def sherif_bg1():
     players_actions = [[0, 1], [0, 1]]
-    utilities = [[[-1, -1, -2, 0], [-3, -2, -1, 0]],
-                 [[0, -1, -2, 1], [0, -2, 2, -1]]]
+    utilities = [[[-1, -1, -2, 0], [-3, -2, -1, 0]], [[0, -1, -2, 1], [0, -2, 2, -1]]]
     theta = [[0], [0, 1]]
     p = [1, 2]
     return BG(players_actions, utilities, theta, p)
@@ -32,8 +33,7 @@ def sherif_bg1():
 @pytest.fixture
 def sherif_bg2():
     players_actions = [[0, 1], [0, 1]]
-    utilities = [[[-1, -1, -2, 0], [-3, -2, -1, 0]],
-                 [[0, -1, -2, 1], [0, -2, 2, -1]]]
+    utilities = [[[-1, -1, -2, 0], [-3, -2, -1, 0]], [[0, -1, -2, 1], [0, -2, 2, -1]]]
     theta = [[0], [0, 1]]
     p = [2, 1]
     return BG(players_actions, utilities, theta, p)
@@ -42,8 +42,7 @@ def sherif_bg2():
 @pytest.fixture
 def sherif_bg3():
     players_actions = [[0, 1], [0, 1]]
-    utilities = [[[-1, -1, -2, 0], [-3, -2, -1, 0]],
-                 [[0, -1, -2, 1], [0, -2, 2, -1]]]
+    utilities = [[[-1, -1, -2, 0], [-3, -2, -1, 0]], [[0, -1, -2, 1], [0, -2, 2, -1]]]
     theta = [[0], [0, 1]]
     p = [3, 1]
     return BG(players_actions, utilities, theta, p)
@@ -55,22 +54,47 @@ def three_bg():
     theta = [[0, 1], [0, 1], [0, 1]]
     all_p = [1, 2, 1, 4, 2, 2, 2, 6]
     utilities = [
-        [[87, 56, 33, 21, 88, 77, 79, 69], [39, 52, 4, 92, 1, 78, 60, 69],
-         [2, 28, 92, 11, 16, 63, 21, 22]],
-        [[97, 12, 13, 92, 38, 2, 91, 62], [32, 40, 10, 57, 19, 18, 19, 15],
-         [35, 12, 0, 56, 93, 22, 52, 35]],
-        [[67, 0, 13, 87, 83, 6, 1, 80], [27, 63, 31, 22, 18, 8, 46, 81],
-         [88, 28, 35, 5, 52, 67, 21, 12]],
-        [[76, 13, 70, 36, 8, 39, 22, 42], [43, 82, 81, 37, 70, 58, 28, 91],
-         [13, 25, 6, 96, 31, 27, 5, 37]],
-        [[42, 62, 83, 91, 62, 11, 19, 0], [33, 88, 78, 14, 90, 27, 40, 86],
-         [29, 91, 63, 65, 78, 36, 3, 35]],
-        [[78, 51, 25, 64, 84, 53, 19, 30], [94, 8, 47, 52, 17, 89, 21, 54],
-         [39, 13, 7, 46, 4, 14, 46, 3]],
-        [[21, 33, 41, 4, 40, 5, 47, 13], [72, 6, 92, 29, 73, 54, 22, 30],
-         [23, 86, 14, 46, 99, 34, 62, 97]],
-        [[69, 11, 25, 65, 82, 52, 68, 56], [33, 12, 39, 98, 41, 63, 99, 10],
-         [18, 62, 99, 58, 62, 25, 55, 7]]]
+        [
+            [87, 56, 33, 21, 88, 77, 79, 69],
+            [39, 52, 4, 92, 1, 78, 60, 69],
+            [2, 28, 92, 11, 16, 63, 21, 22],
+        ],
+        [
+            [97, 12, 13, 92, 38, 2, 91, 62],
+            [32, 40, 10, 57, 19, 18, 19, 15],
+            [35, 12, 0, 56, 93, 22, 52, 35],
+        ],
+        [
+            [67, 0, 13, 87, 83, 6, 1, 80],
+            [27, 63, 31, 22, 18, 8, 46, 81],
+            [88, 28, 35, 5, 52, 67, 21, 12],
+        ],
+        [
+            [76, 13, 70, 36, 8, 39, 22, 42],
+            [43, 82, 81, 37, 70, 58, 28, 91],
+            [13, 25, 6, 96, 31, 27, 5, 37],
+        ],
+        [
+            [42, 62, 83, 91, 62, 11, 19, 0],
+            [33, 88, 78, 14, 90, 27, 40, 86],
+            [29, 91, 63, 65, 78, 36, 3, 35],
+        ],
+        [
+            [78, 51, 25, 64, 84, 53, 19, 30],
+            [94, 8, 47, 52, 17, 89, 21, 54],
+            [39, 13, 7, 46, 4, 14, 46, 3],
+        ],
+        [
+            [21, 33, 41, 4, 40, 5, 47, 13],
+            [72, 6, 92, 29, 73, 54, 22, 30],
+            [23, 86, 14, 46, 99, 34, 62, 97],
+        ],
+        [
+            [69, 11, 25, 65, 82, 52, 68, 56],
+            [33, 12, 39, 98, 41, 63, 99, 10],
+            [18, 62, 99, 58, 62, 25, 55, 7],
+        ],
+    ]
     return BG(players_actions, utilities, theta, all_p)
 
 
@@ -79,48 +103,80 @@ def three_bg():
 
 
 def test_joint_actions1(bimat_bg):
-    assert (bimat_bg.joint_actions == np.mat(
-        [[0., 0.], [0., 1.], [1., 0.], [1., 1.], [2., 0.], [2., 1.]])).all()
+    assert (
+        bimat_bg.joint_actions
+        == np.mat(
+            [[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0], [2.0, 0.0], [2.0, 1.0]]
+        )
+    ).all()
 
 
 def test_joint_actions2(sherif_bg1):
-    assert (sherif_bg1.joint_actions == np.mat(
-        [[0., 0.], [0., 1.], [1., 0.], [1., 1.]])).all()
+    assert (
+        sherif_bg1.joint_actions
+        == np.mat([[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]])
+    ).all()
 
 
 def test_joint_actions3(three_bg):
-    assert (three_bg.joint_actions == np.mat(
-        [[0., 0., 0.], [0., 0., 1.], [0., 1., 0.], [0., 1., 1.], [1., 0., 0.],
-         [1., 0., 1.], [1., 1., 0.],
-         [1., 1., 1.]])).all()
+    assert (
+        three_bg.joint_actions
+        == np.mat(
+            [
+                [0.0, 0.0, 0.0],
+                [0.0, 0.0, 1.0],
+                [0.0, 1.0, 0.0],
+                [0.0, 1.0, 1.0],
+                [1.0, 0.0, 0.0],
+                [1.0, 0.0, 1.0],
+                [1.0, 1.0, 0.0],
+                [1.0, 1.0, 1.0],
+            ]
+        )
+    ).all()
 
 
 def test_joint_type1(bimat_bg):
-    assert (bimat_bg.joint_theta == np.mat(
-        [[0., 0.], [0., 1.], [0., 2.], [1., 0.], [1., 1.], [1., 2.]])).all()
+    assert (
+        bimat_bg.joint_theta
+        == np.mat(
+            [[0.0, 0.0], [0.0, 1.0], [0.0, 2.0], [1.0, 0.0], [1.0, 1.0], [1.0, 2.0]]
+        )
+    ).all()
 
 
 def test_joint_type2(sherif_bg1):
-    assert (sherif_bg1.joint_theta == np.mat([[0., 0.], [0., 1.]])).all()
+    assert (sherif_bg1.joint_theta == np.mat([[0.0, 0.0], [0.0, 1.0]])).all()
 
 
 def test_joint_type3(three_bg):
-    assert (three_bg.joint_theta == np.mat(
-        [[0., 0., 0.], [0., 0., 1.], [0., 1., 0.], [0., 1., 1.], [1., 0., 0.],
-         [1., 0., 1.], [1., 1., 0.],
-         [1., 1., 1.]])).all()
+    assert (
+        three_bg.joint_theta
+        == np.mat(
+            [
+                [0.0, 0.0, 0.0],
+                [0.0, 0.0, 1.0],
+                [0.0, 1.0, 0.0],
+                [0.0, 1.0, 1.0],
+                [1.0, 0.0, 0.0],
+                [1.0, 0.0, 1.0],
+                [1.0, 1.0, 0.0],
+                [1.0, 1.0, 1.0],
+            ]
+        )
+    ).all()
 
 
 def test_proba_norm1(bimat_bg):
-    assert (sum(bimat_bg.p) == 1)
+    assert sum(bimat_bg.p) == 1
 
 
 def test_proba_norm2(sherif_bg1):
-    assert (sum(sherif_bg1.p) == 1)
+    assert sum(sherif_bg1.p) == 1
 
 
 def test_proba_norm3(three_bg):
-    assert (sum(three_bg.p) == 1)
+    assert sum(three_bg.p) == 1
 
 
 """
@@ -133,9 +189,14 @@ generate_joint_matrix(into_mat)
 
 
 def test_proba_type1(bimat_bg):
-    assert bimat_bg.proba_type() == {0: Fraction(1, 10), 1: Fraction(2, 10),
-                                     2: Fraction(2, 10), 3: Fraction(2, 10),
-                                     4: Fraction(1, 10), 5: Fraction(2, 10)}
+    assert bimat_bg.proba_type() == {
+        0: Fraction(1, 10),
+        1: Fraction(2, 10),
+        2: Fraction(2, 10),
+        3: Fraction(2, 10),
+        4: Fraction(1, 10),
+        5: Fraction(2, 10),
+    }
 
 
 def test_proba_type2(sherif_bg1):
@@ -143,10 +204,16 @@ def test_proba_type2(sherif_bg1):
 
 
 def test_proba_type3(three_bg):
-    assert three_bg.proba_type() == {0: Fraction(1, 20), 1: Fraction(2, 20),
-                                     2: Fraction(1, 20), 3: Fraction(4, 20),
-                                     4: Fraction(2, 20), 5: Fraction(2, 20),
-                                     6: Fraction(2, 20), 7: Fraction(6, 20)}
+    assert three_bg.proba_type() == {
+        0: Fraction(1, 20),
+        1: Fraction(2, 20),
+        2: Fraction(1, 20),
+        3: Fraction(4, 20),
+        4: Fraction(2, 20),
+        5: Fraction(2, 20),
+        6: Fraction(2, 20),
+        7: Fraction(6, 20),
+    }
 
 
 def test_get_index_of_type1(bimat_bg):
@@ -214,35 +281,47 @@ def test_get_index_of_type16(three_bg):
 
 
 def test_conditional_probabilities1(bimat_bg):
-    assert bimat_bg.conditional_probabilities(0, 0) == {0: Fraction(1, 5),
-                                                        1: Fraction(2, 5),
-                                                        2: Fraction(2, 5)}
+    assert bimat_bg.conditional_probabilities(0, 0) == {
+        0: Fraction(1, 5),
+        1: Fraction(2, 5),
+        2: Fraction(2, 5),
+    }
 
 
 def test_conditional_probabilities2(bimat_bg):
-    assert bimat_bg.conditional_probabilities(0, 1) == {3: Fraction(2, 5),
-                                                        4: Fraction(1, 5),
-                                                        5: Fraction(2, 5)}
+    assert bimat_bg.conditional_probabilities(0, 1) == {
+        3: Fraction(2, 5),
+        4: Fraction(1, 5),
+        5: Fraction(2, 5),
+    }
 
 
 def test_conditional_probabilities3(bimat_bg):
-    assert bimat_bg.conditional_probabilities(1, 0) == {0: Fraction(1, 3),
-                                                        3: Fraction(2, 3)}
+    assert bimat_bg.conditional_probabilities(1, 0) == {
+        0: Fraction(1, 3),
+        3: Fraction(2, 3),
+    }
 
 
 def test_conditional_probabilities4(bimat_bg):
-    assert bimat_bg.conditional_probabilities(1, 1) == {1: Fraction(2, 3),
-                                                        4: Fraction(1, 3)}
+    assert bimat_bg.conditional_probabilities(1, 1) == {
+        1: Fraction(2, 3),
+        4: Fraction(1, 3),
+    }
 
 
 def test_conditional_probabilities5(bimat_bg):
-    assert bimat_bg.conditional_probabilities(1, 2) == {2: Fraction(1, 2),
-                                                        5: Fraction(1, 2)}
+    assert bimat_bg.conditional_probabilities(1, 2) == {
+        2: Fraction(1, 2),
+        5: Fraction(1, 2),
+    }
 
 
 def test_conditional_probabilities6(sherif_bg1):
-    assert sherif_bg1.conditional_probabilities(0, 0) == {0: Fraction(1, 3),
-                                                          1: Fraction(2, 3)}
+    assert sherif_bg1.conditional_probabilities(0, 0) == {
+        0: Fraction(1, 3),
+        1: Fraction(2, 3),
+    }
 
 
 def test_conditional_probabilities7(sherif_bg1):
@@ -254,50 +333,64 @@ def test_conditional_probabilities8(sherif_bg1):
 
 
 def test_conditional_probabilities9(sherif_bg2):
-    assert sherif_bg2.conditional_probabilities(0, 0) == {1: Fraction(1, 3),
-                                                          0: Fraction(2, 3)}
+    assert sherif_bg2.conditional_probabilities(0, 0) == {
+        1: Fraction(1, 3),
+        0: Fraction(2, 3),
+    }
 
 
 def test_conditional_probabilities10(three_bg):
-    assert three_bg.conditional_probabilities(0, 0) == {0: Fraction(1, 8),
-                                                        1: Fraction(1, 4),
-                                                        2: Fraction(1, 8),
-                                                        3: Fraction(1, 2)}
+    assert three_bg.conditional_probabilities(0, 0) == {
+        0: Fraction(1, 8),
+        1: Fraction(1, 4),
+        2: Fraction(1, 8),
+        3: Fraction(1, 2),
+    }
 
 
 def test_conditional_probabilities11(three_bg):
-    assert three_bg.conditional_probabilities(0, 1) == {4: Fraction(1, 6),
-                                                        5: Fraction(1, 6),
-                                                        6: Fraction(1, 6),
-                                                        7: Fraction(1, 2)}
+    assert three_bg.conditional_probabilities(0, 1) == {
+        4: Fraction(1, 6),
+        5: Fraction(1, 6),
+        6: Fraction(1, 6),
+        7: Fraction(1, 2),
+    }
 
 
 def test_conditional_probabilities12(three_bg):
-    assert three_bg.conditional_probabilities(1, 0) == {0: Fraction(1, 7),
-                                                        1: Fraction(2, 7),
-                                                        4: Fraction(2, 7),
-                                                        5: Fraction(2, 7)}
+    assert three_bg.conditional_probabilities(1, 0) == {
+        0: Fraction(1, 7),
+        1: Fraction(2, 7),
+        4: Fraction(2, 7),
+        5: Fraction(2, 7),
+    }
 
 
 def test_conditional_probabilities13(three_bg):
-    assert three_bg.conditional_probabilities(1, 1) == {2: Fraction(1, 13),
-                                                        3: Fraction(4, 13),
-                                                        6: Fraction(2, 13),
-                                                        7: Fraction(6, 13)}
+    assert three_bg.conditional_probabilities(1, 1) == {
+        2: Fraction(1, 13),
+        3: Fraction(4, 13),
+        6: Fraction(2, 13),
+        7: Fraction(6, 13),
+    }
 
 
 def test_conditional_probabilities14(three_bg):
-    assert three_bg.conditional_probabilities(2, 0) == {0: Fraction(1, 6),
-                                                        2: Fraction(1, 6),
-                                                        4: Fraction(1, 3),
-                                                        6: Fraction(1, 3)}
+    assert three_bg.conditional_probabilities(2, 0) == {
+        0: Fraction(1, 6),
+        2: Fraction(1, 6),
+        4: Fraction(1, 3),
+        6: Fraction(1, 3),
+    }
 
 
 def test_conditional_probabilities15(three_bg):
-    assert three_bg.conditional_probabilities(2, 1) == {1: Fraction(1, 7),
-                                                        3: Fraction(2, 7),
-                                                        5: Fraction(1, 7),
-                                                        7: Fraction(3, 7)}
+    assert three_bg.conditional_probabilities(2, 1) == {
+        1: Fraction(1, 7),
+        3: Fraction(2, 7),
+        5: Fraction(1, 7),
+        7: Fraction(3, 7),
+    }
 
 
 def test_dico_utilities1(bimat_bg):
@@ -307,81 +400,128 @@ def test_dico_utilities1(bimat_bg):
         2: [[-2, -5, -8, -1, -3, -7], [-2, -5, -1, -3, -8, -7]],
         3: [[-2, -4, -7, -1, -3, -6], [-2, -4, -1, -3, -7, -6]],
         4: [[-2, -4, -6, -1, -3, -5], [-2, -4, -1, -3, -6, -5]],
-        5: [[-3, -7, -1, -5, -10, -9], [-3, -7, -10, -1, -5, -9]]}
+        5: [[-3, -7, -1, -5, -10, -9], [-3, -7, -10, -1, -5, -9]],
+    }
 
 
 def test_dico_utilities2(sherif_bg1):
     assert sherif_bg1.dico_utilities() == {
         0: [[-1, -1, -2, 0], [-3, -2, -1, 0]],
-        1: [[0, -1, -2, 1], [0, -2, 2, -1]]}
+        1: [[0, -1, -2, 1], [0, -2, 2, -1]],
+    }
 
 
 def test_dico_utilities3(three_bg):
     assert three_bg.dico_utilities() == {
-        0: [[87, 56, 33, 21, 88, 77, 79, 69], [39, 52, 4, 92, 1, 78, 60, 69],
-            [2, 28, 92, 11, 16, 63, 21, 22]],
-        1: [[97, 12, 13, 92, 38, 2, 91, 62], [32, 40, 10, 57, 19, 18, 19, 15],
-            [35, 12, 0, 56, 93, 22, 52, 35]],
-        2: [[67, 0, 13, 87, 83, 6, 1, 80], [27, 63, 31, 22, 18, 8, 46, 81],
-            [88, 28, 35, 5, 52, 67, 21, 12]],
-        3: [[76, 13, 70, 36, 8, 39, 22, 42], [43, 82, 81, 37, 70, 58, 28, 91],
-            [13, 25, 6, 96, 31, 27, 5, 37]],
-        4: [[42, 62, 83, 91, 62, 11, 19, 0], [33, 88, 78, 14, 90, 27, 40, 86],
-            [29, 91, 63, 65, 78, 36, 3, 35]],
-        5: [[78, 51, 25, 64, 84, 53, 19, 30], [94, 8, 47, 52, 17, 89, 21, 54],
-            [39, 13, 7, 46, 4, 14, 46, 3]],
-        6: [[21, 33, 41, 4, 40, 5, 47, 13], [72, 6, 92, 29, 73, 54, 22, 30],
-            [23, 86, 14, 46, 99, 34, 62, 97]],
-        7: [[69, 11, 25, 65, 82, 52, 68, 56], [33, 12, 39, 98, 41, 63, 99, 10],
-            [18, 62, 99, 58, 62, 25, 55, 7]]}
+        0: [
+            [87, 56, 33, 21, 88, 77, 79, 69],
+            [39, 52, 4, 92, 1, 78, 60, 69],
+            [2, 28, 92, 11, 16, 63, 21, 22],
+        ],
+        1: [
+            [97, 12, 13, 92, 38, 2, 91, 62],
+            [32, 40, 10, 57, 19, 18, 19, 15],
+            [35, 12, 0, 56, 93, 22, 52, 35],
+        ],
+        2: [
+            [67, 0, 13, 87, 83, 6, 1, 80],
+            [27, 63, 31, 22, 18, 8, 46, 81],
+            [88, 28, 35, 5, 52, 67, 21, 12],
+        ],
+        3: [
+            [76, 13, 70, 36, 8, 39, 22, 42],
+            [43, 82, 81, 37, 70, 58, 28, 91],
+            [13, 25, 6, 96, 31, 27, 5, 37],
+        ],
+        4: [
+            [42, 62, 83, 91, 62, 11, 19, 0],
+            [33, 88, 78, 14, 90, 27, 40, 86],
+            [29, 91, 63, 65, 78, 36, 3, 35],
+        ],
+        5: [
+            [78, 51, 25, 64, 84, 53, 19, 30],
+            [94, 8, 47, 52, 17, 89, 21, 54],
+            [39, 13, 7, 46, 4, 14, 46, 3],
+        ],
+        6: [
+            [21, 33, 41, 4, 40, 5, 47, 13],
+            [72, 6, 92, 29, 73, 54, 22, 30],
+            [23, 86, 14, 46, 99, 34, 62, 97],
+        ],
+        7: [
+            [69, 11, 25, 65, 82, 52, 68, 56],
+            [33, 12, 39, 98, 41, 63, 99, 10],
+            [18, 62, 99, 58, 62, 25, 55, 7],
+        ],
+    }
 
 
 def test_expected_utilities1(bimat_bg):
     assert bimat_bg.expected_utilities(
-        {(0, 0): [1, 0, 0], (0, 1): [1, 0, 0], (1, 0): [1, 0], (1, 1): [1, 0],
-         (1, 2): [1, 0]}) == \
-           {(0, 0): Fraction(-11, 5),
-            (0, 1): Fraction(-12, 5),
-            (1, 0): Fraction(-7, 3),
-            (1, 1): Fraction(-2, 1),
-            (1, 2): Fraction(-5, 2)}
+        {
+            (0, 0): [1, 0, 0],
+            (0, 1): [1, 0, 0],
+            (1, 0): [1, 0],
+            (1, 1): [1, 0],
+            (1, 2): [1, 0],
+        }
+    ) == {
+        (0, 0): Fraction(-11, 5),
+        (0, 1): Fraction(-12, 5),
+        (1, 0): Fraction(-7, 3),
+        (1, 1): Fraction(-2, 1),
+        (1, 2): Fraction(-5, 2),
+    }
 
 
 def test_expected_utilities2(bimat_bg):
     assert bimat_bg.expected_utilities(
-        {(0, 0): [1, 0, 0], (0, 1): [1, 0, 0], (1, 0): [0, 1], (1, 1): [0, 1],
-         (1, 2): [0, 1]}) == \
-           {(0, 0): Fraction(-29, 5),
-            (0, 1): Fraction(-26, 5),
-            (1, 0): Fraction(-5, 1),
-            (1, 1): Fraction(-16, 3),
-            (1, 2): Fraction(-6, 1)}
+        {
+            (0, 0): [1, 0, 0],
+            (0, 1): [1, 0, 0],
+            (1, 0): [0, 1],
+            (1, 1): [0, 1],
+            (1, 2): [0, 1],
+        }
+    ) == {
+        (0, 0): Fraction(-29, 5),
+        (0, 1): Fraction(-26, 5),
+        (1, 0): Fraction(-5, 1),
+        (1, 1): Fraction(-16, 3),
+        (1, 2): Fraction(-6, 1),
+    }
 
 
 def test_expected_utilities3(sherif_bg1):
     assert sherif_bg1.expected_utilities(
-        {(0, 0): [1, 0], (1, 0): [1, 0], (1, 1): [0, 1]}) == {
-               (0, 0): Fraction(-1, 1), (1, 0): Fraction(-3, 1),
-               (1, 1): Fraction(-2, 1)}
+        {(0, 0): [1, 0], (1, 0): [1, 0], (1, 1): [0, 1]}
+    ) == {(0, 0): Fraction(-1, 1), (1, 0): Fraction(-3, 1), (1, 1): Fraction(-2, 1)}
 
 
 def test_expected_utilities4(sherif_bg1):
     assert sherif_bg1.expected_utilities(
-        {(0, 0): [0, 1], (1, 0): [0, 1], (1, 1): [1, 0]}) == {
-               (0, 0): Fraction(-4, 3), (1, 0): Fraction(0, 1),
-               (1, 1): Fraction(2, 1)}
+        {(0, 0): [0, 1], (1, 0): [0, 1], (1, 1): [1, 0]}
+    ) == {(0, 0): Fraction(-4, 3), (1, 0): Fraction(0, 1), (1, 1): Fraction(2, 1)}
 
 
 def test_expected_utilities5(three_bg):
     assert three_bg.expected_utilities(
-        {(0, 0): [1, 0], (0, 1): [1, 0], (1, 0): [1, 0], (1, 1): [1, 0],
-         (2, 0): [1, 0], (2, 1): [1, 0]}) == {(0, 0): Fraction(163, 2),
-                                              (0, 1): Fraction(58, 1),
-                                              (1, 0): Fraction(51, 1),
-                                              (1, 1): Fraction(541, 13),
-                                              (2, 0): Fraction(97, 3),
-                                              (2, 1): Fraction(22, 1)
-                                              }
+        {
+            (0, 0): [1, 0],
+            (0, 1): [1, 0],
+            (1, 0): [1, 0],
+            (1, 1): [1, 0],
+            (2, 0): [1, 0],
+            (2, 1): [1, 0],
+        }
+    ) == {
+        (0, 0): Fraction(163, 2),
+        (0, 1): Fraction(58, 1),
+        (1, 0): Fraction(51, 1),
+        (1, 1): Fraction(541, 13),
+        (2, 0): Fraction(97, 3),
+        (2, 1): Fraction(22, 1),
+    }
 
 
 """
@@ -400,101 +540,174 @@ convert_to_HGG()
 
 def test_is_equilibrium1(bimat_bg):
     assert bimat_bg.is_equilibrium(
-        {(0, 0): [1, 0, 0], (0, 1): [1, 0, 0], (1, 0): [1, 0], (1, 1): [1, 0],
-         (1, 2): [1, 0]}, 0.0001)
+        {
+            (0, 0): [1, 0, 0],
+            (0, 1): [1, 0, 0],
+            (1, 0): [1, 0],
+            (1, 1): [1, 0],
+            (1, 2): [1, 0],
+        },
+        0.0001,
+    )
 
 
 def test_is_equilibrium2(bimat_bg):
     assert not bimat_bg.is_equilibrium(
-        {(0, 0): [1, 0, 0], (0, 1): [1, 0, 0], (1, 0): [1, 0], (1, 1): [1, 0],
-         (1, 2): [0, 1]}, 0.0001)
+        {
+            (0, 0): [1, 0, 0],
+            (0, 1): [1, 0, 0],
+            (1, 0): [1, 0],
+            (1, 1): [1, 0],
+            (1, 2): [0, 1],
+        },
+        0.0001,
+    )
 
 
 def test_is_equilibrium3(bimat_bg):
     assert not bimat_bg.is_equilibrium(
-        {(0, 0): [0, 1, 0], (0, 1): [1, 0, 0], (1, 0): [1, 0], (1, 1): [1, 0],
-         (1, 2): [1, 0]}, 0.0001)
+        {
+            (0, 0): [0, 1, 0],
+            (0, 1): [1, 0, 0],
+            (1, 0): [1, 0],
+            (1, 1): [1, 0],
+            (1, 2): [1, 0],
+        },
+        0.0001,
+    )
 
 
 def test_is_equilibrium4(bimat_bg):
     assert not bimat_bg.is_equilibrium(
-        {(0, 0): [1, 0, 0], (0, 1): [1, 0, 0], (1, 0): [0, 1], (1, 1): [0, 1],
-         (1, 2): [0, 1]}, 0.0001)
+        {
+            (0, 0): [1, 0, 0],
+            (0, 1): [1, 0, 0],
+            (1, 0): [0, 1],
+            (1, 1): [0, 1],
+            (1, 2): [0, 1],
+        },
+        0.0001,
+    )
 
 
 def test_is_equilibrium5(sherif_bg1):
     assert sherif_bg1.is_equilibrium(
-        {(0, 0): [1, 0], (1, 0): [0, 1], (1, 1): [1, 0]}, 0.0001)
+        {(0, 0): [1, 0], (1, 0): [0, 1], (1, 1): [1, 0]}, 0.0001
+    )
 
 
 def test_is_equilibrium6(sherif_bg1):
     assert not sherif_bg1.is_equilibrium(
-        {(0, 0): [0, 1], (1, 0): [0, 1], (1, 1): [1, 0]}, 0.0001)
+        {(0, 0): [0, 1], (1, 0): [0, 1], (1, 1): [1, 0]}, 0.0001
+    )
 
 
 def test_is_equilibrium7(sherif_bg2):
     assert sherif_bg2.is_equilibrium(
-        {(0, 0): [Fraction(1, 2), Fraction(1, 2)], (1, 0): [0, 1],
-         (1, 1): [1, 0]}, 0.0001)
+        {(0, 0): [Fraction(1, 2), Fraction(1, 2)], (1, 0): [0, 1], (1, 1): [1, 0]},
+        0.0001,
+    )
 
 
 def test_is_equilibrium8(sherif_bg2):
     assert sherif_bg2.is_equilibrium(
-        {(0, 0): [Fraction(1, 3), Fraction(2, 3)], (1, 0): [0, 1],
-         (1, 1): [1, 0]}, 0.0001)
+        {(0, 0): [Fraction(1, 3), Fraction(2, 3)], (1, 0): [0, 1], (1, 1): [1, 0]},
+        0.0001,
+    )
 
 
 def test_is_equilibrium9(sherif_bg2):
     assert sherif_bg2.is_equilibrium(
-        {(0, 0): [0, 1], (1, 0): [0, 1], (1, 1): [1, 0]}, 0.0001)
+        {(0, 0): [0, 1], (1, 0): [0, 1], (1, 1): [1, 0]}, 0.0001
+    )
 
 
 def test_is_equilibrium10(sherif_bg3):
     assert sherif_bg3.is_equilibrium(
-        {(0, 0): [0, 1], (1, 0): [0, 1], (1, 1): [1, 0]}, 0.0001)
+        {(0, 0): [0, 1], (1, 0): [0, 1], (1, 1): [1, 0]}, 0.0001
+    )
 
 
 def test_is_equilibrium11(sherif_bg3):
     assert not sherif_bg3.is_equilibrium(
-        {(0, 0): [1, 0], (1, 0): [0, 1], (1, 1): [1, 0]}, 0.0001)
+        {(0, 0): [1, 0], (1, 0): [0, 1], (1, 1): [1, 0]}, 0.0001
+    )
 
 
 def test_read_GameFile1():
     read_bg = BG.read_GameFile("filestest/internet.bg")
     assert read_bg.players_actions == [[0, 1], [0, 1]]
     assert read_bg.theta == [[0, 1], [0, 1]]
-    assert read_bg.p == [Fraction(4, 10), Fraction(1, 10), Fraction(1, 10),
-                         Fraction(4, 10)]
-    assert read_bg.utilities == [[[3, 0, 0, 2], [3, 0, 0, 2]],
-                                 [[1, 0, 0, 2], [3, 0, 0, 2]],
-                                 [[3, 0, 0, 2], [1, 0, 0, 2]],
-                                 [[1, 0, 0, 2], [1, 0, 0, 2]]]
+    assert read_bg.p == [
+        Fraction(4, 10),
+        Fraction(1, 10),
+        Fraction(1, 10),
+        Fraction(4, 10),
+    ]
+    assert read_bg.utilities == [
+        [[3, 0, 0, 2], [3, 0, 0, 2]],
+        [[1, 0, 0, 2], [3, 0, 0, 2]],
+        [[3, 0, 0, 2], [1, 0, 0, 2]],
+        [[1, 0, 0, 2], [1, 0, 0, 2]],
+    ]
 
 
 def test_read_GameFile2():
     read_bg = BG.read_GameFile("filestest/test.bg")
     assert read_bg.players_actions == [[0, 1], [0, 1], [0, 1]]
     assert read_bg.theta == [[0, 1], [0, 1], [0, 1]]
-    assert read_bg.p == [Fraction(1, 15), Fraction(2, 15), Fraction(1, 30),
-                         Fraction(1, 6), Fraction(1, 15), Fraction(1, 5),
-                         Fraction(1, 10), Fraction(7, 30)]
+    assert read_bg.p == [
+        Fraction(1, 15),
+        Fraction(2, 15),
+        Fraction(1, 30),
+        Fraction(1, 6),
+        Fraction(1, 15),
+        Fraction(1, 5),
+        Fraction(1, 10),
+        Fraction(7, 30),
+    ]
     assert read_bg.utilities == [
-        [[-3, -10, -1, 4, -7, -9, -5, 5], [-3, -10, -1, 4, -7, -9, -5, 5],
-         [-3, -5, -10, 8, -7, -9, -1, 5]],
-        [[-2, -9, -1, 5, -6, -8, -4, 5], [-2, -9, -1, 5, -6, -8, -4, 5],
-         [-2, -4, -9, 2, -6, -8, -1, 5]],
-        [[-2, -8, -1, 8, -5, -7, -4, 4], [-2, -8, -1, 8, -5, -7, -4, 5],
-         [-2, -3, -8, 5, -5, -7, -1, 4]],
-        [[-2, -7, -1, 7, -4, -6, -4, 1], [-2, -7, -1, 8, -4, -6, -4, 2],
-         [-2, -3, -7, 5, -4, -6, -1, 5]],
-        [[-3, -10, -1, 4, -7, -9, -5, 5], [-3, -10, -1, 4, -7, -9, -5, 5],
-         [-3, -5, -10, 8, -7, -9, -1, 5]],
-        [[-2, -9, -1, 5, -6, -8, -4, 5], [-2, -9, -1, 5, -6, -8, -4, 5],
-         [-2, -4, -9, 2, -6, -8, -1, 5]],
-        [[-2, -8, -1, 8, -5, -7, -4, 4], [-2, -8, -1, 8, -5, -7, -4, 5],
-         [-2, -3, -8, 5, -5, -7, -1, 4]],
-        [[-2, -7, -1, 7, -4, -6, -4, 1], [-2, -7, -1, 8, -4, -6, -4, 2],
-         [-2, -3, -7, 5, -4, -6, -1, 5]]]
+        [
+            [-3, -10, -1, 4, -7, -9, -5, 5],
+            [-3, -10, -1, 4, -7, -9, -5, 5],
+            [-3, -5, -10, 8, -7, -9, -1, 5],
+        ],
+        [
+            [-2, -9, -1, 5, -6, -8, -4, 5],
+            [-2, -9, -1, 5, -6, -8, -4, 5],
+            [-2, -4, -9, 2, -6, -8, -1, 5],
+        ],
+        [
+            [-2, -8, -1, 8, -5, -7, -4, 4],
+            [-2, -8, -1, 8, -5, -7, -4, 5],
+            [-2, -3, -8, 5, -5, -7, -1, 4],
+        ],
+        [
+            [-2, -7, -1, 7, -4, -6, -4, 1],
+            [-2, -7, -1, 8, -4, -6, -4, 2],
+            [-2, -3, -7, 5, -4, -6, -1, 5],
+        ],
+        [
+            [-3, -10, -1, 4, -7, -9, -5, 5],
+            [-3, -10, -1, 4, -7, -9, -5, 5],
+            [-3, -5, -10, 8, -7, -9, -1, 5],
+        ],
+        [
+            [-2, -9, -1, 5, -6, -8, -4, 5],
+            [-2, -9, -1, 5, -6, -8, -4, 5],
+            [-2, -4, -9, 2, -6, -8, -1, 5],
+        ],
+        [
+            [-2, -8, -1, 8, -5, -7, -4, 4],
+            [-2, -8, -1, 8, -5, -7, -4, 5],
+            [-2, -3, -8, 5, -5, -7, -1, 4],
+        ],
+        [
+            [-2, -7, -1, 7, -4, -6, -4, 1],
+            [-2, -7, -1, 8, -4, -6, -4, 2],
+            [-2, -3, -7, 5, -4, -6, -1, 5],
+        ],
+    ]
 
 
 def test_write_GameFile1(bimat_bg):
diff --git a/test/test_hypergraphicalgame.py b/test/test_hypergraphicalgame.py
index a017b04..cadce72 100644
--- a/test/test_hypergraphicalgame.py
+++ b/test/test_hypergraphicalgame.py
@@ -14,9 +14,14 @@ Separate  assert in multiple fucntion
 def first_hgg():
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
     utilities = [
-        [[-3, -7, -7, -10, -1, -5, -5, -9], [-3, -7, -1, -5, -7, -10, -5, -9],
-         [-3, -1, -7, -5, -7, -5, -10, -9]],
-        [[-1, -5, 0, -3], [-1, 0, -5, -3]], [[-1, -5, 0, -3], [-1, 0, -5, -3]]]
+        [
+            [-3, -7, -7, -10, -1, -5, -5, -9],
+            [-3, -7, -1, -5, -7, -10, -5, -9],
+            [-3, -1, -7, -5, -7, -5, -10, -9],
+        ],
+        [[-1, -5, 0, -3], [-1, 0, -5, -3]],
+        [[-1, -5, 0, -3], [-1, 0, -5, -3]],
+    ]
     hypergraph = [[0, 1, 2], [1, 3], [2, 3]]
 
     return HGG(players_actions, utilities, hypergraph)
@@ -25,10 +30,14 @@ def first_hgg():
 @pytest.fixture
 def second_hgg():
     utilities = [
-        [[-3, -1, -3, -2, -2, -3, -2, -1], [-1, -3, -5, -1, -1, -6, -3, -4],
-         [-2, -3, -6, -4, -3, -1, -3, -4]],
+        [
+            [-3, -1, -3, -2, -2, -3, -2, -1],
+            [-1, -3, -5, -1, -1, -6, -3, -4],
+            [-2, -3, -6, -4, -3, -1, -3, -4],
+        ],
         [[-1, -3, -2, -2], [-1, -2, -2, -1]],
-        [[-3, -1, -4, -5], [-1, -3, -1, -5]]]
+        [[-3, -1, -4, -5], [-1, -3, -1, -5]],
+    ]
     # Error up level impossible, 2->3, [[0,1],[0,1],[0,1],[0,1]]
     hypergraph = [[0, 1, 2], [1, 3], [2, 3]]
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
@@ -38,10 +47,17 @@ def second_hgg():
 @pytest.fixture
 def third_hgg():
     utilities = [
-        [[74, 6, 9, 60, 77, 30, 47, 0], [51, 97, 98, 83, 90, 1, 2, 47],
-         [18, 16, 29, 86, 100, 96, 93, 64]],
-        [[84, 48, 27, 5, 100, 62, 16, 62], [10, 88, 72, 47, 13, 24, 42, 72],
-         [1, 36, 68, 0, 53, 5, 61, 97]]]
+        [
+            [74, 6, 9, 60, 77, 30, 47, 0],
+            [51, 97, 98, 83, 90, 1, 2, 47],
+            [18, 16, 29, 86, 100, 96, 93, 64],
+        ],
+        [
+            [84, 48, 27, 5, 100, 62, 16, 62],
+            [10, 88, 72, 47, 13, 24, 42, 72],
+            [1, 36, 68, 0, 53, 5, 61, 97],
+        ],
+    ]
     hypergraph = [[0, 1, 3], [0, 2, 3]]
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
     return HGG(players_actions, utilities, hypergraph)
@@ -51,41 +67,311 @@ def third_hgg():
 def degen_hgg():
     players_actions = [[0, 1, 2], [0, 1, 2], [0, 1, 2], [0, 1, 2]]
     hypergraph = [[1, 2, 3], [0, 1, 3], [0, 1, 2]]
-    utilities = [[[-6, -3, -3, -1, -4, -10, -7, -5, -5, -10, -2, -1, -1, -3,
-                   -7, -6, -1, -2, -6, -3, -3, -4, -8, -3, -7, -8, -8],
-                  [-9, -1, -8, -2, -7, -6, -7, -6, -9, -2, -4, -2, -5, -2, -3,
-                   -7, -3, -7, -7, -5, -3, -5, -10, -5, -8, -9, -9],
-                  [-3, -1, -2, -4, -1, -4, -8, -7, -3, -6, -9, -1, -1, -3, -7,
-                   -3, -7, -2, -1, -4, -10, -4, -9, -4, -3, -6, -3]],
-                 [[-7, -3, -5, -9, -9, -5, -6, -5, -2, -8, -7, -10, -2, -10,
-                   -6, -10, -5, -8, -6, -1, -7, -6, -3, -5, -3, -6, -6],
-                  [-3, -6, -3, -2, -9, -3, -1, -3, -6, -10, -5, -4, -9, -2,
-                   -10, -7, -10, -10, -6, -8, -6, -4, -4, -1, -3, -5, -8],
-                  [-9, -9, -5, -9, -6, -3, -6, -2, -7, -2, -5, -10, -3, -5, -3,
-                   -4, -9, -8, -3, -1, -6, -2, -2, -7, -10, -10, -3]],
-                 [[-1, -8, -5, -4, -2, -5, -1, -10, -5, -2, -1, -3, -7, -3, -5,
-                   -1, -7, -9, -9, -4, -5, -5, -10, -3, -6, -2, -6],
-                  [-5, -7, -1, -9, -3, -7, -6, -10, -8, -9, -4, -1, -8, -5, -1,
-                   -10, -6, -4, -4, -7, -6, -10, -5, -8, -7, -3, -2],
-                  [-6, -8, -6, -3, -1, -6, -7, -2, -9, -7, -9, -10, -4, -3, -6,
-                   -5, -5, -10, -4, -4, -5, -4, -10, -3, -4, -5, -3]]]
+    utilities = [
+        [
+            [
+                -6,
+                -3,
+                -3,
+                -1,
+                -4,
+                -10,
+                -7,
+                -5,
+                -5,
+                -10,
+                -2,
+                -1,
+                -1,
+                -3,
+                -7,
+                -6,
+                -1,
+                -2,
+                -6,
+                -3,
+                -3,
+                -4,
+                -8,
+                -3,
+                -7,
+                -8,
+                -8,
+            ],
+            [
+                -9,
+                -1,
+                -8,
+                -2,
+                -7,
+                -6,
+                -7,
+                -6,
+                -9,
+                -2,
+                -4,
+                -2,
+                -5,
+                -2,
+                -3,
+                -7,
+                -3,
+                -7,
+                -7,
+                -5,
+                -3,
+                -5,
+                -10,
+                -5,
+                -8,
+                -9,
+                -9,
+            ],
+            [
+                -3,
+                -1,
+                -2,
+                -4,
+                -1,
+                -4,
+                -8,
+                -7,
+                -3,
+                -6,
+                -9,
+                -1,
+                -1,
+                -3,
+                -7,
+                -3,
+                -7,
+                -2,
+                -1,
+                -4,
+                -10,
+                -4,
+                -9,
+                -4,
+                -3,
+                -6,
+                -3,
+            ],
+        ],
+        [
+            [
+                -7,
+                -3,
+                -5,
+                -9,
+                -9,
+                -5,
+                -6,
+                -5,
+                -2,
+                -8,
+                -7,
+                -10,
+                -2,
+                -10,
+                -6,
+                -10,
+                -5,
+                -8,
+                -6,
+                -1,
+                -7,
+                -6,
+                -3,
+                -5,
+                -3,
+                -6,
+                -6,
+            ],
+            [
+                -3,
+                -6,
+                -3,
+                -2,
+                -9,
+                -3,
+                -1,
+                -3,
+                -6,
+                -10,
+                -5,
+                -4,
+                -9,
+                -2,
+                -10,
+                -7,
+                -10,
+                -10,
+                -6,
+                -8,
+                -6,
+                -4,
+                -4,
+                -1,
+                -3,
+                -5,
+                -8,
+            ],
+            [
+                -9,
+                -9,
+                -5,
+                -9,
+                -6,
+                -3,
+                -6,
+                -2,
+                -7,
+                -2,
+                -5,
+                -10,
+                -3,
+                -5,
+                -3,
+                -4,
+                -9,
+                -8,
+                -3,
+                -1,
+                -6,
+                -2,
+                -2,
+                -7,
+                -10,
+                -10,
+                -3,
+            ],
+        ],
+        [
+            [
+                -1,
+                -8,
+                -5,
+                -4,
+                -2,
+                -5,
+                -1,
+                -10,
+                -5,
+                -2,
+                -1,
+                -3,
+                -7,
+                -3,
+                -5,
+                -1,
+                -7,
+                -9,
+                -9,
+                -4,
+                -5,
+                -5,
+                -10,
+                -3,
+                -6,
+                -2,
+                -6,
+            ],
+            [
+                -5,
+                -7,
+                -1,
+                -9,
+                -3,
+                -7,
+                -6,
+                -10,
+                -8,
+                -9,
+                -4,
+                -1,
+                -8,
+                -5,
+                -1,
+                -10,
+                -6,
+                -4,
+                -4,
+                -7,
+                -6,
+                -10,
+                -5,
+                -8,
+                -7,
+                -3,
+                -2,
+            ],
+            [
+                -6,
+                -8,
+                -6,
+                -3,
+                -1,
+                -6,
+                -7,
+                -2,
+                -9,
+                -7,
+                -9,
+                -10,
+                -4,
+                -3,
+                -6,
+                -5,
+                -5,
+                -10,
+                -4,
+                -4,
+                -5,
+                -4,
+                -10,
+                -3,
+                -4,
+                -5,
+                -3,
+            ],
+        ],
+    ]
     return HGG(players_actions, utilities, hypergraph)
 
 
 @pytest.fixture
 def first_hgg_fraction():
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
-    utilities = [[[Fraction(-3, 2), Fraction(-7, 2), Fraction(-7, 2),
-                   Fraction(-10, 2), Fraction(-1, 2), Fraction(-5, 2),
-                   Fraction(-5, 2), Fraction(-9, 2)],
-                  [Fraction(-3, 4), Fraction(-7, 4), Fraction(-1, 4),
-                   Fraction(-5, 4), Fraction(-7, 4), Fraction(-10, 4),
-                   Fraction(-5, 4), Fraction(-9, 4)],
-                  [-3, -1, -7, -5, -7, -5, -10, -9]],
-                 [[Fraction(-1, 4), Fraction(-5, 4), 0, Fraction(-3, 4)],
-                  [Fraction(-1, 3), 0, Fraction(-5, 3), Fraction(-3, 3)]],
-                 [[-1, -5, 0, -3],
-                  [Fraction(-1, 3), 0, Fraction(-5, 3), Fraction(-3, 3)]]]
+    utilities = [
+        [
+            [
+                Fraction(-3, 2),
+                Fraction(-7, 2),
+                Fraction(-7, 2),
+                Fraction(-10, 2),
+                Fraction(-1, 2),
+                Fraction(-5, 2),
+                Fraction(-5, 2),
+                Fraction(-9, 2),
+            ],
+            [
+                Fraction(-3, 4),
+                Fraction(-7, 4),
+                Fraction(-1, 4),
+                Fraction(-5, 4),
+                Fraction(-7, 4),
+                Fraction(-10, 4),
+                Fraction(-5, 4),
+                Fraction(-9, 4),
+            ],
+            [-3, -1, -7, -5, -7, -5, -10, -9],
+        ],
+        [
+            [Fraction(-1, 4), Fraction(-5, 4), 0, Fraction(-3, 4)],
+            [Fraction(-1, 3), 0, Fraction(-5, 3), Fraction(-3, 3)],
+        ],
+        [[-1, -5, 0, -3], [Fraction(-1, 3), 0, Fraction(-5, 3), Fraction(-3, 3)]],
+    ]
     hypergraph = [[0, 1, 2], [1, 3], [2, 3]]
 
     return HGG(players_actions, utilities, hypergraph)
@@ -93,43 +379,88 @@ def first_hgg_fraction():
 
 # joint_actions
 
+
 def test_joint_actions1(first_hgg):
-    assert (first_hgg.local_normalformgames[0].joint_actions == np.mat(
-        [[0., 0., 0.], [0., 0., 1.], [0., 1., 0.], [0., 1., 1.], [1., 0., 0.],
-         [1., 0., 1.], [1., 1., 0.], [1., 1., 1.]])).all()
+    assert (
+        first_hgg.local_normalformgames[0].joint_actions
+        == np.mat(
+            [
+                [0.0, 0.0, 0.0],
+                [0.0, 0.0, 1.0],
+                [0.0, 1.0, 0.0],
+                [0.0, 1.0, 1.0],
+                [1.0, 0.0, 0.0],
+                [1.0, 0.0, 1.0],
+                [1.0, 1.0, 0.0],
+                [1.0, 1.0, 1.0],
+            ]
+        )
+    ).all()
 
 
 def test_joint_actions2(first_hgg):
-    assert (first_hgg.local_normalformgames[1].joint_actions == np.mat(
-        [[0., 0.], [0., 1.], [1., 0.], [1., 1.]])).all()
+    assert (
+        first_hgg.local_normalformgames[1].joint_actions
+        == np.mat([[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]])
+    ).all()
 
 
 def test_joint_actions3(first_hgg):
-    assert (first_hgg.local_normalformgames[2].joint_actions == np.mat(
-        [[0., 0.], [0., 1.], [1., 0.], [1., 1.]])).all()
+    assert (
+        first_hgg.local_normalformgames[2].joint_actions
+        == np.mat([[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]])
+    ).all()
 
 
 def test_joint_actions4(degen_hgg):
-    assert (degen_hgg.local_normalformgames[0].joint_actions == np.mat(
-        [[0., 0., 0.], [0., 0., 1.], [0., 0., 2.], [0., 1., 0.], [0., 1., 1.],
-         [0., 1., 2.],
-         [0., 2., 0.], [0., 2., 1.], [0., 2., 2.], [1., 0., 0.], [1., 0., 1.],
-         [1., 0., 2.],
-         [1., 1., 0.], [1., 1., 1.], [1., 1., 2.], [1., 2., 0.], [1., 2., 1.],
-         [1., 2., 2.],
-         [2., 0., 0.], [2., 0., 1.], [2., 0., 2.], [2., 1., 0.], [2., 1., 1.],
-         [2., 1., 2.],
-         [2., 2., 0.], [2., 2., 1.], [2., 2., 2.]])).all()
+    assert (
+        degen_hgg.local_normalformgames[0].joint_actions
+        == np.mat(
+            [
+                [0.0, 0.0, 0.0],
+                [0.0, 0.0, 1.0],
+                [0.0, 0.0, 2.0],
+                [0.0, 1.0, 0.0],
+                [0.0, 1.0, 1.0],
+                [0.0, 1.0, 2.0],
+                [0.0, 2.0, 0.0],
+                [0.0, 2.0, 1.0],
+                [0.0, 2.0, 2.0],
+                [1.0, 0.0, 0.0],
+                [1.0, 0.0, 1.0],
+                [1.0, 0.0, 2.0],
+                [1.0, 1.0, 0.0],
+                [1.0, 1.0, 1.0],
+                [1.0, 1.0, 2.0],
+                [1.0, 2.0, 0.0],
+                [1.0, 2.0, 1.0],
+                [1.0, 2.0, 2.0],
+                [2.0, 0.0, 0.0],
+                [2.0, 0.0, 1.0],
+                [2.0, 0.0, 2.0],
+                [2.0, 1.0, 0.0],
+                [2.0, 1.0, 1.0],
+                [2.0, 1.0, 2.0],
+                [2.0, 2.0, 0.0],
+                [2.0, 2.0, 1.0],
+                [2.0, 2.0, 2.0],
+            ]
+        )
+    ).all()
 
 
 def test_joint_actions5(degen_hgg):
-    assert (degen_hgg.local_normalformgames[0].joint_actions ==
-            degen_hgg.local_normalformgames[1].joint_actions).all()
+    assert (
+        degen_hgg.local_normalformgames[0].joint_actions
+        == degen_hgg.local_normalformgames[1].joint_actions
+    ).all()
 
 
 def test_joint_actions6(degen_hgg):
-    assert (degen_hgg.local_normalformgames[0].joint_actions ==
-            degen_hgg.local_normalformgames[2].joint_actions).all()
+    assert (
+        degen_hgg.local_normalformgames[0].joint_actions
+        == degen_hgg.local_normalformgames[2].joint_actions
+    ).all()
 
 
 # Add test on creation of local games?
@@ -139,8 +470,10 @@ def test_joint_actions6(degen_hgg):
 # from method, useless?, confusing and redondant
 def test_utilities1(first_hgg):
     assert first_hgg.local_normalformgames[0].utilities == [
-        [-3, -7, -7, -10, -1, -5, -5, -9], [-3, -7, -1, -5, -7, -10, -5, -9],
-        [-3, -1, -7, -5, -7, -5, -10, -9]]
+        [-3, -7, -7, -10, -1, -5, -5, -9],
+        [-3, -7, -1, -5, -7, -10, -5, -9],
+        [-3, -1, -7, -5, -7, -5, -10, -9],
+    ]
     # assert first_hgg.local_normalformgames[0].utilities.all() ==
     # np.array([[-3, -7, -7, -10, -1, -5, -5, -9],
     # [-3, -7, -1, -5, -7, -10, -5, -9],
@@ -148,181 +481,446 @@ def test_utilities1(first_hgg):
 
 
 def test_utilities2(first_hgg):
-    assert first_hgg.local_normalformgames[1].utilities == [[-1, -5, 0, -3],
-                                                            [-1, 0, -5, -3]]
+    assert first_hgg.local_normalformgames[1].utilities == [
+        [-1, -5, 0, -3],
+        [-1, 0, -5, -3],
+    ]
 
 
 def test_utilities3(first_hgg):
-    assert first_hgg.local_normalformgames[2].utilities == [[-1, -5, 0, -3],
-                                                            [-1, 0, -5, -3]]
+    assert first_hgg.local_normalformgames[2].utilities == [
+        [-1, -5, 0, -3],
+        [-1, 0, -5, -3],
+    ]
 
 
 def test_utilities4(degen_hgg):
-    assert degen_hgg.local_normalformgames[0].utilities == \
-           [[-6, -3, -3, -1, -4, -10, -7, -5, -5, -10, -2, -1, -1, -3, -7, -6,
-             -1, -2, -6, -3, -3, -4, -8, -3, -7, -8, -8],
-            [-9, -1, -8, -2, -7, -6, -7, -6, -9, -2, -4, -2, -5, -2, -3, -7,
-             -3, -7, -7, -5, -3, -5, -10, -5, -8, -9, -9],
-            [-3, -1, -2, -4, -1, -4, -8, -7, -3, -6, -9, -1, -1, -3, -7, -3,
-             -7, -2, -1, -4, -10, -4, -9, -4, -3, -6, -3]]
+    assert degen_hgg.local_normalformgames[0].utilities == [
+        [
+            -6,
+            -3,
+            -3,
+            -1,
+            -4,
+            -10,
+            -7,
+            -5,
+            -5,
+            -10,
+            -2,
+            -1,
+            -1,
+            -3,
+            -7,
+            -6,
+            -1,
+            -2,
+            -6,
+            -3,
+            -3,
+            -4,
+            -8,
+            -3,
+            -7,
+            -8,
+            -8,
+        ],
+        [
+            -9,
+            -1,
+            -8,
+            -2,
+            -7,
+            -6,
+            -7,
+            -6,
+            -9,
+            -2,
+            -4,
+            -2,
+            -5,
+            -2,
+            -3,
+            -7,
+            -3,
+            -7,
+            -7,
+            -5,
+            -3,
+            -5,
+            -10,
+            -5,
+            -8,
+            -9,
+            -9,
+        ],
+        [
+            -3,
+            -1,
+            -2,
+            -4,
+            -1,
+            -4,
+            -8,
+            -7,
+            -3,
+            -6,
+            -9,
+            -1,
+            -1,
+            -3,
+            -7,
+            -3,
+            -7,
+            -2,
+            -1,
+            -4,
+            -10,
+            -4,
+            -9,
+            -4,
+            -3,
+            -6,
+            -3,
+        ],
+    ]
 
 
 def test_utilities5(degen_hgg):
-    assert degen_hgg.local_normalformgames[1].utilities == \
-           [[-7, -3, -5, -9, -9, -5, -6, -5, -2, -8, -7, -10, -2, -10, -6, -10,
-             -5, -8, -6, -1, -7, -6, -3, -5, -3, -6, -6],
-            [-3, -6, -3, -2, -9, -3, -1, -3, -6, -10, -5, -4, -9, -2, -10, -7,
-             -10, -10, -6, -8, -6, -4, -4, -1, -3, -5, -8],
-            [-9, -9, -5, -9, -6, -3, -6, -2, -7, -2, -5, -10, -3, -5, -3, -4,
-             -9, -8, -3, -1, -6, -2, -2, -7, -10, -10, -3]]
+    assert degen_hgg.local_normalformgames[1].utilities == [
+        [
+            -7,
+            -3,
+            -5,
+            -9,
+            -9,
+            -5,
+            -6,
+            -5,
+            -2,
+            -8,
+            -7,
+            -10,
+            -2,
+            -10,
+            -6,
+            -10,
+            -5,
+            -8,
+            -6,
+            -1,
+            -7,
+            -6,
+            -3,
+            -5,
+            -3,
+            -6,
+            -6,
+        ],
+        [
+            -3,
+            -6,
+            -3,
+            -2,
+            -9,
+            -3,
+            -1,
+            -3,
+            -6,
+            -10,
+            -5,
+            -4,
+            -9,
+            -2,
+            -10,
+            -7,
+            -10,
+            -10,
+            -6,
+            -8,
+            -6,
+            -4,
+            -4,
+            -1,
+            -3,
+            -5,
+            -8,
+        ],
+        [
+            -9,
+            -9,
+            -5,
+            -9,
+            -6,
+            -3,
+            -6,
+            -2,
+            -7,
+            -2,
+            -5,
+            -10,
+            -3,
+            -5,
+            -3,
+            -4,
+            -9,
+            -8,
+            -3,
+            -1,
+            -6,
+            -2,
+            -2,
+            -7,
+            -10,
+            -10,
+            -3,
+        ],
+    ]
 
 
 def test_utilities6(degen_hgg):
-    assert degen_hgg.local_normalformgames[2].utilities == \
-           [[-1, -8, -5, -4, -2, -5, -1, -10, -5, -2, -1, -3, -7, -3, -5, -1,
-             -7, -9, -9, -4, -5, -5, -10, -3, -6, -2, -6],
-            [-5, -7, -1, -9, -3, -7, -6, -10, -8, -9, -4, -1, -8, -5, -1, -10,
-             -6, -4, -4, -7, -6, -10, -5, -8, -7, -3, -2],
-            [-6, -8, -6, -3, -1, -6, -7, -2, -9, -7, -9, -10, -4, -3, -6, -5,
-             -5, -10, -4, -4, -5, -4, -10, -3, -4, -5, -3]]
+    assert degen_hgg.local_normalformgames[2].utilities == [
+        [
+            -1,
+            -8,
+            -5,
+            -4,
+            -2,
+            -5,
+            -1,
+            -10,
+            -5,
+            -2,
+            -1,
+            -3,
+            -7,
+            -3,
+            -5,
+            -1,
+            -7,
+            -9,
+            -9,
+            -4,
+            -5,
+            -5,
+            -10,
+            -3,
+            -6,
+            -2,
+            -6,
+        ],
+        [
+            -5,
+            -7,
+            -1,
+            -9,
+            -3,
+            -7,
+            -6,
+            -10,
+            -8,
+            -9,
+            -4,
+            -1,
+            -8,
+            -5,
+            -1,
+            -10,
+            -6,
+            -4,
+            -4,
+            -7,
+            -6,
+            -10,
+            -5,
+            -8,
+            -7,
+            -3,
+            -2,
+        ],
+        [
+            -6,
+            -8,
+            -6,
+            -3,
+            -1,
+            -6,
+            -7,
+            -2,
+            -9,
+            -7,
+            -9,
+            -10,
+            -4,
+            -3,
+            -6,
+            -5,
+            -5,
+            -10,
+            -4,
+            -4,
+            -5,
+            -4,
+            -10,
+            -3,
+            -4,
+            -5,
+            -3,
+        ],
+    ]
 
 
 # joint_action_except_i
 # no degen hgg
 
+
 def test_joint_action_except_i1(first_hgg):
-    assert (first_hgg.joint_action_except_i(0)[0] == np.mat(
-        [[0., 0.], [0., 1.], [1., 0.], [1., 1.]])).all()
+    assert (
+        first_hgg.joint_action_except_i(0)[0]
+        == np.mat([[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]])
+    ).all()
 
 
 def test_joint_action_except_i2(first_hgg):
-    assert (first_hgg.joint_action_except_i(1)[0] == np.mat(
-        [[0., 0.], [0., 1.], [1., 0.], [1., 1.]])).all()
+    assert (
+        first_hgg.joint_action_except_i(1)[0]
+        == np.mat([[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]])
+    ).all()
 
 
 def test_joint_action_except_i3(first_hgg):
-    assert (first_hgg.joint_action_except_i(2)[0] == np.mat(
-        [[0., 0.], [0., 1.], [1., 0.], [1., 1.]])).all()
+    assert (
+        first_hgg.joint_action_except_i(2)[0]
+        == np.mat([[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]])
+    ).all()
 
 
 def test_joint_action_except_i4(first_hgg):
-    assert (first_hgg.joint_action_except_i(0)[1] == [])
+    assert first_hgg.joint_action_except_i(0)[1] == []
 
 
 def test_joint_action_except_i5(first_hgg):
-    assert (first_hgg.joint_action_except_i(0)[2] == [])
+    assert first_hgg.joint_action_except_i(0)[2] == []
 
 
 def test_joint_action_except_i6(first_hgg):
-    assert (first_hgg.joint_action_except_i(1)[1] == np.mat(
-        [[0.], [1.]])).all()
+    assert (first_hgg.joint_action_except_i(1)[1] == np.mat([[0.0], [1.0]])).all()
 
 
 def test_joint_action_except_i7(first_hgg):
-    assert (first_hgg.joint_action_except_i(1)[2] == [])
+    assert first_hgg.joint_action_except_i(1)[2] == []
 
 
 def test_joint_action_except_i8(first_hgg):
-    assert (first_hgg.joint_action_except_i(2)[1] == [])
+    assert first_hgg.joint_action_except_i(2)[1] == []
 
 
 def test_joint_action_except_i9(first_hgg):
-    assert (first_hgg.joint_action_except_i(1)[2] == np.mat(
-        [[0.], [1.]])).all()
+    assert (first_hgg.joint_action_except_i(1)[2] == np.mat([[0.0], [1.0]])).all()
 
 
 def test_joint_action_except_i10(first_hgg):
-    assert (first_hgg.joint_action_except_i(3)[0] == [])
+    assert first_hgg.joint_action_except_i(3)[0] == []
 
 
 def test_joint_action_except_i11(first_hgg):
-    assert (first_hgg.joint_action_except_i(3)[1] == np.mat(
-        [[0.], [1.]])).all()
+    assert (first_hgg.joint_action_except_i(3)[1] == np.mat([[0.0], [1.0]])).all()
 
 
 def test_joint_action_except_i12(first_hgg):
-    assert (first_hgg.joint_action_except_i(3)[2] == np.mat(
-        [[0.], [1.]])).all()
+    assert (first_hgg.joint_action_except_i(3)[2] == np.mat([[0.0], [1.0]])).all()
 
 
 # expected_utilities
 # no degen hff
 
+
 def test_expected_utilities1(first_hgg):
-    assert (first_hgg.expected_utilities(
-        {0: [1, 0], 1: [1, 0], 2: [1, 0], 3: [1, 0]}) == np.mat(
-        [-3., -4., -4., -2.])).all()
+    assert (
+        first_hgg.expected_utilities({0: [1, 0], 1: [1, 0], 2: [1, 0], 3: [1, 0]})
+        == np.mat([-3.0, -4.0, -4.0, -2.0])
+    ).all()
 
 
 def test_expected_utilities2(first_hgg):
-    assert (first_hgg.expected_utilities(
-        {0: [0, 1], 1: [0, 1], 2: [0, 1], 3: [0, 1]}) == np.mat(
-        [-9., -12., -12., -6.])).all()
+    assert (
+        first_hgg.expected_utilities({0: [0, 1], 1: [0, 1], 2: [0, 1], 3: [0, 1]})
+        == np.mat([-9.0, -12.0, -12.0, -6.0])
+    ).all()
 
 
 def test_expected_utilities3(first_hgg):
-    assert (first_hgg.expected_utilities(
-        {0: [1, 0], 1: [1, 0], 2: [0, 1], 3: [0, 1]}) == np.mat(
-        [-7., -12., -4., -3.])).all()
+    assert (
+        first_hgg.expected_utilities({0: [1, 0], 1: [1, 0], 2: [0, 1], 3: [0, 1]})
+        == np.mat([-7.0, -12.0, -4.0, -3.0])
+    ).all()
 
 
 def test_expected_utilities4(first_hgg):
-    assert (first_hgg.expected_utilities(
-        {0: [1 / 2, 1 / 2], 1: [1 / 2, 1 / 2], 2: [1 / 2, 1 / 2],
-         3: [1 / 2, 1 / 2]}) == np.mat([-5.875, -8.125, -8.125, -4.5])).all()
+    assert (
+        first_hgg.expected_utilities(
+            {0: [1 / 2, 1 / 2], 1: [1 / 2, 1 / 2], 2: [1 / 2, 1 / 2], 3: [1 / 2, 1 / 2]}
+        )
+        == np.mat([-5.875, -8.125, -8.125, -4.5])
+    ).all()
 
 
 # is_equilibrium
 # no degen
 
+
 def test_is_equilibrium1(first_hgg):
-    assert not (
-        first_hgg.is_equilibrium({0: [1, 0], 1: [1, 0], 2: [1, 0], 3: [1, 0]}))
+    assert not (first_hgg.is_equilibrium({0: [1, 0], 1: [1, 0], 2: [1, 0], 3: [1, 0]}))
 
 
 def test_is_equilibrium2(first_hgg):
-    assert (
-        first_hgg.is_equilibrium({0: [0, 1], 1: [0, 1], 2: [0, 1], 3: [0, 1]}))
+    assert first_hgg.is_equilibrium({0: [0, 1], 1: [0, 1], 2: [0, 1], 3: [0, 1]})
 
 
 def test_is_equilibrium3(first_hgg):
-    assert not (
-        first_hgg.is_equilibrium({0: [1, 0], 1: [1, 0], 2: [0, 1], 3: [0, 1]}))
+    assert not (first_hgg.is_equilibrium({0: [1, 0], 1: [1, 0], 2: [0, 1], 3: [0, 1]}))
 
 
 def test_is_equilibrium4(first_hgg):
-    assert not (first_hgg.is_equilibrium(
-        {0: [1 / 2, 1 / 2], 1: [1 / 2, 1 / 2], 2: [1 / 2, 1 / 2],
-         3: [1 / 2, 1 / 2]}))
+    assert not (
+        first_hgg.is_equilibrium(
+            {0: [1 / 2, 1 / 2], 1: [1 / 2, 1 / 2], 2: [1 / 2, 1 / 2], 3: [1 / 2, 1 / 2]}
+        )
+    )
 
 
 # util_of_player
 # no degen
 
+
 def test_util_of_player1(first_hgg):
-    assert (first_hgg.util_of_player(0).keys() == {0} and
-            (first_hgg.util_of_player(0)[0] == [-3, -7, -7, -10, -1, -5, -5,
-                                                -9]))
+    assert first_hgg.util_of_player(0).keys() == {0} and (
+        first_hgg.util_of_player(0)[0] == [-3, -7, -7, -10, -1, -5, -5, -9]
+    )
 
 
 def test_util_of_player2(first_hgg):
-    assert (first_hgg.util_of_player(1).keys() == {0, 1} and
-            (first_hgg.util_of_player(1)[0] == [-3, -7, -1, -5, -7, -10, -5,
-                                                -9]) and
-            (first_hgg.util_of_player(1)[1] == [-1, -5, 0, -3]))
+    assert (
+        first_hgg.util_of_player(1).keys() == {0, 1}
+        and (first_hgg.util_of_player(1)[0] == [-3, -7, -1, -5, -7, -10, -5, -9])
+        and (first_hgg.util_of_player(1)[1] == [-1, -5, 0, -3])
+    )
 
 
 def test_util_of_player3(first_hgg):
-    assert (first_hgg.util_of_player(2).keys() == {0, 2} and
-            (first_hgg.util_of_player(2)[0] == [-3, -1, -7, -5, -7, -5, -10,
-                                                -9]) and
-            (first_hgg.util_of_player(2)[2] == [-1, -5, 0, -3]))
+    assert (
+        first_hgg.util_of_player(2).keys() == {0, 2}
+        and (first_hgg.util_of_player(2)[0] == [-3, -1, -7, -5, -7, -5, -10, -9])
+        and (first_hgg.util_of_player(2)[2] == [-1, -5, 0, -3])
+    )
 
 
 def test_util_of_player4(first_hgg):
-    assert (first_hgg.util_of_player(3).keys() == {1, 2} and
-            (first_hgg.util_of_player(3)[1] == [-1, 0, -5, -3]) and
-            (first_hgg.util_of_player(3)[2] == [-1, 0, -5, -3]))
+    assert (
+        first_hgg.util_of_player(3).keys() == {1, 2}
+        and (first_hgg.util_of_player(3)[1] == [-1, 0, -5, -3])
+        and (first_hgg.util_of_player(3)[2] == [-1, 0, -5, -3])
+    )
 
 
 # PNE METHOD MISSING
@@ -335,9 +933,7 @@ def test_util_of_player4(first_hgg):
 
 
 def test_get_all_PNE1(first_hgg):
-    assert first_hgg.get_all_PNE() == [
-        {0: [0, 1], 1: [0, 1], 2: [0, 1], 3: [0, 1]}
-    ]
+    assert first_hgg.get_all_PNE() == [{0: [0, 1], 1: [0, 1], 2: [0, 1], 3: [0, 1]}]
 
 
 def test_get_all_PNE2(second_hgg):
@@ -353,15 +949,13 @@ def test_get_all_PNE4(degen_hgg):
         {0: [1, 0, 0], 1: [1, 0, 0], 2: [1, 0, 0], 3: [0, 0, 1]},
         {0: [1, 0, 0], 1: [0, 1, 0], 2: [0, 1, 0], 3: [0, 1, 0]},
         {0: [1, 0, 0], 1: [0, 0, 1], 2: [1, 0, 0], 3: [0, 1, 0]},
-        {0: [0, 1, 0], 1: [1, 0, 0], 2: [0, 1, 0], 3: [1, 0, 0]}
+        {0: [0, 1, 0], 1: [1, 0, 0], 2: [0, 1, 0], 3: [1, 0, 0]},
     ]
 
 
 def test_get_all_PNE5(first_hgg_fraction):
     tmp_hgg = first_hgg_fraction.game_as_int()
-    assert tmp_hgg.get_all_PNE() == [
-        {0: [0, 1], 1: [0, 1], 2: [0, 1], 3: [0, 1]}
-    ]
+    assert tmp_hgg.get_all_PNE() == [{0: [0, 1], 1: [0, 1], 2: [0, 1], 3: [0, 1]}]
 
 
 def test_pne_exist1(first_hgg):
@@ -383,37 +977,56 @@ def test_pne_exist4(degen_hgg):
 def test_pne_exist5(first_hgg_fraction):
     tmp_hgg = first_hgg_fraction.game_as_int()
     assert tmp_hgg.pne_exist()
+
+
 # build_subgame
 # no degen
 
 
 def test_build_subgame1(first_hgg):
     sub_first_hgg1 = first_hgg.build_subgame({3: [1, 0]})
-    assert (sub_first_hgg1.players_actions == [[0, 1], [0, 1], [0, 1],
-                                               [-1]] and
-            sub_first_hgg1.utilities == [[[-3, -7, -7, -10, -1, -5, -5, -9],
-                                          [-3, -7, -1, -5, -7, -10, -5, -9],
-                                          [-3, -1, -7, -5, -7, -5, -10, -9]],
-                                         [[-1, 0], [-1, -5]],
-                                         [[-1, 0], [-1, -5]]])
+    assert sub_first_hgg1.players_actions == [
+        [0, 1],
+        [0, 1],
+        [0, 1],
+        [-1],
+    ] and sub_first_hgg1.utilities == [
+        [
+            [-3, -7, -7, -10, -1, -5, -5, -9],
+            [-3, -7, -1, -5, -7, -10, -5, -9],
+            [-3, -1, -7, -5, -7, -5, -10, -9],
+        ],
+        [[-1, 0], [-1, -5]],
+        [[-1, 0], [-1, -5]],
+    ]
 
 
 def test_build_subgame2(first_hgg):
     sub_first_hgg2 = first_hgg.build_subgame({0: [1, 0]})
-    assert (sub_first_hgg2.players_actions == [[-1], [0, 1], [0, 1],
-                                               [0, 1]] and
-            sub_first_hgg2.utilities == [
-                [[-3, -7, -7, -10], [-3, -7, -1, -5], [-3, -1, -7, -5]],
-                [[-1, -5, 0, -3], [-1, 0, -5, -3]],
-                [[-1, -5, 0, -3], [-1, 0, -5, -3]]])
+    assert sub_first_hgg2.players_actions == [
+        [-1],
+        [0, 1],
+        [0, 1],
+        [0, 1],
+    ] and sub_first_hgg2.utilities == [
+        [[-3, -7, -7, -10], [-3, -7, -1, -5], [-3, -1, -7, -5]],
+        [[-1, -5, 0, -3], [-1, 0, -5, -3]],
+        [[-1, -5, 0, -3], [-1, 0, -5, -3]],
+    ]
 
 
 def test_build_subgame3(first_hgg):
     sub_first_hgg3 = first_hgg.build_subgame({1: [1, 0], 2: [0, 1]})
-    assert (sub_first_hgg3.players_actions == [[0, 1], [-1], [-1], [0, 1]] and
-            sub_first_hgg3.utilities == [[[-7, -5], [-7, -10], [-1, -5]],
-                                         [[-1, -5], [-1, 0]],
-                                         [[0, -3], [-5, -3]]])
+    assert sub_first_hgg3.players_actions == [
+        [0, 1],
+        [-1],
+        [-1],
+        [0, 1],
+    ] and sub_first_hgg3.utilities == [
+        [[-7, -5], [-7, -10], [-1, -5]],
+        [[-1, -5], [-1, 0]],
+        [[0, -3], [-5, -3]],
+    ]
 
     # [[[-3, -7, -7, -10, -1, -5, -5, -9], [-3, -7, -1, -5, -7, -10, -5, -9],
     # [-3, -1, -7, -5, -7, -5, -10, -9]],
@@ -435,14 +1048,20 @@ MODIFICATION OF SIMPLIFY REQUIRED
 
 
 def test_simplify_subgame1(first_hgg):
-    simplify_first_hgg1 = first_hgg.build_subgame(
-        {3: [1, 0]}).simplify_subgame()
-    assert (simplify_first_hgg1.players_actions == [[0, 1], [0, 1], [0, 1]] and
-            simplify_first_hgg1.utilities == [
-                [[-3, -7, -7, -10, -1, -5, -5, -9],
-                 [-3, -7, -1, -5, -7, -10, -5, -9],
-                 [-3, -1, -7, -5, -7, -5, -10, -9]],
-                [[-1, 0]], [[-1, 0]]])
+    simplify_first_hgg1 = first_hgg.build_subgame({3: [1, 0]}).simplify_subgame()
+    assert simplify_first_hgg1.players_actions == [
+        [0, 1],
+        [0, 1],
+        [0, 1],
+    ] and simplify_first_hgg1.utilities == [
+        [
+            [-3, -7, -7, -10, -1, -5, -5, -9],
+            [-3, -7, -1, -5, -7, -10, -5, -9],
+            [-3, -1, -7, -5, -7, -5, -10, -9],
+        ],
+        [[-1, 0]],
+        [[-1, 0]],
+    ]
 
     # ISSUE WITH THE DURING THE SIMPLIFICATION
 
@@ -461,66 +1080,89 @@ def test_simplify_subgame1(first_hgg):
 # get_subgame_fixed_strat
 # no degen
 
+
 def test_get_subgame_fixed_strat1(first_hgg):
     sub_first_hgg1 = first_hgg.get_subgame_fixed_strat(
-        {0: [1, 1], 1: [1, 1], 2: [1, 1], 3: [1, 0]})
-    assert (sub_first_hgg1.players_actions == [[0, 1], [0, 1], [0, 1], [0]] and
-            sub_first_hgg1.utilities == [[[-3, -7, -7, -10, -1, -5, -5, -9],
-                                          [-3, -7, -1, -5, -7, -10, -5, -9],
-                                          [-3, -1, -7, -5, -7, -5, -10, -9]],
-                                         [[-1, 0], [-1, -5]],
-                                         [[-1, 0], [-1, -5]]])
+        {0: [1, 1], 1: [1, 1], 2: [1, 1], 3: [1, 0]}
+    )
+    assert sub_first_hgg1.players_actions == [
+        [0, 1],
+        [0, 1],
+        [0, 1],
+        [0],
+    ] and sub_first_hgg1.utilities == [
+        [
+            [-3, -7, -7, -10, -1, -5, -5, -9],
+            [-3, -7, -1, -5, -7, -10, -5, -9],
+            [-3, -1, -7, -5, -7, -5, -10, -9],
+        ],
+        [[-1, 0], [-1, -5]],
+        [[-1, 0], [-1, -5]],
+    ]
 
 
 def test_get_subgame_fixed_strat2(first_hgg):
     sub_first_hgg2 = first_hgg.get_subgame_fixed_strat(
-        {0: [1, 0], 1: [1, 1], 2: [1, 1], 3: [1, 1]})
-    assert (sub_first_hgg2.players_actions == [[0], [0, 1], [0, 1], [0, 1]] and
-            sub_first_hgg2.utilities == [
-                [[-3, -7, -7, -10], [-3, -7, -1, -5], [-3, -1, -7, -5]],
-                [[-1, -5, 0, -3], [-1, 0, -5, -3]],
-                [[-1, -5, 0, -3], [-1, 0, -5, -3]]])
+        {0: [1, 0], 1: [1, 1], 2: [1, 1], 3: [1, 1]}
+    )
+    assert sub_first_hgg2.players_actions == [
+        [0],
+        [0, 1],
+        [0, 1],
+        [0, 1],
+    ] and sub_first_hgg2.utilities == [
+        [[-3, -7, -7, -10], [-3, -7, -1, -5], [-3, -1, -7, -5]],
+        [[-1, -5, 0, -3], [-1, 0, -5, -3]],
+        [[-1, -5, 0, -3], [-1, 0, -5, -3]],
+    ]
 
 
 def test_get_subgame_fixed_strat3(first_hgg):
     sub_first_hgg3 = first_hgg.get_subgame_fixed_strat(
-        {0: [1, 1], 1: [1, 0], 2: [0, 1], 3: [1, 1]})
-    assert (sub_first_hgg3.players_actions == [[0, 1], [0], [1], [0, 1]] and
-            sub_first_hgg3.utilities == [[[-7, -5], [-7, -10], [-1, -5]],
-                                         [[-1, -5], [-1, 0]],
-                                         [[0, -3], [-5, -3]]])
+        {0: [1, 1], 1: [1, 0], 2: [0, 1], 3: [1, 1]}
+    )
+    assert sub_first_hgg3.players_actions == [
+        [0, 1],
+        [0],
+        [1],
+        [0, 1],
+    ] and sub_first_hgg3.utilities == [
+        [[-7, -5], [-7, -10], [-1, -5]],
+        [[-1, -5], [-1, 0]],
+        [[0, -3], [-5, -3]],
+    ]
 
 
 def test_local_game_of_player_n1(first_hgg, degen_hgg):
-    assert (first_hgg.local_game_of_player_n(0) == [0])
+    assert first_hgg.local_game_of_player_n(0) == [0]
 
 
 def test_local_game_of_player_n2(first_hgg):
-    assert (first_hgg.local_game_of_player_n(1) == [0, 1])
+    assert first_hgg.local_game_of_player_n(1) == [0, 1]
 
 
 def test_local_game_of_player_n3(first_hgg):
-    assert (first_hgg.local_game_of_player_n(2) == [0, 2])
+    assert first_hgg.local_game_of_player_n(2) == [0, 2]
 
 
 def test_local_game_of_player_n4(first_hgg):
-    assert (first_hgg.local_game_of_player_n(3) == [1, 2])
+    assert first_hgg.local_game_of_player_n(3) == [1, 2]
 
 
 def test_local_game_of_player_n5(degen_hgg):
-    assert (degen_hgg.local_game_of_player_n(0) == [1, 2])
+    assert degen_hgg.local_game_of_player_n(0) == [1, 2]
 
 
 def test_local_game_of_player_n6(degen_hgg):
-    assert (degen_hgg.local_game_of_player_n(1) == [0, 1, 2])
+    assert degen_hgg.local_game_of_player_n(1) == [0, 1, 2]
 
 
 def test_local_game_of_player_n7(degen_hgg):
-    assert (degen_hgg.local_game_of_player_n(2) == [0, 2])
+    assert degen_hgg.local_game_of_player_n(2) == [0, 2]
 
 
 def test_local_game_of_player_n8(degen_hgg):
-    assert (degen_hgg.local_game_of_player_n(3) == [0, 1])
+    assert degen_hgg.local_game_of_player_n(3) == [0, 1]
 
 
 """
@@ -530,234 +1172,431 @@ Add another hypergraphical game
 
 # get_max_value_of_player_n
 def test_get_max_value_of_player_n1(first_hgg):
-    assert (first_hgg.get_max_value_of_player_n(0) == -1)
+    assert first_hgg.get_max_value_of_player_n(0) == -1
 
 
 def test_get_max_value_of_player_n2(first_hgg):
-    assert (first_hgg.get_max_value_of_player_n(1) == 0)
+    assert first_hgg.get_max_value_of_player_n(1) == 0
 
 
 def test_get_max_value_of_player_n3(first_hgg):
-    assert (first_hgg.get_max_value_of_player_n(2) == 0)
+    assert first_hgg.get_max_value_of_player_n(2) == 0
 
 
 def test_get_max_value_of_player_n4(first_hgg):
-    assert (first_hgg.get_max_value_of_player_n(3) == 0)
+    assert first_hgg.get_max_value_of_player_n(3) == 0
 
 
 def test_get_max_value_of_player_n5(degen_hgg):
-    assert (degen_hgg.get_max_value_of_player_n(0) == -1)
+    assert degen_hgg.get_max_value_of_player_n(0) == -1
 
 
 def test_get_max_value_of_player_n6(degen_hgg):
-    assert (degen_hgg.get_max_value_of_player_n(1) == -1)
+    assert degen_hgg.get_max_value_of_player_n(1) == -1
 
 
 def test_get_max_value_of_player_n7(degen_hgg):
-    assert (degen_hgg.get_max_value_of_player_n(2) == -1)
+    assert degen_hgg.get_max_value_of_player_n(2) == -1
 
 
 def test_get_max_value_of_player_n8(degen_hgg):
-    assert (degen_hgg.get_max_value_of_player_n(3) == -1)
+    assert degen_hgg.get_max_value_of_player_n(3) == -1
 
 
 # index_of_player_in_local
 def test_index_of_player_in_local1(first_hgg, degen_hgg):
-    assert (first_hgg.index_of_player_in_local(0) == {0: 0})
+    assert first_hgg.index_of_player_in_local(0) == {0: 0}
 
 
 def test_index_of_player_in_local2(first_hgg):
-    assert (first_hgg.index_of_player_in_local(1) == {0: 1, 1: 0})
+    assert first_hgg.index_of_player_in_local(1) == {0: 1, 1: 0}
 
 
 def test_index_of_player_in_local3(first_hgg):
-    assert (first_hgg.index_of_player_in_local(2) == {0: 2, 2: 0})
+    assert first_hgg.index_of_player_in_local(2) == {0: 2, 2: 0}
 
 
 def test_index_of_player_in_local4(first_hgg):
-    assert (first_hgg.index_of_player_in_local(3) == {1: 1, 2: 1})
+    assert first_hgg.index_of_player_in_local(3) == {1: 1, 2: 1}
 
 
 def test_index_of_player_in_local5(degen_hgg):
-    assert (degen_hgg.index_of_player_in_local(0) == {1: 0, 2: 0})
+    assert degen_hgg.index_of_player_in_local(0) == {1: 0, 2: 0}
 
 
 def test_index_of_player_in_local6(degen_hgg):
-    assert (degen_hgg.index_of_player_in_local(1) == {0: 0, 1: 1, 2: 1})
+    assert degen_hgg.index_of_player_in_local(1) == {0: 0, 1: 1, 2: 1}
 
 
 def test_index_of_player_in_local7(degen_hgg):
-    assert (degen_hgg.index_of_player_in_local(2) == {0: 1, 2: 2})
+    assert degen_hgg.index_of_player_in_local(2) == {0: 1, 2: 2}
 
 
 def test_index_of_player_in_local8(degen_hgg):
-    assert (degen_hgg.index_of_player_in_local(3) == {0: 2, 1: 2})
+    assert degen_hgg.index_of_player_in_local(3) == {0: 2, 1: 2}
 
 
 # get_subgame_level
 
+
 def test_get_subgame_level1(first_hgg):
     sub_level_first_hgg1 = first_hgg.get_subgame_level(
-        {0: [1, 0], 1: [1, 0], 2: [1, 0], 3: [1, 0]})
-    assert (sub_level_first_hgg1.players_actions == [[0, 1], [0, 1],
-                                                     [0, 1]] and
-            sub_level_first_hgg1.utilities == [
-                [[-3, -7, -7, -10, -1, -5, -5, -9],
-                 [-3, -7, -1, -5, -7, -10, -5, -9],
-                 [-3, -1, -7, -5, -7, -5, -10, -9]],
-                [[-1, 0]], [[-1, 0]]])
+        {0: [1, 0], 1: [1, 0], 2: [1, 0], 3: [1, 0]}
+    )
+    assert sub_level_first_hgg1.players_actions == [
+        [0, 1],
+        [0, 1],
+        [0, 1],
+    ] and sub_level_first_hgg1.utilities == [
+        [
+            [-3, -7, -7, -10, -1, -5, -5, -9],
+            [-3, -7, -1, -5, -7, -10, -5, -9],
+            [-3, -1, -7, -5, -7, -5, -10, -9],
+        ],
+        [[-1, 0]],
+        [[-1, 0]],
+    ]
 
 
 def test_get_subgame_level2(first_hgg):
     sub_level_first_hgg2 = first_hgg.get_subgame_level(
-        {0: [1, 0], 1: [1, 0], 2: [1, 0], 3: [0, 1]})
-    assert (sub_level_first_hgg2.players_actions == [[0, 1], [0, 1],
-                                                     [0, 1]] and
-            sub_level_first_hgg2.utilities == [
-                [[-3, -7, -7, -10, -1, -5, -5, -9],
-                 [-3, -7, -1, -5, -7, -10, -5, -9],
-                 [-3, -1, -7, -5, -7, -5, -10, -9]],
-                [[-5, -3]], [[-5, -3]]])
+        {0: [1, 0], 1: [1, 0], 2: [1, 0], 3: [0, 1]}
+    )
+    assert sub_level_first_hgg2.players_actions == [
+        [0, 1],
+        [0, 1],
+        [0, 1],
+    ] and sub_level_first_hgg2.utilities == [
+        [
+            [-3, -7, -7, -10, -1, -5, -5, -9],
+            [-3, -7, -1, -5, -7, -10, -5, -9],
+            [-3, -1, -7, -5, -7, -5, -10, -9],
+        ],
+        [[-5, -3]],
+        [[-5, -3]],
+    ]
 
 
 def test_get_subgame_level3(degen_hgg):
     sub_level_degen_hgg1 = degen_hgg.get_subgame_level(
-        {0: [1, 0, 0], 1: [1, 0, 0], 2: [1, 0, 0], 3: [1, 0, 0]})
-    assert (sub_level_degen_hgg1.players_actions == [[0, 1, 2], [0, 1, 2],
-                                                     [0, 1, 2]] and
-            sub_level_degen_hgg1.utilities == [
-                [[-6, -1, -7, -10, -1, -6, -6, -4, -7],
-                 [-9, -2, -7, -2, -5, -7, -7, -5, -8]],
-                [[-7, -9, -6, -8, -2, -10, -6, -6, -3],
-                 [-3, -2, -1, -10, -9, -7, -6, -4, -3]],
-                [[-1, -8, -5, -4, -2, -5, -1, -10, -5, -2, -1, -3, -7, -3, -5,
-                  -1, -7, -9, -9, -4, -5, -5, -10, -3, -6, -2, -6],
-                 [-5, -7, -1, -9, -3, -7, -6, -10, -8, -9, -4, -1, -8, -5, -1,
-                  -10, -6, -4, -4, -7, -6, -10, -5, -8, -7, -3, -2],
-                 [-6, -8, -6, -3, -1, -6, -7, -2, -9, -7, -9, -10, -4, -3, -6,
-                  -5, -5, -10, -4, -4, -5, -4, -10, -3, -4, -5, -3]]])
+        {0: [1, 0, 0], 1: [1, 0, 0], 2: [1, 0, 0], 3: [1, 0, 0]}
+    )
+    assert sub_level_degen_hgg1.players_actions == [
+        [0, 1, 2],
+        [0, 1, 2],
+        [0, 1, 2],
+    ] and sub_level_degen_hgg1.utilities == [
+        [[-6, -1, -7, -10, -1, -6, -6, -4, -7], [-9, -2, -7, -2, -5, -7, -7, -5, -8]],
+        [[-7, -9, -6, -8, -2, -10, -6, -6, -3], [-3, -2, -1, -10, -9, -7, -6, -4, -3]],
+        [
+            [
+                -1,
+                -8,
+                -5,
+                -4,
+                -2,
+                -5,
+                -1,
+                -10,
+                -5,
+                -2,
+                -1,
+                -3,
+                -7,
+                -3,
+                -5,
+                -1,
+                -7,
+                -9,
+                -9,
+                -4,
+                -5,
+                -5,
+                -10,
+                -3,
+                -6,
+                -2,
+                -6,
+            ],
+            [
+                -5,
+                -7,
+                -1,
+                -9,
+                -3,
+                -7,
+                -6,
+                -10,
+                -8,
+                -9,
+                -4,
+                -1,
+                -8,
+                -5,
+                -1,
+                -10,
+                -6,
+                -4,
+                -4,
+                -7,
+                -6,
+                -10,
+                -5,
+                -8,
+                -7,
+                -3,
+                -2,
+            ],
+            [
+                -6,
+                -8,
+                -6,
+                -3,
+                -1,
+                -6,
+                -7,
+                -2,
+                -9,
+                -7,
+                -9,
+                -10,
+                -4,
+                -3,
+                -6,
+                -5,
+                -5,
+                -10,
+                -4,
+                -4,
+                -5,
+                -4,
+                -10,
+                -3,
+                -4,
+                -5,
+                -3,
+            ],
+        ],
+    ]
 
 
 def test_get_subgame_level4(degen_hgg):
     sub_level_degen_hgg1 = degen_hgg.get_subgame_level(
-        {0: [1, 0, 0], 1: [1, 0, 0], 2: [1, 0, 0], 3: [1, 0, 0]})
+        {0: [1, 0, 0], 1: [1, 0, 0], 2: [1, 0, 0], 3: [1, 0, 0]}
+    )
     sub_level_degen_hgg1bis = sub_level_degen_hgg1.get_subgame_level(
-        {0: [1, 0, 0], 1: [1, 0, 0], 2: [1, 0, 0]})
-    assert (sub_level_degen_hgg1bis.players_actions == [[0, 1, 2],
-                                                        [0, 1, 2]] and
-            sub_level_degen_hgg1bis.utilities == [
-                [[-6, -10, -6, ]],
-                [[-7, -9, -6, -8, -2, -10, -6, -6, -3],
-                 [-3, -2, -1, -10, -9, -7, -6, -4, -3]],
-                [[-1, -4, -1, -2, -7, -1, -9, -5, -6],
-                 [-5, -9, -6, -9, -8, -10, -4, -10, -7]]])
+        {0: [1, 0, 0], 1: [1, 0, 0], 2: [1, 0, 0]}
+    )
+    assert sub_level_degen_hgg1bis.players_actions == [
+        [0, 1, 2],
+        [0, 1, 2],
+    ] and sub_level_degen_hgg1bis.utilities == [
+        [
+            [
+                -6,
+                -10,
+                -6,
+            ]
+        ],
+        [[-7, -9, -6, -8, -2, -10, -6, -6, -3], [-3, -2, -1, -10, -9, -7, -6, -4, -3]],
+        [[-1, -4, -1, -2, -7, -1, -9, -5, -6], [-5, -9, -6, -9, -8, -10, -4, -10, -7]],
+    ]
 
 
 def test_get_subgame_without_n1(first_hgg):
     sub_n_first_hgg = first_hgg.get_subgame_without_n(
-        {0: [1, 0], 1: [1, 0], 2: [1, 0], 3: [1, 0]}, 0)
-    assert (sub_n_first_hgg.players_actions == [[0, 1], [0, 1], [0, 1]] and
-            sub_n_first_hgg.utilities == [[[-3, -7, -1, -5], [-3, -1, -7, -5]],
-                                          [[-1, -5, 0, -3], [-1, 0, -5, -3]],
-                                          [[-1, -5, 0, -3], [-1, 0, -5, -3]]])
+        {0: [1, 0], 1: [1, 0], 2: [1, 0], 3: [1, 0]}, 0
+    )
+    assert sub_n_first_hgg.players_actions == [
+        [0, 1],
+        [0, 1],
+        [0, 1],
+    ] and sub_n_first_hgg.utilities == [
+        [[-3, -7, -1, -5], [-3, -1, -7, -5]],
+        [[-1, -5, 0, -3], [-1, 0, -5, -3]],
+        [[-1, -5, 0, -3], [-1, 0, -5, -3]],
+    ]
 
 
 def test_get_subgame_without_n2(first_hgg):
     sub_n_first_hgg = first_hgg.get_subgame_without_n(
-        {0: [1, 0], 1: [1, 0], 2: [1, 0], 3: [1, 0]}, 2)
-    assert (sub_n_first_hgg.players_actions == [[0, 1], [0, 1], [0, 1]] and
-            sub_n_first_hgg.utilities == [[[-3, -7, -1, -5], [-3, -1, -7, -5]],
-                                          [[-1, -5, 0, -3], [-1, 0, -5, -3]],
-                                          [[-1, 0]]])
+        {0: [1, 0], 1: [1, 0], 2: [1, 0], 3: [1, 0]}, 2
+    )
+    assert sub_n_first_hgg.players_actions == [
+        [0, 1],
+        [0, 1],
+        [0, 1],
+    ] and sub_n_first_hgg.utilities == [
+        [[-3, -7, -1, -5], [-3, -1, -7, -5]],
+        [[-1, -5, 0, -3], [-1, 0, -5, -3]],
+        [[-1, 0]],
+    ]
 
 
 def test_get_subgame_without_n3(degen_hgg):
     sub_n_degen_hgg1 = degen_hgg.get_subgame_without_n(
-        {0: [1, 0, 0], 1: [1, 0, 0], 2: [1, 0, 0], 3: [1, 0, 0]}, 0)
-    assert (sub_n_degen_hgg1.players_actions == [[0, 1, 2], [0, 1, 2],
-                                                 [0, 1, 2]] and
-            sub_n_degen_hgg1.utilities == [[[-6, -3, -3, -1, -4, -10, -7, -5,
-                                             -5, -10, -2, -1, -1, -3, -7, -6,
-                                             -1, -2, -6, -3, -3, -4, -8, -3,
-                                             -7, -8, -8],
-                                            [-9, -1, -8, -2, -7, -6, -7, -6,
-                                             -9, -2, -4, -2, -5, -2, -3, -7,
-                                             -3, -7, -7, -5, -3, -5, -10, -5,
-                                             -8, -9, -9],
-                                            [-3, -1, -2, -4, -1, -4, -8, -7,
-                                             -3, -6, -9, -1, -1, -3, -7, -3,
-                                             -7, -2, -1, -4, -10, -4, -9, -4,
-                                             -3, -6, -3]],
-                                           [[-3, -6, -3, -2, -9, -3, -1, -3,
-                                             -6],
-                                            [-9, -9, -5, -9, -6, -3, -6, -2,
-                                             -7]],
-                                           [[-5, -7, -1, -9, -3, -7, -6, -10,
-                                             -8],
-                                            [-6, -8, -6, -3, -1, -6, -7, -2,
-                                             -9]]])
+        {0: [1, 0, 0], 1: [1, 0, 0], 2: [1, 0, 0], 3: [1, 0, 0]}, 0
+    )
+    assert sub_n_degen_hgg1.players_actions == [
+        [0, 1, 2],
+        [0, 1, 2],
+        [0, 1, 2],
+    ] and sub_n_degen_hgg1.utilities == [
+        [
+            [
+                -6,
+                -3,
+                -3,
+                -1,
+                -4,
+                -10,
+                -7,
+                -5,
+                -5,
+                -10,
+                -2,
+                -1,
+                -1,
+                -3,
+                -7,
+                -6,
+                -1,
+                -2,
+                -6,
+                -3,
+                -3,
+                -4,
+                -8,
+                -3,
+                -7,
+                -8,
+                -8,
+            ],
+            [
+                -9,
+                -1,
+                -8,
+                -2,
+                -7,
+                -6,
+                -7,
+                -6,
+                -9,
+                -2,
+                -4,
+                -2,
+                -5,
+                -2,
+                -3,
+                -7,
+                -3,
+                -7,
+                -7,
+                -5,
+                -3,
+                -5,
+                -10,
+                -5,
+                -8,
+                -9,
+                -9,
+            ],
+            [
+                -3,
+                -1,
+                -2,
+                -4,
+                -1,
+                -4,
+                -8,
+                -7,
+                -3,
+                -6,
+                -9,
+                -1,
+                -1,
+                -3,
+                -7,
+                -3,
+                -7,
+                -2,
+                -1,
+                -4,
+                -10,
+                -4,
+                -9,
+                -4,
+                -3,
+                -6,
+                -3,
+            ],
+        ],
+        [[-3, -6, -3, -2, -9, -3, -1, -3, -6], [-9, -9, -5, -9, -6, -3, -6, -2, -7]],
+        [[-5, -7, -1, -9, -3, -7, -6, -10, -8], [-6, -8, -6, -3, -1, -6, -7, -2, -9]],
+    ]
 
 
 # get_player_interact
 
+
 def test_get_player_interact1(first_hgg):
-    assert (first_hgg.get_player_interact(0) == [1, 2])
+    assert first_hgg.get_player_interact(0) == [1, 2]
 
 
 def test_get_player_interact2(first_hgg):
-    assert (first_hgg.get_player_interact(1) == [0, 2, 3])
+    assert first_hgg.get_player_interact(1) == [0, 2, 3]
 
 
 def test_get_player_interact3(first_hgg):
-    assert (first_hgg.get_player_interact(2) == [0, 1, 3])
+    assert first_hgg.get_player_interact(2) == [0, 1, 3]
 
 
 def test_get_player_interact4(first_hgg):
-    assert (first_hgg.get_player_interact(3) == [1, 2])
+    assert first_hgg.get_player_interact(3) == [1, 2]
 
 
 def test_get_player_interact5(degen_hgg):
-    assert (degen_hgg.get_player_interact(0) == [1, 2, 3])
+    assert degen_hgg.get_player_interact(0) == [1, 2, 3]
 
 
 def test_get_player_interact6(degen_hgg):
-    assert (degen_hgg.get_player_interact(1) == [0, 2, 3])
+    assert degen_hgg.get_player_interact(1) == [0, 2, 3]
 
 
 def test_get_player_interact7(degen_hgg):
-    assert (degen_hgg.get_player_interact(2) == [0, 1, 3])
+    assert degen_hgg.get_player_interact(2) == [0, 1, 3]
 
 
 def test_get_player_interact8(degen_hgg):
-    assert (degen_hgg.get_player_interact(3) == [0, 1, 2])
+    assert degen_hgg.get_player_interact(3) == [0, 1, 2]
 
 
 def test_get_player_interact_except_e1(first_hgg, degen_hgg):
-    assert (first_hgg.get_player_interact_except_e(0, [0, 1, 2]) == [])
+    assert first_hgg.get_player_interact_except_e(0, [0, 1, 2]) == []
 
 
 def test_get_player_interact_except_e2(first_hgg):
-    assert (first_hgg.get_player_interact_except_e(1, [0, 1, 2]) == [3])
+    assert first_hgg.get_player_interact_except_e(1, [0, 1, 2]) == [3]
 
 
 def test_get_player_interact_except_e3(first_hgg):
-    assert (first_hgg.get_player_interact_except_e(1, [1, 3]) == [0, 2])
+    assert first_hgg.get_player_interact_except_e(1, [1, 3]) == [0, 2]
 
 
 def test_get_player_interact_except_e4(first_hgg):
-    assert (first_hgg.get_player_interact_except_e(2, [0, 1, 2]) == [3])
+    assert first_hgg.get_player_interact_except_e(2, [0, 1, 2]) == [3]
 
 
 def test_get_player_interact_except_e5(first_hgg):
-    assert (first_hgg.get_player_interact_except_e(2, [2, 3]) == [0, 1])
+    assert first_hgg.get_player_interact_except_e(2, [2, 3]) == [0, 1]
 
 
 def test_get_player_interact_except_e6(first_hgg):
-    assert (first_hgg.get_player_interact_except_e(3, [1, 3]) == [2])
+    assert first_hgg.get_player_interact_except_e(3, [1, 3]) == [2]
 
 
 def test_get_player_interact_except_e7(first_hgg):
-    assert (first_hgg.get_player_interact_except_e(3, [2, 3]) == [1])
+    assert first_hgg.get_player_interact_except_e(3, [2, 3]) == [1]
 
 
 # Depend on meaning of returned value of get_player_interact_except_e
@@ -780,27 +1619,27 @@ def test_get_player_interact_except_e7(first_hgg):
 
 
 def test_get_player_except_e1(first_hgg, degen_hgg):
-    assert (first_hgg.get_player_except_e([0, 1, 2]) == [3])
+    assert first_hgg.get_player_except_e([0, 1, 2]) == [3]
 
 
 def test_get_player_except_e2(first_hgg):
-    assert (first_hgg.get_player_except_e([1, 3]) == [0, 2])
+    assert first_hgg.get_player_except_e([1, 3]) == [0, 2]
 
 
 def test_get_player_except_e3(first_hgg):
-    assert (first_hgg.get_player_except_e([2, 3]) == [0, 1])
+    assert first_hgg.get_player_except_e([2, 3]) == [0, 1]
 
 
 def test_get_player_except_e4(degen_hgg):
-    assert (degen_hgg.get_player_except_e([1, 2, 3]) == [0])
+    assert degen_hgg.get_player_except_e([1, 2, 3]) == [0]
 
 
 def test_get_player_except_e5(degen_hgg):
-    assert (degen_hgg.get_player_except_e([0, 1, 3]) == [2])
+    assert degen_hgg.get_player_except_e([0, 1, 3]) == [2]
 
 
 def test_get_player_except_e6(degen_hgg):
-    assert (degen_hgg.get_player_except_e([0, 1, 2]) == [3])
+    assert degen_hgg.get_player_except_e([0, 1, 2]) == [3]
 
 
 """
@@ -820,7 +1659,8 @@ def test_convert_to_NFG1(first_hgg):
         [-3, -3, -7, -7, -7, -7, -10, -10, -1, -1, -5, -5, -5, -5, -9, -9],
         [-4, -8, -8, -12, -1, -4, -5, -8, -8, -12, -11, -15, -5, -8, -9, -12],
         [-4, -8, -1, -4, -8, -12, -5, -8, -8, -12, -5, -8, -11, -15, -9, -12],
-        [-2, 0, -6, -3, -6, -3, -10, -6, -2, 0, -6, -3, -6, -3, -10, -6]]
+        [-2, 0, -6, -3, -6, -3, -10, -6, -2, 0, -6, -3, -6, -3, -10, -6],
+    ]
 
 
 def test_convert_to_NFG2(second_hgg):
@@ -830,7 +1670,8 @@ def test_convert_to_NFG2(second_hgg):
         [-3, -3, -1, -1, -3, -3, -2, -2, -2, -2, -3, -3, -2, -2, -1, -1],
         [-2, -4, -4, -6, -7, -7, -3, -3, -2, -4, -7, -9, -5, -5, -6, -6],
         [-5, -3, -7, -8, -9, -7, -8, -9, -6, -4, -5, -6, -6, -4, -8, -9],
-        [-2, -5, -2, -7, -3, -4, -3, -6, -2, -5, -2, -7, -3, -4, -3, -6]]
+        [-2, -5, -2, -7, -3, -4, -3, -6, -2, -5, -2, -7, -3, -4, -3, -6],
+    ]
 
 
 def test_convert_to_NFG3(third_hgg):
@@ -840,52 +1681,367 @@ def test_convert_to_NFG3(third_hgg):
         [158, 54, 101, 11, 93, 108, 36, 65, 177, 92, 93, 92, 147, 62, 63, 62],
         [51, 97, 51, 97, 98, 83, 98, 83, 90, 1, 90, 1, 2, 47, 2, 47],
         [10, 88, 72, 47, 10, 88, 72, 47, 13, 24, 42, 72, 13, 24, 42, 72],
-        [19, 52, 86, 16, 30, 122, 97, 86, 153, 101, 161, 193, 146, 69, 154,
-         161]]
+        [19, 52, 86, 16, 30, 122, 97, 86, 153, 101, 161, 193, 146, 69, 154, 161],
+    ]
 
 
 def test_convert_to_NFG4(degen_hgg):
     new_nfg = degen_hgg.convert_to_NFG()
     assert new_nfg.players_actions == degen_hgg.players_actions
     assert new_nfg.utilities == [
-        [-8, -4, -6, -15, -11, -13, -12, -8, -10, -13, -13, -9, -11, -11, -7,
-         -14, -14, -10, -7, -6, -3, -16, -15, -12, -11, -10, -7, -10, -9, -12,
-         -9, -8, -11, -11, -10, -13, -9, -17, -13, -5, -13, -9, -7, -15, -11,
-         -11, -6, -9, -17, -12, -15, -19, -14, -17, -15, -10, -16, -10, -5,
-         -11, -11, -6, -12, -11, -8, -10, -16, -13, -15, -9, -6, -8, -9, -12,
-         -12, -5, -8, -8, -9, -12, -12],
-        [-14, -14, -11, -11, -17, -20, -11, -12, -9, -21, -20, -13, -6, -15,
-         -13, -15, -17, -12, -13, -12, -15, -15, -21, -19, -16, -19, -22, -25,
-         -17, -16, -15, -13, -18, -18, -11, -10, -27, -12, -19, -15, -10, -22,
-         -16, -4, -13, -23, -23, -23, -17, -24, -19, -18, -22, -22, -16, -15,
-         -13, -14, -19, -23, -19, -19, -17, -24, -16, -12, -10, -12, -13, -18,
-         -13, -11, -16, -15, -18, -10, -16, -14, -12, -15, -18],
-        [-15, -7, -14, -10, -15, -14, -13, -12, -15, -5, -7, -5, -6, -3, -4,
-         -13, -9, -13, -14, -12, -10, -7, -12, -7, -17, -18, -18, -16, -8, -15,
-         -11, -16, -15, -17, -16, -19, -6, -8, -6, -8, -5, -6, -13, -9, -13,
-         -12, -10, -8, -10, -15, -10, -18, -19, -19, -13, -5, -12, -6, -11,
-         -10, -12, -11, -14, -6, -8, -6, -15, -12, -13, -10, -6, -10, -11, -9,
-         -7, -10, -15, -10, -11, -12, -12],
-        [-12, -10, -7, -13, -10, -9, -17, -16, -8, -15, -15, -4, -10, -9, -10,
-         -12, -13, -5, -7, -6, -17, -10, -11, -11, -9, -8, -10, -5, -6, -12,
-         -6, -6, -14, -10, -12, -13, -9, -14, -4, -4, -8, -10, -6, -12, -5, -5,
-         -13, -18, -8, -18, -12, -7, -15, -11, -6, -2, -8, -7, -2, -10, -11,
-         -8, -9, -8, -11, -8, -3, -5, -14, -5, -9, -9, -11, -14, -13, -14, -19,
-         -7, -13, -16, -6]]
+        [
+            -8,
+            -4,
+            -6,
+            -15,
+            -11,
+            -13,
+            -12,
+            -8,
+            -10,
+            -13,
+            -13,
+            -9,
+            -11,
+            -11,
+            -7,
+            -14,
+            -14,
+            -10,
+            -7,
+            -6,
+            -3,
+            -16,
+            -15,
+            -12,
+            -11,
+            -10,
+            -7,
+            -10,
+            -9,
+            -12,
+            -9,
+            -8,
+            -11,
+            -11,
+            -10,
+            -13,
+            -9,
+            -17,
+            -13,
+            -5,
+            -13,
+            -9,
+            -7,
+            -15,
+            -11,
+            -11,
+            -6,
+            -9,
+            -17,
+            -12,
+            -15,
+            -19,
+            -14,
+            -17,
+            -15,
+            -10,
+            -16,
+            -10,
+            -5,
+            -11,
+            -11,
+            -6,
+            -12,
+            -11,
+            -8,
+            -10,
+            -16,
+            -13,
+            -15,
+            -9,
+            -6,
+            -8,
+            -9,
+            -12,
+            -12,
+            -5,
+            -8,
+            -8,
+            -9,
+            -12,
+            -12,
+        ],
+        [
+            -14,
+            -14,
+            -11,
+            -11,
+            -17,
+            -20,
+            -11,
+            -12,
+            -9,
+            -21,
+            -20,
+            -13,
+            -6,
+            -15,
+            -13,
+            -15,
+            -17,
+            -12,
+            -13,
+            -12,
+            -15,
+            -15,
+            -21,
+            -19,
+            -16,
+            -19,
+            -22,
+            -25,
+            -17,
+            -16,
+            -15,
+            -13,
+            -18,
+            -18,
+            -11,
+            -10,
+            -27,
+            -12,
+            -19,
+            -15,
+            -10,
+            -22,
+            -16,
+            -4,
+            -13,
+            -23,
+            -23,
+            -23,
+            -17,
+            -24,
+            -19,
+            -18,
+            -22,
+            -22,
+            -16,
+            -15,
+            -13,
+            -14,
+            -19,
+            -23,
+            -19,
+            -19,
+            -17,
+            -24,
+            -16,
+            -12,
+            -10,
+            -12,
+            -13,
+            -18,
+            -13,
+            -11,
+            -16,
+            -15,
+            -18,
+            -10,
+            -16,
+            -14,
+            -12,
+            -15,
+            -18,
+        ],
+        [
+            -15,
+            -7,
+            -14,
+            -10,
+            -15,
+            -14,
+            -13,
+            -12,
+            -15,
+            -5,
+            -7,
+            -5,
+            -6,
+            -3,
+            -4,
+            -13,
+            -9,
+            -13,
+            -14,
+            -12,
+            -10,
+            -7,
+            -12,
+            -7,
+            -17,
+            -18,
+            -18,
+            -16,
+            -8,
+            -15,
+            -11,
+            -16,
+            -15,
+            -17,
+            -16,
+            -19,
+            -6,
+            -8,
+            -6,
+            -8,
+            -5,
+            -6,
+            -13,
+            -9,
+            -13,
+            -12,
+            -10,
+            -8,
+            -10,
+            -15,
+            -10,
+            -18,
+            -19,
+            -19,
+            -13,
+            -5,
+            -12,
+            -6,
+            -11,
+            -10,
+            -12,
+            -11,
+            -14,
+            -6,
+            -8,
+            -6,
+            -15,
+            -12,
+            -13,
+            -10,
+            -6,
+            -10,
+            -11,
+            -9,
+            -7,
+            -10,
+            -15,
+            -10,
+            -11,
+            -12,
+            -12,
+        ],
+        [
+            -12,
+            -10,
+            -7,
+            -13,
+            -10,
+            -9,
+            -17,
+            -16,
+            -8,
+            -15,
+            -15,
+            -4,
+            -10,
+            -9,
+            -10,
+            -12,
+            -13,
+            -5,
+            -7,
+            -6,
+            -17,
+            -10,
+            -11,
+            -11,
+            -9,
+            -8,
+            -10,
+            -5,
+            -6,
+            -12,
+            -6,
+            -6,
+            -14,
+            -10,
+            -12,
+            -13,
+            -9,
+            -14,
+            -4,
+            -4,
+            -8,
+            -10,
+            -6,
+            -12,
+            -5,
+            -5,
+            -13,
+            -18,
+            -8,
+            -18,
+            -12,
+            -7,
+            -15,
+            -11,
+            -6,
+            -2,
+            -8,
+            -7,
+            -2,
+            -10,
+            -11,
+            -8,
+            -9,
+            -8,
+            -11,
+            -8,
+            -3,
+            -5,
+            -14,
+            -5,
+            -9,
+            -9,
+            -11,
+            -14,
+            -13,
+            -14,
+            -19,
+            -7,
+            -13,
+            -16,
+            -6,
+        ],
+    ]
 
 
 def test_convert_to_HGG1():
     players_actions = [[0, 1], [0, 1], [0, 1]]
-    utilities = [[-3, -7, -7, -10, -1, -5, -5, -9],
-                 [-3, -7, -1, -5, -7, -10, -5, -9],
-                 [-3, -1, -7, -5, -7, -5, -10, -9]]
+    utilities = [
+        [-3, -7, -7, -10, -1, -5, -5, -9],
+        [-3, -7, -1, -5, -7, -10, -5, -9],
+        [-3, -1, -7, -5, -7, -5, -10, -9],
+    ]
     nfg = NFG(players_actions, utilities)
     new_hgg = HGG.convert_to_HGG(nfg)
     assert new_hgg.players_actions == nfg.players_actions
     assert new_hgg.hypergraph == [[0, 1, 2]]
     assert new_hgg.utilities == [
-        [[-3, -7, -7, -10, -1, -5, -5, -9], [-3, -7, -1, -5, -7, -10, -5, -9],
-         [-3, -1, -7, -5, -7, -5, -10, -9]]]
+        [
+            [-3, -7, -7, -10, -1, -5, -5, -9],
+            [-3, -7, -1, -5, -7, -10, -5, -9],
+            [-3, -1, -7, -5, -7, -5, -10, -9],
+        ]
+    ]
 
 
 def test_convert_to_HGG2():
@@ -894,16 +2050,20 @@ def test_convert_to_HGG2():
         [51, 29, 47, 43, 75, 61, 42, 19, 28, 39, 40, 21, 60, 60, 67, 44],
         [58, 72, 31, 41, 37, 5, 37, 41, 53, 68, 38, 30, 58, 72, 75, 0],
         [29, 73, 42, 13, 34, 31, 54, 25, 47, 29, 19, 46, 85, 79, 65, 24],
-        [1, 17, 49, 9, 51, 25, 21, 49, 28, 77, 41, 69, 13, 100, 49, 27]]
+        [1, 17, 49, 9, 51, 25, 21, 49, 28, 77, 41, 69, 13, 100, 49, 27],
+    ]
     nfg = NFG(players_actions, utilities)
     new_hgg = HGG.convert_to_HGG(nfg)
     assert new_hgg.players_actions == nfg.players_actions
     assert new_hgg.hypergraph == [[0, 1, 2, 3]]
     assert new_hgg.utilities == [
-        [[51, 29, 47, 43, 75, 61, 42, 19, 28, 39, 40, 21, 60, 60, 67, 44],
-         [58, 72, 31, 41, 37, 5, 37, 41, 53, 68, 38, 30, 58, 72, 75, 0],
-         [29, 73, 42, 13, 34, 31, 54, 25, 47, 29, 19, 46, 85, 79, 65, 24],
-         [1, 17, 49, 9, 51, 25, 21, 49, 28, 77, 41, 69, 13, 100, 49, 27]]]
+        [
+            [51, 29, 47, 43, 75, 61, 42, 19, 28, 39, 40, 21, 60, 60, 67, 44],
+            [58, 72, 31, 41, 37, 5, 37, 41, 53, 68, 38, 30, 58, 72, 75, 0],
+            [29, 73, 42, 13, 34, 31, 54, 25, 47, 29, 19, 46, 85, 79, 65, 24],
+            [1, 17, 49, 9, 51, 25, 21, 49, 28, 77, 41, 69, 13, 100, 49, 27],
+        ]
+    ]
 
 
 def test_game_as_int(first_hgg_fraction, first_hgg):
@@ -915,31 +2075,43 @@ def test_read_GameFile1():
     read_hgg = HGG.read_GameFile("filestest/CovG_0.hgg")
     assert read_hgg.players_actions == [[0, 1], [0, 1], [0, 1], [0, 1]]
     assert read_hgg.hypergraph == [[0, 1, 3], [1, 2, 3]]
-    assert read_hgg.utilities == [[[100, 33, 31, 40, 35, 52, 40, 30],
-                                   [25, 34, 18, 47, 54, 30, 52, 44],
-                                   [67, 34, 17, 0, 66, 37, 46, 33]],
-                                  [[31, 70, 11, 59, 70, 78, 66, 52],
-                                   [6, 87, 58, 42, 68, 92, 52, 51],
-                                   [71, 65, 6, 74, 95, 59, 100, 0]]]
+    assert read_hgg.utilities == [
+        [
+            [100, 33, 31, 40, 35, 52, 40, 30],
+            [25, 34, 18, 47, 54, 30, 52, 44],
+            [67, 34, 17, 0, 66, 37, 46, 33],
+        ],
+        [
+            [31, 70, 11, 59, 70, 78, 66, 52],
+            [6, 87, 58, 42, 68, 92, 52, 51],
+            [71, 65, 6, 74, 95, 59, 100, 0],
+        ],
+    ]
 
 
 def test_read_GameFile2():
     read_hgg = HGG.read_GameFile("filestest/pileface.hgg")
     assert read_hgg.players_actions == [[0, 1], [0, 1], [0, 1], [0, 1]]
     assert read_hgg.hypergraph == [[1, 2, 3], [0, 2], [0, 1]]
-    assert read_hgg.utilities == [[[0, -1, -1, -2, 2, 1, 1, 0],
-                                   [0, -1, 2, 1, -1, -2, 1, 0],
-                                   [0, 2, -1, 1, -1, 1, -2, 0]],
-                                  [[0, -1, 1, 0], [0, 1, -1, 0]],
-                                  [[0, -1, 1, 0], [0, 1, -1, 0]]]
+    assert read_hgg.utilities == [
+        [
+            [0, -1, -1, -2, 2, 1, 1, 0],
+            [0, -1, 2, 1, -1, -2, 1, 0],
+            [0, 2, -1, 1, -1, 1, -2, 0],
+        ],
+        [[0, -1, 1, 0], [0, 1, -1, 0]],
+        [[0, -1, 1, 0], [0, 1, -1, 0]],
+    ]
 
 
 def test_read_GameFile3():
     read_hgg = HGG.read_GameFile("filestest/DDP_poly.hgg")
     assert read_hgg.players_actions == [[0, 1], [0, 1], [0, 1]]
     assert read_hgg.hypergraph == [[1, 2], [0, 1]]
-    assert read_hgg.utilities == [[[-1, -5, 0, -3], [-1, 0, -5, -3]],
-                                  [[-1, -4, 0, -3], [-1, 0, -4, -3]]]
+    assert read_hgg.utilities == [
+        [[-1, -5, 0, -3], [-1, 0, -5, -3]],
+        [[-1, -4, 0, -3], [-1, 0, -4, -3]],
+    ]
 
 
 def test_write_GameFile1(first_hgg):
diff --git a/test/test_irda.py b/test/test_irda.py
index 46b627c..4552a26 100644
--- a/test/test_irda.py
+++ b/test/test_irda.py
@@ -10,11 +10,15 @@ import pytest
 @pytest.fixture
 def hgg1():
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
-    utilities = [[[-3, -1, -3, -2, -2, -3, -2, -1],
-                  [-2, -4, -6, -2, -2, -7, -4, -5],
-                  [-2, -3, -6, -4, -3, -1, -3, -4]],
-                 [[-1, -3, -2, -2], [-2, -3, -3, -2]],
-                 [[-3, -1, -4, -5], [-1, -3, -1, -5]]]
+    utilities = [
+        [
+            [-3, -1, -3, -2, -2, -3, -2, -1],
+            [-2, -4, -6, -2, -2, -7, -4, -5],
+            [-2, -3, -6, -4, -3, -1, -3, -4],
+        ],
+        [[-1, -3, -2, -2], [-2, -3, -3, -2]],
+        [[-3, -1, -4, -5], [-1, -3, -1, -5]],
+    ]
     hypergraph = [[0, 1, 2], [1, 3], [2, 3]]
     return HGG(players_actions, utilities, hypergraph)
 
@@ -23,10 +27,17 @@ def hgg1():
 def hgg2():
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
     utilities = [
-        [[87, 77, 0, 49, 63, 99, 98, 25], [76, 100, 10, 43, 73, 65, 8, 56],
-         [8, 36, 3, 100, 24, 3, 64, 28]],
-        [[67, 38, 60, 64, 55, 100, 16, 13], [23, 59, 0, 9, 1, 8, 47, 33],
-         [9, 7, 100, 39, 16, 18, 16, 62]]]
+        [
+            [87, 77, 0, 49, 63, 99, 98, 25],
+            [76, 100, 10, 43, 73, 65, 8, 56],
+            [8, 36, 3, 100, 24, 3, 64, 28],
+        ],
+        [
+            [67, 38, 60, 64, 55, 100, 16, 13],
+            [23, 59, 0, 9, 1, 8, 47, 33],
+            [9, 7, 100, 39, 16, 18, 16, 62],
+        ],
+    ]
     hypergraph = [[0, 1, 2], [1, 2, 3]]
     return HGG(players_actions, utilities, hypergraph)
 
@@ -35,10 +46,17 @@ def hgg2():
 def hgg3():
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
     utilities = [
-        [[29, 39, 100, 46, 40, 18, 97, 37], [23, 81, 64, 62, 90, 73, 76, 53],
-         [26, 36, 51, 5, 14, 99, 0, 54]],
-        [[12, 37, 7, 7, 41, 59, 27, 86], [65, 100, 100, 49, 97, 31, 68, 58],
-         [29, 70, 44, 61, 0, 53, 92, 74]]]
+        [
+            [29, 39, 100, 46, 40, 18, 97, 37],
+            [23, 81, 64, 62, 90, 73, 76, 53],
+            [26, 36, 51, 5, 14, 99, 0, 54],
+        ],
+        [
+            [12, 37, 7, 7, 41, 59, 27, 86],
+            [65, 100, 100, 49, 97, 31, 68, 58],
+            [29, 70, 44, 61, 0, 53, 92, 74],
+        ],
+    ]
     hypergraph = [[0, 2, 3], [1, 2, 3]]
     return HGG(players_actions, utilities, hypergraph)
 
@@ -46,9 +64,11 @@ def hgg3():
 @pytest.fixture
 def nfg1():
     players_actions = [[0, 1], [0, 1], [0, 1]]
-    utilities = [[37, 63, 100, 69, 46, 60, 47, 41],
-                 [24, 14, 79, 75, 100, 70, 34, 0],
-                 [90, 34, 25, 25, 33, 68, 70, 3]]
+    utilities = [
+        [37, 63, 100, 69, 46, 60, 47, 41],
+        [24, 14, 79, 75, 100, 70, 34, 0],
+        [90, 34, 25, 25, 33, 68, 70, 3],
+    ]
     return NFG(players_actions, utilities)
 
 
@@ -58,22 +78,47 @@ def three_bg():
     theta = [[0, 1], [0, 1], [0, 1]]
     all_p = [1, 2, 1, 4, 2, 2, 2, 6]
     utilities = [
-        [[87, 56, 33, 21, 88, 77, 79, 69], [39, 52, 4, 92, 1, 78, 60, 69],
-         [2, 28, 92, 11, 16, 63, 21, 22]],
-        [[97, 12, 13, 92, 38, 2, 91, 62], [32, 40, 10, 57, 19, 18, 19, 15],
-         [35, 12, 0, 56, 93, 22, 52, 35]],
-        [[67, 0, 13, 87, 83, 6, 1, 80], [27, 63, 31, 22, 18, 8, 46, 81],
-         [88, 28, 35, 5, 52, 67, 21, 12]],
-        [[76, 13, 70, 36, 8, 39, 22, 42], [43, 82, 81, 37, 70, 58, 28, 91],
-         [13, 25, 6, 96, 31, 27, 5, 37]],
-        [[42, 62, 83, 91, 62, 11, 19, 0], [33, 88, 78, 14, 90, 27, 40, 86],
-         [29, 91, 63, 65, 78, 36, 3, 35]],
-        [[78, 51, 25, 64, 84, 53, 19, 30], [94, 8, 47, 52, 17, 89, 21, 54],
-         [39, 13, 7, 46, 4, 14, 46, 3]],
-        [[21, 33, 41, 4, 40, 5, 47, 13], [72, 6, 92, 29, 73, 54, 22, 30],
-         [23, 86, 14, 46, 99, 34, 62, 97]],
-        [[69, 11, 25, 65, 82, 52, 68, 56], [33, 12, 39, 98, 41, 63, 99, 10],
-         [18, 62, 99, 58, 62, 25, 55, 7]]]
+        [
+            [87, 56, 33, 21, 88, 77, 79, 69],
+            [39, 52, 4, 92, 1, 78, 60, 69],
+            [2, 28, 92, 11, 16, 63, 21, 22],
+        ],
+        [
+            [97, 12, 13, 92, 38, 2, 91, 62],
+            [32, 40, 10, 57, 19, 18, 19, 15],
+            [35, 12, 0, 56, 93, 22, 52, 35],
+        ],
+        [
+            [67, 0, 13, 87, 83, 6, 1, 80],
+            [27, 63, 31, 22, 18, 8, 46, 81],
+            [88, 28, 35, 5, 52, 67, 21, 12],
+        ],
+        [
+            [76, 13, 70, 36, 8, 39, 22, 42],
+            [43, 82, 81, 37, 70, 58, 28, 91],
+            [13, 25, 6, 96, 31, 27, 5, 37],
+        ],
+        [
+            [42, 62, 83, 91, 62, 11, 19, 0],
+            [33, 88, 78, 14, 90, 27, 40, 86],
+            [29, 91, 63, 65, 78, 36, 3, 35],
+        ],
+        [
+            [78, 51, 25, 64, 84, 53, 19, 30],
+            [94, 8, 47, 52, 17, 89, 21, 54],
+            [39, 13, 7, 46, 4, 14, 46, 3],
+        ],
+        [
+            [21, 33, 41, 4, 40, 5, 47, 13],
+            [72, 6, 92, 29, 73, 54, 22, 30],
+            [23, 86, 14, 46, 99, 34, 62, 97],
+        ],
+        [
+            [69, 11, 25, 65, 82, 52, 68, 56],
+            [33, 12, 39, 98, 41, 63, 99, 10],
+            [18, 62, 99, 58, 62, 25, 55, 7],
+        ],
+    ]
     return BG(players_actions, utilities, theta, all_p)
 
 
@@ -81,54 +126,92 @@ def three_bg():
 def bayesian_hgg1():
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
     theta = [[0, 1], [0, 1], [0, 1], [0, 1]]
-    utilities = [[[[39, 19, 95, 0, 32, 97, 65, 69],
-                   [22, 40, 67, 14, 100, 60, 5, 34],
-                   [46, 27, 72, 45, 18, 84, 100, 33]],
-                  [[61, 96, 22, 34, 34, 35, 39, 54],
-                   [39, 42, 77, 76, 27, 45, 56, 0],
-                   [21, 94, 80, 74, 100, 20, 55, 65]],
-                  [[34, 47, 56, 73, 55, 59, 31, 17],
-                   [57, 43, 0, 23, 41, 100, 73, 86],
-                   [24, 53, 95, 45, 38, 17, 28, 76]],
-                  [[47, 37, 100, 6, 20, 16, 17, 59],
-                   [40, 44, 64, 13, 0, 73, 76, 71],
-                   [23, 52, 19, 70, 41, 43, 30, 28]],
-                  [[53, 38, 44, 33, 9, 71, 31, 82],
-                   [62, 100, 70, 65, 74, 22, 47, 59],
-                   [66, 82, 20, 0, 15, 3, 57, 60]],
-                  [[46, 33, 0, 31, 50, 50, 35, 50],
-                   [26, 77, 56, 47, 37, 51, 56, 57],
-                   [28, 27, 100, 21, 29, 26, 83, 25]],
-                  [[70, 88, 0, 15, 7, 34, 100, 58],
-                   [53, 68, 17, 17, 16, 26, 84, 61],
-                   [63, 80, 10, 15, 11, 43, 84, 50]],
-                  [[91, 49, 99, 85, 62, 38, 21, 87],
-                   [18, 36, 74, 84, 40, 45, 39, 88],
-                   [63, 54, 57, 100, 45, 20, 0, 76]]],
-                 [[[72, 67, 47, 94, 73, 92, 80, 81],
-                   [55, 66, 45, 62, 78, 91, 55, 53],
-                   [54, 75, 47, 42, 0, 52, 47, 100]],
-                  [[64, 79, 39, 7, 43, 22, 68, 26],
-                   [48, 67, 62, 5, 74, 82, 77, 65],
-                   [40, 65, 38, 0, 59, 69, 100, 86]],
-                  [[44, 53, 46, 82, 44, 89, 69, 97],
-                   [61, 96, 88, 93, 70, 20, 100, 46],
-                   [31, 89, 0, 61, 48, 77, 84, 46]],
-                  [[59, 74, 63, 100, 34, 31, 38, 45],
-                   [55, 52, 83, 74, 10, 65, 5, 50],
-                   [74, 64, 65, 96, 19, 70, 0, 38]],
-                  [[32, 100, 0, 54, 5, 37, 45, 66],
-                   [2, 23, 49, 3, 62, 21, 23, 44],
-                   [11, 54, 67, 8, 37, 69, 83, 27]],
-                  [[41, 67, 72, 12, 65, 74, 65, 53],
-                   [68, 68, 57, 49, 0, 91, 80, 61],
-                   [97, 78, 86, 100, 34, 62, 57, 87]],
-                  [[52, 54, 63, 18, 37, 67, 75, 73],
-                   [47, 65, 93, 91, 59, 60, 0, 43],
-                   [82, 76, 49, 91, 100, 82, 95, 50]],
-                  [[39, 19, 95, 0, 32, 97, 65, 69],
-                   [22, 40, 67, 14, 100, 60, 5, 34],
-                   [46, 27, 72, 45, 18, 84, 100, 33]]]]
+    utilities = [
+        [
+            [
+                [39, 19, 95, 0, 32, 97, 65, 69],
+                [22, 40, 67, 14, 100, 60, 5, 34],
+                [46, 27, 72, 45, 18, 84, 100, 33],
+            ],
+            [
+                [61, 96, 22, 34, 34, 35, 39, 54],
+                [39, 42, 77, 76, 27, 45, 56, 0],
+                [21, 94, 80, 74, 100, 20, 55, 65],
+            ],
+            [
+                [34, 47, 56, 73, 55, 59, 31, 17],
+                [57, 43, 0, 23, 41, 100, 73, 86],
+                [24, 53, 95, 45, 38, 17, 28, 76],
+            ],
+            [
+                [47, 37, 100, 6, 20, 16, 17, 59],
+                [40, 44, 64, 13, 0, 73, 76, 71],
+                [23, 52, 19, 70, 41, 43, 30, 28],
+            ],
+            [
+                [53, 38, 44, 33, 9, 71, 31, 82],
+                [62, 100, 70, 65, 74, 22, 47, 59],
+                [66, 82, 20, 0, 15, 3, 57, 60],
+            ],
+            [
+                [46, 33, 0, 31, 50, 50, 35, 50],
+                [26, 77, 56, 47, 37, 51, 56, 57],
+                [28, 27, 100, 21, 29, 26, 83, 25],
+            ],
+            [
+                [70, 88, 0, 15, 7, 34, 100, 58],
+                [53, 68, 17, 17, 16, 26, 84, 61],
+                [63, 80, 10, 15, 11, 43, 84, 50],
+            ],
+            [
+                [91, 49, 99, 85, 62, 38, 21, 87],
+                [18, 36, 74, 84, 40, 45, 39, 88],
+                [63, 54, 57, 100, 45, 20, 0, 76],
+            ],
+        ],
+        [
+            [
+                [72, 67, 47, 94, 73, 92, 80, 81],
+                [55, 66, 45, 62, 78, 91, 55, 53],
+                [54, 75, 47, 42, 0, 52, 47, 100],
+            ],
+            [
+                [64, 79, 39, 7, 43, 22, 68, 26],
+                [48, 67, 62, 5, 74, 82, 77, 65],
+                [40, 65, 38, 0, 59, 69, 100, 86],
+            ],
+            [
+                [44, 53, 46, 82, 44, 89, 69, 97],
+                [61, 96, 88, 93, 70, 20, 100, 46],
+                [31, 89, 0, 61, 48, 77, 84, 46],
+            ],
+            [
+                [59, 74, 63, 100, 34, 31, 38, 45],
+                [55, 52, 83, 74, 10, 65, 5, 50],
+                [74, 64, 65, 96, 19, 70, 0, 38],
+            ],
+            [
+                [32, 100, 0, 54, 5, 37, 45, 66],
+                [2, 23, 49, 3, 62, 21, 23, 44],
+                [11, 54, 67, 8, 37, 69, 83, 27],
+            ],
+            [
+                [41, 67, 72, 12, 65, 74, 65, 53],
+                [68, 68, 57, 49, 0, 91, 80, 61],
+                [97, 78, 86, 100, 34, 62, 57, 87],
+            ],
+            [
+                [52, 54, 63, 18, 37, 67, 75, 73],
+                [47, 65, 93, 91, 59, 60, 0, 43],
+                [82, 76, 49, 91, 100, 82, 95, 50],
+            ],
+            [
+                [39, 19, 95, 0, 32, 97, 65, 69],
+                [22, 40, 67, 14, 100, 60, 5, 34],
+                [46, 27, 72, 45, 18, 84, 100, 33],
+            ],
+        ],
+    ]
     p = [[6, 9, 8, 6, 6, 4, 3, 3], [1, 7, 9, 1, 7, 3, 6, 9]]
     hypergraph = [[0, 1, 2], [0, 2, 3]]
     return BHGG(players_actions, utilities, hypergraph, theta, p)
@@ -156,11 +239,15 @@ def test_irda1(hgg1):
     red_hgg, z_excluded = irda(hgg1)
     assert z_excluded == [(3, 1)]
     assert red_hgg.players_actions == [[0, 1], [0, 1], [0, 1], [0]]
-    assert red_hgg.utilities == [[[-3, -1, -3, -2, -2, -3, -2, -1],
-                                  [-2, -4, -6, -2, -2, -7, -4, -5],
-                                  [-2, -3, -6, -4, -3, -1, -3, -4]],
-                                 [[-1, -2], [-2, -3]],
-                                 [[-3, -4], [-1, -1]]]
+    assert red_hgg.utilities == [
+        [
+            [-3, -1, -3, -2, -2, -3, -2, -1],
+            [-2, -4, -6, -2, -2, -7, -4, -5],
+            [-2, -3, -6, -4, -3, -1, -3, -4],
+        ],
+        [[-1, -2], [-2, -3]],
+        [[-3, -4], [-1, -1]],
+    ]
 
 
 def test_irda2(hgg2):
@@ -169,7 +256,8 @@ def test_irda2(hgg2):
     assert red_hgg.players_actions == [[0, 1], [0], [0, 1], [0]]
     assert red_hgg.utilities == [
         [[87, 77, 63, 99], [76, 100, 73, 65], [8, 36, 24, 3]],
-        [[67, 60], [23, 0], [9, 100]]]
+        [[67, 60], [23, 0], [9, 100]],
+    ]
 
 
 def test_irda3(hgg3):
@@ -177,9 +265,13 @@ def test_irda3(hgg3):
     assert set(z_excluded) == {(1, 0)}
     assert red_hgg.players_actions == [[0, 1], [1], [0, 1], [0, 1]]
     assert red_hgg.utilities == [
-        [[29, 39, 100, 46, 40, 18, 97, 37], [23, 81, 64, 62, 90, 73, 76, 53],
-         [26, 36, 51, 5, 14, 99, 0, 54]],
-        [[41, 59, 27, 86], [97, 31, 68, 58], [0, 53, 92, 74]]]
+        [
+            [29, 39, 100, 46, 40, 18, 97, 37],
+            [23, 81, 64, 62, 90, 73, 76, 53],
+            [26, 36, 51, 5, 14, 99, 0, 54],
+        ],
+        [[41, 59, 27, 86], [97, 31, 68, 58], [0, 53, 92, 74]],
+    ]
 
 
 def test_irda4(nfg1):
@@ -193,8 +285,7 @@ def test_irda5(three_bg):
     tmp_hgg = three_bg.convert_to_HGG()[0]
     red_hgg, z_excluded = irda(tmp_hgg)
     assert set(z_excluded) == set([])
-    assert red_hgg.players_actions == \
-        [[0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1]]
+    assert red_hgg.players_actions == [[0, 1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1]]
     assert red_hgg.utilities == tmp_hgg.utilities
 
 
@@ -202,6 +293,14 @@ def test_irda6(bayesian_hgg1):
     tmp_hgg = bayesian_hgg1.convert_to_HGG()[0]
     red_hgg, z_excluded = irda(tmp_hgg)
     assert set(z_excluded) == set([])
-    assert red_hgg.players_actions == [[0, 1], [0, 1], [0, 1], [0, 1], [0, 1],
-                                       [0, 1], [0, 1], [0, 1], ]
+    assert red_hgg.players_actions == [
+        [0, 1],
+        [0, 1],
+        [0, 1],
+        [0, 1],
+        [0, 1],
+        [0, 1],
+        [0, 1],
+        [0, 1],
+    ]
     assert red_hgg.utilities == tmp_hgg.utilities
diff --git a/test/test_lh_polymatrix.py b/test/test_lh_polymatrix.py
index eaac248..d70b5c4 100644
--- a/test/test_lh_polymatrix.py
+++ b/test/test_lh_polymatrix.py
@@ -10,8 +10,11 @@ from fractions import Fraction
 
 @pytest.fixture
 def polym_3p():
-    utilities = [[[2, 0, 3, 4], [0, 1, 5, 4]], [[3, 5, 1, 4], [4, 1, 1, 2]],
-                 [[3, 2, 6, 7], [6, 5, 0, 3]]]
+    utilities = [
+        [[2, 0, 3, 4], [0, 1, 5, 4]],
+        [[3, 5, 1, 4], [4, 1, 1, 2]],
+        [[3, 2, 6, 7], [6, 5, 0, 3]],
+    ]
     hypergraph = [[0, 1], [0, 2], [1, 2]]
     players_actions = [[0, 1], [0, 1], [0, 1]]
     return LHpolymatrix(PMG(players_actions, utilities, hypergraph))
@@ -21,20 +24,31 @@ def polym_3p():
 def bayesian_polymatrix():
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
     theta = [[0, 1], [0, 1], [0, 1], [0, 1]]
-    same_game = [[[3, 0, 0, 2], [3, 0, 0, 2]], [[3, 0, 0, 2], [1, 0, 0, 2]],
-                 [[1, 0, 0, 2], [3, 0, 0, 2]], [[1, 0, 0, 2], [1, 0, 0, 2]]]
+    same_game = [
+        [[3, 0, 0, 2], [3, 0, 0, 2]],
+        [[3, 0, 0, 2], [1, 0, 0, 2]],
+        [[1, 0, 0, 2], [3, 0, 0, 2]],
+        [[1, 0, 0, 2], [1, 0, 0, 2]],
+    ]
     same_p = [4, 1, 1, 4]
     hypergr = [[0, 1], [1, 2], [2, 3], [0, 3]]
-    bhgg = BHGG(players_actions, [same_game, same_game, same_game, same_game],
-                hypergr, theta, [same_p, same_p, same_p, same_p])
+    bhgg = BHGG(
+        players_actions,
+        [same_game, same_game, same_game, same_game],
+        hypergr,
+        theta,
+        [same_p, same_p, same_p, same_p],
+    )
     return LHpolymatrix(bhgg.convert_to_HGG()[0])
 
 
 @pytest.fixture
 def polym_3p3a():
-    utilities = [[[8, 2, 5, 5, 1, 7, 1, 5, 1], [4, 1, 4, 5, 6, 2, 4, 7, 3]],
-                 [[2, 2, 4, 7, 9, 4, 5, 5, 5], [2, 5, 4, 7, 1, 5, 2, 1, 6]],
-                 [[9, 3, 4, 9, 5, 5, 9, 5, 4], [8, 8, 6, 9, 1, 4, 9, 1, 3]]]
+    utilities = [
+        [[8, 2, 5, 5, 1, 7, 1, 5, 1], [4, 1, 4, 5, 6, 2, 4, 7, 3]],
+        [[2, 2, 4, 7, 9, 4, 5, 5, 5], [2, 5, 4, 7, 1, 5, 2, 1, 6]],
+        [[9, 3, 4, 9, 5, 5, 9, 5, 4], [8, 8, 6, 9, 1, 4, 9, 1, 3]],
+    ]
     hypergraph = [[0, 1], [0, 2], [1, 2]]
     players_actions = [[0, 1, 2], [0, 1, 2], [0, 1, 2]]
     return LHpolymatrix(PMG(players_actions, utilities, hypergraph))
@@ -42,8 +56,7 @@ def polym_3p3a():
 
 @pytest.fixture
 def bimat_poly():
-    utilities = [[[0, 6, 2, 5, 3, 3],
-                  [1, 0, 0, 2, 4, 3]]]
+    utilities = [[[0, 6, 2, 5, 3, 3], [1, 0, 0, 2, 4, 3]]]
     hypergraph = [[0, 1]]
     players_actions = [[0, 1, 2], [0, 1]]
     return LHpolymatrix(PMG(players_actions, utilities, hypergraph))
@@ -55,8 +68,16 @@ def test_maxu_of_p1(polym_3p):
 
 
 def test_maxu_of_p2(bayesian_polymatrix):
-    assert bayesian_polymatrix.maxu_of_p == {0: 12, 1: 8, 2: 12, 3: 8, 4: 12,
-                                             5: 8, 6: 12, 7: 8}
+    assert bayesian_polymatrix.maxu_of_p == {
+        0: 12,
+        1: 8,
+        2: 12,
+        3: 8,
+        4: 12,
+        5: 8,
+        6: 12,
+        7: 8,
+    }
 
 
 def test_maxu_of_p3(polym_3p3a):
@@ -71,47 +92,82 @@ def test_all_utilities1(polym_3p):
     assert polym_3p.all_utilities == {
         0: {1: [[2, 0], [3, 4]], 2: [[3, 5], [1, 4]]},
         1: {0: [[0, 5], [1, 4]], 2: [[3, 2], [6, 7]]},
-        2: {0: [[4, 1], [1, 2]], 1: [[6, 0], [5, 3]]}}
+        2: {0: [[4, 1], [1, 2]], 1: [[6, 0], [5, 3]]},
+    }
 
 
 def test_all_utilities2(polym_3p3a):
     assert polym_3p3a.all_utilities == {
-        0: {1: [[8, 2, 5], [5, 1, 7], [1, 5, 1]],
-            2: [[2, 2, 4], [7, 9, 4], [5, 5, 5]]},
-        1: {0: [[4, 5, 4], [1, 6, 7], [4, 2, 3]],
-            2: [[9, 3, 4], [9, 5, 5], [9, 5, 4]]},
-        2: {0: [[2, 7, 2], [5, 1, 1], [4, 5, 6]],
-            1: [[8, 9, 9], [8, 1, 1], [6, 4, 3]]}}
+        0: {1: [[8, 2, 5], [5, 1, 7], [1, 5, 1]], 2: [[2, 2, 4], [7, 9, 4], [5, 5, 5]]},
+        1: {0: [[4, 5, 4], [1, 6, 7], [4, 2, 3]], 2: [[9, 3, 4], [9, 5, 5], [9, 5, 4]]},
+        2: {0: [[2, 7, 2], [5, 1, 1], [4, 5, 6]], 1: [[8, 9, 9], [8, 1, 1], [6, 4, 3]]},
+    }
 
 
 def test_all_utilities3(bayesian_polymatrix):
     assert bayesian_polymatrix.all_utilities == {
-        0: {2: [[12, 0], [0, 8]], 3: [[3, 0], [0, 2]],
-            6: [[12, 0], [0, 8]], 7: [[3, 0], [0, 2]]},
-        1: {2: [[1, 0], [0, 2]], 3: [[4, 0], [0, 8]],
-            6: [[1, 0], [0, 2]], 7: [[4, 0], [0, 8]]},
-        2: {0: [[12, 0], [0, 8]], 1: [[3, 0], [0, 2]],
-            4: [[12, 0], [0, 8]], 5: [[3, 0], [0, 2]]},
-        3: {0: [[1, 0], [0, 2]], 1: [[4, 0], [0, 8]],
-            4: [[1, 0], [0, 2]], 5: [[4, 0], [0, 8]]},
-        4: {2: [[12, 0], [0, 8]], 3: [[3, 0], [0, 2]],
-            6: [[12, 0], [0, 8]], 7: [[3, 0], [0, 2]]},
-        5: {2: [[1, 0], [0, 2]], 3: [[4, 0], [0, 8]],
-            6: [[1, 0], [0, 2]], 7: [[4, 0], [0, 8]]},
-        6: {0: [[12, 0], [0, 8]], 1: [[3, 0], [0, 2]],
-            4: [[12, 0], [0, 8]], 5: [[3, 0], [0, 2]]},
-        7: {0: [[1, 0], [0, 2]], 1: [[4, 0], [0, 8]],
-            4: [[1, 0], [0, 2]], 5: [[4, 0], [0, 8]]}}
+        0: {
+            2: [[12, 0], [0, 8]],
+            3: [[3, 0], [0, 2]],
+            6: [[12, 0], [0, 8]],
+            7: [[3, 0], [0, 2]],
+        },
+        1: {
+            2: [[1, 0], [0, 2]],
+            3: [[4, 0], [0, 8]],
+            6: [[1, 0], [0, 2]],
+            7: [[4, 0], [0, 8]],
+        },
+        2: {
+            0: [[12, 0], [0, 8]],
+            1: [[3, 0], [0, 2]],
+            4: [[12, 0], [0, 8]],
+            5: [[3, 0], [0, 2]],
+        },
+        3: {
+            0: [[1, 0], [0, 2]],
+            1: [[4, 0], [0, 8]],
+            4: [[1, 0], [0, 2]],
+            5: [[4, 0], [0, 8]],
+        },
+        4: {
+            2: [[12, 0], [0, 8]],
+            3: [[3, 0], [0, 2]],
+            6: [[12, 0], [0, 8]],
+            7: [[3, 0], [0, 2]],
+        },
+        5: {
+            2: [[1, 0], [0, 2]],
+            3: [[4, 0], [0, 8]],
+            6: [[1, 0], [0, 2]],
+            7: [[4, 0], [0, 8]],
+        },
+        6: {
+            0: [[12, 0], [0, 8]],
+            1: [[3, 0], [0, 2]],
+            4: [[12, 0], [0, 8]],
+            5: [[3, 0], [0, 2]],
+        },
+        7: {
+            0: [[1, 0], [0, 2]],
+            1: [[4, 0], [0, 8]],
+            4: [[1, 0], [0, 2]],
+            5: [[4, 0], [0, 8]],
+        },
+    }
 
 
 def test_all_utilities4(bimat_poly):
-    assert bimat_poly.all_utilities == {0: {1: [[0, 6], [2, 5], [3, 3]]},
-                                        1: {0: [[1, 0, 4], [0, 2, 3]]}}
+    assert bimat_poly.all_utilities == {
+        0: {1: [[0, 6], [2, 5], [3, 3]]},
+        1: {0: [[1, 0, 4], [0, 2, 3]]},
+    }
 
 
 # def test_inverse_utilities(polym_3p):
 #     assert polym_3p.inverse_utilities == {}
 
+
 def test_tucker_schema0(polym_3p):
     assert (polym_3p.tucker == np.zeros((9, 10))).all()
 
@@ -130,41 +186,64 @@ def test_tucker_schema3(bimat_poly):
 
 def test_tucker_schema_meth1(polym_3p):
     polym_3p.tucker_schema()
-    assert (polym_3p.tucker == np.mat(
-        [[0, 0, 0, 4, 6, 3, 1, -1, 0, 0], [0, 0, 0, 3, 2, 5, 2, -1, 0, 0],
-         [0, 8, 3, 0, 0, 5, 6, 0, -1, 0], [0, 7, 4, 0, 0, 2, 1, 0, -1, 0],
-         [0, 3, 6, 1, 7, 0, 0, 0, 0, -1], [0, 6, 5, 2, 4, 0, 0, 0, 0, -1],
-         [-1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
-         [-1, 0, 0, 1, 1, 0, 0, 0, 0, 0],
-         [-1, 0, 0, 0, 0, 1, 1, 0, 0, 0]], dtype=float)).all()
+    assert (
+        polym_3p.tucker
+        == np.mat(
+            [
+                [0, 0, 0, 4, 6, 3, 1, -1, 0, 0],
+                [0, 0, 0, 3, 2, 5, 2, -1, 0, 0],
+                [0, 8, 3, 0, 0, 5, 6, 0, -1, 0],
+                [0, 7, 4, 0, 0, 2, 1, 0, -1, 0],
+                [0, 3, 6, 1, 7, 0, 0, 0, 0, -1],
+                [0, 6, 5, 2, 4, 0, 0, 0, 0, -1],
+                [-1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
+                [-1, 0, 0, 1, 1, 0, 0, 0, 0, 0],
+                [-1, 0, 0, 0, 0, 1, 1, 0, 0, 0],
+            ],
+            dtype=float,
+        )
+    ).all()
 
 
 def test_tucker_schema_meth2(polym_3p3a):
     polym_3p3a.tucker_schema()
-    assert (polym_3p3a.tucker == np.mat(
-        [[0, 0, 0, 0, 2, 8, 5, 8, 8, 6, -1, 0, 0],
-         [0, 0, 0, 0, 5, 9, 3, 3, 1, 6, -1, 0, 0],
-         [0, 0, 0, 0, 9, 5, 9, 5, 5, 5, -1, 0, 0],
-         [0, 6, 5, 6, 0, 0, 0, 1, 7, 6, 0, -1, 0],
-         [0, 9, 4, 3, 0, 0, 0, 1, 5, 5, 0, -1, 0],
-         [0, 6, 8, 7, 0, 0, 0, 1, 5, 6, 0, -1, 0],
-         [0, 8, 3, 8, 2, 1, 1, 0, 0, 0, 0, 0, -1],
-         [0, 5, 9, 9, 2, 9, 9, 0, 0, 0, 0, 0, -1],
-         [0, 6, 5, 4, 4, 6, 7, 0, 0, 0, 0, 0, -1],
-         [-1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-         [-1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0],
-         [-1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0], ])).all()
+    assert (
+        polym_3p3a.tucker
+        == np.mat(
+            [
+                [0, 0, 0, 0, 2, 8, 5, 8, 8, 6, -1, 0, 0],
+                [0, 0, 0, 0, 5, 9, 3, 3, 1, 6, -1, 0, 0],
+                [0, 0, 0, 0, 9, 5, 9, 5, 5, 5, -1, 0, 0],
+                [0, 6, 5, 6, 0, 0, 0, 1, 7, 6, 0, -1, 0],
+                [0, 9, 4, 3, 0, 0, 0, 1, 5, 5, 0, -1, 0],
+                [0, 6, 8, 7, 0, 0, 0, 1, 5, 6, 0, -1, 0],
+                [0, 8, 3, 8, 2, 1, 1, 0, 0, 0, 0, 0, -1],
+                [0, 5, 9, 9, 2, 9, 9, 0, 0, 0, 0, 0, -1],
+                [0, 6, 5, 4, 4, 6, 7, 0, 0, 0, 0, 0, -1],
+                [-1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+                [-1, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0],
+                [-1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
+            ]
+        )
+    ).all()
 
 
 def test_tucker_schema_meth3(bimat_poly):
     bimat_poly.tucker_schema()
-    assert (bimat_poly.tucker == np.mat([[0, 0, 0, 0, 7, 1, -1, 0],
-                                         [0, 0, 0, 0, 5, 2, -1, 0],
-                                         [0, 0, 0, 0, 4, 4, -1, 0],
-                                         [0, 4, 5, 1, 0, 0, 0, -1],
-                                         [0, 5, 3, 2, 0, 0, 0, -1],
-                                         [-1, 1, 1, 1, 0, 0, 0, 0],
-                                         [-1, 0, 0, 0, 1, 1, 0, 0], ])).all()
+    assert (
+        bimat_poly.tucker
+        == np.mat(
+            [
+                [0, 0, 0, 0, 7, 1, -1, 0],
+                [0, 0, 0, 0, 5, 2, -1, 0],
+                [0, 0, 0, 0, 4, 4, -1, 0],
+                [0, 4, 5, 1, 0, 0, 0, -1],
+                [0, 5, 3, 2, 0, 0, 0, -1],
+                [-1, 1, 1, 1, 0, 0, 0, 0],
+                [-1, 0, 0, 0, 1, 1, 0, 0],
+            ]
+        )
+    ).all()
 
 
 def test_launch_solver1(bimat_poly):
@@ -175,8 +254,10 @@ def test_launch_solver1(bimat_poly):
 
 def test_launch_solver2(bimat_poly):
     sol = bimat_poly.launch_solver([0, 1])
-    assert sol == {0: [Fraction(2, 3), Fraction(1, 3), 0],
-                   1: [Fraction(1, 3), Fraction(2, 3)]}
+    assert sol == {
+        0: [Fraction(2, 3), Fraction(1, 3), 0],
+        1: [Fraction(1, 3), Fraction(2, 3)],
+    }
     assert bimat_poly.currentgame.is_equilibrium(sol)
 
 
diff --git a/test/test_normalformgame.py b/test/test_normalformgame.py
index 7f88254..268ccf6 100644
--- a/test/test_normalformgame.py
+++ b/test/test_normalformgame.py
@@ -12,9 +12,11 @@ Separate  assert in multiple fucntion
 @pytest.fixture
 def first_nfg():
     players_actions = [[0, 1], [0, 1], [0, 1]]
-    utilities = [[-3, -7, -7, -10, -1, -5, -5, -9],
-                 [-3, -7, -1, -5, -7, -10, -5, -9],
-                 [-3, -1, -7, -5, -7, -5, -10, -9]]
+    utilities = [
+        [-3, -7, -7, -10, -1, -5, -5, -9],
+        [-3, -7, -1, -5, -7, -10, -5, -9],
+        [-3, -1, -7, -5, -7, -5, -10, -9],
+    ]
     return NFG(players_actions, utilities)
 
 
@@ -25,7 +27,8 @@ def second_nfg():
         [51, 29, 47, 43, 75, 61, 42, 19, 28, 39, 40, 21, 60, 60, 67, 44],
         [58, 72, 31, 41, 37, 5, 37, 41, 53, 68, 38, 30, 58, 72, 75, 0],
         [29, 73, 42, 13, 34, 31, 54, 25, 47, 29, 19, 46, 85, 79, 65, 24],
-        [1, 17, 49, 9, 51, 25, 21, 49, 28, 77, 41, 69, 13, 100, 49, 27]]
+        [1, 17, 49, 9, 51, 25, 21, 49, 28, 77, 41, 69, 13, 100, 49, 27],
+    ]
     return NFG(players_actions, utilities)
 
 
@@ -34,8 +37,11 @@ def third_nfg():
     players_actions = [[0, 1], [0, 1], [0, 1]]
     # # util=[[79, 50, 98, 11, 17, 95, 46, 0],
     # [6, 5, 43, 38, 39, 65, 51, 19], [92, 86, 63, 100, 29, 48, 53, 68]]
-    util = [[86, 100, 87, 90, 1, 5, 0, 94], [16, 71, 4, 3, 4, 59, 66, 86],
-            [92, 0, 14, 65, 96, 45, 2, 51]]
+    util = [
+        [86, 100, 87, 90, 1, 5, 0, 94],
+        [16, 71, 4, 3, 4, 59, 66, 86],
+        [92, 0, 14, 65, 96, 45, 2, 51],
+    ]
     return NFG(players_actions, util)
 
 
@@ -48,123 +54,204 @@ def bimat_nfg():
 
 # joint_actions
 def test_joint_actions1(first_nfg):
-    assert (first_nfg.joint_actions == np.mat(
-        [[0., 0., 0.], [0., 0., 1.], [0., 1., 0.], [0., 1., 1.], [1., 0., 0.],
-         [1., 0., 1.], [1., 1., 0.], [1., 1., 1.]])).all()
+    assert (
+        first_nfg.joint_actions
+        == np.mat(
+            [
+                [0.0, 0.0, 0.0],
+                [0.0, 0.0, 1.0],
+                [0.0, 1.0, 0.0],
+                [0.0, 1.0, 1.0],
+                [1.0, 0.0, 0.0],
+                [1.0, 0.0, 1.0],
+                [1.0, 1.0, 0.0],
+                [1.0, 1.0, 1.0],
+            ]
+        )
+    ).all()
 
 
 def test_joint_actions2(second_nfg):
-    assert (second_nfg.joint_actions == np.mat(
-        [[0, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0], [0, 0, 1, 1], [0, 1, 0, 0],
-         [0, 1, 0, 1], [0, 1, 1, 0], [0, 1, 1, 1], [1, 0, 0, 0], [1, 0, 0, 1],
-         [1, 0, 1, 0], [1, 0, 1, 1], [1, 1, 0, 0], [1, 1, 0, 1], [1, 1, 1, 0],
-         [1, 1, 1, 1]])).all()
+    assert (
+        second_nfg.joint_actions
+        == np.mat(
+            [
+                [0, 0, 0, 0],
+                [0, 0, 0, 1],
+                [0, 0, 1, 0],
+                [0, 0, 1, 1],
+                [0, 1, 0, 0],
+                [0, 1, 0, 1],
+                [0, 1, 1, 0],
+                [0, 1, 1, 1],
+                [1, 0, 0, 0],
+                [1, 0, 0, 1],
+                [1, 0, 1, 0],
+                [1, 0, 1, 1],
+                [1, 1, 0, 0],
+                [1, 1, 0, 1],
+                [1, 1, 1, 0],
+                [1, 1, 1, 1],
+            ]
+        )
+    ).all()
 
 
 def test_joint_actions3(bimat_nfg):
-    assert (bimat_nfg.joint_actions == np.mat(
-        [[0., 0.], [0., 1.], [1., 0.], [1., 1.], [2., 0.], [2., 1.]])).all()
+    assert (
+        bimat_nfg.joint_actions
+        == np.mat(
+            [[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0], [2.0, 0.0], [2.0, 1.0]]
+        )
+    ).all()
 
 
 # all_response_of_player
 def test_all_response_of_player1(first_nfg):
-    assert (first_nfg.all_response_of_player(0, [0, 0, 0]) == np.mat(
-        [[0., 0., 0.], [1., 0., 0.]])).all()
+    assert (
+        first_nfg.all_response_of_player(0, [0, 0, 0])
+        == np.mat([[0.0, 0.0, 0.0], [1.0, 0.0, 0.0]])
+    ).all()
 
 
 def test_all_response_of_player2(first_nfg):
-    assert (first_nfg.all_response_of_player(1, [0, 0, 0]) == np.mat(
-        [[0., 0., 0.], [0., 1., 0.]])).all()
+    assert (
+        first_nfg.all_response_of_player(1, [0, 0, 0])
+        == np.mat([[0.0, 0.0, 0.0], [0.0, 1.0, 0.0]])
+    ).all()
 
 
 def test_all_response_of_player3(first_nfg):
-    assert (first_nfg.all_response_of_player(2, [0, 0, 0]) == np.mat(
-        [[0., 0., 0.], [0., 0., 1.]])).all()
+    assert (
+        first_nfg.all_response_of_player(2, [0, 0, 0])
+        == np.mat([[0.0, 0.0, 0.0], [0.0, 0.0, 1.0]])
+    ).all()
 
 
 def test_all_response_of_player4(first_nfg):
-    assert (first_nfg.all_response_of_player(0, [1, 1, 1]) == np.mat(
-        [[0., 1., 1.], [1., 1., 1.]])).all()
+    assert (
+        first_nfg.all_response_of_player(0, [1, 1, 1])
+        == np.mat([[0.0, 1.0, 1.0], [1.0, 1.0, 1.0]])
+    ).all()
 
 
 def test_all_response_of_player5(first_nfg):
-    assert (first_nfg.all_response_of_player(1, [1, 1, 1]) == np.mat(
-        [[1., 0., 1.], [1., 1., 1.]])).all()
+    assert (
+        first_nfg.all_response_of_player(1, [1, 1, 1])
+        == np.mat([[1.0, 0.0, 1.0], [1.0, 1.0, 1.0]])
+    ).all()
 
 
 def test_all_response_of_player6(first_nfg):
-    assert (first_nfg.all_response_of_player(2, [1, 1, 1]) == np.mat(
-        [[1., 1., 0.], [1., 1., 1.]])).all()
+    assert (
+        first_nfg.all_response_of_player(2, [1, 1, 1])
+        == np.mat([[1.0, 1.0, 0.0], [1.0, 1.0, 1.0]])
+    ).all()
 
 
 def test_all_response_of_player7(first_nfg):
-    assert (first_nfg.all_response_of_player(0, [1, 1, 1]) ==
-            first_nfg.all_response_of_player(0, [0, 1, 1])).all()
+    assert (
+        first_nfg.all_response_of_player(0, [1, 1, 1])
+        == first_nfg.all_response_of_player(0, [0, 1, 1])
+    ).all()
 
 
 def test_all_response_of_player8(first_nfg):
-    assert (first_nfg.all_response_of_player(1, [1, 0, 0]) ==
-            first_nfg.all_response_of_player(1, [1, 1, 0])).all()
+    assert (
+        first_nfg.all_response_of_player(1, [1, 0, 0])
+        == first_nfg.all_response_of_player(1, [1, 1, 0])
+    ).all()
 
 
 def test_all_response_of_player9(first_nfg):
-    assert (first_nfg.all_response_of_player(2, [0, 1, 1]) ==
-            first_nfg.all_response_of_player(2, [0, 1, 0])).all()
+    assert (
+        first_nfg.all_response_of_player(2, [0, 1, 1])
+        == first_nfg.all_response_of_player(2, [0, 1, 0])
+    ).all()
 
 
 def test_all_response_of_player10(second_nfg):
-    assert (second_nfg.all_response_of_player(0, [0, 0, 0, 0]) == np.mat(
-        [[0., 0., 0., 0.], [1., 0., 0., 0.]])).all()
+    assert (
+        second_nfg.all_response_of_player(0, [0, 0, 0, 0])
+        == np.mat([[0.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]])
+    ).all()
 
 
 def test_all_response_of_player11(second_nfg):
-    assert (second_nfg.all_response_of_player(1, [1, 0, 0, 1]) == np.mat(
-        [[1., 0., 0., 1.], [1., 1., 0., 1.]])).all()
+    assert (
+        second_nfg.all_response_of_player(1, [1, 0, 0, 1])
+        == np.mat([[1.0, 0.0, 0.0, 1.0], [1.0, 1.0, 0.0, 1.0]])
+    ).all()
 
 
 def test_all_response_of_player12(second_nfg):
-    assert (second_nfg.all_response_of_player(2, [1, 1, 1, 1]) == np.mat(
-        [[1., 1., 0., 1.], [1., 1., 1., 1.]])).all()
+    assert (
+        second_nfg.all_response_of_player(2, [1, 1, 1, 1])
+        == np.mat([[1.0, 1.0, 0.0, 1.0], [1.0, 1.0, 1.0, 1.0]])
+    ).all()
 
 
 def test_all_response_of_player13(bimat_nfg):
-    assert (bimat_nfg.all_response_of_player(0, [0, 0]) == np.mat(
-        [[0., 0.], [1., 0.], [2., 0.]])).all()
+    assert (
+        bimat_nfg.all_response_of_player(0, [0, 0])
+        == np.mat([[0.0, 0.0], [1.0, 0.0], [2.0, 0.0]])
+    ).all()
 
 
 def test_all_response_of_player14(bimat_nfg):
-    assert (bimat_nfg.all_response_of_player(1, [0, 1]) == np.mat(
-        [[0., 0.], [0., 1.]])).all()
+    assert (
+        bimat_nfg.all_response_of_player(1, [0, 1]) == np.mat([[0.0, 0.0], [0.0, 1.0]])
+    ).all()
 
 
 def test_all_response_of_player15(bimat_nfg):
-    assert (bimat_nfg.all_response_of_player(1, [2, 0]) == np.mat(
-        [[2., 0.], [2., 1.]])).all()
+    assert (
+        bimat_nfg.all_response_of_player(1, [2, 0]) == np.mat([[2.0, 0.0], [2.0, 1.0]])
+    ).all()
 
 
 def test_all_response_of_player16(bimat_nfg):
-    assert (bimat_nfg.all_response_of_player(0, [0, 0]) ==
-            bimat_nfg.all_response_of_player(0, [2, 0])).all()
+    assert (
+        bimat_nfg.all_response_of_player(0, [0, 0])
+        == bimat_nfg.all_response_of_player(0, [2, 0])
+    ).all()
 
 
 def test_all_response_of_player17(bimat_nfg):
-    assert (bimat_nfg.all_response_of_player(0, [1, 0]) ==
-            bimat_nfg.all_response_of_player(0, [2, 0])).all()
+    assert (
+        bimat_nfg.all_response_of_player(0, [1, 0])
+        == bimat_nfg.all_response_of_player(0, [2, 0])
+    ).all()
 
 
 # joint_action_except_i
 
+
 def test_joint_action_except_i1(first_nfg, second_nfg, bimat_nfg):
     for n in range(first_nfg.n_players):
-        assert (first_nfg.joint_action_except_i(n) == np.mat(
-            [[0., 0.], [0., 1.], [1., 0.], [1., 1.]])).all()
+        assert (
+            first_nfg.joint_action_except_i(n)
+            == np.mat([[0.0, 0.0], [0.0, 1.0], [1.0, 0.0], [1.0, 1.0]])
+        ).all()
 
 
 def test_joint_action_except_i2(second_nfg):
     for n in range(second_nfg.n_players):
-        assert (second_nfg.joint_action_except_i(n) == np.mat(
-            [[0, 0, 0], [0, 0, 1], [0, 1, 0], [0, 1, 1], [1, 0, 0], [1, 0, 1],
-             [1, 1, 0], [1, 1, 1]])).all()
+        assert (
+            second_nfg.joint_action_except_i(n)
+            == np.mat(
+                [
+                    [0, 0, 0],
+                    [0, 0, 1],
+                    [0, 1, 0],
+                    [0, 1, 1],
+                    [1, 0, 0],
+                    [1, 0, 1],
+                    [1, 1, 0],
+                    [1, 1, 1],
+                ]
+            )
+        ).all()
 
 
 def test_joint_action_except_i3(bimat_nfg):
@@ -172,8 +259,7 @@ def test_joint_action_except_i3(bimat_nfg):
 
 
 def test_joint_action_except_i4(bimat_nfg):
-    assert (bimat_nfg.joint_action_except_i(1) == np.mat(
-        [[0], [1], [2]])).all()
+    assert (bimat_nfg.joint_action_except_i(1) == np.mat([[0], [1], [2]])).all()
 
 
 # get_sub_jointact_of_n
@@ -181,53 +267,83 @@ def test_joint_action_except_i4(bimat_nfg):
 
 
 def test_get_sub_jointact_of_n1(first_nfg):
-    assert (first_nfg.get_sub_jointact_of_n(0) == [[0, 4], [1, 5], [2, 6],
-                                                   [3, 7]])
+    assert first_nfg.get_sub_jointact_of_n(0) == [[0, 4], [1, 5], [2, 6], [3, 7]]
 
 
 def test_get_sub_jointact_of_n2(first_nfg):
-    assert (first_nfg.get_sub_jointact_of_n(1) == [[0, 2], [1, 3], [4, 6],
-                                                   [5, 7]])
+    assert first_nfg.get_sub_jointact_of_n(1) == [[0, 2], [1, 3], [4, 6], [5, 7]]
 
 
 def test_get_sub_jointact_of_n3(first_nfg):
-    assert (first_nfg.get_sub_jointact_of_n(2) == [[0, 1], [2, 3], [4, 5],
-                                                   [6, 7]])
+    assert first_nfg.get_sub_jointact_of_n(2) == [[0, 1], [2, 3], [4, 5], [6, 7]]
 
 
 def test_get_sub_jointact_of_n4(bimat_nfg):
-    assert (bimat_nfg.get_sub_jointact_of_n(0) == [[0, 2, 4], [1, 3, 5]])
+    assert bimat_nfg.get_sub_jointact_of_n(0) == [[0, 2, 4], [1, 3, 5]]
 
 
 def test_get_sub_jointact_of_n5(bimat_nfg):
-    assert (bimat_nfg.get_sub_jointact_of_n(1) == [[0, 1], [2, 3], [4, 5]])
+    assert bimat_nfg.get_sub_jointact_of_n(1) == [[0, 1], [2, 3], [4, 5]]
 
 
 # disutilities
 
+
 def test_disutilities1(first_nfg):
-    assert (first_nfg.disutilities == np.mat(
-        [[3, 3, 3], [7, 7, 1], [7, 1, 7], [10, 5, 5], [1, 7, 7], [5, 10, 5],
-         [5, 5, 10], [9, 9, 9]])).all()
+    assert (
+        first_nfg.disutilities
+        == np.mat(
+            [
+                [3, 3, 3],
+                [7, 7, 1],
+                [7, 1, 7],
+                [10, 5, 5],
+                [1, 7, 7],
+                [5, 10, 5],
+                [5, 5, 10],
+                [9, 9, 9],
+            ]
+        )
+    ).all()
 
 
 def test_disutilities2(second_nfg):
-    assert (second_nfg.disutilities == np.mat(
-        [[25, 18, 57, 100], [47, 4, 13, 84], [29, 45, 44, 52],
-         [33, 35, 73, 92], [1, 39, 52, 50], [15, 71, 55, 76], [34, 39, 32, 80],
-         [57, 35, 61, 52], [48, 23, 39, 73], [37, 8, 57, 24], [36, 38, 67, 60],
-         [55, 46, 40, 32], [16, 18, 1, 88], [16, 4, 7, 1], [9, 1, 21, 52],
-         [32, 76, 62, 74]])).all()
+    assert (
+        second_nfg.disutilities
+        == np.mat(
+            [
+                [25, 18, 57, 100],
+                [47, 4, 13, 84],
+                [29, 45, 44, 52],
+                [33, 35, 73, 92],
+                [1, 39, 52, 50],
+                [15, 71, 55, 76],
+                [34, 39, 32, 80],
+                [57, 35, 61, 52],
+                [48, 23, 39, 73],
+                [37, 8, 57, 24],
+                [36, 38, 67, 60],
+                [55, 46, 40, 32],
+                [16, 18, 1, 88],
+                [16, 4, 7, 1],
+                [9, 1, 21, 52],
+                [32, 76, 62, 74],
+            ]
+        )
+    ).all()
 
 
 def test_disutilities3(bimat_nfg):
-    assert (bimat_nfg.disutilities == np.mat(
-        [[4, 4], [4, 5], [5, 5], [2, 1], [7, 4], [1, 6]])).all()
+    assert (
+        bimat_nfg.disutilities
+        == np.mat([[4, 4], [4, 5], [5, 5], [2, 1], [7, 4], [1, 6]])
+    ).all()
 
 
 # row_where_p_is_i
 # No second_nfg
 
+
 def test_row_where_p_is_i1(first_nfg, second_nfg, bimat_nfg):
     assert (first_nfg.row_where_p_is_i(0, 0) == np.mat([0, 1, 2, 3])).all()
 
@@ -303,6 +419,7 @@ def test_util_of_row6(bimat_nfg):
 # disutil_of_row
 # no second_nfg
 
+
 def test_disutil_of_row1(first_nfg):
     for n in range(first_nfg.n_players):
         assert (first_nfg.disutil_of_row(n, 0) == np.mat([3, 7, 7, 10])).all()
@@ -335,53 +452,73 @@ def test_disutil_of_row6(bimat_nfg):
 # expected_utilities
 # no second_nfg
 def test_expected_utilities1(first_nfg):
-    assert (first_nfg.expected_utilities(
-        {0: [1, 0], 1: [1, 0], 2: [1, 0]}) == np.mat([-3, -3, -3])).all()
+    assert (
+        first_nfg.expected_utilities({0: [1, 0], 1: [1, 0], 2: [1, 0]})
+        == np.mat([-3, -3, -3])
+    ).all()
 
 
 def test_expected_utilities2(first_nfg):
-    assert (first_nfg.expected_utilities(
-        {0: [1, 0], 1: [0, 1], 2: [1, 0]}) == np.mat([-7, -1, -7])).all()
+    assert (
+        first_nfg.expected_utilities({0: [1, 0], 1: [0, 1], 2: [1, 0]})
+        == np.mat([-7, -1, -7])
+    ).all()
 
 
 def test_expected_utilities3(first_nfg):
-    assert (first_nfg.expected_utilities(
-        {0: [0, 1], 1: [0, 1], 2: [0, 1]}) == np.mat([-9, -9, -9])).all()
+    assert (
+        first_nfg.expected_utilities({0: [0, 1], 1: [0, 1], 2: [0, 1]})
+        == np.mat([-9, -9, -9])
+    ).all()
 
 
 def test_expected_utilities4(first_nfg):
-    assert (first_nfg.expected_utilities(
-        {0: [1 / 2, 1 / 2], 1: [1 / 2, 1 / 2], 2: [1 / 2, 1 / 2]}) == np.mat(
-        [-5.875, -5.875, -5.875])).all()
+    assert (
+        first_nfg.expected_utilities(
+            {0: [1 / 2, 1 / 2], 1: [1 / 2, 1 / 2], 2: [1 / 2, 1 / 2]}
+        )
+        == np.mat([-5.875, -5.875, -5.875])
+    ).all()
 
 
 def test_expected_utilities5(bimat_nfg):
-    assert (bimat_nfg.expected_utilities({0: [1, 0, 0], 1: [1, 0]}) == np.mat(
-        [3, 3])).all()
+    assert (
+        bimat_nfg.expected_utilities({0: [1, 0, 0], 1: [1, 0]}) == np.mat([3, 3])
+    ).all()
 
 
 def test_expected_utilities6(bimat_nfg):
-    assert (bimat_nfg.expected_utilities({0: [0, 0, 1], 1: [0, 1]}) == np.mat(
-        [6, 1])).all()
+    assert (
+        bimat_nfg.expected_utilities({0: [0, 0, 1], 1: [0, 1]}) == np.mat([6, 1])
+    ).all()
 
 
 def test_expected_utilities7(bimat_nfg):
-    assert (bimat_nfg.expected_utilities({0: [0, 1, 0], 1: [1, 0]}) == np.mat(
-        [2, 2])).all()
+    assert (
+        bimat_nfg.expected_utilities({0: [0, 1, 0], 1: [1, 0]}) == np.mat([2, 2])
+    ).all()
 
 
 def test_expected_utilities8(bimat_nfg):
-    assert (bimat_nfg.expected_utilities(
-        {0: [Fraction(1, 3), Fraction(1, 3), Fraction(1, 3)],
-         1: [Fraction(1, 2), Fraction(1, 2)]}) == np.mat(
-        [Fraction(19, 6), Fraction(17, 6)])).all()
+    assert (
+        bimat_nfg.expected_utilities(
+            {
+                0: [Fraction(1, 3), Fraction(1, 3), Fraction(1, 3)],
+                1: [Fraction(1, 2), Fraction(1, 2)],
+            }
+        )
+        == np.mat([Fraction(19, 6), Fraction(17, 6)])
+    ).all()
 
 
 # is_equilibrium
 # No second/bimat
 def test_is_equilibrium1(first_nfg):
-    assert not (first_nfg.is_equilibrium(
-        {0: [1 / 2, 1 / 2], 1: [1 / 2, 1 / 2], 2: [1 / 2, 1 / 2]}))
+    assert not (
+        first_nfg.is_equilibrium(
+            {0: [1 / 2, 1 / 2], 1: [1 / 2, 1 / 2], 2: [1 / 2, 1 / 2]}
+        )
+    )
 
 
 # def test_error_equilibrium1(first_nfg):
@@ -391,8 +528,9 @@ def test_is_equilibrium1(first_nfg):
 # def test_error_equilibrium2(first_nfg):
 #     assert first_nfg.error_equilibrium({0: [0, 1], 1: [0, 1], 2: [0, 1]})==0
 
+
 def test_is_equilibrium2(first_nfg):
-    assert (first_nfg.is_equilibrium({0: [0, 1], 1: [0, 1], 2: [0, 1]}))
+    assert first_nfg.is_equilibrium({0: [0, 1], 1: [0, 1], 2: [0, 1]})
 
 
 def test_is_equilibrium3(first_nfg):
@@ -408,7 +546,7 @@ def test_is_equilibrium4(first_nfg):
 
 
 def test_is_pure_equilibrium1(first_nfg):
-    assert (first_nfg.is_pure_equilibrium([1, 1, 1]))
+    assert first_nfg.is_pure_equilibrium([1, 1, 1])
 
 
 def test_is_pure_equilibrium2(first_nfg):
@@ -420,19 +558,19 @@ def test_is_pure_equilibrium3(first_nfg):
 
 
 def test_get_all_PNE1(first_nfg):
-    assert (first_nfg.get_all_PNE() == [{0: [0, 1], 1: [0, 1], 2: [0, 1]}])
+    assert first_nfg.get_all_PNE() == [{0: [0, 1], 1: [0, 1], 2: [0, 1]}]
 
 
 def test_get_all_PNE2(second_nfg):
-    assert (second_nfg.get_all_PNE() == [])
+    assert second_nfg.get_all_PNE() == []
 
 
 def test_get_all_PNE3(bimat_nfg):
-    assert (bimat_nfg.get_all_PNE() == [{0: [1, 0, 0], 1: [1, 0]}])
+    assert bimat_nfg.get_all_PNE() == [{0: [1, 0, 0], 1: [1, 0]}]
 
 
 def test_pne_exist1(first_nfg, second_nfg, bimat_nfg):
-    assert (first_nfg.pne_exist())
+    assert first_nfg.pne_exist()
 
 
 def test_pne_exist2(second_nfg):
@@ -440,21 +578,22 @@ def test_pne_exist2(second_nfg):
 
 
 def test_pne_exist3(bimat_nfg):
-    assert (bimat_nfg.pne_exist())
+    assert bimat_nfg.pne_exist()
 
 
 # get_all_PNE
 
+
 def test_first_pne1(first_nfg, second_nfg, bimat_nfg):
-    assert (first_nfg.first_pne() == {0: [0, 1], 1: [0, 1], 2: [0, 1]})
+    assert first_nfg.first_pne() == {0: [0, 1], 1: [0, 1], 2: [0, 1]}
 
 
 def test_first_pne2(second_nfg):
-    assert (second_nfg.first_pne() == {})
+    assert second_nfg.first_pne() == {}
 
 
 def test_first_pne3(bimat_nfg):
-    assert (bimat_nfg.first_pne() == {0: [1, 0, 0], 1: [1, 0]})
+    assert bimat_nfg.first_pne() == {0: [1, 0, 0], 1: [1, 0]}
 
 
 # def test_build_subgame(first_nfg,second_nfg,bimat_nfg):
@@ -467,37 +606,56 @@ def test_first_pne3(bimat_nfg):
 # build_subgame
 # no second_nfg
 
+
 def test_build_subgame1(first_nfg, second_nfg, bimat_nfg):
     sub_first1 = first_nfg.build_subgame({2: [0, 1]})
-    assert (sub_first1.players_actions == [[0, 1], [0, 1], [-1]] and
-            sub_first1.utilities == [[-7, -10, -5, -9], [-7, -5, -10, -9],
-                                     [-1, -5, -5, -9]])
+    assert sub_first1.players_actions == [
+        [0, 1],
+        [0, 1],
+        [-1],
+    ] and sub_first1.utilities == [
+        [-7, -10, -5, -9],
+        [-7, -5, -10, -9],
+        [-1, -5, -5, -9],
+    ]
 
 
 def test_build_subgame2(first_nfg):
     sub_first2 = first_nfg.build_subgame({0: [1, 0], 1: [0, 1]})
-    assert (sub_first2.players_actions == [[-1], [-1], [0, 1]] and
-            sub_first2.utilities == [[-7, -10], [-1, -5], [-7, -5]])
+    assert sub_first2.players_actions == [
+        [-1],
+        [-1],
+        [0, 1],
+    ] and sub_first2.utilities == [[-7, -10], [-1, -5], [-7, -5]]
 
 
 def test_build_subgame3(first_nfg):
     sub_first_mixed = first_nfg.build_subgame({2: [1 / 2, 1 / 2]})
-    assert (sub_first_mixed.players_actions == [[0, 1], [0, 1], [-1]] and
-            sub_first_mixed.utilities == [[-5, -8.5, -3, -7],
-                                          [-5, -3, -8.5, -7],
-                                          [-2, -6, -6, -9.5]])
+    assert sub_first_mixed.players_actions == [
+        [0, 1],
+        [0, 1],
+        [-1],
+    ] and sub_first_mixed.utilities == [
+        [-5, -8.5, -3, -7],
+        [-5, -3, -8.5, -7],
+        [-2, -6, -6, -9.5],
+    ]
 
 
 def test_build_subgame4(bimat_nfg):
     sub_bimat1 = bimat_nfg.build_subgame({1: [1, 0]})
-    assert (sub_bimat1.players_actions == [[0, 1, 2], [-1]] and
-            sub_bimat1.utilities == [[3, 2, 0], [3, 2, 3]])
+    assert sub_bimat1.players_actions == [[0, 1, 2], [-1]] and sub_bimat1.utilities == [
+        [3, 2, 0],
+        [3, 2, 3],
+    ]
 
 
 def test_build_subgame5(bimat_nfg):
     sub_bimat2 = bimat_nfg.build_subgame({0: [1, 0, 0]})
-    assert (sub_bimat2.players_actions == [[-1], [0, 1]] and
-            sub_bimat2.utilities == [[3, 3], [3, 2]])
+    assert sub_bimat2.players_actions == [[-1], [0, 1]] and sub_bimat2.utilities == [
+        [3, 3],
+        [3, 2],
+    ]
 
 
 # get_subgame_level
@@ -506,43 +664,53 @@ def test_build_subgame5(bimat_nfg):
 
 def test_get_subgame_level1(first_nfg):
     sub_level_first_nfg1 = first_nfg.get_subgame_level(
-        {0: [0, 1], 1: [0, 1], 2: [0, 1]})
-    assert (sub_level_first_nfg1.players_actions == [[0, 1], [0, 1]] and
-            sub_level_first_nfg1.utilities == [[-7, -10, -5, -9],
-                                               [-7, -5, -10, -9]])
+        {0: [0, 1], 1: [0, 1], 2: [0, 1]}
+    )
+    assert sub_level_first_nfg1.players_actions == [
+        [0, 1],
+        [0, 1],
+    ] and sub_level_first_nfg1.utilities == [[-7, -10, -5, -9], [-7, -5, -10, -9]]
 
 
 def test_get_subgame_level2(first_nfg):
     sub_level_first_mixed = first_nfg.get_subgame_level(
-        {0: [0, 1], 1: [1, 0], 2: [1 / 2, 1 / 2]})
-    assert (sub_level_first_mixed.players_actions == [[0, 1], [0, 1]] and
-            sub_level_first_mixed.utilities == [[-5, -8.5, -3, -7],
-                                                [-5, -3, -8.5, -7]])
+        {0: [0, 1], 1: [1, 0], 2: [1 / 2, 1 / 2]}
+    )
+    assert sub_level_first_mixed.players_actions == [
+        [0, 1],
+        [0, 1],
+    ] and sub_level_first_mixed.utilities == [[-5, -8.5, -3, -7], [-5, -3, -8.5, -7]]
 
 
 def test_get_subgame_level3(bimat_nfg):
     sub_level_bimat1 = bimat_nfg.get_subgame_level({0: [0, 1, 0], 1: [1, 0]})
-    assert (sub_level_bimat1.players_actions == [[0, 1, 2]] and
-            sub_level_bimat1.utilities == [[3, 2, 0]])
+    assert sub_level_bimat1.players_actions == [
+        [0, 1, 2]
+    ] and sub_level_bimat1.utilities == [[3, 2, 0]]
 
 
 # get_subgame_without_n
 # no second_nfg, bimat
 
+
 def test_get_subgame_without_n1(first_nfg):
     sub_level_first_nfg1 = first_nfg.get_subgame_without_n(
-        {0: [0, 1], 1: [0, 1], 2: [0, 1]}, 2)
-    assert (sub_level_first_nfg1.players_actions == [[0, 1], [0, 1]] and
-            sub_level_first_nfg1.utilities == [[-7, -10, -5, -9],
-                                               [-7, -5, -10, -9]])
+        {0: [0, 1], 1: [0, 1], 2: [0, 1]}, 2
+    )
+    assert sub_level_first_nfg1.players_actions == [
+        [0, 1],
+        [0, 1],
+    ] and sub_level_first_nfg1.utilities == [[-7, -10, -5, -9], [-7, -5, -10, -9]]
 
 
 def test_get_subgame_without_n2(first_nfg):
     sub_level_first_nfg2 = first_nfg.get_subgame_without_n(
-        {0: [1, 0], 1: [0, 1], 2: [0, 1]}, 0)
-    assert (sub_level_first_nfg2.players_actions == [[0, 1], [0, 1]] and
-            sub_level_first_nfg2.utilities == [[-3, -7, -1, -5],
-                                               [-3, -1, -7, -5]])
+        {0: [1, 0], 1: [0, 1], 2: [0, 1]}, 0
+    )
+    assert sub_level_first_nfg2.players_actions == [
+        [0, 1],
+        [0, 1],
+    ] and sub_level_first_nfg2.utilities == [[-3, -7, -1, -5], [-3, -1, -7, -5]]
 
 
 """
@@ -568,36 +736,47 @@ readNFGpayoff
 # get_subgame_fixed_strat
 # no second_nfg
 
+
 def test_get_subgame_fixed_strat1(first_nfg):
     sub_first_nfg1 = first_nfg.get_subgame_fixed_strat(
-        {0: [1, 1], 1: [1, 1], 2: [1, 0]})
-    assert (sub_first_nfg1.players_actions == [[0, 1], [0, 1], [
-        0]] and sub_first_nfg1.utilities == [[-3, -7, -1, -5],
-                                             [-3, -1, -7, -5],
-                                             [-3, -7, -7, -10]])
+        {0: [1, 1], 1: [1, 1], 2: [1, 0]}
+    )
+    assert sub_first_nfg1.players_actions == [
+        [0, 1],
+        [0, 1],
+        [0],
+    ] and sub_first_nfg1.utilities == [
+        [-3, -7, -1, -5],
+        [-3, -1, -7, -5],
+        [-3, -7, -7, -10],
+    ]
 
 
 def test_get_subgame_fixed_strat2(first_nfg):
     sub_first_nfg2 = first_nfg.get_subgame_fixed_strat(
-        {0: [0, 1], 1: [0, 1], 2: [0, 1]})
-    assert (sub_first_nfg2.players_actions == [[1], [1], [
-        1]] and sub_first_nfg2.utilities == [[-9], [-9], [-9]])
+        {0: [0, 1], 1: [0, 1], 2: [0, 1]}
+    )
+    assert sub_first_nfg2.players_actions == [
+        [1],
+        [1],
+        [1],
+    ] and sub_first_nfg2.utilities == [[-9], [-9], [-9]]
 
 
 def test_get_subgame_fixed_strat3(bimat_nfg):
-    sub_bimat_nfg1 = bimat_nfg.get_subgame_fixed_strat(
-        {0: [1, 1, 0], 1: [1, 1]})
-    assert (
-            sub_bimat_nfg1.players_actions ==
-            [[0, 1], [0, 1]] and sub_bimat_nfg1.utilities ==
-            [[3, 3, 2, 5], [3, 2, 2, 6]])
+    sub_bimat_nfg1 = bimat_nfg.get_subgame_fixed_strat({0: [1, 1, 0], 1: [1, 1]})
+    assert sub_bimat_nfg1.players_actions == [
+        [0, 1],
+        [0, 1],
+    ] and sub_bimat_nfg1.utilities == [[3, 3, 2, 5], [3, 2, 2, 6]]
 
 
 def test_get_subgame_fixed_strat4(bimat_nfg):
-    sub_bimat_nfg2 = bimat_nfg.get_subgame_fixed_strat(
-        {0: [0, 1, 1], 1: [1, 0]})
-    assert (sub_bimat_nfg2.players_actions == [[1, 2], [
-        0]] and sub_bimat_nfg2.utilities == [[2, 0], [2, 3]])
+    sub_bimat_nfg2 = bimat_nfg.get_subgame_fixed_strat({0: [0, 1, 1], 1: [1, 0]})
+    assert sub_bimat_nfg2.players_actions == [
+        [1, 2],
+        [0],
+    ] and sub_bimat_nfg2.utilities == [[2, 0], [2, 3]]
 
 
 def test_readNFGpayoff1():
@@ -609,20 +788,21 @@ def test_readNFGpayoff1():
 def test_readNFGpayoff2():
     read_game = NFG.readNFGpayoff("filestest/RandG_0.nfg")
     assert read_game.players_actions == [[0, 1], [0, 1], [0, 1]]
-    assert read_game.utilities == [[43, 38, 1, 63, 61, 21, 12, 46],
-                                   [89, 35, 0, 88, 87, 68, 24, 22],
-                                   [72, 92, 61, 71, 95, 2, 4, 100]]
+    assert read_game.utilities == [
+        [43, 38, 1, 63, 61, 21, 12, 46],
+        [89, 35, 0, 88, 87, 68, 24, 22],
+        [72, 92, 61, 71, 95, 2, 4, 100],
+    ]
 
 
 def test_readNFGpayoff3():
     read_game = NFG.readNFGpayoff("filestest/custom_game1.nfg")
     assert read_game.players_actions == [[0, 1, 2], [0, 1, 2], [0, 1]]
     assert read_game.utilities == [
-        [91, 49, 69, 98, 95, 15, 70, 59, 68, 52, 45, 22, 14, 37, 54, 58, 41,
-         92],
-        [71, 89, 23, 47, 26, 17, 94, 99, 49, 55, 22, 72, 70, 85, 85, 82, 38,
-         62],
-        [54, 39, 53, 50, 66, 55, 8, 59, 49, 40, 67, 19, 7, 39, 14, 62, 80, 76]]
+        [91, 49, 69, 98, 95, 15, 70, 59, 68, 52, 45, 22, 14, 37, 54, 58, 41, 92],
+        [71, 89, 23, 47, 26, 17, 94, 99, 49, 55, 22, 72, 70, 85, 85, 82, 38, 62],
+        [54, 39, 53, 50, 66, 55, 8, 59, 49, 40, 67, 19, 7, 39, 14, 62, 80, 76],
+    ]
 
 
 def test_readNFGpayoff4():
diff --git a/test/test_pns.py b/test/test_pns.py
index 5d432ae..7557e06 100644
--- a/test/test_pns.py
+++ b/test/test_pns.py
@@ -4,8 +4,7 @@ from gtnash.game.normalformgame import NFG
 from gtnash.game.hypergraphicalgame import HGG
 from fractions import Fraction
 from gtnash.util.irda import irda
-from gtnash.solver.pns import PNS_solver,\
-    unbalance_partitions, allbalancedsupports
+from gtnash.solver.pns import PNS_solver, unbalance_partitions, allbalancedsupports
 
 """
 PNS_solver
@@ -68,115 +67,205 @@ def test_unbalance_partitions6():
 #     for i in allbalancedsupports([[0, 1, 2], [0, 1], [0, 1, 2]]):
 #         print(i)
 
+
 def test_allbalancedsupports1():
-    all_support = [({0}, {0}, {0}), ({0}, {0}, {1}), ({0}, {1}, {0}),
-                   ({0}, {1}, {1}), ({1}, {0}, {0}), ({1}, {0}, {1}),
-                   ({1}, {1}, {0}), ({1}, {1}, {1}), ({0, 1}, {0}, {0}),
-                   ({0, 1}, {0}, {1}), ({0, 1}, {1}, {0}), ({0, 1}, {1}, {1}),
-                   ({0}, {0, 1}, {0}), ({0}, {0, 1}, {1}), ({1}, {0, 1}, {0}),
-                   ({1}, {0, 1}, {1}), ({0}, {0}, {0, 1}), ({0}, {1}, {0, 1}),
-                   ({1}, {0}, {0, 1}), ({1}, {1}, {0, 1}),
-                   ({0, 1}, {0, 1}, {0}),
-                   ({0, 1}, {0, 1}, {1}), ({0, 1}, {0}, {0, 1}),
-                   ({0, 1}, {1}, {0, 1}),
-                   ({0}, {0, 1}, {0, 1}), ({1}, {0, 1}, {0, 1}),
-                   ({0, 1}, {0, 1}, {0, 1})]
+    all_support = [
+        ({0}, {0}, {0}),
+        ({0}, {0}, {1}),
+        ({0}, {1}, {0}),
+        ({0}, {1}, {1}),
+        ({1}, {0}, {0}),
+        ({1}, {0}, {1}),
+        ({1}, {1}, {0}),
+        ({1}, {1}, {1}),
+        ({0, 1}, {0}, {0}),
+        ({0, 1}, {0}, {1}),
+        ({0, 1}, {1}, {0}),
+        ({0, 1}, {1}, {1}),
+        ({0}, {0, 1}, {0}),
+        ({0}, {0, 1}, {1}),
+        ({1}, {0, 1}, {0}),
+        ({1}, {0, 1}, {1}),
+        ({0}, {0}, {0, 1}),
+        ({0}, {1}, {0, 1}),
+        ({1}, {0}, {0, 1}),
+        ({1}, {1}, {0, 1}),
+        ({0, 1}, {0, 1}, {0}),
+        ({0, 1}, {0, 1}, {1}),
+        ({0, 1}, {0}, {0, 1}),
+        ({0, 1}, {1}, {0, 1}),
+        ({0}, {0, 1}, {0, 1}),
+        ({1}, {0, 1}, {0, 1}),
+        ({0, 1}, {0, 1}, {0, 1}),
+    ]
     for s_i, s in enumerate(allbalancedsupports([[0, 1], [0, 1], [0, 1]])):
         assert s == all_support[s_i]
 
 
 def test_allbalancedsupports2():
-    all_support = [({0}, {0}, {0}), ({0}, {0}, {1}), ({0}, {0}, {2}),
-                   ({0}, {1}, {0}),
-                   ({0}, {1}, {1}), ({0}, {1}, {2}), ({1}, {0}, {0}),
-                   ({1}, {0}, {1}),
-                   ({1}, {0}, {2}), ({1}, {1}, {0}), ({1}, {1}, {1}),
-                   ({1}, {1}, {2}),
-                   ({2}, {0}, {0}), ({2}, {0}, {1}), ({2}, {0}, {2}),
-                   ({2}, {1}, {0}),
-                   ({2}, {1}, {1}), ({2}, {1}, {2}), ({0, 1}, {0}, {0}),
-                   ({0, 1}, {0}, {1}),
-                   ({0, 1}, {0}, {2}), ({0, 1}, {1}, {0}), ({0, 1}, {1}, {1}),
-                   ({0, 1}, {1}, {2}),
-                   ({0, 2}, {0}, {0}), ({0, 2}, {0}, {1}), ({0, 2}, {0}, {2}),
-                   ({0, 2}, {1}, {0}),
-                   ({0, 2}, {1}, {1}), ({0, 2}, {1}, {2}), ({1, 2}, {0}, {0}),
-                   ({1, 2}, {0}, {1}),
-                   ({1, 2}, {0}, {2}), ({1, 2}, {1}, {0}), ({1, 2}, {1}, {1}),
-                   ({1, 2}, {1}, {2}),
-                   ({0}, {0, 1}, {0}), ({0}, {0, 1}, {1}), ({0}, {0, 1}, {2}),
-                   ({1}, {0, 1}, {0}),
-                   ({1}, {0, 1}, {1}), ({1}, {0, 1}, {2}), ({2}, {0, 1}, {0}),
-                   ({2}, {0, 1}, {1}),
-                   ({2}, {0, 1}, {2}), ({0}, {0}, {0, 1}), ({0}, {0}, {0, 2}),
-                   ({0}, {0}, {1, 2}),
-                   ({0}, {1}, {0, 1}), ({0}, {1}, {0, 2}), ({0}, {1}, {1, 2}),
-                   ({1}, {0}, {0, 1}),
-                   ({1}, {0}, {0, 2}), ({1}, {0}, {1, 2}), ({1}, {1}, {0, 1}),
-                   ({1}, {1}, {0, 2}),
-                   ({1}, {1}, {1, 2}), ({2}, {0}, {0, 1}), ({2}, {0}, {0, 2}),
-                   ({2}, {0}, {1, 2}),
-                   ({2}, {1}, {0, 1}), ({2}, {1}, {0, 2}), ({2}, {1}, {1, 2}),
-                   ({0, 1}, {0, 1}, {0}),
-                   ({0, 1}, {0, 1}, {1}), ({0, 1}, {0, 1}, {2}),
-                   ({0, 2}, {0, 1}, {0}), ({0, 2}, {0, 1}, {1}),
-                   ({0, 2}, {0, 1}, {2}), ({1, 2}, {0, 1}, {0}),
-                   ({1, 2}, {0, 1}, {1}), ({1, 2}, {0, 1}, {2}),
-                   ({0, 1}, {0}, {0, 1}), ({0, 1}, {0}, {0, 2}),
-                   ({0, 1}, {0}, {1, 2}), ({0, 1}, {1}, {0, 1}),
-                   ({0, 1}, {1}, {0, 2}), ({0, 1}, {1}, {1, 2}),
-                   ({0, 2}, {0}, {0, 1}), ({0, 2}, {0}, {0, 2}),
-                   ({0, 2}, {0}, {1, 2}), ({0, 2}, {1}, {0, 1}),
-                   ({0, 2}, {1}, {0, 2}), ({0, 2}, {1}, {1, 2}),
-                   ({1, 2}, {0}, {0, 1}), ({1, 2}, {0}, {0, 2}),
-                   ({1, 2}, {0}, {1, 2}), ({1, 2}, {1}, {0, 1}),
-                   ({1, 2}, {1}, {0, 2}), ({1, 2}, {1}, {1, 2}),
-                   ({0}, {0, 1}, {0, 1}), ({0}, {0, 1}, {0, 2}),
-                   ({0}, {0, 1}, {1, 2}), ({1}, {0, 1}, {0, 1}),
-                   ({1}, {0, 1}, {0, 2}), ({1}, {0, 1}, {1, 2}),
-                   ({2}, {0, 1}, {0, 1}), ({2}, {0, 1}, {0, 2}),
-                   ({2}, {0, 1}, {1, 2}), ({0, 1, 2}, {0}, {0}),
-                   ({0, 1, 2}, {0}, {1}), ({0, 1, 2}, {0}, {2}),
-                   ({0, 1, 2}, {1}, {0}), ({0, 1, 2}, {1}, {1}),
-                   ({0, 1, 2}, {1}, {2}), ({0}, {0}, {0, 1, 2}),
-                   ({0}, {1}, {0, 1, 2}), ({1}, {0}, {0, 1, 2}),
-                   ({1}, {1}, {0, 1, 2}), ({2}, {0}, {0, 1, 2}),
-                   ({2}, {1}, {0, 1, 2}), ({0, 1}, {0, 1}, {0, 1}),
-                   ({0, 1}, {0, 1}, {0, 2}), ({0, 1}, {0, 1}, {1, 2}),
-                   ({0, 2}, {0, 1}, {0, 1}),
-                   ({0, 2}, {0, 1}, {0, 2}),
-                   ({0, 2}, {0, 1}, {1, 2}), ({1, 2}, {0, 1}, {0, 1}),
-                   ({1, 2}, {0, 1}, {0, 2}),
-                   ({1, 2}, {0, 1}, {1, 2}),
-                   ({0, 1, 2}, {0, 1}, {0}), ({0, 1, 2}, {0, 1}, {1}),
-                   ({0, 1, 2}, {0, 1}, {2}),
-                   ({0, 1, 2}, {0}, {0, 1}),
-                   ({0, 1, 2}, {0}, {0, 2}), ({0, 1, 2}, {0}, {1, 2}),
-                   ({0, 1, 2}, {1}, {0, 1}),
-                   ({0, 1, 2}, {1}, {0, 2}),
-                   ({0, 1, 2}, {1}, {1, 2}), ({0, 1}, {0}, {0, 1, 2}),
-                   ({0, 1}, {1}, {0, 1, 2}),
-                   ({0, 2}, {0}, {0, 1, 2}),
-                   ({0, 2}, {1}, {0, 1, 2}), ({1, 2}, {0}, {0, 1, 2}),
-                   ({1, 2}, {1}, {0, 1, 2}),
-                   ({0}, {0, 1}, {0, 1, 2}),
-                   ({1}, {0, 1}, {0, 1, 2}), ({2}, {0, 1}, {0, 1, 2}),
-                   ({0, 1, 2}, {0, 1}, {0, 1}),
-                   ({0, 1, 2}, {0, 1}, {0, 2}),
-                   ({0, 1, 2}, {0, 1}, {1, 2}), ({0, 1}, {0, 1}, {0, 1, 2}),
-                   ({0, 2}, {0, 1}, {0, 1, 2}),
-                   ({1, 2}, {0, 1}, {0, 1, 2}),
-                   ({0, 1, 2}, {0}, {0, 1, 2}), ({0, 1, 2}, {1}, {0, 1, 2}),
-                   ({0, 1, 2}, {0, 1}, {0, 1, 2})]
-    for s_i, s in enumerate(
-            allbalancedsupports([[0, 1, 2], [0, 1], [0, 1, 2]])):
+    all_support = [
+        ({0}, {0}, {0}),
+        ({0}, {0}, {1}),
+        ({0}, {0}, {2}),
+        ({0}, {1}, {0}),
+        ({0}, {1}, {1}),
+        ({0}, {1}, {2}),
+        ({1}, {0}, {0}),
+        ({1}, {0}, {1}),
+        ({1}, {0}, {2}),
+        ({1}, {1}, {0}),
+        ({1}, {1}, {1}),
+        ({1}, {1}, {2}),
+        ({2}, {0}, {0}),
+        ({2}, {0}, {1}),
+        ({2}, {0}, {2}),
+        ({2}, {1}, {0}),
+        ({2}, {1}, {1}),
+        ({2}, {1}, {2}),
+        ({0, 1}, {0}, {0}),
+        ({0, 1}, {0}, {1}),
+        ({0, 1}, {0}, {2}),
+        ({0, 1}, {1}, {0}),
+        ({0, 1}, {1}, {1}),
+        ({0, 1}, {1}, {2}),
+        ({0, 2}, {0}, {0}),
+        ({0, 2}, {0}, {1}),
+        ({0, 2}, {0}, {2}),
+        ({0, 2}, {1}, {0}),
+        ({0, 2}, {1}, {1}),
+        ({0, 2}, {1}, {2}),
+        ({1, 2}, {0}, {0}),
+        ({1, 2}, {0}, {1}),
+        ({1, 2}, {0}, {2}),
+        ({1, 2}, {1}, {0}),
+        ({1, 2}, {1}, {1}),
+        ({1, 2}, {1}, {2}),
+        ({0}, {0, 1}, {0}),
+        ({0}, {0, 1}, {1}),
+        ({0}, {0, 1}, {2}),
+        ({1}, {0, 1}, {0}),
+        ({1}, {0, 1}, {1}),
+        ({1}, {0, 1}, {2}),
+        ({2}, {0, 1}, {0}),
+        ({2}, {0, 1}, {1}),
+        ({2}, {0, 1}, {2}),
+        ({0}, {0}, {0, 1}),
+        ({0}, {0}, {0, 2}),
+        ({0}, {0}, {1, 2}),
+        ({0}, {1}, {0, 1}),
+        ({0}, {1}, {0, 2}),
+        ({0}, {1}, {1, 2}),
+        ({1}, {0}, {0, 1}),
+        ({1}, {0}, {0, 2}),
+        ({1}, {0}, {1, 2}),
+        ({1}, {1}, {0, 1}),
+        ({1}, {1}, {0, 2}),
+        ({1}, {1}, {1, 2}),
+        ({2}, {0}, {0, 1}),
+        ({2}, {0}, {0, 2}),
+        ({2}, {0}, {1, 2}),
+        ({2}, {1}, {0, 1}),
+        ({2}, {1}, {0, 2}),
+        ({2}, {1}, {1, 2}),
+        ({0, 1}, {0, 1}, {0}),
+        ({0, 1}, {0, 1}, {1}),
+        ({0, 1}, {0, 1}, {2}),
+        ({0, 2}, {0, 1}, {0}),
+        ({0, 2}, {0, 1}, {1}),
+        ({0, 2}, {0, 1}, {2}),
+        ({1, 2}, {0, 1}, {0}),
+        ({1, 2}, {0, 1}, {1}),
+        ({1, 2}, {0, 1}, {2}),
+        ({0, 1}, {0}, {0, 1}),
+        ({0, 1}, {0}, {0, 2}),
+        ({0, 1}, {0}, {1, 2}),
+        ({0, 1}, {1}, {0, 1}),
+        ({0, 1}, {1}, {0, 2}),
+        ({0, 1}, {1}, {1, 2}),
+        ({0, 2}, {0}, {0, 1}),
+        ({0, 2}, {0}, {0, 2}),
+        ({0, 2}, {0}, {1, 2}),
+        ({0, 2}, {1}, {0, 1}),
+        ({0, 2}, {1}, {0, 2}),
+        ({0, 2}, {1}, {1, 2}),
+        ({1, 2}, {0}, {0, 1}),
+        ({1, 2}, {0}, {0, 2}),
+        ({1, 2}, {0}, {1, 2}),
+        ({1, 2}, {1}, {0, 1}),
+        ({1, 2}, {1}, {0, 2}),
+        ({1, 2}, {1}, {1, 2}),
+        ({0}, {0, 1}, {0, 1}),
+        ({0}, {0, 1}, {0, 2}),
+        ({0}, {0, 1}, {1, 2}),
+        ({1}, {0, 1}, {0, 1}),
+        ({1}, {0, 1}, {0, 2}),
+        ({1}, {0, 1}, {1, 2}),
+        ({2}, {0, 1}, {0, 1}),
+        ({2}, {0, 1}, {0, 2}),
+        ({2}, {0, 1}, {1, 2}),
+        ({0, 1, 2}, {0}, {0}),
+        ({0, 1, 2}, {0}, {1}),
+        ({0, 1, 2}, {0}, {2}),
+        ({0, 1, 2}, {1}, {0}),
+        ({0, 1, 2}, {1}, {1}),
+        ({0, 1, 2}, {1}, {2}),
+        ({0}, {0}, {0, 1, 2}),
+        ({0}, {1}, {0, 1, 2}),
+        ({1}, {0}, {0, 1, 2}),
+        ({1}, {1}, {0, 1, 2}),
+        ({2}, {0}, {0, 1, 2}),
+        ({2}, {1}, {0, 1, 2}),
+        ({0, 1}, {0, 1}, {0, 1}),
+        ({0, 1}, {0, 1}, {0, 2}),
+        ({0, 1}, {0, 1}, {1, 2}),
+        ({0, 2}, {0, 1}, {0, 1}),
+        ({0, 2}, {0, 1}, {0, 2}),
+        ({0, 2}, {0, 1}, {1, 2}),
+        ({1, 2}, {0, 1}, {0, 1}),
+        ({1, 2}, {0, 1}, {0, 2}),
+        ({1, 2}, {0, 1}, {1, 2}),
+        ({0, 1, 2}, {0, 1}, {0}),
+        ({0, 1, 2}, {0, 1}, {1}),
+        ({0, 1, 2}, {0, 1}, {2}),
+        ({0, 1, 2}, {0}, {0, 1}),
+        ({0, 1, 2}, {0}, {0, 2}),
+        ({0, 1, 2}, {0}, {1, 2}),
+        ({0, 1, 2}, {1}, {0, 1}),
+        ({0, 1, 2}, {1}, {0, 2}),
+        ({0, 1, 2}, {1}, {1, 2}),
+        ({0, 1}, {0}, {0, 1, 2}),
+        ({0, 1}, {1}, {0, 1, 2}),
+        ({0, 2}, {0}, {0, 1, 2}),
+        ({0, 2}, {1}, {0, 1, 2}),
+        ({1, 2}, {0}, {0, 1, 2}),
+        ({1, 2}, {1}, {0, 1, 2}),
+        ({0}, {0, 1}, {0, 1, 2}),
+        ({1}, {0, 1}, {0, 1, 2}),
+        ({2}, {0, 1}, {0, 1, 2}),
+        ({0, 1, 2}, {0, 1}, {0, 1}),
+        ({0, 1, 2}, {0, 1}, {0, 2}),
+        ({0, 1, 2}, {0, 1}, {1, 2}),
+        ({0, 1}, {0, 1}, {0, 1, 2}),
+        ({0, 2}, {0, 1}, {0, 1, 2}),
+        ({1, 2}, {0, 1}, {0, 1, 2}),
+        ({0, 1, 2}, {0}, {0, 1, 2}),
+        ({0, 1, 2}, {1}, {0, 1, 2}),
+        ({0, 1, 2}, {0, 1}, {0, 1, 2}),
+    ]
+    for s_i, s in enumerate(allbalancedsupports([[0, 1, 2], [0, 1], [0, 1, 2]])):
         assert s == all_support[s_i]
 
 
 def test_allbalancedsupports3():
-    all_support = [({1}, {0}, {0}), ({1}, {0}, {1}), ({1}, {0}, {2}),
-                   ({1}, {0}, {0, 1}), ({1}, {0}, {0, 2}), ({1}, {0}, {1, 2}),
-                   ({1}, {0}, {0, 1, 2})]
+    all_support = [
+        ({1}, {0}, {0}),
+        ({1}, {0}, {1}),
+        ({1}, {0}, {2}),
+        ({1}, {0}, {0, 1}),
+        ({1}, {0}, {0, 2}),
+        ({1}, {0}, {1, 2}),
+        ({1}, {0}, {0, 1, 2}),
+    ]
     for s_i, s in enumerate(allbalancedsupports([[1], [0], [0, 1, 2]])):
         assert s == all_support[s_i]
 
@@ -192,7 +281,8 @@ def pns_4player_nfg():
         [50, 59, 27, 4, 72, 69, 18, 35, 6, 89, 78, 19, 36, 76, 64, 20],
         [97, 5, 90, 60, 6, 13, 56, 82, 89, 79, 52, 34, 35, 100, 60, 34],
         [15, 30, 53, 12, 79, 77, 15, 38, 100, 82, 35, 10, 24, 0, 29, 27],
-        [28, 66, 83, 1, 54, 89, 71, 35, 46, 62, 96, 26, 20, 58, 16, 81]]
+        [28, 66, 83, 1, 54, 89, 71, 35, 46, 62, 96, 26, 20, 58, 16, 81],
+    ]
 
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
     tmp_nfg = NFG(players_actions, utilities)
@@ -207,8 +297,11 @@ def empty_pns():
 @pytest.fixture
 def pns_3player_nfg():
     players_actions = [[0, 1], [0, 1], [0, 1]]
-    utilities = [[6, 7, 0, 5, 1, 4, 2, 3], [0, 3, 7, 4, 6, 5, 1, 2],
-                 [4, 7, 4, 0, 3, 2, 6, 1]]
+    utilities = [
+        [6, 7, 0, 5, 1, 4, 2, 3],
+        [0, 3, 7, 4, 6, 5, 1, 2],
+        [4, 7, 4, 0, 3, 2, 6, 1],
+    ]
     current_nfg = NFG(players_actions, utilities)
     return PNS_solver(current_nfg)
 
@@ -219,7 +312,8 @@ def pns_4p_nfg_degen():
         [50, 59, 27, 4, 72, 69, 18, 35, 6, 89, 78, 19, 36, 76, 64, 20],
         [97, 5, 90, 60, 6, 13, 56, 82, 89, 79, 52, 34, 35, 100, 60, 34],
         [15, 30, 53, 12, 79, 77, 15, 38, 100, 82, 35, 10, 24, 0, 29, 27],
-        [28, 66, 83, 1, 54, 89, 71, 35, 46, 62, 96, 26, 20, 58, 16, 81]]
+        [28, 66, 83, 1, 54, 89, 71, 35, 46, 62, 96, 26, 20, 58, 16, 81],
+    ]
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
     current_nfg = NFG(players_actions, utilities)
     return PNS_solver(current_nfg)
@@ -229,9 +323,14 @@ def pns_4p_nfg_degen():
 def pns_hgg1():
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
     utilities = [
-        [[-3, -7, -7, -10, -1, -5, -5, -9], [-3, -7, -1, -5, -7, -10, -5, -9],
-         [-3, -1, -7, -5, -7, -5, -10, -9]],
-        [[-1, -5, 0, -3], [-1, 0, -5, -3]], [[-1, -5, 0, -3], [-1, 0, -5, -3]]]
+        [
+            [-3, -7, -7, -10, -1, -5, -5, -9],
+            [-3, -7, -1, -5, -7, -10, -5, -9],
+            [-3, -1, -7, -5, -7, -5, -10, -9],
+        ],
+        [[-1, -5, 0, -3], [-1, 0, -5, -3]],
+        [[-1, -5, 0, -3], [-1, 0, -5, -3]],
+    ]
     hypergraph = [[0, 1, 2], [1, 3], [2, 3]]
     hgg = HGG(players_actions, utilities, hypergraph)
     return PNS_solver(hgg)
@@ -240,10 +339,14 @@ def pns_hgg1():
 @pytest.fixture
 def pns_hgg2():
     utilities = [
-        [[-3, -1, -3, -2, -2, -3, -2, -1], [-1, -3, -5, -1, -1, -6, -3, -4],
-         [-2, -3, -6, -4, -3, -1, -3, -4]],
+        [
+            [-3, -1, -3, -2, -2, -3, -2, -1],
+            [-1, -3, -5, -1, -1, -6, -3, -4],
+            [-2, -3, -6, -4, -3, -1, -3, -4],
+        ],
         [[-1, -3, -2, -2], [-1, -2, -2, -1]],
-        [[-3, -1, -4, -5], [-1, -3, -1, -5]]]
+        [[-3, -1, -4, -5], [-1, -3, -1, -5]],
+    ]
     # Error up level impossible, 2->3, [[0,1],[0,1],[0,1],[0,1]]
     hypergraph = [[0, 1, 2], [1, 3], [2, 3]]
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
@@ -254,10 +357,17 @@ def pns_hgg2():
 @pytest.fixture
 def pns_hgg3():
     utilities = [
-        [[74, 6, 9, 60, 77, 30, 47, 0], [51, 97, 98, 83, 90, 1, 2, 47],
-         [18, 16, 29, 86, 100, 96, 93, 64]],
-        [[84, 48, 27, 5, 100, 62, 16, 62], [10, 88, 72, 47, 13, 24, 42, 72],
-         [1, 36, 68, 0, 53, 5, 61, 97]]]
+        [
+            [74, 6, 9, 60, 77, 30, 47, 0],
+            [51, 97, 98, 83, 90, 1, 2, 47],
+            [18, 16, 29, 86, 100, 96, 93, 64],
+        ],
+        [
+            [84, 48, 27, 5, 100, 62, 16, 62],
+            [10, 88, 72, 47, 13, 24, 42, 72],
+            [1, 36, 68, 0, 53, 5, 61, 97],
+        ],
+    ]
     hypergraph = [[0, 1, 3], [0, 2, 3]]
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
     hgg = HGG(players_actions, utilities, hypergraph)
@@ -268,10 +378,17 @@ def pns_hgg3():
 def pns_hgg_irda1():
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
     utilities = [
-        [[87, 77, 0, 49, 63, 99, 98, 25], [76, 100, 10, 43, 73, 65, 8, 56],
-         [8, 36, 3, 100, 24, 3, 64, 28]],
-        [[67, 38, 60, 64, 55, 100, 16, 13], [23, 59, 0, 9, 1, 8, 47, 33],
-         [9, 7, 100, 39, 16, 18, 16, 62]]]
+        [
+            [87, 77, 0, 49, 63, 99, 98, 25],
+            [76, 100, 10, 43, 73, 65, 8, 56],
+            [8, 36, 3, 100, 24, 3, 64, 28],
+        ],
+        [
+            [67, 38, 60, 64, 55, 100, 16, 13],
+            [23, 59, 0, 9, 1, 8, 47, 33],
+            [9, 7, 100, 39, 16, 18, 16, 62],
+        ],
+    ]
     hypergraph = [[0, 1, 2], [1, 2, 3]]
     hgg = HGG(players_actions, utilities, hypergraph)
     red_hgg, z_excluded = irda(hgg)
@@ -282,10 +399,17 @@ def pns_hgg_irda1():
 def pns_hgg_irda2():
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
     utilities = [
-        [[29, 39, 100, 46, 40, 18, 97, 37], [23, 81, 64, 62, 90, 73, 76, 53],
-         [26, 36, 51, 5, 14, 99, 0, 54]],
-        [[12, 37, 7, 7, 41, 59, 27, 86], [65, 100, 100, 49, 97, 31, 68, 58],
-         [29, 70, 44, 61, 0, 53, 92, 74]]]
+        [
+            [29, 39, 100, 46, 40, 18, 97, 37],
+            [23, 81, 64, 62, 90, 73, 76, 53],
+            [26, 36, 51, 5, 14, 99, 0, 54],
+        ],
+        [
+            [12, 37, 7, 7, 41, 59, 27, 86],
+            [65, 100, 100, 49, 97, 31, 68, 58],
+            [29, 70, 44, 61, 0, 53, 92, 74],
+        ],
+    ]
     hypergraph = [[0, 2, 3], [1, 2, 3]]
     hgg = HGG(players_actions, utilities, hypergraph)
     red_hgg, z_excluded = irda(hgg)
@@ -326,78 +450,101 @@ def test_final_support_size8(pns_hgg_irda2):
 
 def test_support_to_strategy1(pns_4player_nfg):
     assert pns_4player_nfg.support_to_strategy(({0}, {0}, {0}, {0})) == {
-        0: [1, 0], 1: [1, 0], 2: [1, 0], 3: [1, 0]}
+        0: [1, 0],
+        1: [1, 0],
+        2: [1, 0],
+        3: [1, 0],
+    }
 
 
 def test_support_to_strategy2(pns_4player_nfg):
-    assert pns_4player_nfg.support_to_strategy(
-        ({0, 1}, {0, 1}, {0, 1}, {0, 1})) == {0: [1, 1], 1: [1, 1], 2: [1, 1],
-                                              3: [1, 1]}
+    assert pns_4player_nfg.support_to_strategy(({0, 1}, {0, 1}, {0, 1}, {0, 1})) == {
+        0: [1, 1],
+        1: [1, 1],
+        2: [1, 1],
+        3: [1, 1],
+    }
 
 
 def test_support_to_strategy3(pns_4player_nfg):
     assert pns_4player_nfg.support_to_strategy(({0, 1}, {1}, {0}, {1})) == {
-        0: [1, 1], 1: [0, 1], 2: [1, 0], 3: [0, 1]}
+        0: [1, 1],
+        1: [0, 1],
+        2: [1, 0],
+        3: [0, 1],
+    }
 
 
 def test_support_to_strategy4(pns_hgg_irda1):
     assert pns_hgg_irda1.support_to_strategy(({0, 1}, {0}, {1}, {0})) == {
-        0: [1, 1], 1: [1], 2: [0, 1], 3: [1]}
+        0: [1, 1],
+        1: [1],
+        2: [0, 1],
+        3: [1],
+    }
 
 
 def test_support_to_strategy5(pns_hgg_irda2):
     assert pns_hgg_irda2.support_to_strategy(({0, 1}, {1}, {0}, {1})) == {
-        0: [1, 1], 1: [1], 2: [1, 0], 3: [0, 1]}
+        0: [1, 1],
+        1: [1],
+        2: [1, 0],
+        3: [0, 1],
+    }
 
 
 def test_create_W_from_support_strat1(pns_4player_nfg):
     stratsupport = pns_4player_nfg.support_to_strategy(({0}, {0}, {0}, {0}))
-    assert set(
-        pns_4player_nfg.create_W_from_support_strat(stratsupport)) == set(
-        [(0, 0), (1, 0), (2, 0), (3, 0)])
+    assert set(pns_4player_nfg.create_W_from_support_strat(stratsupport)) == set(
+        [(0, 0), (1, 0), (2, 0), (3, 0)]
+    )
 
 
 def test_create_W_from_support_strat2(pns_4player_nfg):
-    stratsupport = pns_4player_nfg.support_to_strategy(
-        ({0, 1}, {0, 1}, {0, 1}, {0, 1}))
-    assert set(
-        pns_4player_nfg.create_W_from_support_strat(stratsupport)) == {(0, 0),
-                                                                       (1, 0),
-                                                                       (2, 0),
-                                                                       (3, 0),
-                                                                       (0, 1),
-                                                                       (1, 1),
-                                                                       (2, 1),
-                                                                       (3, 1)}
+    stratsupport = pns_4player_nfg.support_to_strategy(({0, 1}, {0, 1}, {0, 1}, {0, 1}))
+    assert set(pns_4player_nfg.create_W_from_support_strat(stratsupport)) == {
+        (0, 0),
+        (1, 0),
+        (2, 0),
+        (3, 0),
+        (0, 1),
+        (1, 1),
+        (2, 1),
+        (3, 1),
+    }
 
 
 def test_create_W_from_support_strat3(pns_hgg_irda1):
     stratsupport = pns_hgg_irda1.support_to_strategy(({0}, {0}, {0}, {0}))
     assert set(pns_hgg_irda1.create_W_from_support_strat(stratsupport)) == {
-        (0, 0), (1, 0), (2, 0), (3, 0)}
+        (0, 0),
+        (1, 0),
+        (2, 0),
+        (3, 0),
+    }
 
 
 def test_create_Wb_from_support_strat1(pns_4player_nfg):
     stratsupport = pns_4player_nfg.support_to_strategy(({0}, {0}, {0}, {0}))
-    assert set(
-        pns_4player_nfg.create_Wb_from_support_strat(stratsupport)) == {(0, 1),
-                                                                        (1, 1),
-                                                                        (2, 1),
-                                                                        (3, 1)}
+    assert set(pns_4player_nfg.create_Wb_from_support_strat(stratsupport)) == {
+        (0, 1),
+        (1, 1),
+        (2, 1),
+        (3, 1),
+    }
 
 
 def test_create_Wb_from_support_strat2(pns_4player_nfg):
-    stratsupport = pns_4player_nfg.support_to_strategy(
-        ({0, 1}, {0, 1}, {0, 1}, {0, 1}))
-    assert set(
-        pns_4player_nfg.create_Wb_from_support_strat(stratsupport)) == set([])
+    stratsupport = pns_4player_nfg.support_to_strategy(({0, 1}, {0, 1}, {0, 1}, {0, 1}))
+    assert set(pns_4player_nfg.create_Wb_from_support_strat(stratsupport)) == set([])
 
 
 def test_create_Wb_from_support_strat3(pns_hgg_irda1):
     stratsupport = pns_hgg_irda1.support_to_strategy(({0}, {0}, {0}, {0}))
-    assert set(
-        pns_hgg_irda1.create_Wb_from_support_strat(stratsupport)) == {(0, 1),
-                                                                      (2, 1)}
+    assert set(pns_hgg_irda1.create_Wb_from_support_strat(stratsupport)) == {
+        (0, 1),
+        (2, 1),
+    }
 
 
 def test_launch_pns1(pns_4player_nfg):
@@ -405,50 +552,71 @@ def test_launch_pns1(pns_4player_nfg):
     # for x in sol.keys():
     #     for v_i, v in enumerate(sol[x]):
     #         print(v.radical_expression())
-    check_sol = {0: [Fraction(65, 103), Fraction(38, 103)], 1: [1, 0],
-                 2: [Fraction(51, 95), Fraction(44, 95)], 3: [1, 0]}
+    check_sol = {
+        0: [Fraction(65, 103), Fraction(38, 103)],
+        1: [1, 0],
+        2: [Fraction(51, 95), Fraction(44, 95)],
+        3: [1, 0],
+    }
     for p in sol.keys():
         for v_i, v in enumerate(sol[p]):
-            assert float(v) - check_sol[p][v_i] < 0.00001 and float(v) - \
-                   check_sol[p][v_i] > -0.000001
+            assert (
+                float(v) - check_sol[p][v_i] < 0.00001
+                and float(v) - check_sol[p][v_i] > -0.000001
+            )
 
 
 def test_launch_pns2(pns_hgg1):
-    assert pns_hgg1.launch_pns() == {0: [0, 1], 1: [0, 1], 2: [0, 1],
-                                     3: [0, 1]}
+    assert pns_hgg1.launch_pns() == {0: [0, 1], 1: [0, 1], 2: [0, 1], 3: [0, 1]}
 
 
 def test_launch_pns3(pns_hgg2):
     sol = pns_hgg2.launch_pns()
-    check_sol = {0: [Fraction(1, 3), Fraction(2, 3)], 1: [1, 0],
-                 2: [Fraction(2, 3), Fraction(1, 3)], 3: [1, 0]}
+    check_sol = {
+        0: [Fraction(1, 3), Fraction(2, 3)],
+        1: [1, 0],
+        2: [Fraction(2, 3), Fraction(1, 3)],
+        3: [1, 0],
+    }
     for p in sol.keys():
         for v_i, v in enumerate(sol[p]):
-            assert float(v) - check_sol[p][v_i] < 0.00001 and float(v) - \
-                   check_sol[p][v_i] > -0.000001
+            assert (
+                float(v) - check_sol[p][v_i] < 0.00001
+                and float(v) - check_sol[p][v_i] > -0.000001
+            )
 
 
 def test_launch_pns4(pns_hgg3):
     sol = pns_hgg3.launch_pns()
-    check_sol = {0: [Fraction(23, 30), Fraction(7, 30)],
-                 1: [Fraction(23, 42), Fraction(19, 42)], 2: [1, 0],
-                 3: [0, 1]}
+    check_sol = {
+        0: [Fraction(23, 30), Fraction(7, 30)],
+        1: [Fraction(23, 42), Fraction(19, 42)],
+        2: [1, 0],
+        3: [0, 1],
+    }
     for p in sol.keys():
         for v_i, v in enumerate(sol[p]):
-            assert float(v) - check_sol[p][v_i] < 0.00001 and float(v) - \
-                   check_sol[p][v_i] > -0.000001
+            assert (
+                float(v) - check_sol[p][v_i] < 0.00001
+                and float(v) - check_sol[p][v_i] > -0.000001
+            )
 
 
 def test_launch_pns5(pns_hgg_irda1):
     sol = pns_hgg_irda1.launch_pns()
-    check_sol = {0: [Fraction(44, 49), Fraction(5, 49)], 1: [1],
-                 2: [Fraction(11, 23), Fraction(12, 23)], 3: [1]}
+    check_sol = {
+        0: [Fraction(44, 49), Fraction(5, 49)],
+        1: [1],
+        2: [Fraction(11, 23), Fraction(12, 23)],
+        3: [1],
+    }
     for p in sol.keys():
         for v_i, v in enumerate(sol[p]):
-            assert float(v) - check_sol[p][v_i] < 0.00001 and float(v) - \
-                   check_sol[p][v_i] > -0.000001
+            assert (
+                float(v) - check_sol[p][v_i] < 0.00001
+                and float(v) - check_sol[p][v_i] > -0.000001
+            )
 
 
 def test_launch_pns6(pns_hgg_irda2):
-    assert pns_hgg_irda2.launch_pns() == {0: [1, 0], 1: [1], 2: [0, 1],
-                                          3: [1, 0]}
+    assert pns_hgg_irda2.launch_pns() == {0: [1, 0], 1: [1], 2: [0, 1], 3: [1, 0]}
diff --git a/test/test_polynomial_complementary_problem.py b/test/test_polynomial_complementary_problem.py
index 70d1a50..c3ac03d 100644
--- a/test/test_polynomial_complementary_problem.py
+++ b/test/test_polynomial_complementary_problem.py
@@ -2,10 +2,13 @@ import numpy as np
 import pytest
 from sage.all import ideal
 
-from gtnash.util.polynomial_complementary_problem import \
-    PolynomialComplementaryProblem, Subsystem
+from gtnash.util.polynomial_complementary_problem import (
+    PolynomialComplementaryProblem,
+    Subsystem,
+)
 from gtnash.game.normalformgame import NFG
 from gtnash.game.hypergraphicalgame import HGG
+
 # from gtnash.util.irda import irda
 #
 # from fractions import Fraction
@@ -41,7 +44,8 @@ def pcp_4player_nfg():
         [50, 59, 27, 4, 72, 69, 18, 35, 6, 89, 78, 19, 36, 76, 64, 20],
         [97, 5, 90, 60, 6, 13, 56, 82, 89, 79, 52, 34, 35, 100, 60, 34],
         [15, 30, 53, 12, 79, 77, 15, 38, 100, 82, 35, 10, 24, 0, 29, 27],
-        [28, 66, 83, 1, 54, 89, 71, 35, 46, 62, 96, 26, 20, 58, 16, 81]]
+        [28, 66, 83, 1, 54, 89, 71, 35, 46, 62, 96, 26, 20, 58, 16, 81],
+    ]
 
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
     tmp_nfg = NFG(players_actions, utilities)
@@ -57,8 +61,11 @@ def empty_pcp():
 @pytest.fixture
 def pcp_3player_nfg():
     players_actions = [[0, 1], [0, 1], [0, 1]]
-    utilities = [[6, 7, 0, 5, 1, 4, 2, 3], [0, 3, 7, 4, 6, 5, 1, 2],
-                 [4, 7, 4, 0, 3, 2, 6, 1]]
+    utilities = [
+        [6, 7, 0, 5, 1, 4, 2, 3],
+        [0, 3, 7, 4, 6, 5, 1, 2],
+        [4, 7, 4, 0, 3, 2, 6, 1],
+    ]
     current_nfg = NFG(players_actions, utilities)
     return PolynomialComplementaryProblem(current_nfg)
 
@@ -66,8 +73,11 @@ def pcp_3player_nfg():
 @pytest.fixture
 def pcp_3player_nfg_no_y():
     players_actions = [[0, 1], [0, 1], [0, 1]]
-    utilities = [[6, 7, 0, 5, 1, 4, 2, 3], [0, 3, 7, 4, 6, 5, 1, 2],
-                 [4, 7, 4, 0, 3, 2, 6, 1]]
+    utilities = [
+        [6, 7, 0, 5, 1, 4, 2, 3],
+        [0, 3, 7, 4, 6, 5, 1, 2],
+        [4, 7, 4, 0, 3, 2, 6, 1],
+    ]
     current_nfg = NFG(players_actions, utilities)
     return PolynomialComplementaryProblem(current_nfg, fact_y=False)
 
@@ -78,7 +88,8 @@ def pcp_4p_nfg_degen():
         [50, 59, 27, 4, 72, 69, 18, 35, 6, 89, 78, 19, 36, 76, 64, 20],
         [97, 5, 90, 60, 6, 13, 56, 82, 89, 79, 52, 34, 35, 100, 60, 34],
         [15, 30, 53, 12, 79, 77, 15, 38, 100, 82, 35, 10, 24, 0, 29, 27],
-        [28, 66, 83, 1, 54, 89, 71, 35, 46, 62, 96, 26, 20, 58, 16, 81]]
+        [28, 66, 83, 1, 54, 89, 71, 35, 46, 62, 96, 26, 20, 58, 16, 81],
+    ]
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
     current_nfg = NFG(players_actions, utilities)
     return PolynomialComplementaryProblem(current_nfg)
@@ -88,9 +99,14 @@ def pcp_4p_nfg_degen():
 def pcp_hgg1():
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
     utilities = [
-        [[-3, -7, -7, -10, -1, -5, -5, -9], [-3, -7, -1, -5, -7, -10, -5, -9],
-         [-3, -1, -7, -5, -7, -5, -10, -9]],
-        [[-1, -5, 0, -3], [-1, 0, -5, -3]], [[-1, -5, 0, -3], [-1, 0, -5, -3]]]
+        [
+            [-3, -7, -7, -10, -1, -5, -5, -9],
+            [-3, -7, -1, -5, -7, -10, -5, -9],
+            [-3, -1, -7, -5, -7, -5, -10, -9],
+        ],
+        [[-1, -5, 0, -3], [-1, 0, -5, -3]],
+        [[-1, -5, 0, -3], [-1, 0, -5, -3]],
+    ]
     hypergraph = [[0, 1, 2], [1, 3], [2, 3]]
     hgg = HGG(players_actions, utilities, hypergraph)
     return PolynomialComplementaryProblem(hgg)
@@ -99,9 +115,14 @@ def pcp_hgg1():
 def pcp_hgg1_no_y():
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
     utilities = [
-        [[-3, -7, -7, -10, -1, -5, -5, -9], [-3, -7, -1, -5, -7, -10, -5, -9],
-         [-3, -1, -7, -5, -7, -5, -10, -9]],
-        [[-1, -5, 0, -3], [-1, 0, -5, -3]], [[-1, -5, 0, -3], [-1, 0, -5, -3]]]
+        [
+            [-3, -7, -7, -10, -1, -5, -5, -9],
+            [-3, -7, -1, -5, -7, -10, -5, -9],
+            [-3, -1, -7, -5, -7, -5, -10, -9],
+        ],
+        [[-1, -5, 0, -3], [-1, 0, -5, -3]],
+        [[-1, -5, 0, -3], [-1, 0, -5, -3]],
+    ]
     hypergraph = [[0, 1, 2], [1, 3], [2, 3]]
     hgg = HGG(players_actions, utilities, hypergraph)
     return PolynomialComplementaryProblem(hgg, fact_y=False)
@@ -110,10 +131,14 @@ def pcp_hgg1_no_y():
 @pytest.fixture
 def pcp_hgg2():
     utilities = [
-        [[-3, -1, -3, -2, -2, -3, -2, -1], [-1, -3, -5, -1, -1, -6, -3, -4],
-         [-2, -3, -6, -4, -3, -1, -3, -4]],
+        [
+            [-3, -1, -3, -2, -2, -3, -2, -1],
+            [-1, -3, -5, -1, -1, -6, -3, -4],
+            [-2, -3, -6, -4, -3, -1, -3, -4],
+        ],
         [[-1, -3, -2, -2], [-1, -2, -2, -1]],
-        [[-3, -1, -4, -5], [-1, -3, -1, -5]]]
+        [[-3, -1, -4, -5], [-1, -3, -1, -5]],
+    ]
     # Error up level impossible, 2->3, [[0,1],[0,1],[0,1],[0,1]]
     hypergraph = [[0, 1, 2], [1, 3], [2, 3]]
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
@@ -124,10 +149,17 @@ def pcp_hgg2():
 @pytest.fixture
 def pcp_hgg3():
     utilities = [
-        [[74, 6, 9, 60, 77, 30, 47, 0], [51, 97, 98, 83, 90, 1, 2, 47],
-         [18, 16, 29, 86, 100, 96, 93, 64]],
-        [[84, 48, 27, 5, 100, 62, 16, 62], [10, 88, 72, 47, 13, 24, 42, 72],
-         [1, 36, 68, 0, 53, 5, 61, 97]]]
+        [
+            [74, 6, 9, 60, 77, 30, 47, 0],
+            [51, 97, 98, 83, 90, 1, 2, 47],
+            [18, 16, 29, 86, 100, 96, 93, 64],
+        ],
+        [
+            [84, 48, 27, 5, 100, 62, 16, 62],
+            [10, 88, 72, 47, 13, 24, 42, 72],
+            [1, 36, 68, 0, 53, 5, 61, 97],
+        ],
+    ]
     hypergraph = [[0, 1, 3], [0, 2, 3]]
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
     hgg = HGG(players_actions, utilities, hypergraph)
@@ -139,40 +171,48 @@ def test_generate_id_to_act1(empty_pcp):
 
 
 def test_generate_id_to_act2(pcp_4player_nfg):
-    assert pcp_4player_nfg.generate_id_to_act() == {0: [0, 1], 1: [0, 1],
-                                                    2: [0, 1], 3: [0, 1]}
+    assert pcp_4player_nfg.generate_id_to_act() == {
+        0: [0, 1],
+        1: [0, 1],
+        2: [0, 1],
+        3: [0, 1],
+    }
 
 
 def test_generate_id_to_act3(pcp_3player_nfg):
-    assert pcp_3player_nfg.generate_id_to_act() == {0: [0, 1], 1: [0, 1],
-                                                    2: [0, 1]}
+    assert pcp_3player_nfg.generate_id_to_act() == {0: [0, 1], 1: [0, 1], 2: [0, 1]}
 
 
 def test_generate_id_to_act4(pcp_4p_nfg_degen):
-    assert pcp_4p_nfg_degen.generate_id_to_act() == {0: [0, 1], 1: [0, 1],
-                                                     2: [0, 1], 3: [0, 1]}
+    assert pcp_4p_nfg_degen.generate_id_to_act() == {
+        0: [0, 1],
+        1: [0, 1],
+        2: [0, 1],
+        3: [0, 1],
+    }
 
 
 def test_generate_id_to_act5(pcp_hgg1):
-    assert pcp_hgg1.generate_id_to_act() == {0: [0, 1], 1: [0, 1], 2: [0, 1],
-                                             3: [0, 1]}
+    assert pcp_hgg1.generate_id_to_act() == {0: [0, 1], 1: [0, 1], 2: [0, 1], 3: [0, 1]}
 
 
 def test_generate_id_to_act6(pcp_hgg2):
-    assert pcp_hgg2.generate_id_to_act() == {0: [0, 1], 1: [0, 1], 2: [0, 1],
-                                             3: [0, 1]}
+    assert pcp_hgg2.generate_id_to_act() == {0: [0, 1], 1: [0, 1], 2: [0, 1], 3: [0, 1]}
 
 
 def test_generate_id_to_act7(pcp_hgg3):
-    assert pcp_hgg3.generate_id_to_act() == {0: [0, 1], 1: [0, 1], 2: [0, 1],
-                                             3: [0, 1]}
+    assert pcp_hgg3.generate_id_to_act() == {0: [0, 1], 1: [0, 1], 2: [0, 1], 3: [0, 1]}
 
 
 def test_generate_id_to_act8(empty_pcp):
     players_actions = [[0, 1, 2], [0, 1, 2], [0, 1, 2, 3], [0, 1]]
     empty_pcp.game = gen_random_nfg(players_actions)
-    assert empty_pcp.generate_id_to_act() == {0: [0, 1, 2], 1: [0, 1, 2],
-                                              2: [0, 1, 2, 3], 3: [0, 1]}
+    assert empty_pcp.generate_id_to_act() == {
+        0: [0, 1, 2],
+        1: [0, 1, 2],
+        2: [0, 1, 2, 3],
+        3: [0, 1],
+    }
 
 
 def test_generate_id_to_nb_act1(empty_pcp):
@@ -213,15 +253,34 @@ def test_gen_var_x0(empty_pcp):
     players_actions = [[0, 1, 2], [0, 1, 2], [0, 1, 2, 3], [0, 1]]
     empty_pcp.game = gen_random_nfg(players_actions)
     empty_pcp.gen_var_x()
-    assert empty_pcp.set_x == ['x0_0', 'x0_1', 'x0_2', 'x1_0', 'x1_1', 'x1_2',
-                               'x2_0', 'x2_1', 'x2_2', 'x2_3', 'x3_0',
-                               'x3_1', ]
-    assert empty_pcp.couple_to_x == {(0, 0): 'x0_0', (0, 1): 'x0_1',
-                                     (0, 2): 'x0_2', (1, 0): 'x1_0',
-                                     (1, 1): 'x1_1', (1, 2): 'x1_2',
-                                     (2, 0): 'x2_0', (2, 1): 'x2_1',
-                                     (2, 2): 'x2_2', (2, 3): 'x2_3',
-                                     (3, 0): 'x3_0', (3, 1): 'x3_1'}
+    assert empty_pcp.set_x == [
+        "x0_0",
+        "x0_1",
+        "x0_2",
+        "x1_0",
+        "x1_1",
+        "x1_2",
+        "x2_0",
+        "x2_1",
+        "x2_2",
+        "x2_3",
+        "x3_0",
+        "x3_1",
+    ]
+    assert empty_pcp.couple_to_x == {
+        (0, 0): "x0_0",
+        (0, 1): "x0_1",
+        (0, 2): "x0_2",
+        (1, 0): "x1_0",
+        (1, 1): "x1_1",
+        (1, 2): "x1_2",
+        (2, 0): "x2_0",
+        (2, 1): "x2_1",
+        (2, 2): "x2_2",
+        (2, 3): "x2_3",
+        (3, 0): "x3_0",
+        (3, 1): "x3_1",
+    }
 
 
 # {(0,0):'x0_0','x0_1','x0_2',
@@ -231,61 +290,136 @@ def test_gen_var_x0(empty_pcp):
 
 
 def test_gen_var_x1(pcp_3player_nfg):
-    assert pcp_3player_nfg.set_x == ['x0_0', 'x0_1', 'x1_0', 'x1_1', 'x2_0',
-                                     'x2_1']
-    assert pcp_3player_nfg.couple_to_x == {(0, 0): 'x0_0', (0, 1): 'x0_1',
-                                           (1, 0): 'x1_0', (1, 1): 'x1_1',
-                                           (2, 0): 'x2_0', (2, 1): 'x2_1'}
+    assert pcp_3player_nfg.set_x == ["x0_0", "x0_1", "x1_0", "x1_1", "x2_0", "x2_1"]
+    assert pcp_3player_nfg.couple_to_x == {
+        (0, 0): "x0_0",
+        (0, 1): "x0_1",
+        (1, 0): "x1_0",
+        (1, 1): "x1_1",
+        (2, 0): "x2_0",
+        (2, 1): "x2_1",
+    }
 
 
 def test_gen_var_x2(pcp_4player_nfg):
-    assert pcp_4player_nfg.set_x == ['x0_0', 'x0_1', 'x1_0', 'x1_1', 'x2_0',
-                                     'x2_1', 'x3_0', 'x3_1']
-    assert pcp_4player_nfg.couple_to_x == {(0, 0): 'x0_0', (0, 1): 'x0_1',
-                                           (1, 0): 'x1_0', (1, 1): 'x1_1',
-                                           (2, 0): 'x2_0', (2, 1): 'x2_1',
-                                           (3, 0): 'x3_0', (3, 1): 'x3_1'}
+    assert pcp_4player_nfg.set_x == [
+        "x0_0",
+        "x0_1",
+        "x1_0",
+        "x1_1",
+        "x2_0",
+        "x2_1",
+        "x3_0",
+        "x3_1",
+    ]
+    assert pcp_4player_nfg.couple_to_x == {
+        (0, 0): "x0_0",
+        (0, 1): "x0_1",
+        (1, 0): "x1_0",
+        (1, 1): "x1_1",
+        (2, 0): "x2_0",
+        (2, 1): "x2_1",
+        (3, 0): "x3_0",
+        (3, 1): "x3_1",
+    }
 
 
 def test_gen_var_x3(pcp_4p_nfg_degen):
-    assert pcp_4p_nfg_degen.set_x == ['x0_0', 'x0_1', 'x1_0', 'x1_1', 'x2_0',
-                                      'x2_1', 'x3_0', 'x3_1']
-    assert pcp_4p_nfg_degen.couple_to_x == {(0, 0): 'x0_0', (0, 1): 'x0_1',
-                                            (1, 0): 'x1_0', (1, 1): 'x1_1',
-                                            (2, 0): 'x2_0', (2, 1): 'x2_1',
-                                            (3, 0): 'x3_0', (3, 1): 'x3_1'}
+    assert pcp_4p_nfg_degen.set_x == [
+        "x0_0",
+        "x0_1",
+        "x1_0",
+        "x1_1",
+        "x2_0",
+        "x2_1",
+        "x3_0",
+        "x3_1",
+    ]
+    assert pcp_4p_nfg_degen.couple_to_x == {
+        (0, 0): "x0_0",
+        (0, 1): "x0_1",
+        (1, 0): "x1_0",
+        (1, 1): "x1_1",
+        (2, 0): "x2_0",
+        (2, 1): "x2_1",
+        (3, 0): "x3_0",
+        (3, 1): "x3_1",
+    }
 
 
 def test_gen_var_x4(pcp_hgg1):
-    assert pcp_hgg1.set_x == ['x0_0', 'x0_1', 'x1_0', 'x1_1', 'x2_0', 'x2_1',
-                              'x3_0', 'x3_1']
-    assert pcp_hgg1.couple_to_x == {(0, 0): 'x0_0', (0, 1): 'x0_1',
-                                    (1, 0): 'x1_0', (1, 1): 'x1_1',
-                                    (2, 0): 'x2_0', (2, 1): 'x2_1',
-                                    (3, 0): 'x3_0', (3, 1): 'x3_1'}
+    assert pcp_hgg1.set_x == [
+        "x0_0",
+        "x0_1",
+        "x1_0",
+        "x1_1",
+        "x2_0",
+        "x2_1",
+        "x3_0",
+        "x3_1",
+    ]
+    assert pcp_hgg1.couple_to_x == {
+        (0, 0): "x0_0",
+        (0, 1): "x0_1",
+        (1, 0): "x1_0",
+        (1, 1): "x1_1",
+        (2, 0): "x2_0",
+        (2, 1): "x2_1",
+        (3, 0): "x3_0",
+        (3, 1): "x3_1",
+    }
 
 
 def test_gen_var_x5(pcp_hgg2):
-    assert pcp_hgg2.set_x == ['x0_0', 'x0_1', 'x1_0', 'x1_1', 'x2_0', 'x2_1',
-                              'x3_0', 'x3_1']
-    assert pcp_hgg2.couple_to_x == {(0, 0): 'x0_0', (0, 1): 'x0_1',
-                                    (1, 0): 'x1_0', (1, 1): 'x1_1',
-                                    (2, 0): 'x2_0', (2, 1): 'x2_1',
-                                    (3, 0): 'x3_0', (3, 1): 'x3_1'}
+    assert pcp_hgg2.set_x == [
+        "x0_0",
+        "x0_1",
+        "x1_0",
+        "x1_1",
+        "x2_0",
+        "x2_1",
+        "x3_0",
+        "x3_1",
+    ]
+    assert pcp_hgg2.couple_to_x == {
+        (0, 0): "x0_0",
+        (0, 1): "x0_1",
+        (1, 0): "x1_0",
+        (1, 1): "x1_1",
+        (2, 0): "x2_0",
+        (2, 1): "x2_1",
+        (3, 0): "x3_0",
+        (3, 1): "x3_1",
+    }
 
 
 def test_gen_var_x6(pcp_hgg3):
-    assert pcp_hgg3.set_x == ['x0_0', 'x0_1', 'x1_0', 'x1_1', 'x2_0', 'x2_1',
-                              'x3_0', 'x3_1']
-    assert pcp_hgg3.couple_to_x == {(0, 0): 'x0_0', (0, 1): 'x0_1',
-                                    (1, 0): 'x1_0', (1, 1): 'x1_1',
-                                    (2, 0): 'x2_0', (2, 1): 'x2_1',
-                                    (3, 0): 'x3_0', (3, 1): 'x3_1'}
+    assert pcp_hgg3.set_x == [
+        "x0_0",
+        "x0_1",
+        "x1_0",
+        "x1_1",
+        "x2_0",
+        "x2_1",
+        "x3_0",
+        "x3_1",
+    ]
+    assert pcp_hgg3.couple_to_x == {
+        (0, 0): "x0_0",
+        (0, 1): "x0_1",
+        (1, 0): "x1_0",
+        (1, 1): "x1_1",
+        (2, 0): "x2_0",
+        (2, 1): "x2_1",
+        (3, 0): "x3_0",
+        (3, 1): "x3_1",
+    }
 
 
 # GEN OMEGA0 was modified to avoid using IRDA which was "useless"
 # as we are supposed to use it before creating the pcp
 
+
 def test_omega0_1(pcp_3player_nfg):
     assert pcp_3player_nfg.omega0 == {0: 0, 1: 0, 2: 0}
 
@@ -306,182 +440,218 @@ def test_omega0_4(pcp_hgg2):
 
 # def test_generate_Q0(empty_pcp):
 
+
 def test_generate_R1(pcp_3player_nfg):
     ring = pcp_3player_nfg.ring
     assert pcp_3player_nfg.generate_R() == {
-        (0, 0, 0): (-2) * ring('x1_0') * ring('x2_0') - ring('x1_0') * ring(
-            'x2_1') + (-8) * ring('x1_1') * ring('x2_0') + (-3) * ring(
-            'x1_1') * ring('x2_1'),
-        (0, 1, 0): (-7) * ring('x1_0') * ring('x2_0') + (-4) * ring(
-            'x1_0') * ring('x2_1') + (-6) * ring('x1_1') * ring('x2_0') + (
-                       -5) * ring('x1_1') * ring('x2_1'),
-        (1, 0, 0): (-8) * ring('x0_0') * ring('x2_0') + (-5) * ring(
-            'x0_0') * ring('x2_1') + (-2) * ring('x0_1') * ring('x2_0') + (
-                       -3) * ring('x0_1') * ring('x2_1'),
-        (1, 1, 0): -ring('x0_0') * ring('x2_0') + (-4) * ring('x0_0') * ring(
-            'x2_1') + (-7) * ring('x0_1') * ring('x2_0') + (-6) * ring(
-            'x0_1') * ring('x2_1'),
-        (2, 0, 0): (-4) * ring('x0_0') * ring('x1_0') + (-4) * ring(
-            'x0_0') * ring('x1_1') + (-5) * ring('x0_1') * ring('x1_0') + (
-                       -2) * ring('x0_1') * ring('x1_1'),
-        (2, 1, 0): -ring('x0_0') * ring('x1_0') + (-8) * ring('x0_0') * ring(
-            'x1_1') + (-6) * ring('x0_1') * ring('x1_0') + (-7) * ring(
-            'x0_1') * ring('x1_1')}
+        (0, 0, 0): (-2) * ring("x1_0") * ring("x2_0")
+        - ring("x1_0") * ring("x2_1")
+        + (-8) * ring("x1_1") * ring("x2_0")
+        + (-3) * ring("x1_1") * ring("x2_1"),
+        (0, 1, 0): (-7) * ring("x1_0") * ring("x2_0")
+        + (-4) * ring("x1_0") * ring("x2_1")
+        + (-6) * ring("x1_1") * ring("x2_0")
+        + (-5) * ring("x1_1") * ring("x2_1"),
+        (1, 0, 0): (-8) * ring("x0_0") * ring("x2_0")
+        + (-5) * ring("x0_0") * ring("x2_1")
+        + (-2) * ring("x0_1") * ring("x2_0")
+        + (-3) * ring("x0_1") * ring("x2_1"),
+        (1, 1, 0): -ring("x0_0") * ring("x2_0")
+        + (-4) * ring("x0_0") * ring("x2_1")
+        + (-7) * ring("x0_1") * ring("x2_0")
+        + (-6) * ring("x0_1") * ring("x2_1"),
+        (2, 0, 0): (-4) * ring("x0_0") * ring("x1_0")
+        + (-4) * ring("x0_0") * ring("x1_1")
+        + (-5) * ring("x0_1") * ring("x1_0")
+        + (-2) * ring("x0_1") * ring("x1_1"),
+        (2, 1, 0): -ring("x0_0") * ring("x1_0")
+        + (-8) * ring("x0_0") * ring("x1_1")
+        + (-6) * ring("x0_1") * ring("x1_0")
+        + (-7) * ring("x0_1") * ring("x1_1"),
+    }
 
 
 def test_generate_R2(pcp_hgg1):
     ring = pcp_hgg1.ring
     assert pcp_hgg1.generate_R() == {
-        (0, 0, 0): (-3) * ring('x1_0') * ring('x2_0') + (-7) * ring(
-            'x1_0') * ring('x2_1') + (-7) * ring('x1_1') * ring('x2_0') + (
-                       -10) * ring('x1_1') * ring('x2_1'),
-        (0, 1, 0): -ring('x1_0') * ring('x2_0') + (-5) * ring('x1_0') * ring(
-            'x2_1') + (-5) * ring('x1_1') * ring('x2_0') + (-9) * ring(
-            'x1_1') * ring('x2_1'),
-        (1, 0, 0): (-4) * ring('x0_0') * ring('x2_0') + (-8) * ring(
-            'x0_0') * ring('x2_1') + (-8) * ring('x0_1') * ring('x2_0') + (
-                       -11) * ring('x0_1') * ring('x2_1'),
-        (1, 0, 1): (-2) * ring('x3_0') + (-6) * ring('x3_1'),
-        (1, 1, 0): (-2) * ring('x0_0') * ring('x2_0') + (-6) * ring(
-            'x0_0') * ring('x2_1') + (-6) * ring('x0_1') * ring('x2_0') + (
-                       -10) * ring('x0_1') * ring('x2_1'),
-        (1, 1, 1): -ring('x3_0') + (-4) * ring('x3_1'),
-        (2, 0, 0): (-4) * ring('x0_0') * ring('x1_0') + (-8) * ring(
-            'x0_0') * ring('x1_1') + (-8) * ring('x0_1') * ring('x1_0') + (
-                       -11) * ring('x0_1') * ring('x1_1'),
-        (2, 0, 2): (-2) * ring('x3_0') + (-6) * ring('x3_1'),
-        (2, 1, 0): (-2) * ring('x0_0') * ring('x1_0') + (-6) * ring(
-            'x0_0') * ring('x1_1') + (-6) * ring('x0_1') * ring('x1_0') + (
-                       -10) * ring('x0_1') * ring('x1_1'),
-        (2, 1, 2): -ring('x3_0') + (-4) * ring('x3_1'),
-        (3, 0, 1): (-2) * ring('x1_0') + (-6) * ring('x1_1'),
-        (3, 0, 2): (-2) * ring('x2_0') + (-6) * ring('x2_1'),
-        (3, 1, 1): -ring('x1_0') + (-4) * ring('x1_1'),
-        (3, 1, 2): -ring('x2_0') + (-4) * ring('x2_1')
+        (0, 0, 0): (-3) * ring("x1_0") * ring("x2_0")
+        + (-7) * ring("x1_0") * ring("x2_1")
+        + (-7) * ring("x1_1") * ring("x2_0")
+        + (-10) * ring("x1_1") * ring("x2_1"),
+        (0, 1, 0): -ring("x1_0") * ring("x2_0")
+        + (-5) * ring("x1_0") * ring("x2_1")
+        + (-5) * ring("x1_1") * ring("x2_0")
+        + (-9) * ring("x1_1") * ring("x2_1"),
+        (1, 0, 0): (-4) * ring("x0_0") * ring("x2_0")
+        + (-8) * ring("x0_0") * ring("x2_1")
+        + (-8) * ring("x0_1") * ring("x2_0")
+        + (-11) * ring("x0_1") * ring("x2_1"),
+        (1, 0, 1): (-2) * ring("x3_0") + (-6) * ring("x3_1"),
+        (1, 1, 0): (-2) * ring("x0_0") * ring("x2_0")
+        + (-6) * ring("x0_0") * ring("x2_1")
+        + (-6) * ring("x0_1") * ring("x2_0")
+        + (-10) * ring("x0_1") * ring("x2_1"),
+        (1, 1, 1): -ring("x3_0") + (-4) * ring("x3_1"),
+        (2, 0, 0): (-4) * ring("x0_0") * ring("x1_0")
+        + (-8) * ring("x0_0") * ring("x1_1")
+        + (-8) * ring("x0_1") * ring("x1_0")
+        + (-11) * ring("x0_1") * ring("x1_1"),
+        (2, 0, 2): (-2) * ring("x3_0") + (-6) * ring("x3_1"),
+        (2, 1, 0): (-2) * ring("x0_0") * ring("x1_0")
+        + (-6) * ring("x0_0") * ring("x1_1")
+        + (-6) * ring("x0_1") * ring("x1_0")
+        + (-10) * ring("x0_1") * ring("x1_1"),
+        (2, 1, 2): -ring("x3_0") + (-4) * ring("x3_1"),
+        (3, 0, 1): (-2) * ring("x1_0") + (-6) * ring("x1_1"),
+        (3, 0, 2): (-2) * ring("x2_0") + (-6) * ring("x2_1"),
+        (3, 1, 1): -ring("x1_0") + (-4) * ring("x1_1"),
+        (3, 1, 2): -ring("x2_0") + (-4) * ring("x2_1"),
     }
 
 
 # def test_gen_poly
 
+
 def test_generate_poly1(pcp_3player_nfg):
     ring = pcp_3player_nfg.ring
-    y_value = {ring('y2_0'): 1}
+    y_value = {ring("y2_0"): 1}
     tmp_couple_poly = {
-        (n, i): pcp_3player_nfg.couple_to_poly[(n, i)].subs(y_value) for (n, i)
-        in pcp_3player_nfg.couple_to_poly.keys()}
+        (n, i): pcp_3player_nfg.couple_to_poly[(n, i)].subs(y_value)
+        for (n, i) in pcp_3player_nfg.couple_to_poly.keys()
+    }
     assert tmp_couple_poly == {
-        (0, 0): 2 * ring('x1_0') * ring('x2_0') + ring('x1_0') * ring(
-            'x2_1') + 8 * ring('x1_1') * ring('x2_0') + 3 * ring(
-            'x1_1') * ring('x2_1') - 1,
-        (0, 1): 7 * ring('x1_0') * ring('x2_0') + 4 * ring('x1_0') * ring(
-            'x2_1') + 6 * ring('x1_1') * ring('x2_0') + 5 * ring(
-            'x1_1') * ring('x2_1') - 1,
-        (1, 0): 8 * ring('x0_0') * ring('x2_0') + 5 * ring('x0_0') * ring(
-            'x2_1') + 2 * ring('x0_1') * ring('x2_0') + 3 * ring(
-            'x0_1') * ring('x2_1') - 1,
-        (1, 1): ring('x0_0') * ring('x2_0') + 4 * ring('x0_0') * ring(
-            'x2_1') + 7 * ring('x0_1') * ring('x2_0') + 6 * ring(
-            'x0_1') * ring('x2_1') - 1,
-        (2, 0): 4 * ring('x0_0') * ring('x1_0') + 4 * ring('x0_0') * ring(
-            'x1_1') + 5 * ring('x0_1') * ring('x1_0') + 2 * ring(
-            'x0_1') * ring('x1_1') - 1,
-        (2, 1): ring('x0_0') * ring('x1_0') + 8 * ring('x0_0') * ring(
-            'x1_1') + 6 * ring('x0_1') * ring('x1_0') + 7 * ring(
-            'x0_1') * ring('x1_1') - 1}
+        (0, 0): 2 * ring("x1_0") * ring("x2_0")
+        + ring("x1_0") * ring("x2_1")
+        + 8 * ring("x1_1") * ring("x2_0")
+        + 3 * ring("x1_1") * ring("x2_1")
+        - 1,
+        (0, 1): 7 * ring("x1_0") * ring("x2_0")
+        + 4 * ring("x1_0") * ring("x2_1")
+        + 6 * ring("x1_1") * ring("x2_0")
+        + 5 * ring("x1_1") * ring("x2_1")
+        - 1,
+        (1, 0): 8 * ring("x0_0") * ring("x2_0")
+        + 5 * ring("x0_0") * ring("x2_1")
+        + 2 * ring("x0_1") * ring("x2_0")
+        + 3 * ring("x0_1") * ring("x2_1")
+        - 1,
+        (1, 1): ring("x0_0") * ring("x2_0")
+        + 4 * ring("x0_0") * ring("x2_1")
+        + 7 * ring("x0_1") * ring("x2_0")
+        + 6 * ring("x0_1") * ring("x2_1")
+        - 1,
+        (2, 0): 4 * ring("x0_0") * ring("x1_0")
+        + 4 * ring("x0_0") * ring("x1_1")
+        + 5 * ring("x0_1") * ring("x1_0")
+        + 2 * ring("x0_1") * ring("x1_1")
+        - 1,
+        (2, 1): ring("x0_0") * ring("x1_0")
+        + 8 * ring("x0_0") * ring("x1_1")
+        + 6 * ring("x0_1") * ring("x1_0")
+        + 7 * ring("x0_1") * ring("x1_1")
+        - 1,
+    }
 
 
 def test_substitute1(pcp_3player_nfg):
     ring = pcp_3player_nfg.ring
-    x_dico = {ring('x0_1'): 0, ring('x1_1'): 0, ring('x2_1'): 0}
+    x_dico = {ring("x0_1"): 0, ring("x1_1"): 0, ring("x2_1"): 0}
     assert pcp_3player_nfg.substitute(x_dico, 2).couple_to_poly == {
-        (0, 0): 2 * ring('x1_0') * ring('x2_0') * ring('y2_0') - 1,
-        (0, 1): 7 * ring('x1_0') * ring('x2_0') * ring('y2_0') - 1,
-        (1, 0): 8 * ring('x0_0') * ring('x2_0') * ring('y2_0') - 1,
-        (1, 1): ring('x0_0') * ring('x2_0') * ring('y2_0') - 1,
-        (2, 0): 4 * ring('x0_0') * ring('x1_0') * ring('y2_0') - 1,
-        (2, 1): ring('x0_0') * ring('x1_0') * ring('y2_0') - 1}
+        (0, 0): 2 * ring("x1_0") * ring("x2_0") * ring("y2_0") - 1,
+        (0, 1): 7 * ring("x1_0") * ring("x2_0") * ring("y2_0") - 1,
+        (1, 0): 8 * ring("x0_0") * ring("x2_0") * ring("y2_0") - 1,
+        (1, 1): ring("x0_0") * ring("x2_0") * ring("y2_0") - 1,
+        (2, 0): 4 * ring("x0_0") * ring("x1_0") * ring("y2_0") - 1,
+        (2, 1): ring("x0_0") * ring("x1_0") * ring("y2_0") - 1,
+    }
 
 
 def test_substitute1b(pcp_3player_nfg_no_y):
     ring = pcp_3player_nfg_no_y.ring
-    x_dico = {ring('x0_1'): 0, ring('x1_1'): 0, ring('x2_1'): 0}
+    x_dico = {ring("x0_1"): 0, ring("x1_1"): 0, ring("x2_1"): 0}
     assert pcp_3player_nfg_no_y.substitute(x_dico, 2).couple_to_poly == {
-        (0, 0): 2 * ring('x1_0') * ring('x2_0') - 1,
-        (0, 1): 7 * ring('x1_0') * ring('x2_0') - 1,
-        (1, 0): 8 * ring('x0_0') * ring('x2_0') - 1,
-        (1, 1): ring('x0_0') * ring('x2_0') - 1,
-        (2, 0): 4 * ring('x0_0') * ring('x1_0') - 1,
-        (2, 1): ring('x0_0') * ring('x1_0') - 1}
+        (0, 0): 2 * ring("x1_0") * ring("x2_0") - 1,
+        (0, 1): 7 * ring("x1_0") * ring("x2_0") - 1,
+        (1, 0): 8 * ring("x0_0") * ring("x2_0") - 1,
+        (1, 1): ring("x0_0") * ring("x2_0") - 1,
+        (2, 0): 4 * ring("x0_0") * ring("x1_0") - 1,
+        (2, 1): ring("x0_0") * ring("x1_0") - 1,
+    }
 
 
 def test_substitute2(pcp_3player_nfg):
     ring = pcp_3player_nfg.ring
-    x_dico = {ring('x0_1'): 0, ring('x1_1'): 0, ring('x2_1'): 0}
+    x_dico = {ring("x0_1"): 0, ring("x1_1"): 0, ring("x2_1"): 0}
     assert pcp_3player_nfg.substitute(x_dico, 1).couple_to_poly == {
-        (0, 0): 2 * ring('x1_0') * ring('x2_0') * ring('y2_0') - 1,
-        (0, 1): 7 * ring('x1_0') * ring('x2_0') * ring('y2_0') - 1,
-        (1, 0): 8 * ring('x0_0') * ring('x2_0') * ring('y2_0') - 1,
-        (1, 1): ring('x0_0') * ring('x2_0') * ring('y2_0') - 1}
+        (0, 0): 2 * ring("x1_0") * ring("x2_0") * ring("y2_0") - 1,
+        (0, 1): 7 * ring("x1_0") * ring("x2_0") * ring("y2_0") - 1,
+        (1, 0): 8 * ring("x0_0") * ring("x2_0") * ring("y2_0") - 1,
+        (1, 1): ring("x0_0") * ring("x2_0") * ring("y2_0") - 1,
+    }
 
 
 def test_substitute2b(pcp_3player_nfg_no_y):
     ring = pcp_3player_nfg_no_y.ring
-    x_dico = {ring('x0_1'): 0, ring('x1_1'): 0, ring('x2_1'): 0}
+    x_dico = {ring("x0_1"): 0, ring("x1_1"): 0, ring("x2_1"): 0}
     assert pcp_3player_nfg_no_y.substitute(x_dico, 1).couple_to_poly == {
-        (0, 0): 2 * ring('x1_0') * ring('x2_0') - 1,
-        (0, 1): 7 * ring('x1_0') * ring('x2_0') - 1,
-        (1, 0): 8 * ring('x0_0') * ring('x2_0') - 1,
-        (1, 1): ring('x0_0') * ring('x2_0') - 1}
+        (0, 0): 2 * ring("x1_0") * ring("x2_0") - 1,
+        (0, 1): 7 * ring("x1_0") * ring("x2_0") - 1,
+        (1, 0): 8 * ring("x0_0") * ring("x2_0") - 1,
+        (1, 1): ring("x0_0") * ring("x2_0") - 1,
+    }
 
 
 def test_substitute3(pcp_3player_nfg):
     ring = pcp_3player_nfg.ring
-    x_dico = {ring('x0_1'): 0, ring('x1_1'): 0, ring('x2_1'): 0}
+    x_dico = {ring("x0_1"): 0, ring("x1_1"): 0, ring("x2_1"): 0}
     assert pcp_3player_nfg.substitute(x_dico, 0).couple_to_poly == {
-        (0, 0): 2 * ring('x1_0') * ring('x2_0') * ring('y2_0') - 1,
-        (0, 1): 7 * ring('x1_0') * ring('x2_0') * ring('y2_0') - 1
-        }
+        (0, 0): 2 * ring("x1_0") * ring("x2_0") * ring("y2_0") - 1,
+        (0, 1): 7 * ring("x1_0") * ring("x2_0") * ring("y2_0") - 1,
+    }
 
 
 def test_substitute3b(pcp_3player_nfg_no_y):
     ring = pcp_3player_nfg_no_y.ring
-    x_dico = {ring('x0_1'): 0, ring('x1_1'): 0, ring('x2_1'): 0}
+    x_dico = {ring("x0_1"): 0, ring("x1_1"): 0, ring("x2_1"): 0}
     assert pcp_3player_nfg_no_y.substitute(x_dico, 0).couple_to_poly == {
-        (0, 0): 2 * ring('x1_0') * ring('x2_0') - 1,
-        (0, 1): 7 * ring('x1_0') * ring('x2_0') - 1
-        }
+        (0, 0): 2 * ring("x1_0") * ring("x2_0") - 1,
+        (0, 1): 7 * ring("x1_0") * ring("x2_0") - 1,
+    }
 
 
 def test_substitute4(pcp_3player_nfg):
     ring = pcp_3player_nfg.ring
-    x_dico = {ring('x0_1'): 0, ring('x1_1'): 0}
+    x_dico = {ring("x0_1"): 0, ring("x1_1"): 0}
     assert pcp_3player_nfg.substitute(x_dico, 2).couple_to_poly == {
-        (0, 0): 2 * ring('x1_0') * ring('x2_0') * ring('y2_0') + ring(
-            'x1_0') * ring('x2_1') * ring('y2_0') - 1,
-        (0, 1): 7 * ring('x1_0') * ring('x2_0') * ring('y2_0') + 4 * ring(
-            'x1_0') * ring('x2_1') * ring('y2_0') - 1,
-        (1, 0): 8 * ring('x0_0') * ring('x2_0') * ring('y2_0') + 5 * ring(
-            'x0_0') * ring('x2_1') * ring('y2_0') - 1,
-        (1, 1): ring('x0_0') * ring('x2_0') * ring('y2_0') + 4 * ring(
-            'x0_0') * ring('x2_1') * ring('y2_0') - 1,
-        (2, 0): 4 * ring('x0_0') * ring('x1_0') * ring('y2_0') - 1,
-        (2, 1): ring('x0_0') * ring('x1_0') * ring('y2_0') - 1}
+        (0, 0): 2 * ring("x1_0") * ring("x2_0") * ring("y2_0")
+        + ring("x1_0") * ring("x2_1") * ring("y2_0")
+        - 1,
+        (0, 1): 7 * ring("x1_0") * ring("x2_0") * ring("y2_0")
+        + 4 * ring("x1_0") * ring("x2_1") * ring("y2_0")
+        - 1,
+        (1, 0): 8 * ring("x0_0") * ring("x2_0") * ring("y2_0")
+        + 5 * ring("x0_0") * ring("x2_1") * ring("y2_0")
+        - 1,
+        (1, 1): ring("x0_0") * ring("x2_0") * ring("y2_0")
+        + 4 * ring("x0_0") * ring("x2_1") * ring("y2_0")
+        - 1,
+        (2, 0): 4 * ring("x0_0") * ring("x1_0") * ring("y2_0") - 1,
+        (2, 1): ring("x0_0") * ring("x1_0") * ring("y2_0") - 1,
+    }
 
 
 def test_substitute4b(pcp_3player_nfg_no_y):
     ring = pcp_3player_nfg_no_y.ring
-    x_dico = {ring('x0_1'): 0, ring('x1_1'): 0}
+    x_dico = {ring("x0_1"): 0, ring("x1_1"): 0}
     assert pcp_3player_nfg_no_y.substitute(x_dico, 2).couple_to_poly == {
-        (0, 0): 2 * ring('x1_0') * ring('x2_0') + ring(
-            'x1_0') * ring('x2_1') - 1,
-        (0, 1): 7 * ring('x1_0') * ring('x2_0') + 4 * ring(
-            'x1_0') * ring('x2_1') - 1,
-        (1, 0): 8 * ring('x0_0') * ring('x2_0') + 5 * ring(
-            'x0_0') * ring('x2_1') - 1,
-        (1, 1): ring('x0_0') * ring('x2_0') + 4 * ring(
-            'x0_0') * ring('x2_1') - 1,
-        (2, 0): 4 * ring('x0_0') * ring('x1_0') - 1,
-        (2, 1): ring('x0_0') * ring('x1_0') - 1}
+        (0, 0): 2 * ring("x1_0") * ring("x2_0") + ring("x1_0") * ring("x2_1") - 1,
+        (0, 1): 7 * ring("x1_0") * ring("x2_0") + 4 * ring("x1_0") * ring("x2_1") - 1,
+        (1, 0): 8 * ring("x0_0") * ring("x2_0") + 5 * ring("x0_0") * ring("x2_1") - 1,
+        (1, 1): ring("x0_0") * ring("x2_0") + 4 * ring("x0_0") * ring("x2_1") - 1,
+        (2, 0): 4 * ring("x0_0") * ring("x1_0") - 1,
+        (2, 1): ring("x0_0") * ring("x1_0") - 1,
+    }
+
 
 # Substitue for Hgg?
 
@@ -500,41 +670,46 @@ def subsys_empty_no_y(pcp_3player_nfg_no_y):
 def subsys_3p_2l_n1(pcp_3player_nfg):
     # return Subsystem(pcp_3player_nfg,[(0,1),(1,0),(2,0)]
     # ,[(1,1),(0,0),(2,0)],2,{})
-    return Subsystem(pcp_3player_nfg, [(2, 1)],
-                     [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)], 2, {})
+    return Subsystem(
+        pcp_3player_nfg, [(2, 1)], [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)], 2, {}
+    )
 
 
 @pytest.fixture
 def subsys_3p_2l_n1_no_y(pcp_3player_nfg_no_y):
     # return Subsystem(pcp_3player_nfg,[(0,1),(1,0),(2,0)]
     # ,[(1,1),(0,0),(2,0)],2,{})
-    return Subsystem(pcp_3player_nfg_no_y, [(2, 1)],
-                     [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)], 2, {})
+    return Subsystem(
+        pcp_3player_nfg_no_y, [(2, 1)], [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)], 2, {}
+    )
 
 
 @pytest.fixture
 def subsys_3p_2l_n2(pcp_3player_nfg):
     # return Subsystem(pcp_3player_nfg,[(0,1),(1,0),(2,0)],
     # [(1,1),(0,0),(2,1)],2,{})
-    return Subsystem(pcp_3player_nfg, [(2, 1)],
-                     [(0, 0), (0, 1), (1, 0), (1, 1), (2, 1)], 2, {})
+    return Subsystem(
+        pcp_3player_nfg, [(2, 1)], [(0, 0), (0, 1), (1, 0), (1, 1), (2, 1)], 2, {}
+    )
 
 
 @pytest.fixture
 def subsys_3p_2l_n2_no_y(pcp_3player_nfg_no_y):
     # return Subsystem(pcp_3player_nfg,[(0,1),(1,0),(2,0)],
     # [(1,1),(0,0),(2,1)],2,{})
-    return Subsystem(pcp_3player_nfg_no_y, [(2, 1)],
-                     [(0, 0), (0, 1), (1, 0), (1, 1), (2, 1)], 2, {})
+    return Subsystem(
+        pcp_3player_nfg_no_y, [(2, 1)], [(0, 0), (0, 1), (1, 0), (1, 1), (2, 1)], 2, {}
+    )
 
 
 def test_equations1(subsys_empty):
     ring = subsys_empty.ring
-    assert set(
-        subsys_empty.equations
-    ) == {ring('y0_0') - 1, ring('y1_0') -
-          ring('y0_0'), ring('y2_0') -
-          ring('y1_0')}
+    assert set(subsys_empty.equations) == {
+        ring("y0_0") - 1,
+        ring("y1_0") - ring("y0_0"),
+        ring("y2_0") - ring("y1_0"),
+    }
+
 
 # def test_equations1b(subsys_empty_no_y):
 #     # ring = subsys_empty_no_y.ring
@@ -548,146 +723,162 @@ def test_equations1(subsys_empty):
 
 def test_equations2(subsys_3p_2l_n1, pcp_3player_nfg):
     ring = subsys_3p_2l_n1.ring
-    dico_x0 = {ring('x2_1'): 0}
-    assert set(
-        subsys_3p_2l_n1.equations
-    ) == {ring('x2_1'), pcp_3player_nfg.couple_to_poly[(0, 0)].subs(dico_x0),
-          pcp_3player_nfg.couple_to_poly[(0, 1)].subs(dico_x0),
-          pcp_3player_nfg.couple_to_poly[(1, 0)].subs(dico_x0),
-          pcp_3player_nfg.couple_to_poly[(1, 1)].subs(dico_x0),
-          pcp_3player_nfg.couple_to_poly[(2, 0)].subs(dico_x0),
-          ring('y0_0') - 1, ring('y1_0') - ring('y0_0'),
-          ring('y2_0') - ring('y1_0')}
+    dico_x0 = {ring("x2_1"): 0}
+    assert set(subsys_3p_2l_n1.equations) == {
+        ring("x2_1"),
+        pcp_3player_nfg.couple_to_poly[(0, 0)].subs(dico_x0),
+        pcp_3player_nfg.couple_to_poly[(0, 1)].subs(dico_x0),
+        pcp_3player_nfg.couple_to_poly[(1, 0)].subs(dico_x0),
+        pcp_3player_nfg.couple_to_poly[(1, 1)].subs(dico_x0),
+        pcp_3player_nfg.couple_to_poly[(2, 0)].subs(dico_x0),
+        ring("y0_0") - 1,
+        ring("y1_0") - ring("y0_0"),
+        ring("y2_0") - ring("y1_0"),
+    }
 
 
 def test_equations2b(subsys_3p_2l_n1_no_y, pcp_3player_nfg_no_y):
     ring = subsys_3p_2l_n1_no_y.ring
-    dico_x0 = {ring('x2_1'): 0}
-    assert set(
-        subsys_3p_2l_n1_no_y.equations
-    ) == {ring('x2_1'),
-          pcp_3player_nfg_no_y.couple_to_poly[(0, 0)].subs(dico_x0),
-          pcp_3player_nfg_no_y.couple_to_poly[(0, 1)].subs(dico_x0),
-          pcp_3player_nfg_no_y.couple_to_poly[(1, 0)].subs(dico_x0),
-          pcp_3player_nfg_no_y.couple_to_poly[(1, 1)].subs(dico_x0),
-          pcp_3player_nfg_no_y.couple_to_poly[(2, 0)].subs(dico_x0)}
+    dico_x0 = {ring("x2_1"): 0}
+    assert set(subsys_3p_2l_n1_no_y.equations) == {
+        ring("x2_1"),
+        pcp_3player_nfg_no_y.couple_to_poly[(0, 0)].subs(dico_x0),
+        pcp_3player_nfg_no_y.couple_to_poly[(0, 1)].subs(dico_x0),
+        pcp_3player_nfg_no_y.couple_to_poly[(1, 0)].subs(dico_x0),
+        pcp_3player_nfg_no_y.couple_to_poly[(1, 1)].subs(dico_x0),
+        pcp_3player_nfg_no_y.couple_to_poly[(2, 0)].subs(dico_x0),
+    }
 
 
 def test_equations3(subsys_3p_2l_n2, pcp_3player_nfg):
     ring = subsys_3p_2l_n2.ring
-    dico_x0 = {ring('x2_1'): 0}
-    assert set(
-        subsys_3p_2l_n2.equations
-    ) == {ring('x2_1'),
-          pcp_3player_nfg.couple_to_poly[(0, 0)].subs(dico_x0),
-          pcp_3player_nfg.couple_to_poly[(0, 1)].subs(dico_x0),
-          pcp_3player_nfg.couple_to_poly[(1, 0)].subs(dico_x0),
-          pcp_3player_nfg.couple_to_poly[(1, 1)].subs(dico_x0),
-          pcp_3player_nfg.couple_to_poly[(2, 1)].subs(dico_x0),
-          ring('y0_0') - 1,
-          ring('y1_0') - ring('y0_0'),
-          ring('y2_0') - ring('y1_0')}
+    dico_x0 = {ring("x2_1"): 0}
+    assert set(subsys_3p_2l_n2.equations) == {
+        ring("x2_1"),
+        pcp_3player_nfg.couple_to_poly[(0, 0)].subs(dico_x0),
+        pcp_3player_nfg.couple_to_poly[(0, 1)].subs(dico_x0),
+        pcp_3player_nfg.couple_to_poly[(1, 0)].subs(dico_x0),
+        pcp_3player_nfg.couple_to_poly[(1, 1)].subs(dico_x0),
+        pcp_3player_nfg.couple_to_poly[(2, 1)].subs(dico_x0),
+        ring("y0_0") - 1,
+        ring("y1_0") - ring("y0_0"),
+        ring("y2_0") - ring("y1_0"),
+    }
 
 
 def test_equations3b(subsys_3p_2l_n2_no_y, pcp_3player_nfg_no_y):
     ring = subsys_3p_2l_n2_no_y.ring
-    dico_x0 = {ring('x2_1'): 0}
-    assert set(
-        subsys_3p_2l_n2_no_y.equations
-    ) == {ring('x2_1'),
-          pcp_3player_nfg_no_y.couple_to_poly[(0, 0)].subs(dico_x0),
-          pcp_3player_nfg_no_y.couple_to_poly[(0, 1)].subs(dico_x0),
-          pcp_3player_nfg_no_y.couple_to_poly[(1, 0)].subs(dico_x0),
-          pcp_3player_nfg_no_y.couple_to_poly[(1, 1)].subs(dico_x0),
-          pcp_3player_nfg_no_y.couple_to_poly[(2, 1)].subs(dico_x0)
-          }
+    dico_x0 = {ring("x2_1"): 0}
+    assert set(subsys_3p_2l_n2_no_y.equations) == {
+        ring("x2_1"),
+        pcp_3player_nfg_no_y.couple_to_poly[(0, 0)].subs(dico_x0),
+        pcp_3player_nfg_no_y.couple_to_poly[(0, 1)].subs(dico_x0),
+        pcp_3player_nfg_no_y.couple_to_poly[(1, 0)].subs(dico_x0),
+        pcp_3player_nfg_no_y.couple_to_poly[(1, 1)].subs(dico_x0),
+        pcp_3player_nfg_no_y.couple_to_poly[(2, 1)].subs(dico_x0),
+    }
 
 
 def test_inequations1(subsys_empty, pcp_3player_nfg):
-    assert set(subsys_empty.inequations) == set(
-        pcp_3player_nfg.couple_to_poly.values())
+    assert set(subsys_empty.inequations) == set(pcp_3player_nfg.couple_to_poly.values())
 
 
 def test_inequations2(subsys_3p_2l_n1, pcp_3player_nfg):
     ring = subsys_3p_2l_n1.ring
-    dico_x0 = {ring('x2_1'): 0}
+    dico_x0 = {ring("x2_1"): 0}
     assert set(subsys_3p_2l_n1.inequations) == {
-        pcp_3player_nfg.couple_to_poly[(2, 1)].subs(dico_x0)}
+        pcp_3player_nfg.couple_to_poly[(2, 1)].subs(dico_x0)
+    }
 
 
 def test_inequations2b(subsys_3p_2l_n1_no_y, pcp_3player_nfg_no_y):
     ring = subsys_3p_2l_n1_no_y.ring
-    dico_x0 = {ring('x2_1'): 0}
+    dico_x0 = {ring("x2_1"): 0}
     assert set(subsys_3p_2l_n1_no_y.inequations) == {
-        pcp_3player_nfg_no_y.couple_to_poly[(2, 1)].subs(dico_x0)}
+        pcp_3player_nfg_no_y.couple_to_poly[(2, 1)].subs(dico_x0)
+    }
 
 
 def test_inequations3(subsys_3p_2l_n2, pcp_3player_nfg):
     ring = subsys_3p_2l_n2.ring
-    dico_x0 = {ring('x2_1'): 0}
+    dico_x0 = {ring("x2_1"): 0}
     assert set(subsys_3p_2l_n2.inequations) == {
-        pcp_3player_nfg.couple_to_poly[(2, 0)].subs(dico_x0)}
+        pcp_3player_nfg.couple_to_poly[(2, 0)].subs(dico_x0)
+    }
 
 
 def test_inequations3b(subsys_3p_2l_n2_no_y, pcp_3player_nfg_no_y):
     ring = subsys_3p_2l_n2_no_y.ring
-    dico_x0 = {ring('x2_1'): 0}
+    dico_x0 = {ring("x2_1"): 0}
     assert set(subsys_3p_2l_n2_no_y.inequations) == {
-        pcp_3player_nfg_no_y.couple_to_poly[(2, 0)].subs(dico_x0)}
+        pcp_3player_nfg_no_y.couple_to_poly[(2, 0)].subs(dico_x0)
+    }
 
 
 def test_ideal1(subsys_3p_2l_n1, pcp_3player_nfg):
     ring = subsys_3p_2l_n1.ring
-    dico_x0 = {ring('x2_1'): 0}
-    assert subsys_3p_2l_n1.ideal ==\
-        ideal([ring('x2_1'),
-               pcp_3player_nfg.couple_to_poly[(0, 0)].subs(dico_x0),
-               pcp_3player_nfg.couple_to_poly[(0, 1)].subs(dico_x0),
-               pcp_3player_nfg.couple_to_poly[(1, 0)].subs(dico_x0),
-               pcp_3player_nfg.couple_to_poly[(1, 1)].subs(dico_x0),
-               pcp_3player_nfg.couple_to_poly[(2, 0)].subs(dico_x0),
-               ring('y0_0') - 1,
-               ring('y1_0') - ring('y0_0'),
-               ring('y2_0') - ring('y1_0')])
+    dico_x0 = {ring("x2_1"): 0}
+    assert subsys_3p_2l_n1.ideal == ideal(
+        [
+            ring("x2_1"),
+            pcp_3player_nfg.couple_to_poly[(0, 0)].subs(dico_x0),
+            pcp_3player_nfg.couple_to_poly[(0, 1)].subs(dico_x0),
+            pcp_3player_nfg.couple_to_poly[(1, 0)].subs(dico_x0),
+            pcp_3player_nfg.couple_to_poly[(1, 1)].subs(dico_x0),
+            pcp_3player_nfg.couple_to_poly[(2, 0)].subs(dico_x0),
+            ring("y0_0") - 1,
+            ring("y1_0") - ring("y0_0"),
+            ring("y2_0") - ring("y1_0"),
+        ]
+    )
 
 
 def test_ideal1b(subsys_3p_2l_n1_no_y, pcp_3player_nfg_no_y):
     ring = subsys_3p_2l_n1_no_y.ring
-    dico_x0 = {ring('x2_1'): 0}
-    assert subsys_3p_2l_n1_no_y.ideal ==\
-        ideal([ring('x2_1'),
-               pcp_3player_nfg_no_y.couple_to_poly[(0, 0)].subs(dico_x0),
-               pcp_3player_nfg_no_y.couple_to_poly[(0, 1)].subs(dico_x0),
-               pcp_3player_nfg_no_y.couple_to_poly[(1, 0)].subs(dico_x0),
-               pcp_3player_nfg_no_y.couple_to_poly[(1, 1)].subs(dico_x0),
-               pcp_3player_nfg_no_y.couple_to_poly[(2, 0)].subs(dico_x0)])
+    dico_x0 = {ring("x2_1"): 0}
+    assert subsys_3p_2l_n1_no_y.ideal == ideal(
+        [
+            ring("x2_1"),
+            pcp_3player_nfg_no_y.couple_to_poly[(0, 0)].subs(dico_x0),
+            pcp_3player_nfg_no_y.couple_to_poly[(0, 1)].subs(dico_x0),
+            pcp_3player_nfg_no_y.couple_to_poly[(1, 0)].subs(dico_x0),
+            pcp_3player_nfg_no_y.couple_to_poly[(1, 1)].subs(dico_x0),
+            pcp_3player_nfg_no_y.couple_to_poly[(2, 0)].subs(dico_x0),
+        ]
+    )
 
 
 def test_ideal2(subsys_3p_2l_n2, pcp_3player_nfg):
     ring = subsys_3p_2l_n2.ring
-    dico_x0 = {ring('x2_1'): 0}
-    assert subsys_3p_2l_n2.ideal == \
-        ideal([ring('x2_1'),
-               pcp_3player_nfg.couple_to_poly[(0, 0)].subs(dico_x0),
-               pcp_3player_nfg.couple_to_poly[(0, 1)].subs(dico_x0),
-               pcp_3player_nfg.couple_to_poly[(1, 0)].subs(dico_x0),
-               pcp_3player_nfg.couple_to_poly[(1, 1)].subs(dico_x0),
-               pcp_3player_nfg.couple_to_poly[(2, 1)].subs(dico_x0),
-               ring('y0_0') - 1,
-               ring('y1_0') - ring('y0_0'),
-               ring('y2_0') - ring('y1_0')])
+    dico_x0 = {ring("x2_1"): 0}
+    assert subsys_3p_2l_n2.ideal == ideal(
+        [
+            ring("x2_1"),
+            pcp_3player_nfg.couple_to_poly[(0, 0)].subs(dico_x0),
+            pcp_3player_nfg.couple_to_poly[(0, 1)].subs(dico_x0),
+            pcp_3player_nfg.couple_to_poly[(1, 0)].subs(dico_x0),
+            pcp_3player_nfg.couple_to_poly[(1, 1)].subs(dico_x0),
+            pcp_3player_nfg.couple_to_poly[(2, 1)].subs(dico_x0),
+            ring("y0_0") - 1,
+            ring("y1_0") - ring("y0_0"),
+            ring("y2_0") - ring("y1_0"),
+        ]
+    )
 
 
 def test_ideal2b(subsys_3p_2l_n2_no_y, pcp_3player_nfg_no_y):
     ring = subsys_3p_2l_n2_no_y.ring
-    dico_x0 = {ring('x2_1'): 0}
-    assert subsys_3p_2l_n2_no_y.ideal == \
-        ideal([ring('x2_1'),
-               pcp_3player_nfg_no_y.couple_to_poly[(0, 0)].subs(dico_x0),
-               pcp_3player_nfg_no_y.couple_to_poly[(0, 1)].subs(dico_x0),
-               pcp_3player_nfg_no_y.couple_to_poly[(1, 0)].subs(dico_x0),
-               pcp_3player_nfg_no_y.couple_to_poly[(1, 1)].subs(dico_x0),
-               pcp_3player_nfg_no_y.couple_to_poly[(2, 1)].subs(dico_x0)])
+    dico_x0 = {ring("x2_1"): 0}
+    assert subsys_3p_2l_n2_no_y.ideal == ideal(
+        [
+            ring("x2_1"),
+            pcp_3player_nfg_no_y.couple_to_poly[(0, 0)].subs(dico_x0),
+            pcp_3player_nfg_no_y.couple_to_poly[(0, 1)].subs(dico_x0),
+            pcp_3player_nfg_no_y.couple_to_poly[(1, 0)].subs(dico_x0),
+            pcp_3player_nfg_no_y.couple_to_poly[(1, 1)].subs(dico_x0),
+            pcp_3player_nfg_no_y.couple_to_poly[(2, 1)].subs(dico_x0),
+        ]
+    )
 
 
 def test_compute_variety1(subsys_3p_2l_n1):
diff --git a/test/test_wilson_algorithm.py b/test/test_wilson_algorithm.py
index eed6e3a..4020a36 100644
--- a/test/test_wilson_algorithm.py
+++ b/test/test_wilson_algorithm.py
@@ -1,11 +1,14 @@
 # import numpy as np
 import pytest
+
 # from fractions import Fraction
 from sage.all import QQ
 
 from gtnash.solver.wilsonalgorithm import Node, irda_on_game, first_node
-from gtnash.util.polynomial_complementary_problem import \
-    PolynomialComplementaryProblem, Subsystem
+from gtnash.util.polynomial_complementary_problem import (
+    PolynomialComplementaryProblem,
+    Subsystem,
+)
 from gtnash.game.normalformgame import NFG
 from gtnash.game.hypergraphicalgame import HGG
 
@@ -13,8 +16,11 @@ from gtnash.game.hypergraphicalgame import HGG
 @pytest.fixture
 def nfg_3player():
     players_actions = [[0, 1], [0, 1], [0, 1]]
-    utilities = [[6, 7, 0, 5, 1, 4, 2, 3], [0, 3, 7, 4, 6, 5, 1, 2],
-                 [4, 7, 4, 0, 3, 2, 6, 1]]
+    utilities = [
+        [6, 7, 0, 5, 1, 4, 2, 3],
+        [0, 3, 7, 4, 6, 5, 1, 2],
+        [4, 7, 4, 0, 3, 2, 6, 1],
+    ]
     return NFG(players_actions, utilities)
     # return PolynomialComplementaryProblem(current_nfg)
 
@@ -25,7 +31,8 @@ def nfg_4degen():
         [50, 59, 27, 4, 72, 69, 18, 35, 6, 89, 78, 19, 36, 76, 64, 20],
         [97, 5, 90, 60, 6, 13, 56, 82, 89, 79, 52, 34, 35, 100, 60, 34],
         [15, 30, 53, 12, 79, 77, 15, 38, 100, 82, 35, 10, 24, 0, 29, 27],
-        [28, 66, 83, 1, 54, 89, 71, 35, 46, 62, 96, 26, 20, 58, 16, 81]]
+        [28, 66, 83, 1, 54, 89, 71, 35, 46, 62, 96, 26, 20, 58, 16, 81],
+    ]
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
     return NFG(players_actions, utilities)
 
@@ -33,9 +40,11 @@ def nfg_4degen():
 @pytest.fixture
 def nfg_3descent():
     players_actions = [[0, 1], [0, 1], [0, 1]]
-    utilities = [[19, 58, 64, 66, 87, 52, 59, 79],
-                 [73, 23, 80, 0, 100, 89, 43, 69],
-                 [77, 60, 29, 35, 52, 98, 19, 70]]
+    utilities = [
+        [19, 58, 64, 66, 87, 52, 59, 79],
+        [73, 23, 80, 0, 100, 89, 43, 69],
+        [77, 60, 29, 35, 52, 98, 19, 70],
+    ]
     return NFG(players_actions, utilities)
 
 
@@ -43,9 +52,14 @@ def nfg_3descent():
 def hgg1():
     players_actions = [[0, 1], [0, 1], [0, 1], [0, 1]]
     utilities = [
-        [[-3, -7, -7, -10, -1, -5, -5, -9], [-3, -7, -1, -5, -7, -10, -5, -9],
-         [-3, -1, -7, -5, -7, -5, -10, -9]],
-        [[-1, -5, 0, -3], [-1, 0, -5, -3]], [[-1, -5, 0, -3], [-1, 0, -5, -3]]]
+        [
+            [-3, -7, -7, -10, -1, -5, -5, -9],
+            [-3, -7, -1, -5, -7, -10, -5, -9],
+            [-3, -1, -7, -5, -7, -5, -10, -9],
+        ],
+        [[-1, -5, 0, -3], [-1, 0, -5, -3]],
+        [[-1, -5, 0, -3], [-1, 0, -5, -3]],
+    ]
     hypergraph = [[0, 1, 2], [1, 3], [2, 3]]
     return HGG(players_actions, utilities, hypergraph)
 
@@ -56,7 +70,7 @@ def pcp_of_game(game):
 
 def x_pairval_of_pcp(pcp):
     xpairs_val = {}
-    for (n, i) in pcp.couple_to_x.keys():
+    for n, i in pcp.couple_to_x.keys():
         if pcp.omega0[n] == i:
             xpairs_val[(n, i)] = 1
         else:
@@ -66,6 +80,7 @@ def x_pairval_of_pcp(pcp):
 
 # Faire un test_irda.py a part pour plus de test la dessus
 
+
 def test_irda_on_game1(nfg_3player):
     red_game, red_var = irda_on_game(nfg_3player)
     assert (red_game.utilities, red_var) == ([nfg_3player.utilities], [])
@@ -84,70 +99,127 @@ def test_irda_on_game3(hgg1):
 def test_node_complementary1(nfg_3player):
     pcp = pcp_of_game(nfg_3player)
     x_pairval = x_pairval_of_pcp(pcp)
-    sub_sys = Subsystem(pcp, [(2, 1)],
-                        [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)], 2, x_pairval)
-    assert Node(pcp, [(2, 1)], [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)], 2,
-                x_pairval, sub_sys, sub_sys.solutions[0]).is_complementary
+    sub_sys = Subsystem(
+        pcp, [(2, 1)], [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)], 2, x_pairval
+    )
+    assert Node(
+        pcp,
+        [(2, 1)],
+        [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)],
+        2,
+        x_pairval,
+        sub_sys,
+        sub_sys.solutions[0],
+    ).is_complementary
 
 
 def test_node_complementary2(nfg_3player):
     pcp = pcp_of_game(nfg_3player)
     x_pairval = x_pairval_of_pcp(pcp)
-    sub_sys = Subsystem(pcp, [(2, 1)],
-                        [(0, 0), (0, 1), (1, 0), (1, 1), (2, 1)], 2, x_pairval)
-    assert not Node(pcp, [(2, 1)], [(0, 0), (0, 1), (1, 0), (1, 1), (2, 1)], 2,
-                    x_pairval, sub_sys, {}).is_complementary
+    sub_sys = Subsystem(
+        pcp, [(2, 1)], [(0, 0), (0, 1), (1, 0), (1, 1), (2, 1)], 2, x_pairval
+    )
+    assert not Node(
+        pcp,
+        [(2, 1)],
+        [(0, 0), (0, 1), (1, 0), (1, 1), (2, 1)],
+        2,
+        x_pairval,
+        sub_sys,
+        {},
+    ).is_complementary
 
 
 def test_node_complementary3(nfg_3player):
     pcp = pcp_of_game(nfg_3player)
     x_pairval = x_pairval_of_pcp(pcp)
     sub_sys = Subsystem(pcp, [(0, 1)], [(0, 0), (1, 1), (0, 1)], 1, x_pairval)
-    assert not Node(pcp, [(0, 1)], [(0, 0), (1, 1), (0, 1)], 1, x_pairval,
-                    sub_sys, sub_sys.solutions[0]).is_complementary
+    assert not Node(
+        pcp,
+        [(0, 1)],
+        [(0, 0), (1, 1), (0, 1)],
+        1,
+        x_pairval,
+        sub_sys,
+        sub_sys.solutions[0],
+    ).is_complementary
 
 
 def test_node_complementary4(nfg_3player):
     pcp = pcp_of_game(nfg_3player)
     x_pairval = x_pairval_of_pcp(pcp)
-    sub_sys = Subsystem(pcp, [], [(0, 0), (1, 1), (0, 1), (1, 0)], 1,
-                        x_pairval)
-    assert Node(pcp, [], [(0, 0), (1, 1), (0, 1), (1, 0)], 1, x_pairval,
-                sub_sys, sub_sys.solutions[0]).is_complementary
+    sub_sys = Subsystem(pcp, [], [(0, 0), (1, 1), (0, 1), (1, 0)], 1, x_pairval)
+    assert Node(
+        pcp,
+        [],
+        [(0, 0), (1, 1), (0, 1), (1, 0)],
+        1,
+        x_pairval,
+        sub_sys,
+        sub_sys.solutions[0],
+    ).is_complementary
 
 
 def test_node_initial1(nfg_3player):
     pcp = pcp_of_game(nfg_3player)
     x_pairval = x_pairval_of_pcp(pcp)
-    sub_sys = Subsystem(pcp, [(2, 1)],
-                        [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)], 2, x_pairval)
-    assert Node(pcp, [(2, 1)], [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)], 2,
-                x_pairval, sub_sys, sub_sys.solutions[0]).is_initial
+    sub_sys = Subsystem(
+        pcp, [(2, 1)], [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)], 2, x_pairval
+    )
+    assert Node(
+        pcp,
+        [(2, 1)],
+        [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)],
+        2,
+        x_pairval,
+        sub_sys,
+        sub_sys.solutions[0],
+    ).is_initial
 
 
 def test_node_initial2(nfg_3player):
     pcp = pcp_of_game(nfg_3player)
     x_pairval = x_pairval_of_pcp(pcp)
-    sub_sys = Subsystem(pcp, [], [(0, 0), (1, 1), (0, 1), (1, 0)], 1,
-                        x_pairval)
-    assert not Node(pcp, [], [(0, 0), (1, 1), (0, 1), (1, 0)], 1, x_pairval,
-                    sub_sys, sub_sys.solutions[0]).is_initial
+    sub_sys = Subsystem(pcp, [], [(0, 0), (1, 1), (0, 1), (1, 0)], 1, x_pairval)
+    assert not Node(
+        pcp,
+        [],
+        [(0, 0), (1, 1), (0, 1), (1, 0)],
+        1,
+        x_pairval,
+        sub_sys,
+        sub_sys.solutions[0],
+    ).is_initial
 
 
 def test_node_initial3(nfg_3player):
     pcp = pcp_of_game(nfg_3player)
     x_pairval = x_pairval_of_pcp(pcp)
     sub_sys = Subsystem(pcp, [(0, 1)], [(0, 0), (1, 1), (0, 1)], 1, x_pairval)
-    assert not Node(pcp, [(0, 1)], [(0, 0), (1, 1), (0, 1)], 1, x_pairval,
-                    sub_sys, sub_sys.solutions[0]).is_initial
+    assert not Node(
+        pcp,
+        [(0, 1)],
+        [(0, 0), (1, 1), (0, 1)],
+        1,
+        x_pairval,
+        sub_sys,
+        sub_sys.solutions[0],
+    ).is_initial
 
 
 def test_node_initial4(nfg_3player):
     pcp = pcp_of_game(nfg_3player)
     x_pairval = x_pairval_of_pcp(pcp)
     sub_sys = Subsystem(pcp, [(0, 1), (1, 1)], [(0, 0), (1, 1)], 1, x_pairval)
-    assert Node(pcp, [(0, 1), (1, 1)], [(0, 0), (1, 1)], 1, x_pairval, sub_sys,
-                sub_sys.solutions[0]).is_initial
+    assert Node(
+        pcp,
+        [(0, 1), (1, 1)],
+        [(0, 0), (1, 1)],
+        1,
+        x_pairval,
+        sub_sys,
+        sub_sys.solutions[0],
+    ).is_initial
 
 
 # def test_node_degen1(nfg_3player):
@@ -186,13 +258,14 @@ def test_node_initial4(nfg_3player):
 #     assert Node(pcp, [(0, 0), (1, 1)], [(0, 1), (1, 0)], 1,
 #     x_pairval, sub_sys,sub_sys.solutions[0]).is_degenerate
 
+
 def test_first_node0(nfg_3player):
     pcp = pcp_of_game(nfg_3player)
     x_pairval = x_pairval_of_pcp(pcp)
     first_n = first_node(pcp, x_pairval)[0]
     assert first_n.set_z == [(0, 1)]
     assert first_n.set_w == [(0, 0)]
-    assert first_n.coordinates == {pcp.ring('x0_0'): 1, pcp.ring('x0_1'): 0}
+    assert first_n.coordinates == {pcp.ring("x0_0"): 1, pcp.ring("x0_1"): 0}
 
 
 def test_first_node1(nfg_4degen):
@@ -202,7 +275,7 @@ def test_first_node1(nfg_4degen):
     first_n = first_node(pcp, x_pairval)[0]
     assert first_n.set_z == [(0, 0)]
     assert first_n.set_w == [(0, 1)]
-    assert first_n.coordinates == {pcp.ring('x0_0'): 0, pcp.ring('x0_1'): 1}
+    assert first_n.coordinates == {pcp.ring("x0_0"): 0, pcp.ring("x0_1"): 1}
 
 
 def test_first_node2(hgg1):
@@ -211,7 +284,7 @@ def test_first_node2(hgg1):
     first_n = first_node(pcp, x_pairval)[0]
     assert first_n.set_z == [(0, 0)]
     assert first_n.set_w == [(0, 1)]
-    assert first_n.coordinates == {pcp.ring('x0_0'): 0, pcp.ring('x0_1'): 1}
+    assert first_n.coordinates == {pcp.ring("x0_0"): 0, pcp.ring("x0_1"): 1}
 
 
 def test_lift0(nfg_3player):
@@ -228,14 +301,19 @@ def test_lift0(nfg_3player):
 def test_lift1(nfg_3player):
     pcp = pcp_of_game(nfg_3player)
     x_pairval = x_pairval_of_pcp(pcp)
-    sub_sys = Subsystem(pcp, [], [(0, 0), (1, 1), (0, 1), (1, 0)], 1,
-                        x_pairval)
-    lift_node = Node(pcp, [], [(0, 0), (1, 1), (0, 1), (1, 0)],
-                     1, x_pairval, sub_sys,
-                     sub_sys.solutions[0]).lift(pcp, x_pairval)[0]
-    sub_sys_lift = Subsystem(pcp, [(2, 1)],
-                             [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)], 2,
-                             x_pairval)
+    sub_sys = Subsystem(pcp, [], [(0, 0), (1, 1), (0, 1), (1, 0)], 1, x_pairval)
+    lift_node = Node(
+        pcp,
+        [],
+        [(0, 0), (1, 1), (0, 1), (1, 0)],
+        1,
+        x_pairval,
+        sub_sys,
+        sub_sys.solutions[0],
+    ).lift(pcp, x_pairval)[0]
+    sub_sys_lift = Subsystem(
+        pcp, [(2, 1)], [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)], 2, x_pairval
+    )
     assert set(lift_node.set_z) == {(2, 1)}
     assert set(lift_node.set_w) == {(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)}
     assert lift_node.coordinates == sub_sys_lift.solutions[0]
@@ -251,8 +329,7 @@ def test_traverse0(nfg_3player):
     first_n = first_node(pcp, x_pairval)[0]
     lift_node = first_n.lift(pcp, x_pairval)[0]
     next_node = lift_node.traverse(first_n, x_pairval)[0]
-    sub_sys_trav = Subsystem(pcp, [(0, 1)], [(0, 0), (1, 1), (0, 1)], 1,
-                             x_pairval)
+    sub_sys_trav = Subsystem(pcp, [(0, 1)], [(0, 0), (1, 1), (0, 1)], 1, x_pairval)
     assert set(next_node.set_z) == {(0, 1)}
     assert set(next_node.set_w) == {(0, 0), (1, 1), (0, 1)}
     assert next_node.coordinates == sub_sys_trav.solutions[0]
@@ -262,14 +339,20 @@ def test_descent0(nfg_3descent):
     pcp = pcp_of_game(nfg_3descent)
     pcp.omega0 = {0: 0, 1: 1, 2: 0}
     x_pairval = x_pairval_of_pcp(pcp)
-    sub_sys = Subsystem(pcp, [(2, 1)],
-                        [(0, 0), (1, 1), (2, 1), (1, 0), (0, 1)], 2, x_pairval)
-    current_node = Node(pcp, [(2, 1)],
-                        [(0, 0), (1, 1), (2, 1), (1, 0), (0, 1)], 2, x_pairval,
-                        sub_sys, sub_sys.solutions[0])
+    sub_sys = Subsystem(
+        pcp, [(2, 1)], [(0, 0), (1, 1), (2, 1), (1, 0), (0, 1)], 2, x_pairval
+    )
+    current_node = Node(
+        pcp,
+        [(2, 1)],
+        [(0, 0), (1, 1), (2, 1), (1, 0), (0, 1)],
+        2,
+        x_pairval,
+        sub_sys,
+        sub_sys.solutions[0],
+    )
     descent_node = current_node.descend(pcp, x_pairval)[0]
-    sub_sys_desc = Subsystem(pcp, [], [(0, 0), (1, 1), (1, 0), (0, 1)], 1,
-                             x_pairval)
+    sub_sys_desc = Subsystem(pcp, [], [(0, 0), (1, 1), (1, 0), (0, 1)], 1, x_pairval)
     assert set(descent_node.set_z) == set([])
     assert set(descent_node.set_w) == {(0, 0), (1, 1), (1, 0), (0, 1)}
     assert descent_node.coordinates == sub_sys_desc.solutions[0]
@@ -287,9 +370,20 @@ def test_compute_arc0(nfg_3player):
 def test_normalized_strategy0(nfg_3player):
     pcp = pcp_of_game(nfg_3player)
     x_pairval = x_pairval_of_pcp(pcp)
-    sub_sys = Subsystem(pcp, [(2, 1)],
-                        [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)], 2, x_pairval)
-    node = Node(pcp, [(2, 1)], [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)], 2,
-                x_pairval, sub_sys, sub_sys.solutions[0])
-    assert node.normalized_strategy() == {0: [QQ(5 / 12), QQ(7 / 12)],
-                                          1: [QQ(2 / 7), QQ(5 / 7)], 2: [1, 0]}
+    sub_sys = Subsystem(
+        pcp, [(2, 1)], [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)], 2, x_pairval
+    )
+    node = Node(
+        pcp,
+        [(2, 1)],
+        [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)],
+        2,
+        x_pairval,
+        sub_sys,
+        sub_sys.solutions[0],
+    )
+    assert node.normalized_strategy() == {
+        0: [QQ(5 / 12), QQ(7 / 12)],
+        1: [QQ(2 / 7), QQ(5 / 7)],
+        2: [1, 0],
+    }
-- 
GitLab


From 48ebe006c7a0a2fbc2c003f5d0ef3ca533386496 Mon Sep 17 00:00:00 2001
From: Prasanna Maddila <maddilaprasanna10@gmail.com>
Date: Wed, 13 Nov 2024 12:15:48 +0100
Subject: [PATCH 08/13] HypergraphicalGame: Int to delete

---
 gtnash/game/hypergraphicalgame.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/gtnash/game/hypergraphicalgame.py b/gtnash/game/hypergraphicalgame.py
index b23a7cd..f438742 100644
--- a/gtnash/game/hypergraphicalgame.py
+++ b/gtnash/game/hypergraphicalgame.py
@@ -715,8 +715,7 @@ class HGG(AbstractGame):
                 prob_jact_i[n] = p_n_prob
             expc_util_i = self.expected_utilities(prob_jact_i)
             for n, val_util in enumerate(expc_util_i):
-                tmp_util[n] += [int(val_util)]
-                # Int a supprimer
+                tmp_util[n] += [val_util]
         return NFG(self.players_actions, tmp_util)
 
     # should be classmethod
-- 
GitLab


From c92e0abddf17bc874e23c51e35f04c60663029bf Mon Sep 17 00:00:00 2001
From: ssmaddila <siva-sri-prasanna.maddila@inrae.fr>
Date: Thu, 14 Nov 2024 09:16:06 +0100
Subject: [PATCH 09/13] Made test/test_normalformgame.py independent of
 execution directory.

Error was that some filepaths for the read and write tests were using
hardcoded paths i.e. if I execute `pytest` from `home/user`, while the
test directory is at `home/user/gtnash/test`, the failing tests would look
for `filestest/` in `home/user` instead of the test directory. Using
`pathlib` to resolve the correct path at runtime solves this.
---
 test/test_normalformgame.py | 28 ++++++++++++++++------------
 1 file changed, 16 insertions(+), 12 deletions(-)

diff --git a/test/test_normalformgame.py b/test/test_normalformgame.py
index 268ccf6..aaa1299 100644
--- a/test/test_normalformgame.py
+++ b/test/test_normalformgame.py
@@ -1,9 +1,13 @@
+import pathlib
 import numpy as np
 import pytest
 
 from gtnash.game.normalformgame import NFG
 from fractions import Fraction
 
+PATH = pathlib.Path(__file__).parent.resolve()
+FILESTEST = PATH / "filestest"
+
 """
 Separate  assert in multiple fucntion
 """
@@ -780,13 +784,13 @@ def test_get_subgame_fixed_strat4(bimat_nfg):
 
 
 def test_readNFGpayoff1():
-    read_game = NFG.readNFGpayoff("filestest/e02.nfg")
+    read_game = NFG.readNFGpayoff(FILESTEST / "e02.nfg")
     assert read_game.players_actions == [[0, 1], [0, 1, 2]]
     assert read_game.utilities == [[1, 2, 2, 1, 3, 0], [1, 0, 0, 1, 0, 2]]
 
 
 def test_readNFGpayoff2():
-    read_game = NFG.readNFGpayoff("filestest/RandG_0.nfg")
+    read_game = NFG.readNFGpayoff(FILESTEST / "RandG_0.nfg")
     assert read_game.players_actions == [[0, 1], [0, 1], [0, 1]]
     assert read_game.utilities == [
         [43, 38, 1, 63, 61, 21, 12, 46],
@@ -796,7 +800,7 @@ def test_readNFGpayoff2():
 
 
 def test_readNFGpayoff3():
-    read_game = NFG.readNFGpayoff("filestest/custom_game1.nfg")
+    read_game = NFG.readNFGpayoff(FILESTEST / "custom_game1.nfg")
     assert read_game.players_actions == [[0, 1, 2], [0, 1, 2], [0, 1]]
     assert read_game.utilities == [
         [91, 49, 69, 98, 95, 15, 70, 59, 68, 52, 45, 22, 14, 37, 54, 58, 41, 92],
@@ -806,34 +810,34 @@ def test_readNFGpayoff3():
 
 
 def test_readNFGpayoff4():
-    read_game = NFG.readNFGpayoff("filestest/custom_game2.nfg")
+    read_game = NFG.readNFGpayoff(FILESTEST / "custom_game2.nfg")
     assert read_game.players_actions == [[0, 1], [0, 1]]
     assert read_game.utilities == [[-69, -67, -100, -14], [-64, -86, -65, -75]]
 
 
 def test_writeNFGpayoff1(first_nfg):
-    first_nfg.writeNFGpayoff("filestest/first_nfg.nfg")
-    read_game = NFG.readNFGpayoff("filestest/first_nfg.nfg")
+    first_nfg.writeNFGpayoff(FILESTEST / "first_nfg.nfg")
+    read_game = NFG.readNFGpayoff(FILESTEST / "first_nfg.nfg")
     assert read_game.players_actions == first_nfg.players_actions
     assert read_game.utilities == first_nfg.utilities
 
 
 def test_writeNFGpayoff2(second_nfg):
-    second_nfg.writeNFGpayoff("filestest/second_nfg.nfg")
-    read_game = NFG.readNFGpayoff("filestest/second_nfg.nfg")
+    second_nfg.writeNFGpayoff(FILESTEST / "second_nfg.nfg")
+    read_game = NFG.readNFGpayoff(FILESTEST / "second_nfg.nfg")
     assert read_game.players_actions == second_nfg.players_actions
     assert read_game.utilities == second_nfg.utilities
 
 
 def test_writeNFGpayoff3(third_nfg):
-    third_nfg.writeNFGpayoff("filestest/third_nfg.nfg")
-    read_game = NFG.readNFGpayoff("filestest/third_nfg.nfg")
+    third_nfg.writeNFGpayoff(FILESTEST / "third_nfg.nfg")
+    read_game = NFG.readNFGpayoff(FILESTEST / "third_nfg.nfg")
     assert read_game.players_actions == third_nfg.players_actions
     assert read_game.utilities == third_nfg.utilities
 
 
 def test_writeNFGpayoff4(bimat_nfg):
-    bimat_nfg.writeNFGpayoff("filestest/bimat_nfg.nfg")
-    read_game = NFG.readNFGpayoff("filestest/bimat_nfg.nfg")
+    bimat_nfg.writeNFGpayoff(FILESTEST / "bimat_nfg.nfg")
+    read_game = NFG.readNFGpayoff(FILESTEST / "bimat_nfg.nfg")
     assert read_game.players_actions == bimat_nfg.players_actions
     assert read_game.utilities == bimat_nfg.utilities
-- 
GitLab


From 14f81b5cee73af0806530f7f4abf5bd64b4a42a7 Mon Sep 17 00:00:00 2001
From: ssmaddila <siva-sri-prasanna.maddila@inrae.fr>
Date: Thu, 28 Nov 2024 13:09:25 +0100
Subject: [PATCH 10/13] Detecting the right length of the prob_vector

---
 gtnash/game/normalformgame.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/gtnash/game/normalformgame.py b/gtnash/game/normalformgame.py
index 8cbf0cb..2da3fe9 100644
--- a/gtnash/game/normalformgame.py
+++ b/gtnash/game/normalformgame.py
@@ -308,7 +308,9 @@ class NFG(AbstractGame):
             )
             for ai in range(len(self.players_actions[play])):
                 other_strategy = mixed_joint_strategy.copy()
-                other_strategy[play] = np.zeros(len(mixed_joint_strategy[play]))
+                other_strategy[play] = np.zeros(
+                    len(mixed_joint_strategy[play].squeeze())
+                )
                 other_strategy[play][ai] = 1
                 expected_util_of_other = self.expected_utilities(other_strategy)
                 all_valuediff += [
-- 
GitLab


From e63957f5894e40161b37302add8e80efc37c0ee6 Mon Sep 17 00:00:00 2001
From: ssmaddila <siva-sri-prasanna.maddila@inrae.fr>
Date: Tue, 10 Dec 2024 10:48:20 +0100
Subject: [PATCH 11/13] HGG.write_GameFile no longer converts rewards to int.

This function was writing the rewards (self.utilities) by converting
them to integers.
---
 gtnash/game/hypergraphicalgame.py | 2 +-
 gtnash/game/yes                   | 8 ++++++++
 gtnash/game/yes.pub               | 1 +
 3 files changed, 10 insertions(+), 1 deletion(-)
 create mode 100644 gtnash/game/yes
 create mode 100644 gtnash/game/yes.pub

diff --git a/gtnash/game/hypergraphicalgame.py b/gtnash/game/hypergraphicalgame.py
index f438742..7c6b9e9 100644
--- a/gtnash/game/hypergraphicalgame.py
+++ b/gtnash/game/hypergraphicalgame.py
@@ -920,7 +920,7 @@ class HGG(AbstractGame):
             fileTestwrite.write(str_hyper_edge)
             str_utilities = ""
             for uti in payoffwrite[index_hyper_edge]:
-                str_utilities += f"{int(uti)} "
+                str_utilities += f"{uti} "
             fileTestwrite.write(str_utilities + "\n")
         fileTestwrite.close()
 
diff --git a/gtnash/game/yes b/gtnash/game/yes
new file mode 100644
index 0000000..c8abb6a
--- /dev/null
+++ b/gtnash/game/yes
@@ -0,0 +1,8 @@
+-----BEGIN OPENSSH PRIVATE KEY-----
+b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW
+QyNTUxOQAAACC+FTU5eCYKvfiES8OPxyH3rqxo37iAJpqvQeoKNlMzQwAAAKj0waBZ9MGg
+WQAAAAtzc2gtZWQyNTUxOQAAACC+FTU5eCYKvfiES8OPxyH3rqxo37iAJpqvQeoKNlMzQw
+AAAEBJLAv4arQ/UowXfR3i16ICmC5lb4w8w8MkkLijocY/0L4VNTl4Jgq9+IRLw4/HIfeu
+rGjfuIAmmq9B6go2UzNDAAAAInNpdmEtc3JpLXByYXNhbm5hLm1hZGRpbGFAaW5yYWUuZn
+IBAgM=
+-----END OPENSSH PRIVATE KEY-----
diff --git a/gtnash/game/yes.pub b/gtnash/game/yes.pub
new file mode 100644
index 0000000..1f045a1
--- /dev/null
+++ b/gtnash/game/yes.pub
@@ -0,0 +1 @@
+ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIL4VNTl4Jgq9+IRLw4/HIfeurGjfuIAmmq9B6go2UzND siva-sri-prasanna.maddila@inrae.fr
-- 
GitLab


From 9c7cc374753d65f063fdcdf5d9c000a4fa09899d Mon Sep 17 00:00:00 2001
From: ssmaddila <siva-sri-prasanna.maddila@inrae.fr>
Date: Tue, 10 Dec 2024 11:09:55 +0100
Subject: [PATCH 12/13] Fixed HGG.read_GameFile to accept floats

---
 gtnash/game/hypergraphicalgame.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/gtnash/game/hypergraphicalgame.py b/gtnash/game/hypergraphicalgame.py
index 7c6b9e9..2e01224 100644
--- a/gtnash/game/hypergraphicalgame.py
+++ b/gtnash/game/hypergraphicalgame.py
@@ -823,7 +823,9 @@ class HGG(AbstractGame):
         # but there is only 1 element to iterate on
         for i, s in enumerate(iterTest):
             sublist_utilites = [
-                int(sub_int) for sub_int in s.group(1).strip("\n").split(" ") if sub_int
+                float(sub_int)
+                for sub_int in s.group(1).strip("\n").split(" ")
+                if sub_int
             ]
             n_players = len(hypergraph[i])
             # Initialize the list of utility
-- 
GitLab


From e40c71f3f8b6ea6d280a4aaa73b2eeec55394087 Mon Sep 17 00:00:00 2001
From: ssmaddila <siva-sri-prasanna.maddila@inrae.fr>
Date: Fri, 24 Jan 2025 10:32:15 +0100
Subject: [PATCH 13/13] gtnash/game/normalformgame.py: removed np.mat since it
 is deprecated

---
 gtnash/game/normalformgame.py |  16 +-
 notebook/quickstart.ipynb     | 540 ++++------------------------------
 2 files changed, 66 insertions(+), 490 deletions(-)

diff --git a/gtnash/game/normalformgame.py b/gtnash/game/normalformgame.py
index 2da3fe9..547ba5d 100644
--- a/gtnash/game/normalformgame.py
+++ b/gtnash/game/normalformgame.py
@@ -23,9 +23,9 @@ class NFG(AbstractGame):
         self.joint_actions = []
         self.joint_actions = self.generate_joint_actions(players_actions)
         self.utilities = utilities
-        self.disutilities = np.mat(np.zeros(self.joint_actions.shape))
+        self.disutilities = np.asmatrix(np.zeros(self.joint_actions.shape))
         for i, i_utilities in enumerate(utilities):
-            u_tmp = np.mat(i_utilities)
+            u_tmp = np.asmatrix(i_utilities)
             u_tmp = u_tmp.transpose()
             self.disutilities[:, i] = u_tmp
         self.transform_utilities()
@@ -41,11 +41,13 @@ class NFG(AbstractGame):
             lists of actions available to every players.
 
         :returns: A matrix which rows are the joint strategies.
-        :rtype: np.matrix of int.
+        :rtype: np.asmatrixrix of int.
         """
         if players_actions is None:
             players_actions = self.players_actions
-        return np.matrix([jaction for jaction in itertools.product(*players_actions)])
+        return np.asmatrixrix(
+            [jaction for jaction in itertools.product(*players_actions)]
+        )
 
     def all_response_of_player(self, player_ind, action):
         """Generates all the possible joint strategies obtained by
@@ -56,7 +58,7 @@ class NFG(AbstractGame):
         :param list action: Arbitrary joint strategy of players.
 
         :returns: A matrix which rows are the obtained joint strategies.
-        :rtype: np.matrix.
+        :rtype: np.asmatrixrix.
         """
         action_in_use = []
         for i in range(self.n_players):
@@ -74,7 +76,7 @@ class NFG(AbstractGame):
 
         :returns: A matrix which rows are all the pure joint strategies
             excluding player *player_ind*'s action.
-        :rtype: np.matrix.
+        :rtype: np.asmatrixrix.
         """
         action_in_use = [
             act for i, act in enumerate(self.players_actions) if (i != player_ind)
@@ -828,7 +830,7 @@ class NFG(AbstractGame):
         mat_utilities = mat_utilities.astype(str)
         tableau_final = np.concatenate(
             (
-                np.mat(label),
+                np.asmatrix(label),
                 np.concatenate((self.joint_actions, mat_utilities), axis=1),
             ),
             axis=0,
diff --git a/notebook/quickstart.ipynb b/notebook/quickstart.ipynb
index 3489906..e5316b1 100644
--- a/notebook/quickstart.ipynb
+++ b/notebook/quickstart.ipynb
@@ -17,7 +17,19 @@
    "cell_type": "code",
    "execution_count": 1,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "ename": "ModuleNotFoundError",
+     "evalue": "No module named 'gtnash'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mModuleNotFoundError\u001b[0m                       Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[1], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mnumpy\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mnp\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mgtnash\u001b[39;00m\n\u001b[1;32m      3\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01msage\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mall\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;241m*\u001b[39m\n\u001b[1;32m      4\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mgtnash\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mgame\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mnormalformgame\u001b[39;00m  \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;241m*\u001b[39m\n",
+      "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'gtnash'"
+     ]
+    }
+   ],
    "source": [
     "import numpy as np\n",
     "import gtnash\n",
@@ -38,26 +50,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Utilities of the game\n",
-      "[['A0' 'A1' 'A2' 'U0' 'U1' 'U2']\n",
-      " ['0' '0' '0' '6' '0' '4']\n",
-      " ['0' '0' '1' '7' '3' '7']\n",
-      " ['0' '1' '0' '0' '7' '4']\n",
-      " ['0' '1' '1' '5' '4' '0']\n",
-      " ['1' '0' '0' '1' '6' '3']\n",
-      " ['1' '0' '1' '4' '5' '2']\n",
-      " ['1' '1' '0' '2' '1' '6']\n",
-      " ['1' '1' '1' '3' '2' '1']]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "players_actions = [[0, 1], [0, 1], [0, 1]]\n",
     "utilities=[[6,7,0,5,1,4,2,3],[0,3,7,4,6,5,1,2],[4,7,4,0,3,2,6,1]]\n",
@@ -94,7 +89,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -110,18 +105,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{0: [0.4166666666666667?, 0.5833333333333333?], 1: [0.2857142857142857?, 0.714285714285715?], 2: [1.000000000000000?, 0]}\n",
-      "Is this an equilibrium?  True\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "equilibrium = wilson(current_nfg)\n",
     "print(equilibrium)\n",
@@ -139,19 +125,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Player 0: [5/12, 7/12]\n",
-      "Player 1: [2/7, 5/7]\n",
-      "Player 2: [1, 0]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "for n in equilibrium.keys():\n",
     "    print(f\"Player {n}: {[x.radical_expression() for x in equilibrium[n]]}\")"
@@ -166,19 +142,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{0: [0.4166666666666667?, 0.5833333333333333?], 1: [0.2857142857142857?, 0.714285714285715?], 2: [1.000000000000000?, 0]}\n",
-      "CPU times: user 826 ms, sys: 4.82 ms, total: 831 ms\n",
-      "Wall time: 830 ms\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%time print(wilson(current_nfg))"
    ]
@@ -200,19 +166,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "{0: [0.4166666666666667?, 0.5833333333333333?], 1: [0.2857142857142857?, 0.714285714285715?], 2: [1.000000000000000?, 0]}\n",
-      "CPU times: user 188 ms, sys: 28.1 ms, total: 216 ms\n",
-      "Wall time: 375 ms\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from gtnash.solver.pns import *\n",
     "%time print(PNS_solver(current_nfg).launch_pns())"
@@ -235,7 +191,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -252,53 +208,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Utilities of the game\n",
-      "Local game  0 : \n",
-      " [['A0' 'A1' 'U0' 'U1']\n",
-      " ['0' '0' '8' '4']\n",
-      " ['0' '1' '2' '1']\n",
-      " ['0' '2' '5' '4']\n",
-      " ['1' '0' '5' '5']\n",
-      " ['1' '1' '1' '6']\n",
-      " ['1' '2' '7' '2']\n",
-      " ['2' '0' '1' '4']\n",
-      " ['2' '1' '5' '7']\n",
-      " ['2' '2' '1' '3']]\n",
-      "Local game  1 : \n",
-      " [['A0' 'A2' 'U0' 'U2']\n",
-      " ['0' '0' '2' '2']\n",
-      " ['0' '1' '2' '5']\n",
-      " ['0' '2' '4' '4']\n",
-      " ['1' '0' '7' '7']\n",
-      " ['1' '1' '9' '1']\n",
-      " ['1' '2' '4' '5']\n",
-      " ['2' '0' '5' '2']\n",
-      " ['2' '1' '5' '1']\n",
-      " ['2' '2' '5' '6']]\n",
-      "Local game  2 : \n",
-      " [['A1' 'A2' 'U1' 'U2']\n",
-      " ['0' '0' '9' '8']\n",
-      " ['0' '1' '3' '8']\n",
-      " ['0' '2' '4' '6']\n",
-      " ['1' '0' '9' '9']\n",
-      " ['1' '1' '5' '1']\n",
-      " ['1' '2' '5' '4']\n",
-      " ['2' '0' '9' '9']\n",
-      " ['2' '1' '5' '1']\n",
-      " ['2' '2' '4' '3']]\n",
-      "\n",
-      " Hypergraph: \n",
-      "[[0, 1], [0, 2], [1, 2]]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "utilities = [[[8, 2, 5, 5, 1, 7, 1, 5, 1], [4, 1, 4, 5, 6, 2, 4, 7, 3]],\n",
     "             [[2, 2, 4, 7, 9, 4, 5, 5, 5], [2, 5, 4, 7, 1, 5, 2, 1, 6]],\n",
@@ -328,21 +240,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "CPU times: user 64.1 ms, sys: 76.7 ms, total: 141 ms\n",
-      "Wall time: 17.2 ms\n",
-      "player 0 -> mixed strategy -> [0.0, 0.0, 1.0]\n",
-      "player 1 -> mixed strategy -> [0.0, 1.0, 0.0]\n",
-      "player 2 -> mixed strategy -> [1.0, 0.0, 0.0]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "solver = LHpolymatrix(PMG(players_actions, utilities, hypergraph))\n",
     "omega0 = [0,0,0] # Initial joint action used to initialize the Lemke-Howson algorithm\n",
@@ -361,17 +261,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Is it a Nash equilibrium?  True\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(\"Is it a Nash equilibrium? \",current_pmg.is_equilibrium(sol_dict))"
    ]
@@ -386,50 +278,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[['A0' 'A1' 'A2' 'U0' 'U1' 'U2']\n",
-      " ['0' '0' '0' '10' '13' '10']\n",
-      " ['0' '0' '1' '10' '7' '13']\n",
-      " ['0' '0' '2' '12' '8' '10']\n",
-      " ['0' '1' '0' '4' '10' '11']\n",
-      " ['0' '1' '1' '4' '6' '6']\n",
-      " ['0' '1' '2' '6' '6' '8']\n",
-      " ['0' '2' '0' '7' '13' '11']\n",
-      " ['0' '2' '1' '7' '9' '6']\n",
-      " ['0' '2' '2' '9' '8' '7']\n",
-      " ['1' '0' '0' '12' '14' '15']\n",
-      " ['1' '0' '1' '14' '8' '9']\n",
-      " ['1' '0' '2' '9' '9' '11']\n",
-      " ['1' '1' '0' '8' '15' '16']\n",
-      " ['1' '1' '1' '10' '11' '2']\n",
-      " ['1' '1' '2' '5' '11' '9']\n",
-      " ['1' '2' '0' '14' '11' '16']\n",
-      " ['1' '2' '1' '16' '7' '2']\n",
-      " ['1' '2' '2' '11' '6' '8']\n",
-      " ['2' '0' '0' '6' '13' '10']\n",
-      " ['2' '0' '1' '6' '7' '9']\n",
-      " ['2' '0' '2' '6' '8' '12']\n",
-      " ['2' '1' '0' '10' '16' '11']\n",
-      " ['2' '1' '1' '10' '12' '2']\n",
-      " ['2' '1' '2' '10' '12' '10']\n",
-      " ['2' '2' '0' '6' '12' '11']\n",
-      " ['2' '2' '1' '6' '8' '2']\n",
-      " ['2' '2' '2' '6' '7' '9']]\n",
-      "CPU times: user 1.62 s, sys: 8.84 ms, total: 1.62 s\n",
-      "Wall time: 1.63 s\n",
-      "{0: [0, 0, 1.000000000000000?], 1: [0, 1.000000000000000?, 0], 2: [1.000000000000000?, 0, 0]}\n",
-      "Player 0: [0, 0, 1]\n",
-      "Player 1: [0, 1, 0]\n",
-      "Player 2: [1, 0, 0]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "converted_nfg = current_pmg.convert_to_NFG()\n",
     "print(converted_nfg)\n",
@@ -457,40 +308,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Utilities of the hypergraphical game:\n",
-      "Local game  0 : \n",
-      " [['A0' 'A1' 'A3' 'U0' 'U1' 'U3']\n",
-      " ['0' '0' '0' '74' '51' '18']\n",
-      " ['0' '0' '1' '6' '97' '16']\n",
-      " ['0' '1' '0' '9' '98' '29']\n",
-      " ['0' '1' '1' '60' '83' '86']\n",
-      " ['1' '0' '0' '77' '90' '100']\n",
-      " ['1' '0' '1' '30' '1' '96']\n",
-      " ['1' '1' '0' '47' '2' '93']\n",
-      " ['1' '1' '1' '0' '47' '64']]\n",
-      "Local game  1 : \n",
-      " [['A0' 'A2' 'A3' 'U0' 'U2' 'U3']\n",
-      " ['0' '0' '0' '84' '10' '1']\n",
-      " ['0' '0' '1' '48' '88' '36']\n",
-      " ['0' '1' '0' '27' '72' '68']\n",
-      " ['0' '1' '1' '5' '47' '0']\n",
-      " ['1' '0' '0' '100' '13' '53']\n",
-      " ['1' '0' '1' '62' '24' '5']\n",
-      " ['1' '1' '0' '16' '42' '61']\n",
-      " ['1' '1' '1' '62' '72' '97']]\n",
-      "\n",
-      " Hypergraph: \n",
-      "[[0, 1, 3], [0, 2, 3]]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from gtnash.game.hypergraphicalgame import *\n",
     "utilities = [\n",
@@ -521,25 +341,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "CPU times: user 6.66 s, sys: 12.8 ms, total: 6.68 s\n",
-      "Wall time: 6.67 s\n",
-      "{0: [0.651851851851852?, 0.3481481481481481?], 1: [0.7714285714285714?, 0.2285714285714286?], 2: [0, 1.000000000000000?], 3: [1.000000000000000?, 0]}\n",
-      "Is this an equilibrium?  True\n",
-      "Algebraic number representation:\n",
-      "Player 0: [88/135, 47/135]\n",
-      "Player 1: [27/35, 8/35]\n",
-      "Player 2: [0, 1]\n",
-      "Player 3: [1, 0]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%time equilibrium = wilson(current_hgg)\n",
     "print(equilibrium)\n",
@@ -558,25 +362,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "CPU times: user 428 ms, sys: 12 ms, total: 440 ms\n",
-      "Wall time: 442 ms\n",
-      "{0: [0.7666666666666667?, 0.2333333333333334?], 1: [0.5476190476190476?, 0.4523809523809524?], 2: [1.000000000000000?, 0], 3: [0, 1.000000000000000?]}\n",
-      "Is this an equilibrium?  True\n",
-      "Algebraic number representation:\n",
-      "Player 0: [23/30, 7/30]\n",
-      "Player 1: [23/42, 19/42]\n",
-      "Player 2: [1, 0]\n",
-      "Player 3: [0, 1]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "converted_nfg = current_hgg.convert_to_NFG()\n",
     "%time equilibrium_PNS = PNS_solver(converted_nfg).launch_pns()\n",
@@ -596,25 +384,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "CPU times: user 2.38 s, sys: 12.4 ms, total: 2.4 s\n",
-      "Wall time: 2.39 s\n",
-      "{0: [0.651851851851852?, 0.3481481481481481?], 1: [0.7714285714285714?, 0.2285714285714286?], 2: [0, 1.000000000000000?], 3: [1.000000000000000?, 0]}\n",
-      "Is this an equilibrium?  True\n",
-      "Algebraic number representation:\n",
-      "Player 0: [88/135, 47/135]\n",
-      "Player 1: [27/35, 8/35]\n",
-      "Player 2: [0, 1]\n",
-      "Player 3: [1, 0]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "%time equilibrium_wilson = wilson(converted_nfg)\n",
     "print(equilibrium_wilson)\n",
@@ -636,73 +408,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Theta 0 = [[0 0]] and P(Theta 0 ) = 1/10 \n",
-      " [['A0' 'A1' 'U0' 'U1']\n",
-      " ['0' '0' '-3' '-3']\n",
-      " ['0' '1' '-7' '-7']\n",
-      " ['1' '0' '-10' '-1']\n",
-      " ['1' '1' '-1' '-5']\n",
-      " ['2' '0' '-5' '-10']\n",
-      " ['2' '1' '-9' '-9']] \n",
-      "\n",
-      "Theta 1 = [[0 1]] and P(Theta 1 ) = 1/5 \n",
-      " [['A0' 'A1' 'U0' 'U1']\n",
-      " ['0' '0' '-2' '-2']\n",
-      " ['0' '1' '-6' '-6']\n",
-      " ['1' '0' '-9' '-1']\n",
-      " ['1' '1' '-1' '-4']\n",
-      " ['2' '0' '-4' '-9']\n",
-      " ['2' '1' '-8' '-8']] \n",
-      "\n",
-      "Theta 2 = [[0 2]] and P(Theta 2 ) = 1/5 \n",
-      " [['A0' 'A1' 'U0' 'U1']\n",
-      " ['0' '0' '-2' '-2']\n",
-      " ['0' '1' '-5' '-5']\n",
-      " ['1' '0' '-8' '-1']\n",
-      " ['1' '1' '-1' '-3']\n",
-      " ['2' '0' '-3' '-8']\n",
-      " ['2' '1' '-7' '-7']] \n",
-      "\n",
-      "Theta 3 = [[1 0]] and P(Theta 3 ) = 1/5 \n",
-      " [['A0' 'A1' 'U0' 'U1']\n",
-      " ['0' '0' '-2' '-2']\n",
-      " ['0' '1' '-4' '-4']\n",
-      " ['1' '0' '-7' '-1']\n",
-      " ['1' '1' '-1' '-3']\n",
-      " ['2' '0' '-3' '-7']\n",
-      " ['2' '1' '-6' '-6']] \n",
-      "\n",
-      "Theta 4 = [[1 1]] and P(Theta 4 ) = 1/10 \n",
-      " [['A0' 'A1' 'U0' 'U1']\n",
-      " ['0' '0' '-2' '-2']\n",
-      " ['0' '1' '-4' '-4']\n",
-      " ['1' '0' '-6' '-1']\n",
-      " ['1' '1' '-1' '-3']\n",
-      " ['2' '0' '-3' '-6']\n",
-      " ['2' '1' '-5' '-5']] \n",
-      "\n",
-      "Theta 5 = [[1 2]] and P(Theta 5 ) = 1/5 \n",
-      " [['A0' 'A1' 'U0' 'U1']\n",
-      " ['0' '0' '-3' '-3']\n",
-      " ['0' '1' '-7' '-7']\n",
-      " ['1' '0' '-1' '-10']\n",
-      " ['1' '1' '-5' '-1']\n",
-      " ['2' '0' '-10' '-5']\n",
-      " ['2' '1' '-9' '-9']] \n",
-      "\n",
-      "\n",
-      " Type: \n",
-      "[[0, 1], [0, 1, 2]]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "players_actions = [[0, 1, 2], [0, 1]]\n",
     "utilities = [[[-3, -7, -10, -1, -5, -9], [-3, -7, -1, -5, -10, -9]],\n",
@@ -726,79 +434,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Local game  0 : \n",
-      " [['A0' 'A2' 'U0' 'U2']\n",
-      " ['0' '0' '-3/5' '-1']\n",
-      " ['0' '1' '-7/5' '-7/3']\n",
-      " ['1' '0' '-2' '-1/3']\n",
-      " ['1' '1' '-1/5' '-5/3']\n",
-      " ['2' '0' '-1' '-10/3']\n",
-      " ['2' '1' '-9/5' '-3']]\n",
-      "Local game  1 : \n",
-      " [['A0' 'A3' 'U0' 'U3']\n",
-      " ['0' '0' '-4/5' '-4/3']\n",
-      " ['0' '1' '-12/5' '-4']\n",
-      " ['1' '0' '-18/5' '-2/3']\n",
-      " ['1' '1' '-2/5' '-8/3']\n",
-      " ['2' '0' '-8/5' '-6']\n",
-      " ['2' '1' '-16/5' '-16/3']]\n",
-      "Local game  2 : \n",
-      " [['A0' 'A4' 'U0' 'U4']\n",
-      " ['0' '0' '-4/5' '-1']\n",
-      " ['0' '1' '-2' '-5/2']\n",
-      " ['1' '0' '-16/5' '-1/2']\n",
-      " ['1' '1' '-2/5' '-3/2']\n",
-      " ['2' '0' '-6/5' '-4']\n",
-      " ['2' '1' '-14/5' '-7/2']]\n",
-      "Local game  3 : \n",
-      " [['A1' 'A2' 'U1' 'U2']\n",
-      " ['0' '0' '-4/5' '-4/3']\n",
-      " ['0' '1' '-8/5' '-8/3']\n",
-      " ['1' '0' '-14/5' '-2/3']\n",
-      " ['1' '1' '-2/5' '-2']\n",
-      " ['2' '0' '-6/5' '-14/3']\n",
-      " ['2' '1' '-12/5' '-4']]\n",
-      "Local game  4 : \n",
-      " [['A1' 'A3' 'U1' 'U3']\n",
-      " ['0' '0' '-2/5' '-2/3']\n",
-      " ['0' '1' '-4/5' '-4/3']\n",
-      " ['1' '0' '-6/5' '-1/3']\n",
-      " ['1' '1' '-1/5' '-1']\n",
-      " ['2' '0' '-3/5' '-2']\n",
-      " ['2' '1' '-1' '-5/3']]\n",
-      "Local game  5 : \n",
-      " [['A1' 'A4' 'U1' 'U4']\n",
-      " ['0' '0' '-6/5' '-3/2']\n",
-      " ['0' '1' '-14/5' '-7/2']\n",
-      " ['1' '0' '-2/5' '-5']\n",
-      " ['1' '1' '-2' '-1/2']\n",
-      " ['2' '0' '-4' '-5/2']\n",
-      " ['2' '1' '-18/5' '-9/2']]\n",
-      "\n",
-      " Hypergraph: \n",
-      "[[0, 2], [0, 3], [0, 4], [1, 2], [1, 3], [1, 4]]\n",
-      "Correspondance between players in the transformed game and the (player,type) tuples of the bayesian game:\n",
-      "{0: (0, 0), 1: (0, 1), 2: (1, 0), 3: (1, 1), 4: (1, 2)}\n",
-      "Is the new game a polymatrix game?  True\n",
-      "So, it can be solved using Lemke-Howson's algorithm:\n",
-      "CPU times: user 1.36 ms, sys: 31 µs, total: 1.39 ms\n",
-      "Wall time: 1.16 ms\n",
-      "player 0 -> mixed strategy -> [1.0, 0.0, 0.0]\n",
-      "player 1 -> mixed strategy -> [1.0, 0.0, 0.0]\n",
-      "player 2 -> mixed strategy -> [1.0, 0.0]\n",
-      "player 3 -> mixed strategy -> [1.0, 0.0]\n",
-      "player 4 -> mixed strategy -> [1.0, 0.0]\n",
-      "Is this really an equilibrium? True\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "hgg_from_bg,index_to_players = bg.convert_to_HGG()\n",
     "print(hgg_from_bg)\n",
@@ -824,17 +462,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Bayesian game with 4 players, 2 types, 2 actions each and 2 local bayesian games.\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from gtnash.game.bayesian_hypergraphicalgame import *\n",
     "\n",
@@ -905,25 +535,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "We can compute first a:\n",
-      "Hypergraphical game with 8 players, 2 actions each and 16 local games of size 3.\n",
-      "Then, we compute a normal form game from this HGG.\n",
-      "We solve it using the PNS solver:\n",
-      "CPU times: user 11.4 s, sys: 621 ms, total: 12 s\n",
-      "Wall time: 12.2 s\n",
-      "The corresponding equilibrium is:\n",
-      "{0: [1, 0], 1: [0, 1], 2: [0, 1], 3: [1, 0], 4: [1, 0], 5: [1, 0], 6: [0, 1], 7: [0, 1]}\n",
-      "Solving the same NFG using Wilson's algorithm takes far more time, so we do not do it\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "hgg_from_bhgg,index_to_players = bhgg.convert_to_HGG()\n",
     "print(\"We can compute first a:\")\n",
@@ -950,20 +564,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 21,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Bayesian game with 3 players, 2 types, 2 actions each and 2 local bayesian games.\n",
-      "We can compute first a:\n",
-      "Hypergraphical game with 6 players, 2 actions each and 8 local games of size 2.\n",
-      "We can solve the HGG using Lemke and Howson's algorithm, since it is a polymatrix game:\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "players_actions = [[0, 1], [0, 1], [0, 1]]\n",
     "theta = [[0, 1], [0, 1], [0, 1]]\n",
@@ -995,38 +598,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Is the obtained hypergraphical game a polymatrix game?\n",
-      "True\n",
-      "So, we can solve it using the Lemke-Howson algorithm:\n",
-      "CPU times: user 10.5 ms, sys: 0 ns, total: 10.5 ms\n",
-      "Wall time: 9.26 ms\n",
-      "player 0 -> mixed strategy -> [0.0, 1.0]\n",
-      "player 1 -> mixed strategy -> [1.0, 0.0]\n",
-      "player 2 -> mixed strategy -> [0.0, 1.0]\n",
-      "player 3 -> mixed strategy -> [1.0, 0.0]\n",
-      "player 4 -> mixed strategy -> [0.0, 1.0]\n",
-      "player 5 -> mixed strategy -> [1.0, 0.0]\n",
-      "Is this an equilibrium?  True\n",
-      "In order to solve it using Wilson's algorithm, we first transform it into a normal-form game:\n",
-      "We first solve it using the PNS solver:\n",
-      "CPU times: user 632 ms, sys: 15.7 ms, total: 648 ms\n",
-      "Wall time: 657 ms\n",
-      "{0: [0, 1], 1: [1, 0], 2: [0, 1], 3: [1, 0], 4: [0, 1], 5: [1, 0]}\n",
-      "Is this an equilibrium?  True\n",
-      "Then, we solve it using Wilson's algorithm:\n",
-      "CPU times: user 1.7 s, sys: 11.8 ms, total: 1.71 s\n",
-      "Wall time: 1.71 s\n",
-      "Here is the Nash equilibrium:  {0: [0, 1], 1: [1, 0], 2: [0, 1], 3: [1, 0], 4: [0, 1], 5: [1, 0]}\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(\"Is the obtained hypergraphical game a polymatrix game?\")\n",
     "print(hgg_from_bhgg.is_PMG())\n",
@@ -1069,9 +643,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
+   "display_name": "SageMath 9.5",
+   "language": "sage",
+   "name": "sagemath"
   },
   "language_info": {
    "codemirror_mode": {
@@ -1083,7 +657,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.10"
+   "version": "3.11.6"
   }
  },
  "nbformat": 4,
-- 
GitLab