Lorijn van Rooijen

Separating Regular Languages by Piecewise Testable and Unambiguous Languages

Separation is a classical problem asking whether, given two sets belonging to some class, it is possible to separate them by a set from another class. We discuss the separation problem for regular languages. We give a Ptime algorithm to check whether two given regular languages are separable by a piecewise testable language, that is, whether a \(\mathcal{B}\Sigma_1(<)\) sentence can witness that the languages are disjoint. The proof refines an algebraic argument from Almeida and the third author. When separation is possible, we also express a separator by saturating one of the original languages by a suitable congruence. Following the same line, we show that one can as well decide whether two regular languages can be separated by an unambiguous language, albeit with a higher complexity.

A Note on Decidable Separability by Piecewise Testable Languages

The separability problem for word languages of a class \(\mathcal {C}\) by languages of a class \(\mathcal {S}\) asks, for two given languages I and E from \(\mathcal {C}\), whether there exists a language S from \(\mathcal {S}\) that includes I and excludes E, that is, \(I \subseteq S\) and \(S\cap E = \emptyset \). It is known that separability for context-free languages by any class containing all definite languages (such as regular languages) is undecidable. We show that separability of context-free languages by piecewise testable languages is decidable. This contrasts with the fact that testing if a context-free language is piecewise testable is undecidable. We generalize this decidability result by showing that, for every full trio (a class of languages that is closed under rather weak operations) which has decidable diagonal problem, separability with respect to piecewise testable languages is decidable. Examples of such classes are the languages defined by labeled vector addition systems and the languages accepted by higher order pushdown automata of order two. The proof goes through a result which is of independent interest and shows that, for any kind of languages I and E, separability can be decided by testing the existence of common patterns in I and E.

Separating Regular Languages by Locally Testable and Locally Threshold Testable Languages

A separator for two languages is a third language containing the first one and disjoint from the second one. We investigate the following decision problem: given two regular input languages, decide whether there exists a locally testable (resp. a locally threshold testable) separator. In both cases, we design a decision procedure based on the occurrence of special patterns in automata accepting the input languages. We prove that the problem is computationally harder than deciding membership. The correctness proof of the algorithm yields a stronger result, namely a description of a possible separator. Finally, we discuss the same problem for context-free input languages.

Relational semantics for full linear logic

Abstract Relational semantics, given by Kripke frames, play an essential role in the study of modal and intuitionistic logic. In [4] it is shown that the theory of relational semantics is also available in the more general setting of substructural logic, at least in an algebraic guise. Building on these ideas, in [5] a type of frames is described which generalise Kripke frames and provide semantics for substructural logics in a purely relational form. In this paper we study full linear logic from an algebraic point of view. The main additional hurdle is the exponential. We analyse this operation algebraically and use canonical extensions to obtain relational semantics. Thus, we extend the work in [4] , [5] and use their approach to obtain relational semantics for full linear logic. Hereby we illustrate the strength of using canonical extension to retrieve relational semantics: it allows a modular and uniform treatment of additional operations and axioms. Traditionally, so-called phase semantics are used as models for (provability in) linear logic [8] . These have the drawback that, contrary to our approach, they do not allow a modular treatment of additional axioms. However, the two approaches are related, as we will explain.

Generalized Kripke semantics for the Lambek–Grishin calculus

