Descriptional Complexity of Bounded Regular Languages

[Formula: see text] is a binary coded unary regular language, if there exists a unary regular language [Formula: see text] such that [Formula: see text] is in [Formula: see text] if and only if the binary representation of [Formula: see text] is in [Formula: see text]. If a unary language [Formula: see text] is accepted by a minimal deterministic finite automaton (DFA) [Formula: see text] with [Formula: see text] states, then its binary coded version [Formula: see text] is regular and can be accepted by a DFA [Formula: see text] using at most [Formula: see text] states, but at least [Formula: see text] states. There are witness languages matching these upper and lower bounds exactly, for each [Formula: see text]. More precisely, if [Formula: see text] uses [Formula: see text] states in the initial segment and [Formula: see text] states in the loop, where [Formula: see text] is odd and [Formula: see text], then the minimal [Formula: see text] for [Formula: see text] consists of a preamble with at most [Formula: see text] but at least [Formula: see text] states, except for [Formula: see text] with no preamble, and a kernel with at most [Formula: see text] but at least [Formula: see text] states. Also these lower bounds are matched exactly by witness languages, for each [Formula: see text]. If the length of the loop is fixed, the size of the preamble is bounded by [Formula: see text]. The conversion in the opposite way is not always granted: there are binary regular languages the unary versions of which are not even context free. The conversion of a unary nondeterministic finite automaton (NFA) to a binary NFA uses [Formula: see text] states and introduces a binary version of Chrobak normal form.

We investigate the deterministic and nondeterministic state complexity of languages resulting from the concatenation of two regular languages represented by deterministic and nondeterministic finite automata. We prove that the whole range of complexities up to the known upper bounds can be obtained in both cases.

Meyer and Fischer b][MF] proved that nondeterministic finite automata (NFA) can be exponentially more concise than deterministic finite automata (DFA) in their representations of regular languages. Several variants of that basic finite state machine model are now being used to analyze parallelism and to build real-time software systems [HL+]. Even though these variants can sometimes represent regular languages in a more concise manner than NFA, the underlying models fundamentally differ from NFA in how they operate. Degree automata [W] (DA), however, differ from NFA only in their acceptance criteria and accept only regular languages. We show here that DA are also exponentially more concise than NFA on some sequences of regular languages. We also show that the conciseness of probabilistic automata [R] with isolated cutpoints can be unbounded over DA and, concurrently, i.e., over the same sequence of languages, those DA can be exponentially more concise than NFA.

We investigate the descriptional and computational complexity of boundary sets of regular and context-free languages. The right (left, respectively) a-boundary set of a language L are those words that belong to L, where the a-predecessor or the a-successor of these words w.r.t. the prefix (suffix, respectively) relation is not in L. For regular languages described by deterministic finite automata (DFAs) we give tight bounds on the number of states for accepting boundary sets. Moreover, the question whether the boundary sets of a regular language is finite is shown to be NL-complete for DFAs, while it turns out to be PSPACE-complete for nondeterministic devices. Boundary sets for context-free languages are not necessarily context free anymore. Here we find a subtle difference of right and left a-boundary sets. While right a-boundary sets of deterministic context-free languages stay deterministic context free, we give an example of a deterministic context-free language the left a-boundary set of which is already non context free. In fact, the finiteness problem for a-boundary sets of context-free languages becomes undecidable.KeywordsTuring MachineRegular LanguageInput SymbolLanguage TreePushdown AutomatonThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

A Boolean closed full trio is a class of languages that is closed under the Boolean operations (union, intersection, and complementation) and rational transductions. It is well-known that the regular languages constitute such a Boolean closed full trio. It is shown here that every such language class that contains any non-regular language already includes the whole arithmetical hierarchy (and even the one relative to this language). A consequence of this result is that aside from the regular languages, no full trio generated by one language is closed under complementation. Our construction also shows that there is a fixed rational Kripke frame such that assigning an arbitrary non-regular language to some variable allows the definition of any language from the arithmetical hierarchy in the corresponding Kripke structure using multimodal logic.

