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

Systematic literatura review of PSP adaptations

In this report we present a systematic review of existing literature about PSP adaptations. In particular, we are interested in getting to know those adaptations that propose to incorporate the use of Formal Methods. Section 1 presents general concepts about systematic reviews. Section 2 presents the specific systematic review carried out. iv

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 alpha-conversion is based upon name swapping as in nominal abstract syntax. The principles allow to work modulo alpha-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 alpha-conversion and the lemma on substitution composition. The whole work is implemented in Agda

Representation of metamodels using inductive types in a type-theoretic framework for MDE

We present discussions on how to apply a type-theoretic framework composed out by the Calculus of Inductive Constructions and its associated tool the Coq proof assistant to the formal treatment of model transformations in the context of Model-Driven Engineering. We start by studying how to represent models and metamodels in the mentioned theory, which leads us to a formalization in which a metamodel is a collection of mutually defined inductive types representing its various classes and associations. This representation has been put into use for carrying out and verifying on machine the well-known case study of the Class to Relational model transformation. We finally end up discussing ways in which the framework can be used to obtain provably correct model transformations

Proof Assistant Based on Didactic Considerations

We consider some issues concerning the role of Formal Logic in Software Engineering education, which lead us to promote the learning of formal proof through extensive, appropriately guided practice. To this end, we propose to adopt Natural Deduction as proof system and to make use of an adequate proof assistant to carry out formal proof on machine. We discuss some necessary characteristics of such proof assistant and subsequently present the design and implementation of our own version of it. This incorporates several novel features, such as the display and edition of derivations as trees, the use of meta-theorems (derived rules) as lemmas, and the possibility of maintaining a set of draft trees that can be inserted into the main derivation as needed. The assistant checks the validity of each edition operation as performed. So far, it has been implemented for propositional logic and (quite satisfactorily) put into practice in courses of Logic for Software Engineering and Information Systems programs

A Machine-assisted Proof of the Subject Reduction Property for a Small Typed Functional Language

at is, to investigate the production of verified implementations of programming languages. Writing programs in constructive type theory amounts to writing completely formal proofs of often complex theorems. This makes the practical applicability of type theory depends strongly on the availability of adequate programming environments (alias proof assistants). A number of these systems have been or are being developed. We expect our work to become a useful experience in this connection too. In the present work, we conduct a first experiment along the lines given above. We consider a small polymorphic functional language and write a formal proof in constructive type theory of the main property relating the type system of the language with the evaluation of its expressions, namely the Subject Reduction Property. We use the proof assistant ALF ([Alt 94]). The abstract syntax of the language considered is the following : e ::= x j x : e<

Extension of Martin-Löf's Type Theory with Record Types and Subtyping

this paper, the implementation has been used to verify an abstract version of sorting by insertion in (Tasistro 1997). In this latter work, dependent record types are used to express speciøcations of abstract data types. The theory here developed is a direct successor of the calculus of substitutions for type theory (Martin-L#f 1992; Tasistro 1997) in the sense that record types can be seen as type constructions corresponding to contexts of variables ¯record objects becoming then the counterpart to substitutions. Several theories of records have been developed in the context of systems without dependent types, mainly with the motivation of providing foundations for concepts that appear in object oriented programming. Then, for instance, there is by now a standard way of encoding objects in the sense of object oriented programming as recursively deøned records. The general motivation mentioned departs from ours, which, as far as the theory of programming is concerned, is limited to that of providing basic means that allow the use of dependent types for expressing speciøcations of abstract data types and modules in a general way. The problem of formulating a type system for object oriented programming raises a number of questions that are simply not relevant for our purposes. As to dependent record types, they have been implemented in PVS (Owre et al. 1993), which is a theorem proving system based on classical higher order logic. The subtyping that record types induce is, however, not a part of this implementation. In the original type theory, it is possible to encode each particular instance of inclusion between types ff and fi by using a coercion function that injects the objects of type ff into the type fi. In (Barthe 1996; Bailey 1996; Sa#bi 1997) different mechanisms..