Many-sorted Algebras Research Articles

Final algebras, cosemicomputable algebras and degrees of unsolvability

This paper studies some computability notions for abstract data types, and in particular compares cosemicomputable many-sorted algebras with a notion of finality to model minimal-state realizations of abstract (software) machines. Given a finite many-sorted signature Σ and a set of V of visible sorts, for every Σ-algebra A with co-r.e. behavior and nontrivial, computable V-behavior, there is a finite signature extension Σ' of Σ (without new sorts) and a finite set E of Σ'-equations such that A is isomorphic to a reduct of the final (Σ', E)-algebra relative to V. This uses a theorem due to Bergstra and Tucker [3]. If A is computable, then A is also isomorphic to the reduct of the initial (Σ′, E)-algebra. We also prove some results on congruences of finitely generated free algebras. We show that for every finite signature Σ, there are either countably many Σ-congruences on the free Σ-algebra or else there is a continuum of such congruences. There are several necessary and sufficient conditions which separate these two cases. We introduce the notion of the Turing degree of a minimal algebra. Using the results above, we prove that there is a fixed one-sorted signature such that for every r.e. degree d, there is a finite set E of Σ-equations such the initial (Σ, E)-algebra has degree d. There is a two-sorted signature Σ 0 and a single visible sort such that for every r.e. degree d there is a finite set E of Σ-equations such that the initial (Σ, E, V)-algebra is computable and the final (Σ, E, V)-algebra is cosemicomputable and has degree d.

Soundness and completeness of the Birkhoff equational calculus for many-sorted algebras with possibly empty carrier sets

Since the many-sorted extension of the Birkhoff equational calculus is unsound when algebras with empty carrier sets are admitted, Goguen and Meseguer proposed a new sound and complete many-sorted equational calculus. This paper presents another approach, alternative to that proposed by Goguen and Meseguer that makes sound and complete the many-sorted extension of the Birkhoff equational calculus. The possibility of maintaining the classical rules is obtained b y introducing a new notion of satisfiability, called strong satisfiability. An easier notion of satisfiability called weak satisfiability is also studied, and sufficient and necessary conditions are developed in order to reduce the strong satisfiability to the weak one. In fact, strongly sensible signatures, which generalize sensible signatures introduced by Huet and Oppen, guarantee the equivalence between strong, weak and other usual satisfiabilities. Finally, general conditions for the equivalence of the Birkhoff calculus to the Goguen-Meseguer calculus are established.

Data types over multiple-valued logics

Let L be a multiple-valued logic. An equality-test algebra over L is a many-sorted algebra that contains the truth values of L in a special logic domain; it also includes certain operations that take values in the logic domain and are to be viewed as the characteristic functions of nonclassical predicates over the universe of the algebra. In particular the algebra contains for each sort s the characteristic function of the nonclassical equality predicate over the domain of sort s. Nonclassical data structures of this form arise naturally in various computer science contexts. The basic properties of nonclassical equality-test algebras are investigated, and an axiomatization of their conditional-equational theory is obtained for a large class of multiple-valued logics. Some consequences for the specification of nonclassical equality-test data types are drawn.

Using logic programming for formal specification and validation of data models

Mathematical specifications of data models provide formal means to prove the correctness of the models. Such specifications may be used as prototypes to determined the result of transactions on a database. This paper describes the use of logic programming to mechanize the axiomatization of a proposed extension to the relational data model. The extended model is defined using a many-sorted algebra termed DRE-algebra. The DRE-algebra is then directly implemented in PROLOG. The implementation helps in verifying the correctness of the DRE-algebra and is used as an early prototype to investigate design decisions.

Database theory column

Complex object databases have been proposed as a significant extension of relational databases, with many practical applications. In the second database theory column, we present languages for the manipulation of such databases: a many-sorted algebra and an equivalent calculus. Without attempting to standardize, we try to provide general and short definitions that highlight the two key constructors of complex objects: tuples and (finite) sets. We comment on issues, such as language expressive power and complexity, and we describe equivalent rule-based languages with fixpoint semantics. Finally, we review the state-of-the art in database complex objects and list some interesting open questions.

Parametrization for order-sorted algebraic specification

We investigate parametrization for order-sorted algebraic specifications. As a prerequisite we study free constructions for order-sorted algebras and relate the various approaches to order-sorting. Then we analyse parameter passing, the result being that the notion of order-sorted specification has to be restricted in order to establish our main result, namely, that parameter passing satisfies the same correctness criteria as in the case of many-sorted algebras.

Denotational engineering

This paper is devoted to the methodology of using denotational techniques in software design. Since denotations describe the essential components comprising a system and syntax provides ways for the user to access and communicate with these components, we suggest that denotations be developed in the first place and that syntax be derived from them later. That viewpoint is opposite to the traditional (descriptive) style where denotational techniques are used in assigning a meaning to some earlier defined syntax. Our methodology is discussed on an algebraic ground where both denotations and syntax constitute many-sorted algebras and where denotational semantics is a homomorphism between them. On that ground the construction of a denotational model of a software system may be regarded as a derivation of a sequence of algebras. We discuss some mathematical techniques which may support that process especially this part where syntax is derived from denotations. The suggested methodology is illustrated on two small examples.

An algebra for structured office documents

We describe a data model for structured office information objects, which we generically call “documents,” and a practically useful algebraic language for the retrieval and manipulation of such objects. Documents are viewed as hierarchical structures; their layout (presentation) aspect is to be treated separately. The syntax and semantics of the language are defined precisely in terms of the formal model, an extended relational algebra.The proposed approach has several new features, some of which are particularly useful for the management of office information. The data model is based on nested sequences of tuples rather than nested relations. Therefore, sorting and sequence operations and the explicit handling of duplicates can be described by the model. Furthermore, this is the first model based on a many-sorted instead of a one-sorted algebra, which means that atomic data values as well as nested structures are objects of the algebra. As a consequence, arithmetic operations, aggregate functions, and so forth can be treated inside the model and need not be introduced as query language extensions to the model. Many-sorted algebra also allows arbitrary algebra expressions (with Boolean result) to be admitted as selection or join conditions and the results of arbitrary expressions to be embedded into tuples. In contrast to other formal models, this algebra can be used directly as a rich query language for office documents with precisely defined semantics.

Closed sets of universal Horn formulas for many-sorted (partial) algebras

Closed sets of universal Horn formulas for many-sorted (partial) algebras

On the Axiomatization of “If-Then-Else”

The equationally complete proof system for “if-then-else” of Bloom and Tindell (this Journal, 12(1983), pp. 677–707) is extended to a complete proof system for many-sorted algebras with extra opera...

Strong linear convexity. I. Duality of spaces of holomorphic functions

I. p.J. Higgins, "Algebras with a scheme of operators," Math. Nachr., 27, Nos. I-2, I~5132 (1963). 2. B.I. Plotkin, Ts. E. Dididze, and E. M. Kublanova, "Varieties of automata, ~' Kibernetika, No. I, 47-54 (1977). 3. A. I. Malt'sev, Algebraic Systems [in Russian], Nauka, Moscow (1970). 4. A.A. Gvaramiya, " " " many-sorted algebras, : Quas~varleties of " in Theses of Brief Communications, International Mathematical Conference, 1983, Warsaw, Section II, Algebra, p. 20. 5. B~ I. P!otkin and S. M. Vovsi, Varieties of Group Representations [in Russian], Zinatne, Riga (1983)~ 6. V.D. Belousov, Algebraic Nets and Quasigroups [in Russian]~ Shtiintsa~ Kishinev (197]). 7. V. M~ Glushkov, "An abstract theory of automata," Usp. Mat. Nauk, 25, No. 5, 3-62 (~96~)o 8. V.D. Belousov, "Balanced identities in quasigroups," Mat. Sb., 70, No. I, 55-97 (1966)~ 9. J. Jezek and T. Kepka, "Quasigroups isotopic to a group," Comment. Mat. Univ. Carolinae, ~6, No. ~, 59-76 (1975).

Growing certainty with null values

Non-availability of part of the data is a problem common to many database systems. We study here some aspects relating to incomplete information. Obviously, when the information in a database is not complete the answer to any query is only an approximation to the true result. The aim is to get a precise approximation. We regard databases as many-sorted algebras. Based on the concept of extended algebra we define what it means for an algebra to approximate another algebra. We then give the following simple principle for extending query languages to handle missing data: “Whenever information is added to an incomplete database subsequent answers to queries must not be contradictory or less informative than previously.” We then apply this principle to extend the functional query language Varqa. Finally, we compare the previously proposed many-valued logic systems with the system devised based on our principles.

First-order theories as many-sorted algebras.

On montre que chaque theorie d'ordre 1 est une algebre particuliere verifiant des axiomes sous forme d'equation

Parametrized data types do not need highly constrained parameters

Data types may be considered as objects in any suitable category, and need not necessarily be ordered structures or many-sorted algebras. Arrays may be specified having as parameter any object from a category %plane1D;4A6; with finite products and coproducts, if products distribute over coproducts. The Lehmann-Smith least fixpoint approach to recursively-defined data types is extended by introducing the dual notion of greatest fixpoint, which allows the definition of infinite lists and trees without recourse to domains bearing a partial order structure. Finally, the least fixpoint approach is shown allowing the definition of queues directly in terms of stacks, rather than through a separate equational specification.

Algebras with actions and automata

In the present paper we want to give a common structure theory of left action, group operations, R‐modules and automata of different types defined over various kinds of carrier objects: sets, graphs, presheaves, sheaves, topological spaces (in particular: compactly generated Hausdorff spaces). The first section gives an axiomatic approach to algebraic structures relative to a base category B, slightly more powerful than that of monadic (tripleable) functors. In section 2 we generalize Lawveres functorial semantics to many‐sorted algebras over cartesian closed categories. In section 3 we treat the structures mentioned in the beginning as many‐sorted algebras with fixed “scalar” or “input” object and show that they still have an algebraic (or monadic) forgetful functor (theorem 3.3) and hence the general theory of algebraic structures applies. These structures were usually treated as one‐sorted in the Lawvere‐setting, the action being expressed by a family of unary operations indexed over the scalars. But this approach cannot, as the one developed here, describe continuity of the action (more general: the action to be a B‐morphism), which is essential for the structures mentioned above, e.g. modules for a sheaf of rings or topological automata. Finally we discuss consequences of theorem 3.3 for the structure theory of various types of automata. The particular case of algebras with fixed “natural numbers object” has been studied by the authors in [23].

More on advice on structuring compilers and proving them correct

Following Lockwood Morris, a method for algebraically structuring a compiler and proving it correct is described. An example language with block structure and side-effects is presented. This determines an initial many-sorted algebra L which is the ‘abstract syntax’ of the example language. Then the semantics of L is completely determined by describing a semantic algebra M ‘similar’ to L. In particular, initiality of L ensures that there is a unique homomorphism Lsem: L→> M. This is algebraically structuring the semantic definition of the language. A category of flow-charts over a stack machine is used as a target language for the purposes of compilation. The semantics of the flow charts (Tsem: T→ S) is also algebraically determined given interpretations of the primitive operations on the stack and store. The homomorphism comp: L→ T is the compiler which is also uniquely determined by presenting an algebra T of flowcharts similar to L. This is algebraically structuring the compiler. Finally a function encode: M→ S describes source meanings in terms of target meanings. The proof that the compiler is correct reduces to a proof that encode: M→ S is a homomorphism; then both comp ∘ Tsem and Lsem ∘ encode are homomorphisms from L to S and they must be equal because there is only one homomorphism from L to S.

A Constructive Approach to Compiler Correctness

<br /> It is suggested that denotational semantic definitions of programming languages should be based on a small number of abstract data types, each embodying a fundamental concept of computation. Once these fundamental abstract data types have been implemented in a particular target language (e.g. stack-machine code), it is a simple matter to construct a correct compiler for any source language from its denotational semantic definition. The approach is illustrated by constructing a compiler similar to the one which was proved correct by Thatcher, Wagner <em>Et</em> Wright ( 1979). Some familiarity with many-sorted algebras is presumed.

An order-algebraic definition of knuthian semantics

This paper presents a formulation, within the framework of initial algebra semantics, of Knuthian semantic systems (K-systems) which contain both synthesized and inherited attributes. The approach is based on viewing the semantics of a derivation tree of a context-free grammar as a set of values, called an attribute valuation, assigned to the attributes of all its nodes. Any tree's attribute valuation which is consistent with the semantic rules of the K-system may be chosen as the semantics of that derivation tree. The set of attribute valuations of a given tree is organized as a complete partially ordered set such that the semantic rules define a continuous transformation on this set. The least fixpoint of this transformation is chosen as the semantics of a given derivation tree. The mapping from derivation trees to their least fixpoint semantics is a homomorphism between certain algebras. Thus, the semantics of a K-system is an application of the Initial Algebra Semantics Principle of Goguen and Thatcher. This formulation permits a precise definition of K-systems, and generalizes Knuth's original formulation by defining the meaning of recursive (circular) semantic specifications. The algebraic formulation of K-systems is applied to proving the equivalence of K-systems having the same underlying grammar. Such proofs may require verifying that a K-system possesses certain properties and to this end, a principle of structural induction on many-sorted algebras is formulated, justified, and applied.

Some remarks on abstract data types

Some attention has been given recently to abstract data types as a powerful programming concept [1,2,3,4]. In this approach, abstract data types are viewed as sets together with the operators on these sets. One may define a data type either operationally, by writing the procedures for each operator, or denotationally, using many-sorted (heterogeneous) algebras as described for example by Guttag [1,2]. In the algebraic approach to specifying abstract data types, these two problems are raised.1) It is difficult to prove "sufficiency-completeness". That is, it is difficult to prove that the equations characterize the data structure in question.2) The algebraic presentation (that is, the set of equations defining the type) is not very readable or easy to construct.The purpose of this note is to point out that both these problems have a solution, and in fact the solutions are interrelated. These results were originally developed by Goguen et al [5], and an intuitive description of the process is given here.

The existence and construction of free iterative theories

In “Monadic Computation and Iterative Algebraic Theories” by Calvin C. Elgot,the notion “iterative theory” (more fully, “ideal theory closed under conditional iteration”) is introduced and applied to the study of computational processes. The main point of the present paper is to show the existence (in a constructive sense) of free iterative theories. The main complication is the fact that in an iterative theory I the “iteration” operation is not defined for all elements of I . Were it not for this complication, the existence of free iterative theories would follow from general algebraic considerations (extended to many-sorted algebras). Actually we sketch two proofs of the existence of free iterative theories. One argument follows as much as possible general algebraic lines and is given a linguistic flavor in order to emphasize the concreteness of the ideas involved. The second argument depends upon “normal descriptions”: a morphism in the free iterative theory being an equivalence class of normal descriptions.