Search

In the modern world, structured and semi-structured knowledge bases hold a considerable amount of data. There-fore, people who are familiar with formal query languages should not be the only ones who can efficiently and clearly query them. Semantic Parsing (SP) is converting natural language utterances into formal meaning representations. The paper suggests a model for SP that uses a novel method of utilizing the Semi-Supervised Generative Adversarial Network (SS-GAN) to enhance the classifier performance. The proposed SS-GAN extends the fine-tuning of word embedding architectures using unlabeled examples in a generative adversarial environment. We provide a regularization strategy for addressing the mode missing problem and unstable training in SS-GAN. The main viewpoint is to use the extracted feature vectors from the discriminator. Hence, the generator produces outputs by aiding the discriminator's learned features. A reconstruction loss is added to the loss function of the SS-GAN to drive the genera-tor to reconstruct outputs from the discriminator's features, hence steering the generator toward actual data configurations. The proposed reconstruction loss improves the performance of SS-GAN, produces high-quality outputs, and may be combined with other regularization loss functions to improve the performance of diverse GANs. We employ BERT word embedding for our model, which can be included in a downstream task and fine-tuned as a model, while the pre-trained BERT model can capture various linguistic properties. We examine the suggested model using the WikiSQL and SparC datasets, and the analysis findings reveal our model outperforms its rivals. The findings from our experiments indicate that the need for labeled samples can be minimized, down to as few as 100 instances, while still achieving commendable classification outcomes. [ABSTRACT FROM AUTHOR]

Coverings of undirected graphs are used in distributed computing, and unfoldings of directed graphs in semantics of programs. We study these two notions from a graph theoretical point of view so as to highlight their similarities, as they are both defined in terms of surjective graph homomorphisms. In particular, universal coverings and complete unfoldings are infinite trees that are regular if the initial graphs are finite. Regularity means that a tree has finitely many subtrees up to isomorphism. Two important theorems have been established by Leighton and Norris for coverings of finite graphs. We prove similar results for unfoldings of finite directed graphs. Moreover, we generalize coverings and similarly, unfoldings to graphs and digraphs equipped with finite or infinite weights attached to edges of the covered or unfolded graphs. This generalization yields a canonical "factorization" of the universal covering of any finite graph, that (provably) does not exist without using weights. Introducing ω as an infinite weight provides us with finite descriptions of regular trees having nodes of countably infinite degree. Regular trees (trees having finitely many subtrees up to isomorphism) play an important role in the extension of Formal Language Theory to infinite structures described in finitary ways. Our weighted graphs offer effective descriptions of the above mentioned regular trees and yield decidability results. We also generalize to weighted graphs and their coverings a classical factorization theorem of their characteristic polynomials. [ABSTRACT FROM AUTHOR]

Existing formal languages for the specification of self-adaptive cyber-physical systems focus on re-configuring the system-to-be depending on its current context, to satisfy the user's requirements, that is by dynamically composing the software's structure and behavior. While these approaches specify context-sensitive requirements, they rarely consider their run-time dynamic and scalable nature. The State-Constraint Transition (SCT) modeling language, introduced in this paper, provides an answer to the problems linked to the specification of dynamic requirements by introducing the concept of configuration states, in which requirements are translated into constraints. The expressiveness of existing approaches is thus extended, combining the ease of use of well-established notations, notably those based on characteristics, and those based on Finite-state Machines (FSM), with the computational power and expressiveness of the constraint programming approach. The paper briefly presents the results of the preliminary evaluation, which assesses the expressiveness, scalability, and domain independence of the SCT language. [ABSTRACT FROM AUTHOR]

Weighted restarting automata have been introduced to study quantitative aspects of computations of restarting automata. In earlier works we studied the classes of functions and relations that are computed by weighted restarting automata. Here we use them to define classes of formal languages by restricting the weight associated to a given input word through an additional requirement. In this way, weighted restarting automata can be used as language acceptors. First, we show that by using the notion of acceptance relative to the tropical semiring, we can avoid the use of auxiliary symbols. Furthermore, a certain type of word-weighted restarting automata turns out to be equivalent to non-forgetting restarting automata, and another class of languages accepted by word-weighted restarting automata is shown to be closed under the operation of intersection. This is the first result that shows that a class of languages defined in terms of a quite general class of restarting automata is closed under intersection. Finally, we prove that the restarting automata that are allowed to use auxiliary symbols in a rewrite step, and to keep on reading after performing a rewrite step can be simulated by regular-weighted restarting automata that cannot do this. [ABSTRACT FROM AUTHOR]

