Unary Alphabet Research Articles

Finitely ambiguous and finitely sequential weighted automata over fields

Expressive power of finitely ambiguous and finitely sequential weighted automata over fields is examined. Rational series realised by such automata can be classified into infinite hierarchies according to ambiguity and sequentiality degrees of realising automata – it is shown that both these hierarchies are strict already over unary alphabets in case the field under consideration is not locally finite. Moreover, the expressive power of finitely sequential, finitely ambiguous, and polynomially ambiguous weighted automata is compared over different fields, both for unary and arbitrary finite alphabets, drawing a complete picture of the relations between corresponding classes of formal power series.

On Learning Polynomial Recursive Programs

We introduce the class of P-finite automata. These are a generalisation of weighted automata, in which the weights of transitions can depend polynomially on the length of the input word. P-finite automata can also be viewed as simple tail-recursive programs in which the arguments of recursive calls can non-linearly refer to a variable that counts the number of recursive calls. The nomenclature is motivated by the fact that over a unary alphabet P-finite automata compute so-called P-finite sequences, that is, sequences that satisfy a linear recurrence with polynomial coefficients. Our main result shows that P-finite automata can be learned in polynomial time in Angluin's MAT exact learning model. This generalises the classical results that deterministic finite automata and weighted automata over a field are respectively polynomial-time learnable in the MAT model.

Distributed graph problems through an automata-theoretic lens

The locality of a graph problem is the smallest distance T such that each node can choose its own part of the solution based on its radius-T neighborhood. In many settings, a graph problem can be solved efficiently with a distributed or parallel algorithm if and only if it has a small locality.In this work we seek to automate the study of solvability and locality: given the description of a graph problem Π, we would like to determine if Π is solvable and what is the asymptotic locality of Π as a function of the size of the graph. Put otherwise, we seek to automatically synthesize efficient distributed and parallel algorithms for solving Π.We focus on locally checkable graph problems; these are problems in which a solution is globally feasible if it looks feasible in all constant-radius neighborhoods. Prior work on such problems has brought primarily bad news: questions related to locality are undecidable in general, and even if we focus on the case of labeled paths and cycles, determining locality is PSPACE-hard (Balliu et al., PODC 2019).We complement prior negative results with efficient algorithms for the cases of unlabeled paths and cycles and, as an extension, for rooted trees. We study locally checkable graph problems from an automata-theoretic perspective by representing a locally checkable problem Π as a nondeterministic finite automatonM over a unary alphabet. We identify polynomial-time-computable properties of the automaton M that near-completely capture the solvability and locality of Π in cycles and paths, with the exception of one specific case that is co-NP-complete.

Usefulness of information and decomposability of unary regular languages

We continue the research on usefulness of information examining the effect of supplementary information on the complexity of solving a problem. We use DFAs for a formal setting. Given a problem (a regular language) Lprob we measure the complexity of its solution — a DFA Aprob accepting Lprob — using the state complexity. A supplementary information (advice) Ladv given by Aadv is useful if a simpler problem Lnew given by Anew exists such that Lprob=Lnew∩Ladv and both Lnew and Ladv are simpler than Lprob. This is formalized via the notion of decomposability of finite automata and regular languages. We address the problem of deterministic decomposability of unary regular languages. We give a characterization upon deterministic decomposability for the class of unary regular languages and we discuss the problem of deciding whether a given DFA over unary alphabet is decomposable (UDFA-Decomposability problem).

Determinisability of unary weighted automata over the rational numbers

Weighted finite automata over the field of rational numbers and unary alphabets are considered. The notion of a characteristic polynomial is introduced for such automata as a means to provide a decidable necessary and sufficient condition, under which a unary weighted automaton admits a deterministic, i.e., sequential equivalent. The sequentiality problem for univariate rational series is thus proved to be decidable both over the rational numbers and over the integers, confirming a conjecture of S. Lombardy and J. Sakarovitch; its decidability over the nonnegative integers is observed as well. The decision algorithm proposed for these tasks is shown to run in polynomial time. A determinisation algorithm for determinisable unary weighted automata over the rational numbers is also described.

