Abstract 1 Introduction 2 Overview and Organization 3 Lower Bounds in the Low Error Regime 4 Upper Bounds in the Low Error Regime 5 Approximate Set Intersection in the High Error Regime 6 Multipass Histogram Streaming 7 Summary and Open Problems References

Tight Bounds for Low-Error Frequency Moment Estimation and the Power of Multiple Passes

Naomi Green-Maimon ORCID Weizmann Institute of Science, Rehovot, Israel    Or Zamir ORCID Tel Aviv University, Israel
Abstract

Estimating the second frequency moment F2 of a data stream up to a (1±ε) factor is a central problem in the streaming literature. For errors ε>Ω(1/n), the tight bound Θ(log(ε2n)/ε2) was recently established by Braverman and Zamir. In this work, we complete the picture by resolving the remaining regime of small error, ε<1/n, showing that the optimal space complexity is Θ(min(n,1ε2)(1+|log(ε2n)|)) bits for all ε1/n2, assuming a sufficiently large universe. This closes the gap between the best known Ω(n) lower bound and the straightforward O(nlogn) upper bound in that range, and shows that essentially storing the entire stream is necessary for high-precision estimation.

To derive this bound, we fully characterize the two-party communication complexity of estimating the size of a set intersection up to an arbitrary additive error εn. In particular, we prove a tight Ω(nlogn) lower bound for one-way communication protocols when ε<n1/2Ω(1), in contrast to classical O(n)-bit protocols that use two-way communication. Motivated by this separation, we present a two-pass streaming algorithm that computes the exact histogram of a stream with high probability using only O(nloglogn) bits of space, in contrast to the Θ(nlogn) bits required in one pass even to approximate F2 with small error. This yields the first asymptotic separation between one-pass and O(1)-passes space complexity for small frequency moment estimation.

Keywords and phrases:
streaming algorithms, frequency moments, communication complexity, multipass streaming
Category:
Track A: Algorithms, Complexity and Games
Funding:
Naomi Green-Maimon: Work done while at Tel Aviv University.
Or Zamir: Supported by the Israel Science Foundation, Grant No. 1593/24, and by the Blavatnik Family foundation.
Copyright and License:
[Uncaptioned image] © Naomi Green-Maimon and Or Zamir; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Streaming models
; Theory of computation Communication complexity
Related Version:
Full Version: https://arxiv.org/abs/2509.07599
Editors:
Sayan Bhattacharya, Danupon Nanongkai, Michael Benedikt, and Gabriele Puppis

1 Introduction

The streaming model of computation is fundamental for processing massive datasets and has been extensively studied in both theory and practice. A central challenge in this model is the frequency moment estimation problem, in which an algorithm observes a sequence of elements from a universe U and must approximate a function of their frequency distribution using limited memory. Denote by fx the number of times an element xU appeared in the stream; the algorithm aims to return, with probability higher than 99%, a (1±ε)-estimation of Fp:=xUfxp – the p-th frequency moment of the stream. We generally denote the length of the stream by n and assume that |U|=poly(n). In fact, we can usually assume that |U|=O(n2) as hashing the elements into a set of size Θ(n2) is expected to not change the frequencies at all. The primary resource constraint studied in this setting is the amount of space required for a successful approximation. This line of research originated with the foundational work of Alon, Matias, and Szegedy [2], which both introduced this problem and established the first space-efficient algorithms for frequency moment estimation.

Among the frequency moments, the case of p=2, known as second moment estimation, has particular significance. This quantity, sometimes referred to as the repeat rate or surprise index, plays a key role in applications such as database query optimization [1], network traffic anomaly detection [24], and approximate histogram maintenance [18]. For F2, the original algorithm proposed by Alon, Matias, and Szegedy achieves a space complexity of O(logn/ε2) bits. Only recently, Braverman and Zamir [8] obtained a matching lower bound for a wide range of error parameters ε. They showed that for any ε>Ω(1/n) the optimal space complexity for estimating the second frequency moment is Θ(log(ε2n)/ε2). This leaves the range of ε<1/n as the only range without a tight space bound for the problem. In that range, the best known lower bound is Ω(n) which follows from either [8] or the much earlier [33] for ε=1/n. On the other hand, by simply maintaining the entire histogram of the input stream in memory we obtain an upper bound of O(nlog(2+|U|n))=O(nlogn) even for exactly computing the second frequency moment. We note that it suffices to consider only ε1/n2 as the second frequency moment is a natural number in the range [n,n2]. We are thus left with a gap between the Ω(n) lower bound and O(nlogn) upper bound in the range of small error 1/n2ε1/n.

In this work, we establish the space complexity of second moment estimation in this remaining range of error parameters.

Theorem 1.

The space complexity of (1±ε)-estimating the second frequency moment of a stream of n elements, for any 1n2ε1n, is

Θ(nlog(1ε2n)).

We observe that this bound implies a phase transition around ε=1/n: if the wanted error is polynomially-smaller than 1/n then the space required is the same as needed to maintain the entire input in memory and compute an exact answer, while if ε=1/n then only Θ(n) bits of space are needed. Our bounds combined with those of [8] give a complete characterization of the space complexity needed to estimate the second moment up to any error parameter ε. See Figure 1 for a graph. Note that both lower bounds assume that the universe of possible stream elements is sufficiently large.

Figure 1: The optimal space complexity of second moment estimation for all values of ε.

To derive our lower bound, we study and fully characterize the two-party communication complexity of the Approximate Set Intersection problem. In this problem, Alice and Bob are given subsets A and B of a larger universe U, of size at most n each, and need to output |AB| up to an additive error εn with probability at least 2/3. This is a natural generalization of several classical problems in communication complexity: Set Disjointness is a special case of the problem when ε=0, and of Gap Hamming Distance when ε=1/n. When ε<1/n a lower bound of Ω(n) follows from [33] and a matching upper bound of O(n) holds for exactly computing the intersection with two-way communication, even when the element universe U is allowed to be very large [11]. To the best of our knowledge, no tight bounds were explicitly derived in all other settings and ranges of parameters. In [26] the same problem was asked and discussed, resulting only in the rather straightforward O(logn/ε2) upper bound obtained by Alice explicitly sending a sample of her elements to Bob. We obtain the following optimal bounds.

Theorem 2.

For ε<1/n, the one-way communication complexity of Approximate Set Intersection is Θ(nlog(2/ε2n)) and the two-way complexity is Θ(n). For ε1/n the communication complexity of Approximate Set Intersection is Θ(1/ε2+logn) in both the one-way and two-way settings.

The gap between the optimal bounds for Approximate Set Intersection in the one-way and two-way communication settings implies that our lower bound for F2 estimation in the range ε<1/n does not extend to multi-pass streaming algorithms. Motivated by that, we present a streaming algorithm extending the ideas from the communication protocol of Brody et al. [11], that computes an exact histogram of a stream (and in particular its exact F2) using only two passes and O(nloglogn)=o(nlogn) memory.

Theorem 3.

There exists a streaming algorithm that in two passes and using O(nloglogn) bits of memory computes, with high probability, an exact histogram of the stream.

