Quotient Hash Tables - Efficiently Detecting Duplicates in Streaming Data

TL;DR

This paper introduces the Quotient Hash Table (QHT), a novel data structure for efficient duplicate detection in streaming data, achieving significant memory savings and improved analysis over previous methods.

Contribution

The paper presents the QHT and QQHTD data structures, offering a corrected analysis, reduced memory usage, and insights into adversarial input effects for hash-based duplicate filters.

Findings

33% reduction in memory usage compared to previous methods

Thorough analysis of QHT and SQF algorithms

Discussion on adversarial input impacts

Abstract

This article presents the Quotient Hash Table (QHT) a new data structure for duplicate detection in unbounded streams. QHTs stem from a corrected analysis of streaming quotient filters (SQFs), resulting in a 33\% reduction in memory usage for equal performance. We provide a new and thorough analysis of both algorithms, with results of interest to other existing constructions. We also introduce an optimised version of our new data structure dubbed Queued QHT with Duplicates (QQHTD). Finally we discuss the effect of adversarial inputs for hash-based duplicate filters similar to QHT.

Tables

Table 1. Table 1: Error rates of QHTs with the same asymptotic FPR

	$S=4$	$S=8$	$S=16$	$S=32$	$S=64$
$\mathrm{FPR}$ (%)	22.57	23.25	23.53	23.62	23.50
$\mathrm{FNR}$ (%)	35.89	44.24	50.77	54.55	58.73
$\mathrm{FPR}+\mathrm{FNR}$	58.45	67.49	74.30	78.17	82.23

Table 2. Table 2: Error rate (multiplied by 100 100 100 ) on streams of 150,000,000 elements

Stream (duplicate %)	Memory (bits)	SQF	QHT QQHTD	Cuckoo	SBF	A2	b_DBF
Real (10.3 %)	8e+06	51.25	43.78	66.48	54.08	58.94	45.22
	1e+06	55.18	48.38	68.96	57.17	62.12	45.30
	100,000	58.21	52.22	71.83	59.44	64.88	59.39
	10,000	66.45	58.75	78.86	76.29	66.42	99.77
Artificial (88.82 %)	8e+06	86.49	82.76	96.94	97.79	88.06	99.96
	1e+06	98.27	97.80	99.60	99.74	98.49	99.96
	100,000	99.78	99.79	99.96	99.98	99.84	99.96
	10,000	99.97	99.97	100.02	99.99	100.00	99.98
Artificial (39.79 %)	8e+06	96.51	95.37	99.21	99.40	96.86	99.99
	1e+06	99.56	99.42	99.91	99.91	99.60	99.99
	100,000	99.94	99.95	100.00	99.99	99.96	99.98
	10,000	100.00	100.00	100.00	100.00	99.99	100.00

Table 3. Table 3: Average amount of time (in µ µ µ s) required for one iteration of 𝖲𝗍𝗋𝖾𝖺𝗆 𝖲𝗍𝗋𝖾𝖺𝗆 \mathsf{Stream} on each filter with 1 Mb of memory

Filter	SQF	QHT	QQHTD	Cuckoo	SBF	A2	b_DBF
Time	0.423	0.288	0.330	2.464	1.578	1.280	2.565

Table 4. Table 4: Results of filters for various streams of 150,000,000 elements (FPR/FNR in %)

Stream (duplicate %)	Memory (bits)	SQF	QHT/QQHT	Cuckoo	SBF	A2	b_DBF
Real (10.3 %)	8e+06	24.61/26.64	14.00/29.78	28.23/38.26	25.10/28.98	37.72/21.21	0.00/45.22
	1e+06	24.95/30.22	14.25/34.14	28.30/40.65	25.23/31.94	38.00/24.11	0.15/45.16
	100,000	24.99/33.22	14.28/37.94	28.33/43.51	25.42/34.03	38.05/26.83	25.75/33.64
	10,000	25.00/41.45	14.29/44.46	28.37/50.49	26.00/50.29	38.01/28.41	99.58/0.20
Artificial (88.82 %)	8e+06	21.87/64.62	12.02/70.74	27.80/69.14	25.94/71.85	35.22/52.84	0.00/99.96
	1e+06	24.60/73.67	14.00/83.80	28.41/71.19	26.43/73.30	37.72/60.77	0.17/99.79
	100,000	24.94/74.84	14.26/85.53	28.52/71.44	26.49/73.49	38.00/61.83	27.46/72.51
	10,000	24.98/74.99	14.28/85.69	28.55/71.47	26.50/73.50	38.03/61.97	99.67/0.31
Artificial (39.79 %)	8e+06	24.42/72.09	13.86/81.52	28.39/70.82	26.40/73.00	37.54/59.32	0.00/99.99
	1e+06	24.92/74.64	14.24/85.18	28.50/71.41	26.47/73.44	38.00/61.60	0.17/99.82
	100,000	24.99/74.96	14.29/85.66	28.51/71.49	26.49/73.50	38.05/61.91	27.46/72.52
	10,000	25.00/74.99	14.28/85.72	28.52/71.49	26.49/73.51	38.02/61.97	99.69/0.31

Table 5. Table 5: Error rate (times 100 100 100 ) of QHTs and QQHTDs with the same parameters on different streams, depending on their parameters k 𝑘 k and S 𝑆 S

Stream (duplicate %)	Filter	$k=2,S=8$	$k=4,S=16$	$k=8,S=32$	$k=16,S=64$
Real (10.3 %)	QHT	27.01	28.07	28.95	29.3
	QQHTD	24.67	24.56	24.42	24.62
Artificial (4.62 %)	QHT	67.39	74.48	79.32	82.10
	QQHTD	67.91	74.41	79.19	82.26

Equations

$${\mathrm{FPR}}_{\infty }\approx \frac{k}{2^{r^{\prime }}\sqrt{\pi r}}{\mathrm{FNR}}_{\infty }\approx 1-\frac{k}{2^{r^{\prime }}\sqrt{\pi r}}$$

$${\mathrm{FP}}_m$$

$$e_j\text{ is not evicted until }e\text{ arrives})$$

$$=\sum _{j=1}^m{\left(1-P_{\text{fd}}\right)}^{m-j}{P}_{\text{fd}}\times P(\text{hc}{)}_j$$

$$=\sum _{j=1}^m{\left(1-P_{\text{fd}}\right)}^{m-j}{P}_{\text{fd}}{\left(1-\frac{S-k}{k(NS-1)}\right)}^{m-j}$$

