Adding division to rings and fields leads to the question of how to deal with division by 0. From a plurality of options, we discuss in detail what we call Suppes-Ono division in which division by 0 produces 0. We explain the backstory of this semantic option and its associated notion of equality, and prove a result regarding the logical complexity of deciding equations over the rational numbers equipped with Suppes-Ono division. We prove that deciding the validity of the equations is computationally equivalent to the Diophantine Problem for the rational numbers, which is a longstanding open problem.

We analyse abstract data types that model numerical structures with a concept of error. Specifically, we focus on arithmetic data types that contain an error value \(\bot\) whose main purpose is to always return a value for division. To rings and fields, we add a division operator \(x/y\) and study a class of algebras called common meadows wherein \(x/0=\bot\) . The set of equations true in all common meadows is named the equational theory of common meadows . We give a finite equational axiomatisation of the equational theory of common meadows and prove that it is complete and that the equational theory is decidable.

Abstract Eager equality is a novel semantics for equality in the presence of partial operations. We consider term rewriting for eager equality for arithmetic in which division is a partial operator. We use common meadows which are essentially fields that contain an absorptive element $\bot $. The idea is that term rewriting is supposed to be semantics preserving for non-$\bot $ terms only. We show soundness and adequacy results for eager term rewriting w.r.t. the class of all common meadows. However, we show that an eager term rewrite system which is complete for common meadows of rational numbers is not easy to obtain, if it exists at all.

Abstract Common meadows are arithmetic structures with inverse or division, made total on $0$ by a flag $\bot $ for ease of calculation. We examine some axiomatizations of common meadows to clarify their relationship with commutative rings and serve different theoretical agendas. A common meadow fracterm calculus is a special form of the equational axiomatization of common meadows, originally based on the use of division on the rational numbers. We study axioms that allow the basic process of simplifying complex expressions involving division. A useful axiomatic extension of the common meadow fracterm calculus imposes the requirement that the characteristic of common meadows be zero (using a simple infinite scheme of closed equations). It is known that these axioms are complete for the full equational theory of common cancellation meadows of characteristic $0$. Here, we show that these axioms do not prove all conditional equations which hold in all common cancellation meadows of characteristic $0$.

Eager equality for algebraic expressions over partial algebras distinguishes or separates terms only if both have defined values and they are different. We consider arithmetical algebras with division as a partial operator, called meadows, and focus on algebras of rational numbers. To study eager equality, we use common meadows, which are totalisations of partial meadows by means of absorptive elements. An axiomatisation of common meadows is the basis of an axiomatisation of eager equality as a predicate on a common meadow. Applied to the rational numbers, we prove completeness and decidability of the equational theory of eager equality. To situate eager equality theoretically, we consider two other partial equalities of increasing strictness: Kleene equality, which is equivalent to the native equality of common meadows, and one we call cautious equality. Our methods of analysis for eager equality are quite general, and so we apply them to these two other partial equalities; and, in addition to common meadows, we use three other kinds of algebra designed to totalise division. In summary, we are able to compare 13 forms of equality for the partial meadow of rational numbers. We focus on the decidability of the equational theories of these equalities. We show that for the four total algebras, eager and cautious equality are decidable. We also show that for others the Diophantine Problem over the rationals is one-one computably reducible to their equational theories. The Diophantine Problem for rationals is a longstanding open problem. Thus, eager equality has substantially less complex semantics.

Upon adding division to the operations of a field we obtain a meadow. It is conventional to view division in a field as a partial function, which complicates considerably its algebra and logic. But partiality is one out of a plurality of possible design decisions regarding division. Upon adding a partial division function ÷ to a field Q of rational numbers we obtain a partial meadow Q(÷) of rational numbers that qualifies as a data type. Partial data types bring problems for specifying and programming that have led to complicated algebraic and logical theories – unlike total data types. We discuss four different ways of providing an algebraic specification of this important arithmetical partial data type Q(÷) via the algebraic specification of a closely related total data type. We argue that the specification method that uses a common meadow of rational numbers as the total algebra is the most attractive and useful among these four options. We then analyse the problem of equality between expressions in partial data types by examining seven notions of equality that arise from our methods alone. Finally, based on the laws of common meadows, we present an equational calculus for working with fracterms that is of general interest outside programming theory.

