Approximation ratio of RePair∗
Danny Hucke1 , Artur Jeż2 , and Markus Lohrey1
1

arXiv:1703.06061v1 [] 17 Mar 2017

2

University of Siegen, Germany
University of Wroclaw, Poland

Abstract
In a seminal paper of Charikar et al. on the smallest grammar problem,
the authors derive upper and lower bounds on the approximation ratios for
several grammar-based compressors. Here
√ we improve the lower bound for
the famous RePair algorithm from Ω( log n) to Ω(log n/ log log n). The
family of words used in our proof is defined over a binary alphabet, while
the lower bound from Charikar et al. needs an alphabet of logarithmic
size in the length of the provided words.

1

Introduction

The idea of grammar-based compression is based on the fact that in many cases
a word w can be succinctly represented by a context-free grammar that produces
exactly w. Such a grammar is called a straight-line program (SLP) for w. In the
best case, one gets an SLP of size O(log n) for a word of length n, where the size
of an SLP is the total length of all right-hand sides of the rules of the grammar.
A grammar-based compressor is an algorithm that produces for a given word w
an SLP A for w, where, of course, A should be smaller than w. Grammar-based
compressors can be found at many places in the literature. Probably the best
known example is the classical LZ78-compressor of Lempel and Ziv [18]. Indeed,
it is straightforward to transform the LZ78-representation of a word w into an
SLP for w. Other well-known grammar-based compressors are BISECTION [12],
SEQUITUR [16], and RePair [13], just to mention a few.
One of the first appearances of straight-line programs in the literature are
[1, 5], where they are called word chains (since they generalize addition chains
from numbers to words). In [1], Berstel and Brlek prove that the function
g(k, n) = max{g(w) | w ∈ {1, . . . , k}n }, where g(w) is the size of a smallest SLP
for the word w, is in Θ(n/ logk n). Note that g(k, n) measures the worst case
SLP-compression over all words of length n over a k-letter alphabet. The first
systematic investigations of grammar-based compressors are [3, 11]. Whereas in
[11], grammar-based compressors are used for universal lossless compression (in
the information-theoretic sense), Charikar et al. study in [3] the worst case approximation ratio of grammar-based compressors. For a given grammar-based
compressor C that computes from a given word w an SLP C(w) for w one defines the approximation ratio of C on w as the quotient of the size of C(w) and
∗ The

second and third author were supported by the DFG research grant LO 748/10-1.

1

the size g(w) of a smallest SLP for w. The approximation ratio αC (n) is the
maximal approximation ratio of C among all words of length n over any alphabet. In [3] the authors compute upper and lower bounds for the approximation
ratios of several grammar-based compressors (among them are the compressors
mentioned above). The contribution
of this paper is the improvement of the
√
lower bound for RePair from Ω( log n) to Ω(log n/ log log n). While in [3] the
lower bound needs an unbounded alphabet (the alphabet grows logarithmically
in the length of the presented words) our family of words is defined over a binary
alphabet.
RePair works by repeatedly searching for a digram d (a string of length two)
with the maximal number of non-overlapping occurrences in the current text
and replacing all these occurrences by a new nonterminal A. Moreover, the rule
A → d is added to the grammar. RePair is one of the so-called global grammarbased compressor from [3] for which the approximation ratio seems to be very
hard to analyze. Charikar et al. prove
 for all global grammar-based compressors
an upper bound of O (n/ log n)2/3 for the approximation ratio. Note that the
gap to our improved lower bound Ω(log n/ log log n) is still large.
Related work. The theoretically best known grammar-based compressors
with a polynomial (in fact, linear) running time achieve an approximation ratio
of O(log n) [3, 9, 10, 17]. In [8], the precise (up to constant factors) approximation ration for BISECTION (resp., LZ78) was shown to be Θ((n/ log n)1/2 )
(resp., Θ((n/ log n)2/3 )). In [15] the authors prove that RePair combined with
a simple binary encoding of the grammar compresses every word w over an alphabet of size σ to at most 2Hk (w) + o(|w| log σ) bits, for any k = o(logσ |w|),
where Hk (w) is the k-th order entropy of w.
There is also a bunch of papers with practical applications for RePair: web
graph compression [4], bit maps [14], compressed suffix trees [7]. Some practical
improvements of RePair can be found in [6].

