Sous-typage coercitif en présence de réductions non-standards dans un système aux types dépendants

Type Theory lies on the crossroad of Logics, Mathematics and Computer Science. It may be used to develop the "zero-error" programs. The aim of this thesis is to study an extension of a system with dependent types called UTT (including inductive types) that is obtained by adding to the rewrite relation of UTT new rewrite rules concerning finite types. We check that Strong Normalization, Church-Rosser property and Subject Reduction are preserved. We consider another extension by Coercive Subtyping that is seen as an abbreviation mechanism and give a conservativity proof for the system enriched by Coercive Subtyping with respect to underlying UTT (with an without new rewrite rules). The interest of such a system is that it will improve the efficiency of proof assistants and provides a general framework for treatment of the problems involving finite types (combinatorics, graphs etc).La théorie des types est une discipline au croisement de la logique, des mathématiques et de l'informatique. Elle peut servir de support au développement de programme "zéro faute". L'objet de cette thèse est d'étudier l'extension d'un système aux types dépendants UTT (comprenant notamment des types inductifs) par une relation de récriture concernant un fragment du calcul, à savoir les types finis. Nous nous assurons d'abord que les propriétés de normalisation forte, de confluence et de préservation du type sont toujours préservées malgré l'ajout de la réduction. Ensuite nous enrichissons ce système par la notion de sous-typage coercitif vue comme un mécanisme d'abréviation et effectuons la preuve de conservativité pour le système enrichi du sous-typage par rapport au système de base. L'intérêt d'un tel système est qu'il améliora l'efficacité des assistants à la preuve et offrira un bon cadre pour l'étude des problèmes faisant intervenir des ensembles finis (combinatoire, manipulation de graphe etc)

Machine Assisted Proofs for Generic Semantics to Compiler Transformation Correctness Theorems

This thesis investigates the issues involved in the creation of a "general theory of operational semantics" in LEGO, a type-theoretic theorem proving environment implementing a constructionist logic. Such a general theory permits the ability to manipulate and reason about operational semantics both individually and as a class. The motivation for this lies in the studies of semantics directed compiler generation in which a set of generic semantics transforming functions can help convert arbitrary semantic definitions to abstract machines. Such transformations require correctness theorems that quantify over the class of operational semantics. In implementation terms this indicates the need to ensure both the class of operational semantics and the means of inferring results thereon remain at the theorem prover level. The endeavour of this thesis can be seen as assessing both the requirements that general theories of semantics impose on proof assistants and the efficacy of proof assistants in modelling such theories

Constructing and Refining Modules in a Type Theory

The need to apply formal specification and development of programs to large problems has highlighted a need for methods to support modular development. This has two aspects: the modular construction of specifications, and the implementation of modular specifications. This thesis is concerned with both these activities. The main body of work in the development of modular specifications has been carried out in the context of algebraic specification languages, and model-based languages such as Z. However, these languages fail to provide some important mechanisms for structuring specifications. Furthermore, the complex semantics of these languages lead to complicated definitions of what it means for a program to be an implementation of a specification. In this thesis, we show that Martin-Lof's Type Theory provides a framework for both the specification and implementation of program modules; and this framework addresses the shortcomings, noted above, in other specification formalisms. The basic theoretical notion underlying our approach is that a specification is a type, and that an implementation of such a specification is any element in the type. We present a module specification language, and its associated implementation language. The semantics of both the specification and implementation languages are defined in Martin-Lof's Type Theory. We define some specification building operators for our specification language, and show how modular specifications may be incrementally constructed using the specification operators. We give some laws about the specification operators and show how these laws can be used to reason about, and restructure, modular specifications. We define a notion of refinement that supports the implementation of modular specifications by systematic mathematical transformation. We give some refinement laws for refining modular specifications. We also define some operators on program modules, and show how these operators can be used to systematically implement modular specifications