---
title: 'Suffixient Arrays: Minimal Suffix Sampling'
url: https://www.emergentmind.com/topics/suffixient-arrays
type: topic
---

# Suffixient Arrays: Minimal Suffix Sampling

Suffixient arrays are a suffix-array compression technique that retain only a minimum-size subset of prefix endpoints sufficient to support locating one occurrence of a pattern and computing maximal exact matches (MEMs), provided random access to the text is available. In the now-standard formulation, the selected endpoints are ordered co-lexicographically—equivalently, by lexicographic order of the corresponding suffixes of the reversed text—so the structure can be viewed both as a minimal suffixient set and as a sparse subsequence of the suffix array of the reversed text [2407.18753][2605.04258].

## 1. Formal definition and underlying combinatorics

Let $T[1..n]$ be a text over an alphabet $\Sigma$, terminated by a unique sentinel. A substring $\mathrm{str}=T[i_{\text{text}}..j_{\text{text}}]$ is right-maximal if there exist at least two distinct characters $a,b \in \Sigma$ such that both $\mathrm{str}\cdot a$ and $\mathrm{str}\cdot b$ occur in $T$. For any right-maximal $\mathrm{str}$, each occurring string $\mathrm{str}\cdot c$ is a one-character right-maximal extension. A set $X \subseteq \{1,\dots,n\}$ is suffixient if for every such extension there exists a position $x_{\text{text}} \in X$ such that $\mathrm{str}\cdot c$ is a suffix of the prefix $T[1..x_{\text{text}}]$ [2605.04258].

A suffixient array is any minimum-size suffixient set ordered so that the prefixes $T[1..\mathrm{sA}[1]],T[1..\mathrm{sA}[2]],\dots$ appear in co-lexicographic order. In implementation-oriented formulations, this order is induced by the suffix array of the reversed text $T^{\mathrm{rev}}$, together with its LCP array and BWT, and the endpoint mapping is $j_{\text{text}} = n - SA[j] + 1$ [2605.04258]. Earlier work described the same object as a subsampled prefix array, where the co-lexicographic order of prefixes of $T$ is exactly the lexicographic order of suffixes of the reversed text $R=T^{\mathrm{rev}}$ [2506.08225].

The minimal cardinality of a suffixient set is denoted $\chi$. In the measure-theoretic formulation, $\chi(w)$ equals the number of super-maximal right-extensions, written $|SRE(w)|$, and also equals $\min\{|S|: S \text{ is a suffixient set for } w\}$ [2604.04377]. This gives suffixient arrays a precise combinatorial interpretation: they store exactly one representative per super-maximal right-extension, no more and no less.

A central 2026 characterization expresses a minimum suffixient set as
$$
FullL := \{\, n - SA[p] + 1 \mid p = Candt_c(b(x), e(x)),\ 1 < x \le n,\ BWT[x] \ne BWT[x-1],\ c \in \{ BWT[x], BWT[x-1] \} \,\},
$$
where $b(x)$ and $e(x)$ delimit the maximal LCP interval around $x$, and $Candt_c(a,a')$ picks the leftmost maximum-weight run-boundary candidate for character $c$ inside $[a..a')$. The resulting set is suffixient, has minimum possible size, and is already in suffixient-array order when emitted by character groups in the SA-induced co-lex order [2605.04258].

## 2. Query model and algorithmic functionality

Suffixient arrays are specialized indexes. They do not aim to reproduce the full functionality of suffix arrays, compressed suffix arrays, or FM-indexes; instead, they preserve precisely the information needed to locate one occurrence of a pattern and to compute MEMs under a random-access model for the underlying text [2605.04258][2607.00204].

The original presentation emphasizes binary search over the co-lexicographically ordered sampled prefixes. Because the stored prefixes cover every one-character right-extension of every right-maximal substring, binary comparisons against the sampled set never lose the decision boundaries required for correctness. Under this formulation, locating one occurrence of a pattern of length $m$ takes $O(m \log \chi)$ character inspections in the worst case, assuming random access to the text [2407.18753].

The revisited characterization sharpens the query view. Once the minimum set $FullL$ is available, locating one occurrence can be described as greedily following guaranteed one-character extensions of the pattern, verifying them directly by character comparisons in the text. In that formulation, locate returns a text position ending an occurrence in $O(m)$ character comparisons and uses $O(1)$ extra space beyond the array [2605.04258]. The same work sketches MEM enumeration by scanning pattern positions, selecting candidate endpoints grouped by the current character, and extending backward and forward using random access; the expected complexity is $O(m + \mathrm{output})$ [2605.04258].

