Wellfounded recursion with copatterns

Abel, Andreas; Pientka, Brigitte

doi:10.1145/2500365.2500591

Cited by 46 publications

(9 citation statements)

References 22 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…In [36], Uustalu and Vene advocated for the Mendler-style approach as being a more semantic approach to termination checking of total functional programs. We agree whole-heartedly, and consider as interesting future work the design of a high-level language with copatterns using the Mendler-style approach as the basis for productivity checking, similar to the use of sized types by Abel et al [2]. Indeed, Mendler-style recursion schemes were reported by Barthe et al [4] as the inspiration for type-based termination checking with sized types.…”

Section: Related and Future Worksupporting

confidence: 77%

Efficient lambda encodings for Mendler-style coinductive types in Cedille

Jenkins¹,

Stump²,

Diehl³

2020

Electron. Proc. Theor. Comput. Sci.

View full text Add to dashboard Cite

In the calculus of dependent lambda eliminations (CDLE), it is possible to define inductive datatypes via lambda encodings that feature constant-time destructors and a course-of-values induction scheme. This paper begins to address the missing derivations for the dual, coinductive types. Our derivation utilizes new methods within CDLE, as there are seemingly fundamental difficulties in adapting previous known approaches for deriving inductive types. The lambda encodings we present implementing coinductive types feature constant-time constructors and a course-of-values corecursion scheme. Coinductive type families are also supported, enabling proofs for many standard coinductive properties such as stream bisimulation. All work is mechanically verified by the Cedille tool, an implementation of CDLE.

show abstract

Section: Related and Future Worksupporting

confidence: 77%

Efficient lambda encodings for Mendler-style coinductive types in Cedille

Jenkins¹,

Stump²,

Diehl³

2020

Electron. Proc. Theor. Comput. Sci.

View full text Add to dashboard Cite

show abstract

“…Indeed it is well known that programming directly with coiteration is cumbersome and so most programming languages allow the programmer to construct elements of coinductive types using recursion. To guarantee productivity, one must use either the (non-modular) syntactic checks used in most proof assistants today, or sized types [Abel and Pientka 2013;Abel et al 2017;Hughes et al 1996;Sacchini 2013]. Given that the modal operator is in the language, guarded recursion is the most obvious solution to guaranteeing productivity.…”

Section: Introductionmentioning

confidence: 99%

Diamonds are not forever: liveness in reactive programming with guarded recursion

Bahr

Graulund

Møgelberg

2021

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

When designing languages for functional reactive programming (FRP) the main challenge is to provide the user with a simple, flexible interface for writing programs on a high level of abstraction while ensuring that all programs can be implemented efficiently in a low-level language. To meet this challenge, a new family of modal FRP languages has been proposed, in which variants of Nakano's guarded fixed point operator are used for writing recursive programs guaranteeing properties such as causality and productivity. As an apparent extension to this it has also been suggested to use Linear Temporal Logic (LTL) as a language for reactive programming through the Curry-Howard isomorphism, allowing properties such as termination, liveness and fairness to be encoded in types. However, these two ideas are in conflict with each other, since the fixed point operator introduces non-termination into the inductive types that are supposed to provide termination guarantees. In this paper we show that by regarding the modal time step operator of LTL a submodality of the one used for guarded recursion (rather than equating them), one can obtain a modal type system capable of expressing liveness properties while retaining the power of the guarded fixed point operator. We introduce the language Lively RaTT, a modal FRP language with a guarded fixed point operator and an `until' type constructor as in LTL, and show how to program with events and fair streams. Using a step-indexed Kripke logical relation we prove operational properties of Lively RaTT including productivity and causality as well as the termination and liveness properties expected of types from LTL. Finally, we prove that the type system of Lively RaTT guarantees the absence of implicit space leaks.

show abstract

“…Our termination criterion (rule for fix) is inspired by type-based termination [Abel 2004[Abel , 2007[Abel , 2008[Abel , 2012Abel and Pientka 2013;Barthe et al 2004]. Such work also typically uses two different kinds of recursion, one for induction and one for coinduction.…”

Section: Related Workmentioning

confidence: 99%

System FR: formalized foundations for the stainless verifier

Hamza

Voirol

Kunčak

2019

Proc. ACM Program. Lang.

View full text Add to dashboard Cite

We present the design, implementation, and foundation of a verifier for higher-order functional programs with generics and recursive data types. Our system supports proving safety and termination using preconditions, postconditions and assertions. It supports writing proof hints using assertions and recursive calls. To formalize the soundness of the system we introduce System FR, a calculus supporting System F polymorphism, dependent refinement types, and recursive types (including recursion through contravariant positions of function types). Through the use of sized types, System FR supports reasoning about termination of lazy data structures such as streams. We formalize a reducibility argument using the Coq proof assistant and prove the soundness of a type-checker with respect to call-by-value semantics, ensuring type safety and normalization for typeable programs. Our program verifier is implemented as an alternative verification-condition generator for the Stainless tool, which relies on the Inox SMT-based solver backend for automation. We demonstrate the efficiency of our approach by verifying a collection of higher-order functional programs comprising around 14000 lines of polymorphic higher-order Scala code, including graph search algorithms, basic number theory, monad laws, functional data structures, and assignments from popular Functional Programming MOOCs.

show abstract

Wellfounded recursion with copatterns

Cited by 46 publications

References 22 publications

Efficient lambda encodings for Mendler-style coinductive types in Cedille

Efficient lambda encodings for Mendler-style coinductive types in Cedille

Diamonds are not forever: liveness in reactive programming with guarded recursion

System FR: formalized foundations for the stainless verifier

Contact Info

Product

Resources

About