Towards a complexity theory for the congested clique

TL;DR

This paper develops a complexity theory framework for the congested clique model, introducing new classes, hierarchy theorems, and relationships between problems to better understand its computational limits.

Contribution

It introduces nondeterministic and hierarchy models, proves lower bounds, and maps problem relationships, advancing the theoretical understanding of congested clique complexity.

Findings

Defined the nondeterministic congested clique model.

Proved a time hierarchy theorem for the model.

Mapped relationships between natural problems in the model.

Abstract

The congested clique model of distributed computing has been receiving attention as a model for densely connected distributed systems. While there has been significant progress on the side of upper bounds, we have very little in terms of lower bounds for the congested clique; indeed, it is now know that proving explicit congested clique lower bounds is as difficult as proving circuit lower bounds. In this work, we use various more traditional complexity-theoretic tools to build a clearer picture of the complexity landscape of the congested clique: -- Nondeterminism and beyond: We introduce the nondeterministic congested clique model (analogous to NP) and show that there is a natural canonical problem family that captures all problems solvable in constant time with nondeterministic algorithms. We further generalise these notions by introducing the constant-round decision hierarchy (analogous to the polynomial hierarchy). -- Non-constructive lower bounds: We lift the prior non-uniform counting arguments to a general technique for proving non-constructive uniform lower bounds for the congested clique. In particular, we prove a time hierarchy theorem for the congested clique, showing that there are decision problems of essentially all complexities, both in the deterministic and nondeterministic settings. -- Fine-grained complexity: We map out relationships between various natural problems in the congested clique model, arguing that a reduction-based complexity theory currently gives us a fairly good picture of the complexity landscape of the congested clique.

Figures

Equations

$$\text{clique}(S(n))⊊\text{clique}(T(n)).$$

$$G\in L\text{if and only if}\exists z:A(G,z)=1,$$

$$\text{clique}(1)\ne \text{nclique}(1)$$

$$\delta (L)=\inf \{\delta \in [0,1]:\text{L can be solved in O(nδ) rounds}\}.$$

$$T:\mathbb{N}\to \mathbb{N},$$

$$2^{2b{n}^2{2}^{L+bt(n-1)}}.$$

$$\text{clique}(S(n))⊊\text{clique}(T(n)).$$

$$L\in \text{clique}(T(n))\setminus \text{clique}(S(n)).$$

$$G\in L\text{if and only if}\exists z:A(G,z)=1,$$

$$L\notin \text{nclique}(S(n))\text{ and }L\in \text{clique}(T(n)).$$

$$M+L+T(n)(n-1)\log n\leq\biggr{(}\frac{1}{2}+\frac{1}{n}\biggl{)}T(n)n\log n<\frac{3}{4}T(n)n\log n=\frac{3}{4}nL\,,$$

$$\text{nclique}(S(n))⊊\text{nclique}(T(n)).$$

$$\text{clique}(1)\ne \text{nclique}(1);$$

$$\ell (u,v)\in {\mathcal{C}}_{n,u,v,\partial (u)}\text{ and }\ell (u,v)\in {\mathcal{C}}_{n,v,u,\partial (v)}$$

$$G\in L\text{ if and only if }\exists z_1\forall z_2\dots Q{z}_k:A(G,z_1,z_2,\dots ,z_k)=1,$$

$$G\in L\text{ if and only if }\forall z_1\exists z_2\dots Q{z}_k:A(G,z_1,z_2,\dots ,z_k)=1,$$

$${\Sigma }_1=\text{nclique}(1);$$

$${\Sigma }_k\subseteq {\Delta }_k\subseteq {\Sigma }_{k+1}\text{ and }{\Pi }_k\subseteq {\Delta }_k\subseteq {\Pi }_{k+1},$$

$${\Pi }_k\subseteq {\Sigma }_{k+1}\text{ and }{\Sigma }_k\subseteq {\Pi }_{k+1}.$$

$$L\notin \bigcup _{k=0}^{\infty }{\Sigma }_k^{\log }.$$

$$kM+L+\frac{1}{4}(T(n){)}^2(n-1)\log n<\frac{3}{4}(T(n){)}^{2}n\log n=\frac{3}{4}nL,$$

$$\delta (L)=\inf \{\delta \in [0,1]:\text{L can be solved in O(nδ) rounds}\}.$$

$$\text{clique}(1)\ne \text{nclique}(1),$$

Full text

\newclass\local

LOCAL \newclass\congestCONGEST

\newclass\cliqueCLIQUE \newclass\ncliqueNCLIQUE \newclass\allALL \newclass\concliquecoNCLIQUE

• Towards a complexity theory for the congested clique

Janne H. Korhonen  $\cdot$  janne.h.korhonen@aalto.fi

Aalto University

Jukka Suomela  $\cdot$  jukka.suomela@aalto.fi

Aalto University

• Abstract. The congested clique model of distributed computing has been receiving attention as a model for densely connected distributed systems. While there has been significant progress on the side of upper bounds, we have very little in terms of lower bounds for the congested clique; indeed, it is now known that proving explicit congested clique lower bounds is as difficult as proving circuit lower bounds.

In this work, we use various more traditional complexity theory tools to build a clearer picture of the complexity landscape of the congested clique:

• –

Nondeterminism and beyond: We introduce the nondeterministic congested clique model (analogous to NP) and show that there is a natural canonical problem family that captures all problems solvable in constant time with nondeterministic algorithms. We further generalise these notions by introducing the constant-round decision hierarchy (analogous to the polynomial hierarchy).

• –

Non-constructive lower bounds: We lift the prior non-uniform counting arguments to a general technique for proving non-constructive uniform lower bounds for the congested clique. In particular, we prove a time hierarchy theorem for the congested clique, showing that there are decision problems of essentially all complexities, both in the deterministic and nondeterministic settings.

• –

Fine-grained complexity: We map out relationships between various natural problems in the congested clique model, arguing that a reduction-based complexity theory currently gives us a fairly good picture of the complexity landscape of the congested clique.

1 Introduction

The congested clique.

In this work, we study computational complexity questions in the congested clique model of distributed computing. The congested clique is essentially a fully-connected specialisation of the classic \congest model of distributed computing: There are $n$ nodes that communicate with each other in a fully-connected synchronous network by exchanging messages of size $O(\log n)$. Each node in the network corresponds to a node in an input graph $G$, each node starts with knowledge about their incident edges in $G$, and the task is to solve a graph problem related to $G$.

