aeaiiedeRe he hee
f
ai e2009 10  2 7 2Aiadee veChiiea

ours 2-7-2

Assistants de preuve

Christine Paulin-Mohring, BenjaminWerner,

Bruno Barras, Hugo Herbelin,

Jean-Christophe Filliâtre,ClaudeMarhé

1 Introdution au Calul des Construtions Indutives 6

1.1 Motivations . . . 6

1.2 Quelquesrappels surlesthéories de types . . . 7

1.3 Un premierontat ave Coq:Curry-Howard enation . . . 7

1.3.1 Syntaxe debase duformalisme . . . 8

1.3.2 Vériation etinférenede types . . . 8

1.3.3 Deux tatiquesdebase. . . 9

1.4 LesEntiersNaturels dansCCI . . . 11

1.4.1 Dénition . . . 11

1.4.2 Syntaxe alternative . . . 12

1.4.3 Fontionssur lesentiers . . . 12

1.4.4 Calulerpour raisonner . . . 14

1.4.5 Le shémade réurrene desentiers naturels. . . 15

1.4.6 Une preuve par réurrene . . . 15

1.5 D'autres typesdedonnées ourants . . . 16

1.5.1 Listesd'entiers . . . 16

1.5.2 Listesparamétrées . . . 17

1.5.3 Typessomme etproduit . . . 18

1.6 Typesindutifs plusomplexes . . . 18

1.6.1 Ordinaux . . . 18

1.6.2 Arbresarbitrairement branhants . . . 19

1.7 Prédiats indutifs . . . 19

1.7.1 Entiers pairs . . . 19

1.7.2 L'ordre surles entiers . . . 20

1.7.3 Un exempledangereux . . . 20

2 Exemple de développement Gallina : Sémantique d'un mini-langage 21 2.1 Introdution . . . 21

2.2 Présentation duproblème . . . 22

2.2.1 Sémantique statique . . . 22

2.2.2 Sémantique opérationnelle . . . 23

2.2.3 Sémantique axiomatique . . . 24

2.2.4 Quelquespropriétés . . . 24

2.3 Spéiation Gallina . . . 24

2.3.1 Lesexpressions . . . 24

2.3.2 Vériation du type etévaluationonstrutive . . . 29

2.3.3 Lesommandes . . . 30

2.3.4 Miseà jour de lamémoire . . . 31

2.3.5 Sémantique opérationnelle . . . 32

2.3.6 Sémantique axiomatique . . . 33

2.4 Pour en savoir plus . . . 34

2.4.1 Sémantique deslangagesetompilateurs . . . 34

2.4.2 Logiquede Hoare . . . 34

2.4.3 Preuvede programmesJava . . . 34

2.4.4 Plongement superiel ouprofond . . . 35

3 Types indutifs 36 3.1 Généralités . . . 36

3.1.1 Forme générale . . . 36

3.1.2 Forme abstraite . . . 37

3.2 Lesdélarations non-réursives . . . 37

3.2.1 Lesdélarations debase . . . 37

3.2.2 Règlesdeformation etd'introdution . . . 38

3.2.3 Shémasd'élimination . . . 39

3.2.4 Typesindutifs etsortes . . . 44

3.3 Lestypesindutifs réursifs . . . 46

3.3.1 Exemples . . . 46

3.3.2 Condition depositivité. . . 47

3.3.3 Shémad'élimination réursifprimitif . . . 48

3.3.4 Condition degarde . . . 49

3.3.5 Réurrenestruturelle versus réurrene bienfondée . . . 50

3.3.6 Dénitionsmutuellement indutives . . . 51

3.4 Extensions. . . 52

3.4.1 Strutures innies . . . 52

3.4.2 Strutures quotients . . . 53

3.4.3 Rédutionsgénéralisées . . . 53

4 Types oindutifs dans Coq 54 4.1 Introdution . . . 54

4.1.1 Typesonrets . . . 54

4.1.2 Typesréursifspositifs . . . 54

4.2 Exemple deslistesinnies . . . 54

4.2.1 Prinipe de destrutivité . . . 55

4.2.2 Prinipe de o-itération . . . 56

4.2.3 Prinipe de o-réursion . . . 56

4.2.4 Dénitionspar pointsxes . . . 57

4.3 Dénition destypeso-indutifsdansCoq . . . 57

4.3.1 Typesde données innis . . . 58

4.3.2 Conditionsde gardes . . . 58

4.3.3 Rédution . . . 60

4.3.4 Famillesoindutives . . . 61

4.4 Appliations . . . 63

4.4.1 Calul deproessus. . . 63

4.4.2 Logiquetemporelle . . . 63

4.4.3 Autresappliations . . . 63

5 Arhiteture des assistants à la démonstration 64

5.1 Arhiteture deCoq . . . 64

5.2 Critèresde lassiation . . . 64

5.3 Autressystèmes. . . 66

5.4 Preuves par réexion . . . 66

5.4.1 Utilisationde preuvesde déidabilité . . . 67

5.4.2 Utilisationd'unestruture abstraite . . . 67

5.4.3 Un exempleen Coq: l'assoiativitéde l'addition surles entiersnaturels . . 67

6 Extration de programmes et réalisabilité 71 6.1 Interprétation onstrutive despreuves . . . 71

6.1.1 Logiquelassique versus logiqueintuitionniste . . . 71

6.1.2 Construtivitédu CaluldesConstrutions Indutives . . . 73

6.1.3 Leslimites del'isomorphisme deCurry-Howard . . . 74

6.2 Réalisabilité . . . 75

6.2.1 Prinipesgénéraux . . . 75

6.2.2 Diérentesnotions de réalisabilité. . . 76

6.3 Réalisabilitédansle CaluldesConstrutions . . . 78

6.3.1 Oublidestypesdépendants . . . 78

6.3.2 Distintion entre PropetSet . . . 79

6.3.3 Autresméthodes d'analyse . . . 83

6.4 L'extration enpratique . . . 84

7 Preuve de programmes fontionnels 85 7.1 Méthode direte. . . 85

7.1.1 Cas desfontionspartielles . . . 87

7.1.2 Cas desfontionsnon struturellement réursives . . . 90

7.2 Utilisationde typesdépendants . . . 93

7.2.1 Type sous-ensemble sig . . . 93

7.2.2 Variantes de sig . . . 94

7.2.3 Spéiation d'une fontionbooléenne:sumbool . . . 95

7.2.4 Spéiation dansles typesde données . . . 97

7.3 Modules etfonteurs . . . 97

8 Preuve de programmes impératifs 100 8.1 Logiquede Hoarelassique . . . 100

8.1.1 Sémantique opérationnelle . . . 100

8.1.2 Logiquede Hoare . . . 101

8.1.3 Complétude, etaluldeplus faible préondition . . . 101

8.1.4 Diultés . . . 102

8.2 Transformation fontionnelle:laméthode Why . . . 102

8.2.1 Le langageWhy . . . 103

8.2.2 Typage ave eets . . . 104

8.2.3 Calul deplus faible préondition . . . 105

8.2.4 Tradutionfontionnelle . . . 106

8.3 Traitement des strutures données omplexes et appliation à d'autres langages de programmation . . . 108

8.3.1 Exemple d'unprogrammeave un tableau: ledrapeauhollandais . . . 108

8.3.2 ProgrammesJava etC . . . 110

9 Sémantique du Calul des Construtions Indutives 111

9.1 Le CaluldesConstrutions pur (CC) . . . 111

9.1.1 Puissanelogique . . . 111

9.1.2 Puissanealulatoire . . . 112

9.1.3 Extensionsinohérentes duCalul desConstrutions . . . 113

