Results 1  10
of
47
Defining and reasoning about recursive functions: a practical tool for the coq proof assistant
 In Functional and Logic Programming (FLOPS’06), LNCS 3945
, 2006
"... practical tool for the Coq proof assistant ..."
(Show Context)
Cost Recurrences for DML Programs
, 2001
"... A cost recurrence describes an upper bound for the running time of a program in terms of the size of its input. Finding cost recurrences is a frequent intermediate step in complexity analysis, and this step requires an abstraction from data to data size. In this article, we use information contained ..."
Abstract

Cited by 22 (0 self)
 Add to MetaCart
(Show Context)
A cost recurrence describes an upper bound for the running time of a program in terms of the size of its input. Finding cost recurrences is a frequent intermediate step in complexity analysis, and this step requires an abstraction from data to data size. In this article, we use information contained in dependent types to achieve such an abstraction: Dependent ML (DML), a conservative extension of ML, provides dependent types that can be used to associate data with size information, thus describing a possible abstraction. We systematically extract cost recurrences from firstorder DML programs, guiding the abstraction from data to data size with information contained in DML type derivations.
Greedy regular expression matching
 Proc. of ICALP’04
, 2004
"... This paper studies the problem of matching sequences against regular expressions in order to produce structured values. ..."
Abstract

Cited by 18 (0 self)
 Add to MetaCart
This paper studies the problem of matching sequences against regular expressions in order to produce structured values.
Wellfounded Recursion with Copatterns A Unified Approach to Termination and Productivity
, 2013
"... In this paper, we study strong normalization of a core language based on System Fomega which supports programming with finite and infinite structures. Building on our prior work, finite data such as finite lists and trees are defined via constructors and manipulated via pattern matching, while infi ..."
Abstract

Cited by 15 (3 self)
 Add to MetaCart
In this paper, we study strong normalization of a core language based on System Fomega which supports programming with finite and infinite structures. Building on our prior work, finite data such as finite lists and trees are defined via constructors and manipulated via pattern matching, while infinite data such as streams and infinite trees is defined by observations and synthesized via copattern matching. In this work, we take a typebased approach to strong normalization by tracking size information about finite and infinite data in the type. This guarantees compositionality. More importantly, the duality of pattern and copatterns provide a unifying semantic concept which allows us for the first time to elegantly and uniformly support both wellfounded induction and coinduction by mere rewriting. The strong normalization proof is structured around Girard’s reducibility candidates. As such our system allows for nondeterminism and does not rely on coverage. Since System Fomega is general enough that it can be the target of compilation for the Calculus of Constructions, this work is a significant step towards representing observationcentric infinite data in proof assistants such as Coq and Agda.
Semicontinuous sized types and termination
 In Zoltán Ésik, editor, Computer Science Logic, 20th International Workshop, CSL 2006, 15th Annual Conference of the EACSL
"... Abstract. Some typebased approaches to termination use sized types: an ordinal bound for the size of a data structure is stored in its type. A recursive function over a sized type is accepted if it is visible in the type system that recursive calls occur just at a smaller size. This approach is onl ..."
Abstract

Cited by 15 (5 self)
 Add to MetaCart
(Show Context)
Abstract. Some typebased approaches to termination use sized types: an ordinal bound for the size of a data structure is stored in its type. A recursive function over a sized type is accepted if it is visible in the type system that recursive calls occur just at a smaller size. This approach is only sound if the type of the recursive function is admissible, i.e., depends on the size index in a certain way. To explore the space of admissible functions in the presence of higherkinded data types and impredicative polymorphism, a semantics is developed where sized types are interpreted as functions from ordinals into sets of strongly normalizing terms. It is shown that upper semicontinuity of such functions is a sufficient semantic criterion for admissibility. To provide a syntactical criterion, a calculus for semicontinuous functions is developed. 1.
Linear dependent types and relative completeness
 In LICS
, 2011
"... A system of linear dependent types for the lambda calculus with full higherorder recursion, called d`PCF, is introduced and proved sound and relatively complete. Completeness holds in a strong sense: d`PCF is not only able to precisely capture the functional behaviour of PCF programs (i.e. how the ..."
Abstract