A contextual grammar is a language generating mechanism inspired by generating sentences in natural languages. An existing string can be extended to a new string of the language by adjoining a context before and behind the string or by inserting it into the string around some subword. The first mode is called external derivation whereas the second mode is called internal derivation. If conditions are given, around which words which contexts can be adjoined, we speak about contextual grammars with selection. We give an overview about the generative capacity of contextual grammars (working externally or internally) where the selection languages belong to subregular language classes. All languages generated by contextual grammars where all selection languages are elements of a certain subregular language family form again a language family. We compare such families which are based on finite, monoidal, nilpotent, combinational, definite, suffix-closed, ordered, commutative, circular, non-counting, power-separating, or union-free languages, or based on languages defined by restrictions regarding the descriptional complexity. [ABSTRACT FROM AUTHOR]

A contextual grammar is a language generating mechanism inspired by generating sentences in natural languages. An existing string can be extended to a new string of the language by adjoining a context before and behind the string or by inserting it into the string around some subword. The first mode is called external derivation whereas the second mode is called internal derivation. If conditions are given, around which words which contexts can be adjoined, we speak about contextual grammars with selection. We give an overview about the generative capacity of contextual grammars (working externally or internally) where the selection languages belong to subregular language classes. All languages generated by contextual grammars where all selection languages are elements of a certain subregular language family form again a language family. We compare such families which are based on finite, monoidal, nilpotent, combinational, definite, suffix-closed, ordered, commutative, circular, non-counting, power-separating, or union-free languages, or based on languages defined by restrictions regarding the descriptional complexity. [ABSTRACT FROM AUTHOR]

Weighted restarting automata have been introduced to study quantitative aspects of computations of restarting automata. In earlier works we studied the classes of functions and relations that are computed by weighted restarting automata. Here we use them to define classes of formal languages by restricting the weight associated to a given input word through an additional requirement. In this way, weighted restarting automata can be used as language acceptors. First, we show that by using the notion of acceptance relative to the tropical semiring, we can avoid the use of auxiliary symbols. Furthermore, a certain type of word-weighted restarting automata turns out to be equivalent to non-forgetting restarting automata, and another class of languages accepted by word-weighted restarting automata is shown to be closed under the operation of intersection. This is the first result that shows that a class of languages defined in terms of a quite general class of restarting automata is closed under intersection. Finally, we prove that the restarting automata that are allowed to use auxiliary symbols in a rewrite step, and to keep on reading after performing a rewrite step can be simulated by regular-weighted restarting automata that cannot do this. [ABSTRACT FROM AUTHOR]

Firewalls are essential for managing and protecting computer networks. They permit specifying which packets are allowed to enter a network, and also how these packets are modified by IP address translation and port redirection. Configuring a firewall is notoriously hard, and one of the reasons is that it requires using low level, hard to interpret, configuration languages. Equally difficult are policy maintenance and refactoring, as well as porting a configuration from one firewall system to another. To address these issues we introduce a pipeline that assists system administrators in checking if: (i) the intended security policy is actually implemented by a configuration; (ii) two configurations are equivalent; (iii) updates have the desired effect on the firewall behavior; (iv) there are useless or redundant rules; additionally, an administrator can (v) transcompile a configuration into an equivalent one in a different language; and (vi) maintain a configuration using a generic, declarative language that can be compiled into different target languages. The pipeline is based on IFCL, an intermediate firewall language equipped with a formal semantics, and it is implemented in an open source tool called FWS. In particular, the first stage decompiles real firewall configurations for iptables, ipfw, pf and (a subset of) Cisco IOS into IFCL. The second one transforms an IFCL configuration into a logical predicate and uses the Z3 solver to synthesize an abstract specification that succinctly represents the firewall behavior. System administrators can use FWS to analyze the firewall by posing SQL-like queries, and update the configuration to meet the desired security requirements. Finally, the last stage allows for maintaining a configuration by acting directly on its abstract specification and then compiling it to the chosen target language. Tests on real firewall configurations show that FWS can be fruitfully used in real-world scenarios. [ABSTRACT FROM AUTHOR]

In this research, we combine relational learning with multi-domain to develop a formal framework for a recommendation system. The design of our framework aims at: (i) constructing general rules for recommendations, (ii) providing suggested items with clear and understandable explanations, (iii) delivering a broad range of recommendations including novel and unexpected items. We use relational learning to find all possible relations, including novel relations, and to form the general rules for recommendations. Each rule is represented in relational logic, a formal language, associating with probability. The rules are used to suggest the items, in any domain, to the user whose preferences or other properties satisfy the conditions of the rule. The information described by the rule serves as an explanation for the suggested item. It states clearly why the items are chosen for the users. The explanation is in if-then logical format which is unambiguous, less redundant and more concise compared to a natural language used in other explanation recommendation systems. The explanation itself can help persuade the user to try out the suggested items, and the associated probability can drive the user to make a decision easier and faster with more confidence. Incorporating information or knowledge from multiple domains allows us to broaden our search space and provides us with more opportunities to discover items which are previously unseen or surprised to a user resulting in a wide range of recommendations. The experiment results show that our proposed algorithm is very promising. Although the quality of recommendations provided by our framework is moderate, our framework does produce interesting recommendations not found in the primitive single-domain based system and with simple and understandable explanations. [ABSTRACT FROM AUTHOR]