Union-Freeness Revisited — Between Deterministic and Nondeterministic Union-Free Languages

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.

State complexity of GF(2)-operations on unary languages

The paper investigates the state complexity of two operations on regular languages, known as GF(2)-concatenation and GF(2)-inverse (Bakinova et al., “Formal languages over GF(2)”, LATA 2018), in the case of a one-symbol alphabet. The GF(2)-concatenation is a variant of the classical concatenation obtained by replacing Boolean logic in its definition with the GF(2) field; it is proved that GF(2)-concatenation of two unary languages recognized by an m-state and an n-state DFA is recognized by a DFA with 2mn states, and this number of states is necessary in the worst case, as long as m and n are relatively prime. This operation is known to have an inverse, and the state complexity of the GF(2)-inverse operation over a unary alphabet is proved to be exactly 2n−1+1, with the proof based on primitive polynomials over GF(2). For a generalization of the GF(2)-inverse, called the GF(2)-star, the state complexity in the unary case is exactly 2n.

Operational union-complexity

Union-free languages are described by regular expressions using only concatenation and Kleene-star. Every regular language can be given as a union of finitely many union-free languages. By the minimal number of union-free languages needed in such union-free decompositions of a regular language, its union-complexity is defined. In this paper, the union-complexity of the languages obtained by various operations is studied, e.g., having two languages with union-complexities n and m, respectively, what could be the union-complexity of their union/concatenation/shuffle. Particularly, it is shown that the Kleene-star of any regular language has union-complexity 1. In some cases, e.g., at union and concatenation, the resulting language has a bounded union-complexity. In some other cases, e.g., at complement, the resulted language can have arbitrarily large union-complexity. At (k-th) power of a language, the case of the unary alphabet and the general case (alphabet with at least two symbols) have different upper bounds. While, in case of shuffle, there is an unbounded growth in the general case, while for languages over the unary alphabet the growth is bounded. Tight upper bounds are shown for all of the above mentioned cases (whenever the growth is bounded). At intersection we also show an unbounded growth in the general case, especially, over a binary alphabet.

State complexity of unambiguous operations on finite automata

The paper determines the number of states in finite automata necessary to represent “unambiguous” variants of the union, concatenation, and Kleene star operations on formal languages. For the disjoint union of languages represented by an m-state and an n-state deterministic finite automata (DFA), the state complexity is mn−1; for the unambiguous concatenation, it is known to be m2n−1−2n−2 (Daley et al., “Orthogonal concatenation: language equations and state complexity”, J. UCS, 2010), and this paper shows that this number of states is necessary already over a binary alphabet; for the unambiguous star, the state complexity function is determined to be 382n+1. In the case of a unary alphabet, disjoint union requires up to 12mn states in a DFA, unambiguous concatenation has state complexity m+n−2, and unambiguous star requires n−2 states in the worst case. For nondeterministic finite automata, as well as for unambiguous finite automata, the complexity for disjoint union is m+n, for unambiguous concatenation, square, and star, the resulting complexities are m+n, 2n, and n+1, respectively, and all of them are witnessed by binary languages. In the unary nondeterministic or unambiguous case, the corresponding complexities are m+n for disjoint union, m+n−1 and 2n−1 for unambiguous concatenation and square, respectively, and n−1 for unambiguous star.

Abelian Logic Gates

An abelian processor is an automaton whose output is independent of the order of its inputs. Bond and Levine have proved that a network of abelian processors performs the same computation regardless of processing order (subject only to a halting condition). We prove that any finite abelian processor can be emulated by a network of certain very simple abelian processors, which we call gates. The most fundamental gate is a toppler, which absorbs input particles until their number exceeds some given threshold, at which point it topples, emitting one particle and returning to its initial state. With the exception of an adder gate, which simply combines two streams of particles, each of our gates has only one input wire, which sends letters (‘particles’) from a unary alphabet. Our results can be reformulated in terms of the functions computed by processors, and one consequence is that any increasing function from ℕk to ℕℓ that is the sum of a linear function and a periodic function can be expressed in terms of (possibly nested) sums of floors of quotients by integers.

