Re-Pair was first introduced by NJ. Larsson and A. Moffat^[1] in 1999.

In their paper the algorithm is presented together with a detailed description of the data structures required to implement it with linear time and space complexity. The experiments showed that Re-Pair achieves high compression ratios and offers good performance for decompression. However, the major drawback of the algorithm is its memory consumption, which is approximately 5 times the size of the input. Such memory usage is required in order to perform the compression in linear time but makes the algorithm impractical for compressing large files.

The image on the right shows how the algorithm works compresses the string ${\displaystyle w=xabcabcy123123zabc}$ .

During the first iteration, the pair ${\displaystyle ab}$ , which occurs three times in ${\displaystyle w}$ , is replaced by a new symbol ${\displaystyle R_{1}}$ . On the second iteration, the most frequent pair in the string ${\displaystyle w=xR_{1}cR_{1}cy123123zR_{1}c}$ , which is ${\displaystyle R_{1}c}$ , is replaced by a new symbol ${\displaystyle R_{2}}$ . Thus, at the end of the second iteration, the remaining string is ${\displaystyle w=xR_{2}R_{2}y123123zR_{2}}$ . In the next two iterations, the pairs ${\displaystyle 12}$  and ${\displaystyle R_{3}3}$  are replaced by symbols ${\displaystyle R_{3}}$  and ${\displaystyle R_{4}}$  respectively. Finally, the string ${\displaystyle w=xR_{2}R_{2}yR_{4}R_{4}zR_{2}}$  contains no repeated pair and therefore it is used as the axiom of the output grammar.

In order to achieve linear time complexity, Re-Pair requires the following data structures

• A sequence representing the input string. Position ${\displaystyle i}$  of the sequence contains the i-th symbol of the input string plus two references to other positions in the sequence. These references point to the next/previous positions, say ${\displaystyle k}$  and ${\displaystyle m}$ , such that the same substring begins at ${\displaystyle w[i]}$ , ${\displaystyle w[k]}$  and ${\displaystyle w[m]}$  and all three occurrences are captured by the same reference (i.e. there is a variable in the grammar generating the string).
• A priority queue. Each element of the queue is a pair of symbols (terminals or previously defined pairs) that occur consecutively in the sequence. The priority of a pair is given by the number of occurrences of the pair in the remaining sequence. Each time a new pair is created, the priority queue is updated.
• A hash table to keep track of already defined pairs. This table is updated each time a new pair is created or removed.

Since the hash table and the priority queue refer to the same elements (pairs), they can be implemented by a common data structure called PAIR with pointers for the hash table (h_next) and the priority queue (p_next and p_prev). Furthermore, each PAIR points to the beginning of the first (f_pos) and the last (b_pos) occurrences of the string represented by the PAIR in the sequence. The following picture shows an overview of this data structure.

The following two pictures show an example of how these data structures look after the initialization and after applying one step of the pairing process (pointers to NULL are not displayed):

Encoding the grammar edit

Once the grammar has been built for a given input string, in order to achieve effective compression, this grammar has to be encoded efficiently. One of the simplest methods for encoding the grammar is the implicit encoding, which consists on invoking function encodeCFG(X), described below, sequentially on all the axiom's symbols. Intuitively, rules are encoded as they are visited in a depth-first traversal of the grammar. The first time a rule is visited, its right hand side is encoded recursively and a new code is assigned to the rule. From that point, whenever the rule is reached, the assigned value is written.

num_rules_encoded = 256 // By default, the extended ASCII charset are the terminals of the grammar.

writeSymbol(symbol s) {
  bitslen = log(num_rules_encoded); // Initially 8, to describe any extended ASCII character
  write s in binary using bitslen bits
}

void encodeCFG_rec(symbol s) {
  if (s is non-terminal and this is the first time symbol s appears) {
  	take rule s → X Y;
    write bit 1;
    encodeCFG_rec(X);
    encodeCFG_rec(Y);
    assign to symbol s value ++num_rules_encoded;
  } else {
    write bit 0;
    writeSymbol(terminal/value assigned)
  }
}

void encodeCFG(symbol s) {
  encodeCFG_rec(s);
  write bit 1;
}

Another possibility is to separate the rules of the grammar into generations such that a rule ${\displaystyle X\to YZ}$  belongs to generation ${\displaystyle i}$  iff at least one of ${\displaystyle Y}$  or ${\displaystyle Z}$  belongs to generation ${\displaystyle i-1}$  and the other belongs to generation ${\displaystyle j}$  with ${\displaystyle j\leq i-1}$ . Then these generations are encoded subsequently starting from generation ${\displaystyle 0}$ . This was the method proposed originally when Re-Pair was first introduced. However, most implementations of Re-Pair use the implicit encoding method due to its simplicity and good performance. Furthermore, it allows on-the-fly decompression.

There exists a number of different implementations of Re-Pair. Each of these versions aims at improving one specific aspect of the algorithm, such as reducing the runtime, reducing the space consumption or increasing the compression ratio.

• Byte pair encoding
• Sequitur algorithm