Woodruff and Zhou [35] recently showed that for p>2 and ε=o(1), there is an asymptotic separation between the space complexity of Fp estimation in one-pass versus O(1)-passes. Their work leaves open the question of whether such a separation also holds for “small” frequency moments (that is, p2). We show that indeed there exists such separation for F2, at least in the range ε<1/n. In the full version of this paper, we generalize this streaming algorithm for any constant number of passes r and conclude that Θ(nlog(Θ(r))n) bits of memory are both necessary and sufficient for exact histogram computation, where log(k)n denotes the k-fold iterated logarithm.

Problem Model ε<1/n ε1/n
Approx. Set Intersection One-way 𝚯(𝒏𝐥𝐨𝐠(𝟐/𝜺𝟐𝒏)) 𝚯(𝟏/𝜺𝟐+𝐥𝐨𝐠𝒏)
Two-way Θ(n) 𝚯(𝟏/𝜺𝟐+𝐥𝐨𝐠𝒏)
F2 Estimation One-pass 𝚯(𝒏𝐥𝐨𝐠(𝟐/𝜺𝟐𝒏)) Θ(log(ε2n)/ε2)
Two-passes 𝑶(𝒏𝐥𝐨𝐠𝐥𝐨𝐠𝒏) O(log(ε2n)/ε2),Ω(1/ε2+logn)
Figure 2: Complexity of Approximate Set Intersection and F2 Estimation.

See Figure 2 for a table summarizing the best-known bounds for the communication and streaming problem we discuss, with results in bold being those presented in this paper.

The space complexity of frequency moment estimation was extensively studied in many settings, and for many parameter choices [12, 33, 5, 20, 7, 27, 9, 23, 16, 17, 4, 34, 25, 3, 10, 21, 28], we refer the reader to the introduction of [8] for a more exhaustive overview of the existing literature.

2 Overview and Organization

In this section, we outline the main technical ideas behind our results and describe the organization of the rest of the paper.

Section 3: Communication lower bounds and streaming implications, in the 𝜺<𝟏/𝒏 range

We prove that any one-way communication protocol that approximates |AB| up to additive error εn requires Ω(nlog(1/ε2n)) bits when ε<1/n. This is shown via an information-theoretic construction inspired by the construction used by [14] to obtain a lower bound for the one-way communication complexity of Set Disjointness. We construct a large family of inputs for Alice and a small set of inputs for Bob, and show that every Alice input is uniquely identified by the answers of the communication protocol to all of Bob’s possible inputs. In a one-way communication protocol though, Alice’s message depends only on her own input and should thus intuitively encode enough information to answer any possible Bob input – which in this case results in having to fully encode her own input. Our main contribution is proving the existence of such input families, which becomes more involved in comparison to the exact problem of Set Disjointness. We then reduce from this communication problem to streaming F2 estimation using a standard concatenation protocol, implying the same lower bound for streaming algorithms.

Section 4: Matching upper bounds via hashing

We complement the lower bounds with a simple estimator for F2 that matches the bound up to constants. The algorithm hashes the universe into a domain of size m=Θ(1/ε2) using a 4-wise independent hash function, and stores the exact multiset of hash values. Here the main observation is that while the hashing induces too many collisions, we can analytically subtract the expected number of hash collisions from the observed number of collisions to obtain a significantly better estimator for the number of collisions in the original stream. We analyze the variance of the estimator and show it concentrates around the true F2 value, yielding an estimate with additive error εF2 using O(nlog(1/ε2n)) bits of memory.

Section 5: The high-error regime

We analyze the case ε1/n and prove that the communication complexity of approximate set intersection is Θ(1/ε2+logn) in both one-way and two-way models. Both the lower and upper bounds are essentially reductions to the ε=Θ(1/n) case which is very similar to the Gap Hamming Distance Problem. The lower bound is then indeed established by a reduction from the Gap Hamming Distance problem. The matching upper bound is obtained using subsampling which reduces the problem to the problem of estimating the set intersection size of two sets of some size k up to an additive error of Θ(k), a problem which we already present an optimal solution for in the previous sections. These simple bounds complete our characterization of the communication complexity of the Approximate Set Intersection problem.

Section 6: A two-pass algorithm for exact histograms

Motivated by the one-way/two-way gap in communication, we begin by designing a streaming algorithm that computes the exact histogram of the stream in three passes using only O(nloglogn) bits of space. The algorithm uses the first pass to hash elements into buckets and record “cheap” fingerprint-based histograms in each bucket, then uses the second pass to verify which of these histograms is correct using a randomized algebraic identity check, and finally uses the third pass to recompute the histograms of the few incorrect buckets exactly. Our algorithm builds upon the communication protocol of Brody et al. [11] for computing the exact set intersection in two-way communication, and transforms it to a streaming algorithm. One of our main technical contributions in this algorithm is constructing a streaming algorithm that can verify, in one-pass, an assumed histogram for a multiset of elements. This verification step is straightforward in the two-way communication setting, where each party can hash and compare their entire input, but requires new techniques in the streaming model. We then introduce ideas from sparse recovery to eliminate the third pass and achieve the same memory bound with a two-pass streaming algorithm. Finally, we discuss the optimality of this bound, concluding that any constant-pass algorithm for exact computation of F2 (and in particular, exact histogram computation) requires Ω(nlog(t)n) memory for some constant t. In the full version of this paper, we generalize our algorithm to a larger number of passes.

Section 7: Summary

We conclude with a summary of our results and a discussion of open problems. In particular, we highlight the question of whether a separation between one-pass and multi-pass complexity exists also in the lower-accuracy regime ε>1/n.

3 Lower Bounds in the Low Error Regime

In this section, we prove the lower bounds in Theorems 1 and 2 in the ε<1/n regime. We first establish the communication complexity lower bound for computing set intersection size up to small additive error, and then show this result implies a lower bound for second-moment estimation in the streaming model under similar error guarantees. Throughout this section, we assume the universe U is of large enough (yet polynomial) size in n.

3.1 Approximate Set Intersection

Our proof follows the general framework of Dasgupta et al. [14], who proved a Ω(nlogn) lower bound for the one-way communication complexity of Set Disjointness. We begin by defining a promise problem that captures the essential hardness of approximate set intersection, which can be viewed as a refinement of the Gap Hamming Distance promise problem. We then construct, non-explicitly, a large family of inputs for Alice and a much smaller family for Bob such that, for every input in Alice’s family, the answers to the promise problem for all inputs in Bob’s family uniquely identifies it. Such a family implies a lower bound on the one-way communication complexity.

Definition 4 (INTε).

Let X,YU inputs for Alice and Bob respectively, such that |X|,|Y|n. We denote by INTε(X,Y) the communication problem of calculating |XY| up to an additive error εn with probability >2/3.

Definition 5 (INT-Pα Promise Problem).

Let α=α(n)(1000lnn,12), and X,YU inputs for Alice and Bob respectively, such that |X|,|Y|n.
We denote by INT-Pα the communication problem of distinguishing with probability >2/3 between

  • Yes-instances: Pairs (X,Y) such that |XY|n1α+12n1α.

  • No-instances: Pairs (X,Y) such that |XY|n1α12n1α.

For brevity, we write (X,Y)Yes or (X,Y)No, always referring to this promise problem.

We observe that any protocol solving INTε also solves INTPα as long as εn<12n1α, or equivalently, α<log(1/(ε2n))2logn. We thus first establish an Ω(αnlogn) lower bound for INTPα and then deduce from it an Ω(nlog(1/(ε2n))) lower bound for INTε. We begin by constructing a large family 𝒳 of possible inputs to Alice, and a small family 𝒴 for possible inputs to Bob, such that the answers to INTPα on all inputs of 𝒴 uniquely identifies any input X𝒳.

