Results 1 
7 of
7
A partial formalisation of a dependently typed language as an inductiverecursive family
 IN PROCEEDINGS OF THE TYPES MEETING 2006
, 2007
"... It is demonstrated how a dependently typed lambda calculus (a logical framework) can be formalised inside a language with inductiverecursive families. The formalisation does not use raw terms; the welltyped terms are defined directly. It is hence impossible to create illtyped terms. As an exampl ..."
Abstract

Cited by 12 (0 self)
 Add to MetaCart
It is demonstrated how a dependently typed lambda calculus (a logical framework) can be formalised inside a language with inductiverecursive families. The formalisation does not use raw terms; the welltyped terms are defined directly. It is hence impossible to create illtyped terms. As an example of programming with strong invariants, and to show that the formalisation is usable, normalisation is proved. Moreover, this proof seems to be the first formal account of normalisation by evaluation for a dependently typed language.
Bigstep Normalisation
 UNDER CONSIDERATION FOR PUBLICATION IN J. FUNCTIONAL PROGRAMMING
, 2007
"... Traditionally, decidability of conversion for typed λcalculi is established by showing that smallstep reduction is confluent and strongly normalising. Here we investigate an alternative approach employing a recursively defined normalisation function which we show to be terminating and which reflec ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
Traditionally, decidability of conversion for typed λcalculi is established by showing that smallstep reduction is confluent and strongly normalising. Here we investigate an alternative approach employing a recursively defined normalisation function which we show to be terminating and which reflects and preserves conversion. We apply our approach to the simplytyped λcalculus with explicit substitutions and βηequality, a system which is not strongly normalising. We also show how the construction can be extended to System T with the usual βrules for the recursion combinator. Our approach is practical, since it does verify an actual implementation of normalisation which, unlike normalisation by evaluation, is first order. An important feature of our approach is that we are using logical relations to establish equational soundness (identity of normal forms reflects the equational theory), instead of the usual syntactic reasoning using the ChurchRosser property of a term rewriting system.
Hereditary substitutions for simple types, formalized
 In Proceedings of the third ACM SIGPLAN workshop on Mathematically structured functional programming, MSFP ’10
, 2010
"... We analyze a normalization function for the simply typed λcalculus based on hereditary substitutions, a technique developed by Pfenning et al. The normalizer is implemented in Agda, a total language where all programs terminate. It requires no termination proof since it is structurally recursive wh ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
We analyze a normalization function for the simply typed λcalculus based on hereditary substitutions, a technique developed by Pfenning et al. The normalizer is implemented in Agda, a total language where all programs terminate. It requires no termination proof since it is structurally recursive which is recognized by Agda’s termination checker. Using Agda as an interactive theorem prover we establish that our normalization function precisely identifies βηequivalent terms and hence can be used to decide βηequality. An interesting feature of this approach is that it is clear from the construction that βηequality is primitive recursive.
Author manuscript, published in "Mathematically Structured Functional Programming 2010 (2010)" Hereditary Substitutions for Simple Types, Formalized
, 2012
"... We analyze a normalization function for the simply typed λcalculus based on hereditary substitutions, a technique developed by Pfenning et al. The normalizer is implemented in Agda, a total language where all programs terminate. It requires no termination proof since it is structurally recursive wh ..."
Abstract
 Add to MetaCart
We analyze a normalization function for the simply typed λcalculus based on hereditary substitutions, a technique developed by Pfenning et al. The normalizer is implemented in Agda, a total language where all programs terminate. It requires no termination proof since it is structurally recursive which is recognized by Agda’s termination checker. Using Agda as an interactive theorem prover we establish that our normalization function precisely identifies βηequivalent terms and hence can be used to decide βηequality. An interesting feature of this approach is that it is clear from the construction that βηequality is primitive recursive.
Normalization by hereditary substitutions
"... We analyze a normalization function for the simply typed λcalculus based on hereditary substitutions, a technique developed by Pfenning et al. The normalizer is implemented in Agda, a total language where all programs terminate. It requires no termination proof since it is structurally recursive wh ..."
Abstract
 Add to MetaCart
We analyze a normalization function for the simply typed λcalculus based on hereditary substitutions, a technique developed by Pfenning et al. The normalizer is implemented in Agda, a total language where all programs terminate. It requires no termination proof since it is structurally recursive which is recognized by Agda’s termination checker. Using Agda as an interactive theorem prover we establish that our normalization function precisely identifies βηequivalent terms and hence can be used to decide βηequality. An interesting feature of this approach is that it is clear from the construction that βηequality is primitive recursive.
International Journal of Foundations of Computer Science c ○ World Scientific Publishing Company TERMINATION OF ABSTRACT REDUCTION SYSTEMS
"... Communicated by Editor’s name We present a general theorem capturing conditions required for the termination of abstract reduction systems. We show that our theorem generalises another similar general theorem about termination of such systems. We apply our theorem to give interesting proofs of termi ..."
Abstract
 Add to MetaCart
Communicated by Editor’s name We present a general theorem capturing conditions required for the termination of abstract reduction systems. We show that our theorem generalises another similar general theorem about termination of such systems. We apply our theorem to give interesting proofs of termination for typed combinatory logic. Thus, our method can handle most pathorderings in the literature as well as the reducibility method typically used for typed combinators. Finally we show how our theorem can be used to prove termination for incrementally defined rewrite systems, including an incremental general path ordering. All proofs have been formally machinechecked in Isabelle/HOL.
Functional Program Correctness Through Types
"... This thesis addresses the problem of avoiding errors in functional programs. The thesis has three parts, discussing different aspects of program correctness, with the unifying theme that types are an integral part of the methods used to establish correctness. The first part validates a common, but n ..."
Abstract
 Add to MetaCart
This thesis addresses the problem of avoiding errors in functional programs. The thesis has three parts, discussing different aspects of program correctness, with the unifying theme that types are an integral part of the methods used to establish correctness. The first part validates a common, but not obviously correct, method for reasoning about functional programs. In this method, dubbed “fast and loose reasoning”, programs written in a language with nonterminating functions are treated as if they were written in a total language. It is shown that fast and loose reasoning is sound when the programs are written in a given total subset of the language, and the resulting properties are translated back to the partial setting using certain partial equivalence relations which capture the concept of totality. The second part discusses a method for ensuring that functions meet specified time bounds. The method is aimed at implementations of purely