9.2 Le CaluldesConstrutions ave univers(CC

ω

9.2.1 Enodage de l'arithmétique . . . 114

9.2.2 Enodage de lathéoriedesensembles deZermelo . . . 114

9.2.3 Puissanelogique . . . 114

9.3 Extensionsohérentes etinohérentes du CaluldesConstrutions Indutives . . 115

Introdution au Calul des

Construtions Indutives

1.1 Motivations

Ce ourstraitedelapreuve formelle,omme disiplinedel'informatique.Ilprolonge don le

ours de tron ommun Fondements dessystèmes de preuves , maisen mettant l'aent sur

laonstrution eetive de preuves formellesetde leurvériation sur ordinateur.

Si la logique mathématique, 'est-à-dire la formalisation omplète du raisonnement est une

disipline déjà relativement anienne, elle a été relativement bouleversée par l'arrivée de l'or-

dinateur: laapaité de lamahine à manipuler rapidement degrosses expressions symboliques

permetdeformaliserentièrementdesraisonnementsnon-triviaux.Laquestionqueseposelelogi-

ienn'estalors plustantexiste-t-iluneformalisationdetelraisonnement?quedeonstruire

etd'exhiberette formalisation.

C'est ave ette observation à l'espritquenousherherons à traiterdespointssuivants:

Formalismes

Le hoix du formalisme est important pour la pratique des mathématiques formelles. Non

seulement il doit être apable d'exprimer la preuve onçue par le mathématiien, mais il doit

permettredelefairedelamanièrelaplusfaileetlaplusintuitivepossible.Defait,lesévolutions

réentesduCaluldesConstrutionsIndutivesontpresquetoujoursétémotivéesparlapratique

etsont don postérieures auxpremièresimplémentations de CoCpuisCoq.

Modélisation

Plusenorequ'enmathématiquesusuelles,savoirbienénonerlespropositionsquel'onespère

prouverestessentielsil'onveutultimementaboutiràune preuve formelle.Sil'onfaitl'analogie

entrelesativitésdeprouveretprogrammer,alors lehoixdelamodélisationorrespondàelui

delastruturedereprésentation desdonnées,ave lesonséquenesimmédiates etévidentessur

l'arhiteture du logiielobtenu.

Plus généralement, il nous semble que les analogies entre les ativités de preuves etde pro-

grammation sont nombreuses, et s'il existe un art de labonne programmation, il en va de

mêmepourlespreuvesformelles.Deplus, àhaqueoupleformalisme/problème,orrespondun,

ouplusieurs, stylede bonne preuve,toutommeilexiste debonsstylesde programmationpour

un problèmeetunlangage de programmation donné.

Nous nous attaherons partiulièrement à la modélisation et la formalisation de problèmes

informatiquesoù lasûreté estimportante, età lapreuve de orretion deprogrammes.

Arhiteture des systèmes

Ennnousherherons àdérirelesgrandsprinipesd'unlogiield'assistant àladémonstra-

tion. Poursuivant enore l'analogie ave la programmation, ei orrespondrait à ladesription

d'unompilateur. Nousnousintéresserons prinipalement ausystème depreuvesCoq.

1.2 Quelques rappels sur les théories de types

Aujourd'hui, on désigne généralement par théoriedes types un formalisme logique dont

les objetssont des

λ

que par la logique pour parler de es objets. On peut iter en partiulier la logique d'ordre

supérieur de Churh, la Théorie des Types de Martin-Löf, la logique du système PVS et le

Calul desConstrutions Indutives(CCI) dont les variantes implantées par Coqseront l'objet

etlesupportpremier de e ours.

Les objets de la logique d'ordre supérieur de Churh sont les

λ

Lestroisautres formalismesutilisent essentiellement desvariantes(ou plutt desfragments)du

langage deprogrammation ML.Ils sedistinguent par leur logique:

PVSutilise unalul desprédiats lassique,sousforme dealuldesséquents; sesobjets

sont un fragment fortement terminant de ML, enrihi par une notion de sous-type. Les

preuves enrevanhe ne sont pasunobjetdu formalisme.

LathéoriedestypesdeMartin-Löfestunelogiqueprédiative.Lespreuvessontelles-mêmes

des

λ

LeCaluldesConstrutionsIndutivesestluiuneextensiondelalogiqued'ordresupérieur

etautoriselaquantiationimprédiative surtoutes lespropositions.

Sur tous es points, nousrenvoyons biensûr au ours de tron ommun.La plupart seront par

ailleursillustrés toutau longduours.

Un point ommun essentiel de CCI et de la théorie de Martin-Löf est bien sûr qu'ils sont

onstruitssurla orrespondanede Curry-Howard. Rappelonsqueela signieque:

lespreuvessont desobjets,

lespropositions sont destypes,

une preuve d'uneproposition

P

p

P

En simpliant, onpeutdirequeles avantages informatiquesde ette approhe sont:

Une plus grande homogénéité preuves/objets, qui simplie l'implémentation du système

depreuves.

Unstatutbienomprisdespreuvesommeobjetsduformalisme;enonséquene,ellesont

également une représentation laire dansl'implémentation.

Uneartiulationentrealuletdédutionquipermetdespreuvespartiulièrementonises

dansertainsas (depuis l'exemple

2 + 2 = 4

tatique ring).

1.3 Un premier ontat ave Coq: Curry-Howard en ation

Le système Coq est un système de traitement de preuves pour une version prédiative du

Calul desConstrutions Indutives. Lesomposantes essentiellesdu systèmeCoqsont:

unnoyau devériation detypesetde onstrution d'environnements bientypés

unlangage de développement de théoriesmathématiques: Gallina

unoutillage d'aide à laonstrution interative de preuves par destatiquesde preuve

1.3.1 Syntaxe de base du formalisme

Le formalisme implanté parCoqsera donouramment appeléCCI.Ils'agit pour l'essentiel

d'une extension du Calul de Construtions (CC) traité en tron ommun. Il nous faut dès

maintenant signaler quelquesdiérenesde notationsave lasyntaxeemployée jusqu'ii.

Toutd'abord,Coqestonçupourpouvoirêtreutiliséparuneinterfaeenmodetexte(ASCII

ou Uniode). Lesnotationsde Coqpour

λx : A.t

Πx : A.B

La

λ

Laquantiationuniverselle estnotée forall x:A, B. Cetobjetest letypedesfontions

qui à un objet x de type A assoient un objet de type B. Comme en tron ommun, on

utiliseralaèhepoursimplierl'érituredee typelorsquex n'apparaîtrapasdansB.En

ASCIIela donne A->B.

Parailleurs, essentiellement pour desraisonshistoriques,lessortesportent d'autresnomsen

Coq quedans leours de tron ommun. Rappelons que les sortes sont des onstantes partiu-

lières, qui sont les types destypes. Dans le ours de tron ommun,on utilisait une sorte Type

qui est le type des types, et une sorte Kind qui était le type de Type. Cette dernière servant

essentiellement à énoner lesrèglesorrespondant au polymorphisme.

DanslesversionsdeCoqantérieuresàlaversion8.0,Type estremplaéepardeuxsortesju-