The congested clique has recently been receiving increasing attention especially on the side of the upper bounds, and the fully-connected network topology enables significantly faster algorithms than what is possible in the \congest model. However, on the side of complexity theory, there has been significantly less development. Compared to the \local and \congest models, where complexity-theoretic results have generally taken the form of unconditional, explicit lower bounds for concrete problems, such developments have not been forthcoming in the congested clique. Indeed, it was show by Drucker et al. [19] that congested clique lower bounds imply circuit lower bounds, and the latter are notoriously difficult to prove – overall, it seems that there are many parallels between computational complexity in the congested clique and centralised computational complexity.

Towards a complexity theory.

We use concepts and techniques from centralised complexity theory to map out the complexity landscape of the congested clique model. First, we focus on decision problems:

• –

We introduce the nondeterministic version of the congested clique model. In particular, the class $\nclique(1)$ of problems solvable in constant time with nondeterministic algorithms is a natural analogue of the class NP. We show that there is a natural canonical problem family that captures all $\nclique(1)$ problems.

• –

We further generalise the notion of nondeterministic congested clique by introducing the constant-round decision hierarchy, analogous to the polynomial hierarchy.

• –

We prove time hierarchy theorems for the congested clique, showing that there are decision problems of essentially all complexities both in deterministic and nondeterministic settings.

Furthermore, we study the landscape of natural graph problems in the congested clique using a fine-grained complexity approach:

• –

While we cannot prove explicit lower bounds for the congested clique, we map out the relative complexity of problems with polynomial complexity.

1.1 Results: time hierarchy

It is known that in the centralised setting, there are problems of almost any deterministic time complexity, due to the time hierarchy theorem [29, 33]. However, in distributed computing, we know that the picture can be quite different; for LCL problems in the \local model, there are known complexity gaps, implying that at least in some ranges LCL problems can have only very specific complexities [48, 8, 12, 3]. Thus, it makes sense to ask how the picture looks like in the congested clique: for example, it could be that – similarly to LCL problems in the \local model – there are no problems with complexity $o(\log^{*}n)$ and $\omega(1)$.

We show that no such gaps occur in the congested clique model. Writing $\clique(T(n))$ for the set of decision problems that can be solved in $O(T(n))$ rounds, we prove a time hierarchy theorem for the congested clique: for any sensible complexity functions $S$ and $T$ with $S(n)=o(T(n))$, we have that

[TABLE]

The proof of the time hierarchy theorem is based on the earlier circuit counting arguments for a non-uniform version of the congested clique [1, 19]. We show how to lift this result into the uniform setting, allowing us to show the existence of decision problems of essentially arbitrary complexity. Indeed, we use this same technique also for the other separation results in this paper.

1.2 Results: nondeterminism and beyond

Nondeterministic congested clique.

The class NP and NP-complete problems are central in our understanding of centralised complexity theory. We build towards a similar theory for the congested clique by introducing a nondeterministic congested clique model. We define the class $\nclique(T(n))$ as the class of decision problems that have nondeterministic algorithms with running time $O(T(n))$, or equivalently, as the set of decision problems $L$ for which there exists a deterministic algorithm $A$ that runs in $O(T(n))$ rounds and satisfies

[TABLE]

where $z$ is a labelling assigning each node $v$ a nondeterministic guess $z_{v}$; for details, see Section 5.

We show that nondeterminism is only useful up to the number of bits communicated by the algorithm: any nondeterministic algorithm with running time $O(T(n))$ can be converted to a normal form where each yes-instance has an accepting labelling with $|z_{v}|\leq O(T(n)n\log n)$. As an application of this result, we show that $\nclique(S(n))$ does not contain $\clique(T(n))$ for any $S(n)=o(T(n))$.

Constant-round nondeterministic decision.

We argue that the class $\nclique(1)$, consisting of problems solvable in constant time with nondeterministic algorithms, is a natural analogue of the class NP. The class $\nclique(1)$ contains most natural decision problems that have been studied in the congested clique, as well as many NP-complete problems such as $k$-colouring and Hamiltonian path. In particular, the question of proving that

[TABLE]

can be seen as playing a role similar to the P vs. NP question in the centralised setting. Alternatively, $\nclique(1)$ can be seen as an analogue of the class LCL of locally checkable labellings that has been studied extensively in the context of the \local model; see Section 8.

While we cannot prove a separation between deterministic and nondeterministic constant time, we identify a family of canonical problems for $\nclique(1)$: we show that any $\nclique(1)$ problem can be formulated as a specific type of edge labelling problem. In particular, showing a non-constant lower bound for any edge labelling problem would be sufficient to separate $\clique(1)$ and $\nclique(1)$.

Constant-round decision hierarchy.

We extend the notion of nondeterministic clique by studying a constant-round decision hierarchy. This can be seen as analogous to the polynomial hierarchy in the centralised setting; each node can be seen as running an alternating Turing machine.

Unlike for nondeterministic algorithms, it turns out that the label size for algorithms on the higher levels of this hierarchy is not bounded by the amount of communication. Thus, we get two very different versions of this hierarchy:

• –

Unlimited hierarchy $(\Sigma_{k},\Pi_{k})_{k=1}^{\infty}$ with unlimited label size: we show that this version of the hierarchy collapses, as all decision problems are contained on the second level.

• –

Logarithmic hierarchy $(\Sigma^{\log}_{k},\Pi^{\log}_{k})_{k=1}^{\infty}$ with $O(n\log n)$-bit label per node: we show that there are problems that are not contained in this hierarchy.

1.3 Results: fine-grained complexity

By the time hierarchy theorem, we know that there are decision problems of all complexities, but it is beyond our current techniques to prove lower bounds for any specific problem, assuming we exclude lower bounds resulting from input or output sizes. However, what we can do is study the relative complexity of natural problems, much in the vein of centralised fine-grained complexity. In Section 7, we study the relative complexities of various concrete problems that are thought to have polynomial complexity in the congested clique. Specifically, our framework is to compare problem exponents, defined for problem $L$ as

[TABLE]

By mapping out known relationships in this regime, we argue that despite the lack of explicit lower bounds, our understanding of the landscape of problems of polynomial complexity in the congested clique is in many senses better than e.g. in the \congest model.

2 Related work

Upper bounds for the congested clique.

As noted in the introduction, upper bounds have been extensively studied in the congested clique model. Problems studied in prior work include routing and sorting [43], minimum spanning trees [45, 32, 25, 34], subgraph detection [16, 10], shortest path problems [10, 4], local problems [30, 31, 11] and problems related to matrix multiplication [42, 10].

Complexity theory for the congested clique.

Prior work on computational complexity in the congested clique is fairly limited; the notable exceptions are the connections to circuit complexity [19] and counting arguments for the non-uniform version of the model [1, 19]. However, lower bounds can be proven if we consider problems with large outputs; for example, lower bounds are known for triangle enumeration [49] or, trivially, a problem where all nodes are required to output the whole input graph. Moreover, for the broadcast congested clique, a version of the model where each node sends the same message to each other node every round, lower bounds have been proven using communication complexity arguments [19].

