Les outils d’aide à la preuve basés sur la théorie des types permettent à l’utilisateur d’adopter soit un style fonctionnel, soit un style relationnel (c’est-à-dire en utilisant des types inductifs). Chacun des deux styles a des avantages et des inconvénients. Le style relationnel peut être préféré parce qu’il permet à l’utilisateur de décrire seulement ce qui est vrai, de s’abstraire temporairement de la question de la terminaison, et de s’en tenir à une description utilisant des règles. Cependant, une spécification relationnelle n’est pas exécutable.Nous proposons un cadre général pour transformer une spécification inductive en une spécification fonctionnelle, en extrayant à partir de la première une fonction et en produisant éventuellement la preuve de correction de la fonction extraite par rapport à sa spécification inductive. De plus, à partir de modes définis par l’utilisateur, qui permettent de considérer les arguments de la relation comme des entrées ou des sorties (de fonction), nous pouvons extraire plusieurs comportements calculatoires à partir d’un seul type inductif.Nous fournissons également deux implantations de notre approche, l’une dans l’outil d’aide à la preuve Coq et l’autre dans l’environnement Focalize. Les deux sont actuellement distribuées avec leurs outils respectifs. / Proof assistants based on type theory allow the user to adopt either a functional style, or a relational style (e.g., by using inductive types). Both styles have advantages and drawbacks. Relational style may be preferred because it allows the user to describe only what is true, discard momentarily the termination question, and stick to a rule-based description. However, a relational specification is usually not executable.We propose a general framework to turn an inductive specification into a functional one, by extracting a function from the former and eventually produce the proof of soundness of the extracted function w.r.t. its inductive specification. In addition, using user-defined modes which label inputs and outputs, we are able to extract several computational contents from a single inductive type.We also provide two implementations of our approach, one in the Coq proof assistant and the other in the Focalize environnement. Both are currently distributed with the respective tools.

Les preuves par récurrence sont parfaitement adaptées au raisonnement sur des structures de données non-bornées, comme par exemple les entiers et les listes, ou, de manière plus générale, sur des ensembles d’éléments non vides munis d’ordres noethériens. Leur domaine d’application est très vaste, une utilité particulière portant sur la validation des propriétés d’applications industrielles dans des domaines critiques tels que les télécommunications et les cartes à puces. Le principe de récurrence noethérienne est à la base d’un ensemble de techniques de preuve par récurrence modernes, dont celles basées sur la récurrence implicite. Dans cette thèse, nous nous intéresserons à l’intégration du raisonnement par récurrence implicite tel qu’il est implémenté dans le démonstrateur Spike en utilisant l’environnement de preuve certifié Coq. Basé sur la récurrence implicite, Spike est capable de raisonner automatiquement sur des théories conditionnelles de premier ordre. L’implémentation de Spike n’est pas encore certifiée, même si les fondements théoriques sous-jacents ont été approuvés à plusieurs reprises par la communauté scientifique. Une alternative convenable serait de certifier seulement les preuves générées par Spike. Dans ce cas, le processus de certification doit être automatique car les scripts de preuves de Spike sont souvent longs. Des travaux précédents ont montré la possibilité de certifier automatiquement des preuves par récurrence implicite générées par Spike à l’aide de l’environnement certifié de l’assistant de preuve Coq. Nous proposerons des nouvelles tactiques Coq qui seront capables de prouver automatiquement des théorèmes par récurrence implicite. Deux approches seront étudiées. La première approche consiste à utiliser Spike comme un outil externe. Elle est limitée au traitement des spécifications Coq qui peuvent être traduites dans des spécifications conditionnelles, ainsi qu’à des théorèmes convertibles dans des équations conditionnelles. Les traces de preuves générées par Spike sont ensuite traduites dans des scripts Coq qui sont finalement validés par son noyau. Une autre limitation est due à la traduction des applications d’un sous-ensemble de règles d’inférence de Spike. La deuxième approche est l’utilisation des stratégies à la Spike pour construire automatiquement des preuves par récurrence implicite dans Coq. Cette approche se base sur des tactiques Coq qui simulent des règles d’inférence de Spike pour générer de nouveaux sous-buts. Par rapport à la première approche, ces tactiques peuvent utiliser des techniques de raisonnement de Coq qui ne sont pas présentes dans Spike et ouvre la possibilité de mélanger des étapes de preuves automatiques et manuelles. Ces deux approches ont été mises en œuvre et testées sur différents exemples dont des lemmes utilisés dans la preuve de validité de l’algorithme de conformité du protocole de télécommunication ABR / Proofs by induction are perfectly adequate to reasoning on unbounded data structures, for example naturals, lists and more generally on non-empty sets of elements provided with noetherian orders. They are largely used on different fields, particularly for the validation of properties of industrial applications in critical areas such as telecommunications and smart cards. The principle of noetherian induction is the basis of a set of modern techniques of proof by induction, including those based on implicit induction. In this thesis, we will focus on the integration of implicit induction reasoning like it is implemented by spike using the certified proof environnement Coq. Spike is an automatic theorem prover based on implicit induction that is capable of reasoning on conditional first-order theories. The implementation of Spike is not yet certified, even if the underlying theoretical foundations have been approved repeatedly by the scientific community. A suitable alternative is to certify only the proofs produced by Spike. In this case, the certification process must be automatic because scripts of Spike’s proofs are often long. Previous work has shown the possibility of certifying automatically some proofs by implicit induction generated by Spike using the certified environment provided by the Coq proof-assistant. We will propose new Coq tactics that are able to prove automatically theorems by implicit induction. Two approaches will be studied. The first approach consists on using Spike as an external tool. It is limited to process Coq specifications which can be translated in conditional specifications, as well as theorems convertible in conditional equations. Proofs generated by Spike are then translated into Coq scripts finally validated by its kernel. Another limitation is due to the translation of the application of a subset of the Spike inference rules. The second approche is to use strategies à la Spike to automatically build implicit induction proofs in Coq. This approach consists on creating tactics that perform like Spike inference rules to generate new subgoals in Coq. Comparing to the first approach, these tactics permit the use of Coq reasoning techniques which are not present in Spike and opens the possibility of mixing automatic and manual proof steps. Both approaches have been implemented and tested on several examples including lemmas used in the proof of validity of the conformity algorithm for the ABR telecommunications protocol