These guarantees are deliberately narrower than those of full-text indexes. Suffixient arrays do not directly support counting all occurrences or general SA-interval operations without augmentation [2605.04258][2607.00204]. Their design point is different: when paired with a direct-access representation of $T$, they offer a very small, contiguous, cache-friendly index for witness location and MEM extraction.

## 3. The size parameter $\chi$ as a repetitiveness measure

Because the suffixient array stores exactly $\chi$ endpoints, its size is itself a repetitiveness measure. The parameter sits between several classical measures. One line of work proves $\gamma(w) \le \chi(w)$, where $\gamma$ is the size of the smallest string attractor, and also $\chi(w) \le 2r(w)$, where $r(w)$ is the number of runs in the Burrows–Wheeler transform [2604.04377]. A later analysis strengthens the placement of $\chi$ in the repetitiveness landscape, stating $\chi \le 2r$ and showing incomparability with copy–paste measures such as $z$, $v$, $g$, $g_{rl}$, and $c$ [2506.05638].

The measure is structurally sensitive. On Fibonacci words, $\chi(F_k) \le 4$, while on binary de Bruijn sequences $\chi = \Theta(n)$ [2506.05638]. For substrings of episturmian words over an alphabet of size $\sigma$, the bound $\chi \le \sigma + 2$ holds [2506.05638]. These examples explain why suffixient arrays can be extremely compact on highly structured repetitive families and essentially uncompressed on strings with maximal local branching complexity.

A distinct but related result settles the reachability question for $\chi$ at the level of text representation. Every string admits a substring equation system (SES) of size $O(\chi(w))$, with explicit bound $\chi(w)-1+\sigma(w)$, and satisfiability, uniqueness, and reconstruction of an SES can be decided in $O(n)$ time [2604.04377]. This does not make the suffixient array itself a self-sufficient compressed text representation, but it shows that $\chi$ is large enough to control a universal equality-based representation of the underlying string.

## 4. Construction algorithms

The construction literature has progressed from linear-time but multi-scan procedures, through one-pass streaming algorithms, to practical implementations and sublinear-time packed-string constructions.

| Work | Main bound | Distinguishing feature |
|---|---|---|
| [2407.18753] | Linear time; one-pass variant $O(n+\bar r \log \sigma)$ | Introduced suffixient arrays |
| [2605.04258] | One-pass $O(n)$ time, $O(\chi+h)$ words | Standard RAM; monotone-stack characterization |
| [2606.31034] | One-pass $O(n)$ time, practical | First implemented linear-time one-pass constructor |
| [2607.00204] | $O\!\left(\frac{n\log \sigma}{\sqrt{\log n}}+\min(r,\bar r)\log^\varepsilon n\right)$ | First sublinear-time construction under packed assumptions |

The initial construction framework showed that, given the suffix array, LCP array, and BWT of the reversed text, a suffixient array can be constructed in linear time by multiple scans. Under a strict one-pass restriction, the same line of work obtained an $O(n+\bar r \log \sigma)$ algorithm, where $\bar r$ is the number of runs in the BWT of the reversed text; the working space for computing the minimum-size suffixient set is $O(\sigma)$ words, and for producing the suffixient array it becomes $O(\sigma+\chi)\subseteq O(\chi)$ [2605.04258].

The 2026 revisitation replaces per-character balanced-map logic by constant-time array accesses and derives a one-pass linear-time algorithm under the standard RAM model. Its core data structures are a monotone stack over LCP values to compute $b(i)$ online, a weight-sorted doubly linked list holding at most one active candidate per character, arrays $MAP[1..\sigma]$ and $prevW[1..\sigma]$, and per-character output lists $result_c$. The theorem states that scanning $BWT[1..n]$, $SA[1..n]$, and $LCP[1..n]$ of $T^{\mathrm{rev}}$ once suffices to construct a suffixient array in $O(n)$ time using $O(\chi+h)$ words of working space, where $h$ is the suffix-tree height of the reversed text [2605.04258].

The practical linear-time implementation refines the same combinatorial basis through the notion of last $c$-candidates, which are equivalent to the earlier rightmost-maximum rule over run-break boxes. Its final algorithm, LC, computes NSV and PSV values only where needed—at run breaks—using monotone stacks during a single left-to-right scan of $SĀ$, $LCP̄$, and $BWT̄$ [2606.31034]. On the reported benchmarks, LC used the same space as LF, $3.1$–$3.3\times$ less than PLC/FM, and $17$–$19\times$ less than the online method; it was $14$–$39\%$ faster than LF, $6$–$32\%$ faster than PLC, and $6$–$24\%$ faster than FM [2606.31034].

