String Fingerprints: Methods & Applications

• String fingerprints are compact representations that capture essential character or structural information to support efficient filtering and matching.
• They encompass various constructions—from sets of distinct characters to fixed-size bitwise filters and Karp–Rabin algebraic hashes—each optimized for specific query models.
• These techniques are applied in domains such as DNA motif discovery, database indexing with LIKE predicates, compressed string queries, and error-tolerant keyword matching.

Searching arXiv for the cited papers and closely related work on string fingerprints. arXiv search results for: (Cisłak et al., 2017) string fingerprints approximate keyword matching

String fingerprints are compact representations of strings or string-derived objects that preserve selected information for downstream queries. In the literature considered here, the term denotes several distinct constructions: the set of distinct characters appearing in a substring; a lightweight fixed-size block of data for approximate keyword matching using bitwise operations; a binary vector used as a lightweight secondary index for approximate LIKE predicates in columnar engines; and the Karp–Rabin fingerprint used to answer substring fingerprint queries on grammar-compressed strings (Belazzougui et al., 2013, Cisłak et al., 2017, Stoian et al., 14 Jul 2025, Bille et al., 2013). These constructions differ substantially in semantics, guarantees, and intended workload, but they share a common objective: replacing direct string inspection with a smaller representation that supports efficient filtering, indexing, or comparison.

1. Terminological scope and formal models

A first source of ambiguity is that “fingerprint” is not used uniformly across stringology. In one line of work, a fingerprint of a factor $s_i \ldots s_j$ is the set of its distinct letters,

$C_s(i,j)=\{s_k \mid i \le k \le j\},$

and the universe of fingerprints is

$F=\{C_s(i,j)\mid 1\le i\le j\le n\},$

with the empty fingerprint also included by convention (Belazzougui et al., 2013). In another line of work, a fingerprint is a function

$f:\Sigma^\ast \to \{0,1\}^m$

mapping a string to an $m$-bit word that stores information regarding symbol occurrences using individual bits and can be compared with a constant number of bitwise operations (Cisłak et al., 2017). A third formulation uses a binary vector of length $n$ over bins of an alphabet $A$, with

$$d^s_j := \max_{i=1\ldots \mathrm{len}(s)} x_{s_i,j},$$

so that the $j$-th bit is set exactly when the string contains at least one symbol assigned to bin $j$ (Stoian et al., 14 Jul 2025). A fourth, algebraic notion defines the Karp–Rabin fingerprint of a string $C_s(i,j)=\{s_k \mid i \le k \le j\},$0 as

$C_s(i,j)=\{s_k \mid i \le k \le j\},$1

with concatenation and subtraction identities that support substring extraction (Bille et al., 2013).

These definitions imply that “string fingerprint” is best treated as a family of summarization mechanisms rather than a single method. A plausible implication is that comparisons across papers require attention to the query model: membership in a family of substring alphabets, approximate distance filtering, predicate pruning in database scans, and equality-style hashing of substrings are not interchangeable tasks.

Fingerprint notion	Representation	Primary query type
Substring alphabet fingerprint	Set of distinct characters in a substring	Compute $C_s(i,j)=\{s_k \mid i \le k \le j\},$2, test whether $C_s(i,j)=\{s_k \mid i \le k \le j\},$3, report maximal locations
Lightweight approximate-matching fingerprint	Fixed-size $C_s(i,j)=\{s_k \mid i \le k \le j\},$4-bit word	Prune string pairs before exact Hamming or Levenshtein verification
Columnar LIKE fingerprint	Binary vector / fixed-width integer	Filter rows via (FP & pattern_mask) = pattern_mask
Karp–Rabin fingerprint	Modular polynomial hash	Return fingerprint of substring $C_s(i,j)=\{s_k \mid i \le k \le j\},$5 without decompression

2. Fingerprints as sets of distinct substring characters

