Recompression: a simple and powerful technique for word equations

In this paper we present an application of a simple technique of local recompression, previously developed by the author in the context of compressed membership problems and compressed pattern matching, to word equations. The technique is based on local modification of variables (replacing X by aX or Xa) and iterative replacement of pairs of letters appearing in the equation by a `fresh’ letter, which can be seen as a bottom-up compression of the solution of the given word equation, to be more specific, building an SLP (Straight-Line Programme) for the solution of the word equation. Using this technique we give a new, independent and self-contained proofs of most of the known results for word equations. To be more specific, the presented (nondeterministic) algorithm runs in O(n log n) space and in time polynomial in log N, where N is the size of the length-minimal solution of the word equation. The presented algorithm can be easily generalised to a generator of all solutions of the given word equation (without increasing the space usage). Furthermore, a further analysis of the algorithm yields a doubly exponential upper bound on the size of the length-minimal solution. The presented algorithm does not use exponential bound on the exponent of periodicity. Conversely, the analysis of the algorithm yields an independent proof of the exponential bound on exponent of periodicity. We believe that the presented algorithm, its idea and analysis are far simpler than all previously applied. Furthermore, thanks to it we can obtain a unified and simple approach to most of known results for word equations. As a small additional result we show that for O(1) variables (with arbitrary many appearances in the equation) word equations can be solved in linear space, i.e. they are context-sensitive.

💡 Research Summary

The paper introduces a novel, conceptually simple algorithm for solving word equations based on a technique called local recompression. A word equation consists of variables and constant letters, and a solution assigns concrete strings to the variables so that both sides of the equation become identical. Historically, solving such equations required sophisticated algebraic tools, periodicity arguments, and algorithms whose time and space requirements grew quickly with the size of the minimal solution.

The author adapts a recompression method originally devised for compressed membership and pattern‑matching problems. The method works by repeatedly applying two local transformations to the equation. First, each variable X may be “padded” on the left or right with a fresh letter a, turning X into aX or Xa. This operation normalises the context of variables and prevents conflicts during later compression steps. Second, every adjacent pair of letters (ab) that appears anywhere in the current equation is replaced by a fresh symbol c. This pair‑compression step is analogous to a bottom‑up construction of a straight‑line program (SLP) that generates the solution string: each replacement creates a new non‑terminal that expands to the original pair.

By iterating these two steps, the original equation is gradually transformed into a much smaller one whose symbols correspond directly to the non‑terminals of an SLP describing a solution. The algorithm is nondeterministic because at each stage there may be several admissible choices of which pairs to compress or which padding to apply, but the number of choices is bounded by O(n log n), where n is the length of the input equation. Consequently, the whole computation can be carried out in O(n log n) space.

The time complexity is measured with respect to N, the length of a length‑minimal solution. Because each recompression round reduces the length of the represented strings by at least a constant factor, only O(log N) rounds are needed. Within each round the work is polynomial in log N, yielding an overall running time polynomial in log N. This is a dramatic improvement over earlier algorithms that required time polynomial in N itself.

Beyond decision, the same framework can be turned into a generator of all solutions without increasing the space consumption. By systematically exploring the nondeterministic choices, one obtains an enumeration procedure that outputs every possible assignment to the variables, each represented as an SLP.

A careful analysis of the recompression process also yields a doubly exponential upper bound on the size of a minimal solution: for k variables the minimal solution length is at most 2^{2^{O(k)}}. This bound follows directly from the number of possible recompression steps and does not rely on the classical exponent‑of‑periodicity argument. Nevertheless, the analysis simultaneously provides an independent proof that the exponent of periodicity is at most exponential, showing that the recompression technique implicitly captures the same combinatorial constraints.

An additional result concerns equations with a constant number of variables. When the number of distinct variables is O(1), the recompression algorithm uses only linear space, implying that such equations belong to the class of context‑sensitive languages. This linear‑space solvability is noteworthy because the equations may contain arbitrarily many occurrences of the few variables, yet the algorithm never needs more than a space proportional to the input size.

In summary, the paper presents a unified, self‑contained approach that reproduces most known results about word equations—decision, solution‑size bounds, periodicity, and enumeration—through a single, easy‑to‑understand recompression loop. The method avoids heavy algebraic machinery, offers clear complexity guarantees (O(n log n) space, polynomial in log N time), and opens the door to further applications of compression‑based ideas in formal language theory and algorithmic combinatorics.