Complexity theory for  \congest.

For the \congest model, explicit lower bounds are known for many problems, even on graphs with very small diameter [50, 15, 24, 40, 47, 44]. These are generally based on reductions from known lower bounds in communication complexity; however, these reductions tend to boil down to constructing graphs with bottlenecks, that is, graphs where large amounts of information have to be transmitted over a small cut. A key motivation for the study of the congested clique model is to understand computation in networks that do not have such bottlenecks.

Complexity theory for  \local.

Perhaps the most active development related to the computational complexity theory of distributed computing is currently taking place in the context of the \local model. There is a lot of very recent work that aims at developing a complete classification of the complexities of LCL problems in the \local model [13, 7, 26, 8, 12, 3]. In this line of research, the focus is on low-degree large-diameter graphs, while in the congested clique model we will study the opposite corner of the distributed computing landscape: high-degree low-diameter graphs.

Nondeterminism and alternation.

Nondeterministic models of distributed computing have been studied under various names – for example, proof labeling schemes [36, 37, 38, 39], nondeterministic local decision [23], and locally checkable proofs [28] can be interpreted as nondeterministic versions of variants of the \local and \congest models; we refer to the survey by Feuilloley and Fraigniaud [21] for further discussion. However, there seem to be very few papers that take the next step from nondeterministic machines to alternating machines in the context of distributed computing – we are only aware of Reiter [51], who studies alternating quantifiers in finite state machines, and Feuilloley et al. [22] and Balliu et al. [2], who study alternating quantifiers in the \local model.

3 Preliminaries

The congested clique.

The congested clique is a specialisation of the standard \congest model of distributed computing to a fully connected network topology. The network consists of $n$ nodes (i.e. computers) that are connected to all other nodes by edges (i.e. communication links) – that is, the communication graph is a clique.

As an input, we are given an undirected, unweighted graph $G=(V,E)$ with $V=\{1,2,\dotsc,n\}$. Each node of the communication network has a unique identifier $v\in\{1,2,\dotsc,n\}$ and, in addition to it’s own unique identifier, has initially knowledge about edges incident to node $v$ in $G$. The nodes collaborate to solve a problem related to the graph $G$.

The computation is done in synchronous rounds, and all nodes run the same deterministic algorithm. Each round, all nodes (1) perform an unlimited amount of local communication, (2) send a possibly different $O(\log n)$-bit message to each other node, and (3) receive the messages sent to them. The time complexity of an algorithm is measured in the number of rounds used.

Decision problems.

To avoid artefacts resulting from input and output sizes, we restrict our attention for the most part to decision problems on unweighted, undirected graphs. A decision problem $L$ is a family of graphs; a graph $G$ is a yes-instance of $L$ if $G\in L$ and a no-instance otherwise. The complement $\bar{L}$ of problem $L$ contains all graphs $G$ that are not in $L$.

Note that we do not require decision problems to be closed under isomorphisms, that is, problems can refer to the names of the nodes. However, we are only interested in decision problems that are computable in the centralised sense, and we will implicitly assume that this is the case for any problem considered.

An algorithm $A$ solves problem $L$ if for any graph $G$, each node $i$ produces output $A_{i}(G)=1$ if $G\in L$ and $A_{i}(G)=0$ if $G\notin L$; we write $A(G)=1$ to indicate that all nodes produce output $1$ (the algorithm accepts) and $A(G)=0$ to indicate that all nodes output [math] (the algorithm rejects).

Input encoding.

We will tacitly assume that the input is provided for node $v\in V$ in the form of a length-$(n-1)$ bit vector $x_{v}$ indexed by $V\setminus\{v\}$ describing whether each of the potential incident edges is present in the input graph $G=(V,E)$. In particular, any two nodes $u$ and $v$ will share the bit $x_{u,v}=x_{v,u}$.

However, for technical reasons, it is convenient to consider a setting where each node has private input bits, so we will implicitly assume that each of these bits is assigned to exactly one node, so that (1) for each possible edge in the graph, exactly one of its endpoints has the bit corresponding to that edge and (2) each node has at least $\lfloor(n-1)/2\rfloor$ input bits. Note that it takes a single round to move from the latter setting to the former.

Algorithms.

As noted above, we assume all nodes run the same deterministic algorithm. While the congested clique allows $O(\log n)$ bandwidth per round, where the constant hidden by O-notation can depend on the algorithm, we can always move the constant factors to the running time and assume that all algorithms use exactly $\lceil\log_{2}n\rceil$ bits of communication per round.

Deterministic complexity classes.

For a computable function

[TABLE]

we define the complexity class $\clique(T(n))$ as the family of all graph problems that can be solved in $T(n)$ rounds.

Counting arguments.

We will now review known results on the non-uniform version of the congested clique [1, 19]. Specifically, we consider a setting where the number of nodes $n$ and the communication bandwidth $b$ is fixed beforehand, and we want to compute a function $f\colon\{0,1\}^{nL}\to\{0,1\}$, where $L$ is an integer; each node receives $L$ private input bits, and we want all nodes to output the same result $y\in\{0,1\}$. We define an $(n,b,L,t)$-protocol $P$ to be an algorithm that works in this setting and computes an output $P(x_{1},x_{2},\dotsc,x_{n})\in\{0,1\}$ in $t$ rounds. Since the parameters are fixed, there are only a finite number of different $(n,b,L,T)$-protocols, and this number can be bounded by standard counting arguments:

Lemma 1** ([1]).**

The number of different $(n,b,L,t)$-protocols is at most

[TABLE]

By contrast, the number of functions $f\colon\{0,1\}^{nL}\to\{0,1\}$ is $2^{2^{nL}}$, so this implies that for sufficiently large $n$, most such functions do not have a $(n,b,L,t)$-protocol when $t<L/b-1$ [1].

4 Time hierarchy

We start by proving the deterministic time hierarchy theorem: there are problems of essentially all complexities in the congested clique model.

Theorem 2**.**

Let $S,T\colon\mathbb{N}\to\mathbb{N}$ be computable functions such that $S(n)=o(T(n))$ and $T(n)=O(n/\log n)$. Then

[TABLE]

Proof.

We prove the theorem by constructing a language

[TABLE]

For convenience, let us assume that $T(n)<n/(4\log n)$ for all sufficiently large $n$. Now, for all sufficiently large $n$, we define the set of $n$-node graphs that belong to $L$ as follows:

• –