For a text $C_s(i,j)=\{s_k \mid i \le k \le j\},$6 over an ordered alphabet $C_s(i,j)=\{s_k \mid i \le k \le j\},$7 of size $C_s(i,j)=\{s_k \mid i \le k \le j\},$8, the fingerprint of a factor is the set of distinct letters occurring in that factor, and the central objects are the family $C_s(i,j)=\{s_k \mid i \le k \le j\},$9 of all such fingerprints, the set $F=\{C_s(i,j)\mid 1\le i\le j\le n\},$0 of maximal locations, and the quotient set $F=\{C_s(i,j)\mid 1\le i\le j\le n\},$1 obtained by grouping copies, i.e. equal substrings that realize maximal locations (Belazzougui et al., 2013). A pair $F=\{C_s(i,j)\mid 1\le i\le j\le n\},$2 is a maximal location of a fingerprint $F=\{C_s(i,j)\mid 1\le i\le j\le n\},$3 if $F=\{C_s(i,j)\mid 1\le i\le j\le n\},$4, the left neighbor $F=\{C_s(i,j)\mid 1\le i\le j\le n\},$5 is not in $F=\{C_s(i,j)\mid 1\le i\le j\le n\},$6 when defined, and the right neighbor $F=\{C_s(i,j)\mid 1\le i\le j\le n\},$7 is not in $F=\{C_s(i,j)\mid 1\le i\le j\le n\},$8 when defined. The bound $F=\{C_s(i,j)\mid 1\le i\le j\le n\},$9 is immediate from the definition.

Three core problems are studied in this framework. Problem 1 is to compute $f:\Sigma^\ast \to \{0,1\}^m$0. Problem 2 is, given $f:\Sigma^\ast \to \{0,1\}^m$1, to answer whether $f:\Sigma^\ast \to \{0,1\}^m$2. Problem 3 is, given $f:\Sigma^\ast \to \{0,1\}^m$3, to find all maximal locations of $f:\Sigma^\ast \to \{0,1\}^m$4 in $f:\Sigma^\ast \to \{0,1\}^m$5 (Belazzougui et al., 2013). The exact algorithms combine a suffix tree, a participation tree, and a naming procedure based on Karp–Miller–Rosenberg stacks. The participation tree is a trimmed version of suffix-tree paths, has size $f:\Sigma^\ast \to \{0,1\}^m$6, and every path from its root spells a character-permutation that realizes at least one maximal location. Naming proceeds level by level in $f:\Sigma^\ast \to \{0,1\}^m$7 levels, using radix sort on pairs of child names.

The worst-case exact construction for Problem 1 builds the suffix tree in $f:\Sigma^\ast \to \{0,1\}^m$8 time, the participation tree in $f:\Sigma^\ast \to \{0,1\}^m$9 time, names all fingerprints in $m$0 time, and achieves total time $m$1 with space $m$2 bits (Belazzougui et al., 2013). A randomized expected variant replaces suffix-tree-based naming by online randomized hashing and dynamic hash tables, with total expected time $m$3 and space $m$4 bits. A Monte Carlo approximate construction computes polynomial hashes at maximal locations, inserts them into a dynamic MC hash table, and runs in expected $m$5 time with space $m$6 bits and error probability $m$7 for any chosen constant $m$8.

For existential queries, the succinct structure uses $m$9 bits and answers a query set $n$0 of size $n$1 in overall time $n$2 expected or deterministic $n$3, with no false positives or negatives (Belazzougui et al., 2013). For location reporting, augmenting the structure with pointers into the suffix tree yields query time $n$4 and space $n$5 bits. The applications stated for this notion include DNA-motif discovery, information retrieval, and natural-language processing.

3. Lightweight bitwise fingerprints for approximate keyword matching

In approximate keyword matching, a fingerprint is a lightweight, fixed-size block of data for each string that works in a similar way to hash values but can also be used for matching with errors (Cisłak et al., 2017). Let $n$6 be the alphabet and let $n$7 be a chosen subset of tracked symbols, with fingerprint size $n$8 bits, often $n$9 or $A$0. In the simplest occurrence scheme, each bit position corresponds to one symbol in $A$1, and

$A$2

