Showing papers on "Formal language published in 1995"

The Book of traces

Abstract: The theory of traces belongs to both formal language theory and the theory of concurrent systems. In both these disciplines it is a well-recognized and dynamic research area. Within formal language theory it yields the theory of partially commutative monoids, and provides an important connection between languages and graphs. Within the theory of concurrent systems it provides an important formal framework for the analysis and synthesis of concurrent systems. This monograph covers all important research lines of the theory of traces - each chapter of the book is devoted to one research line and is written by leading experts. It is organized in such a way that each chapter can be read independently - and hence is suitable for advanced courses/seminars on formal language theory and the theory of concurrent systems.

On the frame problem in procedure specifications

Abstract: The paper provides examples of situations where formal specifications of procedures in the standard pre/postcondition style become lengthy, cumbersome and difficult to change, a problem which is particularly acute in the case of object oriented specifications with inheritance. We identify the problem as the inability to express that a procedure changes only those things it has to, leaving everything else unmodified, and review some attempts at dealing with this "frame problem" in the software specification community. The second part of the paper adapts a recent proposal for a solution to the frame problem in artificial intelligence-the notion of explanation closure axioms-to provide an approach whereby one can state such conditions succinctly and modularly, with the added advantage of having the specifier be reminded of things that she may have omitted saying in procedure specifications. Since this approach is based on standard predicate logic, its semantics are relatively straightforward. The paper also suggests an algorithm which generates syntactically the explanation closure axioms from the pre/postcondition specifications, provided they are written in a restricted language; it also suggests a model theory supporting it. >

A formal semantics for object model diagrams

Abstract: Informal software development techniques, such as the object modeling technique (OMT), provide the user with easy to understand graphical notations for expressing a wide variety of concepts central to the presentation of software requirements. OMT combines three complementary diagramming notations for documenting requirements: object models, dynamic models, and functional models. OMT is a useful organizational tool in the requirements analysis and system design processes. Currently, the lack of formality in OMT prevents the evaluation of completeness, consistency, and content in requirements and design specifications. A formal method is a mathematical approach to software development that begins with the construction of a formal specification describing the system under development. However, constructing a formal specification directly from a prose description of requirements can be challenging. The paper presents a formal semantics for the OMT object model notations, where an object model provides the basis for the architecture of an object oriented system. A method for deriving modular algebraic specifications directly from object model diagrams is described. The formalization of object models contributes to a mathematical basis for deriving system designs. >

Formal Syntax and Semantics of Programming Languages: A Laboratory Based Approach

Abstract: From the Publisher: Formal Syntax and Semantics of Programming Languages: A Laboratory Based Approach presents a panorama of techniques in formal syntax, operational semantics and formal semantics. Using a teaching/learning perspective rather than a research-oriented approach, an understanding of the meta-languages is accessible to anyone with a basic grounding in discrete mathematics and programming language concepts. Throughout the book, valuable hands-on laboratory exercises provide the opportunity for practical application of difficult concepts. Various exercises and examples, implementing syntactic and semantic specifications on real systems, give students hands-on practice. Supplemental software is available on disk or via file transfer protocol. This book is suitable for an advanced undergraduate or introductory graduate level course on the formal syntax and semantics of programming languages.

Formal language, grammar and set-constraint-based program analysis by abstract interpretation

Abstract: Formal Language, Grammar and Set-Constraint-Based Program Analysis by Abstract Interpretation

Specification and verification of object-oriented programs using supertype abstraction

Abstract: We present a formal specification language and a formal verification logic for a simple object-oriented programming language. The language is applicative and statically typed, and supports subtyping and message-passing. The verification logic relies on a behavioral notion of subtyping that captures the intuition that a subtype behaves like its supertypes. We give a formal definition for legal subtype relations, based on the specified behavior of objects, and show that this definition is sufficient to ensure the soundness of the verification logic. The verification logic reflects the way programmers reason informally about object-oriented programs, in that it allows them to use static type information, which avoids the need to consider all possible run-time subtypes.

A syntactic theory of software architecture

Abstract: Introduces a general, extensible diagrammatic syntax for expressing software architectures based on typed nodes and connections and formalized using set theory. The syntax provides a notion of abstraction corresponding to the concept of a subsystem, and exploits this notion in a general mechanism for pattern matching over architectures. We demonstrate these ideas using a small example architecture language with a limited number of types of nodes and connectors, and a small taxonomy of architectures characterized as sets of patterns in the language. >

A Schema Theorem for context-free grammars