This paper concerns the relation between process algebra and Hoare logic. We investigate the question whether and how a Hoare logic can be used for reasoning about how data change in the course of a process when reasoning equationally about that process. We introduce an extension of ACP (Algebra of Communicating Processes) with features that are relevant to processes in which data are involved, present a Hoare logic for the processes considered in this process algebra, and discuss the use of this Hoare logic as a complement to pure equational reasoning with the equational axioms of the process algebra.

Abstract We consider several novel congruences on the signature of meadows with the aim to survey different notions of fractions. In particular we suggest a notion of “true fraction”.

In process algebras such as ACP (Algebra of Communicating Processes), parallel processes are considered to be interleaved in an arbitrary way. In the case of multi-threading as found in contemporary programming languages, parallel processes are actually interleaved according to some interleaving strategy. An interleaving strategy is what is called a process-scheduling policy in the field of operating systems. In many systems, for instance hardware/software systems, we have to do with both parallel processes that may best be considered to be interleaved in an arbitrary way and parallel processes that may best be considered to be interleaved according to some interleaving strategy. Therefore, we extend ACP in this paper with the latter form of interleaving. The established properties of the extension concerned include an elimination property, a conservative extension property, and a unique expansion property.

In a previous paper, an ACP-style process algebra was proposed in which propositions are used as the visible part of the state of processes and as state conditions under which processes may proceed. This process algebra, called ACPps, is built on classical propositional logic. In this paper, we pre sent a version of ACPps built on a paraconsistent propositional logic which is essentially the same as CLuNs. There are many systems that would have to deal with self-contradictory states if no special measures were taken. For a number of these systems, it is conceivable that accepting self-contradictory states and dealing with them in a way based on a paraconsistent logic is an alternative to taking special measures. The presented version of ACPps can be suited for the description and analysis of systems that deal with self-contradictory states in a way based on the above-mentioned paraconsistent logic.

Each Boolean function can be computed by a single-pass instruction sequence that contains only instructions to set and get the content of Boolean registers, forward jump instructions, and a termination instruction. Auxiliary Boolean registers are not necessary for this. In the current paper, we show that, in the case of the parity functions, shorter instruction sequences are possible with the use of an auxiliary Boolean register in the presence of instructions to complement the content of auxiliary Boolean registers. This result supports, in a setting where programs are instruction sequences acting on Boolean registers, a basic intuition behind the storage of auxiliary data, namely the intuition that this makes possible a reduction of the size of a program. The work presented in this paper is carried out in the setting of PGA (ProGram Algebra)

Every partial function from bit strings of a given length to bit strings of a possibly different given length can be computed by a finite instruction sequence that contains only instructions to set and get the content of Boolean registers, forward jump instructions, and a termination instruction. We look for an equivalence relation on instruction sequences of this kind that captures to a reasonable degree the intuitive notion that two instruction sequences express the same algorithm.

