Space-Efficient Text Indexing with Mismatches using Function Inversion

2026-04-01

AI Summary

This work addresses the problem of efficiently supporting substring matching queries under Hamming distance at most $k$, while using only linear or sublinear space. By integrating CGL trees with Fiat–Naor function inversion techniques, the authors propose a novel compact index structure that achieves, for the first time, query time independent of the alphabet size within linear space. Moreover, it yields the first mismatch index requiring only sublinear extra space. The proposed method attains a query complexity of $\widetilde{O}(|q| + \log^{4k} n + \log^{2k} n \cdot \#occ)$ within $O(n)$ space, significantly outperforming existing linear-space solutions—particularly for $k \geq 3$.

Abstract

A classic data structure problem is to preprocess a string T of length $n$ so that, given a query $q$, we can quickly find all substrings of T with Hamming distance at most $k$ from the query string. Variants of this problem have seen significant research both in theory and in practice. For a wide parameter range, the best worst-case bounds are achieved by the "CGL tree" (Cole, Gottlieb, Lewenstein 2004), which achieves query time roughly $\tilde{O}(|q| + \log^k n + \# occ)$ where $\# occ$ is the size of the output, and space ${O}(n\log^k n)$. The CGL Tree space was recently improved to $O(n \log^{k-1} n)$ (Kociumaka, Radoszewski 2026). A natural question is whether a high space bound is necessary. How efficient can we make queries when the data structure is constrained to $O(n)$ space? While this question has seen extensive research, all known results have query time with unfavorable dependence on $n$, $k$, and the alphabet $Σ$. The state of the art query time (Chan et al. 2011) is roughly $\tilde{O}(|q| + |Σ|^k \log^{k^2 + k} n + \# occ)$. We give an $O(n)$-space data structure with query time roughly $\tilde{O}(|q| + \log^{4k} n + \log^{2k} n \# occ)$, with no dependence on $|Σ|$. Even if $|Σ| = O(1)$, this is the best known query time for linear space if $k\geq 3$ unless $\# occ$ is large. Our results give a smooth tradeoff between time and space. We also give the first sublinear-space results: we give a succinct data structure using only $o(n)$ space in addition to the text itself. Our main technical idea is to apply function inversion (Fiat, Naor 2000) to the CGL tree. Combining these techniques is not immediate; in fact, we revisit the exposition of both the Fiat-Naor data structure and the CGL tree to obtain our bounds. Along the way, we obtain improved performance for both data structures, which may be of independent interest.

Problem

• text indexing
• mismatches
• space efficiency
• Hamming distance
• function inversion

Innovation

• function inversion
• space-efficient indexing
• text indexing with mismatches
• CGL tree
• succinct data structures