Álvaro Tasistro

A type-theoretic framework for certified model transformations

We present a framework based on the Calculus of Inductive Constructions (CIC) and its associated tool the Coq proof assistant to allow certification of model transformations in the context of Model-Driven Engineering (MDE). The approached is based on a semi-automatic translation process from metamodels, models and transformations of the MDE technical space into types, propositions and functions of the CIC technical space. We describe this translation and illustrate its use in a standard case study.

Dependent Types for Nominal Terms with Atom Substitutions

Nominal terms are an extended first-order language for specifying and verifying properties of syntax with binding. Founded upon the semantics of nominal sets, the success of nominal terms with regard to systems of equational reasoning is already well established. This work first extends the untyped language of nominal terms with a notion of non-capturing atom substitution for object-level names and then proposes a dependent type system for this extended language. Both these contributions are intended to serve as a prelude to a future nominal logical framework based upon nominal equational reasoning and thus an extended example is given to demonstrate that this system is capable of encoding various other formal systems of interest.

Alpha-Structural Induction and Recursion for the Lambda Calculus in Constructive Type Theory

We formulate principles of induction and recursion for a variant of lambda calculus in its original syntax (i.e., with only one sort of names) where α-conversion is based upon name swapping as in nominal abstract syntax. The principles allow to work modulo α-conversion and implement the Barendregt variable convention. We derive them all from the simple structural induction principle on concrete terms and work out applications to some fundamental meta-theoretical results, such as the substitution lemma for α-conversion and the lemma on substitution composition. The whole work is implemented in Agda.

Formalisation in Constructive Type Theory of Stoughton's Substitution for the Lambda Calculus

In Stoughton, A., Substitution revisited, Theor. Comput. Sci. 59 (1988), pp. 317-325], Alley Stoughton proposed a notion of (simultaneous) substitution for the Lambda calculus as formulated in its original syntax - i.e. with only one sort of symbols (names) for variables - and without identifying α-convertible terms. According to such formulation, the action of substitution on terms is defined by simple structural recursion and an interesting theory arises concerning the connection to α-conversion. In this paper we present a formalisation of Stoughtons work in Constructive Type Theory using the language Agda, which reaches up to the Substitution Lemma for α-conversion. The development has been quite inexpensive e.g. in labour cost, and we are able to formulate some improvements over the original presentation. For instance, our definition of α-conversion is just syntax directed and we prove it to be an equivalence relation in an easy way, whereas in Stoughton, A., Substitution revisited, Theor. Comput. Sci. 59 (1988), pp. 317-325] the latter was included as part of the definition and then proven to be equivalent to an only nearly structural definition as corollary of a lengthier development. As a result of this work we are inclined to assert that Stoughtons is the right way to formulate the Lambda calculus in its original, conventional syntax and that it is a formulation amenable to fully formal treatment.

Formal metatheory of the Lambda calculus using Stoughton's substitution

Abstract We develop metatheory of the Lambda calculus in Constructive Type Theory, using a first-order presentation with one sort of names for both free and bound variables and without identifying terms up to α -conversion. Concerning β -reduction, we prove the Church–Rosser theorem and the Subject Reduction theorem for the system of assignment of simple types. It is thereby shown that this concrete approach allows for gentle full formalisation, thanks to the use of an appropriate notion of substitution due to A. Stoughton. The whole development has been machine-checked using the system Agda.

Case of (Quite) Painless Dependently Typed Programming: Fully Certified Merge Sort in Agda

We present a full certification of merge sort in the language Agda. It features: termination warrant without explicit proof, no proof cost to ensure that the output is sorted, and a succinct proof that the output is a permutation of the input.

Abstract Insertion Sort in an Extension of Type Theory with Record Types and Subtyping

We describe an extension of Martin-Lofs type theory with dependent record types and subtyping and use it for obtaining a formal definition of a general structure of the algorithms of sorting by insertion. We start by giving a general formulation of the sorting problem according to which the most general sorting algorithms are those that can be used for ordering lists over any set, along any total relation on the set. In particular, the best known members of the family of algorithms of sorting by insertion, namely straight insertion sort and tree sort, are of this kind. The proposed structure of the algorithms of sorting by insertion is based upon a specification of an abstract data type, which we call of insertion structures. The general method of sorting by insertion is then written as a program depending on unspecified implementation of insertion structures. We therefore call it abstract insertion sort. The concrete algorithms of sorting by insertion correspond to particular implementations of insertion structures. We discuss how it is possible to peecify the operations on insertion structures so as to accurately describe the intended family of algorithms. We also derive axioms for the insertion structures so as to obtain a natural decomposition into lemmas of the proofs of correctness of the algorithms of the family.