Abstract 1 Introduction 2 Preliminaries 3 Density Properties of Random Graphs 4 Lower Bound for Cutting Planes 5 Lower Bound for Bounded Depth Resolution over Parities 6 Lower Bound for Randomized Communication References

Average-Case Hardness of Binary-Encoded Clique
in Proof and Communication Complexity

Susanna F. de Rezende ORCID Lund University, Sweden    David Engström ORCID Lund University, Sweden    Yassine Ghannane ORCID University of Copenhagen, Denmark
Lund University, Sweden
   Duri Andrea Janett ORCID University of Copenhagen, Denmark
Lund University, Sweden
   Artur Riazanov ORCID EPFL, Lausanne, Switzerland
Abstract

We study the average-case hardness of establishing that a graph does not have a large clique in both proof and communication complexity. We show exponential lower bounds on the length of cutting planes and bounded-depth resolution over parities refutations of the binary encoding of clique formulas on randomly sampled dense graphs. Moreover, we show that the randomized communication complexity of finding a falsified clause in these formulas is polynomial.

Keywords and phrases:
proof complexity, communication complexity, cutting planes, bounded-depth resolution over parities, clique problem, average-case hardness, binary encoding
Category:
Track A: Algorithms, Complexity and Games
Funding:
Susanna F. de Rezende: Received funding from the Knut and Alice Wallenberg grant KAW 2023.0116, ELLIIT, and the Swedish Research Council grant 2021-05104.
David Engström: Received funding from the Knut and Alice Wallenberg grant KAW 2023.0116, ELLIIT, and the Swedish Research Council grant 2021-05104.
Yassine Ghannane: Supported by the Independent Research Fund Denmark grant 9040-00389B.
Duri Andrea Janett: Supported by the Independent Research Fund Denmark grant 9040-00389B.
Artur Riazanov: Supported by Swiss State Secretariat for Education, Research, and Innovation (SERI) under contract number MB22.00026.
Copyright and License:
[Uncaptioned image] © Susanna F. de Rezende, David Engström, Yassine Ghannane, Duri Andrea Janett,
and Artur Riazanov; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Computational complexity and cryptography
Related Version:
Full Version: https://arxiv.org/abs/2605.10941 [21]
Acknowledgements:
We would like to thank Dmitry Itsykson and Kilian Risse for insightful discussions. We also gratefully acknowledge that we have benefited greatly from being part of Basic Algorithms Research Copenhagen (BARC) environment financed by the Villum Investigator grant 54451.
Editors:
Sayan Bhattacharya, Danupon Nanongkai, Michael Benedikt, and Gabriele Puppis

1 Introduction

The k-Clique problem asks whether a given graph G contains a complete subgraph of size k. This is one of the classical 𝐍𝐏-hard problems [37]. Under the Exponential Time Hypothesis, solving k-Clique on an N-vertex graph requires time NΩ(k) [15], nearly matching the O(Nk) upper bound that can be obtained by simply checking all (Nk) possible subgraphs. Furthermore, it is 𝐍𝐏-hard to approximate the maximum size of a clique even within a factor N1ε [30, 53].

Showing unconditional super-polynomial lower bounds for k-Clique seems beyond the reach of current techniques, as it would immediately imply 𝐏𝐍𝐏. Thus, significant effort has been made to provide unconditional evidence for the hardness of k-Clique. The most direct evidence is hardness in restricted computational models. In circuit complexity, k-Clique was the first problem proven to require exponential-size monotone Boolean circuits [45]. In a later breakthrough, Rossman [47, 48] showed that the k-Clique problem is hard for monotone and bounded-depth circuits even on average.

1.1 Clique in Proof Complexity

Another type of evidence for hardness comes from propositional proof complexity, the study of the complexity of certifying, in various formal proof systems, that a given Boolean formula is a tautology or that it is unsatisfiable.

Proof complexity provides a perspective to analyze several algorithmic approaches to the k-Clique problem: If an algorithm rejects a k-Clique instance, the trace of its execution can be viewed as a certificate of the claim that the given graph does not contain a k-clique. This claim can be encoded as a CNF formula asserting that the graph does have a k-clique, and in this paper we study certificates of unsatisfiability, also called refutations, of this formula. Many classes of algorithms can be captured by propositional proof systems in this way: the core reasoning of state-of-the-art SAT-solvers is captured by resolution [4]; Gröebner basis algorithms by polynomial calculus [17]; the cutting planes methods in integer linear optimization by the cutting planes proof system [18]; and the Lassere hierarchy in semi-definite programming [40] by the sum-of-squares proof system.

Assuming the Nondeterministic Exponential Time Hypothesis [13], in every proof system the shortest refutation of k-Clique for some graph has length at least NΩ(k). On the other hand, unconditional lower bounds are only known for very restricted proof systems. Two encodings of the clique problem into CNF formulas are studied in the literature. The unary encoding uses N propositional variables to encode the ith vertex of the purported k-clique, for every i, while the more succinct binary encoding uses only logN variables to encode the same information in binary.

The following results are known about the unary encoding. For treelike resolution, there are NΩ(k) length lower bounds even on average with respect to the Erdős-Rényi graph distribution [7, 41]. The current best known results are analogous average-case bounds for regular resolution [2], and Sherali–Adams with bounded coefficients [20]. For general resolution, in the parameter range N5/6kN/3, an exp(NΩ(1)) average-case lower bound for dense graphs is known [3], and when k<N1/3, an average-case lower bound 2k1ε holds [43]. Improving this to an optimal NΩ(k) lower bounds is a long-standing open problem, see, e.g., [8, 11], even for worst-case instances. In particular, all known techniques for proving resolution lower bounds seem to fail for this task [2].

Weak proof systems can, however, be very sensitive to the choice of encoding, as was shown in, e.g., [19]. This is also the case for the binary encoding of clique, where strong lower bounds are known for resolution: There is an NΩ(k) average-case lower bound for resolution [42], which was further extended to s-DNF resolution, for s=o(loglogn), at the cost of some loss in the exponent of the bound depending on s [19].

1.2 Our contributions

We prove new lower bounds for k-Clique in three settings. Our first result is that the binary encoding of k-Clique requires exponential proof length in cutting planes. Prior to our work, nothing was known about the hardness of k-Clique for cutting planes, even in the treelike setting.

Theorem 1.1 (Informal).

For N-vertex graphs G sampled from the Erdős-Rényi distribution with appropriate edge density, any cutting planes refutation of the binary-encoded clique formula must have length at least 2NΩ(1).

We consider next the frontier proof system resolution over parities (Res()) [35], which recently received a lot of attention [10, 1, 23, 9, 12], particularly following the breakthrough of [22]. Lower bounds are only known for restricted versions of this system, and in particular, nothing is known about the hardness of refuting k-Clique in Res(). We prove the following length lower bound on Res() proofs of bounded depth.

Theorem 1.2 (Informal).

For N-vertex graphs G sampled from the Erdős-Rényi distribution with appropriate edge density, any Res() refutation of the binary-encoded clique formula in depth m1.5ε, where m is the number of variables in the formula, must have length at least 2NΩ(1).

Lastly, we study the communication version of the problem. Two parties are both given partial information about the members of a purported k-clique in a graph G. Again, G does not actually have a k-clique, and the parties must find a missing edge in the purported clique, while communicating as few bits as possible. This corresponds to finding a falsified clause in the binary-encoded clique formula, if the partial information consists of the bits encoding the purported clique members. We prove the following lower bound in the setting where the parties have access to shared randomness.

Theorem 1.3 (Informal).

For N-vertex graphs G sampled from the Erdős-Rényi distribution with appropriate edge density, the randomized communication cost of finding a falsified clause in the binary-encoded clique formula is NΩ(1).

Randomized communication complexity remains the most versatile tool for obtaining lower bounds for treelike cutting planes. Most of the known lower bounds are obtained via this connection [33, 5, 32, 28, 34]. Treelike cutting planes is a natural next candidate for proving clique lower bounds in the unary encoding.

There is, however, a growing evidence that the randomized communication model is too strong to give strong lower bounds for k-Clique. If, for example, the density of Erdős-Rényi graph is constant, then Alice and Bob can randomly sample a pair of indices of their nodes and verify whether or not the corresponding pair is connected with an edge. Thus, we can only hope for a non-trivial lower bound for the dense setting of k-Clique. Another weakness of the communication approach to k-Clique lower bounds was established by Jukna [36], who observed that for a bipartite version of the unary k-Clique, the corresponding problem has a O(logn)-cost deterministic communication protocol.

Given these drawbacks, we view Theorem 1.3 as an indication of some hope for the communication approach to k-Clique lower bounds: at least in the dense binary setting the barriers above do not apply. Moreover, Theorem 1.3 (qualitatively) generalizes the main theorem in [51] with a much simpler proof.

1.3 Discussion

