Formal language

About: Formal language is a research topic. Over the lifetime, 5763 publications have been published within this topic receiving 154114 citations.

Logic programming and parallel complexity

Abstract: This paper is a survey of the many applications of the theory of parallel algorithms and complexity to logic programming problems. The mathematical tools relevant to the analysis of parallel logic programs include: the concept of alternation, the complexity class NC, and parallel algorithms using randomization and/or achieving optimal speed-ups. The logic programming problems addressed are related to query optimization for deductive databases and to fast parallel execution of primitive operations in logic programming languages, such as, fixpoint operators, term unification, and term matching. The formal language we use to illustrate the addition of recursion to database queries is the language of logical query programs (or programs), whose evaluation has been the object of much recent research. Our presentation highlights the fact that all of these results can be stated using the stage function sH(n) of a program H, where n is the size of the database queried. In this context we also present two new observations. (1) Given a linear single rule program H, it is NP-hard to decide whether sH(n)=O(1); this extends the bounded recursion analysis of[57, 42]. (2) There is a program that can be evaluated in s(n)=O(log n) stages, but whose derivation trees (of width 1) are of size exponential in n. An extension of derivation trees from width 1 to constant width properly strengthens the fast evaluation method of [76].

MDD4SOA: Model-Driven Service Orchestration

Abstract: Service-Oriented Architectures (SOAs) have become an important cornerstone of the development of enterprise-scale software applications. Although a range of domain-specific languages and standards are available for dealing with such architectures, model-driven approaches starting from models written in an established modelling language like UML and including the ability for model transformation (in particular, for code generation) are still in their infancy. In this paper, we show (1) how our UML-based domain-specific language for working with SOA artefacts, UML4SOA, can be used for modelling service orchestrations, and (2) how to exploit so-designed models in the MDD4SOA approach to generate code in multiple languages, among them BPEL and WSDL, Java, and the formal language Jolie. We use a case study for illustrating this approach. Our main contributions are an easy-to-use, conservative extension to the UML2 for modelling service orchestrations on a high level of abstraction, and a fully automated, model-driven approach for transforming these orchestrations down to code.

Petri nets as discrete event models for supervisory control

Abstract: Discrete event systems represents a new field of control theory of increasing importance in the domains of manufacturing, communications, and robotics. Supervisory Control theory, based on formal languages, is a well established framework for the study of discrete event systems. The thesis discusses the use of Petri nets in Supervisory Control. Place/Transition nets have been used by several authors to represent discrete event systems. In our approach, the supervisor, i.e., the control agent that restricts the behavior of a system within a legal behavior, is represented as a Place/Transition net as well. The advantage of such a supervisor, as opposed to a supervisor given as a feedback function, is that a closed loop model of the controlled system may be constructed and analyzed using the techniques pertaining to Petri net models. We show that a Petri net supervisor may not exist if the system's behavior or the legal behavior are nonregular Petri net languages. By defining a new class of Petri net languages, called deterministic P-closed, it is possible to derive necessary and sufficient conditions for the existence of supervisors as nets. The thesis presents an algorithm, based on the concurrent composition operator, for the design of Petri net supervisors and discusses how a composed net may be validated. In a first approach, based on incidence matrix analysis, important properties of the net, such as controllability or such as the absence of blocking states, may be studied by Integer Programming techniques. In a second approach, we consider a class of specifications, called generalized mutual exclusion constraints, and discuss several possible structures for the supervisor capable of enforcing them.

Relating state-based and process-based concurrency through linear logic (full-version)

Abstract: This paper has the purpose of reviewing some of the established relationships between logic and concurrency, and of exploring new ones. Concurrent and distributed systems are notoriously hard to get right. Therefore, following an approach that has proved highly beneficial for sequential programs, much effort has been invested in tracing the foundations of concurrency in logic. The starting points of such investigations have been various idealized languages of concurrent and distributed programming, in particular the well established state-transformation model inspired by Petri nets and multiset rewriting, and the prolific process-based models such as the @p-calculus and other process algebras. In nearly all cases, the target of these investigations has been linear logic, a formal language that supports a view of formulas as consumable resources. In the first part of this paper, we review some of these interpretations of concurrent languages into linear logic and observe that, possibly modulo duality, they invariably target a small semantic fragment of linear logic that we call LV^o^b^s. In the second part of the paper, we propose a new approach to understanding concurrent and distributed programming as a manifestation of logic, which yields a language that merges those two main paradigms of concurrency. Specifically, we present a new semantics for multiset rewriting founded on an alternative view of linear logic and specifically LV^o^b^s. The resulting interpretation is extended with a majority of linear connectives into the language of @w-multisets. This interpretation drops the distinction between multiset elements and rewrite rules, and considerably enriches the expressive power of standard multiset rewriting with embedded rules, choice, replication, and more. Derivations are now primarily viewed as open objects, and are closed only to examine intermediate rewriting states. The resulting language can also be interpreted as a process algebra. For example, a simple translation maps process constructors of the asynchronous @p-calculus to rewrite operators. The language of @w-multisets forms the basis for the security protocol specification language MSR 3. With relations to both multiset rewriting and process algebra, it supports specifications that are process-based, state-based, or of a mixed nature, with the potential of combining verification techniques from both worlds. Additionally, its logical underpinning makes it an ideal common ground for systematically comparing protocol specification languages.