From 12.09.04 to 17.09.04, the Dagstuhl Seminar 04381 
``Dependently Typed Programming\u27\u27 was held
in the International Conference and Research Center (IBFI),
Schloss Dagstuhl.
During the seminar, several participants presented their current
research, and ongoing work and open problems were discussed. Abstracts of
the presentations given during the seminar as well as abstracts of
seminar results and ideas are put together in this paper. The first section
describes the seminar topics and goals in general.
Links to extended abstracts or full papers are provided, if available

Altenkirch, Thorsten

Hofmann, Martin

Hughes, John

Dagstuhl Research Online Publication Server

04381 Abstracts CollectionDependently Typed Programming Dagstuhl Seminar Thorsten Altenkirch1, Martin Hofmann2 and John Hughes31 University of Nottingham, GBtxa@cs.nott.ac.uk2 LMU München, DEhofmann@ifi.lmu.de3 Chalmers TU, Göteborg, SErjmh@cs.chalmers.seAbstract. From 12.09.04 to 17.09.04, the Dagstuhl Seminar 04381 De-pendently Typed Programming was held in the International Confe-rence and Research Center (IBFI), Schloss Dagstuhl. During the semi-nar, several participants presented their current research, and ongoingwork and open problems were discussed. Abstracts of the presentationsgiven during the seminar as well as abstracts of seminar results and ideasare put together in this paper. The ﬁrst section describes the seminartopics and goals in general. Links to extended abstracts or full papersare provided, if available.04381 Summary  Dependently Typed ProgrammingThe Dagstuhl seminar (04381) on Dependently Typed Programming broughttogether researchers from all over the world who are interested in the use ofdependent types in programming. An emerging topic was the interaction of thefunctional programming community and the Types community: an example isthe use of GADTs in Haskell, which represent a restricted use of dependenttypes in Haskell while on the other hand proof systems like COQ in which allowthe expression of many functional programming idioms. Emerging languagesand systems, like Epigram, attempt to unify functional programming and TypeTheory based proof development environments. Discussions during the seminarcentred on the question how to integrate dependent types in real programminglanguages and on the pragmatic and theoretical questions raised by doing this.Joint work of: Altenkirch, Thorsten; Hofmann, Martin; Hughes, JohnDagstuhl Seminar Proceedings 04381Dependently Typed Programminghttp://drops.dagstuhl.de/opus/volltexte/2005/1862 T. Altenkirch, M. Hofmann and J. HughesData vs. codataThorsten Altenkirch (University of Nottingham, GB)In a total language we have to distinguish data and codata. I'll explain codatausing a mirror: while data is deﬁned by a producer contract, i.e. the producerpromises only to use the agreed constructors to construct data, codata is deﬁnedby a consumer contract, i.e. the consumer promises only to use pattern matchingto analyze the codata. These principles give rise to recursion - corecursion andinduction - coinduction. I explain how coinductive reasoning can be explainedusing a coinductive deﬁnition of equality.Filters on Co-Inductive streams; a study on the exampleof Eratosthene's sieveYves Bertot (INRIA - Sophia Antipolis, F)Filters are functions from streams to streams that collect data satisfying a givenpredicate. Formalizing ﬁlters in Co-Inductive programming is diﬃcult becausethey are not plain co-recursive function. We describe a solution that combinesideas from temporal logic, recursion on an ad-hoc predicate, uses of dependenttypes to describe partial functions, and advanced use of guardedness conditions.This solution was completed using Coq 8.0.Keywords: Co-induction, dependent types to describe partial functions, generalrecursion.Formalising Bitonic Sort using Dependt TypesAna Bove (Chalmers UT - Göteborg, S)Bitonic sort (Batcher, 1968) is one of the fastest sorting networks. A sortingnetwork is a special kind of sorting algorithm, where the sequence of comparisonsis not data-dependent. This makes sorting networks (and in particular bitonicsort) suitable for implementation in hardware or in parallel processor arrays.Although the algorithm is short and computationally rather simple, we facetwo problems when we want to use type theory for its formalisation:1) the algorithm is not structurally smaller;2) its correctness proof is not very intuitive, hence its formalisation is notstraightforward.In this talk we present a formalisation of bitonic sort and its correctness proofin constructive type theory.Here, the correctness of bitonic sort is developed on the basis of the 0-1-principle (Knuth, 1973). For bitonic sort, the 0-1-principle states that if bitonicsort sorts every sequence of 0's and 1's then it sorts every sequence of arbitraryvalues.Dependently Typed Programming 3Computation by Judgement RewritingVenanzio Capretta (University of Ottawa, CDN)I will shortly explain two methods to implement general recursion in type theory:(1) by a coinductive model of potentially diverging comutation; (2, with AnaBove) by and inductive characterization of the domain of an algorithm.The second method gives rise to some problem when interpreting higher orderfunctionals. I will discuss a solution that exploit the power of impredicative typetheory. Since the method relies on Dybjer's induction-recursion, I will also discussa representation of this contruct in the Calculus of Constructions.Both methods (1) and (2) represent functions, but do not allow direct com-putation by term reduction. However, in both cases, an eﬀective computationmodel can be realized by a notion of judgement rewriting, consisting in a goal-directed reﬁnement algorithm for sequents starting from the assumption of avariable as result of the computation.Keywords: General Recursion, Impredicativity, Judgement RewritingDependent Types for Update ProgrammingMartin Erwig (Oregon State University, USA)Cells in spreadsheets that serve as headers can be interpreted as unit informationfor other cells to constrain the operations that are allowed to be applied. Unitsessentially reﬁne types and thus are an example of dependent types.We can deﬁne a unit system for end-user spreadsheets that is based on theconcrete notion of units instead of the abstract concept of types. The unit systemcontains concepts, such as dependent units, multiple units, and unit generaliza-tion, that allow the classiﬁcation of spreadsheet contents on a more ﬁne-grainedlevel than types do. Also, because communication with the end user happensonly in terms of objects that are contained in the spreadsheet, this system doesnot require end users to learn new abstract concepts of type systems.Since the unit inference depends on information about headers in a spreads-heet, a realistic unit inference system requires a method for automatically de-termining headers. We sketch several spatial-analysis algorithms for header in-ference.The combined header- and unit-inference system is fully integrated into Mi-crosoft Excel and can be used to automatically identify various kinds of errors inspreadsheets. Test results show that the system works accurately and reliably.4 T. Altenkirch, M. Hofmann and J. HughesPreservation of Typing for the Domain-Free Calculus ofInductive Constructions with Implicit ParametersBenjamin Gregoire (INRIA - Sophia Antipolis, F)In a proof system like Coq, checking the validity of a proof involves compa-ring types modulo beta-conversion, which is potentially a time-consuming task.To speed up this conversion test, Grégoire and Leroy showed how proof termscould be compiled towards a slightly modiﬁed Objective Caml bytecode. Butcompilation erases most of the type information carried by the proofs. It was anopen problem to show that erasure does not change the underlying formalism. Inthis paper, we show the equivalence of the formalism implemented by the proofcompiler and the oﬃcial formalism of Coq.The interest for such a result goes beyond the mere correctness proof of acompilation scheme since even non compiled implementations can be made moreeﬃcient by not comparing type annotations. It is also a signiﬁcant generalisationand strengthening of a similar result (Preservation of Equational Theory) byBarthe and Sørensen on the class of Domain-free pure type systems.Dependently Typed Programming and the Coq ProofAssistantNicolas Magaud (Univ. of New South Wales, AU)Coq is a proof assistant based on the calculus of inductive constructions. Amongother features such as polymorphism, higher-order and primitive inductive de-ﬁnitions, it provides dependent types. These dependent types can be used in awide range of applications.On the one hand, dependent types are used to achieve function deﬁnitions.Such functions usually would not feature dependent types if written in afunctional language like Caml or Haskell. In particular, they allow the user totransform partial functions into total ones by restricting the range of its inputs,e.g. from fact:int->int in a functional programming language we get fact:foralln:int, n>=0 -> int. In addition to that, dependent types are useful to deﬁnefunctions by well-founded induction. In this case, they are used to make sureone does only make recursive calls on smaller terms according to the consideredrelation.On the other hand, we can view Coq as a functional programming languageand actually use dependent types to specify the type of programs. Instead ofdeﬁning a function with a simple type and later prove as lemmas some of itsproperties, we can reﬁne the type of the function to make it more informativeregarding the properties of the function. This leads to fully-speciﬁed functionswhose type carries the function actual speciﬁcation.Finally, dependent data types such as vectors (dependent lists) can be deﬁ-ned. Coq provides means to write dependently typed programs such as reverseDependently Typed Programming 5rev:forall n:nat, (vect n) -> (vect n) and tools such as dependent equality toreason about them.All this shows Coq is a suitable environment to write dependently typedprograms. In addition, it is a framework in which you can even prove propertiesof the dependently typed programs one has deﬁned and also extract these thencertiﬁed programs to eﬃcient functional programming languages like Haskell orCaml.Keywords: Dependent types, Coq, well-founded recursion, formal proofsTowards iteration for truly nested datatypesRalph Matthes (Universität München, D)A case study is presented how one can predicatively justify nested datatypes witha nested recursive call in the datatype deﬁnition. The example is a representationof lambda terms including explicit substitutions by the equationLam A = A + Lam A x Lam A + Lam(1+A) + Lam(Lam A). (*)Following an idea of Anton Setzer and a handwritten manuscript by PeterAczel (Edinburgh, March 2003), Lam can be introduced by an inductive familyof types, indexed over ﬁnite lists of booleans - a predicative construction. It canbe shown (done by Peter Aczel) that Lam is a minimal pre-ﬁxed point of therank-2 operator underlying equation (*). The new insight is that this can even beused to program an iterator for Lam (in our case, within system Coq). However,its operational behaviour is hard to express in an implementation-independentfashion. A possible solution comes from a syntactic form of Kan extensions thatreintroduces impredicativity.The use of Lam is demonstrated by a representation of beta-developments ofuntyped lambda terms.Wobbly types: type inference for generalised algebraicdata typesSimon L. Peyton-Jones (Microsoft Research UK, GB)Generalised algebraic data types (GADTs), sometimes known as guarded re-cursive data types or ﬁrst-class phantom types, are a simple but powerfulgeneralisation of the data types of Haskell and ML.Recent works have given compelling examples of the utility of GADTs, alt-hough type inference is known to be diﬃcult.It is time to pluck the fruit. Can GADTs be added to Haskell, without losingtype inference, or requiring unacceptably heavy type annotations? Can this bedone without completely rewriting the already-complex Haskell type-inferenceengine, and without complex interactions with (say) type classes? We answer6 T. Altenkirch, M. Hofmann and J. Hughesthese questions in the aﬃrmative, giving a type system that explains just whattype annotations are required, and a prototype implementation that implementsit. Our main technical innovation is wobbly types, which express in a declarativeway the uncertainty caused by the incremental nature of typical type-inferencealgorithms.Joint work of: Simon Peyton Jones, Stephanie Weirich, Geoﬀrey WashburnCertiﬁed Typechecking in Foundational Certiﬁed CodeSystemsSusmit Sarkar (CMU - Pittsburgh, USA)Certiﬁed code enable untrusted programs to be proven safe to execute in amachine-checkable manner. This is done by packaging a proof of code safety to-gether with the code. Recent work has focused on building foundational certiﬁedcode systems, where safety is deﬁned relative to a concrete machine architecture.To be practical, such systems factor the proof of program safety into two parts.The ﬁrst part is a generic part, in which a class of programs is proven safe. Inthe second, program-speciﬁc part, the program of interest is shown to belong tothe class. If the class of programs is deﬁned as a type system, the ﬁrst problemcorresponds to proving type safety, and the second problem to type checking.Previous work, including ours, have focussed on the ﬁrst problem. The secondproblem is less well studied. A typechecker for the untrusted program has to beprovided by untrusted sources. It may not implement the type system correctly.We need a certifying typechecker, which can be statically checked. We propose adependently-typed version of SML to write such typecheckers. Dependent typeshelp us check partial correctness statically.Keywords: Foundational certiﬁed codeDelphin: Functional Programming with Dependent TypesCarsten Schürmann (Yale University, USA)Logical frameworks are meta languages designed to represent deductive systems,such as derivation in logic and type theories, or traces of operational semanti-cs and translation procedures. Functional programming languages are designedto help programmers express computations. Delphin aims at combing the twoand provides a programming paradigm for writing programs with higher-order,dependently typed encodings. in a natural way as if they were natural numberslists or trees.Delphin is a two level programming language that distinguishes between auniverse for representation and a universe for computation.Dependently Typed Programming 7As a novelty it would be useful to mentation the injection type embeddingdata into the computation level and a modal type constructor that permitsevaluation under lambda binders and ensures scoping. A version for the simplytyped logical framework is implemented and accessible thorough our homepagehttp://www.cs.yale.edu/Carsten/delphin.Keywords: Delphin, Logical Frameworks, Higher-order Abstract Syntax, Func-tional Programming, Dependent Types.Joint work of: Schürmann, Carsten; Poswolsky, Adam; Sarnat, JeﬀInteractive Programs and Weakly Final Coalgebras inDependent Type Theory (Extended Version)Anton Setzer (University of Wales - Swansea, GB)We reconsider the representation of interactive programs in dependent type theo-ry that the authors proposed in earlier papers. Whereas in previous versions thetype of interactive programs was introduced in an ad hoc way, it is here deﬁnedas a weakly ﬁnal coalgebra for a general form of polynomial functor. The aretwo versions: in the ﬁrst the interface with the real world is ﬁxed, while in thesecond the potential interactions can depend on the history of previous interac-tions. The second version may be appropriate for working with speciﬁcations ofinteractive programs.We focus on command-response interfaces, and consider both client and ser-ver programs, that run on opposite sides such an interface. We give formati-on/introduction/elimination/equality rules for these coalgebras. These are ex-plored in two dimensions: coiterative versus corecursive, and monadic versusnon-monadic. We also comment upon the relationship of the corresponding ru-les with guarded induction. It turns out that the introduction rules are nothingbut a slightly restricted form of guarded induction. However, the form in whichwe write guarded induction is not recursive equations (which would break norma-lisation  we show that type checking becomes undecidable), but instead involvesan elimination operator in a crucial way.Keywords: Dependently types programming, interactive programs, coalgebras,weakly ﬁnal coalgebras, coiteration, corecursion, monadJoint work of: Setzer, Anton; Hancock, PeterFull Paper: http://drops.dagstuhl.de/opus/volltexte/2005/1768 T. Altenkirch, M. Hofmann and J. HughesPartiality is an eﬀectTarmo Uustalu (Tallinn Technical University, EE)Partial functions are usually considered as something basic or purely functio-nal in functional languages, hence semantics starts from CPO-like categorieswith ﬁxpoint operators. We maintain that partiality due to non-terminationcan alternatively be treated as a monadic eﬀect. The appropriate monad is thefree completely iterative monad on the identity functor which captures timed,possibly non-terminating computation; one can also consider the quotient thatidentiﬁes all terminating computations yielding the same value (constructively,this is not the same as the error monad, which can only capture partiality dueto ﬁnite failure). Looping constructions are supported immediately; we discussgeneral recursion and combination of the monad with monads for other eﬀects.Time permitting, I will also show how the dual comonad can be used to repre-sent causal stream functions. (Work in progress jointly with T. Altenkirch andV. Capretta.)A Core Language for Generalized Algebraic DatatypesStephanie Weirich (University of Pennsylvania, USA)Generalised algebraic data types (GADTs), sometimes known as guarded re-cursive data types or ﬁrst-class phantom types, are a simple but powerfulgeneralisation of the data types of Haskell and ML. Recent works have givencompelling examples of the utility of GADTs, although type inference is knownto be diﬃcult.Simon Peyton Jones will be speaking about our work in combining GADTswith Haskell type inference. However, before we could even think about doingthat, we needed to deﬁne the semantics of GADTs in Haskell's explicitly-typedcore language. Although the semantics of GADTs in explicitly-typed languagesis not new, we did encounter a few technical diﬃculties in designing a versionthat worked well with Haskell's existing core language. I'll speak about theseissues as well as provide material background for Simon's talk.

04381 Abstracts Collection -- Dependently Typed Programming

http://drops.dagstuhl.de/opus/volltexte/2005/186/pdf/04381_abstracts_collection.pdf

04381 Abstracts Collection -- Dependently Typed Programming

Abstract

Similar works

Full text

Available Versions

Dagstuhl Research Online Publication Server