Our contributions can be viewed as matching the lower bounds known for the weak version of binary pigeonhole principle (BPHP) with bounds for the binary encoding of k-Clique. In fact, all three bounds are obtained by adapting the techniques previously used to prove lower bounds for the weak binary pigeonhole principle [6, 12], or by adapting extensions of such techniques [25, 51]. Is there a more general principle behind our results, i.e., is there an explicit reduction from BPHP to average-case k-Clique? We know such a reduction exists in the worst case – indeed, the BPHP is a special case of the binary-encoded k-Clique– but in the average case such reductions are not known.

One concrete direction would be to prove

lower bounds on k-Clique in the treelike version of Th(2), the generalization of cutting planes refutations to degree-2 inequalities. Only the strong BPHP is known to be hard for this system [34], and the proof of this fact uses global symmetries of the formula. Therefore, it is unclear how to apply the technique to k-Clique for an Erdős-Rényi random graph, since the latter is unlikely to have symmetries. Does it fail because of the particular technique, or is the strong version of BPHP crucially easier than the weak one?

Open Problem 1.4.

Suppose weak BPHP requires exponential tree-like Th(2) refutation. Show that the binary encoding of k-Clique does as well.

Another interesting direction to extend our lower bounds is to the Ramsey principles [42]. A graph is c-Ramsey if it has neither a clique nor an independent set of size clogn. The Ramsey principle formulas defined in [42] encodes in binary the claim that a given graph is c-Ramsey. For resolution, an asymptotically optimal nΩ(logn) length lower bound was proven in [42]. We ask the same question for cutting planes and Res().

Open Problem 1.5.

Prove that the Ramsey principles are hard for cutting planes or bounded-depth Res().

In particular, matching the bounds known for resolution would require improving our lower bounds and extending them to randomly sampled graphs for a broader range of parameters, specifically to graphs which are not as dense.

As discussed above, for sparse graphs there is always a randomized communication protocol solving k-Clique in binary or unary encoding. However, we can weaken the communication model so it still captures tree-like cutting planes. One such model is a deterministic communication protocol with a Greater Than oracle, i.e., the players can compare real numbers at unit cost.

This model is shown to be significantly weaker than randomized communication [14, 16, 26]. Can we still solve k-Clique over a sparse graph?

Open Problem 1.6.

Suppose that Π is a deterministic communication protocol with a Greater Than oracle. Can Π solve k-Clique for Erdős-Rényi graphs of constant sparsity with O(logn) cost?

1.4 Techniques

We give a brief technical overview of our proofs. Notably, all of our techniques are to some extent based on previous work proving lower bounds on BPHP.

Cutting Planes.

Theorem 1.1 is proved via a bottleneck counting argument [29]. The approach is based on an adaptation of this framework to cutting planes due to Sokolov [50], that was also subsequently refined by Beame and Whitmeyer [6] to prove cutting planes BPHP lower bounds. It leverages a connection between cutting planes proofs and triangle-DAG protocols, saying that small cutting planes refutations of some formula imply small protocols for a related search problem. Informally, the main idea is to then define a partial function μ that maps inputs of the search problem to nodes of the protocol. Intuitively, μ measures progress made by the protocol at some step. By giving a lower bound on the size of the domain of μ and an upper bound on the maximum number of inputs mapped to each node, we establish a size lower bound on the protocol and thus on cutting planes refutations of our starting formula. The twist of our approach is to show that a certain combinatorial property of graphs related to the density of neighborhoods is sufficient to construct such a partial map μ. In particular, dense random graphs asymptotically almost surely exhibit such properties.

Bounded depth 𝐑𝐞𝐬().

Recent progress has led to a BPHP lower bound for depth-m1.5ε Res() [12], based on a notion of closure for a set of linear forms [22], and the random walks with restarts framework [1]. This framework works by performing a random walk on the proof in a top-down manner. If one can bound below the probability that this walk proceeds for many steps without reaching a falsified clause, and assuming that the given refutation is small, some node in the proof must be visited by many random walks, and thus the rank of the linear system at that node must be low. Using the notion of closure, one can then fix only few variables to satisfy that system, which allows repeating this procedure, walking further down the proof, and eventually establishing a depth lower bound.

Adapting the framework to binary-encoded clique formulas, finding a falsified clause is the same as identifying a non-edge in the underlying graph. Our random walk then mimics a uniformly drawn input while maintaining a partial assignment of the clique members to vertices without non-edges between them. We ensure this by always staying within the common neighborhood of previously assigned vertices, and find that the walk can proceed for many steps with sufficient probability. Additionally, we use concentrations bounds on the number of common neighbors of a set of vertices to show that, in the right parameter regimes, after fixing variables, the remaining instance is similar enough to a smaller instance of the original problem, thus allowing us to restart the random walk.

Randomized communication.

Theorem 1.3 (qualitatively) generalizes the BPHP lower bound of Yang and Zhang [51]. They used query-to-communication lifting machinery from [27] to essentially reduce the communication lower bound to a corresponding decision tree lower bound. The proof in [51] is quite involved due to a white-box use of the lifting machinery. Later, [25] proved a structural theorem that allows a black-box proof of the main result in [51], and this theorem was recently extended and used in [46] to get a lower bound for the clause-search problem for random O(logn)-CNFs. We show how to apply this framework to the clique problem.

1.5 Outline of This Paper

The rest of this paper is organized as follows. In Section 2 we give some preliminaries and in Section 3 we introduce some useful combinatorial properties of random graphs. In Section 4 we present our result for cutting planes and in Section 5, we show our theorem for Res(). Finally, we prove our lower bound for randomized communication in Section 6. For complete proofs of our results, we refer to the full version of this paper [21].

2 Preliminaries

We use the symbol to denote a disjoint union of sets. We write {1,,n} as [n], where n+. Let 𝒙A denote 𝒙 uniformly sampled from a set A. We say that an event occurs asymptotically almost surely (a.a.s) if it occurs with probability 1o(1) as n. We will also need the following special case of the Chernoff bound:

Theorem 2.1 (Multiplicative Chernoff bounds).

Let 𝐗1,,𝐗n be independent {0,1}-valued random variables, and let 𝐗=i=1n𝐗i, μ=𝔼[𝐗]. Then, for 0δ1,

Pr[𝑿(1+δ)μ]exp(μδ23),
Pr[𝑿(1δ)μ]exp(μδ22).

2.1 Graph Theory

Let G be a graph over k blocks V(G)=V1Vk, with |Vi|=n for all i[k]. In everything that follows, let us assume, without loss of generality, that n is a power of 2. For uV(G), let B(u)[k] denote the index of the block that contains u, and for every set of vertices UV(G), we define B(U){B(u)uU}. For a subset UV(G) we use N(U,i) to denote the common neighborhood of U at block i. For a set of blocks I[k], we then use N(U,I)=iIN(U,i). For all i[k], every uVi can be identified with an integer in [n], and we denote its binary representation by 𝖻𝗂𝗇(u)=u1ulog(n).

The natural distribution for which k-Clique is conjectured to be hard is an Erdős-Rényi distribution. The p-biased Erdős-Rényi distribution 𝒢(n,p) is defined by sampling an n-vertex graph with each of the (n2) edges present with probability p independently of the other edges. The parameter p that conjecturally makes finding a k-clique in 𝑮𝒢(n,p) hard is at the threshold p where for a lower p<p the graph 𝑮 does not have a k-clique a.a.s., and for a higher p>p it does have a k-clique a.a.s.. By looking at the expected number of k-cliques in 𝑮, one can conclude that the threshold value is Θ(n2/(k1)).

We also define the k-partite version of the same distribution: For a fixed partition of the nodes, 𝒢(n,p,k) is sampled from by first sampling 𝑮𝒢(nk,p) and then intersecting 𝑮 with a complete k-partite graph with n nodes in each part.

2.2 Proof Complexity

We next recall some basic notions from proof complexity; see, e.g., [38, 11] for a more thorough exposition. A Boolean variable x or its negation x¯ is called a literal, and a disjunction of literals over pairwise disjoint variables C=1k is called a clause. A CNF formula is a conjunction of clauses F=C1Cm. We sometimes call the clauses of F axioms, and denote the set of variables occurring in F as Vars(F).

Cutting Planes.

The cutting planes proof system [18] operates on systems of linear inequalities. In its syntactic form, it derives new constraints from previously derived ones by linear combination and division with rounding. Since our lower bounds also apply to it, we define the stronger semantic version of the proof system, which subsumes all usual cutting planes derivation rules.

Let Axb be a system of linear inequalities, where Am×n and bm. A semantic cutting planes refutation of Axb is a sequence of linear inequalities {dixci}i[L], where din and ci, such that the following hold: The final inequality is the trivially false 01, and for every i[L], the inequality dixci is part of the linear system Axb, or there are j,k<i such that dixci follows from djxcj and dkxck by semantic deduction. That is, from inequalities djxcj and dkxck, one can derive any inequality dixci for which it holds that any x{0,1}n satisfying both djxcj and dkxck satisfies dixci. The length of a semantic cutting planes refutation is the number L of inequalities appearing in the sequence.

