scispace - formally typeset
Search or ask a question

Showing papers on "Formal language published in 2008"


Proceedings Article
09 Jul 2008
TL;DR: Church as mentioned in this paper is a universal language for describing stochastic generative processes, which is based on the Lisp model of lambda calculus, containing a pure Lisp as its deterministic subset.
Abstract: Formal languages for probabilistic modeling enable re-use, modularity, and descriptive clarity, and can foster generic inference techniques. We introduce Church, a universal language for describing stochastic generative processes. Church is based on the Lisp model of lambda calculus, containing a pure Lisp as its deterministic subset. The semantics of Church is defined in terms of evaluation histories and conditional distributions on such histories. Church also includes a novel language construct, the stochastic memoizer, which enables simple description of many complex non-parametric models. We illustrate language features through several examples, including: a generalized Bayes net in which parameters cluster over trials, infinite PCFGs, planning by inference, and various non-parametric clustering models. Finally, we show how to implement query on any Church program, exactly and approximately, using Monte Carlo techniques.

509 citations


Book
08 Sep 2008
TL;DR: Many topics often absent from other textbooks, such as repetitions in words, state complexity, the interchange lemma, 2DPDAs, and the incompressibility method are covered here.
Abstract: Intended for graduate students and advanced undergraduates in computer science, A Second Course in Formal Languages and Automata Theory treats topics in the theory of computation not usually covered in a first course. After a review of basic concepts, the book covers combinatorics on words, regular languages, context-free languages, parsing and recognition, Turing machines, and other language classes. Many topics often absent from other textbooks, such as repetitions in words, state complexity, the interchange lemma, 2DPDAs, and the incompressibility method, are covered here. The author places particular emphasis on the resources needed to represent certain languages. The book also includes a diverse collection of more than 200 exercises, suggestions for term projects, and research problems that remain open.

218 citations


Journal ArticleDOI
TL;DR: In this article, the authors argue that constructing a theory of physics is equivalent to finding a representation in a topos of a certain formal language that is attached to the system, and that quantum physics arises when the topos is the category of sets.
Abstract: This paper is the first in a series whose goal is to develop a fundamentally new way of constructing theories of physics. The motivation comes from a desire to address certain deep issues that arise when contemplating quantum theories of space and time. Our basic contention is that constructing a theory of physics is equivalent to finding a representation in a topos of a certain formal language that is attached to the system. Classical physics arises when the topos is the category of sets. Other types of theory employ a different topos. In this paper, we discuss two different types of language that can be attached to a system S. The first is a propositional language PL(S); the second is a higher-order, typed language L(S). Both languages provide deductive systems with an intuitionistic logic. The reason for introducing PL(S) is that, as shown in Paper II of the series, it is the easiest way of understanding, and expanding on, the earlier work on topos theory and quantum physics. However, the main thrust o...

149 citations


Book
01 Jan 2008
TL;DR: This article proposes a goal formalisation method in five steps, in which the domain expert is involved in such a way that the correctness of the result can be assured, and guarantees essential properties like correctness, traceability, reduced variability and reusability.
Abstract: The main problem encountered when starting verification of goals for some formal system, is the ambiguity of those goals when they are specified in natural language. To verify goals given in natural language, a translation of those goals to the formalism of the verification tool is required. The main concern is to assure equivalence of the final translation and the original. A structured method is required to assure equivalence in every case. This article proposes a goal formalisation method in five steps, in which the domain expert is involved in such a way that the correctness of the result can be assured. The contribution of this article is a conceptual goal model, a formal expression language for this model, and a structured method which transforms any input goal to a fully formalised goal in the required target formalism. The proposed formalisation method guarantees essential properties like correctness, traceability, reduced variability and reusability.

123 citations