Bit $A$3 is set if and only if the $A$4-th tracked symbol occurs at least once in $A$5. The method can also halve the string and use $A$6 bits to record occurrence in the first and second half separately, use $A$7 bits per symbol to count up to $A$8 occurrences, or use $A$9 bits per symbol to encode the $$d^s_j := \max_{i=1\ldots \mathrm{len}(s)} x_{s_i,j},$$0-indexed position of first occurrence, saturating at $$d^s_j := \max_{i=1\ldots \mathrm{len}(s)} x_{s_i,j},$$1.

Given two fingerprints $$d^s_j := \max_{i=1\ldots \mathrm{len}(s)} x_{s_i,j},$$2 and $$d^s_j := \max_{i=1\ldots \mathrm{len}(s)} x_{s_i,j},$$3, the fingerprint distance is

$$d^s_j := \max_{i=1\ldots \mathrm{len}(s)} x_{s_i,j},$$4

or, for position fingerprints, the number of differing $$d^s_j := \max_{i=1\ldots \mathrm{len}(s)} x_{s_i,j},$$5-bit fields (Cisłak et al., 2017). The key inequality is

$$d^s_j := \max_{i=1\ldots \mathrm{len}(s)} x_{s_i,j},$$6

for $$d^s_j := \max_{i=1\ldots \mathrm{len}(s)} x_{s_i,j},$$7. Equivalently, if $$d^s_j := \max_{i=1\ldots \mathrm{len}(s)} x_{s_i,j},$$8, then one can conclude $$d^s_j := \max_{i=1\ldots \mathrm{len}(s)} x_{s_i,j},$$9 without explicit verification. The intuition formalized in the cited theorems is that a single edit operation can change at most two bits, or two symbol-fields, in the occurrence or count fingerprint; by induction, $j$0 edits change at most $j$1 bits.

This filter has a one-sided guarantee. There are no false negatives in pruning: a true match within $j$2 errors is never rejected. However, many non-matching pairs may not be ruled out, so false positives remain for exact verification (Cisłak et al., 2017). The limitations are explicit: only symbols in $j$3 are tracked; edits involving untracked symbols may go unnoticed; and the bound may be very loose when $j$4 or strings are extremely repetitive.

The preprocessing and query workflow is correspondingly simple. For each dictionary string $j$5, compute $j$6 in $j$7 time for occurrence or count fingerprints, or $j$8 for position fingerprints, and store $j$9. Given a pattern $j$0 and threshold $j$1, compute $j$2 in $j$3, evaluate $j$4 for each candidate in $j$5 time using bitwise operations and a small lookup table, and verify exact distance only for candidates satisfying $j$6 (Cisłak et al., 2017). The space overhead is one $j$7-bit fingerprint per stored string, i.e. $j$8 extra bits.

Empirically, for $j$9 and $C_s(i,j)=\{s_k \mid i \le k \le j\},$00 bits using occurrence fingerprints with 16 common letters, the reported speedups were over $C_s(i,j)=\{s_k \mid i \le k \le j\},$01 times for the Hamming distance and over $C_s(i,j)=\{s_k \mid i \le k \le j\},$02 times for the Levenshtein distance on synthetic English data; approximately $C_s(i,j)=\{s_k \mid i \le k \le j\},$03 and $C_s(i,j)=\{s_k \mid i \le k \le j\},$04 respectively on English words; and approximately $C_s(i,j)=\{s_k \mid i \le k \le j\},$05–$C_s(i,j)=\{s_k \mid i \le k \le j\},$06 for Hamming and $C_s(i,j)=\{s_k \mid i \le k \le j\},$07–$C_s(i,j)=\{s_k \mid i \le k \le j\},$08 for Levenshtein on URLs (Cisłak et al., 2017). Rejection rates at the fingerprint stage for $C_s(i,j)=\{s_k \mid i \le k \le j\},$09 were approximately $C_s(i,j)=\{s_k \mid i \le k \le j\},$10 by occurrence, $C_s(i,j)=\{s_k \mid i \le k \le j\},$11 by count, and $C_s(i,j)=\{s_k \mid i \le k \le j\},$12 by position on English words of length $C_s(i,j)=\{s_k \mid i \le k \le j\},$13, and approximately $C_s(i,j)=\{s_k \mid i \le k \le j\},$14 by occurrence and $C_s(i,j)=\{s_k \mid i \le k \le j\},$15 by count on URLs of length $C_s(i,j)=\{s_k \mid i \le k \le j\},$16. The worked examples in the source make clear that the lower bound can be weak: a pair may survive filtering even when the true Hamming distance is larger than $C_s(i,j)=\{s_k \mid i \le k \le j\},$17.

