5,367 research outputs found
Inductive and Coinductive Components of Corecursive Functions in Coq
In Constructive Type Theory, recursive and corecursive definitions are
subject to syntactic restrictions which guarantee termination for recursive
functions and productivity for corecursive functions. However, many terminating
and productive functions do not pass the syntactic tests. Bove proposed in her
thesis an elegant reformulation of the method of accessibility predicates that
widens the range of terminative recursive functions formalisable in
Constructive Type Theory. In this paper, we pursue the same goal for productive
corecursive functions. Notably, our method of formalisation of coinductive
definitions of productive functions in Coq requires not only the use of ad-hoc
predicates, but also a systematic algorithm that separates the inductive and
coinductive parts of functions.Comment: Dans Coalgebraic Methods in Computer Science (2008
Inversion, Iteration, and the Art of Dual Wielding
The humble ("dagger") is used to denote two different operations in
category theory: Taking the adjoint of a morphism (in dagger categories) and
finding the least fixed point of a functional (in categories enriched in
domains). While these two operations are usually considered separately from one
another, the emergence of reversible notions of computation shows the need to
consider how the two ought to interact. In the present paper, we wield both of
these daggers at once and consider dagger categories enriched in domains. We
develop a notion of a monotone dagger structure as a dagger structure that is
well behaved with respect to the enrichment, and show that such a structure
leads to pleasant inversion properties of the fixed points that arise as a
result. Notably, such a structure guarantees the existence of fixed point
adjoints, which we show are intimately related to the conjugates arising from a
canonical involutive monoidal structure in the enrichment. Finally, we relate
the results to applications in the design and semantics of reversible
programming languages.Comment: Accepted for RC 201
Tail recursion transformation for invertible functions
Tail recursive functions allow for a wider range of optimisations than
general recursive functions. For this reason, much research has gone into the
transformation and optimisation of this family of functions, in particular
those written in continuation passing style (CPS).
Though the CPS transformation, capable of transforming any recursive function
to an equivalent tail recursive one, is deeply problematic in the context of
reversible programming (as it relies on troublesome features such as
higher-order functions), we argue that relaxing (local) reversibility to
(global) invertibility drastically improves the situation. On this basis, we
present an algorithm for tail recursion conversion specifically for invertible
functions. The key insight is that functions introduced by program
transformations that preserve invertibility, need only be invertible in the
context in which the functions subject of transformation calls them. We show
how a bespoke data type, corresponding to such a context, can be used to
transform invertible recursive functions into a pair of tail recursive function
acting on this context, in a way where calls are highlighted, and from which a
tail recursive inverse can be straightforwardly extracted.Comment: Submitted to 15th Conference on Reversible Computation, 202
Combining Syntactic and Semantic Bidirectionalization
Matsuda et al. [2007, ICFP] and Voigtlander [2009, POPL] introduced two techniques that given a source-to-view function provide an update propagation function mapping an original source and an updated view back to an updated source, subject to standard consistency conditions. Being fundamentally different in approach, both
techniques have their respective strengths and weaknesses. Here we develop a synthesis of the two techniques to good effect. On the intersection of their applicability domains we achieve more than what a simple union of applying the techniques side by side deliver
A Falsification View of Success Typing
Dynamic languages are praised for their flexibility and expressiveness, but
static analysis often yields many false positives and verification is
cumbersome for lack of structure. Hence, unit testing is the prevalent
incomplete method for validating programs in such languages.
Falsification is an alternative approach that uncovers definite errors in
programs. A falsifier computes a set of inputs that definitely crash a program.
Success typing is a type-based approach to document programs in dynamic
languages. We demonstrate that success typing is, in fact, an instance of
falsification by mapping success (input) types into suitable logic formulae.
Output types are represented by recursive types. We prove the correctness of
our mapping (which establishes that success typing is falsification) and we
report some experiences with a prototype implementation.Comment: extended versio
General Recursion via Coinductive Types
A fertile field of research in theoretical computer science investigates the
representation of general recursive functions in intensional type theories.
Among the most successful approaches are: the use of wellfounded relations,
implementation of operational semantics, formalization of domain theory, and
inductive definition of domain predicates. Here, a different solution is
proposed: exploiting coinductive types to model infinite computations. To every
type A we associate a type of partial elements Partial(A), coinductively
generated by two constructors: the first, return(a) just returns an element
a:A; the second, step(x), adds a computation step to a recursive element
x:Partial(A). We show how this simple device is sufficient to formalize all
recursive functions between two given types. It allows the definition of fixed
points of finitary, that is, continuous, operators. We will compare this
approach to different ones from the literature. Finally, we mention that the
formalization, with appropriate structural maps, defines a strong monad.Comment: 28 page
- …