Almost-Smooth Histograms and Sliding-Window Graph Algorithms

TL;DR

This paper extends the smooth-histogram framework to almost-smooth functions, enabling efficient sliding-window algorithms for various subadditive problems in data streams, including graphs, matrices, and norms.

Contribution

It introduces a generalized framework for almost-smooth functions, broadening the applicability of sliding-window algorithms to new problems.

Findings

Developed a $(2+\epsilon)$-approximation for subadditive functions in sliding windows.

Derived new algorithms for Schatten 4-norm and graph problems with near-optimal approximation ratios.

Showed many graph problems are subadditive, enabling efficient sliding-window solutions.

Abstract

We study algorithms for the sliding-window model, an important variant of the data-stream model, in which the goal is to compute some function of a fixed-length suffix of the stream. We extend the smooth-histogram framework of Braverman and Ostrovsky (FOCS 2007) to almost-smooth functions, which includes all subadditive functions. Specifically, we show that if a subadditive function can be $(1+\epsilon)$-approximated in the insertion-only streaming model, then it can be $(2+\epsilon)$-approximated also in the sliding-window model with space complexity larger by factor $O(\epsilon^{-1}\log w)$, where $w$ is the window size. We demonstrate how our framework yields new approximation algorithms with relatively little effort for a variety of problems that do not admit the smooth-histogram technique. For example, in the frequency-vector model, a symmetric norm is subadditive and thus we obtain a sliding-window $(2+\epsilon)$-approximation algorithm for it. Another example is for streaming matrices, where we derive a new sliding-window $(\sqrt{2}+\epsilon)$-approximation algorithm for Schatten $4$-norm. We then consider graph streams and show that many graph problems are subadditive, including maximum submodular matching, minimum vertex-cover, and maximum $k$-cover, thereby deriving sliding-window $O(1)$-approximation algorithms for them almost for free (using known insertion-only algorithms). Finally, we design for every $d\in (1,2]$ an artificial function, based on the maximum-matching size, whose almost-smoothness parameter is exactly $d$.

Tables

Table 1. Table 1: Randomized estimation algorithms for maximum-matching in graphs of arboricity α 𝛼 \alpha .

Stream	Approx.	Space	Reference
insertion-only	$22.5\alpha +6$	$O\left(\alpha {\log }^{2}n\right)$	[CJMM17]
insertion-only	$\left(\alpha +2\right)+\epsilon$	$O_{\epsilon }\left({\log }^{2}n\right)$	[MV18]
sliding-window	$\left(2+\epsilon \right)\left(\alpha +2\right)$	$O_{\epsilon }\left({\log }^{4}n\right)$	Theorem 1.11

Table 2. Table 2: Randomized streaming algorithms for vertex-cover in different settings. The results for vertex-cover size in forests (including VDP graphs) apply also to maximum-matching size, since the two quantities are equivalent by Kőnig’s Theorem, see Remarks 4.5 and 5.4 .

Problem	Graphs	Stream	Approx.	Space	Reference
		insertion-only	$2$	$O\left(n\log n\right)$	Folklore
vertex-cover (approximation)	general	sliding-window	$8+\epsilon$	$O_{\epsilon }\left(n{\log }^{2}n\right)$	[vH16]
		sliding-window	$4+\epsilon$	$O_{\epsilon }\left(n{\log }^{2}n\right)$	Theorem 5.6
vertex-cover size (estimation)	VDP	insertion-only	$1.5-\epsilon$	$\Omega \left(\sqrt{n}\right)$	[ETHL+18]
	VDP	turnstile	$1.25+\epsilon$	$O_{\epsilon }\left(\sqrt{n}{\log }^{2}n\right)$	[vH16]
	VDP	sliding-window	$3.125+\epsilon$	$O_{\epsilon }\left(\sqrt{n}{\log }^{4}n\right)$	Theorem 5.2
	forests	insertion-only	$2+\epsilon$	$O_{\epsilon }\left({\log }^{2}n\right)$	[MV18]
	forests	sliding-window	$4+\epsilon$	$O_{\epsilon }\left({\log }^{4}n\right)$	Theorem 5.3

Equations

$$\mathrm{Pr}\left[f\left(\mathcal{S}\right)\le \Lambda \left(\mathcal{S}\right)\le C\cdot f\left(\mathcal{S}\right)\right]\ge 1-\delta .$$

$$\mathrm{Pr}\left[\left(1-\epsilon \right)f\left(\mathcal{S}\right)\le \Lambda \left(\mathcal{S}\right)\le \left(1+\epsilon \right)C\cdot f\left(\mathcal{S}\right)\right]\ge 1-\delta ,$$

$$\frac{f\left(B\right)}{f\left(AB\right)}\le d\cdot \frac{f\left(BC\right)}{f\left(ABC\right)}$$

$$\begin{array}[]{ccccc}\mathbb{{\cal\varepsilon}}\cdot f\left(AB\right)\leq f\left(B\right)&&\implies&&\mathbb{{\cal\varepsilon}}\cdot f\left(ABC\right)\leq d\cdot f\left(BC\right).\end{array}$$

$$\begin{array}[]{ccccc}\left(1-\beta\left(\mathbb{{\cal\varepsilon}}\right)\right)\cdot f\left(AB\right)\leq f\left(B\right)&&\implies&&\left(1-\mathbb{{\cal\varepsilon}}\right)\cdot f\left(ABC\right)\leq f\left(BC\right).\end{array}$$

$$2f\left(BC\right)\ge$$

$$\ge$$

$$m\left(AB\right)=\left|M\right|=\left|M_A\right|+\left|M_B\right|\le m\left(A\right)+m\left(B\right),$$

$${\Vert X\Vert }_{S_p}={\left(\sum _{i=1}^m{\sigma }_i^p\right)}^{\text{nicefrac}1p}.$$

$${\Vert X\Vert }_{S_p}^2={\Vert Y^{T}Y+Z^{T}Z\Vert }_{S_{p/2}}\le {\Vert Y^{T}Y\Vert }_{S_{p/2}}+{\Vert Z^{T}Z\Vert }_{S_{p/2}}={\Vert Y\Vert }_{S_p}^2+{\Vert Z\Vert }_{S_p}^2,$$

$${\Vert X\Vert }_{S_p}^2={\Vert X^{T}X\Vert }_{S_{\text{nicefrac}p2}}\le \sum _{i=1}^n{\Vert X_i^T{X}_i\Vert }_{S_{\text{nicefrac}p2}}=\sum _{i=1}^n{\Vert X_i\Vert }_2^2\le \mathrm{poly}\left(n\right).$$

$$\hat{f}\left(AB\right)=f\left(M^{\ast }\right)\le f\left(M_A^{\ast }\right)+f\left(M_B^{\ast }\right)-f\left(\varnothing \right)\le \hat{f}\left(A\right)+\hat{f}\left(B\right).$$

$$c_k\left(AB\right)=\left|\tilde{E}\left(U\right)\right|=\left|E_A\right|+\left|E_B\right|\le c_k\left(A\right)+c_k\left(B\right),$$

$$f_d\left(G\right)=\frac{1}{4}\left(\frac{2-d}{d-1}\right)n+m\left(G\right).$$

$$2m\left(BC\right)$$

$$\ge m\left(BC\right)+\epsilon {\alpha }_{d}n+\epsilon m\left(AB\right)-{\alpha }_{d}n$$

$$\ge \epsilon \left(m\left(AB\right)+m\left(BC\right)\right)+\epsilon {\alpha }_{d}n-{\alpha }_{d}n$$

$$\ge \epsilon m\left(ABC\right)+\epsilon {\alpha }_{d}n-{\alpha }_{d}n.$$

$$\epsilon f_d\left(ABC\right)\le \left(d+2-d\right)m\left(BC\right)+{\alpha }_{d}n\le dm\left(BC\right)+\left(d-1\right){\alpha }_{d}n+{\alpha }_{d}n=d\cdot f_d\left(BC\right).$$

$$\epsilon f_d\left(ABC\right)\le f_d\left(ABC\right)={\alpha }_{d}n+m\left(ABC\right)\le {\alpha }_{d}n+\frac{n}{2}.$$

$$d\cdot f_d\left(BC\right)=d\cdot {\alpha }_{d}n+d\cdot m\left(BC\right)\ge d\cdot {\alpha }_{d}n+d\cdot \frac{n}{4}={\alpha }_{d}n+\frac{n}{2}+\left(d-1\right)\cdot {\alpha }_{d}n+\frac{dn}{4}-\frac{n}{2}={\alpha }_{d}n+\frac{n}{2},$$

$$\frac{f_d\left(ABC\right)}{f_d\left(BC\right)}=\frac{\frac{1}{4}\left(\frac{2-d}{d-1}\right)4n+2n}{\frac{1}{4}\left(\frac{2-d}{d-1}\right)4n+n}=\frac{\frac{2-d}{d-1}+2}{\frac{2-d}{d-1}+1}=\frac{2-d+2d-2}{2-d+d-1}=d,$$

$$O\left({\epsilon }^{-1}\log w\cdot s_{MV}\left(\epsilon ,\frac{\epsilon \delta }{2w\log w}\right)\right)=O\left({\epsilon }^{-3}{\log }^{4}n\log \frac{1}{\epsilon \delta }\right),$$

$$E_{\alpha }\left({\left(AB\right)}_t\right)=\left(E_{\alpha }\left({\left(AB\right)}_t\right)\cap A\right)\cup E_{\alpha }\left(B_t\right),$$

$$E_{\alpha }^{\ast }\left(AB\right)\le \left|E_{\alpha }\left(A\right)\right|+\left|E_{\alpha }\left(B_t\right)\right|\le E_{\alpha }^{\ast }\left(A\right)+E_{\alpha }^{\ast }\left(B\right).$$

$$\hat{m}\left(ABC\right)\le \hat{m}\left(AB\right)+\hat{m}\left(BC\right).$$

$$\left|\hat{M}\left(ABC\right)\cap C\right|\le \left|\hat{M}\left(BC\right)\right|.$$

$$2\hat{m}\left(BC\right)\ge$$

$$\ge$$

$$\left|V\left(\hat{M}\left(B_1\right)\right)\right|=2\cdot \hat{m}\left(B_1\right)\le 4\left(1+2\epsilon \right)\cdot \hat{m}\left(B_2\right)\le 4\left(1+2\epsilon \right)\cdot VC\left(W\right).$$

$$\left(1-\epsilon \right)f(B_1^{\prime })\le \left(1-\epsilon \right)\Lambda (B_1^{\prime })<\Lambda (B_2^{\prime })\le \left(1+\epsilon \right)C\cdot f(B_2^{\prime }),$$

$$\frac{1}{cC\left(1+\epsilon \right)}\Lambda (B_2)\le \frac{1}{c}\cdot f(B_2)\le f(W)\le c\cdot f(B_1)\le cdC\cdot \frac{\left(1+\epsilon \right)}{\left(1-\epsilon \right)}f(B_2)\le cdC\cdot \frac{\left(1+\epsilon \right)}{{\left(1-\epsilon \right)}^2}\Lambda (B_2).$$

Full text

We demonstrate how our framework yields new approximation algorithms with relatively little effort for a variety of problems that do not admit the smooth-histogram technique. For example, in the frequency-vector model, a symmetric norm is subadditive and thus we obtain a sliding-window $\left(2+\mathbb{{\cal\varepsilon}}\right)$-approximation algorithm for it. Another example is for streaming matrices, where we derive a new sliding-window $\left(\sqrt{2}+\mathbb{{\cal\varepsilon}}\right)$-approximation algorithm for Schatten $4$-norm. We then consider graph streams and show that many graph problems are subadditive, including maximum submodular matching, minimum vertex-cover, and maximum $k$-cover, thereby deriving sliding-window $O\text{\negmedspace}\left(1\right)$-approximation algorithms for them almost for free (using known insertion-only algorithms). Finally, we design for every $d\in\left(1,2\right]$ an artificial function, based on the maximum-matching size, whose almost-smoothness parameter is exactly $d$.

1 Introduction

Nowadays, there is a growing need for algorithms to process huge data sets. The Internet, including social networks and electronic commerce, as well as astronomical and biological data, provide new challenges for computer scientists and mathematicians, since traditional algorithms are not able to handle such massive data sets in a reasonable time. First, the data is too big to be stored on a single machine. Second, even algorithms with time complexity $O\text{\negmedspace}\left(n^{2}\right)$ could be too slow in practice. Third, and most important, the data could change over time, and algorithms should cope with these dynamic changes. Therefore, several models of computation over Big Data are studied, such as parallel, distributed, and streaming algorithms.

We concentrate on the streaming model (see e.g. [Mut05, BBD*+*02, Agg07]), where the data is given as a sequence of items (or updates) in some order (usually adversarial), and the algorithm can read the data only in that order. Often, the algorithm can only read the data once, although there are also algorithms for multiple passes. More concretely, a stream is a (possibly infinite) sequence $\mathcal{S}=\left\langle\sigma_{1},\sigma_{2},\ldots,\sigma_{i},\ldots\right\rangle$, where each item $\sigma_{i}$ belongs to some universe $U$. The length of the stream, as well as the size of $U$, is assumed to be huge, such that storing the entire stream, or even a constant-size information for each item in $\mathcal{S}$, is impractical. A streaming algorithm $\mathcal{A}$ takes $\mathcal{S}$ as input and computes some function $f$ of the stream $\mathcal{S}$. This means that the algorithm has access to the input in a streaming fashion, i.e., $\mathcal{A}$ can read the input once and only in the order it is given and at every time $t$ the algorithm may be asked to evaluate $f$ on the prefix $\mathcal{S}_{t}=\left\langle\sigma_{1},\ldots,\sigma_{t}\right\rangle$, called a query at time $t$ for $f\left(\mathcal{S}_{t}\right)$. We only consider here the insertion-only model, where all updates are positive, i.e., only adding items to the underlying structure (in some other models, the deletion of previously added items is also allowed).