Fix $L=T(n)\log n\leq\lfloor n/2\rfloor$, and fix a function $f_{n}\colon\{0,1\}^{nL}\to\{0,1\}$ that does not have a $(n,\log n,L,T(n)/2)$-protocol; by Lemma 1, such a function exists. Moreover, we can select $f_{n}$ to be a first function that satisfies this condition under the lexicographical ordering when interpreting functions $\{0,1\}^{nL}\to\{0,1\}$ as bit vectors of length $2^{nL}$.

• –

Let $G$ be a graph on $n$ nodes and let $x_{v}$ be the $L$-bit prefix of the input bit vector that node $v$ receives when $G$ is the input graph. We set $G\in L$ if $f_{n}(x_{1},x_{2},\dotsc,x_{n})=1$, and $G\notin L$ otherwise.

First, we observe that $L\in\clique(T(n))$. That is, we can decide if the input graph $G$ belongs to $L$ in time $T(n)$ as follows:

1. (1)

Each node $v$ broadcasts the first $L=T(n)\log n$ bits of its input – that is, the vector $x_{v}$ – to all other nodes. This takes $T(n)$ rounds. 2. (2)

Each node $v$ uses local computation to find the function $f_{n}$ as specified above; this can be done by exhaustively enumerating all functions $f\colon\{0,1\}^{nL}\to\{0,1\}$ and all $(n,\log n,\allowbreak L,\allowbreak T(n))$-protocols. Each node then locally computes the value $f_{n}(x_{1},x_{2},\dotsc,x_{n})$ and outputs it.

It remains to show that $L\notin\clique(S(n))$. Assume for contradiction that there is an algorithm that solves $L$ in time $O(S(n))$. This implies that for any sufficiently large $n$, there is an $(n,\log n,L,\allowbreak O(S(n)))$-protocol $P_{n}$ for $f_{n}$. However, we have that $S(n)=o(T(n))$, so by the choice of $f_{n}$ the protocol $P_{n}$ cannot exist. ∎

5 Nondeterminism

5.1 Nondeterministic complexity classes

A labelling $z$ of size $k$ is a mapping that assigns each node $v\in V$ a label $z_{v}\in\{0,1\}^{*}$ of length at most $k$. A nondeterministic congested clique algorithm $A$ is an algorithm that takes as an input, in addition to the input graph $G$, a labelling $z$ of size $S(n)$ for some computable function $S\colon\mathbb{N}\to\mathbb{N}$; we say that $S(n)$ is the labelling size of $A$. We can think of $z$ as the sequence of nondeterministic choices made by $A$, or alternatively as a certificate provided by an external prover. We say that $A$ decides the language $L$ if for all graphs $G$,

[TABLE]

where $z$ is a labelling of size $S(n)$.

For a computable function $T\colon\mathbb{N}\to\mathbb{N}$, we define the complexity class $\nclique(T(n))$ as the set of languages $L$ such that there exists a nondeterministic algorithm $A$ with running time of $T(n)$ rounds that decides $L$.

5.2 $\nclique$ normal form

While the definition of $\nclique(T(n))$ allows the algorithms to use an essentially arbitrary amount of nondeterministic bits, we show that nondeterministic bits are only useful, roughly speaking, as long as they can be communicated to other nodes by the algorithm. More precisely, we prove that any nondeterministic algorithm can be converted to a normal form:

Theorem 3**.**

If $L\in\nclique(T(n))$, then there is a nondeterministic algorithm $B$ that decides $L$ with running time $T(n)$ and labelling size $O(T(n)n\log n)$.

Proof.

Let $A$ be the algorithm certifying $L\in\nclique(T(n))$. We say that a communication transcript of an execution of $A$ of node $v$ is a bit vector consisting of all messages sent and received by $v$ during the execution of $A$. Clearly, a communication transcript of a node $v$ has length $O(T(n)n\log n)$.

We now define an algorithm $B$ that works as follows on input $(G,z)$:

1. (1)

Each node $v\in V$ checks that their label $z_{v}$ is a valid communication transcript of length $O(T(n)n\log n)$ (if not, reject). 2. (2)

Nodes verify that their labels are consistent with each other; this can be done in $T(n)$ rounds by simply replaying the transcripts and checking that all the received messages agree with the transcript (if not, reject). 3. (3)

Each node $v\in V$ locally tries all possible local labels of size at most $S(n)$, where $S(n)$ is the labelling size of $A$, to see if there is a label $z^{\prime}_{v}$ so that the execution of $A$ with local label $z^{\prime}_{v}$ and the local input of node $v$ agrees with the transcript $z_{v}$ and accepts (if not, reject; otherwise accept).

Clearly $B$ runs in $T(n)$ rounds. If there is a labelling $z^{\prime}$ such that $A(G,z^{\prime})=1$, then using the transcripts from this execution of $A$ as the labelling $z$ clearly gives $B(G,z)=1$. On the other hand, if there is a $z$ such that $B(G,z)=1$, then there are local labels $z^{\prime}_{v}$ for each $v\in V$ such that $A(G,z^{\prime})=1$. ∎

5.3 Nondeterministic time hierarchy

As an application of the normal form theorem, we can extend the time hierarchy theorem to the nondeterministic congested clique. In fact, we prove a somewhat stronger statement:

Theorem 4**.**

Let $S,T\colon\mathbb{N}\to\mathbb{N}$ be computable functions such that $S(n)=o(T(n))$ and $T(n)=O(n/\log n)$. Then there is a decision problem $L$ such that

[TABLE]

Proof.

We say that a $(n,b,M+L,t)$-protocol is a nondeterministic protocol for function $f\colon\{0,1\}^{nL}\to\{0,1\}$ if for all $x\in\{0,1\}^{nL}$ it holds that $f(x_{1},x_{2},\dotsc,x_{n})=1$ if and only if there is $z\in\{0,1\}^{nM}$ such that $P(z_{1}x_{1},z_{2}x_{2},\dotsc,z_{n}x_{n})=1$.

Now we construct a decision problem $L\in\clique(T(n))\setminus\nclique(S(n))$ using the same construction as in the proof of Theorem 2, with minor modifications as follows. Let $L=T(n)\log n$, and let $M=\frac{1}{4}T(n)n\log n$. We select the functions $f_{n}\colon\{0,1\}^{nL}\to\{0,1\}$ in the construction of $L$ with the extra constraint that $f_{n}$ does not have a nondeterministic $(n,\log n,M+L,T(n)/4)$-protocol; this is possible for sufficiently large $n$, since then

[TABLE]

and thus by Lemma 1 the number of $(n,\log n,M+L,T(n)/4)$-protocols is $2^{o(2^{nL})}$.