Proceedings ArticleDOI
07 Jan 2008
TL;DR: This work presents a family of formal languages that model a wide variety of behaviors for software transactions, and proves some key language-equivalence theorems to confirm that under sufficient static restrictions, no program can determine whether the language implementation uses weak isolation or strong isolation.
Abstract: Software transactions have received significant attention as a way to simplify shared-memory concurrent programming, but insufficient focus has been given to the precise meaning of software transactions or their interaction with other language features. This work begins to rectify that situation by presenting a family of formal languages that model a wide variety of behaviors for software transactions. These languages abstract away implementation details of transactional memory, providing high-level definitions suitable for programming languages. We use small-step semantics in order to represent explicitly the interleaved execution of threads that is necessary to investigate pertinent issues.We demonstrate the value of our core approach to modeling transactions by investigating two issues in depth. First, we consider parallel nesting, in which parallelism and transactions can nest arbitrarily. Second, we present multiple models for weak isolation, in which nontransactional code can violate the isolation of a transaction. For both, type-and-effect systems let us soundly and statically restrict what computation can occur inside or outside a transaction. We prove some key language-equivalence theorems to confirm that under sufficient static restrictions, in particular that each mutable memory location is used outside transactions or inside transactions (but not both), no program can determine whether the language implementation uses weak isolation or strong isolation.

123 citations


Book
11 Sep 2008
TL;DR: This book constitutes the refereed proceedings of the 19th International Conference on Concurrency Theory, CONCUR 2008, held in Toronto, Canada, August 19-22, 2008 and contains 33 revised full papers presented together with 2 tool papers.
Abstract: This book constitutes the refereed proceedings of the 19th International Conference on Concurrency Theory, CONCUR 2008, held in Toronto, Canada, August 19-22, 2008. The 33 revised full papers presented together with 2 tool papers were carefully reviewed and selected from 120 submissions. The topics include model checking, process calculi, minimization and equivalence checking, types, semantics, probability, bisimulation and simulation, real time, and formal languages.

121 citations


Journal ArticleDOI
TL;DR: In this paper, the congruence associated to the direct sum of all irreducible representations of a finite semigroup over an arbitrary field is characterized, and applications are given to obtain many new results, as well as easier proofs of several results in the literature.
Abstract: In this paper we characterize the congruence associated to the direct sum of all irreducible representations of a finite semigroup over an arbitrary field, generalizing results of Rhodes for the field of complex numbers. Applications are given to obtain many new results, as well as easier proofs of several results in the literature, involving: triangularizability of finite semigroups; which semigroups have (split) basic semigroup algebras, two-sided semidirect product decompositions of finite monoids; unambiguous products of rational languages; products of rational languages with counter; and Cerny's conjecture for an important class of automata.

103 citations


Journal ArticleDOI
TL;DR: The paper presents ConSpec, an automata-based policy specification language that trades off clean semantics to language expressiveness; a formal semantics for the language is provided as security automata.

97 citations


Journal ArticleDOI
TL;DR: VDMTools as mentioned in this paper is a group of tools supporting the analysis of system models expressed in the formal language of the Vienna Development Method (VDMTM) for modeling and analysis of distributed embedded real-time systems.
Abstract: We describe the current status of "VDMTools", a group of tools supporting the analysis of system models expressed in the formal language of the Vienna Development Method. Three dialects of the language are supported: the ISO standard VDM specification language with support for modular structuring, the extension VDM++ which supports object-oriented structuring and concurrency, and a version extending VDM++ with features for modeling and analysing distributed embedded real-time systems. VDMTools provides extensive static semantics checking, automatic code generation, roundtrip mapping to UML class diagrams, documentation support, test coverage analysis and debugging support. The tools' focus is on supporting the cost-effective development and exploitation of formal models in industrial settings. The paper presents the components of VDMTools and reports recent experience using them for the development of large models.

94 citations


Journal ArticleDOI
TL;DR: The paper presents ConSpec, an automata based policy specification language that trades off clean semantics to language expressiveness; a formal semantics for the language is provided as security automata.

93 citations