$$=P_{\text{fd}}\frac{1-{\left[\left(1-P_{\text{fd}}\right)\left(1-\frac{S-k}{k(NS-1)}\right)\right]}^m}{1-\left(1-P_{\text{fd}}\right)\left(1-\frac{S-k}{k(NS-1)}\right)}$$

$$=\frac{1}{NS}\frac{1-{\left[\left(1-\frac{1}{NS}\right)\left(1-\frac{S-k}{k(NS-1)}\right)\right]}^m}{1-\left(1-\frac{1}{NS}\right)\left(1-\frac{S-k}{k(NS-1)}\right)}$$

$$=\frac{1-{\left[1-\frac{S-k}{(NS-1)k}-\frac{1}{NS}+\frac{S-k}{kNS(NS-1)}\right]}^m}{1+\frac{NS(S-k)}{(NS-1)k}-\frac{1}{k}\frac{S-k}{NS-1}}$$

$$=\frac{1-{\left[1-\frac{1}{NS}-\frac{S-k}{NSk}\right]}^m}{1+\frac{S-k}{k}}$$

$$=\frac{k}{S}\left(1-{\left[1-\frac{1}{Nk}\right]}^m\right)$$

$${\mathrm{FN}}_{i,m}=$$

$$=$$

$$+ab\sum _{j=i+1}^m\left[{\left(1-a\right)}^{j-i-1}{c}^{m-j}\right]$$

$${\mathrm{FN}}_{i,m}=$$

$${\mathrm{FN}}_m$$

$${\mathrm{FNR}}_{\infty }=$$

$$+\frac{ab}{(1-a-c)(U-(U-1)(1-a))}$$

$$-\frac{ab}{(1-a-c)(U-(U-1)c)}$$

$$\frac{M_{\text{QHT}}}{M_{\text{SQF}}}$$

$${\mathrm{FPR}}_m$$

$$=\frac{k}{S}\left(1-{\left[1-\frac{{\log }_2(S)}{M}\right]}^m\right)$$

$${\mathrm{FNR}}_n$$

$$\left(1-(1-a{)}^{m-i}\right)+ab\frac{(1-a{)}^{m-i}-c^{m-i}}{1-a-c}]$$

$${\mathrm{FNR}}_n$$

$$+(1-b)\sum _{i=1}^m{\left(\frac{U-1}{U}\cdot (1-a)\right)}^{m-i}$$

$$+\frac{ab}{1-a-c}\sum _{i=1}^m{\left(\frac{U-1}{U}(1-a)\right)}^{m-i}$$

$$+\frac{ab}{1-a-c}\sum _{i=1}^m{\left(\frac{U-1}{U}c\right)}^{m-i}]$$

$${\mathrm{FNR}}_n=$$

$$+(1-b)\frac{1-{\left((1-1/U)(1-a)\right)}^m}{1-(1-a)(U-1)/U}$$

$$+\frac{ab}{1-a-c}\frac{1-{\left((1-1/U)(1-a)\right)}^m}{1-(1-a)(U-1)/U}$$

$$-\frac{ab}{1-a-c}\frac{1-{\left((1-1/U)c\right)}^m}{1-c(U-1)/U}]$$

$${\mathrm{FNR}}_{\infty }=$$

$$+\frac{ab}{(1-a-c)(U-(U-1)(1-a))}$$

$$-\frac{ab}{(1-a-c)(U-(U-1)c)}$$

Full text

We also introduce an optimised version of our new data structure dubbed Queued QHT with Duplicates (QQHTD).

Finally we discuss the effect of adversarial inputs for hash-based duplicate filters similar to QHT.

1 Introduction and Motivation

We consider in this paper the following problem: given a possibly infinite stream of symbols, detect whether a given symbol appeared somewhere in the stream. It turns out that instances of this duplicate detection problem arise naturally in many applications: backup systems  [11] or Web caches [10], search engine databases or click counting in web advertisement  [16] , retrieval algorithms [3], data stream management systems [1], or even cryptographic contexts where nonce-reuse is problematic111A nonce is a one-time use random number. [15].

It is generally not possible to store the whole stream in memory, therefore practical solutions to this problem must somehow trade off memory for accuracy. The special case of a single duplicate has a known optimal solution [13, 14], but to the best of the authors knowledge no such results exists for detecting all duplicates in an unbounded stream.

Several algorithms were proposed to address this specific question, which we discuss below. Of particular interest to our investigation are Streaming Quotient Filter (SQF), as described by Dutta et al. in [8]. We point out several crucial mistakes in the original analysis of SQF, and in doing so highlight that a more efficient data structure can be constructed along the same lines. We flesh out such a data structure, which we call the Quotient Hash Table (QHT), and provide a thorough analysis of both SQF and QHT. This analysis is our main contribution. QHT itself is not optimal and can be further improved: we describe such an improvement, dubbed Queued QHT with Duplicates (QQHT), and benchmark our new algorithms against popular alternatives.

2 Preliminaries and related work

2.1 Duplicate Detection

Let $E=(e_{1},\dotsc,e_{n},\dotsc)$ be a (possibly infinite) sequence of elements $e_{i}\in\Gamma$, and write $U=|\Gamma|$. An element $e_{i}$ from $E$ is a duplicate if $\exists e_{j}\in E,j<i$ such as $e_{j}=e_{i}$. Otherwise, $e_{i}$ is unseen.222Note that by definition $e_{1}$ is always unseen.

The duplicate detection problem is the question of finding all duplicates in a stream $E$.333Note that this problem is equivalent to a dynamic formulation of the approximate set membership problem. We recall the following well-known result:

Theorem 2.1**.**

Assume that each $e_{i}$ is sampled uniformly at random from $\Gamma$. Then perfect detection requires $U$ memory bits.

Proof.

A perfect duplicate filter must be able to store all streams $E_{i}=(e_{1},\dotsc,e_{n})$, i.e. must be able to store any subset of $\Gamma$, which we denote by $\mathcal{P}(\Gamma)$. Given that there are $|\mathcal{P}(\Gamma)|=2^{|\Gamma|}=2^{U}$ of them, according to information theory any such filter requires at least $\log_{2}(|\mathcal{P}(\Gamma)|)=\log_{2}(2^{U})=U$ bits of storage.

∎