The following translation enables us to consider cutting planes refutations of unsatisfiable CNF formulas. For every propositional variable x, we add the constraints 0x and x1. For a clause C=iIxijJxj¯, we add the inequality iIxi+jJ(1xj)1.

Resolution over Parities.

The resolution over parities proof system [35], which we refer to as Res(), operates on linear equations over 𝔽2. Let x1,,xn be variables taking values in 𝔽2. A linear form is a polynomial i=1naixi, where all ai𝔽2. Taking a linear form f and a𝔽2, we get a linear equality f=a. A disjunction of linear equations C=i=1m(fi=ai) is called a linear clause. Sometimes, it is convenient to view a linear clause as a negation of a linear system, i.e., C=¬i=1m(fi=ai+1). Note that a propositional clause C=iIxijJxj is a special case of a linear clause: we can write C=iI(xi=1)jJ(xj=0).

Given a CNF formula F, a Res() refutation of F is a sequence of linear clauses {Ci}iL ending with the empty clause and where every clause either belongs to F or was derived from two previous clauses using one of the following two derivation rules: The resolution rule

C(x=1)D(x=0)CD

or the semantic weakening rule, which allows to derive from a linear clause C any linear clause D that semantically follows from it, i.e., such that any x{0,1}n satisfying C also satisfies D.

The length of a Res() refutation is the number L of linear clauses appearing in it. The depth d of a Res() refutation is the largest number of resolution steps among all the paths from axioms to the empty clause in the refutation. The proof system depth-d Res() is the subsystem of Res() consisting only of refutation of depth at most d, where d can depend on the number of variables n.

Shape-DAGs.

We will also work with the top-down definition of the proof systems defined above, namely, triangle- and affine-DAGs solving total search problems. A total search problem is defined as a relation S×𝒪 over finite sets of inputs and outputs 𝒪, such that for every input x there is an output o𝒪 with (x,o)S. Let S1(o)={x(x,o)S}.

For a given unsatisfiable CNF formula F=C1Cm, we consider the falsified clause search problem SearchF: Given an assignment x{0,1}n to the variables of F, output i[m], such that the clause Ci is falsified under x. In detail, (x,i)SearchF if and only if Ci(x)=0.

Definition 2.2 ([24]).

Let S×𝒪 be a total search problem, 2. We call the elements of shapes. A shape-DAG (-DAG) solving S is a rooted directed acyclic graph D of fan-out at most 2, where each node vD is labeled by a shape Fv such that

  1. 1.

    the root rD is labeled by Fr=;

  2. 2.

    for a node v with children u,w, FvFuFw;

  3. 3.

    and for every leaf , there is an output o𝒪 such that FS1(o).

The depth of D is the longest root-to-leaf path in D; its length is the number of nodes in it.

Given a bipartite domain X×Y, a triangle TX×Y is a set which can be written as T={(x,y)X×YaT(x)bT(y)}, for some aT:X, bT:Y. A triangle-DAG is a shape-DAG where the shapes are all triangles. To consider triangle-DAGs for the falsified clause search problem, we split the variables of F into two parts and view {0,1}n as the corresponding product. Let SearchFX,Y(X×Y)×[m] denote {((x,y),i)Ci(x,y)=0}. As the following proposition states, lower bounds from cutting planes follow from lower bounds for triangle-DAGs.

Proposition 2.3 ([49, 31]).

A semantic cutting planes refutation of a given CNF formula F yields, for any partition of the variables Vars(F)=XY, a triangle-DAG solving SearchFX,Y of the same length.

An affine subspace-DAG is a shape-DAG where the shapes are affine subspaces of the domain 𝔽2n. An affine-DAG is an affine subspace-DAG D, where every non-leaf node vD has two outgoing edges, (v,w) and (v,w), labeled Pv=0 and Pv=1, respectively. In addition, for the linear systems Ψv,Ψw,Ψw corresponding to the affine subspaces labeling v,w,w, it holds that Ψw is implied by Ψv(Pv=0) and Ψw is implied by Ψv(Pv=1). Similar to Proposition 2.3, lower bounds for affine-DAGs can be used to derive lower bounds for Res(), as stated formally below.

Proposition 2.4 ([22]).

A Res() refutation of a given CNF formula F yields an affine-DAG solving SearchF of the same length and depth.

2.3 Binary Encoding of Clique Formula

We encode the claim that a graph G has a clique of size k. We use the so-called binary encoding [42, 19], where for every i[k], there are log|V| variables to point out the ith member of a purported k-clique. For a propositional variable x, we use the notation (x0) to denote the literal x, and (x1) to denote the literal x¯.

Assume that the vertices vi, vj and v are represented as vi,1,,vi,log|V|, vj,1,,vj,log|V|, and v1,,vlog|V| in binary, respectively. Let xi,a, where i[k] and a[log|V|], be propositional variables. The formula 𝖡𝖢𝗅𝗂𝗊𝗎𝖾(G,k) consists of the clauses

a=1log|V|(xi,avi,a)a=1log|V|(xj,avj,a), vivjV,ij[k]:{vi,vj}E, (1)
a=1log|V|(xi,ava)a=1log|V|(xj,ava), vV,ij[k]. (2)

The clauses (1) are called edge axioms, and the clauses (2) are called functionality axioms. The edge axioms encode that two non-neighbors are not simultaneously chosen as clique members, while the functionality axioms ensure that all clique members are distinct.

Block encoding.

We next consider a version of the binary clique formula, where cliques are required to have a “block-respecting” structure. That is, we partition the vertices of G into k blocks of equal size V=V1Vk. We then encode the claim that G has a k-clique with one vertex from every block. Such a clique is also called transversal.

Assume that vi is represented as vi,1,,vi,logn and vj is represented as vj,1,,vj,logn. Let xi,a, where i[k] and a[logn], be propositional variables. Then the formula 𝖡𝖢𝗅𝗂𝗊𝗎𝖾block(G,k) consists of the clauses

a=1logn(xi,avi,a)a=1logn(xj,avj,a),viVi,vjVj:{vi,vj}E. (3)

The clauses (3) are edge axioms, and again, encode that for (vi,vj)E, “vi is not the clique member from block i or vj is not the clique member from block j”. Note that in the block encoding, we do not need functionality axioms, since the clique members are from distinct blocks by definition.

The following lemma shows that lower bounds for 𝖡𝖢𝗅𝗂𝗊𝗎𝖾block(G,k) imply lower bounds for 𝖡𝖢𝗅𝗂𝗊𝗎𝖾(G,k). Therefore, for the rest of the paper, we will only consider the block encoding.

Lemma 2.5 ([3]).

Let k+ and G be a graph. If there is a cutting planes (respectively, Res()) refutation of 𝖡𝖢𝗅𝗂𝗊𝗎𝖾(G,k) of length L and depth d, then there is a cutting planes (respectively, Res()) refutation of 𝖡𝖢𝗅𝗂𝗊𝗎𝖾block(G,k) of length at most L and depth at most d.

While the statement in [3] is for the unary encoding of clique formulas and the resolution proof system, its proof can be modified to obtain the lemma above. Indeed, one can obtain 𝖡𝖢𝗅𝗂𝗊𝗎𝖾block(G,k) from 𝖡𝖢𝗅𝗂𝗊𝗎𝖾(G,k) by applying a random restriction, and both cutting planes and Res() are closed under random restrictions.

2.4 Communication Complexity

In this paper, we consider randomized (public coin) two party number-in-hand communication complexity. We quickly define the model and refer to [39, 44] for details.

Two players, Alice and Bob, are given inputs xX and yY, respectively. To solve a search problem S(X×Y)×𝒪, they need to find o𝒪 such that ((x,y),o)S, while communicating as few bits as possible. A deterministic communication protocol Π for S is a rooted binary tree as follows. Every internal node vΠ determines who is going to speak, and the spoken bit, which is a function of v and the input x or y (x if Alice speaks, y otherwise), determines which child of v the computation moves to. Every leaf Π is labeled by o𝒪, such that ((x,y),o)S. We define a randomized communication protocol Πr for S as a distribution over deterministic communication protocols, such that the computation is correct with constant probability. The cost of a deterministic protocol |Π| is the maximum, over all inputs, of the number of bits communicated. The cost of a randomized protocol |Πr| is the maximum cost among the deterministic protocols in the distribution.

We study the communication complexity of Search𝖡𝖢𝗅𝗂𝗊𝗎𝖾(G,k)X,Y, where we split the variables of 𝖡𝖢𝗅𝗂𝗊𝗎𝖾(G,k) such that Alice and Bob each get half of the bits from every clique member, i.e., X=Y=({0,1}log|V|/2)k, and denote this problem by 𝖡𝖢𝗅𝗂𝗊𝗎𝖾cc(G,k). As in the proof complexity setting, a version of Lemma 2.5 applies and we may prove lower bounds for the block encoding, i.e., for 𝖡𝖢𝗅𝗂𝗊𝗎𝖾blockcc(G,k).

