Free theorems for functional logic programs

Christiansen, Jan; Seidel, Daniel; Voigtländer, Janis

doi:10.1145/1707790.1707797

Cited by 9 publications

(9 citation statements)

References 24 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Using function types of the form M (M τ → M τ ) is in particular important, when modeling a functional logic language. For example, some free theorems fail in the context of functional logic languages due to the difference between a non-deterministic choice of two functions and a function that non-deterministically yields two results as shown by Christiansen et al [7] and elaborated by Mehner et al [22]. Mona wanted to use her framework for a variety of effects, thus, the optimized translation of function types used by Abel et al [1] was not applicable anymore.…”

Section: The Endmentioning

confidence: 99%

“…The function fold free was only a means to an end. Mona defined the function induce, which lifts a function that maps the functor F to the corresponding monad M 6 to a homomorphism between the free monad and the corresponding monad 7 .…”

Section: If You Are Keen To Know How Mona Translated These Functions ...mentioning

confidence: 99%

“…The monad M is equipped with the functions ret and join 7. Mona had to pass the type argument M A to the higher-ranked functional argument f used in the application of join because Coq was not able to infer it.…”

mentioning

confidence: 99%

See 2 more Smart Citations

One Monad to Prove Them All

Dylus¹,

Christiansen

Teegen

2019

Programming

Self Cite

View full text Add to dashboard Cite

One Monad to Prove Them All is a modern fairy tale about curiosity and perseverance, two important properties of a successful PhD student. We follow the PhD student Mona on her adventure of proving properties about Haskell programs in the proof assistant Coq.On the one hand, as a PhD student in computer science Mona observes an increasing demand for correct software products. In particular, because of the large amount of existing software, verifying existing software products becomes more important. Verifying programs in the functional programming language Haskell is no exception. On the other hand, Mona is delighted to see that communities in the area of theorem proving are becoming popular. Thus, Mona sets out to learn more about the interactive theorem prover Coq and verifying Haskell programs in Coq.To prove properties about a Haskell function in Coq, Mona has to translate the function into Coq code. As Coq programs have to be total and Haskell programs are often not, Mona has to model partiality explicitly in Coq. In her quest for a solution Mona finds an ancient manuscript that explains how properties about Haskell functions can be proven in the proof assistant Agda by translating Haskell programs into monadic Agda programs. By instantiating the monadic program with a concrete monad instance the proof can be performed in either a total or a partial setting. Mona discovers that the proposed transformation does not work in Coq due to a restriction in the termination checker. In fact the transformation does not work in Agda anymore as well, as the termination checker in Agda has been improved.We follow Mona on an educational journey through the land of functional programming where she learns about concepts like free monads and containers as well as basics and restrictions of proof assistants like Coq. These concepts are well-known individually, but their interplay gives rise to a solution for Mona's problem based on the originally proposed monadic tranformation that has not been presented before. When Mona starts to test her approach by proving a statement about simple Haskell functions, she realizes that her approach has an additional advantage over the original idea in Agda. Mona's final solution not only works for a specific monad instance but even allows her to prove monad-generic properties. Instead of proving properties over and over again for specific monad instances she is able to prove properties that hold for all monads representable by a container-based instance of the free monad. In order to strengthen her confidence in the practicability of her approach, Mona evaluates her approach in a case study that compares two implementations for queues. In order to share the results with other functional programmers the fairy tale is available as a literate Coq file.If you are a citizen of the land of functional programming or are at least familiar with its customs, had a journey that involved reasoning about functional programs of your own, or are just a curious soul looking for the next story about monads ...

show abstract

Section: The Endmentioning

confidence: 99%

Section: If You Are Keen To Know How Mona Translated These Functions ...mentioning

confidence: 99%

See 1 more Smart Citation

One Monad to Prove Them All

Dylus¹,

Christiansen

Teegen

2019

Programming

Self Cite

View full text Add to dashboard Cite

show abstract

