SlowGuess/NeurIPS_2023_OCR huggingface dataset:
$$
\sum_ {a _ {j} \in A _ {j}} x _ {\{i, j \}} (a _ {i}, a _ {j}) = x _ {i} (a _ {i}) \sum_ {a _ {j} \in A _ {j}} x _ {j} (a _ {j}) = x _ {i} (a _ {i});
$$
and for any  $a_{j}\in A_{j}$ $\sum_{a_i\in A_i}x_{\{i,j\}}(a_i,a_j) = x_j(a_j)\sum_{a_i\in A_i}x_i(a_i) = x_j(a_j)$ . For any  $N^{\prime}\in \mathcal{N}$  with  $|N^{\prime}| > 2$  by  $\mathcal{M}$ , we have: for any  $i\in N^{\prime}$ , and  $a_{i}\in A_{i}$ , with  $N_{k} = N^{\prime}\setminus \{i\}$ ,
$$
\begin{array}{l} \sum_ {a _ {N ^ {\prime}} \in A _ {N ^ {\prime}}, a _ {N ^ {\prime}} (i) = a _ {i}} x _ {N ^ {\prime}} \left(a _ {N ^ {\prime}}\right) = x _ {i} \left(a _ {i}\right) \sum_ {a _ {N _ {k}} \in A _ {N _ {k}}} x _ {N _ {k}} \left(a _ {N _ {k}}\right) \\ = x _ {i} \left(a _ {i}\right). \\ \end{array}
$$
Therefore, Eq.(11) is implied by  $\mathcal{M}$ .
Now for any  $N^{\prime}\in \mathcal{N}$ , with two children  $N_l^\prime$  and  $N_r^\prime$  of  $N^{\prime}$ , by  $\mathcal{M}$ , for each  $a_{N_l'}\in A_{N_l'}$ , we have:
$$
\begin{array}{l} \sum_ {a _ {N ^ {\prime}} = (a _ {N _ {l} ^ {\prime}}, a _ {N _ {r} ^ {\prime}}) \in A _ {N ^ {\prime}}} x _ {N ^ {\prime}} (a _ {N ^ {\prime}}) \\ = x _ {N _ {l} ^ {\prime}} \left(a _ {N _ {l} ^ {\prime}}\right) \sum_ {a _ {N _ {r} ^ {\prime}} \in A _ {N _ {r} ^ {\prime}}} x _ {N _ {r} ^ {\prime}} \left(a _ {N _ {r} ^ {\prime}}\right) \\ = x _ {N _ {l} ^ {\prime}} (a _ {N _ {l} ^ {\prime}}), \\ \end{array}
$$
where the condition  $a_{N'} = (a_{N_l'}, a_{N_r'}) \in A_{N'}$  represents that  $a_{N'} \in A_{N'}$ ,  $a_{N'}(N_l') = a_{N_l'}$ . For each  $a_{N_r'} \in A_{N_r'}$ , we have:
$$
\begin{array}{l} \sum_ {a _ {N ^ {\prime}} = (a _ {N _ {l} ^ {\prime}}, a _ {N _ {r} ^ {\prime}}) \in A _ {N ^ {\prime}}} x _ {N ^ {\prime}} (a _ {N ^ {\prime}}) \\ = x _ {N _ {r} ^ {\prime}} \left(a _ {N _ {r} ^ {\prime}}\right) \sum_ {a _ {N _ {l} ^ {\prime}} \in A _ {N _ {l} ^ {\prime}}} x _ {N _ {l} ^ {\prime}} \left(a _ {N _ {l} ^ {\prime}}\right) \\ = x _ {N _ {r} ^ {\prime}} (a _ {N _ {r} ^ {\prime}}). \\ \end{array}
$$
Therefore, Eq.(12) is implied by  $\mathcal{M}$ . Then  $\mathcal{M} \subseteq \mathcal{T}$ .
Given any four bilinear terms:
$$
x _ {\{1, 2 \}} \left(a _ {1}, a _ {2}\right) = x _ {1} \left(a _ {1}\right) x _ {2} \left(a _ {2}\right)
$$
$$
x _ {\{1, 2 \}} \left(a _ {1} ^ {\prime}, a _ {2}\right) = x _ {1} \left(a _ {1} ^ {\prime}\right) x _ {2} \left(a _ {2}\right)
$$
$$
x _ {\{1, 2 \}} \left(a _ {1}, a _ {2} ^ {\prime}\right) = x _ {1} \left(a _ {1}\right) x _ {2} \left(a _ {2} ^ {\prime}\right)
$$
$$
x _ {\{1, 2 \}} \left(a _ {1} ^ {\prime}, a _ {2} ^ {\prime}\right) = x _ {1} \left(a _ {1} ^ {\prime}\right) x _ {2} \left(a _ {2} ^ {\prime}\right).
$$
The following solution is in  $\mathcal{T}$ :
$$
x _ {\{1, 2 \}} (a _ {1}, a _ {2}) = 0
$$
$$
x _ {\{1, 2 \}} (a _ {1} ^ {\prime}, a _ {2}) = 2 / 3
$$
$$
x _ {\{1, 2 \}} (a _ {1}, a _ {2} ^ {\prime}) = 1 / 3
$$
$$
x _ {\{1, 2 \}} (a _ {1} ^ {\prime}, a _ {2} ^ {\prime}) = 0
$$
$$
x _ {1} (a _ {1}) = 1 / 3, x _ {1} (a _ {1} ^ {\prime}) = 2 / 3
$$
$$
x _ {2} (a _ {2}) = 2 / 3, x _ {2} \left(a _ {2} ^ {\prime}\right) = 1 / 3.
$$
However, the above solution is not in  $\mathcal{M}$  because:  $x_{1}(a_{1}) = 1 / 3$  and  $x_{2}(a_{2}) = 2 / 3$  imply that  $x_{\{1,2\}}(a_1,a_2) = 2 / 9$ , which contradicts  $x_{\{1,2\}}(a_1,a_2) = 0$  in the above solution. Therefore,  $\mathcal{T} \nsubseteq \mathcal{M}$ . That is,  $\mathcal{M} \subset \mathcal{T}$ .
Proof. By Theorem 2,  $\mathcal{T}$  includes  $\mathcal{M}$ , i.e.,  $\mathcal{T}$  does not reduce the space of NEs. Program (13) is obtained after we explicitly restrict the feasible solution space to  $\mathcal{T}$  by adding Eqs.(2), (11), and (12) to Program (5). The optimization solver will search this feasible solution space after the relaxation to find the optimal solution for the original bilinear program. Therefore, by solving Program (13), we obtain an optimal NE.
Theorem 4.  $\underline{\mathcal{N}}$  generated by Algorithm 1 is a binary collection, and  $O(n\log n)$  for the size of  $\underline{\mathcal{N}}$  is the minimum size of all binary collections of a game  $G$ .
Proof. First, it is clear that  $\underline{\mathcal{N}}$  generated by Algorithm 1 is a binary collection of  $G$ . Then  $\{-i \mid i \in N\} \subseteq \underline{\mathcal{N}}$ .
The number of internal nodes in each binary tree with  $n - 1$  leaves of  $-i$  for each  $i \in N$  is  $n - 2$  [20]. To obtain the minimum number of internal nodes in these binary trees for  $\{-i \mid i \in N\}$ , we can minimize the difference between binary trees. Given a binary tree  $T_{-n}$  for  $-n$  and a binary tree  $T_{-i}$  for  $-i$  with  $i \in -n$ , the difference between  $T_{-n}$  and  $T_{-i}$  at least includes the path from the root to the node  $\{i\}$  in  $T_{-n}$  and the path from the root to the node  $\{n\}$  in  $T_{-i}$ . Then the number of different internal nodes (i.e., nodes that are not in  $T_{-n}$ ) in these binary trees for  $\{-i \mid i \in N\}$  is at least equal to the total path length in  $T_{-n}$ . Algorithm 1 ensures that the number of different internal nodes in these binary trees for  $\{-i \mid i \in N\}$  is equal to the total path length in  $T_{-n}$ , and the total path length in  $T_{-n}$  by Algorithm 1 is at most  $(n - 1)\lceil \log_2(n - 1)\rceil$ . Given a binary tree with  $k - 1$  internal nodes, the minimum total path length is  $O(k\log k)$  [20]. Therefore,  $O(n\log n)$  for the size of  $\underline{\mathcal{N}}$  is the minimum size of all binary collections of  $G$ .
Algorithm 3 Generate  $\underline{\mathcal{N}}$ : full details of Algorithm 1
1: Build  $(-n)$   
2: for each  $i$  in  $\{1, \dots, n-1\}$  do  
3:  $-i$ : replace  $i$  with  $n$  in  $-n$   
4:  $N' \gets -n$   
5:  $\underline{\mathcal{N}} \gets \underline{\mathcal{N}} \cup \{-i\}$   
6: while  $|N'| > 2$  do  
7:  $\{N_1, N_2\} \gets Ch(N')$  with  $i \in N_1$   
8:  $N''$ : replace  $i$  with  $n$  in  $N'$ ;  
9:  $N'_1$ : replace  $i$  with  $n$  in  $N_1$   
10:  $Ch(N'') \gets \{N'_1, N_2\}$   
11: if  $|N_1| > 1$  then  
12:  $\underline{\mathcal{N}} \gets \underline{\mathcal{N}} \cup \{N'_1\}$   
13: end if  
14:  $N' \gets N_1$   
15: end while  
16: end for
C The Necessity of Eq.(3a) in Program (13)
Now we show the necessity of Eq.(3a) in Program (13). We denote Program  $\mathbf{T}$  as the resulting program after removing Eq.(3a) in Program (13). We use the optimization gap between the optimal objective value  $g^{*}$  in Program (13) and the objective value  $\underline{g}$  obtained from the players' strategies after solving Program  $\mathbf{T}$  (i.e.,  $\underline{g}$  is the real objective value after playing the strategies obtained from solving Program  $\mathbf{T}$ ) to measure the inefficiency of Program  $\mathbf{T}$ , i.e.,  $g^{*} - \underline{g}$ . Note that, by Theorem 2, the optimal objective value of Program  $\mathbf{T}$  is just an upper bound of the optimal objective value of Program (13), which may not be achieved by playing the strategies obtained from solving Program  $\mathbf{T}$ . The following theorem shows that  $g^{*} - \underline{g}$  can be arbitrarily large, i.e., Program  $\mathbf{T}$  is not suitable to be used for computing optimal NEs. In addition, the resulting strategy profile by solving Program  $\mathbf{T}$  may not be an NE.
Theorem 5.  $g^{*} - g$  can be arbitrarily large, and the resulting strategy profile  $x'$  by solving Program T may not be an  $\overline{NE}$ .
Proof. Consider a game with three players,  $A_{1} = \{a_{1}, a_{1}'\}$ ,  $A_{2} = \{a_{2}, a_{2}'\}$  and  $A_{3} = \{a_{3}, a_{3}', a_{3}''\}$ , and the following utility function for three players, respectively, with  $k \geq 1$ :
$$
u = \left(u _ {1}, u _ {2}, u _ {3}\right): \left(a _ {1}, a _ {2}, a _ {3}\right)\rightarrow (0. 5 k, 0. 5 k, - k);
$$
$$
u = \left(u _ {1}, u _ {2}, u _ {3}\right): \left(a _ {1} ^ {\prime}, a _ {2} ^ {\prime}, a _ {3} ^ {\prime}\right)\rightarrow (0. 5 k, 0. 5 k, - k);
$$
$$
u = \left(u _ {1}, u _ {2}, u _ {3}\right): \left(a _ {1}, a _ {2} ^ {\prime}, a _ {3}\right)\rightarrow \left(0. 1 2 5 k, 0. 1 2 5 k, - 0. 2 5 k\right);
$$
$$
u = \left(u _ {1}, u _ {2}, u _ {3}\right): \left(a _ {1}, a _ {2} ^ {\prime}, a _ {3} ^ {\prime}\right)\rightarrow (0. 1 2 5 k, 0. 1 2 5 k, - 0. 2 5 k);
$$
$$
u = \left(u _ {1}, u _ {2}, u _ {3}\right): \left(a _ {1}, a _ {2} ^ {\prime}, a _ {3} ^ {\prime \prime}\right)\rightarrow (0. 1 k, 0. 1 5 k, - 0. 2 5 k);
$$
$$
u = \left(u _ {1}, u _ {2}, u _ {3}\right): \text {o t h e r j o i n t a c t i o n s} \rightarrow (0, 0, 0).
$$
The objective function is  $g = u_{1}(x_{1}, x_{2}, x_{3}) + u_{2}(x_{1}, x_{2}, x_{3})$ . By solving Program T, we obtain  $x_{1}'$  with  $x_{1}'(a_{1}) = 2/3$  and  $x_{1}'(a_{1}') = 1/3$ ,  $x_{2}'$  with  $x_{2}'(a_{2}) = 1/3$  and  $x_{2}'(a_{2}') = 2/3$ , and  $x_{3}'$  with  $x_{3}'(a_{3}) = 1/2 = x_{3}'(a_{3}')$ , and  $x_{3}'(a_{3}''') = 0$ . If players 1 and 2 play  $x_{1}'$  and  $x_{2}'$ , respectively,  $u_{3}(x_{1}', x_{2}', a_{3}) = -k/3 = u_{3}(x_{1}', x_{2}', a_{3}')$ , and  $u_{3}(x_{1}', x_{2}', a_{3}''') = -k/9$ . That is, player 3 will play the pure strategy  $a_{3}''$  to respond to  $x_{1}'$  and  $x_{2}'$ , which will result in  $\underline{g} = k/9$ . Then the resulting strategy profile  $x'$  is not an NE.
5To find an optimal NE, this paper only considers programs guaranteeing exact NEs, and designing programs with approximate NEs is the future work.
It is clear that  $(x_1^*, x_2^*, x_3^*)$  with  $x_1^*(a_1) = 1$ ,  $x_2^*(a_2') = 1$ , and  $x_3^*(a_3'') = 1$  is an NE, which also is an output of solving Program (13) with the objective value  $g^* = k/4$ .
Therefore,  $g^{*} - \underline{g} = 5k / 36$ , which is arbitrarily large when  $k$  is arbitrarily large.
Algorithm 4 Build  $(N^{\prime})$ : Build a minimum-height binary tree for  $N^{\prime}$
1:  $h\gets \lceil \log (|N^{\prime}|)\rceil$    
2: if  $2^{h} = |N^{\prime}|$  then   
3: Lower set  $\mathcal{N}'_1\gets \{\{i\} \mid i\in N'\}$    
4: for  $k\in \{1,\ldots ,[\log (|\mathcal{N}'|)]\}$  do   
5: Upper set  $\mathcal{N}'_2\gets \emptyset$    
6: for  $j\in \{1,\dots ,|\mathcal{N}'_1| / 2\}$  do   
7:  $N_{1}\leftarrow \mathcal{N}'_{1}[j\times 2 - 1]\cup \mathcal{N}'_{1}[j\times 2]$  : the union of the  $(j\times 2 - 1)$  -th element and the  $(j\times 2)$  -th element in  $\mathcal{N}'_1$    
8:  $\mathcal{N}'_2\gets \mathcal{N}'_2\cup \{N_1\}$    
9:  $Ch(N_{1})\gets \{\mathcal{N}'_{1}[j\times 2 - 1],\mathcal{N}'_{1}[j\times 2]\}$    
10: end for   
11: Lower set  $\mathcal{N}'_1\gets \mathcal{N}'_2$    
12:  $\underline{\mathcal{N}}\gets \underline{\mathcal{N}}\cup \mathcal{N}'_2$    
13: end for   
14: else   
15:  $N_1^\prime \gets \{N'[1],\dots ,N'[2^{h - 1}]\}$    
16:  $N_2^\prime \gets N^\prime \setminus N_1^\prime$    
17: if  $3\times 2^{h - 2} <   = |N^{\prime}|$  then   
18: Lower set  $\mathcal{N}'_1\gets \{\{i\} \mid i\in N_1'\}$    
19: for  $k\in \{1,\dots ,[\log (|N_1'|)]\}$  do   
20: Repeat Lines 5-12.   
21: end for   
22: Build(  $N_2^{\prime}$    
23:  $\underline{\mathcal{N}}\gets \underline{\mathcal{N}}\cup \{N'\}$    
24:  $Ch(N^{\prime})\gets \{N_1^{\prime},N_2^{\prime}\}$    
25: else   
26: Lower set  $\mathcal{N}'_1\gets \{\{i\} \mid i\in N_1'\}$    
27: for  $k\in \{1,\dots ,[\log (|N_1'|)] - 1\}$  do   
28: Repeat Lines 5-12.   
29: end for   
30: Build(  $N_2^{\prime}$    
31:  $N_{1}\gets \mathcal{N}'_{1}[2]\cup N_{2}^{\prime}$    
32:  $\underline{\mathcal{N}}\gets \underline{\mathcal{N}}\cup \{N_1\}$    
33:  $Ch(N_{1})\gets \{\mathcal{N}'_{1}[2],N_{2}^{\prime}\}$    
34:  $\underline{\mathcal{N}}\gets \underline{\mathcal{N}}\cup \{N'\}$    
35:  $Ch(N^{\prime})\gets \{\mathcal{N}'_{1}[1],N_{1}\}$    
36: end if   
37: end if
D Binary Trees and Details of Algorithm 1
We consider a special binary tree (full binary tree), which includes two kinds of nodes: nodes with two children (internal nodes) and nodes without children (leaf nodes). A binary tree  $T_{N'}$  of  $N' \subseteq N$  with  $|N'| \geq 2$  is that: 1) its root is  $N'$ ; 2) its nodes are  $\{N'' \mid N'' \subseteq N'\}$ ; 3) each of its leaf nodes is a singleton; and 4) each of its internal nodes  $N''$  has two children  $N'_l$  and  $N'_r$  with  $N'_l \cap N'_r = \emptyset$  and  $N'' = N'_l \cup N'_r$ , i.e.,  $N''$  is divided into two disjoint sets. Let  $Ch(N'') = \{N'_l, N'_r\}$  be the set of  $N''$ 's children in  $T_{N'}$ , and  $Ch(N'') = \emptyset$  if  $N''$  is a singleton. Let  $\mathcal{N}_{T_{N'}}$  be the set of internal nodes in  $T_{N'}$ .
Our binary tree for  $-i$  is a full binary tree, i.e., each internal node has two children, which has  $k - 1$  internal nodes if there are  $k$  leaf nodes [20]. For example, Figure 1(a) has 3 internal nodes and 4 leaf
nodes. The length of the path from the root to a leaf is the number of internal nodes on this path in a binary tree. The height of a binary tree is the maximum path length, and the total path length is the sum of the lengths of the paths from the root to each leaf node in a binary tree. For example, the path length from the root to each leaf node in Figure 1(a) is 2, the height is 2, and the total path length is  $2 \times 4 = 8$ .
To obtain the minimum number of internal nodes in these binary trees for  $\{-i\mid i\in N\}$ , we can minimize the difference between binary trees. Given the binary tree  $T_{-n}$  for  $-n$  and the binary tree  $T_{-i}$  for  $-i$  with  $i\in -n$ , the difference between  $T_{-n}$  and  $T_{-i}$  at least includes the path from the root to the leaf node  $\{i\}$  in  $T_{-n}$  and the path from the root to the leaf node  $\{n\}$  in  $T_{-i}$ . Then the number of different internal nodes (i.e., internal nodes that are not in  $T_{-n}$ ) in these binary trees for  $\{-i\mid i\in N\}$  is at least equal to the total path length in  $T_{-n}$ . Now we propose an algorithm ensuring that the number of different internal nodes in these binary trees for  $\{-i\mid i\in N\}$  is equal to the total path length in  $T_{-n}$ , which is the minimum total path length. To do that, we first build a binary tree for  $-n$  with the minimum height (a full binary tree with the minimum height may not be balanced). Note that there are at most  $2^{h}$  leaf nodes in a binary tree with the height  $h$ , and there are  $n - 1$  leaf nodes and  $n - 2$  internal nodes in a binary tree for  $-n$ . Then we can build a full binary tree  $T_{-n}$  with the height  $\lceil \log_2(n - 1)\rceil$  for  $-n$  and then replace  $i$  with  $n$  in the nodes of  $T_{-n}$  to obtain  $T_{-i}$  for each  $i\in -n = \{1,\dots ,n - 1\}$ . That creates  $n$  full binary trees for  $\{-i\mid i\in N\}$ . This procedure is shown in Algorithm 1, generating our minimum binary collection  $\underline{\mathcal{N}}$ . Figure 1(a) builds a binary tree  $T_{-5}$ , and Figure 1(a) obtains  $T_{-3}$  by replacing 3 with 5 in  $T_{-5}$ .
The full details of Algorithm 1 are shown in Algorithm 3. Line 1 builds a binary tree with the height  $\lceil \log_2(n - 1) \rceil$  for  $-n = \{1, \dots, n - 1\}$ , whose details are shown in Algorithm 4. At Lines 2-16, for each  $i$  in  $\{1, \dots, n - 1\}$ , we search the binary tree for  $-n$  from the root and replace  $i$  with  $n$  in each node including  $i$  to form a new tree for  $-i$ . And we only need to add new internal nodes to  $\underline{\mathcal{N}}$ .
Algorithm 4 builds a binary tree with the height  $\lceil \log_2(|N'|)\rceil$  for  $N^{\prime}$ . If the size of  $N^{\prime}$  is  $2^{\lceil \log_2(|N'|)\rceil}$  (note that each element in  $N^{\prime}$  corresponds to a leaf node, and there are at most  $2^{h}$  leaf nodes in a binary tree with the height  $h$ ), then we can build a complete binary tree, where all leaf nodes are at the lowest level. That is, we combine two nodes at the lower level to form a node at the upper level, as shown at Lines 3-12. If the size of  $N^{\prime}$  is not  $2^{\lceil \log_2(|N'|)\rceil}$ , and it is larger than  $3\times 2^{\lceil \log_2(|N'|)\rceil - 2}$ , then we build a complete binary tree for the subset  $N_{1}^{\prime}$  (Line 15) with the height  $\lceil \log_2(|N_1'|)\rceil = \lceil \log_2(|N'|)\rceil - 1$  (Lines 18-20) and then build a binary tree for the remaining subset (Line 22). Finally, we combine both binary trees together to form a binary tree for  $N^{\prime}$  (Line 24). If the size of  $N^{\prime}$  is not  $2^{\lceil \log_2(|N'|)\rceil}$ , and it is less than  $3\times 2^{\lceil \log_2(|N'|)\rceil - 2}$ , we build a complete binary tree for the subset  $N_{1}^{\prime}$  (Line 28) with the height  $\lceil \log_2(|N_1'|)\rceil = \lceil \log_2(|N'|)\rceil - 1$ . However, at the last step of building the binary tree for  $N_{1}^{\prime}$ , we do not combine two nodes to form a root. We keep both two nodes within  $\mathcal{N}_1^\prime$  by setting  $k\leq \lceil \log (|N_1'|)\rceil -1 = \lceil \log (|N'|)\rceil -2$  at Line 26. Then we build a binary tree for the remaining subset  $N_{2}^{\prime}$  (Line 30). After that, we combine the root of the binary tree for  $N_{2}^{\prime}$  and two nodes in  $\mathcal{N}_1^\prime$  to form a binary tree for  $N^{\prime}$  (Line 31-35). This step is to try to reduce the total path length because the number of nodes in the binary tree for  $N_{2}^{\prime}$  is less than the number of nodes of the binary tree for any node in  $\mathcal{N}_1^\prime$ , and we can reduce the total path length by combining the root of the binary tree for  $N_{2}^{\prime}$  and any node in  $\mathcal{N}_1^\prime$  to form a node first.
E Runtime for Algorithm 1
Table 3 shows the runtime of Algorithm 1, which is extremely small and then can be ignored, compared to the runtime of CRM shown in Tables 4 and 5.
F Experiment Setting
Games: we evaluate our approach on two sets of games: randomly generated games and games that are generated by GAMUT [31]. Payoffs are generated from the interval between 0 and 100 (other ranges (e.g., [0, 1]) do not affect the result). We vary the number of players (i.e.,  $n$ ) and the number of actions (i.e.,  $m$ ) for each player for random games (i.e.,  $(n, m)$ ). For GAMUT games, we use the variants with six players and three actions (i.e., the game (6, 3)), which are much larger than the three-player three-action games (i.e., the game (3, 3)) used in prior work [4, 13]. We show the game size in terms of the number of bilinear terms and integer variables in Appendix G, e.g., the number of
Table 3: Game size and runtime of Algorithm 1.
Integer variables	Bilinear terms	Correlation Plans	Algorithm 1
(n,m)	Size	Based on N	Based on N	|N|	|N|	Runtime
(3,2)	6	12	12	3	3	<0.0001s
(5,2)	10	200	104	25	11	0.0001s
(7,2)	14	2044	564	119	21	0.0002s
(3,3)	9	27	27	3	3	<0.0001s
(4,3)	12	162	135	10	7	<0.0001s
(5,3)	15	765	459	25	11	0.0001s
(4,2)	8	56	44	10	7	<0.0001s
(4,3)	12	162	135	10	7	<0.0001s
(4,4)	16	352	304	10	7	<0.0001s
(4,5)	20	650	575	10	7	<0.0001s
(3,5)	15	75	75	3	3	<0.0001s
(3,8)	24	24	24	3	3	<0.0001s
(3,10)	30	300	300	3	3	<0.0001s
(3,13)	39	507	507	3	3	<0.0001s
(3,15)	45	675	675	3	3	<0.0001s
(3,17)	51	867	867	3	3	<0.0001s
(6,3)	18	3348	1620	56	16	0.0001s
(8,2)	16	6288	1172	246	26	0.0003s
(9,2)	18	19152	2512	501	31	0.0003s
Table 4: Results for random games:  $(n,m)$  represents the game with  $n$  players and  $m = |A_i|$  actions for each player. The format for each result is: Average Runtime  $\pm 95\%$  Confidence Interval (Percentage of Games not Solved within the Time Limit) (Utility Gap). Note that the unit of the runtime is second, and the case that all games have been solved with the time limit should be  $(0\%)$  and is omitted, we only need to care about the utility gap for EXCLUSION, and the utility gap  $\infty$  represents EXCLUSION cannot return a solution within the time limit. For example, for the random games (7,2), CRM solves  $100\%$  of them by using 25s with a  $95\%$  interval 17s, but  $80\%$  of them are not solved by EXCLUSION within the time limit, and EXCLUSION has a utility gap  $53\%$ .
Runtime ± 95% Confidence Interval (Percentage of Games not Solved) (Utility Gap)
Vary	(n,m)	CRM	MIBP	ENUMPOLY	EXCLUSION
n	(3,2)	0.01 ± 0	0.02 ± 0	0.03 ± 0.01	31 ± 41 (gap:15%)
(5,2)	0.2 ± 0.1	0.5 ± 0.4	11 ± 4	753 ± 148 (73%) (gap:64%)
(7,2)	25 ± 17	429 ± 131 (20%)	1000 ± 0 (97%)	835 ± 119 (80%) (gap:53%)
n	(3,3)	0.1 ± 0	0.1 ± 0	51 ± 59	252 ± 140 (20%) (gap:34%)
(4,3)	0.3 ± 0.1	1 ± 0.3	1000 ± 0 (100%)	773 ± 125 (67%) (gap:58%)
(5,3)	22 ± 9	239 ± 87 (7%)	1000 ± 0 (100%)	974 ± 50 (97%) (gap:62%)
m	(4,2)	0.1 ± 0.01	0.1 ± 0.01	0.2 ± 0.1	246 ± 126 (13%) (gap:23%)
(4,3)	0.3 ± 0.1	1 ± 0.3	1000 ± 0 (100%)	773 ± 125 (67%) (gap:58%)
(4,4)	2.8 ± 1	42 ± 12	1000 ± 0 (100%)	1000 ± 0 (100%) (gap:73%)
m	(4,5)	64 ± 42	862 ± 91 (77%)	1000 ± 0 (100%)	1000 ± 0 (100%) (gap:75%)
(3,5)	0.2 ± 0.03	0.3 ± 0.1	1000 ± 0 (100%)	1000 ± 0 (100%) (gap:67%)
(3,8)	4 ± 3	247 ± 140 (17%)	1000 ± 0 (100%)	1000 ± 0 (100%) (gap:∞)
(3,10)	9 ± 9	334 ± 167 (30%)	1000 ± 0 (100%)	1000 ± 0 (100%) (gap:∞)
(3,13)	38 ± 21	342 ± 151 (27%)	1000 ± 0 (100%)	1000 ± 0 (100%) (gap:∞)
bilinear terms in the game (9, 2) is 19152 based on  $\overline{\mathcal{N}}$  but is 2512 based on  $\underline{\mathcal{N}}$ . For each setting, we generated 30 games on MacBook Pro, where the seeds are  $i \in \{1, \dots, 30\}$  for the GAMUT games and 20201125 + i · 10 for random games. Results in this section are hence averaged over 30 cases.
Algorithm Setting: The objective function used in the experiments maximizes the expected utility of player  $n$ . We verified that results for optimizing other objectives (e.g., maximizing social welfare) are similar. We use the non-convex solver of Gurobi 9.5 to solve all mixed-integer bilinear programs with the optimality gap set to 0.0001 (the default setting). EXCLUSION uses this optimality gap as well, which is significantly smaller than 0.001 in [4] (we verified that, with the same optimality gap, our result for EXCLUSION is almost the same as the one in [4]). Experiments are run on an eight-core Intel Core i9 machine at 2.3 GHz with 16GB of RAM. Similarly to the previous literature [34, 4, 13],
Table 5: Results for six-player three-action GAMUT games.
Runtime ± 95% Confidence Interval (Percentage of Games not Solved) (Utility Gap)
Game	CRM	MIBP	ENUMPOLY	EXCLUSION
Bidirectional LEG	1.6 ± 1	972 ± 54 (97%)	1000 ± 0 (100%)	1000 ± 0 (100%) (gap:13%)
Collaboration	1 ± 0.2	967 ± 63 (97%)	1000 ± 0 (100%)	1000 ± 0 (100%) (gap:81%)
Covariant r = 0.5	5 ± 6	1000 ± 0 (100%)	1000 ± 0 (100%)	963 ± 59 (93%) (gap:73%)
PolyMatrix	26 ± 44	194 ± 74 (3%)	867 ± 116 (87%)	1000 ± 0 (100%) (gap:17%)
Random LEG	2 ± 1	1000 ± 0 (100%)	1000 ± 0 (100%)	986 ± 27 (97%) (gap:11%)
Random graphical	0.1 ± 0.1	803 ± 140(83%)	50 ± 30	971 ± 55 (97%) (gap:32%)
Uniform LEG	2.2 ± 1	1000 ± 0 (100%)	1000 ± 0 (100)	986 ± 26 (97%) (gap:11%)