In many streaming scenarios, computing the exact value of $f$ is computationally prohibitive or even impossible. Hence, the goal is to design a streaming algorithm whose output approximates $f$ (often with high probability). As usual, it should have low space complexity, update time, and query time, see Remark 1.1.

The sliding-window model, introduced by Datar, Gionis, Indyk and Motwani [DGIM02], has become a popular model for processing (infinite) data streams, where older data items should be ignored, as they are considered obsolete. In this model, the goal is to compute a function $f$ on a suffix of the stream, referred to as the active window $W$. Throughout, the size $w$ of the active window $W$ is assumed to be known (to the algorithm) in advance. At a point in time $t$, we denote the active window by $W_{t}=\left\langle\sigma_{t-w+1},\ldots,\sigma_{t}\right\rangle$, or $W$ for short when $t$ is clear from the context. The goal is to approximate $f\left(W_{t}\right)$, and possibly provide a corresponding object, e.g., a feasible matching in a graph when the stream is a sequence of edges and $f$ is the maximum-matching size. For a randomized algorithm, we require that a single query at any time $t$ succeeds with probability at least $1-\mathbb{{\cal\delta}}$.

Datar et al. [DGIM02] noted that in the sliding-window model there is a lower bound of $\Omega\left(w\right)$ if deletions are allowed, even for relatively simple tasks like approximating (within factor $2$) the number of distinct items in a stream. Therefore, we assume throughout that the stream $\mathcal{S}$ has only insertions, and no deletions.

A widely studied streaming model is the graph-streaming model (see e.g. [FKM*+*05, McG14]), where the stream $\mathcal{S}$ consists of a sequence of edges (possibly with some auxiliary information, like weights) of an underlying graph $G=\left(V,E\right)$.111All our definitions, e.g., Definitions 1.2 and 1.3, as well as Corollary 2.5, extend naturally to hypergraphs. We assume that $V=\left[n\right]$ for a known value $n\in\mathbb{N}$ and $G$ is a simple graph without parallel edges. This graph-streaming model is sometimes studied in the semi-streaming model, where algorithms are allowed to use $O\text{\negmedspace}\left(n\cdot\operatorname{polylog}\left(n\right)\right)$ space. Observe that for dense graphs, an algorithm in this model cannot store the whole graph, but it can store $\operatorname{polylog}\left(n\right)$ information for each vertex. We slightly abuse the notation of a graph function $f\left(G\right)$ and extend it to a stream of edges $\mathcal{S}$ using the convention $f\left(\mathcal{S}\right)\coloneqq f\left(G\right)$ where $G$ is the graph defined by the edges in the stream $\mathcal{S}$.

Remark 1.1*.*

Throughout, space complexity refers to the storage requirement of an algorithm during the entire input stream, measured in bits. Update time refers to the time complexity of processing a single update from the stream in the RAM model. Query time refers to the time complexity of reporting an output at a single point in time.

Crouch, McGregor and Stubbs [CMS13] initiated the study of graph problems in the sliding-window model, and designed algorithms for several basic graph problems, such as $k$-connectivity, bipartiteness, sparsification, minimum spanning tree and spanners. They also showed approximation algorithms for maximum-matching and for maximum-weight matching. We shall focus on two well-known and closely related optimization problems, maximum-matching and minimum vertex-cover, defined below.

1.1 Basic Terminology

Definition 1.2**.**

A matching in a graph $G=\left(V,E\right)$ is a set of edges $M\subseteq E$ that are disjoint, i.e., no two edges have a common vertex. Denote by $m\left(G\right)$ the maximum size of a matching in $G$. A matching of maximal size (number of edges) is called a maximum-cardinality matching, and is usually referred to as a maximum-matching. In an edge-weighted graph $G$, a maximum- weight matching is a matching with maximal sum of weights.

Definition 1.3**.**

A subset $C\subseteq V$ of the vertices of a graph $G=\left(V,E\right)$ is called a vertex-cover of $G$ if each edge $e\in E$ is incident to at least one vertex in $C$. Denote by $VC\left(G\right)$ the smallest size of a vertex-cover of $G$.

We will use the terminology of Feige and Jozeph [FJ15] to distinguish between estimation and approximation of optimization problems (where the goal is to find a feasible solution of optimal value). An approximation algorithm is required to output a feasible solution whose value is close to the value of an optimal solution, e.g., output a feasible matching of near-optimal size. An estimation algorithm is required to only output a value close to that of an optimal solution, without necessarily outputting a corresponding feasible solution, e.g., estimate the size of a maximum-matching, without providing a corresponding matching.

Definition 1.4**.**

The notation $\widetilde{O}\text{\negmedspace}\left(s\right)$ hides polylogarithmic dependence on $s$, i.e., $\widetilde{O}\text{\negmedspace}\left(s\right)=O\text{\negmedspace}\left(s\cdot\operatorname{polylog}\left(s\right)\right)$. To suppress dependence on $\mathbb{{\cal\varepsilon}}$ we write $O_{\mathbb{{\cal\varepsilon}}}\text{\negmedspace}\left(s\right)=O\text{\negmedspace}\left(s\cdot f\left(\mathbb{{\cal\varepsilon}}\right)\right)$, where $f:\mathbb{R}^{+}\rightarrow\mathbb{R}^{+}$ is some positive function.222Throughout, every dependence on $\mathbb{{\cal\varepsilon}}$ is polynomial, i.e., in our case $O_{\mathbb{{\cal\varepsilon}}}\text{\negmedspace}\left(s\right)=O\text{\negmedspace}\left(s\cdot\operatorname{poly}\left(\mathbb{{\cal\varepsilon}}^{-1}\right)\right)$. We also combine both notations and define $\widetilde{O}_{\mathbb{{\cal\varepsilon}}}\text{\negmedspace}\left(s\right)=O_{\mathbb{{\cal\varepsilon}}}\text{\negmedspace}\left(s\cdot\operatorname{polylog}\left(s\right)\right)$.

Definition 1.5**.**

For $\mathbb{{\cal\delta}}\in\left[0,1\right)$ and $C\geq 1$, a randomized algorithm $\Lambda$ is said to $\left(C,\mathbb{{\cal\delta}}\right)$-approximate a function $f$ if on every input stream $\mathcal{S}$, its output $\Lambda\left(\mathcal{S}\right)$, upon a query (at a single point of time), satisfies

[TABLE]

If $\Lambda$ is a deterministic algorithm then $\mathbb{{\cal\delta}}=0$, and we say in short that it $C$-approximates $f$. We sometime use this shorter terminology and omit $\mathbb{{\cal\delta}}$ also for randomized approximation algorithms, when $\mathbb{{\cal\delta}}$ is a fixed constant, say $0.1$. It is well-known that every algorithm (that reports a real value) with success probability $0.9$ can be amplified to success probability $1-\frac{1}{\operatorname{poly}\left(n\right)}$ using $O\text{\negmedspace}\left(\log\left(n\right)\right)$ independent repetitions and reporting the median.

Remark 1.6*.*

Usually we use Definition 1.5 with an extra approximation factor $1\pm\mathbb{{\cal\varepsilon}}$, for $\mathbb{{\cal\varepsilon}}\in\left(0,\frac{1}{2}\right)$, in the following manner. If algorithm $\Lambda$ satisfies

[TABLE]

then algorithm $\Lambda^{\prime}\coloneqq\frac{1}{1-\mathbb{{\cal\varepsilon}}}\Lambda$ satisfies Definition 1.5 with $C^{\prime}\coloneqq\frac{\left(1+\mathbb{{\cal\varepsilon}}\right)}{\left(1-\mathbb{{\cal\varepsilon}}\right)}C<\left(1+4\mathbb{{\cal\varepsilon}}\right)C$.

1.2 Our Contribution

We introduce an adaptation of the smooth-histogram technique of Braverman and Ostrovsky [BO07] to a more general family of functions, that we call almost-smooth, and demonstrate that it is applicable in a variety of settings, including frequency-vector streams, graph streams, and matrix streams. In fact, many of our examples follow a single reasoning — these functions are subadditive (defined below) and thus $2$-almost-smooth — and some of them (e.g., symmetric norms and maximum-matching) are not smooth and thus do not admit the more restricted smooth-histogram technique. Furthermore, we show artificial examples where the almost-smoothness parameter can take any value in the range $\left(1,2\right]$.

Similarly to [BO07], the main idea in our framework is to maintain several instances of an insertion-only algorithm on different suffixes of the stream, such that at every point in time, the active window $W$ and the largest suffix of it that is maintained have similar value of $f$. We show that for an almost-smooth $f$ our overall algorithm achieves a good approximation of $f\left(W\right)$. Using this technique we obtain new sliding-window algorithms for several problems that admit an insertion-only streaming algorithm like estimating a symmetric norm of a frequency-vector or submodular matching in a graph stream. For more details on the smooth-histogram framework of [BO07] see Appendix A.

Almost-Smooth Functions

We start with an overview of our notion of almost-smooth functions; for a more formal treatment see Definition 2.1 and Remark 2.2. A function $f$ defined on streams is said to be left-monotone (non-decreasing) if for every two disjoint segments $A,B$ of a stream $f\left(B\right)\leq f\left(AB\right)$, where $AB$ denotes their concatenation. Informally, we say that a left-monotone function $f$ is * d-almost-smooth* if $\frac{f\left(B\right)}{f\left(AB\right)}\leq d\cdot\frac{f\left(BC\right)}{f\left(ABC\right)}$ for all disjoint segments $A,B,C$; this means that whenever $f\left(B\right)$ approximates $f\left(AB\right)$ within some factor, appending any segment $C$ will maintain this approximation up to an extra factor $d$. For example, the maximum-matching size is $2$-almost-smooth (see Corollary 2.5), which means that if $A,B,C$ are disjoint sets of edges and $m\left(B\right)$ is a $\left(1+\mathbb{{\cal\varepsilon}}\right)$-approximation of $m\left(AB\right)$, then for every sequence $C$ of additional edges, $m\left(BC\right)$ would $\left(\left(1+\mathbb{{\cal\varepsilon}}\right)2\right)$-approximate $m\left(ABC\right)$.

Algorithms for Almost-Smooth Functions

For almost-smooth functions we show a general transformation of an approximation algorithm in the insertion-only model to the sliding-window model.

Theorem 1.7** (Informal version of Theorem 2.7).**

Suppose function $f$ is $d$-almost-smooth and can be $C$-approximated by an insertion-only algorithm $\Lambda$. Then there exists a sliding-window algorithm $\Lambda^{\negthinspace sw}$ that $\left(\left(1+\mathbb{{\cal\varepsilon}}\right)dC^{2}\right)$-approximates $f$, with only a factor $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-1}\log w\right)$ larger space and update time than $\Lambda$.

We show in Lemma 2.4 that every subadditive function (defined below) $f$ is $2$-almost-smooth; it follows (using Theorem 1.7) that every insertion-only algorithm for approximating such $f$ can be adapted to the sliding-window model with a small overhead in the approximation ratio, space complexity, and update time.

Definition 1.8**.**

A function $f$ is said to be subadditive if for every disjoint segments $A,B$ of a stream it holds that $f\left(AB\right)\leq f\left(A\right)+f\left(B\right)$.

Frequency-Vector Streams

In the frequency-vector model, where the stream consists of additive updates to an underlying vector $x\in\mathbb{R}^{n}$, we show that every symmetric norm is subadditive and thus admits our framework of almost-smoothness. We can then use a result of B$\l$asiok et al. [BBC*+*17] that provides a $\left(1+\mathbb{{\cal\varepsilon}}\right)$-approximation randomized streaming algorithm for every symmetric norm, to deduce the following theorem.

Theorem 1.9** (Informal version of Theorem 3.2).**

Every symmetric norm on $\mathbb{R}^{n}$ admits a $\left(2+\mathbb{{\cal\varepsilon}}\right)$-approximation sliding-window randomized algorithm with space complexity $\widetilde{O}_{\mathbb{{\cal\varepsilon}}}\text{\negmedspace}\left(L\right)$, where $L$ is a certain quantity associated with the norm.

Previously, sliding-window algorithms were known only for $\ell_{p}$ norms [BO07, WZ21]. We also exemplify a norm that does not admit the more restricted smooth-histogram technique of Braverman and Ostrovsky. We prove that the top-$k$ norm for $k=\frac{n}{2}$ is not $d$-almost-smooth for any $d<2$, although it is subadditive and thus $2$-almost-smooth. Moreover, this norm has $L=O\text{\negmedspace}\left(\operatorname{polylog}\left(n\right)\right)$, where $L$ is the associated quantity from Theorem 1.9, and therefore our algorithm has space complexity $O_{\mathbb{{\cal\varepsilon}}}\text{\negmedspace}\left(\operatorname{polylog}\left(nw\right)\right)$ (see Section 3.1). Note that we also use this algorithm to obtain an $O\text{\negmedspace}\left(1\right)$-approximation sliding-window algorithm for Max $k$-Cover (see Section 3.4).

Matrix Streams

For matrix streams, where the stream consists of $n$ row vectors (in $\mathbb{R}^{m}$) that form an $n\times m$ matrix, we show that the Schatten $p$-norm, for $p\geq 2$, is $\sqrt{2}$-almost-smooth. For $p=4$ we use an insertion-only algorithm of Braverman et al. [BKKS20] to obtain a sliding-window algorithm.

Theorem 1.10** (Informal version of Corollary 3.10).**

There exists a sliding-window algorithm that $\left(\sqrt{2}+\mathbb{{\cal\varepsilon}}\right)$-approximates the Schatten $4$-norm of a matrix using $O_{\mathbb{{\cal\varepsilon}}}\text{\negmedspace}\left(\operatorname{polylog}\left(nw\right)\right)$ bits of space.

Graph Streams

