Abstract 1 Introduction 2 Preliminaries 3 Multiparty Communication Lower Bounds for 𝒎𝒏+𝒏 4 Tree-like Proof Complexity Lower Bounds 5 Triangle-DAG Lower Bounds 6 Multiparty Communication Lower Bounds for all 𝒎>𝒏 7 Discussion References

Multiparty Communication Complexity of Collision-Finding and Cutting Planes Proofs of Concise Pigeonhole Principles

Paul Beame ORCID University of Washington, Seattle, WA, USA Michael Whitmeyer ORCID University of Washington, Seattle, WA, USA
Abstract

We prove several results concerning the communication complexity of a collision-finding problem, each of which has applications to the complexity of cutting-plane proofs, which make inferences based on integer linear inequalities.

In particular, we prove an Ω(n11/klogk/2k) lower bound on the k-party number-in-hand communication complexity of collision-finding. This implies a 2n1o(1) lower bound on the size of tree-like cutting-planes refutations of the bit pigeonhole principle CNFs, which are compact and natural propositional encodings of the negation of the pigeonhole principle, improving on the best previous lower bound of 2Ω(n). Using the method of density-restoring partitions, we also extend that previous lower bound to the full range of pigeonhole parameters.

Finally, using a refinement of a bottleneck-counting framework of Haken and Cook and Sokolov for DAG-like communication protocols, we give a 2Ω(n1/4) lower bound on the size of fully general (not necessarily tree-like) cutting planes refutations of the same bit pigeonhole principle formulas, improving on the best previous lower bound of 2Ω(n1/8).

Keywords and phrases:
Proof Complexity, Communication Complexity
Category:
Track A: Algorithms, Complexity and Games
Copyright and License:
[Uncaptioned image] © Paul Beame and Michael Whitmeyer; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Mathematics of computing
Related Version:
Full Version: https://eccc.weizmann.ac.il/report/2025/057/ [3]
Funding:
Research supported by NSF grants CCF-2006359 and CCF-2422205.
Editors:
Keren Censor-Hillel, Fabrizio Grandoni, Joël Ouaknine, and Gabriele Puppis

1 Introduction

The pigeonhole principle, which asserts that there is no injective function f:[m][n] for m>n, is a cornerstone problem in the study of proof complexity. It is typically encoded as unsatisfiable conjunctive normal form formula (CNF), henceforth denoted PHPnm, on the variables yi,j, each of which is an indicator that “pigeon” i is mapped to “hole” j.

It is well known that any refutation of PHPnn+1 using resolution proofs requires size 2Ω(n) [12] and the same asymptotic bound holds for all m that are O(n) [6]. On the other hand, if we allow our proof system to reason about linear inequalities (for example using cutting-planes proofs), then it is easy to see that refuting PHPnn+1 becomes easy – indeed, there exist polynomial size refutations of PHPnn+1.

Despite the pigeonhole principle having short cutting-planes refutations, the related clique-coloring formulas, which state that a graph cannot have both k-cliques and k1-colorings, requires exponential-size cutting-planes refutation [24].111Lower bounds for restricted cutting-planes refutations of these formulas were earlier shown in [17, 4] The clique-coloring formula can be viewed as a kind of indirect pigeonhole principle: The k nodes of the clique correspond to the pigeons and k1 colors correspond to the holes, but the representation of possible mappings is quite indirect.

It is natural to wonder about the extent to which indirection is required for the pigeonhole principle to be hard for cutting-planes reasoning. As part of studying techniques for cutting-planes proofs, Hrubeš and Pudlák [16] considered a very natural compact and direct way of expressing the pigeonhole principle, known as the bit or binary pigeonhole principle222This encoding of the pigeonhole principle was introduced in [1].. The bit pigeonhole principle analog of PHPnm (henceforth denoted BPHPnm) has mlogn variables xi,j for i[m],j[logn] and the principle asserts that, when we organize these variables as an m×[logn] matrix, the rows of the matrix all have distinct values. BPHPnm is the following CNF formula: for each ij[m], include the clauses of a CNF encoding that xixj. One can achieve this by including a clause for each α{0,1}logn expressing that xiαxjα. The end result is a CNF with (m2)n clauses of size 2logn.

Using techniques related to those of [24], Hrubeš and Pudlák [16] showed that BPHPnm requires cutting-planes refutations of size 2Ω(n1/8) for any m>n, proving that even a very direct representation of the pigeonhole principle is hard for cutting-planes proofs. Their arguments, like those of Pudlák, also apply to any proof system that has proof lines consisting of integer linear inequalities with two antecedents per inference that are sound with respect to 01-valued variables; such proofs are known alternatively as semantic cutting-planes proofs or 𝖳𝗁(1) proofs [2].

Recently, Dantchev, Galesi, Ghani, and Martin [8] exhibited a 2Ω(n/logn) lower bound on the size of any general resolution refutation of BPHPnm for all m>n. In fact, they showed that BPHPnm requires proofs of size 2Ω(n1ε) for a more powerful class of proof systems that extend resolution by operating on k-DNFs (known as Res(k) proofs) for klog1/2εn. (Note that any sound proof system operating on DNFs requires size at least 2nΩ(1) to refute PHPnn+1 [23, 20, 14].) In addition, [8] showed that BPHPnm has no refutations in the Sherali-Adams proof system [27] of size smaller than 2Ω(n/log2n). Finally, just as PHPnm has polynomial-size Sum-of-Squares refutations [11], Dantchev et al. showed that BPHPnm has polynomial-sized Sum-of-Squares refutations.

Given the large lower bounds for resolution, Res(k), and Sherali-Adams refutations of BPHPnm, it is natural to ask the extent to which the sub-exponential lower bounds can be improved for cutting-planes proofs; how close to a 2Ω(n) lower bound is possible?

1.1 Tree-like Proofs and Multiparty Communication

In prior work there has been progress towards this question for the restricted class of tree-like refutations. Tree-like proofs require that any time an inequality is used, it must be re-derived (i.e., the underlying graph of deductions is a tree); the polynomial-size cutting-planes refutations of PHPnn+1 can be made tree-like. In contrast, Itsykson and Riazanov [18] showed that BPHPnm requires tree-like cutting-planes refutations of size 2Ω(n) when mn+n.

Our first result pushes this bound almost to its limit. Specifically, we prove that any tree-like semantic cutting-planes refutation of BPHPnm requires size 2n1o(1) whenever mn+22logn2.

In order to show this, we utilize a well-known connection between tree-like refutations and communication complexity. While the results of [18] for cutting planes rely on two-party communication complexity (and number-on-forehead multiparty communication for other results that we mention below), our stronger results are based on multiparty number-in-hand communication. In particular they are based on a similar natural collision-finding communication problem 𝖢𝗈𝗅𝗅m,k, in which each player p[k] in the number-in-hand model receives an input in x(p)[]m, and their goal is to communicate and find a pair ij[m] such that xi(p)=xj(p) for all players p[k]. Such a communication problem is well-defined (in the sense that such a pair i,j always exists) when m>k.