Functional reactive programming (FRP) is a paradigm extending functional languages with primitives which operate on state. Typical FRP systems contain many dozens of such primitives. This thesis aims to identify a minimal subset of primitives which captures the same set of behavior as these systems, and to provide an axiomatic semantics for them using first-order linear temporal logic, with the aim of utilizing these semantics in formal verification of FRP programs. Furthermore, we identify several important properties of these primitives and prove that they are satisfied using the Coq proof assistant.

La préservation de propriétés établies sur le programme source jusqu'au code exécutable est un point important dans les méthodes formelles. Cette propriété de préservation est établie par la vérification formelle du proccessus de compilation. Un compilateur est formellement vérifié s'il est accompagné d'une preuve de préservation sémantique : "si la compilation réussit, le code compilé se comporte comme le code source le prédit." Le projet CompCert étudie la vérification formelle de compilateurs réalistes utilisable dans l'embarqué-critique. Il s'agit de développer et formellement vérifier de tels compilateur via l'assistant de preuve Coq. Un compilateur pour le langage C vers l'assembleur PowerPC a déjà ainsi été produit. Le code exécutable du compilateur a été obtenu en deux étapes non vérifiés : la génération automatique de code Ocaml par le mécanisme d'extration de Coq et la compilation du de ce code extrait par le système Objective Caml. En fait, cette lacune est commune à tous les développements spécifiés dans l'assistant de preuve Coq et destinés à produire un éxécutable. Cette thèse décrit l'étude, le développement et la vérification formelle, dans l'assistant de preuve Coq, d'un compilateur pour le fragment purement fonctionnel du langage ML : le langage cible du mécanisme d'extraction de Coq. Concrètement, il s'git d'une chaîne de compilation en amont pour mini-ML (lambda calcul, let, letrec et filtrage) vers le premier langage intermédiaire de la chaîne de compilation en aval du compilateur CompCert. Ce langage, Cminor, est un langage de bas niveau à la C. L'expressivité du langage source traité rend ce compilateur réaliste. Il comporte aussi des optimisations classiques propre à la compilation de langages fonctionnels : la décurryfication, comme celle implémentée dans le compilateur OCaml ; la représentation uniforme des données, explicitation des fermetures, numérotation des constructeurs et une mise en style par passage de continuation (CPS) optimisée. Le point fort de ce compilateur et que, comme les compilateurs modernes pour langage de haut niveau, il peut interagir avec un gestionnaire de mémoire automatique. Cette interaction a aussi été formellement vérifiée.

Ce document donne un panorama de la représentation des définitions inductives dans différents assistants de preuve en logique d'ordre supérieur, théorie des ensembles et théorie des types. Il présente, étudie et justifie les choix faits dans le système Coq.

Ce manuscrit de thèse présente les travaux menés sur le système de modules de l'assistant de Preuve Coq.

