The need for subtyping in type-systems with dependent types has been realized for some years. But it is hard to prove that systems combining the two features have fundamental properties such as subject reduction. Here we investigate a subtyping extension of the system *P, which is an abstract version of the type system of the Edinburgh Logical Framework LF. By using an equivalent formulation, we establish some important properties of the new system *P^, including subject reduction. Our analysis culminates in a complete and terminating algorithm which establishes the decidability of type-checking.

We study the λΠΣS ≤ calculus, which contains singleton types S(M) classifying terms of base type provably equivalent to the term M. The system includes dependent types for pairs and functions (Σ and Π) and a subtyping relation induced by regarding singletons as subtypes of the base type. The decidability of type checking for this language is non-obvious, since to type check we must be able to determine equivalence of well-formed terms. But in the presence of singleton types, the provability of an equivalence judgment Γ ⊢ M1 ≡ M2: A can depend both on the typing context Γ and on the particular type A at which M1 and M2 are compared. We show how to prove decidability of term equivalence, hence of type checking, in λΠΣS ≤ by exhibiting a type-directed algorithm for directly computing normal forms. The correctness of normalization is shown using an unusual variant of Kripke logical relations organized around sets; rather than defining a logical equivalence relation, we work directly with (subsets of) the corresponding equivalence classes. We then provide a more efficient algorithm for checking type equivalence without constructing normal forms. We also show that type checking, subtyping, and all other judgments of the system are decidable.

We present a generalization of Java’s parametric polymorphism that enables parameterization of classes and methods by type constructors, i.e., functions from types to types. Our extension is formalized as a calculus called FGJω. It is implemented in a prototype compiler and its type system is proven safe and decidable. We describe and motivate our extension through two examples: the definition of generic data-types with binary methods and the definition of generalized algebraic datatypes. The formalization and the safety and decidability proofs are, for space reasons, only shortly described.

Constructor subtyping is a form of subtyping in which an inductive type is viewed as a subtype of another inductive type τ if τ has more constructors than. As suggested in [5, 12], its (potential) uses include proof assistants and functional programming languages. In this paper, we introduce and study the properties of a simply typed λ-calculus with record types and datatypes, and which supports record subtyping and constructor subtyping. In the first part of the paper, we show that the calculus is confluent and strongly normalizing. In the second part of the paper, we show that the calculus admits a well-behaved theory of canonical inhabitants, provided one adopts expansive extensionality rules, including-expansion, surjective pairing, and a suitable expansion rule for datatypes. Finally, in the third part of the paper, we extend our calculus with unbounded recursion and show that confluence is preserved.

. This paper shows that the subtyping relation of a higherorder lambda calculus, F ! , is anti-symmetric. It exhibits the rst such proof, establishing in the process that the subtyping relation is a partial order|reexive, transitive, and anti-symmetric up to -equality. While a subtyping relation is reexive and transitive by denition, anti-symmetry is a derived property. The result, which may seem obvious to the nonexpert, is technically challenging, and had been an open problem for almost a decade. In this context, typed operational semantics for subtyping oers a powerful new technology to solve the problem: of particular importance is our extended rule for the well-formedness of types with head variables. The paper also gives a presentation of F ! without a relation for -equality, apparently the rst such, and shows its equivalence with the traditional presentation. 1 Introduction Object-oriented programming languages such as Smalltalk, C++, Modula 3, and ...

This paper presents the proofs of the strong normalization, subject reduction, and Church-Rosser theorems for a presentation of the intuitionistic modal λ-calculus S4. It is adapted from Healfdene Goguen's thesis, where these properties are shown for the simply typed λ-calculus and for Luo's type theory UTT. Following this method, we introduce the notion of typed operational semantics for our system. We define a notion of typed substitution for our system, which has context stacks instead of the usual contexts. This latter peculiarity leads to the main diculties and consequently to the main original features in our proofs. The techniques elaborated in this work have already been found useful in recent works [DL98, DL99] and should be further exploited to prove the properties of other systems based on modality.

We present a calculus with dependent types, subtyping and late-bound overloading. Besides its theoretical interest this work is motivated by several practical needs that range from the definition of logic encodings, to proof specialization and reuse, and to object-oriented extension of the SML module system. The theoretical study of this calculus is not straightforward. While confluence is relatively easy to prove, subject reduction is much harder. We were not able to add overloading to any existing system with dependent types and subtyping, and prove subject reduction. This is why we also define here as by-product a new subtyping system for dependent types that improves previous systems and enjoys several properties (notably the transitivity elimination property). The calculus with overloading is then obtained as a conservative extension of this new system. Another difficult point is strong normalization, which is a necessary condition to the decidability of subtyping and typing relat...

This paper uses logical relations for the first time to study the decidability of typechecking and subtyping. The result is proved for F ! , a language with higher-order subtyping and bounded operator abstraction not previously known to be decidable. The proof is via an intermediate system called a typed operational semantics, leading to a powerful and uniform technique for showing metatheoretic results of type systems with subtyping, such as strong normalization, subject reduction and decidability of subtyping. 1 Introduction During the last decade, object-oriented programming languages such as Smalltalk, C++, Modula 3, and Java have become popular because they encourage and facilitate software reuse and abstract design. One attempt to give a theoretical understanding of these object-oriented programming languages has been to introduce type systems with features to model constructs from object-oriented programming languages [5, 7], for example bounded quantification [15] and recur...

Abstract not found

) Jan Zwanenburg janz@win.tue.nl, Eindhoven University of Technology, The Netherlands c fl Springer-Verlag Abstract. We extend the framework of Pure Type Systems with subtyping, as found in F ! . This leads to a concise description of many existing systems with subtyping, and also to some new interesting systems. We develop the meta-theory for this framework, including Subject Reduction and Minimal Typing. The main problem was how to formulate the rules of the framework in such a way that we avoid circularities between theory about typing and theory about subtyping. We solve this problem by a simple but rigorous design decision: the subtyping rules do not depend on the typing rules. 1 Introduction The Pure Type Systems (PTSs, see [Bar92]) provide a framework of type systems, in which many particular systems, such as F , F ! , P and the Calculus of Constructions can be concisely expressed and easily compared. Furthermore, the PTSs also include many new interesting sys...