In the graph-streams domain, where the stream consists of edges that form an underlying graph, we consider several problems, starting in Section 3 with two examples of graph problems suitable for our framework. The first one is maximum submodular matching, which is a generalization of the maximum-weight matching problem to submodular objective functions. The second one is Max $k$-Cover, which is dual to Vertex-Cover and whose goal is to cover as many edges as possible using only $k$ vertices. We prove that both problems are subadditive and hence $2$-almost-smooth. For both problems we present an $O\text{\negmedspace}\left(1\right)$-approximation sliding-window algorithms, with space complexity $\widetilde{O}\text{\negmedspace}\left(n\right)$, see Corollaries 3.14 and 3.18, respectively.

Recent research on graph streams [ETHL*+*18, MV16, BS15, CCE*+*16] addressed maximum-matching size in a restricted family of graphs. Specifically, McGregor and Vorotnikova [MV18], improving over Cormode et al. [CJMM17], designed a $\operatorname{polylog}\left(n\right)$-space algorithm for estimating the maximum-matching size in arboricity-$\alpha$ graphs within factor $O\text{\negmedspace}\left(\alpha\right)$. Recall that the arboricity of a graph $G=\left(V,E\right)$ is the minimal $\alpha\geq 1$ such that the set of edges $E$ can be partitioned into at most $\alpha$ forests. For example, it is well known that every planar graph has arboricity $\alpha\leq 3$, see e.g. [GL98].

Using our generalization of the smooth-histogram technique we provide several algorithms for estimating maximum matching and minimum vertex-cover in bounded-arboricity graphs. In particular, we show the following theorem for maximum matching in Section 4. We compare it in Table 1 with the known insertion-only algorithms [CJMM17, MV18]. Note that a straightforward application of Theorem 1.7 leads to a weaker result, where the dependency on the arboricity $\alpha$ is quadratic.

Theorem 1.11**.**

For every $\mathbb{{\cal\varepsilon}},\mathbb{{\cal\delta}}\in\left(0,\frac{1}{2}\right)$, there is a sliding-window $\left(\left(2+\mathbb{{\cal\varepsilon}}\right)\left(\alpha+2\right),\mathbb{{\cal\delta}}\right)$-estimation algorithm for maximum-matching in graphs of arboricity $\alpha$, with space complexity $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-3}\log^{4}n\log\tfrac{1}{\mathbb{{\cal\varepsilon}}\mathbb{{\cal\delta}}}\right)$ bits and update time $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-3}\log^{3}n\log\tfrac{1}{\mathbb{{\cal\varepsilon}}\mathbb{{\cal\delta}}}\right)$.

We design several algorithms also for (estimation and approximation of) vertex-cover based on its relation to maximum matching as summarized in Table 2. First, for general graphs, our sliding-window algorithm (Theorem 5.6) improves the previous approximation ratio, essentially from 8 to 4, using the same space complexity. The improvement comes from utilizing the almost-smoothness of the greedy matching (instead of the optimal vertex-cover). Next, for VDP (vertex-disjoint paths333A graph $G=\left(V,E\right)$ is said to be VDP if $G$ is a union of vertex-disjoint paths. This family was used to prove lower bounds in [ETHL*+*18].) and forest graphs (arboricity $\alpha=1$) we compare our two sliding-window estimation algorithms to one another, as well as to the known turnstile estimation algorithm [vH16]. Notice that Theorem 5.3 applies also to VDP graphs (as a special case of forests) and thus offers a much better space complexity than Theorem 5.2, $O_{\mathbb{{\cal\varepsilon}}}\text{\negmedspace}\left(\log^{4}n\right)$ compared to $\widetilde{O}_{\mathbb{{\cal\varepsilon}}}\text{\negmedspace}\left(\sqrt{n}\right)$, although the approximation ratio is slightly worse.

2 Sliding-Window Algorithm for Almost-Smooth Functions

In this section we generalize the smooth-histogram framework of Braverman and Ostrovsky [BO07] to functions that are almost smooth, as per our new definition, and show that the family of subadditive functions are almost smooth. We show that several graph problems satisfy the subadditivity property, e.g., the maximum-matching size and the minimum vertex-cover size. In the next two sections we use these results to design sliding-window algorithms for those graph problems.

2.1 Almost-Smooth Functions

Recall that for disjoint segments $A,B$ of a stream, we denote by $AB$ their concatenation. We use the parameter $n$ to denote some measure of a stream which will be clear from the context. For example, for graph streams $n$ is the number of vertices in the underlying graph. We extend the definition of smoothness due to [BO07] as follows.

Definition 2.1**.**

(Almost-Smooth Function) A real-valued function $f$ defined on streams is $\left(c,d\right)$-almost-smooth, for $c,d\geq 1$, if it has the following properties:

Non-negative: for every stream $A$ it holds that $f\left(A\right)\geq 0$. 2. 2.

$c$-left-monotone: for every disjoint segments $A,B$ of a stream it holds that $f\left(B\right)\leq c\cdot f\left(AB\right)$. 3. 3.

Bounded: for every stream $A$ it holds that $f\left(A\right)\leq\operatorname{poly}\left(n\right)$. 4. 4.

Almost smooth: for every disjoint segments $A,B,C$ of the stream,

[TABLE]

whenever $f\left(AB\right)\neq 0$ and $f\left(ABC\right)\neq 0$.

Remark 2.2*.*

Almost-smoothness means that appending any segment $C$ at the end of the stream preserves the approximation of $f\left(B\right)$ by $f\left(AB\right)$, up to a multiplicative factor $d$. Observe that property $4$ is equivalent to the condition that for every $\mathbb{{\cal\varepsilon}}>0$ and every disjoint segments of the stream $A,B$ and $C$,

[TABLE]

Obviously, $\mathbb{{\cal\varepsilon}}>c$ is vacuous by property 2, hence it suffices to consider $0<\mathbb{{\cal\varepsilon}}\leq c$. Throughout, it is more convenient to use this equivalent condition.

For generality we defined $\left(c,d\right)$-almost-smooth for any $c\geq 1$, but in our applications $c=1$, in which case we simply omit $c$ and refer to such functions as $d$-almost-smooth.

Remark 2.3*.*

In the original definition of smoothness from [BO07], $c=d=1$, and property $4$ is stated as follows (after some simplification). A function $f$ is $\left(\mathbb{{\cal\varepsilon}},\beta\left(\mathbb{{\cal\varepsilon}}\right)\right)$-smooth if for every $\mathbb{{\cal\varepsilon}}\in\left(0,1\right)$ there exists $\beta=\beta\left(\mathbb{{\cal\varepsilon}}\right)$ such that $\beta\leq\mathbb{{\cal\varepsilon}}$ and

[TABLE]

Observe that this definition implies $d$-almost-smoothness if $d\coloneqq\sup\limits_{0<\mathbb{{\cal\varepsilon}}<1}\frac{1-\beta\left(\mathbb{{\cal\varepsilon}}\right)}{1-\mathbb{{\cal\varepsilon}}}$ is bounded. In most applications, it suffices to consider $0<\mathbb{{\cal\varepsilon}}\leq\frac{1}{2}$, and then $\frac{1-\beta\left(\mathbb{{\cal\varepsilon}}\right)}{1-\mathbb{{\cal\varepsilon}}}\leq 2$ is bounded.

We say that a function $f$ is monotone (non-decreasing) if it is left-monotone and right-monotone, i.e., for every disjoint segments $A,B$ of a stream $f\left(AB\right)\geq f\left(B\right)$ and $f\left(AB\right)\geq f\left(A\right)$.

Lemma 2.4**.**

Every subadditive, non-negative, bounded and monotone function $f$ is $2$-almost-smooth.

Proof.

The first three requirements are clear, as $f$ is assumed to be non-negative, bounded and monotone. Hence, we are only left to show the almost-smoothness property. Let $\mathbb{{\cal\varepsilon}}\in\left(0,1\right]$ and let $A,B$ and $C$ be disjoint segments of the stream satisfying $\mathbb{{\cal\varepsilon}}f\left(AB\right)\leq f\left(B\right)$. Observe that $f\left(AB\right)+f\left(BC\right)\geq f\left(AB\right)+f\left(C\right)\geq f\left(ABC\right)$, because $f$ is subadditive and monotone, and therefore,

[TABLE]

∎

Recall that $m\left(S\right)$ and $VC\left(S\right)$ are the maximum-matching size and the vertex-cover size, respectively, in the graph defined by the stream $S$. Although they are both not smooth functions (as shown in Corollary 2.5), they are almost smooth (as proved by Crouch et al. [CMS13] for $m\left(\cdot\right)$, and reproduced here for completeness).

Corollary 2.5**.**

The maximum-matching size $m\left(\cdot\right)$ and the minimum vertex-cover size $VC\left(\cdot\right)$ are both $2$-almost-smooth. Moreover, they are both not $d$-almost-smooth for any $d<2$.

Proof.

Obviously both $m\left(\cdot\right)$ and $VC\left(\cdot\right)$ are non-negative, bounded and monotone, since on a longer segment of the stream both the maximum-matching and the minimum vertex-cover cannot be smaller. Hence, we are only left to show that they are both subadditive.

Let $M$ be a maximum-matching of the graph defined by the stream $AB$, and denote by $M_{A}$ and $M_{B}$ the edges from $M$ that appear in $A$ and $B$, respectively. Note that $M_{A}$ is a matching in the graph defined by the stream $A$, and similarly for $M_{B}$. Thus, clearly $\left|M_{A}\right|\leq m\left(A\right)$ and $\left|M_{B}\right|\leq m\left(B\right)$, and therefore

[TABLE]

and so $m\left(\cdot\right)$ is subadditive.

Observe that for a disjoint segments of the stream $A$ and $B$, the union of a minimum vertex-cover on $A$ and a minimum vertex-cover on $B$ is clearly a feasible (not necessarily minimum) vertex-cover on $AB$, and since it is a minimization problem we obtain $VC\left(A\right)+VC\left(B\right)\geq VC\left(AB\right)$. Hence $VC\left(\cdot\right)$ is also subadditive.

For the tightness argument we use the following tight example. Let $G=\left(V,E\right)$ be a graph composed of $n$ vertex-disjoint paths of length $3$, i.e., $n$ paths of the form $e_{a}=\left\{x,y\right\},e_{b}=\left\{y,z\right\},e_{c}=\left\{z,w\right\}$. The segment $A$ of the stream contains all the $e_{a}$ edges, $B$ contains all the $e_{b}$ edges, and $C$ contains all the $e_{c}$ edges. Obviously $m\left(AB\right)=m\left(B\right)=m\left(BC\right)=n$ while $m\left(ABC\right)=2n$, and similarly for $VC\left(\cdot\right)$. In particular, both maximum-matching size and minimum vertex-cover are not smooth as per the original definition of [BO07]. ∎

Remark 2.6*.*

It is easy to see that Corollary 2.5 holds even for hypergraphs by the same arguments.

We analyze the smooth-histogram algorithm of [BO07] for functions that are almost-smooth with constant approximation ratio.

Theorem 2.7**.**

*[Formal version of Theorem 1.7] Let $f$ be a $\left(c,d\right)$-almost-smooth function defined on streams. Assume that for every $\mathbb{{\cal\varepsilon}},\mathbb{{\cal\delta}}\in\left(0,\frac{1}{2}\right)$, there exists an algorithm $\Lambda$ for insertion-only streams that $\left(\left(1+\mathbb{{\cal\varepsilon}}\right)C,\mathbb{{\cal\delta}}\right)$-approximates $f$ using space $s\left(\mathbb{{\cal\varepsilon}},\mathbb{{\cal\delta}}\right)$ and update time $t\left(\mathbb{{\cal\varepsilon}},\mathbb{{\cal\delta}}\right)$. Then for every $\mathbb{{\cal\varepsilon}},\mathbb{{\cal\delta}}\in\left(0,\frac{1}{2}\right)$ there exists a sliding-window algorithm $\Lambda^{\negthinspace sw}$ that

$\left(dc^{2}C^{2}\left(1+O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}\right)\right),\mathbb{{\cal\delta}}\right)$-approximates $f$ using space $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-1}\log w\cdot\left(s\left(\mathbb{{\cal\varepsilon}},\frac{\mathbb{{\cal\varepsilon}}\mathbb{{\cal\delta}}}{2w\log w}\right)+\log w\right)\right)$ and update time $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-1}\log w\cdot t\left(\mathbb{{\cal\varepsilon}},\frac{\mathbb{{\cal\varepsilon}}\mathbb{{\cal\delta}}}{2w\log w}\right)\right)$.*

We prove Theorem 2.7 in appendix B. At a high level, we adapt the approach and notations of Crouch et al. [CMS13], which in turns is based on the smooth-histogram method of Braverman and Ostrovsky [BO07].

For certain approximation algorithms we can reduce the dependence on the approximation factor $C$ from quadratic $\left(C^{2}\right)$ to linear $\left(C\right)$. Suppose that the approximation algorithm $\Lambda$ of the function $f$ has the following form: It $\left(1+\mathbb{{\cal\varepsilon}},\mathbb{{\cal\delta}}\right)$-approximates a function $g$, and this $g$ is a $C$-approximation of $f$. Now, if $g$ itself is $\left(c,d\right)$-almost-smooth then we can save a factor of $C$ by arguing directly about approximating $g$.

Theorem 2.8**.**