Definition 6 (Design).

A family 𝒳 of subsets of U is a design if:

  • X𝒳, we have |X|=n,

  • XX𝒳, we have |XX|n400.

Definition 7 (Block-Uniform Distribution 𝒟n,α).

Fix an integer n1 and a parameter α=α(n)(1000lnn,1). Partition the universe [n1+α]U into n disjoint blocks B1,,Bn, each of size nα. The block-uniform distribution 𝒟n,α is the uniform distribution over sets X[n1+α],|X|=n obtained by the following sampling procedure:

  1. 1.

    For each block Bi independently, pick one element xiBi uniformly at random.

  2. 2.

    Output the set X={x1,x2,,xn}.

Lemma 8.

For a sufficiently large integer n and any α=α(n)(1000lnn,12), there exists a design of size exp(cαnlnn) for some constant c.

Proof.

We give a non-explicit construction using the probabilistic method. Independently and uniformly sample N:=exp(13200αnlnn)=exp(cαnlnn) sets from 𝒟n,α.

Let X,X be two sets sampled from 𝒟n,α. Let Y|XX|, and note that YBin(n,1nα) and μ𝔼[Y]=n1nα=n1α. Using a standard Chernoff bound we have

Pr[Y(1+δ)μ](eδ(1+δ)1+δ)μ,

with (1+δ)μ=n400, so δ=1400nα1. Note that as α1000lnn, δ>0 and the Chernoff bound can be applied. Thus, we deduce that

lnPr[Y>n400]μ(δ(1+δ)ln(1+δ))12μδln(δ),

where the last inequality follows as for all δ>0 (which holds for all α when n is sufficiently large), we have

δ(1+δ)ln(1+δ)δlnδ2.

Note that μδ=n1α(nα4001)n600 and lnδln(nα600)=αlnnln600. For all sufficiently large n, this gives lnδ34αlnn. The constants here are arbitrary slack constants chosen to simplify the expressions. Hence,

Pr[Y>n400]exp(αnlnn1600).

We apply a union bound over all (N2) pairs of sets we sampled, and deduce that the probability that any pair had too big of an intersection is bounded by

(N2)exp(11600αnlnn)<1.

Therefore, a design of the required size exists for c=1/3200.

Lemma 9 (Random Y distinguishes between X and X).

There exists a universal constant p0>0 such that the following holds. Let α=α(n)(1000lnn,12) and a design 𝒳, let XX𝒳 be any pair from the design. Then, with Y sampled uniformly from 𝒟n,α,

PrY[((X,Y)Yes(X,Y)No)((X,Y)No(X,Y)Yes)]p0.

We call this event “Y distinguishes between X and X".

Proof.

Let p=nα and μ=n1α. Denote by m=|XX|n400 and M=nm399n400, and denote μM=Mp,μm=mp. We also denote

Zsame=|YXX|,Zdiff=|Y(XX)|,Zdiff=|Y(XX)|.
Z=|YX|=Zsame+Zdiff,Z=|YX|=Zsame+Zdiff.

Note that as X,X,m,M are fixed (and are not random variables), and all probabilities are taken only over the random choice of Y. Because the m intersecting blocks and the M differing blocks are disjoint and the choices of Y values in each block are i.i.d, Zsame is independent of (Zdiff,Zdiff).

Step 1: Chernoff bound for 𝒁same.

We have ZsameBin(m,p) with mean μmμ/400. Using a two-sided Chernoff bound with δ=2μm we have

Pr[|Zsameμm|>2μm]2e4/3,soPr[|Zsameμm|2μm]c212e4/3>0.47.
Step 2: Berry–Esseen tail bound for 𝒁𝐝𝐢𝐟𝐟 and 𝒁𝐝𝐢𝐟𝐟.

Fix an arbitrary ordering of the M “differing” blocks and write

Bi=𝟙{YX is not empty in block i}i=1,,M.

Then Bii.i.d.Ber(p) and Zdiff=i=1MBi. Center the variables by setting Vi:=Bip and SM:=i=1MVi, so that Zdiff=μM+SM.

Verifying the Berry–Esseen assumptions. Each Vi satisfies 𝔼[Vi]=0, σ2:=Var(Vi)=p(1p)>0, and ρ:=𝔼[|Vi|3]=p(1p)3+(1p)p3=p(1p)((1p)2+p2)p(1p)=σ2.

Normalisation. Let σM2=Var(SM)=Mp(1p)=μM(1p) and denote by S^M:=SM/σM which has cumulative distribution function FM(x)=Pr[S^Mx].

Berry–Esseen inequality. By the Berry-Esseen Inequality [15, Ch. XVI, §5, Thm. 1] with the sharpened constant of Shevtsova C=0.4748 [32], where Φ denotes the standard normal CDF, we have

|FM(x)Φ(x)|Cρσ3M=CMp(1p)=CμM(1p)2CμM,

where the last inequality holds as 1p>1/2.

Applying the bound. We want a lower bound for Pr[ZdiffμM0.603μM]. Put k=μM0.603μM and x=(kμM)/σM=0.603/1p(0.853,0.603). Because Φ is decreasing, Φ(x)Φ(0.603)=0.2736. Applying (BE) and assuming that n is large enough so μM100,

Pr[ZdiffμM0.603μM]=FM(x)Φ(x)20.4748μM0.27360.067>0.2.

Hence,

Pr[ZdiffμM0.603μM]c1:=0.2.

By symmetry the same constant bound holds for Pr[ZdiffμM+0.603μM].

Step 3: Combining bounds.

Let R:=μM+0.603μM and L:=μM0.603μM. When all three of the above events hold, we get

ZR+Zsameμ+0.5μ,ZL+Zsameμ0.5μ.

Which implies

Pr[(Zμ+0.5μ)(Zμ0.5μ)]
Pr[(ZdiffR)(ZdiffL)(Zsame[μm2μm,μm+2μm)]]
=Pr[(ZdiffR)(ZdiffL)]Pr[Zsame[μm2μm,μm+2μm)]],

where the last equality holds as Zsame is independent from Zdiff and Zdiff.

Step 4: Negative correlation between 𝒁𝒅𝒊𝒇𝒇 and 𝒁𝒅𝒊𝒇𝒇.

For every differing index i define the indicators Ei=𝟙{Yi=Xi} and Fi=𝟙{YiXi}. Because the random choice of Y is block-wise independent, the collection {(Ei,Fi)}i=1M is also independent. Consider the two increasing events

A:={iEiμM+0.603μM},B:={i(1Fi)μM0.603μM}.

Since Ei=1 implies Fi=1, both A and B are monotone in the same direction. By the Harris (binary FKG) inequality [19] we thus have

Pr[AB]Pr[A]Pr[B].

Rewriting A and B in terms of Zdiff and Zdiff gives

Pr[ZdiffμM+0.603μMZdiffμM0.603μM]
Pr[ZdiffμM+0.603μM]Pr[ZdiffμM0.603μM]c12.
Step 5: Symmetry.

Swapping X and X gives a disjoint event of equal probability. So the total distinguishing probability is at least

