Abstract 1 Introduction 2 Preliminary 3 Lower Bounds for Set Intersection 4 Lower Bounds for Chained Index References Appendix A Proof of Claim 30 Appendix B Proof of Lemma 13

A Min-Entropy Approach to Multi-Party Communication Lower Bounds

Mi-Ying (Miryam) Huang ORCID Thomas Lord Department of Computer Science, University of Southern California, Los Angeles, CA, USA Xinyu Mao ORCID Thomas Lord Department of Computer Science, University of Southern California, Los Angeles, CA, USA Shuo Wang ORCID Department of Mathematics, Massachusetts Institute of Technology, Cambridge, MA, USA Guangxu Yang ORCID Thomas Lord Department of Computer Science, University of Southern California, Los Angeles, CA, USA Jiapeng Zhang ORCID Thomas Lord Department of Computer Science, University of Southern California, Los Angeles, CA, USA
Abstract

Information complexity is one of the most powerful techniques to prove information-theoretical lower bounds, in which Shannon entropy plays a central role. Though Shannon entropy has some convenient properties, such as the chain rule, it still has inherent limitations. One of the most notable barriers is the square-root loss, which appears in the square-root gap between entropy gaps and statistical distances, e.g., Pinsker’s inequality. To bypass this barrier, we introduce a new method based on min-entropy analysis. Building on this new method, we prove the following results.

  • An Ω(Niαimaxi{αi}/k) randomized communication lower bound of the k-party set-intersection problem where the i-th party holds a random set of size N1αi.

  • A tight Ω(n/k) randomized lower bound of the k-party Tree Pointer Jumping problems, improving an Ω(n/k2) lower bound by Chakrabarti, Cormode, and McGregor (STOC 08).

  • An Ω(n/k+n) lower bound of the Chained Index problem, improving an Ω(n/k2) lower bound by Cormode, Dark, and Konrad (ICALP 19).

Since these problems served as hard problems for numerous applications in streaming lower bounds and cryptography, our new lower bounds directly improve these streaming lower bounds and cryptography lower bounds.

On the technical side, min-entropy does not have nice properties such as the chain rule. To address this issue, we enhance the structure-vs-pseudorandomness decomposition used by Göös, Pitassi, and Watson (FOCS 17) and Yang and Zhang (STOC 24); both papers used this decomposition to prove communication lower bounds. In this paper, we give a new breath to this method in the multi-party setting, presenting a new toolkit for proving multi-party communication lower bounds.

Keywords and phrases:
communication complexity, lifting theorems, set intersection, chained index
Funding:
Mi-Ying (Miryam) Huang: Supported by NSF CAREER award 2141536.
Xinyu Mao: Supported by NSF CAREER award 2141536.
Shuo Wang: Supported by NSF CCF award 2227876.
Guangxu Yang: Supported by NSF CAREER award 2141536.
Jiapeng Zhang: Supported by NSF CAREER award 2141536.
Copyright and License:
[Uncaptioned image] © Mi-Ying Huang, Xinyu Mao, Shuo Wang, Guangxu Yang, and
Jiapeng Zhang; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Communication complexity
Related Version:
Previous Version: https://eccc.weizmann.ac.il/report/2024/067/
Acknowledgements:
We thank anonymous reviewers for their helpful comments.
Editors:
Srikanth Srinivasan

1 Introduction

Information complexity is one of the most powerful tools in proving communication complexity lower bounds [17, 5, 6, 23, 40] and streaming lower bounds [5, 16, 2, 31, 3, 13, 37, 12]. The idea of information complexity is to analyze the mutual information between the inputs held by the communication parties and the communication transcript. The definition of information complexity is similar to communication complexity, with information cost replacing communication cost. For a protocol Π, a popular notion of information cost is defined by IC(Π)=𝖽𝖾𝖿I(𝑿;Π(𝑿,𝒀)|𝒀)+I(𝒀;Π(𝑿,𝒀)|𝑿), where 𝑿 and 𝒀 are the input distribution of Alice and Bob respectively and I is the mutual information. Intuitively, IC(Π) captures the mutual information of the inputs and the communication transcript, which is a lower bound of the communication cost. Besides this specific definition, there are many different variants that are smartly designed for diverse applications. However, they all share a similar idea: capture the information cost (usually by Shannon entropy) between the input distribution and the transcript.

Despite a vast number of applications successfully given by the information complexity-based approaches, this framework still has some inherent limitations. Indeed, some significant barriers are not only associated with some specific variants of information cost notions, but further deeply caused by the entropy itself. In this direction, one notable limitation is the square-root loss barrier.

Square-root loss barrier

We first use a simple example to illustrate this phenomenon. Let 𝑰 be a random variable that outputs 1 with probability 1/2+ε and 0 with probability 1/2ε. This is a biased coin with a Θ(ε) statistical distance to the uniform distribution. However, on the other hand, the entropy gap between them has only Θ(ε2). This square gap is not significant if ε is a constant. However, the loss would become very large when it becomes very small. Beyond this simple example, this is indeed a general gap between entropy loss and statistical distance. For example, any result that applies Pinsker’s inequality has a good chance of creating this gap.

Lemma 1 (Pinsker’s inequality).

If P and Q are two distributions, then

DTV(P,Q)12DKL(PQ)

Here DTV(P,Q) is the total variation distance of P and Q and DKL(PQ) is the KL-divergence.

This quadratic gap makes it difficult to get good bounds via entropy-based analysis in many applications. For instance, proofs of multiparty unique-set disjointness [5], set disjointness under product distribution [23, 40], the chained index problem [21], multi-party pointer jumping problem [15], tree pointer jumping problem [16], pointer chasing problem [39], among others, all meet the square-root loss comparing with the upper bounds.

Despite resolving the square-root loss for some specific problems, these efforts are ad-hoc and use non-standard variants of Shannon entropy. Hence, it is hard to extend them for broader applications. A natural question arises: Could we use any measurement other than the Shannon entropy (or its close variants)?

Now, we revisit the example above. For a random variable 𝑿 supported on {0,1}n with entropy H(𝑿)nε, we know the statistical distance between 𝑿 and the uniform distribution is Θ(ε) by Pinsker’s inequality. Furthermore, improving Pinsker’s inequality is hard as it is tight in general. However, on the other hand, for a random variable 𝑿 with min-entropy nε, a simple calculation shows that the statistical distance between 𝑿 and the uniform distribution is Θ(ε). In this paper, min-entropy is a good candidate for avoiding square root loss in general settings.

Analysis of min-entropy via structure-vs-pseudorandomness

Though the min-entropy itself does not meet the square-root loss, there are other challenges in analyzing it. One of the most significant challenges is that, unlike the Shannon entropy, there is no chain rule for min-entropy, where a chain rule is an essential tool in entropy.

In order to overcome this issue, we adopt the structure-vs-pseudorandomness decomposition to serve as the “chain rule” in min-entropy analysis. This approach has been successfully applied in sunflower lemmas [36, 1] and query-to-communication lifting theorems [29, 30, 35, 46, 38]. Though this approach has been successfully applied in several areas, it has not been studied in multi-party settings. In this paper, we extend this approach to the multi-party setting. Beyond the three problems studied in this paper, we believe the min-entropy-based analysis could provide more applications to multi-party problems.

1.1 Our Results

Building on min-entropy analysis, we improve the lower bounds for three communication problems: (1) Set Intersection [7], (2) Tree Pointer Jumping [16], and (3) Chained Index [21].

1.1.1 Set Intersection Problem

To show the advantages of our min-entropy approach, we consider the search version of the set-disjointness problem, which is called the set-intersection problem. There are two versions of the set-intersection problems. The first one requires the players to find the whole intersection; the second one only asks the players to find one element from the intersection. Together, the set-intersection problems have been studied in many papers [34, 42, 11, 14, 41, 7, 45, 27, 26, 32, 9, 40]. In this paper, we focus on the second version. The setting is: each player i is assigned a subset Si of [N], and the goal changes to finding an element ai=1kSi.

We consider the communication complexity under product distribution here, and there are two typical product distributions that have been widely studied before. One is the fixed-size product distribution, where each player i receives a uniformly random subset Si[N] with |Si|=ni. The other one is the Bernoulli product distribution, where each player i receives a random set Si sampled as follows: for each element a[N], aSi independently with probability mi. Babai, Frankl, and Simon [4] first proposed the communication complexity of the set-disjointness problem under fixed-size product distribution where ni=N, and gave an Ω(N) lower bound. Their proof could also be adapted to the setting of Bernoulli product distribution with mi=N1/2. Recently, this bound was extended to the k-party setting by a recent paper by Dershowitz, Oshman, and Roth [23]. They showed that when klogN/6, the communication complexity under the Bernoulli product distribution, where mi=N1/k, is Ω(N11/k/k2). Both of these decision-version lower bounds gave various applications.

In the context of the set-intersection, lower bounds are less known, though it also provides many applications. Bauer, Farshim, and Mazaheri [7] first gave a lower bound under Bernoulli product distribution with applications to cryptography. To be more specific, they proved:

Theorem 2 ([7]).

For the 2-party set-intersection problem under Bernoulli product distribution, where mi=Nαi, α1+α21, its communication complexity is Ω(Nα1+α2+min{α1,α2}1).

Note that this problem is exactly the search version of the set-disjointness problem considered in [4, 23]. Compared to the set-disjointness problem, set-intersection could be studied in a larger range of parameters, i.e., α1+α2<1Ω(1), where the intersection could be very large, i.e., as large as NΩ(1) with high probability.

However, the theorem by [7] is far from tight and does not provide a non-trivial bound when α1,α2 are small. One of the main obstacles here is that the size of the intersections is large, but players only need to find one common element from many valid answers.

We consider the communication problem in [7], and extend it to the k-party setting. Concretely, we assume that each player holds a (random) set Si of size |Si|N1αi with iαi1, and prove the following results for set-intersection.

Theorem 3.

