Near-Duplicate Text Alignment under Weighted Jaccard Similarity

TL;DR

This paper introduces MONO, a novel weighted Jaccard similarity approach for near-duplicate text alignment that guarantees accuracy, is optimal within its framework, and significantly outperforms existing methods in efficiency and scalability.

Contribution

MONO is the first method to support weighted Jaccard similarity with optimality guarantees using consistent weighted sampling in a hash-based framework.

Findings

MONO reduces index construction time by up to 26x.

It decreases index size by up to 30%.

It improves query latency by up to 3x.

Abstract

Near-duplicate text alignment is the task of identifying, among the texts in a corpus, all the subsequences (substrings) that are similar to a given query. Traditional approaches rely on seeding-extension-filtering heuristics, which lack accuracy guarantees and require many hard-to-tune parameters. Recent methods leverage min-hash techniques under a hash-based framework: group subsequences by their min-hash, and for any query, find all sketches similar to the query's sketch. These methods guarantee to report all subsequences whose estimated unweighted Jaccard similarity with the query exceeds a user-provided threshold and are efficient. However, they fail to account for token importance or frequency, which limits their use in real scenarios where tokens carry weights, such as TF-IDF. To address this, we propose MONO, an approach that supports weighted Jaccard similarity using consistent weighted sampling. MONO achieves optimality within the hash-based framework. For example, when token weights are proportional to frequencies, MONO generates O(n + n log f) groups in expectation for a text of length n, where f is the maximum token frequency. Each group takes O(1) space and represents a few subsequences sharing the same sampling. We prove this bound is tight: any algorithm must produce Omega(n + n log f) groups in expectation in the worst case. Experiments show that MONO outperforms the state of the art by up to 26x in index construction time, reduces index size by up to 30 percent, and improves query latency by up to 3x, while scaling well.

Tables

Table 1. Table 1. A snippet of TF and IDF weights we support. Here N = | D | N=|\textnormal{{D}}| is the number of texts in the corpus D and N t = | { S ∈ D ∣ t ∈ S } | N_{t}=|\{\textnormal{S}\in\textnormal{{D}}\mid t\in\textnormal{S}\}| is the number of texts in the corpus containing t t . N N is a global constant while N t N_{t} is a constant local to the token t t .

$\mathrm{𝗍𝖿}$ weight functions		$\mathrm{𝗂𝖽𝖿}$ weight functions
binary:	$\text{1}\left\{f(t,\text{T})>0\right\}$	unary:	1
raw count:	$f(t,\text{T})$	standard:	$\log \frac{N}{N_t}$
logarithmic:	$\log \left(f(t,\text{T})+1\right)$	smooth:	$\log \left(\frac{N+N_t}{N_t}\right)+1$
squared:	$f{(t,\text{T})}^2$	probabilistic:	$\log \frac{N-N_t}{N_t}$

Equations

$${\text{J}}_{\text{T},\text{S}}=\frac{{\sum }_{t\in \text{T}\cup \text{S}}\min (f(t,\text{T}),f(t,\text{S}))}{{\sum }_{t\in \text{T}\cup \text{S}}\max (f(t,\text{T}),f(t,\text{S}))}.$$

$$\text{h}(\text{T})=\min \{\text{h}(t,x)\mid t\in \text{T},1\le x\le f(t,\text{T})\}.$$

$$\mathbf{Pr}(\text{h}(\text{T})=\text{h}(\text{S}))={\text{J}}_{\text{T},\text{S}}.$$

$${\hat{\text{J}}}_{\text{T},\text{S}}=\frac{1}{k}\sum _{i=1}^{k}1\{{\text{h}}_i(\text{T})={\text{h}}_i(\text{S})\}$$

$$\left([a_x,b_x]\times [c_x,d_x]\right)\cap \left([a_y,b_y]\times [c_y,d_y]\right)=\varphi .$$

$$\{(i,j)\mid 1\le i\le j\le |\text{T}|\}\subseteq {\cup }_{x=1}^l\left([a_x,b_x]\times [c_x,d_x]\right).$$

$$\mathsf{H}(\text{T}[i,j],\text{h})=\{\text{h}(t,x)\mid t\in \text{T}[i,j],1\le x\le f(t,\text{T}[i,j])\}.$$

$$\text{h}(\text{T}[i,j])=\min \mathsf{H}(\text{T}[i,j],\text{h}).$$

$${\text{J}}_{\text{T},\text{S}}^w=\frac{{\sum }_{t\in \text{T}\cup \text{S}}\min (w(t,\text{T}),w(t,\text{S}))}{{\sum }_{t\in \text{T}\cup \text{S}}\max (w(t,\text{T}),w(t,\text{S}))}.$$

$$\text{h}(\text{T},w)=\min \{\text{h}(t,w(t,\text{T}))\mid t\in \text{T}\}.$$

$${\hat{\text{J}}}_{\text{T},\text{S}}^w=\frac{1}{k}\sum _{i=1}^{k}1\{{\text{h}}_i(\text{T},w)={\text{h}}_i(\text{S},w)\}.$$

$$\mathsf{H}(\text{T}[i,j],\text{h})=\{\text{h}(t,x)\mid t\in \text{T}[i,j],1\le x\le f(t,\text{T}[i,j])\}.$$

$$\text{h}(\text{T}[i,j])=\min \mathsf{H}(\text{T}[i,j],\text{h}).$$

$$\small r_{k}\doteq\env@cases\left[\textnormal{{S}}[k].x+1,\,b]\times[c,\,\textnormal{{S}}[k+1].y-1\right],&k=i,\\ \left[\textnormal{{S}}[k].x+1,\,b]\times[\textnormal{{S}}[k].y,\,\textnormal{{S}}[k+1].y-1\right],&k\in[i+1,j-1].\right.$$

$$r_i\cup r_{i+1}\cup \cdots \cup r_{j-1}=\mathsf{rec}(b,c)\setminus \mathsf{rec}(\text{S}).$$

$$\mathcal{P}(b,c)=\{W_k\doteq ⟨T,h,v,a_k,b_k,c_k,d_k⟩|k\in [i,j-1],r_k\ne \varnothing \}.$$

$$\begin{array}{rl}\mathbb{E}[|S|]& =\mathbb{E}[\sum _{i=1}^m(n-x_i+1)]=\sum _{i=1}^n(n-i+1)\frac{1}{i}\\ & =(n+1)\sum _{i=1}^n\frac{1}{i}-n\ge (n+1)\ln n-n=\Omega (n\log n).\end{array}$$

Full text

In this paper, we address this limitation by supporting weighted Jaccard similarity using consistent weighted sampling. We design an algorithm MonoActive to group all subsequences in a text by their consistent weighted sampling. We analyze the complexity of our algorithm. For raw count term frequency (where a token’s weight is proportional to its frequency in the text), we prove MonoActive generates $O(n+n\log f)$ groups (each group occupies $O(1)$ space) in expectation for a text with $n$ tokens, where $f$ is the maximum token frequency in the text. We further prove that our algorithm is optimal, meaning that any algorithm must generate $\Omega(n+n\log f)$ groups in expectation. Extensive experiments show that MonoActive outperforms the state-of-the-art by up to 4.7$\times$ in speed and reduces index size by up to 30%, with superior scalability.

**PVLDB Reference Format:

** PVLDB, 14(1): XXX-XXX, 2020.

doi:XX.XX/XXX.XX ††This work is licensed under the Creative Commons BY-NC-ND 4.0 International License. Visit https://creativecommons.org/licenses/by-nc-nd/4.0/ to view a copy of this license. For any use beyond those covered by this license, obtain permission by emailing info@vldb.org. Copyright is held by the owner/author(s). Publication rights licensed to the VLDB Endowment.

Proceedings of the VLDB Endowment, Vol. 14, No. 1 ISSN 2150-8097.

doi:XX.XX/XXX.XX

**PVLDB Artifact Availability:

**The source code, data, and/or other artifacts have been made available at %leave␣empty␣if␣no␣availability␣url␣should␣be␣setURL_TO_YOUR_ARTIFACTS.

1. Introduction

This paper studies the near-duplicate text alignment problem (DBLP:conf/clef/PotthastGHKMOTBGRS12, ; DBLP:conf/clef/PotthastHBBTRS14, ; allign, ; txtalign, ; DBLP:journals/pacmmod/PengZD24, ; llmalign, ). Given a collection of data texts, the task takes a short query text and returns all subsequences (i.e., substrings) of the data texts that are similar to the query. Near-duplicate text alignment has become increasingly important in the era of large language models (LLMs), with key applications in test set leakage (also known as data contamination) detection (DBLP:conf/acl/Magar022, ), training data deduplication (betterlm, ), and memorization analysis (quantifymemo, ; DBLP:conf/emnlp/VuHHS23, ). Beyond LLMs, this problem also plays a crucial role in domains such as bioinformatics (ALTSCHUL1990403, ), log analysis (DBLP:conf/uss/DingZ0M23, ), and plagiarism detection (DBLP:conf/clef/PotthastHGTKRSS13, ; DBLP:conf/clef/PotthastBESR10, ).

Due to the high computational cost of near-duplicate text alignment, previous methods often adopt the seeding–extension–filtering heuristic (DBLP:conf/clef/PotthastBESR10, ; DBLP:conf/usenix/Manber94, ; DBLP:journals/cn/BroderGMZ97, ; DBLP:conf/sigmod/SchleimerWA03, ; DBLP:conf/www/HamidBCH09, ; DBLP:conf/sigmod/BrinDG95, ; DBLP:conf/sigir/SeoC08, ; DBLP:conf/www/KimCT09, ; DBLP:books/aw/Baeza-YatesR99, ; DBLP:journals/jasis/HoadZ03, ; DBLP:conf/sigmod/WangXQWZI16, ). However, these methods lack accuracy guarantees and often involve many hard-to-tune hyperparameters (DBLP:journals/csur/FoltynekMG20, ). To address these limitations, recent studies have proposed to use min-hash techniques (minhash, ; DBLP:conf/nips/0001OZ12, ) for near-duplicate text alignment. These approaches guarantee to retrieve all subsequences whose estimated Jaccard similarities with the query exceed a user-defined threshold (allign, ; txtalign, ; llmalign, ; DBLP:journals/pacmmod/PengZD24, ). However, a key limitation is that they only support the unweighted Jaccard similarity, which treats all tokens equally—regardless of their frequency or importance (note depending on the tokenizer, a token can be a word (whitespace_splitted_tokens, ), a $q$-gram (n-gram, ), a byte-pair-encoding (bpe, ), etc.).

To highlight the issue of unweighted Jaccard similarity, consider $\textnormal{Q}=\text{{AAAAAATTTTTTCCCCCC}}$, $\textnormal{T}=\text{{AAAAAATTTTTGCCCCCC}},$ and $\textnormal{S}=\text{{AATTGCC}.}$ Intuitively, Q is much more similar to T than to S. Yet, under unweighted Jaccard similarity (with each token as a 2-gram), both Q and T, as well as Q and S yield the same similarity score: $4/7$. In contrast, weighted Jaccard similarity correctly reflects the difference: when each token in a text is weighted by its frequency in the text, Q and T have a similarity of $0.8$, while Q and S only score $0.2$. Moreover, unweighted Jaccard similarity fails to distinguish between stop words and content words. For example, consider $\textnormal{Q}=\text{``{I read about Einstein in a book}''}$, $\textnormal{T}=\text{``{I studied Einstein through a book}''}$, $\textnormal{S}=\text{``{I roamed about in a castle}''}.$

Semantically, Q is clearly closer to T than to S. However, the unweighted Jaccard similarity is the same for both: $4/9$ (with each token as a word). If a meaningful token weighting scheme such as TF-IDF (singhal2001modern, ) is applied, then stop words, e.g., I, in, a, about, through, could have near-zero weight and the other words may have near-one weight, and thereby drawing clear distinctions. Under this scheme, the weighted Jaccard similarity between Q and T is around $0.5$, while that between Q and S drops to nearly zero.

Existing Methods. Existing methods propose to group, as the indexing process, the subsequences in each data text based on their min-hash values. This way, when a query arrives, they use the index to identify all the min-hash sketches that are similar to the query’s min-hash sketch and then return the corresponding subsequences as the results efficiently (allign, ; llmalign, ; DBLP:journals/pacmmod/PengZD24, ). A key observation made by these methods is that the nearby subsequences of a text tend to share the same min-hash (this is because appending a token to a subsequence most likely would not change the min-hash of the subsequence). Given a text with $n$ tokens, they group the $O(n^{2})$ subsequences in the text into $O(n)$ groups while represent each group with a tuple of $O(1)$ space.

Limitations of Existing Methods. In many real-world scenarios, tokens are associated with weights, such as TF-IDF (term frequency-inverse document frequency) weights (DBLP:conf/hicss/PasiB23, ). Estimating weighted Jaccard similarity requires consistent weighted sampling (CWS) (DBLP:conf/icdm/Ioffe10, ), as standard min-hash(minhash, ) applies only to the unweighted case. Existing methods do not support CWS or weighted Jaccard similarity. The only exception is AllAlign (allign, ) which supports multi-set Jaccard, a special case of weighted Jaccard where each token’s weight is its frequency in the text. AllAlign is a greedy algorithm which groups the subsequences by their “multi-set min-hash”. However, it lacks a formal complexity analysis, including an upper bound on the number of groups generated and its time complexity. Due to its recursive nature, analyzing its complexity is particularly difficult.