Furthermore, we will make use of the characterization of randomized communication cost in terms of distributional communication complexity [52]: To prove a lower bound on the randomized communication cost, it is enough to prove a lower bounds on deterministic protocols with constant error probability for any input distribution. In particular, we will prove a lower bound for the uniform distribution.

3 Density Properties of Random Graphs

In the subsequent sections, we prove hardness results for graphs satisfying some combinatorial property related to the density of their neighbor sets. In this section, we define the properties we consider and verify that random graphs satisfy them.

Definition 3.1.

Given s,k,n>0, we say a graph G over k blocks of size n is s-almost-complete if for every i,j[k], ij, and xi,yi,xjΣ, where Σ={0,1}log(n)/2, there are at most s different yj such that there is no edge between (xi,yi) and (xj,yj) in G.

Random dense graphs a.a.s. satisfy this property for an appropriate value of s.

Lemma 3.2.

For p[0,1], if 𝐆𝒢(n,p,k), then, a.a.s., 𝐆 is max(2n(1p),9e2log(kn))-almost-complete.

The following property, which appeared in [20], is about the common neighborhood of small subsets of vertices. Similar definitions have also appeared in [3, 7, 2].

Definition 3.3.

Given α,β,R,k,n>0, we say a graph G over k blocks of size n has (α,β,R)-bounded common neighborhoods if every SV(G) of size at most R and every block i[k]B(S) satisfies

N(S,i)(1±β)α|S|n.

For random graphs, this property expresses that the size of common neighborhoods of small sets behaves approximately as expected.

Lemma 3.4.

For 0δ<1, p1nδ, β18log(kn)n1δ, if 𝐆𝒢(n,p,k), then, a.a.s., 𝐆 has (p,β,nδ)-bounded common neighbors.

4 Lower Bound for Cutting Planes

This section is devoted to proving our first result, stated formally below.

Theorem 4.1.

For any integers n and k, and for any real p[0,1] if 𝐆 is a graph sampled from 𝒢(n,p,k) then a.a.s. semantic cutting planes requires length

exp(Ω(min(11p,n1/4log(kn))))

to refute 𝖡𝖢𝗅𝗂𝗊𝗎𝖾block(G,k).

We quickly verify that Theorem 1.1 follows from the theorem stated above. For p=1n1/3 and k=n, we have N=nk=n2, and the bound in Theorem 4.1 becomes 2Ω(N1/12), and it applies to 𝖡𝖢𝗅𝗂𝗊𝗎𝖾(G,k) by Lemma 2.5. Also note that at this edge density, and with k=n, the formula 𝖡𝖢𝗅𝗂𝗊𝗎𝖾(G,k) is a.a.s. unsatisfiable, meaning the bound is non-trivial.

By Proposition 2.3 and Lemma 3.2, we obtain the above theorem by proving a size lower bound on triangle-DAG protocols solving the corresponding search problem, for the variable partition introduced in the preliminaries and over almost-complete graphs.

Theorem 4.2.

Let s,k,n>0, q=n1/4/8s and G over k blocks of size n and s-almost-complete then triangle-DAG protocols solving Search𝖡𝖢𝗅𝗂𝗊𝗎𝖾(G,k)X,Y require size 2q2.

To see that Theorem 4.1 follows from Theorem 4.2 recall that, by Lemma 3.2, 𝑮𝒢(n,p,k) is, a.a.s., s-almost-complete for s=max(2n(1p),9e2log(kn)). Applying Theorem 4.2 to such an s-almost-complete graph we have that

q=n1/48s=Ω(n1/4max(n(1p),log(nk)))=Ω(min(11p,n1/4log(kn)))

from which Theorem 4.1 follows. Before we present the proof of this theorem, let us establish some additional notation. Let G be a graph over k blocks each of size n with V(G)=V1Vk. Recall that for X=Y=Σk, where Σ={0,1}log(n)/2, every x=(xi)1ikX, y=(yi)1ikY, (xi,yi) uniquely identifies a vertex in the i-th block. Given uVi and vVj, where ij, we define Ru,vX×Y to be the rectangle consisting of inputs (x,y)X×Y verifying (xi,yi)=u and (xj,yj)=v, that is, Ru,v{xXxi=u1ulog(n)/2xj=v1vlog(n)/2}×{yYyi=ulog(n)/2+1ulog(n)yj=vlog(n)/2+1vlog(n)}. Let be the set of all rectangles Ru,v where u and v are non-adjacent. Additionally, for any R, we define B(R) to be the set of vertices {u,v} such that R=Ru,v. Note that corresponds to the collection of sets of inputs corresponding to pre-images of solutions of Search𝖡𝖢𝗅𝗂𝗊𝗎𝖾(G,k)X,Y.

For a triangle TX×Y and an input xX, let Tx denote the slice ({x}×Y)T. We define the block width [50, 6] of x in T, denoted 𝖻𝗐(T,x), to be the minimum number of unique blocks mentioned in a covering of Tx by rectangles from , i.e

𝖻𝗐(T,x)=minSTxRSS|RSB(R)|.

When T is evident from context, we simply call this the block width of x.

The proof of the main theorem is based on a bottleneck counting argument following a framework that appeared in previous work [29, 50, 6], adapted to our setting. We construct a partial function μ:XYV(Π), defined in Algorithm 1 for which we prove two properties. First, we show that a substantial fraction of all inputs must be assigned by μ to some node. We then prove that no single node can have many inputs assigned to it and conclude that there must be many nodes in the protocol.

Informally, for a threshold q, the map μ is constructed by traversing the nodes of the triangle-DAG in topological order from the leaves to the root and, whenever we encounter a zXY such that 𝖻𝗐(T,z)>q, we let μ map z to that node in Π and remove z from all nodes not yet considered.

Algorithm 1 Definition of μ.

The first property of μ is straightforward.

Lemma 4.3.

For qn1/4/s and G s-almost-complete, then μ assigns at least |XY|/4 elements.

By definition of a triangle-DAG, the following claim is immediate from Algorithm 1.

Claim 4.4 ([50, 6]).

During the execution of Algorithm 1, for every u in the triangle-DAG Π and zXY, the block width of z in Tu is at most 2q.

We now state the main lemma of this section.

Lemma 4.5.

Let qn1/4/8s and G s-almost-complete. For all uV(Π), μ maps at most |XY|2q elements of XY to u.

Assuming this lemma, Theorem 4.2 follows immediately.

Proof of Theorem 4.2.

By Lemma 4.3, at least |XY|/4 elements from |XY| are assigned to some vertex in Π by μ. On the other hand, Lemma 4.5 bounds the number of zXY assigned to any one vertex in Π. Put together, we conclude that there must be at least |XY|/4|XY|2q=2q2 vertices in Π.

Algorithm 2 Definition of a tree 𝒯 of potential coverings of Tx.

The rest of this section is dedicated to the proof of Lemma 4.5. Fix uV(Π). Our goal is to show that the number of elements xX assigned by μ to u is at most 2q|X|. By symmetry, we have the same bound on the number of such yY and the lemma follows.

To obtain this bound, we run Algorithm 2 on T=(X×Y)Tu, with X and Y taking their values right before processing node u in Algorithm 1. From this, we obtain a tree 𝒯 with the inner nodes labeled by triangles that are subsets of T not covered yet, and with the edges labeled by rectangles in . It satisfies the following properties:

  1. 1.

    First, the set of edge label rectangles cover T, i.e., for every (x,y) in T, there is an edge labeled Ru,v s.t. (x,y)Ru,v.

  2. 2.

    Second, if (x,y)T is in triangle T1 at node t1, and (x,y) is in triangle T2 at node t2, then either t1 is a descendant of t2 or vice-versa, and (x,y) is in every triangle labeling nodes between t1 and t2.

  3. 3.

    Furthermore, for every x, there is a unique path from the root to some leaf t in T such that {Ru,vRu,v edge labels of path} covers Tx.

For any node t of 𝒯 whose path from the root is labeled by R=(R1,R2,,R), the block-depth of t is the number of unique blocks mentioned by the rectangles in R. Then, the block-depth of an input xX is the maximal block-depth over nodes that x is consistent with.

Note that for every leaf t in 𝒯, property 3 above implies that the block-depth of t is an upper bound on bw(Tu,x) for any xX consistent with t. To prove the lemma, we thus only have to bound the number of elements xX that are consistent with leaves of block-depth greater than q. Before doing so, we observe a claim that will allow us to simplify 𝒯.

Claim 4.6.

Let t be a vertex in V(𝒯). If t has out-degree greater than one, then every child of t has block-depth greater than the block-depth of t.