2

Preliminaries

Let [1, k] = {1, . . . , k}. Let w = a1 · · · an (a1 , . . . , an ∈ Σ) be a word or string
over a finite alphabet Σ. The length |w| of w is n and we denote by ε the word
of length 0. We define w[i] = ai for 1 ≤ i ≤ |w| and w[i : j] = ai · · · aj for
1 ≤ i ≤ j ≤ |w|. Let Σ+ = Σ∗ \ {ε} be the set of nonempty words. For w ∈ Σ+ ,
we call v ∈ Σ+ a factor of w if there exist x, y ∈ Σ∗ such that w = xvy. If x = ε,
∗
then
Qn we call v a prefix of w. For words w1 , . . . , wn ∈ Σ , we further denote by
i=j wi the word wj wj+1 · · · wn if j ≤ n and ε otherwise.
A straight-line program, briefly SLP, is a context-free grammar that produces
a single word w ∈ Σ+ . Formally, it is a tuple A = (N, Σ, P, S), where N is a
finite set of nonterminals with N ∩ Σ = ∅, S ∈ N is the start nonterminal,
and P is a finite set of productions (or rules) of the form A → w for A ∈ N ,
w ∈ (N ∪ Σ)+ such that:
• For every A ∈ N , there exists exactly one production of the form A → w,
and
• the binary relation {(A, B) ∈ N × N | (A → w) ∈ P, B occurs in w} is
acyclic.
2

Every nonterminal A ∈ N produces a unique string valA (A) ∈ Σ+ . The string
defined by A is val(A) = valA (S). We omit theP
subscript A when it is clear
from the context. The size of the SLP A is |A| = (A→w)∈P |w|. We denote by
g(w) the size of a smallest SLP producing the word w ∈ Σ+ . We will use the
following lemma:
Lemma 1 ([3, Lemma 3]). A string w contains at most g(w) · k distinct factors
of length k.
A grammar-based compressor C is an algorithm that computes for a nonempty
word w an SLP C(w) such that val(C(w)) = w. The approximation ratio αC (w)
of C for an input w is defined as |C(w)|/g(w). The worst-case approximation
ratio αC (k, n) of C is the maximal approximation ratio over all words of length
n over an alphabet of size k:
αC (k, n) = max{αC (w) | w ∈ [1, k]n } = max{|C(w)|/g(w) | w ∈ [1, k]n }
If the alphabet size is unbounded, i.e., if we allow alphabets of size |w|, then we
write αC (n) instead of αC (n, n).

3

RePair

For a given SLP A = (N, Σ, P, S), a word γ ∈ (N ∪ Σ)+ is called a maximal
string of A if
• |γ| ≥ 2,
• γ appears at least twice without overlap in the right-hand sides of A,
• and no strictly longer word appears at least as many times on the ridehand sides of A without overlap.
A global grammar-based compressor starts on input w with the SLP A =
({S}, Σ, {S → w}, S). In each round, the algorithm selects a maximal string
γ of A and updates A by replacing a largest set of a pairwise non-overlapping
occurrences of γ in A by a fresh nonterminal X. Additionally, the algorithm introduces the rule X → γ. The algorithm stops when no maximal string occurs.
The global grammar-based compressor RePair [13] selects in each round a most
frequent maximal string. Note that the replacement is not unique, e.g. the word
a5 with the maximal string γ = aa yields SLPs with rules S → XXa, X → aa
or S → XaX, X → aa or S → aXX, X → aa. We assume the first variant in
this paper, i.e. maximal strings are replaced from left to right.
The above description of RePair is taken from [3]. In most papers on RePair
the algorithm works slightly different: It replaces in each step a digram (a string
of length two) with the maximal number of pairwise non-overlapping occurrences
in the right-hand sides. For example, for the string w = abcabc this produces the
SLP S → BB, B → Ac, A → ab, whereas the RePair-variant from [3] produces
the smaller SLP S → AA, A → abc.
The following lower and upper bounds on the approximation ratio of RePair
were shown in [3]:

√
• αRePair (n) ∈ Ω log n
3

• αRePair (2, n) ∈ O (n/ log n)2/3



The proof of the lower bound in [3] assumes an alphabet of unbounded size.
√ To
be more accurate, the authors construct for every k a word wk of length Θ( k2k )
over and alphabet of size Θ(k) such that g(w) ∈ O(k) and RePair produces a
grammar of size Ω(k 3/2 ) for wk . We will improve this lower bound using only a
binary alphabet. To do so, we first need to know how RePair compresses unary
words.
Example 1 (unary inputs). RePair produces on input a27 the SLP with rules
X1 → aa, X2 → X1 X1 , X3 → X2 X2 and S → X3 X3 X3 X1 a, where S is the
start nonterminal. For the input a22 only the start rule S → X3 X3 X2 X1 is
different.
In general, RePair creates on unary input am (m ≥ 4) the rules X1 → aa,
Xi → Xi−1 Xi−1 for 2 ≤ i ≤ ⌊log m⌋ − 1 and a start rule, which is strongly
related to the binary representation of m since each nonterminal Xi produces
i
the word a2 . To be more accurate, let b⌊log m⌋ b⌊log m⌋−1 · · · b1 b0 be the binary
representation of m and define the mappings fi (i ≥ 0) by:
• f0 : {0, 1} → {a, ε} with f0 (1) = a and f0 (0) = ε,
• fi : {0, 1} → {Xi , ε} with fi (1) = Xi and fi (0) = ε for i ≥ 1.
Then the start rule produced by RePair on input am is
S → X⌊log m⌋−1 X⌊log m⌋−1 f⌊log m⌋−1 (b⌊log m⌋−1 ) · · · f1 (b1 )f0 (b0 ).
This means that the symbol a only occurs in the start rule if b0 = 1, and the
nonterminal Xi (1 ≤ i ≤ ⌊log m⌋ − 2) occurs in the start rule if and only if
bi = 1. Since RePair only replaces words with at least two occurrences, the most
significant bit b⌊log m⌋ = 1 is represented by X⌊log m⌋−1 X⌊log m⌋−1 . Note that for
1 ≤ m ≤ 3, RePair produces the trivial SLP S → am .

4

Main result

The main result of this paper states:
Theorem 1. αRePair (2, n) ∈ Ω (log n/ log log n)
Proof. We start with a binary De-Bruijn sequence B⌈log k⌉ ∈ {0, 1}∗ of length
2⌈log k⌉ such that each factor of length ⌈log k⌉ occurs at most once [2]. We have
k ≤ |B⌈log k⌉ | < 2k. Note that De-Bruijn sequences are not unique, so without
loss of generality let us fix a De-Bruijn sequence which starts with 1 for the
remaining proof. We define a homomorphism h : {0, 1}∗ → {0, 1}∗ by h(0) = 01
and h(1) = 10. The words wk of length 2k are defined as
wk = h(B⌈log k⌉ [1 : k]).
For example for k = 4 we can take B2 = 1100, which yields w4 = 10100101. We
will analyze the approximation ratio of RePair for the binary words
sk =

k−1
Y


awk [1:k+i] b awk = awk [1:k+1] bawk [1:k+2] b . . . awk [1:2k−1] bawk ,

i=1

4