Unambiguous conjunctive grammars over a one-symbol alphabet

It is demonstrated that unambiguous conjunctive grammars over a unary alphabet Σ={a} have non-trivial expressive power, and that their basic properties are undecidable. The key result is that for every base of positional notation, k⩾11, and for every one-way real-time cellular automaton operating over the alphabet of base-k digits between ⌊k+94⌋ and ⌊k+12⌋, the language of all strings an with the base-k representation of the form 1w1, where w is accepted by the automaton, is described by an unambiguous conjunctive grammar. Another encoding is used to simulate a cellular automaton in a unary language containing almost all strings. These constructions are used to show that for every fixed unambiguous conjunctive language L0, testing whether a given unambiguous conjunctive grammar generates L0 is undecidable.

Investigations on Automata and Languages Over a Unary Alphabet

The investigation of automata and languages defined over a one letter alphabet shows interesting differences with respect to the case of alphabets with at least two letters. Probably, the oldest example emphasizing one of these differences is the collapse of the classes of regular and context-free languages in the unary case (Ginsburg and Rice, 1962). Many differences have been proved concerning the state costs of the simulations between different variants of unary finite state automata (Chrobak, 1986, Mereghetti and Pighizzini, 2001). We present an overview of these results. Because important connections with fundamental questions in space complexity, we give emphasis to unary two-way automata. Furthermore, we discuss unary versions of other computational models, as probabilistic automata, one-way and two-way pushdown automata, even extended with auxiliary workspace, and multi-head automata.

Deciding determinism of unary languages

In this paper, we investigate the complexity of deciding determinism of unary languages. First, we give a method to derive a set of arithmetic progressions from a regular expression E over a unary alphabet, and establish relations between numbers represented by these arithmetic progressions and words in L(E). Next, we define a problem relating to arithmetic progressions and investigate the complexity of this problem. Then by a reduction from this problem we show that deciding determinism of unary languages is coNP-complete. Finally, we extend our derivation method to expressions with counting, and prove that deciding whether an expression over a unary alphabet with counting defines a deterministic language is in Π2p. We also establish a tight upper bound for the size of the minimal DFA for expressions with counting.

Simplifying Nondeterministic Finite Cover Automata

The concept of Deterministic Finite Cover Automata (DFCA) was introduced at WIA '98, as a more compact representation than Deterministic Finite Automata (DFA) for finite languages. In some cases representing a finite language, Nondeterministic Finite Automata (NFA) may significantly reduce the number of states used. The combined power of the succinctness of the representation of finite languages using both cover languages and non-determinism has been suggested, but never systematically studied. In the present paper, for nondeterministic finite cover automata (NFCA) and l-nondeterministic finite cover automaton (l-NFCA), we show that minimization can be as hard as minimizing NFAs for regular languages, even in the case of NFCAs using unary alphabets. Moreover, we show how we can adapt the methods used to reduce, or minimize the size of NFAs/DFCAs/l-DFCAs, for simplifying NFCAs/l-NFCAs.

Efficient Construction of Semilinear Representations of Languages Accepted by Unary Nondeterministic Finite Automata

In languages over a unary alphabet, i.e., an alphabet with only one letter, words can be identified with their lengths. It is well known that each regular language over a unary alphabet can be represented as the union of a finite number of arithmetic progressions. Given a nondeterministic finite automaton NFA working over a unary alphabet a unary NFA, the arithmetic progressions representing the language accepted by the automaton can be easily computed by the determinization of the given NFA. However, the number of the arithmetic progressions computed in this way can be exponential with respect to the size of the original automaton. Chrobak 1986 has shown that in fact On2 arithmetic progressions are sufficient for the representation of the language accepted by a unary NFA with n states, and Martinez 2002 has shown how these progressions can be computed in polynomial time. Recently, To 2009 has pointed out that Chrobak's construction and Martinez's algorithm, which is based on it, contain a subtle error and has shown how to correct this error. Geffert 2007 presented an alternative proof of Chrobak's result, also improving some of the bounds. In this paper, a new simpler and more efficient algorithm for the same problem is presented, using some ideas from Geffert 2007. The time complexity of the presented algorithm is On2n + m and its space complexity is On + m, where n is the number of states and m the number of transitions of a given unary NFA.

