Showing papers on "Formal language published in 1990"

A specifier's introduction to formal methods

Abstract: Formal methods used in developing computer systems (i.e. mathematically based techniques for describing system properties) are defined, and their role is delineated. Formal specification languages, which provide the formal method's mathematical basis, are examined. Certain pragmatic concerns about formal methods and their users, uses, and characteristics are discussed. Six well-known or commonly used formal methods are illustrated by simple examples. They are Z, VDM, Larch, temporal logic, CSP, and transition axioms. >

Introduction to Formal Languages and Automata

Abstract: Formal languages, automata, computability, and related matters form the major part of the theory of computation. This textbook is designed for an introductory course for computer science and computer engineering majors who have knowledge of some higher-level programming language, the fundamentals of

Constraint logic programming languages

Abstract: Constraint Logic Programming (CLP) is an extension of Logic Programming aimed at replacing the pattern matching mechanism of unification, as used in Prolog, by a more general operation called constraint satisfaction. This aritcle provides a panoramic view of the recent work done in designing and implementing CLP languages. It also presents a summary of their theoretical foundations, discusses implementation issues, compares the major CLP languages, and suggests directions for further work.

Inference of k-testable languages in the strict sense and application to syntactic pattern recognition

Abstract: The inductive inference of the class of k-testable languages in the strict sense (k-TSSL) is considered. A k-TSSL is essentially defined by a finite set of substrings of length k that are permitted to appear in the strings of the language. Given a positive sample R of strings of an unknown language, a deterministic finite-state automation that recognizes the smallest k-TSSL containing R is obtained. The inferred automation is shown to have a number of transitions bounded by O(m) where m is the number of substrings defining this k-TSSL, and the inference algorithm works in O(kn log m) where n is the sum of the lengths of all the strings in R. The proposed methods are illustrated through syntactic pattern recognition experiments in which a number of strings generated by ten given (source) non-k-TSSL grammars are used to infer ten k-TSSL stochastic automata, which are further used to classify new strings generated by the same source grammars. The results of these experiments are consistent with the theory and show the ability of (stochastic) k-TSSLs to approach other classes of regular languages. >

A meta-environment for generating programming environments

Abstract: Over the last decade, considerable progress has been made in solving the problems of automatic generation of programming/development environments, given a formal definition of some programming or specification language. In most cases, research has focused on the functionality and efficiency of the generated environments, and, of course, these aspects will ultimately determine the acceptance of environment generators. However, only marginal attention has been paid to the development process of formal language definitions itself. Assuming that the quality of automatically generated environments will be satisfactory within a few years, the development costs of formal language definitions will then become the next limiting factor determining ultimate success and acceptance of environment generators.In this paper we describe the design and implementation of a meta-environment (a development environment for formal language definitions) based on the formalism ASF + SDF. This meta-environment is currently being implemented as part of the Centaur system and is, at least partly, obtained by applying environment generation techniques to the language definition formalism itself. A central problem is providing fully interactive editing of modular language definitions such that modifications made to the language definition during editing can be translated immediately to modifications in the programming environment generated from the original language definition. Therefore, some of the issues addressed are the treatment of formalisms with user-definable syntax and incremental program generation techniques.

Specification and Transformation of Programs: A Formal Approach to Software Development