Because of this result, perfect duplicate detection is often out of reach when $U$ is big — however probabilistic solutions are often sufficient for many applications. Such algorithms make errors: false positives (claiming a duplicate where there isn’t) and false negative (missing a duplicate).

2.2 Filters

Definition 2.1** (Filter).**

A filter $F$ over the memory $\mathcal{M}$ is a tuple $F=(\mathcal{S},\textsf{Detect},\textsf{Insert})$, where:

• •

$\mathcal{S}\in\mathcal{M}$ is the current state

• •

$\textsf{Detect}:\Gamma\times\mathcal{M}\to\{\textsf{DUPLICATE},\textsf{UNSEEN}\}$

• •

$\textsf{Insert}:\Gamma\times\mathcal{M}\to\mathcal{M}$

Here DUPLICATE corresponds to a guess that the provided element is duplicate, and UNSEEN that it is unseen. Insert corresponds to an update of the filter’s memory state after observing a new element. Here $\mathcal{M}$ models the amount of memory (states) available to the algorithm.

In practice, Detect and Insert are often merged into a single algorithm $\textsf{Stream}\leftarrow\textsf{Insert}\circ\textsf{Detect}$.

Definition 2.2** (False positive (resp. negative)).**

If, for an unseen (resp. duplicate) element $e$, $\textsf{Detect}(e)$ outputs DUPLICATE (resp. UNSEEN), $e$ is called a false positive (resp. negative).

Definition 2.3** (FPR, FNR).**

The false positive rate (FPR) of a stream $E$ is the frequency of false positive. The false negative rate is similarly defined as the frequency of false negatives.

We are interested in filters that whose FNR and FPR can be kept low when $\mathcal{M}$ is bounded.

2.3 Hash-based filters

Filters rely on hashing to efficiently answer the duplicate detection problem. These filters are often a variation over the well-known Bloom filters [2]. A Bloom filter uses an array $T$ of $M$ bits, initially all set to [math]. $k$ hash functions $h_{i}$ are also needed. Insertion of an element $e$ is made by setting all $T[h_{i}(e)]$ to $1$. Detection of an element $f$ is the AND of all cells $T[h_{i}(f)]$: if the AND value is [math], then emit UNSEEN, otherwise emit DUPLICATE.

It is easy to see that this approach has a FNR of 0. However, as the stream grows, the FPR gets worse, and in the limit of an infinite stream the FPR is 1. Many variants have been proposed in the literature to compensate for this effect [20], mostly by allowing deletion [5, 6], but doing so increases the FNR.

Alternatively, other filters prefer to store fingerprints: this is the rationale behind several recent constructions [8, 9].

For the data structures most interesting to our question, we refer the reader to the algorithms described in [7, 9, 19, 8, 22].444Cuckoo filters [9] requires a minimal adaptation for unbounded streams: in the original paper, failure is emitted after some number of relocations; we just discard the failure. Theoretical analysis of this new structure is not addressed in this paper.

Other data structures, such as [4, 12] are not considered in this paper, as they require an unbounded amount of memory as the stream grows.

2.4 Streaming Quotient Filter

One construction which we must describe at length is the Streaming Quotient Filter (SQFs) [8]. Given an element $e$, a certain fingerprint555[8] refers to them as “signatures”, but we shun this term to avoid any claim of cryptographic properties. $s(e)$ is stored in an array, at row $h(e)$ and a certain column amongst $k$. This array constitutes the filter’s state.

The filter’s construction uses integers $q$, $k$, $r$ $r^{\prime}<r$ and a hash function $h:\{0,1\}^{*}\to\{0,1\}^{q+r}$. The filter’s state is an array of $2^{q}$ rows and $k$ columns, each holding a $\sigma$-bit element (with $\sigma=r^{\prime}+\lceil\log_{2}(r+1)\rceil$), or the special empty symbol $\bot$. The filter’s state is initially $\bot$ in every cell.

Then, [8] describes $\mathsf{Stream}(e)$ as follows:

• •

Compute $h(e)$. The $q$ most significant bits of $h(e)$ define $h_{e}^{q}$, and the $r$ least significant bits define $h_{e}^{r}$.

• •

Let $w_{e}$ be the Hamming weight of $h_{e}^{r}$, and let $h_{e}^{r^{\prime}}$ be $r^{\prime}$ bits deterministically chosen666E.g., the $r^{\prime}$ least significant bits of $h_{e}^{r}$. from $h_{e}^{r}$. Let $s(e)\leftarrow h_{e}^{r^{\prime}}\|w_{e}$ where $\|$ denotes concatenation.

• •

If $s(e)$ is already stored in the row numbered $h_{e}^{q}$, emit DUPLICATE.

• •

Otherwise, store it in one empty cell of that row. If no empty cell exists in the row, store $s(e)$ in one random cell of the row, replacing any fingerprint previously stored there. Emit UNSEEN.

3 Revisiting SQF: Quotient Hash Table

SQF is introduced and analysed in [8]. However, a careful reading reveals several crucial mistakes in that analysis. We focus here on two of them that directly impact the claim of SQF near-optimality. Note that here, as in the rest of this paper, hash functions are modelled as pseudo-random functions.

Cells in the filter’s state are not independent: in particular, in every row, non-empty cells hold different values (by design); 2. 2.

Terms in geometric sums of order $>1$ cannot be neglected.

Taking these effects into account (see Sections 4.1 and 4.2), and using the same approximation than [8] used777Even though not mentioned in [8], the approximation (stemming from Catalan numbers) is only asmptotatically valid, but computations show that the approximation is correct even for small values of $r$, such as the ones used in practical applications., $\binom{2r}{r}\approx\frac{4^{r}}{\sqrt{\pi r}}$, we get the following asymptotic formulae for the FNR and FPR

[TABLE]

that disagree with [8] — most importantly, the error rates do not decrease to [math], contrarily to what was claimed. Interestingly, the suggested parameters ($r=2$, $k=4$, $r^{\prime}=r/2=1$) indeed achieve an FNR of [math] — but also an FPR of 1.888With these values, only $4$ distinct fingerprints exist, and they can all be stored in the $4$ cells per row. When the filter is full, any duplicate will be reported as such, hence a FNR of [math]. But every new element will also be reported as duplicate, hence a FPR of $1$.

