Showing papers on "Formal language published in 2009"

Distributed Control of Robotic Networks: A Mathematical Approach to Motion Coordination Algorithms

Abstract: This self-contained introduction to the distributed control of robotic networks offers a distinctive blend of computer science and control theory. The book presents a broad set of tools for understanding coordination algorithms, determining their correctness, and assessing their complexity; and it analyzes various cooperative strategies for tasks such as consensus, rendezvous, connectivity maintenance, deployment, and boundary estimation. The unifying theme is a formal model for robotic networks that explicitly incorporates their communication, sensing, control, and processing capabilities--a model that in turn leads to a common formal language to describe and analyze coordination algorithms.Written for first- and second-year graduate students in control and robotics, the book will also be useful to researchers in control theory, robotics, distributed algorithms, and automata theory. The book provides explanations of the basic concepts and main results, as well as numerous examples and exercises.Self-contained exposition of graph-theoretic concepts, distributed algorithms, and complexity measures for processor networks with fixed interconnection topology and for robotic networks with position-dependent interconnection topology Detailed treatment of averaging and consensus algorithms interpreted as linear iterations on synchronous networks Introduction of geometric notions such as partitions, proximity graphs, and multicenter functions Detailed treatment of motion coordination algorithms for deployment, rendezvous, connectivity maintenance, and boundary estimation

Handbook of Weighted Automata

Abstract: Weighted finite automata are classical nondeterministic finite automata in which the transitions carry weights These weights may model, for example, the cost involved when executing a transition, the resources or time needed for this, or the probability or reliability of its successful execution Weights can also be added to classical automata with infinite state sets like pushdown automata, and this extension constitutes the general concept of weighted automata Since their introduction in the 1960s they have stimulated research in related areas of theoretical computer science, including formal language theory, algebra, logic, and discrete structures Moreover, weighted automata and weighted context-free grammars have found application in natural-language processing, speech recognition, and digital image compression This book covers all the main aspects of weighted automata and formal power series methods, ranging from theory to applications The contributors are the leading experts in their respective areas, and each chapter presents a detailed survey of the state of the art and pointers to future research The chapters in Part I cover the foundations of the theory of weighted automata, specifically addressing semirings, power series, and fixed point theory Part II investigates different concepts of weighted recognizability Part III examines alternative types of weighted automata and various discrete structures other than words Finally, Part IV deals with applications of weighted automata, including digital image compression, fuzzy languages, model checking, and natural-language processing Computer scientists and mathematicians will find this book an excellent survey and reference volume, and it will also be a valuable resource for students exploring this exciting research area

Semirings and Formal Power Series

Abstract: This chapter presents basic foundations for the theory of weighted automata: semirings and formal power series. A fundamental question is how to extend the star operation (Kleene iteration) from languages to series. For this, we investigate ordered, complete and continuous semirings and the related concepts of star semirings and Conway semirings. We derive natural properties for the Kleene star of cycle-free series and also of matrices often used to analyze the behavior of weighted automata. Finally, we investigate cycle-free linear equations which provide a useful tool for proving identities for formal power series.

Access control policy combining: theory meets practice

Abstract: Many access control policy languages, e.g., XACML, allow a policy to contain multiple sub-policies, and the result of the policy on a request is determined by combining the results of the sub-policies according to some policy combining algorithms (PCAs). Existing access control policy languages, however, do not provide a formal language for specifying PCAs. As a result, it is difficult to extend them with new PCAs. While several formal policy combining algebras have been proposed, they did not address important practical issues such as policy evaluation errors and obligations; furthermore, they cannot express PCAs that consider all sub-policies as a whole (e.g., weak majority or strong majority). We propose a policy combining language PCL, which can succinctly and precisely express a variety of PCAs. PCL represents an advancement both in terms of theory and practice. It is based on automata theory and linear constraints, and is more expressive than existing approaches. We have implemented PCL and integrated it with SUN's XACML implementation. With PCL, a policy evaluation engine only needs to understand PCL to evaluate any PCA specified in it.

Learning for Semantic Parsing

Abstract: Semantic parsing is the task of mapping a natural language sentence into a complete, formal meaning representation. Over the past decade, we have developed a number of machine learning methods for inducing semantic parsers by training on a corpus of sentences paired with their meaning representations in a specified formal language. We have demonstrated these methods on the automated construction of natural-language interfaces to databases and robot command languages. This paper reviews our prior work on this topic and discusses directions for future research.

To CNF or not to CNF? An Efficient Yet Presentable Version of the CYK Algorithm.