The aim of this article is developing a formal system suitable for reasoning about the distance between propositional formulas. We introduce and study a formal language which is the extension of the classical propositional language obtained by adding new binary operators D≤s and D≥s, s ∈ Range, where Range is a fixed finite set. In our language it is allowed to make formulas of the form D≤s(α; β) with the intended meaning 'distance between formulas α and β is less than or equal to s'. The semantics of the proposed language consists of possible worlds with a distance function defined between sets of worlds. [ABSTRACT FROM AUTHOR]

Circular splicing systems are a mathematical model, inspired by a recombinant behaviour of circular DNA. They are defined by a finite alphabet A, an initial set I of circular words, and a set R of rules. A circular splicing language is a language generated by a circular splicing system. An open problem is to characterize regular circular splicing languages and the corresponding circular splicing systems. In this framework an important role is played by unavoidable sets. These sets have been considered in several contexts. In particular, Ehrenfeucht, Haussler and Rozenberg (1983) proved the following generalization of a famous Higman's theorem: the quasi-order induced by insertions of words from a fixed finite set is a well-quasi-order if and only if the finite set is unavoidable. In this paper we survey the known relations between unavoidable sets and regular circular languages. Motivated by these connections we give an alternative and simpler proof of the Ehrenfeucht, Haussler and Rozenberg result. Our proof is strongly based on a known characterization of unavoidable sets in terms of graphs associated with them. [ABSTRACT FROM AUTHOR]

Let ∑ be an alphabet which has at least two symbols. The density of L ⊆ ∑* is defined as D(L) := limn |L ∩ ∑n|/|∑n| ∈ [0, 1], provided that the limit exists. In 2015, R. Sin'ya has discovered an interesting relation between regular languages and their densities: If L ⊆ ∑* is a regular language, then D(L) = 0 if and only if there exists s ∈ ∑* such that ∑*s∑* ∩ L = ø. In this paper, we give a simple proof of this theorem, obtaining it as a simple consequence of the pumping lemma for regular languages. [ABSTRACT FROM AUTHOR]

In this paper, we study the minimization of lattice-valued multiset finite automata with membership values in a distributive lattice. First, we establish the equivalence of (nondeterministic) lattice multiset finite automata (LMA) and deterministic lattice multiset finite automata (DLMA). Furthermore, we present some operations on lattice-valued regular multiset languages, and prove that the family of lattice-valued regular multiset languages is closed under this operations. We also introduce and study the minimal DLMAs and present an effective algorithm to obtain a minimal DLMA for a given LMA. Finally, we give a decomposition of lattice-valued regular multiset language by some simple lattice-valued regular multiset languages accepted by some special minimal DLMAs. [ABSTRACT FROM AUTHOR]

We improve some results relative to the state complexity of the multiple catenations described by Gao and Yu. In particular we nearly divide by 2 the size of the alphabet needed for witnesses. We also give some refinements to the algebraic expression of the state complexity, which is especially complex with this operation. We obtain these results by using peculiar DFAs defined by Brzozowski. [ABSTRACT FROM AUTHOR]

The paper is concerned with the problem of building models for first-order languages from the perspective of the classic paper of Rasiowa and Sikorski [9]. The central idea, developed in this paper, consists in constructing first-order models from individual variables. The key notion of a Rasiowa-Sikorski set of formulas for an arbitrary countable language L is examined. Each Rasiowa-Sikorski set defines a countable model for L. Conversely, every countable model for L is determined by a Rasiowa-Sikorski set. The focus is on constructing Rasiowa-Sikorski sets by applying forcing techniques restricted to Boolean algebras arising from the subsets of the set of atomic formulas of L. [ABSTRACT FROM AUTHOR]

Deterministic finite automata equipped with the storage medium of a queue are investigated towards their ability to perform reversible computations, that is, computations in which every occurring configuration has exactly one successor and exactly one predecessor. A first result is that any queue automaton can be simulated by a reversible one. So, reversible queue automata are as powerful as Turing machines. Therefore it is of natural interest to impose time restrictions to queue automata. Here we consider quasi realtime and realtime computations. It is shown that every reversible quasi realtime queue automaton can be sped up to realtime. On the other hand, under realtime conditions reversible queue automata are less powerful than general queue automata. Furthermore, we exhibit a lower bound of ... time steps for realtime queue automata witness languages to be accepted by any equivalent reversible queue automaton. We study the closure properties of reversible realtime queue automata and obtain similar results as for reversible deterministic pushdown automata. Finally, we investigate decidability questions and obtain that all commonly studied questions such as emptiness, finiteness, or equivalence are not semidecidable for reversible realtime queue automata. Furthermore, it is not semidecidable whether an arbitrary given realtime queue automaton is reversible. [ABSTRACT FROM AUTHOR]