Abstract: 1. Introduction.- 1.1 Software Engineering.- 1.2 The Problematics of Software Development.- 1.3 Formal Specification and Program Transformation.- 1.4 Our Particular View of Transformational Programming.- 1.5 Relation to Other Approaches to Programming Methodology.- 1.6 An Introductory Example.- 2. Requirements Engineering.- 2.1 Introduction.- 2.1.1 Basic Notions.- 2.1.2 Essential Criteria for Good Requirements Definitions.- 2.1.3 The Particular Role of Formality.- 2.2 Some Formalisms Used in Requirements Engineering.- 2.2.1 A Common Basis for Comparison.- 2.2.2 Flowcharts.- 2.2.3 Decision Tables.- 2.2.4 Formal Languages and Grammars.- 2.2.5 Finite State Mechanisms.- 2.2.6 Petri Nets.- 2.2.7 SA/SADT.- 2.2.8 PSL/PSA.- 2.2.9 RSL/REVS.- 2.2.10 EPOS.- 2.2.11 Gist.- 2.2.12 Summary.- 3. Formal Problem Specification.- 3.1 Specification and Formal Specification.- 3.2 The Process of Formalization.- 3.2.1 Problem Identification.- 3.2.2 Problem Description.- 3.2.3 Analysis of the Problem Description.- 3.3 Definition of Object Classes and Their Basic Operations.- 3.3.1 Algebraic Types.- 3.3.2 Further Examples of Basic Algebraic Types.- 3.3.3 Extensions of Basic Types.- 3.3.4 Formulation of Concepts as Algebraic Types.- 3.3.5 Modes.- 3.4 Additional Language Constructs for Formal Specifications.- 3.4.1 Applicative Language Constructs.- 3.4.2 Quantified Expressions.- 3.4.3 Choice and Description.- 3.4.4 Set Comprehension.- 3.4.5 Computation Structures.- 3.5 Structuring and Modularization.- 3.6 Examples.- 3.6.1 Recognizing Palindromes.- 3.6.2 A Simple Number Problem.- 3.6.3 A Simple Bank Account System.- 3.6.4 Hamming's Problem.- 3.6.5 Longest Ascending Subsequence ("Longest Upsequence").- 3.6.6 Recognition and Parsing of Context-Free Grammars.- 3.6.7 Reachability and Cycles in Graphs.- 3.6.8 A Coding Problem.- 3.6.9 Unification of Terms.- 3.6.10 The "Pack Problem".- 3.6.11 The Bounded Buffer.- 3.6.12 Paraffins.- 3.7 Exercises.- 4. Basic Transformation Techniques.- 4.1 Semantic Foundations.- 4.2 Notational Conventions.- 4.2.1 Program Schemes.- 4.2.2 Transformation Rules.- 4.2.3 Program Developments.- 4.3 The Unfold/Fold System.- 4.4 Further Basic Transformation Rules.- 4.4.1 Axiomatic Rules of the Language Definition.- 4.4.2 Rules About Predicates.- 4.4.3 Basic Set Theoretic Rules.- 4.4.4 Rules from the Axioms of the Underlying Data Types.- 4.4.5 Derived Basic Transformation Rules.- 4.5 Sample Developments with Basic Rules.- 4.5.1 Simple Number Problem.- 4.5.2 Palindromes.- 4.5.3 The Simple Bank Account Problem Continued.- 4.5.4 Floating Point Representation of. the Dual Logarithm of the Factorial.- 4.6 Exercises.- 5. From Descriptive Specifications to Operational Ones.- 5.1 Transforming Specifications.- 5.2 Embedding.- 5.3 Development of Recursive Solutions from Problem Descriptions.- 5.3.1 A General Strategy.- 5.3.2 Compact Rules for Particular Specification Constructs.- 5.3.3 Compact Rules for Particular Data Types.- 5.3.4 Developing Partial Functions from their Domain Restriction.- 5.4 Elimination of Descriptive Constructs in Applicative Programs.- 5.4.1 Use of Sets.- 5.4.2 Classical Backtracking.- 5.4.3 Finite Look-Ahead.- 5.5 Examples.- 5.5.1 Sorting.- 5.5.2 Recognition of Context-Free Grammars.- 5.5.3 Coding Problem.- 5.5.4 Cycles in a Graph.- 5.5.5 Hamming's Problem.- 5.5.6 Unification of Terms.- 5.5.7 The "Pack Problem".- 5.6 Exercises.- 6. Modification of Applicative Programs.- 6.1 Merging of Computations.- 6.1.1 Function Composition.- 6.1.2 Function Combination.- 6.1.3 "Free Merging".- 6.2 Inverting the Flow of Computation.- 6.3 Storing of Values Instead of Recomputation.- 6.3.1 Memo-ization.- 6.3.2 Tabulation.- 6.4 Computation in Advance.- 6.4.1 Relocation.- 6.4.2 Precomputation.- 6.4.3 Partial Evaluation.- 6.4.4 Differencing.- 6.5 Simplification of Recursion.- 6.5.1 From Linear Recursion to Tail Recursion.- 6.5.2 From Non-Linear Recursion to Tail Recursion.- 6.5.3 From Systems of Recursive Functions to Single Recursive Functions.- 6.6 Examples.- 6.6.1 Bottom-up Recognition of Context-Free Grammars.- 6.6.2 The Algorithm by Cocke, Kasami and Younger.- 6.6.3 Cycles in a Graph.- 6.6.4 Hamming's Problem.- 6.7 Exercises.- 7. Transformation of Procedural Programs.- 7.1 From Tail Recursion to Iteration.- 7.1.1 while Loops.- 7.1.2 Jumps and Labels.- 7.1.3 Further Loop Constructs.- 7.2 Simplification of Imperative Programs.- 7.2.1 Sequentialization.- 7.2.2 Elimination of Superfluous Assignments and Variables.- 7.2.3 Rearrangement of Statements.- 7.2.4 Procedures.- 7.3 Examples.- 7.3.1 Hamming's Problem.- 7.3.2 Cycles in a Graph.- 7.4 Exercises.- 8. Transformation of Data Structures.- 8.1 Implementation of Types in Terms of Other Types.- 8.1.1 Theoretical Foundations.- 8.1.2 Proving the Correctness of an Algebraic Implementation.- 8.2 Implementations of Types for Specific Environments.- 8.2.1 Implementations by Computation Structures.- 8.2.2 Implementations in Terms of Modes.- 8.2.3 Implementations in Terms of Pointers and Arrays.- 8.2.3 Procedural Implementations.- 8.3 Libraries of Implementations.- 8.3.1 "Ready-Made" Implementations.- 8.3.2 Complexity and Efficiency.- 8.4 Transformation of Type Systems.- 8.5 Joint Development.- 8.5.1 Changing the Arguments of Functions.- 8.5.2 "Attribution".- 8.5.3 Compositions.- 8.5.4 Transition to Procedural Constructs for Particular Data Types.- 8.6 An Example: Cycles in a Graph.- 8.7 Exercises.- 9. Complete Examples.- 9.1 Warshall's Algorithm.- 9.1.1 Formal Problem Specification.- 9.1.2 Derivation of an Operational Specification.- 9.1.3 Operational Improvements.- 9.1.4 Transition to an Imperative Program.- 9.2 The Majority Problem.- 9.2.1 Formal Specification.- 9.2.2 Development of an Algorithm for the Simple Problem.- 9.2.3 Development of an Algorithm for the Generalized Problem.- 9.3 Fast Pattern Matching According to Boyer and Moore.- 9.3.1 Formal Specification.- 9.3.2 Development of the Function occurs.- 9.3.3 Deriving an Operational Version of ?.- 9.3.4 Final Version of the Function occurs.- 9.3.5 Remarks on Further Development.- 9.3.6 Concluding Remarks.- 9.4 A Text Editor.- 9.4.1 Formal Specification.- 9.4.2 Transformational Development.- 9.4.3 Concluding Remarks.- References.