Our Approach. In this paper, we propose an efficient algorithm MonoActive to group the subsequences of a text by their CWS or multi-set min-hash. We rigorously analyze the complexity for MonoActive. Specifically, for multi-set Jaccard similarity, we prove that MonoActive produces $O(n+n\log f)$ groups for a text with $n$ tokens in expectation, where $f$ is the maximum token frequency in the text. Each group occupies only $O(1)$ space. Furthermore, we prove that MonoActive is worst-case optimal by presenting a lower bound analysis on the number of groups. That is, there exists text instances for which any algorithm under the hash-based framework must generate at least $\Omega(n+n\log f)$ groups in expectation. We further develop an optimization that improves the time complexity of our algorithm from $O(nf\log n)$ to $O(n\log n+n\log n\log f)$ and space complexity from $O(nf)$ to $O(n+n\log f)$. Finally, we show our algorithm can be generalized to group the subsequences in a text based on their consistent weighted samplings, as long as the weight of a token in a text is monotonically increasing with its frequency in the text and is independent of other properties of the text. For example, for logarithmic term frequency (where the weight of a token $t$ with frequency $f_{t}$ is proportional to $\log(f_{t}+1)$), MonoActive generates $O(n+n\log\log f)$ groups in expectation.

In summary, we make the following contributions in this paper.

• •

We develop MonoActive, the first algorithm for near-duplicate text alignment under weighted Jaccard similarity.

• •

We rigorously analyze the complexity of MonoActive and design optimizations to reduce its time and space complexities.

• •

For the special case of multi-set Jaccard similarity, we prove MonoActive is optimal, while the greedy algorithm AllAlign lacks theoretical guarantees.

• •

For multi-set Jaccard similarity, experimental results show that MonoActive outperforms AllAlign by up to $26\times$ in index construction time, reduces index size by up to $30\%$, and improves query latency by up to $3\times$. The performance gain increases as the text length $n$ grows, exhibiting superior scalability.

The rest of the paper is organized as follows. We introduce preliminary knowledge in Section 2 and the framework in Section 3. Section 4 presents our grouping algorithm and Section 5 extends it to weighted Jaccard similarity. Section 6 show experiment results, Section 7 reviews related work, and Section 8 concludes the paper.

2. Preliminaries

We first consider a special case where the tokens are weighted by their frequencies in the text (i.e., term frequency). In this case, the weighted Jaccard similarity degrades to multi-set Jaccard similarity.

2.1. Multi-Set Jaccard Similarity

We first define notations that will be used in the paper. A text T is a sequence of tokens, where $\textnormal{T}[i]$ is the $i$-th token in the text. We define $f(t,\textnormal{T})$ as the frequency of a token $t$ in T, i.e., the number of occurrences of $t$ in T. A text T can be uniquely mapped to a set which exclusively contains all the distinct tokens of T as elements. For ease of presentation, we refer to T both as a text and a set. We use $|\textnormal{T}|$ to denote the length of the text T. Furthermore, we use $\textnormal{T}[i,j]$ to represent the subsequence of T from the $i$-th token to the $j$-th token (inclusive), where $1\leq i\leq j\leq|\textnormal{T}|$. Note all the definitions naturally extend to subsequences. Thus $\textnormal{T}[i,j]$ is both a subsequence and a token set. Given two texts T and S, their multi-set Jaccard similarity is

[TABLE]

Example 0.

Consider two texts $\textnormal{T}=ABBC$ and $\textnormal{S}=BCD$ where each letter denotes a token. The union $\textnormal{T}\cup\textnormal{S}=\{A,B,C,D\}$. The token frequencies are $f(A,\textnormal{T})=1$, $f(B,\textnormal{T})=2$, $f(C,\textnormal{T})=1$, $f(D,\textnormal{T})=0$, $f(A,\textnormal{S})=0$, $f(B,\textnormal{S})=1$, $f(C,\textnormal{S})=1$, and $f(D,\textnormal{S})=1$. Therefore, their multi-set Jaccard similarity is $\texttt{J}_{\textnormal{T},\textnormal{S}}=\frac{2}{5}$.

2.2. Min-Hash for Multi-Set Jaccard Similarity

The multi-set Jaccard similarity of two texts can be efficiently and accurately estimated by their min-hash sketches. Specifically, let $\textit{h}(t,x)$ be a random universal hash function that takes a token $t$ and a positive integer $x$ as input and outputs a non-negative integer hash value. The (multi-set) min-hash of a text T is

[TABLE]

Example 0.

Consider the text T and the hash function h from the running example in the caption of Fig. 1, we have $\textit{h}(\textnormal{T})=\textit{h}(B,4)=1$.

Given a random universal hash function h and two texts T and S, the probability that they share the same min-hash is equivalent to their multi-set Jaccard similarity. Formally, we have

[TABLE]

This is because there are $\Sigma_{t\in\textnormal{T}\cup\textnormal{S}}\max(f(t,\textnormal{T}),f(t,\textnormal{S}))$ unique hash values and $\Sigma_{t\in\textnormal{T}\cup\textnormal{S}}\min(f(t,\textnormal{T}),f(t,\textnormal{S}))$ common hash values in the two texts T and S. T and S share the same min-hash if and only if the smallest hash value of all unique hash values is among their common hash values. The probability of the latter is exactly $\texttt{J}_{\textnormal{T},\textnormal{S}}$.

Min-Hash Sketch. With $k$ independent random universal hash functions $\textit{h}_{1},\cdots,\textit{h}_{k}$, the min-hash sketch of a text T consists of $k$ min-hash values $\textit{h}_{1}(\textnormal{T}),\cdots,\textit{h}_{k}(\textnormal{T})$. The multi-set Jaccard similarity of two texts T and S can be unbiasedly estimated by

[TABLE]

where $\mathbf{1}$ is an indicator function (minhash, ).

Implementation Details. The hash function $\textit{h}(t,x)$ can be drawn from a family $\mathcal{H}$ of universal hash functions $\textit{h}(t,x)=(a_{1}t+a_{2}x+b)\mod p$ where $p$ is a large prime and $a_{1},a_{2},b$ are randomly chosen integers module $p$ with $a_{1}\neq 0,a_{2}\neq 0$. We assume there is no hash collision under the universal hash function throughout the paper.

2.3. Near-Duplicate Text Alignment

Near-duplicate text alignment is formally defined as below.

Definition 0.

Given a collection of texts D, a query Q, and a similarity threshold $\theta\in[0,1]$, the near-duplicate text alignment problem returns all the subsequences $\textnormal{T}[i,j]$, where $\textnormal{T}\in\textnormal{{D}}$ and $1\leq i\leq j\leq|\textnormal{T}|$, such that $\hat{\texttt{J}}_{\textnormal{Q},\textnormal{T}[i,j]}\geq\theta$.

Example 0.

Consider a collection of two texts $\textnormal{{D}}=\{\textnormal{T},\textnormal{S}\}$, where $\textnormal{T}=ABBCDE$ and $\textnormal{S}=BCCDEF$, and a query $\textnormal{Q}=ACE$. Let the similarity threshold be $\theta=0.5$. Suppose the similarity estimation is accurate. The near-duplicate text alignment problem returns three subsequences $\textnormal{T}[1,6],\textnormal{T}[4,6],$ and $\textnormal{S}[3,5]$. Note that $\textnormal{S}[2,5]=CCDE$ is not a result as $\texttt{J}_{\textnormal{Q},\textnormal{S}[2,5]}=\frac{2}{5}<\theta$.

3. The Framework

To improve the query performance of near-duplicate text alignment, it is natural to index the min-hash sketches of all subsequences within each text in D. This way, when a query arrives, one shall use the index to identify all the min-hash sketches that are similar to the query’s sketch and then return the corresponding subsequences as the results efficiently.

The main challenge of indexing the min-hash sketches is the cost – the number of min-hash sketches in a text grows quadratically with the length of the text (as there are $O(n^{2})$ subsequences in a text with $n$ tokens). To reduce the index size, we have a key observation: the min-hash of adjacent subsequences of a text T, such as $\textnormal{T}[i,j]$ and $\textnormal{T}[i,j+1]$, tend to be the same. Thus, the min-hash of adjacent subsequences can be grouped and compactly represented. For this purpose, we define the compact window.

3.1. Compact Window and Partition

Below, we formally define the compact window (allign, ), a structure used to represent the groups of subsequences where the subsequences in each group share the same min-hash.

Definition 0 (Compact Window (allign, )).

Given a text T and a random universal hash function h, a compact window in T is a tuple $\langle\textnormal{T},\textit{h},v,a,b,c,d\rangle$ satisfying that

• •

$1\leq a\leq b\leq c\leq d\leq|\textnormal{T}|$* and*

• •

$\textit{h}(\textnormal{T}[i,j])=v$* for every integers $i\in[a,b]$ and $j\in[c,d]$.*

Example 0.

Consider the running example in Figure 1. Figure 1(a) shows the min-hash of all the subsequences of the text T. Specifically, the integer in the cell $(i,j)$ is the min-hash of the subsequence $\textnormal{T}[i,j]$. For example, the min-hash of $\textnormal{T}[1,10]$ is shown in the cell $(1,10)$, which is $1$. As one can verify, both $\langle\textnormal{T},\textit{h},1,1,2,8,10\rangle$ and $\langle\textnormal{T},\textit{h},2,4,5,5,10\rangle$ (the highlighted rectangle) are compact windows.

Hereinafter, for two integers $p,q$, we abuse $[p,q]$ to denote the integer set $\{p,p+1,\cdots,q\}$. Let $[a,b]\times[c,d]$ be the set of all integer pairs $(i,j)$ where $i\in[a,b]$ and $j\in[c,d]$. A compact window $\langle\textnormal{T},\textit{h},v,a,b,c,d\rangle$ represents all the subsequences $\textnormal{T}[i,j]$ where $(i,j)\in[a,b]\times[c,d]$. We aim to generate a set of compact windows such that each subsequence in T is represented by one and only one compact window in the set (i.e., the set of compact windows is a lossless compression of the min-hash of all subsequences in a text). Formally, we define the concept of partition as below.

Definition 0 (Partition).

Given a text T and a hash function h, a partition $\mathcal{P}(\textnormal{T},\textit{h})$ is a set of compact windows $\{W_{1},W_{2},\cdots,W_{l}\}$, where $l=|\mathcal{P}(\textnormal{T},\textit{h})|$ and $W_{x}=\langle\textnormal{T},\textit{h},v_{x},a_{x},b_{x},c_{x},d_{x}\rangle$, that satisfies

• •

Disjointness: For any two compact windows $W_{x}$ and $W_{y}$ in $\mathcal{P}(\textnormal{T},\textit{h})$,

[TABLE]

• •

Coverage: The union of all compact windows in $\mathcal{P}(\textnormal{T},\textit{h})$ covers all the subsequences in T, i.e.,

[TABLE]

Example 0.

Consider the running example in Figure 1. Figures 1(b) and 1(c) show two example partitions with 13 and 17 compact windows respectively, as outlined by the colors. Each colored rectangle $[a,b]\times[c,d]$ in the figures corresponds to a compact window $\langle\textnormal{T},\textit{h},v,a,b,c,d\rangle$. All the subsequences in this rectangle share the same min-hash $v$.

3.2. Indexing and Query Processing

Algorithm 1 shows the pseudo-code of indexing in our framework. It takes a collection D of data texts and an integer $k$ as input and produces $k$ inverted indexes of compact windows. For this purpose, it first randomly selects $k$ independent hash functions $\textit{h}_{1},\textit{h}_{2},\cdots,\textit{h}_{k}$. Then, for each text T in D, and each hash function $\textit{h}_{i}$, it generates a partition $\mathcal{P}(\textnormal{T},\textit{h}_{i})$. The partition generation algorithm will be described in the next section. For each compact window $\langle\textnormal{T},h_{i},v,a,b,c,d\rangle$ in the partition, it is appended to the inverted list $I_{i}[v]$. Finally, $k$ inverted indexes $I_{1},\cdots,I_{k}$ are returned.

1

1

1

1

1

1

Algorithm 2 presents the pseudo-code of query processing in our framework. The input consists of a query text Q, a multi-set Jaccard similarity threshold $\theta$, the integer $k$, the same $k$ random hash functions $\textit{h}_{1},\textit{h}_{2},\ldots,\textit{h}_{k}$ used during indexing, and the $k$ inverted indexes $I_{1},\cdots,I_{k}$. It first calculates the $k$ min-hash $v_{1},\cdots,v_{k}$ of Q and then retrieves the $k$ corresponding inverted lists $I_{1}[v_{1}],\cdots,I_{k}[v_{k}]$ from the $k$ inverted indexes. The near-duplicate subsequences can be identified by a simple plane sweep algorithm over the compact windows in the $k$ inverted lists. Specifically, the plane sweep algorithm produces all the cells $(x,y)$ where there are at least $\lceil k\theta\rceil$ compact windows $\langle\textnormal{T},\textit{h},v,a,b,c,d\rangle$ in the $k$ inverted lists satisfying $(x,y)\in[a,b]\times[c,d]$. This is because the estimated multi-set Jaccard similarity $\hat{\texttt{J}}_{\textnormal{Q},\textnormal{T}[x,y]}\geq\theta$. The simple plane sweep algorithm is detailed in (llmalign, ), while an optimized version is presented in (DBLP:journals/pacmmod/PengZD24, ). Due to space constraints, we omit the details in this paper.

4. Partition Generation

Given a text T and a hash function h, there exist many possible partitions. In our framework, both the indexing and query costs scale with the partition size. This raises a natural question: how can we generate a small partition, and what is the smallest possible partition? In this section, we study the partition generation problem.

Definition 0 (Partition Generation).

Given a text T and a random universal hash function h, the partition generation problem is to generate a partition $\mathcal{P}(\textnormal{T},\textit{h})$.

4.1. Monotonic Partitioning

In this section, we present our partition generation algorithm. To this end, we first define the hash value set of a subsequence, which contains all the hash values of the subsequence.

Definition 0 (hash value set).

Given a random universal hash function h, the hash value set of a subsequence $\textnormal{T}[i,j]$ is

[TABLE]

Based on Equation 1, the min-hash of a subsequence is the smallest hash value in the hash value set of the subsequence, i.e.,