Abstract: The most familiar algorithm to decide the membership problem for context-free grammars is the one by Cocke, Younger and Kasami (CYK) using grammars in Chomsky normal form (CNF). We propose to teach a simple modification of the CYK algorithm that uses grammars in a much less restrictive binary normal form (2NF) and two precomputations: the set of nullable nonterminals and the inverse of the unit relation between symbols. The modified algorithm is equally simple as the original one, but highlights that the at most binary branching rules alone are responsible for the O(n 3 ) time complexity. Moreover, the simple transformation to 2NF comes with a linear increase in grammar size, whereas some transformations to CNF found in most prominent textbooks on formal languages may lead to an exponential increase.

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.

Requirements Validation for Hybrid Systems

Abstract: The importance of requirements for the whole development flow calls for strong validation techniques based on formal methods. In the case of discrete systems, some approaches based on temporal logic satisfiability are gaining increasing momentum. However, in many real-world domains (e.g. railways signaling), the requirements constrain the temporal evolution of both discrete and continuous variables. These hybrid domains pose substantial problems: on one side, a continuous domain requires very expressive formal languages; on the other side, the resulting expressiveness results in highly intractable problems. In this paper, we address the problem of requirements validation for real-world hybrid domains, and present two main contributions. First, we propose the HRELTL logic, that extends the Linear-time Temporal Logic with Regular Expressions (RELTL) with hybrid aspects. Second, we show that the satisfiability problem for the linear fragment can be reduced to an equi-satisfiable problem for RELTL. This makes it possible to use automatic (albeit incomplete) techniques based on Bounded Model Checking and on Satisfiability Modulo Theory. The choice of the language is inspired by and validated within a project funded by the European Railway Agency, on the formalization and validation of the European Train Control System specifications. The activity showed that most of requirements can be formalized into HRELTL, and an experimental evaluation confirmed the practicality of the analyses.

One Dimensional Cellular Automata

Abstract: The book deals with analytical and computational studies of spatially-extended discrete dynamical systems: one-dimensional cellular automata. The topics included are non-constructible configurations, reversibility, probabilistic analysis and De Bruijn diagrams. Techniques discussed are based on topology, matrix theory, formal languages and probability theory. The book is an excellent reading for anybody interested in non-linearity, emergency, complexity and self-organization.

Formal Languages and Groups as Memory

Abstract: We present an exposition of the theory of M-automata and G-automata, or finite automata augmented with a multiply-only register storing an element of a given monoid or group. Included are a number of new results of a foundational nature. We illustrate our techniques with a group-theoretic interpretation and proof of a key theorem of Chomsky and Schutzenberger from formal language theory.

Mathematical logic in the human brain: syntax.

Abstract: Theory predicts a close structural relation of formal languages with natural languages. Both share the aspect of an underlying grammar which either generates (hierarchically) structured expressions or allows us to decide whether a sentence is syntactically correct or not. The advantage of rule-based communication is commonly believed to be its efficiency and effectiveness. A particularly important class of formal languages are those underlying the mathematical syntax. Here we provide brain-imaging evidence that the syntactic processing of abstract mathematical formulae, written in a first order language, is, indeed efficient and effective as a rule-based generation and decision process. However, it is remarkable, that the neural network involved, consisting of intraparietal and prefrontal regions, only involves Broca's area in a surprisingly selective way. This seems to imply that despite structural analogies of common and current formal languages, at the neural level, mathematics and natural language are processed differently, in principal.

Increasing engagement in automata theory with JFLAP

Abstract: We describe the results from a two-year study with fourteen universities on presenting formal languages in a more visual, interactive and applied manner using JFLAP. In our results the majority of students felt that having access to JFLAP made learning course concepts easier, made them feel more engaged in the course and made the course more enjoyable. We also describe changes and additions to JFLAP we have made based on feedback from users. These changes include new algorithms such as a CYK parser and a user-controlled parser, and new resources that include a JFLAP online tutorial, a wiki and a listserv.

Expressiveness and Closure Properties for Quantitative Languages

Abstract: Weighted automata are nondeterministic automata with numerical weights on transitions. They can define quantitative languages L that assign to each word w a real number L(w). In the case of infinite words, the value of a run is naturally computed as the maximum, limsup, liminf, limit average, or discounted sum of the transition weights. We study expressiveness and closure questions about these quantitative languages. We first show that the set of words with value greater than a threshold can be non-omega-regular for deterministic limit-average and discounted-sum automata, while this set is always omega-regular when the threshold is isolated (i.e., some neighborhood around the threshold contains no word). In the latter case, we prove that the omega-regular language is robust against small perturbations of the transition weights. We next consider automata with transition weights 0 or 1 and show that they are as expressive as general weighted automata in the limit-average case, but not in the discounted-sum case. Third, for quantitative languages L1 and L2, we consider the operations max(L1, L2), min(L1, L2), and 1-L1, which generalize the boolean operations on languages, as well as the sum L1 + L2. We establish the closure properties of all classes of quantitative languages with respect to these four operations.

