Abstract 1 Introduction 2 Preliminaries 3 Additive Sensitivity of RLBWT Variants to Reverse 4 Sensitivity of the Lempel-Ziv Parsing 5 Sensitivity of the Smallest Lexicographic Parsing 6 Conclusions References Appendix A Glossary of Repetitiveness Measures in Table 1

Sensitivity of Repetitiveness Measures to String Reversal

Hideo Bannai ORCID M&D Data Science Center, Institute of Integrated Research, Institute of Science Tokyo, Japan    Yuto Fujie ORCID Joint Graduate School of Mathematics for Innovation, Kyushu University, Fukouka, Japan    Peaker Guo ORCID M&D Data Science Center, Institute of Integrated Research, Institute of Science Tokyo, Japan    Shunsuke Inenaga ORCID Department of Informatics, Kyushu University, Fukouka, Japan    Yuto Nakashima ORCID Department of Informatics, Kyushu University, Fukouka, Japan    Simon J. Puglisi ORCID Department of Computer Science, University of Helsinki, Finland    Cristian Urbina ORCID Faculty of Mathematics, Informatics and Mechanics, University of Warsaw, Poland
Center for Biotechnology and Bioengineering (CeBiB), Santiago, Chile
Abstract

We study the impact that string reversal can have on several repetitiveness measures. First, we exhibit an infinite family of strings where the number, r, of runs in the run-length encoding of the Burrows–Wheeler transform (BWT) can increase additively by Θ(n) when reversing the string. This substantially improves the known Ω(logn) lower-bound for the additive sensitivity of r and it is asymptotically tight. We generalize our result to other variants of the BWT, including the variant with an appended end-of-string symbol and the bijective BWT. We show that an analogous result holds for the size z of the Lempel–Ziv 77 (LZ) parsing of the text, and also for some of its variants, including the non-overlapping LZ parsing, and the LZ-end parsing. Moreover, we describe a family of strings for which the ratio z(wR)/z(w) approaches 3 from below as |w|. We also show an asymptotically tight lower-bound of Θ(n) for the additive sensitivity of the size v of the smallest lexicographic parsing to string reversal. Finally, we show that the multiplicative sensitivity of v to reversing the string is Θ(logn), and this lower-bound is also tight. Overall, our results expose the limitations of repetitiveness measures that are widely used in practice, against string reversal – a simple and natural data transformation.

Keywords and phrases:
String reversal, Repetitiveness measures, Burrows–Wheeler transform, Lempel–Ziv parsing, Lexicographic parsings
Funding:
Hideo Bannai: JSPS KAKENHI Grant Number JP24K02899.
Shunsuke Inenaga: JSPS KAKENHI Grant Numbers JP23K24808 and 23K18466.
Yuto Nakashima: JSPS KAKENHI Grant Number JP25K00136.
Cristian Urbina: Polish National Science Center, grant no. 2022/46/E/ST6/00463; Basal Funds FB0001 and AFB240001, ANID, Chile; and FONDECYT Project 1-230755, ANID, Chile.
Copyright and License:
[Uncaptioned image] © Hideo Bannai, Yuto Fujie, Peaker Guo, Shunsuke Inenaga, Yuto Nakashima, Simon J. Puglisi, and Cristian Urbina; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Data compression
; Mathematics of computing Combinatorics on words
Related Version:
Full Version: https://arxiv.org/abs/2602.14385
Acknowledgements:
The authors thank Gonzalo Navarro for their helpful comments and discussion.
Editors:
Philip Bille and Nicola Prezza

1 Introduction

In many fields of science and industry, there exist huge data collections. Many of these collections are highly repetitive, in the sense that the documents that make them up are highly similar to each other. Examples include the 1000 Human Genomes Project [8] in bioinformatics and the Software Heritage Repository [11]. Repetitiveness measures [32] were introduced to quantify the degree of compressibility of highly repetitive string collections, as other standard techniques based on Shannon’s entropy fail to capture repetitiveness [26].

Some repetitiveness measures abstract the output size of existing compressors, like the size z of the Lempel-Ziv 77 parsing (LZ) [29], the size g of the smallest straight-line program (SLP) generating the string [24], and the number r of equal-symbol runs in the Burrows–Wheeler Transform (BWT) [6]. Other measures are based purely on combinatorial properties of the strings, like the substring complexity δ [40] and the size γ of the smallest string attractor [21].

A fundamental question in this context is what makes a repetitiveness measure μ(w) better than another. One important aspect is reachability: whether it is possible to represent all strings within O(μ(w)) space. Another important aspect is space efficiency: assuming that μ is reachable, how small μ(w) can be on highly repetitive strings. There is also indexability: what queries on the uncompressed string can be answered efficiently using O(μ) space.

Recently, another aspect of repetitiveness measures, which we call robustness, has gained attention. A measure is robust against a string operation if it does not increase much after applying that operation to any string. We are interested in quantifying how much a given measure can increase after applying a string operation in worst-case scenarios. This quantity is called sensitivity [1]. Questions about the sensitivity of a measure are especially important in dynamic domains where the data can change over time, and finding answers to them can be useful, for instance, to understand how to update the measure after applying such a string operation. Akagi et al. [1] studied how much repetitiveness measures can change after applying to the string single character edit operations. There are many other works dealing with similar problems for different combinations of string operation and repetitiveness measures [5, 9, 10, 12, 15, 16, 18, 31, 35, 36, 37, 38].

In this work we focus on studying the fundamental string reversal operation, which takes a string w[1]w[n] and outputs the string w[n]w[1]. We first review known results on the impact of string reversal on repetitiveness measures, and then present our contributions. Table 1 summarizes both the prior results and our contributions.

On the one hand, there are measures of repetitiveness that are fully symmetric, that is, reversing the string does not change the value of the measure at all. This is a desirable property, as arguably, mirroring the string does not change its intrinsic repetitiveness. This class includes the measures δ and γ, the size ν of the smallest NU-system [38], the size b of the smallest bidirectional macro scheme [42]; and the size g,grl,git and c of the smallest straight-line program, run-length straight-line program [39], iterated straight-line program [35], and collage-system [23], respectively. A weaker version of symmetry is exhibited by the size χ of the smallest suffixient set, for which it was recently proved that χ(wR)/χ(w)2 [37], though χ(wR)χ(w) can be as large as Ω(n) [37].

At the other extreme, there are measures widely used in practice – such as the number r of runs in the RLBWT – that are very sensitive to reversal. Giuliani et al. [15] showed that in an infinite family of words, after reversing the string, the measure r can increase from O(1) to Ω(logn). An equivalent result was obtained by Biagi et al. [5] regarding the number rB of runs in the run-length Bijective Burrows-Wheeler Transform (BBWT) [14, 4]. Moreover, the size e of the compact directed acyclic word graph (CDAWG) of a string can increase by a Ω(n) multiplicative factor when reversing the string [17]. For the additive case, the increase can be up to Ω(n); this proof is deferred to the full version.

For some other measures, not much is known. For LZ parsing and some of its variants, it has been conjectured that even though the number of phrases of the parses can change after reversing the string, the ratio z(wR)/z(w) is bounded by a constant. For the size v of the lex-parse of the string, the conjecture is the opposite, namely that v(wR)/v(w) can be ω(1).

