Finite-state Acceptors with Translucent Letters

⋆

Benedek Nagy

and Friedrich Otto

Department of Computer Science, Faculty of Informatics, University of Debrecen

4032 Debrecen, Egyetem t´er 1., Hungary

Fachbereich Elektrotechnik/Informatik, Universit¨at Kassel, 34109 Kassel, Germany

Abstract. Finite-state acceptors with translucent letters are presented. These de-

vices do not read their input strictly from left to right as in the traditional setting,

but for each internal state of such a device, certain letters are translucent, that is,

in this state the acceptor cannot see them. We describe the computational power

of these acceptors, both in the deterministic and in the nondeterministic case. The

languages accepted have semi-linear Parikh images, and the nondeterministic ac-

ceptors are sufﬁciently expressive to accept all rational trace languages. However,

in contrast to the classical ﬁnite-state acceptors, the deterministic acceptors are

less expressive than the nondeterministic ones.

1 Introduction

The ﬁnite-state acceptor is a fundamental computing device for accepting languages. Its

deterministic version (DFA) and its nondeterministic version (NFA) both accept exactly

the regular languages, and they are being used in many areas like compiler construc-

tion, text editors, hardware design, etc. Of course, these acceptors are much too weak

for many applications, as the expressiveness of regular languages is quite limited. Ac-

cordingly, much more powerful models of automata have been introduced and studied

like, e.g., pushdown automata, linear-bounded automata, and Turing acceptors (ma-

chines). But this larger expressive power comes at a price in that certain algorithmic

questions like the word problem or the emptiness problem become more complex or

even undecidable. Hence, when dealing with applications, for example in natural lan-

guage processing or concurrency control, it is of importance to ﬁnd models of automata

that reconcile two contrasting goals: sufﬁcient expressiveness and a moderate degree of

complexity.

In the ﬁeld of natural language processing this has led to the formulation of the no-

tion of “mildly context-sensitivelanguages” [5,6]. These form a subclass of the context-

sensitive languages that is much more expressive than the context-free languages. They

⋆

This work was supported by grants from the Balassi Int´ezet Magyar

Oszt¨ond´ıj Bizotts´aga

OB) and the Deutsche Akademischer Austauschdienst (DAAD). The ﬁrst author was also

supported by the T

AMOP 4.2.1/B-09/1/KONV-2010-0007 project, which is implemented

through the New Hungary Development Plan, co-ﬁnanced by the European Social Fund and

the European Regional Development Fund.

Nagy B. and Otto F..

Finite-state Acceptors with Translucent Letters.

DOI: 10.5220/0003272500030013

In Proceedings of the 1st International Workshop on AI Methods for Interdisciplinary Research in Language and Biology (BILC-2011), pages 3-13

ISBN: 978-989-8425-42-3

 2011 SCITEPRESS (Science and Technology Publications, Lda.)

contain some typical examples of non-context-free languages like { a

| n ≥ 0 }

and { a

| m, n ≥ 0 }, but at the same time they share many of the nice proper-

ties with the context-free languages. For example, they have semi-linear Parikh images

and their parsing complexity is polynomially bounded.

In the study of concurrent systems, the theory of traces is an important area (see,

e.g., [2]), which has also received much attention in formal language theory. For trace

monoids the notions of recognizable and rational subsets do not coincide in general. For

recognizable trace languages a characterization in terms of automata is given through

Zielonka’s asynchronous automata (see [2]), while for rational trace languages a char-

acterization in terms of automata has only been given recently in terms of a special type

of cooperating distributed systems of restarting automata, the so-called CD-systems of

stateless deterministic R(1)-automata [7].

The restarting automaton is a formal device motivated by considerations from lin-

guistics (see, e.g., [4]), while CD-systems of formal systems are closely related to dis-

tributed computing and multiagent systems. In fact, CD-systems of stateless determin-

istic R(1)-automata are related to the binding-blocking automata of [1], which are bio-

logically motivated devices that do not process their input strictly in left-to-right order.

Here we describe an extension of the ﬁnite-state acceptor that vastly increases its

expressive power, the so-called “ﬁnite-state acceptor with translucent letters” (NFAwtl

for short). An NFAwtl does not read its input strictly from left to right as in the tradi-

tional setting, but for each of its internal states, certain letters are translucent, that is,

in this state the NFAwtl cannot see them. Accordingly, it may read (and erase) a let-

