String Synchronizing Sets: Sublinear-Time BWT Construction and Optimal LCE Data Structure

TL;DR

This paper introduces a groundbreaking sublinear-time algorithm for constructing the Burrows-Wheeler transform of binary strings, leveraging a novel concept of string synchronizing sets, and also develops an optimal data structure for LCE queries.

Contribution

It presents the first BWT construction algorithm with sublinear time complexity and introduces string synchronizing sets, enabling optimal LCE data structures with deterministic construction.

Findings

BWT constructed in O(n/√log n) time for binary strings

Introduces string synchronizing sets as a new concept

Designs an optimal O(n/ log n) size LCE data structure

Abstract

Burrows-Wheeler transform (BWT) is an invertible text transformation that, given a text $T$ of length $n$, permutes its symbols according to the lexicographic order of suffixes of $T$. BWT is one of the most heavily studied algorithms in data compression with numerous applications in indexing, sequence analysis, and bioinformatics. Its construction is a bottleneck in many scenarios, and settling the complexity of this task is one of the most important unsolved problems in sequence analysis that has remained open for 25 years. Given a binary string of length $n$, occupying $O(n/\log n)$ machine words, the BWT construction algorithm due to Hon et al. (SIAM J. Comput., 2009) runs in $O(n)$ time and $O(n/\log n)$ space. Recent advancements (Belazzougui, STOC 2014, and Munro et al., SODA 2017) focus on removing the alphabet-size dependency in the time complexity, but they still require $\Omega(n)$ time. In this paper, we propose the first algorithm that breaks the $O(n)$-time barrier for BWT construction. Given a binary string of length $n$, our procedure builds the Burrows-Wheeler transform in $O(n/\sqrt{\log n})$ time and $O(n/\log n)$ space. We complement this result with a conditional lower bound proving that any further progress in the time complexity of BWT construction would yield faster algorithms for the very well studied problem of counting inversions: it would improve the state-of-the-art $O(m\sqrt{\log m})$-time solution by Chan and P\v{a}tra\c{s}cu (SODA 2010). Our algorithm is based on a novel concept of string synchronizing sets, which is of independent interest. As one of the applications, we show that this technique lets us design a data structure of the optimal size $O(n/\log n)$ that answers Longest Common Extension queries (LCE queries) in $O(1)$ time and, furthermore, can be deterministically constructed in the optimal $O(n/\log n)$ time.

Equations

$$\mathsf{R}=\{i\in [1..n-3\tau +2]:\text{per}(T[i..i+3\tau -2])\le \frac{1}{3}\tau \}.$$

$${\mathrm{succ}}_{\mathsf{S}}(i):=\min \{j\in \mathsf{S}\cup \{n-2\tau +2\}:j\ge i\}.$$

$${\mathrm{succ}}_{\mathsf{S}}(s_i+1)-(s_i+1)={\mathrm{succ}}_{\mathsf{S}}(s_j+1)-(s_j+1)\le \tau -1,$$