The problem $L$ constructed using the functions $f_{n}$ is clearly in $\clique(T(n))$ using the same argument as in the proof of Theorem 2. On the other hand, if $L\in\nclique(S(n))$, then by Theorem 3 there is a nondeterministic algorithm for $L$ with running time $O(S(n))$ and labelling size $O(S(n)n\log n)$. But this implies that the functions $f_{n}$ have nondeterministic $(n,\log n,L+O(S(n)n\log n),\allowbreak O(S(n)))$-protocols, which is not possible for large $n$ by the choice of $f_{n}$, since we have $S(n)=o(T(n))$. ∎

Since $\clique(T(n))\subseteq\nclique(T(n))$, a time hierarchy theorem for the nondeterministic congested clique follows immediately from Theorem 4.

Corollary 5**.**

Let $S,T\colon\mathbb{N}\to\mathbb{N}$ be computable functions such that $S(n)=o(T(n))$ and $T(n)=O(n/\log n)$. Then

[TABLE]

6 Constant-round decision

6.1 Constant-round nondeterministic clique

The class $\nclique(1)$ is a natural analogue of class NP in the congested clique; it contains decision versions of most natural problems considered in the congested clique setting. It is also easy to see that $\nclique(1)$ contains many NP-complete decision problems, such as $k$-colouring and Hamiltonian paths. By Theorem 4, we also know that there are problems that can be solved in slightly super-constant time, but are not in $\nclique(1)$. However, our lower bound techniques are not sufficient to show that

[TABLE]

in a sense, this is the congested clique analogue of the P vs. NP question.

However, we can interpret Theorem 3 to state that there is a canonical problem family for $\nclique(1)$. Specifically, we say that a neighbourhood constraint $\mathcal{C}$ is a computable mapping that for any number of nodes $n$, any edge $\{u,v\}$, and any edge-neighbourhood $\partial(u)$ of $u$, gives a set $\mathcal{C}_{n,u,v,\delta(u)}$ of allowed $O(\log n)$-bit labels for the edge $\{u,v\}$. An edge labelling problem is defined by an edge neighbourhood constraint $\mathcal{C}$: given a graph $G$, find a labelling $\ell$ of all edges of the clique with labels $\ell(u,v)$ of size $O(\log n)$ so that the labels satisfy the local constraints at all nodes, that is

[TABLE]

for all $u$ and $v$.

By Theorem 3, any problem with $\nclique(1)$ algorithm $A$ can be interpreted as an edge labelling problem: the edge labels are defined as the set of valid communication transcripts of an accepting run of $A$. This gives us a limited notion of completeness for $\nclique(1)$:

Theorem 6**.**

We have $\nclique(1)\subseteq\clique(T(n))$ if and only if all edge labelling problems can be solved deterministically in $O(T(n))$ rounds.

In particular, we have $\clique(1)=\nclique(1)$ if and only if all edge labelling problems can be solved deterministically in $O(1)$ rounds. However, it seems that identifying a single graph decision problem that is “complete” for $\nclique(1)$ is difficult; in essence, we would have to work reductions running in constant time, which makes the use of any sort of gadget constructions extremely difficult.

6.2 Constant-round decision hierarchy

Whereas $\nclique(1)$ is the congested clique analogue of NP, we can extend this analogue to the polynomial hierarchy by adding more quantifiers, that is, by allowing the nodes to alternate between nondeterministic and co-nondeterministic choices; similar ideas has been studied in the context of local verification [22, 2, 51].

Formally, we say that a $k$-labelling algorithm $A$ of labelling size $S(n)$ is a constant-round congested clique algorithm that takes as an input $k$ labellings $z_{1},z_{2},\dotsc,z_{k}$ of size at most $S(n)$. We define the class $\Sigma_{k}$ as the set of languages $L$ for which there exists a $k$-labelling algorithm $A$ of labelling size $S(n)$ such that

[TABLE]

where $z_{1},z_{2},\dotsc,z_{k}$ are labellings of size at most $S(n)$ and $Q$ is the universal quantifier if $k$ is even and the existential quantifier if $k$ is odd. Similarly, we define $\Pi_{k}$ as the set of languages $L$ for which there exists a $k$-labelling algorithm $A$ of labelling size $S(n)$ such that

[TABLE]

where $z_{1},z_{2},\dotsc,z_{k}$ are labellings of size at most $S(n)$ and $Q$ is the existential quantifier if $k$ is even and the universal quantifier if $k$ is odd. Finally, we define $\Delta_{k}=\Sigma_{k}\cup\Pi_{k}$.

At the first level of the hierarchy we have the class

[TABLE]

by Theorem 3 we know that limiting the labelling size to $O(n\log n)$ gives us the same class as unlimited labelling size. A natural question is then if the same phenomenon happens at the higher levels of the hierarchy?

Turns out this is not the case; we will consider two different versions of the constant-round decision hierarchy:

• –

Unlimited hierarchy: the hierarchy $(\Sigma_{k},\Pi_{k})_{k=1}^{\infty}$ as defined above, with arbitrary labelling size allowed.

• –

Logarithmic hierarchy: the hierarchy $(\Sigma^{\log}_{k},\Pi^{\log}_{k})_{k=1}^{\infty}$ defined otherwise as above, but the algorithm $A$ is required to have labelling size of $O(n\log n)$ – in other words, $O(\log n)$ bits per edge.

In a sense, these correspond to the different \local model hierarchies studied by Feuilloley et al. [22] (the logarithmic hierachy) and Balliu et al. [2] (the unlimited hierarchy).

Basic properties.

We first note basic properties of the constant-round hierarchies. Trivially, we have that

[TABLE]

and thus also

[TABLE]

Moreover, if a decision problem $L$ is in $\Sigma_{k}$, then the complement language $\bar{L}$ is in $\Pi_{k}$, and vice versa. These observations also hold for the logarithmic version of the constant-round hierarchy.

Unlimited hierarchy $(\Sigma_{k},\Pi_{k})_{k=1}^{\infty}$.

For the unlimited hierarchy, we obtain an essentially complete characterisation. By Theorem 4, we know there are problems that are not on the first level. Moreover, in a similar manner as happens with the \local hierarchy of Balliu et al. [2], we show that the unlimited hierarchy collapses to the second level:

Theorem 7**.**

All decision problems $L$ are in $\Sigma_{2}=\Pi_{2}$.

Proof.

Let $L$ be a decision problem. To see that $L\in\Sigma_{2}$, consider the following algorithm $A$:

1. (1)

The existential quantifier is used to guess a graph $G^{\prime}_{v}$ in each node $v$, using $n^{2}$ bits per node. 2. (2)

The universal quantifier is used to verify that all guesses $G^{\prime}_{v}$ equal the input graph $G$: each node $v$ uses $O(\log n)$ universal bits to pick a single bit from the encoding of $G^{\prime}_{v}$ and broadcasts this bit and its index to all other nodes. All nodes $u$ verify that the information broadcast by other nodes is consistent with their guess of $G^{\prime}_{u}$ and their local view of $G$ (if not, reject). 3. (3)