Cited by 10 (5 self)
 Add to MetaCart
(Show Context)
A system of linear dependent types for the lambda calculus with full higherorder recursion, called d`PCF, is introduced and proved sound and relatively complete. Completeness holds in a strong sense: d`PCF is not only able to precisely capture the functional behaviour of PCF programs (i.e. how the output relates to the input) but also some of their intensional properties, namely the complexity of evaluating them with Krivine’s Machine. d`PCF is designed around dependent types and linear logic and is parametrized on the underlying language of index terms, which can be tuned so as to sacrifice completeness for tractability. 1
A Formalization of Strong Normalization for SimplyTyped LambdaCalculus and System F
 LFMTP 2006
, 2006
"... We formalize in the logical framework ATS/LF a proof based on Tait’s method that establishes the simplytyped lambdacalculus being strongly normalizing. In this formalization, we employ higherorder abstract syntax to encode lambdaterms and an inductive datatype to encode the reducibility predicat ..."
Abstract

Cited by 8 (0 self)
 Add to MetaCart
We formalize in the logical framework ATS/LF a proof based on Tait’s method that establishes the simplytyped lambdacalculus being strongly normalizing. In this formalization, we employ higherorder abstract syntax to encode lambdaterms and an inductive datatype to encode the reducibility predicate in Tait’s method. The resulting proof is particularly simple and clean when compared to previously formalized ones. Also, we mention briefly how a proof based on Girard’s method can be formalized in a similar fashion that establishes System F being strongly normalizing.
Refinement Types For Haskell
"... SMTbased checking of refinement types for callbyvalue languages is a wellstudied subject. Unfortunately, the classical translation of refinement types to verification conditions is unsound under lazy evaluation. When checking an expression, such systems implicitly assume that all the free var ..."
Abstract

Cited by 7 (4 self)
 Add to MetaCart
(Show Context)
SMTbased checking of refinement types for callbyvalue languages is a wellstudied subject. Unfortunately, the classical translation of refinement types to verification conditions is unsound under lazy evaluation. When checking an expression, such systems implicitly assume that all the free variables in the expression are bound to values. This property is trivially guaranteed by eager, but does not hold under lazy, evaluation. Thus, to be sound and precise, a refinement type system for Haskell and the corresponding verification conditions must take into account which subset of binders actually reduces to values. We present a stratified type system that labels binders as potentially diverging or not, and that (circularly) uses refinement types to verify the labeling. We have implemented our system in LIQUIDHASKELL and present an experimental evaluation of our approach on more than 10,000 lines of widely used Haskell libraries. We show that LIQUIDHASKELL is able to prove 96 % of all recursive functions terminating, while requiring a modest 1.7 lines of terminationannotations per 100 lines of code. 1.
N.: Automatic termination verification for higherorder functional programs (2013), http://wwwkb.is.s.utokyo.ac.jp/ ˜kuwahara/termination
"... Abstract. We present an automated approach to verifying termination of higherorder functional programs. Our approach adopts the idea from the recent work on termination verification via transition invariants (a.k.a. binary reachability analysis), and is fully automated. Our approach is able to sou ..."
Abstract

Cited by 7 (6 self)
 Add to MetaCart
(Show Context)
Abstract. We present an automated approach to verifying termination of higherorder functional programs. Our approach adopts the idea from the recent work on termination verification via transition invariants (a.k.a. binary reachability analysis), and is fully automated. Our approach is able to soundly handle the subtle aspects of higherorder programs, including partial applications, indirect calls, and ranking functions over function closure values. In contrast to the previous approaches to automated termination verification for functional programs, our approach is sound and complete, relative to the soundness and completeness of the underlying reachability analysis and ranking function inference. We have implemented a prototype of our approach for a subset of the OCaml language, and we have confirmed that it is able to automatically verify termination of some nontrivial higherorder programs. 1
Verifying termination and reduction properties about higherorder logic programs
 J. Autom. Reasoning
"... logic programs ..."
(Show Context)