On the generative capacity of matrix insertion-deletion systems of small sum-norm

A matrix insertion-deletion system (or matrix ins-del system) is described by a set of insertion-deletion rules presented in matrix form, which demands all rules of a matrix to be applied in the given order. These systems were introduced to model very simplistic fragments of sequential programs based on insertion and deletion as elementary operations as can be found in biocomputing. We are investigating such systems with limited resources as formalized in descriptional complexity. A traditional descriptional complexity measure of such a matrix ins-del system is its size $$s=(k;n,i',i'';m,j',j'')$$ s = ( k ; n , i ′ , i ′ ′ ; m , j ′ , j ′ ′ ) , where the parameters from left to right represent the maximal matrix length, maximal insertion string length, maximal length of left contexts in insertion rules, maximal length of right contexts in insertion rules; the last three are deletion counterparts of the previous three parameters. We call the sum $$n+i'+i''+m+j'+j''$$ n + i ′ + i ′ ′ + m + j ′ + j ′ ′ the sum-norm of s. We show that matrix ins-del systems of sum-norm 4 and sizes (3; 1, 0, 0; 1, 2, 0), (3; 1, 0, 0; 1, 0, 2), (2; 1, 2, 0; 1, 0, 0), (2; 1, 0, 2; 1, 0, 0), and (2; 1, 1, 1; 1, 0, 0) describe the recursively enumerable languages. Moreover, matrix ins-del systems of sizes (3; 1, 1, 0; 1, 0, 0), (3; 1, 0, 1; 1, 0, 0), (2; 2, 1, 0; 1, 0, 0) and (2; 2, 0, 1; 1, 0, 0) can describe at least the regular closure of the linear languages. In fact, we show that if a matrix ins-del system of size s can describe the class of linear languages $$\mathrm {LIN}$$ LIN , then without any additional resources, matrix ins-del systems of size s also describe the regular closure of $$\mathrm {LIN}$$ LIN . Finally, we prove that matrix ins-del systems of sizes (2; 1, 1, 0; 1, 1, 0) and (2; 1, 0, 1; 1, 0, 1) can describe at least the regular languages.

Adding Matrix Control: Insertion-Deletion Systems with Substitutions III

Insertion-deletion systems have been introduced as a formalism to model operations that find their counterparts in ideas of bio-computing, more specifically, when using DNA or RNA strings and biological mechanisms that work on these strings. So-called matrix control has been introduced to insertion-deletion systems in order to enable writing short program fragments. We discuss substitutions as a further type of operation, added to matrix insertion-deletion systems. For such systems, we additionally discuss the effect of appearance checking. This way, we obtain new characterizations of the family of context-sensitive and the family of recursively enumerable languages. Not much context is needed for systems with appearance checking to reach computational completeness. This also suggests that bio-computers may run rather traditionally written programs, as our simulations also show how Turing machines, like any other computational device, can be simulated by certain matrix insertion-deletion-substitution systems.

Networks with Evolutionary Processors and Ideals and Codes as Filters

We study how the generative power of networks of evolutionary processors decreases if special codes and ideals are used as input and output filters of the nodes instead of arbitrary regular languages. We show that all recursively enumerable languages can be generated if the filters are right ideals or left ideals. With respect to codes, we obtain a hierarchy of evolutionary language families which is almost identical to that of the families of codes.

Derivation "Trees" and Parallelism in Chomsky-Type Grammars

In this paper we discuss parallel derivations for context-free, contextsensitive and phrase-structure grammars. For regular and linear grammars only sequential derivation can be applied, but a kind of parallelism is present in linear grammars. We show that nite languages can be generated by a recursion-free rule-set. It is well-known that in context-free grammars the derivation can be in maximal (independent) parallel way. We show that in cases of context-sensitive and recursively enumerable languages the parallel branches of the derivation have some synchronization points. In the case of context-sensitive grammars this synchronization can only be local, but in a derivation of an arbitrary grammar we cannot make this restriction. We present a framework to show how the concept of parallelism can be t to the derivations in formal language theory using tokens.

On Promoters/Inhibitors and Symport/Antiport with Traces in P Systems

This article brings together some rather powerful results on P systems in which the computation is performed by the communication of objects through symport and antiport rules considering the trace of an object through membranes, on the one hand, and by P systems with object-rewriting non-cooperative rules, promoters/inhibitors at the level of rules and only one catalyst, on the other. It is recalled here that computational universality can be reached whit these formalisms and that some of the proofs can be sketched. Three ideas are also put forward to brake the direct relationship (infinite hierarchy) induced by the size of the considered alphabet and the number of the membranes needed in a P system (with traces) to generate recursively enumerable languages on the chosen alphabet.

On describing the regular closure of the linear languages with graph-controlled insertion-deletion systems

A graph-controlled insertion-deletion (GCID) system has several components and each component contains some insertion-deletion rules. A transition is performed by any applicable rule in the current component on a string and the resultant string is then 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. When resources are very limited (especially, when deletion is demanded to be context-free and insertion to be one-sided only), then GCID systems are not known to describe the class of recursively enumerable languages. Hence, it becomes interesting to explore the descriptional complexity of such GCID systems of small sizes with respect to language classes below RE and even below CF. To this end, we consider so-called closure classes of linear languages defined over the operations concatenation, Kleene star and union. We show that whenever GCID systems (with certain syntactical restrictions) describe all linear languages (LIN) with t components, we can extend this to GCID systems with just one more component to describe, for instance, the concatenation of two languages from the language family that can be described as the Kleene closure of linear languages. With further addition of one more component, we can extend the construction to GCID systems that describe the regular closure of LIN.

Separating the Classes of Recursively Enumerable Languages Based on Machine Size

In the late nineteen sixties it was observed that the r.e. languages form an infinite proper hierarchy [Formula: see text] based on the size of the Turing machines that accept them. We examine the fundamental position of the finite languages and their complements in the hierarchy. We show that for every finite language L one has that L, [Formula: see text] for some [Formula: see text] where m is the length of the longest word in L, c is the cardinality of L, and [Formula: see text]. If [Formula: see text], then [Formula: see text] for some [Formula: see text]. We also prove that for every n, there is a finite language Ln with [Formula: see text] such that [Formula: see text] but Ln, [Formula: see text] for some [Formula: see text]. Several further results are shown that how the hierarchy can be separated by increasing chains of finite languages. The proofs make use of several auxiliary results for Turing machines with advice.

Jumping Grammars

This paper introduces and studies jumping grammars, which represent a grammatical counterpart to the recently introduced jumping automata. These grammars are conceptualized just like classical grammars except that during the applications of their productions, they can jump over symbols in either direction within the rewritten strings. More precisely, a jumping grammar rewrites a string z according to a rule x → y in such a way that it selects an occurrence of x in z, erases it, and inserts y anywhere in the rewritten string, so this insertion may occur at a different position than the erasure of x. The paper concentrates its attention on investigating the generative power of jumping grammars. More specifically, it compares this power with that of jumping automata and that of classical grammars. A special attention is paid to various context-free versions of jumping grammars, such as regular, right-linear, linear, and context-free grammars of finite index. In addition, we study the semilinearity of context-free, context-sensitive, and monotonous jumping grammars. We also demonstrate that the general versions of jumping grammars characterize the family of recursively enumerable languages. In its conclusion, the paper formulates several open problems and suggests future investigation areas.