Concurrency and discrete event control

Abstract: Much of discrete event control theory has been developed within the framework of automata and formal languages. An alternative approach inspired by the theories of process-algebra as developed in the computer science literature is presented. The framework, which rests on a new formalism of concurrency, can adequately handle nondeterminism and can be used for analysis of a wide range of discrete event phenomena. >

Prudence and other conditions on formal language learning

Abstract: Inductive inference (IIMs) are used to model, among other things, human language learning. Various restrictions on the behavior of IIMs are investigated, the question of interest being whether restricted IIMs can be as powerful as unrestricted IIMs. It is shown that set-driven IIMs are limited in power, whereas order-independent, rearrangement-independent, and prudent IIMs are not. The motivation of formal language learning theory from human language learning is questioned.

The information-processing approach.

Abstract: The information-processing (IP) approach to perception and cognition arose as a reaction to behaviourism. This reaction mainly concerned the nature of explanation in scientific psychology. The “standard” account of behaviour, phrased in strictly external terms, was replaced by a “realist” account, phrased in terms of internal entities and processes. An analysis of the theoretical language used in IP psychology shows an undisciplined state of affairs. A great number of languages is simultaneously in use; no level of analysis is unambiguously referred to; and basic concepts such as information and processing remain largely undefined. Nevertheless, over the past 25 years the IP approach has developed into a disciplined and sophisticated experimental science. A look at actual practice hints at the basic reason for its success. The approach is not so much concerned with absolute or intrinsic properties of the human information processor, but with what can be called its relative or differential properties. A further analysis of this feature of the IP approach in terms of the formal language of a logical system makes explicit the basis of its success. The IP approach can be regarded as developing an empirical difference calculus on an unspecified class of objects, phrased in terms of a simulated “theory-neutral” observation language, and with operators that are structurally analogous to logical operators. This reinterpretation of what the IP approach is about brings a number of advantages. It strengthens its position as an independent science, clarifies its relation with other approaches within psychology and other sciences within the cognitive science group, and makes it independent of philosophical subtleties.