Let $f$ be some function, let $g$ be a $\left(c,d\right)$-almost-smooth function, and assume that $g$ is a $C$-approximation of $f$. Assume that for every $\mathbb{{\cal\varepsilon}},\mathbb{{\cal\delta}}\in\left(0,\frac{1}{2}\right)$, there exists an algorithm $\Lambda$ for insertion-only streams that $\left(1+\mathbb{{\cal\varepsilon}},\mathbb{{\cal\delta}}\right)$-approximates $g$ using space $s\left(\mathbb{{\cal\varepsilon}},\mathbb{{\cal\delta}}\right)$ and update time $t\left(\mathbb{{\cal\varepsilon}},\mathbb{{\cal\delta}}\right)$. Then for every $\mathbb{{\cal\varepsilon}},\mathbb{{\cal\delta}}\in\left(0,\frac{1}{2}\right)$ there exists a sliding-window algorithm $\Lambda^{\negthinspace sw}$ that $\left(dc^{2}C\left(1+O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}\right)\right),\mathbb{{\cal\delta}}\right)$-approximates $f$ using space $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-1}\log w\cdot\left(s\left(\mathbb{{\cal\varepsilon}},\frac{\mathbb{{\cal\varepsilon}}\mathbb{{\cal\delta}}}{2w\log w}\right)+\log w\right)\right)$ and update time $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-1}\log w\cdot t\left(\mathbb{{\cal\varepsilon}},\frac{\mathbb{{\cal\varepsilon}}\mathbb{{\cal\delta}}}{2w\log w}\right)\right)$.

Proof.

By applying Theorem 2.7 to the function $g$ and the algorithm $\Lambda$, that approximates it, we obtain a sliding-window algorithm $\Lambda^{\negthinspace sw}$ that computes a $\left(dc^{2}\left(1+O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}\right)\right),\mathbb{{\cal\delta}}\right)$-approximation of $g$, uses space $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-1}\log w\cdot\left(s\left(\mathbb{{\cal\varepsilon}},\frac{\mathbb{{\cal\varepsilon}}\mathbb{{\cal\delta}}}{2w\log w}\right)+\log w\right)\right)$ and update time $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-1}\log w\cdot t\left(\mathbb{{\cal\varepsilon}},\frac{\mathbb{{\cal\varepsilon}}\mathbb{{\cal\delta}}}{2w\log w}\right)\right)$. Since $g$ is a $C$-approximation of $f$, this algorithm $\Lambda^{\negthinspace sw}$ is in fact a $\left(dc^{2}C\left(1+O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}\right)\right),\mathbb{{\cal\delta}}\right)$-approximation of $f$, using the same space and update time. ∎

3 Example Applications of Almost-Smoothness

We present a variety of examples where our framework yields new approximation algorithms with relatively little effort. More specifically, we provide examples of functions $f$ (over a stream) that are $O\text{\negmedspace}\left(1\right)$-almost-smooth, and then employ our framework to convert known algorithms for insertion-only streams into new algorithms for sliding-window streams, with a slightly larger approximation ratio. For all these problems, the smooth-histogram technique of Braverman and Ostrovsky [BO07] is not applicable, because these functions are not known to be smooth. In fact, many of them are provably not smooth, which justifies the necessity of our generalized framework.

Our first example (Section 3.1) is for the common model of a frequency vector (additive updates to a vector), where the function $f$ to be computed is an arbitrary symmetric norm of that vector. We show that such a norm is subadditive and thus $2$-almost-smooth, and then use a known algorithm [BBC*+*17] to obtain a sliding-window algorithm. Our second example (Section 3.2) is for streaming matrices where each item in the stream is the (next) row of the matrix; this is a natural model for reading a matrix in row order. We show that the Schatten $p$-norm of the matrix is $\sqrt{2}$-almost-smooth, for all $p\geq 2$, and we use a known algorithm for $p=4$ [BKKS20] to derive a new sliding-window algorithm.

We then consider some discrete problems (Sections 3.3 and 3.4). One of them is maximum submodular matching in a graph defined by a stream of edges on fixed vertex set $\left[n\right]$. Using that every submodular function is subadditive, we obtain $2$-almost-smoothness and use an algorithm of [CK14] to conclude a sliding-window algorithm. Another discrete problem is max $k$-cover in a graph, for which we show both approximation and estimation sliding-window algorithms. We use our result for symmetric norms to show a $4$-estimation sliding-window algorithm for max $k$-cover using $\widetilde{O}_{\mathbb{{\cal\varepsilon}}}\text{\negmedspace}\left(\frac{n}{k}\right)$ bits of space. Lastly, we design for every $d\in\left(1,2\right]$ an artificial function, based on the maximum-matching size, that is $d$-almost smooth, and show it is tight.

3.1 Symmetric Norms

Consider the frequency-vector streaming model, where the stream is composed of additive updates to an underlying $n$-dimensional vector $x\in\mathbb{R}^{n}$. We assume that all updates are positive and all entries are polynomially bounded, i.e., $\left|x_{i}\right|\leq\operatorname{poly}\left(n\right)$ for all $i\in\left[n\right]$. The assumption of positive updates is necessary because otherwise even $2$-approximation of the number of distinct items in a stream requires $\Omega\left(w\right)$ bits of space, see Datar et al. [DGIM02].

We show that every symmetric norm $\ell:\mathbb{R}^{n}\rightarrow\mathbb{R}$ (symmetric means invariant under sign-flips and coordinate-permutations, see [Bha97]) can be $\left(2+\mathbb{{\cal\varepsilon}}\right)$-approximated in the sliding-window model with $O\text{\negmedspace}\left(\operatorname{mmc}\left(\ell\right)^{2}\operatorname{poly}\left(\frac{\log nw}{\mathbb{{\cal\varepsilon}}}\right)\right)$ bits of space, where $\operatorname{mmc}\left(\cdot\right)$ is the norm’s maximum modulus of concentration (see [BBC*+*17]). It is known that $\operatorname{mmc}\left(\ell\right)$ depends only on the norm $\ell$ itself and that $1\leq\operatorname{mmc}\left(\ell\right)\leq\sqrt{n}$. For a concrete example of a norm that is $2$-almost-smooth and this parameter $d=2$ is tight, we consider the top-$k$ norm (see Definition 3.3) for $k=\Theta\left(n\right)$, and deduce for it a sliding-window $\left(2+\mathbb{{\cal\varepsilon}}\right)$-approximation algorithm with $\operatorname{poly}\left(\frac{\log n}{\mathbb{{\cal\varepsilon}}}\right)$ bits of space.

Lemma 3.1**.**

Every monotone norm is subadditive, and hence $2$-almost-smooth.

Proof.

Subadditivity follows immediately from the triangle inequality, and obviously every norm is non-negative and bounded. We assume monotonicity, and therefore Lemma 2.4 implies that the norm is $2$-almost-smooth. ∎

B$\l$asiok et al. [BBC*+*17] showed a $\left(1+\mathbb{{\cal\varepsilon}}\right)$-approximation randomized streaming algorithm for an arbitrary symmetric norm. We use their algorithm to achieve $\left(2+\mathbb{{\cal\varepsilon}}\right)$-approximation sliding-window algorithm with almost the same space complexity.

Theorem 3.2** (Formal version of Theorem 1.9).**

Let $\ell$ be a symmetric norm on $\mathbb{R}^{n}$. There exists a $\left(2+\mathbb{{\cal\varepsilon}}\right)$-approximation sliding-window randomized algorithm computing the norm $\ell$ using $O\text{\negmedspace}\left(\operatorname{mmc}\left(\ell\right)^{2}\operatorname{poly}\left(\frac{\log nw}{\mathbb{{\cal\varepsilon}}}\right)\right)$ bits of space with constant success probability.

Proof.

Algorithm $1$ of [BBC*+*17] is a $\left(1+\mathbb{{\cal\varepsilon}}\right)$-approximation of a symmetric norm $\ell$ of a vector defined by a stream using $O\text{\negmedspace}\left(\operatorname{mmc}\left(\ell\right)^{2}\operatorname{poly}\left(\frac{\log n}{\mathbb{{\cal\varepsilon}}}\right)\right)$ bits of space. This algorithm has constant success probability, which can be amplified to $1-\frac{\mathbb{{\cal\varepsilon}}}{10w\log w}$ using the median of $O\text{\negmedspace}\left(\log\frac{w}{\mathbb{{\cal\varepsilon}}}\right)$ independent repetitions. Every symmetric norm is monotone (Proposition IV.1.1 in [Bha97]), therefore $\ell$ is $2$-almost-smooth (Lemma 3.1). This implies, by Theorem 2.7, a $\left(2+\mathbb{{\cal\varepsilon}}\right)$-approximation sliding-window algorithm using $O\text{\negmedspace}\left(\operatorname{mmc}\left(\ell\right)^{2}\operatorname{poly}\left(\frac{\log nw}{\mathbb{{\cal\varepsilon}}}\right)\right)$ bits of space. ∎

We now show a norm for which our almost-smooth framework is applicable, but the smooth-histogram technique of Braverman and Ostrovsky [BO07] does not.

Definition 3.3**.**

For $1\leq k\leq n$ the top-$k$ norm of a vector $x\in\mathbb{R}^{n}$, denoted by $\left\|x\right\|_{\left(k\right)}$, is the $\ell_{1}$ norm of the $k$ entries of $x$ with the largest absolute value, i.e. $\left\|x\right\|_{\left(k\right)}=\sum\limits_{i=1}^{k}\left|x_{i}^{\downarrow}\right|$, where $x^{\downarrow}$ is the vector $x$ reordered in decreasing magnitude.

Remark 3.4*.*

Since the top-$k$ norm is monotone, Lemma 3.1 shows that it is $2$-almost-smooth. Furthermore, for $k\leq\frac{n}{2}$, the almost-smoothness parameter $d=2$ of the top-$k$ norm is tight. Let $A$ be the stream $\left(e_{1},\cdots,e_{k}\right)$, where each $e_{i}\in\mathbb{R}^{n}$ is the $i$-th standard basis vector, thus its total additive update is $x^{A}=\sum\limits_{i=1}^{k}e_{i}$. Similarly, $B$ is the stream $\left(e_{k+1},\cdots,e_{n}\right)$ with corresponding vector $x^{B}=\sum\limits_{i=k+1}^{n}e_{i}$, and $C$ has the same updates as stream $A$, thus $x^{C}=x^{A}$. Observe that $\left\|x^{A}+x^{B}\right\|_{\left(k\right)}=\left\|x^{B}\right\|_{\left(k\right)}=k$ but $\left\|x^{A}+x^{B}+x^{C}\right\|_{\left(k\right)}=2k$ while $\left\|x^{B}+x^{C}\right\|_{\left(k\right)}=k$, hence $d=2$ is indeed tight in the almost-smoothness of the top-$k$ norm.

The maximum modulus of concentration of the top-$k$ norm is $\operatorname{mmc}\left(\left\|\cdot\right\|_{\left(k\right)}\right)=\widetilde{O}\text{\negmedspace}\left(\sqrt{\frac{n}{k}}\right)$, see Section $6.1$ of [BBC*+*17]. Therefore, as a corollary of Theorem 3.2 for the top-$k$ norm, we obtain the following sliding-window algorithm.

Corollary 3.5**.**

There exists a $\left(2+\mathbb{{\cal\varepsilon}}\right)$-approximation sliding-window randomized algorithm for the top-$k$ norm with $O\text{\negmedspace}\left(\frac{n}{k}\operatorname{poly}\left(\frac{\log n}{\mathbb{{\cal\varepsilon}}}\right)\right)$ bits of space. Specifically, for $k=\Theta\left(n\right)$, the space complexity is $\operatorname{poly}\left(\frac{\log n}{\mathbb{{\cal\varepsilon}}}\right)$.

Remark 3.6*.*

We are not aware of a lower bound on the approximation ratio for sliding-window algorithms, and the approximation ratio in Corollary 3.5 can possibly be improved, say to $1+\mathbb{{\cal\varepsilon}}$, using the same space complexity.

3.2 Matrix Streams

A matrix stream is a sequence of updates to an underlying matrix $X\in\mathbb{R}^{n\times m}$, for $n\geq m$, initialized to the all-zeros matrix. We consider only row-order streams, where each update adds a new row to the matrix (from row $1$ to row $n$), hence the $i$-th update in the stream is a row vector $X_{i}\in\mathbb{R}^{m}$ representing the $i$-th row of $X$. We assume that all entries are polynomially bounded, i.e., $\left|X_{i,j}\right|\leq\operatorname{poly}\left(n\right)$ for all $i,j$.

We are interested in the Schatten $p$-norm of a matrix $X$, i.e., the $\ell_{p}$-norm of the spectrum of $X$.

Definition 3.7**.**

The Schatten $p$-norm, for $p\geq 1$, of a matrix $X\in\mathbb{R}^{n\times m}$ with singular values $\sigma_{1}\geq\cdots\geq\sigma_{m}\geq 0$, is defined as

[TABLE]

Remark 3.8*.*

Note that $\left\|X\right\|_{S_{2p}}^{2}=\left\|X^{T}X\right\|_{S_{p}}$ since $X^{T}X$ is a PSD matrix with eigenvalues $\left\{\sigma_{i}^{2}\mid i\in\left[m\right]\right\}$.

Corollary 3.9**.**

For $p\geq 2$, the Schatten $p$-norm is $\sqrt{2}$-almost-smooth.

Proof.

Let $X$ be a matrix defined by a stream of $n$ rows $X_{1},\dots,X_{n}$. The first $n^{\prime}$ rows define a matrix $Y$ and the other $n-n^{{}^{\prime}}$ rows define $Z$. Observe that $X^{T}X=\sum\limits_{i=1}^{n}X_{i}^{T}X_{i}=\sum\limits_{i=1}^{n^{{}^{\prime}}}X_{i}^{T}X_{i}+\sum\limits_{i=1}^{n-n^{{}^{\prime}}}X_{i}^{T}X_{i}=Y^{T}Y+Z^{T}Z$, and using the triangle inequality for the Schatten $p/2$-norm (recall $p\geq 2$), we obtain

[TABLE]

hence the squared Schatten $p$-norm is subadditive. It is clearly also non-negative, thus, in order to prove almost-smoothness we only need to show it is bounded and monotone. Every rank-$1$ matrix $v^{T}v$, for a row vector $v\in\mathbb{R}^{m}$, has (at most) one eigenvalue $\lambda=\left\|v\right\|_{2}^{2}$ different from [math], hence $\left\|v^{T}v\right\|_{S_{p/2}}=\left\|v\right\|_{2}^{2}$, and therefore