ter from the middle or the end of the given input. Here we consider the computational

power of these acceptors. They accept certain non-regular and even some non-context-

free languages, but all languages accepted by NFAwtls have semi-linear Parikh images.

In fact, NFAwtls are sufﬁciently expressive to accept all rational trace languages, but

they also accept some languages that are not rational trace languages. In contrast to the

classical ﬁnite-state acceptors, the deterministic variants of the NFAwtls, the so-called

DFAwtls, are less expressive than the nondeterministic ones, as DFAwtls do not accept

all rational trace languages. Finally, closure and non-closure properties for the class of

languages accepted by NFAwtls and some decidability and undecidability results for

them are presented.

Most of these results follow from translations of our acceptors with translucent let-

ters to the CD-systems of stateless deterministic R(1)-automata and back. However, we

think that our acceptors are much simpler than these CD-systems, and that they are

more easily accessible to non-experts.

This paper is structured as follows. In Section 2 we introduce the ﬁnite-state ac-

ceptor with translucent letters, we present two examples, and we state the ﬁrst results

on their expressive power. In Section 3 we consider rational trace languages, and in

Section 4 we present closure and non-closure results as well as some decidability and

undecidability results. In Section 5 we summarize our work and point to a number

of open problems for future work. Finally, in Section 6 we explain in detail how our

ﬁnite-state acceptors with translucent letters relate to the CD-systems of stateless deter-

ministic R(1)-automata of [7].

2 Finite-state Acceptors with Translucent Letters

Here we introduce the announced variant of the nondeterministic ﬁnite-state acceptor.

Deﬁnition 1. A ﬁnite-state acceptor with translucent letters (NFAwtl) is deﬁned as a

7-tuple A = (Q, Σ, $, τ, I, F, δ), where Q is a ﬁnite set of internal states, Σ is a ﬁnite

alphabet of input letters, $ 6∈ Σ is a special symbol that is used as an endmarker,

τ : Q → 2

is a translucency mapping, I ⊆ Q is a set of initial states, F ⊆ Q is a set

of ﬁnal states, and δ : Q × Σ → 2

is a transition relation. For each state q ∈ Q, the

letters from the set τ(q) are translucent for q, that is, in state q the automaton A does

not see these letters. A is called deterministic, abbreviated as DFAwtl, if |I| = 1 and if

|δ(q, a)| ≤ 1 for all q ∈ Q and all a ∈ Σ.

An NFAwtl A = (Q, Σ, $, τ, I, F, δ) works as follows. For an input word w ∈ Σ

∗

it starts in a nondeterministically chosen initial state q

∈ I with the word w · $ on its

input tape. Assume that w = a

· · · a

for some n ≥ 1 and a

, . . . , a

∈ Σ. Then A

looks for the ﬁrst occurrence from the left of a letter that is not translucent for state q

that is, if w = uav such that u ∈ (τ(q

))

∗

and a 6∈ τ(q

), then A nondeterministically

chooses a state q

∈ δ(q

, a), erases the letter a from the tape thus producing the tape

contents uv · $, and its internal state is set to q

. In case δ(q

, a) = ∅, A halts without

accepting. Finally, if w ∈ (τ(q

))

∗

, then A reaches the $-symbol and the computation

halts. In this case A accepts if q

is a ﬁnal state; otherwise, it does not accept. Thus, A

executes the following computation relation on its set Q · Σ

∗

· $ of conﬁgurations:

qw · $ ⊢











′

uv · $, if w = uav, u ∈ (τ(q))

∗

, a 6∈ τ(q), and q

′

∈ δ(q, a),

Reject, if w = uav, u ∈ (τ(q))

∗

, a 6∈ τ(q

), and δ(q, a) = ∅,

Accept, if w ∈ (τ(q))

∗

and q ∈ F,

Reject, if w ∈ (τ(q))

∗

and q 6∈ F.

Observe that this deﬁnition also applies to conﬁgurations of the form q · $, that is,

q · ε · $ ⊢

Accept holds if and only if q is a ﬁnal state. A word w ∈ Σ

∗

is accepted by

A if there exists an initial state q

∈ I and a computation q

w · $ ⊢

∗

Accept, where ⊢

∗

denotes the reﬂexive transitive closure of the single-step computation relation ⊢

. Now

L(A) = { w ∈ Σ

∗

| w is accepted by A } is the language accepted by A, L(NFAwtl)