A logic modeling language for automated model construction

Abstract: This paper describes PM ∗ (read PM-star) a first-order logic based language, that is the basis of a knowledge based system designed to help non-expert users construct Linear Programming models in the Production, Distribution and Inventory planning domain. Problems specified in PM ∗ define a logic model which is used to generate problem-specific inferences and inferences required to automate model construction. PM ∗ extends previous work on the PM language (Krishnan, 1988) through the integration of problem representation and model construction within a uniform predicate logic frame.

Implicit definability on finite structures and unambiguous computations

Abstract: The expressive power and the computational strength of first-order implicit definability on finite structures are studied. It is shown that every fixpoint query is a member of an implicitly definable pair of queries on finite structures. This turns out to be an optimal result, since in addition it is proven that there are natural fixpoint queries that are not implicitly definable on finite structures. First-order implicit definability on ordered finite structures is also investigated, and logical characterization of the complexity class UP intersection coUP is obtained in terms of it, where UP is the class of NP languages accepted by unambiguous Turing machines. >

Specifications of a simplified transport protocol using different formal description techniques

Abstract: Formal description techniques have been developed for the specification of OSI communication protocols and services, and can also be used as specification languages for other application areas. This paper presents two complete example specifications of a simplified Transport protocol (class 2) written in Estelle and LOTOS, and the outline of a similar specification in SDL. These examples are of sufficient complexity to demonstrate the difficulties encountered in the development of formal specifications. They may also be taken as a basis for a comparative evaluation of the three languages, Estelle, LOTOS and SDL, bearing in mind that they are particular examples.

A unified approach for showing language containment and equivalence between various types of Ω-automata

Abstract: We consider the language containment and equivalence problems for six different types of ω-automata: Buchi, Muller, Rabin, Streett, the L-automata of Kurshan, and the ∀-automata of Manna and Pnueli. We give a six by six matrix in which each row and column is associated with one of these types of automata. The entry in the i th row and j th column is the complexity of showing containment between the i th type of automaton and the j th . Thus, for example, we give the complexity of showing language containment and equivalence between a Buchi automaton and a Muller or Streett automaton. Our results are obtained by a uniform method that associates a formula of the logic CTL* with each type of automaton. Our algorithms use a model checking procedure for the logic with the formulas obtained from the automata. The results of our paper are important for verification of finite state concurrent systems with fairness constraints. A natural way of reasoning about such systems is to model the finite state program by one ω-automaton and its specification by another.