[TABLE]

We omit the hash function h in the hash value set for brevity.

Example 0.

Consider the T and h from the running example. Figures 2(a) and 2(b) show the hash value sets $\mathsf{H}(\textnormal{T}[3,6])$ and $\mathsf{H}(\textnormal{T})$. In the figures, each integer in the highlighted cell $(t,x)$ represents the hash value $\textit{h}(t,x)$ in the corresponding hash value set. Specifically, we have $\mathsf{H}(\textnormal{T}[3,6])=\{2,5,8,9\}$. Thus $\textit{h}(\textnormal{T}[3,6])=\min\mathsf{H}(\textnormal{T}[3,6])=2$.

The min-hash of any subsequence of a text T must belong to the hash value set $\mathsf{H}(\textnormal{T})$ of T, as formalized below.

Lemma 0.

$\textit{h}(\textnormal{T}[i,j])\in\mathsf{H}(\textnormal{T})$* for any $1\leq i\leq j\leq|\textnormal{T}|$.*

Proof.

Based on Definition 2, $\mathsf{H}(\textnormal{T}[i,j])\subseteq\mathsf{H}(\textnormal{T})$. Based on Equation 3, \textit{h}(\textnormal{T}[i,j])$$=$$\min\mathsf{H}(\textnormal{T}[i,j]). Thus $\textit{h}(\textnormal{T}[i,j])\in\mathsf{H}(\textnormal{T})$. ∎

Based on Lemma 4, the min-hash of any subsequence of T belongs to $\mathsf{H}(\textnormal{T})$. Thus, for each hash value $v=\textit{h}(t,x)\in\mathsf{H}(\textnormal{T})$, we propose to generate a few disjoint compact windows to represent all the subsequences whose min-hash is $v$. The compact windows generated along the way must form a partition.

Specifically, we observe that if the min-hash of a subsequence $\textnormal{T}[i,j]$ comes from a token $t$ and a frequency $x$ such that $\textit{h}(t,x)=\min\mathsf{H}(\textnormal{T}[i,j])$, then $x\leq f(t,\textnormal{T}[i,j])$, and thus there must exist a subsequence $\textnormal{T}[p,q]$ of $\textnormal{T}[i,j]$ (i.e., $i\leq p\leq q\leq j$) such that $\textnormal{T}[p,q]$ starts and ends with token $t$ and has exactly $x$ occurrences of $t$; otherwise $\textit{h}(t,x)\not\in\mathsf{H}(\textnormal{T}[i,j])$ and cannot be the min-hash of $\textnormal{T}[i,j]$ based on Lemma 4. Next, we formalize our observation.

Definition 0 (Key).

Given a text T, a key $s$ is a pair of integers $(p,q)$ with $1\leq p\leq q\leq|\textnormal{T}|$ such that $\textnormal{T}[p]=\textnormal{T}[q]$. We refer to $(p,q)$ as the coordinates of $s$, define $s.x=p$ and $s.y=q$. The hash value of $s$ is $\textit{h}(\textnormal{T}[q],f(\textnormal{T}[q],\textnormal{T}[p,q]))$, abbreviated as $\textit{h}(\textnormal{T},p,q)$.

Definition 0 (Key Set).

The key set of a subsequence $\textnormal{T}[i,j]$, denoted as $\textnormal{{K}}(\textnormal{T}[i,j])$ is $\{(p,q)\mid[p,q]\subseteq[i,j]\text{ and }(p,q)\text{ is a key }\}$.

Example 0.

Consider the running example in Figure 1. Figure 1(d) shows all the keys in $\textnormal{{K}}(\textnormal{T})$ and their hash values, where the integer in cell $(p,q)$ represents the hash value of key $(p,q)\in\textnormal{{K}}(\textnormal{T})$ (in contrast, Figure 1(a) shows the min-hash of the subsequence $\textnormal{T}[p,q]$ in cell $(p,q)$). In total, there are 23 keys in $\textnormal{{K}}(\textnormal{T})$. The $x$-value and $y$-value of the key $(1,3)$ are respectively 1 and 3. The hash value of $(1,3)$ is $\textit{h}(\textnormal{T},1,3)=\textit{h}(A,f(A,\textnormal{T}[1,3]))=\textit{h}(A,2)=5$.

The min-hash of a subsequence is exactly the smallest hash value of all its keys, as formalized below.

Lemma 0.

$\textit{h}(\textnormal{T}[i,j])=\min\{\textit{h}(p,q,\textnormal{T})\mid(p,q)\in\textnormal{{{K}}}(\textnormal{T}[i,j])\}$.

Proof.

Based on Definitions 2, 5, and 6, we have $\mathsf{H}(\textnormal{T}[i,j])=\{\textit{h}(p,q,\textnormal{T})\mid(p,q)\in\textnormal{{K}}(\textnormal{T}[i,j])\}$. Based on Equation 1, we have $\textit{h}(\textnormal{T}[i,j])=\min\{\textit{h}(p,q,\textnormal{T})\mid(p,q)\in\textnormal{{K}}(\textnormal{T}[i,j])\}$. ∎

Example 0.

In Figure 1(d), the key set $\textnormal{{K}}(\textnormal{T}[i,j])$ consists of all keys on the bottom-right of the cell $(i,j)$, i.e., $(p,q)$ with $p\geq i$ and $q\leq j$. For example, $\textnormal{{K}}(\textnormal{T}[1,3])=\{(1,1),(1,3),(2,2),(3,3)\}$. By Lemma 8, the min-hash of $\textnormal{T}[1,3]$ is $\textit{h}(\textnormal{T}[1,3])=\min\{5,2,9,2\}=2$.

We say a subsequence $\textnormal{T}[i,j]$ contains a key $(p,q)$ if and only if $(p,q)\in\textnormal{{K}}(\textnormal{T}[i,j])$. Lemma 10 follows directly from Lemma 8.

Lemma 0.

A subsequence has min-hash $v$ if and only if it contains a key with hash value $v$ and no key with a smaller hash value.

Lemma 10 motivates us to visit all keys in $\textnormal{{K}}(\textnormal{T})$ in ascending order of their hash values (breaking ties arbitrarily). When visiting a key $(p,q)$ with hash value $v$, we identify all subsequences that contain $(p,q)$ but no visited key. The min-hash of all these subsequences must be $v$ based on Lemma 10. We then group them into disjoint compact windows. Next, we characterize these subsequences.

Definition 0 (Rectangle of a key).

Given a key $(p,q)$ in a text T, where $n=|\textnormal{T}|$, its rectangle ${\mathsf{rec}}(p,q)=[1,p]\times[q,n]=\{(i,j)\mid i\in[1,p],j\in[q,n]\}$. For a set L of keys, ${\mathsf{rec}}(\textnormal{{L}})$ is the union of ${\mathsf{rec}}(p,q)$ with $(p,q)\in\textnormal{{L}}$.

Figure 3(a) shows the rectangles of two keys $(p,q)$ (outlined by dashed lines) and $(p^{\prime},q^{\prime})$ (the shaded rectangle). By Definitions 6 and 11, a subsequence $\textnormal{T}[i,j]$ contains a key $(p,q)$ if and only if $(i,j)\in{\mathsf{rec}}(p,q)$, i.e., the rectangle ${\mathsf{rec}}(p,q)$ precisely characterizes all subsequences that contain the key $(p,q)$. To exclude subsequences that contain visited keys, we maintain a “skyline” to track the union of the rectangles of visited keys, as formalized below.

Definition 0 (Dominance).

Consider two keys $(p,q)$ and $(p^{\prime},q^{\prime})$. $(p,q)$ dominates $(p^{\prime},q^{\prime})$ if and only if $[p,q]\subset[p^{\prime},q^{\prime}]$.

Informally, a key dominates all keys located on its top-left side, as illustrated in Figure 3(a), regardless of their hash values. Note that a key does not dominate itself based on the definition. In Example 7, the key $(1,1)$ dominates another key $(1,3)$ as $[1,1]\subset[1,3]$.

Definition 0 (Skyline).

The skyline of a set L of keys, denoted as $\textnormal{{{S}}}(\textnormal{{L}})$, is the subset of keys in L that are not dominated by any key in L:* $\textnormal{{{S}}}(\textnormal{{L}})=\{(p^{\prime},q^{\prime})\in\textnormal{{L}}\mid\nexists\,(p,q)\in\textnormal{{L}}\text{, }(p,q)\text{ dominates }(p^{\prime},q^{\prime})\}.$*

Lemma 0.

For a key set L and its skyline $\textnormal{{S}}(\textnormal{{L}})$, ${\mathsf{rec}}(\textnormal{{L}})={\mathsf{rec}}(\textnormal{{S}}(\textnormal{{L}}))$.

Proof.

By definitions, a key $(p,q)$ dominates another key $(p^{\prime},q^{\prime})$ if and only if ${\mathsf{rec}}(p^{\prime},q^{\prime})\subset{\mathsf{rec}}(p,q)$. Furthermore, by the definition of skyline, for any key $s$ of L not in the skyline $\textnormal{{S}}(\textnormal{{L}})$, there must be another key $s^{\prime}$ in the skyline that dominates $s$. Thus ${\mathsf{rec}}(s)\subset{\mathsf{rec}}(s^{\prime})$. Therefore ${\mathsf{rec}}(\textnormal{{L}})={\mathsf{rec}}(\textnormal{{S}}(\textnormal{{L}}))$. ∎

When visiting a key $(p,q)\in\textnormal{{K}}(\textnormal{T})$ with hash value $v$, let L be the set of all visited keys. Based on the discussion above, all subsequences in ${\mathsf{rec}}(p,q)\setminus{\mathsf{rec}}(\textnormal{{S}}(\textnormal{{L}}))$ must have min-hash $v$. As shown in Figure 3 (the red dot $(b,c)$ is $(p,q)$ and the indented black line is the skyline), these subsequences collectively form a “staircase shape”. We generate one compact window for “each step of the staircase” (red dashed rectangles).

In summary, our partitioning algorithm works as follows. Given a text T, we traverse all keys in $\textnormal{{K}}(\textnormal{T})$ in ascending order of their hash values, maintaining a dynamic skyline of the visited keys. When visiting a key $(p,q)$ with hash value $v$, let L be the set of visited keys. For each key in $\textnormal{{S}}(\textnormal{{L}})$ that is dominated by $(p,q)$, we generate a compact window. We then update the skyline by adding $(p,q)$ if it is not dominated by any key in the skyline, and removing all keys in the skyline that are dominated by $(p,q)$. As a result, the skyline is updated to $\textnormal{{S}}(\textnormal{{L}}\cup\{(p,q)\})$. The following sections elaborate on these details.

Example 0.

Consider the running example. There are 23 keys in T in total. The first 8 of them in the order of hash values are $(2,8)$, $(1,1)$, $(3,3)$, $(5,5)$, $(6,6)$, $(9,9)$, $(10,10)$, and $(2,4)$. As illustrated in Figure 4, we first visit $(2,8)$. The skyline is empty. A compact window $\langle\textnormal{T},\textit{h},1,1,2,8,10\rangle$ is generated and $(2,8)$ is added to the skyline. Then we visit $(1,1)$. A compact window is generated and $(1,1)$ is added to the skyline. Next, we visit $(3,3)$. Notice that two compact windows are generated. Since the key $(2,8)$ in the skyline is dominated by $(3,3)$, it is removed from the skyline, while $(3,3)$ is added. Later we visit $(5,5)$ and one compact window is generated. The process is repeated. When we visit the key $(2,4)$, we find $(2,4)$ is dominated by the key $(3,3)$ on the skyline. Thus no compact window will be generated and the skyline remains the same. In the end, 13 compact windows are generated as shown in Figure 1(b).

4.2. The Monotonic Partitioning Algorithm

Before presenting the pseudo-code of our algorithm, we first discuss how to efficiently find all keys in a skyline that are dominated by a key. This can be achieved by binary search, as formalized next.

Definition 0 (Coordinate Order).

A skyline S is in coordinate order if its keys are ordered lexicographically by their coordinates. We denote $\textnormal{{S}}[i]$ as the $i$-th key in S under this order.

The following lemmas show a skyline is a totally ordered set.

Lemma 0.

Let S be a skyline of any set of keys. For any two keys $(p,q)$ and $(p^{\prime},q^{\prime})$ in S, if $p\leq p^{\prime}$, then $q\leq q^{\prime}$.

Proof.

Suppose that $p\leq p^{\prime}$ and $q>q^{\prime}$. Then $(p,q)$ dominates $(p^{\prime},q^{\prime})$, since $p\leq p^{\prime}$ and $q>q^{\prime}$ implies $[p^{\prime},q^{\prime}]\subset[p,q]$. This contradicts the definition of the skyline, where no key is dominated by another. Therefore, we must have $q\leq q^{\prime}$. ∎

Lemma 0.

Let S be the skyline of a set of keys in coordinate order. Then $\textnormal{{S}}[1].x\leq\cdots\leq\textnormal{{S}}[l].x$ and $\textnormal{{S}}[1].y\leq\cdots\leq\textnormal{{S}}[l].y$ where $l=|\textnormal{{S}}|$.

Proof.

Consider any two consecutive keys $\textnormal{{S}}[i]$ and $\textnormal{{S}}[i+1]$ for $1\leq i<l$. Since the keys in S are sorted lexicographically by their coordinates, we have $\textnormal{{S}}[i].x\leq\textnormal{{S}}[i+1].x$. By Lemma 17, this implies $\textnormal{{S}}[i].y\leq\textnormal{{S}}[i+1].y$. This completes the proof. ∎

4

4

4

4

4

4

4

4

4

4

4

4

4

4

4

4

4

4

4

4

Lemma 19 shows that by a binary search, one can determine if a key is dominated by any key in a skyline under coordinate order.

Lemma 0.