denotes the class of all languages that are accepted by NFAwtls, and L(DFAwtl) denotes

the class of all languages that are accepted by DFAwtls.

The classical nondeterministic ﬁnite-state acceptor (NFA) is obtained from the

NFAwtl by removing the endmarker $ and by ignoring the translucency relation τ, and

the deterministic ﬁnite-state acceptor (DFA) is obtained from the DFAwtl in the same

way. Thus, the NFA (DFA) can be interpreted as a special type of NFAwtl (DFAwtl).

Accordingly, we havethe following, where REG denotes the class of regular languages.

Lemma 1. REG ⊆ L(DFAwtl) ⊆ L(NFAwtl).

However, already DFAwtls are much more expressive than standard DFAs.

Example 1. Let A = (Q, Σ, $, τ, I, F, δ), where Q = {q

, q

}, I = {q

} = F ,

Σ = {a, b, c}, and the functions τ and δ are deﬁned as follows:

τ(q

) = ∅, δ(q

, a) = {q

τ(q

) = {a, c}, δ(q

, b) = {q

τ(q

) = {a, b}, δ(q

, c) = {q

and δ(q, x) = ∅ for all other pairs (q, x) ∈ Q × Σ. Observe that A is in fact a DFAwtl.

Given the word w = abaccb as input, A will execute the following computation:

abaccb · $ ⊢

baccb · $ ⊢

accb · $ ⊢

acb · $ ⊢

cb · $

⊢

c · $ ⊢

· $ ⊢

Accept,

as q

is a ﬁnal state. In fact, it can be shown that

L(A) = { w ∈ Σ

∗

| |w|

= |w|

≥ 0,

and for each preﬁx u of w : |u|

≥ max{|u|

, |u|

} }.

This language is not context-free, as L(A) ∩ (a

∗

· b

∗

· c

∗

) = { a

| n ≥ 0 }.

Thus, already DFAwtls accept non-context-free languages, that is, we have the

proper inclusion REG ( L(DFAwtl).

An NFAwtl A = (Q, Σ, $, τ, I, F, δ) can be described by a graph, similar to the

graph representation of NFAs. A state q ∈ Q is represented by a node labelled q, where

the node of an initial state p is marked by a special incoming edge without a label, and

the node of a ﬁnal state p is marked by a special outgoing edge with label (τ(p))

∗

. For

each state q ∈ Q and each letter a ∈ Σ r τ(q), if δ(q, a) = {q

, . . . , q

}, then there is

a directed edge labelled ((τ(q))

∗

, a) from the node corresponding to state q to the node

corresponding to state q

for each i = 1, . . . , s. The graph representation of the DFAwtl

A of Example 1 is given in Figure 1, where {ε} is used instead of ∅

∗

?>=<89:;

({ε},a)





{ε}

?>=<89:;

({a,c}

∗

,b)

?>=<89:;

({a,b}

∗

,c)

ccG

Fig.1. The graphical representation of the DFAwtl A of Example 1.

Example 2. An NFTwtl for the language

{ a

w | n ≥ 1, w ∈ {a, b, c}

satisfying |w|

= |w|

}

is described by the diagram in Figure 2.

?>=<89:;

({ε},a)

?>=<89:;

({b,c}

∗

,a)





?>=<89:;

({a,c}

∗

,b)

?>=<89:;

({a,b}

∗

,c)

({a,b}

∗

,c)

bbE

?>=<89:;

{ε}

Fig.2. The graphical representation of an NFAwtl accepting the language { a

w | n ≥ 1, w ∈

{a, b, c}

satisfying |w|

= |w|

According to the deﬁnition above,an NFAwtl may accept a word without processing

it completely. For example, the NFAwtl A

= ({q}, {a}, $, τ, {q}, {q}, δ) deﬁned by

τ(q) = {a} and δ(q, a) = ∅ accepts each word from a

∗

in a single step. This, however,

is only a convenience, as shown by the following normal form result.

Proposition 1. From a given NFAwtl A = (Q, Σ, $, τ, I, F, δ) one can effectively con-

struct an NFAwtl B = (Q

′

, Σ, $, τ

′

, I

′

, F

′

, δ

′

) such that L(B) = L(A), but for each

word w ∈ L(B), each accepting computation of B on input w consists of |w| many

reading steps plus a ﬁnal step that accepts the empty word.

Observe that the DFAwtl of Example 1 and the NFAwtl of Example 2 are in normal

form. Nevertheless it remains open whether Proposition 1 holds for DFAwtls in general.

If A is an NFAwtl on Σ that is in normal form, then by removing the translucency

relation from A, we obtain a standard NFA A

′

that has the following properties.

Proposition 2. By removing the translucency relation from an NFAwtl A in normal

form, we obtain an NFA A

′

such that L(A

′

) is a subset of L(A) that is letter-equivalent

to L(A).

Here two languages over the same alphabet Σ = {a

, . . . , a

} are called letter-

equivalent if they have the same image under the Parikh mapping ψ : Σ

∗

→ N

. Thus,

we see that each language from L(NFAwtl) is letter-equivalent to a regular language.

This yields the following consequence.

Corollary 1. All languages in L(NFAwtl) are semi-linear, that is, if L ⊆ Σ

∗

is ac-

cepted by some NFAwtl, then ψ(L) is a semi-linear subset of N

As the languages { a

| n ≥ 0 } and { a

| n ≥ 0 } do not contain regular

sublanguages that are letter-equivalent to the languages themselves, it follows from

Proposition 2 that these languages are not accepted by any NFAwtls.

3 Rational Trace Languages

Let Σ be a ﬁnite alphabet, and let D be a binary relation on Σ that is reﬂexive and

symmetric, that is, (a, a) ∈ D for all a ∈ Σ, and (a, b) ∈ D implies that (b, a) ∈ D,

too. Then D is called a dependency relation on Σ, and the relation I

= (Σ×Σ)rD is

called the correspondingindependence relation. Obviously, the relation I

is irreﬂexive

and symmetric. The independence relation I

induces a binary relation ≡

on Σ

∗

that

is deﬁned as the smallest congruence relation containing the set of pairs { (ab, ba) |

(a, b) ∈ I

}. For w ∈ Σ

∗

, the congruence class of w mod ≡

is denoted by [w]

, that

is, [w]

= { z ∈ Σ

∗

| w ≡

z }. These congruence classes are called traces, and the

factor monoid M (D) = Σ

∗

/ ≡

is a trace monoid. In fact, M(D) is the free partially

commutative monoid presented by (Σ, D) (see, e.g., [2]).

Traces are being used in concurrency theory to describe sequences of actions that

are partially independent of each other. Let a and b symbolize two actions that are

executed in parallel. If they are independent, then in a sequential simulation it does not

matter in which order they are executed, that is, ab and ba are equivalent. As such traces

have received much attention (see, e.g., [2]).

If M (D) is a trace monoid generated by Σ, then we use ϕ

to denote the morphism

: Σ

∗

→ M (D) that is deﬁned by w 7→ [w]

for all words w ∈ Σ

∗

. We call a

language L ⊆ Σ

∗

a rational trace language, if there exists a dependency relation D on

Σ such that L = ϕ

−1

(S) for a rational subset S of the trace monoid M(D) presented

by (Σ, D), that is, if there exist a trace monoid M(D) and a regular language R ⊆ Σ

∗

such that L = ϕ

−1

(ϕ

(R)) =

w∈R

[w]

. By LRAT we denote the class of all

rational trace languages.

Theorem 1. LRAT ( L(NFAwtl).

The above inclusion is proper as the Dyck language D

′

∗

, which is not a rational trace

language, is accepted by a DFAwtl. On the other hand, the following technical result

shows that Theorem 1 does not extend to DFAwtls.

Proposition 3. The rational trace language

∨

= { w ∈ {a, b}

∗

| ∃n ≥ 0 : |w|

= n and |w|

∈ {n, 2n} }

is not accepted by any DFAwtl.

It follows that L(DFAwtl) and LRAT are incomparable under inclusion.

4 Closure Properties and Decidability Results

Proposition 4.

(a) The language class L(NFAwtl) is closed under union, product, and Kleene star.

(b) The language class L(NFAwtl) is neither closed under intersection with regular

languages, nor under complementation, nor under ε-free morphisms.

The commutative closure com(L) of a language L ⊆ Σ

∗

is the set of all words that

are letter-equivalent to a word from L, that is,

com(L) = ψ

−1

(ψ(L)) = { w ∈ Σ

∗

| ∃ u ∈ L : ψ(w) = ψ(u) },

where ψ : Σ

∗

→ N

|Σ|

denotes the Parikh mapping. If L is accepted by an NFAwtl A in

normal form, then from A we obtain a ﬁnite-state acceptor A

′

for a regular sublanguage

E of L that is letter-equivalent to L by ignoring the transparency relation (Proposi-

tion 2). Obviously, the commutative closure com(L) of L coincides with the commu-

tative closure com(E) of E. For the dependency relation D = { (a, a) | a ∈ Σ },

the trace monoid M(D) is the free commutative monoid generated by Σ. Thus,

com(E) =

w∈E

[w]

is simply the rational trace language ϕ

−1

(ϕ

(E)). Hence,

it follows from Theorem 1 that this language is accepted by an NFAwtl B.

Corollary 2. The language class L(NFAwtl) is closed under the operation of taking

the commutative closure.

A language L ⊆ Σ

∗

is called commutative if com(L) = L holds, that is, if it

contains all permutations of all its elements. As each semi-linear language is letter-

equivalent to some regular language, it follows that each commutative semi-linear lan-

guage is the commutativeclosure of some regular language, and therewith it is a rational

trace language. Thus, Theorem 1 implies the following result.

Corollary 3. All commutative semi-linear languages are contained in L(NFAwtl).

If L

⊆ Σ

∗

and L

⊆ Γ

∗

are languages, then the shufﬂe of L

and L

is deﬁned as

sh(L

, L

) = { u

· · · u

| n ≥ 1, u

· · · u

∈ L

, v

· · · v

∈ L

If Σ and Γ are disjoint, then sh(L

, L

) is called a disjoint shufﬂe.

Proposition 5. The language class L(NFAwtl) is closed under disjoint shufﬂe.

However, it is still open whether the language class L(NFAwtl) is closed under in-

verse morphisms or under the operation of reversal. An NFAwtl can easily be simulated

by a nondeterministic one-tape Turing machine that is simultaneously linearly space-

bounded and quadratically time-bounded. Hence, we have the complexity result.

Proposition 6. L(NFAwtl) ⊆ NSpaceTime(n, n

It follows in particular that L(NFAwtl) only contains context-sensitive languages.

Proposition 2 yields an effective construction of a ﬁnite-state acceptor A

′

from an

NFAwtl A such that the language E = L(A

′

) is a subset of the language L = L(A)

that is letter-equivalent to L. Hence, E is non-empty if and only if L is non-empty, and

E is inﬁnite if and only if L is inﬁnite. As the emptiness problem and the ﬁniteness

problem are decidable for ﬁnite-state acceptors, this immediately yields the following

decidability results.

Proposition 7. The following decision problems are effectively decidable:

Instance : An NFAwtl A.

Question 1 : Is the language L(A) empty?

Question 2 : Is the language L(A) ﬁnite?

On the other hand, it is undecidable in general whether a rational trace language is

recognizable (see, e.g., [2]). As a rational subset S of a trace monoid M(D) is recogniz-

able if and only if ϕ

−1

(S) is a regular language, we obtain the following undecidability

result from Theorem 1.

Proposition 8. The following decision problem is undecidable in general:

Instance : An NFAwtl A.

Question : Is the language L(A) regular?

By a reduction from the universality problem for rational transducers, which is un-

decidable in general [3], also the following undecidability results can be derived.

Proposition 9. The following problems are undecidable in general:

Instance : Two NFAwtls A

and A

Question 1 : Is L(A

) contained in L(A

Question 2 : Are A

and A

equivalent, that is, does L(A

) = L(A

) hold?

5 Conclusions

We have presented ﬁnite-state acceptors with translucent letters, and we have seen that

they are quite expressive. In fact they accept a subclass of the class of all languages

with semi-linear Parikh image that properly contains all rational trace languages. As

the deterministic variants of our acceptors do not accept all rational trace languages,

it remains to characterize their expressive power. In particular, which rational trace

languages are accepted by DFAwtls? Then we have given a number of closure and non-

closure results for the language class L(NFAwtl), but it remains open whether or not

this class is closed under inverse morphisms or under the operation of reversal. Also the

closure and non-closure properties of the class L(DFAwtl) remain to be studied.

It appears that the fact that the translucency mapping only depends on the actual

state but not on the letter actually processed is one of the reasons for the limited expres-

sive power of DFAwtls. Hence, we plan to also study a variant of the DFAwtl in which

the translucency mapping depends on the actual state and the letter read (erased).

6 Proofs

The NFAwtl considered here is closely related to the so-called cooperating distributed

system of stateless deterministic R(1)-automata that was introduced in [7].

A stateless deterministic R(1)-automaton is a one-tape machine with a read/write

window of size 1. Formally it is described by a 5-tuple M = (Σ, c, $, 1, δ), where Σ is

a ﬁnite alphabet, the symbols c, $ 6∈ Σ serve as markers for the left and right border of

the work space, respectively, and δ : Σ ∪ {c, $} → {MVR, Accept, ε, ∅} is a (partial)

transition function. There are three types of transition steps: move-right steps (MVR),

which shift the window one step to the right, combined rewrite/restart steps (ε), which

delete the content a (a ∈ Σ) of the window, thereby shortening the tape, and place

the window over the left end of the tape, and accept steps (Accept), which cause the

automaton to halt and accept. If δ(a) = ∅, then no step is possible and the automaton

halts and rejects.

A conﬁguration of M is described by a pair (α, β), where either α = ε and β ∈

{c} · Σ

∗

· {$} or α ∈ {c} · Σ

∗

and β ∈ Σ

∗

· {$}; here αβ is the current content of

the tape, and it is understood that the head scans the ﬁrst symbol of β. A restarting

conﬁguration is of the form (ε, cw$), where w ∈ Σ

∗

. By ⊢

we denote the single-step

computation relation of M, and ⊢

∗

denotes the reﬂexive transitive closure of ⊢

The automaton M proceeds as follows. Starting from an initial conﬁguration

(ε, cw$), the window moves right until a conﬁguration of the form (cx, ay$) is reached

such that δ(a) = ε. Now the latter conﬁguration is transformed into the restarting

conﬁguration (ε, cxy$). This computation, which is called a cycle, is expressed as

w ⊢

xy. A computation of M now consists of a ﬁnite sequence of cycles that is

followed by a tail computation, which consists of a sequence of move-right operations

possibly followed by an accept step. An input word w ∈ Σ

∗

is accepted by M, if

the computation of M which starts with the initial conﬁguration (ε, cw$) ﬁnishes by

executing an accept step. By L(M) we denote the language consisting of all words

accepted by M.

If M = (Σ, c, $, 1, δ) is a stateless deterministic R(1)-automaton, then we can par-

tition its alphabet Σ into four disjoint subalphabets:

(1.) Σ

= { a ∈ Σ | δ(a) = MVR}, (3.) Σ

= { a ∈ Σ | δ(a) = Accept},

(2.) Σ

= { a ∈ Σ | δ(a) = ε }, (4.) Σ

= { a ∈ Σ | δ(a) = ∅ } .

A cooperating distributed system of stateless deterministic R(1)-automata (or

a stl-det-local-CD-R(1)-system for short) consists of a ﬁnite collection M =

((M

, σ

)

j∈J

, J

) of stateless deterministic R(1)-automata M

= (Σ, c, $, 1, δ

) (j ∈

J), successor relations σ

⊆ J (j ∈ J), and a subset J

⊆ J of initial indices. Here it

is required that J

6= ∅, and that σ

6= ∅ for all j ∈ J. Various modes of operation have

been introduced and studied, but here we are only interested in mode = 1 computations.

A computation of M (in mode = 1) on an input word w proceeds as follows.

First an index j

∈ J

is chosen nondeterministically. Then the R-automaton M

starts the computation with the initial conﬁguration (ε, cw$), and executes a single

cycle. Thereafter an index j

∈ σ

is chosen nondeterministically, and M

continues

the computation by executing a single cycle. This continues until, for some l ≥ 0,

the machine M

accepts. Should at some stage the chosen machine M

be unable

to execute a cycle or to accept, then the computation fails. By L(M) we denote the

language that the system M accepts. By L(stl-det-local-CD-R(1)) we denote the class

of languages that are accepted by stl-det-local-CD-R(1)-systems.

If A = (Q, Σ, $, τ, I, F, δ) is an NFAwtl, then we can assign a stl-det-local-CD-

R(1)-system M to it by deﬁning M = ((M

, σ

)

j∈J

, J

) as follows. The set of indices

is J = Q × Σ, and J

= I × Σ. For all pairs (q, a) ∈ J, M

(q,a)

= (Σ, c, $, 1, δ

(q,a)

)

is deﬁned by the following transition relation and successor set:

(q,a)

(b) = MVR for all b ∈ τ(q),

(q,a)

($) = Accept, if q ∈ F, δ

(q,a)

(a) = ε, if a 6∈ τ(q) and δ(q, a) 6= ∅,

(q,a)



δ(q, a) × Σ, if δ(q, a) 6= ∅,

Q × Σ, otherwise.

Further,δ

(q,a)

($) = ∅ , if q is not

a ﬁnal state of A. Observe that the automaton M

(q,a)

cannot make any rewrite/restart

step, and hence, its successor set is never used, if a ∈ τ(q) or δ(q, a) = ∅.

A computation step q

uav · $ ⊢

uv · $ of A is simulated by the component

,a)

of M as (ε, c· uav · $) ⊢

∗

,a)

(c· u, av · $) ⊢

,a)

(ε, c· uv · $). Further, an

accepting step of A of the form q

u·$ ⊢

Accept is simulated by a component M

,a)

as (ε, c·u·$) ⊢

∗

,a)

(c·u, $) ⊢

,a)

Accept. Thus, in order to simulate an accepting

computation of A, one must guess the next letter to be deleted in each step, and choose

the corresponding component of M. It now follows easily that L(M) = L(A) holds.

Conversely, if M = ((M

, σ

)

j∈J

, J

) is a CD-system of stateless deterministic

R(1)-automata M

= (Σ, c, $, 1, δ

) (j ∈ J), then we can associate an NFAwtl A =

(J ∪ {+}, Σ, $, τ, J

, F, δ) to M as follows. For each index j ∈ J, we deﬁne the

translucency mapping τ and the transition function δ as follows:

τ(j) =



Σ, if δ

(j)

, otherwise,



δ(j, a) = σ

for all a ∈ Σ

(j)

δ(j, b) = {+} for all b ∈ Σ

(j)

Here Σ

(j)

, Σ

(j)

, and Σ

(j)

are the subsets of Σ mentioned above that correspond to the

R(1)-automaton M

. Further, we deﬁne τ(+) = Σ and

F = { j ∈ J | δ

($) = Accept} ∪ {+}.

It can now be veriﬁed that A can simulate the accepting computations of M in a step-

wise fashion. Thus, it follows that L(A) = L(M) holds.

Now Proposition 1 and Theorem 1 are immediate consequences of the above cor-

respondence and the results on stl-det-local-CD-R(1)-systems presented in [7], while

the closure and non-closure results as well as the decidability and undecidability results

follow from [8].

References

1. Balan, M.S.: Automaton models inpsired by peptide computing. In: Domaratzki, M., Salo-

maa, K. (eds.): UC’07, Workshop on Language Theory in Biocomputing, Proc., Kingston,

Ontario, Canada (2007) 1–15

2. Diekert, V., Rozenberg, G. (eds.): The Book of Traces, World Scientiﬁc, Singapore (1995)

3. Ibarra, O.: Reversal-bounded multicounter machines and their decision problems. J. As-

soc. Comput. Mach. 25 (1978) 116–133

4. Janˇcar, P., Mr´az, F., Pl´atek, M., Vogel, J.: Restarting automata. In: Reichel, H. (ed.): FCT

1995, Proc., Lecture Notes in Computer Science, Vol. 965, Springer-Verlag, Berlin Heidel-

berg (1995) 283–292

5. Joshi, A.K.: Mildly Context-Sensitive Grammars. http://www.kornai.com/MatLing/

mcsﬁn.pdf (12.11.2010)

6. Mery, B., Amblard, M., Durand, I., Retor´e, C.: A Case Study of the Convergence of Mildly

Context-Sensitive Formalisms for Natural Language Syntax: from Minimalist Grammars to

Multiple Context-Free Grammars. Rapport de recherche, nr. 6042, INRIA Futurs, Parc Club

Orsay Universit´e, Orsay (2006)

7. Nagy, B., Otto, F.: CD-systems of stateless deterministic R(1)-automata accept all rational

trace languages. In: Dediu, A.H., Fernau, H., Martin-Vide, C. (eds.): LATA 2010, Proc.,

Lecture Notes in Computer Science, Vol. 6031, Springer-Verlag, Berlin Heidelberg (2010)

463–474

8. Nagy, B., Otto, F.: CD-Systems of Stateless Deterministic R-Automata with Window

Size One. Kasseler Informatikschriften 2/2010, Fachbereich Elektrotechnik/Informatik,

Universit¨at Kassel, 2010. https://kobra.bibliothek.uni-kassel.de/handle/ urn:nbn:de:hebis:34-

2010042732682