For the k-party set-intersection problem under Bernoulli product distribution, where mi=Nαi, iαi1 and k0.1min{Nmini{αi}/2,N(1maxi{αi})/3}111We assume all the distributions considered in this paper satisfy this constraint.:

  1. 1.

    the communication complexity is Ω(Niαimaxi{αi}/k) to achieve a constant accuracy;

  2. 2.

    there exists a protocol that solves this problem under the distribution mentioned above with a constant accuracy and uses O(klogNNiαimaxi{αi}) communication cost.

Note that this theorem establishes the first non-trivial lower bound when 2α1+α21 (we assume α1α2 here). Actually, it implies that Θ~(Niαimaxi{αi}) is tight (up to logarithmic factors when k<logN) for the distributional-version of set-intersection considered in [7]. Also, our bound is similar to [23] when α1==αk=1/k, where they proved a lower bound of Ω(N11/k/k2) for klogN/6. Similar to the two-party setting, our result significantly strengthens theirs when the size of the intersection is large.

1.1.2 Tree Pointer Jumping Problem

The Tree Pointer Jumping problem is a communication problem introduced by Chakrabarti, Cormode, and McGregor [16] with applications in streaming lower bounds. For t,k2, we consider a complete k-level t-ary tree T rooted at v1. The k-party Tree Pointer Jumping problem, denoted by TPJk,t(ϕ), takes as an input a function ϕ:V(T)[t] with ϕ(v){0,1} if v is a leaf of T , where V(T) is the set of nodes of T. We use to denote the set of all valid functions ϕ here. For each input ϕ, we define the functions gϕ by,

gϕ(v)={the ϕ(v)-th child of vif v is not an internal node;ϕ(v)if v is a leaf.

The output of TPJk,t(ϕ) is defined by TPJk,t(ϕ):=gϕ(gϕ(gϕ(v1))). In the communication setting, the input ϕ is distributed to k players. The problem is described as follows:

  • Player i receives the labels of the i-th level nodes, i.e., the first player receives ϕ(v1),…, and the last player receives the labels of the leaves.

  • In each round, players send messages in reverse order: from the last player to the first player. The cost of this round is the total number of bits sent by all players.

  • Players could communicate (k1) rounds, and the first player outputs the answer.

The goal of the players is to compute TPJk,t(ϕ) while minimizing the maximum cost of each round. For any (r1)-round protocol Π, we use Rmax(Π) to denote the maximum communication cost in all rounds. In this direction, [16] first proved the following lower bound.

Theorem 4 ([16]).

For any (k1)-round protocol Π with 𝐏𝐫ϕUnif()[Π(ϕ)=TPJk,t(ϕ)]2/3, we have that Rmax(Π)=Ω(t/k2).

Chakrabarti, Cormode, and McGregor [16] first used Theorem 4 to improve multi-pass streaming lower bound for median finding. Later on, Chakrabarti and Wirth [18] used this theorem to show a pass/approximation trade-off for the SET-COVER in the semi-streaming setting. In this paper, we improve the lower bound from Theorem 4 based on min-entropy analysis.

Theorem 5.

For any (k1)-round protocol Π with 𝐏𝐫ϕUnif()[Π(ϕ)=TPJk,t(ϕ)]2/3, we have that Rmax(Π)=Ω(t/k).

As corollaries, our improved lower bounds can be directly used to improve the applications given by [16] and [18]. Since this paper is a merged version of [44] and [33], we omit the proof of Theorem 5. Readers can refer to [33] for the complete proof and further applications.

1.1.3 Chained Index Problem

The Chained Index problem, introduced by Cormode, Dark, and Konrad [21], is another useful tool with many applications in streaming lower bounds [21, 24, 25, 10, 22]. For this problem, we consider the following communication setting.

  • There are k players. Each player i receives an input zi=(σi,xi)[n]×{0,1}n

  • It is promised that x1(σ2)==xk1(σk). Here xi(σi+1) is the σi+1-th coordinate of xi.

  • Their goal is to compute xi(σi+1) through a one-way communication from the first player to the last player, where the last player should output the answer.

We say that a one-way protocol solves the Chained Index problem if for every input (z1,,zk), the last player always outputs the correct answer with probability 2/3. The communication cost of this protocol is the total communication bits of all players. Using tools from information complexity, Cormode, Dark, and Konrad proved the following lower bounds for the Chained Index problem.

Theorem 6 ([21]).

Any one-way communication protocol that solves the Chained Index problem has randomized communication complexity Ω(n/k2).

Since it has been introduced, many streaming lower bounds [21, 24, 25, 10, 22] were built on Theorem 6. Interested readers can find detailed discussions in the papers mentioned above. Theorem 6 was obtained by direct entropy-based analysis. In this paper, we improve this lower bound.

Theorem 7.

Any one-way communication protocol that solves the Chained Index problem has randomized communication complexity Ω(n/k+n).

1.2 Proof Outline

In this section, we give a brief overview to our proof technique and we use the set-intersection problem for illustration. The proofs for chained index problem is similar in spirit.

Instead of considering Bernoulli distributions, we consider the following product distribution to simplify our presentation:

  • Each player i independently and uniformly samples cN1αi elements from [N] (may have duplicates), where c equals (1+2/k) here.

Thus, each player i receives a vector in [N]cN1αi and gets its set Si[N] by removing the duplicate elements in the vector. In general, for any I[cN1αi] and β[N]I, we consider β as a subset of [N] in a similar way. We prove the lower bound under this distribution, and then reductions are established in Section 3.3 to prove our main theorem.

It is well known that a deterministic protocol Π partitions the input domain into 2|Π| rectangles by step-by-step communication. The crucial idea of our proof is to further partition these leaf rectangles in the protocol tree into many structured rectangles. A structured rectangle R=X1×X2××Xk satisfies that: for each i, Xi is fixed on some coordinates and pseudorandom on the remaining coordinates. The formal definition is given below.

Definition 8 (Structured rectangles).

Assuming R=X1×X2××Xk, where each Xi is a subset of [N]cN1αi, is a rectangle. We say R is a structured rectangle if there exist subsets of coordinates J1,J2,,Jk with Ji[cN1αi] satisfying that

  • For each i, there exists a βi[N]Jic such that xiXi,xi(Jic)=βi. Here, Jic is the complement of Ji defined by Jic:=[cN1αi]Ji and xi(Jic)[N]Jic is the values of xi on Jic.

  • For each i, Xi has a high block-wise min-entropy (see definitions in Section 2) on the coordinates Ji.

The notion of structured rectangle has also been widely used in query-to-communication lifting theorems [30, 19, 35].

In the decomposition, we recursively (starting from the root to the leaves) decompose all rectangles in the protocol tree, i.e., for a node (which is also a rectangle), we decompose it based on the decomposition of its ancestors. This is the key step compared to existing decomposition (pre-sampling techniques) in cryptography, which may lead to new applications. The formal process of this decomposition is referred to Section 3.

After the decomposition process, each leaf has been partitioned into many structured rectangles. For a structured rectangle R=X1×X2××Xk associated with J1,,Jk and βi[N]Jic for i[k], we say that:

  1. 1.

    R is bad if iβi.

  2. 2.

    R is good if iβi=. We also call good structured rectangles as pseudorandom rectangles.

Then, our proof consists of the following two parts.

  • If the communication complexity of Π is small, the total size of bad structured rectangles is small compared to the size of the input domain (formalized by Lemma 17);

  • On the other hand, we show that players can not find a common intersection from pseudorandom rectangles (formalized by Lemma 18).

Combining the two parts, we are able to prove the main theorem. We defer the detailed proofs to Section 3.

Comparison with existing methods

Similar questions have been widely studied in several recent papers [7, 32, 23, 40]. All of these papers used standard known techniques in communication complexity such as information complexity.

These papers achieved tight bounds for set-disjointness (decision version), or set-intersection enumeration (finding whole intersections). However, all of their bounds for search problems are sub-optimal whenever the size of the set intersection (the solution space for the search problem) is large. By contrast, our method follows the structure-vs-pseudorandomness approach by Yang and Zhang [46], which was inspired by lifting theorems [30, 19, 35]. In [46], authors first introduced the techniques in proving query-to-communication lifting theorems directly to a communication setting without gadgets and proved the communication complexity lower bound for the collision problem in a two-party setting.

Compared to [46], we further extend their approach in two aspects: 1) we generalize this method into the multi-party setting; 2) we adopt it to prove communication lower bounds for search problems with many solutions. To the best of our knowledge, existing lower-bound methods could not address communication problems in these two settings. We believe these two settings could provide many applications.

1.3 Subsequent works and future directions

A late work by Sundaresan [43] further improved the lower bound of the Chained Index problem to Ω(nklogn) via a reduction to a variant called the biased index problem.

Göös et al. [28] investigated quantum-classical separations in the communication model. To be more specific, they exhibit a total search problem whose communication complexity in the quantum simultaneous message passing model is exponentially smaller than in the classical two-way randomized model, which they call the Bipartite NullCodeword problem. To establish classical lower bounds, they employed a structure-vs-randomness approach, akin to the techniques used in [46] and this paper.

Another notable result was demonstrated by Mao, Yang, and Zhang in [38], where they improved the lower bound for a classical communication problem known as the k-step pointer chasing problem by the structure-vs-randomness approach.

In [8], Beame and Whitmeyer established near-optimal lower bounds for the k-party collision-finding problem of the strong bit pigeonhole principle which implies the tree-like semantic cutting-planes refutation lower bounds in proof complexity. However, their lower bounds only hold for the strong bit pigeonhole principle, they left lower bounds for the weak bit pigeonhole principle as an open question.

Paper organization

In Section 2, we give preliminaries. Section 3 shows an almost tight bound for the Set Intersection problem. In Section 4, we prove an improved lower bound for the Chained Index problem.

2 Preliminary

Definitions for set intersection problem

To begin with, we formally define the product distributions for set intersection problem adopted in this paper. For fixed parameters: k is the number of parties, N is the size of the domain, and αi(0,1) are parameters indicating the size of each player’s set. We consider the following three types of hardness distributions in this paper (two of them have appeared in Section 1):

  1. 1.

    Each player i independently and uniformly samples cN1αi elements from [N] (may have duplicates), where c equals (1+2/k).

  2. 2.

    Each player i independently and uniformly samples ciN1αi distinct elements from [N], where 11/kci1+1/k.

  3. 3.

    Each player i independently samples its set Si with that every element a[N] is contained in Si with probability Nαi.