“…Last but not least, we see an opportunity to apply ideas and solutions of the functional logic paradigm in probabilistic programming. For instance, Christiansen et al (Christiansen et al 2010) investigate free theorems for functional logic programs. As their work considers nondeterminism and sharing, adapting it to probabilistic programming should be easy.…”

Section: Related and Future Workmentioning

confidence: 99%

Implementing a Library for Probabilistic Programming Using Non-strict Non-determinism

Dylus¹,

Christiansen²,

Teegen³

2019

Theory and Practice of Logic Programming

Self Cite

View full text Add to dashboard Cite

This paper presents PFLP, a library for probabilistic programming in the functional logic programming language Curry. It demonstrates how the concepts of a functional logic programming language support the implementation of a library for probabilistic programming. In fact, the paradigms of functional logic and probabilistic programming are closely connected. That is, language characteristics from one area exist in the other and vice versa. For example, the concepts of non-deterministic choice and call-time choice as known from functional logic programming are related to and coincide with stochastic memoization and probabilistic choice in probabilistic programming, respectively. We will further see that an implementation based on the concepts of functional logic programming can have benefits with respect to performance compared to a standard list-based implementation and can even compete with full-blown probabilistic programming languages, which we illustrate by several benchmarks. Under consideration in Theory and Practice of Logic Programming (TPLP). KEYWORDS: probabilistic programming, functional logic programming, non-determinism, laziness, calltime choice * This is an extended version of a paper presented at the International Symposium on Practical Aspects of Declarative Languages (PADL 2018), invited as a rapid communication in TPLP. The authors acknowledge the assistance of the conference program chairs Nicola Leone and Kevin Hamlen. 14 We use version 2.7.10 of Python.

show abstract

“…These efforts are motivated by the fact that parametricity is used to justify the soundness of some important compiler optimizations, like the 'short-cut deforestation' of GHC (GHC-Team 2011) -although it is admitted that seq still makes this particular transformation unsound (Hudak et al 2007). Regarding FLP, it is known that non-determinism not only breaks free theorems, but also equational rules for concrete functions that hold for Haskell, like (filter p) (Christiansen et al 2010). The situation gets even worse when considering extra variables and narrowing -not treated in the present work but standard in FLP systems -because then the function f above could also introduce a free variable in its resulting list, thus breaking the equivalence from a new side wrt Haskell, as in FLP free variables may produce interesting values in contrast to loop and fail.…”

Section: Loss Of Parametricitymentioning

confidence: 99%

A liberal type system for functional logic programs

López-Fraguas¹,

Martin-Martin²,

Rodríguez-Hortalá³

2014

Math. Struct. Comp. Sci.

View full text Add to dashboard Cite

We propose a new type system for functional logic programming which is more liberal than the classical Damas-Milner usually adopted, but it is also restrictive enough to ensure type soundness. Starting from Damas-Milner typing of expressions, we propose a new notion of well-typed program that adds support for type-indexed functions, a particular form of existential types, opaque higher-order patterns and generic functions -as shown by an extensive collection of examples that illustrate the possibilities of our proposal. In the negative side, the types of functions must be declared, and therefore types are checked but not inferred. Another consequence is that parametricity is lost, although the impact of this flaw is limited as 'free theorems' were already compromised in functional logic programming because of non-determinism. † This work has been partially supported by the Spanish projects STAMP (TIN2008-06622-C03-01), Prometidos-CM (S2009TIC-1465) and GPD (UCM-BSCH-GR35/10-A-910502). † As mentioned in Section 1, patterns in our setting (both first and higher order patterns) are treated in a purely syntactic way, so syntactic unification is used instead of more complex HO unification procedures.

show abstract

Free theorems for functional logic programs

Cited by 9 publications

References 24 publications

One Monad to Prove Them All

One Monad to Prove Them All

Implementing a Library for Probabilistic Programming Using Non-strict Non-determinism

A liberal type system for functional logic programs

Contact Info

Product

Resources

About