4. Workload-aware fingerprints for LIKE predicate pruning

A more recent use of string fingerprints arises in cloud data warehouses and columnar query engines, where string columns are described as text-heavy and current processing as relying primarily on techniques like dictionary encoding and prefix-based partition pruning (Stoian et al., 14 Jul 2025). In this setting, a string fingerprint is a binary vector of fixed bitwidth $C_s(i,j)=\{s_k \mid i \le k \le j\},$18 obtained by partitioning the alphabet $C_s(i,j)=\{s_k \mid i \le k \le j\},$19 into bins via a binary assignment matrix $C_s(i,j)=\{s_k \mid i \le k \le j\},$20. For a string $C_s(i,j)=\{s_k \mid i \le k \le j\},$21, the fingerprint bit $C_s(i,j)=\{s_k \mid i \le k \le j\},$22 indicates whether $C_s(i,j)=\{s_k \mid i \le k \le j\},$23 contains at least one character assigned to bin $C_s(i,j)=\{s_k \mid i \le k \le j\},$24.

To approximate a LIKE-substring test s.contains(q), the pattern fingerprint $C_s(i,j)=\{s_k \mid i \le k \le j\},$25 is computed while ignoring wildcards, and the approximate membership test is

$C_s(i,j)=\{s_k \mid i \le k \le j\},$26

If this test fails, $C_s(i,j)=\{s_k \mid i \le k \le j\},$27 cannot contain $C_s(i,j)=\{s_k \mid i \le k \le j\},$28; if it passes, the full LIKE pattern must still be checked (Stoian et al., 14 Jul 2025). The operational realization in a columnar engine stores, alongside each string column $C_s(i,j)=\{s_k \mid i \le k \le j\},$29, an auxiliary column FP of fixed-width integer type such as a 16-bit integer. At load time, each row’s string is scanned once, mapped through char2bin, and accumulated into a bit mask using bitwise OR. At query time, a pattern_mask is built from the distinct characters of the pattern, and the engine evaluates $F=\{C_s(i,j)\mid 1\le i\le j\le n\},$12 so that the bitwise test filters rows before the expensive full LIKE evaluation (Stoian et al., 14 Jul 2025).

The no-false-negative property is stated directly: if the pattern’s characters all appear in a string, then every bit set in $C_s(i,j)=\{s_k \mid i \le k \le j\},$30 will also be set in $C_s(i,j)=\{s_k \mid i \le k \le j\},$31, so the filter never rejects a true match (Stoian et al., 14 Jul 2025). False positives occur when the bit-mask test passes but the string does not contain the pattern as a substring. For a workload $C_s(i,j)=\{s_k \mid i \le k \le j\},$32, the per-pattern false-positive rate is defined as

$C_s(i,j)=\{s_k \mid i \le k \le j\},$33

and the overall expected false positive probability is $C_s(i,j)=\{s_k \mid i \le k \le j\},$34. Under the simplifying assumption that bin bits are set independently with empirical probabilities $C_s(i,j)=\{s_k \mid i \le k \le j\},$35, a pattern whose fingerprint has $C_s(i,j)=\{s_k \mid i \le k \le j\},$36 set bits passes on a random non-matching row with approximate probability

$C_s(i,j)=\{s_k \mid i \le k \le j\},$37

The source uses this product-of-densities formula to explain why longer patterns and sparser bins lead to exponentially lower false-positive rates.