This collision-finding problem is intimately related to the unsatisfiable BPHPnm formula via the following natural search problem associated with any unsatisfiable CNF formula: Given unsatisfiable CNF φ, the associated search problem 𝖲𝖾𝖺𝗋𝖼𝗁φ takes as input a truth assignment α to the variables of φ and requires the output of the index of a clause of φ that is falsified by α. In particular the connection follows by considering a natural k-party number-in-hand communication game that we denote by 𝖲𝖾𝖺𝗋𝖼𝗁φk wherein the assignment α to the variables of φ is evenly distributed among the k players. and the players must communicate to find an answer for 𝖲𝖾𝖺𝗋𝖼𝗁φ(α). It is not hard to see that if we have a communication protocol solving 𝖲𝖾𝖺𝗋𝖼𝗁BPHPnmk(α) then such a protocol also solves 𝖢𝗈𝗅𝗅m,n1/kk on input α.

Our first result is a lower bound on 𝖢𝗈𝗅𝗅m,n1/kk that holds even when we allow randomized protocols.

Theorem 1.1.

The randomized number-in-hand communication complexity of 𝖢𝗈𝗅𝗅m,n1/kk is Ω(n11/klogk/2k) whenever n+1mn+2k2n1/k.

We pause here to note that this bound is nearly tight. There is a deterministic protocol wherein the first player sends a subset of coordinates of size m/n1/k in which their inputs are all equal. This requires log(mm/n1/k)(m/n1/k)log(m/n1/k) bits; when mn, this is O(n11/klog(n1/k))=O(n11/klogn/k) bits of communication. Player two then announces a subset of these coordinates on which they are equal of size m/n2/k. The players can continue in this manner until they have found a collision (which is guaranteed by the pigeonhole principle). Note that the amount of communication is bounded by a geometric series, and is dominated by the first term, which results in communication O(n11/klogn/k). This shows that up to logarithmic factors and a factor of 2k, Theorem 1.1 is tight.

We state here a simplified corollary333When m is somewhat larger, we can obtain somewhat weaker lower bounds. of Theorem 1.1 which formalizes our lower bounds for cutting-planes refutations of BPHPnm.

Theorem 1.2.

Any tree-like semantic cutting-planes refutation of BPHPnm requires size 2n12/logno(1/logn) when mn+22logn2.

We remark that Itsykson and Riazanov [18] utilized the same connection between communication and proof complexity to achieve their results. They were also interested in a k-party number-on-forehead version of 𝖢𝗈𝗅𝗅m,k (in particular, in their version, the matrices are added rather than concatenated), which leads to weaker lower bounds in stronger proof systems 𝖳𝗁(k1) that manipulate degree k1 polynomial inequalities.

Itsykson and Riazanov also left as an open problem whether their bounds for 𝖲𝖾𝖺𝗋𝖼𝗁BPHPnm could be extended to the regime of the “weak” pigeonhole principle when m=n+Ω(n). Göös and Jain [10] first answered this in the affirmative, giving an Ω(n1/12) lower bound on the randomized communication complexity of 𝖢𝗈𝗅𝗅2n,n1/22. Yang and Zhang [32] subsequently improved this to an Ω(n1/4) bound, which is tight for randomized computation. Because of the connection between communication protocols and tree-like communication, Yang and Zhang’s bound showed that any tree-like cutting planes refutation of BPHPnm requires size 2Ω(n1/4). We extend the lower bounds of Yang and Zhang for all k2 as follows:

Theorem 1.3.

For all m>n and 2klogn/4, the randomized number-in-hand communication complexity of 𝖢𝗈𝗅𝗅m,n1/kk is Ω(n1/21/(2k)/k).

This bound, whose proof combines techniques of Yang, Zhang, and Wang [31, 32], is much weaker than that of Theorem 1.1 when m is close to n but it is tight, up to an O(logn) factor, for randomized protocols when m is n+Ω(n). For k=Ω(logn), it also implies the following proof complexity bound which asymptotically matches the bound of [18], but applies for all m>n.

Corollary 1.4.

For all m>n, any tree-like semantic cutting-planes refutation of BPHPnm requires size 2Ω~(n).

1.2 General Proofs and DAG-like Protocols

Our second result improves on the 2Ω(n1/8) lower bound on the size of cutting-planes refutations of BPHPnm (for all m>n) of Hrubeš and Pudlák [16], and subsumes the 2Ω(n1/4) lower bound for tree-like proofs of Yang and Zhang [32]. Hrubeš and Pudlák used the method of interpolation involving a version of the method of approximation due to Jukna [19]. On the other hand, we use a bottleneck-counting method inspired by recent work of Sokolov [29] that refines a method introduced by Haken and Cook [13].

Theorem 1.5.

Any semantic cutting planes refutation of BPHPnm requires size at least 2n1/4/22, for any m>n.

We prove Theorem 1.5 via a connection between cutting-planes refutations and certain types of DAG-like communication protocols [15, 28]. Specifically, we prove a lower bound on the size of any two party triangle-DAG protocol computing 𝖲𝖾𝖺𝗋𝖼𝗁BPHPnm. We define such protocols formally in Section 2.3.

For now, we state the connection as the following proposition, originally due to Sokolov and Hrubeš and Pudlák [28, 15]. Its proof can be found in Section 2.3 for completeness.

Proposition 1.6 ([28, 15]).

Given a semantic cutting planes refutation for CNF formula φ of size s and any partition of the variables of φ into two sets, there is a size s triangle-DAG computing 𝖲𝖾𝖺𝗋𝖼𝗁φ.

In our setting, for BPHPnm, there is a natural partition of the variables such that each clause has exactly half of its variables coming from Vx and half of its variables coming from Vy. This can be achieved, for example, by letting Vx be the set of variables corresponding to the first 12logn columns of the matrix associated with BPHPnm. In light of Proposition 1.6, we derive Theorem 1.5 by proving the following.

Theorem 1.7.

For the natural partition of variables VxVy=[mlogn], any triangle-DAG computing 𝖲𝖾𝖺𝗋𝖼𝗁BPHPnm requires size 2n1/4/22.

2 Preliminaries

2.1 Proof Complexity

Proof complexity studies how the size required for refutations of unsatisfiable formulas depends on the size of the formulas themselves. The size of a refutation in general depends on the allowable structure (lines, derivation rules, etc.) of a proof. In general, a proof system corresponds to a polynomial-time verifier that can check proofs of a certain format. It generally suffices to derive refutations of unsatisfiable CNF formulas; so it is usual to focus solely on inputs of this form.

For most proof systems, a sequence of deductions can be thought of as a directed graph, where two (or possibly more) lines (whether given or derived) are combined soundly to create a new line. The underlying graph then has edges pointing from the derived inequality to its antecedents.444The direction of arrows in this digraph may seem counterintuitive, but it is convenient when thinking of the graph as a search problem for a violated axiom. In this case, we can follow a path in the graph to find such a a violated axiom on one of the leaves/sources. We say that a proof is tree-like if every inequality is used as an antecedent at most once in the proof – that is, if we want to use an inequality twice, we must derive it twice.

For example, in the resolution proof system the lines are clauses, and we have the derivation rule (Ax)(B¬x)AB.