[TABLE]

Thus, the squared Schatten $p$-norm is bounded. To prove it is monotone, we use Weyl’s inequality, that for every real matrices $Y,Z$ it holds that $\sigma_{i}\left(Y^{T}Y+Z^{T}Z\right)\geq\sigma_{i}\left(Y^{T}Y\right)$ for all $i$ and thus $\left\|Y+Z\right\|_{S_{p}}^{2}\geq\left\|Y\right\|_{S_{p}}^{2}$.

It then follows from Lemma 2.4 that the squared Schatten $p$-norm is $2$-almost-smooth. It is then straightforward that the Schatten $p$-norm itself is $\sqrt{2}$-almost-smooth. ∎

By plugging a known streaming algorithm for the Schatten $4$-norm into our almost-smooth framework, we obtain a sliding-window algorithm with constant approximation ratio and constant space.

Corollary 3.10** (Formal version of Theorem 1.10).**

There exists a sliding-window algorithm that $\left(\sqrt{2}+\mathbb{{\cal\varepsilon}}\right)$-approximates the Schatten $4$-norm using $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-3}\log n\log\frac{w}{\mathbb{{\cal\varepsilon}}}\log w\right)$ bits of space with constant success probability.

Proof.

Algorithm $5$ of [BKKS20] is a $\left(1+\mathbb{{\cal\varepsilon}}\right)$-approximation of the Schatten $4$-norm in the row-order model, using $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-2}\log n\right)$ bits of space. This algorithm has constant success probability, which can be amplified to $1-\frac{\mathbb{{\cal\varepsilon}}}{10w\log w}$ using the median of $O\text{\negmedspace}\left(\log\frac{w}{\mathbb{{\cal\varepsilon}}}\right)$ independent repetitions. Now Theorem 2.7 and the above $\sqrt{2}$-almost-smoothness of the Schatten $4$-norm imply a $\left(\sqrt{2}+\mathbb{{\cal\varepsilon}}\right)$-approximation sliding-window algorithm using $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-3}\log n\log\frac{w}{\mathbb{{\cal\varepsilon}}}\log w\right)$ bits of space. ∎

3.3 Submodular Functions

The *maximum submodular matching * (MSM) problem is a generalization of the maximum weight matching (MWM) problem to submodular objective functions.

Definition 3.11**.**

A submodular function on a ground set $\mathcal{X}$ is a set function $f:2^{\mathcal{X}}\rightarrow\mathbb{R}$ that satisfies $f\left(A\cup B\right)+f\left(A\cap B\right)\leq f\left(A\right)+f\left(B\right)$ for all $A,B\subseteq\mathcal{X}$.

Definition 3.12**.**

For a graph $G=\left(V,E\right)$ and a monotone non-negative submodular function $f:2^{E}\rightarrow\mathbb{R}_{+}$, the MSM problem asks to find a matching $M\subseteq E$ such that $f\left(M\right)$ is maximized. If $M^{*}\subseteq E$ is a matching maximizing $f\left(\cdot\right)$ we denote $\widehat{f}\left(G\right)=f\left(M^{*}\right)$, and say that $M^{*}$ is an $f$-maximum matching. For a stream $S$ of edges whose underlying graph is $G$, we define $\widehat{f}\left(S\right)=\widehat{f}\left(G\right)$.

Remark 3.13*.*

If $f:2^{E}\rightarrow\mathbb{R}_{+}$ is submodular then the derived function $\widehat{f}$ of streams of edges is subadditive (see Definition 1.8). To see this, let $AB$ be a stream with $f$-maximum matching $M^{*}$. Denote by $M_{A}^{*}$ and $M_{B}^{*}$ the edges from the matching $M^{*}$ that appear in the sub-streams $A$ and $B$, respectively. Since $A$ clearly contains $M_{A}^{*}$, the $f$-maximum matching in $A$ has value $\widehat{f}\left(A\right)\geq f\left(M_{A}^{*}\right)$, and similarly for $B$. Therefore,

[TABLE]

Chakrabarti and Kale [CK14] showed a constant-factor approximation algorithm for the MSM problem in the semi-streaming model. They modeled access to $f$ using a value oracle, which upon receiving a query subset $E^{{}^{\prime}}\subseteq E$ outputs $f\left(E^{{}^{\prime}}\right)$. We use the same model of a value oracle. By apply our almost-smooth framework to their algorithm, we achieve a constant-factor approximation algorithm for the MSM problem in the sliding-window model.

Corollary 3.14**.**

There exists a deterministic $O\text{\negmedspace}\left(1\right)$-approximation sliding-window algorithm for the MSM problem with $O\text{\negmedspace}\left(n\log n\log w\right)$ bits of space.

Proof.

Theorem $1$ of [CK14] provides a deterministic $7.75$-approximation insertion-only algorithm $\Lambda$ for the MSM problem with $O\text{\negmedspace}\left(n\log n\right)$ bits of space. Since the MSM problem is subadditive (see Remark 3.13), and thus $2$-almost-smooth, we derive from Theorem 2.7 a sliding-window algorithm $\Lambda^{sw}$ that $\left(2\cdot 7.75^{2}\left(1+\mathbb{{\cal\varepsilon}}\right)\right)$-approximates the MSM problem using $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-1}n\log n\log w\right)$ bits of space. ∎

Remark 3.15*.*

One interesting submodular function follows from the Facility Location problem. Let $m\in\mathbb{N}$ and $G=\left(V,E\right)$ be a graph, and for every edge $e\in E$ let $V_{e}\in\mathbb{R}_{+}^{m}$ be a vector of values associated with the edge $e$. The function $f:2^{E}\rightarrow\mathbb{R}_{+}$ defined by $f\left(E^{{}^{\prime}}\right)=\sum\limits_{i=1}^{m}\max\limits_{e\in E^{{}^{\prime}}}V_{e,i}$ for $E^{{}^{\prime}}\subseteq E$ is submodular, monotone, and non-negative (See [Fri74, KG14]).

3.4 Max $k$-Cover

The Max $k$-Cover problem is dual to Vertex-Cover, and its goal is to cover as many edges as possible (in a graph $G$) using only $k$ vertices. Recently, McGregor and Vu [MV19] studied the Max $k$-Cover problem in the dynamic graph stream model, where the stream consists of edge insertions and deletions. Specifically, they showed a $\left(1+\mathbb{{\cal\varepsilon}}\right)$-approximation streaming algorithm for arbitrary $k$ with space bound $\widetilde{O}\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-2}n\right)$ and success probability $1-\frac{1}{\operatorname{poly}\left(n\right)}$, where $n=\left|V\right|$, see Theorem $20$ of [MV19]. Note that we can assume the entire stream is of length at most $2w$ (see claim B.1) and since we are only concerned with insertion-only graph streams we assume $w=O\text{\negmedspace}\left(n^{2}\right)$. The aforementioned algorithm already has high probability of success and thus requires no amplification. Using this and our almost-smoothness technique, we achieve $\left(2+\mathbb{{\cal\varepsilon}}\right)$-approximation algorithm in the sliding-window model, with space bound $\widetilde{O}\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-3}n\right)$. In addition, we present a $\left(2+\mathbb{{\cal\varepsilon}}\right)$-estimation algorithm in the same dynamic graph stream model, and consequently a $\left(4+\mathbb{{\cal\varepsilon}}\right)$-estimation algorithm in the sliding-window model, both with space bound $\widetilde{O}_{\mathbb{{\cal\varepsilon}}}\text{\negmedspace}\left(\frac{n}{k}\right)$.

Definition 3.16**.**

For a graph $G=\left(V,E\right)$, a subset of vertices $U\subseteq V$ is said to cover the set of incident edges $\widetilde{E}\left(U\right)=\left\{e\in E:e\cap U\neq\emptyset\right\}$. Denote by $c_{k}\left(G\right)=\max\left\{\left|\widetilde{E}\left(U\right)\right|:\left|U\right|=k\right\}$ the largest number of edges that can be covered by $k$ vertices in $G$. For a stream $S$ of edges, whose underlying graph is $G$, we define $c_{k}\left(S\right)=c_{k}\left(G\right)$.

Corollary 3.17**.**

For every $k$, the Max $k$-Cover function $c_{k}\left(\cdot\right)$ is subadditive, and hence $2$-almost-smooth.

Proof.

Let $AB$ be a stream of edges that defines a graph $G=\left(V,E\right)$ and suppose $c_{k}\left(G\right)=\left|\widetilde{E}\left(U\right)\right|$ for some $U\subseteq V$ with $\left|U\right|=k$. Let $E_{A}=\widetilde{E}\left(U\right)\cap A$ and $E_{B}=\widetilde{E}\left(U\right)\cap B$ and observe that $\left|\widetilde{E}\left(U\right)\right|=\left|E_{A}\right|+\left|E_{B}\right|$. Therefore

[TABLE]

and so $c_{k}\left(\cdot\right)$ is subadditive. Obviously $c_{k}\left(\cdot\right)$ is also non-negative, bounded and monotone, hence Lemma 2.4 applies. ∎

We start with a sliding-window approximation algorithm for Max $k$-Cover. We obtain a sliding-window algorithm by plugging a known algorithm into Theorem 2.7. Specifically, we use the aforementioned algorithm of McGregor and Vu [MV19, Theorem 20] and the fact that Max $k$-Cover is $2$-almost-smooth to obtain the following corollary.

Corollary 3.18**.**

For every $k$ there exists a sliding-window $\left(2+\mathbb{{\cal\varepsilon}}\right)$-approximation algorithm for Max $k$-Cover using $\widetilde{O}\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-3}n\right)$ bits of space.

We now design a sliding-window estimation streaming algorithms for Max $k$-Cover. Observe that if $\sigma_{k}\left(G\right)$ denotes the sum of degrees of the $k$ vertices of largest degree in $G$, then a greedy algorithm that reports $\sigma_{k}\left(G\right)$, achieves a $2$-estimation of Max $k$-Cover. We can implement it in a graph stream using a known algorithm for the top-$k$ norm (similarly to Corollary 3.5), which will $\left(2+\mathbb{{\cal\varepsilon}}\right)$-estimate $\sigma_{k}\left(G\right)$. Hence, we deduce a $\left(2+\mathbb{{\cal\varepsilon}}\right)$-estimation algorithm for Max $k$-Cover in the dynamic graph stream model with space bound $\widetilde{O}_{\mathbb{{\cal\varepsilon}}}\text{\negmedspace}\left(\frac{n}{k}\right)$. Moreover, we can similarly obtain a $\left(4+\mathbb{{\cal\varepsilon}}\right)$-estimation algorithm in the sliding-window model using a sliding-window algorithm for the top-$k$ norm. The details follow.

Theorem 3.19**.**

For every $k$ there exists a sliding-window $\left(4+\mathbb{{\cal\varepsilon}}\right)$-estimation algorithm for Max $k$-Cover using $\widetilde{O}_{\mathbb{{\cal\varepsilon}}}\text{\negmedspace}\left(\frac{n}{k}\right)$ bits of space.

Proof.

Let $x\in\mathbb{R}^{n}$ represent the degrees of the $n$ vertices, and notice that $\left\|x\right\|_{\left(k\right)}=\sigma_{k}\left(G\right)$ using the notation from Section 3.1. By incrementing coordinates $x_{i},x_{j}$ whenever an edge $\left(i,j\right)$ arrives, we create a virtual stream (twice as long) simulating updates to $x$ in the frequency-vector model. Using Corollary 3.5 (with twice as large window size) we can $\left(2+\mathbb{{\cal\varepsilon}}\right)$-estimate $\sigma_{k}\left(G\right)$ in the sliding-window model using $\widetilde{O}_{\mathbb{{\cal\varepsilon}}}\text{\negmedspace}\left(\frac{n}{k}\right)$ bits of space. Since $\frac{1}{2}c_{k}\left(G\right)\leq\frac{1}{2}\sigma_{k}\left(G\right)\leq c_{k}\left(G\right)$, reporting the $\left(2+\mathbb{{\cal\varepsilon}}\right)$-estimate of $\sigma_{k}\left(G\right)$ gives a sliding-window $\left(4+\mathbb{{\cal\varepsilon}}\right)$-estimate of Max $k$-Cover and uses $\widetilde{O}_{\mathbb{{\cal\varepsilon}}}\text{\negmedspace}\left(\frac{n}{k}\right)$ bits of space. ∎

3.5 Example of $d$-Almost-Smooth Functions for $d\in\left(1,2\right]$

We design a special family of functions whose almost-smoothness parameter $d$ can be any number between $1$ and $2$. For every $d\in\left(1,2\right]$ define the following function for an $n$-vertex graph $G$ with maximum matching size $m\left(G\right)$

[TABLE]

For a stream $S$ of edges, with an underlying graph $G$, we define $f_{d}\left(S\right)=f_{d}\left(G\right)$.

Lemma 3.20**.**

For every $d\in\left(1,2\right]$ the function $f_{d}$ defined above is $d$-almost-smooth and not $d^{\prime}$-almost-smooth for any $d^{\prime}<d$.

Proof.

Let $d\in\left(1,2\right]$, and observe that the function $f_{d}\left(\cdot\right)$ is non-negative, bounded and monotone, since $m\left(\cdot\right)$ satisfies all those requirements. Hence, we are only left to show the almost-smoothness property. We shall use the equivalent definition explained in Remark 2.2. Define $\alpha_{d}=\frac{1}{4}\left(\frac{2-d}{d-1}\right)$, let $\mathbb{{\cal\varepsilon}}\in\left(0,1\right]$ and let $A,B$ and $C$ be disjoint segments of the stream satisfying $\mathbb{{\cal\varepsilon}}f_{d}\left(AB\right)\leq f_{d}\left(B\right)$, i.e., $\mathbb{{\cal\varepsilon}}\alpha_{d}n+\mathbb{{\cal\varepsilon}}m\left(AB\right)\leq\alpha_{d}n+m\left(B\right)$. We divide the proof into two cases. If $m\left(BC\right)\leq\frac{n}{4}=\frac{d-1}{2-d}\alpha_{d}n$ then using the same logic as in Lemma 2.4 we obtain