Given a skyline S in coordinate order and a key $(b,c)$, let $j$ be the largest index such that $\textnormal{{S}}[j].y\leq c$. There exists a key in S that dominates $(b,c)$ if and only if $j$ exists and $\textnormal{{S}}[j]$ dominates $(b,c)$.

Proof.

Suppose there exists a key $\textnormal{{S}}[i]$ in S that dominates $(b,c)$, i.e., $b\leq\textnormal{{S}}[i].x$ and $\textnormal{{S}}[i].y\leq c$. Then $j$ exists by the definition of $j$. Since $j$ is the largest index with $\textnormal{{S}}[j].y\leq c$, we have $\textnormal{{S}}[i].y\leq\textnormal{{S}}[j].y$, which by Lemma 18, implies $\textnormal{{S}}[i].x\leq\textnormal{{S}}[j].x$. Thus, $b\leq\textnormal{{S}}[i].x\leq\textnormal{{S}}[j].x$ and $\textnormal{{S}}[j].y\leq c$. As $\textnormal{{S}}[i]$ dominates $(b,c)$, $\textnormal{{S}}[j]$ dominates $(b,c)$. On the other hand, if $j$ exists and $\textnormal{{S}}[j]$ dominates $(b,c)$, then clearly S contains a key (namely $\textnormal{{S}}[j]$) that dominates $(b,c)$. ∎

Algorithm 4 shows the pseudo-code our monotonic partitioning algorithm. It takes a text T and a hash function h as input and produces a partition $\mathcal{P}(\textnormal{T},\textit{h})$. It first generates all the keys in the text using the procedure GenerateKeys (Line LABEL:algo:skyline:1). GenerateKeys (Algorithm 3) first builds an inverted index to keep track of the positions of each distinct token in T (Lines LABEL:algo:genkey:1-LABEL:algo:genkey:3). For each inverted list $(t,A)$ (Line LABEL:algo:genkey:4), it enumerates every pair of positions $A[i]$ and $A[j]$ where $i\leq j$ (Lines LABEL:algo:genkey:5-LABEL:algo:genkey:6). Then $(A[i],A[j])$ must be a key. The key, along with its hash value $h(t,j-i+1)$, is added to the key set K (Line LABEL:algo:genkey:7). Finally, the procedure returns the set K of all keys in T, along with their hash values (Line LABEL:algo:genkey:8).

Once the key set K is generated, Algorithm 4 initializes the skyline with two guard keys $(0,0)$ and $(n+1,n+1)$ in Line LABEL:algo:skyline:2. The guard keys help simplify the algorithm by avoiding a few corner cases. The keys in S will always be kept in coordinate order using a self-balanced binary search tree. After that, we visit the keys in K in ascending order of their hash values; let $(b,c)$ be the key currently being visited and $v$ be its hash value (Line LABEL:algo:skyline:3), denote by L the set of keys that have already been visited. S maintains the skyline on L upon the insertion of $(b,c)$. Specifically, if $(b,c)$ has been dominated by any key in S, then ${\mathsf{rec}}(b,c)\setminus{\mathsf{rec}}(\textnormal{{L}})$ is empty and no subsequence in ${\mathsf{rec}}(b,c)$ would have min-hash $v$. It means all subsequences in ${\mathsf{rec}}(b,c)$ have been represented by compact windows generated earlier. In this case, we generate no compact window: skip $(b,c)$ and jump to the next key (Line LABEL:algo:skyline:5).

Based on Lemma 19, we can efficiently determine whether $(b,c)$ is dominated by any key in S via binary search. Note that if the result is $j^{\prime}=0$ (Line LABEL:algo:skyline:4), then $\textnormal{{S}}[j^{\prime}]$ refers to the guard key $(0,0)$, which does not dominate $(b,c)$. This case corresponds to the scenario in Lemma 19 where no such index $j$ exists.

When $(b,c)$ is not dominated by any key in S, we first find all the keys in S that are dominated by $(b,c)$. Lemma 1 ($\mathsf{C1}$) shall prove that with two binary searches on S (Lines LABEL:algo:skyline:6-LABEL:algo:skyline:7), $\textnormal{{S}}[i+1]$ to $\textnormal{{S}}[j-1]$ are exactly the keys in S dominated by $(b,c)$. Lines LABEL:algo:skyline:8-LABEL:algo:skyline:13 generate up to $j-i$ compact windows (red dashed rectangles in Figure 3(b)). Lemma 1 ($\mathsf{C2}$) shall prove that these compact windows are disjoint and cover all the subsequences $\textnormal{T}[i,j]$ where $(i,j)\in{\mathsf{rec}}(b,c)\setminus{\mathsf{rec}}(\textnormal{{L}})$, whose min-hash must be $v$ (by Lemma 10 and Lemma 14). We update S by removing these dominated keys (Line LABEL:algo:skyline:14) and inserting the new key $(b,c)$ (Line LABEL:algo:skyline:15).

In practice, Line LABEL:algo:skyline:4 and Line LABEL:algo:skyline:6 can be combined in one binary search. We use two binary searches for ease of presentation later.

Example 0.

Consider the running example. As shown in Figure 4(c), when visiting $(b=3,c=3)$, we have $v=2$ and $\textnormal{{S}}=\{(0,0),(1,1),(2,8),(11,11)\}$. The binary search would find $j^{\prime}=2$ as $\textnormal{{S}}[2].y=1\leq c$ and $\textnormal{{S}}[3].y=8>c$. Clearly, $\textnormal{{S}}[j^{\prime}]=(1,1)$ does not dominate $(3,3)$. Then the next two binary searches would find $i=2$ and $j=4$. Next, when $k=2$, a compact window $\langle\textnormal{T},\textit{h},v=2,a=2,b=3,c^{\prime}=3,d=7\rangle$ is generated and $c^{\prime}$ becomes 8. When $k=3$, another compact window $\langle\textnormal{T},\textit{h},2,3,3,8,10\rangle$ is produced. Finally, the key $\textnormal{{S}}[3]=(2,8)$ is removed from the skyline, while $(3,3)$ is added.

Let $f_{\textnormal{T}}$ be the maximum token frequency in T, i.e., $f_{\textnormal{T}}=\max_{t\in\textnormal{T}}f(t,\textnormal{T})$.

Theorem 21.

Given a text T and a hash function h, Algorithm 4 generates a partition $\mathcal{P}(\textnormal{T},\textit{h})$.

Theorem 22.

In expectation, the partition $\mathcal{P}(\textnormal{T},\textit{h})$ generated by Algorithm 4 has $O(n+n\log f_{\textnormal{T}})$ compact windows, where $n=|\textnormal{T}|$.

Theorem 23.

When given the length and the maximum token frequency of a text, Algorithm 4, the Monotonic Partitioning algorithm, is optimal in terms of the expected partition size in the worst case.

We prove Theorem 21 in Appendix A (due to space limitation) and Theorem 22 in Section 4.3. Note that the “expectation” in Theorem 22 is due to the nature of the hash function as opposed to any assumption on T. We also provide a lower bound in Theorem 23, with the proof provided in Appendix B for interested readers.

4.3. Active Keys and Complexity Analysis

The total number of keys generated by Algorithm 3 is $O(\sum_{t\in\textnormal{T}}f^{2}(t,\textnormal{T}))$, which can go up to $O(n^{2})$ – when all the tokens are duplicated (i.e., $f_{\textnormal{T}}=n$). This leads to a running time of $O(n^{2}\log n)$ and space $O(n^{2})$ just for producing, sorting and storing the keys.

We observe that not all keys in $\textnormal{{K}}(\textnormal{T})$ need to be enumerated. Specifically, in Algorithm 4, when visiting a key $(b,c)\in\textnormal{{K}}(\textnormal{T})$, the key is skipped if it is dominated by a key in the skyline of visited keys (Line LABEL:algo:skyline:5). Although it is non-trivial to determine all the skipped keys in advance, we identify a subset of them – referred to as non-active keys – which, as formalized below, are guaranteed to be dominated and can thus be safely skipped during key generation.

Definition 0 (Active Hash Value).

Given a text T and a hash function h, a hash value $\textit{h}(t,x)$ for a token $t\in\textnormal{T}$ is said to be active if and only if $\textit{h}(t,x)<\textit{h}(t,x^{\prime})$ for all positive integers $x^{\prime}<x$.

That is to say, a hash value $\textit{h}(t,x)$ is active if and only if it is the smallest among $\textit{h}(t,1),\textit{h}(t,2),\cdots,\textit{h}(t,x-1),\textit{h}(t,x)$. For example, Figure 2(c) shows all the active hash values in the hash value set $\mathsf{H}(\textnormal{T})$ in Figure 2(b). The bold, red integers are active hash values, while the rest (i.e., gray ones) are non-active hash values.

Definition 0 (Active Key).

A key $(p,q)$ is active if and only if its hash value $\textit{h}(p,q,\textnormal{T})$ is active for token $\textnormal{T}[p]$ (note that $\textnormal{T}[p]=\textnormal{T}[q]$ for a key). The set of active keys in a text T is denoted as $\textnormal{{X}}(\textnormal{T})$.

For example, Figure 1(e) shows the active key set $\textnormal{{X}}(\textnormal{T})$ of T under the hash function h from the running example. Although T contains 23 keys in total, only 14 of them are active keys.

Note that a key is added to the skyline in Algorithm 4 if and only if it is not skipped, i.e., the condition in Line LABEL:algo:skyline:5 evaluates to false.

Lemma 0.

No non-active key is added to the skyline in Algorithm 4.

Proof.

Let $(p,q)\in\textnormal{{K}}(\textnormal{T})$ be a non-active key. Then its hash value $\textit{h}(t,x)$ must be non-active, where $t=\textnormal{T}[p]=\textnormal{T}[q]$ and $x=f(t,\textnormal{T}[p,q])$. Let $p=q_{1}<q_{2}<\cdots<q_{x}=q$ be the positions such that $\textnormal{T}[q_{i}]=t$ for all $1\leq i\leq x$. Since $\textit{h}(t,x)$ is non-active, by Definition 24, there exists some $1\leq i<x$ such that $\textit{h}(t,i)<\textit{h}(t,x)$. Then the corresponding key $(p,q_{i})$ has a smaller hash value than $(p,q)$ and satisfies $[p,q_{i}]\subset[p,q]$, hence it dominates $(p,q)$. Moreover, since $\textit{h}(t,i)<\textit{h}(t,x)$, $(p,q_{i})$ is visited before $(p,q)$.

Now, consider two cases. (1) If $(p,q_{i})$ is in the skyline at the time $(p,q)$ is visited, then $(p,q)$ will be skipped by Lemma 19. (2) If $(p,q_{i})$ is not in the skyline, it must be pruned by a key dominates $(p,q_{i})$. By Lemma 27 (dominance is transitive), there exists a key in the skyline that dominates $(p,q_{i})$ and thus also dominates $(p,q)$. In this case, $(p,q)$ will also be skipped. In either case, $(p,q)$ will not be added to the skyline. Therefore, only active keys can enter the skyline in Line LABEL:algo:skyline:15, and all non-active keys are skipped. ∎

Lemma 0.

Dominance is transitive, i.e., if $(p,q)$ dominates $(p^{\prime},q^{\prime})$ and $(p^{\prime},q^{\prime})$ dominates $(p^{\prime\prime},q^{\prime\prime})$, then $(p,q)$ dominates $(p^{\prime\prime},q^{\prime\prime})$.

Proof.

This is because $[p,q]\subset[p^{\prime},q^{\prime}]\subset[p^{\prime\prime},q^{\prime\prime}]$. ∎

Lemma 0.

The total number of compact windows generated by Algorithm 4 is no more than $2|\textnormal{{X}}(\textnormal{T})|$.

Proof.

Consider Lines LABEL:algo:skyline:9-LABEL:algo:skyline:13. The algorithm produces at most $j-i$ compact windows. Note that inserting the key $(b,c)$ results in the removal of $j-i-1$ other keys from the skyline, and these removed keys will not be reinserted. Thus, among the $j-i$ compact windows generated, one corresponds to the insertion of $(b,c)$ and one to the removal of each key. Thus one compact window is produced upon the insertion of a key and one compact window is produced upon the removal of a key. Moreover, by Lemma 26, only active keys can be added to the skyline. Hence, the total number of compact windows generated by Algorithm 4 is at most $2|\textnormal{{X}}(\textnormal{T})|$. ∎

Lemma 0.

In expectation, $|\textnormal{{X}}(\textnormal{T})|=O(n+n\log f_{\textnormal{T}})$, where $n=|\textnormal{T}|$.

Proof.