Further more, there is redundancy between the Hamming weight $w_{e}$ of $h_{e}^{r}$ and the reduced remainder $h_{e}^{r^{\prime}}$. For instance, if $h_{e}^{r^{\prime}}$ contains at least one bit set to $1$, we know that $w_{e}\neq 0$. Intuitively this means SQF is wasteful, and we could expect to avoid collisions in the filter’s state by using a better adjusted encoding: this intuition happens to be correct as shown in Section 4.4.

Finally, since the state table contains $2^{q}$ rows, with $k$ cell each, the total memory required by an SQF is $M=2^{q}k\sigma$.

3.1 Full-size Hashing, Memory Adjustments

Our first observation is that SQF’s fingerprint scheme (a hash and a Hamming weight) can be fruitfully replaced by a single hash function of the same size. Not only does this simplify the theoretical analysis, it also provides a much more efficient use of the available space. We also use more flexible hash functions, that give much more flexibility in adjusting the total memory $M$ of the filter. Combining these two effects, we obtain Algorithm 1 which we call Quotient Hash Table (QHT).

3.2 Empty Cells

SQF and QHT as described above make essential use of the “empty” cells in $T$. The need for this feature is present for all fingerprint-based structures including Cuckoo filters [9].999Other constructions do not face this issue, including SBF [7] and b_DBF [19]: in these schemes, [math] always codes for absence. However, a low-level implementation cannot rely on the availability of such a special value. Our options are to initialise all cells to [math] and either

treat [math] as a fingerprint; 2. 2.

if an element has a fingerprint of [math], reassign its fingerprint to $1$; 3. 3.

while an element has a fingerprint [math], compute a new fingerprint based on some deterministic scheme.

The first option is at a risk of a high false positive rate, even for small streams: when a new element, whose fingerprint is [math], should be stored in an empty bucket, it is instead dismissed as a duplicate. More specifically, before the filter is completely filled, a new element has probability at least $\frac{1}{S}$ to be false positive, which leads to a high number of false positive at the beginning of any stream.

The second option is significantly faster than the third101010The third option needs, on average, $\frac{S}{S-1}$ hash computations for each insertion, whereas the second option only needs 1., which on the other hand has better statistical properties, making the analysis simpler. While the second option was preferred by [9] in their implementation111111https://github.com/efficient/cuckoofilter/blob/aac6569cf30f0dfcf39edec1799fc3f8d6f594da/src/cuckoofilter.h, we retain the slower, but easier to analyse option.

3.3 Semi-sorting

The technique of semi-sorting was introduced in [9] to shave some extra storage. The idea is as follows: treating empty cells as buckets containing the “0” fingerprint, for each row, sort the cells by their fingerprints, and then encode the result as a number.

As an example, for $s=4$ and $k=4$ there are only 3,876 possible sorted states, which can be encoded using $12$ bits, as opposed to the $16$ bits required to store four 4-bit fingerprints.

3.4 Comparison with Hash Tables

As the name implies, QHT are related to hash tables. Indeed, a hash table is a QHT, wherein the number of rows is equal to $1$. In particular, QHT cannot have worse performances than such structures, and bear similarities with so-called compaction techniques [21].

4 Error Rate Analysis

4.1 False Positive Rate

Consider a QHT with $N$ rows, $k$ buckets per row, and $s$-bits fingerprints. For simplicity, further assume that no bucket is empty (which is true after some time), and that the stream is sampled uniformly at random from $\Gamma$.

Theorem 4.1**.**

For a QHT of $N$ rows, $k$ buckets per row and $S$ possible fingerprints, as the number of insertions goes to infinity, the FPR goes to $k/S$. Moreover the probability that an unseen element inserted after $m$ other elements triggers a false positive is $\displaystyle\operatorname{FP}_{m}=\frac{k}{S}\left(1-\left[1-\frac{1}{Nk}\right]^{m}\right)$.

Proof.

An element $e$ is a false positive if and only if $e$ has not been encountered yet, but $\textsf{Detect}(e)=\textsf{DUPLICATE}$. This event is triggered by the presence, in the filter, of another element $e^{\prime}$ with a hash and fingerprint colliding with those of $e$. $e^{\prime}$ is called a false duplicate, and if $e^{\prime}$ is still in the filter when $e$ arrives, we refer to the event as a hard collision.

Our first remark is that the only false duplicate that may create a hard collision with $e$ is the last false duplicate inserted before $e$ arrives: let us assume that $e_{1}$, $e_{2}$ are false duplicates, and that $e_{1}$ arrives before $e_{2}$. When we insert $e_{2}$ in the filter, $e_{1}$ is either still in the filter or has been evicted.

• •

If $e_{1}$ has been evicted, then $e_{1}$ will not hardly collide with $e$.

• •

If $e_{1}$ is still in the filter, then $e_{2}$ will be claimed as a duplicate and dismissed.

However, if we look at the table $T$ storing all fingerprints, dismissing $e_{2}$ is strictly equivalent to replacing $e_{1}$ by $e_{2}$. Consequently, every false duplicate is erased by any new false duplicate, and only the last false duplicate can cause a hard collision. As a result, we will only focus on the probability that the last false duplicate (before $e$ arrives) causes a hard collision.

Let us assume that the last false duplicate appears at position $i$ of the stream $E=\{e_{1},e_{2},\dotsc,e_{m},e\}$, in other words, $e_{i}$ is the last false duplicate in the stream before $e$.

Now, $e_{i}$ has to remain in the filter until $e$ arrives, even though new elements are added. Let us suppose that element $e_{j}$, $i<j\leq m$, does not evict $e_{i}$ from the filter. For $e_{i}$ to be evicted, the following conditions must be true:

• •

$h(e_{j})=h(e_{i})$

• •

$s(e_{j})$ is different from all the other fingerprints stored in the row $T[h(e_{j})]$ (knowing that one of the buckets contains $s(e_{i})$)

• •

$s(e_{j})$ is inserted into the bucket in which $s(e_{i})$ is stored

Since we know that $e_{i}$ is the last false duplicate, we cannot simultaneously have $h(e_{j})=h(e_{i})$ and $s(e_{j})=s(e_{i})$. As such, the first two conditions are not independent. Let $P_{\text{hs}}$ be the probability that these two conditions are satisfied. Given that $e_{i}$ is the last false positive, there are only $NS-1$ possibilities for the couple ($h(e_{j}),s(e_{j}))$. Moreover, among these $NS-1$ states, only $S-1$ verify the first condition, and among these $S-1$ states, only $S-k$ verify the second condition. Finally, $P_{\text{hs}}=\frac{S-k}{NS-1}$. If we assign the last event to the probability $P_{\text{selection}}$, we immediately get $P_{\text{selection}}=\frac{1}{k}$.

