Generic proof systems like Isabelle provide some limited but useful metatheoretic facilities for declared logics; in particular, users can prove simple derived rules and also `solve' formulae that contain metavariables --- a technique useful for, e.g., program synthesis. We show how an arbitrary first order theory can be conservatively extended to provide similar facilities, without a supporting metatheory, and examine what the limitations of this approach are. Keywords: computer assisted proof, logical frameworks, metatheoretic extensibility, second-order logic, proof theory. 1 Introduction Using a generic proof development system like Isabelle [12] to prove theorems of a logic is sometimes easier than using a custom-built prover. This is because the generic system contains a metalogic in which object logics are encoded and this may allow extra methods of proof construction. In this paper we look at two examples of this. First, in the metalogic, users can derive new rules or...

This paper presents the type system of the Tool persistent programming language that captures much of the flavor of Smalltalk within a safe static typing discipline. Following the spirit of Smalltalk providing a highly flexible and extensible programming environment based on a small set of expressive language primitives, Tool provides only few built-in type concepts with rich semantics that achieve power through systematic use and orthogonality.

. OBJ--3 [GWM + 93] is a functional programming language with first-order function types. OBJ--3 has two special features: overloading of function symbols and the possibility to order the sorts. This ordering is induced by set inclusion on the carrier sets. We call the feature to be able to order the sorts inclusion set subtyping. The algebraic semantics of OBJ--3 is based on the theory of order-sorted algebras [GM89]. Furthermore, OBJ--3 allows parameterized programming [Gog90]. However, the concepts of higher-order functions and parametric polymorphism are only emulated by parameters of OBJ--3 modules. In this paper we show how to extend OBJ--3 by parametric polymorphism in an elegant way. We call this extended language OBJ--P. In the second part of the paper we describe the operational semantics of OBJ--P. The operational semantics is a translation of OBJ--P programs into programs without overloading and subtypes. Here, we improve the approaches of Goguen, Jouannaud, and Mesegu...

We propose to use order-sorted algebras (OSA) on multiple levels to describe languages together with their type systems. It is demonstrated that even advanced aspects can be modeled, including, parametric polymorphism, complex relationships between different sorts of an operation's rank, the specification of a variable number of parameters for operations, and type constructors using values (and not only types) as arguments. The basic idea is to use a signature to describe a type system where sorts denote sets of type names and operations denote type constructors. The values of an algebra for such a signature are then used as sorts of another signature now describing a language having the previously defined type system. This way of modeling is not restricted to two levels, and we will show useful applications of three-level algebras.

Our ultimate goal is to define a framework and a methodology which will allow users to construct or extend complex reasoning systems in such a way that the correctness of the resulting system is guaranteed. Our approach is based on the following principles: (i) construct the prover according to certain general (but precise) criteria, in particular maintain a sharp distinction among the logical, control, and interaction components; (ii) use a uniform framework to specify these three levels; (iii) represent (selected parts of) the code in a classical first order theory, use the inference capabilities of the system to reason deductively about this theory, and, as a result, synthesize new code which can be pushed back in the underlying implementation. This paper describes the approach, what we have done so far and how we intend to proceed to pursue our ultimate goal.

This is a collection of some more or less chaotic remarks on the ML type system, definitely not sufficient to fill a research paper of reasonable quality, but perhaps interesting enough to be written down as a note. At the beginning the idea was to investigate the complexity of type reconstruction and typability in bounded order fragments of ML. Unexpectedly the problem turned out to be hard, and finally I obtained only partial results. I do not feel like spending more time on this topic, so the text is not polished, the proofs --- if included at all --- are only sketched and of rather poor mathematical quality. I believe however, that some remarks, especially those of "philosophical" nature, shed some light on the ML type system and may be of some value to the reader interested especially in the interaction between theory and practice of ML type reconstruction. 1 Introduction The ML type system was developed by Robin Milner in the late seventies [26, 3], but was influenced by much ol...

This paper explores how certain ideas in object oriented languages have their correspondents in functional languages. In particular we look at the analogue of the iterators of the C++ standard template library. We also give an example of the use of constructor classes which feature in Haskell 1.3 and Gofer. 1 Introduction The combination of higher order and polymorphic functions in modern programming languages --- chiefly in functional languages, but increasingly in object-oriented languages as well --- makes them most suitable for software reuse. Polymorphism allows operations to be applied over whole classes of types, whilst function parameters mean that particular operations can be abstracted away, to be passed in as values on application. the first part of the paper provides a tutorial on this, in the Miranda 1 functional programming language. Beyond this `algorithmic' abstraction, there lies data abstraction: access to a particular type can be given (solely) through a signature...

This paper discusses the use of OBJ3's parameterized modules for higher order programming, giving examples beyond those in [8, 3, 4] and showing some capabilities that may seem surprising. We also discuss parameterized views, which are not yet implemented, but which we hope soon will be. We assume familiarity with [8], which appears as the first paper in this book

Abstract — High assurance systems have been defined as systems “you would bet your life on. ” This article discusses the application of a form of functional programming— what we call “monadic programming”—to the generation of high assurance and secure systems. Monadic programming languages leverage algebraic structures from denotational semantics and functional programming—monads—as a flexible, modular organizing principle for secure system design and implementation. Monadic programming languages are domain-specific functional languages that are both sufficiently expressive to express essential system behaviors and semantically straightforward to support formal verification. Fig. 1: A separation kernel mediates all inter-domain communication, thereby enforcing its security policy. The dotted arrow designates permitted information flows.

In this paper we develop an axiomatic approach to structured specifications in which both the underlying logical system and corresponding institution of the structured specifications are treated as abstract institutions, which means two levels of institution independence. This abstract axiomatic approach provides a uniform framework for the study of structured specifications independently from any actual choice of specification building operators, and moreover it unifies the theory and the model oriented approaches. Within this framework we develop concepts and results about ‘abstract structured specifications ’ such as co-limits, model amalgamation, compactness, interpolation, sound and complete proof theory, and pushout-style parameterization with sharing, all of them in a top down manner dictated by the upper level of institution independence. 1.