Les systèmes basés sur la Théorie des Types prennent une importance considérable tant pour la vérification de programmes qu'en tant qu'outils permettant la preuve formelle de théorèmes mettant en jeu des calculs complexes. Ces systèmes nécessitent aujourd'hui une grande expertise pour être utilisés efficacement. Nous développons des constructions de haut niveau permettant d'utiliser les langages basés sur les théories des types dépendants aussi simplement que les langages de programmation fonctionnels usuels, sans sacrifier pour autant la richesse des constructions disponibles dans les premiers. Nous étudions un nouveau langage permettant l'écriture de programmes certifiés en ne donnant que leur squelette algorithmique et leur spécification. Le typage dans ce système donne lieu à la génération automatique d'obligations de preuve pouvant être résolues a posteriori. Nous démontrons les propriétés métathéoriques essentielles du système, dont les preuves sont partiellement mécanisées, et détaillons son implémentation dans l'assistant de preuve Coq. D'autre part, nous décrivons l'intégration et l'extension d'un système de "Type Classes" venu d'Haskell à Coq via une simple interprétation des constructions liées aux classes dans la théorie des types sous-jacente. Nous démontrons l'utilité des classes de types dépendantes pour la spécification et la preuve et présentons une implémentation économique et puissante d'une tactique de réécriture généralisée basée sur les classes. Nous concluons par la mise en œuvre de l'ensemble de ces contributions lors du développement d'une bibliothèque certifiée de manipulation d'une structure de données complexe, les "Finger Trees".

Outils Génériques de Modélisation et de Démonstration pour la Formalisation des Mathématiques en Théorie des Types. Application à la Théorie des Catégories.

Dans le domaine des systèmes informatisés où la fiabilité est la première priorité, les méthodes formelles ont prouvé leur efficacité pour la conception de logiciels sûrs. La dépendance à de tels systèmes augmente, et les contraintes rencontrées se font plus diverses et précises, en particulier les contraintes temporelles. Certaines méthodes formelles, notamment la méthode B, rendent la conception malaisée sous de telles contraintes, puisqu'elles n'ont pas été prévues pour cela à l'origine.<br /><br />Nous nous proposons donc d'étendre la méthode B pour lui permettre de spécifier et valider des systèmes à contraintes temporelles complexes. Nous utilisons pour ce faire des calculs de durées pour exprimer la sémantique du langage B et en déduire une extension conservative qui permet de l'utiliser à la fois dans son cadre d'origine et dans le cadre de systèmes à contraintes temporelles.<br /><br />Nous nous penchons également sur le problème de l'utilisation d'un outil de preuve générique pour valider des formules de calcul des durées. La généricité de ce type d'outil répond à la multiplication des méthodes formelles, mais pose le problème de l'intégration des fondations mathématiques de ces méthodes à un outil générique. Nous proposons donc d'étudier la mise en oeuvre en plongement léger du calcul des durées dans l'assistant de preuve Coq. Nous en déduisons un retour sur expérience de la définition d'une logique modale particulière dans un outil à vocation générique.

Cette thèse porte sur la vérification des règles ajoutées de l'Atelier B en utilisant une plate-forme appelée BCARe qui repose sur un plongement de la théorie sous-jacente à la méthode B (théorie de B) dans l'assistant à la preuve Coq. En particulier, nous proposons trois approches pour prouver la validité d'une règle, ce qui revient à prouver une formule exprimée dans la théorie de B. Ces trois approches ont été évaluées sur les règles de la base de règles de SIEMENS IC-MOL. La première approche dite autarcique est développée avec le langage de tactiques de Coq Ltac. Elle repose sur une première étape qui consiste à déplier tous les opérateurs ensemblistes pour obtenir une formule de la logique du premier ordre. Puis nous appliquons une procédure de décision qui met en oeuvre une heuristique naïve en ce qui concerne les instanciations. La deuxième approche, dite sceptique,appelle le prouveur automatique de théorèmes Zenon après avoir effectué l'étape de normalisation précédente. Nous vérifions ensuite les preuves trouvées par Zenon dans le plongement profond de B en Coq. La troisième approche évite l'étape de normalisation précédente grâce à une extension de Zenon utilisant des règles d'inférence spécifiques à la théorie de B. Ces règles sont obtenues grâce à la technique de superdéduction. Cette dernière approche est généralisée en une extension de Zenon à toute théorie grâce à un calcul dynamique des règles de superdéduction. Ce nouvel outil, appelé Super Zenon, peut par exemple prouver des problèmes issus de la bibliothèque de problèmes TPTP.