Abstract: The basic Schema Theorem for genetic algorithms is modified for a grammatically-based learning system. A context-free grammar is used to define a language in which each sentence is mapped to a fitness value. The derivation trees associated with these sentences are used to define the structure of schemata. The effect of crossover and mutation on schemata is described. A schema theorem is developed which describes how sentences of a language are propagated during evolution.

Formal specification languages in knowledge and software engineering

Abstract: During the last few years, a number of formal specification languages for knowledge-based systems (KBS) have been developed. Characteristics of such systems are a complex knowledge base and an inference engine which uses this knowledge to solve a given problem. Languages for KBS have to cover both these aspects. They have to provide a means to specify a complex and large amount of knowledge and they have to provide a means to specify the dynamic reasoning behaviour of a KBS. Nevertheless, KBS are just a specific type of software system. Therefore, it seems quite natural to compare formal languages for specifying KBS with formal languages which were developed by the software community for specifying software systems. That is the subject of this paper.

Global logic resulting from disequilibration process

Abstract: Describing a system in which internal detection or observation proceeds at a finite velocity is always destined to end up with a form of self-contradiction. For any formal language, for such a description, we must assume that the velocity of observation propagation or VOP be infinity. In the present paper, we propose a self-referential scheme intended for formally describing a system exhibiting the process of disequilibration propagating at a finite VOP, and find that a global logic can emerge from local disequilibration. Conservative cellular automata of Margolus type, for instance, enable disequilibration to be replaced by such a process that the number of particles is not conserved globally while appearing to be conserved by local observers. One cannot determine local rules universally. Nevertheless, global logic emerges as a result of the dynamics of a one-to-many type mapping. This is a fundamental aspect of natural languages or communication relevant to natural life and intelligence.

Growing context-sensitive languages and Church-Rosser languages

Abstract: The growing context-sensitive languages (GCSL) are characterized by a nondeterministic machine model, the so-called shrinking two-pushdown automaton (sTPDA). Then the deterministic version of this automaton (sDTPDA) is shown to characterize the class of generalized Church-Rosser languages (GCRL). Finally, we prove that each growing context-sensitive language is accepted in polynomial time by some one-way auxiliary pushdown automaton with a logarithmic space bound (OW-auxPDA[log, poly]). As a consequence the class of (generalized) Church-Rosser languages and the class of context-free languages are incomparable under set inclusion, which verifies a conjecture of Mc-Naughton et al [MNO88].

Linear and circular splicing systems

Abstract: Considers closure properties of classes of languages under the operation of iterated splicing. The main result is that full abstract families of languages are closed under splicing using a regular set of splicing rules. The author has the same result for families of circular strings, with two extra assumptions: the languages in the abstract family must be closed under cyclic permutations and the splicing scheme must be reflective. In both cases the hypotheses are satisfied by the families of regular languages and of context-free languages. >

Using units of measurement in formal specifications

Abstract: In the physical sciences and engineering, units of measurement provide a valuable aid to both the exposition and comprehension of physical systems. In addition, they provide an error checking facility comparable to static type checking commonly found with programming languages. It is argued that units of measurement can provide similar benefits in the specification and design of software and computer systems. To demonstrate this, we present an extension of the Z specification notation with support for the incorporation of units in specifications and demonstrate the feasibility of static dimensional analysis of the resulting language.

Formal semantics of visual languages using spatial reasoning

Abstract: This paper describes a new approach to develop formal semantics of visual languages. The proposed framework relies on a spatial logic for describing qualitative spatial relationships between elements of visual languages and on description logic theory. Visual languages that are ideally suited for this approach should be based on geometrical objects such as points, (directed) lines, and convex regions. A prominent feature of our approach is the capability for automatic verification of semantics specifications. The specifications defining our example language, Pictorial Janus, are fully developed and were automatically verified using a representative set of example programs.

Automata That Take Advice

Abstract: Karp and Lipton introduced advice-taking Turing machines to capture nonuniform complexity classes. We study this concept for automata-like models and compare it to other nonuniform models studied in connection with formal languages in the literature. Based on this we obtain complete separations of the classes of the Chomsky hierarchy relative to advices.

Automata and Formal Languages : An Introduction

Abstract: 0. Mathematical Preliminaries. 1. Alphabets and Languages. 2. Regular Languages. 3. Context Free Languages. 4. Turing Machines. 5. Turing Machines and Languages. 6. Decidability. 7. An Introduction to Computational Complexity. Bibliography.

Designing a Framework by Stepwise Generalization

