Minimal Unique Substring (MUS)

• MUS is defined as a substring that appears exactly once in a string and becomes repeating when its first or last character is removed.
• MUSs exhibit non-nesting properties, ensuring that no MUS is completely contained within another, which bounds their total number by the string length.
• Efficient linear-time algorithms using suffix arrays and LCP arrays compute MUSs, making them essential for advanced string indexing and bioinformatics applications.

A minimal unique substring (MUS) of a string $T$ is a substring that occurs exactly once in $T$ and is minimal with respect to that uniqueness: deleting its first character or its last character yields a repeating substring. Equivalently, every proper substring of a MUS is repeating. MUSs are typically identified with their occurrence intervals $[s,t]$, form a non-nesting family, and their total number in a string of length $n$ is at most $n$ (Mieno et al., 2019, Mieno et al., 2016).

1. Formal definition and core structural properties

Let $T$ be a string of length $n$ over an alphabet $\Sigma$, and let $\mathrm{occ}_T(w)$ denote the number of occurrences of a string $w$ in $T$0. A substring $T$1 is unique if $T$2, and repeating if $T$3. The standard MUS definition is

$T$4

which is equivalent to requiring every proper substring of $T$5 to be repeating (Mieno et al., 2019).

Two structural properties recur throughout the literature. First, distinct MUSs do not nest. If $T$6 and $T$7 are MUSs with $T$8, then $T$9 contains $[s,t]$0, forcing the inner substring to occur once and contradicting minimality. Second, for each start position $[s,t]$1, there is at most one MUS commencing at $[s,t]$2; otherwise one candidate would be a proper prefix of the other, and the shorter one would prevent the longer one from being minimal. These two facts together yield the global bound $[s,t]$3 (Fujimaru et al., 22 Aug 2025).

Concrete examples illustrate the definition sharply. For $[s,t]$4, the substring $[s,t]$5 is a MUS because it occurs once, while both $[s,t]$6 and $[s,t]$7 occur twice; in fact $[s,t]$8. For $[s,t]$9, using the convention that the empty string $n$0 occurs $n$1 times, each single character is a MUS and no longer substring is minimal, so $n$2 (Fujimaru et al., 22 Aug 2025).

2. Relation to shortest unique substrings

MUSs are closely tied to shortest unique substring (SUS) queries. For a query interval $n$3, a substring $n$4 is a SUS for $n$5 if it is unique, contains $n$6, and every strictly shorter substring containing $n$7 is repeating. The special case $n$8 yields point-SUS queries (Mieno et al., 2016, Mieno et al., 2019).

The algorithmic connection is direct: all known optimal solutions for both point- and interval-SUS queries follow the same high-level plan of first computing $n$9, or an equivalent structure, and then building auxiliary arrays that enumerate exactly those unique substrings covering the query that are minimal in length. In the classical linear-time preprocessing framework, this supports $n$0 query time for point SUS and $n$1 query time for interval SUS, where $n$2 and $n$3 are the output sizes (Mieno et al., 2016).

This dependence on MUSs persists in succinct indexing. A space-efficient formulation marks MUS starts and ends with the bit-vectors $n$4 and $n$5, augments them with rank/select, and emulates virtual arrays of MUS start positions, end positions, and lengths. On top of these, an interval-SUS structure of $n$6 bits answers any interval query in output-sensitive $n$7 time, while a point-SUS structure of $n$8 bits supports point queries in the same $n$9 time (Mieno et al., 2019).

3. Linear-time computation and compact representation

The standard linear-time route to all MUSs uses suffix arrays and longest-common-prefix information. Let $T$0 be the suffix array of $T$1, and $T$2 the usual adjacent-suffix LCP array, with sentinel zeros at the boundaries. For each suffix $T$3, define

$T$4

Then $T$5 is the shortest unique substring starting at $T$6; moreover it is minimal unique, and every MUS arises in this way. Consequently, after building $T$7 and $T$8 in $T$9 time, one computes each $n$0 and outputs the corresponding intervals, obtaining all MUSs in $n$1 total time (Fujimaru et al., 22 Aug 2025).

The same viewpoint underlies bit-space reductions. In the space-efficient construction, $n$2 iff $n$3 is the start of some MUS and $n$4 iff $n$5 is its end; each vector contains exactly $n$6 one-bits. Rank/select over these bit-vectors emulates the arrays

$n$7

and an $n$8 structure over $n$9 supports constant-time range minima for SUS reporting (Mieno et al., 2019).

The same paper gives a small-space MUS construction pipeline. A single left-to-right scan, combined with compact LCP/ISA access, computes $\Sigma$0 and $\Sigma$1 in $\Sigma$2 time using $\Sigma$3 bits; choosing the in-place $\Sigma$4 representation yields $\Sigma$5 and $\Sigma$6, hence true $\Sigma$7 time in $\Sigma$8 bits (Mieno et al., 2019). This places MUS computation in the class of linear-time, linear-bit string indexing primitives.

