Coq (logiciel)

Au début des années 80, Gérard Huet lance un projet de fabrication d’un démonstrateur interactif de théorème. Il s'agit d'un assistant de preuve. Thierry Coquand et Gérard Huet conçoivent la logique de Coq et le calcul des constructions. Christine Paulin-Mohring étend cette logique avec une nouvelle construction, les types inductifs et un mécanisme d’extraction qui permet d’obtenir automatiquement un programme zéro défaut à partir d’une preuve[2].

Coq est fondé sur le calcul des constructions, une théorie des types d'ordre supérieur, et son langage de spécification est une forme de lambda-calcul typé. Le calcul des constructions utilisé dans Coq comprend directement les constructions inductives, d'où son nom de calcul des constructions inductives (CIC).

Coq a été récemment doté de fonctionnalités d'automatisation croissantes. Citons notamment la tactique Omega qui décide l'arithmétique de Presburger[3].

Plus particulièrement, Coq permet :

• de manipuler des assertions du calcul ;
• de vérifier mécaniquement des preuves de ces assertions ;
• d'aider à la recherche de preuves formelles ;
• de synthétiser des programmes certifiés à partir de preuves constructives de leurs spécifications.

C'est un logiciel libre distribué selon les termes de la licence GNU LGPL.

Parmi les grands succès de Coq, on peut citer :

• théorème des quatre couleurs la démonstration complètement mécanisée a été terminée en 2004 par Georges Gonthier et Benjamin Werner ;
• théorème de Feit-Thompson la preuve du théorème a été terminée par Georges Gonthier et son équipe en septembre 2012[4] ;
• CompCert, un compilateur optimisant pour le langage C qui est en grande partie programmé et prouvé en Coq.

Coq utilise la correspondance de Curry-Howard. La preuve d'une proposition est vue comme un programme dont le type est cette proposition. Pour définir un programme ou une preuve, il faut:

• Soit l'écrire dans le langage Gallina, proche du langage de programmation fonctionnelle OCaml.
• Soit déclarer son type (ou la proposition que l'on veut démontrer). Le langage Ltac permet alors de définir cette preuve/programme par chaînage arrière, de façon interactive. Cette méthode est privilégiée pour les preuves mathématiques car Coq est alors capable de deviner certaines étapes intermédiaires.

Il est aussi possible d'utiliser SSReflect à la place de Ltac. Autrefois développé séparément, il est maintenant inclus par défaut dans Coq.

Require Import Arith List Bool.

Fixpoint factorielle (x : nat) : nat :=
match x with
0 => 1
| S p => x * factorielle( p )
end.

Require Import Arith List Bool.

Definition factorielle: forall n:nat, nat.
(* on nomme l'argument *)
intro n.
(* on fait une définition par récurrence*)
induction n.
* (* si l'argument est 0, on retourne 1*)
  apply 1%nat.
* (* si l'argument de la forme (S n), on retourne un produit *)
  apply Nat.mul. 
  - (* 1er facteur du produit: valeur de factorielle en n *)
    apply IHn.
  - (* 2e facteur du produit: le successeur de n *)
    apply S.
    + apply n.
(*On indique que la définition est terminée et que l'on souhaite pouvoir calculer cette fonction. *)
Defined.

Require Import Omega.

Lemma odd_or_ind: forall n : nat,
                  (exists p:nat, n=2*p) \/ (exists p:nat, n = 1 + 2 * p).
Proof.
    induction n.
    - (* cas 0 *) left. exists 0. trivial.
    - (* cas (n + 1) *)
      destruct IHn as [[p Hpair] | [p Himpair]].
      + (* n pair *)
        right. exists p. omega.
      + (* n impair *)
        left. exists (p + 1). omega.
(* On indique que la preuve est terminée et qu'elle ne sera pas utilisée comme un programme.*)
Qed.

• Démonstration automatique de théorèmes
• Isabelle
• Mizar
• PhoX
• PVS