Ergo (Conchon & Contejean,2006) est un prouveur totalement automatique de th´eor`emes ´enonc´es dans une logique typ´ee, polymorphe et du premier ordre (not´ee PFOL). Sa conception est en partie inspir´ee de Simplify (Detlefs et al, 2005). Par contre, la logique d’Ergo est typ´ee et polymorphe contrairement `a celle de Simplify qui est non typ´ee. De notre point vue, cela rend la logique plus int´eressante que celle de Simplify. En effet, les obligations de preuve qui sont dans le fragment du premier ordre de notre logique peuvent ˆetre envoy´ees directement `a Ergo.
En plus de la logique du premier ordre, Ergo a un support natif de l’arithm´etique lin´eaire et de la th´eorie des constructeurs (c’est-`a-dire des symboles de fonction tels que f (x) = f (y) implique x = y). Ce point rend plus performant le raisonnement sur des structures de donn´ees alg´ebriques.
Dans le cas g´en´eral, nos obligations de preuve sont naturellement exprim´ees dans une logique d’ordre sup´erieur comme le montre notre pr´esentation. N´eanmoins, la logique d’ordre sup´erieur peut se coder dans la logique du premier ordre. Un codage standard introduit un pr´edicat apply qui aide `a simuler la β-conversion (Kerber,1991).
Dans notre cas, ce codage peut ˆetre ajust´e pour sembler tr`es naturel. Les symboles pre et post qui, jusqu’`a maintenant, ont ´et´e vus comme des projections pour les paires peuvent ˆetre r´einterpr´et´es comme des pr´edicats et simuler l’application en plus de la projection. De plus, nous pouvons trans- former pre en un pr´edicat binaire et post en un pr´edicat ternaire pour ´eviter l’application currifi´ee des fonctions. Pour r´ecapituler, `a la place des formules d’ordre sup´erieur :
f = (λ(x1: θ1).F1, λ(x1: θ1).λ(x2: θ2).F2),
on peut ´ecrire :
∀(x1: θ1).(pre(f, x1) ⇔ F1) ∧ ∀(x1: θ1).∀(x2: θ2).(post(f, x1, x2) ⇔ F2)
132 11. La logique sous-jacente
Types des objets
T ::= α Variable de type
| ε (T ) Application de type
Pr´edicats
P ::= true Proposition vraie
| false Proposition fausse
| p(o, . . . , o) Application | v = v Egalit´e´ | P ∧ P Conjonction | P ∨ P Disjonction | ¬ P N´egation | ∃(x : T ).P Quantification existentielle | ∀(x : T ).P Quantification universelle Objets o ::= x Variables | f (o) Applications D´eclarations
D ::= pred p : ∀α.T → prop Pr´edicat
| val v : ∀α.T → T Valeur
| axiom ∀α.P Axiome
| type ε [ n] Constructeur de type (et son arit´e)
Fig. 11.4: Syntaxe de la logique du premier ordre polymorphe.
La paire et les trois λ-abstractions ont ´et´e η-expans´ees, et les projections et les applications de symboles ont ´et´e fusionn´es dans les applications de pre et post. Si on suppose que F1 et F2 sont du premier
ordre alors la formule obtenue est du premier ordre.
La section 11.5.2 pr´esente la syntaxe et le syst`eme de type de la logique du premier ordre poly- morphe que nous ciblons.
11.5.2 La logique du premier ordre polymorphe
La syntaxe de la logique du premier ordre polymorphe est rappel´ee par la figure 11.4. La diff´e- rence essentielle entre PFOL et PHOL est la quantification qui ne peut pas se faire sur des pr´edicats dans PFOL. Notons aussi que la quantification sur les types de PFOL ne permet ´evidemment pas la quantification sur les types de pr´edicats.
11.5.3 Codage de PHOL vers PFOL
Codage du noyau
Nous utilisons la traduction d´ecrite par Gilles Dowek, Th´er`ese Hardin et Claude Kirchner (Dowek
et al,2001). Il s’agit d’une sorte de d´efonctionnalisation (Reynolds,1990,Pottier & Gauthier,2004) , encore appel´e λ-lifting : les pr´edicats utilis´es comme valeurs de premi`ere classe vont ˆetre cod´es sous
11.5 Interfa¸cage avec la logique du premier ordre polymorphique 133
la forme d’objets de la logique. Un pr´edicat not´e ε permet leur interpr´etation.
Notre contribution est d’adapter cette traduction classique `a un monde polymorphiquement typ´e et de faire quelques ajustements pour que le r´esultat du codage soit adapt´e aux prouveurs automatiques. Pour mener `a bien ce codage, nous avons donc besoin de plusieurs constantes et constructeurs de types pour d´enoter les pr´edicats comme des objets :
– le type o correspond au type des d´enotations des termes au niveau objet ;
– le constructeur de type ofun d’arit´e 2 est le type des objets d´enotant des fonctions (logiques ou des pr´edicats) ;
– le symbole de fonction apply de type ∀αβ.(ofun (α, β), α) → β correspond `a l’application d’une fonction au niveau objet.
– le symbole de pr´edicat ε de type o → prop correspond `a l’interpr´etation de la d´enotation objet. – les constantes correspondant aux connecteurs logiques.
Comme indiqu´e dans (Dowek et al,2001), il est n´ecessaire de rajouter des axiomes d’extensionnalit´e pour que ce codage soit correct et complet.
Codage de l’´egalit´e
Mˆeme si le codage est correct et complet, les prouveurs automatiques du premier ordre ont des strat´egies de r´esolution peu enclines `a utiliser les th´eor`emes d’interpr´etation. Les m´ethodes utilis´ees cherchent `a contrˆoler le nombre d’instanciations des lemmes, passer par une couche d’interpr´etation n’est donc pas tr`es efficace en g´en´eral.
Beaucoup de prouveurs automatiques utilisent l’algorithme congruence closure pour maintenir efficacement les classes d’´equivalence entre termes (et factoriser ainsi le travail d’instanciation). Coder les ´egalit´es handicape donc le prouveur puisqu’il doit passer par des lemmes d’interpr´etation pour les obtenir.
Quand c’est possible, on essaie donc de traduire les ´egalit´es entre des objets d’ordre sup´erieur sans utiliser le passage par les combinateurs d’interpr´etation. En effet, lorsque l’on a par exemple deux fonctions logiques ´egalis´ees ainsi :
λx.f (x) = λy.g(y)
Il suffit de renommer la variable y en x pour r´e´ecrire cette ´egalit´e en
∀x.f (x) = g(x)
Le mˆeme raisonnement s’applique aux pr´edicats mais on utilise alors le connecteur d’´equivalence logique plutˆot que l’´egalit´e.
Codage des types inductifs
Nous utilisons le mˆeme codage que celui propos´e par Jean-Christophe Filliˆatre et Nicolas Ayache (Ayache & Filliˆatre,2006). Il s’agit de traduire les lemmes d’injection, d’inversion et d’alg`ebre libre pour chaque d´eclaration de types alg´ebriques.
Codage des pr´edicats inductifs
Chaque cas des pr´edicats inductifs est traduit au premier ordre par la proc´edure indiqu´ee plus haut. Le prouveur automatique peut ainsi trouver le cas du pr´edicat inductif `a employer. Nous ne traduisons pas les sch´emas d’induction car comme ils sont du second ordre, il y a peu de chance qu’ils soient utilis´es.
Par contre, on d´etecte les pr´edicats inductifs dirig´es par la syntaxe d’un type alg´ebrique (ty- piquement lorsqu’on trouve un cas d’inductif pour chaque constructeur de donn´ees). C’est un cas particuli`erement commun et on g´en`ere un lemme d’inversion qui s’av`ere tr`es utile en pratique.
134 11. La logique sous-jacente
Codage des fonctions logiques
Les fonctions logiques sont des fonctions r´ecursives discriminant sur un argument d’un type al- g´ebrique. C’est le cas typique mis en lumi`ere par le codage de Nicolas Ayache et Jean-Christophe Filliˆatre (Ayache & Filliˆatre, 2006). Nous utilisons la mˆeme m´ethode : on produit une ´egalit´e pour chaque cas de la fonction logique.
11.5.4 Codage de PFOL vers FOL
Nous avons mentionn´e l’utilisation du prouveur automatique Ergo (Conchon & Contejean, 2006) car il travaille directement dans PFOL. Nous pensons que c’est une solution plus prometteuse que les logiques non typ´ees car le typage peut diriger les instanciations `a effectuer et rendre la recherche de preuve plus efficace. Ergo (Conchon & Contejean,2006) est un syst`eme tr`es r´ecent et, `a ce jour, il lui manque quelques propri´et´es essentielles comme l’int´egration de symboles commutatifs et associatifs dans le raisonnement. Il a donc ´et´e n´ecessaire, dans l’impl´ementation, d’encoder la logique polymor- phiquement typ´ee du premier ordre vers une logique du premier ordre non typ´ee pour pouvoir utiliser un plus grand nombre de prouveurs comme par exemple Simplify (Detlefs et al,2005).
Si on oublie tout simplement les types, le codage est incorrect. En effet, la propri´et´e
∀(x, y : unit).x = y
est valide dans PFOL. Par contre,
∀x, y.x = y
est ´evidemment invalide dans FOL. Ce probl`eme a ´et´e trait´e de mani`ere approfondie par St´ephane Lescuyer (Lescuyer,2006,Couchot & Lescuyer,2007). La solution consiste `a encoder les types `a l’aide de termes du premier ordre. On utilise ensuite un pr´edicat sort d’arit´e 2 qui prend un terme et une repr´esentation de type pour contraindre la forme des termes `a avoir le bon type. On encode ainsi la v´erification de typage `a l’int´erieur de la logique en embarquant les types `a l’int´erieur des termes. L’´enonc´e probl´ematique se r´e´ecrit alors
∀x, y.sort(x, unit) = sort(y, unit)
L’instanciation de ce th´eor`eme est alors limit´ee aux termes de la forme sort(t, unit) et le codage s’assure que ce sont seulement les termes qui ont le type unit dans le langage source.
CHAPITRE DOUZE
Le langage calculatoire
Ce chapitre formalise le langage de programmation du syst`eme. Il s’agit d’un langage fonctionnel pur polymorphiquement typ´e, muni de types alg´ebriques et dans lequel le programmeur peut ins´erer des assertions logiques.
12.1 Syntaxe
La syntaxe de notre langage de programmation apparaˆıt dans la figure 12.1. Il est muni d’un syst`eme de type `a la ML (Milner, 1978) ce qui implique une distinction entre les types τ et les sch´emas de type σ. Comptent, parmi les types, les variables de type, les types alg´ebriques param´etr´es et les types fonctionnels. Nous ´ecrivons−→ pour le constructeur de type des fonctions calculatoires.
de fa¸con `a le distinguer du constructeur de type des fonctions logiques → (figure11.1).
Nous imposons une s´eparation syntaxique entre valeurs et expressions et nous demandons que les deux sous-termes des applications ainsi que les termes analys´es par le pattern matching soient des valeurs. Ce style rappelle les formes A-normales (Flanagan et al, 1993) o`u le r´esultat de tout calcul interm´ediaire doit ˆetre nomm´e par la construction let. Bien sˆur, un tel style n’est pas confortable pour le programmeur et, en pratique, le langage de surface permet les constructions habituelles qui sont traduites automatiquement vers le langage pr´esent´e ici.
Le langage admet une inf´erence de type dans le style de Hindley-Milner. Cependant, dans cette pr´esentation, nous ne sommes pas int´eress´es par l’inf´erence de type donc nous travaillons sur des programmes explicitement typ´es comme en t´emoignent
(i) la syntaxe des valeurs et des motifs o`u les variables et les constructeurs de donn´ees sont annot´es par des vecteurs de types qui indiquent comment les sch´emas de type polymorphes doivent ˆetre instanci´es,
(ii) les constructions fun et let dont les variables li´ees sont annot´es par des types, et (iii) la construction let o`u les variables de type α sont explicitement li´ees.
Une d´efinition de fonction suit la forme g´en´erale :
fun f (x1: τ1/F1) : (x2: τ2/F2) = t
Le mot-cl´e / doit ˆetre lu o`u . Toute fonction est r´ecursive : f est li´ee `a l’int´erieur de t. Le param`etre formel x1 est li´e dans la pr´econdition F1, dans la postcondition F2 et dans t. La variable x2 est le
r´esultat de la fonction et est uniquement li´ee dans la postcondition F2. Toute fonction doit ˆetre annot´ee
par une pr´econdition et une postcondition (si l’une d’elles manque, on suppose qu’elle vaut true). Une variable locale est d´efinie comme suit :
let (x α : τ /F ) = t1in t2
136 12. Le langage calculatoire Types calculatoires τ ::= α Variable | ε τ Donn´ees | τ−→ τ. Fonctions σ ::= ∀α. τ Schema Valeurs v ::= x τ Variable | D τ (v, . . . , v) Donn´ees
| fun f (x : τ /F ) : (x : τ /F ) = t Fonction r´ecursive Motifs p ::= x τ Variable | D τ (p, . . . , p) Donn´ees Expressions t ::= v Valeur | v (v) Application de fonction
| let (x α : τ /F ) = t in t Liaison locale
| match v with c Analyse par cas
Cas
c ::= ∅ Nil
| p.t 8 c Cons
Fig. 12.1: Le langage calculatoire (syntaxe).
La variable locale x est li´ee dans F et dans t2. Les variables de type α sont li´ees dans τ , F et dans t1.
La proposition F sert de postcondition `a t1. Si la proposition est manquante alors on suppose qu’elle
vaut une postcondition par d´efaut dont la d´efinition sera donn´ee dans la section12.3. Une analyse par cas s’´ecrit :
match v with c
Ici, c est une s´equence ´eventuellement vide de branches. Chaque branche est de la forme p.t o`u les variables qui apparaissent dans le motif p sont li´ees dans t. Les motifs doivent ˆetre lin´eaires.