Limited automata are one-tape Turing machines which are allowed to rewrite each tape cell only in the first d visits, for a given constant d. When d > 2, these devices characterize the class of context-free languages. In this paper we consider restricted versions of these models which we call strongly limited automata, where rewrites, head reversals, and state changes are allowed only at certain points of the computation. Those restrictions are inspired by a simple algorithm for accepting Dyck languages on 2-limited automata. We prove that the models so defined are still able to recognize all context-free languages. We also consider descriptional complexity aspects. We prove that there are polynomial transformations of context-free grammars and pushdown automata into strongly limited automata and vice versa. [ABSTRACT FROM AUTHOR]

Motivated by possible machine learning of picture languages, we introduce a new twodimensional automaton called two-dimensional limited context restarting automaton. Our model is a simplification of the two-dimensional restarting tiling automaton, from which it differs in that it does not require to scan input pictures in a fixed order. We show that the two-dimensional limited context restarting automaton is equally powerful as the two-dimensional sgraffito automaton. Moreover, the correctness preserving version of the new model, while still being nondeterministic, is equivalent to the deterministic sgraffito automaton. However, the property of being correctness preserving is not even semi-decidable for two-dimensional limited context restarting automata. [ABSTRACT FROM AUTHOR]

We generalize the models of visibly pushdown automata (VPDAs) and visibly pushdown transducers (VPDTs) by equipping them with reversal-bounded counters. We show that some of the results for VPDAs and VPDTs (e.g., closure under intersection and decidability of emptiness for VPDA languages) carry over to the generalized models, but other results (e.g., determinization and closure under complementation) do not carry over, in general. We define a model that combines the desirable features of a VPDA and reversal-bounded counters, called 2-phase VPCM, and show that the deterministic and nondeterministic versions are equivalent and that the family of languages they define is closed under Boolean operations and has decidable emptiness, infiniteness, disjointness, containment, and equivalence problems. We also investigate the finite-ambiguity and finite-valuedness problems concerning these devices. [ABSTRACT FROM AUTHOR]

We consider the computational complexity of problems related to partial word automata. Roughly speaking, a partial word is a word in which some positions are unspecified and a partial word automaton is a finite automaton that accepts a partial word language--here the unspecified positions in the word are represented by a "hole" symbol . A partial word language L0 can be transformed into an ordinary language L by using a -substitution. In particular, we investigate the complexity of the compression or minimization problem for partial word automata, which is known to be NP-hard. We improve on the previously known complexity on this problem, by showing PSPACE-completeness. In fact, it turns out that almost all problems related to partial word automata, such as, e.g., equivalence and universality, are already PSPACE- complete. Moreover, we also study these problems under the further restriction that the involved automata accept only finite languages. In this case, the complexities of the studied problems drop from PSPACE-completeness down to coNP-hardness and containment in P2 depending on the problem investigated. [ABSTRACT FROM AUTHOR]

Given a language L, we study the language of words D(L), that distinguish between pairs of different left quotients of L. We characterize this distinguishability operation, show that its iteration has always a fixed point, and we generalize this result to operations derived from closure operators and Boolean operators. For the case of regular languages, we give an upper bound for the state complexity of the distinguishability operation, and prove its tightness. We show that the set of minimal words that can be used to distinguish between different left quotients of a regular language L has at most n - 1 elements, where n is the state complexity of L, and we also study the properties of its iteration. We generalize the results for the languages of words that distinguish between pairs of different right quotients and two-sided quotients of a language L. [ABSTRACT FROM AUTHOR]

We prove the existence of a canonical form for semi-deterministic transducers with sets of pairwise incomparable output strings. Based on this, we develop an algorithm which learns semi-deterministic transducers given access to translation queries. We also prove that there is no learning algorithm for semi-deterministic transducers that uses only domain knowledge. [ABSTRACT FROM AUTHOR]

Numerical P systems are a class of P systems inspired both from the structure of living cells and from economics. In this work, we further investigate the generative capacity of numerical P systems as language generators. The families of languages generated by non-enzymatic, by enzymatic, and by purely enzymatic (all programs are enzymatic) numerical P systems working in the sequential mode are compared with the language families in the Chomsky hierarchy. Especially, a characterization of recursively enumerable languages is obtained by using purely enzymatic numerical P systems working in the sequential mode. [ABSTRACT FROM AUTHOR]