where the prefixes wk [1 : k + i] for 1 ≤ i ≤ k are interpreted as binary numbers.
For example we have s4 = a20 ba41 ba82 ba165 .
k+i−1
Since B⌈log k⌉ [1] = wk [1] = 1,
≤ awk [1:k+i] ≤ 2k+i − 1 for
 we have 2
k
1 ≤ i ≤ k and thus |sk | ∈ Θ 4 .
Claim 1. A smallest SLP producing sk has size O(k).

There is an SLP A of size O(k) for the first a-block awk [1:k+1] of length Θ(2k ).
Let A be the start nonterminal of A. For the second a-block awk [1:k+2] we only
need one additional rule: If wk [k + 2] = 0, then we can produce awk [1:k+2] by
the fresh nonterminal B using the rule B → AA. Otherwise, if wk [k + 2] = 1,
then we use B → AAa. The iteration of that process yields for each a-block
only one additional rule of size at most 3. If we replace the a-blocks in sk by
nonterminals as described, then the resulting word has size 2k + 1 and hence
g(sk ) ∈ O(k).
Claim 2. The SLP produced by RePair on input sk has size Ω(k 2 / log k).

On unary inputs of length m, the start rule produced by RePair is strongly
related to the binary encoding of m as described above. On input sk , the
algorithm starts to produce a start rule which is similarly related to the binary
words wk [1 : k + i] for 1 ≤ i ≤ k. Consider the SLP G which is produced by
RePair after (k − 1) rounds on input sk . We claim that up to this point RePair
is not affected by the b’s in sk and therefore has introduced the rules X1 → aa
and Xi → Xi−1 Xi−1 for 2 ≤ i ≤ k − 1. If this is true, then the start rule after
k − 1 rounds begins with
S → Xk−1 Xk−1 fk−1 (wk [2])fk−2 (wk [3]) · · · f0 (wk [k + 1])b · · ·
where f0 (1) = a, f0 (0) = ε and fi (1) = Xi , fi (0) = ε for i ≥ 1. All other
a-blocks are longer than the first one, hence each factor of the start rule which
corresponds to an a-block begins with Xk−1 Xk−1 . Therefore, the number of
occurrences of Xk−1 Xk−1 in the SLP is at least k. Since the symbol b occurs
only k − 1 times in sk , it follows that our assumption is correct and RePair is
not affected by the b’s in the first (k − 1) rounds on input sk . Also, for each
block awk [1:k+i] , the k − 1 least significant bits of wk [1 : k + i] (1 ≤ i ≤ k) are
represented in the corresponding factor of the start rule of G, i.e., the start rule
contains non-overlapping factors vi with
vi = fk−2 (wk [i + 2])fk−3 (wk [i + 3]) . . . f1 (wk [k + i − 1])f0 (wk [k + i])

(1)

for 1 ≤ i ≤ k. For example after 3 rounds on input s4 = a20 ba41 ba82 ba165 , we
have the start rule
S → X3 X3 X2 b X35 a b X310 X1 b X320 X2 a,
| {z } |{z} | {z } | {z }
a20

a41

a82

a165

where v1 = X2 , v2 = a, v3 = X1 and v4 = X2 a. The length of the factor
vi ∈ {a, X1 , . . . , Xk−2 }∗ from equation (1) is exactly the number of 1’s in the
word wk [i + 2 : k + i]. Since wk is constructed by the homomorphism h, it is
easy to see that |vi | ≥ (k − 3)/2. Note that no letter occurs more than once
in vi , hence g(vi ) = |vi |. Further, each substring of length 2⌈log k⌉ + 2 occurs

5