We assume that iαi1, otherwise the existence of intersections can be not guaranteed. Furthermore, if iαi1C holds for some constant C>0, the common intersection of all players could be very large (NC).

The hardness distribution 3 is the Bernoulli product distribution with wide applications. Previous papers have mainly focused on this distribution. We prove the lower bound under distribution 1, and use two simple reductions to get the lower bound results for the hardness distributions 2 and 3. We refer to the two reductions to Section 3.3. In what follows, our discussion mainly focuses on distribution 1.

For a distribution D and a communication protocol Π, we define the accuracy of Π on D by:

AccΠ(D):=𝐏𝐫S1,,SkD[Π(S1,,Sk)i=1kSi].

For simplicity, we define this accuracy notion, which does not take the cases when sets are disjoint into consideration, differently from [7] in which they also consider the accuracy of distinguishing disjoint cases, namely, they define

AccΠ(D):=𝐏𝐫S1,,SkD[Π(S1,,Sk)i=1kSi or Π(S1,,Sk)=i=1kSi=].

Since we aim to establish lower bounds for those protocols achieving AccΠ(D)=Ω(1), we only consider the range of α1,,αk with222𝐏𝐫S1,,SkD[i=1kSi]>1/2 is guaranteed by the definitions of hardness distribution 3 when iαi1.

𝐏𝐫S1,,SkD[i=1kSi]>1/2.

In this paper, our lower bound result shows that achieving AccΠ(D)>ϵ, where epsilon is a constant less than 1/2, requires large amounts of communication. This also implies a non-trivial hardness result to achieve AccΠ(D)>ϵ+1/2 since the disjoint cases could contribute at most 1/2 to AccΠ(D) when 𝐏𝐫S1,,SkD[i=1kSi]>1/2 holds. Hence, our results also imply hardness results under the [7] setting.

Next, we introduce some useful notions in communication complexity. In a k-party communication problem, where each party holds an input xi from a domain Δi, a rectangle is defined by R:=X1×X2××Xk (XiΔi).

For a set XiΔi, we denote 𝑿i as the uniform distribution on Xi. In the set-intersection problem (particularly hard distribution 1), we consider the cases that each input is in Δi=[N]Mi where Mi=cN1αi, and an instance xi[N]Mi can be transformed into a subset of [N] by removing duplicate elements. Also, for two instances xi[N]Mi,xj[N]Mj, we define xixj by the intersection of the two subsets of [N] deduced from xi and xj.

For a set of coordinates Ji[Mi], we use 𝑿i(Ji) to denote marginal distribution of 𝑿i on Ji. For an instance xi[N]Mi and a set of coordinates Ji[Mi], define xi(Ji) to be an instance in [N]Ji by projecting xi on Ji.

Structure-vs-pseudorandomness decomposition

We use capital letters X to denote a set and bold symbols like 𝑹 to denote random variables. For a set X, we use 𝑿 to denote the random variable uniformly distributed over the set X. We introduce the formal definition of min-entropy.

Definition 9 (Min-entropy).

For a random variable 𝐗 taking value on Δ, its min-entropy is defined as follows:

H(𝑿)=minxΔ(log1𝐏𝐫[𝑿=x]).

A useful concept adopted in this paper is the dense notion used in lifting theorems [30, 35].

Definition 10 (Density function).

We define the one-side density function for a random variable 𝐗 on its support [N]J as:

𝒟(𝑿):=|J|logNH(𝑿).

Note that 𝒟(𝐗)0 always holds by definitions and 𝒟(𝐗)=0 when 𝐗 is a uniform distribution.

The density function is also known as the entropy deficiency in lifting theorem papers, and we design the k-side density function in order to extend the two-party results to the k-party setting.

Definition 11 (k-side density function).

For a structured rectangle R=X1×X2××Xk, where each Xi is subset of [N]Mi and associated with a set Ji[Mi], we define its k-side density function as:

𝒟(R)=𝒟(𝑿1(J1))+𝒟(𝑿2(J2))++𝒟(𝑿k(Jk)).

In structure-vs-pseudorandomness decomposition, one of the most important notions, which captures the pseudorandomness, is the block-wise density.

Definition 12 (Block-wise density [29]).

For γ>0. A random variable 𝐗 supported on [N]n is said to be γ-dense if for all nonempty I[n], we have that H(𝐗(I))γ|I|logN, here 𝐗(I) is the marginal distribution of 𝐗 on the set I.

The definition of γ-dense measures the pseudorandomness of a random variable. In our proof, a typical choice of γ=1110klogN for set intersection and γ=12ϵk for the Chain Index problem.333γ=0.9 in previous structure-vs-pseudorandomness decomposition [30, 20, 19, 35].

The following lemma tells us that a random variable could be decomposed by a combination of random variables with dense properties by fixing some positions:

Lemma 13 (Density-restoring partition [30]).

Let X be a subset of [N]M and J be a subset of [M], and there exists an βNJc such that xX,x(Jc)=β. Then, there exists a partition of X:

X:=X1X2Xr

such that every Xi is associated with a set IiJ and a value τi[N]Ii. Then, they satisfy the following properties:

  1. 1.

    xXi,x(Ii)=τi;

  2. 2.

    𝑿i(JIi) is γ-dense;

  3. 3.

    D(𝑿i(JIi))D(𝑿(J))(1γ)|Ii|logN+δi.

Here, we define δi:=log(|X|/|jiXj|).

We also use the following simple version of Lemma 13 for some proofs.

Proposition 14.

Let Z1,,ZT be a partition of the set Z. Then

i=1T|Zi||Z|log|Zi|log|Z|logT.

For dense random variables, we also have the following useful lemma.

Lemma 15.

If 𝐗1,𝐗2,,𝐗 are <k independent (1110klogN)-dense random variables and each 𝐗i takes value from [N]Ji with |Ji|cN1αi, where c is a constant and Nαi=ω(k), then for any element a[N], it holds

𝐏𝐫[ai=1𝑿i]ecNiαi,

here e2.7 denotes the Euler’s number.

Proof.

We know that all 𝑿i’s are independent. Thus, we first bound the probability that 𝐏𝐫[a𝑿i]. Assuming that Ji=(j1,j2,,j|Ji|), we have the following argument

𝐏𝐫[a𝑿i]=𝐏𝐫[aq=1|Ji|𝑿i(jq)]q=1|Ji|𝐏𝐫[a𝑿i(jq)]c(1+1/k)Nαi,

where the last inequality comes from the definition of (1110klogN)-dense. Hence, we know that

𝐏𝐫[ai𝑿i]=i𝐏𝐫[a𝑿i]c(1+1/k)1NiαiceNiαi.

3 Lower Bounds for Set Intersection

In this section, we prove the communication lower bound for the hardness distribution 1 (where each player i gets cNαi independent and uniform samples from [N]). Then, in Section 3.3, we use reductions to obtain lower bounds for hardness distributions 2 and 3. Formally, we prove that:

Theorem 16.

If a communication protocol Π solves k-party set-intersection problem under the hardness distribution 1 with accuracy bigger than 0.1, the communication complexity CC(Π) is Ω(Niαimaxi{αi}k).

3.1 The Decomposition and Sampling Process

The key idea of this proof, as we introduce in Section 1, is to decompose rectangles (nodes444Note that a node of the protocol tree is a rectangle.) of the protocol tree into structured rectangles and analyze the accuracy of the protocol could achieve in those decomposed structured rectangles. We design a decomposition and sampling process in this section to

  • decompose the rectangles of the protocol tree into structured rectangles;

  • sample a decomposed rectangle with respect to its size.

We define the root rectangle of the protocol tree to be Rroot, which contains all valid inputs. Rroot is also a structured rectangle by definitions. We start from Rroot and begin our decomposition and sampling process, which uses a random walk on the protocol tree from the root Rroot to a leaf, and do the decomposition along the path. See Algorithm 1 for the formal decomposition process.

Algorithm 1 The decomposition and sampling process.

We use Rcur to denote the current rectangle of the decomposition and sampling process. It begins with Rcur=Rroot, and at each step Rcur is partitioned into two subrectangles R0,R1 by the protocol. Then, we replace Rcur with R0 or R1 with probability |R0|/|Rcur| or |R1|/|Rcur| (which also equals to |X0|/|Xicur| or |X1|/|Xicur| as we defined in Algorithm 1), and reach a new rectangle. After reaching the new rectangle, the structured property of Rcur may get destroyed, and our decomposition works here to maintain the structured property. We use the density-restoring partition (Lemma 13) to further decompose the current rectangle Rcur into r subrectangles Rcur=R1R2Rr, and each Rj is a structured rectangle. Again, we choose Rj to be our next rectangle with probability |Rj|/|Rcur|, and do the process above recursively until reaching a leaf rectangle. As shown in the decomposition and sampling process, we eventually sample a structured rectangle in the leaf level with respect to its size.

Note that at some point of the random walk, the current rectangle Rcur may not exist on the protocol tree since we do the density-restoring partition to further decompose the rectangles. However, every Rcur that potentially appears in the random walk must be fully contained in a rectangle of the protocol tree. Thus, the protocol Π also partitions Rcur into two sub-rectangles if Rcur is not in the leaf level of the protocol tree.

Note that the output Rcur of the process above is a random variable over rectangles. We define 𝑹leaf to be the random variables over decomposed structured rectangles in the leaf level (not leaf rectangles of the protocol tree, but sub-rectangles of those leaves after decomposition) sampled by the process above, and 𝑹leaf is associated with random sets 𝑱ileafs. For convenience, we define the support of 𝑹leaf to be leaf. One may see the two important properties of the decomposition and sampling process:

  • Every rectangle Rleaf is a structured rectangle;

  • For a rectangle R=X1×X2××Xkleaf, we have that

    𝐏𝐫[𝑹leaf=R]=i|Xi|NcN1αi=|R|NciN1αi.

The verification of the two properties is straightforward from the definition of our decomposition and sampling process. The first statement offers a structured property that makes it easier to analyze the rectangles. The second statement tells us that the probability that 𝑹leaf=R equals the probability that the input lies in R. This is crucial in later bounding the accuracy of Π.