The concept of stratified graph introduces some method of representation which can be embedded with an interpretationmechanismin order to obtain objects fromsome knowledge domain based on the considered symbolic graph-based representations. As it was defined in the literature, the inference process uses the paths of the stratified graphs, an order between the elementary arcs of a path and some results of universal algebras. The order is defined by considering a structured path instead of a regular path. In a previous paper the concept of system of knowledge representation was defined. It includes a stratified graph G, a partial algebra Y of objects, an injective mapping that embeds the nodes of G into objects of Y and a set of algorithms that takes pairs of objects from Y to get some other object of Y. In this paper the inference process defined for such a system of knowledge considers the interpretation of the symbolic elements of a stratified graph as formal language constructions. The concepts introduced in this paper can initiate a possible research line concerning the automatic generation mechanism for formal languages. [ABSTRACT FROM AUTHOR]

A multiple interpretation scheme is an ordered sequence of morphisms. The ordered multiple interpretation of a word is obtained by concatenating the images of that word in the given order of morphisms. The arbitrary multiple interpretation of a word is the semigroup generated by the images of that word. These interpretations are naturally extended to languages. Four types of ambiguity of multiple interpretation schemata on a language are defined: o-ambiguity, internal ambiguity, weakly external ambiguity and strongly external ambiguity. We investigate the problem of deciding whether a multiple interpretation scheme is ambiguous on regular languages. [ABSTRACT FROM AUTHOR]

We propose and investigate a formal language operation inspired by the naturally occurring phenomenon of DNA primer extension by a DNA-template-directed DNA Polymerase enzyme. Given two DNA strings u and v, where the shorter string v (called primer) is Watson-Crick complementary and can thus bind to a substring of the longer string u (called template) the result of the primer extension is a DNA string that is complementary to a suffix of the template which starts at the binding position of the primer. The operation of DNA primer extension can be abstracted as a binary operation on two formal languages: a template language L1 and a primer language L2. We call this language operation L1-directed extension of L2 and study the closure properties of various language classes, including the classes in the Chomsky hierarchy, under directed extension. Furthermore, we answer the question under what conditions can a given language of target strings be generated from a given template language when the primer language is unknown. We use the canonic inverse of directed extension in order to obtain the optimal solution (the minimal primer language) to this question. [ABSTRACT FROM AUTHOR]

Limited automata are one-tape Turing machines which are allowed to rewrite each tape cell only in the first d visits, for a given constant d. For each d ≥⃒ 2, these devices characterize the class of context-free languages. We investigate the equivalence between 2-limited automata and pushdown automata, comparing the relative sizes of their descriptions. We prove exponential upper and lower bounds for the sizes of pushdown automata simulating 2-limited automata. In the case of the conversion of deterministic 2-limited automata into deterministic pushdown automata the upper bound is double exponential and we conjecture that it cannot be reduced. On the other hand, from pushdown automata we can obtain equivalent 2-limited automata of polynomial size, also preserving determinism. From our results, it follows that the class of languages accepted by deterministic 2-limited automata coincides with the class of deterministic context-free languages. [ABSTRACT FROM AUTHOR]

In this paper, we approach the problem of accepting all recursively enumerable languages by accepting networks of evolutionary processors (ANEPs, for short) with a fixed architecture. More precisely, we show that every recursively enumerable language can be accepted by an ANEP with an underlying graph in the form of a star with 13 nodes or by an ANEP with an underlying grid with 13 × 4 = 52 nodes as well as by ANEPs having underlying graphs in the form of a chain, a ring, or a wheel with 29 nodes each. In all these cases, the size and form as well as the general working strategy of the constructed networks do not depend on the accepted language; only the rewriting rules and the filters associated to each node of the networks depend on this language. Noteworthy is also the fact that the filtering process is implemented using random context conditions only. Our results answer problems which were left open in a paper published by J. Dassow and F. Manea at the conference on Descriptional Complexity of Formal Systems (DCFS) 2010 and improve a result published by B. Truthe at the conference on Non-Classical Models of Automata and Applications (NCMA) 2013. [ABSTRACT FROM AUTHOR]

Scientists have long dreamed of creating machines humans could interact with by voice. Although one no longer believes Turing's prophecy that machines will be able to converse like humans in the near future, real progress has been made in the voice and text-based human-machine interaction. This paper is a light introduction and survey of some deployed natural language systems and technologies and their historical evolution. We review two fundamental problems involving natural language: the language prediction problem and the language understanding problem. While describing in detail all these technologies is beyond our scope, we do comment on some aspects less discussed in the literature such as language prediction using huge models and semantic labeling using Marcus contextual grammars. [ABSTRACT FROM AUTHOR]