A more powerful proof system is the cutting planes proof system555Cutting planes proofs can simulate resolution proofs, see e.g. [19, 25]., denoted 𝖢𝖯, where lines are linear inequalities. Clauses can be trivially converted into linear inequalities666For example, xyz could be converted to the inequality x+y+z1. but, more generally, cutting planes can start with any system of inequalities Axb where A is a matrix with integer entries. We say that the system is unsatisfiable iff it is unsatisfiable for any x{0,1}n. The most basic form of the cutting planes proof system consists of three rules: addition of inequalities, multiplication of inequalities by positive integers, and most crucially, the rounded division rule, also known as the Gomory-Chvátal rule. The rounded division rule is the simple but powerful observation that if a1,,an are all integers with a common factor c, and we have the inequality aTxb, then we can derive that 1caTxbc.

In general, there are many more sound derivation rules for integer/linear inequalities than just rounded division (such as saturation [9] for example), and even more generally, one may allow any sound derivation rule for linear inequalities, which yields what is known as semantic cutting planes or 𝖳𝗁(1) – we use the two names interchangeably.

There is a well-known connection between communication complexity and tree-like proofs, which we will now detail. Given any unsatisfiable formula φ, an assignment α to the variables can be distributed among k players, who must then communicate in order to find a a violated clause in φ. This is a search problem, and is denoted 𝖲𝖾𝖺𝗋𝖼𝗁φ(α). Short tree-like proofs of the unsatisfiability of φ can often be converted into short protocols for 𝖲𝖾𝖺𝗋𝖼𝗁φ using standard techniques.

For example, a short tree-like proof of unsatisfiability of φ using the resolution rule naturally corresponds to a decision tree for finding a violated clause of φ in the following way. For every derivation of the form (Ax)(B¬x)(AB) where AB is known to be false, we query x in order see whether Ax or B¬x is necessarily false. We can continue in this manner, from the root of the tree-like refutation, until we hit an unsatisfied clause in the original formula.

On the other hand, tree-like semantic cutting planes refutations naturally correspond to threshold decision trees, which we now define.

Definition 2.1 (Threshold Decision Tree).

A threshold decision tree is a tree whose vertices are labeled with inequalities of the form a1x1+anxnb where a1,,an,b are integers. Edges are labelled with 0 or 1, and leaves are axioms of a system of inequalities Axb.

We traverse a threshold decision tree by computing the threshold function at the root, following the corresponding edge, and continuing in this manner until we hit a leaf. We say that a threshold decision tree computes the search problem for a formula φ if this process leads to a leaf corresponding to a violated clause in φ.

First, we have the following well-known lemma, which states that one can derive a low-depth threshold decision tree from a small 𝖳𝗁(1) refutation.777As noted in [19], there is no meaningful converse to this statement, since if there are m inequalities in our unsatisfiable system, there exists a trivial depth m threshold decision tree finding one that is violated.

Proposition 2.2.

Given a size S tree-like 𝖳𝗁(1) refutation of an unsatisfiable system Axb, there is a depth O(logS) threshold decision tree finding a violated axiom.

Proposition 2.2 goes back to the work of Impagliazzo, Pitassi, and Urquhart [17], and can also be found for instance in [19]. We omit the proof, but the idea is a common one: find a node in the tree with roughly half (between 1/3 and 2/3) of the leaves as its descendants, make that the root of the threshold decision tree, and recurse.

2.2 Communication Complexity

We mainly focus on k-party number-in-hand communication, wherein each player p receives an input x(p), and the players’ goal is to communicate as little as possible in order to compute a known function or relation involving their collective inputs. In general, players may have access to shared randomness, and we allow incorrect answers with probability 1/3.

An important function for us is the number-in-hand disjointness problem with k players and input size n, henceforth denoted 𝖣𝖨𝖲𝖩nk. This is the communication problem wherein each player and input in {0,1}n, and they must decide if there exists a coordinate i for which they all have a 1 in that coordinate. Disjointness in general is an extremely well-studied problem [7, 25], and for the specific case of the NIH model, we have the following lower bound due to Braverman and Oshman.

Theorem 2.3 ([5]).

The randomized communication complexity of 𝖣𝖨𝖲𝖩nk is Ω(nlogk).

Our results rely on the following connection between threshold decision trees for finding violated clauses and k-party NIH communication. It is closely related to previous work.

Lemma 2.4.

For x{0,1}n, if an unsatisfiable system Axb on has a threshold decision tree of depth dn finding a violated axiom, then for any partition of the input variables into k parts there is a randomized protocol for 𝖲𝖾𝖺𝗋𝖼𝗁NIHk(Axb) using O(dklogklogn) bits of communication.

Lemma 2.4 is similar for example to Lemma 5 in [17] or Lemma 19.11 in [19], but is slightly stronger so we give a brief proof. Using a well-known theorem of Muroga [21] we can assume, without loss of generality, that each of the threshold functions in the decision tree has integer coefficients of absolute value at most 2n(n+1)(n+1)/2.

The players evaluate these threshold functions using the following efficient randomized protocol given by Viola [30] which tightens and refines a protocol first given by Nisan [22].

Proposition 2.5 ([30]).

Suppose that each player p[k] receives an input x(p)[2n,2n]. Then there is a randomized number-in-hand protocol with error at most ε that determines whether px(p)>s and communicates O(klogklog(n/ε)) bits.

Corollary 2.6.

Suppose that each player p[k] receives an input x(p)[2t]. Then they can execute a randomized number-in-hand protocol to determine whether papx(p)b, where each |ap|2w with error at most ε using at most O(klogklog((w+t)/ε)) bits of communication.

Proof of Lemma 2.4.

Given a threshold decision tree of depth d, which has coefficients of magnitude at most 2O(nlogn) without loss of generality [21], we simply traverse it from the root, evaluating the threshold functions until a root is reached. By Corollary 2.6, the players can communicate O(klog((nlogn)/ε)logk) bits to compute the threshold function with error probability ε. Setting ε=Θ(1/d) and continuing in this manner, by a union bound the threshold functions are all computed correctly with constant probability. Using the assumption that dn, this yields a protocol communicating O(dklogklogn) bits.

Given a system of unsatisfiable inequalities Axb, and a partition of an assignment α{0,1}n between k players, there is a natural (number-in-hand) communication game wherein players must communicate to a find an axiom violated by α. Lemma 2.4 implies the following result connecting communication complexity and proof complexity.

Lemma 2.7.

For any partition of n variables into k parts, if 𝖲𝖾𝖺𝗋𝖼𝗁NIHk(Axb) requires t bits of communication, then any tree-like 𝖳𝗁(1) refutation of Axb requires size 2Ω(t/(klogklogn)).

Proof.