Each node $v$ locally checks if $G^{\prime}_{v}\in L$ (if this holds for all nodes, accept; otherwise reject).

Clearly, if the input graph $G$ is in $L$, then picking the real input graph $G$ as the existential guess results in $A$ accepting for all universal guesses. On the other hand, if $G\notin L$, then regardless of the existential guess, $A$ will not accept for all universal guesses: if $G^{\prime}_{v}=G$ for all $v$, then step (3) will reject, and if $G^{\prime}_{v}\neq G$ for some $v$, then there is a universal guess that will lead to step (2) rejecting.

Moreover, the above implies that for any decision problem $L$, we have that $\bar{L}\in\Sigma_{2}$, and thus $L\in\Pi_{2}$. It follows that all decision problems are also in $\Pi_{2}$. ∎

Logarithmic hierarchy $(\Sigma^{\log}_{k},\Pi^{\log}_{k})_{k=1}^{\infty}$.

For the logarithmic version of the constant-round hierarchy, the complexity landscape seems to be much richer that in the case of the unlimited hierarchy: any constant number of quantifiers is not enough to replicate the trick of Theorem 7 of guessing the whole input at all nodes. Indeed, we show that there are problems that are not on any level of the logarithmic constant-round hierarchy:

Theorem 8**.**

There is a decision problem $L$ such that

[TABLE]

Proof.

Again, we use the same general proof technique as in the proofs of Theorems 2 and 4. Fix a computable function $T(n)=\omega(n)$; let $L=(T(n))^{2}\log n$ and $M=\frac{1}{4}T(n)n\log n$. Otherwise using the same construction for the language $L$ as before, we select the functions $f_{n}\colon\{0,1\}^{nL}\to\{0,1\}$ so that for any $k\leq T(n)$, there is no $(n,\log n,kM+L,(T(n))^{2}/4)$-protocol that $\Sigma^{\log}_{k}$-computes $f_{n}$; this is possible for sufficiently large $n$, since then

[TABLE]

and thus by Lemma 1 the number of $(n,\log n,kM+L,(T(n))^{2}/4)$-protocols is $2^{o(2^{nL})}$.

If $L\in\Sigma^{\log}_{k}$ for some $k$, then there is a $\Sigma_{k}$ algorithm for $L$ with running time $O(1)$ and labelling size $O(n\log n)$. But this implies that there is an $(n,\log n,O(kn\log n)+L,O(1))$-protocol that $\Sigma_{k}$-computes $L$; this is not possible for large $n$ by the choice of $f_{n}$, since we have $T(n)=\omega(1)$. ∎

The proof of Theorem 8 actually implies that there are problems with only slightly super-constant deterministic complexity that are not on any level of the hierarchy. However, our lower bound technique does not appear to be sufficiently refined to separate different levels of the logarithmic constant-round hierarchy, so it remains open whether the hierarchy has infinitely many levels.

7 Fine-grained complexity

Problem exponent.

In the following, we will consider concrete problems that are not necessarily decision problems, and allow more generally problems defined in terms of weighted graphs and matrices. For a problem $L$, we define the exponent of $L$ as

[TABLE]

The basic idea is that the problem exponent captures the polynomial complexity of the problem, and we can compare the relative complexity of problems by comparing their exponents.

Relationships between problems.

In Figure 1, we summarise the relationships between prominent problems using this framework. These relations follow from prior work:

• –

Relationships between $k$-independent set ($k$-IS), maximum independent set (MaxIS) and minimum vertex cover (MinVC) are trivial. The upper bound for $k$-independent set is due to Dolev et al. [16].

• –

Relationships between 3-independent set detection (i.e. triangle detection), $k$-cycle detection ($k$-CYCLE), subgraph detection and Boolean matrix multiplication (Boolean-MM) as well as between approximate weighted all-pairs shortest paths problem and ring matrix multiplication (Ring MM) follow from the work of Censor-Hillel et al. [10]; they also give the upper bound $\delta(\text{{\sf Ring MM}})\leq 1-2/\omega$, where $\omega<2.3728639$ is the matrix multiplication exponent [41].

• –

The relationship between the $k$-colouring problem ($k$-COL) and maximum independent set follows from an easy reduction [46]: replace each vertex $v$ with $k$ copies $v_{1},\dotsc,v_{k}$ connected into a clique, and connect $v_{i}$ and $u_{i}$ if the edge $\{v,u\}$ is present in the original graph. Clearly, the new graph has independent set of size $n$ if and only if the original graph is $k$-colourable. For constant $k$, the blowup from implementing this reduction is constant.

• –

The relationship between $(2-\varepsilon)$-approximate weighted undirected all-pairs shortest paths problem and Boolean matrix multiplication follows from a reduction by Dor et al. [17].

• –

The relationships between other variants of the all-pairs shortest paths problem (APSP) and single-source shortest paths problem (SSSP) are trivial. The upper bound for unweighted directed APSP is due to Le Gall [42], and the upper bound for approximate SSSP is due to Becker et al. [5].

These are our main new contributions (see Sections 7.1–7.3 for proofs):

• –

Dominating set of size $k$ ($k$-DS) can be found in $O(n^{1-1/k})$ rounds, showing \delta(\text{\sfk-DS})\leq 1-1/k.

• –

For any fixed constant $k$, if a dominating set of size $k$ can be found in $O(n^{\delta})$ rounds, then an independent set of size $k$ can be found in $O(k^{2\delta+4}n^{\delta})$ rounds, showing \delta(\text{\sfk-IS})\leq\delta(\text{\sfk-DS}).

• –

A vertex cover of size $k$ ($k$-VC) can be found in $O(k)$ rounds, showing \delta(\text{\sfk-VC})=0 in our framework.

We note that one challenge involved in this approach is that the congested clique setting requires the use of extremely fine-grained reductions; we are essentially allowed only $n^{o(1)}$ factor blowups in the reductions. By contrast, most known reductions between NP-complete problems have polynomial blowup, making them useless in this setting.

One potentially fruitful perspective is to consider for which pairs of problems we cannot prove reductions. For example, the reduction from Boolean matrix multiplication to $(2-\varepsilon)$-approximate APSP breaks down if we consider $2$-approximate APSP instead. Indeed, we know that constant-approximation APSP can be solved faster than the current matrix multiplication upper bound, using the spanner constructions of Censor-Hillel et al. [11], so conjecturing the existence of a faster-than-matrix-multiplication algorithm for $2$-approximate APSP does not seem unreasonable. Another similar question is the existence of faster-than-matrix-multiplication algorithms for exact single-source shortest paths problems.