Next, we bound the accuracy of Π. For every structured rectangle R=X1×X2××Xkleaf associated with J1,J2,,Jk, we define Jic as [cN1αi]Ji, namely the fixed parts of Xi. Hence, for each Xi, it holds xXi,x(Jic)=βi since R is a structured rectangle. We can then divide all the rectangles in leaf into two types:

  1. 1.

    R is a bad structured rectangle if iβi;

  2. 2.

    R is a good structured rectangle if iβi=.

Assume R is a bad structured rectangle. Then, there exists a universal common element a555We can choose any element that lies in iβi here. such that aixi for any possible instance (x1,x2,,xk) in R. The protocol is thus able to achieve perfect correctness by outputting a when the input lies in R. Hence, we need to show with a low probability that 𝑹leaf is a bad rectangle, namely the probability that the input lies in bad rectangles is small. To be more specific, we prove the following lemma:

Lemma 17.

If CC(Π)0.0001Niαimaxi{αi}/k, it holds that 𝐏𝐫R𝐑leaf[R is bad]0.05.

For those good structured rectangles, we show the following facts: For a good structured rectangle, the protocol Π cannot achieve high accuracy since there is no intersection on the fixed parts, while the other parts are dense. Formally, we prove the following lemma:

Lemma 18.

For a good structured rectangle R=X1×X2××Xk, it holds that for any a[N],

𝐏𝐫[ai𝑿i]0.05.

Combining the three lemmas above, we can easily prove Theorem 16.

Proof of Theorem 16.

We prove the theorem by showing that communication protocol Π with CC(Π)0.0001Niαimaxi{αi}/k can achieve at most 0.1 accuracy.

It is well known that a communication protocol Π partitions the whole input domain into several leaf rectangles and assigns an answer to each leaf rectangle. With our decomposition and sampling process, original leaf rectangles are further decomposed into the two types of structured rectangles mentioned above. The accuracy of Π comes from the following two parts:

  1. 1.

    The probability 𝐏𝐫[𝑹leaf is bad]=p1.

  2. 2.

    The probability that the protocol outputs the correct answer in a good structured rectangle is p2.

From Lemma 17 and 18, we know that p10.05,p20.05. By a union bound, the total accuracy is thus no more than p1+p20.1 as desired. It suffices to prove the two important lemmas above.

3.2 Proofs of Technical Lemmas

We first prove Lemma 17 by the following round-by-round analysis.

Proof of Lemma 17.

Recall the decomposition process from line 4 to line 12. In each communication round, player i sends one bit, and partitions Xicur into two parts X0,X1. Then, Xicur is replaced by X0 (or X1) with probability |X0||Xicur| (or |X1||Xicur|). In this process, the density function 𝒟(𝑿icur(Ji)) would increase since the size of |Xicur| decreases. This contributes to the density function with an increment of:

  • log(|Xicur||X0|) with probability |X0|/|Xicur|;

  • log(|Xicur||X1|) with probability |X1|/|Xicur|.

Thus, in expectation, the density function of Rcur=X1cur×X2cur××Xkcur after partitioning will increase

|X0||Xicur|log(|Xicur||X0|)+|X1||Xicur|log(|Xicur||X1|)1, (1)

where |Xicur| denotes the size of Xicur before partitioning. Furthermore, if 𝑿icur(Ji) is no longer (1110klogn)-dense, we partition Xicur by Lemma 13 and get Xicur=X1X2Xr and I1I2Ir with Xj(Ij)=τj for all j. We use Lemma 13, where we take γ=11/(10klogN), and get:

𝒟(𝑿j(JiIi))𝒟(𝑿icur(Ji))(1γ)|Ij|logN+γj=𝒟(𝑿icur(Ji))|Ij|10k+δj. (2)

Recall that δj:=log(|Xicur|/|pjXp|) here. In the decomposition process, Xicur is replaced with Xj with probability |Xj|/|Xicur|. Hence, taking the expectation in one communication round, we have

𝔼[δj]=j|Xj||Xicur|log(|Xicur|/|pjXp|)01log11xdx=1. (3)

Thus, combining (1), (2) and (3) and taking expectations, we know that after CC(Π) rounds of communication (where each round communicates exact one bit message), it holds:

𝔼R𝑹leaf[𝒟(R)]2CC(Π)𝔼J1𝑱1leaf,,Jk𝑱kleaf[j=1k|Jjc|]10k.

Here, the 2CC(Π) comes from (1) and (3). We know that 𝔼R𝑹leaf[𝒟(R)]0 from definitions. Hence, we have

j=1k𝔼Jj𝑱jleaf[|Jjc|]20kCC(Π). (4)

We can bound the probability that the bad structured rectangle appears round by round. At each round of communication, if we choose Xj to replace Xicur, then we will fix |Ij| more positions for Xicur. We then consider the probability that this new fixed part contributes to forming a bad structured rectangle with future fixed positions.

Let Rj=X1cur×X2cur×Xj×Xkcur, for any x=(x1cur,x2cur,,xj,,xkcur)Rj, we label it as a error term if aτj, apixpcur(Jp) 666 τj is a fixed subset of [N] with size at most |Ij| since Xj is fixed on Ij. Input x may be labeled many times during the decomposition process.. By Lemma 15, for any aτj,

𝐏𝐫[api𝑿pcur(Jp)]eck1N(p=1kαp)αi

By a union bound, the probability that error terms appear in Rj is

𝐏𝐫[aτj,api𝑿pcur(Jp)]|Ij|eck1N(p=1kαp)αi

Also, we know that the total number of fixed elements equals i=1k|Jic|, which is identical to the summation of |Ij| of every step, thus, the average probability of error terms at the end of the decomposition process is at most

eck1N(iαi)maxi{αi}i=1k𝔼Ji𝑱ileaf[|Jic|].

We note that for any Rleaf, if R is bad, then all instances xR have been labeled as an error term in the decomposition process, together with (4), we have

𝐏𝐫R𝑹leaf[R is bad]eck1N(iαi)maxi{αi}i=1k𝔼Ji𝑱ileaf[|Jic|]0.05.

The last inequality holds since c=(1+2/k) and CC(Π)0.0001Niαimaxi{αi}/k. Next, we show that in the good structured rectangles, the protocol Π cannot achieve large accuracy in finding the common element. This also comes from the structured properties of the rectangles:

Proof of Lemma 18.

Notice that we consider the rectangle R=X1×X2××Xk associated with J1,J2,Jk that has no common elements on fixed parts Jic. Thus, for any element a[N], there exists at least a party i which does not contain a on its fixed part. Thus, we use Lemma 15 for 𝑿i(Ji) with =1, and get

𝐏𝐫[a𝑿i]=𝐏𝐫[a𝑿i(Ji)]ce/Nαi=o(1).

3.3 Lower Bounds for Other Hardness Distributions

In this section, we first establish a reduction from Bernoulli hardness distribution (hardness distribution 3) to hardness distribution 2 by the following lemma:

Lemma 19.

If a communication protocol Π that solves set-intersection under hardness distribution 3 with accuracy ϵ, there exists parameters c1,,ck with each 11/kci1+1/k for hardness distribution 2 so that Π can find set intersection under this distribution with accuracy ϵ2kexp(N1maxi{αi}3k2), which is bigger than ϵ0.01 when N1maxi{αi}100k2logk.

Proof.

We first use Chernoff bound to bound the probability of the size of set Si of each player i exceeding (1+1/k)N1αi or less than (11/k)N1αi under the hardness distribution 3:

𝐏𝐫[||Si|N1αi|>1/kN1αi]2exp(N1αi3k2).

We use A to denote the event that i,||Xi|N1αi|>1/kN1αi. Then, by a union bound, we know that:

𝐏𝐫[A]2kexp(N1maxi{αi}3k2).

Then, condition on ¬A, we have the success probability of Π in finding set intersection under hardness distribution 3 is bigger than ϵ2kexp(N1maxi{αi}3k2). Furthermore, condition on ¬A, the hardness distribution 3 can be represented by a combination of product distributions:

c1,c2,,ckσ(c1,c2,,ck)Dc1,c2,,ck,

where Dc1,c2,,ck denotes the hardness distribution 2 with parameters c1,c2,,ck. Then, the lemma follows from an averaging argument. It suffices to construct a reduction from hardness distribution 2 to hardness distribution 1.

Lemma 20.

If there exists a communication protocol Π with communication complexity C which solves set-intersection under hardness distribution 2 with accuracy ϵ, there exists a communication protocol Π with communication complexity C which solves set-intersection under hardness distribution 1 with accuracy ϵ0.05 when k2Nmini{αi}1100 holds.

Proof.

We construct the communication protocol Π as follows:

  1. 1.

    For each player i, remove the duplicate elements of its input and get a Si[N].

  2. 2.

    Randomly sample ciN1αi elements from Si, Π fail if |Yi|<ciN1αi.

  3. 3.

    Run the communication protocol Π on Yis to find intersection.

We know that the successful probability of Π under hardness distribution 1 is bigger than

ϵ𝐏𝐫[Π fail at step 2].

It suffices to bound 𝐏𝐫[Π fail at step 2]. From the union bound, we have:

𝐏𝐫[Π fail at step 2] k𝐏𝐫[|Si|<ciN1αi]
k𝐏𝐫[#repeated elements in Si>(cci)N1αi].

We know that

𝔼[#repeated elements]=cN1αi(1(11/N)cN1αi1)c2N12αi.

From Markov’s Inequality, we have

𝐏𝐫[#repeated elements>(cci)N1αi]𝔼[#repeated elements]/(cci)N1αikc2Nαi.

If kNαi1100k holds, which is guaranteed by the constraints, 𝐏𝐫[Π fail at step 2]0.05 also holds. This concludes the lemma.

3.4 Efficient Protocols for the Hardness Distribution

In this section, we first explain an efficient protocol for the hardness distribution 3, where we use D3 to denote the distribution, showing that our lower bound result is almost tight for this distribution. Also, this protocol can be easily extended to some more general product distributions sharing "similarities" with the Bernoulli product distribution. Formally, we prove:

Theorem 21.

There is a protocol Π, which solves the hardness distribution 3, with AccΠ(D3)0.1 and

CC(Π)=O(Niαimaxi{αi}logN).

Furthermore, this protocol can be extended to more general distributions. Let D be any distribution that satisfies the following properties:

  1. 1.

    each party holds a set of size Θ(N1αi);

  2. 2.

    the size of intersecting part of all parties is Ω(N1iαi);

there exists a protocol Π with O(klogNNiαimaxi{αi}) communication cost that achieves Ω(1) accuracy under D.

Proof.

To begin with, we first propose an efficient protocol to solve D3. Without loss of generality, we assume α1α2αk and each party i gets a subset Si[N]. Then, the communication protocol Π proceeds as follows:

  1. 1.

    The first party uniformly and randomly picks min{|S1|,Niαimaxi{αi}} elements from S1 and sends them, denoted by M1, to the second party.

  2. 2.

    The second party receives the message M1 from the first one, and sends M2:=M1S2 to the third party.

  3. 3.

    The process goes on, and the last party computes Mk1Sk. If it is not empty, the last party outputs any element in it. Otherwise, the protocol fails.

Then, we bound AccΠ(D3) and its communication complexity to show Π is highly efficient. From the definitions, we know that

AccΠ(D3)=𝐏𝐫[M1S2Sk].

Also, we have that

𝐏𝐫[M1S2Sk|M1|=m]=1(11Niαimaxi{αi})mmeNiαimaxi{αi}.

The last inequality holds since mNiαimaxi{αi}. From Chernoff bound, we know that the probability that 𝐏𝐫[|M1|Niαimaxi{αi}/2]eN1α1/12e10k3. The last inequality is from the constraint of k0.1min{Nmini{αi}/2,N(1maxi{αi})/3}. Furthermore, when

|M1|Niαimaxi{αi}/2,

it holds that

𝐏𝐫[M1S2Sk|M1|=m]12e.

Combining the facts above, we have AccΠ(D3)12e(1e10k3)0.1.

On the other hand, we bound the communication complexity by bounding the expected size of |Mi|. 𝔼[|M1|]Niαimaxi{αi}logN holds from definitions. Furthermore, we have

𝔼[|Mi|]𝔼[|Mi1|]Nαi.

Then, 𝔼[iMi]O(Niαimaxi{αi}logn) follows by NαiNmini{αi}1/2. This concludes the first statement.

Next, we slightly change the protocol above to match the second statement. The protocol Π proceeds as follows:

  1. 1.

    The first party uniformly and randomly picks Θ(Niαimaxi{αi}) elements from S1 and sends them, denoted by M1, to the second party.

  2. 2.

    The second party receives the message M1 from the first one, and sends M2:=M1S2 to the third party.

  3. 3.

    The process goes on, and the last party computes Mk1Sk. If it is not empty, the last party outputs any element in it.

Obviously, the communication complexity of this protocol Π is O(klognNiαimaxi{αi}). Also, we know the accuracy is bigger than

Ω(1(1Ω(N1iαi)|S1|)Θ(Niαimaxi{αi}))=Ω(1).

Thus, our lower bounds show that those trivial protocols are nearly optimal.

4 Lower Bounds for Chained Index

Recall that in the Chained Index problem, the player i receives an input zi=(σi,xi)[n]×{0,1}n. The players aim to compute xk1(σk) through a one-way communication. In this section, we show an improved lower bound for the Chained Index problem. In light of Yao’s principle, we consider the following hard distribution.

The distribution χk.

  1. 1.

    Uniformly sample σ1,,σk[n].

  2. 2.

    Sample (x1,,xk)({0,1}n)k conditioned on x1(σ2)==xk1(σk).

  3. 3.

    Output z=(z1,,zk) where zi=(σi,xi) for every i[k].

For a subset R([n]×{0,1}n)k, define the weight of R under χk as

χk(R)=𝖽𝖾𝖿𝐏𝐫zχk[zR]=#{((σ1,x1),,(σk,xk))R:x1(σ2)==xk1(σk)}nk2(k1)(n1)+n+1.

We prove the following lower bound. We say a one-way k-party protocol has signature (C1,,Ck) if, for each i[k], the i-th party sends at most Ci bits (on all inputs).

Theorem 22.

Let ε(0,1/4] be a constant. Let Π be a protocol for the k-party chained index problem with signature (C1,,Ck). If Π has 2ε advantage, i.e.,

𝐏𝐫z=(σ1,x1,,σk,xk)χk[Π(z)=xk1(σk)]12+2ε.

Then t=1kCtmax{132ε2n/k,18εn}=Ω(n/k+n).

We use a decomposition and sampling process 𝖣𝖲, as shown in Algorithm 2, in our analysis. 𝖣𝖲 takes as input a protocol Π, and samples a rectangle R that is contained in Πv for some leaf node v. Our proof proceeds in two steps:

  1. 1.

    Section 4.1 shows that the accuracy of Π is captured by a quantity called average fixed size, which is a natural quantity that arises in the running of 𝖣𝖲.

  2. 2.

    Section 4.2 proves that the average fixed size can be bounded from above by O(kCC(Π)). Consequently, if Π enjoys high accuracy, we get a lower bound of CC(Π).

We first recall some basic definitions.

𝒌-party one-way protocols

A deterministic k-party one-way communication protocol Π is specified by a rooted binary tree. For every internal vertex v,

  • it has 2 children, denoted by Π(v,0) and Π(v,1);

  • v is owned by some party – we denote the owner by 𝗈𝗐𝗇𝖾𝗋(v)[k];

  • every leaf node specifies an output.

Starting from the root, the owner of the current node 𝖼𝗎𝗋 partitions its input space into two parts X0 and X1, and sets the current node to Π(𝖼𝗎𝗋,b) if its input belongs to Xb.

The communication complexity of Π, denoted by CC(Π), is the depth of the tree. On a path from root to some leaf, each time the owner switches, we call it a new round; in a one-way protocol, the label of the owner is non-decreasing.

Fact 23.

The set of all inputs that lead to an internal vertex v is a rectangle, denoted by Πv=X1××Xk.

Normalized protocols

We normalized a protocol Π as follows so as to make it defined on all inputs, including those not in supp(χk). For the i-th party, given input (σi,xi)[n]×{0,1}n and previous transcripts 𝗍𝗋𝖺𝗇𝗌, output 0 if the input is invalid, i.e., given 𝗍𝗋𝖺𝗇𝗌, there is no input in supp(χk) matches xi. Otherwise, the i-th party outputs 1 and proceeds as Π. Clearly, by normalizing, we communicate k more bits.

Algorithm 2 Decomposition and Sampling Process 𝖣𝖲.
Lemma 24 (Loop invariant).

After each iteration in algorithm 2,

  • RΠv;

  • for all i[k], 𝑿i(Ji) is γ-dense;

  • for all i[k], there exists αi{0,1}Ji¯ such that x(Ji¯)=αi for all xXi.

Proof.

The first item is true because every time v is updated, R is updated accordingly to a sub-rectangle of Πv and updating R into its sub-rectangles does not violate this condition.

Since we applied density restoring partition at the end of each iteration, the second and the third items are guaranteed by Lemma 13 and the way that Xi,Ji are updated.

4.1 Relating Accuracy and Average Fixed Size

As shown in Lemma 24, during the execution of 𝖣𝖲(Π), for every i[k], the set Xi is “fixed” on Ji¯ in the sense that all strings in Xi share the same value on coordinates in Ji¯. So we call the expected size of |Ji¯| average fixed size. However, in order to relate the accuracy of Π to average fixed size, we need to consider the expectation of |Ji¯| in a slightly different distribution.

Definition 25 (Average fixed size).

Let 𝒰k denote the uniform distribution over the input space ([n]×{0,1}n)k. Let t[k] and consider the following process, denoted by 𝖴𝗇𝗂𝖿t(Π):

  1. 1.

    run 𝖣𝖲(Π) until the t-th round;

  2. 2.

    continue running 𝖣𝖲 with χk replaced by 𝒰k in the execution of Line 9, Line 13, and Line 16;

  3. 3.

    upon entering the (t+1)-th round (i.e., until Line 17 is reached with i=t), return Jt.

The average fixed size of the t-th party is defined as 𝐄Jt𝖴𝗇𝗂𝖿t(Π)[|Jt¯|].

Lemma 26 (Relating accuracy and average fixed size).

Assume that γlog[1+(12ε1+2ε)1/k]. Then

𝐏𝐫z=(σ1,x1,,σk,xk)χk[Π(z)=xk1(σk)]12+ε+2nt=1k𝐄Jt𝖴𝗇𝗂𝖿t(Π)[|Jt¯|].
 Remark 27.

γ=𝖽𝖾𝖿12εk satisfies the condition. Indeed,

log[1+(12ε1+2ε)1/k](12ε1+2ε)1/k11k4ε1+2ε12εk,

where the first inequality is by log(1+x)x, and the second is by (1x)r1rx for x(1,0) and r(0,1).

The proof of the lemma is obtained through the following two lemmas. The first lemma readily says that conditioned on the flag 𝖻𝖺𝖽 is not raised, Π has little advantage in the rectangle R output by 𝖣𝖲(Π). The second lemma shows the probability that the flag is raised is bounded in terms of the average fixed size.

Lemma 28.

If 𝖣𝖲(Π) outputs (R,J1,,Jk) and 𝖻𝖺𝖽=False in the end, then

𝐏𝐫z=(ρ1,x1,,ρk,xk)R[Π(z)=xk1(ρk)|x1(ρ2)==xk1(ρk)]12+ε.
Lemma 29.

𝐏𝐫𝖣𝖲(Π)[𝖻𝖺𝖽=True]2nt=1k𝐄Jt𝖴𝗇𝗂𝖿t(Π)[|Jt¯|].

Next, we first prove Lemma 26 using the above two lemmas.

Proof of Lemma 26.

Note that in the running of 𝖣𝖲(Π), we first sample σ1,,σk[n] and then always update R to a randomly chosen rectangle; the probability of each rectangle being chosen is proportional to its weight under χk. Consequently,

𝐏𝐫z=(σ1,x1,,σk,xk)χk[Π(z)=xk1(σk)]
=𝐏𝐫(R,J1,,Jk)𝖣𝖲(Π)(σ1,x1,,σk,xk)R[Π(z)=xk1(σk)|x1(σ2)==xk1(σk)]
𝐏𝐫𝖣𝖲(Π)[𝖻𝖺𝖽=True]+𝐏𝐫(R,J1,,Jk)𝖣𝖲(Π)z=(σ1,x1,,σk,xk)R[Π(z)=xk1(σk)|x1(σ2)==xk1(σk)𝖻𝖺𝖽=False]
12+ε+2nt=1k𝐄Jt𝖴𝗇𝗂𝖿t(Π)[|Jt¯|].

where the last step is by Lemma 28 and Lemma 29.

It remains to prove the two lemmas.

Proof of Lemma 28.

Say R=({σ1}×X1)××({σk}×Xk). Since 𝖻𝖺𝖽=False in the end, we have σi+1Ji for all i[k1]. By Lemma 24, we have H(𝑿i(σi+1))γ for all i. Since R is contained in some leaf node of Π, Π output the same answer in R, say b{0,1}. Note that for b{0,1},

𝐏𝐫z=(ρ1,x1,,ρk,xk)R[x1(ρ2)==xk1(ρk)=b]=i[k1]𝐏𝐫xiXi[xi(σi+1)=b],

since we must have ρi=σi. Write pi=𝖽𝖾𝖿𝐏𝐫xiXi[xi(σi)=b]. Then we have

𝐏𝐫z=(ρ1,x1,,ρk,xk)R[Π(z)=xk1(ρk)|x1(ρ2)==xk1(ρk)]
=𝐏𝐫z=(ρ1,x1,,ρk,xk)R[x1(ρ2)==xk1(ρk)=b|x1(ρ2)==xk1(ρk)]
=𝐏𝐫z=(ρ1,x1,,ρk,xk)R[x1(σ2)==xk1(σk)=b]/𝐏𝐫z=(ρ1,x1,,ρk,xk)R[x1(σ2)==xk1(σk)]
=i[k]pii[k]pi+i[k](1pi)=11+i[k](1/pi1).

Since H(𝑿i(σi+1))γ for all i, we have pi[12γ,2γ], which implies

11+i[k](1/pi1)11+(2γ1)k.

Since we assumed γlog[1+(12ε1+2ε)1/k], it holds that 11+(2γ1)k12+ε, concluding the proof.

Proof of Lemma 29.

Let t denote the event that the flag 𝖻𝖺𝖽 is raised when i=t (i.e., when the i-th round ends) for the first time. Clearly, 𝐏𝐫[𝖻𝖺𝖽=True]=t=1k1𝐏𝐫[t]. It suffices to show 𝐏𝐫[t]𝐄Jt𝖴𝗇𝗂𝖿t(Π)[|Jt¯|]. for each t.

Fix t[k1] and the random coins 𝖼𝗈𝗂𝗇 used for the first (t1) rounds, i.e., until Line 17 is reached with i=t1). Let Rt1=({σ1}×X1××({σt}×{0,1}n)×([n]×{0,1}n)kt be the value of rectangle R when running 𝖣𝖲(Π) using 𝖼𝗈𝗂𝗇 until the t-th round begins. The core of our proof is to compare the process with one that runs under uniform weight instead of the weight under χk; this is why we can deal with the promise.

  • Let 𝖱𝖾𝖺𝗅t be the process that runs 𝖣𝖲(Π) until the t-th round begins with 𝖼𝗈𝗂𝗇, then run the t-th round with fresh random coins.

  • Let 𝖴𝗇𝗂𝖿t(Π;𝖼𝗈𝗂𝗇) be the process that runs 𝖣𝖲(Π) until the t-th round begins with 𝖼𝗈𝗂𝗇, then runs the t-th round with χk replaced by 𝒰k.

Note that during the execution of 𝖱𝖾𝖺𝗅t and 𝖴𝗇𝗂𝖿t, the partitions are the same, and the only difference is that when choosing 𝒃,𝒋,σt+1, the probabilities are different. Let X^t,J^t,σ^t+1 be a possible value of Xt,Jt,σt+1 at the end of the t-th round. In 𝖱𝖾𝖺𝗅t we update R according to χk, and thus the probability that Xt=X^t,σt+1=σ^t+1 in the end of 𝖱𝖾𝖺𝗅t equals

p(X^t,σ^t+1)=χk(({σ1}×X1)××({σt}×X^t)×({σ^t+1}×{0,1}n)×([n]×{0,1}n)kt1)χk(Rt1).

Similarly, the probability that Xt=X^t,σt+1=σ^t+1 in the end of 𝖴𝗇𝗂𝖿t(Π,𝖼𝗈𝗂𝗇) equals

q(X^t,σ^t+1)= 𝒰k(({σ1}×X1)××({σt}×X^t)×({σ^t+1}×{0,1}n)×([n]×{0,1}n)kt1)𝒰k(Rt1)
= |X^t|n2n.

The next claim reveals a connection between the two probabilities, whose proof is by direct calculation and is deferred to the appendix.

Claim 30.

For all possible value X^t,σ^t+1, p(X^t,σ^t+1)2q(X^t,σ^t+1).

Since Jt is determined by the value of Xt and the event t is determined by Xt and σt+1, the above claim implies that 𝐏𝐫𝖱𝖾𝖺𝗅t[t]2𝐏𝐫𝖴𝗇𝗂𝖿t(Π;𝖼𝗈𝗂𝗇)[t]. Note that in 𝖴𝗇𝗂𝖿t(Π;𝖼𝗈𝗂𝗇), σt+1 is chosen uniformly at random, and thus

𝐏𝐫𝖴𝗇𝗂𝖿t(Π;𝖼𝗈𝗂𝗇)[t]𝐄Jt𝖴𝗇𝗂𝖿t(Π;𝖼𝗈𝗂𝗇)[|Jt¯|]/n.

Taking expectation over 𝖼𝗈𝗂𝗇 we get 𝐏𝐫[t]2n𝐄Jt𝖴𝗇𝗂𝖿t(Π)[|J¯t|], as desired.

4.2 Average Fixed Size is Bounded by Communication

Now that the accuracy of a protocol Π is bounded from above by the average fixed size (i.e., t=1k𝐄Jt𝖴𝗇𝗂𝖿t(Π)[|Jt¯|]), in what follows we show that the average fixed size is at most O(kCC(Π)). Formally, we prove that

Lemma 31.

Assume that Π is a normalized protocol with signature (C1,,Ck). Then

t=1k𝐄Jt𝖴𝗇𝗂𝖿t(Π)[|Jt¯|]21γt[k]Ct.
Proof.

The proof strategy is similar to the proof of Lemma 29. Fix t[k1] and consider 𝐄Jt𝖴𝗇𝗂𝖿𝗍(Π)[|J¯t|]. Fix the random coins 𝖼𝗈𝗂𝗇 used for the first (t1) rounds (i.e., until Line 17 is reached with i=t1). Let 𝖱𝖾𝖺𝗅t and 𝖴𝗇𝗂𝖿t(Π;𝖼𝗈𝗂𝗇) be defined as in the proof of Lemma 29. Moreover, let ct denote the number of bits sent by the t-th party, i.e., the number of iterations in the t-th round. By a standard density increment argument, we have

Claim 32.

𝐄Jt𝖴𝗇𝗂𝖿t(Π;𝖼𝗈𝗂𝗇)[|Jt¯|]21γ𝐄𝖴𝗇𝗂𝖿t(Π;𝖼𝗈𝗂𝗇)[𝒄t]21γCt.

Averaging over 𝖼𝗈𝗂𝗇, we have

𝐄Jt𝖴𝗇𝗂𝖿𝗍(Π)[|Jt¯|]=𝐄𝖼𝗈𝗂𝗇,Jt𝖴𝗇𝗂𝖿t(Π;𝖼𝗈𝗂𝗇)[|Jt¯|]21γCt,

where the second inequality follows from Claim 32. By summing up all t’s, we get the desired result. It remains to prove Claim 32.

Proof of Claim 32.

We shall prove this lemma by a density increment argument. That is, we study the change of the density function D(𝑿t(Jt)). in each iteration. Let ϕ be the value of D(𝑿t(Jt)) at the end of the -th iteration.

We fix the random coins used for the first (1) iterations and consider the updates in the current iteration.

  1. 1.

    First, Xt is partitioned into Xt=X0X1 according to Π. Then, Xt is updated to Xb with probability |Xb||X|. Consequently, D(𝑿𝒕(Jt)) will increase as |Xt| shrinks, and in expectation (over the random choice of 𝒃) the increment is

    b{0,1}|Xb||Xt|log(|Xt||Xb|)1. (5)
  2. 2.

    Next, we further partition Xt according to Lemma 13. Say X is partitioned into Xt=X1Xm and let I1,,Im be the index sets promised by Lemma 13; and for all j[m] we have

    D(𝑿j(JtIj))D(𝑿t(Jt))(1γ)|Ij|+δj,

    where δj=log(|Xt|/|vjXv|). With probability pj=𝖽𝖾𝖿|Xj|/|Xt|, we update Xt:=Xj and Jt:=JtIj. Therefore, taking expectation over the random choice of 𝒋, the density function will decrease by

    D(𝑿𝒕(Jt))𝐄j𝒋[D(𝑿𝒕j(JtIj))]𝐄j𝒋[(1γ)|Ij|δj]. (6)

    Note that δj=𝖽𝖾𝖿log1vjpv and thus

    𝐄j𝒋[δj]=j=1mpjlog1vjpv01log11xdx1. (7)

Let 1 be the σ-algebra generated by the random coins used for the first (1) iterations. Let 𝜷 be the increment of |Jt¯| in the -th iteration. Observe that 𝜷=|I𝒋| by definition. By Equation 6 and Equation 7, taking expectation over random choice of 𝒋, D(𝑿t(Jt)) decrease by at least (1γ)𝐄[𝜷|1]1 due to the density restoring partition. Then

𝐄[ϕϕ1]=𝐄[𝐄[ϕϕ1|1]]𝐄[1((1γ)𝜷1)]. (8)

In the beginning, ϕ0=D({0,1}n)=0. Since the density function is always non-negative by definition, we have ϕ𝒄t0 and thus 𝐄[ϕ𝒄tϕ0]0. On the other hand, by telescoping,

𝐄[ϕ𝒄tϕ0]=𝐄[=1𝒄t(ϕϕ1)]𝐄[=1𝒄t(𝜷+2)],

where the inequality follows from Equation 8. Observe that t=1𝒄t𝜷t=|𝑱t¯| by definition. We conclude that

𝐄[|𝑱t¯|]=𝐄[=1𝒄t𝜷]2𝐄[𝒄t]1γ2Ct1γ,

as desired.

4.3 Putting Things Together

Now we are prepared to prove Theorem 22.

Proof of Theorem 22.

We first normalize Π so as to make it accept all inputs in ([n]×{0,1}n)k. Denoted by Π the normalized protocol, then Π has signature (C1+1,,Ck+1).

Set γ=12εk. One can check that γ satisfies the requirement in Lemma 26. By Lemma 26 and Lemma 31, we have

Accuracy(Π)=𝖽𝖾𝖿𝐏𝐫z=(σ1,x1,,σk,xk)χk[Π(z)=xk1(σk)]12+ε+4nk2ε2t=1k(Ct+1). (9)

Since Π,Π have the same output on valid inputs and we assumed Accuracy(Π)12+2ε, we get Accuracy(Π)12+2ε. Combining with Equation 9 and rearranging, we have

t=1kCtε2n4kk. (10)

The above lower bound is vacuous when k=ω(n). Next, we strengthen the lower bound to Ω(n/k+n) via simple reductions. Consider two cases.

  • Case 1: kεn/4. Equation 10 implies that

    t=1kCtε2n4kkε2n4kε2n16k>ε2n8kεn2.
  • Case 2: k>εn/4. Let 𝒯=𝖽𝖾𝖿{t[k]:Ct1} be the set of talking parties. If |𝒯|εn/8ε2n32k, we are done. Otherwise, we construct a protocol Π^ for ChainIndk where k=𝖽𝖾𝖿2|𝒯|εn/4, described below.

    • Say the talking parties are Pi1,,Pik/2. Let P2j1 emulate Pij, and P2j emulate Pij+1,Pij+11 by doing nothing. Note that on receiving an input sampled from μk, the parties P2j can imagine they are given inputs for all Pij+1,Pij+11 from μk. Since Pij+1,Pij+11 never talks, P2j perfect emulate Pij+1,Pij+11 them by doing nothing. In sum,

      𝐏𝐫zχk[Π^(z)=ChainIndk(z)]=𝐏𝐫zχk[Π(z)=ChainIndk(z)]12+2ε.

      Observe that Π^ has signature (Ci1,0,Ci2,0,,Cik/2,0). Applying Equation 10 to Π^, we get

      i=1kCi=t=1kCitε2n4kkεn2ε2n8k.

Therefore, we conclude that i=1kCimax{132ε2n/k,18εn}, regardless of the value of k.

References

  • [1] Ryan Alweiss, Shachar Lovett, Kewen Wu, and Jiapeng Zhang. Improved bounds for the sunflower lemma. In Proceedings of the 52nd Annual ACM SIGACT Symposium on Theory of Computing, pages 624–630, 2020. doi:10.1145/3357713.3384234.
  • [2] Alexandr Andoni, Andrew McGregor, Krzysztof Onak, and Rina Panigrahy. Better bounds for frequency moments in random-order streams. arXiv preprint, 2008. arXiv:0808.2222.
  • [3] Sepehr Assadi, Yu Chen, and Sanjeev Khanna. Polynomial pass lower bounds for graph streaming algorithms. In Proceedings of the 51st Annual ACM SIGACT Symposium on theory of computing, pages 265–276, 2019. doi:10.1145/3313276.3316361.
  • [4] Laszlo Babai, Peter Frankl, and Janos Simon. Complexity classes in communication complexity theory. In 27th Annual Symposium on Foundations of Computer Science (sfcs 1986), pages 337–347, 1986. doi:10.1109/SFCS.1986.15.
  • [5] Ziv Bar-Yossef, Thathachar S Jayram, Ravi Kumar, and D Sivakumar. An information statistics approach to data stream and communication complexity. Journal of Computer and System Sciences, 68(4):702–732, 2004. doi:10.1016/J.JCSS.2003.11.006.
  • [6] Boaz Barak, Mark Braverman, Xi Chen, and Anup Rao. How to compress interactive communication. In Proceedings of the forty-second ACM symposium on Theory of computing, pages 67–76, 2010. doi:10.1145/1806689.1806701.
  • [7] Balthazar Bauer, Pooya Farshim, and Sogol Mazaheri. Combiners for backdoored random oracles. In Advances in Cryptology–CRYPTO 2018: 38th Annual International Cryptology Conference, Santa Barbara, CA, USA, August 19–23, 2018, Proceedings, Part II 38, pages 272–302. Springer, 2018. doi:10.1007/978-3-319-96881-0_10.
  • [8] Paul Beame and Michael Whitmeyer. Multiparty communication complexity of collision finding, 2024. doi:10.48550/arXiv.2411.07400.
  • [9] Anup Bhattacharya, Sourav Chakraborty, Arijit Ghosh, Gopinath Mishra, and Manaswi Paraashar. Disjointness through the lens of vapnik–chervonenkis dimension: Sparsity and beyond. Comput. Complex., 31(2), December 2022. doi:10.1007/s00037-022-00225-6.
  • [10] Sujoy Bhore, Fabian Klute, and Jelle J Oostveen. On streaming algorithms for geometric independent set and clique. In International Workshop on Approximation and Online Algorithms, pages 211–224. Springer, 2022. doi:10.1007/978-3-031-18367-6_11.
  • [11] Mark Braverman, Ankit Garg, Denis Pankratov, and Omri Weinstein. From information to exact communication. In Proceedings of the Forty-Fifth Annual ACM Symposium on Theory of Computing, STOC ’13, pages 151–160, New York, NY, USA, 2013. Association for Computing Machinery. doi:10.1145/2488608.2488628.
  • [12] Mark Braverman, Sumegha Garg, Qian Li, Shuo Wang, David P Woodruff, and Jiapeng Zhang. A new information complexity measure for multi-pass streaming with applications. In Proceedings of the 56th Annual ACM Symposium on Theory of Computing, pages 1781–1792, 2024. doi:10.1145/3618260.3649672.
  • [13] Mark Braverman, Sumegha Garg, and David P Woodruff. The coin problem with applications to data streams. In 2020 ieee 61st annual symposium on foundations of computer science (focs), pages 318–329. IEEE, 2020. doi:10.1109/FOCS46700.2020.00038.
  • [14] Joshua Brody, Amit Chakrabarti, Ranganath Kondapally, David P. Woodruff, and Grigory Yaroslavtsev. Beyond set disjointness: The communication complexity of finding the intersection. In Proceedings of the 2014 ACM Symposium on Principles of Distributed Computing, PODC ’14, pages 106–113, New York, NY, USA, 2014. Association for Computing Machinery. doi:10.1145/2611462.2611501.
  • [15] Amit Chakrabarti. Lower bounds for multi-player pointer jumping. In Twenty-Second Annual IEEE Conference on Computational Complexity (CCC’07), pages 33–45. IEEE, 2007. doi:10.1109/CCC.2007.14.
  • [16] Amit Chakrabarti, Graham Cormode, and Andrew McGregor. Robust lower bounds for communication and stream computation. In Proceedings of the fortieth annual ACM symposium on Theory of computing, pages 641–650, 2008. doi:10.1145/1374376.1374470.
  • [17] Amit Chakrabarti, Yaoyun Shi, Anthony Wirth, and Andrew Yao. Informational complexity and the direct sum problem for simultaneous message complexity. In Proceedings 42nd IEEE Symposium on Foundations of Computer Science, pages 270–278. IEEE, 2001.
  • [18] Amit Chakrabarti and Anthony Wirth. Incidence geometries and the pass complexity of semi-streaming set cover. In Proceedings of the twenty-seventh annual ACM-SIAM symposium on Discrete algorithms, pages 1365–1373. SIAM, 2016. doi:10.1137/1.9781611974331.CH94.
  • [19] Arkadev Chattopadhyay, Yuval Filmus, Sajin Koroth, Or Meir, and Toniann Pitassi. Query-To-Communication Lifting for BPP Using Inner Product. In Christel Baier, Ioannis Chatzigiannakis, Paola Flocchini, and Stefano Leonardi, editors, 46th International Colloquium on Automata, Languages, and Programming (ICALP 2019), volume 132 of Leibniz International Proceedings in Informatics (LIPIcs), pages 35:1–35:15, Dagstuhl, Germany, 2019. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.ICALP.2019.35.
  • [20] Sandro Coretti, Yevgeniy Dodis, Siyao Guo, and John Steinberger. Random oracles and non-uniformity. In Annual International Conference on the Theory and Applications of Cryptographic Techniques, pages 227–258. Springer, 2018. doi:10.1007/978-3-319-78381-9_9.
  • [21] Graham Cormode, Jacques Dark, and Christian Konrad. Independent sets in vertex-arrival streams. arXiv preprint, 2018. arXiv:1807.08331.
  • [22] Jacques Dark, Adithya Diddapur, and Christian Konrad. Interval selection in data streams: Weighted intervals and the insertion-deletion setting. In 43rd IARCS Annual Conference on Foundations of Software Technology and Theoretical Computer Science (FSTTCS 2023), pages 24:1–24:17. Schloss-Dagstuhl-Leibniz Zentrum für Informatik, 2023. doi:10.4230/LIPIcs.FSTTCS.2023.24.
  • [23] Nachum Dershowitz, Rotem Oshman, and Tal Roth. The communication complexity of multiparty set disjointness under product distributions. In Proceedings of the 53rd Annual ACM SIGACT Symposium on Theory of Computing, pages 1194–1207, 2021. doi:10.1145/3406325.3451106.
  • [24] Moran Feldman, Ashkan Norouzi-Fard, Ola Svensson, and Rico Zenklusen. The one-way communication complexity of submodular maximization with applications to streaming and robustness. In Proceedings of the 52nd Annual ACM SIGACT Symposium on Theory of Computing, pages 1363–1374, 2020. doi:10.1145/3357713.3384286.
  • [25] Moran Feldman, Ashkan Norouzi-Fard, Ola Svensson, and Rico Zenklusen. Submodular maximization subject to matroid intersection on the fly. In 30th Annual European Symposium on Algorithms (ESA 2022), pages 52:1–52:14. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2022. doi:10.4230/LIPIcs.ESA.2022.52.
  • [26] Dmitry Gavinsky. The communication complexity of the inevitable intersection problem. Chicago Journal of Theoretical Computer Science, 2020(3), August 2020. URL: http://cjtcs.cs.uchicago.edu/articles/2020/3/contents.html.
  • [27] Satrajit Ghosh and Mark Simkin. The communication complexity of threshold private set intersection. In Alexandra Boldyreva and Daniele Micciancio, editors, Advances in Cryptology – CRYPTO 2019, pages 3–29, Cham, 2019. Springer International Publishing. doi:10.1007/978-3-030-26951-7_1.
  • [28] Mika Göös, Tom Gur, Siddhartha Jain, and Jiawei Li. Quantum communication advantage in tfnp, 2024. doi:10.48550/arXiv.2411.03296.
  • [29] Mika Göös, Shachar Lovett, Raghu Meka, Thomas Watson, and David Zuckerman. Rectangles are nonnegative juntas. SIAM Journal on Computing, 45(5):1835–1869, 2016. doi:10.1137/15M103145X.
  • [30] Mika Göös, Toniann Pitassi, and Thomas Watson. Query-to-communication lifting for bpp. In 2017 IEEE 58th Annual Symposium on Foundations of Computer Science (FOCS), pages 132–143, 2017. doi:10.1109/FOCS.2017.21.
  • [31] Venkatesan Guruswami and Krzysztof Onak. Superlinear lower bounds for multipass graph processing. Algorithmica, 76:654–683, 2016. doi:10.1007/S00453-016-0138-7.
  • [32] Dawei Huang, Seth Pettie, Yixiang Zhang, and Zhijun Zhang. The communication complexity of set intersection and multiple equality testing. SIAM Journal on Computing, 50(2):674–717, 2021. doi:10.1137/20M1326040.
  • [33] Mi-Ying(Miryam) Huang, Xinyu Mao, Guangxu Yang, and Jiapeng Zhang. Breaking square-root loss barriers via min-entropy. In In Electronic Colloquium on Computational Complexity (ECCC) (TR24-067), 2024. URL: https://eccc.weizmann.ac.il/report/2024/067/.
  • [34] Bala Kalyanasundaram and Georg Schintger. The probabilistic communication complexity of set intersection. SIAM Journal on Discrete Mathematics, 5(4):545–557, 1992. doi:10.1137/0405044.
  • [35] Shachar Lovett, Raghu Meka, Ian Mertz, Toniann Pitassi, and Jiapeng Zhang. Lifting with sunflowers. Leibniz international proceedings in informatics, 215, 2022. doi:10.4230/LIPICS.ITCS.2022.104.
  • [36] Shachar Lovett, Noam Solomon, and Jiapeng Zhang. From dnf compression to sunflower theorems via regularity. In Proceedings of the 34th Computational Complexity Conference, pages 1–14, 2019. doi:10.4230/LIPICS.CCC.2019.5.
  • [37] Shachar Lovett and Jiapeng Zhang. Streaming lower bounds and asymmetric set-disjointness. In 2023 IEEE 64th Annual Symposium on Foundations of Computer Science (FOCS), pages 871–882. IEEE, 2023. doi:10.1109/FOCS57990.2023.00056.
  • [38] Xinyu Mao, Guangxu Yang, and Jiapeng Zhang. Gadgetless lifting beats round elimination: Improved lower bounds for pointer chasing. arXiv preprint, 2024. doi:10.48550/arXiv.2411.10996.
  • [39] Noam Nisan and Avi Widgerson. Rounds in communication complexity revisited. In Proceedings of the twenty-third annual ACM symposium on Theory of computing, pages 419–429, 1991. doi:10.1145/103418.103463.
  • [40] Rotem Oshman and Tal Roth. The Communication Complexity of Set Intersection Under Product Distributions. In Kousha Etessami, Uriel Feige, and Gabriele Puppis, editors, 50th International Colloquium on Automata, Languages, and Programming (ICALP 2023), volume 261 of Leibniz International Proceedings in Informatics (LIPIcs), pages 95:1–95:20, Dagstuhl, Germany, 2023. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.ICALP.2023.95.
  • [41] Jeff M. Phillips, Elad Verbin, and Qin Zhang. Lower bounds for number-in-hand multiparty communication complexity, made easy. SIAM Journal on Computing, 45(1):174–196, 2016. doi:10.1137/15M1007525.
  • [42] M. Saglam and G. Tardos. On the communication complexity of sparse set disjointness and exists-equal problems. In 2013 IEEE 54th Annual Symposium on Foundations of Computer Science (FOCS), pages 678–687, Los Alamitos, CA, USA, October 2013. IEEE Computer Society. doi:10.1109/FOCS.2013.78.
  • [43] Janani Sundaresan. Optimal communication complexity of chained index. ITCS, 2025.
  • [44] Shuo Wang, Guangxu Yang, and Jiapeng Zhang. Communication complexity of set-intersection problems and its applications. In In Electronic Colloquium on Computational Complexity (ECCC) (TR23-164), 2023.
  • [45] Thomas Watson. Communication Complexity with Small Advantage. In Rocco A. Servedio, editor, 33rd Computational Complexity Conference (CCC 2018), volume 102 of Leibniz International Proceedings in Informatics (LIPIcs), pages 9:1–9:17, Dagstuhl, Germany, 2018. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.CCC.2018.9.
  • [46] 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, pages 630–639, 2024. doi:10.1145/3618260.3649607.

Appendix A Proof of Claim 30

Claim 33 (Claim 30 restated).

Let tk. Let σ1,,σt+1[n],X1,,Xt{0,1}n. For {t,t+1}, define

R=𝖽𝖾𝖿({σ1}×X1)××({σ1}×X1)×({σ}×{0,1}n)×([n]×{0,1}n)k.

Then

χk(Rt+1)χk(Rt)2𝒰k(Rt+1)𝒰k(Rt).
Proof of Claim 30.

To start with, observe that

𝒰k(Rt+1)𝒰k(Rt)=|Rt+1||Rt|=|Xt|n2n. (11)

We claim that for {t,t+1},

χk(R)=#{(x1,,x1)X1××X1:x1(σ2)==x1(σ)}n2(n1)+1. (12)

Then we have

χk(Rt+1) =#{(x1,,xt)X1××Xt:x1(σ2)==xt(σt+1)}nt+12(n1)(t+1)+1
#{(x1,,xt1)X1××Xt1:x1(σ2)==xt1(σt)}|Xt|nt+12(n1)(t+1)+1
=χk(Rt)|Xt|n2n1.

where the first and the third equality is from Equation 12. Combining with Equation 11 we have the desired result.

It remains to show Equation 12. Suppose that ((ρ1,x1),,(ρk,xk))R satisfies x1(ρ2)==xk1(ρk). Then we ρ1=σ1,,ρ=σ and

x1(σ2)==x1(σ)=b for some b{0,1}.

For every ρ+1,,ρk[n], there exists exactly 2(n1) possible values for each xj with jk1 (with one bit fixed to be b) and 2n possible values for xk (which is not used at all). Therefore,

χk(R) =#{((ρ1,x1),,(ρk,xk))Rt+1:x1(ρ2)==xk1(ρk)}nk2(n1)(k1)+n+1
=nk2(n1)(k1)+n#{(x1,,x1)X1××X1:x1(σ2)==x1(σ)}nk2(n1)(k1)+n+1
=#{(x1,,x1)X1××X1:x1(σ2)==x1(σ)}n2(n1)+1,

which is exactly what we wanted.

Appendix B Proof of Lemma 13

The following lemma and proof are from Lemma 5 in [30].

Lemma 34 (Lemma 13 restated).

Let γ(0,1). Let X be a subset of [n]M and J[M]. Suppose that there exists an β[n]J¯ such that xX,x(J¯)=β. Then, there exists a partition X=X1X2Xr and every Xi is associated with a set IiJ and a value αi{0,1}Ii that satisfy the following properties.

  1. 1.

    xXi,x(Ii)=αi;

  2. 2.

    𝑿i(JIi) is γ-dense;

  3. 3.

    D(𝑿i(JIi))D(𝑿(J))(1γ)logn|Ii|+δi, where δi=𝖽𝖾𝖿log(|X|/|jiXj|).

Proof.

We prove it by a greedy algorithm as follows.

Algorithm 3 Greedy Algorithm.

Item 1 is guaranteed by the construction of Xi and Ii.

We prove Item 2 by contradiction. Assume towards contradiction that 𝑿i(JIi) is not γ-dense for some i. By definition, there is a nonempty set KJIi and β[n]K violating the min-entropy condition, namely, 𝐏𝐫[𝑿(K)=β]>nγ|K|. Write Xi=𝖽𝖾𝖿jiXi. Then

𝐏𝐫[𝑿i(IiK)=(αi,β)]=𝐏𝐫[𝑿i(Ii)=αi]𝐏𝐫[𝑿i(K)=β]>nγ|Ii|nγ|K|=nγ|IiK|,

where the first equality holds as (𝑿i|𝑿i(Ii)=αi)=𝑿i. However, this means at moment that Ii is chosen, the set IiKJ also violates the min-entropy condition (witnessed by (αi,β)), contradicting the maximality of Ii.

Finally, Item 3 is proved by straightforward calculation:

D(𝑿i(JIi)) =|JIi|lognlog|Xi|
(|J|logn|Ii|logn)log(|Xi|nγ|Ii|)
=(|J|lognlog|X|)(1γ)|Ii|logn+log(|X||Xi|)
=D(𝑿(J))(1γ)|Ii|logn+δi.