Verifying the unification algorithm in LCF
Science of Computer Programming - Ellis Horwood series in artificial intelligence
Information and Computation - Semantics of Data Types
Programming in Martin-Lo¨f's type theory: an introduction
Programming in Martin-Lo¨f's type theory: an introduction
The ALF proof editor and its proof engine
TYPES '93 Proceedings of the international workshop on Types for proofs and programs
An Efficient Unification Algorithm
ACM Transactions on Programming Languages and Systems (TOPLAS)
Function Definition in Higher-Order Logic
TPHOLs '96 Proceedings of the 9th International Conference on Theorem Proving in Higher Order Logics
Nested General Recursion and Partiality in Type Theory
TPHOLs '01 Proceedings of the 14th International Conference on Theorem Proving in Higher Order Logics
Nested General Recursion and Partiality in Type Theory
TPHOLs '01 Proceedings of the 14th International Conference on Theorem Proving in Higher Order Logics
Type-Theoretic Functional Semantics
TPHOLs '02 Proceedings of the 15th International Conference on Theorem Proving in Higher Order Logics
Extracting General Recursive Program Schemes in Nuprl's Type Theory
LOPSTR '01 Selected papers from the 11th International Workshop on Logic Based Program Synthesis and Transformation
Modelling general recursion in type theory
Mathematical Structures in Computer Science
A coinductive monad for prop-bounded recursion
PLPV '07 Proceedings of the 2007 workshop on Programming languages meets program verification
Inductive and Coinductive Components of Corecursive Functions in Coq
Electronic Notes in Theoretical Computer Science (ENTCS)
General recursion in type theory
TYPES'02 Proceedings of the 2002 international conference on Types for proofs and programs
Partiality, state and dependent types
TLCA'11 Proceedings of the 10th international conference on Typed lambda calculi and applications
Filters on coinductive streams, an application to eratosthenes' sieve
TLCA'05 Proceedings of the 7th international conference on Typed Lambda Calculi and Applications
Recursive functions with higher order domains
TLCA'05 Proceedings of the 7th international conference on Typed Lambda Calculi and Applications
Hi-index | 0.00 |
General recursive algorithms are such that the recursive calls are performed on arguments satisfying no condition that guarantees termination. Hence, there is no direct way of formalising them in type theory.The standard way of handling general recursion in type theory uses a well-founded recursion principle. Unfortunately, this way of formalising general recursive algorithms often produces unnecessarily long and complicated codes. On the other hand, functional programming languages like Haskell impose no restrictions on recursive programs, and then writing general recursive algorithms is straightforward. In addition, functional programs are usually short and self-explanatory. However, the existing frameworks for reasoning about the correctness of Haskell-like programs are weaker than the framework provided by type theory.The goal of this work is to present a method that combines the advantages of both programming styles when writing simple general recursive algorithms. The method introduced here separates the computational and logical parts of the definition of an algorithm, which has several advantages. First, the resulting type-theoretic algorithms are compact and easy to understand; they are as simple as their Haskell versions. Second, totality is now a separate task and hence, this method can also be used in the formalisation of partial functions. Third, the method presented here also simplifies the task of formal verification. Finally, it can easily be extended to treat nested and mutual recursion.The main feature of the method is the introduction of an inductive predicate, specially defined for the algorithm to be formalised. This predicate can be thought of as characterising the set of inputs for which the algorithm terminates. It contains an introduction rule for each of the cases that need to be considered and provides an easy syntactic condition that guarantees the termination of the algorithm.