Guarded Language Operators as Contractions in a Length-Based Ultrametric Space

1. Introduction

The study of fixed point equations on structured spaces is a central theme in both pure and applied mathematics. Since Banach’s classical work [1], contraction mappings on complete metric spaces have provided a powerful framework for proving existence and uniqueness of solutions to recursive equations. One of the main advantages of this approach is its constructive nature: the fixed point is obtained as the limit of the Picard iteration sequence, and the contraction constant yields explicit information about the rate of convergence.

In the semantics of programming languages, metric and ultrametric ideas have played an important role in the analysis of recursive definitions. In particular, de Bakker and Zucker [2] showed that complete metric methods provide a natural setting for denotational semantics of concurrency, while America and Rutten [3] developed a categorical treatment of complete metric spaces and contraction-based fixed point constructions for recursive domain equations. A recurring idea in this line of work is that contractivity is closely related to guardedness: recursion becomes well behaved when each recursive occurrence is separated from the surrounding structure by a sufficient amount of observable information.

The present paper develops an analogous point of view in the setting of formal languages. Let $\Sigma$ be a finite alphabet and let $\mathcal{L}$ denote the set of all formal languages over $\Sigma$. We equip $\mathcal{L}$ with a length-based ultrametric in which two languages are close whenever they coincide on all words up to a sufficiently large length. This makes $\mathcal{L}$ a natural environment for studying recursive language constructions by fixed point methods.

We introduce a class of wrapping operators of the form

$$T_{S,G}\left(L\right)=S\cup \bigcup _{r=1}^p{u}_{r}L{v}_r,$$

where $S\subseteq {\Sigma }^{*}$ is a fixed seed language and

$$G=\{(u_r,v_r):r=1,\dots ,p\}\subseteq {\Sigma }^{*}\times {\Sigma }^{*}$$

is a finite family of guards. The key assumption is that the total guard length satisfies

$$\underset{1\le r\le p}{min}\left(|u_r|+|v_r|\right)\ge m$$

for some integer $m\ge 1$. Under this hypothesis, every wrapped word carries a mandatory outer layer of total length at least m before the recursive core can be reached. This is the feature that yields contractivity.

Our main result shows that every such wrapping operator is a contraction on $(\mathcal{L},d)$ with contraction factor $2^{-m}$. Banach’s fixed point theorem then implies that the corresponding recursive language equation

$$L=T_{S,G}\left(L\right)$$

admits a unique solution in $\mathcal{L}$. Moreover, the Picard iterates converge to this solution from any initial language, and the convergence is quantitatively controlled by the guard length. In particular, when the iteration starts from the empty language, one obtains an explicit bound ensuring correctness on all words up to any prescribed length.

Beyond its theoretical interest, the framework developed in this paper has a natural interpretation in computer science. In particular, recursive data structures, document formats with nested syntax, and schema-based validation mechanisms can be modeled using wrapping operators. In this setting, the contractive nature of guarded recursion provides not only well-defined semantics, but also explicit bounds on the number of steps required to validate inputs of bounded size. This connects the abstract fixed-point theory developed here with practical questions in parsing, serialization, and validation of recursive data.

The paper is organized as follows. Section 2 recalls the required preliminaries on formal languages, the length-based ultrametric on $\mathcal{L}$, and Banach’s contraction principle. Section 3 introduces wrapping operators generated by finite families of guards and establishes the main fixed point and convergence results. Section 4 contains several examples illustrating the theory, including a case in which ultrametric convergence differs from set-theoretic convergence. Section 5 presents an application to recursive document validation.

2. Preliminaries

Throughout the paper, $\Sigma$ denotes a fixed finite alphabet and ${\Sigma }^{*}$ the set of all finite words over $\Sigma$, including the empty word $\epsilon$. For a word $w\in {\Sigma }^{*}$, its length is denoted by $\left|w\right|$.

Definition 1 

([4,5]). A formal language over Σ is any subset $L\subseteq {\Sigma }^{*}$.

We denote by $\mathcal{L}$ the set of all formal languages over $\Sigma$.

Definition 2 

([4,5]). Each language $L\in \mathcal{L}$ is identified with its characteristic function

