Results 1  10
of
19
From coinductive proofs to exact real arithmetic
"... Abstract. We give a coinductive characterisation of the set of continuous functions defined on a compact real interval, and extract certified programs that construct and combine exact real number algorithms with respect to the binary signed digit representation of real numbers. The data type corresp ..."
Abstract

Cited by 20 (7 self)
 Add to MetaCart
(Show Context)
Abstract. We give a coinductive characterisation of the set of continuous functions defined on a compact real interval, and extract certified programs that construct and combine exact real number algorithms with respect to the binary signed digit representation of real numbers. The data type corresponding to the coinductive definition of continuous functions consists of finitely branching nonwellfounded trees describing when the algorithm writes and reads digits. This is a pilot study in using prooftheoretic methods for obtaining certified algorithms in exact real arithmetic. 1
Fixed points of type constructors and primitive recursion
 Computer Science Logic, 18th International Workshop, CSL 2004, 13th Annual Conference of the EACSL, Karpacz, Poland, September 2024, 2004, Proceedings, volume 3210 of Lecture Notes in Computer Science
, 2004
"... Our contribution to CSL 04 [AM04] contains a little error, which is easily corrected by 2 elementary editing steps (replacing one character and deleting another). Definition of wellformed contexts (fifth page). Typing contexts should, in contrast to kinding contexts, only contain type variable decla ..."
Abstract

Cited by 9 (3 self)
 Add to MetaCart
(Show Context)
Our contribution to CSL 04 [AM04] contains a little error, which is easily corrected by 2 elementary editing steps (replacing one character and deleting another). Definition of wellformed contexts (fifth page). Typing contexts should, in contrast to kinding contexts, only contain type variable declarations without variance information. Hence, the second rule is too liberal; we must insist on p = ◦. The corrected set of rules is then: ⋄ cxt ∆ cxt ∆, X ◦κ cxt ∆ cxt ∆ ⊢ A: ∗ ∆, x:A cxt Definition of welltyped terms (immediately following). Since wellformed typing contexts ∆ contain no variance information, hence ◦ ∆ = ∆, we might drop the “◦ ” in the instantiation rule (fifth rule). The new set of rules is consequently, (x:A) ∈ ∆ ∆ cxt ∆ ⊢ x: A ∆, X ◦κ ⊢ t: A ∆ ⊢ t: ∀X κ. A ∆, x:A ⊢ t: B ∆ ⊢ λx.t: A → B ∆ ⊢ t: ∀X κ. A ∆ ⊢ F: κ
Representing Cyclic Structures as Nested Datatypes
"... We show that cyclic structures, i.e., finite or possibly infinite structures with backpointers, unwindable into possibly infinite structures, can be elegantly represented as nested datatypes. This representation is free of the various deficiencies characterizing the more naive representation as mixe ..."
Abstract

Cited by 9 (3 self)
 Add to MetaCart
(Show Context)
We show that cyclic structures, i.e., finite or possibly infinite structures with backpointers, unwindable into possibly infinite structures, can be elegantly represented as nested datatypes. This representation is free of the various deficiencies characterizing the more naive representation as mixedvariant datatypes. It is inspired by the representation of lambdaterms as a nested datatype via the de Bruijn notation. 1
Realisability and adequacy for (co)induction
"... Abstract. We prove the correctness of a formalised realisability interpretation of extensions of firstorder theories by inductive and coinductive definitions in an untyped λcalculus with fixedpoints. We illustrate the use of this interpretation for program extraction by some simple examples in th ..."
Abstract

Cited by 4 (4 self)
 Add to MetaCart
Abstract. We prove the correctness of a formalised realisability interpretation of extensions of firstorder theories by inductive and coinductive definitions in an untyped λcalculus with fixedpoints. We illustrate the use of this interpretation for program extraction by some simple examples in the area of exact real number computation, and hint at further nontrivial applications in computable analysis. 1
Recursion on nested datatypes in dependent type theory
 Logic and Theory of Algorithms. Volume 5028 of Lecture Notes in Computer Science
, 2008
"... Abstract. Nested datatypes are families of datatypes that are indexed over all types and where the datatype constructors relate different members of the family. This may be used to represent variable binding or to maintain certain invariants through typing. In dependent type theory, a major concern ..."
Abstract

Cited by 3 (1 self)
 Add to MetaCart