[TABLE]

Hence, $2m\left(BC\right)+\alpha_{d}n\geq\mathbb{{\cal\varepsilon}}m\left(ABC\right)+\mathbb{{\cal\varepsilon}}\alpha_{d}n=\mathbb{{\cal\varepsilon}}f_{d}\left(ABC\right)$, and therefore

[TABLE]

In the other case, when $m\left(BC\right)>\frac{n}{4}$, since the graph has $n$ vertices we have $m\left(ABC\right)\leq\frac{n}{2}$, and therefore

[TABLE]

From the assumption $m\left(BC\right)>\frac{n}{4}$ we obtain

[TABLE]

hence $\mathbb{{\cal\varepsilon}}f_{d}\left(ABC\right)\leq d\cdot f_{d}\left(BC\right)$, as required.

For the tightness argument we use the same example as in Corollary 2.5 of disjoint union of $n$ paths of length $3$. Recall that $\left|V\right|=4n$ and thus $m\left(AB\right)=m\left(B\right)=m\left(BC\right)=n$ but $m\left(ABC\right)=2n$, therefore we deduce that

[TABLE]

showing that indeed $f_{d}$ is not $d^{\prime}$-almost-smooth for any $d^{\prime}<d$. ∎

4 Applications to Maximum-Matching

We show here a concrete example of the usefulness of the almost-smooth histogram framework for the graph streaming model. Specifically, for graphs of bounded arboricity $\alpha$, we use a known insertion-only $O\text{\negmedspace}\left(\alpha\right)$-estimation algorithm for maximum-matching, and deduce a sliding-window algorithm with approximation factor $O\text{\negmedspace}\left(\alpha^{2}\right)$ and space $\operatorname{polylog}\left(n\right)$. We then improve the approximation ratio to $O\text{\negmedspace}\left(\alpha\right)$ by observing that the number of $\alpha$-good edges (the quantity used to approximate the maximum-matching size) is itself a subadditive function, and thus we can argue directly about it. See Table 1.

Recall that in the usual graph streaming model, the input is a stream of edge insertions to an underlying graph on the set of vertices $V=\left[n\right]$, where $n$ is known in advance. We assume that the underlying graph does not contain parallel edges, i.e., the stream of edges does not contain the same edge twice. Hence, the length of the entire stream is bounded by $n^{2}$.

In the sliding-window model the graph is defined using only the last $w$ edge insertions from the stream, referred to as the active window $W$. Note that $w$ is known (to the algorithm) in advance, and that $w\leq n^{2}$, as the length of the entire stream is bounded by $n^{2}$.

McGregor and Vorotnikova [MV18], based on the result of Cormode et al. [CJMM17], presented an algorithm that approximates the size of the maximum-matching in a graph with arboricity $\alpha$ within factor $\left(1+\mathbb{{\cal\varepsilon}}\right)\left(\alpha+2\right)$, with constant probability, using space $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-2}\log^{2}n\right)$ and update time $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-2}\log n\right)$. To achieve low failure probability $\mathbb{{\cal\delta}}$ it is standard to compute a median of $\log\mathbb{{\cal\delta}}^{-1}$ parallel repetitions. Therefore, direct application of the Almost-Smooth-Histogram method yields the following theorem (but see Theorem 4.4 for the improved approximation).

Theorem 4.1**.**

For every $\mathbb{{\cal\varepsilon}},\mathbb{{\cal\delta}}\in\left(0,\frac{1}{2}\right)$, there is a sliding-window $\left(\left(2+\mathbb{{\cal\varepsilon}}\right)\left(\alpha+2\right)^{2},\mathbb{{\cal\delta}}\right)$-estimation algorithm for maximum-matching size in a graph with arboricity $\alpha$, with space complexity $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-3}\log^{4}n\log\tfrac{1}{\mathbb{{\cal\varepsilon}}\mathbb{{\cal\delta}}}\right)$ and update time $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-3}\log^{3}n\log\tfrac{1}{\mathbb{{\cal\varepsilon}}\mathbb{{\cal\delta}}}\right)$.

Proof.

For $\mathbb{{\cal\varepsilon}},\mathbb{{\cal\delta}}\in\left(0,\frac{1}{2}\right)$ let $\Lambda_{MV}$ be the algorithm of McGregor and Vorotnikova [MV18], amplified to have success probability $1-\mathbb{{\cal\delta}}$, providing $\left(\left(1+\mathbb{{\cal\varepsilon}}\right)\left(\alpha+2\right),\mathbb{{\cal\delta}}\right)$-approximation for maximum-matching size in graphs with arboricity at most $\alpha$. As shown in Corollary 2.5, $m\left(\cdot\right)$ is $2$-almost-smooth. Therefore, using Theorem 2.7 with $c=1,d=2,C=\alpha+2$ and algorithm $\Lambda_{MV}$, we obtain a sliding window algorithm $\Lambda$ which $\left(\left(2+\mathbb{{\cal\varepsilon}}\right)\left(\alpha+2\right)^{2},\mathbb{{\cal\delta}}\right)$-approximate the maximum-matching size in graphs with arboricity $\alpha$.

The space complexity of $\Lambda_{MV}$ is $s_{MV}\left(\mathbb{{\cal\varepsilon}},\mathbb{{\cal\delta}}\right)=O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-2}\log^{2}n\log\mathbb{{\cal\delta}}^{-1}\right)$ and it the update time is $t_{MV}\left(\mathbb{{\cal\varepsilon}},\mathbb{{\cal\delta}}\right)=O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-2}\log n\log\mathbb{{\cal\delta}}^{-1}\right)$. Hence the space complexity of $\Lambda$ is

[TABLE]

and similarly for the update time, where we used the fact that $w\leq n^{2}$. ∎

For the purpose of approximating the maximum-matching size in graphs with arboricity bounded by $\alpha$ Cormode et al. [CJMM17] introduced the notion of $\alpha$-good edges. The algorithm of [MV18] used in the above proof actually approximates the maximum number of $\alpha$-good edges in prefixes of the stream. Thus, using the same algorithm of [MV18], we can directly approximate the maximum size of the set of $\alpha$-good edges in the active window $W$. For completeness we present here the definition of Cormode et al. [CJMM17] for $\alpha$-good edges in a stream, and the notion of $E_{\alpha}^{*}$ due to McGregor and Vorotnikova [MV18].

Definition 4.2**.**

Let $\mathcal{S}=\left(e_{1},e_{2},\ldots,e_{k}\right)$ be a sequence of $k$ edges on the set of vertices $V=\left[n\right]$. We say that an edge $e_{i}=\left\{u,v\right\}$ is $\alpha$-good (with respect to the stream $\mathcal{S}$) if $d_{i}\left(u\right)\leq\alpha$ and $d_{i}\left(v\right)\leq\alpha$, where $d_{i}\left(x\right)$ is the number of edges incident on the vertex $x$ that appear after edge $e_{i}$ in the stream, i.e., $d_{i}\left(x\right)=\left|\left\{e_{j}\mid j>i\land x\in e_{j}\right\}\right|$. Denote by $E_{\alpha}\left(\mathcal{S}\right)$ the set of $\alpha$-good edges in the stream $S$, and let $E_{\alpha}^{*}\left(\mathcal{S}\right)=\max\limits_{t\in\left[k\right]}\left|E_{\alpha}\left(\mathcal{S}_{t}\right)\right|$, where $\mathcal{S}_{t}=\left(e_{1},e_{2},\ldots,e_{t}\right)$ is the prefix of $S$ of length $t$.

Although the size of the set of $\alpha$-good edges in a stream is not smooth or even almost-smooth, the function $E_{\alpha}^{*}\left(\cdot\right)$ is almost-smooth, since it is subadditive.

Lemma 4.3**.**

The function $E_{\alpha}^{*}\left(\cdot\right)$ is $2$-almost-smooth.

Proof.

Obviously $E_{\alpha}^{*}\left(\cdot\right)$ is non-negative and bounded. It is also monotone, since it is defined by taking a maximum of prefixes and earlier edges do not interfere with later edges being $\alpha$-good. Hence, we are only left to show that it is indeed subadditive. Let $A$ and $B$ be disjoint segments of the stream $S=\left(e_{1},e_{2},\ldots,e_{k}\right)$. If $E_{\alpha}^{*}\left(AB\right)=E_{\alpha}^{*}\left(A\right)$ then obviously $E_{\alpha}^{*}\left(A\right)+E_{\alpha}^{*}\left(B\right)\geq E_{\alpha}^{*}\left(AB\right)$, as $E_{\alpha}^{*}$ is non-negative. Otherwise, let $1\leq t\leq k$ be such that $e_{t}\in B$ and $E_{\alpha}^{*}\left(AB\right)=\left|E_{\alpha}\left(\left(AB\right)_{t}\right)\right|$, then

[TABLE]

where it is a disjoint union. Note that $E_{\alpha}\left(\left(AB\right)_{t}\right)\cap A\subseteq E_{\alpha}\left(A\right)$, as every $\alpha$-good edge from $A$ with respect to the stream $\left(AB\right)_{t}$ is also $\alpha$-good edge in the stream $A$. Hence $E_{\alpha}^{*}\left(\cdot\right)$ is subadditive,

[TABLE]

Therefore, using Lemma 2.4 we deduce that it is indeed $2$-almost-smooth, as required. ∎

McGregor and Vorotnikova [MV18] proved that $m\left(\mathcal{S}\right)\leq\left|E_{\alpha}\left(\mathcal{S}\right)\right|\leq\left(\alpha+2\right)\cdot m\left(\mathcal{S}\right)$ for every stream $\mathcal{S}$, and thus also $m\left(\mathcal{S}\right)\leq E_{\alpha}^{*}\left(\mathcal{S}\right)\leq\left(\alpha+2\right)\cdot m\left(\mathcal{S}\right)$. They also designed for $E_{\alpha}^{*}\left(\cdot\right)$ a $\left(1+\mathbb{{\cal\varepsilon}},\mathbb{{\cal\delta}}\right)$-approximation algorithm with space complexity $s_{MV}\left(\mathbb{{\cal\varepsilon}},\mathbb{{\cal\delta}}\right)$, as explained in Theorem 4.1. Since $E_{\alpha}^{*}\left(\cdot\right)$ is $2$-almost-smooth by Lemma 4.3 we can apply Theorem 2.8, with $g=E_{\alpha}^{*}\left(\cdot\right)$ and $f=m\left(\cdot\right)$, to obtain the following improvement over Theorem 4.1.

Theorem 4.4** (Restatement of Theorem 1.11).**

For every $\mathbb{{\cal\varepsilon}},\mathbb{{\cal\delta}}\in\left(0,\frac{1}{2}\right)$, there is a sliding-window $\left(\left(2+\mathbb{{\cal\varepsilon}}\right)\left(\alpha+2\right),\mathbb{{\cal\delta}}\right)$-estimation algorithm for the maximum-matching size in a graph with arboricity $\alpha$, with space bound $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-3}\log^{4}n\log\tfrac{1}{\mathbb{{\cal\varepsilon}}\mathbb{{\cal\delta}}}\right)$ and update time $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-3}\log^{3}n\log\tfrac{1}{\mathbb{{\cal\varepsilon}}\mathbb{{\cal\delta}}}\right)$.

Remark 4.5*.*

For arboricity $\alpha=1$ we can achieve better approximation ratio. Cormode et al. [CJMM17] showed that in this case $m\left(\mathcal{S}\right)\leq\left|E_{1}\left(\mathcal{S}\right)\right|\leq 2\cdot m\left(\mathcal{S}\right)$ and thus $m\left(\mathcal{S}\right)\leq E_{1}^{*}\left(\mathcal{S}\right)\leq 2\cdot m\left(\mathcal{S}\right)$. Therefore, by Theorem 2.8 there is a $\left(4+\mathbb{{\cal\varepsilon}},\mathbb{{\cal\delta}}\right)$-approximation algorithm for the maximum-matching size in forest graphs in the sliding-window model with the same space and update time bounds.

5 Applications to Minimum Vertex-Cover

We show here few results for minimum vertex-cover (again in the sliding-window model), based on its relationship to maximum and maximal matching, and the fact that it is also almost smooth, see Corollary 2.5. We start by showing an algorithm with approximation factor $3.125+\mathbb{{\cal\varepsilon}}$ for the size of a minimum vertex-cover in VDP graphs using $\widetilde{O}\text{\negmedspace}\left(\sqrt{n}\right)$ space. We continue and present another algorithm for a larger family of graphs, namely, forest graphs, where the approximation factor grows to $4+\mathbb{{\cal\varepsilon}}$ but the space complexity reduces to $\operatorname{polylog}\left(n\right)$. We then proceed to show how to report a feasible vertex cover. We reproduce a known algorithm for general graphs with approximation factor $8+\mathbb{{\cal\varepsilon}}$ that computes a vertex cover using $\widetilde{O}\text{\negmedspace}\left(n\right)$ space. Then we show how to improve the approximation factor to $4+\mathbb{{\cal\varepsilon}}$ by a tighter analysis of that same algorithm, using that the size of a greedy maximal matching is also almost smooth.

There are two different but related problems to consider. The first one is estimating the size of the minimum vertex-cover (without providing a corresponding vertex cover of that size), and the second one is computing a feasible vertex-cover of approximately minimum size.

Recall that the minimum vertex-cover size is almost-smooth, since it is subadditive, as shown in Corollary 2.5. Hence, we can use the Almost-Smooth-Histogram approach to estimate the size of the minimum vertex-cover in the sliding-window model, as explain in the next section.

5.1 Vertex-Cover Estimation

