Finite-state Acceptors with Translucent Letters
Benedek Nagy
1
and Friedrich Otto
2
1
Department of Computer Science, Faculty of Informatics, University of Debrecen
4032 Debrecen, Egyetem t´er 1., Hungary
2
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 sufficiently 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 finite-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 find models of automata
that reconcile two contrasting goals: sufficient expressiveness and a moderate degree of
complexity.
In the field 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
(M
¨
OB) and the Deutsche Akademischer Austauschdienst (DAAD). The first 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-financed 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
Copyright
c
2011 SCITEPRESS (Science and Technology Publications, Lda.)
contain some typical examples of non-context-free languages like { a
n
b
n
c
n
| n 0 }
and { a
n
b
m
c
n
d
m
| 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 finite-state acceptor that vastly increases its
expressive power, the so-called “finite-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 sufficiently expressive to accept all rational trace languages, but
they also accept some languages that are not rational trace languages. In contrast to the
classical finite-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 finite-state ac-
ceptor with translucent letters, we present two examples, and we state the first 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
finite-state acceptors with translucent letters relate to the CD-systems of stateless deter-
ministic R(1)-automata of [7].
4
2 Finite-state Acceptors with Translucent Letters
Here we introduce the announced variant of the nondeterministic finite-state acceptor.
Definition 1. A finite-state acceptor with translucent letters (NFAwtl) is defined as a
7-tuple A = (Q, Σ, $, τ, I, F, δ), where Q is a nite set of internal states, Σ is a finite
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 final states, and δ : Q × Σ 2
Q
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
0
I with the word w · $ on its
input tape. Assume that w = a
1
a
2
· · · a
n
for some n 1 and a
1
, . . . , a
n
Σ. Then A
looks for the first occurrence from the left of a letter that is not translucent for state q
0
,
that is, if w = uav such that u (τ(q
0
))
and a 6∈ τ(q
0
), then A nondeterministically
chooses a state q
1
δ(q
0
, a), erases the letter a from the tape thus producing the tape
contents uv · $, and its internal state is set to q
1
. In case δ(q
0
, a) = , A halts without
accepting. Finally, if w (τ(q
0
))
, then A reaches the $-symbol and the computation
halts. In this case A accepts if q
0
is a final state; otherwise, it does not accept. Thus, A
executes the following computation relation on its set Q · Σ
· $ of configurations:
qw · $
A
q
uv · $, if w = uav, u (τ(q))
, a 6∈ τ(q), and q
δ(q, a),
Reject, if w = uav, u (τ(q))
, a 6∈ τ(q
0
), and δ(q, a) = ,
Accept, if w (τ(q))
and q F,
Reject, if w (τ(q))
and q 6∈ F.
Observe that this definition also applies to configurations of the form q · $, that is,
q · ε · $
A
Accept holds if and only if q is a final state. A word w Σ
is accepted by
A if there exists an initial state q
0
I and a computation q
0
w · $
A
Accept, where
A
denotes the reflexive transitive closure of the single-step computation relation
A
. 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 finite-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.
5
Example 1. Let A = (Q, Σ, $, τ, I, F, δ), where Q = {q
0
, q
1
, q
2
}, I = {q
0
} = F ,
Σ = {a, b, c}, and the functions τ and δ are defined as follows:
τ(q
0
) = , δ(q
0
, a) = {q
1
},
τ(q
1
) = {a, c}, δ(q
1
, b) = {q
2
},
τ(q
2
) = {a, b}, δ(q
2
, c) = {q
0
},
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:
q
0
abaccb · $
A
q
1
baccb · $
A
q
2
accb · $
A
q
0
acb · $
A
q
1
cb · $
A
q
2
c · $
A
q
0
· $
A
Accept,
as q
0
is a final state. In fact, it can be shown that
L(A) = { w Σ
| |w|
a
= |w|
b
= |w|
c
0,
and for each prefix u of w : |u|
a
max{|u|
b
, |u|
c
} }.
This language is not context-free, as L(A) (a
· b
· c
) = { a
n
b
n
c
n
| 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 final 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
1
, . . . , q
s
}, then there is
a directed edge labelled ((τ(q))
, a) from the node corresponding to state q to the node
corresponding to state q
i
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:;
q
0
({ε},a)
{ε}
//
?>=<89:;
q
1
({a,c}
,b)
//
?>=<89:;
q
2
({a,b}
,c)
ccG
G
G
G
G
G
G
G
G
G
G
G
Fig.1. The graphical representation of the DFAwtl A of Example 1.
Example 2. An NFTwtl for the language
{ a
n
w | n 1, w {a, b, c}
+
satisfying |w|
a
= |w|
b
= |w|
c
}
is described by the diagram in Figure 2.
6
//
?>=<89:;
0
({ε},a)
MM
({ε},a)
//
?>=<89:;
1
({b,c}
,a)
?>=<89:;
2
({a,c}
,b)
//
?>=<89:;
3
({a,b}
,c)
//
({a,b}
,c)
bbE
E
E
E
E
E
E
E
E
E
E
E
?>=<89:;
4
{ε}
//
Fig.2. The graphical representation of an NFAwtl accepting the language { a
n
w | n 1, w
{a, b, c}
+
satisfying |w|
a
= |w|
b
= |w|
c
}.
According to the definition above,an NFAwtl may accept a word without processing
it completely. For example, the NFAwtl A
1
= ({q}, {a}, $, τ, {q}, {q}, δ) defined 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 final 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
1
, . . . , a
n
} are called letter-
equivalent if they have the same image under the Parikh mapping ψ : Σ
N
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
n
.
As the languages { a
n
b
n
| n 0 } and { a
n
b
n
c
n
| 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 finite alphabet, and let D be a binary relation on Σ that is reflexive 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
D
= (Σ×Σ)rD is
7
called the correspondingindependence relation. Obviously, the relation I
D
is irreflexive
and symmetric. The independence relation I
D
induces a binary relation
D
on Σ
that
is defined as the smallest congruence relation containing the set of pairs { (ab, ba) |
(a, b) I
D
}. For w Σ
, the congruence class of w mod
D
is denoted by [w]
D
, that
is, [w]
D
= { z Σ
| w
D
z }. These congruence classes are called traces, and the
factor monoid M (D) = Σ
/
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 ϕ
D
to denote the morphism
ϕ
D
: Σ
M (D) that is defined by w 7→ [w]
D
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
D
(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
D
(ϕ
D
(R)) =
S
wR
[w]
D
. 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
1
, 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
L
= { w {a, b}
| n 0 : |w|
a
= n and |w|
b
{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) },
8
where ψ : Σ
N
|Σ|
denotes the Parikh mapping. If L is accepted by an NFAwtl A in
normal form, then from A we obtain a finite-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) =
S
wE
[w]
D
is simply the rational trace language ϕ
1
D
(ϕ
D
(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
1
Σ
and L
2
Γ
are languages, then the shuffle of L
1
and L
2
is defined as
sh(L
1
, L
2
) = { u
1
v
1
u
2
· · · u
n
v
n
| n 1, u
1
· · · u
n
L
1
, v
1
· · · v
n
L
2
}.
If Σ and Γ are disjoint, then sh(L
1
, L
2
) is called a disjoint shuffle.
Proposition 5. The language class L(NFAwtl) is closed under disjoint shuffle.
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
2
).
It follows in particular that L(NFAwtl) only contains context-sensitive languages.
Proposition 2 yields an effective construction of a finite-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 infinite if and only if L is infinite. As the emptiness problem and the finiteness
problem are decidable for finite-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) finite?
9
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
D
(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
1
and A
2
.
Question 1 : Is L(A
1
) contained in L(A
2
)?
Question 2 : Are A
1
and A
2
equivalent, that is, does L(A
1
) = L(A
2
) hold?
5 Conclusions
We have presented finite-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 finite 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
10
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 configuration 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 first symbol of β. A restarting
configuration is of the form (ε, cw$), where w Σ
. By
M
we denote the single-step
computation relation of M, and
M
denotes the reflexive transitive closure of
M
.
The automaton M proceeds as follows. Starting from an initial configuration
(ε, cw$), the window moves right until a configuration of the form (cx, ay$) is reached
such that δ(a) = ε. Now the latter configuration is transformed into the restarting
configuration (ε, cxy$). This computation, which is called a cycle, is expressed as
w
c
M
xy. A computation of M now consists of a finite 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 configuration (ε, cw$) finishes 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.) Σ
1
= { a Σ | δ(a) = MVR}, (3.) Σ
3
= { a Σ | δ(a) = Accept},
(2.) Σ
2
= { a Σ | δ(a) = ε }, (4.) Σ
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 finite collection M =
((M
j
, σ
j
)
jJ
, J
0
) of stateless deterministic R(1)-automata M
j
= (Σ, c, $, 1, δ
j
) (j
J), successor relations σ
j
J (j J), and a subset J
0
J of initial indices. Here it
is required that J
0
6= , and that σ
j
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
0
J
0
is chosen nondeterministically. Then the R-automaton M
j
0
starts the computation with the initial configuration (ε, cw$), and executes a single
cycle. Thereafter an index j
1
σ
j
0
is chosen nondeterministically, and M
j
1
continues
the computation by executing a single cycle. This continues until, for some l 0,
the machine M
j
l
accepts. Should at some stage the chosen machine M
j
l
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 defining M = ((M
j
, σ
j
)
jJ
, J
0
) as follows. The set of indices
is J = Q × Σ, and J
0
= I × Σ. For all pairs (q, a) J, M
(q,a)
= (Σ, c, $, 1, δ
(q,a)
)
is defined by the following transition relation and successor set:
11
δ
(q,a)
(c) = MVR, δ
(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)
(c) = for all letters c (Σr(τ(q){a})), and δ
(q,a)
($) = , if q is not
a final 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
1
uav · $
A
q
2
uv · $ of A is simulated by the component
M
(q
1
,a)
of M as (ε, c· uav · $)
M
(q
1
,a)
(c· u, av · $)
M
(q
1
,a)
(ε, c· uv · $). Further, an
accepting step of A of the form q
1
u·$
A
Accept is simulated by a component M
(q
1
,a)
as (ε, c·u·$)
M
(q
1
,a)
(c·u, $)
M
(q
1
,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
)
jJ
, J
0
) is a CD-system of stateless deterministic
R(1)-automata M
j
= (Σ, c, $, 1, δ
j
) (j J), then we can associate an NFAwtl A =
(J {+}, Σ, $, τ, J
0
, F, δ) to M as follows. For each index j J, we define the
translucency mapping τ and the transition function δ as follows:
τ(j) =
Σ, if δ
j
(c) = Accept,
Σ
(j)
1
, otherwise,
,
δ(j, a) = σ
j
for all a Σ
(j)
2
,
δ(j, b) = {+} for all b Σ
(j)
3
.
Here Σ
(j)
1
, Σ
(j)
2
, and Σ
(j)
3
are the subsets of Σ mentioned above that correspond to the
R(1)-automaton M
j
. Further, we define τ(+) = Σ and
F = { j J | δ
j
($) = Accept} {+}.
It can now be verified 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 Scientific, 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
12
5. Joshi, A.K.: Mildly Context-Sensitive Grammars. http://www.kornai.com/MatLing/
mcsfin.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
13