A distinctive contribution of this framework is instance-optimized partitioning via mixed-integer programming. Binary decision variables assign each character to exactly one bin, define the string and pattern fingerprints, and introduce $C_s(i,j)=\{s_k \mid i \le k \le j\},$38 to indicate a correctly rejected non-match (Stoian et al., 14 Jul 2025). The objective maximizes

$C_s(i,j)=\{s_k \mid i \le k \le j\},$39

which is equivalent to minimizing false positives. Constraint (1) enforces a partition of characters into exactly one bin each; Constraints (2–3) define the fingerprint $C_s(i,j)=\{s_k \mid i \le k \le j\},$40 from the assignment; Constraint (4) permits $C_s(i,j)=\{s_k \mid i \le k \le j\},$41 only when at least one fingerprint bit of $C_s(i,j)=\{s_k \mid i \le k \le j\},$42 is missing in $C_s(i,j)=\{s_k \mid i \le k \le j\},$43. The source notes that a linearized version can be solved with Gurobi or CPLEX under a time limit such as $C_s(i,j)=\{s_k \mid i \le k \le j\},$44.

On DuckDB v1.3.0 with the IMDb title column from the JOB benchmark, consisting of $C_s(i,j)=\{s_k \mid i \le k \le j\},$45 rows reduced to $C_s(i,j)=\{s_k \mid i \le k \le j\},$46 printable bytes, the reported experiment extracted 300 $C_s(i,j)=\{s_k \mid i \le k \le j\},$47-grams for $C_s(i,j)=\{s_k \mid i \le k \le j\},$48, split into 20 training patterns and 280 unseen test patterns (Stoian et al., 14 Jul 2025). A 16-bit fingerprint optimized on a 50-tuple sample of the first data block with a $C_s(i,j)=\{s_k \mid i \le k \le j\},$49 Gurobi time limit yielded a speedup of $C_s(i,j)=\{s_k \mid i \le k \le j\},$50 on the 20 training patterns and $C_s(i,j)=\{s_k \mid i \le k \le j\},$51 on the 280 unseen patterns during the full $C_s(i,j)=\{s_k \mid i \le k \le j\},$52-row scan. At 8-bit, the reported overall speedup was $C_s(i,j)=\{s_k \mid i \le k \le j\},$53, with a solver optimality gap under $C_s(i,j)=\{s_k \mid i \le k \le j\},$54 after $C_s(i,j)=\{s_k \mid i \le k \le j\},$55. The optimization overhead of approximately $C_s(i,j)=\{s_k \mid i \le k \le j\},$56 is stated to amortize after only 4 runs of the 300-query workload, and the additional storage is only $C_s(i,j)=\{s_k \mid i \le k \le j\},$57 bits per row, i.e. 2 bytes for $C_s(i,j)=\{s_k \mid i \le k \le j\},$58.

5. Karp–Rabin fingerprints in compressed strings

The Karp–Rabin fingerprint is a type of hash value with strong algebraic properties, and in grammar-compressed strings it serves as the basis for substring fingerprint queries without decompressing any characters (Bille et al., 2013). The paper considers a string $C_s(i,j)=\{s_k \mid i \le k \le j\},$59 of size $C_s(i,j)=\{s_k \mid i \le k \le j\},$60 compressed by a context-free grammar of size $C_s(i,j)=\{s_k \mid i \le k \le j\},$61, and gives the first $C_s(i,j)=\{s_k \mid i \le k \le j\},$62-space data structures answering fingerprint queries for substrings $C_s(i,j)=\{s_k \mid i \le k \le j\},$63. The two compression models are Straight-Line Programs (SLPs), which are context-free grammars in Chomsky normal form generating exactly one string, and Linear SLPs, in which the root may have an arbitrary number of children while every other nonterminal has a nonterminal left child and a terminal right child.

The algebraic properties of the Karp–Rabin fingerprint enable substring extraction from prefix fingerprints. If

$C_s(i,j)=\{s_k \mid i \le k \le j\},$64

then for strings $C_s(i,j)=\{s_k \mid i \le k \le j\},$65 and $C_s(i,j)=\{s_k \mid i \le k \le j\},$66,

