SlowGuess/NeurIPS_2023_OCR huggingface dataset:
Georgios Chionas  
Department of Computer Science  
University of Liverpool  
Liverpool, United Kingdom  
g.chionas@liverpool.ac.uk
Dariusz R. Kowalski Piotr Krysta*  
School of Computer and Cyber Sciences  
Augusta University  
Augusta, Georgia, USA  
{dkowalski,pkrysta} @augusta.edu
We study the Combinatorial Group Testing (CGT) problem in a novel game-theoretic framework, with a solution concept of Adversarial Equilibrium (AE). In this new framework, we have  $n$  selfish autonomous agents, corresponding to the elements of the universe  $[n] = \{0,1,\dots ,n - 1\}$ , and a hidden set  $K\subseteq [n]$  of active agents of size  $|K| = k\ll n$ . In each round of the game, each active agent decides if it is present in a query  $Q\subseteq [n]$ , and all agents receive some limited feedback on  $Q\cap K$ . The goal of each active agent is to ensure that its id could be revealed from the feedback as early as possible.
We present a comprehensive set of results for this new game, where we design and analyze adaptive algorithmic strategies of agents which are AE's. In particular, if  $k$  is known to the agents, then we show adaptive AE strategies with provably near-optimal maximum revealing time of  $O(k\log (n / k))$ . In the case of unknown  $k$ , we design adaptive AE strategies with maximum revealing time of order  $n^{k - 1}$ , and we prove a lower bound of  $\Omega (n)$  on the maximum revealing time of any such algorithmic strategies. This shows a strong separations between the two models of known and unknown  $k$ , as well as between the classic CGT, i.e., without selfish agents, and our game theoretic CGT model.
Combinatorial Group Testing (CGT) is a classic area of learning theory, see the book Du et al. [2000]. It is about revealing elements from a hidden set of size  $k$ , typically much smaller than the size  $n$  of the universe of all elements, by asking queries and receiving answers (feedback). Queries are typically subsets of the universe, while feedback is a fixed function that provides some limited information about the intersection of the query with the hidden set, e.g., how big is the size of the intersection. CGT was introduced by Dorfman [1943] in the context of revealing infected individuals in large populations using pooled tests, and has been intensively explored recently during the COVID-19 pandemic, c.f., Augenblick et al. [2020], Mallapaty et al. [2020], Sinnott-Armstrong et al. [2020]. CGT has growing applications to Machine Learning, c.f.: simplifying multi-label classifiers Ubaru et al. [2020], approximating the nearest neighbor Engels et al. [2021], and accelerating forward pass of a deep neural network Liang and Zou [2021]. CGT was also used in data mining and stream processing, c.f.: extracting the most frequent elements Cormode et al. [2003], Cormode and Muthukrishnan [2005], Cormode and Hadjielefteriou [2008], Yu et al. [2004], Kowalski and Pajak [2022b], quantile tracking Cormode et al. [2005], Gilbert et al. [2002b], Greenwald and Khanna [2001], or approximate histogram maintenance and reconstruction Gibbons et al. [2002], Gilbert et al. [2002a]. Other areas include coding and network communication, c.f.: Kautz and Singleton [1964], Clementi et al. [2001], Porat and Rothschild [2011]. The adversarial aspects of CGT were also considered, c.f., Klonowski et al. [2022], Kowalski and Pajak [2022a].
* Piotr Krysta is also affiliated with Computer Science Department, University of Liverpool, U.K.
We study the Combinatorial Group Testing (CGT) problems in a novel game theoretic framework, with a solution concept which is an Adversarial Equilibrium (AE). In this enhanced model, elements are autonomous selfish players, also called agents, while those with id in the hidden set are active. Ideally, the active agents should follow a CGT algorithm to have them revealed after some number of queries have been answered. We study efficient deterministic CGT algorithms which are also AE – that is, which additionally incentivise the active agents to follow the CGT algorithm without any deviations. In particular, they are designed in such a way that an agent could worsen its revealing time if it decides to include/exclude itself from the query created by the CGT algorithm (see Section 2.1 for a detailed definition of AE). We also show substantial limitations on scalability of the maximum revealing time when the number  $k$  of active agents is unknown.
Closest related work and their relevance. The concept of deterministic Adversarial Equilibrium (AE), used in our work, was introduced in the context of non-adaptive contention resolution (CR) games by Chionas et al. [2023]. CR is a communication problem in which each player has a packet to transmit successfully (i.e., alone) in a given time unit on the multiple-access channel to which it is connected, together with other agents. It was introduced in the context of resolving conflicts in Local Area Networks (LAN), co-funded by the recent Turing Award winner Robert Metcalfe, c.f., Metcalfe and Boggs [1976]. Initially it was assumed that agents would respect the given algorithm. Greenberg and Winograd [1985] proved a lower bound  $\Omega\left(\frac{k\log(n)}{\log(k)}\right)$  on the running time of any adaptive deterministic CR algorithm with restricted feedback with collision detection. Capetanakis [1979a,b] and Hayes [1978] independently found an adaptive, deterministic binary tree algorithm to solve the CR problem, which runs in  $O(k + k\log (n / k))$  time.
CR could be interpreted as a CGT-type problem with some subtle differences. The main conceptual similarity between CR and CGT is the environment – agents decide to transmit in CR (equivalently, be included in the query in the CGT) or not and they receive feedback from the channel (equivalently, broker of the CGT process – the feedback function). The main, though subtle, difference is that in CR it is required that every active agent needs to eventually be in a singleton intersection with some query (i.e., to transmit successfully on the channel, without interference from other active agent), while this is not required in the CGT – in the CGT, the set of active agents could be revealed based on analyzing the feedback, even if some agents are not in singleton intersections with any queries.
Fiat et al. [2007] initiated the work on CR algorithms in which agents seek to minimize their individual latency costs. They designed randomized algorithms that are Nash equilibria with bounded latency. Later, Christodoulou et al. [2014] studied CR games where the cost of each agent depends on the number of attempted transmissions before success. As mentioned earlier, Chionas et al. [2023] were the first who introduced deterministic game theoretic framework to CR. In particular, they showed non-adaptive adversarial equilibria of well-scalable  $O(\log n)$  latency (i.e., revealing time), but only for  $k = 2, 3$  active agents. In contrast, we study more general adaptive algorithms (which correspond to much richer space of strategies), provide a wider framework for the analysis of adversarial equilibrium for general field of CGT with any feedback function, and design well-scalable equilibria for any size  $k$  of the hidden set.
Bolouki et al. [2017] studied a Bayesian game where the population is partitioned in two sets, i.e., healthy and infected individuals. The goal of the former set is to have the infected individuals revealed as soon as possible, while the goal of the latter set is not to get revealed for as long as possible. The only strategy of individuals is to comply or not when they are called for a test. Our setting is quite different in the following aspect. We consider a richer space of strategies, since the agents may choose to comply with the query or to deviate by either including themselves in a query without being called for, or not including themselves in a query while being called for.
Technical contributions. Apart from our conceptual contribution of designing an adversarial equilibrium model for general (i.e., adaptive) CGT (see Section 2.1), we demonstrate its difference compared to the classical CGT (and related settings, such as CR) by providing several new techniques and performance bounds, c.f., Table 1. The main conceptual difference between the classical and our CGT setting is that while we preserve all features of the classical model, in addition we augment it
${}^{2}$  Depending on the feedback function,revealing of a hidden agent/element could be direct,when the id of this element is returned in the feedback, or indirect, when the analysis of the feedback for the previous queries ensures that the agent must be in the hidden set.
Class	(n,k)-CGT	(n,k)-CGT and (n,k)-AE
Lower Bound	Upper Bound	Lower Bound	Upper Bound
known k	Ω(k log(n)/log(k)) *	O(k log(n/k)) †	Ω(k log(n)/log(k)) *	O(k log(n/k)) Thm. 3.1
unknown k	Ω(k log(n)/log(k)) *	O(k log(n/k)) †	Ω(n) Thm. 4.1	O(nk-1) Thm. 4.2
Table 1: Summary of our main results. Asymptotic notations  $O, \Omega$  denote an upper/ lower estimate wrt a constant factor. All logarithms are to base 2, unless stated otherwise. Results marked * and † were published in Greenberg and Winograd [1985] and in Capetanakis [1979a,b], Hayes [1978], resp.
with the game theoretic aspect. This adds new technical challenges in designing efficient algorithms in this new setting. In the main part, we focus on popular feedback function with collisions, and design two algorithms with two very different revealing mechanisms that are also adversarial equilibria. The first algorithm (see Section 3) assumes knowledge of the number of active agents  $k$  and reveals agents' ids one by one, using appropriate shortcuts in the binary search process. The second algorithm (see Section 4.2), designed for unknown  $k$ , reveals all the active players during the first successful query, by gradually decreasing the size of subsequent queries.
The maximum revealing time of the first algorithm is  $O(k \log(2n / k))$ , for any  $2 \leq k \leq n$ . This is very close to the best possible maximum revealing time, due to the lower bound  $\Omega \left( \frac{k \log(n)}{\log(k)} \right)$  by Greenberg and Winograd [1985] for any adaptive deterministic solution in the considered CGT setting. In contrast, Chionas et al. [2023] designed scalable non-adaptive algorithms only for  $k = 2, 3$ . Moreover, proving AE for general adaptive CGT algorithms, done in this work, is more challenging than proving it for non-adaptive solutions, as the space of all adaptive algorithms is much bigger and complex than the space of pre-defined sequences of queries, i.e., non-adaptive algorithms.
The existence of such algorithms allows to consider the price of stability, c.f., Nisan et al. [2007], Maschler et al. [2020], in CGT games with respect to adversarial equilibria in adaptive strategies. Our equilibria with deterministic adaptive strategies imply an upper bound of  $O(\log k)$  on the price of stability (PoS). This upper bound on PoS follows by dividing our bound  $O(k\log (2n / k))$  on the maximum revealing time by the lower bound  $\Omega \left( \frac{k\log(n)}{\log(k)} \right)$  of Greenberg and Winograd [1985]. To compare, Chionas et al. [2023] designed adversarial equilibria in less complex deterministic non-adaptive strategies in the CR game (related to our setting), achieving constant PoS only for  $k = 2, 3$  and the PoS of only  $\frac{n}{\Theta(k\log(n / k))}$  for any  $k > 3$ .
All the abovementioned results and comparisons assume known  $k$ . In case of unknown  $k$ , we formally show that this setting is more difficult than the one with known  $k$  by proving a lower bound  $\Omega(n)$  on the maximum revealing time even if an upper bound  $k' \geq 3$  on  $k$  is known (see Section 4.1). We also designed a universal AE algorithm for any unknown  $k$ , mentioned earlier, which has polynomial revealing time if the actual number of active agents is constant in  $n$  (see Section 4.2).
Extensions and applications. We analyzed several extensions and applications of the new framework, showing its generality. We applied it to other feedback functions: ones that instead of returning an id of a singleton intersection return a "beep" (i.e., a single bit indicating that the intersection is a singleton), and others which return "null" in case of non-singleton intersection of the query with the hidden set. Direct applications include adaptive equilibria contention resolution algorithms and new mechanisms for blockchain. Due to the page limit, all details, proofs and extensions and applications are deferred to the Supplementary Materials, in the form of the full version of our paper.
2 The Model, the Problem and the Preliminaries
In Combinatorial Group Testing (CGT) types of problems, we are given a universe  $[n] = \{0,1,\ldots ,n - 1\}$  of  $n$  elements and a hidden subset  $K\subseteq [n]$  of size  $|K| = k$ , where  $2\leq k\leq n$ .<sup>4</sup>
${}^{3}$  PoS is the ratio between the cost of the best-case equilibrium and the cost of the socially optimal outcome. In our case, the cost is the maximum revealing time.
4Typically CGT assumes that  $k\ll n$  , that is, the hidden set is much smaller than the size of the universe,  $n$
Later, when introducing game theoretic framework for CGT, we will also be referring to the hidden subset  $K$  as configuration of the game. Let  $\mathcal{F}_n^k$  be the set of all  $k$ -element subsets of  $[n]$ , i.e., the family of all possible hidden sets. The goal of an algorithm is to learn the set  $K$  using the smallest number of queries. A query  $Q \subseteq [n]$  returns a value of some function, called Feedback  $(Q \cap K)$ . We consider a classical feedback defined in the following way:
- if  $|Q \cap K| = 0$ , then Feedback( $Q \cap K$ ) =  $\emptyset$  ("empty");
- if  $|Q \cap K| = 1$ , then Feedback  $(Q \cap K) = i$ , where  $\{i\} = Q \cap K$  (element  $i$  "selected");
- if  $|Q \cap K| \geq 2$ , then Feedback  $(Q \cap K) = \bot$  ("clash" or "collision" or "2+").
This feedback function is one of the simplest considered in CGT, known in the literature as a ternary feedback or  $(2,\log n)$ -feedback in the generalized CGT terminology, cf. Klonowski et al. [2022]. If the query has a singleton intersection with the hidden set, then naturally the feedback reveals the respective agent's ID. If the intersection is empty or has size at least 2 (clash), then the feedback is empty or clash, respectively. We also study different feedback functions in extensions, included in the Supplementary Materials due to the page limit.
A (deterministic) algorithm for the CGT problem is an adaptive algorithm which, based on the history of the computation, generates subsequent queries  $Q_{t}$ , which are asked by the algorithm in the order specified by index  $t$ , for  $t = 1,2,3,\ldots$ . Each query  $Q_{t}$  may depend on the feedback  $\mathrm{Feedback}(Q_1\cap K),\dots, \mathrm{Feedback}(Q_{t - 1}\cap K)$  from the previous queries  $Q_{1},Q_{2},\ldots ,Q_{t - 1}$  generated by the algorithm, where  $K$  is the hidden set on which the algorithm is executed. We will refer to the index  $t$  as time, step or round of the algorithm. Note that the first query  $Q_{1}$  is hardwired since the feedback history before round 1 is fixed (empty).
Feedback histories. Suppose that a given algorithm for a given hidden set  $K$ , generates a sequence of queries  $Q_{1}, Q_{2}, \ldots, Q_{t}$  when the algorithm is executed on  $K$  by a round  $t$ . The corresponding unique sequence of feedbacks received in such execution,  $\phi[1..t] = \text{Feedback}(Q_{1} \cap K)$ ,  $\text{Feedback}(Q_{2} \cap K), \ldots, \text{Feedback}(Q_{t} \cap K)$ , is called a feedback history (of the algorithm on set  $K$ , if we know the algorithm and  $K$ ) by round  $t$ . Note that for a given feedback history there is a unique sequence of queries that resulted in such feedback history – this is because we consider deterministic algorithms. We have  $\phi[t] \in \{\emptyset, \bot\} \cup [n]$ , for a round  $t \in \{1, 2, 3, \ldots\}$ , and  $\phi[1..t] \in (\{\emptyset, \bot\} \cup [n])^t$  (when  $t$  is irrelevant, we simply write  $\phi$ , where  $\phi \in (\{\emptyset, \bot\} \cup [n])^*$ ). Although the algorithm is not given set  $K$  as an input, for each round  $t$  it knows the feedback history. We call a given sequence of queries, or feedbacks, a valid query sequence/feedback history iff they are query sequence/feedback history obtained in an execution of the algorithm on some hidden set  $K \in \mathcal{F}_n^k$ .
Compatibility. For a given algorithm, we say that a set  $K \in \mathcal{F}_n^k$  is compatible with a given feedback history, if the execution of the algorithm on the hidden set  $K$  generates that feedback history. For a given feedback history  $\phi$ , let  $\mathcal{K}_{\phi} \subseteq \mathcal{F}_n^k$  be the family of all sets  $K$  compatible with  $\phi$ , and let  $\mathcal{K}_{\phi}|_i = \{K \in \mathcal{K}_{\phi} : i \in K\}$ .
Definition 1 (Revealing time). Suppose we are given an algorithm, a hidden set  $K \in \mathcal{F}_n^k$ , and an element  $i \in K$ . Let  $\phi_t$  be the feedback history of the algorithm run on the hidden set  $K$  for  $t$  rounds. The smallest  $t$  such that all sets  $K' \in \mathcal{F}_n^k$  compatible with  $\phi_t$  contain element  $i$  is called the revealing time of element  $i$  on the hidden set  $K$ .
Note that, in our feedback model above, the revealing time  $t$  of agent  $i$  could sometimes result from explicit feedback in round  $t$ , i.e.,  $\text{Feedback}(Q_t \cap K) = i$ , but in other cases could be deducted implicitly by ruling out non-compatible configurations that do not contain  $i$  (c.f., Definition 1).
We say that an algorithm solves the CGT problem, or is an  $(n,k)$ -CGT, if for any hidden set  $K\in \mathcal{F}_n^k$  the revealing time of any element  $i\in K$  is finite. The maximum of the revealing time, over all hidden sets  $K\in \mathcal{F}_n^k$  and  $i\in K$ , is called the maximum revealing time of the  $(n,k)$ -CGT algorithm. A performance measure of a secondary interest is the maximum completion time, which is the maximum, over all hidden sets  $K\in \mathcal{F}_n^k$ , of the minimum round when empty queries follow.
$^5\rho [t_1,\ldots ,t_a]$  denotes a sub-sequence of  $\rho$  consisting of values of sequence  $\rho$  in positions  $t_1,\dots ,t_a$
Clearly, an  $(n,k)$ -CGT algorithm has to reveal all elements in the hidden set before stopping to generate non-empty queries (feedback to which does not bring any information); therefore, the maximum completion time is not earlier than the maximum revealing time.
2.1 Game-theoretic framework for CGT
We now define the game theoretic setting of the CGT problem. The set of available selfish players, also called agents, coincides with the elements of the universe  $[n]$ . The hidden set  $K \subseteq [n]$  is the set of active agents chosen among available agents, who participate in the given instance of the game. As mentioned earlier, we also refer to the hidden set  $K$  as configuration of the game. Initially an adversary chooses a configuration  $K \in \mathcal{F}_n^k$  and informs every agent of their status with respect to the configuration, i.e., each active agent knows about the fact that it is in set  $K$ , but does not know ids of the other active agents in  $K$ .
Each agent then executes the same deterministic algorithm, called a strategy, determined by the parameter  $n$  (and  $k$ , if given) and the feedback history. Actions of an agent will also be determined by its unique id. We will usually denote the algorithm as a collection of deterministic algorithms (strategies)  $(s_0, s_1, \ldots, s_{n-1})$ , one for each of the  $n$  agents. In each round, the strategy determines if the agent, say  $i$ , is in the current query in a round  $t$  or not, i.e.,  $s_i[t] = 1$  or  $s_i[t] = 0$ , respectively. After each agent decides whether it is present in the query or not, the outcome of the feedback function is computed centrally, based on the combined agents' decisions and communicated to all the agents.<sup>7</sup>
Given an algorithm, the goal of each active agent  $i \in K$  is to minimize the revealing time of  $i$ . Therefore, the payoff or utility of agent  $i \in K$  is a strictly decreasing function of  $i$ 's revealing time. In order to improve its payoff, an agent  $i \in K$  may want to deviate from the algorithm at some rounds  $t$ , in which the corresponding query  $Q_{t}$  generated by the algorithm could be modified by  $i$  by either:
- including itself in the query  $Q_{t}$ : the original query, where  $i \notin Q_{t}$ , is modified to  $Q_{t}' = Q_{t} \cup \{i\}$ ; or
- excluding itself from the query  $Q_{t}$ : the original query, where  $i \in Q_{t}$ , is modified to  $Q_{t}' = Q_{t} \setminus \{i\}$ .
The agents following the algorithm are not informed about the deviation of the other agent, although could deduct some information later on, based on the received feedback - the feedback is given for the modified query, i.e.,  $\phi[t] = \text{Feedback}(Q_t' \cap K)$  for the game configuration  $K$ .
Adversarial equilibria. The following notion of an adversarial equilibrium has been introduced by Chionas et al. [2023] in the context of related but more restricted non-adaptive contention resolution games. We extend this definition to the CGT game. A collection of deterministic algorithms (strategy profile)  $(s_0, s_1, \ldots, s_{n-1})$ , one for each of the  $n$  agents, solving the CGT problem, is called an  $(n, k)$ -adversarial equilibrium, or  $(n, k)$ -AE, iff for any agent  $i \in [n]$  and any change of its strategy (a.k.a. a deviation) from  $s_i$  to some other strategy  $s_i' \neq s_i$  (while all other agents  $j \neq i$  follow their strategies  $s_j$ ), if there is a configuration  $K$  of  $k$  agents for which the change strictly decreases the revealing time of agent  $i$ , then there is a configuration  $K'$  of  $k$  agents for which this change strictly increases the revealing time of agent  $i$ .  $K(K', \text{resp.})$  is called an improving (worsening, resp.) configuration for agent  $i$  under deviation  $s_i'$ . We also call strategies  $(s_0, s_1, \ldots, s_{n-1})$  a  $n$ -AE if it is  $(n, k)$ -AE for any  $k = 2, 3, \ldots, n$ .
Essentially, the notion of adversarial equilibrium is similar to the notion of individual Pareto optimality. This means that, for a strategy profile that is adversarial equilibrium, for each agent there does not exist an action (deviation) that improves its payoff in one configuration (compared to its respective payoff before deviation) without worsening it in another configuration (again compared to its respective payoff before the deviation). We refer the reader for a further discussion about this definition to Chionas et al. [2023] and to the Supplementary Materials.
Universal Adversarial Equilibria (with unknown  $k$ ). An algorithm is universal  $(n, k')$ -AE if the algorithm is  $(n, k)$ -AE for every  $k \leq k'$ . An algorithm which is universal  $(n, n)$ -AE, is also called universal  $n$ -AE.
Note that, since the algorithm is deterministic, all agents could compute the strategies of other agents – however, due to initially unknown configuration (and, thus, ambiguity) and potential deviations (see the next paragraph), such strategies' computation may not often help the agent to predict the actual feedback (which could help to improve the revealing time by deviation, see again the next paragraph for details).
2.2 Preliminaries