Pr[Y distinguishes X,X]2c12c2=:p0>0.

Lemma 10 (Existence of family 𝒴 fully distinguishing a design 𝒳).

Let α=α(n)(1000lnn,12), and let 𝒳 be a design of size exp(cαnlnn). There exists a family 𝒴U such that:

  • |Y|=n for all Y𝒴.

  • |𝒴|kαnlnn for a universal constant k.

  • For any XX𝒳, some Y𝒴 distinguishes them.

We call this behavior 𝒴 describes 𝒳.

Proof.

We draw a set 𝒴 of the desired size uniformly and independently from 𝒟n,α. Note that the amount of pairs XX𝒳 is smaller than exp(cαnlnn)2=exp(2cαnlnn). As described in Lemma 9, for some XX, the probability that a single y𝒴 distinguishes between X and X is at least p0, (where p0 is the constant probability bound from Lemma 9). As the sets in 𝒴 are chosen independently,

[Y𝒴,Y does not distinguish between X and X]<(1p0)|𝒴|.

Therefore, by a union bound,

[XX𝒳:Y𝒴,Y does not distinguish between X and X]
<exp(2cαnlnn)(1p0)|𝒴|,

and for |𝒴|>2cln(1p0)kαnlnn, this probability is smaller than 1. Meaning, when randomly choosing 𝒴 of size kαnlnn, the probability that it differentiates between every pair XX𝒳 is positive. Therefore, by the probabilistic method, a family 𝒴 that meets the conditions exist.

We are now ready to prove the desired lower bound.

Lemma 11.

For any large enough n, and for any ε<1/(2e500n), the randomized one-way communication complexity of INTε is Ω(nlog(1/ε2n)).

Proof.

Any algorithm that solves INTε with probability >2/3 can be amplified to fail with probability at most δ for any constant δ by repetition. We thus assume the algorithm has a small enough failure probability, to be specified later. Denote by α=α(n):=log(1/(ε2n))2logn. For this choice, εn<12n1α, and thus an algorithm that solves INTε can easily be used to solve INT-Pα. Note that for n3/4<ε<1/(2e500n) we have 1000lnn<α<12. We may ignore the range εn3/4 as for ε=2n3/4 we already we get a lower bound of Ω(nlogn) which matches the upper bound even for ε=0.

By Lemma 8, there exists a design 𝒳 of size exp(cαnlnn). By Lemma 10, there exists some set-family 𝒴 of size kαnlnn that describes 𝒳. Consider the input distribution in which Alice gets a random set X from 𝒳 and Bob gets a random set Y from 𝒴. Applying Yao’s minimax principle [36], it suffices to lower-bound the distributional one-way communication complexity of any deterministic protocol that fails on this distribution with probability less than δ.

As |𝒳|=exp(cαnlnn), a uniformly sampled X𝒳 has entropy

H(X)=log2|𝒳|=cαnlnnln2,

and for simplicity we modify the constant c to “absorb” the factor 1ln2. By Lemma 10, the sequence {INTPα(X,y):y𝒴} uniquely determines X, therefore

H({INTPα(X,y)}y𝒴)H(X)cαnlnn.

Let A(X) be the message sent by Alice in a deterministic one-way protocol. Let δ be small enough that δ<1/3 and H(δ)<c2k, and let t=|𝒴|=kαnlnn. Then,

H(δ) H(INTPα(X,Y)A(X),Y) by Fano’s inequality
=1ty𝒴H(INTPα(X,y)A(X),Y=y)
=1ty𝒴H(INTPα(X,y)A(X)) since XY
1tH({INTPα(X,y)}y𝒴A(X)) by sub-additivity
=1t(H({INTPα(X,y)}y𝒴)H(A(X))) by the chain rule
1t(H({INTPα(X,y)}y𝒴)|A(X)|).

Rearranging, we have that the message size is at least

|A(X)|H({INTPα(X,y)}y𝒴)tH(δ).

Since H({INTPα(X,y)}y𝒴)=H(X)cαnlnn and tH(δ)<c2αnlnn, we get,

|A(X)|c2αnlnn=Ω(αnlnn)=Ω(nlog(1/ε2n)).

3.2 Second Moment Estimation

Corollary 12.

The space complexity of (1±ε)-estimating the second frequency moment of a stream of n elements from U, for any 1n2ε12e500n, is

Ω(nlog(1ε2n)).
Proof.

Given a streaming algorithm that (1±ε)-estimates F2 using s bits of memory, we obtain a one-way communication protocol for INT2ε that uses s+O(logn) bits.

Alice feeds her set X (each element once) into the streaming algorithm, obtaining memory image M. She sends (M,|X|) to Bob. Bob resumes the algorithm on his set Y, obtains an output Z, and returns

m=Z|X||Y|2.

Let S be the concatenation of X followed by Y. Each element in XY has frequency 1 in S, each element in XY frequency 2, so

F2(S)=|XY|+4|XY|=|X|+|Y|+2|XY|.

The above implies that F24n, hence |ZF2(S)|F2(S)ε4εn, which in turn gives

|m|XY||=12|ZF2(S)|2εn.

Thus the protocol computes INT2ε with the same success probability as the F2 estimator (say 2/3), using s+O(logn) bits. Applying Theorem 11 now yields the claimed streaming lower bound for F2.

4 Upper Bounds in the Low Error Regime

In this section we present matching upper bounds to the lower bounds established in the previous section, for both problems of interest: approximate set intersection in the one-way communication model, and second-moment estimation in the streaming model. These results establish the upper bounds required for Theorems 1 and 2 in the ε<1/n regime.

4.1 Second Moment Estimation

Lemma 13.

Let n be large enough, 1/n2ε1/n, and U a set of size |U|=poly(n). Then, we can (1±ε)-estimate the second frequency moment of a stream of n elements from U, with probability larger than 99%, using space

O(nlog(1ε2n)).

We first observe that any unordered multiset of n elements from a universe of size m can be stored using log(n+m1n)=O(nlog(2+mn)) bits of space. This immediately implies, for example, the O(nlog|U|n) upper bound when |U|2n. The algorithm we present to prove Lemma 13 is rather natural: we choose mε2 and draw a hash function h:U[m] that maps our element universe to a smaller one, and then maintain exactly the image of the input stream through h. Finally, we directly compute the F2 of the stream. When ε1/n and hence mn, and thus, our hash table is expected to contain roughly Θ(n2/m)Θ(n) hash collisions. The crucial observation is that, as we only care about the number of (actual) collisions in the table, we may subtract from it the expected number of hash collisions and thus vastly reduce the error caused by the hashing.

Algorithm 𝓐

  • Denote by m:=201ε2.

  • Draw a hash function h:U[m] from a 4-wise independent hash family, and store it in memory.

  • When receiving the elements of the stream S, maintain in memory the exact multiset h(S) of images of stream elements through h.

  • Finally, directly compute F:=F2(h(S)) the second frequency moment of the maintained multiset, then output F:=mm1(Fn2m).

We note that the space complexity of 𝒜 is as desired, as h can be stored using O(logn) bits of memory and the multiset h(S) using O(nlog(2+mn)) bits of space.

Claim 14.

𝔼[F]=F2(S).

Proof.