Regular tree languages definable in FO and in FOmod

Abstract: We consider regular languages of labeled trees. We give an effective characterization of the regular languages over such trees that are definable in first-order logic in the language of labeled graphs. These languages are the analog on trees of the “locally threshold testable” languages on strings. We show that this characterization yields a decision procedure for determining whether a regular tree language is first-order definable: The procedure is polynomial time in the minimal automaton presenting the regular language. We also provide an algorithm for deciding whether a regular language is definable in first-order logic supplemented with modular quantifiers.

Cellular Automata and Language Theory.

Abstract: Cellular automaton A (one-dimensional) cellular automaton is a linear array of cells which are connected to both of their nearest neighbors. The total number of cells in the array is determined by the input data. They are exactly in one of a finite number of states, which is changed according to local rules depending on the current state of a cell itself and the current states of its neighbors. The state changes take place simultaneously at discrete time steps. The input mode for cellular automata is called parallel. One can suppose that all cells fetch their input symbol during a pre-initial step. Iterative array Basically, iterative arrays are cellular automata whose leftmost cell is distinguished. This socalled communication cell is connected to the input supply and fetches the input sequentially. The cells are initially empty, that is, in a special quiescent state. Formal language The data on which the devices operate are strings built from input symbols of a finite set or alphabet. A subset of strings over a given alphabet is a formal language. Signal Signals are used to transmit and encode information in cellular automata. If a cell changes to the state of its neighbor after some k time steps, and if subsequently its neighbors and their neighbors do the same, then the basic signal moves with speed k through the array. With the help of auxiliary signals, rather complex signals can be established. Closure property Closure properties of families of formal languages indicate their robustness under certain operations. A family of formal languages is closed under some operation, if any application of the operation on languages from the family yields again a language from the family. Turing machine A Turing machine is the simplest form of a universal computer. It captures the idea of an effective procedure or algorithm. At any time the machine is in any one of a finite number of states. It is equipped with an infinite tape divided into cells and a read-write head scanning a single cell. Each cell may contain a symbol from a finite set or alphabet. Initially, the finite input is written in successive cells. All other cells are empty. Dependent on a list of instructions, which serve as the program for the machine, the action is determined completely by the current state and the symbol currently scanned by the head. The action comprises the symbol to be written on the current cell, the new state of the machine, and the information of whether the head should move left or right. Decidability A formal problem with two alternatives is decidable, if there is an algorithm or a Turing machine that solves it and halts on all inputs. That is, given an encoding of some instance of the problem, the algorithm or Turing machine returns the correct answer yes or no. The problem is semidecidable, if the algorithm halts on all instances for which the answer is yes.

Specifying and Monitoring Temporal Properties in Web Services Compositions

Abstract: Current Web service composition approaches and languages such as WS-BPEL do not allow to define temporal constraints in a declarative and separate way. Also it is not possible to verify if there are contradictions between the temporal constraints implemented in the composition. These limitations lead to maintainability and correctness problems. In this paper, we tackle these problems through a novel approach to temporal constraints in Web service compositions, which combines formal methods and aspect-oriented programming. In this approach, we use a powerful and expressive formal language, called XTUS-Automata, for specifying time-related properties and we introduce specification patterns that ease the definition of such constraints. The formal specifications are translated automatically into AO4BPEL aspects, which ensure the runtime monitoring of the temporal constraints. Our approach enables a declarative, separate, and verifiable specification of temporal properties and it generates automatically modular enforcement code for those properties.

The Logic of Action