This issue contains five papers on algebraic and logical methods for data and modelling which were solicited for The Computer Journal in honour of the 60th birthday of John V Tucker. The topic reflects the focus of Tucker’s scientific career, and the computer journal—being the flagship journal of the BCS—represents a most appropriate forum to recognize this milestone. Tucker has throughout his life been committed to progressing British computing (science, technology, history and education as well as the BCS.

Let Q_0 denote the rational numbers expanded to a ‘meadow’, that is, after taking its zero-totalized form (0^{−1}=0) as the preferred interpretation. In this paper, we consider ‘cancellation meadows’, i.e. meadows without proper zero divisors, such as Q_0 and prove a generic completeness result. We apply this result to cancellation meadows expanded with differentiation operators, the sign function, and with floor, ceiling and a signed variant of the square root, respectively. We give an equational axiomatization of these operators and thus obtain a finite basis for various expanded cancellation meadows.

We introduce an algebra of data linkages. Data linkages are intended for modelling the states of computations in which dynamic data structures are involved. We present a simple model of computation in which states of computations are modelled as data linkages and state changes take place by means of certain actions. We describe the state changes and replies that result from performing those actions by means of a term rewriting system with rule priorities. The model in question is an upgrade of molecular dynamics. The upgrading is mainly concerned with the features to deal with values and the features to reclaim garbage.

Instruction sequence is a key concept in practice, but it has as yet not come prominently into the picture in theoretical circles. This paper concerns instruction sequences, the behaviours produced by them under execution, the interaction between these behaviours and components of the execution environment, and two issues relating to computability theory. Positioning Turing’s result regarding the undecidability of the halting problem as a result about programs rather than machines, and taking instruction sequences as programs, we analyse the autosolvability requirement that a program of a certain kind must solve the halting problem for all programs of that kind. We present novel results concerning this autosolvability requirement. The analysis is streamlined by using the notion of a functional unit, which is an abstract state-based model of a machine. In the case where the behaviours exhibited by a component of an execution environment can be viewed as the behaviours of a machine in its different states, the behaviours concerned are completely determined by a functional unit. The above-mentioned analysis involves functional units whose possible states represent the possible contents of the tapes of Turing machines with a particular tape alphabet. We also investigate functional units whose possible states are the natural numbers. This investigation yields a novel computability result, viz. the existence of a universal computable functional unit for natural numbers.

We study several aspects of the behaviours produced by instruction sequences under execution in the setting of the algebraic theory of processes known as ACP. We use ACP to describe the behaviours produced by instruction sequences under execution and to describe two protocols implementing these behaviours in the case where the processing of instructions takes place remotely. We also show that all finite-state behaviours considered in ACP can be produced by instruction sequences under execution.

We investigate the expressiveness of backward jumps in a frame work of formalized sequential programming called program algebra and characterize established non-uniform complexity classes in terms of instruction sequences, backward jumps and auxiliary registers.

We perceive programs as single-pass instruction sequences. A single-pass instruction sequence under execution is considered to produce a behaviour to be controlled by some execution environment. Threads as considered in basic thread algebra model such behaviours. We show that all regular threads, i.e. threads that can only be in a finite number of states, can be produced by single-pass instruction sequences without jump instructions if use can be made of Boolean registers. We also show that, in the case where goto instructions are used instead of jump instructions, a bound to the number of labels restricts the expressiveness.

Abstract It is a fact of life that sequential programs are often fragmented. Consequently, fragmented program behaviours are frequently found. We consider this phenomenon in the setting of thread algebra. We extend basic thread algebra with poly-threading, the barest mechanism for sequencing of threads that are taken for program fragment behaviours. This mechanism is the counterpart of program overlaying at the level of program behaviours. We relate the resulting theory to the process theory known as ACP and use it to describe analytic execution architectures suited for fragmented programs. We also consider the case where the steps of fragmented program behaviours are interleaved in the ways of non-distributed and distributed multi-threading.

A combination of program algebra with the theory of meadows is designed leading to a theory of computation in algebraic structures. It is proven that total functions on cancellation meadows can be computed by straight-line programs using at most five auxiliary variables. A similar result is obtained for signed meadows.

Sequential propositional logic deviates from conventional propositional logic by taking into account that during the sequential evaluation of a propositional statement, atomic propositions may yield different Boolean values at repeated occurrences. We introduce “free valuations” to capture this dynamics of a propositional statement's environment. The resulting logic is phrased as an equationally specified algebra rather than in the form of proof rules, and is named “proposition algebra.” It is strictly more general than Boolean algebra to the extent that the classical connectives fail to be expressively complete in the sequential case. The four axioms for free valuation congruence are then combined with other axioms in order define a few more valuation congruences that gradually identify more propositional statements, up to static valuation congruence (which is the setting of conventional propositional logic). Proposition algebra is developed in a fashion similar to the process algebra ACP and the program algebra PGA, via an algebraic specification which has a meaningful initial algebra for which a range of coarser congruences are considered important as well. In addition, infinite objects (i.e., propositional statements, processes and programs respectively) are dealt with by means of an inverse limit construction which allows the transfer of knowledge concerning finite objects to facts about infinite ones while reducing all facts about infinite objects to an infinity of facts about finite ones in return.

We take a process component as a pair of an interface and a behaviour. We study the composition of interacting process components in the setting of process algebra. We formalize the interfaces of interacting process components by means of an interface group. An interesting feature of the interface group is that it allows for distinguishing between expectations and promises in interfaces of process components. This distinction comes into play in case components with both client and server behaviour are involved.

We study shedding in the setting of data linkage dynamics, a simple model of computation that bears on the use of dynamic data structures in programming. Shedding is complementary to garbage collection. With shedding, each time a link to a data objec

We introduce a strict version of the concept of a load/store instruction set architecture in the setting of Maurer machines. We take the view that transformations on the states of a Maurer machine are achieved by applying threads as considered in thread algebra to the Maurer machine. We study how the transformations on the states of the main memory of a strict load/store instruction set architecture that can be achieved by applying threads depend on the operating unit size, the cardinality of the instruction set and the maximal number of states of the threads.

We study sequential programs that are instruction sequences with dynamically instantiated instructions. We define the meaning of such programs in two different ways. In either case, we give a translation by which each program with dynamically instantiated instructions is turned into a program without them that exhibits on execution the same behaviour by interaction with some service. The complexity of the translations differ considerably, whereas the services concerned are equally simple. However, the service concerned in the case of the simpler translation is far more powerful than the service concerned in the other case.

We model micro-architectures with non-pipelined instruction processing and pipelined instruction processing using Maurer machines, basic thread algebra and program algebra. We show that stored programs are executed as intended with these micro-architectures. We believe that this work provides a new mathematical approach to the modelling of micro-architectures and the verification of their correctness and the anticipated speed-up results.

A 0-totalised field is a field in which division is a total operation with 0−1=0. Equational reasoning in such fields is greatly simplified but in deriving a term one still wishes to know whether or not the calculation has invoked 0−1. If it has not then we call the derivation division safe. We propose three methods of guaranteeing division safe calculations in 0-totalised fields.

Threads as contained in a thread algebra emerge from the behavioral abstraction from programs in an appropriate program algebra. Threads may make use of services such as stacks, and a thread using a single stack is called a pushdown thread. Equivalence of pushdown threads is shown decidable whereas pushdown thread inclusion is undecidable. This is again an example of a borderline crossing where the equivalence problem is decidable, whereas the inclusion problem is not.

We develop an algebraic theory of threads, synchronous cooperation of threads and interaction of threads with Maurer machines, and investigate program parallelization using the resulting theory. Program parallelization underlies techniques for speeding up instruction processing on a computer that make use of the abilities of the computer to process instructions simultaneously in cases where the state changes involved do no influence each other. One of our findings is that a strong induction principle is needed when proving theorems about sufficient conditions for the correctness of program parallelizations. The induction principle introduced has brought us to construct a projective limit model for the theory developed.

Abstract We take a thread as the behavior of a sequential deterministic program under execution and multi-threading as the form of concurrency provided by contemporary programming languages such as Java and C#. We outline an algebraic theory about threads and multi-threading. In the case of multi-threading, some deterministic interleaving strategy determines how threads are interleaved. Interleaving operators for a number of plausible interleaving strategies are specified in a simple and concise way. By that, we show that it is essentially open-ended what counts as an interleaving strategy. We use deadlock freedom as an example to show that there are properties of multi-threaded programs that depend on the interleaving strategy used.

We give an equational specification of the field operations on the rational numbers under initial algebra semantics using just total field operations and 12 equations. A consequence of this specification is that 0 −1 = 0, an interesting equation consistent with the ring axioms and many properties of division. The existence of an equational specification of the rationals without hidden functions was an open question. We also give an axiomatic examination of the divisibility operator, from which some interesting new axioms emerge along with equational specifications of algebras of rationals, including one with the modulus function. Finally, we state some open problems, including: Does there exist an equational specification of the field operations on the rationals without hidden functions that is a complete term rewriting system?

In a previous paper we developed an algebraic theory about threads and a form of concurrency where some deterministic interleaving strategy determines how threads that exist concurrently are interleaved. The interleaving of different threads constitutes a multi-thread. Several multi-threads may exist concurrently on a single host in a network, several host behaviours may exist concurrently in a single network on the internet, etc. In the current paper we assume that the above-mentioned kind of interleaving is also present at those other levels. We extend the theory developed so far with features to cover the multi-level case. We employ the resulting theory to develop a simplified, formal representation schema of the design of systems that consist of several multi-threaded programs on various hosts in different networks and to verify a property of all systems designed according to that schema.

We study extensions of the process algebra axiom system ACP with two recursive operations: the binary Kleene star * , which is defined by x * y = x ( x * y + y , and the push-down operation $ , defined by x $ y = x (( x $ y )( x $ y )) + y . In this setting it is easy to represent register machine computation, and an equational theory results that is not decidable. In order to increase the expressive power, abstraction is then added: with rooted branching bisimulation equivalence each computable process can be expressed, and with rooted ô-bisimilarity each semi-computable process that initially is finitely branching can be expressed. Moreover, with abstraction and a finite number of auxiliary actions these results can be obtained without binary Kleene star. Finally, we consider two alternatives for the push-down operation. Each of these gives rise to similar results.

Abstract. The jump instruction is considered essential for an adequate theoretical understanding of imperative sequential programming. Using atomic actions and tests as a basis we outline an algebra of programs, denoted PGA, which captures the crux of sequential programming. PGA provides an ontology for programs rather than a semantics. Out of a multitude of conceivable semantic views on PGA we single out a behaviour extraction operator which assigns to each program a behaviour. The meaning of the constants of PGA is explained in terms of the extracted behaviour. Using PGA a small hierarchy of program notations is developed. Projection semantics is proposed as a tool for the description of program semantics.

We discuss the key notions of discrete time process algebra in the setting of ACP. Time is measured in discrete slices. The emphasis is on absolute, relative and parametric time notation. Note: Partial support received from ESPRIT Basic Research Action 7166, C0NCUR2.

We consider processes that have transitions labeled with atomic actions, and states labeled with formulas over a propositional logic. These state labels are called signals. A process in a parallel composition may proceed conditionally, dependent on the presence of a signal in the process in parallel. This allows a natural treatment of signal observation

PIM is an equational logic designed to function as a “transformational toolkit” for compilers and other programming tools that analyze and manipulate imperative languages. It has been applied to such problems as program slicing, symbolic evaluation, conditional constant propagation, and dependence analysis. PIM consists of the untyped lambda calculus extended with an algebraic data type that characterizes the behavior of lazy stores and generalized conditionals. A graph form of PIM terms is by design closely related to several intermediate representations commonly used in optimizing compilers. In this article, we show that PIM's core algebraic component, PIM t , possesses a complete equational axiomatization (under the assumption of certain reasonable restrictions on term formation). This has the practical consequence of guaranteeing that every semantics-preserving transformation on a program representable in PIM t can be derived by application of PIM t rules. We systematically derive the complete PIM t logic as the culmination of a sequence of increasingly powerful equational systems starting from a straightforward “interpreter” for closed PIM t terms. This work is an intermediate step in a larger program to develop a set of well-founded tools for manipulation of imperative programs by compilers and other systems that perform program analysis.

Abstract The axiom system ACP of [BeK84a] was extended with real time features in [BaB91]. Here we proceed to define a discrete time extension of ACP, along the lines of ATP [NiS94]. We present versions based on relative timing and on absolute timing. Both approaches are integrated using parametric timing. The time free ACP theory is embedded in the discrete time theory.

This paper proposes a framework for the integration of the algebra of communicating processes (ACP) and the algebra of flownomials (AF). Basically, this means to combine axiomatisations of parallel and looping operators. To this end a model of process graphs with multiple entries and exits is introduced. In this model the usual operations of both algebras are defined, e.g. alternative composition, sequential composition, feedback, parallel composition, left merge, communication merge, encapsulation, etc. The main results consist of correct and complete axiomatisations for process graphs modulo isomorphism and modulo bisimulation.

We classify the computable and semicomputable algebras in terms of finite equational initial algebra specifications and their properties as term term rewriting systems, such as completeness.Further results on properties of these specifications, such as on their size and orthogonality, are provided which show that our main results are the best possible.

We introduce iteration in process algebra by means of (the original, binary version of) Kleene's star operation: x * y is the process that chooses between x and y, and upon termination of x has this choice again. We add this operation to a whole range of process algebra axiom systems, starting from BPA (Basic Process Algebra). In the case of the most complex system under consideration, ACP τ , every regular process can be defined with handshaking (two-party communication) and auxiliary actions. Next we introduce nesting in process algebra: x#y is defined by the equation x#y=x(x#y)x+y

Abstract We illustrate the difference between sequential composition in process algebra axiomatisations like ACP and action prefixing in process calculi like CCS. We define both early and late input in a general framework extending ACP, and consider various subalgebras, some very close to value passing CCS, another one close to CSP.

Abstract The real time process algebra of Baeten and Bergstra [ Formal Aspects of Computing , 3 , 142–188 (1991)] is extended to real space by requiring the presence of spatial coordinates for each atomic action, in addition to the required temporal attribute. It is found that asynchronous communication cannot easily be avoided. Based on the state operators of Baeten and Bergstra [ Information and Computation , 78 , 205–245 (1988)] and following Bergstra et al. [ Proc. Seminar on Concurrency , LNCS 197, Springer, 1985, pp. 76–95], asychronous communication mechanisms are introduced as an additional feature of real space process algebra. The overall emphasis is on the introductory explanation of the features of real space process algebra, and characteristic examples are given for each of these.

article Free AccessDecidability of bisimulation equivalence for process generating context-free languages Authors: J. C. M. Baeten Univ. of Amsterdam, Amsterdam, The Netherlands Univ. of Amsterdam, Amsterdam, The NetherlandsView Profile , J. A. Bergstra Univ. of Amsterdam, Amsterdam, The Netherlands; and State Univ. of Utrecht, Utrecht, The Netherlands Univ. of Amsterdam, Amsterdam, The Netherlands; and State Univ. of Utrecht, Utrecht, The NetherlandsView Profile , J. W. Klop CWI, Amsterdam, The Netherlands; and Free Univ., Amsterdam, The Netherlands CWI, Amsterdam, The Netherlands; and Free Univ., Amsterdam, The NetherlandsView Profile Authors Info & Claims Journal of the ACMVolume 40Issue 3July 1993 pp 653–682https://doi.org/10.1145/174130.174141Published:01 July 1993Publication History 96citation724DownloadsMetricsTotal Citations96Total Downloads724Last 12 Months22Last 6 weeks7 Get Citation AlertsNew Citation Alert added!This alert has been successfully added and will be sent to:You will be notified whenever a record that you have chosen has been cited.To manage your alert preferences, click on the button below.Manage my AlertsNew Citation Alert!Please log in to your account Save to BinderSave to BinderCreate a New BinderNameCancelCreateExport CitationPublisher SiteeReaderPDF

Abstract We describe an axiom system ACP p that incorporates real timed actions. Many examples are provided in order to explain the intuitive contents of the notation. ACP p is a generalisation of ACP. This implies that some of the axioms have to be relaxed and that ACP can be recovered as a special case from it. The purpose of ACP p is to serve as a specification language for real time systems. The axioms of ACP p explain its operational meaning in an algebraic form.

An axiomatic algebraic calculus of modules is given that is based on the operators combination/union, export, renaming, and taking the visible signature . Four different models of module algebra are discussed and compared.

Readiness and failure semantics are studied in the setting of Algebra of Communicating Processes (ACP). A model of process graphs modulo readiness equivalence, respectively, failure equivalence, is constructed, and an equational axiom system is presented which is complete for this graph model. An explicit representation of the graph model is given, the failure model, whose elements are failure sets. Furthermore, a characterisation of failure equivalence is obtained as the maximal congruence which is consistent with trace semantics. By suitably restricting the communication format in ACP, this result is shown to carry over to subsets of Hoare’s Communicating Sequential Processes (CSP) and Milner’s Calculus of Communicating Systems (CCS). Also, the characterisation implies a full abstraction result for the failure model. In the above we restrict ourselves to finite processes without $\tau $-steps. At the end of the paper a comment is made on the situation for infinite processes with $\tau $-steps: notably we obtain that failure semantics is incompatible with Koomen’s fair abstraction rule, a proof principle based on the notion of bisimulation. This is remarkable because a weaker version of Koomen’s fair abstraction rule is consistent with (finite) failure semantics.

We consider a process semantics intermediate between bi-simulation semantics and readiness semantics, called here ready-trace semantics. The advantage of this semantics is that, while retaining the simplicity of readiness semantics, it is still possible to augment this process model with the mechanism of atomic actions with priority (the θ operator). It is shown that in readiness semantics and a fortiori in failure semantics such an extension with θ is impossible. Ready-trace semantics is considered here in the simple setting of concrete process algebra, that is: without abstraction (no silent moves), moreover for finite processes only. For such finite processes without silent moves a complete axiomatisation of ready-trace semantics is given via the method of process graph transformations.

We prove that those data types which may be defined by conditional equation specifications and final algebra semantics are exactly the cosemicomputable data types-those data types which are effectively computable, but whose inequality relations are recursively enumerable. And we characterize the computable data types as those data types which may be specified by conditional equation specifications using both initial algebra semantics and final algebra semantics. Numerical bounds for the number of auxiliary functions and conditional equations required are included in both theorems.

Summary A λ-theory T is a consistent set of equations between λ-terms closed under derivability. The degree of T is the degree of the set of Gödel numbers of its elements. is the λ-theory axiomatized by the set {M = N∣ M, N unsolvable}. A λ-theory is sensible iff T ⊃ ; for a motivation see [6] and [4]. In §1 it is proved that the theory is Σ20-complete. We present Wadsworth's proof that its unique maximal consistent extension * (= Th(D∞)) is Π20-complete. In §2 it is proved that η (= λη-calculus + ) is not closed under the ω-rule (see [1]). In §3 arguments are given to conjecture that is Π11-complete. This is done by representing recursive sets of sequence numbers as λ-terms and by connecting wellfoundedness of trees with provability in ω. In §4 an infinite set of equations independent over η will be constructed. From this it follows that there are 2ℵ0 sensible theories T such that and 2ℵ0 sensible hard models of arbitrarily high degrees. In §5 some nonprovability results needed in §§1 and 2 are established. For this purpose one uses the theory η extended with a reduction relation for which the Church–Rosser theorem holds. The concept of Gross reduction is used in order to show that certain terms have no common reduct.