Denote by x1,,xn the elements of the stream S. Denote by Xi,j the event that h(xi)=h(xj). We have F=i,j[n]Xi,j. We observe that if xi=xj then Pr(Xi,j)=1, and if xixj then Pr(Xi,j=1)=1m. By linearity of expectation we thus have 𝔼[F]=F2(S)+(n2F2(S))1m and in turn 𝔼[F]=F2(S).

Claim 15.

Var(F)1100(εF2(S))2.

Proof.

We begin by bounding Var(F). Denote by P:={(i,j)[n]2|xi=xj} the set of F2(S) pairs of indices such that the two corresponding stream elements are equal. Denote by PC=[n]2P all other indices. We have

𝔼[F2] =𝔼[((i,j)[n]2Xi,j)2]
=𝔼[((i,j)PXi,j)2+2((i,j)PXi,j)((i,j)PCXi,j)+((i,j)PCXi,j)2]
=F2(S)2+2F2(S)𝔼[(i,j)PCXi,j]+𝔼[((i,j)PCXi,j)2]
=F2(S)2+2F2(S)(n2F2(S))1m+𝔼[((i,j)PCXi,j)2].

Let (i,j),(k,)PC. Note that xixj and xkx. The set I:={xi,xj,xk,x} can thus be of size 2, 3, or 4. If its size is |I|=2, then Pr(Xi,jXk,)=1m. Also, without loss of generality xi=xk,xj=x and thus (i,k),(j,)P. In particular, there are at most 2|P|2 such pairs. If |I|{3,4}, then Pr(Xi,jXk,)=1m2. We therefore have

𝔼[((i,j)PCXi,j)2]2|P|21m+|PC|21m2=2F2(S)21m+(n2F2(S))21m2.

Combining the inequalities above we deduce

Var(F)=𝔼[F2]𝔼[F]22F2(S)21m2201(εF2(S))2.

We conclude that

Var(F)=(mm1)2Var(F)1100(εF2(S))2,

for any sufficiently large n (and in turn m).

We conclude the proof of Lemma 13 by using Chebyshev’s inequality. ∎

4.2 Approximate Set Intersection

Corollary 16.

For any ε<1/n, the randomized one-way communication complexity of INTε is O(nlog(1/ε2n)).

Proof.

By the same argument as in Corollary 12, any algorithm that (1±ε)-estimates F2 can be converted to a communication algorithm solving INT2ε with the same success probability, at an added communication cost of O(logn), which doesn’t change the asymptotic communication bound and implies the desired upper bound.

5 Approximate Set Intersection in the High Error Regime

In this section, we establish a tight Θ(1/ε2+logn) bound on the communication complexity of the approximate set intersection problem, for both the one-way and two-way communication models. Combined with the results from the low-error regime, these bounds complete the proof of Theorem 2.

5.1 Lower Bound

Lemma 17.

Let ε>1/n. The randomized communication complexity of INTε is Ω(1ε2).

Proof.

We show a reduction from the Gap Hamming Distance (GHD) communication problem. In GHD, Alice and Bob receive binary strings x{0,1}k and y{0,1}k respectively, and output (with probability >2/3) “Yes” if Δ(x,y)<12kk, “No” if Δ(x,y)>12k+k, and any answer is acceptable if neither condition holds (where Δ denotes the Hamming distance). Chakrabarti and Regev ([13]) proved that any randomized protocol solving GHD requires Ω(k) bits of communication, even with two-way communication.

Let k=1/ε2 and let x,y{0,1}k be some input to GHD. Assume, without loss of generality, that kn (otherwise pad n up to the next multiple of k). We construct two sets A,B as follows,

A :=i=0k1{(xin+ink+t)|0t<nk},
B :=i=0k1{(yin+ink+t)|0t<nk}.

Each coordinate i of the GHD strings is “blown up” into a block of nk distinct elements. Hence, A,B[2n],|A|=|B|=n, and for every i the two blocks are equal (meaning, they contribute n/k to the intersection size) iff xi=yi. Note that

Δ(x,y)<k2k |AB|=nnkΔ(x,y)
>n2+knk=n2+εn(“Yes” instance),
Δ(x,y)>k2+k |AB|=nnkΔ(x,y)
<n2knk=n2εn(“No” instance).

Let Π(A,B) be some communication protocol that solves INTε. The following algorithm will hence solve GHD: Alice calculates A and Bob calculates B, then they run Π(A,B) and answer “Yes” iff Π(A,B) outputs anything larger than n/2. As shown above, if the GHD answer is “Yes”, this will indeed be the case, and if the GHD answer is “No”, it will not. As the only communication required by this protocol is the one required by Π, by the above, Π requires Ω(k)=Ω(1/ε2) bits of communication.

Similarly, a reduction from Equality yields a lower bound of Ω(logn) for private-randomness two-way communication protocols, even when ε is constant: encode each input as a distinct block of size 2εn+1, so equal inputs give intersection size 2εn+1 and unequal inputs give intersection size 0.

5.2 Upper Bound

Lemma 18.

Let ε>1/n. The one-way randomized communication complexity of INTε is O(1ε2) in the public-randomness model, and O(1ε2+logn) in the private-randomness model.

Proof.

We work in the public-randomness model and remark the changes needed for private-randomness at the end. We present three solutions, each improving on the last.

Algorithm 1 (One-way, 𝑶((𝐥𝐨𝐠𝒏)/𝜺𝟐) bits).

Define p=cnε2,c=40. Alice samples AA such that aiA:aiA with probability p, independently. If |A|10p|A|, the algorithm aborts, which by Markov’s inequality happens with probability <0.1. Otherwise, Alice sends (|A|,A). Bob outputs 1p|AB|.
Correctness: Denote C=AB,C=AB, and note that cC:Pr[cC]=p. Denote m=|C|,m=|C|. As 𝔼[m]=mp, and Var[m]mp, by Chebyshev’s inequality,

Pr[|1pmm|εn2]=Pr[|mpm|εnp2]Var[m]ε2n2p2/44mpε2n2p24c110

By a union bound, the algorithm fails with probability <0.2.
Communication cost: Each element in A can be written using O(logn) bits, and |A| is logn bits long. As |A| is bounded by 10p|A|10c/ε2, the communication cost is O(logn/ε2).

Algorithm 2 (Two-way, 𝑶(𝟏/𝜺𝟐) bits).

Reusing the notations from Algorithm 1, we replace the method for sampling A: Alice and Bob, interpret their shared randomness as a random hash function h:U[n]. Using h, they construct the samples,

A={aA:h(a)pn},B={bB:h(b)pn}.

We note that C=AB=AB as any element in the intersection is either in both samples or neither. Therefore, as before, Pr[cC]=p=Pr[cAB]. If A or B have size 10c/ε2, the algorithm aborts, which happens with probability <0.2 by the same analysis as above. After constructing the two sets, Alice and Bob run a two-way communication algorithm for computing |AB| exactly using O(|A|+|B|) bits of communication and fails with probability at most 0.01, e.g. using the protocol of Brody et al. [11]. As both sets are of size O(1/ε2), this is also the required communication. As before, they output 1pm=1p|AB|, which is a correct response with probability >0.9. Therefore, the algorithm fails with probability <0.31<1/3, as claimed.

Algorithm 3 (One-way, 𝑶(𝟏/𝜺𝟐) bits).