Finally, the probability $P_{\neg\text{evict}}$ of $e_{i}$ not being evicted by $e_{j}$ is $P_{\neg\text{evict}}=1-P_{hs}P_{\text{selection}}$ and: $P_{\neg\text{evict}}=1-\frac{S-k}{k(NS-1)}$

Now, $e_{i}$ has to avoid eviction by every element before $e$ arrives, i.e. by all elements $e_{i+1},\dotsc,e_{m}$, which happens with probability $P({\text{hc}})_{i}=\left(P_{\neg\text{evict}}\right)^{m-i}$.

At that point, we know the probability that a hard collision happens when the last false duplicate has been inserted at position $i$.

The probability of any element $e^{\prime}$ being a false duplicate is $P_{\text{fd}}=\frac{1}{N}\frac{1}{S}$. In the stream $E=(e_{1},\dotsc,e_{m},e)$, the last false duplicate is $e_{m}$ with probability $P_{\text{fd}}$; it is $e_{m-1}$ with probability $\left(1-P_{\text{fd}}\right)P_{\text{fd}}$; and $e_{m-k}$ with probability $\left(1-P_{\text{fd}}\right)^{k}P_{\text{fd}}$. The probability that the next element will result in a false positive after $m$ elements are inserted, is equal to the probability that the last false duplicate is not evicted. Thus the probability $\operatorname{FP}_{m}$ that a false positive happens after $m$ elements are inserted is

[TABLE]

[TABLE]

We now have the probability that a new element $e$, inserted after $m$ insertions, is detected as a false positive.

Assuming the stream is of size $n$, and noting $\operatorname{FPR}_{n}$ its false positive rate, we get that $\operatorname{FPR}_{n}$ is equal to the averages of all $\operatorname{FP}_{m}$ of its stream, i.e., $\displaystyle\operatorname{FPR}_{n}=\frac{1}{n}\sum_{m=1}^{n}\operatorname{FP}_{m}$. Given that $\displaystyle\lim_{m\to\infty}\operatorname{FP}_{m}=\frac{k}{S}$ and using Cesàro’s mean properties, we get, as one could have expected, $\operatorname{FPR}_{n}\xrightarrow[n\to\infty]{}\frac{k}{S}$. ∎

Thanks to the expression of $\operatorname{FP}_{m}$, we can see that the more rows there are, the slower the FPR reaches its asymptotic (saturated) value.

A similar phenomenon can be observed with the Stable Bloom Filter [7]121212In a Stable Bloom Filter, the FPR is bounded by $\displaystyle\left(1-\left(\frac{1}{1+\frac{1}{P\left(1/K-1/m\right)}}\right)^{\text{Max}}\right)^{K}$, where $m$ is the number of rows, and $K$, $P$, Max are diverse filter parameters. We clearly see that a higher number of rows will only decrease the FPR down to a certain point, but no further.: adding rows will only decrease the FPR to a certain point. An other structure adapted to streaming data we found, the block decaying Bloom Filter [19], operates on a sliding window and therefore did not use the same False Positive definition as the one we did131313More precisely, their definition false positive definition is restrained to the sliding window. So an element is a false positive if is not already present in the sliding window, and yet marked as a duplicate..

4.1.1 Application to SQF

One should be tempted to directly apply this result to an SQF. However, as pointed out earlier, in an SQF fingerprints are correlated and therefore not equiprobable141414For example, consider the SQF with the parameters $r=3$, $r^{\prime}=1$. Only the hash $h^{r}_{1}=000$ will lead to the fingerprint $000$, whereas both hashes $h_{2}^{r}=001$ and $h_{3}^{r}=010$ will lead to the fingerprint $001$..

However, for an optimal SQF, fingerprints are equiprobable so the analysis above holds for optimal SQFs. In the general case, the authors of [8] have approximated the probability of fingerprint collision in an SQF with $\frac{1}{2r^{\prime}\sqrt{\pi r}}$. Replacing $\frac{1}{S}$ with this probability in our analysis, we get an approximate asymptotic FPR of $\frac{k}{2^{r^{\prime}}\sqrt{\pi r}}$ for SQFs, as announced in Section 3.

4.2 False Negative Rate

Theorem 4.2**.**

For a QHT of $N$ rows, $k$ buckets per row, and $S$ different fingerprints, assuming $U\gg N$, then as the number of insertions goes to infinity, $\displaystyle\operatorname{FNR}_{\infty}=1-\frac{k}{S}$.

Proof.

Assume that $e$ is a duplicate, we denote by $e_{k}$ the last element in the stream such that $e_{i}=e$. Following the same reasoning as for the FPR, $e_{i}$ will trigger a false negative if and only if $e_{i}$ is removed from the filter before $e$ arrives, and if any false duplicate of $e$, inserted between the removal of $e_{i}$ and $e$, is deleted before $e$ arrives.

Let us assume that $e_{i}$ is deleted at time $j$ (this happens with probability $\displaystyle P_{i,j}^{\text{Del}}$) by something else than a false duplicate. Using similar arguments than in the previous section, we have $P_{i,j}^{\text{Del}}=\left(1-\frac{S-k}{k(NS-1)}\right)^{j-i-1}\frac{S-k}{k(NS-1)}$.

The probability that all false duplicates, inserted after time $j$, are deleted before $e$ arrives is $1-\operatorname{FP}_{n-j}$.

Let $a=\frac{S-k}{k(NS-1)}$, $b=\frac{k}{S}$ and $c=1-\frac{1}{Nk}$, and denote by $\operatorname{FN}_{i,m}$ the probability, in a stream $E=(e_{1},\dotsc,e_{m},e)$ where the last duplicate of $e$ is inserted at $i$, that $e_{i}$ is deleted before $e$ arrives and no false positive persists until $e$,

[TABLE]

Given that $1-a\neq c$, we get:

[TABLE]

The probability $\operatorname{FN}_{m}$ of $e$ to be a false negative is then $\displaystyle\sum_{i=1}^{m}P_{\text{dup},i}\cdot\operatorname{FN}_{i,m}$, where $P_{\text{dup},i}$ is the probability that the last duplicate already seen is $e_{i}$, so $P_{\text{dup},i}=\left(\frac{U-1}{U}\right)^{m-i}\frac{1}{U}$.