Abstract: In this article we provide a brief overview of the logic of action in philosophy, linguistics, computer science and artificial intelligence. The logic of action is the formal study of action in which formal languages are the main tool of analysis. The concept of action is of central interest to many disciplines: the social sciences including economics, the humanities including history and literature, psychology, linguistics, law, computer science, artificial intelligence, and probably others. In philosophy it has been studied since the beginning because of its importance for epistemology and, particularly, ethics; and since a few decades it is even studied for its own sake. But it is in the logic of action that action is studied in the most abstract way. The logic of action began in philosophy. But it has also played a certain role in linguistics. And currently it is of great importance in computer science and artificial intelligence. For our purposes it is natural to separate the accounts of these developments. 1 The logic of action in philosophy 1.1 Historical overview Already St Anselm studied the concept of action in a way that must be classified as logical; had he known symbolic logic, he would certainly have made use of it. (Cf. [33] and [101].) In modern times the subject was introduced by, among others, Alan Ross Anderson, Frederick B. Fitch, Stig Kanger, and Georg Henrik von Wright; Kanger’s work was further developed by his students Ingmar Porn and Lars Lindahl. The first clearly semantic account was given by Brian F. Chellas in [11]. (For a more detailed account, see [83] or the mini-history in [8].) Today there are two rather different groups of theories that may be described as falling under the term logic of action. One, the result of the creation of Nuel Belnap and his many collaborators, may be called stit theory (a term that will be explained in the next paragraph). The other is dynamic logic. Both are connected

Asynchronous sequential processes

Abstract: Deterministic behavior for parallel and distributed computation is rather difficult to ensure. To reach that goal, many formal calculi, languages, and techniques with well-defined semantics have been proposed in the past. But none of them focused on an imperative object calculus with asynchronous communications and futures. In this article, an object calculus, Asynchronous Sequential Processes (ASP), is defined, with its semantics. We prove also confluence properties for the ASP calculus. ASPs main characteristics are asynchronous communications with futures, and sequential execution within each process. This paper provides a very general and dynamic property ensuring confluence. Further, more specific and static properties are derived. Additionally, we present a formalization of distributed components based on ASP, and show how such components are used to statically ensure determinacy. This paper can also be seen as a formalization of the concept of futures in a distributed object setting.

Updatable Security Views

Abstract: Security views are a flexible and effective mechanism for controlling access to confidential information. Rather than allowing untrusted users to access source data directly, they are instead provided with are restricted view, from which all confidential information has been removed. The program that generates the view effectively embodies a confidentiality policy for the underlying source data. However, this approach has a significant drawback: it prevents users from updating the data in the view.To address the "view update problem" in general, a number of bidirectional languages have been proposed. Programs in these languages---often called lenses---can be run in two directions: read from left to right, they map sources to views; from right to left,they map updated views back to updated sources. However, existing bidirectional languages do not deal adequately with security. In particular, they do not provide a way to ensure the integrity of source data as it is manipulated by untrusted users of the view.We propose a novel framework of secure lenses that addresses these shortcomings. We enrich the types of basic lenses with equivalence relations capturing notions of confidentiality and integrity, and formulate the essential security conditions as non-interference properties. We then instantiate this framework in the domain of string transformations, developing syntax for bidirectional string combinators with security-annotated regular expressions as their types.

A stochastic context free grammar based framework for analysis of protein sequences.

Abstract: Background In the last decade, there have been many applications of formal language theory in bioinformatics such as RNA structure prediction and detection of patterns in DNA. However, in the field of proteomics, the size of the protein alphabet and the complexity of relationship between amino acids have mainly limited the application of formal language theory to the production of grammars whose expressive power is not higher than stochastic regular grammars. However, these grammars, like other state of the art methods, cannot cover any higher-order dependencies such as nested and crossing relationships that are common in proteins. In order to overcome some of these limitations, we propose a Stochastic Context Free Grammar based framework for the analysis of protein sequences where grammars are induced using a genetic algorithm.

Language Issues for Cognitive Radio

Abstract: This paper discusses various aspects of formal languages in the context of cognitive radio. A bottom up approach is taken in which an example of a specification of a feature of cognitive radio in a selected language is shown, followed by an example of a feature that cannot be expressed in the language and the identification of a capability that needs to be added to the language in order to cover the identified gap in the expressiveness. Following this pattern, we start with a language based on description logics and add the capability of expressing rules, then functions, and finally behavioral aspects. The running example used in this paper - conveying the description of a component to be synthesized by another radio - covers two major aspects of a cognitive radio: an ability to express own capabilities and an ability to interoperate with other cognitive radios.

Modelling of distance education forum: Formal languages as interpretation methodology of messages in asynchronous text-based discussion

Abstract: This article presents a study carried out in the area of distance learning electronic forums. Based on the relevant bibliographic review, electronic forums are increasingly becoming part of the learning process. The specific study was stimulated by previous works relevant to the modelling of the behaviour of IT students at Hellenic Open University (HOU) and addresses the issue of distance learning forum modelling using a formal language, aiming to fill the gap that exists in this area, which is demonstrated by the relevant bibliographic review. For this purpose: (a) a relevant note was submitted to HOU's forums, (b) the main concepts of formal languages were specified, (c) a formal language was created which was specified using mathematical terms and represents the messages of HOU's forum, (d) the correctness of such language was verified using specific examples of its function, (e) a language syntactic check algorithm was designed, (f) the parameters impacting on the effectiveness of a distance learning forum were determined, (g) concepts such as time, group size and volume of information were incorporated into the language and (h) efforts were made to identify the factors impacting on the effectiveness of a distance learning forum and the following concepts were incorporated: time, group size and volume of information, in the language.