01 Jan 2008
TL;DR: These lecture notes present some basic notions and results on Automata Theory, Formal Languages Theory, Computability Theory, and Parsing Theory as well as on parsing techniques for context-free languages.
Abstract: These lecture notes present some basic notions and results on Automata Theory, Formal Languages Theory, Computability Theory, and Parsing Theory. I prepared these notes for a course on Automata, Languages, and Translators which I am teaching at the University of Roma Tor Vergata. More material on these topics and on parsing techniques for context-free languages can be found in standard textbooks such as [1, 8, 9]. The reader is encouraged to look at those books. A theorem denoted by the triple k.m.n is in Chapter k and Section m, and within that section it is identified by the number n. Analogous numbering system is used for algorithms, corollaries, definitions, examples, exercises, figures, and remarks. We use ‘iff’ to mean ‘if and only if’. Many thanks to my colleagues of the Department of Informatics, Systems, and Production of the University of Roma Tor Vergata. I am also grateful to my stu- dents and co-workers and, in particular, to Lorenzo Clemente, Corrado Di Pietro, Fulvio Forni, Fabio Lecca, Maurizio Proietti, and Valerio Senni for their help and encouragement. Finally, I am grateful to Francesca Di Benedetto, Alessandro Colombo, Donato Corvaglia, Gioacchino Onorati, and Leonardo Rinaldi of the Aracne Publishing Com- pany for their kind cooperation.

DissertationDOI
13 Mar 2008
TL;DR: The main contribution of this thesis is the graphical language VisuaL with its formal underpinning Deterministic Abstract Recognizers (DARs), which defines a new family of formal languages called Open Regular Languages (ORLs) and is the context-sensitive wildcard, which makes Visua L specifications more evolvable (i.e. less susceptible to changes), and more concise.
Abstract: The development and maintenance of today's software systems is an increasingly effort-consuming and error-prone task. A major cause of the effort and errors is the lack of human-readable and formal documentation of software design. In practice, software design is often informally documented, or not documented at all. There fore, (a) the design cannot be properly communicated between software engineers, (b) it cannot be automatically analyzed for finding and removing faults, (c) the conformance of an implementation to the design cannot be automatically verified, and (d) source code maintenance tasks have to be manually performed, although some of these tasks can be automated using formal documentation. In this thesis, we address these problems for the design and documentation of the behavior implemented in procedural programs. We present the following solutions each addressing the respective problem stated above: (a) A graphical language called VisuaL, which enables engineers to specify constraints on the possible sequences of function calls from a given procedural program, (b) an algorithm called Check-Design, which automatically verifies the consistency between multiple specifications written in VisuaL, (c) an algorithm called CheckSource, which automatically verifies the consistency between a given implementation and a corresponding specification written in VisuaL, and (d) an algorithm called TransformSource, which uses VisuaL specifications for automatically inserting additional source code at well-defined locations in existing source code. Empirical evidence indicates that CheckSource is beneficial during some of the typical control-flow maintenance tasks: 60% effort reduction, and prevention of one error per 250 lines of source code. These results are statistically significant at the level 0,05. Moreover, the combination of CheckSource and TransformSource is beneficial during some of the typical control-flow maintenance tasks: 75% effort reduction, and prevention of one error per 140 lines of source code. These results are statistically significant at the level 0,01. The main contribution of this thesis is the graphical language VisuaL with its formal underpinning Deterministic Abstract Recognizers (DARs), which defines a new family of formal languages called Open Regular Languages (ORLs). The key feature of VisuaL is the context-sensitive wildcard, which makes VisuaL specifications more evolvable (i.e. less susceptible to changes), and more concise.

Posted Content
Tobias Kuhn1
TL;DR: AceWiki as mentioned in this paper is a prototype of a new kind of semantic wiki using the controlled natural language Attempto Controlled English (ACE) for representing its content, which is a subset of English with a restricted grammar and a formal semantics.
Abstract: We present AceWiki, a prototype of a new kind of semantic wiki using the controlled natural language Attempto Controlled English (ACE) for representing its content. ACE is a subset of English with a restricted grammar and a formal semantics. The use of ACE has two important advantages over existing semantic wikis. First, we can improve the usability and achieve a shallow learning curve. Second, ACE is more expressive than the formal languages of existing semantic wikis. Our evaluation shows that people who are not familiar with the formal foundations of the Semantic Web are able to deal with AceWiki after a very short learning phase and without the help of an expert.