We obtain the probability $\operatorname{FN}_{m}$ that the $(m+1)$th element $e$ of the stream will be a false negative:

[TABLE]

For a stream of $n$ elements, the false negative rate $\operatorname{FNR}_{n}$ is defined as the average error probability: $\operatorname{FNR}_{n}=\frac{1}{n}\sum_{m=1}^{n}\operatorname{FN}_{m}$

We show, in Appendix B, that for $\displaystyle\operatorname{FNR}_{\infty}=\lim_{n\to\infty}\operatorname{FNR}_{n}$,

[TABLE]

A not obvious consequence of the above expression for FNR is that when $N$ increases, which corresponds to using more memory, it is possible to achieve an arbitrary small error rate.151515This fact is straightforward but requires the substitution of $a,b,c$ by their full expression, before taking the limit. At some point however, the memory is so large that every stream element can be stored, and there is no need for probabilistic data structures anymore. In practice we expect memory to be a limited resource, so this situation is unlikely to present itself.

Finally, assuming $U\gg Nk$ (or even $U\gg N$), i.e., that there are more distinct elements in the stream that what the filter is able to store, we get the limit rate of $1-b$, which is $\operatorname{FNR}_{\infty}\approx 1-\frac{k}{S}$. ∎

Note that $\operatorname{FNR}_{\infty}+\operatorname{FPR}_{\infty}=1$.

The value of $\operatorname{FNR}_{\infty}$ also gives (using the same corrections as for the FPR in Section 4.1.1) the FNR for SQF.

4.3 Error Rate and Filter Saturation

Claim 4.1**.**

The asymptotic relation $\operatorname{FNR}_{\infty}+\operatorname{FPR}_{\infty}=1$ is universal (as long as $U\gg M$) amongst hash-based duplicate detection filters and is the result of the filter’s saturation. Furthermore, when a filter reaches saturation, it behaves similarly, from the error rate point of view, to a filter answering DUPLICATE at random (we will call such filters random filters).

Proof.

In order to see this, first note that random filters always verify the relation $\operatorname{FNR}+\operatorname{FPR}=1$. Given that a random filter will return DUPLICATE with a probability of $p$, an unseen element will be classified as DUPLICATE with probability $p$, and a duplicate will be classified as UNSEEN with probability $1-p$, hence the result.

Now, on infinite streams with infinitely many different elements, filters are saturated with information. Given that a filter can only store at most one element per bit (cf. Section 2.1), thus a filter of size $M$ can remember at most $M$ elements. However, after $fM$ insertions (with $f\gg 1$), the filter remembers at most a tiny fraction $\frac{1}{f}\ll 1$ of the stream. Having reached its saturated state, the filter has an extremely tiny probability $\frac{1}{f}\approx 0$ of correctly guessing whether the incoming element is a duplicate or not, given what the filter actually knows about the stream. For this reason, the best strategy of a saturated filter is almost indistinguishable from a random strategy, i.e. randomly outputting DUPLICATE. When the stream grows indefinitely, the filter becomes asymptotically equivalent to a random filter. ∎

Furthermore, in practical cases, we observe that duplicate filters are equivalent to a specific kind of random filters: they answer DUPLICATE with some fixed probability $p$, $p$ depending on the filter’s nature and its parameters (i.e., $p$ does not change with time).

Interpretation

The interpretation of these results could suggest that streaming filters are useless: they need more memory than a random filter, despite being asymptotically equivalent. However, this is only true because of our hypotheses and definitions: we define a false negative to be a duplicate element claimed as unseen by the filter. However, after some amount of time, it is often acceptable that the element may be considered as unseen again: for instance a nonce is theoretically unique, but in practice after a reasonable amount of time nonce reuse is not a vulnerability. For this reason, adapting false positive and false negative to sliding windows may be relevant here. Moreover, we assumed that all elements of the stream had the same probability of occurrence. In practice, this hypothesis is not always correct, and as we will see in Section 6, filters operating on real data perform significantly better than random filters, and resist better to saturation.

4.4 Comparing QHT to SQF

Let us compare the memory required for a QHT to reach the same error rates than an SQF.

Given that both FPR and FNR depend only on $k$, $N$ and $S$, imposing the equality on these parameters ensures that both filters have exactly the same FPR and FNR.

Note that $S$ is not a user-chosen parameter, but rather a consequence of other parameters.

Theorem 4.3**.**

For exactly the same FPR and FNR, a QHT requires 33% fewer memory than an SQF.

The proof is made through the following subsections.

4.4.1 Deriving S from Filters Parameters