In this context, our contributions are as follows:

  1. 1.

    In Section 3, we show that the number r (resp. rB) of runs of the RLBWT (resp. RLBBWT) can increase by Θ(n) after reversing the string. This improves the currently known Ω(logn) lower bound for the additive increase on these measures under string reversal [5, 15].

  2. 2.

    In Section 4, we show that the number z (resp. zno, resp. ze) of phrases of the Lempel-Ziv parsing (resp. LZ without overlaps, resp. LZ-end) can increase by Θ(n) when applying the reverse operation. This improves the currently known Ω(n) lower bound for the additive increase on z [9]. Moreover, we show a family where z(wR)/z(w) approaches 3 as |w| goes to infinity.

  3. 3.

    Finally, in Section 5, we show that the number v of phrases in the lex-parse of a string can grow by a Ω(logn) multiplicative factor after applying the reverse operation, and this is asymptotically tight. Moreover, we show a string family where after reversing the string, the additive increase on the measure v is Θ(n).

We conclude in Section 6 with conclusions and future directions for research.

Table 1: Summary of the best known bounds on the multiplicative and additive sensitivity of repetitiveness measures to string reversal. While the upper-bounds hold for all strings, the lower-bounds hold for specific infinite string families. We mark results obtained in this work with . See Table 2 in the appendix for a glossary of the measures listed in this table.
Measure MS lower-bound MS upper-bound AS lower-bound AS upper-bound
r,r$ Ω(logn) [15], O(log2n) [41, 19] Ω(n) O(n)
rB Ω(logn) [5] O(log3n) Ω(n) O(n)
z,zno 3o(1) O(logn) Ω(n) O(n)
zend,ze 1 O(logn),O(log2n) Ω(n) O(n)
v Ω(logn) O(logn) Ω(n) O(n)
χ 4/3 [37] 2 [37] Ω(n) [37] O(n)
e Ω(n) [17] O(n) [17] Ω(n) O(n)
δ,γ,ν,b,c,git,grl,g 1 1 0 0

2 Preliminaries

We denote [i,j]={i,i+1,,j} if ij, and otherwise. An ordered alphabet Σ={a1,a2,,aσ} is a finite set of symbols equipped with an order relation < such that a1<a2<<aσ. A string w[1n]=w[1]w[n] is a finite sequence of symbols in Σ. The length of w is denoted by |w|=n. The unique string of length 0, called the empty string, is denoted by ε. The set of all strings is Σ, and we let Σ+=Σ{ε}.

For strings x=x[1]x[n] and y=y[1]y[m], their concatenation is xyxy=x[1]x[n]y[1]y[m]. By i=1kwi we denote the concatenation of the strings w1,w2,,wk in that order. We also let wk=i=1kw. For a string w, a sequence of non-empty strings (xk)k=1m=(x1,,xm) is referred to as a factorization (or parsing) of w if w=i=1mxi; each xk is called a phrase (or factor). The run-length encoding of a string w is 𝚛𝚕𝚎(w)=(a1,p1),,(am,pm) where aiai+1 for i[1,m1], pi1 for all i, and w=i=1maipi. For a string w=xyz, the string x (resp. y, resp. z) is called a prefix (resp. substring, resp. suffix) of w. A substring (resp. prefix, resp. suffix) is proper if it is different from w, and non-trivial if in addition it is different from ε. We use the notation w[ij] to denote the string w[i]w[j] when 1ijn and ε otherwise. We denote Sw(k) the set of substrings of length k appearing in w.

The lexicographic order on Σ is defined recursively by ε<x for every xΣ+, and for a,bΣ and u,vΣ, by au<bv if either a<b, or a=b and u<v. The ω-order is defined as x<ωy iff xω<yω, where xω is the infinite periodic string with period x.

The suffix array (SA) of a string w of length n is an array 𝑆𝐴[1n] such that 𝑆𝐴[i] is the starting position of the ith lexicographically smallest suffix of w. The inverse suffix array (ISA) of w is the array 𝐼𝑆𝐴[1n] defined by 𝐼𝑆𝐴[𝑆𝐴[i]]=i for i[1,n]. The longest common prefix array (LCP) of w is an array 𝐿𝐶𝑃[1n] where 𝐿𝐶𝑃[i] stores the length of the longest common prefix of the suffixes w[𝑆𝐴[i1]n] and w[𝑆𝐴[i]n] for i[2,n], and 𝐿𝐶𝑃[1]=0.

A rotation of w[1n] is any string of the form w[in]w[1i1] for i[1,n]. Let (w)={w1,w2,,wn} be the lexicographically sorted multiset of rotations of w. The Burrows-Wheeler transform (BWT) of w is the string 𝙱𝚆𝚃(w)=w1[n]w2[n]wn[n]. Moreover, let 𝙱𝚆𝚃x(w) denote the substring of 𝙱𝚆𝚃(w) induced by the rotations having string x as a prefix. That is, let [𝑙𝑏,𝑢𝑏] be the maximal range such that wi[1|x|]=x for all i[𝑙𝑏,𝑢𝑏]; then 𝙱𝚆𝚃x(w)=w𝑙𝑏[n]w𝑢𝑏[n]. The BWT-matrix of w is a 2D array containing in the ith row the rotation wi for i[1,n]; its last column coincides with 𝙱𝚆𝚃(w).

A Lyndon word is any string w that is smaller than any of its other rotations, or alternatively, smaller than any of its proper suffixes. The Lyndon factorization of a string w is the unique sequence 𝙻𝙵(w)=x1,,x satisfying that w=i=1xi, each xi is Lyndon, and xixi+1 for i[1,1].

2.1 Repetitiveness Measures

We explain the repetitiveness measures relevant to our work. For an in-depth overview on repetitiveness measures, see Navarro’s survey [32, 33]. We start by introducing two measures that act as lower-bounds for the other measures considered in this work. One is the substring complexity δ of a string w [25, 40], defined as δ(w)=maxk[1,|w|]|Sw(k)|/k. The other one is γ [21], which we do not explain here, as we only use a few known results on this measure.

A popular measure of repetitiveness is the size of the run-length encoding of the BWT (RLBWT) of a string. The BWT is known for its indexing functionality [13] and indexing-related applications in Bioinformatics [27, 28, 30].

Definition 1.

We denote r(w)=|𝚛𝚕𝚎(𝙱𝚆𝚃(w))|.

Sometimes, a $-symbol, smaller than any other symbol of w, is assumed to appear at the end. We denote this variant r$(w)=|𝚛𝚕𝚎(𝙱𝚆𝚃(w$))|.

The Bijective Burrows–Wheeler Transform (BBWT) of w, denoted 𝙱𝙱𝚆𝚃(w), is obtained by considering the rotations of all the factors in the Lyndon factorization 𝙻𝙵(w), then sorting them in ω-order, and finally concatenating their last characters. By taking the run-length encoding of the BBWT (RLBBWT) we obtain the following repetitiveness measure.

Definition 2.

We denote rB(w)=|𝚛𝚕𝚎(𝙱𝙱𝚆𝚃(w))|.

Example 3.

Let w=𝚋𝚊𝚊𝚋𝚊𝚊𝚋𝚊. Then, 𝙻𝙵(w)=𝚋,𝚊𝚊𝚋,𝚊𝚊𝚋,𝚊. We sort the rotations of 𝚋, 𝚊𝚊𝚋 (two times), and 𝚊, in ω-order and take their last characters:

𝚊<ω𝚊𝚊𝚋ω𝚊𝚊𝚋<ω𝚊𝚋𝚊ω𝚊𝚋𝚊<ω𝚋𝚊𝚊ω𝚋𝚊𝚊<ω𝚋.