A Formal Syntax of Natural Languages and the Deductive Grammar

Abstract: 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.

FAdo and GUItar

Abstract: FAdo is an ongoing project which aims to provide a set of tools for symbolic manipulation of formal languages. To allow high-level programming with complex data structures, easy prototyping of algorithms, and portability (to use in computer grid systems for example), are its main features. Our main motivation is the theoretical and experimental research, but we have also in mind the construction of a pedagogical tool for teaching automata theory and formal languages. For the graphical visualization and interactive manipulation a new interface application, GUItar, is being developed. In this paper, we describe the main components of the FAdo system as well as the basics of the graphical interface and editor, the export/import filters and its generic interface with external systems, such as FAdo .

Specification and planning of UAV missions: a Process Algebra approach

Abstract: Formal languages have recently come under attention as a powerful tool to describe in a precise and rigorous way mission specifications (i.e., mission objectives and constraints) for robotic systems, and to design planning and control algorithms that provably achieve the specifications. In this paper, we consider Process Algebras as a mission specification language for teams of UAVs. The main advantage of the proposed approach is that Process Algebra specifications are amenable to efficient planning algorithms. In particular, a tree-search algorithm is presented that computes a feasible plan in polynomial time. Branch-and-bound techniques are used to compute an optimal plan if computation time is available. Several mission specification examples are presented, and results from a numerical simulation are discussed.

Power of Randomization in Automata on Infinite Strings

Abstract: Probabilistic Buchi Automata (PBA) are randomized, finite state automata that process input strings of infinite length. Based on the threshold chosen for the acceptance probability, different classes of languages can be defined. In this paper, we present a number of results that clarify the power of such machines and properties of the languages they define. The broad themes we focus on are as follows. We precisely characterize the complexity of the emptiness, universality, and language containment problems for such machines, answering canonical questions central to the use of these models in formal verification. Next, we characterize the languages recognized by PBAs topologically, demonstrating that though general PBAs can recognize languages that are not regular, topologically the languages are as simple as *** -regular languages. Finally, we introduce Hierarchical PBAs, which are syntactically restricted forms of PBAs that are tractable and capture exactly the class of *** -regular languages.

On the Semantics of UML/MARTE Clock Constraints

Abstract: The UML goal of being a general-purpose modeling language discards the possibility to adopt too precise and strict a semantics. Users are to refine or define the semantics in their domain specific profiles. In the UML Profile for MARTE, we devised a broadly expressive Time Model to provide a generic timed interpretation for UML models. Our clock constraint specification language supports the specification of systems with multiple clock domains. Starting with a priori independent clocks, we progressively constrain them to get a family of possible executions. Our language supports both synchronous and asynchronous constraints, just like the synchronous language Signal, but also allows explicit non determinism. In this paper, we give a formal semantics to a core subset of MARTE clock constraint language and we give an equivalent interpretation of this kernel in two other very different formal languages, Signal and Time Petri nets.

Automated implementation of complex distributed algorithms specified in the IOA language

Abstract: IOA is a formal language for describing Input/Output automata that serves both as a formal specification language and as a programming language (Garland et al. in http://theory.lcs.mit.edu/tds/ioa/manual.ps, 2004). The IOA compiler automatically translates IOA specifications into Java code that runs on a set of workstations communicating via the Message Passing Interface. This paper describes the process of compiling IOA specifications and our experiences running several distributed algorithms, ranging from simple ones such as the Le Lann, Chang and Roberts (LCR) leader election in a ring algorithm to that of Gallager, Humblet and Spira (GHS) for minimum-weight spanning tree formation in an arbitrary graph (Humblet et al. in ACM Trans Program Lang Syst 5(1):66–77, 1983). Our IOA code for all the algorithms is derived from their Input/Output automaton descriptions that have already been formally proved correct. The successful implementation of these algorithms is significant for two reasons: (a) it is an indication of the capabilities of the IOA compiler and of its advanced state of development, and (b) to the best of our knowledge, these are the first complex, distributed algorithms implemented in an automated way that have been formally and rigorously proved correct. Thus, this work shows that it is possible to formally specify, prove correct, and implement complex distributed algorithms using a common formal methodology.