Results 1  10
of
13
A Coverage Checking Algorithm for LF
, 2003
"... Coverage checking is the problem of deciding whether any closed term of a given type is an instance of at least one of a given set of patterns. It can be used to verify if a function defined by pattern matching covers all possible cases. This problem has a straightforward solution for the first ..."
Abstract

Cited by 39 (12 self)
 Add to MetaCart
Coverage checking is the problem of deciding whether any closed term of a given type is an instance of at least one of a given set of patterns. It can be used to verify if a function defined by pattern matching covers all possible cases. This problem has a straightforward solution for the firstorder, simplytyped case, but is in general undecidable in the presence of dependent types. In this paper we present a terminating algorithm for verifying coverage of higherorder, dependently typed patterns.
Termination Checking with Types
, 1999
"... The paradigm of typebased termination is explored for functional programming with recursive data types. The article introduces , a lambdacalculus with recursion, inductive types, subtyping and bounded quanti cation. Decorated type variables representing approximations of inductive types ..."
Abstract

Cited by 28 (6 self)
 Add to MetaCart
The paradigm of typebased termination is explored for functional programming with recursive data types. The article introduces , a lambdacalculus with recursion, inductive types, subtyping and bounded quanti cation. Decorated type variables representing approximations of inductive types are used to track the size of function arguments and return values. The system is shown to be type safe and strongly normalizing. The main novelty is a bidirectional type checking algorithm whose soundness is established formally.
Tabled HigherOrder Logic Programming
 In 20th International Conference on Automated Deduction
, 2003
"... Elf is a general metalanguage for the specification and implementation of logical systems in the style of the logical framework LF. Based on a logic programming interpretation, it supports executing logical systems and reasoning with and about them, thereby reducing the effort required for each ..."
Abstract

Cited by 26 (11 self)
 Add to MetaCart
Elf is a general metalanguage for the specification and implementation of logical systems in the style of the logical framework LF. Based on a logic programming interpretation, it supports executing logical systems and reasoning with and about them, thereby reducing the effort required for each particular logical system. The traditional logic programming paradigm is extended by replacing firstorder terms with dependently typed terms and allowing implication and universal quantification in the bodies of clauses. These higherorder features allow us to model concisely and elegantly conditions on variables and the discharge of assumptions which are prevalent in many logical systems. However, many specifications are not executable under the traditional logic programming semantics and performance may be hampered by redundant computation. To address these problems, I propose a tabled higherorder logic programming interpretation for Elf. Some redundant computation is eliminated by memoizing subcomputation and reusing its result later. If we do not distinguish different proofs for a property, then search based on tabled logic programming is complete and terminates for programs with bounded recursion. In this proposal, I present a prooftheoretical characterization for tabled higherorder logic programming. It is the basis of the implemented prototype for tabled logic programming interpreter for Elf. Preliminary experiments indicate that many more logical specifications are executable under the tabled semantics. In addition, tabled computation leads to more efficient execution of programs. The goal of the thesis is to demonstrate that tabled logic programming allows us to efficiently automate reasoning with and about logical systems in the logical f...
Weak Normalization for the SimplyTyped LambdaCalculus in Twelf (Extended Abstract)
 In Logical Frameworks and Metalanguages (LFM 04), IJCAR
, 2004
"... Andreas Abel Department of Computer Science, Chalmers University of Technology Rannvagen 6, SWE41296 Goteborg, Sweden Abstract. Weak normalization for the simplytyped calculus is proven in Twelf, an implementation of the Edinburgh Logical Framework. Since due to prooftheoretical restrict ..."
Abstract

Cited by 11 (3 self)
 Add to MetaCart
Andreas Abel Department of Computer Science, Chalmers University of Technology Rannvagen 6, SWE41296 Goteborg, Sweden Abstract. Weak normalization for the simplytyped calculus is proven in Twelf, an implementation of the Edinburgh Logical Framework. Since due to prooftheoretical restrictions Twelf Tait's computability method does not seem to be directly usable, a combinatorical proof is adapted and formalized instead.
Delphin: Functional Programming with Deductive Systems
, 2002
"... We present the design and implementation of the strict and pure functional programming language Delphin. Its novel and distinctive features include a twolevel design that distinguishes cleanly between the tasks of representing data and programming with data. One level is the logical framework LF [5 ..."
Abstract

Cited by 6 (2 self)
 Add to MetaCart
