TEA: Automatically Proving Termination of Programs in a Non-strict Higher-Order Functional Language

@inproceedings{Panitz1997TEAAP,
  title={TEA: Automatically Proving Termination of Programs in a Non-strict Higher-Order Functional Language},
  author={Sven Eric Panitz and Manfred Schmidt-Schau{\ss}},
  booktitle={SAS},
  year={1997}
}
We present TEA, a tool that is able to detect termination of functions written in a non-strict high-level functional programming language like Haskell. Since almost every compiler for lazy functional languages transforms programs into a functional core language, we use such a core language as the source language for the analysis. TEA is able to detect two kinds of termination: nf-termination and lazy termination. Intuitively, nf-termination of f means that given arguments ai in normal form, the… 

Automated Termination Analysis for Haskell: From Term Rewriting to Programming Languages

It is shown how termination techniques for ordinary rewriting can be used to handle those features of Haskell which are missing in term rewriting (e.g., lazy evaluation, polymorphic types, and higher-order functions).

Automated termination proofs for haskell by term rewriting

This work presents a new approach which permits the application of existing techniques from term rewriting to prove termination of most functions defined in Haskell programs and shows how termination techniques for ordinary rewriting can be used to handle those features of Haskell which are missing in term rewriting.

Termination Analysis by Inductive Evaluation ?

This paper develops the inductive evaluation method which analyzes the auxiliary functions occurring in the conditions of the recursive calls and extends it to partial functions in order to determine their domains automatically.

Termination Analysis by Inductive Evaluation

This paper develops the inductive evaluation method which analyzes the auxiliary functions occurring in the conditions of the recursive calls and extends it to partial functions in order to determine their domains automatically.

From Outermost Termination to Innermost Termination

All of the several techniques that have been developed to investigate innermost termination become applicable to analyze outermost termination of TRSs iff the transformed TRS is innermost terminating.

Ensuring Termination in ESFP

This work exhibits a powerful termination analysis technique which it is demonstrated can be extended to partial functions, and shows here that similar ideas can be applied in the dual case to check whether recursive function de nitions are strongly normalising.

The DP framework for proving termination of term rewriting

This thesis extends existing techniques and develops new methods for mechanized termination analysis of term rewrite systems and designs several novel techniques within the dependency pair framework, which can successfully be applied to prove termination of previously challenging programs.

Local Termination

The principal goal of this paper is generalizing the semantic characterization of global termination to local termination, made possible by admitting the well-founded monotone algebras to be partial.

Abstract Interpretation Based Formal Methods and Future Challenges

The main point is that in order to reason or compute about a complex system, some information must be lost, that is the observation of executions must be either partial or at a high level of abstraction.

References

SHOWING 1-10 OF 25 REFERENCES

Termination Analysis for Functional Programs using Term Orderings

This paper presents a procedure for automated termination proofs of functional programs in contrast to previously presented methods a suited well-founded ordering does not have to be fixed in advance by the user, but can be synthesized automatically.

Lazy functional languages - abstract interpretation and compilation

  • G. Burn
  • Computer Science
    Research monographs in parallel and distributed computing
  • 1991
A more efficient implementation model is described that can be used when information is known about how functions use their arguments, and a semantically sound analysis technique called abstract interpretation is developed, which can determine this information, and how to use the information to compile more efficient code for sequential and parallel machines.

Termination of Rewriting'

This survey describes methods for proving that systems of rewrite rules are terminating programs, including polynomial interpretations and path orderings, and illustrates the use in termination proofs of various kinds of orderings on terms.

Termination of Rewriting

Strictness and Totality Analysis

A novel inference system for strictness and totality analysis for the simplytyped lazy lambda-calculus with constants and fixpoints is defined, allowing conjunctions only at “top-level”.

Strictness analysis using abstract reduction

This paper presents a new and general strictness analysis technique for lazy functional languages that is practically usable and shows that the analyser is very fast and that it finds much strictness information.

Automatically Proving Termination Where Simplification Orderings Fail

There exist numerous interesting and relevant TRSs that cannot be oriented by orderings of this restricted class and therefore their termination cannot be proved automatically with the existing techniques.

Automatic Termination Proofs With Transformation Orderings

This work introduces an algorithm which automatically generates transformation orderings for many non-trivial systems including Hercules & hydra and sorting algorithms.

Abstract interpretation: a unified lattice model for static analysis of programs by construction or approximation of fixpoints

A program denotes computations in some universe of objects. Abstract interpretation of programs consists in using that denotation to describe computations in another universe of abstract objects, so

The implementation of the Gofer functional programming system

The main ideas and techniques used in the implementation of Gofer are described, to be particularly useful for work using Gofer as a platform to explore the use of new language features or primitives.