For any $t\in\textnormal{T}$ and $i\in[f(t,\textnormal{T})]$, the probability that $\textit{h}(t,i)$ is active, i.e., it is smaller than all the hash values $\textit{h}(t,j)$ for all $j<i$ is $\frac{1}{i}$. Therefore, the total number of active hash values among $\textit{h}(t,1),\cdots,\textit{h}(t,f(t,\textnormal{T}))$ in expectation is $\sum_{i\in[f(t,\textnormal{T})]}\frac{1}{i}=O(1+\ln(f(t,\textnormal{T})))$, seeing that even when $f(t,\textnormal{T})=1$, the summation is still $1$. Moreover, there are $O(f(t,\textnormal{T}))$ keys with hash value $\textit{h}(t,i)$ for any $i\in[f(t,\textnormal{T})]$. Therefore, in expectation, the total number of active keys in T, i.e., $|\textnormal{{X}}(\textnormal{T})|$, is $O(\sum_{t\in\textnormal{T}}(f(t,\textnormal{T})(1+\ln(f(t,\textnormal{T}))))=O(n+\sum_{t\in\textnormal{T}}(f(t,\textnormal{T})\ln(f(t,\textnormal{T})))=O(n+n\log f_{\textnormal{T}})$. ∎

Combining Lemmas 28 and 29, in expectation, the total number of compact windows in the partition $\mathcal{P}(\textnormal{T},\textit{h})$ generated by Algorithm 4 is $O(|\textnormal{{X}}(\textnormal{T})|)=O(n+n\log f_{\textnormal{T}})$, which proves Theorem 22.

To incorporate this optimization in our algorithm, we replace procedure GenerateKeys with a similar procedure GenerateActiveKeys (Algorithm 5). It generates active keys by enumerating, for each token $t$, every possible frequency $x$ of $t$: the algorithm maintains the smallest hash value encountered in $minkey$ and only when the current hash value $\textit{h}(t,x)<minkey$, it produces all the keys whose hash values are $\textit{h}(t,x)$ and updates $minkey$ as $\textit{h}(t,x)$.

An additional optimization is to sort the active hash values prior to generating the corresponding active keys, rather than generating and subsequently sorting all active keys. This approach is justified by two key observations: (1) active keys associated with the same hash value can be ordered arbitrarily, and (2) the number of active hash values does not exceed the total number of active keys.

Theorem 30.

Algorithm 4 with GenerateActiveKeys in Line LABEL:algo:skyline:1 has time complexity $O(|\textnormal{{X}}(\textnormal{T})|\log n)$ and space complexity $O(|\textnormal{{X}}(\textnormal{T})|)$. In expectation, the time complexity is $O(n\log n+n\log n\log f_{\textnormal{T}}),$ and space complexity is $O(n\log f_{\textnormal{T}}+n)$.

Proof.

Because for any $i\in[n]$, $(i,i)$ is an active key, thus $|\textnormal{{X}}(\textnormal{T})|\geq n$. The size of the skyline S is $O(n)$ as each $b\in[n]$ will have at most one key in S. The binary search and each update to the skyline take $O(\log n)$. GenerateActiveKeys only produces active keys $\textnormal{{X}}(\textnormal{T})$. Each active key costs up to three binary searches of the skyline and two updates and corresponds to up to two compact windows. In addition, GenerateActiveKeys takes $O(|\textnormal{{X}}(\textnormal{T})|+n)=O(|\textnormal{{X}}(\textnormal{T})|)$ time; sorting the active hash values takes $O(n\log n)$ time as there are at most $n$ active hash values. Thus the time complexity is $O(|\textnormal{{X}}(\textnormal{T})|\log n)$. The space complexity is $O(|\textnormal{{X}}(\textnormal{T})|)$. By Lemma 28, in expectation, $|\textnormal{{X}}(\textnormal{T})|=O(n+n\log f_{\textnormal{T}})$. Therefore, the time complexity is $O(n\log n+n\log n\log f_{\textnormal{T}})$; the space complexity is $O(n\log f_{\textnormal{T}}+n)$ in expectation. ∎

Lemma 2 in Appendix A shall prove the correctness of this optimization. Note that there are $O(nf_{\textnormal{T}})$ keys in $\textnormal{{K}}(\textnormal{T})$. Thus, the time and space complexities of vanilla Algorithm 4 (without the active key optimization) are respectively $O(nf_{\textnormal{T}}\log n)$ and $O(nf_{\textnormal{T}})$.

5. Generalization to Weighted Jaccard Similarity

Consider a text T where each distinct token $t$ is associated with a weight. The weight is determined by a weight function $w(t,\textnormal{T})$ where $w(t,\textnormal{T})>0$ for $t\in\textnormal{T}$ and $w(t,\textnormal{T})=0$ for $t\notin\textnormal{T}$. The weighted Jaccard similarity of two texts T and S is defined as

[TABLE]

To estimate weighted jaccard similarity, one can use improved consistent weighted sampling (ioffe2010improved, ). In a nutshell, it designs a hash family $\mathcal{H}$. Given a text T, for each distinct token $t$ in T, a hash function $h\in\mathcal{H}$ takes the token $t$ and its weight $w(t,\textnormal{T})$ as input and outputs a hash value, denoted as $\textit{h}(t,w(t,\textnormal{T}))$. With hash function $h$, we define the weighted min-hash of a text T as the smallest hash value among all distinct tokens in T, denoted as $\textit{h}(\textnormal{T},w)$. Formally,

[TABLE]

The hash family $\mathcal{H}$ designed in improved consistent weighted sampling scheme guarantees that for any two texts T and S and weight function $w$, $\mathbf{Pr}[\textit{h}(\textnormal{T},w)=\textit{h}(\textnormal{S},w)]=\texttt{J}^{w}_{\textnormal{T},\textnormal{S}}.$

Thus the weighted Jaccard similarity of two texts T and S can be accurately and unbiasedly estimated by $k$ independent hash functions $\textit{h}_{1},\cdots,\textit{h}_{k}$ randomly drawn from the hash family $\mathcal{H}$ as

[TABLE]

16

16

16

16

16

16

16

16

16

16

16

16

16

16

16

16

Implementation Details. Algorithm 6 implements the improved consistent weighted sampling scheme (ioffe2010improved, ). Drawing a random hash function $\textit{h}\in\mathcal{H}$ is the same as instantiating a new object $o$ of $\mathsf{ICWS}$ class (Lines 1-10). The constructor (Lines 2-6) samples three independent random variables for every token $t$ in the vocabulary $\Sigma$ from the $\mathsf{ICWS}$ specified distributions. The hash computation (Lines 7-10) $o.\textit{h}(t,w(t,\textnormal{T}))$ of $o$ returns the hash value based on token $t$ and the weight of $t$ in T. Note that an object is initialized with a random seed; the set of possible objects form the hash family.

A hash value $(t,y,a)$ is an instance of the $\mathsf{HashValue}$, where the comparators $=$ and $<$ are defined. For simplicity, we assume there are no hash collisions: for any two hash values $(t_{1},y_{1},a_{1})$ and $(t_{2},y_{2},a_{2})$, if $t_{1}\neq t_{2}$, then $a_{1}\neq a_{2}$. Comparator $<$ provides hash values a total order, i.e., for any two hash values $v_{1}=(t_{1},y_{1},a_{1})$ and $v_{2}=(t_{2},y_{2},a_{2})$, we say $v_{1}<v_{2}$ if and only if $a_{1}<a_{2}$. Besides, for a token $t$, $r_{t},c_{t}$ and $\beta_{t}$ depend solely on $t$. Thus the weight determines both $y$ and $a$, i.e., there is a one-to-one mapping between $y$ and $a$ in a hash value $(t,y,a)$. Thus, $v_{1}=v_{2}$ iff. $t_{1}=t_{2}$ and $y_{1}=y_{2}$.

Consistency and Uniformity. The weighted min-hash under improved consistent weight sampling has the nice properties below:

• •

Uniformity: Denote by $(t,y,a)$ the weighted min-hash of a text T, then $(t,y)$ is distributed uniformly over $\cup_{t^{\prime}\in\Sigma}\{t^{\prime}\}\times[0,w(t^{\prime},\textnormal{T})]$.

• •

Consistency: Let $v=(t,y,a)$ be the weighted min-hash of a text T. Given a text S with $w(t^{\prime},\textnormal{S})\leq w(t^{\prime},\textnormal{T})$ for all $t^{\prime}\in\Sigma$. If $y\leq w(t,\textnormal{S})$, then $v$ must also be the weighted min-hash of S.

Assumption on the Weight Function ($\mathsf{AoW}$): Given a text T, we assume that for any token $t$ in T, its weight is a monotonically increasing function of its frequency $f(t,\textnormal{T})$ and is independent of other properties of T. With $\mathsf{AoW}$, we can simplify the notation of the weight of a token $t$ in T as $w(t,x)$ where $x=f(t,\textnormal{T})$. We can also simplify the hash function as $\textit{h}_{w}(t,x)\doteq\textit{h}(t,w(t,x))$ where $x$ is a positive integer. The $\mathsf{AoW}$, i.e., for any $1\leq x\leq x^{\prime}$, $w(t,x)\leq w(t,x^{\prime})$, is reasonable especailly when it comes to TF-IDF weights.

Term Frequency–Inverse Document Frequency (TF-IDF) (singhal2001modern, ). TF-IDF is a widely used weighting scheme that captures both the importance of a token within a text and its rarity across a corpus D. The TF-IDF weight function is defined as $w(t,\textnormal{T})={\mathsf{tf}}\cdot{\mathsf{idf}}$ where ${\mathsf{tf}}$ is the TF weight and ${\mathsf{idf}}$ is the IDF weight. A few example TF and IDF weights we support (but not limited to) are listed in Table 1.

Hash Value Set. We omit the weight function $w$ in the notation of a hash value $\textit{h}_{w}(t,x)$ when the context is clear and abbreviate the hash value as $\textit{h}(t,x)$. We can define the hash value set of a subsequence in the same way as Definition 2.

Definition 0.

Given a random hash function h from $\mathcal{H}$ and a weight function $w$, the hash value set of a subsequence $\textnormal{T}[i,j]$ is

[TABLE]

Next we show that, under the assumption of ${\mathsf{AoW}}$, the hash values under consistent weighted sampling have the property below.

Lemma 0.

Given a random hash function h from $\mathcal{H}$ and a weight function $w$ under the assumption of ${\mathsf{AoW}}$, we have $\textit{h}(t,1)\geq\textit{h}(t,2)\geq\cdots\geq\textit{h}(t,x)$ for any token $t$ in any text T where $x=f(t,\textnormal{T})$.

Proof.

Under the assumption of ${\mathsf{AoW}}$, we have $w(t,1)\leq w(t,2)\leq\cdots\leq w(t,x)$. Now consider texts $\textnormal{T}_{1},\textnormal{T}_{2},\cdots,\textnormal{T}_{x}$ where $\textnormal{T}_{i}$ consists of exactly $i$ copies of token $t$. Then $\textnormal{T}_{i}$ has only one hash value $\textit{h}(t,i)$, which must be its weighted min-hash by Equation 4. Consider any $j>i$. Let $\textit{h}(t,i)=(t,y,a)$ and $\textit{h}(t,j)=(t,y^{\prime},a^{\prime})$, which are the weighted min-hash of $\textnormal{T}_{i}$ and $\textnormal{T}_{j}$. By uniformity, $y$ distributes uniformly over $[0,w(t,i)]$ and so does $y^{\prime}$ over $[0,w(t,j)]$. By consistency, because $w(t,i)\leq w(t,j)$, if $y^{\prime}\leq w(t,i)$, we have $\textit{h}(t,i)=\textit{h}(t,j)$. Otherwise, i.e., $y^{\prime}>w(t,i)$, because $y\leq w(t,i)$, we have $y<y^{\prime}$. Under the same $t$, i.e., $r_{t},c_{t},\beta_{t}$ are fixed, we have $a\propto\frac{1}{y}$ (Line 9, Algorithm 6). Thus we have $a>a^{\prime}$, which indicates $\textit{h}(t,i)>\textit{h}(t,j)$. In both cases, we have $\textit{h}(t,i)\geq\textit{h}(t,i)$. Thus $\textit{h}(t,1)\geq\textit{h}(t,2)\geq\cdots\geq\textit{h}(t,x)$ for any $t$ and T. ∎

Based on Lemma 2 and Equation 4, we have

[TABLE]

With the above definitions, all the definitions, lemmas, theorems, algorithms, and conclusions naturally extend to the weighted min-hash. For example, a hash value $\textit{h}(t,x)$ is active if and only if it is strictly greater than all of $\textit{h}(t,1),\cdots,\textit{h}(t,x-1)$.

Lemma 0.

In expectation, $|\textnormal{{X}}(\textnormal{T})|$ is $O(n)$ for binary TF, $O(n+n\log f_{\textnormal{T}})$ for raw count TF, $O(n+\log\log f_{\textnormal{T}})$ for logarithmic TF, and $O(n+n\log f_{\textnormal{T}})$ for squared TF, each combined with any IDF in Table 1.

Proof.

Given a text with $n$ tokens and a weight function $w$. Consider a token $t\in\textnormal{T}$. Let $x=f(t,\textnormal{T})$. Clearly, $\textit{h}(t,1)$ must be an active hash value. For any $i\in[2,x]$, based on the proof of Lemma 2, $\textit{h}(t,i)$ is active if and only if $\textit{h}(t,i)<\textit{h}(t,i-1)$. Let $\textit{h}(t,i)=(t,y_{i},a_{i})$ and $\textit{h}(t,i-1)=(t,y_{i-1},a_{i-1})$. $\textit{h}(t,i)<\textit{h}(t,i-1)$ if and only if $y_{i}\in(w(t,i-1),w(t,i)]$. By uniformity, $y_{i}$ distributed uniformly over $[0,w(t,i)]$. Thus the probability that $\textit{h}(t,i)$ is active is $\frac{w(t,i)-w(t,i-1)}{w(t,i)}$. There are $x-i+1=O(x)$ keys corresponding to the hash value $\textit{h}(t,i)$ (imagine a sliding window of size $i$ over a string of length $x$). Thus in expectation, the number of active keys in T is $\mathbb{E}[\textnormal{{X}}(\textnormal{T})]=O(\sum_{t\in\textnormal{T}}f(t,\textnormal{T})\sum_{i=1}^{f(t,\textnormal{T})}\frac{w(t,i)-w(t,i-1)}{w(t,i)}).$ Note that $w(t,0)=0$. Clearly, for $x\geq 1$, when $w(t,x)=x\cdot\textsf{IDF}$, we have $\mathbb{E}[|\textnormal{{X}}(\textnormal{T})|]=O(n+n\log f_{\textnormal{T}})$. When $w(t,x)=1\cdot\textsf{IDF}$, $\mathbb{E}[|\textnormal{{X}}(\textnormal{T})|]=O(n)$. For $w(t,x)=\log(x+1)\cdot\textsf{IDF}$, $\mathbb{E}[|\textnormal{{X}}(\textnormal{T})|]=O(n+n\log\log f_{\textnormal{T}})$ based on taylor expansion. For $w(t,x)=x^{2}\cdot\textsf{IDF}$, $\mathbb{E}[|\textnormal{{X}}(\textnormal{T})|]=O(n+n\log f_{\textnormal{T}})$. ∎

A caveat is that, instead of breaking ties arbitrarily for keys with the same hash value when visiting the key set of a text, we need to order the keys firstly by their hash values and secondly by their frequencies. That is to say for two keys $(p,q)$ and $(p^{\prime},q^{\prime})$ with the same hash value, if $f(\textnormal{T}[p],\textnormal{T}[p,q])>f(\textnormal{T}[p^{\prime}],\textnormal{T}[p^{\prime},q^{\prime}])$, we should visit $(p,q)$ before $(p^{\prime},q^{\prime})$. If $f(\textnormal{T}[p],\textnormal{T}[p,q])=f(\textnormal{T}[p^{\prime}],\textnormal{T}[p^{\prime},q^{\prime}])$, we can break tie arbitrarily.

6. Experiment

Environment. We implemented all the methods, including the baselines, using C++. The programs were compiled with GCC 11.4.0 and optimized using the -O3 flag. All experiments were conducted on a machine equipped with an Intel Xeon Gold 6212 CPU @ 2.40GHz and 1 TB of memory, running Ubuntu 18.04.5.

Datasets. We conducted experiments on two datasets, PAN (DBLP:conf/clef/PotthastEBSR11, ) and OWT (Gokaslan2019OpenWeb, ). PAN (https://pan.webis.de/data.html) is a benchmark for external plagiarism detection (DBLP:conf/clef/PotthastEBSR11, ). Each text in PAN is a book. Tokens are generated by splitting words based on whitespace. In total, there are 11,093 texts and 642,380,109 tokens in the dataset. OWT consists of 8 million web texts highly ranked on Reddit. Each token is a byte-pair-encoding generated by the GPT-2 tokenizer(radford2019language, ). The vocabulary size is 50,257.

Parameters and Settings. There are three parameters, the text length $n$, the maximum token frequency $f$, and the min-hash sketch size $k$ (see Section 2.2). We report the compact window generation time (i.e., partition time) and the number of compact windows generated (i.e., partition size) per text. To avoid text-dependent bias, for each configuration of parameters, we randomly choose $10$ text under the configuration and report the average partition time/size.

To fix the text length $n$, texts with more than $n$ tokens were truncated to their first $n$ tokens. Texts with fewer than $n$ tokens were concatenated until they reached or exceeded $n$ tokens, after which they were truncated to the first $n$ tokens as a single text.

To evaluate the impact of the maximum token frequency $f$, we fixed the text length $n$ and used the first 100,000 texts in OWT and the first 10,000 texts in PAN. These texts were grouped based on their maximum token frequencies using intervals of 100. For example, texts with maximum token frequencies in the range $[1,100]$ formed one group, while those in $[101,200]$ formed another.

Compared Methods. We consider 3 methods in our experiment.

• •

MonoAll: Our vanilla monotonic partitioning, Algorithm 4.

• •

MonoActive: Our monotonic partitioning with active hash optimization (Section 4.3). It calls Algorithm 5 to generate keys.

• •

AllAlign: A greedy partitioning algorithm for multi-set Jaccard similarity (allign, ). AllAlign generates compact windows in recursion. In each iteration, it takes a rectangle of the shape $[a,b]\times[a,c]$ as input and partitions all the subsequences $\textnormal{T}[i,j]$ in this rectangle into a few compact windows and one or more smaller rectangles of that shape. The smaller rectangles are recursively partitioned until no rectangles left. At the beginning, the input rectangle is $[1,n]\times[1,n]$. However, AllAlign is greedy and its time and space complexities are unknown.

6.1. Evaluating Active Hash Optimization

This section evaluates our two methods MonoActive and MonoAll on two datasets OWT and PAN. Since the optimization in MonoActive does not change the generated compact windows, the partition size of MonoActive and MonoAll are the same, we only consider the partition time. Recall that in Theorem 30, the time complexities of MonoActive and MonoAll are respectively $O(n\log n\log f)$ and $O(nf\log n)$ when the maximum frequency $f>1$.

Figures 5(a)-5(b) show that the partition time of two methods increases with the text length. MonoActive consistently outperforms MonoAll because MonoActive avoids unnecessary computations for non-active keys. The ratio between the partition time of MonoAll and that of MonoActive echoes our complexity analysis.

Figures 5(c)-5(d) show that with $k=64$ and $n=5000$, as the maximum frequency $f$ increases, the runtime of MonoActive remained nearly constant whereas that of MonoAll grew almost linearly with $f$. For example, on PAN, when $f\in[901,1000]$, $f\in[1901,2000]$, and $f\in[2901,3000]$, MonoActive took 0.27, 0.29, 0.33 seconds for partition generation on average, while MonoAll took 3.98, 10.56, 22.59 seconds. When $f$ increased around threefold, the runtime of MonoActive and MonoAll respectively increased 1.2$\times$ and 5.7$\times$. This observation is consistent with our complexity analysis.

Figures 5(e)-5(f) show that both methods exhibit linear runtime growth with $k$. This is because the partition generation is independent across the $k$ random universal hash functions. Thus, hereinafter, we skip evaluating the impact of the parameter $k$.

6.2. Evaluating Weighted Jaccard Similarity

This section evaluates near-duplicate text alignment under weighted Jaccard similarity. Our algorithm MonoActive is the only method that supports this problem. We evaluated four token weight functions $w(t,x)$: (1) binary TF weight $[x\geq 1]$; (2) logarithmic TF weight $\log(x+1)$; (3) raw count TF weight $x$; and (4) squared TF weight $x^{2}$; all combined with unary IDF weight.

Figures 6(a) and 6(b) report the partition sizes (i.e.,, the number of compact windows generated) as the text length $n$ varies from $10^{3}$ to $10^{6}$. As observed, the squared weight consistently yields the largest partitions, followed by the raw count weight, whereas the binary weight produces the smallest partitions. For all weight functions, the partition size increases approximately linearly with $n$. For instance, when $n$ increases from 1,000 to 1 million on PAN, the partition sizes under the four weight functions increase from 64K, 67K, 71K, and 89K to 64M, 68M, 82M, and 158M, respectively. This is because the partition sizes of the binary, logarithmic, raw count, and squared weights are respectively $O(n)$, $O(n+n\log\log f)$, $O(n+n\log f)$, and $O(n+n\log f)$, according to Lemma 3. Although squared and raw count weights have the same complexity, the constant factor of squared weight is larger than that of raw count weight.

Figures 6(c) and 6(d) present the average partitioning time (i.e.,, the compact window generation time) under the four weight functions as the text length $n$ increases from $10^{3}$ to $10^{6}$. Among them, the binary weight consistently achieved the fastest partitioning time, followed by the logarithmic weight, while the squared weight resulted in the slowest runtime. All weight functions exhibit quasilinear growth with respect to $n$. For example, when $n$ increased from $10^{3}$ to $10^{6}$ on PAN, the partitioning times under the four weights increased from 0.47, 0.50, 0.48, and 0.49 seconds to 60.96, 110.99, 143.43, and 229.02 seconds, respectively. This aligns with our complexity analysis, which shows that the runtime of MonoActive scales with $|\textnormal{{X}}(\textnormal{T})|\log n$ for all weight functions.

Figures 6(e) and 6(f) show the average query latency when varying the text length $n$ from $10^{3}$ to $10^{6}$. The queries are sampled from the same dataset of the data texts but are disjoint from them. Each query is a text of length $100$, and the same set of queries is used across all values of $n$. Similarly, the squared weight had the largest query latency, followed by raw count weight, while the binary weight had the smallest latency. This is because query processing cost grows with the number of compact windows sharing the same hash values between the query and the data texts (a.k.a., collided compact windows). Weight functions that generate more compact windows are more likely to incur a larger number of such collisions, thereby increasing query latency.

Figures 6(g)–6(h) show the average partition sizes generated under the four weight functions, with $n=5{,}000$ and $k=64$ fixed while varying the maximum token frequency $f$. As $f$ increased, the partition size under the binary weight remained constant. The partition size under logarithmic increased modestly, whereas those under raw count and squared weights grew sublinearly with $f$. For example, when $f$ increased from the range $[901,1000]$ to $[2901,3000]$, the partition sizes under the binary, logarithmic, raw count, and squared weights increased from 320K, 412K, 607K, and 1M to 320K, 625K, 1.5M, and 2.8M, respectively. These results are consistent with our theoretical analysis. The numbers of compact windows generated by binary, logarithmic, raw count, and squared weights scale with $n$, $n\log\log f$, $n\log f$, and $n\log f$, respectively.

Figures 6(i)–6(j) report the average partitioning time of the four weight functions under varying $f$. The partitioning time either remained nearly constant or decreased slightly across all four weight functions. This is because a significant part of MonoActive’s runtime is spent on sorting the active hash values, the number of which is proportional to the number of distinct tokens in the text. As $f$ increases while $n$ remains fixed, the number of distinct tokens decreases, thereby reducing the sorting cost. Finally, Figures 6(k)–6(l) show the average query latency of the four weight functions under varying $f$. The two datasets showed different behaviors. This is because the query time depends heavily on the query text (which determines the number of collided compact windows).

6.3. Comparing with the State-of-the-Art

This section compares our method MonoActive with AllAlign, the state-of-the-art method for multi-set Jaccard similarity.

Figures 7(a) and 7(b) show, when varying the text length $n$ from $10^{3}$ to $10^{6}$, the average number of compact windows generated by MonoActive and AllAlign (i.e., partition sizes, which are proportional to their index sizes) on two datasets OWT and PAN, while Figures 7(g) and 7(h) show the reduction ratio (i.e., $1-\frac{\texttt{MonoActive}}{\texttt{AllAlign}}$). As shown, MonoActive consistently generated less compact windows than AllAlign, up to 30.82%. More importantly, the gap between the number of compact windows for MonoActive and AllAlign steadily widens as $n$ increases. For example, when $n$ increased from 1000 to 1 million, the gap grew from 10.86% to 30.82% on PAN and from 7.69% to 26.08% on OWT. This is because AllAlign’s recursive approach divides the rectangles into multiple rectangular regions, imposing early boundaries that may split what is a single compact window in MonoActive into multiple. The number of compact windows generated by MonoActive grew linearly with $n$, which is consistent with our complexity analysis.

Figures 7(c) and 7(d) show, when varying the text length $n$ from $10^{3}$ to $10^{6}$, the average compact window generation time (i.e., partition time, which is proportional to the index time) of AllAlign and MonoActive, respectively, while Figures 7(i) and 7(j) show the speedup of MonoActive over AllAlign. MonoActive was significantly faster than AllAlign. For example, on the PAN dataset, when $n=10^{6}$, AllAlign took 7581s on average to generate the compact windows, whereas MonoActive only spent 284s, achieving a speedup of 26.7$\times$. This is because AllAlign produces more compact windows than MonoActive and AllAlign is recursive whereas MonoActive is non-recursive. Moreover, the speedup of MonoActive over AllAlign increased as $n$ grew. For example, on the PAN dataset, when $n$ increased from $10^{4}$ to $10^{6}$, the speedup improved from 1.46 to 26.7. A similar trend is observed on OWT.

Figures 7(e) and 7(f) show the average query latency of the two methods when varying the text length $n$ from $10^{3}$ to $10^{6}$, while Figures 7(k) and 7(l) show the speedup of MonoActive over AllAlign. The queries are generated in the same way as described earlier. The query latency of MonoActive was up to 3.15$\times$ faster than that of AllAlign, though the number of compact windows was only up to $30.82\%$ less. For example, on the PAN dataset, when $n$ increased from $10^{3}$ to $10^{6}$, the speedup improved from 1.4 to 3.15. A similar trend is observed on OWT. This is because, although the number of collided compact windows grows linearly with the number of generated compact windows in expectation, the cost of query processing scales quadratically with the number of collided windows in the worst case. Therefore, reducing the number of compact windows can lead to a significant speedup in query time.

We also evaluate the impact of the maximum token frequency $f$. Figures 7(m)–7(r) present the number of compact windows generated, the compact window generation time, and the query latency of the two methods, under varying $f$ with fixed text length $n=5000$. Figures 7(s)–7(x) further report the relative improvements. As $f$ increases, the generation time of MonoActive remains largely stable, whereas that of AllAlign increases significantly. For example, on the PAN dataset, when $f$ increases from $600$ to $3000$, the speedup improved from 1.41 to 16.26. In addition, the gap in the number of compact windows produced by the two methods first grows and then decreases with larger $f$. This trend arises because higher token frequencies lead to deeper recursion and more early boundaries in AllAlign, which fragment compact windows and increase computational cost. However, as $f$ approaches $n$, the text instances approach the worst-case scenario and both methods produce a large number of compact windows. The gap of the query latency increases with the increase of $f$. This is because the collided windows are dominated by tokens with the highest frequencies. In AllAlign, the high-frequency tokens trigger deeper recursion, resulting in more finely fragmented compact windows. These fragments increase the number of collided compact windows and the number of iterations in the inner loop. As a result, the query latency grows superlinearly with the number of collided compact windows.

Scalability. As shown in Figures 7(g)-7(l), the performance gain of MonoActive over AllAlign increased as the text length $n$ grew in terms of partition size, partition generation time, and query latency. Thus MonoActive scales better than AllAlign. This is attributed to the complexity guarantees of our algorithm.

7. Related Work

Near-Duplicate Text Alignment. Most of existing methods for near-duplicate text alignment rely on rule-based heuristics and the “seeding-extension-filtering” framework (DBLP:conf/usenix/Manber94, ; DBLP:journals/cn/BroderGMZ97, ; DBLP:conf/www/HamidBCH09, ; DBLP:conf/sigmod/BrinDG95, ; DBLP:conf/sigir/SeoC08, ; DBLP:conf/www/KimCT09, ; DBLP:books/aw/Baeza-YatesR99, ; DBLP:journals/jasis/HoadZ03, ). They first find “seed matches” between the data texts and the query. Various kinds of seeds have been proposed, such as fingerprints (DBLP:conf/clef/PotthastBESR10, ), super-shingles (broder1997syntactic, ), 0 mod p (DBLP:conf/usenix/Manber94, ), fixed-length windows (DBLP:conf/sigmod/WangXQWZI16, ), q-grams (DBLP:conf/sigmod/SchleimerWA03, ), and sentences (DBLP:conf/clef/Sanchez-PerezGS15, ). Then they extend the seed matches as far as possible to form candidates. Finally, candidates failing predefined criteria (e.g., length or overlap thresholds) are filtered. However, these heuristics are highly sensitive to the hard-to-tune hyper-parameters (DBLP:journals/csur/FoltynekMG20, ) such as the granularity of the seeds and various kinds of thresholds (DBLP:conf/clef/Sanchez-PerezGS15, ; DBLP:conf/semeval/AgirreBCDGMRW16, ). They also lack accuracy guarantees.

A few recent works propose to use the min-hash techniques (minhash, ) for near-duplicate text alignment (allign, ; txtalign, ; llmalign, ; DBLP:journals/pacmmod/PengZD24, ). They introduce the concept of “compact windows” to group nearby subsequences sharing the same min-hash. It has been shown that when duplicate tokens have the same hash value, the $O(kn^{2})$ min-hashes in a text with $n$ tokens can be compressed in compact windows using $O(kn)$ space and $O(kn\log n)$ time, where $k$ is the sketch size (allign, ). Along this line, an algorithm is developed to group the $O(n^{2})$ bottom-$k$ sketches in a text with $n$ tokens into compact windows using $O(nk^{2})$ space and $O(n\log n+nk)$ time (txtalign, ). To further reduce the space cost, another algorithm is designed to group the $O(kn^{2})$ one-permutation hashing (DBLP:conf/nips/0001OZ12, ) min-hash sketches into compact windows using $O(n+k)$ space and $O(n\log n+k)$ time (DBLP:journals/pacmmod/PengZD24, ). These algorithms are used to evaluate the memorization behaviour in large language models (LLMs), revealing that up to 10% of texts generated by GPT-2 (radford2019language, ) had near-duplicates in its training data. It also shows that the min-hash sketches of all subsequences no shorter than $t$ tokens in a text with $n$ tokens can be grouped into $O(\frac{n}{t})$ compact windows on average (llmalign, ). However, none of these works can deal with weighted min-hash (i.e., consistent weighted sampling (ioffe2010improved, )).

Min-Hash Sketch. Min-hash was originally introduced in statistics for coordinated sampling (brewer1972selecting, ) and later adapted for database applications by Flajolet and Martin (flajolet1985probabilistic, ). Broder (DBLP:journals/cn/BroderGMZ97, ) employed the min-hash sketch to detect near-duplicate web pages. Several variants of the min-hash sketch have been proposed to improve the sketching time of the classic min-hash sketch, including the bottom-$k$ sketch (DBLP:conf/stoc/Thorup13, ), one-permutation hashing (OPH) (DBLP:conf/nips/0001OZ12, ), and fast similarity sketch (dahlgaard2017fast, ). The number of min-hashes generated by one-permutation hashing is not fixed. A few works propose techniques to address this issue (shrivastava2014densifying, ; shrivastava2014improved, ; shrivastava2017optimal, ).

Weighted Jaccard Similarity Estimation. Many techniques have been proposed to estimate the weighted Jaccard similarity (ertl2018bagminhash, ; manasse2010consistent, ; ioffe2010improved, ; wu2018improved, ). Specifically, (gollapudi2006exploiting, ) extends the classic min-hash to estimate the multi-set Jaccard similarity. A method dealing with integer weights is mentioned in (charikar2002similarity, ). It was extended by (chum2008near, ) to support a more general weight function. Consistent weighted sampling (CWS) is first proposed in (manasse2010consistent, ) to estimate weighted Jaccard similarity. Ioffe proposes improved consistent weighted sampling, which simplified CWS and guarantees worst-case constant time for each non-zero weight (ioffe2010improved, ). Shrivastava proposes to use rejected sampling to estimate the weigthed Jaccard Similarity (shrivastava2016simple, ).

8. Conclusion

In conclusion, this paper extends near-duplicate text alignment to support weighted Jaccard similarity by leveraging consistent weighted sampling. We introduce MonoActive, an efficient and theoretically optimal algorithm for grouping subsequences based on their consistent weighted samplings. Our analysis establishes tight bounds on the number of groups generated, and our experiments demonstrate substantial improvements over state-of-the-art methods in both index time and index size. These results highlight the practicality and scalability of our approach for real-world text alignment tasks where token weights matter.

Appendix A Correctness of Monotonic Partitioning

This section serves as a proof of Theorem 21. Let $n=|\textnormal{T}|$.

Augmented Skyline. Since every key $(p,q)\in\textnormal{{K}}(\textnormal{T})$ has $(p,q)\in[1,n]\times[1,n]$, the two guard keys $(0,0)$ and $(n+1,n+1)$ neither dominate nor are dominated by any key in $\textnormal{{K}}(\textnormal{T})$. For any key set $\textnormal{{L}}\subseteq\textnormal{{K}}(\textnormal{T})$, set $\{(0,0),(n+1,n+1)\}\cup\textnormal{{S}}(\textnormal{{L}})$ is a skyline – no key in the set dominates another. We refer to this set as the augmented skyline of L. All the previous discussions about a skyline naturally apply to the corresponding augmented skyline.

By Definition 11, ${\mathsf{rec}}(\{(0,0),(n+1,n+1)\}\cup\textnormal{{S}}(\textnormal{{L}}))={\mathsf{rec}}(\textnormal{{S}}(\textnormal{{L}}))\cup{\mathsf{rec}}(0,0)\cup{\mathsf{rec}}(n+1,n+1)={\mathsf{rec}}(\textnormal{{S}}(\textnormal{{L}}))$. This is because ${\mathsf{rec}}(0,0)=[1,0]\times[0,n]=\phi$ and ${\mathsf{rec}}(n+1,n+1)=[1,n+1]\times[n+1,n]=\phi$.

Lemma 19 tests the existence of any key in L that dominates $(b,c)$. If not, we need to update the augmented skyline to include $(b,c)$ and, at the same time, generate compact windows according to Lemma 1 below. Please see Figure 3(b) as an illustration.

Lemma 0.

Given a key set $\textnormal{{L}}\subseteq\textnormal{{K}}(\textnormal{T})$ and a key $(b,c)\not\in\textnormal{{L}}$. Let S be the augmented skyline of L in coordinate order. Let

• •

$i$* be the largest index such that $\textnormal{{S}}[i].y<c$ and*

• •

$j$* be the smallest index such that $\textnormal{{S}}[j].x>b$.*

The two guard keys in S ensure that $i$ and $j$ exist. We claim $\mathsf{C1}$ \&$$\mathsf{C2}.

1. $\mathsf{C1}$

If $i+1\leq j-1$, then the keys in S dominated by $(b,c)$ are exclusively $\textnormal{{S}}[i+1],\textnormal{{S}}[i+2],\cdots,\textnormal{{S}}[j-1]$; otherwise, there is no key in S dominated by $(b,c)$. 2. $\mathsf{C2}$

If $(b,c)$ is not dominated by any key in S, then

[TABLE]

are $j-i$ mutually disjoint rectangles that jointly cover the growing part of the skyline when including $(b,c)$, i.e.,

[TABLE]

Proof.

We prove $\mathsf{C1}$ in two complementary cases.

Case $i+1>j-1$. Assume there is a key $\textnormal{{S}}[k]$ that is dominated by $(b,c)$. Then $\textnormal{{S}}[k].x\leq b<\textnormal{{S}}[j].x$ and $\textnormal{{S}}[i].y<c\leq\textnormal{{S}}[k].y$. By Lemma 18, $i<k$ and $k<j$. Hence $i\leq k-1\leq j-2$, which contradicts $i+1>j-1$. Thus, no key in S is dominated by $(b,c)$.

Case $i+1\leq j-1$. For any $k\notin[i+1,j-1]$, either $k\leq i$ or $k\geq j$. By the definition of $i$, $\textnormal{{S}}[k].y<c$ for $k\leq i$, and by the definition of $j$, $\textnormal{{S}}[k].x>b$ for $k\geq j$. For any $k\leq i$ or $k\geq j$, $(b,c)$ does not dominate $\textnormal{{S}}[k]$. For any $k\in[i+1,j-1]$, by the definitions of $i$ and $j$, we have $\textnormal{{S}}[k].x\leq b$ and $\textnormal{{S}}[k].y\geq c$. Since $(b,c)\notin\textnormal{{L}}$, we must have $(b,c)\neq\textnormal{{S}}[k]$. Thus $[b,c]\subset[\textnormal{{S}}[k].x,\textnormal{{S}}[k].y]$. Thus, $(b,c)$ dominates $\textnormal{{S}}[k]$ for $\forall k\in[i+1,j-1]$. This proves $\mathsf{C1}$.

We prove $\mathsf{C2}$ below by considering when $(b,c)$ is not dominated by any key in S. We first show $\textnormal{{S}}[i+1]$ exists in the augmented skyline by showing $i<j$. If otherwise, i.e.,, $i\geq j$, by Lemma 18, $\textnormal{{S}}[i].x\geq\textnormal{{S}}[j].x>b$, in addition, $\textnormal{{S}}[i].y<c$ by definition, thus $\textnormal{{S}}[i]$ dominates $(b,c)$, contradiction. $\textnormal{{S}}[j]$ exists and thus $\textnormal{{S}}[i+1]$ exists.

We then show $r_{i},r_{i+1},\cdots,r_{j-1}$ are mutually disjoint: the $y$-ranges of these rectangles, i.e., $[c,\textnormal{{S}}[i+1].y-1],[\textnormal{{S}}[i+1].y,\textnormal{{S}}[i+2].y],\cdots,$ $[\textnormal{{S}}[j-2].y,\textnormal{{S}}[j-1].y],[\textnormal{{S}}[j-1].y,\textnormal{{S}}[j].y]$ are mutually disjoint.

Next, consider any $(p,q)\in{\mathsf{rec}}(b,c)\setminus{\mathsf{rec}}(\textnormal{{S}})$, we show there exists $k\in[i,j-1]$ such that $(p,q)\in r_{k}$. Since $(p,q)\in{\mathsf{rec}}(b,c)$ and thus $q\in[c,n]$, $q$ will fall in exactly one of the 3 cases below.

• Case 1

: $q\in[c,\textnormal{{S}}[i+1].y-1]$,

• Case 2

: $q\in[\textnormal{{S}}[k].y,\textnormal{{S}}[k+1].y-1]$ for some $k\in[i+1,j-1]$,

• Case 3

: $q\in[\textnormal{{S}}[j].y,n]$.

In Case 1, the definition of $i$ ensures that $\textnormal{{S}}[i].y<c$. Besides, for any $\textnormal{{S}}[u]$ in the augmented skyline, $\textnormal{{S}}[u].y-1\leq n$, and thus $[c,\textnormal{{S}}[i+1].y-1]\subseteq[\textnormal{{S}}[i].y,n]$. $(p,q)$ is not dominated by any key in S including $\textnormal{{S}}[i]$ and $q\in[c,\textnormal{{S}}[i+1].y-1]$, $p\not\in[1,\textnormal{{S}}[i].x]$. As $(p,q)\in{\mathsf{rec}}(b,c)$, $p\in[1,b]$, and thus $p\in[\textnormal{{S}}[i].x+1,b]$. Thus, $(p,q)\in r_{i}$.

In Case 2, consider $k\in[i+1,j-1]$ such that $q\in[\textnormal{{S}}[k].y,\textnormal{{S}}[k+1].y-1]$. As $(p,q)\not\in{\mathsf{rec}}(\textnormal{{S}}[k])=[1,\textnormal{{S}}[k].x]\times[\textnormal{{S}}[k].y,n]$ and $p\in[\textnormal{{S}}[k].y,\textnormal{{S}}[k+1].y-1]\subseteq[\textnormal{{S}}[k].y,n]$, $p\not\in[1,\textnormal{{S}}[k].x]$. Together with $p\in[1,b]$, we have $p\in[\textnormal{{S}}[k].x+1,b]$. Thus $(p,q)\in r_{k}$.

Lastly, we show Case 3 is impossible. If $\textnormal{{S}}[j]=(n+1,n+1)$, then $[\textnormal{{S}}[j].y,n]=\phi$; otherwise, since $(p,q)$ is not dominated by $\textnormal{{S}}[j]$ and $q\in[\textnormal{{S}}[j].y,n]$, we have $p\not\in[1,\textnormal{{S}}[j].x]$. As $p\in[1,b]$, $\textnormal{{S}}[j].x>b\geq p>\textnormal{{S}}[j].x$, contradiction. Thus, Case 3 is impossible.

In conclusion, $\textnormal{{S}}[i+1]$ exists and thus the ranges of the three cases are well defined. Case 3 is impossible, thus $q$ can only fall in Case 1 or 2, and in either case, there is $k\in[i,j-1]$ s.t. $(p,q)\in r_{k}$. ∎

Now we prove Theorem 21. Firstly, it is trivial to verify GenerateKeys produces $\textnormal{{K}}(\textnormal{T})$. Algorithm 4 examines all keys in $\textnormal{{K}}(\textnormal{T})$ in the increasing order of their hash values. Let $(b,c)$ with hash value $v$ be the current visiting key and L be the set of visited keys. We prove by induction that at the end of each for-loop of Algorithm 4, S is the augmented skyline of $\textnormal{{L}}\cup\{(b,c)\}$ and the set of compact windows $\mathcal{P}(b,c)$ generated during the loop constitutes a partition of ${\mathsf{rec}}(b,c)\setminus{\mathsf{rec}}(\textnormal{{S}})$. Thus the union of all generated compact windows forms a partition of ${\mathsf{rec}}(\textnormal{{S}})$. Note that a guard key $(p,q)$ has ${\mathsf{rec}}(p,q)=\phi$, thus ${\mathsf{rec}}(\textnormal{{S}})={\mathsf{rec}}(\textnormal{{S}}(\textnormal{{L}}))$.

We assume S is the augmented skyline of L at the beginning of each for loop. This is true at the beginning of the first loop, when $\textnormal{{L}}=\phi$ and $\textnormal{{S}}=\{(0,0),(n+1,n+1)\}$. Clearly, S is the augmented skyline of L. Next, we consider two cases for each loop.

In the case there exists a key in S dominates $(b,c)$, by Lemma 19, Line LABEL:algo:skyline:5 evaluates to true and the loop ends111When using Lemma 19 on $\textnormal{{S}}(\textnormal{{L}})$, $j$ does not exist only if Line LABEL:algo:skyline:5 on augmented skyline S has $\textnormal{{S}}[j^{\prime}]$ taking the guard key $(0,0)$ – Line LABEL:algo:skyline:5 also tests false; otherwise, the same key is returned, i.e., $\textnormal{{S}}(\textnormal{{L}})[j]=\textnormal{{S}}[j^{\prime}]$. Thus, Line LABEL:algo:skyline:5 correctly facilitates Lemma 19.. S remains unchanged. The augmented skyline of $\textnormal{{L}}\cup\{(b,c)\}$ is S as $(b,c)$ is dominated. $\mathcal{P}(b,c)=\phi$ is a partition of ${\mathsf{rec}}(b,c)\setminus{\mathsf{rec}}(\textnormal{{S}})=\phi$.

In the case $(b,c)$ is not dominated by any key in $\textnormal{{S}}(\textnormal{{L}})$, by Lemma 19, Line LABEL:algo:skyline:5 evaluates to false. Furthermore, by Lemma 1($\mathsf{C1}$), all keys dominated by $(b,c)$ in S (if there is any) are precisely $\textnormal{{S}}[i+1],\cdots,\textnormal{{S}}[j-1]$. By the definition of skyline, $\textnormal{{S}}\cup\{(b,c)\}\setminus\{\textnormal{{S}}[i+1],\cdots,\textnormal{{S}}[j-1]\}$ must be the augmented skyline of $\textnormal{{L}}\cup\{(b,c)\}$. Next, we show that $\mathcal{P}(b,c)$ generated during the loop is a partition of ${\mathsf{rec}}(b,c)\setminus{\mathsf{rec}}(\textnormal{{L}})$.

Consider Lemma 1 ($\mathsf{C2}$) and determine $i$,$j$ and $r_{k}$ (denoted as $[a_{k},b_{k}]\times[c_{k},d_{k}]$), $k\in[i,j-1]$ accordingly. Note that $r_{k}\neq\phi$ only if $a_{k}\leq b_{k}$ and $c_{k}\leq d_{k}$. The tuples added to $\mathcal{P}(\textnormal{T},\textit{h})$ in Lines LABEL:algo:skyline:9-LABEL:algo:skyline:13 are

[TABLE]

First, any $W_{k}\in\mathcal{P}(b,c)$ is a compact window because by Lemma 10 and Lemma 14, all subsequences in ${\mathsf{rec}}(b,c)\setminus{\mathsf{rec}}(\textnormal{{S}}(\textnormal{{L}}))$ have min-hash $v$. Secondly, all the compact windows $W_{k}$ in $\mathcal{P}(b,c)$ constitute a partition of ${\mathsf{rec}}(b,c)\setminus{\mathsf{rec}}(\textnormal{{S}})$ because by Lemma 1 ($\mathsf{C2}$), the rectangles $\{r_{k}|k\in[i,j-1]\}$, form a partition of ${\mathsf{rec}}(b,c)\setminus{\mathsf{rec}}(\textnormal{{S}})$.

Since along the loop, the increments ${\mathsf{rec}}(b,c)\setminus{\mathsf{rec}}(\textnormal{{S}})$ are disjoint, the union of all generated $\mathcal{P}(b,c)$ forms a partition of ${\mathsf{rec}}(\textnormal{{S}}(\textnormal{{L}}))$.

The resulting $\mathcal{P}(\textnormal{T},\textit{h})$ satisfies the coverage condition in Definition 3: for every subsequence $\textnormal{T}[x,y]$ of T, $(x,y)$ is in ${\mathsf{rec}}(\textnormal{{S}}(\textnormal{{L}}))$ and is thus covered by exactly one compact window. Denote by $v$ the hash value of subsequence $\textnormal{T}[x,y]$. By Lemma 10, $\textnormal{T}[x,y]$ must contain a key, say $(b,c)$, with hash value $v$. Thus, $(x,y)\in{\mathsf{rec}}(b,c)\subseteq{\mathsf{rec}}(\textnormal{{S}}(\textnormal{{L}}))$. This completes the proof of Theorem 21.

Lemma 0.

Algorithm 4 with GenerateActiveKeys produces a partition of T.

Proof.

It is easy to verify GenerateActiveKeys produces all the active keys $\textnormal{{X}}(\textnormal{T})$. Based on Lemma 26, for any non-active key $(b,c)$, it is skipped in our algorithm, which means $\mathcal{P}(b,c)=\phi$. Based on the proof of Theorem 21, Algorithm 4 with GenerateActiveKeys produces a partitioning of T. ∎

Appendix B Lower Bound Analysis

This section analyzes the lower bound of the partition generation problem. A hard case is when all the tokens are the same, i.e., there is only one token $t$ in the text T. Next we show every partition $\mathcal{P}(\textnormal{T},\textit{h})$ has $\Omega(n\log n)$ compact windows in expectation in the worst case. Formally, we define two subsequences are mergeable as below.

Definition 0 (Mergeable).

Given text T and hash function h, two subsequences $\textnormal{T}[i,j]$ and $\textnormal{T}[p,q]$ are mergeable if they can be represented by the same compact window $\langle\textnormal{T},\textit{h},v,a,b,c,d\rangle$, i.e., $i,p\in[a,b]$, $b\leq c$, $j,q\in[c,d]$, and $\textit{h}(\textnormal{T}[x,y])=v,\forall x\in[a,b],y\in[c,d]$.

Clearly, for a set of subsequences from the same text that are mutually not mergeable, it needs at least one compact window in the partition for each subsequence in the set. Thus we analyze the lower bound of the partition generation problem by constructing a set of subsequences that are mutually not mergeable.

Lemma 0.

For a text T of length $n$ of one token $t$, i.e., all tokens in T are duplicate, any partition $\mathcal{P}(\textnormal{T},\textit{h})$ of T contains $\Omega(n+n\log n)$ compact windows in expectation. The expectation is introduced by the randomness of the hash function as opposed to any other assumption.

Proof.

Let $\textit{h}(t,x_{1}),\textit{h}(t,x_{2}),\cdots,\textit{h}(t,x_{m})$ be all the active hash of the token $t$ where $1\leq x_{1}<x_{2}<\cdots<x_{m}\leq n=|\textnormal{T}|$. That means, $\textit{h}(t,x_{j})>\textit{h}(t,x_{i})$ for every $1\leq j<i\leq m$. Construct a set of subsequences $S=S_{1}\cup S_{2}\cup\cdots\cup S_{m}$ where $S_{i}=\{\textnormal{T}[p,q]\mid q-p+1=x_{i}\}$. That is to say, $S_{i}$ is the set of all subsequences in T containing exactly $x_{i}$ tokens. Consider two sets $S_{i}$ and $S_{j}$ where $1\leq i\neq j\leq m$. First, they must be disjoint as the lengths of their subsequences are different. Furthermore, based on the definition of active hash, the min-hash of subsequences in $S_{i}$ and $S_{j}$ are respectively $\textit{h}(t,x_{i})$ and $\textit{h}(t,x_{j})$. Since $x_{i}\neq x_{j}$, the subsequences from $S_{i}$ and $S_{j}$ are not mergeable based on Definition 1.

Assume that there are two distinct subsequences $\textnormal{T}[p_{1},q_{1}]$ and $\textnormal{T}[p_{2},q_{2}]$ from the same set $S_{i}$ that are mergeable. As they all of the same length and are distinct, either $p_{1}<p_{2}$ or $p_{1}>p_{2}$. Without loss of generality, assume $p_{1}<p_{2}$. As the two subsequences are mergeable, there exists a compact window $\langle\textnormal{T},\textit{h},v,a,b,c,d\rangle$ representing both subsequences. Thus $p_{1}<p_{2}\leq b\leq c\leq q_{1}$. The subsequence $\textnormal{T}[b,c]$ then contains less than $x_{i}$ tokens because $c-b+1\leq q_{1}-p_{2}+1=(q_{1}-p_{1}+1)+p_{1}-p_{2}=x_{i}+p_{1}-p_{2}<x_{i}$. Thus $\textit{h}(\textnormal{T}[b,c])>x_{i}$ since $\textit{h}(t,x_{i})$ is active hash, contradicting the definition of a compact window, i.e., $\textit{h}(\textnormal{T}[b,c])=\textit{h}(\textnormal{T}[p_{1},q_{1}])=\textit{h}(t,x_{i})$.

Based on the discussion above, the subsequences in $S$ are mutually not mergeable. Next, we calculate the expected size of $S$. There are $n-x_{i}+1$ subsequences in $S_{i}$. Thus $|S|=\sum_{i=1}^{m}(n-x_{i}+1)$. Let us consider an arbitrary index $j\in[1,n]$. We observe that $j=x_{i}$ for some $i\in[1,m]$ if and only if $\textit{h}(t,j)$ is the smallest among $\textit{h}(t,1),\textit{h}(t,2),\cdots,\textit{h}(t,j)$. The probability is $\frac{1}{j}$. Thus we have

[TABLE]

Note that when $n=1$, $\mathbb{E}[|S|]=1$, besides, $n\leq n\log n$ when $n\geq 2$. So $\mathbb{E}[|S|]=\Omega(n\log n+n)$. The subsequences in $S$ are mutually not mergeable. One compact window is needed to represent each of the subsequence in $S$. Thus any partition $\mathcal{P}(\textnormal{T},\textit{h})$ contains $\Omega(n\log n+n)$ compact windows in expectation. ∎

Lemma 2 shows a hard case in terms of partition size. The reason we keep factor $n$ in the lower bound is for the special case when $n=1$. This will be useful when we conduct frequency-aware analysis below.

When $f_{\textnormal{T}}\ll n$. Next we consider the cases when we know the length and the maximum token frequency $f_{\textnormal{T}}$ of a text.

Lemma 0.

Consider integer $n>0$ and $f_{\textnormal{T}}\in[1,n]$, there is a text T of length $n$ and maximum frquency $f_{\textnormal{T}}$ such that any partition $\mathcal{P}(\textnormal{T},\textit{h})$ of T contains $\Omega(n+n\log f_{\textnormal{T}})$ compact windows in expectation.

Proof.

Without loss of generality, assume that $n$ is a multiple of $f_{\textnormal{T}}$. Let $m$ be $\frac{n}{f_{\textnormal{T}}}$. Let $\textnormal{T}=t_{1}t_{1}\cdots t_{1}t_{2}t_{2}\cdots t_{2}\cdots t_{2}t_{m}\cdots t_{m}$ where each $t_{i}$ (where $1\leq i\leq m$) appears $f_{\textnormal{T}}$ times next to each other in T.

We construct a set of subsequences $S=S^{1}\cup S^{2}\cup\cdots\cup S^{m}$ where $S^{i}$ is constructed in the same way as in the proof in Lemma 2 for $t_{i}$. The subsequences within each $S^{i}$ are mutually not mergeable as shown earlier. Next we show any two subsequences $\textnormal{T}[p_{1},q_{1}]$ and $\textnormal{T}[p_{2},q_{2}]$ from $S^{i}$ and $S^{j}$ (where $i\neq j)$ are not mergeable. This is obvious as $\textit{h}(\textnormal{T}[p_{1},q_{1}])=\textit{h}(t_{i},x)$ for some $x\in[1,f_{i}]$ and $\textit{h}(\textnormal{T}[p_{2},q_{2}])=\textit{h}(t_{j},y)$ for some $y\in[1,f_{y}]$. However, $\textit{h}(t_{i},x)\neq\textit{h}(t_{j},y)$ assuming the universal hash function h has no collision.

Based on the discussion above, it needs $\Omega(f_{\textnormal{T}}(1+\log f_{\textnormal{T}}))$ compact windows to represent all the subsequences $\textnormal{T}[p,q]$ where $\textnormal{T}[p]=\text{[}q]=t_{i}$ for each $1\leq i\leq m$. Thus in total, it needs $\Omega(\sum_{i\in[m]}f_{\textnormal{T}}(1+\log f_{\textnormal{T}}))=\Omega(n+n\log f_{\textnormal{T}})$ compact windows to represent all the subsequences in T. Thus every partition $\mathcal{P}(\textnormal{T},\textit{h})$ has $\Theta(n+n\log f_{\textnormal{T}})$ compact windows. ∎

Now we prove Theorem 23. Theorem 21 shows that the expected number of compact windows of Algorithm 4 is $O(n+n\log f_{\textnormal{T}})$ while Lemma 3 shows a case of T, given $n$ and $f_{\textnormal{T}}$, such that no partition can have the number of compact windows smaller than $\Omega(n+n\log f_{\textnormal{T}})$ in expectation. Thus, given $n$ and $f_{\textnormal{T}}$, Algorithm 4 is optimal in the worst case.