The Sardinas-Patterson's test for codes has contributed many effective testing algorithms to the development of theory of codes, formal languages, etc. However, we will show that a modification of this test proposed in this paper can deduce more effective testing algorithms for codes. As a consequence, we establish a quadratic algorithm that, given as input a regular language X defined by a tuple (φ, M, B), where φ : A* → M is a monoid morphism saturating X, M is a finite monoid, $B \subseteq M$, X = φ-1(B), decides in time complexity $\mathcal{O}(n^2)$ whether X is a code, where n = Card(M). Specially, n can be chosen as the finite index of X. A quadratic algorithm for testing of ⋄-codes is also established. [ABSTRACT FROM AUTHOR]

In abstract argumentation, each argument is regarded as atomic. There is no internal structure to an argument. Also, there is no specification of what is an argument or an attack. They are assumed to be given. This abstract perspective provides many advantages for studying the nature of argumentation, but it does not cover all our needs for understanding argumentation or for building tools for supporting or undertaking argumentation. If we want a more detailed formalisation of arguments than is available with abstract argumentation, we can turn to structured argumentation, which is the topic of this special issue of Argument and Computation. In structured argumentation, we assume a formal language for representing knowledge, and specifying how arguments and counterarguments can be constructed from that knowledge. An argument is then said to be structured in the sense that normally the premises and claim of the argument are made explicit, and the relationship between the premises and claim is formally defined (for instance using logical entailment). In this introduction, we provide a brief overview of the approaches covered in this special issue on structured argumentation. [ABSTRACT FROM AUTHOR]

The regulated rewriting mechanism is one of the most efficient methods to augment the Chomsky hierarchy with a large variety of language classes. In this paper we investigate the derivation mechanism in regulated rewriting grammars such as matrix grammars, by studying their Szilard languages. We focus on the complexity of Szilard languages associated with unrestricted and leftmost-like derivations in matrix grammars, with or without appearance checking. The reason is twofold. First, to relate these classes of languages to parallel complexity classes such as 𝒩𝒞1 and 𝒜𝒞1, and, second, to improve some previous results. We prove that unrestricted Szilard languages and certain leftmost Szilard languages of context-free matrix grammars, without appearance checking, can be accepted by indexing alternating Turing machines in logarithmic time and space. Consequently, these classes are included in UE*-uniform 𝒩𝒞1. Unrestricted Szilard languages of matrix grammars with appearance checking can be accepted by deterministic Turing machines in 𝒪(n log n) time and 𝒪(log n) space. Leftmost-like Szilard languages of context-free matrix grammars, with appearance checking, can be recognized by nondeterministic Turing machines by using the same time and space resources. Hence, all these classes are included in 𝒜𝒞1. [ABSTRACT FROM AUTHOR]

A filtration of a formal language L by a sequence s maps L to the set of words formed by taking the letters of words of L indexed only by s. We consider the languages resulting from filtering by all arithmetic progressions. If L is regular, it is easy to see that only finitely many distinct languages result; we give bounds on the number of distinct languages in terms of the state complexity of L. By contrast, there exist CFL's that give infinitely many distinct languages as a result. We use our technique to show that two related operations, including diag (which extracts the diagonal of words of square length arranged in a square array), preserve regularity but do not preserve context-freeness. [ABSTRACT FROM AUTHOR]

In an earlier paper, the author used derivatives to construct a deterministic automaton recognizing the language defined by an ω-regular expression. The construction was related to a determinization method invented by Safra. This paper describes a new construction, inspired by Piterman's improvement to Safra's method. It produces an automaton with fewer states. In addition, the presentation and proofs are simplified by going via a nondeterministic automaton having derivatives as states. [ABSTRACT FROM AUTHOR]

Applying an attributed graph transformation rule to a given object graph always implies some kind of constraint solving. In many cases, the given constraints are almost trivial to solve. For instance, this is the case when a rule describes a transformation G ⇒ H, where the attributes of H are obtained by some simple computation from the attributes of G. However there are many other cases where the constraints to solve may be not so trivial and, moreover, may have several answers. This is the case, for instance, when the transformation process includes some kind of searching. In the current approaches to attributed graph transformation these constraints must be completely solved when defining the matching of the given transformation rule. This kind of early binding is well-known from other areas of Computer Science to be inadequate. For instance, the solution chosen for the constraints associated to a given transformation step may be not fully adequate, meaning that later, in the search for a better solution, we may need to backtrack this transformation step. In this paper, based on our previous work on the use of symbolic graphs to deal with different aspects related with attributed graphs, including attributed graph transformation, we present a new approach that, based on the new notion of narrowing graph transformation rule, allows us to delay constraint solving when doing attributed graph transformation, in a way that resembles lazy computation. For this reason, we have called lazy this new kind of transformation. Moreover, we show that the approach is sound and complete with respect to standard attributed graph transformation. A running example, where a graph transformation system describes some basic operations of a travel agency, shows the practical interest of the approach. [ABSTRACT FROM AUTHOR]