We can now modify 𝒯 by removing every vertex in 𝒯 with a child of the same block-depth and replacing it with that child. This leaves us with a new tree 𝒯 where every path from the root to a leaf has strictly increasing block-depth. Note that the block-depth of an input xX is the same in 𝒯 as in 𝒯. In order to conclude the proof, it is now sufficient to note the following straightforward claim.

Claim 4.7.

The number of vertices at block-depth d in 𝒯 is at most (n2)d.

Given this claim we can conclude that Lemma 4.5 holds. Indeed, every xX mapped by μ must be consistent with a leaf in 𝒯 of block-depth larger that q, and since block-depth can only increase by 1 or 2 from parent to child in 𝒯, every xX consistent with a leaf of block-depth greater that q is consistent with a vertex of block-depth exactly q+1 or q+2. Furthermore, only |X|/n inputs xX can be consistent with a vertex tV(𝒯) at block-depth since all xX consistent with t coincide on the blocks mentioned on the path to t. From Claim 4.7, it follows that at most

(n2)q+1|X|(n)q+1+(n2)q+2|X|(n)q+22q|X|

elements of |X| are mapped to u by μ. By symmetry the same holds for |Y| and the lemma follows.

5 Lower Bound for Bounded Depth Resolution over Parities

In this section, we prove our second result, stated formally below.

Theorem 5.1.

Let γ>0 be a constant, let p[1nγ,1] and k be functions of n, where k<exp(no(1)) and let 𝐆𝒢(n,p,k). Then asymptotically almost surely, for any Res()-refutation of depth D and size S that refutes 𝖡𝖢𝗅𝗂𝗊𝗎𝖾(G,k) it must hold that