Abstract: Frameworks are class collections that capture the common aspects of applications in a certain problem domain. It is argued that conventional object-oriented design methods do not suit well to frameworks. As an alternative, we suggest a two-phase design method. The first phase is a stepwise generalization of a problem to its most general form. The second phase proceeds in the opposite direction, giving an implementation for every generalization level. The implementation of a certain level can be regarded as a framework for implementing the next more specific level. The main advantage of our method is that it enhances the generality (and therefore reusability) of the framework architecture, and explains the design decisions in the simplest possible context. As a case study, we describe a framework supporting the analysis of formal languages.

Decidability and closure properties of weak Petri net languages in supervisory control

Abstract: We extend the class of control problems that can be modeled by Petri nets considering the notion of weak terminal behavior. Deterministic weak languages represent closed-loop terminal behaviors that may be enforced by nonblocking Petri net supervisors if controllable. The class of deterministic weak PN languages is not closed under the supremal controllable sublanguage operator. >

Features aka the semantics of a formal language of manufacturing

Abstract: Features are application and viewer-dependent interpretations of geometry. This article demonstrates how the notion of features arising out of geometric data may be formalised as the semantics of a language of shape, using machining operations as an extended example. The syntax and semantics of formal languages are discussed, with particular reference to their use in design. A simplified lathe is defined, and a parametric attributed set grammar is presented which specifies the range of shapes manufacturable on that lathe. A simple feature space is then defined, in which feature models representing those shapes may be constructed. The link between the shapes and the feature models is then formalised as the semantics of the grammar using description functions, and it is shown how the feature models develop as shape generation proceeds. Finally, some implications of this work for feature-based design and manufacturing are discussed.

Encoding Lexicalized Tree Adjoining Grammars with a Nonmonotonic Inheritance Hierarchy

Abstract: This paper shows how DATR, a widely used formal language for lexical knowledge representation, can be used to define an LTAG lexicon as an inheritance hierarchy with internal lexical rules. A bottom-up featural encoding is used for LTAG trees and this allows lexical rules to be implemented as covariation constraints within feature structures. Such an approach eliminates the considerable redundancy otherwise associated with an LTAG lexicon.

A New Approach to Formal Language Theory by Kolmogorov Complexity

Abstract: We present a new approach to formal language theory using Kolmogorov complexity. The main results presented here are an alternative for pumping lemma(s), a new characterization for regular languages, and a new method to separate deterministic context-free languages and nondeterministic context-free languages. The use of the new "incompressibility arguments" is illustrated by many examples. The approach is also successful at the high end of the Chomsky hierarchy since one can quantify nonrecursiveness in terms of Kolmogorov complexity.

A requirements capture method and its use in an air traffic control application

Abstract: This paper describes our experience in capturing, using a formal specification language, a model of the knowledge-intensive domain of oceanic air traffic control. This model is intended to form part of the requirements specification for a decision support system for air traffic controllers. We give an overview of the methods we used in analysing the scope of the domain, choosing an appropriate formalism, developing a domain model, and validating the model in various ways. Central to the method was the development of a formal requirements engineering environment which provided automated tools for model validation and maintenance.

A Review of Object-Oriented Approaches in Formal Methods

Abstract: This paper presents a survey of recent approaches in the application of the object-oriented paradigm to formal specification. The complexity of current information systems demands the use of a higher degree of formalism in the development process. Formal languages such as Z, VDM and Lotos have been used extensively in academic environments and research projects ; however, their utilization in the 'real world' is still relatively small. The use of object-oriented concepts has now been suggested as a good solution to the lack of expressiveness that characterizes most of these languages. Several approaches addressing this issue have appeared in the literature recently, including extensions to most existing languages. In this paper we review some of these techniques and discuss problems and issues relevant to the combination of formal methods and object orientation.

DNA evolutionary linguistics and RNA structure modeling: a computational approach

Abstract: The authors are concerned with analysing formal linguistic properties of DNA sequences in which a number of the language theoretic analysis on DNA sequences are established by means of computational methods. First, employing a formal language theoretic framework, the authors consider a kind of evolutionary problem of DNA sequences, asking (1) how DNA sequences were initially created and then evolved (grew up) to be a language of certain complexity, and (2) what primitive constructs were minimally required for the process of evolution. In terms of formal linguistic concepts, the authors present several results that provide their views on these questions at a conceptual level. Based on the formal analysis on these biological questions, the authors then choose a certain type of tree generating grammars called tree adjunct grammars (TAG) to attach the problem of modeling the secondary structure of RNA sequences. By proposing an extended model of TAGs, the authors demonstrate the usefulness of the grammars for modeling some typical RNA secondary structures including "pseudoknots", which suggests that TAG families as RNA grammars have a great potential for RNA secondary structure prediction. >