A Modular Framework for Specification and Implementation

A modular framework for the formal specification and implementation of large families of sorts and functions is introduced. It is intended to express generation principles, to rename, combine and construct implementations of specifications in flexible styles. Parameterization is also included. The main characteristics of this approach are the inclusion of predicates in the signature of specifications and the use of an ultra-loose semantics. Signatures are triples of sets of sorts, sets of function symbols and sets of predicate symbols; the latter contain among others also standard predicate symbols, in particular the equality symbols as well as predicate symbols expressing generation principles which hold for an object if and only if it can be denoted by a term of a specific signature. These standard predicate symbols lead to an ultra-loose semantics for specifications: models are not required to be term-generated; instead, the term-generated subalgebra of a model is required to satisfy the axioms. Main advantages of this approach are the simplicity of the notion of implementation and the simplicity of the corresponding language for writing structured specifications.

[1]  Donald Sannella,et al.  Building Specifications in an Arbitrary Institution , 1984, Semantics of Data Types.

[2]  Friedrich L. Bauer,et al.  Algorithmic Language and Program Development , 1982, Texts and Monographs in Computer Science.

[3]  Hartmut Ehrig,et al.  Parameter passing commutes with implementation of parameterized data types , 1982 .

[4]  Hartmut Ehrig,et al.  Programming in the Large with Algebraic Module Specifications (Invited Paper) , 1986, IFIP Congress.

[5]  Martin Wirsing,et al.  Structured Algebraic Specifications: A Kernel Language , 1986, Theor. Comput. Sci..

[6]  Joseph A. Goguen,et al.  The Semantics of CLEAR, A Specification Language , 1979, Abstract Software Specifications.

[7]  K. Mani Chandy,et al.  Current trends in programming methodology , 1977 .

[8]  Loe M. G. Feijs.  The Calculus lambda-pi , 1987, Algebraic Methods.

[9]  Martin Wirsing,et al.  Implementation of Parameterised Specifications (Extended Abstract) , 1982, ICALP.

[10]  李幼升,et al.  Ph , 1989 .

[11]  Manfred Broy,et al.  Algebraic Implementations Preserve Program Correctness , 1986, Sci. Comput. Program..

[12]  Jan A. Bergstra,et al.  Module algebra , 1990, JACM.

[13]  José Meseguer,et al.  Principles of OBJ2 , 1985, POPL.

[14]  Rolf Hennicker,et al.  Observational Implementations , 1989, STACS.

[15]  Michael D. Rychener.  Control requirements for the design of production system architectures , 1977 .

[16]  John V. Guttag,et al.  The specification and application to programming of abstract data types. , 1975 .

[17]  H. Keisler,et al.  Handbook of mathematical logic , 1977 .

[18]  C. A. R. Hoare,et al.  An axiomatic basis for computer programming , 1969, CACM.

[19]  Hartmut Ehrig,et al.  Algebraic Implementation of Abstract Data Types , 1982, Theor. Comput. Sci..

[20]  Donald Sannella,et al.  Program specification and development in standard ML , 1985, POPL.

[21]  Martin Wirsing,et al.  Implementation of parameterised specifications: Automata, Languages and Programming , 1982 .