Modular Descriptions of Regular Functions

TL;DR

This paper explores different formal methods for describing string-to-string transformations, comparing automata-based operational approaches with more human-readable descriptions using basic transformations and combinators.

Contribution

It introduces a unified perspective on formal descriptions of string transformations, highlighting the advantages of human-friendly formalisms alongside automata-based models.

Findings

Automata-based descriptions enable direct implementation with deterministic input scanners.

Human-friendly descriptions simplify understanding and designing string transformations.

Combinators extend basic transformations to express complex string operations.

Abstract

We discuss various formalisms to describe string-to-string transformations. Many are based on automata and can be seen as operational descriptions, allowing direct implementations when the input scanner is deterministic. Alternatively, one may use more human friendly descriptions based on some simple basic transformations (e.g., copy, duplicate, erase, reverse) and various combinators such as function composition or extensions of regular operations.

Equations

$$f,g::=(u,v)\mid f+g\mid f\cdot g\mid f^{\ast }$$

$$\mathsf{exchange}:=\Big{(}\mathsf{erase}\cdot(\#\mid\varepsilon)\cdot\mathsf{copy})\Big{)}\odot\Big{(}\mathsf{copy}\cdot(\#\mid\varepsilon)\cdot\mathsf{erase}\Big{)}\,.$$

$$h:u_1\#u_2\#u_3\#\cdots u_n\#\mapsto u_2{u}_1\#u_3{u}_2\#\cdots u_n{u}_{n-1}\#$$

$$f:u_1\#u_2\#u_3\#\cdots u_n\#\mapsto u_1\#u_1\#u_2\#u_2\#u_3\#u_3\#\cdots u_n\#u_n\#$$

$$g:=\mathsf{erase}\cdot (\#\mid \epsilon )\cdot (\mathsf{exchange}\cdot (\#\mid \#){)}^{\ast }\cdot \mathsf{erase}\cdot (\#\mid \epsilon ).$$

$$f,g::={\color[rgb]{0,0,1}\mathsf{reverse}}\mid(u,v)\mid f+g\mid f\cdot g\mid f^{*}\mid{\color[rgb]{0,0,1}f\odot g}\mid{\color[rgb]{0,0,1}f\circ g}$$

$$f,g::={\color[rgb]{0,0,1}\mathsf{reverse}}\mid{\color[rgb]{0,0,1}\mathsf{duplicate}}\mid(u,v)\mid f+g\mid f\cdot g\mid f^{*}\mid{\color[rgb]{0,0,1}f\circ g}\,.$$

$$h:=\mathsf{erase}\cdot (\#\mid \epsilon )\cdot (f\circ (\mathsf{copy}\cdot (\#\mid \epsilon )\cdot \mathsf{copy}\cdot (\#\mid \epsilon )){)}^{\ast }\cdot \mathsf{erase}\cdot (\#\mid \epsilon ).$$

$$f,g::=(u,v)\mid f+g\mid f\cdot g\mid f^{*}\mid{\color[rgb]{0,0,1}f\odot g}\mid{\color[rgb]{0,0,1}f^{r\text{-}*}}\mid{\color[rgb]{0,0,1}[K,f]^{2+}}\mid{\color[rgb]{0,0,1}[K,f]^{r\text{-}2+}}\,.$$

Full text

123b\mid b$$\backslash\mid\backslash$$a\mid a$$\%\mid\varepsilon$$\backslash n\mid\backslash n$$c\mid\varepsilon121\mid 0$$0\mid 1$$\begin{array}[]{c}0\mid 0\\ 1\mid 1\end{array}$$\mid\varepsilon$${}\mid 1$${}\mid\varepsilon121\mid 0$$0\mid 1$$\begin{array}[]{c}0\mid 0\\ 1\mid 1\end{array}$${}\mid\varepsilon$${}\mid 1$${}\mid\varepsilon0123456{\vdash}\mid{\vdash},\rightarrow$$1\mid\varepsilon,\rightarrow$$0\mid\varepsilon,\leftarrow$$1\mid\varepsilon,\leftarrow$$\begin{array}[]{c}0\mid 0,\rightarrow\\ {\vdash}\mid\varepsilon,\rightarrow\end{array}$$1\mid 1,\rightarrow$$0\mid\varepsilon,\rightarrow$${\dashv}\mid\varepsilon,\leftarrow$$1\mid\varepsilon,\leftarrow$$\begin{array}[]{c}0\mid 1,\rightarrow\\ {\vdash}\mid 1,\rightarrow\end{array}$$1\mid 0,\rightarrow$${\dashv}\mid{\dashv},\rightarrow1X:=\varepsilon;Y:=1$$Y$$1\mid X:=X1;Y:=Y0$$0\mid Y:=X1;X:=X012X:=\varepsilon;Y:=\varepsilon;Z:=\varepsilon$$1\mid X:=X1;Y:=Y0;Z:=Z$$Z1Y$$0\mid Z:=X;X:=\varepsilon;Y:=\varepsilon$$1\mid X:=X1;Y:=Y0;Z:=Z$$0\mid Z:=Z0X;X:=\varepsilon;Y:=\varepsilon$$Z1Y

We investigate string-to-string functions which are ubiquitous. A preprocessing that erases comments from a program, or a micro-computation that replaces a binary string with its increment, or a syntactic fix that reorders the arguments of a function to comply with a different syntax, are all examples of string-to-string transformations/functions. We discuss various ways of describing such functions and survey some of the main results.

Operationally, we need to parse the input string and to produce an output word. The simplest such mechanism is to use a deterministic finite-state automaton (1DFA) to parse the input from left to right and to produce the output along the way. These are called sequential transducers, or one-way input-deterministic transducers (1DFT), see e.g. [6, Chapter IV], [18, Chapter V] or [15]. Transitions are labelled with pairs $a\mid u$ where $a$ is a letter read from the input string and $u$ is the word, possibly empty, to be appended to the output string. Sequential transducers allow for instance to strip comments from a latex file, see Figure 1. Transformations that can be realized by a sequential transducer are called sequential functions. A very important property of sequential functions is that they are closed under composition. This can be easily seen by taking a cartesian product of the two sequential transducers, synchronizing the output of the first transducer with the input of the second one. Also, each sequential function $f$ can be realized with a canonical minimal sequential transducer $\mathcal{A}_{f}$ which can be computed from any sequential transducer $\mathcal{B}$ realizing $f$. As a consequence, equivalence is decidable for sequential transducers.

With a sequential transducer, it is also possible to increment an integer written in binary if the string starts with the least significant bit (lsb), see Figure 2 left. On the other hand, increment is not a sequential function when the lsb is on the right. There are two possibilities to overcome this problem.

The first solution is to give up determinism when reading the input string. One-way input-nondeterministic finite-state transducers (1NFT) do not necessarily define functions. It is decidable in PTIME whether a 1NFT defines a function [19, 17]. We give a proof below111 Let $\mathcal{A}$ be a 1NFT with $m$ states. We show that, if $\mathcal{A}$ is functional on all words of length $\leq 2m^{2}$, then $\mathcal{A}$ is functional.

Let $w=a_{1}a_{2}\ldots a_{n}\in\mathsf{dom}(\mathcal{A})$ with $n>2m^{2}$. By induction, we assume that $\mathcal{A}$ is functional on all words of length $<n$. Consider two accepting runs for $w$: $p_{0}\xrightarrow{a_{1}}p_{1}\xrightarrow{a_{2}}p_{2}\cdots p_{n-1}\xrightarrow{a_{n}}p_{n}$ and $q_{0}\xrightarrow{a_{1}}q_{1}\xrightarrow{a_{2}}q_{2}\cdots q_{n-1}\xrightarrow{a_{n}}q_{n}$.

Since $n$ is large enough, we find $0\leq i<j<k\leq n$ with $(p_{i},q_{i})=(p_{j},q_{j})=(p_{k},q_{k})$. We split the input word $w=w_{1}w_{2}w_{3}w_{4}$ in four factors $w_{1}=a_{1}\cdots a_{i}$, $w_{2}=a_{i+1}\cdots a_{j}$, $w_{3}=a_{j+1}\cdots a_{k}$ and $w_{4}=a_{k+1}\cdots a_{n}$ and we consider the ouputs $x_{1}x_{2}x_{3}x_{4}$ and $y_{1}y_{2}y_{3}y_{4}$ of the two accepting runs: $p_{0}\xrightarrow{w_{1}\mid x_{1}}p_{i}\xrightarrow{w_{2}\mid x_{2}}p_{j}\xrightarrow{w_{3}\mid x_{3}}p_{k}\xrightarrow{w_{4}\mid x_{4}}p_{n}$ and $q_{0}\xrightarrow{w_{1}\mid y_{1}}q_{i}\xrightarrow{w_{2}\mid y_{2}}q_{j}\xrightarrow{w_{3}\mid y_{3}}q_{k}\xrightarrow{w_{4}\mid y_{4}}q_{n}$.

The three repeated pairs allow us to consider shortcuts in the accepting paths. First we skip $w_{2}w_{3}$ and we get two accepting runs for the shorter word $w_{1}w_{4}$: $p_{0}\xrightarrow{w_{1}\mid x_{1}}p_{i}=p_{k}\xrightarrow{w_{4}\mid x_{4}}p_{n}$ and $q_{0}\xrightarrow{w_{1}\mid y_{1}}q_{i}=q_{k}\xrightarrow{w_{4}\mid y_{4}}q_{n}$. By induction, the outputs must be equal: $x_{1}x_{4}=y_{1}y_{4}$. Wlog we assume that $y_{1}$ is a prefix of $x_{1}$ and we obtain $x_{1}=y_{1}z$ and $zx_{4}=y_{4}$ for some $z$.

Second, we skip $w_{3}$ and by induction the ouputs on the shorter word $w_{1}w_{2}w_{4}$ should be equal: $x_{1}x_{2}x_{4}=y_{1}y_{2}y_{4}$. Therefore, $y_{1}zx_{2}x_{4}=y_{1}y_{2}zx_{4}$ and $zx_{2}=y_{2}z$. Similarly, skipping $w_{2}$ we get $x_{1}x_{3}x_{4}=y_{1}y_{3}y_{4}$ and $zx_{3}=y_{3}z$. Finally, $x_{1}x_{2}x_{3}x_{4}=y_{1}zx_{2}x_{3}x_{4}=y_{1}y_{2}zx_{3}x_{4}=y_{1}y_{2}y_{3}zx_{4}=y_{1}y_{2}y_{3}y_{4}$. Hence, $\mathcal{A}$ is functional on $w$

which is mostly inspired from [6, Chapter IV].

We are interested in functional 1NFT (f1NFT). This is in particular the case when the transducer is input-unambiguous. Actually, one-way, input-unambiguous, finite-state transducers (1UFT) have the same expressive power as f1NFT [21]. We prove this result below when discussing regular look-ahead. For instance, increment with lsb on the right is realized by the 1UFT on Figure 2 right. Transformations realized by f1NFT are called rational functions. They are easily closed under composition. The equivalence problem is undecidable for 1NFT [16] but decidable in PTIME for f1NFT [19, 17]. This follows directly from the decidability of the functionality of 1NFTs: consider two f1NFTs $\mathcal{A}_{1}$ and $\mathcal{A}_{2}$, first check whether $\mathsf{dom}(\mathcal{A}_{1})=\mathsf{dom}(\mathcal{A}_{2})$, then check whether $\mathcal{A}_{1}\uplus\mathcal{A}_{2}$ is functional. It is also decidable in PTIME whether a f1NFT defines a sequential function, i.e., whether it can be realized by a 1DFT [8, 21].

Interestingly, any rational function $h$ can be written as $r\circ g\circ r\circ f$ where $f,g$ are sequential functions and $r$ is the reverse function mapping $w=a_{1}a_{2}\cdots a_{n}$ to $w^{r}=a_{n}\cdots a_{2}a_{1}$ [13]. We provide a sketch of proof below.222 Assume that $h$ is realized by a 1UFT $\mathcal{B}$. Consider the unique accepting run $q_{0}\xrightarrow{a_{1}\mid u_{1}}q_{1}\cdots q_{n-1}\xrightarrow{a_{n}\mid u_{n}}q_{n}$ of $\mathcal{B}$ on some input word $w=a_{1}\cdots a_{n}$. We have $h(w)=u_{1}\cdots u_{n}$.

Let $\mathcal{A}$ be the DFA obtained with the subset construction applied to the input NFA induced by $\mathcal{B}$. Consider the run $X_{0}\xrightarrow{a_{1}}X_{1}\cdots X_{n-1}\xrightarrow{a_{n}}X_{n}$ of $\mathcal{A}$ on $w$. We have $q_{i}\in X_{i}$ for all $0\leq i\leq n$. The first sequential function $f$ adorns the input word with the run of $\mathcal{A}$: $f(w)=(X_{0},a_{1})\cdots(X_{n-1},a_{n})$.

The sequential transducer $\mathcal{C}$ realizing $g$ is defined as follows. For each state $q$ of $\mathcal{B}$ there is a transition $\delta=q\xrightarrow{(X,a)}p$ in $\mathcal{C}$ if there is a unique $p\in X$ such that $\delta^{\prime}=p\xrightarrow{a}q$ is a transition in $\mathcal{B}$. Moreover, if $\delta^{\prime}$ outputs $u$ in $\mathcal{B}$ then $\delta$ outputs $u^{r}$ in $\mathcal{C}$.

Notice that $q_{n}\xrightarrow{(X_{n-1},a_{n})\mid u_{n}^{r}}q_{n-1}\cdots q_{1}\xrightarrow{(X_{0},a_{1})\mid u_{1}^{r}}q_{0}$ is a run of $\mathcal{C}$ producing $u_{n}^{r}\cdots u_{1}^{r}=h(w)^{r}$.

The result follows.

In classical automata, whether or not a transition can be taken only depends on the input letter being scanned. This can be enhanced using regular look-ahead or look-behind. For instance, the f1NFT on the right of Figure 2 can be made deterministic using regular look-ahead. In state 1, when reading digit 0, we move to state 2 if the suffix belongs to $1^{*}$ and we stay in state 1 otherwise, i.e., if the suffix belongs to $1^{*}0\{0,1\}^{*}$. Similarly, we choose to start in the initial state $2$ (resp. 1) if the word belongs to $1^{*}$ (resp. $1^{*}0\{0,1\}^{*}$). More generally, any f1NFT can easily be made deterministic using regular look-ahead: we consider an arbitrary total order $<$ on the set of states of the f1NFT and we select the least accepting path for the lexicographic ordering. If from state $p$ reading $a$ we have the choice between several transitions leading to states $q_{1}<q_{2}<q_{3}\cdots$, we select the least $i$ such that the suffix can be accepted from $q_{i}$. This query is indeed regular. We deduce that regular look-ahead increases the expressive power of one-way deterministic transducers.

Notice that a one-way transducer which is deterministic thanks to regular look-ahead can be easily transformed into a 1UFT. For instance, if a non-deterministic choice between $p\xrightarrow{a,L_{1}}q_{1}$ and $p\xrightarrow{a,L_{2}}q_{2}$ is resolved by the disjoint regular look-ahead $L_{1}$ and $L_{2}$, then the 1UFT goes to $q_{1}$ (or $q_{2})$ and spans a copy of the automaton for $L_{1}$ (or $L_{2})$ to check that the suffix satisfies the correct look-ahead. We have actually proved that f1NFT and 1UFT have the same expressive power: starting with a f1NFT, we get a deterministic transducer using regular look-ahead, then we turn it into a 1UFT.

Remember that increment with lsb on the right is not a sequential function. The first solution was to use f1NFT or 1UFT as in Figure 2 right. The other solution is to keep input-determinism but to allow the transducer to move its input head in both directions, i.e., left or right (two-way). So we consider two-way input-deterministic finite-state transducers (2DFT) [1]. To realize increment of binary numbers with the lsb on the right with a 2DFT, one has to locate the last 0 digit, replace it with 1, keep unchanged the digits on its left and replace all 1’s on its right with 0’s. This is realized by the 2DFT of Figure 3. We use ${\vdash},{\dashv}\notin\Sigma$ for the end-markers so the input tape contains ${\vdash}w{\dashv}$ when given the input word $w\in\Sigma^{*}$.

Transformations realized by 2DFTs are called regular functions. They form a very robust class. Remarkably, regular functions are closed under composition [9], which is now a non trivial result. Actually, a 2DFT can be transformed into a reversible one of exponential size [11]. In a reversible transducer, computation steps can be deterministically reversed. As a consequence, the composition of two 2DFTs can be achieved with a single exponential blow-up. Also, contrary to the one-way case, input-nondeterminism does not add expressive power as long as we stay functional: given a f2NFT, one may construct an equivalent 2DFT [14]. Similarly, regular look-ahead and look-behind do not increase the expressive power of regular functions [14]. Moreover, the equivalence problem for regular functions is still decidable [10].

Regular functions are also those that can be defined with MSO transductions [14], but we will not discuss this here.

By using registers, we obtain yet another formalism defining string-to-string transformations. For instance incrementing a binary number with lsb on the right is realized by the one-way register transducer on Figure 4. It uses two registers $X,Y$ initialized with the empty string and 1 respectively and updated while reading the binary number. Register $X$ keeps a copy of the binary number read so far, while $Y$ contains its increment. The final output of the transducer is the string contained in register $Y$. This register automaton is a special case of “simple programs” defined in [9]. In these simple programs, a register may be reset to the empty string, copied to another register, or updated by appending a finite string. The input head is two-way and most importantly simple programs may be composed. Simple programs coincide in expressive power with 2DFTs [9], hence define once again the class of regular functions.

Notice that when reading digit 0, the transducer of Figure 4 copies the string stored in $X$ into $Y$ without resetting $X$ to $\varepsilon$. By restricting to one-way register automata with copyless updates (e.g., not of the form $Y:=X1;X:=X0$ where the string contained in $X$ is duplicated) but allowing concatenation of registers in updates (e.g., $Z:=Z0X;X:=\varepsilon$), we obtain another kind of machines, called copyless streaming string transducers (SST), once again defining the same class of regular functions [3]. Continuing our example, incrementing a binary number with lsb on the right can be realized with the SST on Figure 5. It uses three registers $X,Y,Z$ initialized with the empty string and updated while reading the binary number. Register $X$ keeps a copy of the last sequence of 1’s while register $Y$ contains a sequence of 0’s of same length. Now register $Z$ keeps a copy of the input read so far up to, and excluding, the last 0. Hence, the increment of the binary number read so far is given by $Z1Y$ which is the final output of the transducer. If the input number is $1^{n}$ then the computation ends in state 1 with $Y=0^{n}$ and $Z=\varepsilon$. Hence the final ouput is $Z1Y=10^{n}$. Similarly, if the input number is of the form $w01^{n}$ then the run ends in state $2$ with $Z=w$ and $Y=0^{n}$: the final output is $Z1Y=w10^{n}$.

The above machines provide a way of describing string-to-string transformations which is not modular. Describing regular functions in such devices is difficult, and it is even more difficult to understand what is the function realized by a 2DFT or an SST. We discuss now more compositional and modular descriptions of regular functions. Such a formalism, called regular list functions, was described in [7]. It is based on function composition together with some natural functions over lists such as reverse, append, co-append, map, etc. Here we choose to look at combinators derived from regular expressions.

The idea is to start from basic functions, e.g., $(1\mid 0)$ means “read 1 and output 0”, and to apply simple combinators generalizing regular expressions [4, 2, 12, 5]. For instance, using the Kleene iteration, $(1\mid 0)^{*}$ describes a function which replaces a sequence of 1’s with a sequence of 0’s of same length. Similarly, $\mathsf{copy}:=((0\mid 0)+(1\mid 1))^{*}$ describes a regular function which simply copies an input binary string to the output. Now, incrementing a binary number with lsb on the right is described with the expression $\mathsf{increment0}:=\mathsf{copy}\cdot(0\mid 1)\cdot(1\mid 0)^{*}$, assuming that the input string contains at least one 0 digit. If the input string belongs to $1^{*}$, we may use the expression $\mathsf{increment1}:=(\varepsilon\mid 1)\cdot(1\mid 0)^{*}$. Notice that such a regular transducer expression (RTE) defines simultaneously the domain of the regular function as a regular expression, e.g., $\mathsf{dom}(\mathsf{increment0})=(0+1)^{*}01^{*}$, and the output to be produced. The input regular expression explains how the input should be parsed. If the input regular expression is ambiguous, parsing the input word is not unique and the expression may be non functional. For instance, $\mathsf{copy}\cdot(1\mid 0)^{*}$ is ambiguous. The input word $w=1011$ may be parsed as $10\cdot 11$ or $101\cdot 1$ or $1011\cdot\varepsilon$ resulting in the outputs $1000$ or $1010$ or $1011$ respectively. On the other end, $\mathsf{increment}:=\mathsf{increment0}+\mathsf{increment1}$ has an unambiguous input regular expression.

Simple RTEs are defined by the syntax

[TABLE]

where $u$ is a finite input word, $v$ is a finite output word, and the rational operations should be unambiguous. For instance, $f^{*}$ is unambiguous if for all input words $w$, there is at most one factorization $w=u_{1}u_{2}\cdots u_{n}$ with $u_{i}\in\mathsf{dom}(f)$. Simple RTEs define precisely the rational functions (f1NFT or 1UFT). This follows from a more general result: the equivalence of weighted automata and rational series, usually referred to as the Kleene-Schützenberger theorem [20], applied to the semiring of rational languages and restricted to unambiguous weighted automata.

A 2DFT may easily duplicate the input word, defining the function $w\mapsto w\#w$, which cannot be computed with a sequential transducer or a f1NFT. In addition to the classical regular combinators ($+$ for disjoint union, $\cdot$ for unambiguous concatenation or Cauchy product, ∗ for unambiguous Kleene iteration), we add the Hadamard product $(f\odot g)(w)=f(w)\cdot g(w)$ where the input word is read twice, first producing the output computed by $f$ then the output computed by $g$. Hence the function duplicating its input can be simply written as $\mathsf{duplicate}:=(\mathsf{copy}\cdot(\varepsilon\mid\#))\odot\mathsf{copy}$. The Hadamard product also allows to exchange two strings $u\#v\mapsto vu$ where $u,v\in\{0,1\}^{*}$. Let $\mathsf{erase}:=((0\mid\varepsilon)+(1\mid\varepsilon))^{*}$ and

[TABLE]

A 2DFT may also scan its input back and forth in pieces. This was used in the 2DFT of Figure 3 to locate the last 0 of the input. This is also needed to realize the regular function $h$ defined by

[TABLE]

where $u_{1},\ldots,u_{n}\in\{0,1\}^{*}$ and $n>1$. It is easy to build a 2DFT realizing $h$, but this regular function cannot be expressed using the regular combinators $+$, $\cdot$, $*$, $\odot$. On the other hand, we show that $h$ can be expressed with the help of composition. First, we iterate the function $\mathsf{duplicate}$ on a $\#$-separated sequence of binary words with the RTE $f:=(\mathsf{duplicate}\cdot(\#\mid\#))^{*}$. We have

[TABLE]

when $u_{1},\ldots,u_{n}$ are binary strings. Next, we erase the first $u_{1}$ and the last $u_{n}$ and we exchange the remaining consecutive pairs with the RTE

[TABLE]

We have $g\circ f\colon u_{1}\#u_{2}\#u_{3}\#\cdots u_{n}\#\mapsto u_{2}u_{1}\#u_{3}u_{2}\#\cdots u_{n}u_{n-1}\#$. Hence, $h=g\circ f$.

Another crucial feature of 2DFTs is their ability to reverse the input, i.e., to implement the function $\mathsf{reverse}\colon a_{1}a_{2}\cdots a_{n}\mapsto a_{n}\cdots a_{2}a_{1}$. We add the basic function $\mathsf{reverse}$ to our expressions and we obtain RTEs with composition, Hadamard product and reverse (chr-RTE) following the syntax:

[TABLE]

where $u$ is a finite input word, $v$ is a finite output word, and the rational operations $+$, $\cdot$, $*$ should be unambiguous. It turns out that regular functions (2DFTs) are exactly those that can be described with chr-RTEs. Further, we may remove the Hadamard product if we provide $\mathsf{duplicate}$ as a basic function. Indeed, we can easily check that $f\odot g=(f\cdot(\#\mid\varepsilon)\cdot g)\circ\mathsf{duplicate}$. We obtain RTEs with composition, duplicate and reverse (cdr-RTE) following the syntax:

[TABLE]

Once again, cdr-RTEs define exactly the class of regular functions. We believe that both chr-RTE and cdr-RTE form very convenient, compositional and modular formalisms for defining regular functions.

An alternative solution to the fact that the regular function $h$ defined above cannot be described using the regular combinators $+$, $\cdot$, $*$, $\odot$ was proposed in [4]. Instead of using composition, they introduced a 2-chained Kleene iteration: $[K,f]^{2+}$ first unambiguously parses an input word as $w=u_{1}u_{2}\cdots u_{n}$ with $u_{1},\ldots,u_{n}\in K$ and then apply $f$ to all consecutive pairs of factors, resulting in the output $f(u_{1}u_{2})f(u_{2}u_{3})\cdots f(u_{n-1}u_{n})$. For instance, with the functions defined above, we can easily check that $h=[K,f]^{2+}$ with $K=\{0,1\}^{*}\#$ and $f:=\mathsf{exchange}\cdot(\#\mid\#)$.

We show that the 2-chained Kleene iteration $[K,f]^{2+}$ can be expressed if we allow composition of functions in addition to the regular combinators $+$, $\cdot$, $*$, $\odot$. First, consider an unambiguous regular expression for the regular language $K$ in which we replace each atomic letter $a$ with $(a\mid a)$. We obtain a simple RTE $f_{K}$ with domain $K$ and which is the identity on its domain $K$. Now consider the function $g_{K}$ defined by the simple RTE $g_{K}=(f_{K}\cdot(\varepsilon\mid\#))^{*}$. When an input word $w$ can be unambiguously parsed as $w=u_{1}u_{2}\cdots u_{n}$ with $u_{1},\ldots,u_{n}\in K$, we get $g_{K}(w)=u_{1}\#u_{2}\#\cdots u_{n}\#$. As above, we consider the function $g:=(\mathsf{duplicate}\cdot(\#\mid\#))^{*}$ so that $(g\circ g_{K})(w)=u_{1}\#u_{1}\#u_{2}\#u_{2}\#u_{3}\#u_{3}\#\cdots u_{n}\#u_{n}\#$. With a further composition, we erase the first $u_{1}$ and the last $u_{n}$ and we apply $f$ to the remaining consecutive pairs with the RTE

[TABLE]

We obtain $[K,f]^{2+}=h\circ g\circ g_{K}$. Therefore, regular functions described by RTEs using combinators $+$, $\cdot$, $*$, $\odot$, $2+$ can be expressed with ch-RTEs using combinators $+$, $\cdot$, $*$, $\odot$, $\circ$ or cd-RTEs using $\mathsf{duplicate}$ instead of the Hadamard product.

Since the regular function $\mathsf{reverse}$ cannot be expressed with the regular combinators $+$, $\cdot$, $*$, $\odot$ and $2{+}$, reversed versions of Kleene star and 2-chained Kleene iteration were also introduced in [4]. The reversed Kleene star $r\text{-}*$ parses the input word from left to right but produces the output in reversed order. For instance, $f^{r\text{-}*}(w)=f(u_{n})\cdots f(u_{2})f(u_{1})$ if the input word is unambiguously parsed as $w=u_{1}u_{2}\cdots u_{n}$ with $u_{i}\in\mathsf{dom}(f)$. Hence, reversing a binary string is described with the expression $((0\mid 0)+(1\mid 1))^{r\text{-}*}$.

Conversely, the reversed Kleene star can be expressed with the basic function $\mathsf{reverse}$ and composition: $f^{r\text{-}*}=(f\circ\mathsf{reverse})^{*}\circ\mathsf{reverse}$. Indeed, assume that an input word is unambiguously parsed as $w=u_{1}u_{2}\cdots u_{n}$ when applying $f^{r\text{-}*}$ resulting in $f(u_{n})\cdots f(u_{2})f(u_{1})$. Then, $\mathsf{reverse}(w)=w^{r}$ is unambiguously parsed as $u_{n}^{r}\cdots u_{2}^{r}u_{1}^{r}$ when applying $(f\circ\mathsf{reverse})^{*}$. The result follows since $(f\circ\mathsf{reverse})(u^{r})=f(u)$.

There is also a reversed version of the two-chained Kleene iteration. With the above notation, we get $[K,h]^{r\text{-}2+}(w)=h(u_{n-1}u_{n})\cdots h(u_{2}u_{3})h(u_{1}u_{2})$ when the input word can be unambiguously parsed as $w=u_{1}u_{2}\cdots u_{n}$ with $u_{1},\ldots,u_{n}\in K$.

Once again, we obtain an equivalent formalism for describing regular functions: the regular transducer expressions using $+$, $\cdot$, $\odot$, $*$, $r\text{-}*$, $2+$, $r\text{-}2+$ as combinators [4, 2, 12, 5]:

[TABLE]

To conclude, we have seen various formalisms for describing string to string transformations. With increasing expressive power, we have sequential functions (1DFT), rational functions (f1NFT or 1UFT or 1DFT with regular look-ahead or simple RTE), and regular functions. Each class of functions is closed under composition and its equivalence problem is decidable. The robust and expressive class of regular functions can be described with various machine models such as 2DFT or 2UFT or f2NFT or SST. It also admits compositional descriptions based on regular combinators. We believe that using function composition instead of the technically involved 2-chained Kleene iteration makes the descriptions much easier. Hence, we advocate the use of chr-RTEs or cdr-RTEs as described above.