Graph transformation systems have been studied extensively and applied to several areas of computer science like formal language theory, the modeling of databases, concurrent or distributed systems, and visual, logical, and functional programming. In most kinds of applications it is necessary to have the possibility of restricting the applicability of rules. This is usually done by means of application conditions. In this paper, we continue the work of extending the fundamental theory of graph transformation to the case where rules may use arbitrary (nested) application conditions. More precisely, we generalize the Embedding theorem, and we study how local confluence can be checked in this context. In particular, we define a new notion of critical pair which allows us to formulate and prove a Local Confluence Theorem for the general case of rules with nested application conditions. All our results are presented, not for a specific class of graphs, but for any arbitrary ℳ-adhesive category, which means that our results apply to most kinds of graphical structures. We demonstrate our theory on the modeling of an elevator control by a typed graph transformation system with positive and negative application conditions. [ABSTRACT FROM AUTHOR]

In transforming any large scale, complex, global supply network, a key challenge is knowledge management. There are many stakeholders, spread across a number of enterprise functions, whose decisions directly or indirectly impact the success of the transformation. Typically, each stakeholder has important, often tacit knowledge that in contemporary practice is difficult or impossible to share effectively with other stakeholders, yet can be critical to the success of the transformation. The intended "to be" state maybe defined abstractly, but the full intent may not be explicitly understood by all stakeholders. The lack of a complete coherent shared understanding of the to-be state can have major repercussions in transformation decision making. The challenge for global enterprises is to capture as much of the critical tacit or implicit knowledge as is practical, so it can be vetted, shared, re-used, and leveraged. This chapter introduces a methodology and a set of tools that can be used to effect some aspects of knowledge capture, sharing and re-use in the context of enterprise transformation, and illustrates their use with two examples. [ABSTRACT FROM AUTHOR]