We construct A,B as in Algorithm 2, but replace the two-way intersection sub-routine by the one-way estimator presented in Corollary 12, that computes the same intersection size up to a small additive error: For k=Θ(1ε2), with O(k) transmitted bits it outputs z|AB| up to an additive error ε200k=Θ(1/k)k, and fails with probability <0.01. As Algorithms 1 and 2 gave an error <12εn, the triangle inequality shows we end up with error <εn if both Algorithm 2 and the sub-routine succeed. The overall failure probability is thus <0.2+0.1+0.01=0.31<1/3.

Private randomness.

Newman’s Theorem [29] replaces shared randomness by private randomness at an additive cost of O(logn) bits, resulting in O(1/ε2+logn).

6 Multipass Histogram Streaming

In this section we present a two-pass streaming algorithm that, with high probability, computes the exact histogram using O(nloglogn) bits of space. Afterwards, we consider streaming algorithms with a constant number of passes r and show that, for any fixed constant r, Θ(nlog(Θ(r))n) bits of memory are both necessary and sufficient for exact histogram computation.

6.1 Two–Pass Algorithm

Our approach is inspired by the two-way communication protocol of Brody et al. [11] for computing exact set intersection, which repeatedly verifies the equality of large sets and invokes a more expensive local-refinement step only when a set fails verification. While such verification is straightforward in the communication setting (each party has full access to its input), our main contribution is to design an analogous mechanism that operates efficiently in the streaming model.

At a high level, the algorithm partitions the stream into buckets via hashing and constructs compact approximate histograms using short fingerprints rather than full element identities. Most of these histograms are correct, and errors arise only from the small number of fingerprint collisions. A simpler three-pass warmup version of this framework appears in the full version.

The main idea of the two-pass algorithm is to avoid correcting buckets individually. Instead, we define a single global discrepancy polynomial that captures all over- and under-counts simultaneously. Since only a small number of coefficients of this polynomial can be non-zero, sparse-recovery ideas allow us to reconstruct it with high probability, and then directly correct the affected histogram entries.

Lemma 19.

Let S=x0,,xT1 be a stream of Tn elements drawn from a universe U. There is a two-pass streaming algorithm that outputs the exact histogram of S using O(nloglogn) bits of memory and succeeds with probability at least 13n2.

Preliminaries

We use the following hash functions throughout this section.

  • b:U[nlogn] is a 6logn-wise independent hash function. We refer to all elements with value j in b as the j-th bucket.

  • j[nlogn],gj:U[210loglogn] is a pairwise independent hash function. We refer to gb(xi)(xi) as the fingerprint of xi.

Definition 20.

Let 𝒟 denote the family of multi-linear polynomials δ(zx1,,zx|U|) with at most 6n/(logn)5 non-zero coefficients, where all coefficients are integers in [n,n].

The algorithm

Pass 1 (fingerprint histograms)

For every bucket j[n/logn], initialize an empty histogram Hj. The structure of the histograms is a list of pairs, each containing a fingerprint and a counter of appearances of this fingerprint in this bucket. When an element xi arrives, we check if gb(xi)(xi) was already encountered in bucket b(xi). If it is new, we add it to the histogram with counter 1. If it is not new, we increment the respective counter. We use the notation Hj[y] for the number of appearances of fingerprint y in the j-th bucket.

Pass 2 (sparse recovery)

Choose a prime q with 3n<q<23n and pick a random hash function h:U𝔽q.

For each index i let first(xi) be the first stream element x such that b(x)=b(xi) and fingerprint(x)=fingerprint(xi). Define two polynomials in 𝔽q[z1,,z|U|]:

TrueSum(z1,,z|U|)=i=1|U|zxi,HistSum(z1,,z|U|)=i=1|U|zfirst(xi).

If some pair i<j satisfies xixj but gb(xi)(xi)=gb(xj)(xj) (i.e., two distinct elements in the same bucket share a fingerprint), the coefficients of zj differ in the two polynomials, hence TrueSumHistSum (as polynomials); if all fingerprints are unique, the polynomials coincide. Let Δ(z1,,z|U|)TrueSumHistSum.

Evaluate TrueSum and HistSum at the point (h(x))xU by maintaining two accumulators, accTrue and accHist, in 𝔽q:

  • To evaluate TrueSum, for every element xi we encounter, we add h(xi) to accTrue (mod q).

  • To evaluate HistSum, for every element xi, check if the fingerprint(xi) was observed before in the b(xi)-th bucket. We can differentiate between “new” and “not new” fingerprints by keeping an additional bit next to the fingerprints in the histogram, which doesn’t change the asymptotic memory requirements of the histogram.

    • If fingerprint(xi) is new in the bucket, add h(xi)Hb(xi)[fingerprint(xi)] to accHist (mod q).

    • If fingerprint(xi) is not a new fingerprint, we ignore it.

At the end, set resaccTrueaccHist𝔽q, and note that res=Δ(h(x1),,h(x|U|)).

Output

Let {δi}i[|𝒟|] be an enumeration of 𝒟. For each i, check if δi(h(x1),,h(x|U|))=res; on the first match set δ=δi (if no matches are found, abort).

For this δ, and for each zx with a positive coefficient ax, create a new histogram entry (or increment the existing entry) for gb(x)(x) in bucket b(x) with counter ax; for each zx with a negative coefficient ax, subtract ax from the histogram entry of gb(x)(x) in bucket b(x).

The following lemmas are used in the correctness proof.

Lemma 21.

Let XU such that |X|n. Let b:U[nlogn] be a hash function as described in the preliminaries. We call b1(j) the j-th bucket. With probability at least 11n2, every bucket contains at most 6logn distinct elements from X.

Proof.

Fix some bucket j. The expected number of distinct elements xX in this bucket is at most logn. For any xiX, let Zi be an indicator for b(xi)=j. Let Zi=1nZi indicate the number of distinct stream elements in this bucket, and μ𝔼[Z]logn. Schmidt–Siegel’s limited-independence Chernoff bound [31] states that the multiplicative Chernoff bound can be applied on binary variables that are k-wise independent for kδμ1μ/n. In our case, as b is 6logn-wise independent, the bound is applicable for δ=5 (for large enough n), obtaining that the probability that the j-th bucket has more than 6logn distinct stream elements is bounded by exp(52logn7)<1n3. A union bound over all buckets implies that the probability that all buckets contain at most 6logn elements is at least 1nlogn1n3>11n2.

Lemma 22.

Denote k=nlogn, and let X1,,XkU be sets that are pairwise disjoint, such that i[k],|Xi|6logn. Let gi:U[210loglogn] be hash functions as described in the preliminaries. For xjXi we call gi(xj) the fingerprint of xj. We say a set Xi contains a fingerprint collision if xkxmXi such that gi(xk)=gi(xm). Then, with probability at least 11n2, less than n(logn)6 of the sets X1,,Xk contain a fingerprint collision.

Proof.

For every set Xi let Zi be an indicator that there is a fingerprint collision in this set, and let Zi=1kZi. As gi is pairwise independent, p:=Pr[Zi=1](6logn2)(logn)1018(logn)8, and by linearity of expectation, μ𝔼[Z]18n(logn)9. As the different gi hash functions are independent of one another, the Zi are independent random variables, therefore, by a Chernoff bound,

Pr[Zn(logn)6]Pr[Z(1+(logn)2)μ]exp(18n(logn)3)<1n2.

