48 research outputs found
The Heart of Intersection Type Assignment
This paper gives a new proof for the approximation theorem and the characterisation of normalisability using intersection types. The technique applied is to define reduction on derivations and to show a strong normalisation result for this reduction. From this result, the characterisation of strong normalisation and the approximation result will follow easily; the latter, in its turn, will lead to the characterisation of (head-)normalisability
The Heart of Intersection Type Assignment
This paper gives a new proof for the approximation theorem and the characterisation of normalisability using intersection types. The technique applied is to define reduction on derivations and to show a strong normalisation result for this reduction. From this result, the characterisation of strong normalisation and the approximation result will follow easily; the latter, in its turn, will lead to the characterisation of (head-)normalisability
Refinement Types as Higher Order Dependency Pairs
Refinement types are a well-studied manner of performing in-depth analysis on
functional programs. The dependency pair method is a very powerful method used
to prove termination of rewrite systems; however its extension to higher order
rewrite systems is still the object of active research. We observe that a
variant of refinement types allow us to express a form of higher-order
dependency pair criterion that only uses information at the type level, and we
prove the correctness of this criterion
The heart of intersection type assignment: Normalisation proofs revisited
AbstractThis paper gives a new proof for the approximation theorem and the characterisation of normalisability using intersection types for a system with âw and a â€-relation that is contra-variant over arrow types. The technique applied is to define reduction on derivations and to show a strong normalisation result for this reduction. From this result, the characterisation of strong normalisation and the approximation result will follow easily; the latter, in its turn, will lead to the characterisation of (head) normalisability
Resource control and intersection types: an intrinsic connection
In this paper we investigate the -calculus, a -calculus
enriched with resource control. Explicit control of resources is enabled by the
presence of erasure and duplication operators, which correspond to thinning and
con-traction rules in the type assignment system. We introduce directly the
class of -terms and we provide a new treatment of substitution by its
decompo-sition into atomic steps. We propose an intersection type assignment
system for -calculus which makes a clear correspondence between three
roles of variables and three kinds of intersection types. Finally, we provide
the characterisation of strong normalisation in -calculus by means of
an in-tersection type assignment system. This process uses typeability of
normal forms, redex subject expansion and reducibility method.Comment: arXiv admin note: substantial text overlap with arXiv:1306.228
Proof Theoretic Concepts for the Semantics of Types and Concurrency
We present a method for providing semantic interpretations for languages with a type system featuring inheritance polymorphism. Our approach is illustrated on an extension of the language Fun of Cardelli and Wegner, which we interpret via a translation into an extended polymorphic lambda calculus. Our goal is to interpret inheritances in Fun via coercion functions which are definable in the target of the translation. Existing techniques in the theory of semantic domains can be then used to interpret the extended polymorphic lambda calculus, thus providing many models for the original language. This technique makes it possible to model a rich type discipline which includes parametric polymorphism and recursive types as well as inheritance.
A central difficulty in providing interpretations for explicit type disciplines featuring inheritance in the sense discussed in this paper arises from the fact that programs can type-check in more than one way. Since interpretations follow the type-checking derivations, coherence theorems are required: that is, one must prove that the meaning of a program does not depend on the way it was type-checked. The proof of such theorems for our proposed interpretation are the basic technical results of this paper. Interestingly, proving coherence in the presence of recursive types, variants, and abstract types forced us to reexamine fundamental equational properties that arise in proof theory (in the form of commutative reductions) and domain theory (in the form of strict vs. non-strict functions)