67 research outputs found
Strong normalisation for applied lambda calculi
We consider the untyped lambda calculus with constructors and recursively
defined constants. We construct a domain-theoretic model such that any term not
denoting bottom is strongly normalising provided all its `stratified
approximations' are. From this we derive a general normalisation theorem for
applied typed lambda-calculi: If all constants have a total value, then all
typeable terms are strongly normalising. We apply this result to extensions of
G\"odel's system T and system F extended by various forms of bar recursion for
which strong normalisation was hitherto unknown.Comment: 14 pages, paper acceptet at electronic journal LMC
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
Equations for Hereditary Substitution in Leivant's Predicative System F: A Case Study
This paper presents a case study of formalizing a normalization proof for
Leivant's Predicative System F using the Equations package. Leivant's
Predicative System F is a stratified version of System F, where type
quantification is annotated with kinds representing universe levels. A weaker
variant of this system was studied by Stump & Eades, employing the hereditary
substitution method to show normalization. We improve on this result by showing
normalization for Leivant's original system using hereditary substitutions and
a novel multiset ordering on types. Our development is done in the Coq proof
assistant using the Equations package, which provides an interface to define
dependently-typed programs with well-founded recursion and full dependent
pattern- matching. Equations allows us to define explicitly the hereditary
substitution function, clarifying its algorithmic behavior in presence of term
and type substitutions. From this definition, consistency can easily be
derived. The algorithmic nature of our development is crucial to reflect
languages with type quantification, enlarging the class of languages on which
reflection methods can be used in the proof assistant.Comment: In Proceedings LFMTP 2015, arXiv:1507.07597. www:
http://equations-fpred.gforge.inria.fr
Transformation of structure-shy programs : applied to XPath queries and strategic functions
Various programming languages allow the construction of structure-shy programs. Such programs are defined generically for many different datatypes and only specify specific behavior for a few relevant subtypes. Typical examples are XML query languages that allow selection of subdocuments without exhaustively specifying intermediate element tags. Other examples are languages and libraries for polytypic or strategic functional programming and for adaptive object-oriented programming. In this paper, we present an algebraic approach to transformation of declarative structure-shy programs, in particular for strategic functions and XML queries. We formulate a rich set of algebraic laws, not just for transformation of structure-shy programs, but also for their conversion into structure-sensitive programs and vice versa. We show how subsets of these laws can be used to construct effective rewrite systems for specialization, generalization, and optimization of structure-shy programs. We present a type-safe encoding of these rewrite systems in Haskell which itself uses strategic functional programming techniques.(undefined
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)
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
Transformation of structure-shy programs with application to XPath queries and strategic functions
Various programming languages allow the construction of structure-shy programs. Such programs are defined generically for many different datatypes and only specify specific behavior for a few relevant subtypes. Typical examples are XML query languages that allow selection of subdocuments without exhaustively specifying intermediate element tags. Other examples are languages and libraries for polytypic or strategic functional programming and for adaptive object-oriented programming.
In this paper, we present an algebraic approach to transformation of declarative structure-shy programs, in particular for strategic functions and XML queries. We formulate a rich set of algebraic laws, not just for transformation of structure-shy programs, but also for their conversion into structure-sensitive programs and vice versa. We show how subsets of these laws can be used to construct effective rewrite systems for specialization, generalization, and optimization of structure-shy programs. We present a type-safe encoding of these rewrite systems in Haskell which itself uses strategic functional programming techniques. We discuss the application of these rewrite systems for XPath query optimization and for query migration in the context of schema evolution
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
- âŠ