In this case, 𝙱𝙱𝚆𝚃(w)=𝚊𝚋𝚋𝚊𝚊𝚊𝚊𝚋, 𝚛𝚕𝚎(𝙱𝙱𝚆𝚃(w))=(𝚊,1),(𝚋,2),(𝚊,4),(𝚋,1), and rB(w)=4. It can be verified that 𝙱𝚆𝚃(w)=𝚋𝚋𝚋𝚊𝚊𝚊𝚊𝚊 and r(w)=2.

The following measure is known for being one of the smallest reachable measures in terms of space, that is also computable in linear time [29].

Definition 4.

The Lempel-Ziv parse of a string w is a factorization of w into phrases 𝙻𝚉(w)=x1,,xz such that, for each 1jz, phrase xj is the longest prefix of xjxz with another occurrence in w starting at position i|x1x2xj1|; if no such prefix exists, then xj is the first occurrence of some character and |xj|=1.

We consider some variants of the Lempel-Ziv parsing and the measure z. The zno variant additionally requires that the source of any phrase must not overlap the phrase. The ze variant requires that the source of any phrase must have an occurrence aligned with the end of a previous phrase. While z and zno are greedy and optimal among parses satisfying their respective conditions, ze is greedy, but not optimal: there can be other parsings smaller than ze such that each phrase has its source starting to its left and is aligned with a previous phrase. We denote zend the actual smallest of these parsings.

The last measure we consider is based on another type of ordered parsings [34]. In the Lempel-Ziv parse, the source of a phrase appears before the phrase in w, in left-to-right order. In lexicographic parsings [34], the suffix starting at a given phrase must be greater than the suffix starting at its source, in lexicographic order. The size of left-to-right greedy version of this parsing is optimal, and is also considered a measure of repetitiveness.

Definition 5.

The lex-parse of a string w is a factorization of w into phrases 𝙻𝙴𝚇(w)=x1,,xv, such that, for each 1jv, phrase xj has starting position i=1+t<j|xt| and length max{1,𝐿𝐶𝑃[i]}, where i=𝐼𝑆𝐴[i].

Example 6.

Consider the string w=𝚊𝚋𝚛𝚊𝚌𝚊𝚍𝚊𝚋𝚛𝚊𝚌𝚊𝚋𝚛𝚊. Its Lempel-Ziv parse is 𝙻𝚉(w)=(𝚊,𝚋,𝚛,𝚊,𝚌,𝚊,𝚍,𝚊𝚋𝚛𝚊𝚌𝚊,𝚋𝚛𝚊). Its lex-parse is 𝙻𝙴𝚇(w)=(𝚊𝚋𝚛𝚊𝚌𝚊,𝚍,𝚊𝚋𝚛𝚊,𝚌,𝚊,𝚋,𝚛,𝚊). Thus, z(w)=9 and v(w)=8.

We remark that although the lex-parse can be computed from its definition in a left-to-right fashion, the source of each phrase can appear either to its left or to its right in w.

2.2 Reverse Operation and Its Impact on Repetitiveness Measures

The reverse of a string w=w[1]w[2]w[n] is the string wR=w[n]w[2]w[1]. In what follows, we analyze the additive and multiplicative increase that reversing the string can have on the values of various measures. We consider worst-case scenarios, and we refer to those increases as additive sensitivity and multiplicative sensitivity of a measure to the reverse operation. When considering upper-bounds for the sensitivity of a measure, we need them to hold for all strings. Lower-bounds generally hold for a specific infinite string family. Some measures, such as δ and γ, are invariant to string reversal. We focus on those that are not.

One of the repetitiveness measures for which the sensitivity to reverse has been studied is z. Constantinescu [9] showed that z can increase by Ω(n) when reversing the string. It is also conjectured that z(wR)/z(w)=O(1). For the upper-bound, it is known that γzznozend=O(γlogn) [33], and γ is invariant upon reversal, hence, for z,zno, and zend, the multiplicative sensitivity is O(logn). Recently, Kempa and Saha proved that ze=O(δlog2n) [22], and δ is invariant to reversals, hence, the multiplicative sensitivity of ze is O(log2n).

Giuliani et al. [15] showed that r(wR)/r(w)=Ω(logn). Specifically, they describe a family where r(w)=O(1) and r(wR)=Θ(logn), hence, in this family also holds r(wR)r(w)=Ω(logn). This result can be extended to r$ (see the full version). Kempa and Kociumaka [19] showed that r$=O(δlog2(n)), and because r$=Ω(δ) and δ is invariant to reversals, it follows that r$(wR)/r$(w)=O(log2n). This result was also extended to r [41].

Recently, Biagi et al. [5] showed a family where rB(w)=O(1) and rB(wR)=Θ(logn). For an upper-bound, we can obtain a weaker version of the upper-bound for r: because rB=Ω(δ), z=O(δlogn), and rB=O(zlog2n) [2], it follows that rB(wR)/rB(w)=O(log3n).

Regarding lexicographic parsings, it can be derived from the relation δv=O(δlogn) and the fact that δ is invariant upon reversal, that v(wR)/v(w)=O(logn) [25, 34].

3 Additive Sensitivity of RLBWT Variants to Reverse

In this section, we show that under string reversal, the additive sensitivity of r, r$, and rB are all Ω(n). This substantially improves the previous Ω(logn) lower-bounds on the additive sensitivity, which can be derived from the results of Giuliani et al. [15] and Biagi et al. [5] on the multiplicative sensitivity of r and rB.

In the following proofs, we rely on an infinite family of strings defined as follows.

Definition 7 (uk).