4. Sliding-window MUSs

The MUS problem has also been studied in a sliding-window model. For a fixed width $\Sigma$9, one considers the sequence of windows $\mathrm{occ}_T(w)$0 and asks how $\mathrm{occ}_T(w)$1 changes as the window moves one position to the right. The central combinatorial result is that a single slide changes only a constant number of MUSs: $\mathrm{occ}_T(w)$2 and the size difference satisfies

$\mathrm{occ}_T(w)$3

Therefore the total symmetric-difference mass over all $\mathrm{occ}_T(w)$4 slides is $\mathrm{occ}_T(w)$5 (Mieno et al., 2019).

The analysis uses two auxiliary suffix notions for a window $\mathrm{occ}_T(w)$6: the longest repeating suffix $\mathrm{occ}_T(w)$7, namely the longest suffix with at least two occurrences in $\mathrm{occ}_T(w)$8, and the shortest quasi-unique suffix $\mathrm{occ}_T(w)$9, namely the shortest suffix with at most two occurrences in $w$0. Their interaction controls when MUSs are inserted or deleted after a slide (Mieno et al., 2019).

The maintenance algorithm operates in $w$1 time and $w$2 space, where $w$3 is the maximum number of distinct characters in every window. Its core data structures are a sliding-window suffix tree, three active points—the primary point $w$4 for $w$5, the secondary point $w$6 for $w$7, and the tertiary point $w$8 for the longest suffix occurring at least three times—and circular arrays $w$9 and $T$00 of length $T$01, which record the unique end of the MUS starting at a position and the start of the MUS ending at a position. Because MUSs do not nest, these arrays support $T$02 insertion and deletion of individual MUS intervals. Setting $T$03 yields an online $T$04-time, $T$05-space algorithm for all MUSs of $T$06 (Mieno et al., 2019).

5. Extremal combinatorics and local density

Although $T$07 globally, MUSs can cluster around a single position. For

$T$08

the maximum possible value of $T$09 over strings of length $T$10 is $T$11. The upper bound states that $T$12 for every $T$13 and every position $T$14; the lower bound gives an infinite family of strings $T$15 of length $T$16 and a position $T$17 such that $T$18 (Fujimaru et al., 22 Aug 2025).

This local bound has direct algorithmic consequences. Any data structure that must list all MUSs covering a query position may require $T$19 output time in the worst case. The same paper notes that, under single-character edits, a position-based update can destroy and create MUSs covering the edited position, and the $T$20 crossing bound quantifies the worst-case local sensitivity of MUS sets (Fujimaru et al., 22 Aug 2025).

Related SUS bounds show that MUSs act as a sparse underlying structure for denser shortest-covering families. If $T$21, then the total number of point-SUS intervals over all positions satisfies

$T$22

and this is tight; for non-trivial interval-SUSs,

$T$23

These results explain why output-sensitive SUS data structures remain linear in total output size even though they may report more intervals than the MUS set itself (Mieno et al., 2016).

6. Variants, applications, and open directions

The exact uniqueness model has been extended to approximate uniqueness. In the $T$24-mismatch setting, a substring $T$25 is $T$26-mismatch unique if there is no other equal-length substring $T$27 with Hamming distance at most $T$28. The corresponding shortest-covering query, denoted $T$29, can be solved by an in-place three-stage framework: first compute left-bounded shortest unique substrings $T$30, then the rightmost shortest $T$31 covering each position $T$32, and finally assemble $T$33 either from $T$34 or by extending the previous answer. The framework uses only the read-only string $T$35 plus arrays $T$36 and $T$37, for peak memory $T$38 machine words $T$39 bytes, and runs in $T$40 time for $T$41 and $T$42 time for any $T$43 (Hon et al., 2015).

Applications of MUS- and SUS-based uniqueness analysis are concentrated in string indexing and computational biology. The sliding-window work explicitly lists shortest-unique-substring queries, anti-dictionary compression via minimal absent words, and indexing problems in bioinformatics; the approximate framework further points to primer design for PCR, read-uniqueness in genome assembly, and marker discovery between strains, where a bounded number of mismatches must be tolerated (Mieno et al., 2019, Hon et al., 2015).

Several open directions remain explicit in the literature. Proposed extensions include handling edits in dynamic strings and higher-order “unique fragments” under different occurrence models (Mieno et al., 2019). On the SUS side, open questions include whether the all-point-SUS problem can be solved in less than $T$44 space, whether the same $T$45-preprocessing and $T$46-query bounds can be achieved on compressed representations such as run-length or grammar compression, and whether the fixed-alphabet conjecture

$T$47

holds for all strings over an alphabet of size $T$48 (Mieno et al., 2016). These questions indicate that, despite the linear-time computability of MUSs and their clean non-nesting structure, the fine-grained geometry of uniqueness in strings is still not fully characterized.