Acta Informatica最新文献

Graph-controlled insertion-deletion (GCID) systems are regulated extensions of insertion-deletion systems. At AFL 2023, star-controlled GCID system was introduced as a restriction of GCID systems. Such a system has several components and each component contains some insertion-deletion rules. The components are the vertices of a directed control graph, whose arcs describe how strings can move between components. A rule is applied to a string in a component and the resultant string is moved to the target component specified in the rule. The language of the system is the set of all terminal strings collected in the final component. In this paper, we impose the restriction in the structure of the underlying graph to be a star structure where there is a central, control component which acts like a master and transmits a string (after applying one of its rules) to one of the components specified in the applied rule. A component which receives the string can process the obtained string with any applicable rule available in it and sends back the resultant string only to the center component. In this restricted GCID, where there is a special component, namely, a central component that will process the string and then send it to any other component that processes another step and then send the string back to the central component. With this restriction, here we obtain three new, different computational completeness results for some typical descriptional complexity measures, hence sharpening the Pareto frontier of this type of grammar. These results are crucially based on a variant of Special Geffert normal form (SGNF) of type-0 grammars, that we called space separating SGNF in a paper that appeared in Natural Computing in 2019.

In this paper, we give the structure of finite maximal prefix codes over binary alphabet with constant average length 4, and prove that the families of finite maximal prefix codes are divided into 217 classes. In addition, some finite maximal prefix codes with constant average length greater than or equal to 5 are found, conduct a preliminary exploration of the case.

A subsequence of a string T is any string that can be obtained by removing zero or more symbols from T. The paper deals with the Window Accumulated Subsequence matching Problem (WASP), which is defined as follows: Given two strings, the text T and the pattern P, and a positive integer w, the window size, find the number of size w substrings of T that contain P as a subsequence. Three algorithms for this problem are introduced: a bit-parallel approach, an algorithm preprocessing the pattern, and an algorithm preprocessing the text. The bit-parallel approach outperforms the state-of-the-art algorithm, and the other two algorithms outperform the bit-parallel approach for small alphabets, short patterns, and windows that are not much larger than the pattern. Furthermore, a preprocessing of the text that solves WASP for a fixed window size and each possible pattern of a given size is described. This is beneficial when we are to solve WASP for a single text and multiple patterns, because when the text is preprocessed, a solution is provided promptly.

We introduce and investigate tree-walking-storage automata, which are finite-state devices equipped with a tree-like storage. The automata are generalized stack automata, where the linear stack storage is replaced by a non-linear tree-like stack. Therefore, tree-walking-storage automata have the ability to explore the interior of the tree storage without altering the contents, where the possible moves of the tree pointer correspond to those of tree-walking automata. In addition, a tree-walking-storage automaton can append (push) non-existent descendants to a tree node and remove (pop) leaves from the tree. As for classical stack automata, we also consider non-erasing and checking variants. As a first step to investigate these models we consider the computational capacities of deterministic one-way variants. In particular, a primary focus lies on comparing the different variants of tree-walking-storage automata as well as with classical stack automata, enabling us to draw a complete picture. Basic closure properties of the induced families of languages are shown. In particular, we consider Boolean operations and several AFL operations.

The Alethe format has been adopted by several SMT solvers for explaining why a set of constraints is unsatisfiable. We describe how to interpret Alethe proof traces and generate corresponding proofs that are accepted by the Lambdapi proof checker, a foundational proof assistant based on dependent type theory and rewriting that is intended to serve as a pivot for exchanging proofs between interactive proof assistants. We give an overview of the encoding of SMT logic and of Alethe proof traces in Lambdapi and present results of the evaluation of the checker on benchmark examples.

In 1982, Harary introduced the concept of Ramsey achievement game on graphs. Given a graph F with no isolated vertices, consider the following game played on the complete graph (K_n) by two players Alice and Bob. First, Alice colors one of the edges of (K_n) blue, then Bob colors a different edge red, and so on. The first player who can complete the formation of F in his color is the winner. The minimum n for which Alice has a winning strategy is the achievement number of F, denoted by a(F). If we replace (K_n) in the game by the complete bipartite graph (K_{n,n}), we get the bipartite achievement number, denoted by (operatorname {ba}(F)). In this paper, we correct (operatorname {ba}(mK_2)=m+1) to m and disprove (operatorname {ba}(K_{1,m})=2m-2) from Erickson and Harary (1983). We also find the exact values or upper and lower bounds of bipartite achievement numbers on matchings, stars, and double stars.

In this work we introduce a new notion called opacity complexity to measure the complexity of automatic sequences. We study basic properties of this notion, and exhibit an algorithm to compute it. As applications, we compute the opacity complexity of some well-known automatic sequences, including in particular constant sequences, purely periodic sequences, the Thue-Morse sequence, the period-doubling sequence, the Golay-Shapiro(-Rudin) sequence, the paperfolding sequence, the Baum-Sweet sequence, the Tower of Hanoi sequence, and so on.

For an arbitrary finite family of graphs, the distance labeling problem asks to assign labels to all nodes of every graph in the family in a way that allows one to recover the distance between any two nodes of any graph from their labels. The main goal is to minimize the number of unique labels used. We study this problem for the families (mathcal {C}_n) consisting of cycles of all lengths between 3 and n. We observe that the exact solution for directed cycles is straightforward and focus on the undirected case. We design a labeling scheme requiring (frac{nsqrt{n}}{sqrt{6}}+O(n)) labels, which is almost twice less than is required by the earlier known scheme. Using the computer search, we find an optimal labeling for each (nle 17), showing that our scheme gives the results that are very close to the optimum.

In this paper, we continue the research on the power of contextual grammars with selection languages from subfamilies of the family of regular languages. In the past, two independent hierarchies have been obtained for external and internal contextual grammars, one based on selection languages defined by structural properties (finite, monoidal, nilpotent, combinational, definite, ordered, non-counting, power-separating, suffix-closed, commutative, circular, or union-free languages), the other one based on selection languages defined by resources (number of non-terminal symbols, production rules, or states needed for generating or accepting them). In a previous paper, the language families of these hierarchies for external contextual grammars were compared and the hierarchies merged. In the present paper, we compare the language families of these hierarchies for internal contextual grammars and merge these hierarchies.

This paper introduces sweeping permutation automata, which move over an input string in alternating left-to-right and right-to-left sweeps and have a bijective transition function. It is proved that these automata recognize the same family of languages as the classical one-way permutation automata (Thierrin, “Permutation automata”, Mathematical Systems Theory, 1968). The proof is constructive: an n-state two-way permutation automaton is transformed to a one-way permutation automaton with at most (F(n)=max _{k+ell =n, m leqslant ell } k cdot { ell atopwithdelims ()m} cdot {k - 1 atopwithdelims ()ell - m} cdot (ell - m)!) states (here the maximum is over all partitions of n into k states with transitions to the right and (ell) states with transitions to the left, where m states have no transitions on the left end-marker). This number of states is proved to be necessary in the worst case, and its growth rate is estimated as (F(n) = n^{frac{n}{2} - frac{1 + ln 2}{2}frac{n}{ln n}(1 + o(1))}).