7.1 Dominating set upper bound

We now prove the upper bound for finding $k$-dominating sets:

Theorem 9**.**

Dominating set of size $k$ can be found in $O(n^{1-1/k})$ rounds in the congested clique model.

We employ a slight modification of the Dolev et al. [16] algorithm for finding subgraphs of size $k$. For convenience, let us assume that $n^{1/k}$ is an integer; if not, we use $\lfloor n^{1/k}\rfloor$ instead.

1. (1)

Partition the node set $V$ arbitrarily into sets $S_{1},S_{2},\dotsc,S_{n^{1/k}}$ of size $O(n^{1-1/k})$. 2. (2)

Assign each node $v\in V$ a label $\ell(v)\in[n^{1/k}]^{k}$, so that each possible label is assigned to some node. Moreover, we will assume that this is done in a globally consistent manner so all nodes will know labels of all nodes. 3. (3)

For each node $v\in V$, let $S_{v}=S_{\ell(v)_{1}}\cup S_{\ell(v)_{2}}\cup\dotsb\cup S_{\ell(v)_{k}}$. Node $v$ learns all edges incident to nodes in $S_{v}$, and locally checks if there is a dominating set of size $k$ contained in $S_{v}$; clearly, knowing all edges incident to nodes in $S_{v}$ is sufficient for checking this.

It remains to prove that the algorithm detects a dominating set of size $k$ if one exist, and that it runs in $O(kn^{1-1/k})$ rounds. The first part is simple: if there is a dominating set $D=\{v_{1},v_{2},\dotsc,v_{k}\}$ of size $k$ such that $v_{i}\in S_{j_{i}}$, then some node $v\in V$ will receive the label $\ell(v)=(j_{1},j_{2},\dotsc,j_{k})$ and detect $D$.

For the running time, we observe first that there are at most $kn^{2-1/k}=O(n^{2-1/k})$ edges incident to nodes in $S_{v}$ for all $v\in V$, so each node has to receive $O(n^{2-1/k})$ messages in step 3. On the other hand, we note that for each edge $e$, there are $2kn^{1-1/k}$ nodes $v\in V$ that have to learn about the existence of $e$, so each node has to send at most $2kn^{2-1/k}$ messages in step 3. Delivering the messages can thus be done in $O(n^{1-1/k})$ rounds using the routing protocol of Lenzen [43].

7.2 From independent set to dominating set

We next prove that finding a $k$-dominating set is at least as hard as finding a $k$-independent set in the congested clique, for any fixed $k$:

Theorem 10**.**

If a dominating set of size $k$ can be found in $O(n^{\delta})$ rounds in the congested clique model, then an independent set of size $k$ can be found in $O(k^{2\delta+4}n^{\delta})$ rounds.

The proof is straightforward; we construct a reduction from $k$independent set to $k$-dominating set that increases the number of vertices by a linear factor.

Construction.

Let $G=(V,E)$ be the input graph. We construct a new graph $G^{\prime}=(V^{\prime},E^{\prime})$ such that $G$ has an independent set of size $k$ if and only if $G^{\prime}$ has a dominating set of size $k$:

• –

As a base for the construction of $G^{\prime}$, we start with $k$ copies $K^{1},K^{2},\dotsc,K^{k}$ of clique on $n$ nodes. We identify the nodes in each clique with the original node set $V$ so that for each node $v\in V$, there is a corresponding node $v^{i}$ in the clique $K^{i}$.

• –

For each pair $(i,j)\in[k]^{2}$ with $i<j$, we construct a compatibility gadget as follows. We add an independent set $I^{i,j}$ on $n$ nodes to $G^{\prime}$, again identified with the original node set $n$ so that for each node $v\in V$, there is a corresponding node $v^{i,j}$ in the independent set $I^{i,j}$. We connect $I^{i,j}$ to $K^{i}$ and $K^{j}$:

• –

for each $v\in V$, we add an edge between the node $v^{i}$ in $K^{i}$ and $u^{i,j}$ in $I^{i,j}$ for all $u\in V\setminus\{v\}$, and

• –

for each $v\in V$, we add an edge between the node $v^{j}$ in $K^{j}$ and $u^{i,j}$ in $I^{i,j}$ for all $u\in V\setminus\{v\}$ that are not neighbours of $v$ in the original graph $G$.

• –

For each clique $K^{i}$, we add two new special nodes $x^{i}$ and $y^{i}$ that are connected to all nodes in $K^{i}$, but not to other nodes.

See Figure 2 for an illustration.

Properties of the construction.

Clearly, the graph $G^{\prime}$ has at most $(k^{2}+k+2)n$ nodes. To see the correspondence between independent sets in $G$ and dominating sets in $G^{\prime}$, we make the following observations; note that we will tacitly abuse the identification between various nodes in the original graph $G$ and the new graph $G^{\prime}$.

• –

Consider an independent set $I=\{v_{1},v_{2},\dotsc,v_{k}\}$ of size $k$ in $G$, and let $D$ be a node set obtained by picking $v_{i}^{i}$ from $K^{i}$ in $G^{\prime}$ for all $i=1,2,\dotsc,k$. Clearly $D$ dominates all nodes in set $K^{i}$ as well as the two special vertices attached to $K^{i}$, for all $i$. Furthermore, for each compatibility gadget corresponding to $(i,j)$, the node $v_{i}^{i}$ in $K^{i}$ dominates all nodes in $I^{i,j}$ except $v_{i}^{i,j}$; since $v_{j}$ is not a neighbour of $v_{i}$ in $G$, the node $v_{j}^{j}$ in $K^{j}$ dominates $v_{i}^{i,j}$ in $I^{i,j}$. Thus $D$ is a dominating set of size $k$ in $G^{\prime}$.

• –

Consider a dominating set $D=\{w_{1},w_{2},\dotsc,w_{k}\}$ of size $k$ in $G^{\prime}$. First, we observe that $D$ must contain exactly one node from each of the cliques $K^{1},K^{2},\dotsc,K^{k}$, since otherwise all the special nodes are not dominated; for convenience, let us assume that $w_{i}$ is in $K^{i}$ for all $i$. Since $D$ is a dominating set, all nodes in the compatibility gadget $I^{i,j}$ are also dominated. Since $w_{i}$ dominates all nodes in $I^{i,j}$ except one, we must have that $w_{j}$ in $K^{j}$ dominates the remaining node in $I^{i,j}$. But this implies by construction that $w_{i}$ and $w_{j}$ correspond to different nodes in $G$, and they are also not neighbours in $G$. Thus, $D$ corresponds to an independent set of size $k$ in $G$.

Simulation in the congested clique.