$C_s(i,j)=\{s_k \mid i \le k \le j\},$67

and from prefix fingerprints one obtains

$C_s(i,j)=\{s_k \mid i \le k \le j\},$68

All such operations take $C_s(i,j)=\{s_k \mid i \le k \le j\},$69 time when powers $C_s(i,j)=\{s_k \mid i \le k \le j\},$70 are precomputed (Bille et al., 2013).

For general SLPs, the data structure uses a heavy-path decomposition of the parse tree and stores, for each nonterminal, the length of its expansion, the fingerprint of its full expansion, the fingerprint of a distinguished heavy-path prefix $C_s(i,j)=\{s_k \mid i \le k \le j\},$71, and the power $C_s(i,j)=\{s_k \mid i \le k \le j\},$72 (Bille et al., 2013). Prefix queries $C_s(i,j)=\{s_k \mid i \le k \le j\},$73 are answered in $C_s(i,j)=\{s_k \mid i \le k \le j\},$74 time by following the sequence of heavy paths returned by a standard random-access routine and maintaining a modular accumulator that adds and subtracts contributions of heavy-path side subtrees. Once $C_s(i,j)=\{s_k \mid i \le k \le j\},$75 is available in $C_s(i,j)=\{s_k \mid i \le k \le j\},$76 time, arbitrary substring queries follow in $C_s(i,j)=\{s_k \mid i \le k \le j\},$77 extra time via the subtraction identity, so the whole structure uses $C_s(i,j)=\{s_k \mid i \le k \le j\},$78 space and answers fingerprint queries in $C_s(i,j)=\{s_k \mid i \le k \le j\},$79 time.

For Linear SLPs, the structure stores predecessor-search support on block boundaries, prefix fingerprints at those boundaries, a dictionary tree with an $C_s(i,j)=\{s_k \mid i \le k \le j\},$80-space level-ancestor structure, and $C_s(i,j)=\{s_k \mid i \le k \le j\},$81 and $C_s(i,j)=\{s_k \mid i \le k \le j\},$82 for each nonterminal (Bille et al., 2013). A query for $C_s(i,j)=\{s_k \mid i \le k \le j\},$83 first finds the predecessor block boundary $C_s(i,j)=\{s_k \mid i \le k \le j\},$84 in $C_s(i,j)=\{s_k \mid i \le k \le j\},$85 time, then combines the stored prefix fingerprint up to $C_s(i,j)=\{s_k \mid i \le k \le j\},$86 with the fingerprint of a length-$C_s(i,j)=\{s_k \mid i \le k \le j\},$87 prefix inside the next block recovered by a level-ancestor query. This yields $C_s(i,j)=\{s_k \mid i \le k \le j\},$88 query time and $C_s(i,j)=\{s_k \mid i \le k \le j\},$89 space. With a finger to a nearby block, finger-predecessor search further improves the time to $C_s(i,j)=\{s_k \mid i \le k \le j\},$90.

These fingerprint data structures are then used to solve longest common extension queries. Once substring-equality tests are available in time $C_s(i,j)=\{s_k \mid i \le k \le j\},$91, the standard exponential-search plus binary-search scheme finds

$C_s(i,j)=\{s_k \mid i \le k \le j\},$92

in $C_s(i,j)=\{s_k \mid i \le k \le j\},$93 time (Bille et al., 2013). Consequently, the reported bounds are $C_s(i,j)=\{s_k \mid i \le k \le j\},$94 for SLPs, $C_s(i,j)=\{s_k \mid i \le k \le j\},$95 for Linear SLPs, and $C_s(i,j)=\{s_k \mid i \le k \le j\},$96 when finger queries are used.

The guarantees here differ from the deterministic one-sided filters discussed above. The data structures are exact assuming no fingerprint collisions. By picking the modulus $C_s(i,j)=\{s_k \mid i \le k \le j\},$97 and base $C_s(i,j)=\{s_k \mid i \le k \le j\},$98 at random, the collision probability is $C_s(i,j)=\{s_k \mid i \le k \le j\},$99, and a union bound over stored hashes yields high-probability correctness (Bille et al., 2013). The source also states that one can derandomize to a Las Vegas structure via postprocessing verification.