Journal ArticleDOI
TL;DR: A general method is presented for comparative semantics of FDs grounded in Harel and Rumpe's guidelines for defining formal visual languages and in Krogstie et al.'s semiotic quality framework.
Abstract: Feature diagrams (FDs) are a family of popular modelling languages, mainly used for managing variability in software product lines. FDs were first introduced by Kang et al. as part of the feature-oriented domain analysis (FODA) method back in 1990. Since then, various extensions of FODA FDs were devised to compensate for purported ambiguity and lack of precision and expressiveness. Recently, the authors surveyed these notations and provided them with a generic formal syntax and semantics, called free feature diagrams (FFDs). The authors also started investigating the comparative semantics of FFD with respect to other recent formalisations of FD languages. Those results were targeted at improving the quality of FD languages and making the comparison between them more objective. The previous results are recalled in a self-contained, better illustrated and better motivated fashion. Most importantly, a general method is presented for comparative semantics of FDs grounded in Harel and Rumpe's guidelines for defining formal visual languages and in Krogstie et al.'s semiotic quality framework. This method being actually applicable to other visual languages, FDs are also used as a language (re)engineering exemplar throughout the paper.

Proceedings ArticleDOI
15 Sep 2008
TL;DR: 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 are shown.
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.

Journal ArticleDOI
TL;DR: The survey at hand picks out important studies on learning indexed families of recursive languages (including basic as well as recent research), summarizes and illustrates the corresponding results, and points out links to related fields such as grammatical inference, machine learning, and artificial intelligence in general.

Journal Article
TL;DR: The results clearly show that the state complexity of a combined operation can be very different from the composition of the state complexities of its participating individual operations.
Abstract: The state complexity of two combined operations, star of catenation and star of reversal, on regular languages is considered in this paper. Tight bounds are obtained for both combined operations. The results clearly show that the state complexity of a combined operation can be very different from the composition of the state complexities of its participating individual operations. A new approach for research in automata and formal language theory is also explained.