It remains to argue that given an input graph $G$ and a dominating set algorithm $A$ with running time $O(n^{\delta})$, we can simulate in the congested clique the execution of $A$ on $G^{\prime}$ in $O(n^{\delta})$ rounds. We have each node $v\in V$ simulate the nodes $v^{i}$ and $v^{i,j}$ for the possible choices of parameters $i$ and $j$; by construction, $v$ can determine all edges incident to those nodes in $G^{\prime}$ from its local view of $G$. Moreover, we have nodes $1$ and $2$ simulate the special nodes in $x^{i}$ and $y^{i}$, respectively. Thus, each node is simulating at most $O(k^{2})$ nodes in $G^{\prime}$. The running time of $A$ in $G^{\prime}$ is $O((k^{2}n)^{\delta})$, and the overhead from simulating $O(k^{2})$ nodes per each node in $G$ is $O(k^{4})$ rounds for each round in $G^{\prime}$, for total running time $O(k^{2\delta+4}n^{\delta})$.

7.3 Vertex cover and fixed-parameter tractability

Vertex cover.

Minimum vertex cover and maximum independent set are known to be essentially the same problem. However, we show that the parameterised version of vertex cover is significantly easier than independent set in the congested clique model:

Theorem 11**.**

Vertex cover of size $k$ can be found in $O(k)$ rounds in the congested clique model.

We use a very simple idea that also appears in the centralised Buss kernelisation algorithm [9, 14].

Lemma 12**.**

If $G=(V,E)$ has a vertex cover $C$ of size $k$, and $v\in V$ is a vertex of degree at least $k+1$, then $v\in C$.

Proof.

If $v\notin C$, then all neighbours of $v$ are in $C$, which implies $|C|\geq k+1$. ∎

In the congested clique, we exploit this idea as follows. As a preprocessing phase, all nodes of degree at least $k+1$ join the vertex cover—denote this set by $C$—and broadcast this information to all nodes; if more than $k$ nodes attempt to join the vertex cover, we know that there is no vertex cover of size $k$. As the main phase, all nodes $v\notin C$ broadcast full information about their incident edges not covered by $C$, and all nodes locally compute a minimum vertex cover for $G[V\setminus C]$. By Lemma 12, we know that there is a vertex cover of size $k$ for $G$ if and only if there is a vertex cover of size $k-|C|$ for $G[V\setminus C]$.

The preprocessing phase takes a single round. Since all nodes of degree at least $k+1$ join $C$ in the preprocessing phase, all nodes active in the main phase have to broadcast information about at most $k$ edges, so the main phase takes at most $k$ rounds.

Fixed-parameter tractability.

The above result, taken together with prior upper bounds results for parameterised problems such as $k$-independent set and $k$-cycle detection, illustrate that ideas from fixed-parameter algorithms [14, 18] can also be applied in the congested clique. Specifically, the following is known in the congested clique model:

• –

A vertex cover of size $k$ can be found in $O(k)$ rounds – the complexity is dependent polynomially on $k$, and not at all on $n$.

• –

A $k$-path can be found in $\exp(k)$ rounds [35, 20] and a $k$-cycle in $\exp(k)n^{0.157}$ rounds [10] – the complexity is exponential in $k$, but the complexity in terms of $n$ is independent of $k$.

• –

An independent set of size $k$ can be found in $O(n^{1-2/k})$ rounds and a dominating set of size $k$ in $O(n^{1-1/k})$ rounds – the complexity in terms of $n$ is dependent on $k$.

Compare this to what we know from the centralised setting:

• –

Vertex cover, $k$-path and $k$-cycle are all fixed-parameter tractable problems: they can be solved in time $\exp(k)\operatorname{poly}(n)$. However, vertex cover admits a polynomial kernel [9, 14] – intuitively, this means that vertex cover instances can be compressed to size $\operatorname{poly}(k)$ in polynomial time***We refer to the recent book by Cygan et al. [14] for the formal definition of a kernel, as well as detailed discussion of the topic. – while the other two do not [6].

• –

By contrast, parameterised versions of independent set and dominating set are W[1]-hard and W[2]-hard, respectively, which strongly suggests that they are not fixed-parameter tractable, but rather require $n^{\Omega(k)}$ time to be solved [18].

8 Conclusions

Nondeterminism.

As a major open question, we highlight the lack of separation between constant-round deterministic and nondeterministic congested clique. It seems reasonable to conjecture that

[TABLE]

but it is not clear how we should approach proving such separation. Indeed, it would be interesting even if we could prove this conditional on a centralised complexity assumption, such as $\text{P}\neq\text{NP}$.

$\nclique(1)$ as an LCL analogue.

As we noted before, the class $\nclique(1)$ plays a similar role in the congested clique to the class LCL of locally checkable labellings that been in the focus of recent complexity-theoretic work in the \local model. Note that here we refer to LCL problems in the original sense of Naor and Stockmeyer [48], that is, class LCL consists of search problems such as 2-colouring, sinkless orientation and maximal independent set, where a valid output can be verified in constant rounds. By contrast, work on local decision often uses LCL to refer to the corresponding labelling verification problems, such as verifying a valid colouring of a graph [23, 28].

Similarly to the LCL problems, the class of $\nclique(1)$-labelling problems on labelled graphs is a natural class of search problems on the congested clique. We define an $\nclique(1)$-labelling problem $L$ as a set of pairs $(G,z)$, where $G$ is an input graph with edge and node labels of $O(\log n)$ bits, $z$ is an output labelling, and the membership $(G,z)\in L$ is decidable in constant rounds. Given an input graph, the computational task is to output a label $z_{v}$ for each node $v$ such that $(G,z)\in L$, or reject if such labelling does not exist. This class captures many natural graph problems of interest, but we do not have lower bounds for any problem in this class.

Randomness.

In this work, we have focused on deterministic and nondeterministic computation; however, there are problems in the congested clique model where the best randomised upper bounds are significantly better than the best deterministic upper bounds, e.g. minimum spanning tree [45, 27]. Thus, a possible extension of the present work is to study the randomised complexity landscape of the congested clique. Indeed, the counting arguments of Applebaum et al. [1] extend to randomised protocols. Likewise, Theorem 4 implies that there are problems that cannot be solved in $O(S(n))$ rounds with one-sided Monte Carlo algorithms, but can be solved in $O(T(n))$ rounds deterministically for $S(n)=o(T(n))$, as the Monte Carlo algorithm can be converted to a nondeterministic algorithm.

Acknowledgements.

This work was supported in part by the Academy of Finland, Grant 285721. We thank Alkida Balliu, Parinya Chalermsook, Magnús M. Halldórsson, Juho Hirvonen, Petteri Kaski, Dennis Olivetti and Christopher Purcell for comments and discussions.