A two-way deterministic finite state automaton with one counter (2D1CA) is a fundamental computational model that has been examined in many different aspects since sixties, but we know little about its power in the case of unary languages. Up to our knowledge, the only known unary nonregular languages recognized by 2D1CAs are those formed by strings having exponential length, where the exponents form some trivial unary regular language. In this paper, we present some non-trivial subsets of these languages. By using the input head as a second counter, we present simulations of two-way deterministic finite automata with linearly bounded counters and linear–space Turing machines. We also show how a fixed-size quantum register can help to simplify some of these languages. Finally, we compare unary 2D1CAs with two–counter machines and provide some insights about the limits of their computational power.

It is well known that the set of powers of any given order, for example squares, in a regular language need not be regular. Nevertheless, finite automata can identify them via their roots. More precisely, we recall that, given a regular language L, the set of square roots of L is regular. The same holds true for the nth roots for any n and for the set of all nontrivial roots; we give a concrete construction for all of them. Using the above result, we obtain decision algorithms for many natural problems on powers. For example, it is decidable, given two regular languages, whether they contain the same number of squares at each length. Finally, we give an exponential lower bound on the size of automata identifying powers in regular languages. Moreover, we highlight interesting behavior differences between taking fractional powers of regular languages and taking prefixes of a fractional length. Indeed, fractional roots in a regular language can typically not be identified by finite automata.

In this paper we continue the research on usefulness of information examining the effect of supplementary information on the complexity of solving a problem (see Rovan and Sadovský [7] for an overview). We use deterministic finite automata for a formal setting. Given a problem (a regular language) \(L_{prob}\) we measure the complexity of its solution – a DFA \(A_{prob}\) such that \(L_{prob} = L(A_{prob})\) – using the state complexity. A supplementary information (advice) \(L_{adv}\) given by \(A_{adv}\) is useful if a simpler problem \(L_{new}\) given by \(A_{new}\) exists such that \(L_{prob} = L_{new} \cap L_{adv}\) and both \(L_{new}\) and \(L_{adv}\) are simpler than \(L_{prob}\). This is formalized via the notion of decomposability of finite automata (see [1] for DFA case and [7] for NFA case). We address the problem of decomposability of unary regular languages and give a characterization of \(\lambda \)-cyclic languages upon deterministic decomposability.

A regular language L is called dense if the fraction f m of words of length m over some fixed signature that are contained in L tends to one if m tends to infinity. We present an algorithm that computes the number of accumulation points of (f m ) in polynomial time, if the regular language L is given by a finite deterministic automaton, and can then also efficiently check whether L is dense. Deciding whether the least accumulation point of (f m ) is greater than a given rational number, however, is coNP-complete. If the regular language is given by a non-deterministic automaton, checking whether L is dense becomes PSPACE-hard. We will formulate these problems as convergence problems of partially observable Markov chains, and reduce them to combinatorial problems for periodic sequences of rational numbers.

Proposes a natural subclass of regular languages, called alphabetic pattern constraints (APC), which is effectively closed under permutation rewriting, i.e. under iterative application of rules of the form ab/spl rarr/ba. It is well-known that regular languages do not have this closure property in general. Our result can be applied for example to regular model checking, for verifying properties of parametrized linear networks of regular processes and for modeling and verifying properties of asynchronous distributed systems. We also consider the complexity of testing membership in APC, and show that the question is complete for PSPACE when the input is an NFA (nondeterministic finite automaton) and complete for NLOGSPACE when it is a DFA (deterministic finite automaton). Moreover, we show that both the inclusion problem and the question of closure under permutation rewriting are PSPACE-complete when we restrict ourselves to the APC class.

This chapter provides an introduction to the theory of regular languages and finite automata. These concepts will be used in the following chapters for describing behaviors of asynchronous circuits and for specifying abstract behaviors. The theory of regular languages and finite automata is now well established as one of the important basic tools of computer science. We present this theory in a somewhat different way than is done in most textbooks, because we feel that our approach is more general and permits us to establish the relationship between regular languages and finite automata in a very natural way. For a general introduction to regular languages and finite automata, see one of the many texts on this subject, for example [65, 77, 100, 120]; for material closer to our treatment see [16, 17, 20].