First we consider estimating the size of the minimum vertex cover in the sliding-window model. We provide the first sub-linear space algorithm in the sliding-window model for estimating $VC\left(\cdot\right)$, for some families of graphs, as explained below.

A graph $G=\left(V,E\right)$ is said to be VDP (stands for vertex-disjoint paths) if $G$ is a union of vertex disjoint paths. We show two sliding-window algorithms for different families of graphs. One with $\widetilde{O}\text{\negmedspace}\left(\sqrt{n}\right)$ space obtaining almost $3.125$-approximation for the family of VDP graphs and the other one with $\operatorname{polylog}\left(n\right)$ space obtaining almost $4$-approximation for graphs of arboricity $\alpha=1$. Observe that the results are incomparable, since the first algorithm has better approximation ratio but its space complexity is much bigger. Also, the second algorithm is applicable for a larger family of graphs.

For the family of VDP graphs there is a randomized algorithm in the turnstile streaming model to approximate $VC\left(\cdot\right)$, presented in [vH16]. Using the standard argument of computing a median of $\log\mathbb{{\cal\delta}}^{-1}$ parallel repetitions, to achieve low failure probability $\mathbb{{\cal\delta}}$, we can state this result as follows.

Theorem 5.1**.**

[vH16, Theorem 1.1]** For every $\mathbb{{\cal\varepsilon}}\in\left(0,\frac{1}{2}\right),\mathbb{{\cal\delta}}\in\left(0,1\right)$, there exists a turnstile $\left(\frac{5}{4}+\mathbb{{\cal\varepsilon}},\mathbb{{\cal\delta}}\right)$-approximation streaming algorithm for $VC\left(\cdot\right)$ in VDP graphs with space bound $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-1}\sqrt{n}\log^{2}n\log\mathbb{{\cal\delta}}^{-1}\right)$.

Using Theorem 2.7, with $c=1,d=2$ and $C=\frac{5}{4}$ (thus $dc^{2}C^{2}=3.125$), we obtain as a corollary the following result for the sliding-window model.

Theorem 5.2**.**

For every $\mathbb{{\cal\varepsilon}}\in\left(0,\frac{1}{2}\right),\mathbb{{\cal\delta}}\in\left(0,1\right)$, there exists a sliding-window $\left(3.125+\mathbb{{\cal\varepsilon}},\mathbb{{\cal\delta}}\right)$-approximation algorithm for $VC\left(\cdot\right)$ in VDP graphs with space bound $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-2}\sqrt{n}\log^{4}n\log\frac{1}{\mathbb{{\cal\varepsilon}}\mathbb{{\cal\delta}}}\right)$.

Observe that a VDP graph has arboricity $\alpha=1$, because it is a forest, and in particular it is a bipartite graph. Recall that according to Kőnig’s theorem, in a bipartite graph the size of a minimum vertex cover equals the size of a maximum-matching. Therefore, we conclude from Remark 4.5 that there is a $\left(4+\mathbb{{\cal\varepsilon}},\mathbb{{\cal\delta}}\right)$-approximation algorithm for the minimum vertex cover in VDP graphs using $\operatorname{polylog}$ space. Obviously it extends to all forests, i.e., graphs with arboricity $\alpha=1$. Comparing to Theorem 5.2, the following theorem has slightly worse approximation factor but its space complexity is much better, moreover, its applicable for a wider family of graphs.

Theorem 5.3**.**

For every $\mathbb{{\cal\varepsilon}},\mathbb{{\cal\delta}}\in\left(0,\frac{1}{2}\right)$, there is a sliding-window $\left(4+\mathbb{{\cal\varepsilon}},\mathbb{{\cal\delta}}\right)$-approximation algorithm for the size of the minimum vertex-cover size in a forest graph, with space bound $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-3}\log^{4}n\log\tfrac{1}{\mathbb{{\cal\varepsilon}}\mathbb{{\cal\delta}}}\right)$ and update time $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-3}\log^{3}n\log\tfrac{1}{\mathbb{{\cal\varepsilon}}\mathbb{{\cal\delta}}}\right)$.

Remark 5.4*.*

According to the previous paragraph and Remark 4.5, the algorithm of Cormode et al. [CJMM17] $\left(2+\mathbb{{\cal\varepsilon}}\right)$-approximates the minimum vertex-cover size in forest graphs (arboricity $\alpha=1$) in the insertion-only model with space $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-2}\log^{2}n\right)$ and update time $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-2}\log n\right)$.

5.2 Vertex-Cover Approximation

Here we consider computing a feasible vertex cover of approximately minimum size. We improve the approximation ratio of the algorithm of [vH16] from $8+\mathbb{{\cal\varepsilon}}$ to $4+\mathbb{{\cal\varepsilon}}$, using a tighter analysis of his algorithm.

A maximal matching is a matching that cannot be extended by adding an edge to it, i.e., a matching $M$ in a graph $G=\left(V,E\right)$ is maximal if every edge $e\in E\backslash M$ is adjacent to at least one edge from the matching $M$. For a stream $A$ of edge insertions, denote by $\widehat{M}\left(A\right)$ the greedy matching on $A$, and denote by $\widehat{m}\left(A\right)$ its size. Notice that for every stream $A$ the greedy matching $\widehat{M}\left(A\right)$ is maximal. Recall that for a matching $M$ we denote by $V\left(M\right)$ the set of all endpoints of edges from $M$, i.e., $V\left(M\right)=\left\{v\in V\mid\exists u\in V,\left\{v,u\right\}\in M\right\}$.

We first show that the greedy-matching size of a stream of edge insertions is almost-smooth. The proof is similar in nature to that of Corollary 2.5, but different because $\widehat{m}\left(\cdot\right)$ is not left-monotone, but rather $2$-left-monotone. Furthermore, we can use the actual matching, since it is well structured.

Lemma 5.5**.**

The greedy-matching size is $\left(2,2\right)$-almost-smooth.

Proof.

The first and third requirements are clear, as $\widehat{m}\left(\cdot\right)$ is non-negative and bounded. For the $2$-monotonicity, let $A,B$ be disjoint segments of the stream. Note that for every $e\in\widehat{M}\left(B\right)$ at least one of its endpoints is in $V\left(\widehat{M}\left(AB\right)\right)$, hence $\widehat{m}\left(B\right)\leq\left|V\left(\widehat{M}\left(AB\right)\right)\right|=2\cdot\widehat{m}\left(AB\right)$.

To prove the almost-smoothness property, let $A,B$ and $C$ be disjoint segments of the stream, and suppose $\mathbb{{\cal\varepsilon}}\widehat{m}\left(AB\right)\leq\widehat{m}\left(B\right)$ for some $\mathbb{{\cal\varepsilon}}\in\left(0,1\right)$. We first claim that

[TABLE]

The lefthand-side counts the edges in $\widehat{M}\left(ABC\right)$, which can be partitioned into edges from $AB$ and from $C$. The former set is, by construction, $\widehat{M}\left(ABC\right)\cap AB=\widehat{M}\left(AB\right)$, hence we actually need to show that

[TABLE]

To prove this, we map each edge $e\in\widehat{M}\left(ABC\right)\cap C$ to an edge $f\left(e\right)\in\widehat{M}\left(BC\right)$, defined as the first (earliest) edge in the stream $BC$ that intersects $e$ (i.e., shares at least one endpoint with $e$, possibly $e$ itself). Observe that $f\left(e\right)$ is well-defined because the greedy matching $\widehat{M}\left(BC\right)$ considers at some point the edge $e\in C$ itself; moreover, if $e\in\widehat{M}\left(BC\right)$ then $f\left(e\right)=e$, and otherwise $f\left(e\right)\neq e$. Assume for contradiction that $f\left(e_{1}\right)=f\left(e_{2}\right)$ for two distinct edges $e_{1}\neq e_{2}\in\widehat{M}\left(ABC\right)\cap C$, and without loss of generality, let $e_{1}$ appear before $e_{2}$ in the stream $C$. Observe that $f\left(e_{1}\right)\notin\widehat{M}\left(ABC\right)$ because it intersects two distinct edges $e_{1},e_{2}$ in that same matching $\widehat{M}\left(ABC\right)$ (having two distinct edges handles the possibility that $f\left(e_{1}\right)$ is one of $e_{1},e_{2}$). This means that there is some $e_{0}\in\widehat{M}\left(ABC\right)$ that intersects $f\left(e_{1}\right)$ and appears before it in the stream $ABC$. Notice that this $e_{0}\neq e_{1},e_{2}$ because $e_{0}$ appears before $f\left(e_{1}\right)$ (in $ABC$) which in turn appears no later than $e_{1}$ and $e_{2}$ (in $BC$). We thus have three distinct edges $e_{0},e_{1},e_{2}\in\widehat{M}\left(ABC\right)$, all intersecting $f\left(e_{1}\right)$, which has only two endpoints, therefore at least two of those three edges must intersect each other, in contradiction to $\widehat{M}\left(ABC\right)$ being a matching. This implies that $f$ is injective, and consequently the claimed inequality.

Let us now complete the proof of the lemma. By construction, $\widehat{m}\left(B\right)\leq\widehat{m}\left(BC\right)$, and we conclude that

[TABLE]

∎

We proceed to show an approximation algorithm for minimum vertex-cover using our almost-smoothness framework, as stated in the next theorem. Its proof basically transforms an approximation algorithm for maximum-matching to one for minimum vertex-cover. The proof starts with a general technique, and then refines the analysis by exploiting the specifics of our setting.

Theorem 5.6**.**

For every $\mathbb{{\cal\varepsilon}}\in\left(0,\frac{1}{2}\right)$, there is a sliding-window $\left(4+\mathbb{{\cal\varepsilon}}\right)$-approximation algorithm for the minimum vertex cover with space bound $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-1}n\log^{2}n\right)$.

Remark 5.7*.*

Below, we wish to use the algorithm presented in Theorem 2.7, however that algorithm returns a number, while we need an algorithm that returns a feasible solution. This disparity is easy to resolve for greedy-matching, by simply outputting the underlying vertices of the greedy-matching associated with bucket $B_{1}$, instead of outputting only its size.

Proof of Theorem 5.6.

If $M^{*}\subseteq E$ is a maximal matching in the graph $G=\left(V,E\right)$ then the set of vertices $V\left(M^{*}\right)$ is a vertex cover of the graph $G$, because every edge from $E$ has at least one of its endpoints in $V\left(M^{*}\right)$ (otherwise the matching $M^{*}$ would not be maximal). For every stream $A$ the greedy matching $\widehat{M}\left(A\right)$ is a maximal matching and thus $V\left(\widehat{M}\left(A\right)\right)$ is a vertex cover of the edges from $A$. Hence, we refer to the greedy-matching algorithm also as the greedy vertex cover algorithm, with the only difference that it outputs the vertices $V\left(\widehat{M}\left(A\right)\right)$ of the matching, instead of the edges $\widehat{M}\left(A\right)$ of the matching.

The greedy vertex cover algorithm achieves $2$-approximation in the standard insertion-only streaming model for the minimum vertex cover using $O\text{\negmedspace}\left(n\log n\right)$ space, because at least one vertex from each matched edge must be in the minimum vertex cover. By using this greedy algorithm and the $2$-almost-smoothness of the minimum vertex cover size, we can deduce from the variant of Theorem 2.7 discussed in Remark 5.7, an $\left(8+\mathbb{{\cal\varepsilon}}\right)$-approximation algorithm for reporting a minimum vertex cover in the sliding-window model with $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-1}n\log^{2}n\right)$ space, matching the result of [vH16].

We can improve the approximation ratio by using the algorithm of Crouch et al. [CMS13], which achieves $\left(3+\mathbb{{\cal\varepsilon}}\right)$-approximation to maximum-matching, using the same space complexity. Their algorithm maintains a greedy matching in various buckets, such that the difference between adjacent buckets is not too large. Specifically, for any adjacent buckets $B_{i}$ and $B_{i+1}$ it holds that $2\widehat{m}\left(B_{i+1}\right)\geq\left(1-\mathbb{{\cal\varepsilon}}\right)\widehat{m}\left(B_{i}\right)$. By an easy modification to their algorithm, just outputting the greedy matching on the bucket $B_{1}$ instead of the bucket $B_{2}$, it holds that $V\left(\widehat{M}\left(B_{1}\right)\right)$ is a vertex cover (of $B_{1}\supseteq W$) at most $\left(6+\mathbb{{\cal\varepsilon}}\right)$-factor larger than the minimum vertex cover on the active window $W$. Note that the algorithm of [CMS13] and the algorithm of [vH16] are essentially the same, the only difference is that [vH16] stores the vertices instead of the edges.

We can improve even further, to $\left(4+\mathbb{{\cal\varepsilon}}\right)$-approximation, by leveraging the fact that the greedy-matching size is $\left(2,2\right)$-almost-smooth. Indeed, let us use the algorithm of Crouch et al. [CMS13], but output $V\left(\widehat{M}\left(B_{1}\right)\right)$ instead of $B_{2}$. At the end of the stream we are guaranteed that $2\widehat{m}\left(B_{2}\right)\geq\left(1-\mathbb{{\cal\varepsilon}}\right)\widehat{m}\left(B_{1}\right)$, because the greedy matching size is $\left(2,2\right)$-almost-smooth. Since the minimum vertex cover is monotone and $W\subseteq B_{1}$ $VC\left(W\right)\leq VC\left(B_{1}\right)\leq\left|V\left(\widehat{M}\left(B_{1}\right)\right)\right|=2\cdot\widehat{m}\left(B_{1}\right)$. Note that $V\left(\widehat{M}\left(B_{1}\right)\right)$ is indeed a vertex cover on the active window $W$, since it is a vertex cover on $B_{1}$. Additionally, $VC\left(W\right)\geq VC\left(B_{2}\right)\geq\widehat{m}\left(B_{2}\right)$, since $VC\left(\cdot\right)$ is monotone, $B_{2}\subseteq W$ and the minimum vertex cover size is at least the size of any matching. For $\mathbb{{\cal\varepsilon}}<\frac{1}{2}$ it holds that $\frac{1}{1-\mathbb{{\cal\varepsilon}}}\leq 1+2\mathbb{{\cal\varepsilon}}$, and we obtain