$${\mathbf{1}}_L:{\Sigma }^{*}\to \{0,1\},{\mathbf{1}}_L\left(w\right)=\left\{\begin{array}{cc}1,\hfill & w\in L,\hfill \\ 0,\hfill & w\notin L.\hfill \end{array}\right.$$

For $u\in {\Sigma }^{*}$ and $L\subseteq {\Sigma }^{*}$, we define left and right concatenation by

$$uL:=\{uw:w\in L\},Lu:=\{wu:w\in L\}.$$

Definition 3 

([2]). For any two formal languages $L_1,L_2\in \mathcal{L}$ define a distance between $L_1$ and $L_2$ by

$$d(L_1,L_2)=\left\{\begin{array}{cc}0,\hfill & L_1=L_2,\hfill \\ 2^{-k},\hfill & k=min\left\{\right|w|:{\mathbf{1}}_{L_1}\left(w\right)\ne {\mathbf{1}}_{L_2}\left(w\right)\}.\hfill \end{array}\right.$$

Lemma 1. 

Let $L_1,L_2\in \mathcal{L}$ be two formal languages. If $d(L_1,L_2)=2^{-k}$, then $L_1$ and $L_2$ coincide on all words of length strictly less than k, and there exists a word w with $\left|w\right|=k$ such that

$${\mathbf{1}}_{L_1}\left(w\right)\ne {\mathbf{1}}_{L_2}\left(w\right).$$

This follows directly from Definition 3; see [2].

Theorem 1 

([2]). The function d is an ultrametric on $\mathcal{L}$, i.e.,

$$d(L_1,L_3)\le max\{d(L_1,L_2),d(L_2,L_3)\}\mathrm{for}\mathrm{all}{L}_1,L_2,L_3\in \mathcal{L}.$$

Definition 4. 

A sequence $\left(L_n\right)\subseteq \mathcal{L}$ is Cauchy if for every $k\in \mathbb{N}$ there exists N such that

$${\mathbf{1}}_{L_n}\left(w\right)={\mathbf{1}}_{L_m}\left(w\right)\mathrm{for}\mathrm{all}\left|w\right|\le k\mathrm{and}\mathrm{all}n,m\ge N.$$

This is the standard notion of a Cauchy sequence in the metric space $(\mathcal{L},d)$; see [2] for the underlying metric structure.

Theorem 2 

([2]). The ultrametric space $(\mathcal{L},d)$ is complete.

Definition 5 

([1]). Let $(X,d)$ be a metric space. A mapping $T:X\to X$ is a contraction if there exists $c\in (0,1)$ such that

$$d(Tx,Ty)\le cd(x,y)\mathrm{for}\mathrm{all}x,y\in X.$$

Definition 6 

([1]). An element $x^{*}\in X$ is a fixed point of T if $T\left(x^{*}\right)=x^{*}$.

Theorem 3 

([1]). Let $(X,d)$ be a complete metric space and let $T:X\to X$ be a contraction. Then T admits a unique fixed point $x^{*}$, and the iterates

$$x_{n+1}=T\left(x_n\right)$$

converge to $x^{*}$ for every $x_0\in X$.

3. Main Result

Definition 7. 

Let Σ be a finite alphabet. A finite set

$$G=\{(u_r,v_r):r=1,\dots ,p\}\subseteq {\Sigma }^{*}\times {\Sigma }^{*}$$

is called a finite set of guards.

Definition 8. 

Let Σ be a finite alphabet, let $S\subseteq {\Sigma }^{*}$, and let

$$G=\{(u_r,v_r):r=1,\dots ,p\}\subseteq {\Sigma }^{*}\times {\Sigma }^{*}$$

be a finite set of guards.

We define an operator

$$T_{S,G}:\mathcal{L}\to \mathcal{L}$$

by

$$T_{S,G}\left(L\right)=S\cup \bigcup _{r=1}^p{u}_{r}L{v}_r,L\in \mathcal{L}.$$

We call $T_{S,G}$ a wrapping operator generated by the seed S and the guards G.

Definition 9. 

Let

$$G=\{(u_r,v_r):r=1,\dots ,p\}\subseteq {\Sigma }^{*}\times {\Sigma }^{*}.$$

We say that G has guard length at least $m\ge 1$ if

$$\underset{1\le r\le p}{min}\left(|u_r|+|v_r|\right)\ge m.$$

Remark 1. 

When no ambiguity arises, we write T instead of $T_{S,G}$.

Lemma 2. 

Let $u,v\in {\Sigma }^{*}$. Then for all $A,B\in \mathcal{L}$,

$$d(uAv,uBv)\le 2^{-\left(\right|u|+|v\left|\right)}d(A,B).$$

Proof. 

We consider two cases.

Case 1: $A=B$. Then $uAv=uBv$, hence

$$d(uAv,uBv)=0\le 2^{-\left(\right|u|+|v\left|\right)}d(A,B).$$

Case 2: $A\ne B$. Let

$$k=min\left\{\right|w|:{\mathbf{1}}_A\left(w\right)\ne {\mathbf{1}}_B\left(w\right)\}.$$

Then

$$d(A,B)=2^{-k}.$$

By Lemma 1, the languages A and B coincide on all words of length strictly less than k, and there exists a word $w_0\in {\Sigma }^{*}$ with $|w_0|=k$ such that

$${\mathbf{1}}_A\left(w_0\right)\ne {\mathbf{1}}_B\left(w_0\right).$$

We claim that $uAv$ and $uBv$ coincide on all words of length strictly less than

$$k+\left|u\right|+\left|v\right|.$$

Let $x\in {\Sigma }^{*}$ satisfy

$$\left|x\right|<k+\left|u\right|+\left|v\right|.$$

If x does not begin with u, then clearly

$$x\notin uAv\mathrm{and}x\notin uBv,$$

so

$${\mathbf{1}}_{uAv}\left(x\right)={\mathbf{1}}_{uBv}\left(x\right)=0.$$

Assume now that x begins with u. Then there exists a unique word $y\in {\Sigma }^{*}$ such that

$$x=uy.$$

From

$$\left|x\right|<k+\left|u\right|+\left|v\right|$$

we obtain

$$\left|y\right|<k+\left|v\right|.$$

If y does not end with v, then

$$y\notin Av\mathrm{and}y\notin Bv,$$

hence

$$x\notin uAv\mathrm{and}x\notin uBv.$$

Assume finally that y ends with v. Then there exists a unique word $z\in {\Sigma }^{*}$ such that

$$y=zv.$$

Since

$$\left|y\right|<k+\left|v\right|,$$

it follows that

$$\left|z\right|<k.$$

Therefore

$${\mathbf{1}}_A\left(z\right)={\mathbf{1}}_B\left(z\right),$$

because A and B coincide on all words of length strictly less than k. Hence

$$z\in A\iff z\in B,$$

which implies

$$y\in Av\iff y\in Bv$$

and therefore

$$x\in uAv\iff x\in uBv.$$

We have shown that $uAv$ and $uBv$ coincide on all words of length strictly less than

$$k+\left|u\right|+\left|v\right|.$$

Thus

$$d(uAv,uBv)\le 2^{-(k+|u|+|v\left|\right)}=2^{-\left(\right|u|+|v\left|\right)}{2}^{-k}=2^{-\left(\right|u|+|v\left|\right)}d(A,B).$$

This completes the proof.    □

Lemma 3. 

For all $A,B,S\in \mathcal{L}$,

$$d(A\cup S,B\cup S)\le d(A,B).$$

Proof. 

If $A=B$, then $A\cup S=B\cup S$ and $d(A\cup S,B\cup S)=0\le d(A,B)$.

Let $A\ne B$ and let

$$k=min\left\{\right|w|:{\mathbf{1}}_A\left(w\right)\ne {\mathbf{1}}_B\left(w\right)\}\ge 0.$$

Then $d(A,B)=2^{-k}$.

We will prove that for all words w with $\left|w\right|<k$, we have ${\mathbf{1}}_{A\cup S}\left(w\right)={\mathbf{1}}_{B\cup S}\left(w\right)$.

Let $\left|w\right|<k$. From the definition of k, we know that ${\mathbf{1}}_A\left(w\right)={\mathbf{1}}_B\left(w\right)$. We consider two subcases:

Case 1: ${\mathbf{1}}_A\left(w\right)={\mathbf{1}}_B\left(w\right)=1$. Then $w\in A$ and $w\in B$. Consequently, $w\in A\cup S$ and $w\in B\cup S$, so ${\mathbf{1}}_{A\cup S}\left(w\right)=1={\mathbf{1}}_{B\cup S}\left(w\right)$.

Case 2: ${\mathbf{1}}_A\left(w\right)={\mathbf{1}}_B\left(w\right)=0$. Then $w\notin A$ and $w\notin B$. To determine whether $w\in A\cup S$, we need to check whether $w\in S$. We have:

$$\begin{array}{cc}\hfill {\mathbf{1}}_{A\cup S}\left(w\right)& =max\{{\mathbf{1}}_A\left(w\right),{\mathbf{1}}_S\left(w\right)\}=max\{0,{\mathbf{1}}_S\left(w\right)\}={\mathbf{1}}_S\left(w\right),\hfill \\ \hfill {\mathbf{1}}_{B\cup S}\left(w\right)& =max\{{\mathbf{1}}_B\left(w\right),{\mathbf{1}}_S\left(w\right)\}=max\{0,{\mathbf{1}}_S\left(w\right)\}={\mathbf{1}}_S\left(w\right).\hfill \end{array}$$

Therefore ${\mathbf{1}}_{A\cup S}\left(w\right)={\mathbf{1}}_S\left(w\right)={\mathbf{1}}_{B\cup S}\left(w\right)$.

Thus we have proved that for all w with $\left|w\right|<k$, we have ${\mathbf{1}}_{A\cup S}\left(w\right)={\mathbf{1}}_{B\cup S}\left(w\right)$. This means that the first possible disagreement between $A\cup S$ and $B\cup S$ occurs at length at least k. Consequently,

$$d(A\cup S,B\cup S)\le 2^{-k}=d(A,B).$$

   □

Lemma 4. 

Let Σ be a finite alphabet, let $S\subseteq {\Sigma }^{*}$, and let

$$G=\{(u_r,v_r):r=1,\dots ,p\}\subseteq {\Sigma }^{*}\times {\Sigma }^{*}$$

be a finite set of guards with guard length at least $m\ge 1$. Let

$$T=T_{S,G}:\mathcal{L}\to \mathcal{L}$$

be the wrapping operator generated by the seed S and the guards G. Then

$$d(T\left(A\right),T\left(B\right))\le 2^{-m}d(A,B)\mathrm{for}\mathrm{all}A,B\in \mathcal{L}.$$

Proof. 

By Definitions 8 and 9, there exist $S\subseteq {\Sigma }^{*}$ and finitely many pairs $(u_r,v_r)$, $r=1,\dots ,p$, such that

$$T\left(L\right)=S\cup \bigcup _{r=1}^p{u}_{r}L{v}_r\mathrm{for}\mathrm{all}L\in \mathcal{L},$$

and

$$|u_r|+|v_r|\ge m\mathrm{for}\mathrm{all}r=1,\dots ,p.$$

Let $A,B\in \mathcal{L}$ be arbitrary. For each $r=1,\dots ,p$, Lemma 2 gives

$$d(u_{r}A{v}_r,u_{r}B{v}_r)\le 2^{-\left(\right|u_r|+|v_r\left|\right)}d(A,B)\le 2^{-m}d(A,B).$$

We now estimate the distance between the unions

$$U_A:=\bigcup _{r=1}^p{u}_{r}A{v}_r,U_B:=\bigcup _{r=1}^p{u}_{r}B{v}_r.$$

If $U_A=U_B$, then

$$d(U_A,U_B)=0\le 2^{-m}d(A,B).$$

Assume that $U_A\ne U_B$, and let k be the first length at which they differ. Then there exists a word $w_0$ with $|w_0|=k$ such that

$${\mathbf{1}}_{U_A}\left(w_0\right)\ne {\mathbf{1}}_{U_B}\left(w_0\right).$$

Without loss of generality, assume that

$${\mathbf{1}}_{U_A}\left(w_0\right)=1\mathrm{and}{\mathbf{1}}_{U_B}\left(w_0\right)=0.$$

Then there exists an index $r_0$ such that

$${\mathbf{1}}_{u_{r_0}A{v}_{r_0}}\left(w_0\right)=1,$$

while

$${\mathbf{1}}_{u_{r}B{v}_r}\left(w_0\right)=0\mathrm{for}\mathrm{all}r=1,\dots ,p.$$

In particular,

$${\mathbf{1}}_{u_{r_0}B{v}_{r_0}}\left(w_0\right)=0.$$

Hence

$${\mathbf{1}}_{u_{r_0}A{v}_{r_0}}\left(w_0\right)\ne {\mathbf{1}}_{u_{r_0}B{v}_{r_0}}\left(w_0\right),$$

so the first disagreement between $u_{r_0}A{v}_{r_0}$ and $u_{r_0}B{v}_{r_0}$ occurs at some length not exceeding k. Therefore

$$d(U_A,U_B)=2^{-k}\le d(u_{r_0}A{v}_{r_0},u_{r_0}B{v}_{r_0}).$$

Using the estimate above, we obtain

$$d(U_A,U_B)\le 2^{-m}d(A,B).$$

Finally, by Lemma 3,

$$d(T\left(A\right),T\left(B\right))=d(S\cup U_A,S\cup U_B)\le d(U_A,U_B)\le 2^{-m}d(A,B).$$

This completes the proof.    □

Theorem 4. 

Let Σ be a finite alphabet, let $S\subseteq {\Sigma }^{*}$, and let

$$G=\{(u_r,v_r):r=1,\dots ,p\}\subseteq {\Sigma }^{*}\times {\Sigma }^{*}$$

be a finite set of guards with guard length at least $m\ge 1$. Let

$$T=T_{S,G}:\mathcal{L}\to \mathcal{L}$$

be the wrapping operator generated by the seed S and the guards G. Then the equation

$$L=T\left(L\right)$$

admits a unique solution $L^{*}\in \mathcal{L}$. Moreover, for every initial language $L^{\left(0\right)}\in \mathcal{L}$, the sequence defined by

$$L^{(n+1)}=T\left(L^{\left(n\right)}\right),n\ge 0,$$

converges to $L^{*}$.

Proof. 

The space $(\mathcal{L},d)$ is complete by the completeness theorem stated in the Preliminaries. By Lemma 4, the operator T is a contraction on $(\mathcal{L},d)$. Therefore, the conclusion follows from Banach’s contraction principle.    □

Lemma 5. 

Let Σ be a finite alphabet, let $S\subseteq {\Sigma }^{*}$, and let

$$G=\{(u_r,v_r):r=1,\dots ,p\}\subseteq {\Sigma }^{*}\times {\Sigma }^{*}$$

be a finite set of guards with guard length at least $m\ge 1$. Let

$$T=T_{S,G}:\mathcal{L}\to \mathcal{L}$$

be the wrapping operator generated by the seed S and the guards G. Then for any initial approximation $L^{\left(0\right)}$ and for any $n\ge 1$,

$$d(L^{\left(n\right)},L^{*})\le 2^{-mn}d(L^{\left(0\right)},L^{*}).$$

Proof. 

We prove the statement by induction on n.

For $n=1$, from Lemma 4 we have

$$d(L^{\left(1\right)},L^{*})=d(T\left(L^{\left(0\right)}\right),T\left(L^{*}\right))\le 2^{-m}d(L^{\left(0\right)},L^{*}).$$

Assume the statement holds for n. Then

$$\begin{array}{cc}\hfill d(L^{(n+1)},L^{*})& =d(T\left(L^{\left(n\right)}\right),T\left(L^{*}\right))\hfill \\ \hfill & \le 2^{-m}d(L^{\left(n\right)},L^{*})(\mathrm{by}\mathrm{contractivity})\hfill \\ \hfill & \le 2^{-m}·2^{-mn}d(L^{\left(0\right)},L^{*})(\mathrm{by}\mathrm{the}\mathrm{inductive}\mathrm{hypothesis})\hfill \\ \hfill & =2^{-m(n+1)}d(L^{\left(0\right)},L^{*}).\hfill \end{array}$$

This completes the proof.    □

Corollary 1. 

Under the conditions of Lemma 5, if we want $L^{\left(n\right)}$ and $L^{*}$ to coincide on all words of length less than N, it is sufficient to require

$$d(L^{\left(n\right)},L^{*})\le 2^{-N}.$$

A sufficient condition for this is

$$n\ge {\displaystyle \frac{N+{log}_{2}d(L^{\left(0\right)},L^{*})}{m}},$$

provided that $d(L^{\left(0\right)},L^{*})>0$.

In particular, if $L^{\left(0\right)}=\varnothing$, then $d(L^{\left(0\right)},L^{*})\le 1$, hence

$$n\ge {\displaystyle \frac{N}{m}}$$

is a sufficient condition.

If $d(L^{\left(0\right)},L^{*})=0$, then $L^{\left(0\right)}=L^{*}$ and the conclusion is trivial.

Proof. 

If $d(L^{\left(0\right)},L^{*})=0$, then $L^{\left(0\right)}=L^{*}$, hence $L^{\left(n\right)}=L^{*}$ for all $n\ge 0$, and the conclusion is immediate.

Assume now that $d(L^{\left(0\right)},L^{*})>0$. By Lemma 5,

$$d(L^{\left(n\right)},L^{*})\le 2^{-mn}d(L^{\left(0\right)},L^{*}).$$

Thus it is sufficient to require

$$2^{-mn}d(L^{\left(0\right)},L^{*})\le 2^{-N}.$$

Taking base-2 logarithms, we obtain

$$-mn+{log}_{2}d(L^{\left(0\right)},L^{*})\le -N,$$

which is equivalent to

$$-mn\le -N-{log}_{2}d(L^{\left(0\right)},L^{*}).$$

Multiplying by $-1$, we get

$$mn\ge N+{log}_{2}d(L^{\left(0\right)},L^{*}).$$

Therefore,

$$n\ge {\displaystyle \frac{N+{log}_{2}d(L^{\left(0\right)},L^{*})}{m}}$$

is a sufficient condition.

If $L^{\left(0\right)}=\varnothing$, then $d(L^{\left(0\right)},L^{*})\le 1$, so

$${log}_{2}d(L^{\left(0\right)},L^{*})\le 0.$$

Hence

$$N+{log}_{2}d(L^{\left(0\right)},L^{*})\le N,$$

and therefore

$$n\ge {\displaystyle \frac{N}{m}}$$

is also a sufficient condition.    □

Theorem 5. 

Let Σ be a finite alphabet, let $S\subseteq {\Sigma }^{*}$, and let

$$G=\{(u_r,v_r):r=1,\dots ,p\}\subseteq {\Sigma }^{*}\times {\Sigma }^{*}$$

be a finite set of guards with guard length at least $m\ge 1$. Let

$$T=T_{S,G}:\mathcal{L}\to \mathcal{L}$$

be the wrapping operator generated by the seed S and the guards G. Let $L^{*}$ be the fixed point of T. If

$$d(L,L^{*})\le 2^{-N},$$

then L and $L^{*}$ coincide on all words of length strictly less than N.

Proof. 

If $d(L,L^{*})=0$, then $L=L^{*}$, and the conclusion is immediate.

Assume that $d(L,L^{*})>0$. By Definition 3, there exists an integer $k\ge 0$ such that

$$d(L,L^{*})=2^{-k},$$

where k is the smallest length at which L and $L^{*}$ differ. Since

$$d(L,L^{*})\le 2^{-N},$$

it follows that

$$2^{-k}\le 2^{-N},$$

hence

$$k\ge N.$$

Therefore the first disagreement between L and $L^{*}$ can occur only at a word of length at least N. Equivalently, L and $L^{*}$ coincide on all words of length strictly less than N.    □

4. Examples

Example 1. 

Let $\Sigma =\{a,b\}$ and consider the operator $T:\mathcal{L}\to \mathcal{L}$ given by

$$T\left(L\right)=\left\{\epsilon \right\}\cup aLb.$$

Here $S=\left\{\epsilon \right\}$, $p=1$, $u_1=a$, $v_1=b$, and $|u_1|+|v_1|=2$, hence T is guarded with guard length $m=2$.

Starting with $L^{\left(0\right)}=\varnothing$, the first iterates are

$$\begin{array}{cc}\hfill L^{\left(1\right)}& =T(\varnothing )=\left\{\epsilon \right\},\hfill \\ \hfill L^{\left(2\right)}& =T\left(\right\{\epsilon \left\}\right)=\{\epsilon ,ab\},\hfill \\ \hfill L^{\left(3\right)}& =T\left(\right\{\epsilon ,ab\left\}\right)=\{\epsilon ,ab,aabb\},\hfill \\ \hfill L^{\left(4\right)}& =T\left(\right\{\epsilon ,ab,aabb\left\}\right)=\{\epsilon ,ab,aabb,aaabbb\}.\hfill \end{array}$$

By induction one easily verifies that

$$L^{\left(n\right)}=\{a^k{b}^k:0\le k<n\}(n\ge 1).$$

Consequently, the limit (and hence the unique fixed point of T) is

$$L^{*}=\bigcup _{n\ge 1}{L}^{\left(n\right)}=\{a^k{b}^k:k\ge 0\}.$$

Moreover, since $m=2$, Lemma 4 gives contractivity with constant $2^{-2}$, and Theorem 4 yields convergence of the Picard iteration to the unique fixed point.

Example 2. 

Let $\Sigma =\{0,1\}$ and consider two operators $T_1,T_2:\mathcal{L}\to \mathcal{L}$ defined by

$$\begin{array}{cc}\hfill T_1\left(L\right)& =\left\{\epsilon \right\}\cup 0L1\cup 00L11,\hfill \\ \hfill T_2\left(L\right)& =\left\{\epsilon \right\}\cup 00L11\cup 000L111.\hfill \end{array}$$

Both operators are guarded, but with different guard lengths:

$$m_1=2\mathit{for}{T}_1\mathit{and}{m}_2=4\mathrm{for}{T}_2.$$

Starting with $L^{\left(0\right)}=\varnothing$, the first iterates for $T_1$ are

$$\begin{array}{cc}\hfill L_1^{\left(1\right)}& =\left\{\epsilon \right\},\hfill \\ \hfill L_1^{\left(2\right)}& =\{\epsilon ,01,0011\},\hfill \\ \hfill L_1^{\left(3\right)}& =\{\epsilon ,01,0011,000111,00001111\}.\hfill \end{array}$$

For $T_2$ we obtain

$$\begin{array}{cc}\hfill L_2^{\left(1\right)}& =\left\{\epsilon \right\},\hfill \\ \hfill L_2^{\left(2\right)}& =\{\epsilon ,0011,000111\},\hfill \\ \hfill L_2^{\left(3\right)}& =\{\epsilon ,0011,000111,00001111,0000011111,000000111111\}.\hfill \end{array}$$

The fixed points can be described explicitly. For $T_1$ one checks that

$$L_1^{*}=\{0^n{1}^n:n\ge 0\}.$$

Indeed, $T_1$ allows wrapping by $(0,1)$ and by $(00,11)$, hence every application increases the exponent by 1 or by 2, and all $n\ge 0$ are reachable.

For $T_2$ the allowed wrappings are $(00,11)$ and $(000,111)$, so the exponent increases by 2 or 3. Since the semigroup generated by 2 and 3 contains all integers $n\ge 2$, we obtain

$$L_2^{*}=\left\{\epsilon \right\}\cup \{0^n{1}^n:n\ge 2\}.$$

In particular, $L_2^{*}\subset L_1^{*}$.

Finally, the guard length controls the certified correctness depth: the contraction constants are

$$c_1=2^{-m_1}={\displaystyle \frac{1}{4}},c_2=2^{-m_2}={\displaystyle \frac{1}{16}},$$

so the error $d(L_i^{\left(n\right)},L_i^{*})$ decays faster for $T_2$ than for $T_1$.

Example 3. 

Let $\Sigma =\{x,y\}$ and define $T:\mathcal{L}\to \mathcal{L}$ by

$$T\left(L\right)=xLx\cup yLy.$$

This operator is guarded with seed $S=\varnothing$ and guard length $m=2$, since each wrapping adds one symbol on the left and one symbol on the right. Hence, by Lemma 4, T is a contraction on $(\mathcal{L},d)$ with constant $2^{-2}$, and therefore it has a unique fixed point.

Starting from $L^{\left(0\right)}=\left\{\epsilon \right\}$ we obtain

$$L^{\left(1\right)}=\{xx,yy\},L^{\left(2\right)}=\{xxxx,xyyx,yxxy,yyyy\},$$

and, in general, $L^{\left(n\right)}$ consists of palindromes of length exactly $2n$.

Although the set-theoretic union ${\bigcup }_{n\ge 0}{L}^{\left(n\right)}$ is the set of all even-length palindromes, the Picard iteration converges in the ultrametric to the empty language. Indeed, the shortest words in $L^{\left(n\right)}$ have length $2n$, so the first disagreement between $L^{\left(n\right)}$ and ∅ occurs at length $2n$, and therefore

$$d\left(L^{\left(n\right)},\varnothing \right)=2^{-2n}\underset{n\to \infty }{\to }0.$$

Since $T(\varnothing )=\varnothing$, the limit ∅ is a fixed point; by Banach’s theorem it is the unique fixed point of T.

This example shows that convergence in the length-based ultrametric means stabilization of membership on all words up to any fixed length, and does not coincide with convergence in terms of set-theoretic inclusion.

5. Applications in Computer Science

The results of the previous sections have natural applications in computer science, especially in recursively defined languages, data structures, and validation schemes. The basic idea is that recursion is well controlled whenever each recursive occurrence is separated from the outer context by a nonzero guard. In this case, the corresponding wrapping operator is a contraction in the metric space under consideration; that is, it reduces the distance between languages by a factor smaller than 1. From a computer-science perspective, this means that the recursive specification can be viewed not only as a formal description, but also as a computational process in which, for inputs of bounded length, there exists a provable bound beyond which the result is guaranteed to be correct.

5.1. Recursive Data Structures and Formats

The first direct application of the theory under consideration is to recursive data structures and formats, in which complex objects are constructed from simpler ones by adding a new outer structural layer. Such situations arise in XML (Extensible Markup Language) and HTML (Hypertext Markup Language) documents with nested tags [6], in Lisp-like expressions, in serialized trees, and in JSON (JavaScript Object Notation) objects with recursively nested substructures [7]. In this setting, the set of valid objects can be described by an operator that adds new correct wrappers around already valid substructures to the basic admissible cases. The fixed point of this operator then represents the language of all valid objects that can be generated through a finite number of construction steps. From a computer science perspective, the sequence of iterations $L^{\left(0\right)},L^{\left(1\right)},L^{\left(2\right)},\dots$ can be viewed as a series of progressively refined approximations of the valid format. The initial iterations cover only the simplest structures, while subsequent ones allow increasingly deeper nesting. This corresponds to the way parsers and validators for recursive formats operate in practice: they process the structure layer by layer rather than as a single indivisible object. Therefore, fixed-point theory provides both a formal description and a clear model for stepwise computation and validity checking.

Table 1. Examples of recursive data structures and formats with their computer science interpretation.

Example	Sample Recursive Construction	Computer Science Interpretation
HTML/XML documents	<tag>doc</tag>	Each new layer of tags adds an outer syntactic context; $L^{\left(n\right)}$ describes documents with nesting depth up to n.
S-expressions	(f expr)	An appropriate model for parsing nested Lisp-like terms, where each new expression contains an already valid subexpression.
JSON tree structure	{"value": x,"children": [node]}	Describes recursively nested objects; $L^{\left(n\right)}$ corresponds to trees of depth up to n.
Linked list	{"head": x,"tail": list}	Each new object adds one more node to the list; the iterations describe lists of length up to n.
Serialized abstract syntax tree	Add(expr,num),Neg(expr)	Each constructor builds a more complex expression from an already valid subexpression; $L^{\left(n\right)}$ describes trees with bounded syntactic depth.
Constructions in a Domain-Specific Language (DSL)	Wrap(cmd)	Each operator adds a new syntactic layer around an already valid command or expression.

Table 1. Examples of recursive data structures and formats with their computer science interpretation.

Example	Sample Recursive Construction	Computer Science Interpretation
HTML/XML documents	<tag>doc</tag>	Each new layer of tags adds an outer syntactic context; $L^{\left(n\right)}$ describes documents with nesting depth up to n.
S-expressions	(f expr)	An appropriate model for parsing nested Lisp-like terms, where each new expression contains an already valid subexpression.
JSON tree structure	{"value": x,"children": [node]}	Describes recursively nested objects; $L^{\left(n\right)}$ corresponds to trees of depth up to n.
Linked list	{"head": x,"tail": list}	Each new object adds one more node to the list; the iterations describe lists of length up to n.
Serialized abstract syntax tree	Add(expr,num),Neg(expr)	Each constructor builds a more complex expression from an already valid subexpression; $L^{\left(n\right)}$ describes trees with bounded syntactic depth.
Constructions in a Domain-Specific Language (DSL)	Wrap(cmd)	Each operator adds a new syntactic layer around an already valid command or expression.

5.2. Recursive Data Types, Abstract Syntax Trees, and Serialization

A particularly important application of the theory under consideration arises in recursive data types and abstract syntax trees (ASTs). In compilers, interpreters, and static analysis systems, more complex constructions are built from simpler ones through constructors that add a new outer layer around an already valid subexpression [8]. Thus, a valid structure can be viewed as the result of successive construction rather than merely as a formally specified object.

For example, in a language of arithmetic expressions with the constructors Num, Neg(expr), and Add(expr, Num), the corresponding operator may be written schematically as

$$T\left(L\right)=\left\{\mathtt{Num}\right\}\cup \mathtt{Neg}\left(L\right)\cup \mathtt{Add}(L,\mathtt{Num}),$$

which describes how new valid expressions are obtained from already valid ones.

In this case, the fixed point $L^{*}$ is the set of all well-formed serialized expressions, while $L^{\left(n\right)}$ contains the expressions of syntactic depth at most n. The same logic applies to classical data structures. A binary tree can be represented by Leaf and Node(left, right) [12], and a singly linked list by Cons(head, tail) [8]. In serialization, for example in JSON [7], this leads to forms such as {"head": value, "tail": List} or {"value": x, "children": [Tree, …]}. In both cases, the recursive part appears inside a clearly defined outer context. This wrapper plays the role of a guard and makes the step-by-step construction and verification of valid structures possible.

5.3. Validation under Limited Resources: The Length of the Guard as a Computational Parameter

One of the most practically relevant consequences of the theory is its application to validation under limited resources. In real systems, it is usually not necessary to determine validity for all possible unfoldings of recursion, but only for inputs up to a certain size—for example, a JSON document of fixed length [7], a syntax tree up to a given depth, or a query of limited volume. Therefore, the quantitative result of the paper has direct algorithmic meaning: if the minimum length of the outer wrapper is m, then after sufficiently many iterations the approximation $L^{\left(n\right)}$ already coincides with the fixed point on all inputs of length below N.

In the paper itself, this is formulated as an explicit bound of the form $n\ge N/m$ for correctness on words below a given length. From a computer science perspective, this means that the convergence theorem can be used as a formal stopping criterion. Instead of introducing an arbitrary recursion bound, the number of required steps can be derived from the structure of the specification itself. For a validator of nested JSON objects [11,14], a parser for Lisp-like expressions, or verification of serialized trees, this means that the necessary processing depth is not chosen heuristically, but is determined by the parameter m. Thus, the length of the guard becomes a measure not only of the structure of recursion, but also of the cost of its reliable computation.

Among the most important computer science interpretations of the theory under consideration is that the length of the guard can be viewed as a computational parameter. Mathematically, m is the minimum length of the mandatory outer wrapper added at each recursive step. From a computer science perspective, this is the amount of syntactic context that separates one recursive level from the next. The greater this value, the more quickly the iterations stabilize on inputs of limited length, since the contraction coefficient is $2^{-m}$. This also gives the result a clear practical meaning. A more explicit outer structure not only facilitates reading of the data, but also makes formal validation more predictable. For example, a JSON object with fields "head" and "tail" contains more mandatory structural context than an array in which the recursive element is placed directly. For this reason, a validator for a list may reach a correct result in fewer steps than a validator for a more general recursive array structure on the same input.

5.4. Restricted Fragment of Recursive JSON Schemas

The most direct practical application of the theory under consideration is to recursive JSON schemas [9,10,11]. Here, however, it must be clearly emphasised that the approach does not cover JSON Schema in its full generality, but rather a restricted recursive fragment in which the recursive occurrence is located within a clearly defined outer context—for example, inside an array, in an object with fixed keys [7], or within a nested property. In such cases, the language of valid JSON documents can be regarded as the result of step-by-step construction: one starts from the simplest admissible values and then gradually adds increasingly deeply nested structures. It is precisely this class of schemas that corresponds to the model of wrapping operators introduced in this paper.

A particularly noteworthy example is the model of nested comments in a social network. A comment may contain the fields "author", "text", and "replies", where "replies" is an array of new comments with the same structure. The initial approximation then describes comments without replies, the next one describes comments with one level of nested replies, and each subsequent step permits one more level of nesting. In the same way, a JSON representation of a linked list or a tree structure can be viewed as a serialization of classical recursive data types [8,12]. In this sense, the theory provides a clear model for the step-by-step construction and validation of recursive JSON structures when the recursion is placed within a sufficiently explicit structural wrapper.

5.5. Scope and Limitations

The proposed model is strongest for positive, structurally guarded recursive specifications that can be reduced to a finite wrapping operator. This includes formats with nested tags [6], abstract syntax trees [8], linked lists, tree-shaped JSON structures, and a limited but practically relevant fragment of recursive JSON schemas [9,11]. Under these conditions, the results of the previous sections provide, at once, unambiguous semantics, iterative convergence, and a formal validation bound for inputs of limited length.

At the same time, the model should not be regarded as a complete semantics for all possible schema languages with richer compositional operators [6,10]. The most accurate conclusion is that the theory under consideration provides a rigorous foundation for guarded recursive validation and the step-by-step unfolding of recursive structures, but it does not offer a definitive solution for all constructive possibilities of industrial schema standards [10,11].