The newest asymptotic development shows that the smallest suffixient array can also be computed in
$$
O\!\left(\frac{n\log \sigma}{\sqrt{\log n}}+\min(r,\bar r)\log^\varepsilon n\right)
$$
time for any $\varepsilon>0$, with working space
$$
O\!\left(\frac{n\log \sigma}{\log n}+\min(r,\bar r)\right),
$$
where $r$ and $\bar r$ are the numbers of BWT runs in $T$ and its reverse. This becomes sublinear when $\log \sigma = o(\sqrt{\log n})$ and $\min(r,\bar r)=o(n/\log^\varepsilon n)$ [2607.00204].

## 5. Certification, testing, and dynamic maintenance

Once suffixient arrays were introduced as a minimal-sampling principle, two algorithmic questions became natural: how to certify that a given subset is suffixient, and how to maintain smallest suffixient sets under updates.

The testing problem admits linear-time solutions. In the prefix-array formulation, let $box(i)=[PSV[i]+1,NSV[i]-1]$ be the maximal LCP interval around a position in the suffix array of the reversed text. A subset is suffixient if and only if every relevant BWT run break has a sampled index with the correct BWT letter inside the corresponding box; minimum cardinality holds if and only if, for equal BWT letters, the boxes of sampled positions are pairwise disjoint [2506.08225]. These tests reduce suffixient-set verification to a single linear sweep once $SA_R$, $LCP_R$, $BWT_R$, the previous/next-smaller arrays, and the auxiliary $SLPR$ array are available [2506.08225].

The dynamic problem is harder because $\chi$ is not invariant under local edits. An online maintenance algorithm now exists in both right-to-left and left-to-right streaming models. It maintains the smallest suffixient set in worst-case $O(\log^2\log n)$ time per processed letter over integer alphabets, improving to $O(\log\log n)$ when $\sigma = O(\log^{1/4} n)$, with $O(n)$ space [2604.27548]. The main tool is Weiner’s suffix tree algorithm, together with dynamic colored-predecessor and dynamic LCA primitives. Although the paper does not define a distinct “suffixient array,” it explicitly notes that the maintained set can be output as a sorted array of positions after each update [2604.27548].

These certification and maintenance results are important because they separate the combinatorial notion from any particular constructor. A suffixient array is not merely a derived by-product of one batch algorithm; it is now a verifiable, dynamically maintainable object.

## 6. Relationship to other indexes, empirical profile, and open directions

Suffixient arrays occupy a distinct point in the design space of string indexes. A full suffix array uses $\Theta(n)$ space and supports general interval queries; compressed suffix arrays and FM-indexes support richer operations through backward search and rank/select over the BWT; the $r$-index uses $O(r)$-scale space and is particularly strong on repetitive texts. By contrast, the suffixient array stores only $\chi$ endpoints and is tailored to locate one occurrence and compute MEMs with random access to $T$ [2605.04258][2607.00204].

This specialization yields two practical consequences. First, the structure can be asymptotically smaller than run-length-BWT-based indexes because $\chi$ is bounded by run counts yet can be strictly smaller on some families [2506.05638]. Second, its memory access pattern is simple: the sampled array is contiguous and searched co-lexicographically, leaving only direct text access as the nonlocal component. The original experimental study reports that the index is simultaneously faster and orders of magnitude smaller than the suffix array, and smaller and one to two orders of magnitude faster than the $r$-index; it also reports average pattern matching query time as low as $3.5$ ns per character, against a RAM-throughput lower bound of $1.18$ ns per character [2407.18753].

Several limitations remain explicit in the literature. Query support is specialized rather than general: suffixient arrays do not directly provide full counting queries or all-occurrence reporting without extra machinery [2605.04258]. Most constructions assume that $SA$, $LCP$, and $BWT$ of the reversed text are already available or streamable, and all query algorithms require random access to $T$ [2605.04258]. The one-pass linear constructor still carries an $O(\chi+h)$ workspace term, where $h$ is suffix-tree height, and practical work identifies further reductions in stack-related space as an open problem [2606.31034].

Open directions therefore cluster around three themes. One is functional extension: counting and multi-locate while preserving near-$\chi$ space remains open [2605.04258]. A second is representational integration: SES reachability shows that texts admit $O(\chi)$-size equality-based representations, but direct indexing and random access over those representations are not supplied by that result [2604.04377]. A third is dynamic and streaming computation: near-real-time maintenance is now known, but combining dynamic guarantees with the smallest practical working space, compressed text access, and one-pass reversed-array construction remains unresolved [2604.27548][2606.31034].

Source: https://www.emergentmind.com/topics/suffixient-arrays