[TABLE]

We conclude that the output $V\left(\widehat{M}\left(B_{1}\right)\right)$ is a vertex cover on the active window $W$ and it is at most a factor $4\left(1+2\mathbb{{\cal\varepsilon}}\right)$ larger then $VC\left(W\right)$. ∎

Acknowledgments

We thank Oded Goldreich and Shahar Dobzinski for suggesting to generalize Corollary 2.5 to subadditive functions as presented in Lemma 2.4. We also thank Sepehr Assadi and Krishna Chaitanya for pointing out an error in our earlier proof of Lemma 5.5.

Appendix A Smooth-Histogram Framework

The smooth-histogram technique presented by Braverman and Ostrovsky [BO07] is one of only two general techniques for adapting insertion-only algorithms to the sliding-window model. The other one is an earlier technique called exponential histogram, due to Datar et al. [DGIM02]. The approach of [BO07] is to maintain several instances of an insertion-only algorithm on different suffixes of the stream, such that at every point in time, the algorithm can output an approximation of $f$ on $W$. They showed that for a large family of functions, which they called smooth (see Remark 2.3), this approach yields a good approximation algorithm for the sliding-window model. Their technique yields no results for functions that are not smooth, specifically graph problems such as maximum-matching size. We extend this framework to a much broader family of functions that we call almost-smooth.

More precisely, assume there is an algorithm $\Lambda$ that $C$-approximates a left-monotone non-decreasing function $f$ in the insertion-only model. The smooth-histogram framework (for the sliding-window model) maintains $k=O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-1}\log w\right)$ instances of $\Lambda$. Each instance $\Lambda_{i}$ processes the stream from some initial point in time until the end of the stream (or until it is discarded), i.e., it corresponds to some suffix of the stream, referred to as a bucket. The bucket corresponding to $\Lambda_{i}$ is denoted by $B_{i}$, and we denote by $\Lambda_{i}\left(B_{i}\right)$ the value of instance $\Lambda_{i}$ on the stream $B_{i}$. These buckets will satisfy the invariant $B_{1}\supseteq W\supsetneq B_{2}\supsetneq B_{3}\supsetneq\cdots\supsetneq B_{k}$, where $W$ is the active window. In order to use only a small amount of space, whenever two nonadjacent instances have “close” values, all instances between them will be deleted. Instances $\Lambda_{i}$ and $\Lambda_{j}$, for $j>i$, are considered close if $\Lambda_{i}\left(B_{i}\right)$ and $\Lambda_{j}\left(B_{j}\right)$ are within factor $1+\mathbb{{\cal\varepsilon}}$ of each other. At each step of receiving a new item from the stream, the sliding-window algorithm updates all the instances, creates a new instance $\Lambda_{k+1}$, which initially contains only the new item, deletes all unnecessary instances, as explained above, and lastly renumbers the buckets (consecutively starting from $1$). For a more elaborate description see Algorithm 1 in Section 2.

We show that applying this approach to almost-smooth functions yields good approximation algorithms while only storing a small number of buckets. Intuitively, $\Lambda_{1}\left(B_{1}\right)$ approximates $f\left(W\right)$ (up to some factor that depends on $d,C$ and $\mathbb{{\cal\varepsilon}}$) because $\Lambda_{1}\left(B_{1}\right)$ and $\Lambda_{2}\left(B_{2}\right)$ are close up to some factor (since deleted buckets have close value to nearby buckets by the almost-smoothness of $f$) and thus they bound $\Lambda\left(W\right)$. Therefore, by deleting buckets between close instances we ensure that the number of buckets is small while the approximation ratio is roughly $dC^{2}$.

Braverman and Ostrovsky [BO07] proved that all $\ell_{p}$-norms, for $p>0$, are smooth (in our terminology it means almost-smoothness parameter $d=1$) and consequently obtained algorithms that $\left(1+\mathbb{{\cal\varepsilon}}\right)$-approximate these norms in the sliding-window model, with an overhead (relative to insertion-only algorithms) of roughly factor $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-1}\log w\right)$ in the space complexity.

While they analyze their framework only for smooth functions (such as $\ell_{p}$-norms) our analysis considers the larger family of $d$-almost-smooth function (which includes all the subadditive functions). Many graph problems are $2$-almost-smooth (as they are subadditive) but not smooth, and thus do not fit their analysis. Additionally, they do not consider functions that have only a $C$-approximation algorithms in the insertion-only model for constant $C>1$. We analyze the dependence on $C$ and present here the first sliding-window algorithms for such functions.

We point out that previously studied techniques for estimating “weakly superadditive” functions, such as $\ell_{p}$ norms for $p\in\left[1,2\right]$ (e.g. the exponential-histogram technique of Datar et al. [DGIM02, Section 6]), are not relevant to our study of subadditive functions. For example, maximum-matching is subadditive but not weakly superadditive.

Appendix B Proof of Theorem 2.7

To avoid dependence on the length of the entire stream (for the success probability) we make use of a general observation due to Braverman regarding algorithms for the sliding-window model. Intuitively, it says that without loss of generality, the entire stream can be assumed to have length at most twice the size of the window.

Claim B.1*.*

Every sliding-window algorithm $\Lambda$ can be modified such that it will not depend on the length of the entire stream, but only depend on at most $2w$ last items from the stream, while using at most a factor $2$ more space.

Proof of Claim B.1.

To avoid dependence on the length of the stream $N$, and instead be dependent only on the length of the window $w$, we can argue as follows: partition the entire stream $D$ to segments $D_{1},D_{2},\ldots,D_{t}$, of length $w$ each, where $t=\left\lceil\frac{N}{w}\right\rceil$ (except maybe the last segment $D_{t}$, which is of length $0<N-\left(t-1\right)w\leq w$). At each segment $D_{i}$ start a new instance of algorithm $\Lambda$, and keep running it during the next segment as well, for at most $2w$ updates in total (for each instance of $\Lambda$). At any point in time, to answer a query the algorithm queries the instance of $\Lambda$ on the penultimate segment, which corresponds to a suffix of the stream of length at least $w$, and thus contains the entire active window. Thus, at each point in time it is enough to store only the two instances of algorithm $\Lambda$ corresponding to the last two segments, increasing the storage requirement only by a factor of $2$. ∎

Proof of Theorem 2.7.

Assume, without loss of generality, that the length of the entire stream is at most $2w$, as explained in Claim B.1. Denote by $\Lambda(X)$ the output of algorithm $\Lambda$ when run on the stream $X$. Assume that $\Lambda$ has $\frac{\varepsilon\mathbb{{\cal\delta}}}{2w\log w}$ failure probability and $\mathbb{{\cal\varepsilon}}$ is the accuracy parameter, i.e., it $\left(\left(1+\mathbb{{\cal\varepsilon}}\right)C,\frac{\mathbb{{\cal\varepsilon}}\mathbb{{\cal\delta}}}{2w\log w}\right)$-approximates $f$. Recall that we use the term “bucket” to refer to a suffix of the stream. Our algorithm maintains (not explicitly) $k=O\left(\varepsilon^{-1}\log n\right)$ “buckets” $B_{1},\ldots,B_{k}$. At all points in time, these buckets will satisfy the invariant $B_{1}\supseteq W\supsetneq B_{2}\supsetneq B_{3}\supsetneq\cdots\supsetneq B_{k}$, where $W$ is the active window. For each bucket $B_{i}$ the algorithm maintains an instance of $\Lambda$, denoted by $\Lambda_{i}$. In order to use only a small amount of space, whenever two nonadjacent buckets have similar value according to $\Lambda$ we will delete all buckets between them. For ease of exposition, the algorithm will be defined using these buckets, and later we explain how to not actually store the buckets themselves. In each step of receiving a new item $a$ from the stream, the algorithm updates the current buckets $B_{1},\ldots,B_{k}$ and the corresponding instances $\Lambda_{1}(B_{1}),\ldots,\Lambda_{k}(B_{k})$ in the following way.

Since $f$ is bounded by some polynomial in $w$, and $\Lambda_{i+2}(B_{i+2})\leq\left(1-\varepsilon\right)\Lambda_{i}(B_{i})$ for every $1\leq i\leq k-2$ (as the “unnecessary” instances were deleted in the process of updating), it follows that the number of instances are bounded by $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-1}\log w\right)$. Hence, the number of times any instance of $\Lambda$ is invoked is at most $O\text{\negmedspace}\left(\tfrac{1}{\mathbb{{\cal\varepsilon}}}\log w\right)\cdot m$, where $m$ is the length of the entire stream, which we assumed to be bounded by $2w$. Since we set the failure probability to be $\frac{\mathbb{{\cal\varepsilon}}\mathbb{{\cal\delta}}}{2w\log w}$ then by union bound the probability that any invocation of any instance of $\Lambda$ fails is $\mathbb{{\cal\delta}}$, i.e., with probability $1-\mathbb{{\cal\delta}}$ every instance of $\Lambda$ succeeds every time it is invoked. Thus, from now on we assume that every instance of $\Lambda$ succeeds every time, i.e., it $\left(1+\mathbb{{\cal\varepsilon}}\right)C$-approximates $f$ on the corresponding bucket whenever it is invoked.

Now, let us explain how to achieve $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-1}\log w\cdot\left(s\left(\mathbb{{\cal\varepsilon}},\frac{\mathbb{{\cal\varepsilon}}\mathbb{{\cal\delta}}}{2w\log w}\right)+\log w\right)\right)$ space complexity. We can directly update the instances $\Lambda_{1},\ldots,\Lambda_{k}$, without storing the buckets $B_{1},\ldots,B_{k}$ explicitly, hence we only need to maintain the storage that algorithm $\Lambda$ requires. Additional to the space required by instances $\Lambda_{1},\ldots,\Lambda_{k}$, we need to store a counter $c_{i}$ for every instance $\Lambda_{i}$, indicating its initialization time (initialized to $c_{i}=1$ and incremented each time a new item arrives), such that we can perform the last step of the algorithm, by comparing the counter of bucket $B_{2}$ to the number $w$ (which is the size of the active window $W$). This way, for each bucket $B_{i}$ we store $s\left(\mathbb{{\cal\varepsilon}},\frac{\mathbb{{\cal\varepsilon}}\mathbb{{\cal\delta}}}{2w\log w}\right)+\log w$ bits. As we have seen previously, the number of instances of $\Lambda$ are bounded by $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-1}\log w\right)$. Therefore, the total number of bits used by the algorithm is $O\text{\negmedspace}\left(\mathbb{{\cal\varepsilon}}^{-1}\log w\cdot\left(s\left(\mathbb{{\cal\varepsilon}},\frac{\mathbb{{\cal\varepsilon}}\mathbb{{\cal\delta}}}{2w\log w}\right)+\log w\right)\right)$, as claimed.

For the approximation ratio denote by $\tilde{\Lambda}$ the output of the algorithm, and note that either $\tilde{\Lambda}=\Lambda_{1}(B_{1})$ in the case $B_{1}=W$, or $\tilde{\Lambda}=dcC\frac{\left(1+\mathbb{{\cal\varepsilon}}\right)}{\left(1-\mathbb{{\cal\varepsilon}}\right)^{2}}\cdot\Lambda_{2}(B_{2})$ otherwise. If $B_{1}=W$ then $\tilde{\Lambda}=\Lambda(B_{1})$ is obviously $\left(1+\mathbb{{\cal\varepsilon}}\right)C$-approximates $f$ on $B_{1}=W$. Otherwise $B_{1}\supsetneq W\supsetneq B_{2}$, which means that at some earlier point in time, denoted by $t^{*}$, the algorithm had deleted some buckets between buckets $B_{1}$ and $B_{2}$ to make them adjacent (for the first time). For $i\in\left\{1,2\right\}$ denote by $B_{i}^{\prime}$ the bucket $B_{i}$ at the time $t^{*}$. Let $D$ be the suffix of the stream starting at time $t^{*}$, and observe that $B_{1}=B_{1}^{\prime}D$ and $B_{2}=B_{2}^{\prime}D$. At time $t^{*}$ we had $\left(1-\mathbb{{\cal\varepsilon}}\right)\Lambda(B_{1}^{\prime})<\Lambda(B_{2}^{\prime})$, which implies

[TABLE]

namely $\frac{\left(1-\mathbb{{\cal\varepsilon}}\right)}{\left(1+\mathbb{{\cal\varepsilon}}\right)C}f(B_{1}^{\prime})\leq f(B_{2}^{\prime})$. Note that we used here the formulation of Remark 1.6. Since $f$ is $\left(c,d\right)$-almost-smooth, at the end of the stream we have $\frac{1}{d}\cdot\frac{\left(1-\mathbb{{\cal\varepsilon}}\right)}{\left(1+\mathbb{{\cal\varepsilon}}\right)C}f(B_{1})\leq f(B_{2})$. Now, by monotonicity $\frac{1}{c}\cdot f(B_{2})\leq f\left(W\right)\leq c\cdot f(B_{1})$, and altogether

[TABLE]

Since $\frac{\left(1+\mathbb{{\cal\varepsilon}}\right)^{2}}{\left(1-\mathbb{{\cal\varepsilon}}\right)^{2}}\leq 1+20\mathbb{{\cal\varepsilon}}$ for $\mathbb{{\cal\varepsilon}}\leq\frac{1}{2}$, we conclude that at the end of the stream the output of the algorithm $\tilde{\Lambda}=dcC\frac{\left(1+\mathbb{{\cal\varepsilon}}\right)}{\left(1-\mathbb{{\cal\varepsilon}}\right)^{2}}\cdot\Lambda(B_{2})$ approximates $f(W)$ as claimed. ∎