Book ChapterDOI
01 Jun 2008
TL;DR: The aim of the paper is to motivate the technical development and illustrate the use of the formal language by means of a simple example in which there there are both physical and normative constraints on agents' behaviours.
Abstract: There is growing interest in the idea that, in some cases, interactions among multiple, independently acting agents in a multi-agent system can be regulated and managed by norms (or `social laws') which, if respected, allow the agents to co-exist in a shared environment. We present a formal (modal-logical) language for describing and analysing such systems. We distinguish between system norms, which express a system designer's view of what system behaviours are deemed to be legal, permitted, desirable, and so on, and agent-specific norms which constrain and guide an individual agent's behaviours and which are supposed to be incorporated, in one way or another, in the agent's implementation. The language provides constructs for expressing properties of states and transitions in a transition system, and modalities of the kind found in logics of action/agency for expressing that an agent brings it about that, or is responsible for, its being the case that A. The novel feature is that an agent, or group of agents, brings it about that a transition has a certain property rather than bringing it about that a certain state of affairs obtains, as is usually the case. The aim of the paper is to motivate the technical development and illustrate the use of the formal language by means of a simple example in which there there are both physical and normative constraints on agents' behaviours. We discuss some relationships between system norms and agent-specific norms, and identify several different categories of non-compliant behaviour that can be expressed and analysed using the formal language. The final part of the paper presents some transcripts of output from a model-checker for the language.

Book ChapterDOI
22 Nov 2008
TL;DR: A language for expressing proofs that is expressive enough to specify all constructs occurring in cryptographic games, including probabilistic behaviors, the usage of oracles, and polynomial-time programs is proposed.
Abstract: Game-based cryptographic proofs are typically expressed using pseudocode, which lacks a formal semantics. This can lead to ambiguous specifications, hidden mistakes, and even wrong proofs. We propose a language for expressing proofs that is expressive enough to specify all constructs occurring in cryptographic games, including probabilistic behaviors, the usage of oracles, and polynomial-time programs. The language is a probabilistic higher-order lambda calculus with recursive types, references, and support for events, and is simple enough that researchers without a strong background in the theory of programming languages can understand it. The language has been implemented in the proof assistant Isabelle/HOL.

Journal ArticleDOI
TL;DR: In this paper models and techniques are described which allow us to incorporate informal design artefacts into a formal software development process.
Abstract: There are many different ways of building software applications and of tackling the problems of understanding the system to be built, designing that system and finally implementing the design. One approach is to use formal methods, which we can generalise as meaning we follow a process which uses some formal language to specify the behaviour of the intended system, techniques such as theorem proving or model-checking to ensure the specification is valid (i.e., meets the requirements and has been shown, perhaps by proof or other means of inspection, to have the properties the client requires of it) and a refinement process to transform the specification into an implementation. Conversely, the approach we take may be less structured and rely on informal techniques. The design stage may involve jotting down ideas on paper, brainstorming with users etc. We may use prototyping to transform these ideas into working software and get users to test the implementation to find problems. Formal methods have been shown to be beneficial in describing the functionality of systems, what we may call application logic, and underlying system behaviour. Informal techniques, however, have also been shown to be useful in the design of the user interface to systems. Given that both styles of development are beneficial to different parts of the system we would like to be able to use both approaches in one integrated software development process. Their differences, however, make this a challenging objective. In this paper we describe models and techniques which allow us to incorporate informal design artefacts into a formal software development process.

Proceedings ArticleDOI
24 Jun 2008
TL;DR: A tree extension of the Simon theorem says that a string language can be defined by a boolean combination of Sigma1 formulas if and only if its syntactic monoid is J-trivial.
Abstract: This paper presents a decidable characterization of tree languages that can be defined by a boolean combination of Sigma1 formulas. This is a tree extension of the Simon theorem, which says that a string language can be defined by a boolean combination of Sigma1 formulas if and only if its syntactic monoid is J-trivial.

Book ChapterDOI
15 Jun 2008
TL;DR: A complete self-contained elementary construction of an aperiodic tile set is given and how to use this tile set to elementary prove the undecidability of the classical Domino Problem is sketched.
Abstract: Thanks to a careful study of elementary properties of two-by-two substitution systems, we give a complete self-contained elementary construction of an aperiodic tile set and sketch how to use this tile set to elementary prove the undecidability of the classical Domino Problem

Journal ArticleDOI
TL;DR: This work develops an account where mass nouns are treated as non-singular terms, faithful to the intuition that, if there are eight pieces of silverware on a table, the speaker refers to eight things at once when he says: the silverware that is on the table comes from Italy.
Abstract: A dilemma put forward by Schein (1993, Plurals and events. Cambridge MIT Press) and Rayo (2002, Nous, 36, 436–464) suggests that, in order to characterize the semantics of plurals, we should not use predicate logic, but plural logic, a formal language whose terms may refer to several things at once. We show that a similar dilemma applies to mass nouns. If we use predicate logic and sets when characterizing their semantics, we arrive at a Russellian paradox. And if we use predicate logic and mereological sums, the semantics turns out to be too weak. We then develop an account where mass nouns are treated as non-singular terms. This semantics is faithful to the intuition that, if there are eight pieces of silverware on a table, the speaker refers to eight things at once when he says: The silverware that is on the table comes from Italy. We show that this account provides a satisfactory semantics for a wide range of sentences.

Journal ArticleDOI
TL;DR: This paper chronologizes some results that developed from the investigations on the inferability of the pattern languages from positive data.

Book ChapterDOI
22 Sep 2008
TL;DR: This paper introduces a hierarchy of substitutable context-free languages as the analogue of that of k-reversible regular languages and shows that each class in the hierarchy is also polynomial-time identifiable in the limit from positive data.
Abstract: Recently Clark and Eyraud (2005, 2007) have shown that substitutable context-free languages are polynomial-time identifiable in the limit from positive data. Substitutability in context-free languages can be thought of as the analogue of reversibility in regular languages. While reversible languages admit a hierarchy, namely k-reversible regular languages for each nonnegative integer k, Clark and Eyraud targeted the subclass of context-free languages that corresponds to zero-reversible regular languages only. Following Clark and Eyraud's proposal, this paper introduces a hierarchy of substitutable context-free languages as the analogue of that of k-reversible regular languages and shows that each class in the hierarchy is also polynomial-time identifiable in the limit from positive data.

Proceedings ArticleDOI
03 Dec 2008
TL;DR: A new language is proposed, built upon synchronous data-flow languages, to handle multi-rate systems properly and has strong formal semantics, which prevents non-deterministic communications, and relies on real-time primitives that enable efficient use of existing multi-periodic schedulers.
Abstract: Implementing real-time critical systems is an increasingly complex process that calls for high-level formal programming languages. Existing languages mainly focus on mono-periodic systems, implementing multi-periodic systems with these languages is possible but inefficient. As a result, current practice usually consists in writing one program for each different rate and then letting a real-time operating system handle the multi-rate aspects. This can be a source of non-determinism as communications between processes of different rates are not precisely defined. We propose a new language, built upon synchronous data-flow languages, to handle multi-rate systems properly. It has strong formal semantics, which prevents non-deterministic communications, and relies on real-time primitives that enable efficient use of existing multi-periodic schedulers.

Proceedings ArticleDOI
15 Jul 2008
TL;DR: This paper proposes a formalisation of policy composition by means of term rewriting, and shows how, in this setting, it is able to express a wide range of policy combinations and reason about them.
Abstract: In large, and often distributed, environments, where access control information may be shared across multiple sites, the combination of individual specifications in order to define a coherent access control policy is of fundamental importance. In order to ensure non-ambiguous behaviour, formal languages, often relying on firstorder logic, have been developed for the description of access control policies. We propose in this paper a formalisation of policy composition by means of term rewriting. We show how, in this setting, we are able to express a wide range of policy combinations and reason about them. Modularity properties of rewrite systems can be used to derive the correctness of the global policy, i.e. that every access request has an answer and this answer is unique


Journal ArticleDOI
TL;DR: In this paper, a representation of regular and context-free languages with insertion systems of weight (2,0) and star languages, respectively, has been presented, in the form L = h(L(γ) ∩ D), where γ is an insertion system of weight(3, 0) (at most three symbols are inserted in a context of length zero), h is a projection, and D is a Dyck language.
Abstract: Insertion-deletion operations are much investigated in linguistics and in DNA computing and several characterizations of Turing computability and characterizations or representations of languages in Chomsky hierarchy were obtained in this framework. In this note we contribute to this research direction with a new characterization of this type, as well as with representations of regular and context-free languages, mainly starting from context-free insertion systems of as small as possible complexity. For instance, each recursively enumerable language L can be represented in a way similar to the celebrated Chomsky-Schutzenberger representation of context-free languages, i.e., in the form L = h(L(γ) ∩ D), where γ is an insertion system of weight (3, 0) (at most three symbols are inserted in a context of length zero), h is a projection, and D is a Dyck language. A similar representation can be obtained for regular languages, involving insertion systems of weight (2,0) and star languages, as well as for context-free languages – this time using insertion systems of weight (3, 0) and star languages.

Book
26 Sep 2008
TL;DR: The present text is a re-edition of Volume I of Formal Grammars in Linguistics and Psycholinguistics, a three-volume work published in 1974 as discussed by the authors.
Abstract: The present text is a re-edition of Volume I of Formal Grammars in Linguistics and Psycholinguistics , a three-volume work published in 1974. This volume is an entirely self-contained introduction to the theory of formal grammars and automata, which hasn’t lost any of its relevance. Of course, major new developments have seen the light since this introduction was first published, but it still provides the indispensible basic notions from which later work proceeded. The author’s reasons for writing this text are still relevant: an introduction that does not suppose an acquaintance with sophisticated mathematical theories and methods, that is intended specifically for linguists and psycholinguists (thus including such topics as learnability and probabilistic grammars), and that provides students of language with a reference text for the basic notions in the theory of formal grammars and automata, as they keep being referred to in linguistic and psycholinguistic publications; the subject index of this introduction can be used to find definitions of a wide range of technical terms. An appendix has been added with further references to some of the core new developments since this book originally appeared.