We present the design and implementation of the strict and pure functional programming language Delphin. Its novel and distinctive features include a twolevel design that distinguishes cleanly between the tasks of representing data and programming with data. One level is the logical framework LF [5], serving as Delphin's data representation language. The other level is # [15], a type theory designed to support programming using pattern matching and recursion. The main contribution of this work is therefore Delphin, in which one can program with higherorder, dependentlytyped data structures such as proofs and typing derivations in a natural and intuitive way.
Verifying termination and reduction properties about higherorder logic programs
 J. Autom. Reasoning
"... logic programs ..."
A Monotonic HigherOrder Semantic Path Ordering
 Proc. of 8th Int. Conf. on Logic for Programming, Artificial Intelligence and Reasoning (LPAR'01) LNAI 2250:531547
, 2000
"... . There is an increasing use of (first and higherorder) rewrite rules in many programming languages and logical systems. The recursive path ordering (RPO) is a wellknown tool for proving termination of such rewrite rules in the firstorder case [Der82]. However, RPO has some weaknesses. For i ..."
Abstract

Cited by 5 (3 self)
 Add to MetaCart
. There is an increasing use of (first and higherorder) rewrite rules in many programming languages and logical systems. The recursive path ordering (RPO) is a wellknown tool for proving termination of such rewrite rules in the firstorder case [Der82]. However, RPO has some weaknesses. For instance, since it is a simplification ordering, it can only handle simply terminating systems. Several techniques have been developed for overcoming these weaknesses of RPO. A very recent such technique is the monotonic semantic path ordering (MSPO) [BFR00], a simple and easily automatizable ordering which generalizes other more adhoc methods. Another recent extension of RPO is its higherorder version HORPO [JR99]. HORPO is an ordering on terms of a typed lambdacalculus generated by a signature of higherorder function symbols. Althgough many interesting examples can be proved terminating using HORPO, it inherits the weaknesses of the firstorder RPO. Therefore, there is an obvious need for higherorder termination orderings without these weaknesses. Here we define the first such ordering, the monotonic higherorder semantic path ordering (MHOSPO), which is still automatizable like MSPO. We give evidence of its power by means of several natural and nontrivial examples which cannot be handled by HORPO. 1
Verifying Uniqueness in a Logical Framework
, 2004
"... We present an algorithm for verifying that some specified arguments of an inductively defined relation in a dependently typed # calculus are uniquely determined by some other arguments. We prove it correct and also show how to exploit this uniqueness information in coverage checking, which allo ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
We present an algorithm for verifying that some specified arguments of an inductively defined relation in a dependently typed # calculus are uniquely determined by some other arguments. We prove it correct and also show how to exploit this uniqueness information in coverage checking, which allows us to verify that a definition of a function or relation covers all possible cases. In combination, the two algorithms significantly extend the power of the metareasoning facilities of the Twelf implementation of LF.
Programming Languages and Systems Group
, 2005
"... Programs written in Haskell may fail at runtime with either a pattern match error, or with nontermination. Both of these can be thought of as giving the value ⊥ as a result. Other forms of failure, for example heap exhaustion, are not considered. The first section of this document reviews previous ..."
Abstract
 Add to MetaCart
Programs written in Haskell may fail at runtime with either a pattern match error, or with nontermination. Both of these can be thought of as giving the value ⊥ as a result. Other forms of failure, for example heap exhaustion, are not considered. The first section of this document reviews previous work, including total functional programming and sized types. Attention is paid to termination checkers for both Prolog and various functional languages. The main result from work so far is a static checker for pattern match errors that allows nonexhaustive patterns to exist, yet ensures that a pattern match error does not occur. It includes a constraint language that can be used to reason about pattern matches, along with mechanisms to propagate these constraints between program components. The proposal deals with future work to be done. It gives an approximate timetable for the design and implementation of a static checker for termination and pattern match errors.
Termination and Productivity Checking with Continuous Types
"... Abstract. We analyze the interpretation of inductive and coinductive types as sets of strongly normalizing terms and isolate classes of types with certain continuity properties. Our result enables us to relax some side conditions on the shape of recursive definitions which are accepted by the typeb ..."
Abstract
 Add to MetaCart
Abstract. We analyze the interpretation of inductive and coinductive types as sets of strongly normalizing terms and isolate classes of types with certain continuity properties. Our result enables us to relax some side conditions on the shape of recursive definitions which are accepted by the typebased termination calculus of Barthe, Frade, Giménez, Pinto and Uustalu, thus enlarging its expressivity. 1 Introduction and Related Work Interactive theorem provers like Coq [13], LEGO [20] and Twelf [18] support proofs by induction on finitedepth (inductive) structures (like natural numbers, lists, infinitely branching trees) and infinitedepth (coinductive) structures (like streams, processes, trees with infinite paths) in the form of recursive programs.