DlogS{Ω(n3γ/2), if γ<1/2Ω(n1+γ2logkn), if 1/2γ<1Ω(n1ε), if γ1

for any constant ε>0.

We start by verifying that Theorem 1.2 from the introduction follows from this theorem. Let γ=1/3 and k=n1/3+ε/100 for ε>0 given in Theorem 1.2. Then N=kn=n4/3+ε/100, and 𝖡𝖢𝗅𝗂𝗊𝗎𝖾(G,k) has m=klogN=O(n1/3+ε/100logn). So, if

Dm1.5ε=O(n(1/3+ε/100)(1.5ε)log1.5εn)=o(n3γ/2ε/4),

we have that logS=Ω(poly(n))=Ω(poly(N)). Therefore, sampling 𝐆 using p=n1/3 and k=n1/3+ε/100 a.a.s. yields an unsatisfiable formula requiring size S=2NΩ(1) to refute in depth at most m1.5ε, as required.

To prove Theorem 5.1 we prove the slightly more general statement below.

Theorem 5.2.

Let α>0, 0<β<1/300 be real numbers and let R1/100(1α) be a positive integer. Given a graph G with (α,β,R)-bounded common neighborhoods and a Res()-refutation of 𝖡𝖢𝗅𝗂𝗊𝗎𝖾(G,k) of depth D and size S, it must hold that

DlogSΩ(Rmin(R,1/β))

The remainder of this section is dedicated to the proof of this theorem. But first we show that Theorem 5.1 follows from Theorem 5.2.

Proof of Theorem 5.1.

Let α=p1nγ. We choose δ differently according to γ. Let δ=γ if γ<1, otherwise, let δ=1ε. Now let R=nδ/100 and let β=18log(kn)n1δ. By Lemma 3.4, 𝑮 will asymptotically almost surely have (α,β,R)-bounded common neighbourhoods. Note that R1/100(1α) and so we can apply Theorem 5.2 and obtain the lower bound

DlogSΩ(Rmin(R,1/β)).

We split the analysis into cases depending on γ. If γ<1/2, note that 1/βnδ/2=nγ/2R for large enough n and k<exp(no(1)), and therefore we get the first lower bound, that is, DlogSΩ(nγnγ/2)=Ω(n3γ/2).

If γ1/2, note that 1/βn(1δ)/2nδ/2=10R for large enough n and using the assumption k<exp(no(1)). This implies that we get the bound

DlogSΩ(nγn1γ2lognk)=Ω(n1+γ2lognk)

for 1/2γ<1 and the bound

DlogSΩ(nδn1δ2lognk)=Ω(n1+δ2lognk)=Ω(n1ε/2lognk)Ω(n1ε)

for γ>1, where for the last inequality we assume n large enough and k<exp(no(1)).

The proof of Theorem 5.2 adapts the proof by Byramji and Impagliazzo [12] of a Res() size depth tradeoff for the BPHP. They do this by showing that in a small Res() refutation of BPHP, it is possible to repeatedly perform long random walks without reaching a sink.

5.1 Technical Lemmas and Definitions

Here we collect some technical preliminaries that are used only in this section. We start by recalling the notion of safe systems, introduced by [22].

We say that a set of linear forms F over variables xi,j({0,1}logn)[k] is dangerous if the number of distinct blocks from which variables appear in F is smaller than the size of F. If no subset of F is dangerous we say that F is safe. It turns out that safe sets have a very nice characterization making them nice to work with.

Lemma 5.3 ([22]).

Let L be a collection of k independent linear forms and M the corresponding coefficient matrix. V is safe if and only if we can pick k variables, no two from the same block, such that the corresponding columns in M are linearly independent.

To handle non-safe systems we use the notion of closure. The closure of F, Cl(F)[k] is defined as the minimal set (with respect to inclusion) of blocks such that F[Cl(F)] is safe, where F[S] denotes the set of linear forms F after setting variables belonging to a block in S to zero. It turns out that the closure is uniquely defined [22, Lemma 4.1]. In an abuse of notation we will, for a linear system Ψ, write Cl(Ψ) to refer to the closure of

Lemma 5.4 ([22]).

If F is a collection of linear forms, then |Cl(F)|+dim(F[Cl(F)])dim(F).

To assign variables in a way that satisfies linear systems, we need the concept of affine restrictions. A (block respecting) affine restriction ρ is a partial assignment that for some set F[k] sets all variables xi,j, i[k]F as an affine function of the unassigned variables xi,j, iF. In this paper all affine restrictions will be block respecting and will for brevity just be called affine restrictions. For a linear system Ψ we use Ψ|ρ to denote the system after substituting variables according to ρ.

We introduce the search problem NonEdgeMG({0,1}logn)[k]B(M)×(V(G)2), where M is some set of vertices of G such that vertices in M from distinct blocks in G always have edges between them. As input we are given an assignment to the blocks outside of the support of M such that every selected vertex lies in N(M,[k]B(M)). We are then asked to output two selected vertices not connected by an edge. When the graph G is clear from context, we simply write NonEdgeM. Observe that NonEdgeMG is equivalent to Search𝖡𝖢𝗅𝗂𝗊𝗎𝖾(G,k|B(M)|) where G is the subgraph of G induced by N(M,[k]B(M)). Thus, any affine-DAG solving the falsified clause search problem also solves NonEdgeG, as such it is enough to find lower bound for this problem. The following lemma was stated in [12] with A1=A2==An. Their proof still works for or slightly more general formulation.

Lemma 5.5 ([12, Lemma 4.6]).

Let Ψ be a linear system on ({0,1}logn)k whose rank is r. For each i[k] let Ai{0,1}logn be such that |Ai|2n/3. Let 𝐱iAi independently for each i[k] Then

Pr[𝒙 satisfies Ψ](34)r.

5.2 Proof of Theorem 5.2

Throughout this section we let α, β<1/300 be positive real values and R<1/100(1α) a positive integer. Furthermore, we assume G is a fixed graph with (α,β,R)-bounded common neighborhoods. Note that this choice of parameters ensures that for every vertex set |M|R, |N(M,i)|2n/3.

The proof of Theorem 5.2 follows the same strategy as [12]. Given an affine-DAG solving NonEdgeM we wish to find an affine-DAG of much smaller depth solving a slightly smaller instance NonEdgeM; repeating this process shows that the original depth must have been large. Formally, we use the following lemma which we will spend the remainder of the section proving.

Lemma 5.6.

Let MV(G) be a set of vertices and suppose there is an affine-DAG Π solving NonEdgeM whose depth is at most D and size is at most S. Then

D>(R|M|)/8.

Moreover, for some universal constant C it holds that if |M|+8dR for d=logSmin(R,1/β) then there exists a set MM of size |M||M|+ClogS and an affine-DAG Π solving NonEdgeM whose depth is at most Dd and size is at most S.

First we show how Theorem 5.2 follows from Lemma 5.6.

Proof of Theorem 5.2.

A Res()-refutation of 𝖡𝖢𝗅𝗂𝗊𝗎𝖾(G,k) of depth D and size S immediately gives an affine Π solving NonEdge. Let d=logSmin((1α)1/2,1/β) we start by considering the case when 8dR/2. Then

R16dlogSmin(R,1/β)logSR.

This means logSR and the desired bound follows immediately since by Lemma 5.6 we have that D>R/8.

Now consider the case 8d<R/2. We can here use Lemma 5.6 to find a set M1 of size |M1|=ClogS and an affine-DAG Π1 of depth at most Dd and size at most S solving NonEdgeM1. We keep applying Lemma 5.6 iteratively in this way, using M=Mt1 to find Mt=M of size |Mt|tClogS and Πt of depth at most Ddt and size at most S. We repeat this process as long as the condition of Lemma 5.6 holds, i.e., as long as |Mt|+8dR. Thus the final t must satisfy tClogS+8dR which means tR/2ClogS. But at that point we have an affine-DAG Πt of depth DdR/2ClogS solving Mt. Since an affine-DAG cannot have negative depth we find that DΩ(dR/logS)=Ω(Rmin(R,1/β)/logS) and thus the theorem follows.

Now all that remains is to prove Lemma 5.6. We do so by constructing a random walk according to Algorithm 3, over our affine-DAG. We require from this random walk to satisfy several properties. During the walk, we build an affine restriction, which sets relatively few variables and satisfies all linear systems labeling nodes on the walked path. We will ensure that the walk visits all nodes with the same probability, as answering according to a uniformly sampled fixed input. We show that, with a significant probability, the walk does not witness a missing edge. On the other hand, if the affine-DAG is not sufficiently large, some node v must be visited with a significant probability in one of these successful runs. This is only possible if the rank of the system Ψ labeling v is not too large.

We can then use the fact that a small rank Ψ can be satisfied by restricting a few blocks. We combine this with the fact that v was reached in a successful run to find a valid instance of NonEdgeM that is solved by the dag rooted at v, i.e., a DAG of lower depth as desired.

We start by presenting Algorithm 3. This is essentially the same algorithm as [12, Algorithm 1] with two main differences. First, we require xi to lie in N(M,i) rather than an arbitrary set A. Second, we say that the algorithm fails if it assigns blocks in a way that could select vertices not connected by an edge rather than if it finds a collision between pigeons.

Algorithm 3 Random walk simulator.

Let us state two properties of Algorithm 3 that follow immediately from the analysis of [12], the difference lying in the fact that we use N(M,i) as a set of valid assignments to the xi rather than an arbitrary set A.

Lemma 5.7 ([12, Lemma 4.1]).

At the end of every iteration of the while loop in Algorithm 3

  1. 1.

    the equations in L uniquely determine xi,j for all i[k]F, j[logn] as an affine function of xi,j, iF, j[logn];

  2. 2.

    fixing the variables in xi,j, iF, j[logn] and setting the remaining variables as determined by L ensures that xiN(M,i) for all i[k]F;

  3. 3.

    L implies all parity constraints on the path from the root to the current node.

Lemma 5.8 ([12, Lemma 4.2]).

Let Wv be the event that node v of T is visited by Algorithm 3, Let 𝐱iN(M,i) independently for each i[k]B(M), and Vv be the event that running T on 𝐱 reaches v. Then for every vT, we have Pr[Wv]=Pr[Vv].

Now, we will show that the algorithm does not fail with a non-negligible probability (i.e., the walk does not witness a missing edge).

Lemma 5.9.

Let T be a depth-d parity decision tree and M a set of vertices. If |M|+8dR, then the probability that Algorithm 3 does not return FAIL when run on T and M is at least exp(Ω(dβ+d2(1α)).

We now wish to show that it is possible to use a successful run of Algorithm 3 to find an affine restriction satisfying the reached node.

Lemma 5.10.

Let v,C,L,F be returned by a successful run of Algorithm 3 when run on T and M. Let Ψ be the linear system labeling the node in the affine-DAG corresponding to v, and let r be the rank of Ψ. If |M|+2rR, then there exists a set F[k] and an affine restriction ρ fixing blocks [k]F satisfying the following conditions:

  1. 1.

    The number of blocks fixed by ρ, say s, is at most r.

  2. 2.

    Ψ is implied by Ψρ (the linear system equivalent to the affine restriction ρ).

  3. 3.

    There exists a set MV(G)M such that |M|2s and for any assignment to F, if we set the blocks [k]F according to ρ, all the vertices assigned to [k]F lie in M and form a complete subgraph of G.

With this we have both shown that the probability of succeeding is significant and that when we succeed, we can extract an affine restriction satisfying the system labeling the reached node. We can now combine these facts to obtain Lemma 5.6. For the details of this argument see the full version of this paper [21].

6 Lower Bound for Randomized Communication

In this section, we lower bound randomized communication cost required to solve 𝖡𝖢𝗅𝗂𝗊𝗎𝖾blockcc(G,k).

Theorem 6.1.

For any integers n and k, and for any real p[0,1], if 𝐆 is a graph sampled from 𝒢(n,p,k) then a.a.s. randomized communication protocol solving 𝖡𝖢𝗅𝗂𝗊𝗎𝖾blockcc(𝐆,k) has cost

Ω(min(1n0.05(1p),n0.225log(kn))).

To see that Theorem 1.3 follows we set p=1n1/3 and k=n. 𝑮 then has N=n2 vertices and we get the lower bound Ω(n0.22)=NΩ(1) on the cost of the protocol as required.

For the rest of this section, recall that SG𝖡𝖢𝗅𝗂𝗊𝗎𝖾blockcc(G,k)={(x,y,uv)x,yΣk,uvE(G),{u,v}V(x,y)}, where Σ={0,1}logn/2, V(x,y)Vk is the list on nodes described by x,yΣk.

Theorem 6.2.

Let s,k,n>0, and G be an s-almost-complete graph on k blocks of size n. Then the randomized communication complexity of SG is Ω(n0.45/s).

Theorem 6.1 follows immediately from Theorem 6.2 and Lemma 3.2. To see this recall that Lemma 3.2 states that a.a.s. a graph 𝑮 sampled as in Theorem 6.1 is s-almost-complete for s=max{2n(1p),9e2log(kn)}. From Theorem 6.2 it then follows that the randomized communication complexity of SG is

Ω(n0.45s)=Ω(min(1n0.05(1p),n0.225log(kn))

The rest of this section is dedicated to the proof of Theorem 6.2. By Yao’s principle for randomized communication complexity [52], it suffices to show that every small cost deterministic protocol errs significantly on some input distribution. We will show this for the uniform distribution over inputs (𝒙,𝒚)Σk×Σk.

6.1 Lifting Background

We start by introducing some concepts necessary to define subcube-like protocols, which we will use in our analysis. Every node v in a communication protocol Π is associated with a rectangle Rv=Xv×Yv. For a random variable 𝒙 we write its min-entropy as H(𝒙)=minxlog(1/Pr[𝒙=x]). We say that a random variable 𝒙{0,1}m is γ-spread if for every subset I[m], the marginal distribution 𝒙I satisfies H(𝒙I)γ|I|. We define subcube-like communication protocols [25, 46].

Definition 6.3.

We say that a rectangle R=X×Y{0,1}m×{0,1}m is γ-subcube-like with respect to I,J[m] if XI,YJ are fixed to some values, and the random variables 𝐱[m]I,𝐲[m]J are γ-spread for 𝐱X and 𝐲Y. We write fix(X)=I and fix(Y)=J.

A communication protocol Π is called γ-subcube-like if all the rectangles associated to the nodes in Π are γ-subcube-like.

In our proof of Theorem 6.2, we use the following theorem from [25], which essentially says that, without loss of generality, we can assume the protocol to be subcube-like.

Theorem 6.4 ([25], Theorem 29).

Let Π be a deterministic communication protocol with input from X×Y. Then, for any constant γ<1, there is a protocol Π that γ-subcube-like, and has cost |Π|=O(|Π|/ε) such that Pr𝐱,𝐲X×Y[Π(𝐱,𝐲)Π(𝐱,𝐲)]ε.

6.2 Proof of Theorem 6.2

Assume that Π solves SG with an error ε. By Theorem 6.4, there is a 0.9-subcube-like protocol Π of cost O(|Π|/ε)d solving SG to an error 2ε. Sample uniform random inputs 𝒙,𝒚Σk={0,1}klog|Σ| for Alice and Bob. Let the output of Π(𝒙,𝒚) be an edge connecting nodes from blocks 𝒂[k] and 𝒃[k]. We denote this edge with (𝒂𝒙𝒂𝒚𝒂,𝒃𝒙𝒃𝒚𝒃) meaning that both nodes are described by first specifying the block, and then specifying the number of the node inside the block identified with Σ×Σ. Let be the leaf of Π such that (𝒙,𝒚)R. For a set I[klog|Σ|] let the set blocks(I) be the set of all blocks i[k] whose bits are mentioned in I.

The proof can be summarized as follows. If one of the blocks 𝒂 and 𝒃 is never mentioned in the fixed part of the leaf rectangle R, then, by density of the graph, the answer is likely to be wrong. Otherwise, at least one bit describing the nodes in 𝒂 and 𝒃 is fixed at the leaf. In that case, we argue that since there are at most d blocks that can be mentioned, it is unlikely that a non-edge was discovered among those.

For an arbitrary node v of Π let Dvblocks(fix(Xv))blocks(fix(Yv)). Then the event where one of the block 𝒂,𝒃 is never fixed in the run of the protocol is expressed simply as “{𝒂,𝒃}D”. Then

Pr[(𝒂𝒙𝒂𝒚𝒂,𝒃𝒙𝒃𝒚𝒃)E(G)] Pr[(𝒂𝒙𝒂𝒚𝒂,𝒃𝒙𝒃𝒚𝒃)E(G){𝒂,𝒃}D] (4)
+Pr[(𝒂𝒙𝒂𝒚𝒂,𝒃𝒙𝒃𝒚𝒃)E(G){𝒂,𝒃}D] (5)

Bounding the summand (4).

Observe that for each leaf of Π the probability Pr[{𝒂,𝒃}D=]{0,1}, i.e., leaves can be categorized into safe and dangerous: is safe if Pr[{𝒂,𝒃}D=]=1, otherwise it is dangerous. We also note the following useful claim.

Claim 6.5.

Suppose is a safe leaf, then

Pr[(𝒂𝒙𝒂𝒚𝒂,𝒃𝒙𝒃𝒚𝒃)E(G)(𝒙,𝒚)R]s/n0.45. (6)

Since (4) is a convex combination of left-hand sides of (6), we conclude by ˜6.5 that the summand (4) is bounded with s/n0.45 as well.

Bounding the summand (5).

We would like to apply a union bound over all values of {𝒂,𝒃}. We first verify this for a fixed pair of blocks a and b:

Claim 6.6.

For every ab[k] we have

Pr[(a𝒙a𝒚a,b𝒙b𝒚b)E(G){a,b}D]s/n0.45.

We need some additional notation to implement our union bound. For a protocol leaf define

pa,b()Pr𝒛,𝒘R[(a𝒛a𝒘a,b𝒛b𝒘b)E(G)].

Since the pair (𝒂,𝒃) is uniquely determined by , so denote a() and b() the blocks returned in the leaf . Having that, we rewrite
Pr[(𝒂𝒙𝒂𝒚𝒂,𝒃𝒙𝒃𝒚𝒃) E(G)¬F] (def. of dangerous leaves) =: dangerous leafpa(),b()()Pr[(𝒙,𝒚)R] =𝔼[p𝒂,𝒃()𝟙{𝒂,𝒃}D] (sum includes the term 𝒂,𝒃) ab[k]𝔼[𝟙{a,b}Dpa,b()] =ab[k]Pr[{a,b}D(a𝒙a𝒚a,b𝒙b𝒚b)E(G)] =ab[k]Pr[(a𝒙a𝒚a,b𝒙b𝒚b)E(G){a,b}D]Pr[{a,b}D] (number of pairs is |D|2) 𝔼[|D|2]maxab[k]Pr[(a𝒙a𝒚a,b𝒙b𝒚b)E(G){a,b}D] (Claim 6.6) d2s/n0.45.

Finally, we have established that the success probability of Π is at most 2d2s/n0.4512ε=Ω(1), so d=Ω(n0.45/s) as required.

References

  • [1] Yaroslav Alekseev and Dmitry Itsykson. Lifting to bounded-depth and regular resolutions over parities via games. In Proceedings of the 57th Annual ACM Symposium on Theory of Computing (STOC ’25), pages 584–595, 2025. doi:10.1145/3717823.3718150.
  • [2] Albert Atserias, Ilario Bonacina, Susanna F. de Rezende, Massimo Lauria, Jakob Nordström, and Alexander Razborov. Clique is hard on average for regular resolution. Journal of the ACM, 68(4):23:1–23:26, 2021. Preliminary version in STOC ’18. doi:10.1145/3449352.
  • [3] Paul Beame, Russell Impagliazzo, and Ashish Sabharwal. The resolution complexity of independent sets and vertex covers in random graphs. Computational Complexity, 16(3):245–297, 2007. Preliminary version in CCC ’01. doi:10.1007/S00037-007-0230-0.
  • [4] Paul Beame, Henry Kautz, and Ashish Sabharwal. Towards understanding and harnessing the potential of clause learning. Journal of Artificial Intelligence Research, 22(1):319–351, 2004. doi:10.1613/jair.1410.
  • [5] Paul Beame, Toniann Pitassi, and Nathan Segerlind. Lower bounds for Lovász–Schrijver systems and beyond follow from multiparty communication complexity. SIAM Journal on Computing, 37(3):845–869, 2007. Preliminary version in ICALP ’05. doi:10.1137/060654645.
  • [6] Paul Beame and Michael Whitmeyer. Multiparty communication complexity of collision-finding and cutting planes proofs of concise pigeonhole principles. In Procceedings of the 52nd International Colloquium on Automata, Languages, and Programming (ICALP ’25), volume 334 of LIPIcs, pages 21:1–21:20, 2025. doi:10.4230/LIPIcs.ICALP.2025.21.
  • [7] Olaf Beyersdorff, Nicola Galesi, and Massimo Lauria. Parameterized complexity of DPLL search procedures. ACM Transactions on Computational Logic, 14(3):20:1–20:21, 2013. Preliminary version in SAT ’11. doi:10.1145/2499937.2499941.
  • [8] Olaf Beyersdorff, Nicola Galesi, Massimo Lauria, and Alexander A Razborov. Parameterized bounded-depth Frege is not optimal. ACM Transactions on Computation Theory (TOCT), 4(3):1–16, 2012. Preliminary version in ICALP ’11. doi:10.1145/2355580.2355582.
  • [9] Sreejata Kishor Bhattacharya and Arkadev Chattopadhyay. Exponential lower bounds on the size of reslin proofs of nearly quadratic depth. arXiv preprint arXiv:2507.23008, 2025. doi:10.48550/arXiv.2507.23008.
  • [10] Sreejata Kishor Bhattacharya, Arkadev Chattopadhyay, and Pavel Dvořák. Exponential Separation Between Powers of Regular and General Resolution over Parities. In 39th Computational Complexity Conference (CCC 2024), volume 300 of Leibniz International Proceedings in Informatics (LIPIcs), pages 23:1–23:32. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2024. doi:10.4230/LIPIcs.CCC.2024.23.
  • [11] Sam R. Buss and Jakob Nordström. Proof complexity and SAT solving. In Armin Biere, Marijn J. H. Heule, Hans van Maaren, and Toby Walsh, editors, Handbook of Satisfiability, volume 336 of Frontiers in Artificial Intelligence and Applications, chapter 7, pages 233–350. IOS Press, 2nd edition, 2021. doi:10.3233/faia200990.
  • [12] Farzan Byramji and Russell Impagliazzo. Lower bounds for bit pigeonhole principles in bounded-depth resolution over parities. arXiv preprint arXiv:2511.20023, 2025. doi:10.48550/arXiv.2511.20023.
  • [13] Marco L. Carmosino, Jiawei Gao, Russell Impagliazzo, Ivan Mihajlin, Ramamohan Paturi, and Stefan Schneider. Nondeterministic extensions of the strong exponential time hypothesis and consequences for non-reducibility. In Proceedings of the 7th ACM Conference on Innovations in Theoretical Computer Science (ITCS ’16), pages 261–270, 2016. doi:10.1145/2840728.2840746.
  • [14] Arkadev Chattopadhyay, Shachar Lovett, and Marc Vinyals. Equality alone does not simulate randomness. In Proceedings of the 34th Computational Complexity Conference (CCC ’19), pages 14:1–14:11, 2019. doi:10.4230/LIPIcs.CCC.2019.14.
  • [15] Jianer Chen, Xiuzhen Huang, Iyad A. Kanj, and Ge Xia. Linear FPT reductions and computational lower bounds. In Proceedings of the 36th Annual ACM Symposium on Theory of Computing (STOC ’04), pages 212–221, 2004. doi:10.1145/1007352.1007391.
  • [16] Tsun-Ming Cheung, Hamed Hatami, Kaave Hosseini, Aleksandar Nikolov, Toniann Pitassi, and Morgan Shirley. A lower bound on the trace norm of boolean matrices and its applications. In Proceedings of the 16th Innovations in Theoretical Computer Science Conference (ITCS ’25), pages 37:1–37:15, 2025. doi:10.4230/LIPIcs.ITCS.2025.37.
  • [17] Matthew Clegg, Jeffery Edmonds, and Russell Impagliazzo. Using the Groebner basis algorithm to find proofs of unsatisfiability. In Proceedings of the 28th Annual ACM Symposium on Theory of Computing (STOC ’96), pages 174–183, 1996. doi:10.1145/237814.237860.
  • [18] William Cook, Collette Rene Coullard, and György Turán. On the complexity of cutting-plane proofs. Discrete Applied Mathematics, 18(1):25–38, 1987. doi:10.1016/0166-218x(87)90039-4.
  • [19] Stefan Dantchev, Nicola Galesi, Abdul Ghani, and Barnaby Martin. Proof complexity and the binary encoding of combinatorial principles. SIAM Journal on Computing, 53(3):764–802, 2024. doi:10.1137/20M134784X.
  • [20] Susanna de Rezende, Aaron Potechin, and Kilian Risse. Clique is hard on average for unary Sherali-Adams. In Proceedings of the 64th IEEE Annual Symposium on Foundations of Computer Science (FOCS 23’), pages 12–25, 2023. doi:10.1109/focs57990.2023.00008.
  • [21] Susanna F. de Rezende, David Engström, Yassine Ghannane, Duri Andrea Janett, and Artur Riazanov. Average-case hardness of binary-encoded clique in proof and communication complexity. arXiv preprint arXiv:2605.10941, 2026. doi:10.48550/arXiv.2605.10941.
  • [22] Klim Efremenko, Michal Garlík, and Dmitry Itsykson. Lower bounds for regular resolution over parities. In Proceedings of the 56th Annual ACM Symposium on Theory of Computing (STOC ’24), pages 640–651, 2024. doi:10.1145/3618260.3649652.
  • [23] Klim Efremenko and Dmitry Itsykson. Amortized closure and its applications in lifting for resolution over parities. In Proceedings of the 40th Computational Complexity Conference (CCC ’25), pages 8:1–8:24, 2025. doi:10.4230/LIPIcs.CCC.2025.8.
  • [24] Ankit Garg, Mika Göös, Pritish Kamath, and Dmitry Sokolov. Monotone circuit lower bounds from resolution. Theory of Computing, 16(13):1–30, 2020. Preliminary version in STOC ’18. doi:10.4086/TOC.2020.V016A013.
  • [25] Mika Göös, Tom Gur, Siddhartha Jain, and Jiawei Li. Quantum communication advantage in TFNP. In Proceedings of the 57th Annual ACM Symposium on Theory of Computing, (STOC ’25), pages 1465–1475, 2025. doi:10.1145/3717823.3718155.
  • [26] Mika Göös, Nathaniel Harms, and Artur Riazanov. Equality is far weaker than constant-cost communication. In Proceedings of the 29th International Conference on Randomization and Computation (RANDOM ’25), volume 353, pages 58:1–58:14, 2025. doi:10.4230/LIPIcs.APPROX/RANDOM.2025.58.
  • [27] Mika Göös, Toniann Pitassi, and Thomas Watson. Query-to-communication lifting for BPP. SIAM Journal on Computing, 49(4):FOCS17–441–FOCS17–461, 2020. doi:10.1137/17M115339X.
  • [28] Mika Göös and Toniann Pitassi. Communication lower bounds via critical block sensitivity. SIAM Journal on Computing, 47(5):1778–1806, 2018. Preliminary version in STOC ’14. doi:10.1137/16M1082007.
  • [29] Armin Haken and Stephen A. Cook. An exponential lower bound for the size of monotone real circuits. Journal of Computer and System Sciences, 58(2):326–335, 1999. doi:10.1006/jcss.1998.1617.
  • [30] Johan Håstad. Clique is hard to approximate within n1ε. Acta Mathematica, 182(1), 1999. doi:10.1007/BF02392825.
  • [31] Pavel Hrubeš and Pavel Pudlák. A note on monotone real circuits. Information Processing Letters, 131:15–19, 2018. doi:10.1016/j.ipl.2017.11.002.
  • [32] Trinh Huynh and Jakob Nordström. On the virtue of succinct proofs: amplifying communication complexity hardness to time-space trade-offs in proof complexity. In Proceedings of the 44th Symposium on Theory of Computing Conference, (STOC ’12), pages 233–248, 2012. doi:10.1145/2213977.2214000.
  • [33] Russell Impagliazzo, Toniann Pitassi, and Alasdair Urquhart. Upper and lower bounds for tree-like cutting planes proofs. In Proceedings 9th Annual IEEE Symposium on Logic in Computer Science (LICS ’94), pages 220–228, 1994. doi:10.1109/LICS.1994.316069.
  • [34] Dmitry Itsykson and Artur Riazanov. Proof complexity of natural formulas via communication arguments. In Proceedings of the 36th Computational Complexity Conference (CCC ’21), pages 3:1–3:34, 2021. doi:10.4230/LIPIcs.CCC.2021.3.
  • [35] Dmitry Itsykson and Dmitry Sokolov. Resolution over linear equations modulo two. Annals of Pure and Applied Logic, 171(1):102722, 2020. Preliminary version in MFCS ’14. doi:10.1016/J.APAL.2019.102722.
  • [36] Stasys Jukna. Clique problem, cutting plane proofs and communication complexity. Information Processing Letters, 112(20):772–777, 2012. doi:10.1016/j.ipl.2012.07.003.
  • [37] Richard M. Karp. Reducibility among Combinatorial Problems, pages 85–103. Springer US, 1972. doi:10.1007/978-1-4684-2001-2_9.
  • [38] Jan Krajíček. Proof Complexity, volume 170 of Encyclopedia of Mathematics and Its Applications. Cambridge University Press, 2019. doi:10.1017/9781108242066.
  • [39] Eyal Kushilevitz and Noam Nisan. Communication Complexity. Cambridge University Press, 1997. doi:10.1016/S0065-2458(08)60342-3.
  • [40] Jean B. Lasserre. Global optimization with polynomials and the problem of moments. SIAM Journal on Optimization, 11(3):796–817, 2001. doi:10.1137/s1052623400366802.
  • [41] Massimo Lauria. Cliques enumeration and tree-like resolution proofs. Information Processing Letters, 135:62–67, 2018. doi:10.1016/J.IPL.2018.03.001.
  • [42] Massimo Lauria, Pavel Pudlák, Vojtěch Rödl, and Neil Thapen. The complexity of proving that a graph is Ramsey. Combinatorica, 37(2):253–268, 2017. Preliminary version in ICALP ’13. doi:10.1007/S00493-015-3193-9.
  • [43] Shuo Pang. Large clique is hard on average for resolution. In International Computer Science Symposium in Russia (CSR ’21), pages 361–380, 2021. doi:10.1007/978-3-030-79416-3_22.
  • [44] Anup Rao and Amir Yehudayoff. Communication Complexity and Applications. Cambridge University Press, 2020. doi:10.1145/3357713.3384286.
  • [45] Alexander A. Razborov. Lower bounds on the monotone complexity of some boolean functions. Doklady Akademii Nauk SSSR, 1985. doi:10.1007/bf01157687.
  • [46] Artur Riazanov, Anastasia Sofronova, Dmitry Sokolov, and Weiqiang Yuan. Searching for falsified clause in random (logn)-CNFs is hard for randomized communication. In Proceedings of the 29th International Conference on Randomization and Computation (RANDOM ’25), pages 64:1–64:17, 2025. doi:10.4230/LIPIcs.APPROX/RANDOM.2025.64.
  • [47] Benjamin Rossman. On the constant-depth complexity of k-clique. In Proceedings of the 40th Annual ACM Symposium on Theory of Computing (STOC ’08), pages 721–730, 2008. doi:10.1145/1374376.1374480.
  • [48] Benjamin Rossman. The monotone complexity of k-clique on random graphs. SIAM Journal on Computing, 43(1):256–279, 2014. Preliminary version in FOCS ’10. doi:10.1137/110839059.
  • [49] Dmitry Sokolov. Dag-like communication and its applications. In Proceedings of the 12th International Computer Science Symposium in Russia (CSR ’17), volume 10304 of Lecture Notes in Computer Science, pages 294–307. Springer, 2017. doi:10.1007/978-3-319-58747-9_26.
  • [50] Dmitry Sokolov. Random (logn)-CNF are hard for cutting planes (again). In Proceedings of the 56th Annual ACM Symposium on Theory of Computing (STOC ’24), pages 2008–2015, 2024. doi:10.1145/3618260.3649636.
  • [51] Guangxu Yang and Jiapeng Zhang. Communication lower bounds for collision problems via density increment arguments. In Proceedings of the 56th Annual ACM Symposium on Theory of Computing (STOC ’24), pages 630–639, 2024. doi:10.1145/3618260.3649607.
  • [52] Andrew C. Yao. Lower bounds by probabilistic arguments. In Proceedings of the 24th Annual Symposium on Foundations of Computer Science (FOCS ’83), pages 420–428, 1983. doi:10.1109/SFCS.1983.30.
  • [53] David Zuckerman. Linear degree extractors and the inapproximability of max clique and chromatic number. Theory of Computing, 3(6):103–128, 2007. doi:10.4086/TOC.2007.V003A006.