Controlled Pure Grammar Systems

This paper discusses grammar systems that have only terminals, work in the leftmost way, and generate their languages under the regulation by control lan- guages over rule labels. It establishes three results concerning their generative power. First, without any control languages, these systems are not even able to generate all context-free languages. Second, with regular control languages, these systems, hav- ing no more than two components, characterize the family of recursively enumerable languages. Finally, with control languages that are themselves generated by regular- controlled context-free grammars, these systems over unary alphabets generate nothing but regular languages. In its introductory section, the paper gives a motivation for in- troducing these systems, and in the concluding section, it formulates several open problems.

State complexity of operations on two-way finite automata over a unary alphabet

The paper determines the number of states in two-way deterministic finite automata (2DFA) over a one-letter alphabet sufficient and in the worst case necessary to represent the results of basic language-theoretic operations on 2DFAs with a certain number of states. It is proved that (i) intersection of an m-state 2DFA and an n-state 2DFA requires between m+n and m+n+1 states; (ii) union of an m-state 2DFA and an n-state 2DFA, between m+n and 2m+n+4 states; (iii) Kleene star of an n-state 2DFA, (g(n)+O(n))2 states, where g(n)=e(1+o(1))nlnn is the maximum value of lcm(p1,…,pk) for ∑pi⩽n, known as Landau’s function; (iv) k-th power of an n-state 2DFA, between (k−1)g(n)−k and k(g(n)+n) states; (v) concatenation of an m-state 2DFA and an n-state 2DFA, e(1+o(1))(m+n)ln(m+n) states. It is furthermore demonstrated that the Kleene star of a two-way nondeterministic automaton (2NFA) with n states requires Θ(g(n)) states in the worst case, its k-th power requires (k⋅g(n))Θ(1) states, and the concatenation of an m-state 2NFA and an n-state 2NFA, eΘ((m+n)ln(m+n)) states.

Behaviours of Unary Quantum Automata

We study the stochastic events induced by MM-qfa's working on unary alphabets. We give two algorithms for unary MM-qfa's: the first computes the dimension of the ergodic and transient components of the non halting subspace, while the second tests whether the induced event is d-periodic. These algorithms run in polynomial time whenever the MM-qfa given in input has complex amplitudes with rational components. We also characterize the recognition power of unary MM-qfa's, by proving that any unary regular language can be accepted by a MM-qfa with constant cut point and isolation. Yet, the amount of states of the resulting MM-qfa is linear in the size of the corresponding minimal dfa. We also single out families of unary regular languages for which the size of the accepting MM-qfa's can be exponentially decreased.

On One-way One-bit O (One)-message Cellular Automata

Cellular automata are one-dimensional arrays of interconnected interacting finite automata, also called cells. Here, we investigate one of the weakest class of cellular automata, namely the class of real-time one-way cellular automata. Additionally, we impose two restrictions on the inter-cell communication. First, the number of allowed uses of the links between cells is bounded. Moreover, the amount of information to be communicated in one time step is bounded by a constant being independent from the given automaton. In the weakest case, we consider cellular automata with one-way information flow where each cell receives one bit of information exactly once. In this case, we obtain a characterization of the regular languages for unary alphabets and the acceptance of non-context-free languages for non-unary alphabets. Next, a proper language hierarchy can be derived when increasing the number of allowed uses of the links between cells step by step. Finally, decidability problems of these restricted cellular automata are studied and undecidability of almost all problems can be proven even in the most restricted case of one-way one-bit communication.

On the Number of Membranes in Unary P Systems

We consider P systems with a linear membrane structure working on objects over a unary alphabet using sets of rules resembling homomorphisms. Such a restricted variant of P systems allows for a unique minimal representation of the generated unary language and in that way for an effective solution of the equivalence problem. Moreover, we examine the descriptional complexity of unary P systems with respect to the number of membranes.