Hence, with probability at least 11n2, less than n(logn)6 sets have a fingerprint collision.

Lemma 23.

|𝒟|2n (for all sufficiently large n).

Proof.

Let s6n/(logn)5. As throughout the paper, we assume |U|nc for a constant c>0. Then,

|𝒟|m=0s(|U|m)(2n+1)m(s+1)(|U|s)(2n+1)s(s+1)(e|U|s)s(2n+1)s.

Using |U|nc and s=6n/(logn)5,

log|𝒟|log(s+1)+s(log(e|U|/s)+log(2n+1))=o(n).

Hence log|𝒟|n for all sufficiently large n, i.e., |𝒟|2n.

Correctness

By Lemmas 21 and 22, with probability >12n2, Δ has at most s6n/(logn)5 non-zero coefficients, and all coefficients are integers in [n,n], hence Δ𝒟. For any 𝒟δΔ, by Schwartz-Zippel and the fact that they are both multi-linear,

Prh𝔽q[z1,,z|U|][δ(h(x1),,h(x|U|))=Δ(h(x1),,h(x|U|))]1q13n.

Therefore, by a union bound over 𝒟, using Lemma 23,

Prh𝔽q[z1,,z|U|][δ𝒟{Δ}:δ(h)=Δ(h)]|𝒟|q(23)n.

Finally, if δ=Δ, then TrueSumΔ+HistSum, hence all coefficients match and the correction step yields the exact histogram. Summing the failure probabilities from the two preliminary lemmas (2/n2) and the probability that some δΔ coincides with Δ at h gives an overall bound of <3/n2.

Representing the hash 𝒉

Representing a fully random h:U𝔽q naively requires too much memory. Instead, we use Newman’s public–to–private randomness reduction [29], observing that it also works for streaming algorithms. For any problem with at most N possible inputs, there exists a set of O(logN) values of the shared randomness such that picking uniformly from this set preserves the success probability up to a small additive error, simultaneously for all inputs. In particular, it suffices to only maintain in memory an index of one choice within this family, which requires only O(loglogN) bits of space. In our case, N=|U|n bounds the number of possible streams.

Memory cost

Hash functions.

The function b is 6logn-wise independent, requiring O(log2n) bits of memory. The functions gj are nlogn pairwise independent hash functions, each requiring O(logn) bits to describe, for a total of O(n) bits.

Counters in histograms.

The total sum of all counters is n, hence all counters together require at most O(n) bits.

Fingerprints.

Each bucket stores at most 6logn distinct fingerprints with high probability (by Lemma 21). Each fingerprint uses 10loglogn bits. Since there are nlogn buckets, the total fingerprint storage is

nlogn6logn10loglogn=O(nloglogn).
Second pass.

We store two accumulators in 𝔽q, requiring Θ(n) bits total, and reuse O(n) working memory while enumerating candidates δ𝒟.

Summing all contributions gives

O(n)+O(n)+O(nloglogn)+O(n)=O(nloglogn).

6.2 Higher Number of Passes and Further Remarks

We remark that an algorithm using only O(n) memory cannot compute F2 exactly with probability >2/3, let alone the full histogram, with any constant number of passes over the stream. This follows from the r-rounds communication lower bound of Ω(nlog(r)n) for the set disjointness problem, established by Sağlam and Tardos [30]. For any constant r, by the standard streaming–communication simulation, their result implies a corresponding Ω(nlog(2r1)n) lower bound for r-pass streaming algorithms. We note that for super-constant r, there also exists an algorithm that calculates exact histograms with only O~(n/r+n) bits of memory, by using each pass to compute an exact histogram of another 1/r fraction of the element identities and finally aggregating it with a succinctly represented histogram of the elements processed in the rounds so far. This is near optimal, as a lower bound of Ω(n/r) can be obtained from the two-way communication bound of Ω(n) for set-disjointness, and a Ω(n) lower bound follows from the memory required to represent a histogram.

On the positive side, the set-intersection communication protocol of Brody et al. [11], on which our streaming algorithm is based, extends naturally to r rounds and yields an O(nlog(Ω(r))n) upper bound in the communication model. Using the ideas we introduced, the full version of this paper translates their protocol into the streaming setting and extends them to obtain an analogous r-pass streaming upper bound. Specifically, the full version proves using (2r1)-passes, O(nlog(r)n) bits of memory suffice for exactly computing the histogram.

Finally, while our three-pass algorithm is also efficient in terms of running time, our two-pass algorithm is not. Since our focus is on space complexity, we presented the simplest solution we could find; however, it is likely that efficiency can be achieved using standard polynomial sparse-recovery techniques [37, 6, 22].

7 Summary and Open Problems

We provide tight bounds for estimating the second frequency moment F2 of a data stream in the low-error regime ε<1/n. Our results fully characterize the one-pass space complexity of (1±ε)-approximating F2 for all values of ε, matching upper and lower bounds up to constant factors. Central to our approach is a precise understanding of the communication complexity of Approximate Set Intersection, which exhibits a sharp phase transition at ε=1/n.

We also present a two-pass streaming algorithm that exactly computes a histogram using O(nloglogn) bits of memory, showing a strict asymptotic separation between one-pass and constant-pass space complexity for F2 estimation when ε<1/n. This naturally leads to the following question. Is there also a separation between one-pass and O(1)-pass streaming algorithms for F2 estimation in the regime ε>1/n? The older Ω(1/ε2+logn) space lower bound for F2 is now known to be sub-optimal for one-pass yet holds also for any constant number of passes. Can either the lower bound or algorithm be improved in these settings?

We also leave as an open problem characterizing the exact trade-off between the number of passes and memory required for exactly computing a stream’s histogram. For example, using two passes we currently have a gap between our O(nloglogn) upper bound and the Ω(nlogloglogn) lower bound implied by the communication complexity of Set Intersection.