6. Guarantees, limitations, and recurrent misconceptions

Across these formulations, one recurring misconception is to treat all string fingerprints as conventional hash values. The cited work on approximate keyword matching states that the fingerprints work in a similar way to hash values; however, they can be also used for matching with errors (Cisłak et al., 2017). The cited database work similarly uses fingerprints as lightweight secondary indexes that approximate LIKE predicates, albeit with false positives (Stoian et al., 14 Jul 2025). By contrast, substring alphabet fingerprints are exact set-theoretic objects rather than lossy encodings, while Karp–Rabin fingerprints are algebraic hashes whose correctness is probabilistic unless verified (Belazzougui et al., 2013, Bille et al., 2013).

A second misconception is to equate “no false negatives” with exact matching. The lightweight bitwise filters for Hamming and Levenshtein distance never discard a true match within $F=\{C_s(i,j)\mid 1\le i\le j\le n\},$00 errors, but many non-matching pairs may not be ruled out (Cisłak et al., 2017). The LIKE fingerprints likewise never reject a true match under the character-containment relaxation, yet full predicate evaluation is still required because substring order and multiplicity are not encoded (Stoian et al., 14 Jul 2025). A plausible implication is that these fingerprints are best understood as admissible filters rather than complete decision procedures.

A third misconception concerns the source of efficiency. In the approximate-matching setting, the speedup derives from an $F=\{C_s(i,j)\mid 1\le i\le j\le n\},$01 bitwise-and-popcount filter applied before an $F=\{C_s(i,j)\mid 1\le i\le j\le n\},$02 or $F=\{C_s(i,j)\mid 1\le i\le j\le n\},$03 exact check, with one $F=\{C_s(i,j)\mid 1\le i\le j\le n\},$04-bit fingerprint per stored string as overhead (Cisłak et al., 2017). In the substring-alphabet setting, the gains come from preprocessing via suffix trees, participation trees, naming, and succinct static functions that support $F=\{C_s(i,j)\mid 1\le i\le j\le n\},$05 or $F=\{C_s(i,j)\mid 1\le i\le j\le n\},$06 query times (Belazzougui et al., 2013). In the compressed-string setting, the asymptotic improvement is obtained by exploiting grammar structure and heavy-path or predecessor machinery, not by raw bit-parallelism (Bille et al., 2013). In the database setting, the advantage comes from reducing expensive LIKE evaluations and associated compute and I/O overhead by using a cheap bitwise-AND test (Stoian et al., 14 Jul 2025).

The limitations are correspondingly heterogeneous. For lightweight approximate matching, only tracked symbols in $F=\{C_s(i,j)\mid 1\le i\le j\le n\},$07 contribute to the fingerprint, and the lower bound may be loose when $F=\{C_s(i,j)\mid 1\le i\le j\le n\},$08 or the strings are highly repetitive (Cisłak et al., 2017). For substring alphabet fingerprints, the exact structures can require terms involving $F=\{C_s(i,j)\mid 1\le i\le j\le n\},$09, $F=\{C_s(i,j)\mid 1\le i\le j\le n\},$10, and $F=\{C_s(i,j)\mid 1\le i\le j\le n\},$11 in time and space (Belazzougui et al., 2013). For workload-optimized LIKE fingerprints, generalization to unseen predicates is empirical rather than universal, although the source reports that the learned partitioning often generalizes to unseen patterns (Stoian et al., 14 Jul 2025). For Karp–Rabin fingerprints, the underlying limitation is collision probability, mitigated by randomization or Las Vegas verification (Bille et al., 2013).

Taken together, these results show that string fingerprints are not a single algorithmic primitive but a broad design pattern: represent a string, substring, or query-relevant aspect of string content in a more compact domain, and exploit that representation for pruning, indexing, or compressed querying. The specific semantics of the representation determine whether the outcome is an exact set-membership structure, a one-sided approximate filter, or a probabilistic equality surrogate.