Zeta functions of formal languages

Abstract: Motivated by symbolic dynamics and algebraic geometry over finite fields, we define cyclic languages and the zeta function of a language. The main result is that the zeta function of a cyclic language which is recognizable by a finite automation is rational.

Many-valued logics and plausible reasoning

Abstract: The analysis of reasoning with inconsistent information is modeled by a formal metasystem, META, which is presented. Semantics for META is given in terms of possible translations into three-valued logics which are based on a notion of contextual negation. From the point of view of applications, it is shown that this analysis can provide better foundations for default reasoning. >

Logic-based approach for modeling organization of design standards

Abstract: Several studies have been conducted on representing and processing design standards for design automation. One of the main outcomes of these studies is the standards analysis, synthesis, and expression (SASE) model. To extend the utility of the SASE model for processing (reasoning about) design standards, a logic‐based approach is proposed. This approach provides: (1) A formal language, founded on predicate logic, for representing the standard; and (2) a mechanical means for reasoning about the standard using the language. The formal language is used to model the overall organization of a portion of the American Institute of Steel Construction (AISC) design specification. The model, called the formal organizational submodel, is composed of a set of axioms that capture the relationships between the classifiers and the provisions of the standard. Reasoning about the formal organizational submodel is accomplished using the resolution theorem proving strategy. This paper's main contribution is its use of pred...

On embedded languages for model management

Abstract: The authors present a technique called embedded languages which is a generalization of the EML (executable modeling language) approach. They believe that this technique can prove extremely useful in implementing desirable features not found in existing systems. The approach is discussed with reference to an advanced model management system, TEFA, which is being developed on the basis of this technique. >

Declarative specification of visual languages

Abstract: In order to specify the relationship between pictures and their meaning, a class of declarative, constraint-based picture specification languages is introduced. These extend previous approaches to picture specification based on constraints and grammar formalisms. As the languages are defined as an abstract language scheme, it is ensured that they share a common declarative semantics and execution model. The declarative semantics allows both people and machines to easily reason about a specification independently of any underlying implementation. The operational semantics permit a picture specification to be used to both generate and recognize pictures defined by visual languages. Implementation techniques developed for constraint logic programs, which enable this to be done efficiently, are discussed. >

On representation schemes for promising electronically

Abstract: This paper proposes and discusses a series of representational techniques for expressing promises in first-order logic. It is argued that the proposed representations have properties that cohere well with our pre-theoretic concept of promising, including creation of intensional contexts. Also, representations of promises in other formal languages, and inferences with them, may be validated by translating the expressions into the first-order formalism proposed here. Finally, a brief discussion is given to indicate that the proposed representational techniques may be applied generally to other illocutionary forces (or propositional attitudes).

Formaliser — An Interactive Support Tool for Z

Abstract: Formaliser is a software tool which supports the interactive editing, syntax, scope and type checking of Z specifications. The tool uses windows and a mouse, operating in a “WYSIWYG”, point-and-click style. Unconstrained text may be interspersed with syntax-enforced formal utterances. The tool is generic, in that it may be configured for formal languages other than Z. The software runs on low-cost desk-top machines. This paper illustrates the use and implementation of the tool.

Some relations among stochastic finite state networks used in automatic speech recognition

Abstract: In the literature on automatic speech recognition, the popular hidden Markov models (HMMs), left-to-right hidden Markov models (LRHMMs), Markov source models (MSMs), and stochastic regular grammars (SRGs) are often proposed as equivalent models. However, no formal relations seem to have been established among these models to date. A study of these relations within the framework of formal language theory is presented. The main conclusion is that not all of these models are equivalent, except certain types of hidden Markov models with observation probability distribution in the transitions, and stochastic regular grammar. >