at most once in v1 , . . . , vk , because otherwise there would be a factor of length
⌈log k⌉ occurring more than once in B⌈log k⌉ . It follows that there are at least
k · (⌈(k − 3)/2⌉ − 2⌈log k⌉ − 1) ∈ Θ(k 2 )
different factors of length 2⌈log k⌉ + 2 ∈ Θ(log k) in the right-hand side of the
start rule of G. By Lemma 1 it follows that a smallest SLP for the right-hand side
of the start rule has size Ω(k 2 / log k) and therefore |RePair(sk )| ∈ Ω(k 2 / log k).
In conclusion: We showed that a smallest SLP for sk has size O(k), while RePair
produces an SLP of size Ω(k 2 / log k). This implies αRePair (sk ) ∈ Ω(k/ log k),
which together with n = |sk | and k ∈ Θ(log n) finishes the proof.
Note that in the above prove, RePair chooses in the first k − 1 rounds a
digram for the replaced maximal string. Therefore, Theorem 1 also holds for
the RePair-variant, where in every round a digram (which is not necessarily a
maximal string) is replaced.

References
[1] J. Berstel and S. Brlek. On the length of word chains. Inf. Process. Lett.,
26(1):23–28, 1987.
[2] N. de Bruijn. A combinatorial problem. Nederl. Akad. Wet., Proc., 49:758–
764, 1946.
[3] M. Charikar, E. Lehman, A. Lehman, D. Liu, R. Panigrahy, M. Prabhakaran, A. Sahai, and A. Shelat. The smallest grammar problem. IEEE
Trans. Inf. Theory, 51(7):2554–2576, 2005.
[4] F. Claude and G. Navarro. Fast and compact web graph representations.
ACM Transactions on the Web, 4(4), 2010.
[5] A. A. Diwan. A new combinatorial complexity measure for languages. Tata
Institute, Bombay, India, 1986.
[6] M. Gańczorz and A. Jeż. Improvements on re-pair grammar compressor.
to appear in Proceedings of DCC 2017. IEEE Computer Society, 2017.
[7] R. González and G. Navarro. Compressed text indexes with fast locate.
In Proceedings of CPM 2007, volume 4580 of Lecture Notes in Computer
Science, pages 216–227. Springer, 2007.
[8] D. Hucke, M. Lohrey, and P. Reh. The smallest grammar problem revisited.
Proceedings of SPIRE 2016, LNCS 9954, pages 35–49. Springer 2017.
[9] A. Jeż. Approximation of grammar-based compression via recompression.
Theoretical Computer Science, 592:115–134, 2015.
[10] A. Jeż. A really simple approximation of smallest grammar. Theoretical
Computer Science, 616:141–150, 2016.
[11] J. C. Kieffer and E.-H. Yang. Grammar-based codes: A new class of universal lossless source codes. IEEE Trans. Inf. Theory, 46(3):737–754, 2000.
6

[12] J. C. Kieffer, E.-H. Yang, G. J. Nelson, and P. C. Cosman. Universal lossless
compression via multilevel pattern matching. IEEE Trans. Inf. Theory,
46(4):1227–1245, 2000.
[13] N. J. Larsson and A. Moffat. Offline dictionary-based compression. Proceedings of DCC 1999, pages 296–305. IEEE Computer Society, 1999.
[14] G. Navarro, S. J. Puglisi, and D. Valenzuela. Practical compressed document retrieval. In Proceedings of SEA 2011, volume 6630 of Lecture Notes
in Computer Science, pages 193–205. Springer, 2011.
[15] G. Navarro and L. M. S. Russo. Re-pair achieves high-order entropy. In
Proceedings of DCC 2008, page 537. IEEE Computer Society, 2008.
[16] C. G. Nevill-Manning and I. H. Witten. Identifying hierarchical structure
in sequences: A linear-time algorithm. J. Artif. Intell. Res., 7:67–82, 1997.
[17] W. Rytter. Application of Lempel-Ziv factorization to the approximation
of grammar-based compression. Theor. Comput. Sci., 302(1–3):211–222,
2003.
[18] J. Ziv and A. Lempel. Compression of individual sequences via variable-rate
coding. IEEE Trans. Inf. Theory, 24(5):530–536, 1977.

7