By Proposition 2.2, given a size S tree-like 𝖳𝗁(1) proof, we get a depth d=O(logS) threshold decision tree finding a violated axiom. By Lemma 2.4, there exists a communication protocol finding a violated axiom using O(logSklogklogn) bits of communication. This implies that log(S)klogklognct for constant c, which in turn implies S is 2Ω(t/(klogklogn), as desired.

2.3 Triangle-DAGs

Given a bipartite domain X×Y, a triangle TX×Y is any set that can be written as T={(x,y):aT(x)<bT(y)} for some labelling aT:X and bT:Y.

A triangle-DAG computing a search problem 𝖲𝖾𝖺𝗋𝖼𝗁(X×Y×𝒪) is a directed acyclic graph D of fan-out at most 2 where each node uD is associated with a triangle TuX×Y satisfying the following:

  • there is a distinguished root node r with fan-in zero, and Tr=X×Y, and

  • for each non-sink node u with children v,v we have TuTvTv, and

  • each sink node u is labeled with an output o such that Tu𝖲𝖾𝖺𝗋𝖼𝗁1(o).

Given these definitions, we restate Proposition 1.6 for convenience. Proofs may be found in [28, 15] or in our full paper [3].

See 1.6

3 Multiparty Communication Lower Bounds for 𝒎𝒏+𝒏

In this section we prove Theorem 1.1, which we now recall. See 1.1 The idea for the proof is to exhibit a random reduction from the decision problem 𝖣𝖨𝖲𝖩mk1k to the collision problem. This is analogous to the approach of Itsykson and Riazanov [18] for number-on-forehead communication complexity which used lower bounds for disjointness in that model and a randomized decision-to-search reduction paradigm introduced by Raz and Wigderson [26] to prove lower bounds on the monotone depth complexity of matching. The details and parameters of our reduction are necessarily quite different.

In our setting, we embed k players’ inputs to a disjointness problem into k matrices such that, when these matrices are concatenated, the resulting matrix has distinct rows if and only if the players’ inputs were disjoint. We can then add a few “fake” rows to this matrix and run our algorithm for 𝖢𝗈𝗅𝗅m,n1/kk, and see if the collisions it finds involve the fake rows or not. If so, we conclude that the inputs were disjoint and if not, we know that they were not disjoint.

The following key combinatorial lemma allows us to carry out the first step of this process.

Lemma 3.1.

For all integers k1 there exist matrices Mk1{0,1}2k×k and Mk0{0,1}2k×k such that

  1. 1.

    Mk1 has 2k1 unique pairs of identical rows.

  2. 2.

    For any string b{0,1}k, define the matrix Mk(b1,bk) as the matrix formed by making its i-th column equal to the i-th column of Mk0 if bi=0, and equal to the i-th column of Mk1 if bi=1. Then Mk(b) has unique rows for all b1.

We defer the proof of Lemma 3.1 to Section 3.1.

Proof of Theorem 1.1 using Lemma 3.1.

As alluded to, we will reduce the NIH disjointness problem to our bit-pigeonhole problem. Namely, we will reduce 𝖣𝖨𝖲𝖩mk1k to a 𝖢𝗈𝗅𝗅m~,~k communication game, where m~=mk2k+2k1m, and ~=2m.

The players get x(1),,x(k)[mk1] (viewed as bit strings of length mk1), and need to determine whether x(1)x(k)=. First, we define Bmk(j):=[binmk(j),,binmk(j)]T{0,1}2k×klogm, where the same row is repeated 2k times.

For each i[mk1], consider the matrix Mk(xi(1),,xi(k)) from Lemma 3.1. Note that each player p knows the p-th column of Mk(xi(1),,xi(k)) for all i, but without communication the other players do not know this column. Then we can define

M~:=[Mk(x1(1),,x1(k))Bmk(0)Mk(x1(1),,x1(k))Bmk(1)Mk(x1(1),,x1(k))Bmk(m1)Mk(x2(1),,x2(k))Bmk(m)Mk(x2(1),,x2(k))Bmk(2m1)Mk(xmk1(1),,xmk1(k))Bmk(mk1)]{0,1}mk2k×(klogm+k).

Observe that each player p can construct their “part” of this matrix without communicating by constructing the p-th column of every MkSi matrix (which only depends on x(p)), and then taking the the p-th part of each of the Bmk(j) matrices.

Lemma 3.1 lets us connect the distinctness property of this matrix with the disjointness property of the players’ inputs.

Claim 3.2.

If (x(1),,x(k)) are disjoint, then M~ has distinct rows.

Proof.

The only possible collisions happen in every group of 2k rows, since Bmk(j) has every row different from Bmk(i) for all ij. Within these groups, by Lemma 3.1, if the inputs are disjoint then there are no collisions.

Claim 3.3.

If X is not disjoint, then there are at least 2k1m pairs of colliding rows in M~.

Proof.

Any coordinate i for which xi(p)=1 for all p generates Si=, which by Lemma 3.1 generates 2k1m such pairs, since input i was repeated m times.

We cannot run any collision protocol for M~ yet, as there are not guaranteed collisions. To address this, the players use shared randomness to put an additional 2k1m rows at the bottom of M~. These rows will be chosen randomly with the following two properties:

  1. 1.

    Each fake row will be distinct.

  2. 2.

    Each player’s “part” of the matrix (which consists of logm+1 columns) when restricted to these rows will repeat the 2m unique possible bit strings an addition 2k1m/(2m)=2k2 times.888This is important because if we bias and have a certain fake row appear more often in the input for player p, then 𝒜 could potentially detect and use this to its advantage.

Denote this new matrix M. M now has “fake” collisions which involve any of the last 2k1m rows.

Let 𝒜 denote the randomized protocol solving the 𝖢𝗈𝗅𝗅(2m)k+2k1m,2mk problem.

Observe that if the inputs are disjoint, then the only collisions in M involve fake rows. The players would like to feed their parts of this matrix into 𝒜 and conclude that their inputs are disjoint if the output involves a fake row, and conclude that they were not disjoint if the output involves two non-fake rows. However, this is problematic, as we have no guarantees over how 𝒜 behaves, and it could always find a collision involving one of the last 2m rows (which it knows are fake), regardless of if there are other collisions. This necessitates the following random shuffling.

  1. 1.

    Each player applies (the same) random permutation π:[2kmk+2k1m][2kmk+2k1m] which shuffles the rows of M.

  2. 2.

    Each player applies an individual random permutation π(p):[2m][2m] to each of their rows. Note that this preserves collisions/distinctness in the concatenation.

Denote π:=(π,π(1),,π(k)), and call this final matrix Mπ.

Algorithm.

The algorithm for disjointness is as follows: the players use their inputs and shared randomness to compute (without communication) their respective parts of 5 independent copies of an Mπ constructed in the above manner, and run 𝒜 using these as inputs. The players then examine the outputs (i1,j1),(i5,j5) of the algorithm on these five inputs. They then exchange an additional O(klogm) bits to determine if each claimed collision actually was a collision. Finally, if any of the claimed collisions were actually collisions on rows that were not fake (under the appropriate permutation), then the players can conclude with certainty that their inputs were not disjoint. Otherwise, if 𝒜 only ever finds colliding pairs that involve a row the players know is fake (or otherwise fail to find any collisions), then players guess that (x(1),,x(k)) were disjoint.

Analysis.

We analyze one iteration of the algorithm. Suppose 𝒜 has error probability at most 1/3 – that is, with probability at least 2/3, it outputs two rows i,j that are equal.

Suppose (x(1),,x(k)) are disjoint. Then by assumption, 𝒜 finds a collision with probability at least 2/3, and we know this collision will always involve a fake row by ˜3.2. Therefore the players will correctly output that their inputs were distinct with probability at least 2/3, and this is only improved by the five-fold repetition.

Otherwise, suppose that the players’ inputs were not disjoint. Suppose further that 𝒜 successfully finds a collision – this happens with probability at least 2/3. Recall that by ˜3.3 Mπ will have at least 2k1m distinct pairs of real collisions. Adding the 2k1m fake rows produced additional “fake” collisions. These fake rows could have created up to 2k1m additional unique pairs of fake collisions, or could have “joined” the real collisions, creating up to 2k1m groups of 3 equal rows in Mπ.

If 𝒜 outputs a collision from one of the groups of three, then because we applied random permutations to the rows, it is equally likely to have chosen any of the 3 possible pairs. Therefore, with probability at least 1/3, it outputs a real collision, and the players successfully discover that they are not disjoint. Otherwise, if 𝒜 outputs one of the unique collision pairs, then (again because we have applied random permutations to the rows), any such unique collision is equally likely to be output. If t of the fake rows formed a group of three with real collisions, then that leaves at most 2k1mt fake rows to collide with a different unique row. It also leaves 2k1mt untouched real collisions, so 𝒜 outputs a real collision with probability at least 1/2. Either way, the probability that 𝒜 outputs a real collision is at least 2/31/3=2/9.

Therefore, after repeating this 5 times independently, the probability of seeing at least one real collision is at least 1(7/9)5>2/3.

Let n:=(2m)k. We have shown that if 𝖢𝗈𝗅𝗅m~,~k with input size m~=2kmk+2k1m=n+2k2n1/k can be solved with o(n11/klogk/2k) communication, then we can solve the decision disjointness problem with o(n11/klogk/2k)+O(klogm) which is at most o(mk1logk), contradicting the Ω(mk1logk) lower bound from Theorem 2.3.

3.1 Proof of Lemma 3.1

We first recall Lemma 3.1.

See 3.1

Proof.

Let k{0,,k1} be the set of integers with an even number of 1s in their binary representation.

Define

Mk1=[bink(y1)bink(y1)bink(y2)bink(y2)bink(y2k1)bink(y2k1)]{0,1}2k×k,

where yi is the i-th smallest number in k.

We pause here to note that each of the columns of Mk1 are actually each the truth table of a linear function. Let f1:{0,1}k{0,1} be the linear function f1(x)=x,e1, where e1 is the first standard basis vector. Then we can describe the first column of Mk1 as the truth table of f1. More generally, we have that for i<k the i-th column of Mk1 is the truth table of fi(x)=x,ei, and the last column is the truth table of fk(x)=x,e1++ek1.

If we define Fk1 to be the matrix whose column i is the vector whose inner product we are taking with x in fi, and Bk𝔽22k×k whose rows are the binary strings written in order, then we have that

Mk1=[bink(0)bink(1)bink(2k1)][10010101001100010000]=:BkFk1

where all operations are over 𝔽2. Mk1 has repeated rows precisely because Fk1 has linearly dependent columns.

With this perspective in mind, if we can find a k×k matrix Fk0 over 𝔽2 such that replacing any (nonzero) number of columns of Fk1 with corresponding columns in Fk0 produces a matrix with linearly independent columns, then we are done, as we can let Mk0:=BkFk0.

We define Fk0 to be the following lower triangular matrix:

Fk0:=[1000110011101111],

Clearly Fk0 is full rank.

We claim that replacing any set nonempty set S of columns of Fk1 with the corresponding columns in Fk0 produces a matrix FkS with linearly independent columns. Consider arbitrary k, and arbitrary nonempty S[k].

Case 1.

Suppose kS, that is, the last column of FkS is ek. Then our matrix is lower triangular with 1s on the diagonal, and so has linearly independent columns.

Case 2.

Suppose kS, that is, the last column of FkS is e1++ek1. In this case, the first k1 columns are lower triangular with 1s on the diagonal, and therefore their span is equal to 𝗌𝗉𝖺𝗇{e1,,ek1}. It suffices then to show that also ek is in the column span. Towards this goal, take the minimal 0<i<k such that iS, and observe that summing the first i columns of FkS equals 1, the all 1s vector. Adding this to the last column produces ek, so we are done.

4 Tree-like Proof Complexity Lower Bounds

In this section, we prove the following more detailed version of Theorem 1.2.

Theorem 4.1.

When mn+2k2n1/k, any tree-like semantic cuttings planes refutation of BPHPnm must have size at least 2Ω(n11/k2k/(klogn)).

Proof.

The theorem follows quite readily from Lemma 2.7 and the fact that 𝖲𝖾𝖺𝗋𝖼𝗁BPHPnmk reduces to 𝖢𝗈𝗅𝗅m,n1/kk. If we translate BPHPnm to a system of inequalities, then there are O(nm2)=O(n3) inequalities on mlogn variables.

Lemma 2.7 then says that any tree-like semantic cutting planes proof of the unsatisfiability of BPHPnm must have size at least 2Ω(t/(klogklogn). By Theorem 1.1, t=Ω(n11/k2klogk). Plugging this in yields that the tree-like size must be at least 2Ω(n11/k2k/(klogn).

From Theorem 4.1 we achieve Theorem 1.2, which we restate now.

Corollary 4.2.

Any tree-like semantic cutting planes refutation of BPHPnm requires size 2n12/logno(1/logn) when mn+22logn2.

Proof.

Let k=logn. Plugging this into the bound from Theorem 4.1, we get that mn+2logn2n1/logn=22logn2. In this regime, Theorem 4.1 gives the size lower bound

2Ω(n11/lognn1/logn/(log3/2n))=2cn12/logn1.5loglogn/logn,

for appropriate constant c. Using the fact that c=nlogc/logn, the bound becomes

2n12/logno(1/logn).

5 Triangle-DAG Lower Bounds

In this section, we prove Theorem 1.7, which we restate here for convenience.

See 1.7

Before proving Theorem 1.7, we need the following notion of triangle slices. For a triangle TX×Y and a given xX, we define the slice Tx to be T({x}×Y), and define the slice Ty analogously. Note that for any triangle T defined by functions a and b there is a natural total pre-order on X where xx iff a(x)a(x) and hence TxTx; similarly, there is an total pre-order on Y where yy iff b(y)b(y) and hence TyTy. This immediately implies the following.

Proposition 5.1.

Given a triangle T, if yY is such that |Ty| is maximized, then for all (x,y)T we have (x,y)T.

We will have the following proposition.

Proposition 5.2.

For any triangle T and rectangle R, TR is a triangle.

Proof.

By definition, T={(x,y):a(x)<b(y)} for some a,b. If R=X×Y, simply modify a(x)= for all xX and b(y)= for all yY.

The proof of Theorem 1.7 uses the bottleneck counting method of Haken and Cook for cutting planes proofs [13] as adapted for direct use on triangle-DAGs by Sokolov [29].

Let V(D) denote the nodes of a triangle-DAG D computing 𝖲𝖾𝖺𝗋𝖼𝗁BPHPnm under the natural partition of variables. At a high level, to prove Theorem 1.7, we will construct a partial function μ:XYV(D) such that

(a) (Lemma 5.5) most xX and yY are mapped by μ to a node of D, and

(b) (Lemma 5.6) there is no node of D with too many x or y assigned to it by μ.

It is then easy to combine these two properties and conclude that |V(D)| must be large999The name bottleneck counting came from its original version due to Haken [12] in which a class of full input assignments was mapped by a function μ to nodes in a proof DAG and each input assignment could be viewed as “flowing” from the root to a particular sink node (defined by the assignment). In that case, μ identified a node on such a path, a bottleneck node, that did not permit many assignments to flow through it. Since there were many assignments, only few of which could pass through any bottleneck node identified by μ, there must be many bottleneck nodes in the DAG. In the modified form for cutting planes/triangle-DAGs, while the full assignment is flowing through the triangle-DAG, the mapping μ is based on half of the input assignment, either the x or y portion, and the sink node is not unique; not all assignments are assigned in this way, but many are..

For any ij[m], there is an associated rectangle Ri,jX×Y of inputs that violate at least one of the n clauses enforcing an inequality between coordinates i and j given by

Ri,j={(x,y)X×Yxi=xj,yi=yj}.

Observe that the set of all rectangles {Ri,j:ij[m]} covers the entire space X×Y as long as m>n. (That is, X×Y=ij[m]Ri,j.) Note that in order for a triangle-DAG to correctly compute 𝖲𝖾𝖺𝗋𝖼𝗁BPHPnm, it must, at the very least, have each sink be contained in a single Ri,j.

Definition 5.3.

For a node uV(D), let Tu denote the triangle associated with that node. Define the width w(T,z) of z in triangle T to be the minimal size of any subset S{Ri,j:ij[m]} such that TzRSR.

With this definition in hand, we can define our μ:XYV(D) using Algorithm 1 which depends on a parameter k that we will eventually set to n/4.

Algorithm 1 Defining the partial map μ:XYV(D).

Intuitively, in using Algorithm 1 we are going backwards through our DAG D, and whenever the protocol had too many options for what clause to output when the protocol was at a node u for a fixed zXY (which corresponds to large width), we assign z to u. Arguing that |μ1(u)| is not too large is thus arguing that a protocol cannot make huge strides in learning about which clause to output for too many zXY suddenly in one single node u.

We now make some basic observations about our definition of μ. First, note that no zXY is assigned to any sink node of D, since every sink node sV(D) is wholly contained in an Ri,j, and therefore we have that w(Ts,z)=1 for all z. The following observation will be of critical importance in our analysis.

Claim 5.4.

During the execution of Algorithm 1, for every u in triangle-DAG D and every zXY, w(T~u,z)2k.

Proof.

By definition in a triangle-DAG, if v and v are children of node u, then we have that TuTvTv. In particular, we know that if zXY was not assigned to nodes v or v, then w(T~u,z)2k, since we can take the union of the coverings for T~vz and T~vz.

Finally, we note that at the end of Algorithm 1 at the root r, for all zXY, we have that w(T~r,z)<k.

Lemma 5.5.

Let kn/2. For μ constructed using Algorithm 1, at least |X|/2 elements of X are assigned by μ or at least |Y|/2 elements of Y are assigned by μ.

Proof.

At the end of Algorithm 1 after processing the root r of D, since Tr=X×Y, we have T~r=X×Y which is the rectangle of unassigned inputs. If |X||X|/2 then we are done; otherwise, let xX. Since w(T~r,x)<k, there exists a set S, |S|<k, such that for all yY, yi=yj for at least one (i,j)S.

So, we obtain

𝐏𝐫yY[yY] 𝐏𝐫[(i,j)S s.t. yi=yj]|S|max(i,j)S𝐏𝐫[yi=yj]<k/n1/2.

Hence, |Y|<|Y|/2, as desired.

This shows that a large number of elements of XY are assigned by μ. It remains to show that each node in the protocol D only has a bounded number of elements of XY assigned by μ.

Lemma 5.6.

Let μ be defined by Algorithm 1 with k=n/4. For all all uV(D), μ maps at most |X|2n1/4/2+1 elements of X to u; the analogous bound also holds for Y.

Proof.

We fix any uV(D) and focus on the number of elements xX that μ maps to u; the bound for the number of such yY is identical. In particular, consider the values of X and Y and T~u in Algorithm 1 immediately before processing node u; any xX that μ maps to u must be in X.

Our strategy will be to construct a set of potential coverings for the slices {T~ux:xX} by monochromatic rectangles. We will then aim to show that most xX have width <k even when restricted to this set of potential coverings, thereby limiting how many xX could be assigned by μ to u.

Algorithm 2 Defining tree 𝒯, which encodes a set of potential coverings of T~x for all xX.

We now describe this potential covering in detail. Intuitively, our strategy will be to construct a tree 𝒯, each of whose nodes is labelled by a triangle of inputs that are not yet covered, where each edge of the tree is labelled with a pair ij[m]. We say that xX is consistent with a node t𝒯 iff for all (i,j) labels on the edges of the unique path to t in 𝒯, we have that xi=xj. Furthermore, 𝒯 will be constructed so that if xX is consistent with a leaf t of 𝒯, then T~ux is covered by {Ri,j:(i,j) is on the path to t}. We produce the tree 𝒯 of potential coverings of of T~ux for all xX using Algorithm 2 applied with T~=T~u, X=X, and Y=Y which satisfy the preconditions by ˜5.4.

Refer to caption
Figure 1: A single iteration of Algorithm 2.

First, observe that any xX such that T~x is consistent with at least one leaf in 𝒯, by the choice of y in Algorithm 2 along with Proposition 5.1. We define the set of equality constraints of a leaf t𝒯 to be the set E(t):={ij[m]:(i,j) is on the unique path to t in 𝒯}. Observe that we have the desired property that if x is consistent with a leaf t of 𝒯, then T~ux is covered by {Ri,j:(i,j)E(t)}, thereby ensuring that w(T~u,x)0pt𝒯(t).

Therefore, if μ maps xX to u then x must be consistent with a leaf of 𝒯 of depth at least k. Let 𝒯 denote tree 𝒯 truncated at depth k. Thus, the total number of xX that μ maps to u is at most

t𝖫𝖾𝖺𝗏𝖾𝗌(𝒯)0pt𝒯(t)=k|{xX:x is consistent with t}|. (1)
 Remark 5.7.

Before explaining the details of our analysis, it is useful to discuss a naive bound on (1) that does not suffice to yield our bounds: Naively, there could be (2k)k leaves in 𝒯 at depth k, and each such leaf t could have the property that E(t) forms a clique on =O(k) coordinates when viewed as a graph. In this case, the fraction of xX that could be consistent with the intersection Ri1,j1Rik,jk is (1/n). If we simply take a union bound over all (2k)k paths, the upper bound we would get on (1) is (2k)k(1/n) which, since is only O(k), is larger than 1 unless kk is at most polynomial in n, which requires that k is o(log2n).  

In light of Remark 5.7, we need to be more careful about how we bound (1). For tV(𝒯), we define its equality graph G(t) to be a graph with vertex set [m] and edge set E(t). We use this name because if x is consistent with t, then xi=xj for all (i,j)E(t). We say that an edge (i,j) denoting xi=xj is implied by equality graph G(t) if adding it completes a cycle in G(t).

The key observation is the following.

Claim 5.8.

Let t be a node in 𝒯, and G(t) its associated equality graph. If t has out-degree strictly larger than 1 in 𝒯, then none of the outgoing edges can be labelled by an (i,j) that is implied by G(t).

Proof.

We prove the contrapositive. Consider any x consistent with the path to t in 𝒯 (meaning xi=xj for all (i,j)E(t)). Let T be the triangle labelling node t and consider the y that we choose when processing T in Algorithm 2. If there is some outgoing edge from t labelled (i,j) that is implied by G(t), then Ri,jTy and hence yi=yj. Since we know that xi=xj is already implied in T, the single rectangle Ri,j covers all of Ty, so t will have out-degree 1 in 𝒯.

˜5.8 implies that every path in 𝒯 goes through a node that branches at least 2k times, since k edges must imply equality constraints on at least 2k coordinates (the worst case is a clique). We simplify 𝒯 further by collapsing nodes of 𝒯 with out-degree 1. Then we are left with 𝒯′′, which is a tree with every path of length between 2k and k. Since the input distribution on X is uniform and none of the out-degree 1 edges of 𝒯 involve new constraints by ˜5.8, the probability that x is consistent with any leaf t𝒯′′ is precisely (1/n)0pt𝒯′′(t). Then we can bound (1) as follows:

t𝒯0pt𝒯(t)=k |{xX:x is consistent with t}|
=t𝖫𝖾𝖺𝗏𝖾𝗌(𝒯′′)|{xX:x is consistent with t}|
=i=2kkt𝖫𝖾𝖺𝗏𝖾𝗌(𝒯′′)0pt𝒯′′(t)=i|{xX:x is consistent with t}|
i=2kk(2k)i(1/n)isince 𝒯 and hence 𝒯′′ has out-degree at most 2k
|X|i=2kk(1/2)isince k=n/4
22k+1|X|.

This implies that the number of xX that get assigned to u by μ is at most |X|22k+1|X|2n1/4/2+1 as required. The analogous bound holds for the number of y assigned to u by μ. We now have all we need to prove our main theorem.

Proof of Theorem 1.5.

Let k=n/4. By Lemma 5.5, μ given by Algorithm 1 maps at least 1/2 of the elements of X or elements of Y to vertices of D. Choose the applicable X or Y. By Lemma 5.6, at most a 2n1/4/2+1 fraction of these can map to a single vertex of D. Therefore D has at least 2n1/4/22 vertices.

 Remark 5.9.

Hrubeš and Pudlák [16] proved their lower bound using the interpolation method combined with a modified form of a general monotone switching lemma of Jukna [19]. The construction of Algorithm 2 has some flavor of the monotone switching lemma arguments, but the overall argument here seems fairly different. It would not be surprising that if one could modify this method to yield a similar lower bound to the one we give here, but exactly how to do that is not clear. In any case, we find the form of the bottleneck counting argument appealing.

6 Multiparty Communication Lower Bounds for all 𝒎>𝒏

See 1.3

We note that this is essentially optimal in that a simple randomized protocol nearly matches our lower bound.

Proposition 6.1.

For mn+n11/k and klogn/4, there is a randomized k-party number-in-hand protocol for 𝖢𝗈𝗅𝗅m,n1/kk with complexity O(n1/21/(2k)logn).

Details of both proofs are in our full paper [3]. We sketch the proof of Theorem 1.3, which simplifies and generalizes ideas of Yang, Zhang, and Wang [32, 31] to the k>2-party setting for 𝖢𝗈𝗅𝗅m,n1/kk. It is based on a method for decomposing the input space into structured rectangles on which a protocol’s output is constant.

Definition 6.2.

For a random variable X supported on ΩJ, we say it is (1δ)-dense if the min-entropy of all its projections is nearly as large as possible; that is, for all IJ, H(X(I))(1δ)|I|log|Ω|, where X(I) denotes X marginalized to the coordinates in I.

For 𝖢𝗈𝗅𝗅m,n1/kk we have supp(Xi)=Ωm for Ω=[n1/k] and we will choose δ=1logn.

Definition 6.3 (Structured rectangle).

Given a rectangle R=X1××Xk, where each XiΩm, we say that R is structured iff there exist J1,,Jk[m] and τ1,,τk where each τi:[m]JiΩ such that

  • Xi is (1δ)-dense on the coordinates in Ji and

  • Xi is fixed to τi on the coordinates in Ji¯:=[m]Ji.

Using ideas from [31] we obtain:

Lemma 6.4.

Let Π be a deterministic k-party number-in-hand protocol solving 𝖢𝗈𝗅𝗅m,n1/kk. There is a partition of the inputs into structured rectangles, each of which yields a fixed output of Π, such that the probability distribution leaf on these structured rectangles induced by uniform inputs satisfies 𝐄Rleafi|Ji¯|2kCC(Π) where J1,,Jk are the sets associated with the structured property of R.

Our proof considers rectangles in the support of leaf of three kinds: (1) Those where i|Ji¯| is larger than its expected value of 2kCC(Π), (2) those where it is not much larger and every element of the rectangle contains some fixed collision, and (3) the rest. The fraction of inputs in rectangles of type (1) is small by Markov’s inequality and the fraction in rectangles of type (3) on which any fixed answer of Π can be correct, is small because they are structured. Analyzing the total measure of inputs in rectangles of type (2) relies on a subtle charging scheme that allocates the total number of such inputs to rectangles of all types using a per-rectangle fraction proportional to min(i(|Ji¯|2),k2CC2(Π))/n11/k.

7 Discussion

We end by discussing some related problems and directions for future study. In particular, we highlight three possible directions.

  • Multiparty DAG-like communication lower bounds. In general, it would be interesting to see if the 2Ω(n1/4) we give can be further improved, or if any nontrivial (size 2o(n)) cutting planes refutation of BPHPnn+1 exists. One possible way to improve the lower bound could be to study a multiparty (k>2) version of DAG-like protocols. Concretely, could one can prove DAG-like communication lower bounds for the k-player analog 𝖲𝖾𝖺𝗋𝖼𝗁BPHPnmk? We have shown that generalizing to k players helps in the tree-like case, and perhaps this holds true in the DAG-like setting as well.

  • Stronger bounds for tree-like cutting-planes proof complexity of the weak bit pigeonhole principle When m=n+Ω(n), we only obtain the weaker 2Ω(n) size lower bound for BPHPnm, rather than the 2no(1) size lower bound we obtain for values of m closer to n. Can we extend the range of our strong lower bound to all values of m>n? To do so we must use a technique that does not use randomized communication complexity.

  • Finally, we highlight that for m close to n, the loss of 2k in the denominator of Theorem 1.1 could potentially be improved when mn+n1/k. Indeed, we do not suspect that it should be present at all, and we conjecture that 𝖲𝖾𝖺𝗋𝖼𝗁BPHPnmk should remain hard for k all the way up to logn. However, it seems unlikely that any reduction from k-party disjointness would be able to achieve this since an additional input bit per player seems essential in implementing the reduction.

References

  • [1] Albert Atserias, Moritz Müller, and Sergi Oliva. Lower bounds for DNF-refutations of a relativized weak pigeonhole principle. J. Symb. Log., 80(2):450–476, 2015. doi:10.1017/JSL.2014.56.
  • [2] Paul Beame, Toniann Pitassi, and Nathan Segerlind. Lower bounds for Lovász–Schrijver systems and beyond follow from multiparty communication complexity. SIAM J. Comput., 37(3):845–869, 2007. doi:10.1137/060654645.
  • [3] Paul Beame and Michael Whitmeyer. Multiparty communication complexity of collision-finding and cutting planes proofs of concise pigeonhole principles. Electron. Colloquium Comput. Complex., TR25-057, 2025. URL: https://eccc.weizmann.ac.il/report/2025/057.
  • [4] Maria Luisa Bonet, Toniann Pitassi, and Ran Raz. Lower bounds for cutting planes proofs with small coefficients. In Proceedings of the Twenty-Seventh Annual ACM Symposium on Theory of Computing (STOC 1995), pages 575–584, Las Vegas, Nevada, 1995. ACM. doi:10.1145/225058.225275.
  • [5] Mark Braverman and Rotem Oshman. The communication complexity of number-in-hand set disjointness with no promise. Electron. Colloquium Comput. Complex., TR15-002, 2015. URL: https://eccc.weizmann.ac.il/report/2015/002.
  • [6] Samuel R. Buss and György Turán. Resolution proofs of generalized pigeonhole principles. Theor. Comput. Sci., 62(3):311–317, 1988. doi:10.1016/0304-3975(88)90072-2.
  • [7] Arkadev Chattopadhyay and Toniann Pitassi. The story of set disjointness. SIGACT News, 41(3):59–85, 2010. doi:10.1145/1855118.1855133.
  • [8] Stefan S. Dantchev, Nicola Galesi, Abdul Ghani, and Barnaby Martin. Proof complexity and the binary encoding of combinatorial principles. SIAM J. Comput., 53(3):764–802, 2024. doi:10.1137/20M134784X.
  • [9] Stephan Gocht, Jakob Nordström, and Amir Yehudayoff. On division versus saturation in pseudo-boolean solving. In Proceedings of the Twenty-Eighth International Joint Conference on Artificial Intelligence, IJCAI 2019, pages 1711–1718. ijcai.org, August 2019. doi:10.24963/IJCAI.2019/237.
  • [10] Mika Göös and Siddhartha Jain. Communication complexity of collision. In Approximation, Randomization, and Combinatorial Optimization. Algorithms and Techniques, APPROX/RANDOM 2022, volume 245 of LIPIcs, pages 19:1–19:9. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2022. doi:10.4230/LIPICS.APPROX/RANDOM.2022.19.
  • [11] Dima Grigoriev, Edward A. Hirsch, and Dmitrii V. Pasechnik. Complexity of semi-algebraic proofs. In STACS 2002, 19th Annual Symposium on Theoretical Aspects of Computer Science, Proceedings, volume 2285 of Lecture Notes in Computer Science, pages 419–430. Springer, 2002. doi:10.1007/3-540-45841-7_34.
  • [12] Armin Haken. The intractability of resolution. Theor. Comput. Sci., 39:297–308, 1985. doi:10.1016/0304-3975(85)90144-6.
  • [13] Armin Haken and Stephen A. Cook. An exponential lower bound for the size of monotone real circuits. J. Comput. Syst. Sci., 58(2):326–335, 1999. doi:10.1006/JCSS.1998.1617.
  • [14] Johan Håstad. On small-depth Frege proofs for PHP. In 64th IEEE Annual Symposium on Foundations of Computer Science, FOCS 2023, pages 37–49. IEEE, November 2023. doi:10.1109/FOCS57990.2023.00010.
  • [15] Pavel Hrubes and Pavel Pudlák. A note on monotone real circuits. Electron. Colloquium Comput. Complex., TR17-048, 2017. URL: https://eccc.weizmann.ac.il/report/2017/048.
  • [16] Pavel Hrubes and Pavel Pudlák. Random formulas, monotone circuits, and interpolation. Electron. Colloquium Comput. Complex., TR17-042, 2017. URL: https://eccc.weizmann.ac.il/report/2017/042.
  • [17] Russell Impagliazzo, Toniann Pitassi, and Alasdair Urquhart. Upper and lower bounds for tree-like cutting planes proofs. In Proceedings of the Ninth Annual Symposium on Logic in Computer Science (LICS ’94), pages 220–228, Paris, France, 1994. IEEE Computer Society. doi:10.1109/LICS.1994.316069.
  • [18] Dmitry Itsykson and Artur Riazanov. Proof complexity of natural formulas via communication arguments. In Proceeedings of the 36th Computational Complexity Conference, CCC 2021, volume 200 of LIPIcs, pages 3:1–3:34. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2021. doi:10.4230/LIPICS.CCC.2021.3.
  • [19] Stasys Jukna. Boolean Function Complexity - Advances and Frontiers, volume 27 of Algorithms and combinatorics. Springer, 2012. doi:10.1007/978-3-642-24508-4.
  • [20] Jan Krajícek, Pavel Pudlák, and Alan R. Woods. An exponential lower bound to the size of bounded depth Frege proofs of the pigeonhole principle. Random Struct. Algorithms, 7(1):15–40, 1995. doi:10.1002/RSA.3240070103.
  • [21] Saburo Muroga, Iwao Toda, and Satoru Takasu. Theory of majority decision elements. Journal of the Franklin Institute, 271(5):376–418, 1961.
  • [22] Noam Nisan. The communication complexity of threshold gates. Combinatorics, Paul Erdos is Eighty, 1(301-315):6, 1993.
  • [23] Toniann Pitassi, Paul Beame, and Russell Impagliazzo. Exponential lower bounds for the pigeonhole principle. Comput. Complex., 3:97–140, 1993. doi:10.1007/BF01200117.
  • [24] Pavel Pudlák. Lower bounds for resolution and cutting plane proofs and monotone computations. J. Symb. Log., 62(3):981–998, 1997. doi:10.2307/2275583.
  • [25] Anup Rao and Amir Yehudayoff. Communication Complexity: and Applications. Cambridge University Press, 2020. doi:10.1017/9781108671644.
  • [26] Ran Raz and Avi Wigderson. Monotone circuits for matching require linear depth. J. ACM, 39(3):736–744, 1992. doi:10.1145/146637.146684.
  • [27] Hanif D. Sherali and Warren P. Adams. A hierarchy of relaxations between the continuous and convex hull representations for zero-one programming problems. SIAM J. Discret. Math., 3(3):411–430, 1990. doi:10.1137/0403036.
  • [28] Dmitry Sokolov. Dag-like communication and its applications. In Computer Science - Theory and Applications - 12th International Computer Science Symposium in Russia, CSR 2017, Proceedings, volume 10304 of Lecture Notes in Computer Science, pages 294–307. Springer, 2017. doi:10.1007/978-3-319-58747-9_26.
  • [29] Dmitry Sokolov. Random (log n)-CNF are hard for cutting planes (again). In Proceedings of the 56th Annual ACM Symposium on Theory of Computing, STOC 2024, Vancouver, BC, Canada, June 24-28, 2024, pages 2008–2015. ACM, 2024. doi:10.1145/3618260.3649636.
  • [30] Emanuele Viola. The communication complexity of addition. Combinatorica, 35(6):703–747, 2015. doi:10.1007/S00493-014-3078-3.
  • [31] Shuo Wang, Guangxu Yang, and Jiapeng Zhang. Communication complexity of set-intersection problems and its applications. Electron. Colloquium Comput. Complex., TR23-164, 2023. URL: https://eccc.weizmann.ac.il/report/2023/164.
  • [32] 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 2024, pages 630–639. ACM, June 2024. doi:10.1145/3618260.3649607.