We consider the representational state complexity of unranked tree automata. The bottom-up computation of an unranked tree automaton may be either deterministic or nondeterministic, and further variants arise depending on whether the horizontal string languages defining the transitions are represented by a DFA or an NFA. Also, we consider for unranked tree automata the alternative syntactic definition of determinism introduced by Cristau et al. (FCT'05, LNCS 3623, pp. 68-79). We establish upper and lower bounds for the state complexity of conversions between different types of unranked tree automata. [ABSTRACT FROM AUTHOR]

Between modal logic and closure operators for topological spaces as well as for formal languages there exists a strong relation. Modal logic allows to define classes of formal languages in several ways. [ABSTRACT FROM AUTHOR]

SystemC is an IEEE standard system-level language used in hardware/software co-design and has been widely adopted in the industry. This paper describes a formal approach to verifying SystemC designs by providing a mapping to the process algebra mCRL2. Our mapping formalizes both the simulation semantics as well as exhaustive state-space exploration of SystemC designs. By exploiting the existing reduction techniques of mCRL2 and also its model-checking tools, we efficiently locate the race conditions in a system and resolve them. A tool is implemented to automatically perform the proposed mapping. This mapping and the implemented tool enabled us to exploit process-algebraic verification techniques to analyze a number of case-studies, including the formal analysis of a single-cycle and a pipelined MIPS processor specified in SystemC. [ABSTRACT FROM AUTHOR]

5′ → 3′ WK-automata are Watson-Crick automata whose two heads start on opposite ends of the input word and always run in opposite directions. One full reading in both directions is called a run. We prove that the expressive power of these automata increases with every additional run that they can make, both for deterministic and non-deterministic machines. This defines two incomparable infinite hierarchies of language classes between the regular and the context-sensitive languages. These hierarchies are complemented with classes defined by several restricted variants of 5′ → 3′ WK-automata like stateless automata. Finally we show that several standard problems are undecidable for languages accepted by 5′ → 3′ WK-automata in only one run, for example the emptiness and the finiteness problems. [ABSTRACT FROM AUTHOR]

Restarting automata were introduced as a model for analysis by reduction, which is a linguistically motivated method for checking correctness of a sentence. We propose a new restricted version of restarting automata called clearing restarting automata with a very simple definition but simultaneously with interesting properties with respect to their possible applications. The new model can be learned very efficiently from positive examples and its stronger version can be used to learn effectively a large class of languages. We relate the class of languages recognized by clearing restarting automata to the Chomsky hierarchy. [ABSTRACT FROM AUTHOR]

Recognizable two-dimensional languages (REC) are defined by tiling systems that generalize to two dimensions non-deterministic finite automata for strings. We introduce the notion of deterministic tiling system and the corresponding family of languages (DREC) and study its structural and closure properties. Furthermore we show that, in contrast with the one-dimensional case, there exist other classes between deterministic and non-deterministic families that we separate by means of examples and decidability properties. [ABSTRACT FROM AUTHOR]

We discuss the power of networks of evolutionary processors where only two types of nodes are allowed. We prove that (up to an intersection with a monoid) every recursively enumerable language can be generated by a network with one deletion and one insertion node. Networks with an arbitrary number of deletion and substitution nodes only produce finite languages, and for each finite language one deletion node or one substitution node is sufficient. Networks with an arbitrary number of insertion and substitution nodes only generate context-sensitive languages, and (up to an intersection with a monoid) every context-sensitive language can be generated by a network with one substitution node and one insertion node. All results are optimal with respect to the number of nodes. [ABSTRACT FROM AUTHOR]

We consider a new variant of the halting condition in P systems, i.e., a computation in a P system is already called halting if not for all membranes a rule is applicable anymore at the same time, whereas usually a computation is called halting if no rule is applicable anymore in the whole system. This new variant of partial halting is especially investigated for several variants of P systems using membrane rules with permitting contexts and working in different transition modes, especially for minimal parallelism. Both partial halting and minimal parallelism are based on an arbitrary set of subsets from the set of rules assigned to the membranes. [ABSTRACT FROM AUTHOR]

A not so well-known result in formal language theory is that the Higman-Haines sets for any language are regular [11, Theorem 4.4]. It is easily seen that these sets cannot be effectively computed in general. The Higman-Haines sets are the languages of all scattered subwords of a given language as well as the sets of all words that contain some word of a given language as a scattered subword. Recently, the exact level of unsolvability of Higman-Haines sets was studied in [8]. Here we focus on language families whose Higman-Haines sets are effectively constructible. In particular, we study the size of descriptions of Higman-Haines sets for the lower classes of the Chomsky hierarchy, namely for the family of regular, linear context-free, and context-free languages. We prove upper and lower bounds on the size of descriptions of these sets for general and unary languages. [ABSTRACT FROM AUTHOR]

The two areas of grammar systems and P systems, which have provided interesting computational models in the study of formal string language theory have been in the recent past effectively linked in [4] by incorporating into P systems, a communication mode called t–mode of cooperating distributed grammar systems. On the other hand cooperating array grammar systems [5] and array P systems [1] have been developed in the context of two-dimensional picture description. In this paper, motivated by the study of [4], these two systems are studied by linking them through the t–communication mode, thus bringing out the picture description power of these systems. [ABSTRACT FROM AUTHOR]

This paper presents a formal syntax framework of natural languages for computational linguistics. The abstract syntax of natural languages, particularly English, and their formal manipulations are described. On the basis of the abstract syntax, a universal language processing model and the deductive grammar of English are developed toward the formalization of Chomsky's universal grammar in linguistics. Comparative analyses of natural and programming languages, as well as the linguistic perception on software engineering, are discussed. A wide range of applications of the deductive grammar of English have been explored in language acquisition, comprehension, generation, and processing in cognitive informatics, computational intelligence, and cognitive computing. [ABSTRACT FROM AUTHOR]

We investigate the nondeterministic state complexity of basic operations for prefix-free regular languages. The nondeterministic state complexity of an operation is the number of states that are necessary and sufficient in the worst-case for a minimal nondeterministic finite-state automaton that accepts the language obtained from the operation. We establish the precise state complexity of catenation, union, intersection, Kleene star, reversal and complementation for prefix-free regular languages. [ABSTRACT FROM AUTHOR]

This paper proposes a formal environment for distributed embedded systems. This approach consists of modelling our embedded system in a hierarchical manner by subdividing it into levels. The first level consists of the modelled application using a task set and the operating system objects (semaphores, mailboxes, watchdogs) which schedule tasks to realise application functions. The second level consists of modelling the hardware components of our embedded system. Our distributed system consists of a network of ECU (Electronic Control Unity) in which like-CAN bus allows ECU to communicate with each other. The communication with the ECU is based on pre-emptive fixed priority scheduling. The Architecture scheme contains an OS layer. This paper suggests an approach based on abstraction to different pieces of architecture, e.g., ECU, OS, application, communicating bus, is suggested. A formal method which allows for interaction between software and hardware elements of the distributed architecture is developed. Based on IF-language, models of all these elements are proposed. The external environment of the distributed systems is also modelled. Observer automata is also suggested to specify architecture properties. These ideas are presented through exploration of an automotive case study. [ABSTRACT FROM AUTHOR]