melles ,Prop etSet.Intuitivement, Set ontient les typesdedonnées (objets alulatoires

qui sont pris en ompte par le proessus d'extration de programmes de Coq f le hapitre

onsaré)et Proplesénonés logiques(qui sont oubliés par leproessusd'extration).

Depuislaversion8.0deCoq,PropgardelerlejouéparTypedansleCaluldesConstrutions

traité dans le ours de tron ommun. Il reste une sorte nomméeSet mais qui est une version

prédiative de Type. Typiquement, le type forall A:Set, A->A ne peutpas s'appliquer à lui-

même en Coqversion8.0.

Pournerienarranger,lasorteKindsetrouverenomméeTypedansCoq.Auleteurquiserait

tentédevoirlàunesoure deonfusion,rappelonssimplement quel'informatique estsansdoute

lasienedelabureauratie etd'unevision unpeutyrannique del'ordreetpartiulièrement du

renommage...

1.3.2 Vériation et inférene de types

A partir de là, nous pouvons taper nos premières ommandes pour utiliser le vériateur

de type.En syntaxe Coq, l'identité polymorphe estdon notée fun (A:Type) (a:A) => a. On

demande au système de vérier la bonne-formation d'un objet par la ommande Chek; les

ommandes Coqétant toujours terminéespar un point, eladonne:

Coq < Chek (fun (A:Type) (a:A) => a).

fun (A : Type) (a : A) => a

: forall A : Type, A -> A

Toutesles opérations detypagede Coqontlieu dansunenvironnement global.Cetenviron-

nement orrespond au ontexte

Γ

Γ ⊢ t : T

pousserdenouvelles variablesdansl'environnement:

Coq < Variable A : Prop.

A is assumed

Coq < Variable a : A.

a is assumed

De plus, l'environnement de Coq peut également ontenir des onstantes, ou abréviations.

Pour ela, onassoieuntermeà unnom; deplus, l'environnement mémoriseaussiun destypes

du orpsde laonstante 1

.

Coq < Definition Id (B:Type) (b:B) := b.

Id is defined

Coq < Chek Id.

Id

: forall B : Type, B -> B

Coq < Print Id.

Id = fun (B : Type) (b : B) => b

: forall B : Type, B -> B

Argument sopes are [type_sope _℄

1.3.3 Deux tatiques de base

Construireunepreuverevient,dansnotreformalisme,àexhiberun

λ

L'utilisateur dispose pour ela d'un mode de preuve interatif. Les ommandes de e mode

interatifsontappeléestatiquesdepreuve.Voiiune illustrationsommairede leurprinipe,sur

un exemple simple; on se donne trois variables propositionnelles A, B et C, puis l'on herhe à

prouver latautologie suivante:

Coq < Variables A B C : Prop.

A is assumed

B is assumed

C is assumed

Coq < Lemma exemp1 : ((A -> B) -> C) -> B -> C.

1 subgoal

A : Prop

B : Prop

C : Prop

============================

((A -> B) -> C) -> B -> C

On a alors le lemme omme seul but ourant, sous la double barre. On peut ommener à

onstruire lapreuve:

Coq < intros b.

1 subgoal

A : Prop

B : Prop

C : Prop

: (A -> B) -> C

b : B

============================

C

1

Rappelonsqu'enraisondelarègledeonversion,untermebien-formépeutavoirplusieurstypesdansCCou

CCI.

Onvoitque(A->B)->CetBontétépousséesommehypothèsesdansleontexteloal,au-dessus

de ladoublebarre. Ellesont éténommées ommedemandé.

Du point devuedelaonstrution delapreuve,ette tatiqueorrespondàla

λ

Coq < Show Proof.

LOC:

Subgoals

1 -> ((A -> B) -> C) -> B -> C

Proof: fun ( : (A -> B) -> C) (b : B) =>?1 b

Une preuve partiellepeutomporter plusieurs points d'interrogations, 'est-à-direque l'onpeut

avoirplusieurs sous-buts simultanément, haun ave sonontexteloal.

La tatique apply orrespondà l'appliation:

Coq < apply .

1 subgoal

A : Prop

B : Prop

C : Prop

: (A -> B) -> C

b : B

============================

A -> B

On est alors passé au terme de preuve partiel fun (:(A->B)->C) (b:B) => ?1 où le but

ourant est maintenant A->C. Onnit don lapreuve par

Coq < intros a.

1 subgoal

A : Prop

B : Prop

C : Prop

: (A -> B) -> C

b : B

a : A

============================

B

Coq < exat b.

Proof ompleted.

La ommande Qed (ou Save) permet alors d'ajouter à l'environnement global le terme exemp1

ainsirée:

Coq < Qed.

intros b.

apply .

intros a.

exat b.

exemp1 is defined

Coq < Print exemp1.

exemp1 =

fun ( : (A -> B) -> C) (b : B) => (fun _ : A => b)

: ((A -> B) -> C) -> B -> C

Rassuronsenn leleteur:unepreuveaussisimplepeut,heureusement,également êtretrou-

vée automatiquement par les tatiques de preuve plus évoluées dont dispose le système. Plus

généralement, e doument n'est d'ailleurs pas un manuel d'utilisateur, ni un ours de Coq.

Nousrenvoyonspour elaà ladoumentation standard de Coq[Coq07℄.

1.4 Les Entiers Naturels dans CCI

1.4.1 Dénition

Le typedesentiersnaturelsestlepluspetittypeontenant

0

S

telledénition parplus petit point xeest appelée une dénitionindutive.

La syntaxeen Coq d'unetelledénitionest:

Coq < Indutive nat : Set :=

Coq < | O : nat

Coq < | S : nat -> nat.

Cette ommandeajouteà l'environnement dusystèmeles objetssuivants:

letype nat : Set

lesdeux objetsO : nat etS : nat -> nat appelés onstruteurs denat.

En général, ette dénition (ainsi que la plupart de elles qui suivent) sont déjà présentes

dansl'environnement dusystème aulanement.

Coq < Print nat.

Indutive nat : Set := O : nat | S : nat -> nat

Coq < Chek nat.

nat

: Set

Coq < Chek O.

O

: nat

Coq < Chek S.

S

: nat -> nat

Remarque Informellemment,leplus petittype ainsidéni estelui dont leshabitantssont O,

(S O), (S (S O)), et. On a don bien une représentation de lanotion mathématique d'entier

naturel.

Remarque La vision informatique est que ette dénition est laversion Coq du type onret

MLbien onnu:

# type nat = O | S of nat;;

Onpeutremarquerau passage,qu'en Coqleonstruteur Sestfontionnel etpeut don exister

sanssonargument. Ils'agit làd'unpoint syntaxique, d'importane marginale.

Remarque D'un point de vue ensembliste, les entiers naturels sont le plus petit point xe de

l'opérateur suivant:

F (X) ≡ { 0 } ∪ { (S x), x ∈ X } .

Cet opérateur est monotone, et admet don un plus petit point xe. En eet, l'univers des

ensembles estun treillisomplet par rapportàl'ordre d'inlusion.

Cette possibilitéde voir ladénitionommeun pluspetit point xeseraommune à toutes

les dénitions indutives. Par ailleurson verraplus tard, omment espointsxes apparaissent

également danslasémantique delathéorie.

Dansehapitre,nousn'expliiteronspaslesrèglesdetypagequisous-tendentlesdénitions

indutives. Ellesseront expliitéesen partie lors duours 3.

1.4.2 Syntaxe alternative

Par défaut, les entiers de nat sont représentés en Coq via la notation standard en base 10.

Par exemple, la notation 3 désigne l'entier naturel (S(S(S O))). Qu'il soit lair que es deux

éritures désignent lemême terme etsont représentées de manièreidentiquedanslesystème.

Onverra plusloin queles symboles inxes+, *,<=, ...désignent aussipar défauten Coqles

opérationsarithmétiques surnat.Àtout moment lors d'unesession Coq,on peutdésativer les

notationsévoluées telles que3,+, <=, ...en utilisant laommandeSet Printing All.

1.4.3 Fontions sur les entiers

Deux exemples simples

Lesentierssontl'arhétype dutypededonnéesréursif.ToutommeenML,l'onalulesur

esentiersgrâe àdes fontionsdénies par deuxméanismes fondamentaux:

leltrage,

laréursion.

Le premier exemple d'unetellefontion est engénéral l'addition. Voii sadénitionen ML:

let re plus n m =

math n with

O -> m

| (S p) -> S(plus p m);;

et l'équivalent en syntaxeCoq:

Coq < Fixpoint plus (n m:nat) {strut n} : nat :=

Coq < math n with

Coq < | O => m

Coq < | S p => S (plus p m)

Coq < end.

Et voii,de même, unedénition delamultipliation:

Coq < Fixpoint mult (n m:nat) {strut n} : nat :=

Coq < math n with

Coq < | O => O

Coq < | S p => plus m (mult p m)

La notion de réursion struturelle

On omprend bien que la onstrution Fixpoint orrespond à la dénition d'une fontion

réursive, au même titre que le let re de ML. Onnote en revanhe que le premier desdeux

argumentsde haunedes deuxfontions estsyntaxiquement distinguépar l'emploidu mot-lé

strut. Laraison en estsimple:lorsque lathéoriedestypes,ommeii, estutiliséeen tantque

formalisme logique, la ohérene du formalisme est essentiellement assurée par la propriété de

normalisation, 'est-à-dire de la terminaison des aluls. Une sommaire justiation informelle

pourraitêtredonnéeainsi: supposons qu'ilsoit possible de dénirla fontionsuivante.

Coq < Fixpoint non_sens (n: nat) : nat := non_sens n.

Il est alors lair que l'objet (non_sens O) ne orrespond mathématiquement pas à un entier

naturel, etnesaurait êtreaepté dansleformalisme.

Onreviendraparlasuiteàl'étudedelapropriétédenormalisation,etrenverra,pourl'instant,

au oursde tronommun.Retenons pour l'instantque:

Toutes les fontionsréursivesaeptées parle systèmedoivent terminer.

Pour pouvoir dénirdesrègles detypage,il importe don d'isolerunelasse de fontionsréur-

sivesterminantes.Pourefaire,ongénéraliselalassedesfontionsdénissablesdanslesystème

Tde Gödel:

Dénition 1 On onsidère un terme de type nat de la forme (S

n

struturellement pluspetit que (S

n

n

toutterme struturellement plus petit que

n

Une fontionest struturellement réursive sil'onpeutdistinguer l'unde sesarguments, qui

déroitstruturellement à haque appel réursif.

En Coq,seules desfontionsstruturellement réursivespeuventêtre déniespar Fixpoint.

Les fontions plus etmult dénies i-dessussont struturellement réursives par rapport à

leur premierargument. Biensûr, lafontion non_sensestrejetée par lesystème.

Voii unedénitionalternativede l'addition,quidéroitparrapportàsonseondargument.

Coq < Fixpoint plus' (n m:nat) {strut m} : nat :=

Coq < math m with

Coq < | O => n

Coq < | S p => S (plus' n p)

Coq < end.

Fontions plus omplexes

Dans le système T, seul

n

n

dénitioni-dessusestplussouple,parexemple voiiune dénitionpossibleenCoqduquotient

de ladivisionentière par deux:

Coq < Fixpoint div2 (n:nat) : nat :=

Coq < math n with

Coq < | 0 => 0

Coq < | 1 => 0

Coq < | (S (S p)) => (S (div2 p))

Coq < end.

Il faut noter que ette fontion pourrait également être dénie dans le système T, mais de

manière un peu plus lourde.Il s'agit don là d'unaménagement du formalisme qui n'étend pas

l'expressivité duformalisme, maisjustesononfort d'utilisation.

Dans un registre diérent, le méanisme de réursion struturelle permet la dénition de

fontionslogiquement omplexes,'est-à-direquiroissent trèsvite.L'exempleleplusonnuest

lafontion due àAkermann,dont voii ladénitionML:

let re ak = funtion

O,m -> S(m)

| S(n),O -> ak(n,(S(O)))

| S(n),S(m) -> ak(n,ak(S(n),m));;

Laterminaisondeettedénitionestassuréeparunedéroissanedelapaired'argumentsvis-

à-visdel'ordrelexiographique.Entermederéursionstruturelle,eiestodéparl'utilisation

de deuxréursionsemboîtées.En Coq, lasyntaxe estalors un peu plusomplexe;laommande

fix jouant le rled'unlet re...in:

Coq < Fixpoint ak (n:nat) : nat -> nat :=

Coq < math n with

Coq < | O => fun m:nat => S m

Coq < | S n' =>

Coq < (fix aux (m:nat) : nat :=

Coq < math m with

Coq < | O => ak n' (S O)

Coq < | S m' => ak n' (aux m')

Coq < end)

Coq < end.

1.4.4 Caluler pour raisonner

Donnons un exemple simple (etlassique) d'utilisation de larègle de onversion; ils'agit de

prouver

2 + 2 = 4

+

Coq < Lemma deux_et_deux : 2 + 2 = 4.

1 subgoal

============================

2 + 2 = 4

Ilsut d'observerqueletermeorrespondant à

2 + 2

laproposition estlogiquement identiée à 4=4:

Coq < simpl.

1 subgoal

============================

4 = 4

Coq < reflexivity.

Proof ompleted.

Remarquons que la tatique simpl, qui proède don à la

β

est:

Γ ⊢ t : A Γ ⊢ B : s A = _β B

Γ ⊢ t : B Conv

Onvoitbienquelestermes-preuvesde laonlusionetde laprémisseprinipalesontidentiques.

Enonséquene,l'onpourraitdansl'exemple préédent,sepasseromplètementde simplet

utiliserjuste reflexivity,quionstruit lapreuve orrespondant àlaréexivité de l'égalité. La

dénitionexate duprédiatd'égalité sera détaillée plus tard.

Exerie 1 Prouver à partir delà, la ommutativité de l'addition.

1.4.5 Le shéma de réurrene des entiers naturels

Le fait que nat est bien le plus petit type los par ses deux onstruteurs est exprimé par

le shéma de réurrene. Il s'agit d'une propriété logique qui s'énone ainsi: soit

P

sur lesentiers; pour que laproposition

P (n)

n

onditions susantessoient vériées:

P (0)

pour toutentier

n

P (n)

P (S(n))

Dans une logique d'ordre supérieur, e shéma peut être exprimé omme une proposition. En

syntaxeCoq:

forall (P: nat -> Prop),

(P O) ->

(forall (m:nat), (P m)->(P (S m)))->

forall (n:nat), (P n)

De fait, la dénition d'un type indutif génère automatiquement une preuve du shéma de

réurrene orrespondant. Si le type indutif est nommé I, la preuve du shéma de réurrene

s'appelleraI_ind;par exemple:

Coq < Chek nat_ind.

nat_ind

: forall P : nat -> Prop,

P 0 -> (forall n : nat, P n -> P (S n)) -> forall n : nat, P n

L'utilisation du shéma de réurrene enCoq se faitgrâe aux tatiques elimet indution.

1.4.6 Une preuve par réurrene

Voiiunautreexemplesimple,ombinantlealuletleraisonnementparréurrene.Ils'agit

de prouverune première étape verslaommutativité de l'addition,à savoir:

Coq < Lemma omm_0 : forall n:nat, n = n + 0.

1 subgoal

============================

forall n : nat, n = n + 0

Cettepreuve sefaitbiensûr par réurrenesurn; leasde baseest trivial:

Coq < indution n.

2 subgoals

============================

0 = 0 + 0

subgoal 2 is:

S n = S n + 0

Coq < reflexivity.

1 subgoal

n : nat

IHn : n = n + 0

============================

S n = S n + 0

Pour leaspar réurrene, on peutproéder àune étape derédution:

Coq < simpl.

1 subgoal

n : nat

IHn : n = n + 0

============================

S n = S (n + 0)

Ilsut alors d'utiliserl'hypothèse deréurrenepour remplaerdanslebut ourant,p+0 parp;

ela peutsefaire par:

Coq < rewrite <- IHn.

1 subgoal

n : nat

IHn : n = n + 0

============================

S n = S n

Coq < reflexivity.

Proof ompleted.

1.5 D'autres types de données ourants

Comme en ML, le prinipe de dénitions indutives permet la onstrution de types de

données plusomplexesque lesentiers. Suivent quelquesexemples ourants.

1.5.1 Listes d'entiers

Il estsans doute inutile de rappeler la struture deslistes, ave leurs deuxonstruteurs nil

etons .La ommandedénissant les listes d'entiersnaturels estbiensûr:

Coq < Indutive list : Set :=

Coq < | nil : list

Coq < | ons : nat -> list -> list.

Unepremière remarque,marginale,estqueontrairementà ML,lesonstruteurspeuventavoir

1.5.2 Listes paramétrées

Il est préférable de remplaer ladénitionpréédentepar une autre où letype deséléments

deslistes estun paramètre.La bonne dénition deslistes est:

Coq < Indutive list (A:Set) : Set :=

Coq < | nil : list A

Coq < | ons : A -> list A -> list A.

Il s'agit de la même dénition, mais paramétrée par le type A. Cette abstration est possible

grâeaux typesfontionnels:

Coq < Chek list.

list

: Set -> Set

Coq < Chek nil.

nil

: forall A : Set, list A

Coq < Chek ons.

ons

: forall A : Set, A -> list A -> list A

A titred'exemple, onérira ainsil'équivalent de l'objetML

[1; 2; 3]

Coq < Chek (ons nat 1 (ons nat 2 (ons nat 3 (nil nat)))).

ons nat 1 (ons nat 2 (ons nat 3 (nil nat)))

: list nat

ÀonditiondereouriràladénitiondéniedanslemoduleListdelabibliothèquestandard

de Coq,on peutaussiutiliserlanotation suivante:

Coq < Require Import List.

Coq < Chek (1 :: 2 :: 3 :: nil).

1 :: 2 :: 3 :: nil

: list nat

Le shéma de réurrenestruturelle surles listes est:

Coq < Chek list_ind.

list_ind

: forall (A : Type) (P : list A -> Prop),

P nil ->

(forall (a : A) (l : list A), P l -> P (a :: l)) ->

forall l : list A, P l

On reonnaît lamême struture que pour les entiers, ave toutefois l'argument supplémentaire

de onsetlaparamétrisation par rapportàA.

1.5.3 Types somme et produit

Un exemple ourant de typeparamétré est letypesomme:

Coq < Indutive sum (A B:Set) : Set :=

Coq < | inl : A -> sum A B

Coq < | inr : B -> sum A B.

Son shéma d'élimination est plus simple, puisque le type est non réursif; il s'agit juste d'ex-

primer que tout élément de (sum A B) ne peut être onstruit qu'à partir de l'un des deux

onstruteurs:

Coq < Chek sum_ind.

sum_ind

: forall (A B : Set) (P : sum A B -> Prop),

(forall a : A, P (inl A B a)) ->

(forall b : B, P (inr A B b)) -> forall s : sum A B, P s

1.6 Types indutifs plus omplexes

Dans tous les exemples de typesréursifsvus jusqu'ii, l'ordreorrespondant à laréursion

(et la réurrene) struturelle se onfondait ave la relation de sous-terme. Le méanisme des

typesindutifs autorisetoutefois desonstrutionsplus générales.

1.6.1 Ordinaux

La dénitionquisuit estsouvent appelétype desordinaux parabusde langage.Ils'agit

enfait d'unenotationordinale, quine permetquelareprésentation d'unfragment desordinaux

onstrutibledansCCI.Ils'agitd'uneopiedutypedesentiersnaturels,étendueparunnouveau

onstruteur orrespondant àla limite ordinale:

Coq < Indutive Ord : Set :=

Coq < | Oo : Ord

Coq < | So : Ord -> Ord

Coq < | lim : (nat -> Ord) -> Ord.

Onremarquequeleonstruteurlimestréursif,maisquesonargumentestunesuiteentière

d'ordinaux.

L'ordredelaréursionstruturelleestalorsgénéralisédelamanièresuivante:quelquesoitles

termes

n

f

→

(f n)

(

f )

Voii une dénitionlégalede fontion sure typedes ordinaux:

Cette vision de la réursion struturelle est également reétée dans l'énoné du shéma de

réurrene dutype:

Coq < Chek Ord_ind.

Ord_ind

: forall P : Ord -> Prop,

P Oo ->

(forall o : Ord, P o -> P (So o)) ->

(forall o : nat -> Ord, (forall n : nat, P (o n)) -> P (lim o)) ->

forall o : Ord, P o

C'est-à-dire quepourappliquer le shémaspéialiséà unprédiat

P

étant donnée

f

→

pour toutentier

n

(f n)

P

alors

(lim f )

P

1.6.2 Arbres arbitrairement branhants

On peut utiliser l'idée préédente pour dénir un type d'arbre très général: en utilisant le

polymorphismeon s'autoriseà indexerles lsde haque n÷udpar un type arbitraire.

Coq < Indutive Inf_tree : Type :=

Coq < Node : forall A:Set, (A -> Inf_tree) -> Inf_tree.

Inf_tree is defined

Inf_tree_ret is defined

Inf_tree_ind is defined

Inf_tree_re is defined

Cetypeest trèspeuintuitif.Il utiliseetombine toutesles ressouresdu formalismesetpermet

ainsilaonstrution detrès nombreuxéléments. Defait, lelogiien anglaisPeterAzelaprouvé

qu'il était possible d'enoder leséléments delathéorie desensemblesdanse type.

1.7 Prédiats indutifs

Nous avonsvu omment onstruire desobjets onrets. Le méanisme de dénitions indu-

tives permet également la dénition d'objets plus logiques, et en partiulier de prédiats. En

partiulier, e sera en général lamanièrelaplus ommode d'isolerune partie deséléments d'un

type indutif.

1.7.1 Entiers pairs

En théorie des ensembles, une dénition possible de l'ensemble des entiers pairs est de dire

que'est lepluspetitensemble telque:

0est pair

pour toutentier

n

n

n + 2

La même dénitionest possible dansCCI.Le prédiateven, êtrepair , étantun objetde

type nat

→

Coq < Indutive even : nat -> Prop :=

Coq < | evenO : even 0

Coq < | evenS : forall n:nat, even n -> even (S (S n)).

On voit bien que la struture d'une preuve de parité est réursive, à l'image de la struture

d'untermedetype nat. Ceiestreétédansleshéma deréurrene quipermetdeprouverdes

propriétés d'entiers pairs:

Coq < Chek even_ind.

even_ind

: forall P : nat -> Prop,

P 0 ->

(forall n : nat, even n -> P n -> P (S (S n))) ->

forall n : nat, even n -> P n

1.7.2 L'ordre sur les entiers

Un exemple essentielestl'ordre surles entiers:

Coq < Indutive le (n:nat) : nat -> Prop :=

Coq < | le_n : le n n

Coq < | le_S : forall m:nat, le n m -> le n (S m).

Son prinipe deréurrene:

Coq < Chek le_ind.

le_ind

: forall (n : nat) (P : nat -> Prop),

P n ->

(forall m : nat, le n m -> P m -> P (S m)) ->

forall n0 : nat, le n n0 -> P n0

ExerieProuver:

forall (n m:nat), (le n m)->(le (S n) (S m))

forall (n:nat), (le O n)

forall (n m:nat), (le n m)->(le m p)->(le n p)

1.7.3 Un exemple dangereux

Voii un exemple pour illustrer lessubtilités propres aux mathématiquesformelles. Onpeut

proposer unedénition alternative à le:

Coq < Indutive le_a : nat -> nat -> Prop :=

Coq < | le_aO : forall n:nat, le_a 0 n

Coq < | le_aS : forall n m:nat, le_a n m -> le_a (S n) (S m).

Or ette dénition, qui semble raisonnable et est mathématiquement saine, est peu prati-

able telle quelle. En partiulier la preuve de la transitivité est très pénible; on peut utiliser

ette dénition, mais pour ertaines propriétés, il vaut mieux ommener par prouver d'abord

l'équivalene ave ladénitionpréédente. L'onrisquesinon de s'ensablerrapidement.

Exemple de développement Gallina :

Sémantique d'un mini-langage

Le but de e ours est d'illustrer sur un exemple les fontionnalités du langage de spéi-

ation Gallina assoié au Calul des Construtions Indutives et implanté dans l'assistant à la

démonstration Coq.

L'exemple hoisitraitede lasémantiqued'unmini-langage deprogrammation impératif (ty-

page,évaluationetsémantiqueaxiomatique).Plusieurssolutionsàlamodélisationdesdiérentes

notions sont proposées.Les diérentesonstrutions utilisées danse hapitre seront expliquées

plusen détaildansles prohainsours.

2.1 Introdution

Gallina est lenomdonné aulangage de spéiation del'assistant Coq. Il permetde dénir:

destypesde donnéesstruturés,

desfontionsqui peuvent être réursivessurlastruture desdonnées,

desrelations spéiéesindutivement par un ensemblede propriétés de fermeture,

desformules du aluldesprédiatsd'ordre supérieur.

Ces aratéristiques du langage le rendent partiulièrement adapté à la formalisation des

mathématiques etnotamment del'informatique théorique.

Onpourranotamment sefaireuneopinion sureslogan enonsultant surlapagede Coqla

listedes développementsréaliséspar les utilisateurs.

Les dénitionsintervenant ensémantiquedeslangagessereprésentent partiulièrement bien

en Gallina:

lesarbresdesyntaxeabstraiteseodentnaturellementommedestypesde donnéesstru-

turés,

l'ordre supérieur permettra de manipuler aisément les mémoires qui pourront être repré-

sentées pardes fontionsou bienlesassertions quisont desprédiats surlamémoire,

lesdénitions sémantiquestelles queletypage oul'évaluation, lorsqu'ellessontprésentées

par un ensemble de règles d'inférene se traduisent immédiatement en dénitions indu-

tives.

Nous détaillons ii laformalisation de la sémantique d'un petit langage de programmation

danslestyleimpératif.

Ce genre de formalisation (aussi appelé plongement profond) onstitue une alternative à la

preuve de programme impératif. Une autre alternative est le plongement simple (aussi appelé

plongement superiel) qui simule les propriétés des programmes impératifs à partir de leur

interprétation dansun langage purement fontionnel. La sémantique est alors impliite dans la

tradution. Cette question sera évoquée dans le hapitre traitant de la preuve de programmes

impératifs.

2.2 Présentation du problème

Notre langage omprend lesommandes suivantes, à partir d'unensembledevariables

X

C ::=

| X

E

| C ₁ ; C ₂

|

E

C ₁

C ₂

|

E

C

Fig. 2.1 Syntaxe desommandes

Lesexpressions sont forméesdeonstrutions entières etbooléennessimplesetsontdonnées

par lasyntaxede lagure2.2.

E ::= X ^s

|

|

| E 1

E 2

| n

|

E

| E ₁

E ₂

s ::=

|

op

::= + | − | ∗ | . . .

Fig.2.2 Syntaxe desexpressions

On herhe à dénir des sémantiques statiques, opérationnelles naturelles et axiomatiques

pourelangage.Toutessontreprésentéesensémantiquenaturelleparladénitiond'unerelation

entreun programmeet desvaleurs. Cetterelation seradérite àl'aide desrèglesd'inférene.

2.2.1 Sémantique statique

Il s'agit de déterminerde manièrestatiquesans l'exéuterqu'un programme estbien formé.

Ii il faut vérier que dans les expressions onditionnelles ou de boule, les tests sont faits sur

desexpressionsbooléennes.Celanousamèneàdénirunerelationdetypagesurlesexpressions.

Lesdeux valeursseront lesdeux sortesnat etbool.

La relation detypage

E : s

X ^s : s

:

:

n :

E ₁ :

E ₂ :

E ₁

E ₂ :

E :

null

E :

E ₁ :

E ₂ :

E ₁

E ₂ :

Fig.2.3 Sémantique statiquedesexpressions

Pour les ommandes,ondénit larelation

C :

skip

:

E : s X

E :

C 1

C 2

C ₁ ; C ₂ :

E :

C 1 :

C 2 :

if

E

C ₁

C ₂ :

E :

C :

while

E

C :

Fig. 2.4 Sémantiquestatique desommandes

2.2.2 Sémantique opérationnelle

La sémantique opérationnelle dénit le programme omme une transformation de l'état de

lamémoire. Cettemémoire assoieà haquevariableet sorte unevaleur quisera une onstante

entière

n

b

jour:si

x

s

m(x, s)

variable

x

s

v

m[x ← v]

x

v

v

Sémantique des expressions

On a besoin de la relation qui assoie à haque mémoire

m

E

v

représentantlerésultatdel'évaluationde

E

m

m ⊢ E ⊲v

On utilisera des onstantes et des fontions sur le domaine des valeurs réalisant les opérations

booléennes et arithmétiques. Elles seront notées en italique en utilisant le même identiateur

que dansla syntaxe:ainsi, à laonstrution syntaxique xor orrespond lafontion sémantique

xor.

m ⊢ X ^s ⊲ m(X, s) m ⊢

⊲

m ⊢

⊲

m ⊢ n ⊲ n m ⊢ E ₁ ⊲ b ₁ m ⊢ E ₂ ⊲ b ₂

m ⊢ E ₁

E ₂ ⊲ b ₁

b ₂

m ⊢ E ⊲ n m ⊢

E ⊲

n

m ⊢ E ₁ ⊲ n ₁ m ⊢ E ₂ ⊲ n ₂ m ⊢ E ₁

E ₂ ⊲ n ₁

n ₂

Fig. 2.5Sémantiquedesexpressions

Sémantique des ommandes

La relation

m ⊢ C ⊲ m ^′

C

m

transforme en unemémoire

m ^′

m ⊢

⊲ m m ⊢ E ⊲ v m ⊢ X

E ⊲ m[X ← v]

m ⊢ C ₁ ⊲ m ₁ m ₁ ⊢ C ₂ ⊲ m ^′ m ⊢ C ₁ ; C ₂ ⊲ m ^′ m ⊢ E ⊲

m ⊢ C ₁ ⊲ m ^′

m ⊢

E

C ₁

C ₂ ⊲ m ^′

m ⊢ E ⊲

m ⊢ C ₂ ⊲ m ^′ m ⊢

E

C ₁

C ₂ ⊲ m ^′ m ⊢ E ⊲

m ⊢ C ⊲ m 1 m 1 ⊢

E

C ⊲ m ^′

m ⊢

E

C ⊲ m ^′

m ⊢ E ⊲

m ⊢

E

C ⊲ m

Fig. 2.6 Sémantique desommandes

2.2.3 Sémantique axiomatique

Il s'agit d'interpréter les ommandes omme destransformations de prédiats, esprédiats

spéiant despropriétés delamémoire. Si

P

Q

C

alors ondénitune relation

{ P } C { Q }

C

mémoire vériant

P

Q

Nousauronsbesoindetransformateursdeprédiatspartiuliers.Laonjontionetl'implia-

tiondedeuxprédiatsserontnotéspar

P ∧ Q

P ⇒ Q

x

E

alors

P[x ← E]

m

P(m[x ← v])

v

valeur telleque

m ⊢ E ⊲ v

w

E = w

m

assoielapropriété

v = w

v

m ⊢ E ⊲ v

La dénitionde ette relation estdonnéepar les règlesd'inférene de lagure2.7.

{ P }

{ P } { P [X ← E] } X

E { P } { P } C ₁ { P ₁ } { P ₁ } C ₂ { Q } { P } C ₁ ; C ₂ { Q } { P ∧ (E =

) } C 1 { Q } { P ∧ (E =

) } C 2 { Q }

{ P }

E

C ₁

C ₂ { Q } { P ∧ (E =

) } C { P } { P }

E

C { P ∧ (E =

) }

P ⇒ P ₁ { P ₁ } C { Q ₁ } Q ₁ ⇒ Q { P } C { Q }

Fig. 2.7 Sémantiqueaxiomatique desommandes

On remarque que toutes es dénitions font intervenir des notions dénies dans le méta-

langage tellesque lamémoire,les domainessémantiques,les opérationssures domaines,...

2.2.4 Quelques propriétés

Parmi les propriétés intéressantes àmontrer on a:

Déidabilité delaorretion par rapportàlasémantiquestatique(algorithme detypage).

Touteexpression orretement typée admetune valeur.

Corretionde lasémantiqueaxiomatique.Si

{ P } C { Q }

C

P

Q

2.3 Spéiation Gallina

Nous montrons omment représenterlathéorie préédenteen Gallina.

2.3.1 Les expressions

Dénitions

On hoisit de représenter les variables et les opérateurs binaires par desensembles paramé-

triques qui pourront être instaniésdans un seondtemps. Par ontre, les fontionsbooléennes

sont représentéesde manièreonrèteparunonstruteur dutype dedonnées. Cehoixpermet

d'illustrerdeux traitements possiblesdesopérations dulangage quel'on herhe à modéliser.

Coq < Parameter name : Set.

Coq < Indutive sort : Set :=

Coq < | Sbool : sort

Coq < | Snat : sort.

Coq < Parameter op : Set.

Coq < Indutive expr : Set :=

Coq < | Var : name -> sort -> expr

Coq < | Tr : expr

Coq < | Fa : expr

Coq < | Xor : expr -> expr -> expr

Coq < | Num : nat -> expr

Coq < | Null : expr -> expr

Coq < | Opn : op -> expr -> expr -> expr.

Expressions orretes

Leprédiatexprorrettraduitlarelationdéritedanslagure2.3.Chaquerègled'inférene

dénissant la relation est traduite en un onstruteur de la dénition indutive. Les variables

libresdesdénitionsdeviennent desvariablesquantiéesuniversellement danslesonstruteurs.

Coq < Indutive exprorret : sort -> expr -> Prop :=

Coq < | orvar : forall (n:name) (s:sort), exprorret s (Var n s)

Coq < | ortr : exprorret Sbool Tr

Coq < | orfa : exprorret Sbool Fa

Coq < | orxor :

Coq < forall b :expr,

Coq < exprorret Sbool b ->

Coq < exprorret Sbool -> exprorret Sbool (Xor b )

Coq < | ornum : forall n:nat, exprorret Snat (Num n)

Coq < | ornull :

Coq < forall e:expr, exprorret Snat e -> exprorret Sbool (Null e)

Coq < | orop :

Coq < forall (o:op) (e f:expr),

Coq < exprorret Snat e ->

Coq < exprorret Snat f -> exprorret Snat (Opn o e f).

Domaines sémantiques

Il s'agit dereprésenter ledomaine sémantique des variables, à haque sorte de variableor-

respondun ensembleau sens mathématique qui sera représentépar un type dedonnées Coq ii

le type des booléens ou des entiers. Le domaine sémantique des valeurs semval est représenté

par lasommedisjointe desdeuxtypes.

Coq < Indutive semval : Set :=

Coq < | Bool : bool -> semval

Coq < | Nat : nat -> semval.

Interprétation des fontions

Lesfontionssémantiquesorrespondantauxopérateursonretspeuventêtreexpliitement

programmées. Par ontre lasémantiquedesopérationsarithmétiques (qui sont vues demanière

paramétrique) doit êtrefournie ommeunparamètre.

Coq < Definition boolxor (b1 b2:bool) : bool :=

Coq < if b1 then if b2 then false else true else b2.

Coq < Definition iszero (n:nat) : bool :=

Coq < math n with

Coq < | O => true

Coq < | S n => false

Coq < end.

Coq < Parameter semop : op -> nat -> nat -> nat.

Compatibilité entre sorteset valeurs

Ilnousfaudrarelierlasortedesexpressionsetletypedeleurinterprétationsémantique.Pour

ela, on dénit sort_val une fontion des domaines sémantiques dans les sortes qui à haque

valeursémantiqueassoiela sorteorrespondante.

Coq < Definition sort_val (v:semval) : sort :=

Coq < math v with

Coq < | Bool b => Sbool

Coq < | Nat n => Snat

Coq < end.

Onutiliseraégalementunerelationompatentrelesvaleursetlessortestelleque

(

v)

soit équivalent à

∃ b :

.v = (

b)

(

v)

équivalent à

∃ n :

.v = (

n)

Coq < Indutive valbool : semval -> Prop :=

Coq < valbool_intro : forall b:bool, valbool (Bool b).

Coq < Indutive valnat : semval -> Prop :=

Coq < valnat_intro : forall n:nat, valnat (Nat n).

Coq < Definition ompat (s:sort) (v:semval) : Prop :=

Coq < math s with

Coq < | Sbool => valbool v

Coq < | Snat => valnat v

Coq < end.

On remarque que le dénition indutive de valbool est un odage indutif diret de la propo-

sition fun

x

b

x

b

dane entreompatetsort_val.

Coq < Theorem ompat_sort_val :

Coq < forall (s:sort) (v:semval), ompat s v -> s = sort_val v.

Une alternative est dereprésenterlanotion deompatibilité par unprédiat indutif:

Coq < Indutive ompat1 : sort -> semval -> Prop :=

Coq < | ompat_bool : forall b:bool, ompat1 Sbool (Bool b)

Coq < | ompat_nat : forall n:nat, ompat1 Snat (Nat n).

Lesdeux dénitionssont équivalentes, remarquonsquedansleseond aslapropriété

(

v) → ∃ n :

.v = (

)

néessite une inversion du prédiat indutif alors que dans le as de ompat 'est une simple

La mémoire

La mémoire est représentée omme une fontion qui à toute variable et sorte assoie une

valeursémantique, ilfaudra deplus supposerqueette valeur estompatible ave lasorte.

Coq < Definition memory := name -> sort -> semval.

Valeur d'une expression

Pour onstruirelarelationentreune expressionetsavaleur,on peutsedonnerune mémoire

ommeparamètredansuneSetion,lorsquelasetionestfermée,lesnotions introduitesseront

automatiquement abstraitespar rapport auxparamètres dont elles dépendent.

Coq < Setion Valexpr.

Coq < Variable memstate : memory.

Coq < Hypothesis memstate_orret :

Coq < forall (n:name) (s:sort), ompat s (memstate n s).

La dénition exprval formalise la sémantique des expressions telle qu'elle est présentée à la

gure2.5.

Coq < Indutive exprval : expr -> semval -> Prop :=

Coq < | valvar : forall (n:name) (s:sort), exprval (Var n s) (memstate n s)

Coq < | valtr : exprval Tr (Bool true)

Coq < | valfa : exprval Fa (Bool false)

Coq < | valxor :

Coq < forall (f g:expr) (bf bg:bool),

Coq < exprval f (Bool bf) ->

Coq < exprval g (Bool bg) -> exprval (Xor f g) (Bool (boolxor bf bg))

Coq < | valnum : forall n:nat, exprval (Num n) (Nat n)

Coq < | valtzero :

Coq < forall (f:expr) (nf:nat),

Coq < exprval f (Nat nf) -> exprval (Null f) (Bool (iszero nf))

Coq < | valopn :

Coq < forall (o:op) (f g:expr) (nf ng:nat),

Coq < exprval f (Nat nf) ->

Coq < exprval g (Nat ng) -> exprval (Opn o f g) (Nat (semop o nf ng)).

Onpeutmaintenant énonerlethéorèmequiditquetouteexpressionorretement typéeadmet

une valeur.

Coq < Theorem expr_val_or : forall (E:expr) (s:sort),

Coq < exprorret s E -> exists v : semval, exprval E v.

Lapreuveparréurrenenéessiteunlemmeplusfortquiditquelavaleuraluléeestompatible

ave lasorte del'expression.

Coq < Lemma expr_val_or_dom : forall (E:expr) (s:sort),

Coq < exprorret s E -> exists2 v : semval, ompat s v & exprval E v.

Représentation de la mémoire à l'aide de types dépendants

Letraitementdelarelationentrelasortedel'expressionetledomainedelavaleursémantique

est lourd. On peut proter de l'expressivité du langage de spéiation de Coq pour utiliser

d'autresformalisations.Ononstruitunefamilledépendantesval(dontletypeestsort

→

qui à lasorte Sbool assoiele typebool età Snatassoiele type nat.Le domaine sémantique

semvalpourraitêtrereprésentéparunoupleforméd'unesorte

s

(

s)

ei revient juste à oder une somme disjointe expliitement à l'aide d'un séleteur

s

hampdontle typevarie suivant leséleteur.

On peuttirer partie de ette représentation pour simplier la formalisation en rendant im-

pliite dansladénitionde lamémoire lanotion deompatibilité.

Coq < Definition sval (s:sort) : Set :=

Coq < math s with

Coq < | Sbool => bool

Coq < | Snat => nat

Coq < end.

Coq < Definition memory1 := name -> forall s:sort, sval s.

Ondénit alors:

Coq < Parameter memstate1 : memory1.

Coq < Indutive exprval1 : expr -> forall s:sort, sval s -> Prop :=

Coq < | valvar1 :

Coq < forall (n:name) (s:sort), exprval1 (Var n s) s (memstate1 n s)

Coq < | valtr1 : exprval1 Tr Sbool true

Coq < | valfa1 : exprval1 Fa Sbool false

Coq < | valxor1 :

Coq < forall (f g:expr) (bf bg:bool),

Coq < exprval1 f Sbool bf ->

Coq < exprval1 g Sbool bg -> exprval1 (Xor f g) Sbool (boolxor bf bg)

Coq < | valnum1 : forall n:nat, exprval1 (Num n) Snat n

Coq < | valtzero1 :

Coq < forall (f:expr) (nf:nat),

Coq < exprval1 f Snat nf -> exprval1 (Null f) Sbool (iszero nf)

Coq < | valopn1 :

Coq < forall (o:op) (f g:expr) (nf ng:nat),

Coq < exprval1 f Snat nf ->

Coq < exprval1 g Snat ng -> exprval1 (Opn o f g) Snat (semop o nf ng).

Le lemmede orretion de l'évaluations'énonealors simplement :

Coq < Theorem expr_val_or1 : forall (E:expr) (s:sort),

Coq < exprorret s E -> exists v : sval s, exprval1 E s v.

Laformalisationetlapreuve sont plussimplesependantl'usagede typesdépendantsrendra la

formalisation de lafontion d'ériture surla mémoire plus omplexe en eet on doitavoir ave

n:name,s:sort,v:(sval s),mem:memory1

Coq < Definition update : forall (m:nat) (s':sort), sval s'.

Le simple fait de savoir que

s = s ^′

v

(

s)

ausside type

(

s ^′ )

s

s ^′

Demanière générale,en présenede typesdépendants, l'usagede l'égalitédevient déliat. Il

n'est paspossible par exemple d'érire

v = v ^′

v : (

s)

v ^′ : (

s ^′ )

s

et

s ^′

s = s ^′

notions plusomplexes d'égalité.

2.3.2 Vériation du type et évaluation onstrutive

On pourraitdénir lefaitqu'une expression

e

∀ s :

. ¬ (

s e)

En fait il est plus aisé de manipuler des dénitions positives et don de dénir une notion

onstrutive d'expression erronée en énumérant les as d'éhe possibles. Si on s'intéresse à

l'interprétationonstrutivedespreuves(quenousverronsplustard)onremarquequ'unepreuve

quel'expressionerronée permetde retrouverexatementlanaturede l'erreur àsavoirdansquel

sousterme unopérateur aété appliquéà uneexpression d'unesorte non adaptée.

Coq < Indutive exprerr : expr -> Prop :=

Coq < | errxorl : forall b :expr, exprorret Snat b -> exprerr (Xor b )

Coq < | errxorr : forall b :expr, exprorret Snat -> exprerr (Xor b )

Coq < | errtzero : forall b:expr, exprorret Sbool b -> exprerr (Null b)

Coq < | erropl :

Coq < forall (op:op) (b :expr),

Coq < exprorret Sbool b -> exprerr (Opn op b )

Coq < | erropr :

Coq < forall (op:op) (b :expr),

Coq < exprorret Sbool -> exprerr (Opn op b )

Coq < | errongxorl : forall b :expr, exprerr b -> exprerr (Xor b )

Coq < | errongxorr : forall b :expr, exprerr -> exprerr (Xor b )

Coq < | errongtzero : forall b:expr, exprerr b -> exprerr (Null b)

Coq < | errongopl :

Coq < forall (op:op) (b :expr), exprerr b -> exprerr (Opn op b )

Coq < | errongopr :

Coq < forall (op:op) (b :expr), exprerr -> exprerr (Opn op b ).

Le théorème exprimant ladéidabilité du typage et de l'évaluationest juste une preuve dufait

que pour toute expression

E

v

E

formée. Le fait d'utiliser une interprétation onstrutive de la disjontion et de l'existentielle

assure l'existene d'un algorithme permettant de déider dans quel as on est et de aluler

eetivement lavaleur.Onétablitunrésultatdedéidabilité sansavoiràreprésenterunenotion

de alulabilité.

Coq < Theorem expr_val_hek_proof : forall E:expr,

Coq < {v : semval | exprval E v & exprorret (sort_val v) E} + {exprerr E}.

Sionnes'intéresse qu'àlapartiealuldeette preuve alorson aunefontion eval_progquià

touteexpressionassoieunevaleurouriendutout.Cettefontionpeutégalement sereprésenter

dansGallina enutilisant letype optionde Coq.

Coq < Print option.

Indutive option (A : Type) : Type :=

For Some: Argument A is impliit

For None: Argument A is impliit and maximally inserted

For option: Argument sope is [type_sope℄

For Some: Argument sopes are [type_sope _℄

For None: Argument sope is [type_sope℄

Coq < Impliit Arguments Some [A℄.

La fontion eval_progsealulepar point xestruturel surl'expression.

Coq < Fixpoint eval_prog (e:expr) : option semval :=

Coq < math e with

Coq < | Var n s => Some (memstate n s)

Coq < | Tr => Some (Bool true)

Coq < | Fa => Some (Bool false)

Coq < | Xor f g =>

Coq < math eval_prog f, eval_prog g with

Coq < | Some (Bool bf), Some (Bool bg) => Some (Bool (boolxor bf bg))

Coq < | _, _ => None (A:=semval)

Coq < end

Coq < | Num n => Some (Nat n)

Coq < | Null f =>

Coq < math eval_prog f with

Coq < | Some (Nat nf) => Some (Bool (iszero nf))

Coq < | _ => None (A:=semval)

Coq < end

Coq < | Opn o f g =>

Coq < math eval_prog f, eval_prog g with

Coq < | Some (Nat nf), Some (Nat ng) => Some (Nat (semop o nf ng))

Coq < | _, _ => None (A:=semval)

Coq < end

Coq < end.

LasetionValexpr,ouvertepage 27estalorsferméeequiapoureetd'abstrairelesdénitions

eetuéesdanslasetionparrapportàmemstateetàl'hypothèsememstate_orretlorsqu'elle

estutilisée.

Coq < End Valexpr.

Coq < Chek eval_prog.

eval_prog

: memory -> expr -> option semval

2.3.3 Les ommandes

Lareprésentationdelasyntaxeetdelasémantiquestatiquedesommandessuitlesdénitions

desgures 2.1et2.4.

Syntaxe

Coq < Indutive om : Set :=

Coq < | skip : om

Coq < | aff : name -> expr -> om