properties. It turns out that this extension is precisely the algebra of Galois closed sets of the canonical frame as defined in section 2 of [Geh06]. Thus we get a simple abstract manner of working with the canonical frame. This makes it easy to treat additional operations and their interaction axioms. In particular, from A = (A,⊗, /, \,⊕,;, ) we get Aδ = (Aδ,⊗σ, / π, \ π,⊕π,; σ, σ) and Aδ is the algebra of Galois closed sets for some frame which we denote by (X,Y,6, R⊗σ , R⊕π) =: F(A). The central role of the canonical extension in the process of finding relational semantics is illustrated by the following diagramme. Lambek-Grishin logic LG-algebras A = (A,⊗, /, \,⊕,;, ) Canonical extensions Aδ ∼= (G(X,Y,6),⊗σ, / π, \ π,⊕π,; σ, σ) Lambek-Grishin frames F(A) = (X,Y,6, R⊗σ , R⊕π) Relational semantics // oo This process works for the Lindenbaum algebra A of the LG∅-logic in the sense that the canonical frame F(A) with the interpretation given by the embedding map is a model of precisely those sequents that are deducible in LG∅, as the following equivalences demonstrate. A ` B holds in LG∅ ⇐⇒ A 6 B holds in A ∗ ⇐⇒ [A]Aδ 6 [B]Aδ holds in A ⇐⇒ F(A) A ` B, where the subscript Aδ means that the formula is interpreted in Aδ. We call A = (A,⊗, /, \,⊕,;, ) an LG-algebra provided A is a poset, and the operations of A satisfy the rules of LG∅, i.e. / and \ are upper residuals of ⊗, while ; and are lower residuals of ⊕. The process of getting a canonical extension and from a canonical extension a Lambek-Grishin frame works for any LG-algebra. When dealing with a class of algebras that satisfy additional interaction axioms (e.g. one of Grishin’s groups, see next section), our aim is to find out which first-order condition is imposed by these axioms on the class of Lambek-Grishin frames. In order to prove the completeness of an axiomatic extension of LG∅, two components are needed: 1. We have to show that if we start with A, the Lindenbaum algebra for some extension of LG∅, then for each additional axiom, the equivalence indicated by ∗ still works. This

On Separation by Locally Testable and Locally Threshold Testable Languages

A separator for two languages is a third language containing the first one and disjoint from the second one. We investigate the following decision problem: given two regular input languages, decide whether there exists a locally testable (resp. a locally threshold testable) separator. In both cases, we design a decision procedure based on the occurrence of special patterns in automata accepting the input languages. We prove that the problem is computationally harder than deciding membership. The correctness proof of the algorithm yields a stronger result, namely a description of a possible separator. Finally, we discuss the same problem for context-free input languages.

Active coevolutionary learning of requirements specifications from examples

Within software engineering, requirements engineering starts from imprecise and vague user requirements descriptions and infers precise, formalized specifications. Techniques, such as interviewing by requirements engineers, are typically applied to identify the users needs. We want to partially automate even this first step of requirements elicitation by methods of evolutionary computation. The idea is to enable users to specify their desired software by listing examples of behavioral descriptions. Users initially specify two lists of operation sequences, one with desired behaviors and one with forbidden behaviors. Then, we search for the appropriate formal software specification in the form of a deterministic finite automaton. We solve this problem known as grammatical inference with an active coevolutionary approach following Bongard and Lipson [2]. The coevolutionary process alternates between two phases: (A) additional training data is actively proposed by an evolutionary process and the user is interactively asked to label it; (B) appropriate automata are then evolved to solve this extended grammatical inference problem. Our approach leverages multi-objective evolution in both phases and outperforms the state-of-the-art technique [2] for input alphabet sizes of three and more, which are relevant to our problem domain of requirements specification.

From User Demand to Software Service: Using Machine Learning to Automate the Requirements Specification Process

Bridging the gap between informal, imprecise, and vague user requirements descriptions and precise formalized specifications is the main task of requirements engineering. Techniques such as interviews or story telling are used when requirements engineers try to identify a users needs. The requirements specification process is typically done in a dialogue between users, domain experts, and requirements engineers. In our research, we aim at automating the specification of requirements. The idea is to distinguish between untrained users and trained users, and to exploit domain knowledge learned from previous runs of our system. We let untrained users provide unstructured natural language descriptions, while we allow trained users to provide examples of behavioral descriptions. In both cases, our goal is to synthesize formal requirements models similar to statecharts. From requirements specification processes with trained users, behavioral ontologies are learned which are later used to support the requirements specification process for untrained users. Our research method is original in combining natural language processing and search-based techniques for the synthesis of requirements specifications. Our work is embedded in a larger project that aims at automating the whole software development and deployment process in envisioned future software service markets.