(Show Context)
Abstract. Nested datatypes are families of datatypes that are indexed over all types and where the datatype constructors relate different members of the family. This may be used to represent variable binding or to maintain certain invariants through typing. In dependent type theory, a major concern is the termination of all expressible programs, so that types that depend on object terms can still be typechecked mechanically. Therefore, we study iteration and recursion schemes that have this termination guarantee throughout. This is not based on syntactic criteria (recursive calls with “smaller ” arguments) but just on types (“typebased termination”). An important concern are reasoning principles that are compatible with the ambient type theory, in our case induction principles. In previous work, the author has proposed an abstract description of nested datatypes together with a mapping operation (like map for lists) and an iterator on the term side and an induction principle on the logical side that could all be implemented within the Coq system (with impredicative Set that is just needed for the justification, not for the definition and the examples). For verification purposes, it is important to have naturality theorems for the obtained iterative functions. Although intensional type theory does not provide naturality in general, criteria for naturality could be established that are met in case studies on “bushes” and representations of lambda terms (also with explicit flattening). The new contribution is an extension of this abstract description to full primitive recursion and its illustration by way of examples that have been carried out in Coq. Unlike the iterative system, we do not yet have a justification within Coq. 1
Verification of the Redecoration Algorithm for Triangular Matrices
, 2007
"... Abstract. Triangular matrices with a dedicated type for the diagonal elements can be profitably represented by a nested datatype, i. e., a heterogeneous family of inductive datatypes. These families are fully supported since the version 8.1 of the Coq theorem proving environment, released in 2007. R ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
(Show Context)
Abstract. Triangular matrices with a dedicated type for the diagonal elements can be profitably represented by a nested datatype, i. e., a heterogeneous family of inductive datatypes. These families are fully supported since the version 8.1 of the Coq theorem proving environment, released in 2007. Redecoration of triangular matrices has a succinct implementation in this representation, thus giving the challenge of proving it correct. This has been achieved within Coq, using also induction with measures. An axiomatic approach allowed a verification in the Isabelle theorem prover, giving insights about the differences of both systems. 1
Program extraction via typed realisability for induction and coinduction
, 2009
"... and coinduction ..."
Realisability for induction and coinduction with applications to constructive analysis
 J. Univers. Comput. Sci
, 2010
"... Abstract: We prove the correctness of a formalised realisability interpretation of extensions of firstorder theories by inductive and coinductive definitions in an untyped λcalculus with fixedpoints. We illustrate the use of this interpretation for program extraction by some simple examples in th ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
Abstract: We prove the correctness of a formalised realisability interpretation of extensions of firstorder theories by inductive and coinductive definitions in an untyped λcalculus with fixedpoints. We illustrate the use of this interpretation for program extraction by some simple examples in the area of exact real number computation and hint at further nontrivial applications in computable analysis.
A foundation for GADTs and inductive families: dependent polynomial functor approach
 In WGP’11
, 2011
"... Every Algebraic Datatype (ADT) is characterised as the initial algebra of a polynomial functor on sets. This paper extends the characterisation to the case of more advanced datatypes: Generalised Algebraic Datatypes (GADTs) and Inductive Families. Specifically, we show that GADTs and Inductive Fa ..."
Abstract

Cited by 1 (0 self)
 Add to MetaCart
(Show Context)
Every Algebraic Datatype (ADT) is characterised as the initial algebra of a polynomial functor on sets. This paper extends the characterisation to the case of more advanced datatypes: Generalised Algebraic Datatypes (GADTs) and Inductive Families. Specifically, we show that GADTs and Inductive Families are characterised as initial algebras of dependent polynomial functors. The theoretical tool we use throughout is an abstract notion of polynomial between sets together with its associated general form of polynomial functor between categories of indexed sets introduced by Gambino and Hyland. In the context of ADTs, this fundamental result is the basis for various generic functional programming techniques. To establish the usefulness of our approach for such developments in the broader context of inductively defined dependent types, we apply the theory to construct zippers for Inductive Families.
Adjoint Folds and Unfolds Or: Scything Through the Thicket of Morphisms
"... Abstract. Folds and unfolds are at the heart of the algebra of programming. They allow the cognoscenti to derive and manipulate programs rigorously and effectively. Fundamental laws such as fusion codify basic optimisation principles. However, most, if not all, programs require some tweaking to be g ..."
Abstract
 Add to MetaCart
(Show Context)
Abstract. Folds and unfolds are at the heart of the algebra of programming. They allow the cognoscenti to derive and manipulate programs rigorously and effectively. Fundamental laws such as fusion codify basic optimisation principles. However, most, if not all, programs require some tweaking to be given the form of an (un) fold, and thus make them amenable to formal manipulation. In this paper, we remedy the situation by introducing adjoint folds and unfolds. We demonstrate that most programs are already of the required form and thus are directly amenable to manipulation. Central to the development is the categorical notion of an adjunction, which links adjoint (un) folds to standard (un) folds. We discuss a number of adjunctions and show that they are directly relevant to programming.