Union-free expressions are used in union normal form to decompose any regular language to a finite union of union-free languages. Based on the automata characterisation of the union-free languages, by restricting the 1CFPAs not to have transitions by the empty word, or to be deterministic, the n-union-free and the deterministic union-free languages are defined. Union-complexity as a measure of descriptional complexity of regular languages was introduced recently. By the minimum number of union-free/n-union-free/deterministic union-free languages needed to get a regular language as their union, its union-complexity/n-union-complexity/d-union-complexity is defined. It is already known that union-complexity and n-union-complexity are finite for every regular language, however there are regular languages with infinite d-union-complexity. Operational union-complexity, that is, to predict the union-complexity of a language obtained by a language operation from languages with known union-complexity is an important and interesting question belonging to the field of descriptional complexity of formal systems. In the present paper, the Kleene plus, the positive Kleene closure operator is studied. As the Kleene star and plus operations have very different effects on the union-free languages, it is an interesting problem to investigate how the union-complexities may change under this operation. In particular, we show that the union-complexity of a regular language is not growing when this operation is being applied on it. On the other hand, the n-union-complexity of the Kleene plus of an n-union-free language remains 1, but the n-union-complexity of the Kleene plus of other regular languages may grow. Further, the deterministic union-complexity may jump to an infinite value even if the original language had a relatively small deterministic union-complexity, e.g., 4.Keywordsunion-complexityunion-free languagesregular expressionsKleene closure

Computer Science and Engineering have given us the field of automata theory, one of the largest areas that is concerned with the efficiency of an algorithm in solving a problem on a computational model. Various classes of formal languages are represented using Chomsky hierarchy. These languages are described as a set of specific strings over a given alphabet and can be described using state or transition diagrams. The state/transition diagram for regular languages is called a finite automaton which is used in compiler design for recognition of tokens. Other applications of finite automata include pattern matching, speech and text processing, CPU machine operations, etc. The construction of finite automata is a complicated and challenging process as there is no fixed mathematical approach that exists for designing Deterministic Finite Automata (DFA) and handling the validations for acceptance or rejection of strings. Consequently, it is difficult to represent the DFA’s transition table and graph. Novel learners in the field of theoretical computer science often feel difficulty in designing of DFA The present paper proposes an algorithm for designing of deterministic finite automata (DFA) for a regular language with a given prefix. The proposed method further aims to simplify the lexical analysis process of compiler design.

We consider five operators on a regular language. Each of them is a tool for constructing a code (respectively prefix, suffix, bifix, infix) and a hypercode out of a given regular language. We give the precise values of the (deterministic) state complexity of these operators: over a constant-size alphabet for the first four of them and over a quadratic-size alphabet for the hypercode operator.

Union-free expressions are regular expressions without using the union operation. Consequently, (nondeterministic) union-free languages are described by regular expressions using only concatenation and Kleene star. The language class is also characterised by a special class of finite automata: 1CFPAs have exactly one cycle-free accepting path from each of their states. Obviously such an automaton has exactly one accepting state. The deterministic counterpart of such class of automata defines the deterministic union-free (d-union-free, for short) languages. In this paper [Formula: see text]-free nondeterministic variants of 1CFPAs are used to define n-union-free languages. The defined language class is shown to be properly between the classes of (nondeterministic) union-free and d-union-free languages (in case of at least binary alphabet). In case of unary alphabet the class of n-union-free languages coincides with the class of union-free languages. Some properties of the new subregular class of languages are discussed, e.g., closure properties. On the other hand, a regular expression is in union normal form if it is a finite union of union-free expressions. It is well known that every regular expression can be written in union normal form, i.e., all regular languages can be described as finite unions of (nondeterministic) union-free languages. It is also known that the same fact does not hold for deterministic union-free languages, that is, there are regular languages that cannot be written as finite unions of d-union-free languages. As an important result here we show that every regular language can be defined by a finite union of n-union-free languages. This fact also allows to define n-union-complexity of regular languages.