$$d_i=\{\begin{array}{ll}n-s_{i+1}+s_i& \text{if }T[s_{i+1}+2\tau -1]\succ T[s_{i+1}+2\tau -1-p_i],\\ s_{i+1}-s_i-n& \text{otherwise (if si+1=n−2τ+2 in particular).}\end{array}$$

$$\mathrm{LCE}(i,j)=s_{i^{\prime }+\ell }-i+\mathrm{LCE}(s_{i^{\prime }+\ell },s_{j^{\prime }+\ell })<s_{i^{\prime }+\ell }-i+3\tau .$$

$$\mathrm{LCE}(i,j)=\{\begin{array}{ll}\min (s_{i^{\prime }}-i,s_{j^{\prime }}-j)+2\tau -1& \text{ if }{s}_{i^{\prime }}-i\ne s_{j^{\prime }}-j,\\ s_{i^{\prime }}-i+\mathrm{LCE}(s_{i^{\prime }},s_{j^{\prime }})& \text{ if }{s}_{i^{\prime }}-i=s_{j^{\prime }}-j.\end{array}$$

$$\mathcal{F}=\{X\in \{0,1{\}}^{3\tau -1}:X^{\prime }\notin \mathcal{D}\text{ for every prefix }{X}^{\prime }\text{ of }X\}.$$

$$r_j^{=}=|\{j^{\prime }\in \text{pos}(j):\text{L-exp}(j^{\prime })=\text{L-exp}(j)\}|\text{and}{r}_j^{<}=|\{j^{\prime }\in \text{pos}(j):\text{L-exp}(j^{\prime })<\text{L-exp}(j)\}|.$$

$${\mathsf{R}}_U^{-}=\{j\in {\mathsf{R}}^{-}:\text{L-root}(j)=U\}\subseteq {\mathsf{R}}^{-}.$$

$$T_A=\prod _{i=1}^m\overline{{\text{bin}}_{\epsilon \log m}(A[i])}\cdot 01\cdot 1^{\epsilon \log m}\cdot {\text{pad}}_{\log m}({\text{bin}}_{\log m}(i-1))\cdot 0.$$

$$T_A=\prod _{i=1}^m\overline{{\text{bin}}_{\log m}(A[i])}\cdot 01\cdot 1^{\log m}\cdot 0\cdot {\text{bin}}_{\log m}(i-1)\cdot 0\cdot 1^{\log m}\cdot 0.$$

$$\mathsf{R}=\{i\in [1..n-3\tau +2]:[i..i+2\tau )\subseteq \mathsf{Q}\}.$$

$$\mathsf{S}=\{i\in [1..n-2\tau +1]:\min \{\mathsf{id}(j):j\in [i..i+\tau ]\setminus \mathsf{Q}\}\in \{\mathsf{id}(i),\mathsf{id}(i+\tau )\}\}.$$

$$\min \{\mathsf{id}(j):j\in [i..i+\tau ]\setminus \mathsf{Q}\}=\min \{\mathsf{id}(j):j\in [i^{\prime }..i^{\prime }+\tau ]\setminus \mathsf{Q}\}.$$

$$\mathbb{P}[i\in \mathsf{S}]=\mathbb{P}[\min \{\mathsf{id}(j):j\in [i..i+\tau ]\}\in \{\mathsf{id}(i),\mathsf{id}(i+\tau )\}]\le 2\cdot \frac{3}{\tau }$$

$$\mathsf{B}=\big{\{}i\in[1\mathinner{\ldotp\ldotp}n-\tau+1]\setminus\mathsf{Q}:\text{\rm per}(T[i\mathinner{\ldotp\ldotp}i+\tau-1))\leq\tfrac{1}{3}\tau\text{ or }\text{\rm per}(T[i+1\mathinner{\ldotp\ldotp}i+\tau))\leq\tfrac{1}{3}\tau\big{\}}$$

Full text

In this paper, we propose the first algorithm that breaks the $\mathcal{O}(n)$-time barrier for BWT construction. Given a binary string of length $n$, our procedure builds the Burrows–Wheeler transform in $\mathcal{O}(n/\sqrt{\log n})$ time and $\mathcal{O}(n/\log n)$ space. We complement this result with a conditional lower bound proving that any further progress in the time complexity of BWT construction would yield faster algorithms for the very well studied problem of counting inversions: it would improve the state-of-the-art $\mathcal{O}(m\sqrt{\log m})$-time solution by Chan and Pǎtraşcu (SODA 2010). Our algorithm is based on a novel concept of string synchronizing sets, which is of independent interest. As one of the applications, we show that this technique lets us design a data structure of the optimal size $\mathcal{O}(n/\log n)$ that answers Longest Common Extension queries (LCE queries) in $\mathcal{O}(1)$ time and, furthermore, can be deterministically constructed in the optimal $\mathcal{O}(n/\log n)$ time.

1 Introduction

The problem of text indexing is to preprocess an input text $T$ so that given any query pattern $P$, we can quickly find the occurrences of $P$ in $T$ (typically in $\mathcal{O}(|P|+{\rm occ})$ time, where $|P|$ is the length of $P$ and ${\rm occ}$ is the number of reported occurrences). Two classical data structures for this task are the suffix tree [43] and the suffix array [33]. The suffix tree is a trie containing all suffixes of $T$ with each unary path compressed into a single edge labeled by a text substring. The suffix array is a list of suffixes of $T$ in the lexicographic order, with each suffix encoded using its starting position. Both data structures take $\Theta(n)$ words of space, where $n$ is the length of $T$. In addition to indexing, they underpin dozens of applications in bioinformatics, data compression, and information retrieval [17, 2]. While the suffix tree is slightly faster for some operations, the suffix array is often preferred due to its simplicity and lower space usage.

Nowadays, however, indexing datasets of size close to the capacity of available RAM is often required. Even the suffix arrays are then prohibitively large, particularly in applications where the text consists of symbols from some alphabet $\Sigma$ of small size $\sigma=|\Sigma|$ (e.g., $\Sigma=\{{\tt A},{\tt C},{\tt G},{\tt T}\}$ and so $\sigma=4$ in bioinformatics). For such collections, the classical indexes are $\Theta(\log_{\sigma}n)$ times larger than the text, which takes only $\Theta(n\log\sigma)$ bits, i.e., $\Theta(n/\log_{\sigma}n)$ machine words, and thus they prevent many sequence analysis tasks to be performed without a significant penalty in space consumption.

This situation changed dramatically in early 2000’s, when Ferragina and Manzini [13], as well as Grossi and Vitter [16], independently proposed indexes with the capabilities of the suffix array (incurring only a $\mathcal{O}(\log^{\varepsilon}n)$ slowdown in the query time) that take a space asymptotically equal to that of the text (and with very small constant factors). These indexes are known as the FM-index and the compressed suffix array (CSA). The central component and the time and space bottleneck in the construction of both the FM-index and CSA111Although originally formulated in terms of the so-called “$\Psi$ function” [16], it is now established (see, e.g., [35, 21]) that the CSA is essentially dual to the FM-index. is the Burrows–Wheeler transform (BWT) [8]. BWT is an invertible permutation of the text that consists of symbols preceding suffixes of text in the lexicographic order. Almost immediately after their discovery, the BWT-based indexes replaced suffix arrays and suffix trees and the BWT itself has become the basis of almost all space-efficient algorithms for sequence analysis. Modern textbooks spend dozens of pages describing its applications [40, 32, 39], and BWT-indexes are widely used in practice; in bioinformatics, they are the central component of many read-aligners [30, 31].

BWT Construction

Given the practical importance of BWT, its efficient construction emerged as one of the most important open problems in the field of indexing and sequence analysis. The first breakthrough was the algorithm of Hon et al. [21], who reduced the time complexity of BWT construction for binary strings from $\mathcal{O}(n\log n)$ to $\mathcal{O}(n)$ time using working space of $\mathcal{O}(n)$ bits. This bound has been recently generalized to any alphabet size $\sigma$. More precisely, Belazzougui [4] described a (randomized) $\mathcal{O}(n)$-time construction working in optimal space of $\mathcal{O}(n/\log_{\sigma}n)$ words. Munro et al. [35] then proposed an alternative (and deterministic) construction. These algorithms achieve the optimal construction space, but their running time is still $\Omega(n)$, which is up to $\Theta(\log n)$ times more than the lower bound of $\Omega(n/\log_{\sigma}n)$ time (required to read the input and write the output). Up until now, all $o(n)$-time algorithms required additional assumptions, such as that the BWT is highly compressible using run-length encoding [25].

In this paper, we propose the first algorithm that always breaks the $\mathcal{O}(n)$-time barrier for BWT construction. Given a binary string of length $n$, our algorithm builds the Burrows–Wheeler transform in $\mathcal{O}(n/\sqrt{\log n})$ time and $\mathcal{O}(n/\log n)$ space. We complement this result with a conditional lower bound proving that any further progress in the time complexity of BWT construction would imply faster algorithms for the very well studied problem of counting inversions: it would improve the state-of-the-art $\mathcal{O}(m\sqrt{\log m})$-time solution by Chan and Pǎtraşcu [9]. We also generalize our construction to larger alphabets whose size $\sigma$ satisfies $\log\sigma\leq\sqrt{\log n}$. In this case, the running time is $\mathcal{O}(n\log\sigma/\sqrt{\log n})$ and the space complexity is $\mathcal{O}(n\log\sigma/\log n)$, proportional to the input and output size.

LCE Queries

The Longest Common Extension queries $\operatorname{LCE}(i,j)$ (also known as the Longest Common Prefix queries), given two positions in a text $T$, return the length of the longest common prefix of the suffixes $T[i\mathinner{\ldotp\ldotp}n]$ and $T[j\mathinner{\ldotp\ldotp}n]$ starting at positions $i$ and $j$, respectively. These queries were introduced by Landau and Vishkin [29] in the context of approximate pattern matching. Since then, they became one of the most commonly used tools in text processing. Standard data structures answer LCE queries in constant time and take linear space. The original construction algorithm [29, 43, 20] works in linear time for constant alphabets only, but it has been subsequently generalized to larger integer alphabets [12] and simplified substantially [24, 6]. Thus, LCE queries are completely resolved in the classic setting where the text $T$ is stored in $\mathcal{O}(n)$ space.

However, if $T$ is over a small alphabet of size $\sigma$, then it can be stored in $\mathcal{O}(n\log\sigma)$ bits. Yet, until very recently, even for the binary alphabet there was no data structure of $o(n\log n)$ bits supporting LCE queries in constant time. The first such solutions are by Tanimura et al. [42] and Munro et al. [36], who showed that constant-time queries can be implemented using data structures of size $\mathcal{O}(n\log\sigma/\sqrt{\log n})$ and $\mathcal{O}(n\sqrt{\log\sigma}/\sqrt{\log n})$, respectively. The latter result admits an $\mathcal{O}(n/\sqrt{\log_{\sigma}n})$-time construction from the packed representation of $T$. In yet another study, Birenzwige et al. [7] considered LCE queries in a model where $T$ is available for read-only random access, but not counted towards the data structure size. Constant-time LCE queries in the optimal space of $\mathcal{O}(n\log\sigma)$ bits can be deduced as a corollary of their results, but the construction algorithm is randomized and takes $\mathcal{O}(n)$ time.

Our contribution in the area of LCE queries is a data structure of the optimal size $\mathcal{O}(n/\log_{\sigma}n)$ that answers LCE in $\mathcal{O}(1)$ time and, furthermore, can be deterministically constructed in the optimal $\mathcal{O}(n/\log_{\sigma}n)$ time. This significantly improves the state of the art and essentially closes the LCE problem also in the packed setting.

Our Techniques

Our main innovation and the key tool behind both our results is a novel notion of string synchronizing sets, which relies on local consistency—the idea to make symmetry-breaking decisions involving a position $i$ of the text $T$ based on the characters at the nearby positions. This way, we can guarantee that equal fragments of the text are handled in the same way. The classic implementations of local consistency involve parsing the text; see e.g. [41, 23]. Unfortunately, the context size at a given level of the parsing is expressed in terms of the number of phrases, whose lengths may vary significantly between regions of the text. To overcome these limitations, Kociumaka et al. [28] introduced samples assignments with fixed context size. Birenzwige et al. [7] then applied the underlying techniques to define partitioning sets, which they used for answering LCE queries. Moreover, they obtained an alternative construction of partitioning sets (with slightly inferior properties) by carefully modifying the parsing scheme of [41]. In his PhD thesis [27], the second author introduced synchronizing functions, an improved version of samples assignments with stronger properties and efficient deterministic construction procedures. He also used synchronizing functions to develop the optimal LCE data structure in a packed text. In this work, we reproduce the latter result using synchronizing sets, which are closely related to synchronizing functions, but enjoy a much simpler and cleaner interface.

Organization of the Paper

After introducing the basic notation and tools in Section 2, we start by defining the main concept of the paper—the string synchronizing set—and proving some of its properties (Section 3). Next, we show how to sort suffixes in such a set (Section 4) and extend these ideas into an optimal LCE data structure (Section 5). We then describe how to build the BWT given a small string synchronizing set (Section 6) and prove the conditional optimality of our construction (Section 7). We conclude by showing efficient algorithms for the construction of string synchronizing set (Section 8).

2 Preliminaries

Let $T\in\Sigma^{*}$ be a string over alphabet $\Sigma=[0\mathinner{\ldotp\ldotp}\sigma-1]$. Unless explicitly stated otherwise, we assume $\smash{\sigma=n^{\mathcal{O}(1)}}$, where $n=|T|$. For $1\leq i\leq j\leq n$, we write $T[i\mathinner{\ldotp\ldotp}j]$ to denote the substring $T[i]T[i+1]\cdots T[j]$. Throughout, we use $[i\mathinner{\ldotp\ldotp}j)$ as a shorthand for $[i\mathinner{\ldotp\ldotp}j-1]$. The length of the longest common prefix of $X,Y\in\Sigma^{*}$ is denoted $\text{\rm lcp}(X,Y)$.

An integer $p\in[1\mathinner{\ldotp\ldotp}|X|]$ is a period of $X$ if $X[i]=X[i+p]$ for $i\in[1\mathinner{\ldotp\ldotp}|X|-p]$. The shortest period of $X$ is denoted as $\text{\rm per}(X)$.

Lemma 2.1** (Periodicity Lemma [14]).**

If a string $X$ has periods $p,q$ such that $p+q-\gcd(p,q)\leq|X|$, then $\gcd(p,q)$ is also its period.

2.1 Suffix Array and BWT

The suffix array [33] $\text{\rm SA}[1\mathinner{\ldotp\ldotp}n]$ of a text $T$ is a permutation defining the lexicographic order on suffixes: $T[\text{\rm SA}[i]\mathinner{\ldotp\ldotp}n]\allowbreak\prec T[\text{\rm SA}[j]\mathinner{\ldotp\ldotp}n]$ if $i<j$. It takes $\mathcal{O}(n)$ space and can be constructed in $\mathcal{O}(n)$ time [24].

Given positions $i,j$ in $T$, the Longest Common Extension query $\operatorname{LCE}(i,j)$ asks for $\text{\rm lcp}(T[i\mathinner{\ldotp\ldotp}n],T[j\mathinner{\ldotp\ldotp}n])$. The standard solution consists of the suffix array SA, the inverse permutation $\smash{\text{\rm SA}^{-1}}$ (defined so that $\text{\rm SA}[\text{\rm SA}^{-1}[i]]=i$), the LCP table $\text{\rm LCP}[2\mathinner{\ldotp\ldotp}n]$ (whose entries are $\text{\rm LCP}[i]=\operatorname{LCE}(\text{\rm SA}[{i-1}],\text{\rm SA}[i])$), and a data structure for range minimum queries built on top of the LCP table; see [24, 12, 6, 20].

Proposition 2.2**.**

LCE queries in a text $T\in[0\mathinner{\ldotp\ldotp}\sigma)^{n}$ with $\sigma=n^{\mathcal{O}(1)}$ can be answered in $\mathcal{O}(1)$ time after $\mathcal{O}(n)$-time preprocessing.

The Burrows–Wheeler transform (BWT) [8] of $T[1\mathinner{\ldotp\ldotp}n]$ is defined as $\text{\rm BWT}[i]=T[\text{\rm SA}[i]-1]$ if $\text{\rm SA}[i]>1$ and $\text{\rm BWT}[i]=T[n]$ otherwise. To ensure the correct handling of boundary cases, it is often assumed that $\text{\rm BWT}[\text{\rm SA}^{-1}[1]]$ contains a sentinel \\notin\Sigma$. In this paper, we avoid this to make sure that$\text{\rm BWT}[1\mathinner{\ldotp\ldotp}n]\in[0\mathinner{\ldotp\ldotp}\sigma)^{n}$. Our construction also returns$\text{\rm SA}^{-1}[1]$, though, so that the corresponding value can be set as needed.

2.2 Word RAM Model

Throughout the paper, we use the standard word RAM model of computation [18] with $w$-bit machine words, where $w\geq\log n$.

In the word RAM model, strings are typically represented as arrays, with each character occupying a single memory cell. Nevertheless, a single character can be represented using $\left\lceil\log\sigma\right\rceil$ bits, which might be much less than $w$. Consequently, one may store a text $T\in[0\mathinner{\ldotp\ldotp}\sigma)^{n}$ in \mathcal{O}\big{(}\big{\lceil}{\frac{n\log\sigma}{w}}\big{\rceil}\big{)} consecutive memory cells. In the packed representation of $T$, we assume that the first character corresponds to the $\left\lceil\log\sigma\right\rceil$ least significant bits of the first cell.

Proposition 2.3**.**

Suppose that $T\in[0\mathinner{\ldotp\ldotp}\sigma)^{n}$ is stored in the packed representation. The packed representation of any length-$\ell$ substring can be retrieved in \mathcal{O}\big{(}\big{\lceil}{\frac{\ell\log\sigma}{w}}\big{\rceil}\big{)} time. The longest common prefix of two length-$\ell$ fragments can be identified in the same time.

Proof.

The bit sequence corresponding to any fragment of length $\ell$ is contained in the concatenation of at most 1+\big{\lceil}{\frac{\ell\left\lceil\log\sigma\right\rceil}{w}}\big{\rceil} memory cells of the packed representation of $T$. Its location can be determined in $\mathcal{O}(1)$ time, and the resulting sequence can be aligned using $\mathcal{O}(\lceil{\frac{\ell\log\sigma}{w}}\rceil)$ bit-wise shift operations, as well as $\mathcal{O}(1)$ bit-wise and operations to mask out the adjacent characters. This results in a packed representation of the length-$\ell$ fragment of $T$. In order to compute the length of the longest common prefix of two such fragments, we xor the packed representations and find the position $p$ of the least significant bit in the resulting sequence. The resulting length is \big{\lfloor}{\frac{p-1}{\left\lceil\log\sigma\right\rceil}}\big{\rfloor} assuming $1$-based indexing of positions. ∎

A particularly important case is that of $\sigma=2$. In many applications, these bitvectors are equipped with a data structure answering rank queries: for $B[1\mathinner{\ldotp\ldotp}n]$, $\mathrm{rank}_{B}(i)=|\{j\in[1\mathinner{\ldotp\ldotp}i]:B[j]=1\}|$. Jacobson [22] proved that $\mathrm{rank}_{B}$ queries can be answered in $\mathcal{O}(1)$ time using an additional component of $o(n)$ extra bits. However, an efficient construction of such a component is much more recent.

Proposition 2.4** ([3, 37]).**

A packed bitvector $B[1\mathinner{\ldotp\ldotp}n]$ can be extended in \mathcal{O}\big{(}\frac{n}{\log n}\big{)} time with a data structure of size o\big{(}\frac{n}{\log n}\big{)} which answers $\mathrm{rank}_{B}$ queries in $\mathcal{O}(1)$ time.

2.3 Wavelet Trees

Wavelet trees, invented by Grossi, Gupta, and Vitter [15] for space-efficient text indexing, are important data structures with a vast number of applications far beyond text processing (see [38]).

The wavelet tree of a string $W\in[0\mathinner{\ldotp\ldotp}2^{b})^{n}$ is recursively defined as follows. First, we create the root node $v_{\varepsilon}$. This completes the construction for $b=0$. If $b>0$, we attach to $v_{\varepsilon}$ a bitvector $B_{\varepsilon}[1\mathinner{\ldotp\ldotp}n]$ in which $B_{\varepsilon}[i]$ is the most significant bit of $W[i]$ (interpreted as a $b$-bit number). Next, we partition $W$ into subsequences $W_{0}$ and $W_{1}$ by scanning $W$ and appending $W[i]$, with the most significant bit $d$ removed, to the subsequence $W_{d}$. Finally, we attach the recursively created wavelet trees of $W_{0}$ and $W_{1}$ (over alphabet $[0\mathinner{\ldotp\ldotp}2^{b-1})$) to $v_{\varepsilon}$. The result is a perfect binary tree with $2^{b}$ leaves.

Assuming that we label edges [math] (resp. $1$) if they go to the left (resp. right) child, we define the label of a node to be the concatenation of the labels on the root-to-node path. If $B_{X}$ denotes the bitvector of a node $v_{X}$ labeled $X\in\{0,1\}^{<b}$, then $B_{X}$ contains one bit (following $X$ as a prefix) from each $W[i]$ whose binary encoding has prefix $X$. Importantly, the bits in the bitvector $B_{X}$ occur in the same order as the corresponding elements $W[i]$ occur in $W$.

It is easy to see that the space occupied by the bitvectors is $\mathcal{O}(nb)$ bits, i.e., \mathcal{O}\big{(}\frac{nb}{\log n}\big{)} words. We need one extra machine word per node for pointers and due to word alignment, which sums up to $\mathcal{O}(2^{b})$. Thus, the total size of a wavelet tree is \mathcal{O}\big{(}2^{b}+\frac{nb}{\log n}\big{)} machine words, which is \mathcal{O}\big{(}\frac{nb}{\log n}\big{)} if $b\leq\log n$. As shown recently, a wavelet tree can be constructed efficiently from the packed representation of $W$.

Theorem 2.5** ([3, 37]).**

Given the packed representation of a string $W$ of length $n$ over $[0\mathinner{\ldotp\ldotp}2^{b})$ for $b\leq\log n$, we can construct its wavelet tree in $\mathcal{O}(nb/\sqrt{\log n})$ time using $\mathcal{O}(nb/\log n)$ space.

3 String Synchronizing Sets

In this section, we introduce string synchronizing sets, the central novel concept underlying both main results of this paper.

Definition 3.1**.**

Let $T$ be a string of length $n$ and let $\tau\leq\frac{1}{2}n$ be a positive integer. We say that a set $\mathsf{S}\subseteq[1\mathinner{\ldotp\ldotp}n-2\tau+1]$ is a $\tau$-synchronizing set of $T$ if it satisfies the following conditions:

if $T[i\mathinner{\ldotp\ldotp}i+2\tau)=T[j\mathinner{\ldotp\ldotp}j+2\tau)$, then $i\in\mathsf{S}$ holds if and only if $j\in\mathsf{S}$ (for $i,j\in[1\mathinner{\ldotp\ldotp}n-2\tau+1]$), and 2. 2.

$\mathsf{S}\cap[i\mathinner{\ldotp\ldotp}i+\tau)=\emptyset$* if and only if $i\in\mathsf{R}$ (for $i\in[1\mathinner{\ldotp\ldotp}n-3\tau+2]$), where*

[TABLE]

Intuitively, the above definition requires that the decision on whether $i\in\mathsf{S}$ depends entirely on $T[i\mathinner{\ldotp\ldotp}i+2\tau)$, i.e., it is made consistently across the whole text (the first consistency condition) and that $\mathsf{S}$ contains densely distributed positions within (and only within) non-periodic regions of $T$ (the second density condition).

The properties of a $\tau$-synchronizing set $\mathsf{S}$ allow for symmetry-breaking decisions that let us individually process only positions $i\in\mathsf{S}$, compared to the classic $\mathcal{O}(n)$-time algorithms handling all positions one by one. Thus, we are interested in minimizing the size of $\mathsf{S}$. Since $\mathsf{R}=\emptyset$ is possible in general, the smallest $\tau$-synchronizing set we can hope for is of size $\Omega(\frac{n}{\tau})$ in the worst case. Our deterministic construction in Section 8 matches this lower bound.

Note that the notion of a $\tau$-synchronizing set is valid for every positive integer $\tau\leq\frac{1}{2}n$. Some applications make use of many synchronizing sets with parameters $\tau$ spread across the whole domain; see [1, 27]. However, in this paper we only rely on $\tau$-synchronizing sets for $\tau=\varepsilon\log_{\sigma}n$ (where $\varepsilon$ is a sufficiently small positive constant), because this value turns out to be the suitable for processing the packed representation of a text $T\in[0\mathinner{\ldotp\ldotp}\sigma)^{n}$ stored in $\Theta(n/\log_{\sigma}n)$ machine words. This is because our generic construction algorithm (Proposition 8.10) runs in $\mathcal{O}(n)$ time, whereas a version optimized for packed strings (Theorem 8.11) takes $\mathcal{O}(\frac{n}{\tau})$ time only for $\tau\leq\varepsilon\log_{\sigma}n$ with $\varepsilon<\frac{1}{5}$. (Note that an $\mathcal{O}(\frac{n}{\tau})$-time construction is feasible for $\tau=\mathcal{O}(\log_{\sigma}n)$ only, because we need to spend $\Omega(n/\log_{\sigma}n)$ time already to read the whole packed text.) Moreover, the running time of our BWT construction procedure involves a term $\sigma^{\mathcal{O}(\tau)}$, which would dominate if we set $\tau$ too large.

We conclude this section with two properties of $\tau$-synchronizing sets useful across all our applications. To formulate them, we define the successor in $\mathsf{S}$ for each $i\in[1\mathinner{\ldotp\ldotp}n-2\tau+1]$:

[TABLE]

The sentinel $n-2\tau+2$ guarantees that the set on the right-hand side is non-empty. Our first result applies the density condition to relate $\mathrm{succ}_{\mathsf{S}}(i)$ for $i\in\mathsf{R}$ with maximal periodic regions of $T$.

Fact 3.2**.**

Let $T$ be a text and let $\mathsf{S}$ be its $\tau$-synchronizing set for a positive integer $\tau\leq\frac{1}{2}$. If $i\in\mathsf{R}$ and $p=\text{\rm per}(T[i\mathinner{\ldotp\ldotp}i+3\tau-2])$, then $T[i\mathinner{\ldotp\ldotp}\mathrm{succ}_{\mathsf{S}}(i)+2\tau-2]$ is the longest prefix of $T[i\mathinner{\ldotp\ldotp}n]$ with period $p$.

Proof.

Let us define $s=\mathrm{succ}_{\mathsf{S}}(i)$ and observe that $[i\mathinner{\ldotp\ldotp}s)\cap\mathsf{S}=\emptyset$. Consequently, $[j\mathinner{\ldotp\ldotp}j+\tau)\cap\mathsf{S}=\emptyset$ holds for every $j\in[i\mathinner{\ldotp\ldotp}s-\tau]$. By the density condition, this implies $[i\mathinner{\ldotp\ldotp}s-\tau]\subseteq\mathsf{R}$, i.e., that $\text{\rm per}(T[j\mathinner{\ldotp\ldotp}j+3\tau-2])\leq\tfrac{1}{3}\tau$ for $j\in[i\mathinner{\ldotp\ldotp}s-\tau]$. We shall prove by induction on $j$ that $p=\text{\rm per}(T[i\mathinner{\ldotp\ldotp}j+3\tau-2])$ holds for $j\in[i\mathinner{\ldotp\ldotp}s-\tau]$. Tha base case of $j=i$ follows from the definition of $p$. For $j>i$, on the other hand, let us denote $p^{\prime}=\text{\rm per}(T[j\mathinner{\ldotp\ldotp}j+3\tau-2])$ and assume $p=\text{\rm per}(T[i\mathinner{\ldotp\ldotp}j+3\tau-3])$ by the inductive hypothesis. We observe that $j+3\tau-2-p^{\prime}-p>j+2\tau-2\geq j$, so $T[j+3\tau-2]=T[j+3\tau-2-p^{\prime}]=T[j+3\tau-2-p^{\prime}-p]=T[j+3\tau-2-p]$. This shows that $p=\text{\rm per}(T[i\mathinner{\ldotp\ldotp}j+3\tau-2])$ and completes the inductive step. We conclude that $p$ is the shortest period of $T[i\mathinner{\ldotp\ldotp}s+2\tau-2]$. We now need to prove that this is the longest prefix of $T[i\mathinner{\ldotp\ldotp}n]$ with period $p$. The claim is trivially true if $s=n-2\tau+2$. Otherwise, $s\in\mathsf{S}$, so $[s-\tau+1\mathinner{\ldotp\ldotp}s]\cap\mathsf{S}\neq\emptyset$. By the density condition, this means that $s-\tau+1\notin\mathsf{R}$, i.e., $\text{\rm per}(T[s-\tau+1\mathinner{\ldotp\ldotp}s+2\tau-1])>\frac{1}{3}\tau$. As a result, $\text{\rm per}(T[i\mathinner{\ldotp\ldotp}s+2\tau-1])>\frac{1}{3}\tau\geq p$. This completes the proof. ∎

The second result applies the consistency condition to relate $\mathrm{succ}_{\mathsf{S}}(i)$ with $\mathrm{succ}_{\mathsf{S}}(j)$ for two common starting positions $i,j\in[1\mathinner{\ldotp\ldotp}n-2\tau+1]$ of a sufficiently long substring.

Fact 3.3**.**

Let $T$ be a text and let $\mathsf{S}$ be its $\tau$-synchronizing set for a positive integer $\tau\leq\frac{1}{2}$. If a substring $X$ of length $|X|\geq 2\tau$ occurs in $T$ at positions $i$ and $j$, then either

1. (i)

$\mathrm{succ}_{\mathsf{S}}(i)-i=\mathrm{succ}_{\mathsf{S}}(j)-j\leq|X|-2\tau$, or 2. (ii)

$\mathrm{succ}_{\mathsf{S}}(i)-i>|X|-2\tau$* and $\mathrm{succ}_{\mathsf{S}}(j)-j>|X|-2\tau$.*

Moreover, (i) holds if $|X|\geq 3\tau-1$ and $\text{\rm per}(X)>\frac{1}{3}\tau$.

Proof.

First, we shall prove that (i) holds if (ii) does not. Without loss of generality, we assume that $\mathrm{succ}_{\mathsf{S}}(i)-i\leq\mathrm{succ}_{\mathsf{S}}(j)-j$, which yields $\mathrm{succ}_{\mathsf{S}}(i)-i\leq|X|-2\tau$. In particular, $T[i\mathinner{\ldotp\ldotp}\mathrm{succ}_{\mathsf{S}}(i)+2\tau)=T[j\mathinner{\ldotp\ldotp}j-i+\mathrm{succ}_{\mathsf{S}}(i)+2\tau)$ is a prefix of $X$. Moreover, $\mathrm{succ}_{\mathsf{S}}(i)\leq n-2\tau+1$, so $\mathrm{succ}_{\mathsf{S}}(i)\in\mathsf{S}$. The consistency condition therefore implies $j-i+\mathrm{succ}_{\mathsf{S}}(i)\in\mathsf{S}$. Hence, $\mathrm{succ}_{\mathsf{S}}(j)\leq j-i+\mathrm{succ}_{\mathsf{S}}(i)$, and $\mathrm{succ}_{\mathsf{S}}(i)-i=\mathrm{succ}_{\mathsf{S}}(j)-j$ thus holds as claimed.

Next, we shall prove that $\mathrm{succ}_{\mathsf{S}}(i)-i\leq|X|-2\tau$ if $|X|\geq 3\tau-1$ and $\text{\rm per}(X)>\frac{1}{3}\tau$. From this, we shall conclude that (ii) does not hold (whereas (i) holds) in that case. If $i\notin\mathsf{R}$, then $[i\mathinner{\ldotp\ldotp}i+\tau)\cap\mathsf{S}\neq\emptyset$ by the density condition, so $\mathrm{succ}_{\mathsf{S}}(i)-i\leq\tau-1\leq|X|-2\tau$. Otherwise, let us define $p=\text{\rm per}(T[i\mathinner{\ldotp\ldotp}i+3\tau-2])$ and note that $T[i\mathinner{\ldotp\ldotp}\mathrm{succ}_{\mathsf{S}}(i)+2\tau-2]$ has period $p$ by Fact 3.2. Since $p\leq\frac{1}{3}n$, this means that $|X|>|T[i\mathinner{\ldotp\ldotp}\mathrm{succ}_{\mathsf{S}}(i)+2\tau-2]|$, which is equivalent to the desired inequality $\mathrm{succ}_{\mathsf{S}}(i)-i\leq|X|-2\tau$. ∎

4 Sorting Suffixes Starting in Synchronizing Sets

Let $T\in[0\mathinner{\ldotp\ldotp}\sigma)^{n}$ be a text stored in the packed representation and let $\mathsf{S}$ be its $\tau$-synchronizing set of size $\mathcal{O}(\frac{n}{\tau})$ for $\tau=\mathcal{O}(\log_{\sigma}n)$. In this section, we show that given the above as input, the suffixes of $T$ starting at positions in $\mathsf{S}$ can be sorted lexicographically in the optimal $\mathcal{O}(\frac{n}{\tau})$ time. We assume that the elements of $\mathsf{S}$ are stored in an array in the left-to-right order so that we can access the $i$th smallest element, denoted $s_{i}$, in constant time for $i\in[1\mathinner{\ldotp\ldotp}|\mathsf{S}|]$. The presented algorithm is the first step in our BWT construction. It also reveals the key ideas behind our LCE data structure.

4.1 The Nonperiodic Case

Consider first a case when $\mathsf{R}=\emptyset$. The density condition then simplifies to the following statement:

1. ${2}^{\prime}.$

$\mathsf{S}\cap[i\mathinner{\ldotp\ldotp}i+\tau)\neq\emptyset$ for every $i\in[1\mathinner{\ldotp\ldotp}n-3\tau+2]$.

We introduce a string $T^{\prime}$ of length $n^{\prime}:=|\mathsf{S}|$ defining it so that $T^{\prime}[i]=T[s_{i}\mathinner{\ldotp\ldotp}\min(n,s_{i}+3\tau-1)]$. All characters of $T^{\prime}$ are strings over $[0\mathinner{\ldotp\ldotp}\sigma)$ of length up to $3\tau$. Hence, they can be encoded using $\mathcal{O}(\tau\log\sigma)=\mathcal{O}(\log n)$-bit integers so that the lexicographic order is preserved.222For example, we may append $6\tau-2|T^{\prime}[i]|$ zeroes and $|T^{\prime}[i]|$ ones to $T^{\prime}[i]$. The result can then be interpreted as the base-$\sigma$ representation of an integer in $[0\mathinner{\ldotp\ldotp}\sigma^{6\tau})$. Furthermore, the lexicographic order of the suffixes of $T^{\prime}$ coincides with that of the corresponding suffixes of $T$.

Lemma 4.1**.**

Assume $\mathsf{R}=\emptyset$ holds for a text $T$. If positions $i,j$ of $T^{\prime}$ satisfy $T^{\prime}[i\mathinner{\ldotp\ldotp}n^{\prime}]\prec T^{\prime}[j\mathinner{\ldotp\ldotp}n^{\prime}]$, then $T[s_{i}\mathinner{\ldotp\ldotp}n]\prec T[s_{j}\mathinner{\ldotp\ldotp}n]$.

Proof.

We proceed by induction on $\text{\rm lcp}(T^{\prime}[i\mathinner{\ldotp\ldotp}n^{\prime}],T^{\prime}[j\mathinner{\ldotp\ldotp}n^{\prime}])$. The base case is that $T^{\prime}[i]\prec T^{\prime}[j]$. If $T^{\prime}[i]$ is a proper prefix of $T^{\prime}[j]$, then $T[s_{i}\mathinner{\ldotp\ldotp}n]=T^{\prime}[i]\prec T^{\prime}[j]\preceq T[s_{j}\mathinner{\ldotp\ldotp}n]$. Otherwise, $T^{\prime}[i]\cdot W\prec T^{\prime}[j]$ holds for any string $W$, so $T[s_{i}\mathinner{\ldotp\ldotp}n]\prec T^{\prime}[j]\preceq T[s_{j}\mathinner{\ldotp\ldotp}n]$.

Henceforth, we assume that $T^{\prime}[i]=T^{\prime}[j]$. Since $i\neq j$, this implies $|T^{\prime}[i]|=|T^{\prime}[j]|=3\tau$ and $s_{i},s_{j}\leq n-3\tau+1$. The density condition yields $s_{n^{\prime}}\geq n-3\tau+2$ (due to $n-3\tau+2\notin\mathsf{R}$), so we further have $i,j\in[1\mathinner{\ldotp\ldotp}n^{\prime})$ and $T^{\prime}[i+1\mathinner{\ldotp\ldotp}n^{\prime}]\prec T^{\prime}[j+1\mathinner{\ldotp\ldotp}n^{\prime}]$. Moreover, $X:=T[s_{i}+1\mathinner{\ldotp\ldotp}s_{i}+3\tau)=T[s_{j}+1\mathinner{\ldotp\ldotp}s_{j}+3\tau)$ occurs in $T$ at positions $s_{i}+1$ and $s_{j}+1$. As $\text{\rm per}(X)>\frac{1}{3}\tau$ (due to $s_{i}+1\notin\mathsf{R}$), Fact 3.3 implies

[TABLE]

i.e., $s_{i+1}-s_{i}=s_{j+1}-s_{j}\leq\tau$. Furthermore, $T[s_{i}\mathinner{\ldotp\ldotp}s_{i+1})=T[s_{j}\mathinner{\ldotp\ldotp}s_{j+1})$ because $T[s_{i}\mathinner{\ldotp\ldotp}{s_{i}+3\tau})=T^{\prime}[i]=T^{\prime}[j]=T[s_{j}\mathinner{\ldotp\ldotp}{s_{j}+3\tau})$. Due to $T[s_{i+1}\mathinner{\ldotp\ldotp}n]\prec T[s_{j+1}\mathinner{\ldotp\ldotp}n]$ (which we derive from the inductive hypothesis), this implies $T[s_{i}\mathinner{\ldotp\ldotp}n]\prec T[s_{j}\mathinner{\ldotp\ldotp}n]$ and completes the proof of the inductive step. ∎

By Lemma 4.1, the suffix array of $T^{\prime}$ can be used to retrieve the lexicographic order of the suffixes $T[s_{i}\mathinner{\ldotp\ldotp}n]$ for $s_{i}\in\mathsf{S}$. Recall that each symbol of $T^{\prime}$ takes $\mathcal{O}(\tau\log\sigma)=\mathcal{O}(\log n)$ bits, so the suffix array of $T^{\prime}$ can be computed in $\mathcal{O}(|T^{\prime}|)=\mathcal{O}(\frac{n}{\tau})$ time [24].

4.2 The General Case

We now show how to adapt the approach from the previous section so that it also works if $\mathsf{R}\neq\emptyset$. As before, we construct a string $T^{\prime}$ of length $n^{\prime}=|\mathsf{S}|$ over a polynomially bounded integer alphabet, and we sort its suffixes. However, the definition of $T^{\prime}$ becomes more involved. To streamline the formulae, we set $s_{n^{\prime}+1}=n-2\tau+2$. For each $i\in[1\mathinner{\ldotp\ldotp}n^{\prime}]$, we define $T^{\prime}[i]=(T[s_{i}\mathinner{\ldotp\ldotp}\min(n,s_{i}+3\tau-1)],d_{i})$, where $d_{i}$ is an integer specified as follows:

1. (a)

If $s_{i+1}-s_{i}\leq\tau$ (in particular, if $s_{i}>n-3\tau+1$), then $d_{i}=0$. 2. (b)

Otherwise, we set $p_{i}=\text{\rm per}(T[s_{i}+1\mathinner{\ldotp\ldotp}s_{i}+3\tau))$ and

[TABLE]

Note that each $T^{\prime}[i]$ can be encoded in $\mathcal{O}(\tau\log\sigma+\log n)=\mathcal{O}(\log n)$ bits so that the comparison of the resulting integers is equivalent to the lexicographic comparison of the corresponding symbols.

Lemma 4.2**.**

If positions $i,j$ of $T^{\prime}$ satisfy $T^{\prime}[i\mathinner{\ldotp\ldotp}n^{\prime}]\prec T^{\prime}[j\mathinner{\ldotp\ldotp}n^{\prime}]$, then $T[s_{i}\mathinner{\ldotp\ldotp}n]\prec T[s_{j}\mathinner{\ldotp\ldotp}n]$.

Proof.

Induction on $\text{\rm lcp}(T^{\prime}[i\mathinner{\ldotp\ldotp}n^{\prime}],T^{\prime}[j\mathinner{\ldotp\ldotp}n^{\prime}])$. If $\text{\rm lcp}(T[s_{i}\mathinner{\ldotp\ldotp}n],\allowbreak T[s_{j}\mathinner{\ldotp\ldotp}n])<3\tau$, then we proceed as in the proof of Lemma 4.1.

Otherwise, the string $X=T[s_{i}+1\mathinner{\ldotp\ldotp}s_{i}+3\tau)=T[s_{j}+1\mathinner{\ldotp\ldotp}s_{j}+3\tau)$ occurs in $T$ at positions $s_{i}+1$ and $s_{j}+1$. If $\min(s_{i+1}-s_{i},s_{j+1}-s_{j})\leq\tau$, then Fact 3.3 yields $s_{i+1}-s_{i}=s_{j+1}-s_{j}\leq\tau$, so $d_{i}=d_{j}=0$ and $T^{\prime}[i]=T^{\prime}[j]$. Moreover, $i,j\in[1\mathinner{\ldotp\ldotp}n^{\prime})$ due to $s_{i},s_{j}\leq n-3\tau+1$. Consequently, the claim follows from $T[s_{i}\mathinner{\ldotp\ldotp}s_{i+1})=T[s_{j}\mathinner{\ldotp\ldotp}s_{j+1})$ because the inductive hypothesis yields $T[s_{i+1}\mathinner{\ldotp\ldotp}n]\prec T[s_{j+1}\mathinner{\ldotp\ldotp}n]$.

On the other hand, $\min(s_{i+1}-s_{i},s_{j+1}-s_{j})>\tau$ yields $d_{i},d_{j}\neq 0$. Moreover, the density condition implies $s_{i}+1,s_{j}+1\in\mathsf{R}$ with $p_{i}=p_{j}=\text{\rm per}(X)\leq\frac{1}{3}\tau$. By Fact 3.2, the longest prefix of $T[s_{i}+1\mathinner{\ldotp\ldotp}n]$ with period $p_{i}$ is $P_{i}:=T[s_{i}+1\mathinner{\ldotp\ldotp}s_{i+1}+2\tau-2]$ and the longest prefix of $T[s_{j}+1\mathinner{\ldotp\ldotp}n]$ with period $p_{j}$ is $P_{j}:=T[s_{j}+1\mathinner{\ldotp\ldotp}s_{j+1}+2\tau-2]$. Both $P_{i}$ and $P_{j}$ start with $X$, so one of them is a prefix of the other. We consider three cases based on how their lengths, $|P_{i}|=n+2\tau-2-|d_{i}|$ and $|P_{j}|=n+2\tau-2-|d_{j}|$, compare to each other.

• •

If $|d_{i}|>|d_{j}|$, then $P_{i}$ is a proper prefix of $P_{j}$. If $i=n^{\prime}$, then $T[s_{i}\mathinner{\ldotp\ldotp}n]=P_{i}\prec P_{j}\preceq T[s_{j}\mathinner{\ldotp\ldotp}n]$. Otherwise, we note that $d_{i}<0$ due to $d_{i}<d_{j}$, so $T[s_{i}+1+|P_{i}|]\prec\allowbreak P_{i}[|P_{i}|-p_{i}+1]=P_{j}[|P_{i}|-p_{j}+1]=T[s_{j}+1+|P_{i}|]$, which yields the claim.

• •

If $|d_{i}|=|d_{j}|$, then $P_{i}=P_{j}$. If $i=n^{\prime}$, then $T[s_{i}\mathinner{\ldotp\ldotp}n]=P_{i}=P_{j}\prec T[s_{j}\mathinner{\ldotp\ldotp}n]$. Otherwise, we consider two subcases:

• –

If $d_{i}=-d_{j}$, then $d_{i}<0<d_{j}$, so $T[s_{i}+1+|P_{i}|]\prec P_{i}[|P_{i}|-p_{i}+1]=P_{j}[|P_{j}|-p_{j}+1]\prec T[s_{j}+1+|P_{j}|]$, which also yields the claim.

• –

Finally, if $d_{i}=d_{j}$, then $T^{\prime}[i]=T^{\prime}[j]$ and $i,j\in[1\mathinner{\ldotp\ldotp}n^{\prime})$, so the inductive hypothesis gives $T[s_{i+1}\mathinner{\ldotp\ldotp}n]\prec T[s_{j+1}\mathinner{\ldotp\ldotp}n]$. The claim follows due to $T[s_{i}\mathinner{\ldotp\ldotp}s_{i+1})=T[s_{j}\mathinner{\ldotp\ldotp}s_{j+1})$.

• •

If $|d_{i}|<|d_{j}|$, then $P_{j}$ is a proper prefix of $P_{i}$. Moreover, $d_{j}>0$ due to $d_{i}<d_{j}$, so $T[s_{i}+1+|P_{j}|]=P_{i}[|P_{j}|-p_{i}+1]=P_{j}[|P_{j}|-p_{j}+1]\prec T[s_{j}+1+|P_{j}|]$ and the claim holds.∎

We now prove that efficient construction of $T^{\prime}$ is indeed possible. The only difficulty is computing the values $p_{i}$ in case $s_{i+1}-s_{i}>\tau$. To achieve this in constant time, we observe that $p_{i}\leq\frac{1}{3}\tau$ holds by the density condition due to $s_{i}<n-3\tau+2$ and $s_{i}+1\notin\mathsf{R}$. Consequently, $p_{i}$ is also the shortest period of every prefix of $T[s_{i}+1\mathinner{\ldotp\ldotp}s_{i}+3\tau)$ of length $2p_{i}$ or more. By the synchronizing property of primitive strings [11, Lemma 1.11], this means that the leftmost occurrence of $T[s_{i}+1\mathinner{\ldotp\ldotp}s_{i}+\tau]$ in $T[s_{i}+2\mathinner{\ldotp\ldotp}s_{i}+2\tau]$ starts at position $p_{i}$. We can find it in $\mathcal{O}(1)$ time (after $\mathcal{O}(n^{\varepsilon})$-time preprocessing) using the packed string matching algorithm [5].

Theorem 4.3**.**

Given the packed representation of a text $T\in[0\mathinner{\ldotp\ldotp}\sigma)^{n}$ and its $\tau$-synchronizing set $\mathsf{S}$ of size $\mathcal{O}(\frac{n}{\tau})$ for $\tau=\mathcal{O}(\log_{\sigma}n$), we can compute in $\mathcal{O}(\frac{n}{\tau})$ time the lexicographic order of all suffixes of $T$ starting at positions in $\mathsf{S}$.

5 Data Structure for LCE Queries

In Section 4, for a text $T\in[0\mathinner{\ldotp\ldotp}\sigma)^{n}$ and its $\tau$-synchronizing set $\mathsf{S}$ with $\tau=\mathcal{O}(\log_{\sigma}n)$, we constructed a string $T^{\prime}$ such the lexicographic order of the suffixes of $T^{\prime}$ coincides with the order of suffixes of $T$ starting at positions in $\mathsf{S}$. In this section, we show how to reduce LCE queries in $T$ to LCE queries in $T^{\prime}$. Our approach results in a data structure with $\mathcal{O}(1)$-time LCE queries and $\mathcal{O}(\frac{n}{\tau})$-time construction provided that $|\mathsf{S}|=\mathcal{O}(\frac{n}{\tau})$. Recall that $n^{\prime}=|\mathsf{S}|=|T^{\prime}|$, $s_{i}$ is the $i$th smallest element of $\mathsf{S}$, and $s_{n^{\prime}+1}=n-2\tau+2$.

5.1 The Nonperiodic Case

Analogously to Section 4.1, we start with the case of $\mathsf{R}=\emptyset$, which makes the definition of $T^{\prime}$ simpler: $T^{\prime}[i]=T[s_{i}\mathinner{\ldotp\ldotp}\min(n,s_{i}+3\tau-1)]$.

Consider an LCE query in the text $T$. If $\operatorname{LCE}(i,j)<3\tau$, we can retrieve it in $\mathcal{O}(1)$ time from the packed representation of $T$. Otherwise, Fact 3.3 yields $\mathrm{succ}_{\mathsf{S}}(i)-i=\mathrm{succ}_{\mathsf{S}}(j)-j<\tau$. Hence, $\operatorname{LCE}(i,j)=s_{i^{\prime}}-i+\operatorname{LCE}(s_{i^{\prime}},s_{j^{\prime}})$, where $s_{i^{\prime}}=\mathrm{succ}_{\mathsf{S}}(i)$ and $s_{j^{\prime}}=\mathrm{succ}_{\mathsf{S}}(j)$. A similar reasoning can be repeated to determine $\operatorname{LCE}(s_{i^{\prime}},s_{j^{\prime}})$, which must be smaller than $3\tau$ or equal to $s_{i^{\prime}+1}-s_{i^{\prime}}+\operatorname{LCE}(s_{i^{\prime}+1},s_{j^{\prime}+1})$. The former condition can be verified by checking whether $T^{\prime}[i^{\prime}]=T^{\prime}[j^{\prime}]$. A formal recursive application of this argument results in the following characterization:

Fact 5.1**.**

Consider a string $T\in[0\mathinner{\ldotp\ldotp}\sigma)^{n}$ which satisfies $\mathsf{R}=\emptyset$. For positions $i,j$ in $T$ such that $\operatorname{LCE}(i,j)\geq 3\tau-1$, let us define $s_{i^{\prime}}=\mathrm{succ}_{\mathsf{S}}(i)$ as well as $s_{j^{\prime}}=\mathrm{succ}_{\mathsf{S}}(j)$. If $\ell=\operatorname{LCE}_{T^{\prime}}(i^{\prime},j^{\prime})$, then

[TABLE]

Proof.

The proof is by induction on $\ell$. Due to $i,j\notin\mathsf{R}$, Fact 3.3 yields $s_{i^{\prime}}-i=s_{j^{\prime}}-j<\tau$, and therefore $T[i\mathinner{\ldotp\ldotp}s_{i^{\prime}})=T[j\mathinner{\ldotp\ldotp}s_{j^{\prime}})$. Hence, $\operatorname{LCE}(i,j)=s_{i^{\prime}}-i+\operatorname{LCE}(s_{i^{\prime}},s_{j^{\prime}})$. If $\ell=0$, it just remains to prove that $\operatorname{LCE}(s_{i^{\prime}},s_{j^{\prime}})<3\tau$, which follows from $T^{\prime}[i^{\prime}]\neq T^{\prime}[j^{\prime}]$.

For $\ell>0$, we note that $T^{\prime}[i^{\prime}]=T^{\prime}[j^{\prime}]$, so $\operatorname{LCE}(s_{i^{\prime}},s_{j^{\prime}})\geq 3\tau$ and $\operatorname{LCE}(s_{i^{\prime}}+1,s_{j^{\prime}}+1)\geq 3\tau-1$. The inductive hypothesis now yields $\operatorname{LCE}(s_{i^{\prime}}+1,s_{j^{\prime}}+1)=s_{i^{\prime}+\ell}-s_{i^{\prime}}-1+\operatorname{LCE}(s_{i^{\prime}+\ell},s_{j^{\prime}+\ell})$ and $\operatorname{LCE}(s_{i^{\prime}+\ell},s_{j^{\prime}+\ell})<3\tau$. Since $\operatorname{LCE}(i,j)=s_{i^{\prime}}-i+\operatorname{LCE}(s_{i^{\prime}},s_{j^{\prime}})=s_{i^{\prime}}+1-i+\operatorname{LCE}(s_{i^{\prime}}+1,s_{j^{\prime}}+1)$, this completes the proof. ∎

Fact 5.1 leads to a data structure for LCE queries that consists of the packed representation of $T$ (Proposition 2.3), a $\tau$-synchronizing set $\mathsf{S}$ of size $\mathcal{O}(\frac{n}{\tau})$, a component for LCE queries in $T^{\prime}$ (Proposition 2.2; the alphabet size is $\sigma^{3\tau}=n^{\mathcal{O}(1)}$), and a bitvector $B[1\mathinner{\ldotp\ldotp}n]$, with $B[i]=1$ if and only if $i\in\mathsf{S}$, equipped with a component for $\mathcal{O}(1)$-time rank queries (Proposition 2.4).

To compute $\operatorname{LCE}(i,j)$, we first use the packed representation to retrieve the answer in $\mathcal{O}(1)$ time provided that $\operatorname{LCE}(i,j)\,{<}\,3\tau$. Otherwise, we obtain $i^{\prime}$ and $j^{\prime}$ such that $s_{i^{\prime}}=\mathrm{succ}_{\mathsf{S}}(i)$ and $s_{j^{\prime}}=\mathrm{succ}_{\mathsf{S}}(j)$ using $\mathrm{rank}_{B}$ queries, and we compute $\ell=\operatorname{LCE}_{T^{\prime}}(i^{\prime},j^{\prime})$. By Fact 5.1, $\operatorname{LCE}(i,j)=s_{i^{\prime}+\ell}-i+\operatorname{LCE}(s_{i^{\prime}+\ell},s_{j^{\prime}+\ell})$. Since $\operatorname{LCE}(s_{i^{\prime}+\ell},s_{j^{\prime}+\ell})<3\tau$, we finalize the algorithm using the packed representation again.

5.2 The General Case

In this section, we generalize the results of Section 5.1 so that the case of $\mathsf{R}\neq\emptyset$ is also handled. Our data structure consists of the same components; the only difference is that the string $T^{\prime}$ is now defined as in Section 4.2 rather than as in Section 4.1.

The query algorithm needs more changes but shares the original outline. If $\operatorname{LCE}(i,j)<3\tau$, then we determine the answer using Proposition 2.3. Otherwise, we apply the following lemma as a reduction to computing $\operatorname{LCE}(\mathrm{succ}_{\mathsf{S}}(i),\mathrm{succ}_{\mathsf{S}}(j))$.

Lemma 5.2**.**

For positions $i,j$ in $T$ such that $\operatorname{LCE}(i,j)\geq 3\tau-1$, let us define $s_{i^{\prime}}=\mathrm{succ}_{\mathsf{S}}(i)$ and $s_{j^{\prime}}=\mathrm{succ}_{\mathsf{S}}(j)$. Then

[TABLE]

Proof.

If $\min(s_{i^{\prime}}-i,s_{j^{\prime}}-j)<\tau$, then $\min({s_{i^{\prime}}-i},s_{j^{\prime}}-j)\leq\operatorname{LCE}(i,j)-2\tau$, so Fact 3.3 yields $s_{i^{\prime}}-i=s_{j^{\prime}}-j<\tau$. Moreover, $T[i\mathinner{\ldotp\ldotp}s_{i^{\prime}}+2\tau)=T[j\mathinner{\ldotp\ldotp}s_{j^{\prime}}+2\tau)$ and, in particular, $T[i\mathinner{\ldotp\ldotp}s_{i^{\prime}})=T[j\mathinner{\ldotp\ldotp}s_{j^{\prime}})$. Hence, $\operatorname{LCE}(i,j)=s_{i^{\prime}}-i+\operatorname{LCE}(s_{i^{\prime}},s_{j^{\prime}})$ holds as claimed.

We now assume that $\min(s_{i^{\prime}}-i,s_{j^{\prime}}-j)\geq\tau$. Then $i,j\in\mathsf{R}$, and $T[i\mathinner{\ldotp\ldotp}i+3\tau-2]=T[j\mathinner{\ldotp\ldotp}j+3\tau-2]$ have the same shortest period $p\leq\frac{1}{3}\tau$. By Fact 3.2, the longest prefix of $T[i\mathinner{\ldotp\ldotp}n]$ with period $p$ is $T[i\mathinner{\ldotp\ldotp}s_{i^{\prime}}+2\tau-2]$ and the longest prefix of $T[j\mathinner{\ldotp\ldotp}n]$ with period $p$ is $T[j\mathinner{\ldotp\ldotp}s_{j^{\prime}}+2\tau-2]$. In particular, one of these prefixes is a prefix of the other. If $s_{i^{\prime}}-i\neq s_{j^{\prime}}-j$, then the longest common prefix of $T[i\mathinner{\ldotp\ldotp}n]$ and $T[j\mathinner{\ldotp\ldotp}n]$ is the shorter of the two prefixes with period $p$. Hence, $\operatorname{LCE}(i,j)=\min(s_{i^{\prime}}-i,s_{j^{\prime}}-j)+2\tau-1$ holds as claimed. Otherwise, $T[i\mathinner{\ldotp\ldotp}s_{i^{\prime}}+2\tau-2]=T[j\mathinner{\ldotp\ldotp}s_{j^{\prime}}+2\tau-2]$ yields $T[i\mathinner{\ldotp\ldotp}s_{i^{\prime}})=T[j\mathinner{\ldotp\ldotp}s_{j^{\prime}})$ and thus also the claim. ∎

We are left with determining the values $\operatorname{LCE}(s_{i},s_{j})$ for $i,j\in[1\mathinner{\ldotp\ldotp}n^{\prime}+1]$, i.e., handling LCE queries for positions in $\mathsf{S}\cup\{n-2\tau+2\}$. The next result reduces this task to answering LCE queries in $T^{\prime}$.

Lemma 5.3**.**

If $\ell=LCE_{T^{\prime}}(i,j)$ for positions $i,j\in[1\mathinner{\ldotp\ldotp}{n^{\prime}+1}]$, then $\operatorname{LCE}(s_{i},s_{j})=s_{i+\ell}-s_{i}+\operatorname{LCE}(s_{i+\ell},s_{j+\ell})$. Moreover, $\operatorname{LCE}(s_{i},s_{j})<3\tau$ or $\operatorname{LCE}(s_{i},s_{j})=\min(s_{i+1}-s_{i},s_{j+1}-s_{j})+2\tau-1$ holds if $\ell=0$.

Proof.

We prove the first claim inductively. The base case of $\ell=0$ holds trivially, so let us consider $\ell>0$. We then have $i,j\in[1\mathinner{\ldotp\ldotp}n^{\prime}]$ and $T^{\prime}[i]=T^{\prime}[j]$. This equality yields $\operatorname{LCE}(s_{i},s_{j})\geq 3\tau$, so we may use Lemma 5.2 for $s_{i}+1$ and $s_{j}+1$ to obtain $\operatorname{LCE}(s_{i},s_{j})=s_{i+1}-s_{i}+\operatorname{LCE}(s_{i+1},s_{j+1})$ provided that $s_{i+1}-s_{i}=s_{j+1}-s_{j}$. The latter equality follows from Fact 3.3 if $d_{i}=d_{j}=0$ and from $d_{i}=d_{j}$ otherwise. We derive the final claim by applying the inductive hypothesis for $i+1$ and $j+1$; note that $\operatorname{LCE}_{T^{\prime}}(i+1,j+1)=\ell-1$.

Next, let us prove the second claim for $\ell=0$. It holds trivially if $\operatorname{LCE}(s_{i},s_{j})<3\tau$. Otherwise, $i,j\in[1\mathinner{\ldotp\ldotp}n^{\prime}]$, which implies $T^{\prime}[i]\neq T^{\prime}[j]$ and $d_{i}\neq d_{j}$. Since Fact 3.3 gives equivalence between $d_{i}=0$ and $d_{j}=0$, we conclude that $d_{i},d_{j}\neq 0$. If $s_{i+1}-s_{i}\neq s_{j+1}-s_{j}$, then we may use Lemma 5.2 to prove $\operatorname{LCE}(s_{i}+1,s_{j}+1)=\min(s_{i+1}-s_{i}-1,s_{j+1}-s_{j}-1)+2\tau-1$, which yields the claimed equality. Otherwise, we must have $d_{i}=-d_{j}$; assume $d_{i}<0<d_{j}$ without loss of generality. By Fact 3.2, $T[s_{i}\mathinner{\ldotp\ldotp}s_{i+1}+2\tau-2]=T[s_{j}\mathinner{\ldotp\ldotp}s_{j+1}+2\tau-2]$ has period $p=\text{\rm per}(T[s_{i}+1\mathinner{\ldotp\ldotp}s_{i}+3\tau))$. Furthermore, $i=n^{\prime}$ and hence $s_{i+1}+2\tau-2=n$, or $T[s_{i+1}+2\tau-1]\prec T[s_{i+1}+2\tau-1-p]=T[s_{j+1}+2\tau-1-p]\prec T[s_{j+1}+2\tau-1]$. In either case, we have $\operatorname{LCE}(s_{i},s_{j})=s_{i+1}-s_{i}+2\tau-1$, which concludes the proof. ∎

We are now ready to describe the complete query algorithm determining $\operatorname{LCE}(i,j)$ for two positions $i,j$ in $T$. We start by using Proposition 2.3 to compare the first $3\tau$ symbols of $T[i\mathinner{\ldotp\ldotp}n]$ and $T[j\mathinner{\ldotp\ldotp}n]$. If we detect a mismatch, the procedure is completed. Otherwise, we compute the indices $i^{\prime},j^{\prime}\in[1\mathinner{\ldotp\ldotp}n^{\prime}+1]$ of $s_{i^{\prime}}=\mathrm{succ}_{\mathsf{S}}(i)$ and $s_{j^{\prime}}=\mathrm{succ}_{\mathsf{S}}(j)$ using rank queries on the bitvector $B$. If $s_{i^{\prime}}-i\neq s_{j^{\prime}}-j$, then we answer the query $\operatorname{LCE}(i,j)=\min(s_{i^{\prime}}-i,s_{j^{\prime}}-j)+2\tau-1$ according to Lemma 5.2. Otherwise, Lemma 5.2 yields $\operatorname{LCE}(i,j)=s_{i^{\prime}}-i+\operatorname{LCE}(s_{i^{\prime}},s_{j^{\prime}})$, and it remains to compute $\operatorname{LCE}(s_{i^{\prime}},s_{j^{\prime}})$. For this, we query for $\ell=\operatorname{LCE}_{T^{\prime}}(i^{\prime},j^{\prime})$ and note that $\operatorname{LCE}(s_{i^{\prime}},s_{j^{\prime}})=s_{i^{\prime}+\ell}-s_{i^{\prime}}+\operatorname{LCE}(s_{i^{\prime}+\ell},s_{j^{\prime}+\ell})$ by Lemma 5.3. Finally, we are left with determining the latter LCE value. We start by comparing the first $3\tau$ symbols of $T[s_{i^{\prime}+\ell}\mathinner{\ldotp\ldotp}n]$ and $T[s_{j^{\prime}+\ell}\mathinner{\ldotp\ldotp}n]$. If we detect a mismatch, the procedure is finished. Otherwise, we compute $\operatorname{LCE}(s_{i^{\prime}+\ell},s_{j^{\prime}+\ell})=\min(s_{i^{\prime}+\ell+1}-s_{i^{\prime}+\ell},s_{j^{\prime}+\ell+1}-s_{j^{\prime}+\ell})+2\tau-1$ according to Lemma 5.3. This completes the algorithm.

Before we conclude, note that given a synchronizing set of size $\mathcal{O}(\frac{n}{\tau})$ for $\tau=\mathcal{O}(\log_{\sigma}n)$, the data structure can be constructed in $\mathcal{O}(\frac{n}{\tau})$ time. This follows from Theorem 4.3 (building $T^{\prime}$), Proposition 2.2 (LCE queries in $T^{\prime}$), and Proposition 2.4 ($\mathrm{rank}_{B}$ queries). If $\tau\leq\varepsilon\log_{\sigma}n$ for a positive constant $\varepsilon<\frac{1}{5}$, then Theorem 8.11 also lets us compute an appropriate $\tau$-synchronizing set in $\mathcal{O}(\frac{n}{\tau})$ time. The overall construction time, $\mathcal{O}(\frac{n}{\tau})$, is minimized by $\tau=\Theta(\log_{\sigma}n)$.

Theorem 5.4**.**

LCE queries in a text $T\in[0\mathinner{\ldotp\ldotp}\sigma)^{n}$ with $\sigma=n^{\mathcal{O}(1)}$ can be answered in $\mathcal{O}(1)$ time after $\mathcal{O}(n/\log_{\sigma}n)$-time preprocessing of the packed representation of $T$.

6 BWT Construction

Let $T\in[0\mathinner{\ldotp\ldotp}\sigma)^{n}$, for $\log\sigma\leq\sqrt{\log n}$, be a text given in the packed representation, and let $\mathsf{S}$ be a $\tau$-synchronizing set of $T$ of size $\mathcal{O}(\frac{n}{\tau})$, where $\tau=\varepsilon\log_{\sigma}n$ for some sufficiently small constant $\varepsilon>0$. We assume that $\tau$ is a positive integer and that $3\tau-1\leq n$.

In this section, we show how to construct the BWT of $T$ in $\mathcal{O}(n\log\sigma/\sqrt{\log n})$ time and $\mathcal{O}(n/\log_{\sigma}n)$ space. For simplicity, we first restrict ourselves to a binary alphabet. The time and space complexities then simplify to $\mathcal{O}(n/\sqrt{\log n})$ and $\mathcal{O}(n/\log n)$.

6.1 Binary Alphabet

Similarly as in previous sections, we first assume $\mathsf{R}=\emptyset$ (note that this implies $\mathsf{S}\neq\emptyset$ due to $3\tau-1\leq n$). In Section 6.1.2, we consider the general case and describe the remaining parts of our construction.

6.1.1 The Nonperiodic Case

To compensate for the lack of a sentinel T[n]=\$$ (see [Section 2](#S2)), let us choose b_{$}\in{0,1}$such that$\text{\rm per}(X)>\frac{1}{3}\tau$holds for$X=b_{$}T[1\mathinner{\ldotp\ldotp}2\tau). Using packed string matching [[5](#bib.bib5)], we add to \mathsf{S}$all positions where$X$occurs in$T$. This increases$|\mathsf{S}|$by$\mathcal{O}(\frac{n}{\tau})and does not violate [Definition 3.1](#S3.Thmtheorem1). Denote by(s_{i}^{\prime}){i\in[1\mathinner{\ldotp\ldotp}|\mathsf{S}|]}$the set$\mathsf{S}, sorted using [Theorem 4.3](#S4.Thmtheorem3) according to the order of the corresponding suffixes, i.e., T[s{i}^{\prime}\mathinner{\ldotp\ldotp}n]\prec T[s_{j}^{\prime}\mathinner{\ldotp\ldotp}n]$if$i<j$. Define a sequence$W$of length$|\mathsf{S}|$so that$W[i]\in[0\mathinner{\ldotp\ldotp}2^{3\tau})$is an integer whose base-2 representation is$\overline{T[s_{i}^{\prime}-\tau\mathinner{\ldotp\ldotp}s_{i}^{\prime}+2\tau)}$, where$\overline{X}$denotes the string-reversal operation.333Whenever$T[k]$is out of bounds, we let$T[k]=b_{$}$if$k=0$and$T[k]=0$otherwise. In the word RAM model with word size$w=\Omega(\log n)$, reversing any$\mathcal{O}(\log n)$-bit string takes$\mathcal{O}(1)$time after$\mathcal{O}(n^{\delta})$-time ($\delta<1)$preprocessing. Thus,$W[1\mathinner{\ldotp\ldotp}|\mathsf{S}|]$can be constructed in$\mathcal{O}(|\mathsf{S}|+n^{\delta})=\mathcal{O}(n/\log n)$ time.

Recall that the density condition simplifies to $\mathsf{S}\cap{[i\mathinner{\ldotp\ldotp}i+\tau)}\neq\emptyset$ for $i\in[1\mathinner{\ldotp\ldotp}n-3\tau+2]$ if $\mathsf{R}=\emptyset$. Thus, except for $\mathcal{O}(\tau)$ rightmost symbols, every symbol of $T$ is included in at least one character of $W$. In principle, it suffices to rearrange these bits to obtain the BWT. For this, we utilize as a black box the wavelet tree of $W$ and prove that its construction performs the necessary permuting. We are then left with a task of copying the bits from the wavelet tree.

More precisely, we show how to extract (almost) all bits of the BWT of $T$ from the bitvectors $B_{X}$ in the wavelet tree of $W$ in $2^{\Theta(\tau)}+\mathcal{O}(n/\log n)$ time. Intuitively, we partition the BWT into $2^{\Theta(\tau)}$ blocks that appear as bitvectors $B_{X}$.

A similar string $W$ was constructed in [10] for an evenly distributed set of positions. In that case, however, the bitvectors in the wavelet tree form non-contiguous subsequences of the BWT.

Distinguishing Prefixes

To devise the announced partitioning of the BWT, for $j\in[1\mathinner{\ldotp\ldotp}\max\mathsf{S}]$ let $D_{j}=T[j\mathinner{\ldotp\ldotp}\mathrm{succ}_{\mathsf{S}}(j)+2\tau)$ be the distinguishing prefix of $T[j\mathinner{\ldotp\ldotp}n]$. By the density condition for $\mathsf{R}=\emptyset$, $\mathrm{succ}_{\mathsf{S}}(j)-j<\tau$ and thus $|D_{j}|\leq 3\tau-1$. Let $\mathcal{D}=\{D_{j}:j\leq\max\mathsf{S}\}$.

Recall that $B_{X}$ is the bitvector associated with the node $v_{X}$ whose root-to-node label in the wavelet tree of $W$ is $X$. By definition of the wavelet tree (applied to $W$), for any $X\in\{0,1\}^{\leq 3\tau-1}$, $B_{\overline{X}}$ contains the bit preceding $X$ from each string $T[s_{i}^{\prime}-\tau\mathinner{\ldotp\ldotp}s_{i}^{\prime}+2\tau)$ that has $X$ as a suffix. (The order of these bits matches the sequence $(s^{\prime}_{i})_{i\in[1\mathinner{\ldotp\ldotp}|\mathsf{S}|]}$.)

Lemma 6.1**.**

1. (1)

If $T[j\mathinner{\ldotp\ldotp}j+|X|)=X$ for $X\in\mathcal{D}$, then $D_{j}=X$. 2. (2)

If $\text{\rm SA}[b\mathinner{\ldotp\ldotp}e]$ includes all suffixes of $T$ having $X\in\mathcal{D}$ as a prefix, then $\text{\rm BWT}[b\mathinner{\ldotp\ldotp}e]=B_{\overline{X}}$.

Proof.

(1) Let $X=D_{i}$, i.e., $X=T[i\mathinner{\ldotp\ldotp}\mathrm{succ}_{\mathsf{S}}(i)+2\tau)$. Since $X$ also occurs at position $j$ and $\mathrm{succ}_{\mathsf{S}}(i)-i\leq|X|-2\tau$, we have $\mathrm{succ}_{\mathsf{S}}(j)-j=\mathrm{succ}_{\mathsf{S}}(i)-i$ by Fact 3.3. Consequently, $D_{j}=T[j\mathinner{\ldotp\ldotp}\mathrm{succ}_{\mathsf{S}}(j)+2\tau)=X$.

(2) By the above discussion, $B_{\overline{X}}$ contains the bits preceding $X$ as suffixes in $\smash{(T[s_{i}^{\prime}-\tau\mathinner{\ldotp\ldotp}s_{i}^{\prime}+2\tau))_{i\in[1\mathinner{\ldotp\ldotp}|\mathsf{S}|]}}$. From (1), there is a bijection between the occurrences of $X$ in $T$ and such suffixes (importantly, b_{\}T[1\mathinner{\ldotp\ldotp}s_{i}^{\prime}+2\tau)$for$s_{i}^{\prime}\in\mathsf{S}$is not a suffix of$X$due to the modification of$\mathsf{S}$, so$X$is never compared against out-of-bounds symbols of$T$in$W$). By definition of$\text{\rm BWT}[b\mathinner{\ldotp\ldotp}e]$and$|X|\leq 3\tau-1$,$B_{\overline{X}}$and$\text{\rm BWT}[b\mathinner{\ldotp\ldotp}e]$ indeed contain the same (multisets of) bits.

To show that the bits of $\text{\rm BWT}[b\mathinner{\ldotp\ldotp}e]$ occur in $B_{\overline{X}}$ in the same order, observe that $T[s_{i}^{\prime}+2\tau-|X|\mathinner{\ldotp\ldotp}n]\prec T[s_{j}^{\prime}+2\tau-|X|\mathinner{\ldotp\ldotp}n]$ holds if $T[s_{i}^{\prime}-\tau\mathinner{\ldotp\ldotp}s_{i}^{\prime}+2\tau)$ and $T[s_{j}^{\prime}-\tau\mathinner{\ldotp\ldotp}s_{j}^{\prime}+2\tau)$ have $X$ as a suffix for $i<j$. This is because $T[s_{i}^{\prime}+2\tau-|X|\mathinner{\ldotp\ldotp}s_{i}^{\prime})=T[s_{j}^{\prime}+2\tau-|X|\mathinner{\ldotp\ldotp}s_{j}^{\prime})$ is a prefix of $X$, and we have $T[s_{i}^{\prime}\mathinner{\ldotp\ldotp}n]\prec T[s_{j}^{\prime}\mathinner{\ldotp\ldotp}n]$ by $i<j$. ∎

The Algorithm

We start by building the string $W$ and its wavelet tree. By Theorem 2.5, this takes $\mathcal{O}((n/\tau)\allowbreak\log(2^{3\tau})/\sqrt{\log(n/\tau)})=\mathcal{O}(n/\sqrt{\log n})$ time and $\mathcal{O}(n/\log n)$ space.

Next, we create a lookup table that, for any $X\in\{0,1\}^{2\tau}$, tells whether $X$ occurs at a position $j\in\mathsf{S}$ (by the consistency condition, $j\in\mathsf{S}$ for every position $j$ where $X$ occurs in $T$). It needs $\mathcal{O}(n^{2\varepsilon})$ space and is easily filled: set “yes” for each $T[j\mathinner{\ldotp\ldotp}j+2\tau)$ with $j\in\mathsf{S}$.

Initialize the output to an empty string. Consider the preorder traversal of a complete binary tree of depth $3\tau-1$ with each edge to a left child labeled “0” and to a right child—“1”. Whenever we visit a node with root-to-node path $X$ such that $|X|\geq 2\tau$, we check if the length-$2\tau$ suffix of $X$ is a “yes” substring. If so, we report $X$ and skip the traversal of the current subtree. Otherwise, we descend into the subtree. This procedure enumerates $\mathcal{D}$ in the lexicographic order in $\mathcal{O}(2^{3\tau})=\mathcal{O}(n^{3\varepsilon})$ time. For each reported substring $X$, we append $B_{\overline{X}}$ to the output string. Locating $v_{\overline{X}}$ takes $\mathcal{O}(|X|)=\mathcal{O}(\log n)$ time; hence, we spend $\mathcal{O}(n/\log n+n^{3\varepsilon}\log n)=\mathcal{O}(n/\log n)$ time in total.

The above traversal outputs a BWT subsequence containing the symbols preceding positions in $[1\mathinner{\ldotp\ldotp}\max\mathsf{S}]$. To include the missing symbols, we make the following adjustment: while visiting a node with label $X\notin\mathcal{D}$, we check if $X$ occurs as a suffix of $T$. If so, then before descending into the subtree, we append the preceding character $T[n-|X|]$ to the output string.

The algorithm runs in $\mathcal{O}(n/\sqrt{\log n})$ time and uses $\mathcal{O}(n/\log n)$ space. For correctness, observe that the set $\mathcal{D}$ is prefix-free by Lemma 6.1. Thus, no symbol is output twice.

To complete the construction, we need $\text{\rm SA}^{-1}[1]$ (see Section 2.1). Let $D_{1}$ be the distinguishing prefix of $T[1\mathinner{\ldotp\ldotp}n]$ and let $i_{1}$ be the index of $\min\mathsf{S}$ in $(s_{i}^{\prime})_{i\in[1\mathinner{\ldotp\ldotp}|\mathsf{S}|]}$. Observe that the symbol T[0]=b_{\}$occurs in$B_{\overline{D_{1}}}$at position$|{i\leq i_{1}:\overline{D_{1}}\text{ is a prefix of }W[i]}|$, which can be determined in$\mathcal{O}(|\mathsf{S}|)$time. Appending$B_{\overline{D_{1}}}$to the constructed BWT, we map this position in$B_{\overline{D_{1}}}$to the corresponding one in the BWT. Finally, we overwrite$b_{$}$by setting$\text{\rm BWT}[\text{\rm SA}^{-1}[1]]=T[n]$.

6.1.2 The General Case

Let use define

[TABLE]

Observe that if $T[j\mathinner{\ldotp\ldotp}j+3\tau-1)\in\mathcal{F}$, then $j\in\mathsf{R}$. Conversely, whenever $j\in\mathsf{R}$, then $T[j\mathinner{\ldotp\ldotp}j+3\tau-1)\in\mathcal{F}$. Thus, $\mathsf{R}$ contains precisely the starting positions of all strings in $\mathcal{F}$. Hence, in the general case with $\mathsf{R}$ possibly non-empty, the algorithm of Section 6.1.1 outputs the BWT subsequence missing exactly the symbols $T[j-1]$ for $j\in\mathsf{R}$.

The crucial property of $\mathsf{R}$ that allows handling the general case is that $\mathsf{R}$ cannot have many “gaps”. Moreover, whenever $X\in\mathcal{F}$ occurs at a position $j\in\mathsf{R}$ with $j-1\in\mathsf{R}$, then $T[j-1]$ depends on $X$.

Lemma 6.2**.**

Let $\mathsf{R}^{\prime}=\{j\in\mathsf{R}:j-1\notin\mathsf{R}\}$ be a subset of $\mathsf{R}$. Then:

1. (1)

$|\mathsf{R}^{\prime}|\leq|\mathsf{S}|+1$. 2. (2)

If $X\,{=}\,T[j\mathinner{\ldotp\ldotp}j+|X|)\,{\in}\,\mathcal{F}$ and $j\,{\notin}\,\mathsf{R}^{\prime}$, then $T[j-1]\,{=}\,X[\text{\rm per}(X)]$.

Proof.

(1) By density condition, $j\in\mathsf{R}^{\prime}$ implies $j-1\in\mathsf{S}$ if $j>1$.

(2) Note that $\text{\rm per}(X)=\text{\rm per}(T[j-1\mathinner{\ldotp\ldotp}\mathrm{succ}_{\mathsf{S}}(j-1)+2\tau-2])\leq\frac{1}{3}\tau$ due to Fact 3.2 and because $\mathrm{succ}_{\mathsf{S}}(j-1)=\mathrm{succ}_{\mathsf{S}}(j)\geq j+\tau$. Hence, $T[j-1]=T[j-1+\text{\rm per}(X)]=X[\text{\rm per}(X)]$. ∎

Consider thus the following modification: whenever we reach $X\in\mathcal{F}$ during the enumeration of $\mathcal{D}$, we append to the output a unary string of $f_{X}$ symbols $X[\text{\rm per}(X)]$, where $f_{X}$ is the number of occurrences of $X$ in $T$. By Lemma 6.2, the number of mistakes in the resulting BWT, over all $X\in\mathcal{F}$, is only $|\mathsf{R}^{\prime}|=\mathcal{O}(\frac{n}{\tau})$.

To implement the above modification (excluding BWT correction), we need to compute $\text{\rm per}(X)$ and $f_{X}$ for every $X\in\{0,1\}^{3\tau-1}$. The period is determined using a lookup table.

Computing Frequencies of Length-$\ell$ Substrings

Consider $\lfloor|T|/\ell\rfloor$ blocks of length $2\ell-1$ starting in $T$ at positions of the form $1+k\ell$ (the last block might be shorter). Sort all blocks in $\mathcal{O}(\frac{n}{\ell})$ time into a list $L$. Then, scan the list and for each distinct block $B$ in $L$, consider the multiset of all its length-$\ell$ substrings $X$. For each such $X$, increase its frequency by the frequency of $B$ in $L$. The correctness follows by noting that $T[i\mathinner{\ldotp\ldotp}i+\ell)$ is contained in the $\left\lceil i/\ell\right\rceil$th block only.

There are at most $1+2^{2\ell-1}$ distinct blocks and we spend $\mathcal{O}(\ell)$ time for each. The total running time is therefore $\mathcal{O}(\frac{n}{\ell}+\ell 2^{2\ell-1})$.

In our application, $\ell=3\tau-1<3\varepsilon\log n$, so it suffices to choose $\varepsilon<\frac{1}{6}$ so that $\mathcal{O}(\frac{n}{\ell}+\ell 2^{2\ell-1})=\mathcal{O}(n/\log n+n^{6\varepsilon}\log n)=\mathcal{O}(n/\log n)$.

Correcting BWT

We will now show how to compute the rank (i.e., the position in the suffix array) of every suffix of $T$ starting in $\mathsf{R}^{\prime}$. This will let us correct the mistakes in the BWT produced within the previous step. If $r_{j}$ is the rank of $T[j\mathinner{\ldotp\ldotp}n]$, where $j\in\mathsf{R}^{\prime}$, we set $\text{\rm BWT}[r_{j}]=T[j-1]$. To compute $r_{j}$, we only need to know $r_{j}^{\prime}$: the local rank of $T[j\mathinner{\ldotp\ldotp}n]$ among the suffixes of $T$ starting with $T[j\mathinner{\ldotp\ldotp}j+3\tau-1)$ (note that any such suffix starts at $j^{\prime}\in\mathsf{R}$) since the rank among other suffixes is known during the enumeration of $\mathcal{D}$. Formally, for $j\in\mathsf{R}^{\prime}$, define $\text{\rm pos}(j)=\{j^{\prime}\in\mathsf{R}:\operatorname{LCE}_{T}(j,j^{\prime})\geq 3\tau-1\text{ and }T[j^{\prime}\mathinner{\ldotp\ldotp}n]\preceq T[j\mathinner{\ldotp\ldotp}n]\}$ so that $r_{j}^{\prime}=|\text{\rm pos}(j)|$.

Motivated by Lemma 6.2, we focus on the properties of runs of consecutive positions in $\mathsf{R}$. We start by partitioning such runs into classes, where the computation of local ranks is easier and can be done independently. For $X\in\mathcal{F}$, we define the Lyndon root $\text{\rm L-root}(X)=\min\{X[t\mathinner{\ldotp\ldotp}t+p):t\in[1\mathinner{\ldotp\ldotp}p]\}\in\{0,1\}^{\leq\tau/3}$, where $p=\text{\rm per}(X)$. We further set $\text{\rm L-root}(j)=\text{\rm L-root}(T[j\mathinner{\ldotp\ldotp}j+3\tau-1))$ for every $j\in\mathsf{R}$. It is easy to see that if $j\in\mathsf{R}\setminus\mathsf{R}^{\prime}$, then $\text{\rm L-root}(j-1)=\text{\rm L-root}(j)$. Thus, to compute $r_{j}^{\prime}$ for some $j\in\mathsf{R}^{\prime}$, it suffices to look at the runs starting at $j^{\prime}\in\mathsf{R}^{\prime}$ such that $\text{\rm L-root}(j)=\text{\rm L-root}(j^{\prime})$.

Further, for $j\in\mathsf{R}$, let us define $e_{j}=\min\{j^{\prime}\geq j:j^{\prime}\not\in\mathsf{R}\}+3\tau-2$. We define $\text{\rm type}(j)=+1$ if $T[e_{j}]\succ T[e_{j}-p]$ and $\text{\rm type}(j)=-1$ otherwise, where $p=\text{\rm per}(T[j\mathinner{\ldotp\ldotp}e_{j}))$. Similarly as for the L-root, if $j\in\mathsf{R}\setminus\mathsf{R}^{\prime}$, then $\text{\rm type}(j-1)=\text{\rm type}(j)$. Furthermore, if $\text{\rm type}(j)=-1$ holds for $j\in\mathsf{R}^{\prime}$, then $\text{\rm type}(j^{\prime})=-1$ holds for all $j^{\prime}\in\text{\rm pos}(j)$. Let $\mathsf{R}^{-}=\{j\in\mathsf{R}:\text{\rm type}(j)=-1\}$, $\mathsf{R}^{+}=\mathsf{R}\setminus\mathsf{R}^{-}$, $\mathsf{R}^{\prime-}=\mathsf{R}^{\prime}\cap\mathsf{R}^{-}$, and $\mathsf{R}^{\prime+}=\mathsf{R}^{\prime}\cap\mathsf{R}^{+}$. In the rest of this section, we focus on computing $r_{j}^{\prime}$ for $j\in\mathsf{R}^{\prime-}$. The set $\mathsf{R}^{\prime+}$ is processed symmetrically.

To efficiently determine local ranks for a group of runs with the same L-root, we refine the classification further into individual elements of $\mathsf{R}$. Let $U=\text{\rm L-root}(j)$ for $j\in\mathsf{R}$. It is easy to see that the following L-decomposition $T[j\mathinner{\ldotp\ldotp}e_{j})=U^{\prime}U^{k}U^{\prime\prime}$ (where $k\geq 1$, $U^{\prime}$ is a proper suffix of $U$, and $U^{\prime\prime}$ is a proper prefix of $U$) is unique. We call the triple $(|U^{\prime}|,k,|U^{\prime\prime}|)$ the L-signature of $j$ and the value $\text{\rm L-exp}(j)=k$ its L-exponent. By the uniqueness of L-decompositions, given $j\in\mathsf{R}^{\prime-}$, we have $\text{\rm L-exp}(j^{\prime})\leq\text{\rm L-exp}(j)$ for all $j^{\prime}\in\text{\rm pos}(j)$.

Note that, letting $\mathsf{S}=(s_{i})_{i\in[1\mathinner{\ldotp\ldotp}|\mathsf{S}|]}$ where $s_{i}<s_{i^{\prime}}$ if $i<i^{\prime}$ and $s_{0}=0$, $s_{|\mathsf{S}|+1}=n-2\tau+2$, we have, by the density condition: $\mathsf{R}^{\prime}=\{s_{i}+1:i\in[0\mathinner{\ldotp\ldotp}|\mathsf{S}|]\text{ and }s_{i+1}\,{-}\,s_{i}\,{>}\,\tau\}$. Furthermore, whenever $j-1=s_{i}$ for $j\in\mathsf{R}^{\prime}$, then $e_{j}=s_{i+1}+2\tau-1$. Thus, computing $\mathsf{R}^{\prime}$ and $\{e_{j}\}_{j\in\mathsf{R}^{\prime}}$ (and also the type of each $j\in\mathsf{R}^{\prime}$) takes $\mathcal{O}(|\mathsf{S}|)$ time.

For $j\in\mathsf{R}^{\prime-}$, let

[TABLE]

To compute $r_{j}^{=}$ for each $j\in\mathsf{R}^{\prime-}$, consider sorting the list of all $j\in\mathsf{R}^{\prime-}$ first according to $\text{\rm L-root}(j)$, second according to $|U^{\prime\prime}|$ in its L-signature, and third according to $T[e_{j}\mathinner{\ldotp\ldotp}n]$. Such ordering can be obtained in $\mathcal{O}(|\mathsf{R}^{\prime-}|)$ time by utilizing the sequence $(s_{i}^{\prime})_{i\in[1\mathinner{\ldotp\ldotp}|\mathsf{S}|]}$ and the fact that $e_{j}-2\tau+1\in\mathsf{S}$. The L-root and $|U^{\prime\prime}|$ are computed using lookup tables. Then, to determine $r_{j}^{=}$, we count $j^{\prime}\in\mathsf{R}^{\prime-}$ with the same L-root that are not later than $j$ in the list and the factor $U^{\prime}U^{k}$ in their L-decomposition is at least as long as for $j$. To this end, we issue a 3-sided orthogonal 2D range counting query on an input instance containing, for every $j\in\mathsf{R}^{\prime-}$, a point with $|U^{\prime}U^{k}|$ from its L-decomposition as the first coordinate and its position in the above list as the second coordinate. Answering a batch of $m$ orthogonal 2D range counting queries takes $\mathcal{O}(m\sqrt{\log m})$ time and $\mathcal{O}(m)$ space [9]. Since $m=|\mathsf{R}^{\prime-}|$, this step takes $\mathcal{O}(n/\sqrt{\log n})$ time.

To compute $r_{j}^{<}$ for each $j\in\mathsf{R}^{\prime-}$, we sort $j\in\mathsf{R}^{\prime-}$ first by $\text{\rm L-root}(j)$, and then by $\text{\rm L-exp}(j)$. For a fixed $\smash{U\in\{0,1\}^{\leq\tau/3}}$, let us define

[TABLE]

Let also $\mathsf{R}^{\prime-}_{U}=\mathsf{R}^{\prime}\cap\mathsf{R}^{-}_{U}$. The key observation is that there are only $|U|$ different prefixes of length $3\tau-1$ in $\{T[j\mathinner{\ldotp\ldotp}n]:j\in\mathsf{R}^{-}_{U}\}$. We will incrementally compute the frequency of each of these prefixes $X\in\{0,1\}^{3\tau-1}$ and keep the count in an array $C[0\mathinner{\ldotp\ldotp}|U|)$, indexed by $t=|U^{\prime}|$ in the L-decomposition of every $j\in\mathsf{R}^{-}_{U}$ with $T[j\mathinner{\ldotp\ldotp}j+3\tau-1)=X$ (denote this set as $\mathsf{R}^{-}_{U,t}$). A single round of the algorithm handles $\mathsf{H}_{k}=\{j\in\mathsf{R}^{\prime-}_{U}:\text{\rm L-exp}(j)=k\}$. We execute the rounds for increasing $k$ and maintain the invariant that $C[t]$ contains $|\{j\in\mathsf{R}^{-}_{U,t}:\text{\rm L-exp}(j)\leq k\}|$ at the end of round $k$. At the beginning of round $k$, we use the values of $C$ to first compute $r_{j}^{<}$ for each $j\in\mathsf{H}_{k}$ and then update $C$ to maintain the invariant. The update consists of increasing some entries in $C$ for each $j\in\mathsf{H}_{k}$, and then increasing all entries in $C$ by the total number $q$ of yet unprocessed positions (having higher L-exponent), i.e., $q=|\mathsf{R}^{\prime-}_{U}|-\sum_{i=1}^{k}|\mathsf{H}_{i}|$. It is easy see that for each $j\in\mathsf{H}_{k}$, the update can be expressed as a constant number of increments in contiguous ranges of $C$. Additionally, if $\mathsf{H}_{k-1}=\emptyset$ and $k_{\rm prev}=\max\{k^{\prime}<k:\mathsf{H}_{k^{\prime}}\neq\emptyset\}$, right at the beginning of round $k$ (before computing $r_{j}^{<}$ for $j\in\mathsf{H}_{k}$), we increment all of $C$ by $q\cdot(k-k_{\rm prev}-1)$, to account for the skipped L-exponents. Each update of $C$ takes $\mathcal{O}(\log|U|)=\mathcal{O}(\log\log n)$ time if we implement $C$ as a balanced BST. Thus, the algorithm takes $\mathcal{O}(|\mathsf{R}^{\prime-}|\log\log n)=\mathcal{O}(n/\sqrt{\log n})$ time. Note, that there are $\mathcal{O}(2^{\tau/3})=\mathcal{O}(n^{\varepsilon/3})$ different L-roots; hence, we can afford to initialize $C$ in $\mathcal{O}(\log n)$ time for each $U$.

Theorem 6.3**.**

Given the packed representation of a text ${T\,{\in}\,\{0,1\}^{n}}$ and its $\tau$-synchronizing set $\mathsf{S}$ of size $\mathcal{O}(n/\tau)$ for $\tau=\varepsilon\log n$, where $\varepsilon>0$ is a sufficiently small constant, the Burrows–Wheeler transform of $T$ can be constructed in $\mathcal{O}(n/\sqrt{\log n})$ time and $\mathcal{O}(n/\log n)$ space.

6.2 Large Alphabets

Note that our BWT construction does not immediately generalize to larger alphabets since for binary strings it already relies on wavelet tree construction for sequences over alphabets of polynomial size. More precisely, in the binary case, we combined the bitvectors $B_{X}$ in the wavelet tree of a large-alphabet sequence $W$ to retrieve fragments of the Burrows–Wheeler transform of the text $T$. For an alphabet $\Sigma=[0\mathinner{\ldotp\ldotp}\sigma)$, the BWT consists of $(\log\sigma)$-bit characters. Thus, instead of standard binary wavelet trees, we use wavelet trees of degree $\sigma$. For simplicity, we assume that $\sigma$ is a power of two.

6.2.1 High-Degree Wavelet Trees

To construct a degree-$\sigma$ wavelet tree, we consider a string $W$ of length $n$ over an alphabet $[0\mathinner{\ldotp\ldotp}\sigma^{b})$ and think of every symbol $W[i]$ as of a number in base $\sigma$ with exactly $b$ digits (including leading zeros). First, we create the root node $v_{\varepsilon}$ and construct its string $D_{\varepsilon}$ of length $n$ setting as $D_{\varepsilon}[i]$ the most significant digit of $W[i]$. We then partition $W$ into $\sigma$ subsequences $W_{0},W_{1},\ldots,W_{\sigma-1}$ by scanning through $W$ and appending $W[i]$ with the most significant digit removed to $W_{c}$, where $c$ is the removed digit of $W[i]$. We recursively repeat the construction for every $W_{c}$ and attach the resulting tree as the $c$th child of the root. The nodes of the resulting degree-$\sigma$ wavelet tree are labeled with strings $Y\in[0\mathinner{\ldotp\ldotp}\sigma)^{\leq b}$. For $|Y|<b$, the string $D_{Y}$ at node $v_{Y}$ labeled with $Y$ contains the next digit following the prefix $Y$ in the $\sigma$-ary representation of $W[i]$ for each element $W[i]$ of $W$ whose $\sigma$-ary representation contains $Y$ as a prefix. (The digits in $D_{Y}$ occur in the order as the corresponding entries $W[i]$.) The total size of a wavelet tree is \mathcal{O}\big{(}\sigma^{b}+\frac{nb\log\sigma}{\log n}\big{)} words, which is \mathcal{O}\big{(}\frac{nb\log\sigma}{\log n}\big{)} if $b\leq\log_{\sigma}n$.

As observed in [3], the binary wavelet tree construction procedure can be used as a black box to build degree-$\sigma$ wavelet trees. Here, we present a more general version of this reduction.

Lemma 6.4** (see [3, Lemma 2.2]).**

Given the packed representation of a string \smash{W\in\big{[}0\mathinner{\ldotp\ldotp}\sigma^{b}\big{)}^{n}} with $b\leq\log_{\sigma}n$, we can construct its degree-$\sigma$ wavelet tree in $\mathcal{O}(nb\log\sigma/\sqrt{\log n}+nb\log^{2}\sigma/\log n)$ time using $\mathcal{O}(nb/\log_{\sigma}n)$ space.

Proof.

Consider a binary wavelet tree for $W$, where each symbol $W[i]$ is interpreted as an integer with $b\log\sigma$ binary digits. For every node $v_{X}$, where $X\in\{0,1\}^{<b\log\sigma}$, we define $D_{X}$ as the bitvector containing the $\log\sigma$ bits following $X$ in every symbol $W[i]$ prefixed with $X$ (in the order these symbols appear in $W$). If $|X|>(b-1)\log\sigma$, we pad $W[i]$ with trailing zeros. Bitvectors $D_{X}$ can be interpreted as strings over $[0\mathinner{\ldotp\ldotp}\sigma)$. In the rest of the proof, we adopt the latter convention. This way, we have generalized the strings $D_{Y}$, i.e., for every node $v_{Y}$ from the degree-$\sigma$ wavelet tree of $W$, where $Y\in[0\mathinner{\ldotp\ldotp}\sigma)^{<b}$, we have $D_{Y}=D_{X}$, where $X$ is the binary encoding of $Y$.

The algorithm starts by constructing the binary wavelet tree for $W$. Next, we compute the strings $D_{X}$ for all its nodes. To obtain the degree-$\sigma$ wavelet tree of $W$, it then suffices to remove all nodes whose depth is not a multiple of $\log\sigma$. For each surviving node, we set its nearest preserved ancestor as the parent. Each inner node has $\sigma$ children, and we order them consistently with the left-to-right order in the original binary wavelet tree.

The key observation is that for any $X\in\{0,1\}^{<b\log\sigma-1}$, the string $D_{X}$ can be computed from $D_{X0}$, $D_{X1}$, and $B_{X}$. First, we shift the binary representations of the characters from $D_{X0}$ and $D_{X1}$ by a single bit to the right, prepending a [math] to the characters in $D_{X0}$ and a $1$ to the characters in $D_{X1}$. Then, we construct $D_{X}$ by interleaving $D_{X0}$ and $D_{X1}$ according to the order defined by $B_{X}$: if the $i$th bit is [math], we append to the constructed string $D_{X}$ the next character of $D_{X0}$, and otherwise we append the next character of $D_{X1}$.

We pack every $\frac{1}{4}\frac{\log n}{\log\sigma}$ consecutive characters of strings $D_{X}$ with $X\in\{0,1\}^{<b\log\sigma}$ into a single machine word. During interleaving, instead of accessing $D_{X0}$ and $D_{X1}$ directly, we keep two buffers, each of at most $\frac{1}{4}\frac{\log n}{\log\sigma}$ yet-unmerged characters from the corresponding string, as well as a buffer of at most $\frac{1}{4}\log n$ yet-unused bits of $B_{X}$. We continue the computation of $D_{X}$ until one of the buffers becomes empty. To implement this efficiently, we preprocess (and store in a lookup table) all possible scenarios between two buffer refills for every possible initial content of the input buffers. We store the generated data (of at most $\frac{1}{2}\log n$ bits) and the final content of all buffers.

The preprocessing takes $\tilde{\mathcal{O}}(2^{\frac{3}{4}\log n})=o(n/\log n)$ time and space. The number of operations required to generate $D_{X}$ is proportional to the number of times we reload the buffers; hence, it takes $\mathcal{O}(1+|D_{X}|/\frac{\log n}{\log\sigma})$ time. Due to $\smash{\sum_{X\in\{0,1\}^{<b\log\sigma}}|D_{X}|=n(b\log\sigma-1)}$, the total complexity is $\smash{\mathcal{O}(\sigma^{b}+nb\log^{2}{\sigma}/\log n)=\mathcal{O}(nb\log^{2}{\sigma}/\log n)}$. Adding the time to construct the binary wavelet tree of $W$ (see Theorem 2.5), this yields the final complexity. ∎

6.2.2 BWT Construction Algorithm

Our construction algorithm for $T\in[0\mathinner{\ldotp\ldotp}\sigma)^{n}$ uses a $\tau$-synchronizing set $(s_{i}^{\prime})_{i\in[1\mathinner{\ldotp\ldotp}|\mathsf{S}|]}$ (where $T[s_{i}^{\prime}\mathinner{\ldotp\ldotp}n]\prec T[s_{j}^{\prime}\mathinner{\ldotp\ldotp}n]$ if $i<j$) for $\tau=\varepsilon\log_{\sigma}n$. We then build a sequence $W\in[0\mathinner{\ldotp\ldotp}\sigma^{3\tau})^{|\mathsf{S}|}$ with $W[i]=\overline{T[s_{i}^{\prime}-\tau\mathinner{\ldotp\ldotp}s_{i}^{\prime}+2\tau)}$, i.e., we reverse $T[s_{i}^{\prime}-\tau\mathinner{\ldotp\ldotp}s_{i}^{\prime}+2\tau)$ and then interpret it as a $3\tau$-digit integer in base $\sigma$. Next, we construct a degree-$\sigma$ wavelet tree of $W$ and combine the strings $D_{Y}$, where $Y\in[0\mathinner{\ldotp\ldotp}\sigma)^{\leq 3\tau-1}$, to obtain the BWT of $T$. The procedure is analogous to the binary case.

Theorem 6.5**.**

Given the packed representation of a text $T\in[0\mathinner{\ldotp\ldotp}\sigma)^{n}$ with $\log\sigma\leq\sqrt{\log n}$ and its $\tau$-synchronizing set $\mathsf{S}$ of size $\mathcal{O}(\frac{n}{\tau})$ with $\tau=\varepsilon\log_{\sigma}n$, where $\varepsilon>0$ is a sufficiently small constant, the Burrows–Wheeler transform of $T$ can be constructed in $\mathcal{O}(n\log\sigma/\sqrt{\log n})$ time and $\mathcal{O}(n/\log_{\sigma}n)$ space.

7 Conditional Optimality of the Binary BWT Construction

Given an array $A[1\mathinner{\ldotp\ldotp}m]$ of integers, the task of counting inversions is to compute the number of pairs $(i,j)$ such that $i<j$ and $A[i]>A[j]$. The currently fastest solution for the above problem, due to Chan and Pǎtraşcu [9], runs in $\mathcal{O}(m\sqrt{\log m})$ time and $\mathcal{O}(m)$ space.

Without loss of generality [19], we assume $A[i]\in[0\mathinner{\ldotp\ldotp}m)$. In this section, we show that improving the BWT construction from Section 6.1 also yields an improvement over [9]. More precisely, we show that computing the BWT of a packed text $T\in\{0,1\}^{n}$ in time $\mathcal{O}(f(n))$ implies an $\mathcal{O}(m+f(m\log m))$-time construction of the wavelet tree for $A$; hence, improving over Theorem 6.3 implies an $o(m\sqrt{\log m})$-time wavelet tree construction. The main result then follows from the next observation since it is easy to count inversions in a length-$n$ bitvector in $\mathcal{O}(n/\log n)$ time.

Observation 7.1**.**

The number of inversions in any integer sequence $A$ is equal to the total number of inversions in the bitvectors of the wavelet tree of $A$.

We first consider the case when $A[i]<m^{\varepsilon}$ for all $i\in[1\mathinner{\ldotp\ldotp}m]$ and for some sufficiently small constant $\varepsilon<1$; it is almost a direct reversal of the reduction from Section 6.1.1.

7.1 The Case $A[i]<m^{\varepsilon}$

Let $\text{\rm bin}_{k}(x)\in\{0,1\}^{k}$ be the base-2 representation of $x\in[0\mathinner{\ldotp\ldotp}2^{k})$ and let $\text{\rm pad}_{k}:\{0,1\}^{k}\rightarrow\{0,1\}^{2k}$ be a padding function that, given $X\in\{0,1\}^{k}$, inserts a 0-bit before each bit of $X$.

Assume $\varepsilon\log m$ and $\log m$ are integers. Given $A[1\mathinner{\ldotp\ldotp}m]$, let

[TABLE]

The text $T_{A}$ is of length $m(3+2(1+\varepsilon)\log m)$ and constructing it takes $\mathcal{O}(m)$ time. Recall that $B_{X}$ denotes the bitvector corresponding to the node of the wavelet tree of $A$ with root-to-node label $X$.

Lemma 7.2**.**

For $X\in\{0,1\}^{<\varepsilon\log m}$, let $\text{\rm SA}[b\mathinner{\ldotp\ldotp}e]$ be the range containing all suffixes of $T_{A}$ having $\overline{X}\cdot 01\cdot 1^{\varepsilon\log m}$ as a prefix. Then, $B_{X}=\text{\rm BWT}[b\mathinner{\ldotp\ldotp}e]$.

Proof.

Let $g:i\mapsto(i-1)(3+2(1+\varepsilon)\log m)+\varepsilon\log m-|X|+1$ restricted to $A_{X}:=\{i\in[1\mathinner{\ldotp\ldotp}m]:X\text{ is a prefix of }\text{\rm bin}_{\varepsilon\log m}(A[i])\}$ be a one-to-one map between $A_{X}$ and the set $\text{\rm SA}[b\mathinner{\ldotp\ldotp}e]$. It remains to observe that $T_{A}[g(i)\mathinner{\ldotp\ldotp}|T_{A}|]\prec T_{A}[g(j)\mathinner{\ldotp\ldotp}|T_{A}|]$ holds if $i<j$ for $i,j\in A_{X}$, and $\text{\rm bin}_{\varepsilon\log m}(A[i])[|X|+1]=T_{A}[g(i)-1]$ for $i\in A_{X}$. ∎

To compute the BWT ranges corresponding to the bitvectors $B_{X}$ for $\smash{X\in\{0,1\}^{<\varepsilon\log m}}$, we proceed as in Section 6: perform a preorder traversal of the complete binary tree of height $2\varepsilon\log m+1$ corresponding to lexicographic enumeration of $\smash{X^{\prime}\in\{0,1\}^{\leq 2\varepsilon\log m+1}}$. For $\smash{X^{\prime}=X011^{\varepsilon\log m}}$, where $\smash{X\in\{0,1\}^{<\varepsilon\log m}}$, copy the bits from BWT into $B_{\overline{X}}$. The number of bits to copy is given by the number $f_{X^{\prime}}$ of occurrences of $X^{\prime}$ in $T_{A}$. After copying the bits (or when we reach $\smash{X^{\prime}\in\{0,1\}^{2\varepsilon\log m+1}}$), advance the position in BWT by $f_{X^{\prime}}$.

To determine the frequencies of all $\{0,1\}^{\leq 2\varepsilon\log m+1}$, compute $f_{X^{\prime}}$ for all $X^{\prime}\in\{0,1\}^{2\varepsilon\log m+1}$ in $\mathcal{O}(m)$ time using the algorithm in Section 6.1.2. The remaining frequencies are then easily derived.

The algorithm runs in $\mathcal{O}(m+f(m\log m))$ time, where $f(n)$ is the runtime of the BWT construction for a packed text from $\{0,1\}^{n}$.

7.2 The Case $A[i]<m$

Given an array $A[1\mathinner{\ldotp\ldotp}m]$ with values $A[i]\in[0\mathinner{\ldotp\ldotp}m)$, let

[TABLE]

Lemma 7.3**.**

For $X\in\{0,1\}^{<\log m}$, let $\text{\rm SA}[b\mathinner{\ldotp\ldotp}e]$ be the range containing all suffixes of $T_{A}$ having $\overline{X}\cdot 01\cdot 1^{\log m}$ as a prefix. Then, $B_{X}=\text{\rm BWT}[b\mathinner{\ldotp\ldotp}e]$.

The main challenge lies in obtaining the BWT ranges, as the approach of Section 7.1 no longer works. Consider instead partitioning the suffixes in SA according to the length-$\log m$ prefix (separately handling shorter suffixes). Observe that there is a unique bijection $\mathrm{ext}:\{0,1\}^{\log m}\setminus\{1^{\log m}\}\to\{0,1\}^{<\log m}\cdot 01\cdot 1^{\log m}$ such that $X$ is a prefix of $\mathrm{ext}(X)$. Furthermore, if the range $\text{\rm SA}[b\mathinner{\ldotp\ldotp}e]$ contains suffixes of $T_{A}$ prefixed by $X\in\{0,1\}^{\log m}\setminus\{1^{\log m}\}$, then the analogous range $\text{\rm SA}[b^{\prime}\mathinner{\ldotp\ldotp}e^{\prime}]$ for $\mathrm{ext}(X)$ satisfies $e^{\prime}=e$. Thus, it suffices to precompute frequencies $F:=\{(X,f_{X}):X\in\{0,1\}^{\log m}\setminus\{1^{\log m}\}\}$ and $F^{\prime}:=\{(X,f_{X}):X\in\{0,1\}^{<\log m}\cdot 01\cdot 1^{\log m}\}$.

To this end, construct $F_{\rm pref}\,{:}{=}\,\{(X,f_{X}^{\prime}):X\in\{0,1\}^{\leq\log m}\}$, with $f_{X}^{\prime}$ defined as the number occurrences of $X$ as prefixes of strings in $\mathcal{A}=(\overline{\text{\rm bin}_{\log m}(A[i])})_{i\in[1\mathinner{\ldotp\ldotp}m]}$. To compute $F_{\rm pref}$, we first in $\mathcal{O}(m)$ time build $\{(X,f_{X}^{\prime}):X\in\{0,1\}^{\log m}\}\subseteq F_{\rm pref}$ by scanning $\mathcal{A}$. The remaining elements of $F_{\rm pref}$ are derived by the equality $f_{X}^{\prime}=f_{X0}^{\prime}+f_{X1}^{\prime}$. Analogously prepare suffix frequencies $F_{\rm suf}$. Given $F_{\rm pref}$ and $F_{\rm suf}$, we can compute $F$ in $\mathcal{O}(m)$ time: the number of occurrences of $X\in\{0,1\}^{\log m}$ overlapping factors $\mathcal{A}$ is obtained from $F_{\rm pref}$ and $F_{\rm suf}$; the number of other occurrences is easily determined as it only depends on $m$. Finally, $F^{\prime}$ is computed directly from $F_{\rm suf}$.

Theorem 7.4**.**

If there exists an algorithm that, given the packed representation of a text $T\in\{0,1\}^{n}$, constructs its BWT in $\mathcal{O}(f(n))$ time, then we can compute the number of inversions in an array of $m$ integers in $\mathcal{O}(m+f(m\log m))$ time. In particular, if $f(n)=o(n/\sqrt{\log n})$, then the algorithm runs in $o(m\sqrt{\log m})$ time.

8 Synchronizing Sets Construction

Throughout this section, we fix a text $T$ of length $n$ and a positive integer $\tau\leq\frac{1}{2}n$. We also introduce a partition $\mathcal{P}$ of the set $[1\mathinner{\ldotp\ldotp}{n-\tau+1}]$ so that positions $i,j$ belong to the same class if and only if $T[i\mathinner{\ldotp\ldotp}i+\tau)=T[j\mathinner{\ldotp\ldotp}j+\tau)$. In other words, each class contains the starting positions of a certain length-$\tau$ substring of $T$. We represent $\mathcal{P}$ using an identifier function $\mathsf{id}:[1\mathinner{\ldotp\ldotp}n-\tau+1]\to[0\mathinner{\ldotp\ldotp}|\mathcal{P}|)$ such that $\mathsf{id}(i)=\mathsf{id}(j)$ if and only if $T[i\mathinner{\ldotp\ldotp}i+\tau)=T[j\mathinner{\ldotp\ldotp}{j+\tau})$.

The local consistency of a string synchronizing set $\mathsf{S}$ means that the decision on whether $i\in\mathsf{S}$ should be made solely based on $T[i\mathinner{\ldotp\ldotp}i+2\tau)$ or, equivalently, on $\mathsf{id}(i),\ldots,\mathsf{id}(i+\tau)$. The density condition, on the other hand, is formulated in terms of a set $\mathsf{R}=\{i\in[1\mathinner{\ldotp\ldotp}n-3\tau+2]:\text{\rm per}(T[i\mathinner{\ldotp\ldotp}i+3\tau-2])\leq\frac{1}{3}\tau\}$. Here, we introduce its superset $\mathsf{Q}=\{i\in[1\mathinner{\ldotp\ldotp}n-\tau+1]:\text{\rm per}(T[i\mathinner{\ldotp\ldotp}i+\tau)\leq\frac{1}{3}\tau)\}$. The periodicity lemma (Lemma 2.1) lets us relate these two sets:

[TABLE]

Based on an identifier function $\mathsf{id}$ and the set $\mathsf{Q}$, we define a synchronizing set $\mathsf{S}$ as follows. Consider a window of size $\tau+1$ sliding over the identifiers $\mathsf{id}(j)$. For any position $i$ of the window, we compute the smallest identifier $\mathsf{id}(j)$ for $j\in[i\mathinner{\ldotp\ldotp}i+\tau]\setminus\mathsf{Q}$. We insert $i$ to $\mathsf{S}$ if the minimum is attained for $\mathsf{id}(i)$ or $\mathsf{id}(i+\tau)$.

Construction 8.1**.**

For an identifier function $\mathsf{id}$, we define

[TABLE]

Let us formally argue that this results in a synchronizing set.

Lemma 8.2**.**

Construction 8.1* always yields a $\tau$-synchronizing set.*

Proof.

As for the local consistency of $\mathsf{S}$, observe that if positions $i,i^{\prime}$ satisfy $T[i\mathinner{\ldotp\ldotp}i+2\tau)=T[i^{\prime}\mathinner{\ldotp\ldotp}i^{\prime}+2\tau)$, then $\mathsf{id}(i+\delta)=\mathsf{id}(i^{\prime}+\delta)$ for $\delta\in[0\mathinner{\ldotp\ldotp}\tau]$. Moreover, $i+\delta\in\mathsf{Q}$ if and only if $i^{\prime}+\delta\in\mathsf{Q}$. Consequently, $\{\mathsf{id}(i),\mathsf{id}(i+\tau)\}=\{\mathsf{id}(i^{\prime}),\mathsf{id}(i^{\prime}+\tau)\}$ and

[TABLE]

Thus, $i\in\mathsf{S}$ if and only if $i^{\prime}\in\mathsf{S}$.

To prove the density condition, first assume that $i\notin\mathsf{R}$. As (1) yields $[i\mathinner{\ldotp\ldotp}i+2\tau)\setminus\mathsf{Q}\neq\emptyset$, we can choose a position $j$ in the latter set with minimum identifier. If $j<i+\tau$, then $j\in\mathsf{S}$ due to $\mathsf{id}(j)=\min\{\mathsf{id}(j^{\prime}):j^{\prime}\in[j\mathinner{\ldotp\ldotp}j+\tau]\setminus\mathsf{Q}\}$. Otherwise, $j-\tau\in\mathsf{S}$ due to $\mathsf{id}(j)=\min\{\mathsf{id}(j^{\prime}):j^{\prime}\in[j-\tau\mathinner{\ldotp\ldotp}j]\setminus\mathsf{Q}\}$. In either case, $\mathsf{S}\cap[i\mathinner{\ldotp\ldotp}i+\tau)\neq\emptyset$.

The converse implication is easy: if $i\in\mathsf{R}$, then $[i\mathinner{\ldotp\ldotp}i+2\tau)\subseteq\mathsf{Q}$ by (1), so $[j\mathinner{\ldotp\ldotp}j+\tau]\setminus\mathsf{Q}=\emptyset$ and therefore $j\notin\mathsf{S}$ for $j\in[i\mathinner{\ldotp\ldotp}i+\tau)$. Consequently, $\mathsf{S}\cap[i\mathinner{\ldotp\ldotp}i+\tau)=\emptyset$. ∎

The main challenge in building a $\tau$-synchronizing set with Construction 8.1 is to choose an appropriate identifier function $\mathsf{id}$ so that resulting synchronizing set $\mathsf{S}$ is small. We first consider only texts satisfying $\mathsf{Q}=\emptyset$. Note that this is a stronger assumption that $\mathsf{R}=\emptyset$, which we made in the nonperiodic case of Sections 4, 5 and 6.

8.1 The Nonperiodic Case

The key feature of strings without small periods is that their occurrences cannot overlap too much. We say that a set $A\subseteq\mathbb{Z}$ is $d$-sparse if every two distinct elements $i,i^{\prime}\in A$ satisfy $|i-i^{\prime}|>d$.

Fact 8.3**.**

An equivalence class $\mathsf{P}\in\mathcal{P}$ is $\frac{1}{3}\tau$-sparse if $\mathsf{P}\cap\mathsf{Q}=\emptyset$.

Proof.

Suppose that positions $i,i^{\prime}\in\mathsf{P}$ satisfy $i<i^{\prime}\leq i+\frac{1}{3}\tau$. We have $T[i\mathinner{\ldotp\ldotp}i+\tau)=T[i^{\prime}\mathinner{\ldotp\ldotp}i^{\prime}+\tau)$, so $\text{\rm per}(T[i\mathinner{\ldotp\ldotp}i^{\prime}+\tau))\leq i^{\prime}-i\leq\frac{1}{3}\tau$. In particular, $\text{\rm per}(T[i\mathinner{\ldotp\ldotp}i+\tau))\leq\frac{1}{3}\tau$, so $i\in\mathsf{Q}$ and $\mathsf{P}\cap\mathsf{Q}\neq\emptyset$. ∎

8.1.1 Randomized Construction

It turns out that choosing $\mathsf{id}$ uniformly at random leads to satisfactory results if $\mathsf{Q}=\emptyset$.

Fact 8.4**.**

Let $\pi:\mathcal{P}\to[0\mathinner{\ldotp\ldotp}|\mathcal{P}|)$ be a uniformly random bijection, and let $\mathsf{id}$ be an identifier function such that $\mathsf{id}(j)=\pi(\mathsf{P})$ for each $j\in\mathsf{P}$ and $\mathsf{P}\in\mathcal{P}$. If $\mathsf{Q}=\emptyset$, then a $\tau$-synchronizing set $\mathsf{S}$ defined with Construction 8.1 based on such a function $\mathsf{id}$ satisfies $\mathbb{E}[|\mathsf{S}|]\leq\frac{6n}{\tau}$.

Proof.

Observe that for every position $i\in[1\mathinner{\ldotp\ldotp}n-2\tau+1]$, we have $|[i\mathinner{\ldotp\ldotp}i+\tau]\setminus\mathsf{Q}|=|[i\mathinner{\ldotp\ldotp}i+\tau]|=\tau+1$. Moreover, Fact 8.3 guarantees that $|[i\mathinner{\ldotp\ldotp}i+\tau]\cap\mathsf{P}|\leq 3$ for each class $\mathsf{P}\in\mathcal{P}$. Thus, positions in $[i\mathinner{\ldotp\ldotp}i+\tau]$ belong to at least $\frac{\tau}{3}$ distinct classes. Each of them has the same probability of having the smallest identifier, so

[TABLE]

holds for every $i\in[1\mathinner{\ldotp\ldotp}n-2\tau+1]$. By linearity of expectation, we conclude that $\mathbb{E}[|\mathsf{S}|]\leq\tfrac{6n}{\tau}$. ∎

8.1.2 Deterministic Construction

Our next goal is to provide an $\mathcal{O}(n)$-time deterministic construction of a synchronizing set $\mathsf{S}$ of size $|\mathsf{S}|=\mathcal{O}(\frac{n}{\tau})$. The idea is to gradually build an identifier function $\mathsf{id}$ assigning consecutive identifiers to classes $\mathsf{P}\in\mathcal{P}$ one at a time. Our choice of the subsequent classes is guided by a carefully designed scoring function inspired by Fact 8.4.

Proposition 8.5**.**

If $\mathsf{Q}=\emptyset$ for a text $T$ and a positive integer $\tau\leq\frac{1}{2}n$, then in $\mathcal{O}(n)$ time one can construct a $\tau$-synchronizing set of size at most $\frac{18n}{\tau}$.

Proof.

First, we build the partition $\mathcal{P}$. A simple $\mathcal{O}(n)$-time implementation is based on the suffix array SA and the LCP table of $T$ (see Section 2.1). We cut the suffix array before every position $i$ such that $\text{\rm LCP}[i]<\tau$, and we remove positions $i$ with $\text{\rm SA}[i]>n-\tau+1$. The values $\text{\rm SA}[\ell\mathinner{\ldotp\ldotp}r]$ in each remaining maximal region form a single class $\mathsf{P}\in\mathcal{P}$. We store pointers to $\mathsf{P}$ for all positions $j\in\mathsf{P}$.

Next, we iteratively construct the function $\mathsf{id}$ represented in a table $\mathsf{id}[1\mathinner{\ldotp\ldotp}n-\tau+1]$. Initially, each value $\mathsf{id}[j]$ is undefined ($\bot$). In the $k$th iteration, we choose a class $\mathsf{P}_{k}\in\mathcal{P}$ and set $\mathsf{id}[j]=k$ for $j\in\mathsf{P}_{k}$. Finally, we build a $\tau$-synchronizing set as in Construction 8.1.

Our choice of subsequent classes $\mathsf{P}_{k}$ is guided by a scoring function. To define it, we distinguish active blocks which are maximal blocks $\mathsf{id}[\ell\mathinner{\ldotp\ldotp}r]$ consisting of undefined values only and satisfying $r-\ell\geq\tau$. Each position $j\in[\ell\mathinner{\ldotp\ldotp}r]$ lying in an active block $\mathsf{id}[\ell\mathinner{\ldotp\ldotp}r]$ is called an active position and assigned a score: $-1$ if it is among the leftmost or the rightmost $\left\lfloor\frac{1}{3}\tau\right\rfloor$ positions within an active block and $+2$ otherwise. Note that the condition $r-\ell\geq\tau$ implies that the total score of positions within an active block is non-negative. Hence, the global score of all active positions is also non-negative.

Our algorithm explicitly remembers whether each position is active and what its score is. Moreover, we store the aggregate score of active positions in each class $\mathsf{P}\in\mathcal{P}$ and maintain a collection $\mathcal{P}^{+}\subseteq\mathcal{P}$ of unprocessed classes with non-negative scores. Note that the aggregate score is 0 for the already processed classes, so $\mathcal{P}^{+}$ is non-empty until there are no unprocessed classes. Hence, we can always choose the subsequent class $\mathsf{P}_{k}$ from $\mathcal{P}^{+}$.

Having chosen the class $\mathsf{P}_{k}$, we need to set $\mathsf{id}[j]=k$ for $j\in\mathsf{P}_{k}$. If the position $j\in\mathsf{P}_{k}$ was active, then some nearby positions $j^{\prime}$ may cease to be active or change their scores. This further modifies the aggregate scores of other classes $\mathsf{P}\in\mathcal{P}$, some of which may enter or leave $\mathcal{P}^{+}$. Nevertheless, the affected positions $j^{\prime}$ satisfy $|j-j^{\prime}|\leq\tau$, so we can implement the changes caused by setting $\mathsf{id}[j]=k$ in $\mathcal{O}(\tau)$ time. The total cost of processing $\mathsf{P}_{k}$ is $\mathcal{O}(|\mathsf{P}_{k}|+\tau|\mathsf{A}_{k}|)$, where $\mathsf{A}_{k}\subseteq\mathsf{P}_{k}$ consists of positions which were active initially.

Finally, we build the synchronizing set $\mathsf{S}$ according to Construction 8.1. Recall that a position $i\in[1\mathinner{\ldotp\ldotp}n-2\tau+1]$ is inserted to $\mathsf{S}$ if and only if $\min\mathsf{id}[i\mathinner{\ldotp\ldotp}i+\tau]\in\{\mathsf{id}[i],\mathsf{id}[i+\tau]\}$. Hence, it suffices to slide a window of fixed width $\tau+1$ over the table $\mathsf{id}[1\mathinner{\ldotp\ldotp}n-\tau+1]$ computing the sliding-window minima. This takes $\mathcal{O}(n)$ time.

To bound the size $|\mathsf{S}|$, consider a position $i$ inserted to $\mathsf{S}$, let $k=\min\mathsf{id}[i\mathinner{\ldotp\ldotp}i+\tau]$, and note that $k=\mathsf{id}[i]$ or $k=\mathsf{id}[i+\tau]$. Observe that prior to processing $\mathsf{P}_{k}$, we had $\mathsf{id}[j]=\bot$ for $j\in[i\mathinner{\ldotp\ldotp}i+\tau]$. Consequently, $\mathsf{id}[i\mathinner{\ldotp\ldotp}i+\tau]$ was contained in an active block and $i,i+\tau$ were active positions. At least one of them belongs to $\mathsf{P}_{k}$, so it also belongs to $\mathsf{A}_{k}$. Hence, if $i\in\mathsf{S}$, then $i\in\bigcup_{k}\mathsf{A}_{k}$ or $i+\tau\in\bigcup_{k}\mathsf{A}_{k}$, which yields $|\mathsf{S}|\leq 2|\bigcup_{k}\mathsf{A}_{k}|=2\sum_{k}|\mathsf{A}_{k}|$. In order to bound this quantity, let us introduce sets $\mathsf{A}^{+}_{k}\subseteq\mathsf{A}_{k}$ formed by active positions that had score $+2$ prior to processing $\mathsf{P}_{k}$. The choice of $\mathsf{P}_{k}$ as a class with non-negative aggregate score guarantees that $|\mathsf{A}_{k}|\leq 3|\mathsf{A}^{+}_{k}|$.

Finally, we shall prove that the set $\mathsf{A}^{+}:=\bigcup_{k}\mathsf{A}^{+}_{k}$ is $\frac{1}{3}\tau$-sparse. Consider two distinct positions $j,j^{\prime}\in\mathsf{A}^{+}$ such that $j\in\mathsf{A}^{+}_{k}$, $j^{\prime}\in\mathsf{A}^{+}_{k^{\prime}}$. If $k=k^{\prime}$, then $|j-j^{\prime}|>\frac{1}{3}\tau$ because $\mathsf{A}^{+}_{k}\subseteq\mathsf{P}_{k}$ is $\frac{1}{3}\tau$-sparse by Fact 8.3. Hence, we may assume without loss of generality that $k^{\prime}<k$. Prior to processing $\mathsf{P}_{k}$, the position $j^{\prime}$ was not active (the value $\mathsf{id}[j^{\prime}]=k^{\prime}$ was already set) whereas $j$ was active and had score $+2$. Hence, there must have been at least $\left\lfloor\frac{1}{3}\tau\right\rfloor$ active positions with score $-1$ in between, so $|j-j^{\prime}|\geq\left\lfloor\frac{1}{3}\tau\right\rfloor+1>\frac{1}{3}\tau$.

Consequently, |\mathsf{A}^{+}|\leq\big{\lceil}{\frac{3(n-\tau+1)}{\tau}\big{\rceil}}\leq\frac{3n}{\tau}, which implies $|\mathsf{S}|\leq 2\sum_{k}|\mathsf{A}_{k}|\leq 6\sum_{k}|\mathsf{A}^{+}_{k}|=6|\mathsf{A}^{+}|\leq\frac{18n}{\tau}$. Moreover, the overall running time is $\mathcal{O}(n+\tau\sum_{k}|\mathsf{A}_{k}|)=\mathcal{O}(n+\tau\frac{n}{\tau})=\mathcal{O}(n)$. ∎

8.1.3 Efficient Implementation for Small $\tau$

Next, we shall implement our construction in $\mathcal{O}(\frac{n}{\tau})$ time if $\tau\leq\varepsilon\log_{\sigma}n$ and $\varepsilon<\frac{1}{5}$.

Our approach relies on local consistency of the procedure in Proposition 8.5. More specifically, we note that the way this procedure handles a position $i$ depends only on the classes of the nearby positions $j$ with $|j-i|\leq\tau$. In particular, these classes determine how the score of $i$ changes and whether $i$ is inserted to $\mathsf{S}$.

Motivated by this observation, we partition $[1\mathinner{\ldotp\ldotp}n-\tau+1]$ into $\mathcal{O}(\frac{n}{\tau})$ blocks so that the $b$th block contains positions $i$ with $\lceil{\frac{i}{\tau}\rceil}=b$. We define $T[1+(b-2)\tau\mathinner{\ldotp\ldotp}(b+2)\tau]$ to be the context of the $b$th block (assuming that $T[i]=\#\notin\Sigma$ for out-of-bound positions $i\notin[1\mathinner{\ldotp\ldotp}n]$), and we say that blocks are equivalent if they share the same context.

Based on the initial observation, we note that if two blocks $b,b^{\prime}$ are equivalent, then the corresponding positions $i=b\tau-\delta$ and $i^{\prime}=b^{\prime}\tau-\delta$ (for $\delta\in[0\mathinner{\ldotp\ldotp}\tau)$) are processed in the same way by the procedure of Proposition 8.5. This means that we need to process just one representative block in each equivalence class.

We can retrieve each context in $\mathcal{O}(1)$ time using Proposition 2.3. Consequently, it takes $\mathcal{O}(\frac{n}{\tau})$ time to partition the blocks into equivalence classes and construct a family $\mathcal{B}$ of representative blocks. Our choice of $\tau$ guarantees that $|\mathcal{B}|=\mathcal{O}(1+\sigma^{4\tau})=\mathcal{O}(n^{4\varepsilon})$. Similarly, the class $\mathsf{P}\in\mathcal{P}$ of a position $j$ is determined by $T[j\mathinner{\ldotp\ldotp}j+\tau)$, so $|\mathcal{P}|=\mathcal{O}(n^{\varepsilon})$ and the substring can also be retrieved in $\mathcal{O}(1)$ time. Hence, the construction procedure has $\mathcal{O}(n^{\varepsilon})$ iterations. If we spent \mathcal{O}\big{(}\tau^{\mathcal{O}(1)}\big{)} time for each representative block at each iteration, the overall running time would be \mathcal{O}\big{(}n^{\varepsilon}n^{4\varepsilon}\tau^{\mathcal{O}(1)}\big{)}=\mathcal{O}\big{(}n^{5\varepsilon+o(1)}\big{)}=\mathcal{O}\big{(}n^{1-\Omega(1)}\big{)}=\mathcal{O}(\frac{n}{\tau}). This allows for a quite simple approach.

We maintain classes $\mathsf{P}\in\mathcal{P}$ indexed by the underlying substrings. For each class, we store the identifier $\mathsf{id}(j)$ assigned to the positions $j\in\mathsf{P}$ and a list of positions $j\in\mathsf{P}$ contained in the representative blocks. To initialize these components (with the identifier $\mathsf{id}(j)$ set to $\bot$ at first), we scan all representative blocks in \mathcal{O}\big{(}\tau^{\mathcal{O}(1)}\big{)} time per block, which yields \mathcal{O}\big{(}|\mathcal{B}|\tau^{\mathcal{O}(1)}\big{)}=o(\frac{n}{\tau}) time in total.

Choosing a class to be processed in every iteration involves computing scores. To determine the score of a particular class $\mathsf{P}\in\mathcal{P}$, we iterate over all positions $j\in\mathsf{P}$ contained in the representative blocks. We retrieve the class of each fragment $j^{\prime}$ with $|j-j^{\prime}|\leq\tau$ in order to compute the score of $j$. We add this score, multiplied by the number of equivalent blocks, to the aggregate score of $\mathsf{P}$. Having computed the score of each class, we take an arbitrary class $\mathsf{P}_{k}$ with a non-negative score (and no value assigned yet), and we assign the subsequent identifier $k$ to this class. As announced above, the running time of a single iteration is \mathcal{O}\big{(}|\mathcal{B}|\tau^{\mathcal{O}(1)}\big{)} as we spend \mathcal{O}\big{(}\tau^{\mathcal{O}(1)}\big{)} time for each position contained in a representative block.

In the post-processing, we compute $\mathsf{S}$ restricted to positions in representative blocks: For every position $i$ contained in a representative block, we retrieve the classes of the nearby positions $j\in[i\mathinner{\ldotp\ldotp}i+\tau]$ to check whether $i$ should be inserted to $\mathsf{S}$. This takes \mathcal{O}\big{(}\tau^{\mathcal{O}(1)}\big{)} time per position $i$, which is \mathcal{O}\big{(}|\mathcal{B}|\tau^{\mathcal{O}(1)}\big{)}=o(\frac{n}{\tau}) in total.

Finally, we build the whole set $\mathsf{S}$: For each block, we copy the positions of the corresponding representative block inserted to $\mathsf{S}$ (shifting the indices accordingly). The running time of this final phase is $\mathcal{O}(|\mathsf{S}|+\frac{n}{\tau})$, which is $\mathcal{O}(\frac{n}{\tau})$ due to $|\mathsf{S}|\leq\frac{18n}{\tau}$.

Proposition 8.6**.**

For every constant $\varepsilon<\frac{1}{5}$, given the packed representation of a text $T\in[0\mathinner{\ldotp\ldotp}\sigma)^{n}$ and a positive integer $\tau\leq\varepsilon\log_{\sigma}n$ such that $\mathsf{Q}=\emptyset$, one can construct in $\mathcal{O}(\frac{n}{\tau})$ time a $\tau$-synchronizing set of size $\mathcal{O}(\frac{n}{\tau})$.

8.2 The General Case

In this section, we adapt our constructions so that they work for arbitrary strings. For this, we first study the structure of the set $\mathsf{Q}$.

8.2.1 Structure of Highly Periodic Fragments

The probabilistic argument in the proof of Fact 8.4 relies on the large size of each set $[i\mathinner{\ldotp\ldotp}i+\tau]\setminus\mathsf{Q}$ that we had due to $\mathsf{Q}=\emptyset$. However, in general the sets $[i\mathinner{\ldotp\ldotp}i+\tau]\setminus\mathsf{Q}$ can be of arbitrary size between [math] and $\tau+1$. To deal with this issue, we define the following set (assuming $\tau\geq 2$).

[TABLE]

(In the special case of $\tau=1$, we set $\mathsf{B}=\emptyset$.) Intuitively, $\mathsf{B}$ forms a boundary which separates $\mathsf{Q}$ from its complement, as formalized in the fact below. However, it also contains some additional fragments included to make sure that $\mathsf{B}$ consists of full classes $\mathsf{P}\in\mathcal{P}$.

Fact 8.7**.**

If $[\ell\mathinner{\ldotp\ldotp}r]\cap\mathsf{Q}\neq\emptyset$ and $[\ell\mathinner{\ldotp\ldotp}r]\not\subseteq\mathsf{Q}$ for two positions $\ell,r\in[1\mathinner{\ldotp\ldotp}n-\tau+1]$, then $[\ell\mathinner{\ldotp\ldotp}r]\cap\mathsf{B}\neq\emptyset$.

Proof.

We proceed by induction on $r-\ell$. In the base case, $r=\ell+1$ and the assumption yields that $\{\ell,\ell+1\}\setminus\mathsf{Q}$ consists of a single element $i$. However, this means that $i-1\in\mathsf{Q}$ (if $i=\ell+1$) or $i+1\in\mathsf{Q}$ (if $i=\ell$). We conclude that $\text{\rm per}(T[i\mathinner{\ldotp\ldotp}i+\tau-1))\leq\frac{1}{3}\tau$ or $\text{\rm per}(T[i+1\mathinner{\ldotp\ldotp}i+\tau))\leq\frac{1}{3}\tau$, respectively, so $i\in\mathsf{B}$ as claimed.

For the inductive step with $r-\ell\geq 2$, it suffices to note that if $[\ell\mathinner{\ldotp\ldotp}r]\cap\mathsf{Q}\neq\emptyset$ and $[\ell\mathinner{\ldotp\ldotp}r]\not\subseteq\mathsf{Q}$, then the same is true for $[\ell\mathinner{\ldotp\ldotp}r-1]$ or for $[\ell+1\mathinner{\ldotp\ldotp}r]$ (because these two subsets have a non-empty intersection). ∎

We conclude the analysis with a linear-time construction of $\mathsf{Q}$ and $\mathsf{B}$, which also reveals an upper bound on $|\mathsf{B}|$.

Lemma 8.8**.**

Given a text $T$ and a positive integer $\tau$, the sets $\mathsf{Q}$ and $\mathsf{B}$ can be constructed in $\mathcal{O}(n)$ time. Moreover, $|\mathsf{B}|\leq\frac{6n}{\tau}$.

Proof.

Note that if $\tau\leq 2$, then $\mathsf{B}=\mathsf{Q}=\emptyset$, and the claim holds trivially. We assume $\tau\geq 3$ henceforth.

Let $I=[i\mathinner{\ldotp\ldotp}i+b)\subseteq[1\mathinner{\ldotp\ldotp}n-\tau+1]$ be a block of $b\leq\left\lceil\frac{1}{3}\tau\right\rceil$ subsequent positions. Consider a fragment $x=T[i+b\mathinner{\ldotp\ldotp}i+\tau-1)$ (non-empty due to $\tau\geq 3$), and let $p=\text{\rm per}(x)$. Let us further define $y=T[\ell\mathinner{\ldotp\ldotp}r]$ as the maximal fragment with period $p$ containing $x$ and contained in $T[i\mathinner{\ldotp\ldotp}i+b+\tau-1)$. We claim that $I\cap\mathsf{Q}=I\cap\mathsf{B}=\emptyset$ if $p>\frac{1}{3}\tau$ or $|y|<\tau-1$, whereas $I\cap\mathsf{Q}=I\cap[\ell\mathinner{\ldotp\ldotp}r-\tau+1]$ and $I\cap\mathsf{B}=I\cap\{\ell-1,r-\tau+2\}$ otherwise.

First, let us consider a position $j\in I\cap[\ell\mathinner{\ldotp\ldotp}r-\tau+1]$ provided that $p\leq\frac{1}{3}\tau$. Observe that $T[j\mathinner{\ldotp\ldotp}j+\tau)$ is contained in $y$, so $\text{\rm per}(T[j\mathinner{\ldotp\ldotp}j+\tau))=p\leq\frac{1}{3}\tau$, which implies $j\in I\cap\mathsf{Q}$. On the other hand, if $j\in I\cap\mathsf{Q}$, we define $p^{\prime}=\text{\rm per}(T[j\mathinner{\ldotp\ldotp}j+\tau))$. Note that $x$ is contained in $T[j\mathinner{\ldotp\ldotp}j+\tau)$ and thus also has $p^{\prime}\leq\frac{1}{3}\tau$ as its period. Moreover, $p+p^{\prime}-1\leq\left\lfloor\frac{2}{3}\tau\right\rfloor-1=\tau-1-\left\lceil\frac{1}{3}\tau\right\rceil\leq\tau-1-b=|x|$, so $p\mid p^{\prime}$ by the periodicity lemma (Lemma 2.1). Consequently, $p=p^{\prime}\leq\frac{1}{3}\tau$ and $T[j\mathinner{\ldotp\ldotp}j+\tau)$ is contained in $y$, which yields $j\in I\cap[\ell\mathinner{\ldotp\ldotp}r-\tau+1]$.

Next, let us consider a position $j\in I\cap\{\ell-1,r-\tau+2\}$ provided that $p\leq\frac{1}{3}\tau$ and $|y|\geq\tau-1$. Observe that $T[j+1\mathinner{\ldotp\ldotp}j+\tau)$ or $T[j\mathinner{\ldotp\ldotp}j+\tau-1)$ is contained in $y$, so $\text{\rm per}(T[j+1\mathinner{\ldotp\ldotp}j+\tau))=p\leq\frac{1}{3}\tau$ or $\text{\rm per}(T[j\mathinner{\ldotp\ldotp}j+\tau-1))=p\leq\frac{1}{3}\tau$. Furthermore, $j\notin\mathsf{Q}$ due to $j\notin I\cap[\ell\mathinner{\ldotp\ldotp}r-\tau+1]=I\cap\mathsf{Q}$, so $j\in I\cap\mathsf{B}$. On the other hand, if $j\in I\cap\mathsf{B}$, we define $p^{\prime}=\text{\rm per}(T[j+1\mathinner{\ldotp\ldotp}j+\tau-1))$. Note that $x$ is contained in $T[j+1\mathinner{\ldotp\ldotp}j+\tau-1)$ and thus also has $p^{\prime}\leq\frac{1}{3}\tau$ as its period. Moreover, $p+p^{\prime}-1\leq\left\lfloor\frac{2}{3}\tau\right\rfloor-1=\tau-1-\left\lceil\frac{1}{3}\tau\right\rceil\leq\tau-1-b=|x|$, so $p\mid p^{\prime}$ by the periodicity lemma (Lemma 2.1). Consequently, $p=p^{\prime}\leq\frac{1}{3}\tau$ and $T[j+1\mathinner{\ldotp\ldotp}j+\tau-1)$ is contained in $y$, which yields $j\in I\cap[\ell-1\mathinner{\ldotp\ldotp}r-\tau+2]$ and $|y|\geq\tau-1$. Furthermore, $j\notin I\cap\mathsf{Q}=I\cap[\ell\mathinner{\ldotp\ldotp}r-\tau+1]$, so $j\in I\cap\{\ell-1,r-\tau+2\}$ holds as claimed.

Finally, we observe that $p=\text{\rm per}(x)$ can be computed in $\mathcal{O}(|x|)=\mathcal{O}(\tau)$ time [34, 26], and $y$ can be easily constructed in $\mathcal{O}(|y|)=\mathcal{O}(\tau)$ time as a greedy extension of $x$. Hence, it takes $\mathcal{O}(\tau)$ time to determine $I\cap\mathsf{Q}$ and $I\cap\mathsf{B}$. Moreover, the size of the latter set is at most two.

The domain $[1\mathinner{\ldotp\ldotp}n-\tau+1]$ can be decomposed into \big{\lceil}{\frac{n-\tau+1}{\lceil{\tau/3}\rceil}\big{\rceil}}\leq\frac{3n}{\tau} blocks $I$ of size $b\leq\left\lceil\frac{1}{3}\tau\right\rceil$, so we conclude that the sets $\mathsf{Q}$ and $\mathsf{B}$ can be constructed in $\mathcal{O}(n)$ time and that the size of the latter set is at most $\frac{6n}{\tau}$.∎

8.2.2 Randomized Construction

The set $\mathsf{B}$ lets us adopt the results of Section 8.1 to arbitrary texts. As indicated in a probabilistic argument, the key trick is to assign the smallest identifiers to classes in $\mathsf{B}$.

Fact 8.9**.**

There is an identifier function $\mathsf{id}$ such that Construction 8.1 yields a synchronizing set of size at most $\frac{18n}{\tau}$.

Proof.

As in Fact 8.4, we take a random bijection $\pi:\mathcal{P}\to[0\mathinner{\ldotp\ldotp}|\mathcal{P}|)$ and set $\mathsf{id}(j)=\pi(\mathsf{P})$ if $j\in\mathsf{P}$. However, this time we draw $\pi$ uniformly at random only among bijections such that if $\mathsf{P}\subseteq\mathsf{B}$ and $\mathsf{P}^{\prime}\cap\mathsf{B}=\emptyset$ for classes $\mathsf{P},\mathsf{P}^{\prime}\in\mathcal{P}$, then $\pi(\mathsf{P})<\pi(\mathsf{P}^{\prime})$. (Note that each class in $\mathcal{P}$ is either contained in $\mathsf{B}$ or is disjoint with this set.)

Consider a position $i$. Observe that if $[i\mathinner{\ldotp\ldotp}i+\tau]\cap\mathsf{B}\neq\emptyset$, then $i\in\mathsf{S}$ holds only if $i\in\mathsf{B}$ or $i+\tau\in\mathsf{B}$. Hence, the number of such positions $i\in\mathsf{S}$ is at most $2|\mathsf{B}|\leq\frac{12n}{\tau}$. Otherwise, Fact 8.7 implies that $[i\mathinner{\ldotp\ldotp}i+\tau]\subseteq\mathsf{Q}$ or $[i\mathinner{\ldotp\ldotp}i+\tau]\cap\mathsf{Q}=\emptyset$. In the former case, we are guaranteed that $i\notin\mathsf{S}$ by Construction 8.1. On the other hand, $\mathbb{P}[i\in\mathsf{S}]\leq\frac{6}{\tau}$ holds in the latter case as in the proof of Fact 8.4 since $[i\mathinner{\ldotp\ldotp}i+\tau]\setminus\mathsf{Q}=[i\mathinner{\ldotp\ldotp}i+\tau]$ is of size $\tau+1$. By linearity of expectation, the expected number of such positions $i\in\mathsf{S}$ is up to $\frac{6n}{\tau}$.

We conclude that $\mathbb{E}[|\mathsf{S}|]\leq\frac{12n}{\tau}+\frac{6n}{\tau}=\frac{18n}{\tau}$. In particular, $|\mathsf{S}|\leq\frac{18n}{\tau}$ holds for some identifier function $\mathsf{id}$. ∎

8.2.3 Deterministic Construction

Our adaptation of the deterministic construction uses Facts 8.7 and 8.8 in a similar way. As in the proof of Proposition 8.5, we gradually construct $\mathsf{id}$ handling one partition class $\mathsf{P}\in\mathcal{P}$ at a time. We start with classes contained in $\mathsf{B}$ (in an arbitrary order), then we process classes contained in $\mathsf{Q}$ (still in an arbitrary order). In the final third phase, we choose the subsequent classes disjoint with $\mathsf{B}\cup\mathsf{Q}$ according to their scores.

Proposition 8.10**.**

Given a text $T\in[0\mathinner{\ldotp\ldotp}\sigma)^{n}$ for $\sigma=n^{\mathcal{O}(1)}$ and a positive integer $\tau\leq\frac{1}{2}n$, in $\mathcal{O}(n)$ time one can construct a $\tau$-synchronizing set of size at most $\frac{30n}{\tau}$.

Proof.

First, we build the partition $\mathcal{P}$ as in the proof of Proposition 8.5. Next, we construct $\mathsf{Q},\mathsf{B}\subseteq[1\mathinner{\ldotp\ldotp}n-\tau+1]$ using Lemma 8.8 and identify each class $\mathsf{P}\in\mathcal{P}$ as contained in $\mathsf{B}$, contained in $\mathsf{Q}$, or disjoint with $\mathsf{B}\cup\mathsf{Q}$.

We start the iterative construction of an identifier function $\mathsf{id}$ by initializing a table $\mathsf{id}[1\mathinner{\ldotp\ldotp}n-\tau+1]$ with markers $\bot$ representing undefined values. In the first two phases, we process the classes contained in $\mathsf{B}$ and $\mathsf{Q}$, respectively, assigning them initial subsequent identifiers and setting $\mathsf{id}[j]=k$ for the $k$th class $\mathsf{P}_{k}\in\mathcal{P}$ considered.

Before moving on to classes disjoint with $\mathsf{B}\cup\mathsf{Q}$, we compute the auxiliary components required for the scoring function (defined exactly as in the proof of Proposition 8.5). For this, we scan the table $\mathsf{id}$ to identify active blocks and assign scores to active positions, maintaining the aggregate score of each class $\mathsf{P}\in\mathcal{P}$ and the collection $\mathcal{P}^{+}$ of unprocessed classes with non-negative score. The total running time up to this point is clearly $\mathcal{O}(n)$.

The subsequent classes $\mathsf{P}_{k}$ are processed exactly as in the proof of Proposition 8.5: we choose the class $\mathsf{P}_{k}$ from $\mathcal{P}^{+}$ and set $\mathsf{id}[j]=k$ for each $j\in\mathsf{P}_{k}$, updating the active positions, scores, aggregate scores, and $\mathcal{P}^{+}$ accordingly. The running time of a single iteration is still $\mathcal{O}(|\mathsf{P}_{k}|+\tau|\mathsf{A}_{k}|)$, where $\mathsf{A}_{k}\subseteq\mathsf{P}_{k}$ consists of positions active prior to processing $\mathsf{P}_{k}$. The original argument from the proof of Proposition 8.5 still shows that $\sum_{k}|\mathsf{A}_{k}|\leq\frac{9n}{\tau}$ (this is because $\mathsf{A}_{k}\setminus\mathsf{Q}=\emptyset$ for each $k$), so the running time of the third phase is $\mathcal{O}(\sum_{k}|\mathsf{P}_{k}|+\tau\sum_{k}|\mathsf{A}_{k}|)=\mathcal{O}(n)$.

Finally, we build the synchronizing set $\mathsf{S}$ according to Construction 8.1 using the sliding-window approach from the proof of Proposition 8.5. The only difference is that we have to ignore identifiers $\mathsf{id}[j]$ of positions $j\in\mathsf{Q}$ while computing the sliding-window minima.

It remains to bounds to size of the set $\mathsf{S}$ constructed this way. For this, we shall prove that if $i\in\mathsf{S}$, then $i$ or $i+\tau$ belongs to $\mathsf{B}\cup\bigcup_{k}\mathsf{A}_{k}$, from which we conclude the desired bound: $|\mathsf{S}|\leq 2|\mathsf{B}|+2\sum_{k}|\mathsf{A}_{k}|\leq\frac{12n}{\tau}+\frac{18n}{\tau}$.

Hence, let us consider a position $i\in\mathsf{S}$ and recall that $\min\{\mathsf{id}[j]:j\in[i\mathinner{\ldotp\ldotp}i+\tau]\setminus\mathsf{Q}\}\in\{\mathsf{id}[i],\mathsf{id}[i+\tau]\}$ by Construction 8.1. Since we processed the classes contained in $\mathsf{B}$ first, if $[i\mathinner{\ldotp\ldotp}i+\tau]\cap\mathsf{B}\neq\emptyset$, then the minimum on the left-hand side is attained by $\mathsf{id}[j]$ with $j\in\mathsf{B}$. Consequently, $i\in\mathsf{B}$ or $i+\tau\in\mathsf{B}$, consistently with the claim.

Otherwise, Fact 8.7 yields that $[i\mathinner{\ldotp\ldotp}i+\tau]\cap\mathsf{Q}=\emptyset$ or $[i\mathinner{\ldotp\ldotp}i+\tau]\subseteq\mathsf{Q}$, with the latter case infeasible due to $i\in\mathsf{S}$. Consequently, $[i\mathinner{\ldotp\ldotp}i+\tau]\setminus\mathsf{Q}=[i\mathinner{\ldotp\ldotp}i+\tau]$ and we observe that $k=\min\mathsf{id}[i\mathinner{\ldotp\ldotp}i+\tau]$ satisfies $k\in\{\mathsf{id}[i],\mathsf{id}[i+\tau]\}$. Hence, we had $\mathsf{id}[j]=\bot$ for $j\in[i\mathinner{\ldotp\ldotp}i+\tau]$ prior to processing the class $\mathsf{P}_{k}$. This class is disjoint with $\mathsf{B}\cup\mathsf{Q}$ and each of these positions $j$ was active at that point. In particular, $i$ and $i+\tau$ were active, so $i\in\mathsf{A}_{k}$ or $i+\tau\in\mathsf{A}_{k}$, consistently with the claim.

This completes the characterization of positions $i\in\mathsf{S}$ resulting in $|\mathsf{S}|\leq\frac{30n}{\tau}$. ∎

8.2.4 Efficient Implementation for Small $\tau$

We conclude by noting that the procedure of Proposition 8.10 can be implemented in $\mathcal{O}(\frac{n}{\tau})$ time for $\tau<\varepsilon\log_{\sigma}n$ just as we implemented the procedure of Proposition 8.5 to prove Proposition 8.6. The only observation needed to make this seamless adaptation is that we can check in \mathcal{O}\big{(}\tau^{\mathcal{O}(1)}\big{)} time whether a given position belongs to $\mathsf{Q}$ or $\mathsf{B}$. In particular, we have sufficient time to perform these two checks for every position contained in a representative block or its context.

Theorem 8.11**.**

For every constant $\varepsilon<\frac{1}{5}$, given the packed representation of a text $T\in[0\mathinner{\ldotp\ldotp}\sigma)^{n}$ and a positive integer $\tau\leq\varepsilon\log_{\sigma}n$, one can construct in $\mathcal{O}(\frac{n}{\tau})$ time a $\tau$-synchronizing set of size $\mathcal{O}(\frac{n}{\tau})$.