Let Σ={𝚊,𝚋}i[1,k]{#i,&i} such that

#1<&1<#2<&2<<#k<&k<𝚊<𝚋.

Define uk=i=1k𝚋𝚊#i𝚊&i. It holds that |uk|=5k.

3.1 Additive Sensitivity of 𝒓 and 𝒓$

We first fully characterize the BWT of strings uk and their reverse ukR. Then, we count the number of BWT-runs they have and how they differ. Figure 1 gives an example for u3.

Figure 1: Illustration of Lemma 8, Lemma 9, and Proposition 11 on u3=𝚋𝚊#1𝚊&1𝚋𝚊#2𝚊&2𝚋𝚊#3𝚊&3. The BWT matrices of relevant strings are illustrated, with the prefixes of the rotations shown alongside the BWTs. The changes caused by appending $ are highlighted in blue. (The orange dots on the left illustrate the proof of Lemma 13).
Lemma 8.

𝙱𝚆𝚃(uk)=𝚊2k(i=1k𝚋#i)&k(i=1k1&i) and r(uk)=3k+1.

Proof.

We characterize the BWT of uk and count its number of runs. Observe that in uk, the rotations starting with the symbols #i and &i for i[1,k] are always preceded by 𝚊. The rotations starting with 𝚋’s are sorted according to the following symbols 𝚊#i (or equivalently, according to their starting position within uk, from left to right), and preceded by &i1 for i>1, and by &k in the case of i=1 (i.e., 𝚋𝚊#1&k). The rotations starting with 𝚊 are sorted according to their following symbol #i or &i (or equivalently, according to their starting position within uk, from left to right), and preceded in an alternating fashion by 𝚋, #1, 𝚋, #2, …, 𝚋, #k. Hence, we can partition the BWT of uk in the following disjoint ranges:

  1. (1)

    𝙱𝚆𝚃#i(uk)=𝚊 and 𝙱𝚆𝚃&i(uk)=𝚊 for i[1,k].

  2. (2)

    𝙱𝚆𝚃𝚊(uk)=i=1k𝚋#i.

  3. (3)

    𝙱𝚆𝚃𝚋(uk)=&k(i=1k1&i).

Though interleaved, the ranges in (1) yield a prefix of the BWT of uk of length 2k formed by only 𝚊’s. Thus, 𝙱𝚆𝚃(uk)=𝚊2k(i=1k𝚋#i)&k(i=1k1&i) and r(uk)=3k+1.

Lemma 9.

𝙱𝚆𝚃(ukR)=(𝚊𝚋)k(i=1k&i)(i=2k#i)#1𝚊k and r(ukR)=4k+1.

Proof.

First observe that ukR=j=0k1&kj𝚊#kj𝚊𝚋, and in the following, we have i=kj. We characterize the BWT of ukR and count its number of runs. Observe that just as for uk, in ukR the rotations starting with #i for i[1,k] are always preceded by 𝚊. On the other hand, the rotations starting with &i are always preceded by 𝚋. The rotations starting with 𝚋’s are always preceded by 𝚊. The rotations starting with 𝚊#i for i[1,k] are sorted according to #i (or equivalently, according to their starting positions within ukR from right to left), and preceded by &1,…, &k. The rotations starting with 𝚊𝚋 are sorted according to their following symbol &i, and preceded by #i+1 when i<k and #1 when i=k. Hence, we can partition the BWT of ukR in the following disjoint ranges.

  1. (1)

    𝙱𝚆𝚃#i(ukR)=𝚊 and 𝙱𝚆𝚃&i(ukR)=𝚋 for i[1,k].

  2. (2)

    𝙱𝚆𝚃𝚊#i(ukR)=&i for i[1,k].

  3. (3)

    𝙱𝚆𝚃𝚊𝚋(ukR)=(i=2k#i)#1.

  4. (4)

    𝙱𝚆𝚃𝚋(ukR)=𝚊k.

The interleaved ranges in (1) yield a prefix of the BWT of ukR of the form (𝚊𝚋)k. Thus, 𝙱𝚆𝚃(ukR)=(𝚊𝚋)k(i=1k&i)(i=2k#i)#1𝚊k and r(ukR)=4k+1.

Recall that |uk|=5k. By Lemma 8 and Lemma 9 we derive the following result.

Proposition 10.

There exists an infinite string family where r(wR)r(w)=n/5=Θ(n).

For the r$ variant, we observe that the BWT of uk does not change much after appending a $ at its end, because the relative order among all rotations of uk$ is decided before comparing against the $ (except for $uk). In the case of ukR, the two rotations of ukR starting with 𝚊𝚋&k and 𝚋&k are changed so they start with 𝚊𝚋$ and 𝚋$, respectively. For both r$(uk) and r$(ukR), the number of runs increases by exactly one. The differences in their BWTs with respect to the version without the $ are highlighted in Figure 1. We obtain the following.

Proposition 11.

There exists a string family where r$(wR)r$(w)=n/5=Θ(n).

3.2 Additive Sensitivity of 𝒓𝑩

We first characterize the Lyndon factorization of uk and ukR.

Lemma 12.

𝙻𝙵(uk)=(𝚋,𝚊,#1𝚊&1i=2k𝚋𝚊#i𝚊&i) and 𝙻𝙵(ukR)=(&kj𝚊,#kj𝚊𝚋)j=0k1.

Proof.

Let uk=#1𝚊&1i=2k𝚋𝚊#i𝚊&i, then uk=𝚋𝚊uk. First, 𝚋 and 𝚊 are trivially Lyndon. Next, uk is Lyndon because it begins with #1, which is the unique smallest symbol occurring in uk. Since 𝚋>𝚊>uk, it follows that the Lyndon factorization of uk is (𝚋,𝚊,uk).

Now consider ukR=j=0k1(&kj𝚊)(#kj𝚊𝚋). For each j[0,k1], &kj𝚊 is Lyndon because &kj<𝚊, and #kj𝚊𝚋 is Lyndon because #kj is its unique smallest symbol. Further, for each j[0,k2], we have &kj𝚊>#kj𝚊𝚋>&kj1𝚊. Thus, the Lyndon factorization of ukR is (&kj𝚊,#kj𝚊𝚋)j=0k1=(&k𝚊,#k𝚊𝚋,&k1𝚊,#k1𝚊𝚋,,&1𝚊,#1𝚊𝚋).

Lemma 13.

𝙱𝙱𝚆𝚃(uk)=&k𝚊2k1#1(i=2k𝚋#i)𝚊(i=1k1&i)𝚋 and rB(uk)=3k+2.

Proof.

Let uk=#1𝚊&1i=2k𝚋𝚊#i𝚊&i, which is the third Lyndon factor of 𝙻𝙵(uk). We first determine 𝙱𝚆𝚃(uk). Compared with the BWT-matrix of uk (Lemma 8), removing the prefix 𝚋𝚊 affects only the following rows (illustrated on the left of Figure 1):

  • the rotation starting with 𝚋 and preceded by &k disappears;

  • the rotation starting with 𝚊#1 and preceded by 𝚋 disappears;

  • the rotation starting with #1 is now preceded by &k instead of 𝚊, but it is still the first rotation.

All remaining rotations keep both their preceding symbols and their relative order, because the order of all rotations of uk coincides with their suffix order. Hence,

𝙱𝚆𝚃(uk)=&k𝚊2k1#1(i=2k𝚋#i)(&1&k1).

Finally, we incorporate 𝚊 and 𝚋 into the ω-sorted rotations. The factor 𝚊 is ordered after the rotation 𝚊&k#k and before the first rotation beginning with 𝚊𝚋. The factor 𝚋 is larger than every rotation of every factor of uk in ω-order, so it appears last. Therefore, the desired results follow.

Lemma 14.

𝙱𝙱𝚆𝚃(ukR)=(𝚋𝚊)k(i=1k&i)(i=1k#i)𝚊k and rB(ukR)=4k+1

Proof.

By Lemma 12, we have 𝙻𝙵(ukR)=(&k𝚊,#k𝚊𝚋,&k1𝚊,#k1𝚊𝚋,,&1𝚊,#1𝚊𝚋). For each i[1,k], we sort the following rotations by ω-order: &i𝚊,𝚊&i,#i𝚊𝚋,𝚊𝚋#i,𝚋#i𝚊.

First, among the rotations beginning with #i or &i, the order is

#1𝚊𝚋<ω&1𝚊<ω#2𝚊𝚋<ω&2𝚊<ω<ω#k𝚊𝚋<ω&k𝚊.

Next, among the rotations beginning with 𝚊, every rotation of the form 𝚊&i precedes every rotation of the form 𝚊𝚋#j:

𝚊&1<ω𝚊&2<ω<ω𝚊&k<ω𝚊𝚋#1<ω𝚊𝚋#2<ω<ω𝚊𝚋#k.

Finally, all rotations beginning with 𝚋 come last, and among them we have

𝚋#1𝚊<ω𝚋#2𝚊<ω<ω𝚋#k𝚊.

Thus, the ω-sorted list of rotations becomes the following, with the last character of each rotation highlighted in blue:

((#i𝚊𝚋,&i𝚊)i=1k,(𝚊&i)i=1k,(𝚊𝚋#i)i=1k,(𝚋#i𝚊)i=1k)

Therefore, the desired results follow.

Recall that |uk|=5k. By Lemma 13 and Lemma 14 we derive the following result.

Proposition 15.

There exists a string family where rB(wR)rB(w)=n/51=Θ(n).

4 Sensitivity of the Lempel-Ziv Parsing

4.1 Multiplicative Sensitivity

Experimentation [20] suggests that the multiplicative sensitivity of the Lempel-Ziv parsing to the reverse operation is O(1), although the exact constant remains unclear. In [20], an essentially brute-force search over short strings revealed a binary string

T=𝚊𝚋𝚊𝚋𝚊𝚋𝚊𝚋𝚊𝚋𝚊𝚊𝚋𝚊𝚋𝚊𝚋𝚊𝚊𝚋𝚊𝚋𝚊𝚊𝚊𝚋𝚊𝚋𝚊𝚊𝚊𝚋𝚊𝚋𝚊𝚊𝚊𝚋𝚊𝚋𝚋𝚊𝚋𝚊𝚋𝚊𝚊𝚋𝚊𝚋𝚊𝚊𝚊𝚋𝚊

of length 55 with z(T)=14 and z(TR)=6.

We now show a family for which z(wR)/z(w) approaches 3 from below as |w|.

Definition 16 (Tp).

For p1, let Σ={x}i[1,p]{ai,bi}. For i[1,p], define Ai=aia1 and Bi=bib1. Then define 𝒜p=ApA1, and p=B1Bp. Next, let mp=|𝒜p|=|p|=p(p+1)/2, and for j[1,mp], define

Gj ={𝒜p[mpj+1mp]xp[1j+1]for 1jmp1,𝒜pxpfor j=mp.

Finally, we define Tp=j=1mpGj, noting that |Tp|Θ(p4).

For example, we illustrate T4 on the left of Figure 2.

Figure 2: Illustration of Tp=G1Gmp (left) and TpR=GmpRG1R (right) for p=4. Note that 𝒜4=a4a3a2a1a3a2a1a2a1a1, 4=b1b2b1b3b2b1b4b3b2b1, and m4=10. The colored boundaries illustrate Lemma 19 and Lemma 20.
Observation 17.

z(𝒜p)=z(p)=z(𝒜pR)=z(pR)=2p1.

Proof.

The Lempel-Ziv factorization of 𝒜p is

((apu)u=0p1,(Apv)v=1p1),

where (apu)u=0p1=(ap,,a1) and (Apv)v=1p1=(Ap1,,A1), which means z(𝒜p)=p+(p1)=2p1. The Lempel-Ziv factorization of p is

(b1,(bu+1,Bu)u=1p1)=(b1,b2,B1,b3,B2,,bp,Bp1),

so z(p)=1+2(p1)=2p1. We can similarly show that z(𝒜pR)=z(pR)=2p1.

Observation 18.

For any i,k[1,p], if biak occurs in Tp, then it occurs exactly once.

Proof.

Any occurrence of biak must be of the form Gj[|Gj|]Gj+1[1] for some j[1,mp1]. By construction, Gj[|Gj|] and Gj+1[1] correspond to the following two sequences, respectively:

((bvu+1)u=1v)v=2p =(b2,b1),(b3,b2,b1),(b4,b3,b2,b1),,(bp,bp1,,b1), and
((au)u=1v)v=2p =(a1,a2),(a1,a2,a3),(a1,a2,a3,a4),,(a1,a2,,ap).

Since for v[2,p] and u[1,v], each bvu+1au is unique, the desired result follows.

Lemma 19.

z(Tp)=3p2/2+3p/2.

Proof.

By Observation 18, the Lempel-Ziv factorization of Tp contains a phrase boundary between each consecutive Gj and Gj+1 (blue boundaries on the left of Figure 2).

We next examine the phrases inside each Gj for j[2,mp]. For s[2,p], let ms=i=1si. Then each j[2,mp] can be written as j=msd for some s[2,p] and d[0,s1]. Now, observe that, Gj yields the following phrases depending on d and j:

Gj yields {Gj[1sd],Gj[sd+1|Gj|1],Gj[|Gj|]if d>0,Gj[1],Gj[2|Gj|1],Gj[|Gj|]if d=0 and j<mp,Gj[1],Gj[2|Gj|]if d=0 and j=mp.

In Figure 2 (left), for each Gj, the first boundary is red when d>0 and green when d=0; the second boundary is shown in orange for j<mp.

Finally, since z(G1)=4, it follows that z(Tp)=4+3(mp2)+2=3p2/2+3p/2.

Lemma 20.

z(TpR)=p2/2+9p/22.

Proof.

First observe that, in Tp, each Gj occurs in Gk only when kj, and does not occur in any Gk with k<j. Consequently, in TpR=GmpRG1R, each GjR for j[1,mp1] has an occurrence in GkR for kj. Hence, by Observation 18, each GjR is parsed as a separate phrase in the Lempel-Ziv factorization of Gmp1RG1R (blue boundaries on the right of Figure 2). Further, since GmpR=(𝒜pxp)R, we have z(GmpR)=z(pRx𝒜pR)=(2p1)+1+(2p1)=4p1 by Observation 17. Therefore, z(TpR)=z(GmpR)+(mp1)=p2/2+9p/22.

Proposition 21.

There exists a string family where lim infnz(wR)/z(w)=3. The same result holds for zno.

In contrast, we do not obtain an analogous result for ze; exploring whether such a family exists for ze is left for future work. We also observe that both z(Tp) and z(TpR) are in O(|Tp|). Hence, the multiplicative sensitivity does not imply a linear additive sensitivity. To obtain a linear additive gap, we consider a different string family in the next subsection.

4.2 Additive Sensitivity

Constantinescu [9] showed that the size z of the Lempel-Ziv factorization of a string can increase by Ω(n) when reversing the string111This holds for an asymptotically equivalent LZ variant, which adds a trailing character at each phrase.. We improve this lower-bound to Ω(n), and show that this new result also holds for the sensitivity of the Lempel-Ziv parsing without overlaps and the Lempel-Ziv-end variants. The infinite family of strings that we rely on is defined as follows. (The same family will be reused in Section 5.2.)

Definition 22 (wσ).

Let σ2 be an even integer and Σ={a1,,aσ} such that a1<<aσ. We then define

wσ=(i=1σ1aiai+1)(i=1σai),

noting that n=|wσ|=3σ2.

Lemma 23.

Let σ2 be an even integer. Then, z(wσ)=2σ+σ/22.

Proof.

The Lempel-Ziv factorization of wσ is

((ai,ai+1)i=1σ1,(a2j1a2j)j=1σ/2),

where the first 2(σ1) phrases are (ai,ai+1)i=1σ1=(a1,a2,a2,a3,,aσ1,aσ), and the remaining σ/2 phrases are (a2j1a2j)j=1σ/2=(a1a2,a3a4,,aσ1aσ). Thus, z(wσ)=2σ+σ/22.

Lemma 24.

Let σ2 be an even integer. Then, z(wσR)=2σ1.

Proof.

First observe that wσR=(i=0σ1aσi)(i=0σ2aσiaσi1). Then, the Lempel-Ziv factorization of wσR is

((aσi)i=0σ1,(aσiaσi1)i=0σ2).

So we have z(wσR)=2σ1.

The next proposition follows from Lemma 23 and Lemma 24. The other Lempel-Ziv variants yield the exact same factorizations on wσ and wσR.

Proposition 25.

There exists an infinite string family where z(wR)z(w)=n+261=Θ(n). The same result holds for zno,ze and zend.

5 Sensitivity of the Smallest Lexicographic Parsing

5.1 Multiplicative Sensitivity

In this subsection we prove that, similarly to the RLBWT and its variants [5, 15], the size of the lex-parse of a string can increase by a logarithmic factor upon reversing the string. To prove this result, we rely on a family of words constructed from the Fibonacci words.

Definition 26 (Fk and Ck).

Let Fk denote the kth Fibonacci word where F1=𝚋, F2=𝚊, and Fk=Fk1Fk2 for each k3. We denote fk=|Fk| the lengths of these words. Moreover, we let Ck=Fk[1fk2] be the kth central word.

We summarize in the following lemma some known properties of Fibonacci words.

Lemma 27 ([15, 34]).

For each k6,

  1. (i)

    Ck is a palindrome.

  2. (ii)

    Ck=Fk2Fk3F3F2.

  3. (iii)

    𝚊Ck𝚋 is Lyndon.

  4. (iv)

    Fk2 occurs in Fk exactly three times, starting at positions 1, fk2+1, and fk1+1.

  5. (v)

    Fk=Ck{𝚊𝚋if k is odd,𝚋𝚊if k is even;Fk2Fk1=Ck{𝚋𝚊if k is odd,𝚊𝚋if k is even.

We also use the following well-known property of Lyndon words.

Lemma 28 ([7]).

Consider Lyndon words u and v such that u<v. Then, uv is Lyndon.

Figure 3: Illustration of Lemma 31. Top: several factorizations of w=FkR𝚌 for odd k. Bottom: the sorted suffixes of w (suffixes starting with 𝚊, 𝚋, and 𝚌 are shown in three colors on the left; the ordinals indicate the order of the six phrases in the lex-parse of w highlighted in gray).

The main result we prove in this section is the following.

Proposition 29.

There exists a string family where v(wR)/v(w)=Θ(logn).

This lower-bound is asymptotically tight, as in Section 2 we showed v(wR)/v(w)=O(logn). The string family for which this proposition holds is composed of the reverses of strings 𝚌Fk=𝚌Ck𝚊𝚋 for odd k. It is known that v=Θ(logn) on odd Fibonacci words Fk=Ck𝚊𝚋 [34], and prepending 𝚌 to this string only increases v by 1, as 𝚌 is a unique symbol that does not interfere with the relative order of the other suffixes of Fk.

Lemma 30.

For each odd k, it holds that v(𝚌Fk)=Θ(logn).

Therefore, it remains to prove that v=O(1) on the strings (𝚌Fk)R for odd k. Specifically, we show that v6 on these strings.

Lemma 31.

For each odd k9, v((𝚌Fk)R)=6.

Proof.

See Figure 3. Let w=(𝚌Fk)R=(𝚌Ck𝚊𝚋)R=𝚋𝚊Ck𝚌. First, since 𝚊Ck𝚋 is Lyndon by (iii) of Lemma 27, 𝚊Ck𝚋<Ck[j|Ck|]𝚋 holds for any j[1,|Ck|]. This implies that 𝚊Ck<Ck[j|Ck|] and 𝚊Ck𝚌<Ck[j|Ck|]𝚌. We infer that w[2|w|]=𝚊Ck𝚌 is the smallest suffix of w that begins with 𝚊. Further, we know that w[1|w|]=𝚋𝚊Ck𝚌 is the smallest suffix of w that begins with 𝚋. Thus, the first two phrases are 𝚋 and 𝚊, respectively.

We now prove that, starting at position 3 in w, the third phrase is Ck3. By repeatedly applying the definition Fk=Fk1Fk2, we have the following factorizations of Fk:

Fk=Fk2Fk3Fk3Fk4=Fk2Fk3Fk4Fk5Fk4=Fk2Fk2Fk5Fk4.

Since k is odd, by (v) of Lemma 27, Fk5Fk4=Ck3𝚊𝚋, so Fk=Fk2Fk2Ck3𝚊𝚋. By (i) of Lemma 27, Ck3 is a palindrome; it follows that FkR=𝚋𝚊Ck3Fk2RFk2R. Thus, in w=FkR𝚌, the factor immediately following the first occurrence of Ck3 is

Fk2RFk2R𝚌=𝚋𝚊Ck2𝚋𝚊Ck2𝚌.

In particular, by (iii) of Lemma 27, 𝚊Ck2𝚋 is Lyndon. From the first paragraph of this proof, we also have that 𝚊Ck2𝚌 is Lyndon. Since 𝚊Ck2𝚋<𝚊Ck2𝚌, Lemma 28 implies that 𝚊Ck2𝚋𝚊Ck2𝚌 is Lyndon. Hence, w[3|w|]=Ck3𝚋𝚊Ck2𝚋𝚊Ck2𝚌 is the smallest suffix of w that begins with Ck3𝚋. Next, we derive the following identities using (ii) and (v) of Lemma 27:

Ck3 =Fk5Fk6Fk7F3F2=Fk5Fk6Ck5=Fk4Ck5,
Fk2R =Fk4RFk3R=Fk4R𝚊𝚋Ck3,
Ck5Fk4R =Ck5𝚋𝚊Ck4=Fk5Ck4=Fk5Fk6F3F2=Ck3, and
Ck3Fk2R =Fk4Ck5Fk4R𝚊𝚋Ck3=Fk4Ck3𝚊𝚋Ck3.

These identities imply a factorization of w as 𝚋𝚊Fk4Ck3𝚊𝚋Ck3𝚋𝚊Ck2. Thus, there exists an occurrence of Ck3𝚊 in w, and the lexicographic predecessor of w[3|w|] is a suffix of w beginning with Ck3𝚊. Therefore, the longest common prefix between these two suffixes is Ck3, which is the third phrase.

By (iv) of Lemma 27, there are exactly three occurrences of Fk2R in FkR, each followed by 𝚊, 𝚋, 𝚌, and the last two of these occurrences are not the one followed by 𝚊, it follows that the next two phrases are both Fk2R. Finally, the last phrase is 𝚌, and therefore,

𝙻𝙴𝚇(w)=(𝚋,𝚊,Ck3,Fk2R,Fk2R,𝚌).

5.2 Additive Sensitivity

In this subsection we show that v has Θ(n) additive sensitivity to the reverse operation. For the lower bound instance, we use the string family defined in Definition 22.

Lemma 32.

v(wσ)=2σ+σ/22.

Proof.

Among the suffixes of wσ=a1a2a2a3aσ1aσa1aσ, we observe the following.

  • Two suffixes start with a1; in text position order, they start with a1a2a2 and a1a2a3.

  • For each i[2,σ2], three suffixes start with ai; in text position order, they start with aiaiai+1, aiai+1ai+1, and aiai+1ai+2.

  • Three suffixes start with aσ1; in text position order, they start with aσ1aσ1aσ, aσ1aσa1, and aσ1aσ.

  • Two suffixes start with aσ; in text position order, they start with aσa1 and aσ.

With these observations, and by inspecting the longest common prefixes of consecutive suffixes (see Figure 4), we obtain that

𝙻𝙴𝚇(wσ)=((ai,ai+1)i=1σ2,aσ1aσ,(a2j1a2j)j=1σ/21,aσ1,aσ),

where (ai,ai+1)i=1σ2=(a1,a2,,aσ2,aσ1) and (a2j1a2j)j=1σ/21=(a1a2,,aσ3aσ2). So we have v(wσ)=2(σ2)+1+(σ/21)+2=2σ+σ/22.

Figure 4: Illustration of Lemma 32 and Lemma 33: prefixes of sorted suffixes of wσ (left) and wσR (right). The ordinals indicate the order of the highlighted phrases for σ=6 where w6=a1a2a2a3a3a4a4a5a5a6a1a2a3a4a5a6.
Lemma 33.

v(wσR)=2σ1.

Proof.

By symmetric observations of the proof of Lemma 32, it can be verified that

𝙻𝙴𝚇(wσR)=((aσi)i=0σ3,a2a1,(aσiaσi1)i=0σ3,a2,a1),

where (aσi)i=0σ3=(aσ,,a3) and (aσiaσi1)i=0σ3=(aσaσ1,,a3a2). So we have v(wσR)=2(σ2)+3=2σ1.

Note that although z(wσ)=v(wσ) and z(wσR)=v(wσR), the factorizations are different.

Proposition 34.

There exists a string family where v(wR)v(w)=n+261=Θ(n).

6 Conclusions

We have presented several results on the sensitivity of repetitiveness measures to string reversal. We have described an infinite string family exhibiting a Θ(n) additive increase in the number r of BWT runs under reversal. We gave analogous results for the size of the Lempel-Ziv parse, and the lex-parse. We also described a string family where the Lempel-Ziv parse ratio z(wR)/z(w) can approach 3 when applying the reverse operation. Finally, we described a string family where the size v of the lex-parse can increase by an Ω(logn) factor after reversing the string, and this increase is asymptotically tight.

Many open problems remain in this general direction. Two central questions are whether z(wR)/z(w)=O(1) holds and whether r(wR)/r(w)=O(logn) holds. Another related direction is the asymptotic relation between z and v. While v=o(z) for even Fibonacci words, it is unknown if v=O(z) in general. If indeed z has O(1) multiplicative sensitivity against the reverse operation, as conjectured, this may offer further insight into understanding how z and v relate. Beyond these, several bounds for χ, e (as can be seen in Table 1), and other measures can be improved. It is worth noting that, although our lower bounds are asymptotically tight, determining the exact tight constants remains an interesting combinatorial question. There may also be conditional lower bounds worth exploring – for instance, as a function of the alphabet size. For an extended version of this paper, we also plan to explore the impact of string reversal on other variants of the Lempel-Ziv parsing, including the family of Lempel-Ziv height-bounded (LZHB) parsings [3].

Overall, our results elucidate the limitations of many repetitiveness measures with respect to string reversal. We hope this work brings renewed attention to this string operation and motivates progress on these long-standing questions.

References

  • [1] Tooru Akagi, Mitsuru Funakoshi, and Shunsuke Inenaga. Sensitivity of string compressors and repetitiveness measures. Information and Computation, 291:104999, 2023. doi:10.1016/j.ic.2022.104999.
  • [2] Golnaz Badkobeh, Hideo Bannai, and Dominik Köppl. Bijective BWT based compression schemes. In 31st International Symposium on String Processing and Information Retrieval (SPIRE 2024), volume 14899 of Lecture Notes in Computer Science (LNCS), pages 16–25. Springer, 2024. doi:10.1007/978-3-031-72200-4_2.
  • [3] Hideo Bannai, Mitsuru Funakoshi, Diptarama Hendrian, Myuji Matsuda, and Simon J. Puglisi. Height-Bounded Lempel-Ziv Encodings. In Proc. 32nd Annual European Symposium on Algorithms (ESA 2024), volume 308 of Leibniz International Proceedings in Informatics (LIPIcs), pages 18:1–18:18, Dagstuhl, Germany, 2024. Schloss Dagstuhl – Leibniz-Zentrum für Informatik. doi:10.4230/LIPIcs.ESA.2024.18.
  • [4] Hideo Bannai, Dominik Köppl, and Zsuzsanna Lipták. A survey of the Bijective Burrows-Wheeler transform. In Paolo Ferragina, Travis Gagie, and Gonzalo Navarro, editors, The Expanding World of Compressed Data: A Festschrift for Giovanni Manzini’s 60th Birthday, Manzini’s Festschrift, Venice, Italy, July 25, 2025, OASIcs, pages 2:1–2:26. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2025. doi:10.4230/OASIcs.MANZINI.2.
  • [5] Elena Biagi, Davide Cenzato, Zsuzsanna Lipták, and Giuseppe Romana. On the number of equal-letter runs of the bijective Burrows-Wheeler Transform. Theoretical Computer Science, 1027:115004, 2025. doi:10.1016/j.tcs.2024.115004.
  • [6] Michael Burrows and David Wheeler. A block sorting lossless data compression algorithm. Technical Report 124, Digital Equipment Corporation, 1994.
  • [7] Kuo Tsai Chen, Ralph H. Fox, and Roger C. Lyndon. Free differential calculus, IV. The quotient groups of the lower central series. Annals of Mathematics, 68(1):81–95, 1958.
  • [8] 1000 Genomes Project Consortium. A global reference for human genetic variation. Nature, 526(7571):68, 2015. doi:10.1038/nature15393.
  • [9] Sorin Constantinescu. On the complexity of strings. PhD thesis, University of Western Ontario, 2008.
  • [10] Sorin Constantinescu and Lucian Ilie. The Lempel-Ziv complexity of fixed points of morphisms. In Proc. 31st Mathematical Foundations of Computer Science (MFCS 2006), volume 4162 of Lecture Notes in Computer Science (LNCS), pages 280–291. Springer Berlin Heidelberg, 2006. doi:10.1007/11821069_25.
  • [11] Roberto Di Cosmo and Stefano Zacchiroli. Software heritage: Why and how to preserve software source code. In Proc. 14th International Conference on Digital Preservation, (iPRES 2017), 2017. URL: https://phaidra.univie.ac.at/o:931064.
  • [12] Gabriele Fici, Giuseppe Romana, Marinella Sciortino, and Cristian Urbina. Morphisms and BWT-run sensitivity. In 50th International Symposium on Mathematical Foundations of Computer Science (MFCS 2025), volume 345 of Leibniz International Proceedings in Informatics (LIPIcs), pages 49:1–49:18. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2025. doi:10.4230/LIPIcs.MFCS.2025.49.
  • [13] Travis Gagie, Gonzalo Navarro, and Nicola Prezza. Fully functional suffix trees and optimal text searching in BWT-runs bounded space. Journal of the ACM, 67(1):2:1–2:54, 2020. doi:10.1145/3375890.
  • [14] Joseph Yossi Gil and David Allen Scott. A bijective string sorting transform, 2012. arXiv:1201.3077.
  • [15] Sara Giuliani, Shunsuke Inenaga, Zsuzsanna Lipták, Nicola Prezza, Marinella Sciortino, and Anna Toffanello. Novel results on the number of runs of the Burrows-Wheeler-Transform. In Proc. 47th International Conference on Current Trends in Theory and Practice of Computer Science (SOFSEM 2021), volume 12607 of Lecture Notes in Computer Science (LNCS), pages 249–262. Springer, 2021. doi:10.1007/978-3-030-67731-2_18.
  • [16] Sara Giuliani, Shunsuke Inenaga, Zsuzsanna Lipták, Giuseppe Romana, Marinella Sciortino, and Cristian Urbina. Bit catastrophes for the Burrows-Wheeler Transform. Theory of Computing Systems, 69(2):19, 2025. doi:10.1007/s00224-024-10212-9.
  • [17] Shunsuke Inenaga and Dmitry Kosolobov. Relating left and right extensions of maximal repeats, 2024. doi:10.48550/arXiv.2410.15958.
  • [18] Hyodam Jeon and Dominik Köppl. Compression sensitivity of the Burrows–Wheeler Transform and its bijective variant. Mathematics, 13(7), 2025. doi:10.3390/math13071070.
  • [19] Dominik Kempa and Tomasz Kociumaka. Resolution of the Burrows-Wheeler Transform conjecture. Communications of the ACM, 65(6):91–98, 2022. doi:10.1145/3531445.
  • [20] Dominik Kempa, Juha Kärkkäinen, and Simon J. Puglisi, 2014. Unpublished.
  • [21] Dominik Kempa and Nicola Prezza. At the roots of dictionary compression: string attractors. In Proceedings of the 50th Annual ACM SIGACT Symposium on Theory of Computing (STOC 2018), pages 827–840. ACM, 2018. doi:10.1145/3188745.3188814.
  • [22] Dominik Kempa and Barna Saha. An upper bound and linear-space queries on the LZ-End parsing. In Proc. 33rd Annual ACM-SIAM Symposium on Discrete Algorithms (SODA 2022), pages 2847–2866, 2022. doi:10.1137/1.9781611977073.111.
  • [23] Takuya Kida, Tetsuya Matsumoto, Yusuke Shibata, Masayuki Takeda, Ayumi Shinohara, and Setsuo Arikawa. Collage system: a unifying framework for compressed pattern matching. Theoretical Computer Science, 298(1):253–272, 2003. doi:10.1016/S0304-3975(02)00426-7.
  • [24] John C. Kieffer and En-Hui Yang. Grammar-based codes: A new class of universal lossless source codes. IEEE Transactions on Information Theory, 46(3):737–754, 2000. doi:10.1109/18.841160.
  • [25] Tomasz Kociumaka, Gonzalo Navarro, and Nicola Prezza. Towards a definitive compressibility measure for repetitive sequences. IEEE Transactions on Information Theory, 69(4):2074–2092, 2023. doi:10.1109/TIT.2022.3224382.
  • [26] Sebastian Kreft and Gonzalo Navarro. On compressing and indexing repetitive sequences. Theoretical Computer Science, 483:115–133, 2013. doi:10.1016/j.tcs.2012.02.006.
  • [27] Tak Wah Lam, Ruiqiang Li, Alan Tam, Simon C. K. Wong, Edward Wu, and Siu-Ming Yiu. High throughput short read alignment via bi-directional BWT. In Proc. 3rd IEEE International Conference on Bioinformatics and Biomedicine (BIBM 2009), pages 31–36. IEEE Computer Society, 2009. doi:10.1109/BIBM.2009.42.
  • [28] Ben Langmead, Cole Trapnell, Mihai Pop, and Steven L Salzberg. Ultrafast and memory-efficient alignment of short DNA sequences to the human genome. Genome Biology, 10(3):R25, 2009. doi:10.1186/gb-2009-10-3-r25.
  • [29] Abraham Lempel and Jacob Ziv. On the complexity of finite sequences. IEEE Transactions on Information Theory, 22(1):75–81, 1976. doi:10.1109/TIT.1976.1055501.
  • [30] Heng Li and Richard Durbin. Fast and accurate long-read alignment with Burrows-Wheeler Transform. Bioinformatics, 26(5):589–595, 2010. doi:10.1093/bioinformatics/btp698.
  • [31] Yuto Nakashima, Dominik Köppl, Mitsuru Funakoshi, Shunsuke Inenaga, and Hideo Bannai. Edit and Alphabet-Ordering Sensitivity of Lex-Parse. In 49th International Symposium on Mathematical Foundations of Computer Science (MFCS 2024), volume 306 of Leibniz International Proceedings in Informatics (LIPIcs), pages 75:1–75:15. Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2024. doi:10.4230/LIPIcs.MFCS.2024.75.
  • [32] Gonzalo Navarro. Indexing highly repetitive string collections, part I: Repetitiveness measures. ACM Computing Surveys, 54(2):article 29, 2021. doi:10.1145/3434399.
  • [33] Gonzalo Navarro. Indexing highly repetitive string collections, 2022. arXiv:2004.02781.
  • [34] Gonzalo Navarro, Carlos Ochoa, and Nicola Prezza. On the approximation ratio of ordered parsings. IEEE Transactions on Information Theory, 67(2):1008–1026, 2021. doi:10.1109/TIT.2020.3042746.
  • [35] Gonzalo Navarro, Francisco Olivares, and Cristian Urbina. Generalized straight-line programs. Acta Informatica, 62(1):14, 2025. doi:10.1007/s00236-025-00481-3.
  • [36] Gonzalo Navarro, Giuseppe Romana, and Cristian Urbina. Smallest suffixient sets as a repetitiveness measure. In Proc. 32th International Symposium on String Processing and Information Retrieval (SPIRE 2025), volume 16073 of Lecture Notes in Computer Science (LNCS), pages 217–232. Springer, 2025. doi:10.1007/978-3-032-05228-5_18.
  • [37] Gonzalo Navarro, Giuseppe Romana, and Cristian Urbina. Smallest suffixient sets: Effectiveness, resilience, and calculation, 2025. arXiv:2506.05638.
  • [38] Gonzalo Navarro and Cristian Urbina. Repetitiveness measures based on string morphisms. Theoretical Computer Science, 1043:115259, 2025. doi:10.1016/j.tcs.2025.115259.
  • [39] Takaaki Nishimoto, Tomohiro I, Shunsuke Inenaga, Hideo Bannai, and Masayuki Takeda. Fully dynamic data structure for LCE queries in compressed space. In 41st International Symposium on Mathematical Foundations of Computer Science (MFCS 2016), volume 58 of Leibniz International Proceedings in Informatics (LIPIcs), pages 72:1–72:15, 2016. doi:10.4230/LIPIcs.MFCS.2016.72.
  • [40] Sofya Raskhodnikova, Dana Ron, Ronitt Rubinfeld, and Adam D. Smith. Sublinear algorithms for approximating string compressibility. Algorithmica, 65(3):685–709, 2013. doi:10.1007/S00453-012-9618-6.
  • [41] Giuseppe Romana. Repetitiveness Measures based on String Attractors and Burrows-Wheeler Transform: Properties and Applications. PhD thesis, Università degli Studi di Palermo, 2023.
  • [42] James A. Storer and Thomas G. Szymanski. Data compression via textual substitution. Journal of the ACM, 29(4):928–951, 1982. doi:10.1145/322344.322346.

Appendix A Glossary of Repetitiveness Measures in Table 1

Table 2: Glossary of the repetitiveness measures appearing in the first column of Table 1.
Symbol Meaning
r Number of runs in the run-length encoding of 𝙱𝚆𝚃(w).
r$ Number of runs in the run-length encoding of 𝙱𝚆𝚃(w$), where $ is an end-of-string symbol smaller than every symbol of w.
rB Number of runs in the run-length encoding of the bijective Burrows–Wheeler transform 𝙱𝙱𝚆𝚃(w).
z Number of phrases in the Lempel–Ziv parse of w.
zno Number of phrases in the non-overlapping Lempel–Ziv parse of w.
ze Number of phrases in the greedy LZ-End parse of w.
zend Minimum number of phrases in an LZ-End parse of w.
v Number of phrases in the lex-parse of w.
χ Size of the smallest suffixient set of w.
e Number of nodes plus edges in the compact directed acyclic word graph (CDAWG) of w.
δ Substring complexity of w, namely δ(w)=max1k|w||Sw(k)|/k, where Sw(k) is the set of distinct substrings of w of length k.
γ Size of the smallest string attractor of w.
ν Size of the smallest NU-system generating w.
b Minimum number of phrases in a bidirectional macro scheme for w.
c Size of the smallest collage system generating w.
g Size of the smallest straight-line program generating w.
grl Size of the smallest run-length straight-line program generating w.
git Size of the smallest iterated straight-line program generating w.