on the World Wide Web (\the Web") (www.cs.cornell.edu/Info/NuPrl/nuprl.html)

In this article we explain two di#erent operational interpretations of functional programs by two di#erent logics. The programs are simply typed #-terms with pairs, projections, if-then-else, and least fixed point recursion. A logic for call-by-value evaluation and a logic for call-byname evaluation are obtained as as extensions of a system which we call the basic logic of partial terms (BPT). This logic is suitable to prove properties of programs that are valid under both strict and non-strict evaluation. We use methods from denotational semantics to show that the two extensions of BPT are adequate for call-by-value and call-byname evaluation. Neither the programs nor the logics contain the constant `undefined'. 1

In this paper we develop mathematically strong systems of analysis in higher types which, nevertheless, are proof-theoretically weak, i.e. conservative over elementary resp. primitive recursive arithmetic. These systems are based on non-collapsing hierarchies ( n -WKL+ ; n -WKL+ ) of principles which generalize (and for n = 0 coincide with) the so-called `weak' Konig's lemma WKL (which has been studied extensively in the context of second order arithmetic) to logically more complex tree predicates. Whereas the second order context used in the program of reverse mathematics requires an encoding of higher analytical concepts like continuous functions F : X ! Y between Polish spaces X;Y , the more exible language of our systems allows to treat such objects directly. This is of relevance as the encoding of F used in reverse mathematics tacitly yields a constructively enriched notion of continuous functions which e.g. for F : IN ! IN can be seen (in our higher order context) Basic Research in Computer Science, Centre of the Danish National Research Foundation.

this paper we introduce a variable typed logic of effects (i.e. a logic of effects where classes can be defined and quantified over) inspired by the variable type systems of Feferman [3, 4] for purely functional languages. A similar extension incorporating non-local control operations was introduced in [27]. The logic we present provides an expressive language for defining specifications and constraints and for studying properties and program equivalences, in a uniform framework. Thus it has an advantage over a plethora of systems in the literature that aim to capture solitary aspects of computation. The theory also allows for the construction of inductively defined sets and derivation of the corresponding induction principles. Classes can be used to express, inter alia, the non-expansiveness of terms [29]. Other effects can also be represented within the system. These include read/write effects and various forms of interference [24]. The first order fragment is described in [16] where it is used to resolve the denotationally problematic examples of [17]. In our language atoms, references and lambda abstractions are all first class values and as such are storable. This has several consequences. Firstly, mutation and variable binding are separate and so we avoid the problems that typically arise (e.g. in Hoare's and dynamic logic) from the conflation of program variables and logical variables. Secondly, the equality and sharing of references (aliasing) is easily expressed and reasoned about. Thirdly, the combination of mutable references and lambda abstractions allows us to study object based programming within our framework. Our atomic formulas express the (operational or observational) equivalence of programs `a la Plotkin [23]. Neither Hoare's logic nor Dynamic logi...

Constructive type theory as conceived by Per Martin-Löf has a very rich type system, but partial functions cannot be typed. This also makes it impossible to directly write recursive programs. In this paper a constructive type theory Red is defined which includes a partial type constructor A; objects in the type A may diverge, but if they converge, they must be members of A. A fixed point typing principle is given to allow typing of recursive functions. The extraction paradigm of type theory, whereby programs are automatically extracted from constructive proofs, is extended to allow extraction of fixed points. There is a Scott fixed point induction principle for reasoning about these functions. Soundness of the theory is proven. Type theory becomes a more expressive programming logic as a result.

This paper deals with: (i) the theory ID # 1 which results from c ID 1 by restricting induction on the natural numbers to formulas which are positive in the fixed point constants, (ii) the theory BON() plus various forms of positive induction, and (iii) a subtheory of Peano arithmetic with ordinals in which induction on the natural numbers is restricted to formulas which are \Sigma in the ordinals. We show that these systems have proof-theoretic strength '!0.

This paper deals with universes in explicit mathematics. After introducing some basic definitions, the limit axiom and possible ordering principles for universes are discussed. Later, we turn to least universes, strictness and name induction. Special emphasis is put on theories for explicit mathematics with universes which are proof-theoretically equivalent to Feferman's T 0 . 1 Introduction In some form or another, universes play an important role in many systems of set theory and higher order arithmetic, in various formalizations of constructive mathematics and in logics for computation. One aspect of universes is that they expand the set or type formation principles in a natural and perspicuous way and provide greater expressive power and proof-theoretic strength. The general idea behind universes is quite simple: suppose that we are given a formal system Th comprising certain set (or type) existence principles which are justified on specific philosophical grounds. Then it may be a...

Would ye both eat your cake and have your cake?

. In this paper we describe progress towards a theory of tranformational program development. The transformation rules are based on a theory of contextual equivalence for functional languages with imperative features. Such notions of equivalence are fundamental for the process of program specification, derivation, transformation, refinement and other forms of code generation and optimization. This paper is dedicated to Professor Satoru Takasu. 1 Introduction This paper describes progress towards a theory of program development by systematic refinement beginning with a clean simple program thought of as a specification. Transformations include reuse of storage, and re-representation of abstract data. The transformation rules are based on a theory of constrained equivalence for functional languages with imperative features (i.e. Lisp, Scheme or ML). Such notions of equivalence are fundamental for the process of program specification, derivation, transformation, refinement, and other for...

. We introduce two logics for partiality, a call-by-value logic and a call-by-name logic. Both logics are variants of the logic of partial terms, an extension of the first-order predicate calculus by a definedness predicate. In our logics, however, quantifiers may only be instantiated to value terms and not to arbitrary, defined terms as in the logic of partial terms. We show that the call-by-value logic is computationally adequate for call-by-value evaluation, whereas the call-by-name logic has the same property for call-by-name evaluation. In order to relate the call-by-value logic to partial combinatory logic, we introduce a new lambda abstraction for terms of partial combinatory logic which has better properties than the one used previously. 1