For a QHT, $S$ is derived from the number of bits of the fingerprint $s$, with the straightforward relation161616If we are on a system without the empty feature (see Section 3.2, then $S=2^{s}-1$. For an SQF, one can just assign the empty value to one of the unassigned fingerprints.: $S=2^{s}$. For an SQF, however, the relation is more complicated.

When $r$ and $r^{\prime}$ are fixed, for any element $e$, let $h_{e}^{r}$ be decomposed as $h_{e}^{r}=h_{e}^{r^{\prime}}\|f$, where $h_{e}^{r^{\prime}}$ is the $r^{\prime}$-bits word used in the fingerprint, $h$ being the $r-r^{\prime}$ remaining bits of $h_{e}^{r}$. For $\omega(\cdot)$ the Hamming weight function, we have $s(e)=h_{r^{\prime}}\|\omega(h_{e}^{r})$. Yet $\omega(h_{e}^{r})=\omega(h_{e}^{r^{\prime}})+\omega(f)$. We know that $\omega(h_{e}^{r^{\prime}})$ is entirely dependent on $h_{e}^{r^{\prime}}$, which is already used in the fingerprint. Thus, if we fix $h_{e}^{r^{\prime}}$, there are only $r-r^{\prime}+1$ possible values for $\omega(f)$ and thus for $\omega(h_{e}^{r})$. Given that $h_{e}^{r^{\prime}}$ can have $2^{r^{\prime}}$ different values, we get that $S_{SQF}=2^{r^{\prime}}\cdot(r-r^{\prime}+1)$.

4.4.2 Comparing Required Memory

For QHTs, we have the relation $M_{\text{QHT}}=N_{\text{QHT}}k_{\text{QHT}}s$. For SQF, the formula is rather $M_{\text{SQF}}=N_{\text{SQF}}k_{\text{SQF}}(r^{\prime}+\lceil\log_{2}(r+1)\rceil)$ (because fingerprints occupy $r^{\prime}+\lceil\log_{2}(r+1)\rceil$ bits).

Given that $N_{\text{QHT}}=N_{\text{SQF}}$ and $k_{\text{QHT}}=k_{\text{SQF}}$, the ratio $\frac{M_{\text{QHT}}}{M_{\text{SQF}}}$ is:

[TABLE]

Given that $s=\lceil\log_{2}(S_{\text{QHT}})\rceil=\lceil\log_{2}(S_{\text{SQF}})\rceil=\lceil\log_{2}(2^{r^{\prime}}\cdot(r-r^{\prime}+1))\rceil$, we have

[TABLE]

Using the recommended settings in [8]171717Their optimal choice of parameters also includes setting $k=4$. However, setting $r=2$ and $r^{\prime}=1$ imposes $S=4$, so that setting $k=4$ results in an FPR of 1: after some time the filter systematically responds DUPLICATE. Using e.g. $k=3$ avoids this. ($r=2$, $r^{\prime}=1$) the ratio becomes $\frac{M_{\text{QHT}}}{M_{\text{SQF}}}=\frac{2}{3}$ , which concludes the proof.

4.5 Parameter Tuning

As noted in Section 4.2, no matter the choice of the parameters we have $\operatorname{FNR}+\operatorname{FPR}=1$: any particular parameters choice will be a trade off between good FPR and good FNR performance, at least asymptotically. However, when the stream is small enough, one may choose parameters that will maximally delay saturation.

We know that $M=Nk\log_{2}(S)$, so plugging this into the FPR formula gives

[TABLE]

Which means that, for fixed $M$ and $\frac{k}{S}$ (i.e. for a fixed memory amount and a fixed asymptotic FPR), $\log_{2}(S)$ must be as small as possible in order to keep the FPR low for as long as possible.

For instance, assume that we want an asymptotic FPR of 25%. The potential values for the couple $(k,S)$ are $(1,4)$, $(2,8)$, $(3,16)$ and so on (leading respectively to $s=2,3,4$). Because of the above relation, we know that setting $k=1,s=2$ will yield the best saturation resistance for the FPR.

In order to test this heuristic, we compared several QHT of approximately 65,536 bits, with the same ratio $\frac{k}{S}$, but a different value for $S$. We took streams of 100,000 elements (well under saturation value for this amount of memory), from an alphabet of $2^{20}$ elements. Each element of the stream was uniformly randomly selected, leading to a stream with about 4.6% of duplicate elements. We averaged the results on 10 runs.

We observe in Table 1 that filters with a small value of $S$ do indeed perform better than filters with a bigger value of $S$, which concludes the experiment.

5 Further improvements: QQHTD

5.1 Keeping Track of Duplicates

In Algorithm 1, we do not insert anything if the element is detected as a duplicate. However, following [9]’s example, we can insert it anyway, resulting in a structure we call QHT with Duplicates, or QHTD. We briefly discuss its properties.

As we showed previously, the asymptotic FPR of a QHT is $\frac{k}{S}$, which was expected: each cell stores $k$ distinct fingerprints, the probability that one of them matches the fingerprint of a unique element is logically $\frac{k}{S}$. Similarly, in QHTD each cell stores $k$ fingerprints, not necessarily distinct. The probability that at least one of these fingerprints is the same than the one of an unseen element is $\text{FPR}_{\text{QHTD}}=1-\left(1-\frac{1}{S}\right)^{k}$. Given the results of Section 4.3, the asymptotic FNR of QHTD is $\left(1-\frac{1}{S}\right)^{k}$.

5.2 Queuing Buckets for a Better Sliding Window

One caveat of the QHT (and QHTD) is the fact that at any insertion, any element of the row is equally likely to be evicted: if this allows an easy FPR and FNR derivation, it makes it functioning a bit counter intuitive. As a matter of fact, one would expect a filter to first forget about the oldest elements before forgetting about the newest ones. Indeed, this behaviour matches the need of a filter operating on a sliding window, without taking into account oldest elements.

The solution we provide for QHT is to order the buckets of a given cell in a FIFO queue, which means that instead of selecting a random bucket in the cell for insertion, one will append the fingerprint to the end of the queue, and pop the first element (so that the size of the queue remains constant). Combined with QHTD improvement, this yields Algorithm 2.

Note that classical queues (i.e. doubly chained lists) are not suited for our use, as chains require extra storage bits for pointers. Thus, we create an array of $k$ elements, in which we manually move every element at each “pop”. When $k$ is small (typically less than 5, which it usually is), the added overhead is not significant.

Finally, note that a QQHTD with one bucket par cell is equivalent to its QHT counterpart. However, with more buckets per cell, QQHTDs offer a noticeable improvement over QHTs on real data streams (see Appendix A).

6 Benchmarks

6.1 Comparison of QHT to Other Filters

We used streams of 150,000,000 elements, on filters of size ranging from 10 kb to 8 Mb. In any case the filters are too small to keep track of the whole stream, and we will see that filters do reach saturation. We used 2 artificial streams, for which the elements where randomly generated from an alphabet of $2^{24}$ and $2^{27}$ elements respectively, leading to a duplicate rate of about $88\%$ and $38\%$ respectively. We also used a real dataset of URLs visited by a crawling robot, extracted from the April 2018 CommonCrawl’s dump [17] The source code is available from on BitBucket.181818https://bitbucket.org/team_qht/qht/src/master.

The filters, so their asymptotic FPR was as close as possible to the arbitrary value of 25%, are:

• •

SQF, 1 bucket per row, $r=2$ and $r^{\prime}=1$

• •

QHT, 1 bucket per row, 3 bits per fingerprint. This specific QHT is equivalent to a QQHTD with the same parameters, so we do not include the latter in the benchmark.

• •

Cuckoo Filter[9], cells containing 1 element of 3 bits each

• •

Stable Bloom Filter (SBF) [7], 2 bits per cell, 2 hash functions, targeted FPR of 0.02191919Our benchmarks actually obtained an asymptotic FPR of around 28%, without us being able to find bugs in our implementation.

• •

$A2$ Filter[22], targeted FPR of $0.1$ on the sliding window.

• •

Block-Decaying Bloom Filter (b_DBF)[19], sliding window of 6000 elements.

Results, averaged on 5 runs, are given in Table 2. Note that, for better readability, the error rates have been multiplied by $100$ in the table. Further more, we recall that the error rate, being defined as $E=\operatorname{FPR}+\operatorname{FNR}$, is bounded by [math] below and $2$ above, $1$ being the error rate of a random filter. A filter can have worse results than random; for instance a filter which is always wrong has an error rate of $2$.

As we can see in Table 2, QHT (or QQHTD) are extremely competitive and resist very well to saturation; they also appear to be the most competitive on the real stream. b_DBF are efficient, but reach very quickly their saturation. A more detailed analysis of their FPR (see Appendix A) shows that even though their FPR is close to 0, they get an FNR close to 1. Moreover, as we see in Section 6.2, they are significantly slower, which can be a bottleneck for critical applications. Further more, not only are QHT/QQHTD the most efficient filter on both real and artificial streams, they are also very easily tunable, and any asymptotic FPR rate is very simply achievable. This is not the case of other filters, such as A2 or b_DBF, which require careful tuning.

6.2 Speed Comparison

We also benchmarked the speed of every filter on real-time detection, on a laptop with Intel i7. We used the same filters as in the previous subsection, with a memory of 1 Mb, on a stream of 150,000,000 elements. We averaged, on these filters, the time needed for $\textsf{Insert}\circ\textsf{Detect}$ to execute for each element. Results are shown in Table 3. We observe that safe for SQF, QHT is 6 times as fast as any other filter, and 10 times as fast as b_DBF. Even SQF is 50% slower than QHT. Even with additional features, QQHTD are also faster than SQF by a large magin, because fingerprint derivation is more costly in the latter. As a conclusion, we observe that QQHTD are most suited filters for high-speed analysis.

7 Adversarial Resistance

Now, despite the good performances of QQHTD on normal streams, one may not always assume that the stream is “normal”: there may be an attacker trying to fool the filter. For instance if the filter must detect duplicates in order to avoid an attack (nonce requirements), then the question of adversarial resistance is primordial.

We can model an adversarial system in which an attacker has a knowledge of the output of Stream (i.e., whether the element is classified as DUPLICATE or UNSEEN), but no knowledge of the internal memory state $\mathcal{M}$. Thus the attacker is able to carry an adaptive attack, by choosing the next element to send to the filter as a function of all previous insertions. In this adversarial game, the attacker can send an arbitrary stream to the filter, and is allowed to get the result of Stream for every element. Then, at her convenience, the attacker goes into the second phase of the game, in which she has two possible actions:

• •

Send an unseen element that will be a false positive with high probability (false positive attack);

• •

Send a duplicate element that will be a false negative with high probability (false negative attack).

Theorem 7.1**.**

No filter can resist a false negative attack.

Proof.

We craft false negatives in $\Omega(M)$ steps ($M$ being the filter’s memory size). Let us remind that no structure can remember more than one element per memory bit. For this reason, the structure can remember at most $M$ different elements. Consequently, if the attacker generates a stream of random unseen elements, then on average each element will stay for $M$ insertions in the filter’s memory. More generally, after $hM$ insertions (for some rational $h\geq 1$), an element is forgotten with probability at least $P_{\text{forgot}}=1-(1-\frac{1}{M})^{hM}\simeq 1-e^{-h}$. Thus an attacker simply generates $\Omega(M)$ unique elements before sending the first element again. $M$ can even be estimated via saturation (see Section 4.3). Given that CPU time is cheaper than memory requirements, the attacker keeps her advantage over any filter of any size. ∎

Theorem 7.2**.**

Assuming the existence of one-way functions, QHT can resist a false positive attack.

Proof.

Following [18] we replace all hash functions by one-way hash functions, and apply a (secret) one-way permutation on incoming elements, then classically store the results in the filter. Because of the permutation, the attacker gains no advantage in adaptively choosing the elements, thus loosing her advantage. ∎

As a conclusion, QHTs are adapted to contexts where low false positives are crucial, such as white-list email filtering. Note however that this is the case of most filters, as long as they rely on hash functions (and so can apply [18]).

8 Conclusion

This paper introduces a new duplicate detection filter, QHT, and its variant QHTD. QHTs achieve a better utilization of the available space, and as such are more efficient than existing filters. Moreover, QHTD have more efficiency for detecting duplicates in a real dataset.

We showed that, for an infinite stream with an infinite number of unseen elements, the number of rows is less important than the fingerprint space, and the number of buckets per row. Moreover, we proved that all filters, having reached saturation, are not more efficient than random filters, and as such, a benchmarking of stream filters should only focus on the pre-saturation state, with small streams.

Even though QHTs are significantly more efficient than other structures in the literature, we do not know if these filters are optimal: are there other filters having an optimal resilience to saturation? Future work also includes examining the theoretical resistance to saturation of QQHTDs, and a finer examination of the QHT/QQHTD behaviour on a sliding window.

Appendix A Tables of error rates for various streams

Table 4 gives the error rates (FPR and FNR) used to derive Table 2.

Appendix B Deriving $\operatorname{FNR}_{\infty}$

This derivation was removed from Section 4.2 for better readability. We know that $\displaystyle\operatorname{FNR}_{n}=\frac{1}{n}\sum_{m=1}^{n}\operatorname{FN}_{m}=\frac{1}{n}\sum_{m=1}^{n}\sum_{i=1}^{m}P_{\text{dup},i}\cdot\operatorname{FN}_{i,m}$, so

[TABLE]

Expanding,

[TABLE]

[TABLE]

Given that $\displaystyle\operatorname{FNR}_{\infty}=\lim_{n\to\infty}\operatorname{FNR}_{n}$, using Cesàro’s mean we get:

[TABLE]

Which concludes the proof.

Appendix C Comparison of QHT and QQHTD

In this appendix, we explore the difference between a QHT and a QQHTD with the same parameters, on the same stream. We took filters of 65,536 bits each, on streams of 100,000 elements each. One stream issued from our ‘real’ dataset (10.32% of duplicates), the other a random uniform stream on an alphabet of $2^{20}$ elements (4.62% of duplicates). Results are given in 5.

We observe that while QQHTD offer no advantage on artificial streams, their performance (relative to the QHT) are noticeably better, which empirically validates the optimizations.