References

  • [1] Noga Alon, Phillip B Gibbons, Yossi Matias, and Mario Szegedy. Tracking join and self-join sizes in limited storage. In Proceedings of the eighteenth ACM SIGMOD-SIGACT-SIGART symposium on Principles of database systems, pages 10–20, 1999. doi:10.1145/303976.303978.
  • [2] Noga Alon, Yossi Matias, and Mario Szegedy. The space complexity of approximating the frequency moments. In Proceedings of the twenty-eighth annual ACM symposium on Theory of computing, pages 20–29, 1996. doi:10.1145/237814.237823.
  • [3] Alexandr Andoni. High frequency moments via max-stability. In 2017 IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP), pages 6364–6368. IEEE, 2017. doi:10.1109/ICASSP.2017.7953381.
  • [4] Alexandr Andoni, Robert Krauthgamer, and Krzysztof Onak. Streaming algorithms via precision sampling. In 2011 IEEE 52nd Annual Symposium on Foundations of Computer Science, pages 363–372. IEEE, 2011. doi:10.1109/FOCS.2011.82.
  • [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] Michael Ben-Or and Prasoon Tiwari. A deterministic algorithm for sparse multivariate polynomial interpolation. In Proceedings of the twentieth annual ACM symposium on Theory of computing, pages 301–309, 1988.
  • [7] Lakshminath Bhuvanagiri, Sumit Ganguly, Deepanjan Kesh, and Chandan Saha. Simpler algorithm for estimating frequency moments of data streams. In Proceedings of the seventeenth annual ACM-SIAM symposium on Discrete algorithm, pages 708–713, 2006. URL: http://dl.acm.org/citation.cfm?id=1109557.1109634.
  • [8] Mark Braverman and Or Zamir. Optimality of frequency moment estimation. In Proceedings of the 57th Annual ACM Symposium on Theory of Computing (STOC), Prague, Czech Republic, June 2025.
  • [9] Vladimir Braverman and Rafail Ostrovsky. Recursive sketching for frequency moments. arXiv preprint, 2010. arXiv:1011.2571.
  • [10] Vladimir Braverman, Emanuele Viola, David P. Woodruff, and Lin F. Yang. Revisiting Frequency Moment Estimation in Random Order Streams. In 45th International Colloquium on Automata, Languages, and Programming (ICALP 2018), volume 107 of Leibniz International Proceedings in Informatics (LIPIcs), pages 25:1–25:14. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2018. doi:10.4230/LIPIcs.ICALP.2018.25.
  • [11] 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.
  • [12] Amit Chakrabarti, Subhash Khot, and Xiaodong Sun. Near-optimal lower bounds on the multi-party communication complexity of set disjointness. In 18th IEEE Annual Conference on Computational Complexity, 2003. Proceedings., pages 107–117. IEEE, 2003. doi:10.1109/CCC.2003.1214414.
  • [13] Amit Chakrabarti and Oded Regev. An optimal lower bound on the communication complexity of gap-hamming-distance, 2012. arXiv:1009.3460.
  • [14] Anirban Dasgupta, Ravi Kumar, and D. Sivakumar. Sparse and lopsided set disjointness via information theory. In Anupam Gupta, Klaus Jansen, José Rolim, and Rocco Servedio, editors, Approximation, Randomization, and Combinatorial Optimization. Algorithms and Techniques, pages 517–528, Berlin, Heidelberg, 2012. Springer Berlin Heidelberg. doi:10.1007/978-3-642-32512-0_44.
  • [15] William Feller. An introduction to probability theory and its applications. Vol. II. Second edition. John Wiley & Sons Inc., New York, 1971.
  • [16] Sumit Ganguly. A lower bound for estimating high moments of a data stream. arXiv preprint, 2011. arXiv:1201.0253.
  • [17] Sumit Ganguly. Polynomial estimators for high frequency moments. arXiv preprint, 2011. arXiv:1104.4552.
  • [18] Anna C Gilbert, Sudipto Guha, Piotr Indyk, Yannis Kotidis, Sivaramakrishnan Muthukrishnan, and Martin J Strauss. Fast, small-space algorithms for approximate histogram maintenance. In Proceedings of the thiry-fourth annual ACM symposium on Theory of computing, pages 389–398, 2002.
  • [19] T. E. Harris. A lower bound for the critical probability in a certain percolation process. Mathematical Proceedings of the Cambridge Philosophical Society, 56(1):13–20, 1960. doi:10.1017/S0305004100034241.
  • [20] Piotr Indyk and David Woodruff. Optimal approximations of the frequency moments of data streams. In Proceedings of the thirty-seventh annual ACM symposium on Theory of computing, pages 202–208, 2005. doi:10.1145/1060590.1060621.
  • [21] Rajesh Jayaram and David P. Woodruff. Towards Optimal Moment Estimation in Streaming and Distributed Models. In Approximation, Randomization, and Combinatorial Optimization. Algorithms and Techniques (APPROX/RANDOM 2019), volume 145 of Leibniz International Proceedings in Informatics (LIPIcs), pages 29:1–29:21. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2019. doi:10.4230/LIPIcs.APPROX-RANDOM.2019.29.
  • [22] Erich Kaltofen and Lakshman Yagati. Improved sparse multivariate polynomial interpolation algorithms. In International Symposium on Symbolic and Algebraic Computation, pages 467–474. Springer, 1988. doi:10.1007/3-540-51084-2_44.
  • [23] Daniel M Kane, Jelani Nelson, and David P Woodruff. On the exact space complexity of sketching and streaming small norms. In Proceedings of the twenty-first annual ACM-SIAM symposium on Discrete Algorithms, pages 1161–1178. SIAM, 2010. doi:10.1137/1.9781611973075.93.
  • [24] Balachander Krishnamurthy, Subhabrata Sen, Yin Zhang, and Yan Chen. Sketch-based change detection: Methods, evaluation, and applications. In Proceedings of the 3rd ACM SIGCOMM conference on Internet measurement, pages 234–247, 2003. doi:10.1145/948205.948236.
  • [25] Yi Li and David P Woodruff. A tight lower bound for high frequency moment estimation with small error. In International Workshop on Approximation Algorithms for Combinatorial Optimization, pages 623–638. Springer, 2013. doi:10.1007/978-3-642-40328-6_43.
  • [26] Jeřábek Meir. Communication complexity of approximating the size of set intersection, June 2018. Theoretical Computer Science, Stack Exchange. URL: https://cstheory.stackexchange.com/questions/41086/communication-complexity-of-approximating-the-size-of-set-intersection.
  • [27] Morteza Monemizadeh and David P Woodruff. 1-pass relative-error lp-sampling with applications. In Proceedings of the twenty-first annual ACM-SIAM symposium on Discrete Algorithms, pages 1143–1160. SIAM, 2010. doi:10.1137/1.9781611973075.92.
  • [28] Jelani Nelson and Huacheng Yu. Optimal bounds for approximate counting. In Proceedings of the 41st ACM SIGMOD-SIGACT-SIGAI Symposium on Principles of Database Systems, pages 119–127, 2022. doi:10.1145/3517804.3526225.
  • [29] Ilan Newman. Private vs. common random bits in communication complexity. Information Processing Letters, 39(2):67–71, 1991. doi:10.1016/0020-0190(91)90157-D.
  • [30] Mert Saglam and Gabor 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.
  • [31] Jeanette P. Schmidt, Alan Siegel, and Aravind Srinivasan. Chernoff–hoeffding bounds for applications with limited independence. SIAM Journal on Discrete Mathematics, 8(2):223–250, 1995. doi:10.1137/S089548019223872X.
  • [32] Irina G. Shevtsova. On the absolute constant in the berry–esseen inequality. Doklady Mathematics, 82(3):862–864, 2010. doi:10.1134/S1064562410030099.
  • [33] David P Woodruff. Optimal space lower bounds for all frequency moments. In SODA, volume 4, pages 167–175. Citeseer, 2004. URL: http://dl.acm.org/citation.cfm?id=982792.982817.
  • [34] David P Woodruff and Qin Zhang. Tight bounds for distributed functional monitoring. In Proceedings of the forty-fourth annual ACM symposium on Theory of computing, pages 941–960, 2012. doi:10.1145/2213977.2214063.
  • [35] David P Woodruff and Samson Zhou. Separations for estimating large frequency moments on data streams. In ICALP, 2021.
  • [36] Andrew C. Yao. Probabilistic computations: Toward a unified measure of complexity. In Proceedings of the 18th Annual Symposium on Foundations of Computer Science (FOCS), pages 222–227. IEEE, 1977.
  • [37] Richard Zippel. Probabilistic algorithms for sparse polynomials. In International symposium on symbolic and algebraic manipulation, pages 216–226. Springer, 1979. doi:10.1007/3-540-09519-5_73.