Automated model construction: a logic based approach

Abstract: Attempts to integrate Artificial Intelligence (AI) techniques into Decision Support Systems (DSS) have received much attention in recent years. Significant among these has been the application of knowledge-based techniques to support various phases of the modeling process. This paper describes a logic based approach to mechanically construct Linear Programming (LP) models from qualitative problem specifications and illustrates it in the context of production, distribution and inventory planning problems. Specifically, we describe the features of a first-order logic based formal language called PM which is at the heart of an implemented knowledge-based tool for model construction. Problems specified in PM define a logic model which is then used to generate problem-specific inferences, and as input to a set of logic programming procedures that perform model construction.

Notes on renewal systems

Abstract: A renewal system is a symbolic dynamical system generated by free concatenations of a finite set of words. Renewal systems are sofic, but not every sofic shift is topologically conjugate to a renewal system

Generalized forbidding grammars

Abstract: Each production of a generalized forbidding grammar has an associated finite set of words. Such a production can be applied only if none of its associated words is a substring of a given rewritten sentential form. It is shown that these grammars with productions having associated only words consisting of one or two symbols characterize type 0 languages

A syntax and semantics for network diagrams

Abstract: Research concerning the automated design of network diagrams is reported. A formulation of syntax and semantics for network diagrams that is used in the Automated Network Diagram Designer (ANDD) system is presented. The syntactic formulation differs from previous work in two significant ways: perceptual-organization phenomena are explicitly represented, and syntax is described in terms of constraints rather than as a grammar of term-rewriting rules. The semantic formulation is based on an application-independent model of network systems that can be used to model many applications. Examples that show how these concepts are used by ANDD to automatically design network diagrams are included. >

Generation and recognition of formal languages by modifiable grammars

Abstract: In this article the formal definitions of modifiable grammars are presented, and the equivalence between classes of modifiable grammars and Turing machines is proved. Some criteria for reducing modifiable grammars to context-free grammars are provided. A lazy LR(1) algorithm for context-free grammars and an algorithm for constructing a LR(1) parser for modifiable grammars are discussed.

Formal Languages and Power Series.

Abstract: Publisher Summary This chapter discusses formal language theory and focuses on a specific tool called formal power series. Formal language theory, together with automata theory, is the oldest branch of theoretical computer science. The chapter discusses the fundamental notions about formal power series and languages. It also various normal forms for grammars. The chapter describes a class of generating devices that are somewhat different from grammars but still equivalent to grammars in the sense that the family of languages generated by the new devices equals the family of recursively enumerable languages. The new devices, called Post canonical systems or Post systems, very closely resemble formal systems in logic. The productions have the shape of inference rules. The family of languages generated by Post systems equals the family of recursively enumerable languages. The chapter discusses Markov algorithms, which resemble the intuitive notion of an algorithm. Viewed as language-defining devices, Markov algorithms are equivalent to grammars and Post systems.

Further remarks on parallel communicating grammar systems

Abstract: We continue the study of parallel communicating grammar systems introduced in P[acaron]un and Sântean [7] as a grammatical model of parallel computing. The investigated topics are: closure properties, the efficiency of generating a (linear) language by such a system compared with usual grammars, hierarchies.

A Formal Operational Semantics for Languages of Type Prolog III

Abstract: We use dynamic algebras introduced by Gurevich in [Gurevich 1988], [Gurevich 1991] to develop a formal semantics for the logical core of constraint logic programming languages of type Prolog III [Colmerauer 1990]. Our specification abstracts away from any particular feature of the mechanism for the resolution of constraints, thus providing a uniform description of constraint logic programming languages which turns out to be a natural refinement of the standard Prolog algebras developed in [Borger 1990]. In particular we show how our method can be used for a precise but simple method to handle specification problems connected to the freeze predicate.