, même si l'implantation des types normalisés n'est pas encore faite
, )))))). -->= (O
, Déclaration du type normalisé À partir d'ici on suppose que les types normalisés ont été implantés dans Coq
, Definition Z1:Set := Norm(N2 , nfN2)
, Check class(N2, nfN2
, N2 , nfN2) Les principes d'élimination du type normalisé peuvent être générés automatiquement : Print Z1_rec
, Une preuve sur les types normalisés On illustre ci-dessous l'utilisation de la conversion sur les types normalisés. Goal class
, Pour dénir une fonction sur un type normalisé, il faut d'abord en dénir une sur son type support
, Definition SZ: Z1 -> Z1 :=
, L'évaluation d'une telle fonction utilise la nf -réduction
, ))))). -->class(N2, vol.2
, EXEMPLES DE TYPES NORMALISÉS
, Auto-stabilisation
, Les algorithmes auto-stabilisants sont des algorithmes répartis ayant la particularité suivante : en partant de n'importe quelle conguration initiale, l'algorithme fait revenir le réseau dans une conguration correcte (légitime) au bout d'un temps ni. L'ensemble des congurations légitimes, déterminé par ailleurs, est l'ensemble des congurations correspondant à un déroulement "autorisé" de l'algorithme. Par exemple pour un algorithme de passage de jeton dans un anneau, les congurations légitimes sont celles dans lesquelles il y a un et un seul jeton sur le réseau
, On dira que A est auto-stabilisant pour L si : Toute exécution de A à partir de n'importe quelle conguration initiale aboutit au bout d'un temps ni dans L
, En général on utilise une dénition moins générale mais plus précise de l'auto-stabilisation : Dénition 8.2.2 (Auto-stabilisation 2)
, On dira que A est auto-stabilisant pour L si : 1. Toute exécution de A à partir de n'importe quelle conguration initiale
, Toute transition de A partant d'un élément de L aboutit dans L (stabilité)
, cette dénition est en fait très semblable à la précédente car un algorithme auto-stabilisant pour L au sens de la première dénition est auto-stabilisant pour un sous-ensemble de L au sens de la deuxième
, pour une raison quelconque, a (ponctuellement) un comportement imprévu qui brise le déroulement correct de l'algorithme, alors au bout d'un temps ni le déroulement correct pourra reprendre, sans intervention extérieure. Signalons que le point 1 de la dénition ci-dessus implique qu'une exécution de l'algorithme ne peut pas s, L'intérêt de l'auto-stabilisation réside bien entendu dans la tolérance aux pannes et aux fautes : si une machine du réseau
, En Coq On représente en Coq l'algorithme réparti par une relation sur les congurations, représentant les transitions eectuées par l'algorithme. Celui-ci étant non déterministe, il n'est en eet pas possible de dénir une fonction correspondante. On commence donc par quelques dénitions sur les relations
, Un algorithme réparti sera donc de type A -> A -> Prop. Puis on déclare un certain nombre de notions utiles sur les relations ainsi que des facilités d'écriture pour ces notions
, On dénit l'union de deux relations (\/ représente le ou sur Prop) : Definition explicit_union
, A->A->Prop:= relplus_1step: (x,y:A)(R x y)->(explicit_rel_plus R x y) | relplus_trans1: (x,y,z:A)(R x y)->(explicit_rel_plus R y z) ->(explicit_rel_plus R x z)
, On dénit ensuite les notions de réductibilité et irréductibilité d'un terme t par une relation R (considérée comme un système de réduction). (explicit_irr R t) sera prouvable s'il n'existe pas de successeur par R de t. (explicit_red R t) sera prouvable s'il en existe un. Definition explicit_irr :=
, Puis on clôt cette section : End extension_rels
, De même on utilisera les notations (rel_plus R), (star R), (irr R t) et (red R t), On dénit ensuite quelques facilités syntaxiques permettant d'utiliser les notations de manière intuitive
, Syntactic Definition union := (explicit_union ?)
, Puis on démontre quelques propriétés sur les relations. Voici par exemple la démonstration de transitivité de la clôture transitive d'une relation R sur un type T : Lemma star_star: (T:Set)(R:T -> T -> Prop
, On ouvre une nouvelle section en déclarant (comme variables temporaires) à nouveau le type des congurations, puis la relation R représentant l'algorithme, puis le prédicat L représentant les congurations légitimes. Tous seront donc des paramètres des prochaines dénitions : Section selfstab
, Type des configurations *) Variable str:Set
, Variable R: str -> str -> Prop
, Configurations légitimes *) Variable L: str -> Prop
, On dénit ensuite les diérentes propriétés nécessaires à l'auto-stabilisation : la stabilité et la convergence. La stabilité ne pose pas de problème : (* Clôture de L par R: on ne sort plus des états légitimes une
, Pour dénir la convergence, on doit dénir une variante de la notion d'accessibilité (voir section 5.4.4) ; nous donnons tout d'abord une reformulation de cette dernière 1 : Inductive finite, A->Prop := finite_intro : (x:A)((y:A)(R x y)->(finite R y))->(finite R x)
, On dira que L est inévitable pour un terme t si toutes les réductions partant de t par R atteignent L. On remarque que cette notion correspond à la propriété d'un ensemble d'être le bar d'un élément pour une réduction, Pour cela on utilise la propriété inductive suivante : Inductive inevitable : str -> Prop := (* Si x
, x:str) (L x) -> (inevitable x) (* Si L est inévitable pour tous les successeurs de x, alors L est inévitable pour x*) | all_inevitable:(x:str) ((y:str) (R x y) -> (inevitable y)) ->
, On peut maintenant dénir l'auto-stabilisation de R : Definition self_stab:= closure /\ (w:str) (inevitable w)
, on remarque que l'ordre des arguments de la relation est inversé par rapport à la section 5
, On peut donner une autre formulation dans le cas où le nombre de congurations est ni : L est inévitable si et seulement si il n'y a pas de cycle en dehors de L. On commence par dénir la propriété correspondant à l'absence de cycle en dehors de L : (* Pas de cycle commençant par une configuration non légitime *) Definition no_cycle:= (w:str
, Lemma no_cycle2: (w:str) no_cycle ->~(L w) ->~(Rplus w w)
, Et l'autre formulation de l'auto-stabilisation, équivalente à la première seulement si le nombre de congurations est ni (en toute rigueur, il faut faire la preuve dans Coq de cette équivalence
, Signalons une dernière formulation de la convergence : une relation R converge vers L si sa restriction aux éléments en dehors de L termine
, Puis on donne la dénition de l'auto-stabilisation : Definition self_stab3:= closure /\ (w:str)(finite restrict_R x)
, Nous allons maintenant implanter dans Coq la méthode de preuve d'auto-stabilisation de, vol.01
, Nous donnerons plus loin les hypothèses précises d'application de cette méthode, mais précisons déjà qu'elle s'applique sur des réseaux linéaires, c'est-à-dire dont chaque n÷ud a au plus deux voisins
, Les mots : une modélisation intéressante Les intérêts de cette topologie particulière sont les suivants : Les congurations peuvent être représentées par des mots sur l
, Comme un n÷ud change d'état en fonction de ses deux voisins, les membres gauches des règles du système de réécriture seront de taille inférieure ou égale à 3. Comme d'autre part la topologie du réseau ne change pas au cours de l'exécution de l'algorithme, la taille des mots n'est pas modiée par le système de réécriture, L'algorithme peut être modélisé par un système de réécriture sur les mots représentant les congurations
, un algorithme d'exclusion mutuelle à 4 états. Le système considéré est un réseau linéaire à N machines, numérotées de 0 à N ? 1. Chaque n÷ud du réseau a quatre états possibles : {0, 1, 2, 3}, sauf le n÷ud 0 (la machine bottom) qui ne peut avoir que les deux états {1, 3} et le n÷ud N ? 1 (la machine top) qui ne peut avoir que les deux états {0, p.2
, Require Export PolyList. (* Rappel: Inductive list
, On commence une nouvelle section, dans laquelle on déclare (temporairement, voir section 5.6) le type de l'alphabet : 9
, Section Ensf_sec. Variable ens_symb:Set
, Ensuite on dénit les mots comme les listes sur l'alphabet : Definition Word :=
, Syntactic Definition epsilon := (nil ens_symb)
, On dénit ensuite le type des ensembles de mots : Definition wordset := Word -> Prop
, La première opération sur les ensembles est la construction de l'ensemble contenant un mot donné : Definition lword : Word->wordset :=
, Puis la dénition de l'ensemble des mots construits : par concaténation de mots de deux ensembles : lconc 1 , par mise à la puissance de mots d'un ensemble : lpuiss
, Definition lconc : wordset->wordset->wordset :=
, wordset->wordset := [l:wordset]Cases n of | O =>
,
, Definition lstar : wordset->wordset :=
, Definition lplus : wordset->wordset :=
, La fonction app eectue la concaténation de deux mots
, Représentation d'algèbres non libres en théorie des types On démontre ensuite quelques résultats sur ces opérations ; à titre d'exemple, on montre ici la preuve d'un principe d'induction sur les ensembles de la forme
, Lemma induction_star : (P:Word->Prop)(l:wordset) ((n:nat)(w:Word) (lpuiss n l w)->(P w) ) -> ( (w:Word)(lstar l w)->(P w) )
, On va donc représenter un système de réécriture comme la clôture par contexte d'une relation représentant les règles l i ?? r i . On a vu que les règles des algorithmes que nous considérons sont réparties en trois ensembles de règles T , M et B, correspondant chacun à une extension au contexte diérente : M est étendu à droite et à gauche, T est étendu seulement à gauche car ses règles ne s'appliquent qu'à la n du mot, B est étendu seulement à droite car ses règles ne s, ) que les algorithmes répartis seraient représentés par des relations sur les mots, correspondant à des systèmes de réécriture sur les mots
, On déclare les trois relations correspondant aux trois ensembles de règles : Variables T
, Puis on dénit la relation de réécriture associée, clôture à gauche pour T, à droite pour B, et à gauche et à droite pour M
,
,
, :A)~(w=epsilon) ->~(w'=epsilon) -> (M u v) -> (TBM_R (w^(u^w')) (w^(v^w')))
, Une des hypothèses admises sur le système de réécriture représentant un algorithme réparti est qu'il ne change pas la topologie du réseau. T, B et M doivent donc préserver la taille des mots. On dénit donc la longueur d'un mot ainsi que la propriété length_preserve. On dénit également la propriété permettant de caractériser deux relations s'appliquant sur des termes de même taille, On voit ici que pour M , les contextes droite et gauche ne doivent pas être vides
, Les hypothèses Nous énonçons maintenant les hypothèses sur l'algorithme A permettant d'appliquer notre méthode de preuve d'auto-stabilisation ; nous verrons plus loin leur traduction en Coq : 1. A se présente sous la forme des trois ensembles de règles expliqués plus haut
, Comme pour l'algorithme de Ghosh, le nombre d'états possibles pour chaque n÷ud du réseau est ni
, A est stable pour
, A ne s'arrête pas en dehors de L
, A privé des règles de T termine
, JBM01] consiste en deux étapes. L'une est faite une fois pour toutes (c'est la partie générique de la preuve) et l'autre est à appliquer pour chaque nouvelle preuve d'algorithme (c'est la partie spécique)
, Dénition 9, vol.5
,
, Dénition 9, vol.5
, Soit E un alphabet et E sa version activée
, Un mot contenant au moins une lettre active est appelé actif
, Un mot ne contenant aucune lettre active est appelé inactif
, On dénit également l'opération de désactivation retournant la version inactive d'un mot
, On met ici le type de l'alphabet en paramètre, mais on instanciera ce paramètre par nat à la n de cette section, an d'avoir une représentation concrète des lettres, Représentation des mots activés dans Coq On commence par dénir les lettres actives et inactives à l'aide d'un type inductif à deux constructeurs (un pour les lettres actives, un pour les lettres inactives)
, On dénit maintenant le type des mots activés : stria, l'opération de désactivation d'une lettre destr_lettre, ainsi que d'autres opérations de manipulation de lettres actives et inactives. Notamment active_last permet d'activer la dernière lettre d'un mot, ce qui permettra de construire les réductions actives, vol.9
, Syntactic Definition stria :=(Word lettre)
, Definition destr_lettre :lettre -> A :=
, | (act f) => l end, = Cases w of | nil =>
, stria:= Cases x of | nil => epsilon | (cons (inact n) epsilon) => (act n)::epsilon | (cons (act n) nil) => (act n)::epsilon | (cons x w) => x::(active_last w) end. On dénit quelques prédicats sur les mots activés : être actif, inactif, etc. Inductive active_word_strict: stria -> Prop:= | strac_act: (u:stria
, | strac_ina: (u:stria) (c:lettre)
, Inductive active_word: stria -> Prop:= | empty_act: (active_word epsilon) | strict_act:(w:stria) (active_word_strict w) -> (active_word w)
, Inductive inact_word:stria -> Prop := | empty_ina:(inact_word epsilon) | strin_ina:(u:stria) (c:A)
, Inductive pure_active:stria -> Prop := | empty_pact:(pure_active epsilon) | strac_pact:(u:stria) (c:A)
, Les réductions actives On dénit l'extension aux mots activés d'un système de réécriture sur les mots
, Soit R un système de réécriture sur les mots formés sur l'alphabet A, on étend R aux mots activés de la manière suivante : Soit u et u deux mots sur A tels que u se réécrit en u et P l'ensemble des positions du sous-mot de u réécrit. Soit w un mot activé tel que u = desactive(w)
, en ce qui concerne l'activation des lettre de w : si active_pos(w) ? P = ?, alors active_pos(w ) = active_pos(w) sinon active_pos(w ) = active_pos(w) ? P . On dira alors que la partie active s
, Par exemple, pour l'exemple de Ghosh, on a les réductions suivantes (le sous-mot réécrit est 30, qui se réécrit en 10
, Une étape de réduction active de R est une étape de réduction de R dans laquelle le sous-mot réécrit est actif, vol.9
, Dénition 9, vol.5
, Une réduction active de R est une réduction : commençant par un mot w dont la dernière lettre est la seule lettre active
, Par exemple, la réduction suivante par l'algorithme de Ghosh est active : #312# ?? M 2 #322# ?? M 1 #332# ?? T 1 #330# ?? M, vol.2, p.300
, On voit que la partie active se propage jusqu'à contenir complètement le mot. Nous verrons plus loin que les réductions actives sont cette classe de réductions qu'il sut de prouver convergentes pour prouver l'auto-stabilisation de l'algorithme. Intuitivement, tant qu'une partie d'un mot n'est pas active, il n'est pas pertinent de considérer les réductions qui s'y appliquent
, A étaient une reformulation de A sur les mots activés, telle que la partie active est propagée si la réécriture s'applique sur une partie active, Représentation des réductions actives On a vu que les réductions actives d'un algorithme
,
, Nous aurons également besoin dans la suite de considérer les relations ne s'appliquant qu'aux mots inactifs ; c'est pourquoi nous dénissons la propriété suivante, qui caractérise de telles relations : Definition Rel_inactive:=[R:stria -> stria -> Prop] (u,v: stria
, Pour cela on commence par déclarer les trois ensembles de règles. Ces derniers sont supposés avoir le type stria -> stria -> Prop mais ne s'appliquent qu'aux mots inactifs : Section active_red. Variable A:Set
, Hypothesis T_in: (Rel_inactive ? T)
, Hypothesis B_in: (Rel_inactive ? B)
, Hypothesis M_in: (Rel_inactive ? M)
, Représentation d'algèbres non libres en théorie des types Le mot-clé Hypothesis permet d'introduire une variable temporaire, de la même manière que Variable. Toutes ces hypothèses seront donc à démontrer à chaque cas particulier, On dénit ensuite la relation de réécriture sur les mots inactifs en utilisant TBM_R sur T, B et M. (* La réécriture sur les mots inactifs *) Definition R := (TBM_R A T B M)
, Restriction de R aux mots n'appartenant pas à L *) Definition R' := (restrict_R A R L)
, On dénit également les restrictions de R à {T} et à {M,B}. Cette dernière correspond à l'hypothèse
, Inductive Top: stria -> stria -> Prop := | TopT: (u,v,w:stria) (T u v) -> (Top (w^u) (w^v))
, Inductive RmoinsTop:stria -> stria -> Prop := | B_B': (u,v,w:stria) (B u v) -> (RmoinsTop (u^w) (v^w))
, | M_M': (u,v,w,w':stria)~(w=stre) ->~(w'=stre) -> (M u v) -> (RmoinsTop (w^(u^w')) (w^(v^w')))
, On dénit ensuite la réécriture qui propage la partie active en utilisant toujours TBM_R sur les versions "activées" de T, B et M : (* Les versions activées de
, Definition Bact:=(actify A B)
, Definition Mact:=(actify A M
, La réécriture sur les mots qui propage la partie active *) Definition Ract := (TBM_R A Tact Bact Mact)
, Restriction: *) Definition Ract' := (restrict_R A Ract L)
, Inductive Topact: stria -> stria -> Prop := | TopTa: (u,v,w:stria)
, On remarque que si R'?Ract' termine, alors R est auto-stabilisant pour L. En eet, l'union des deux relations permet de simuler R sur les mots actifs et inactifs. On verra plus loin que, sous certaines hypothèses, il sut même que R'?Ract' termine pour les mots dont seule la dernière lettre est active
, Les hypothèses sur le réseau Pour correspondre aux conditions décrites à la section 9.4, il faut que l'algorithme vérie les propriétés suivantes : 9
,
, A ne s'arrête pas en dehors de L
, Hypothesis T_length_p:(length_preserve ? T)
, Hypothesis M_length_p:(length_preserve ? M)
, Hypothesis B_length_p:(length_preserve ? B)
, Hypothesis RmoinsTop_termine: (x:stria) (finite stria RmoinsTop x)
, Hypothesis R_notL_red: (x:stria)~(L x) -> (EX y|(R x y))
, Hypothesis R_closure:(closure ? R L)
, Hypothesis Ract_closure:(closure ? Ract L)
, On va maintenant démontrer que si les réductions actives convergent vers L, alors toutes les réductions convergent vers L. La démonstration donnée dans
, Soient deux relations R et Q vériant la propriété de semi-commutation suivante : ?x, y, z.(R x y) ? (Q y z) ? ?y
,
, On procède par l'absurde ; supposons qu'il existe une réduction innie ? par R ? Q, commençant par un terme t. On distingue deux cas possibles (notons qu'on utilise ici le tiers exclu sur une propriété non décidable) : soit il y a un nombre ni d'étapes correspondant à Q, auquel cas il y a un élément de la réduction à partir duquel on a une réduction innie par R
, soit il y a une innité d'étapes correspondant à Q, auquel cas on peut construire une réduction innie par Q à partir de t en utilisant la semi-commutation pour "faire remonter" les étapes de Q en tête de la réduction
, On voit que cette démonstration utilisant le tiers exclu sur la propriété indécidable contenir un nombre inni d'étapes de Q n'est pas constructive. Il est donc nécessaire d'en donner une diérente dans Coq
, Représentation d'algèbres non libres en théorie des types Variable T:Set. Variables R,Q:T -> T -> Prop
, n'est pas nécessaire au début *) Hypothesis Qacc:(x:T) (finite Q x). Hypothesis commut_R:(x,y,z:T) (R x y) -> (Q y z) ->
, On déduit, par itération de l'hypothèse commut_R, la propriété suivante: *) Lemma commut_R_rec:(x,y,z:T) (star R x y) -> (Q y z) -> (EX y'| (Q x y') & (star R y' z))
, En fait, pour un x donné, on montre que si Q termine et R termine pour tous les successeurs de x par Q, alors R ? Q termine. On procède par lemmes successifs, chaque lemme utilise le précédent. On commence par montrer que si R ? Q termine pour les successeurs de x par R * o Q, alors R ? Q termine aussi
, finite R x) -> ((y:T) (EX z|(star R x z)&(Q z y)) -> (finite (union Q R) y))
, On restreint l'hypothèse : il sut que seuls les successeurs par Q soient accessibles pour R ? Q (on utilise ici la commutation), pourvu que R termine : Lemma acc_union2:(x:T) (finite R x) -> ((y:T) (Q x y) -> (finite (union Q R) y)) -> (finite (union Q R) x)
,
, On en déduit que si R termine pour tous les successeurs de x par Q * , alors R ? Q termine aussi pour x, Intros. Assumption. Intros. Apply H8. Inversion H9. Apply H10. Right. Assumption. Auto. Save
, e)) -> (finite (union Q R) x), Lemma acc_union: (x:T) ((e:T) (star Q x e) -> (finite R
, Lemma acc_union_forall: ((x:T) (finite R x)) -> ((x:T) (finite (union Q R) x))
, Intros. Apply acc_union. Auto. Save
, On sait déjà qu'il sut de montrer que R' ?Ract' termine pour montrer que R converge vers L. Le théorème suivant permet de se restreindre aux réductions actives (c'est-à-dire par Ract' et commençant par un mot
, Si la réduction Ract' termine pour tout mot ayant pour seule lettre active la dernière, alors la réduction R'?Ract' termine pour tout mot
, On exprime ce théorème de la manière suivante : Theorem topc:((x:stria) (last_active x) -> (finite stria Ract' x)) -> (x:stria)~x=epsilon -> (finite stria (union R' Ract') x)
, Représentation d'algèbres non libres en théorie des types On explique ici les deux lemmes principaux permettant de prouver ce résultat : Premièrement, pour prouver la convergence de R'?Ract', il sut de considérer les réductions commençant par un mot dont seule la dernière lettre est active. En eet, l'utilisation de lettres actives et inactives est redondante et ce sous-ensemble de mots de départ sut pour prouver la convergence sur tous les mots de la relation R de départ
, -> (finite (union R' Ract') x)
, La preuve de ce lemme intermédiaire nécessite un travail assez lourd de raisonnement sur les mots, dont nous ne donnons pas les détails ici
, Deuxièmement, si pour un x donné tous les successeurs e de x par R' sont tels que Ract' termine à partir de e, alors R'?Ract' termine à partir de x
, )) ->(finite (union R' Ract') x), Lemma Ract_only:(x:stria) (last_active x) ->((e:stria)(star R' x e)->(finite Ract' e
, Intros x accR'x accRacttrR'. Apply (acc_union ? R' Ract')
, En eet R' et Ract' semi-commutent et R' termine, donc il sut que Ract' termine pour que R'?Ract' termine
, An d'avoir une représentation concrète des lettres de l'alphabet, on décide de se placer désormais sur l'alphabet N. On redénit donc le type stria comme les mots activés sur l'alphabet des entiers
, Require Arith.(* Pour avoir la syntaxe (1) pour l'entier 1. *)
, Syntactic Definition stria :=(Word (lettre nat))
, On eectue quelques dénitions spéciques aux mots activés sur nat. Definition w_one := |+(1)+| :: epsilon. Definition set_one:= (lword (lettre nat) w_one). Definition w_zero := |+(0)+| :: epsilon
, On dénit également les ensembles correspondant aux expressions régulières 1 * , 1 + , 0 1 + , 1 1 + qui serviront dans la suite
, Definition Unstar := (lstar (lettre nat) set_one)
, Definition Unplus := (lplus (lettre nat) set_one). Inductive zero_unplus:stria -> Prop:= 9.6. LA PARTIE SPÉCIFIQUE DE LA PREUVE 145 zunpl:(u:stria)
, Inductive Un_unplus:stria -> Prop:= uunpl:(u:stria) (Unplus u) -> (Un_unplus (|+(1)+| :: u))
, Un exemple d'algorithme On utilise pour illustrer la méthode un exemple très simple d'algorithme à deux états : 0 ou 1. Les trois ensembles de règles sont les suivants
, L'ensemble des congurations légitimes est le suivant : L = {01 + } On déclare ces données de la manière suivante : Inductive ex1T: stria -> stria -> Prop := | ex1T1:(ex1T
, Inductive ex1B: stria -> stria -> Prop := | ex1B1:(ex1B (|-(0)-| :: (|-(0)-| :: epsilon)) (|-(0)-| :: (|
, Inductive ex1M: stria -> stria -> Prop := | ex1M1:(ex1M (|-(0)-| :: (|-(0)-| :: epsilon)) (|-(0)-| :: (|
, Hints Resolve ex1T1 ex1T3 ex1B1 ex1B2 ex1B3 ex1M1 ex1M2 : acthint
, Syntactic Definition ex1R :=(R ex1T ex1M ex1B)
, Syntactic Definition ex1Ract :=(Ract ex1T ex1M ex1B)
, Syntactic Definition ex1R' :=(R' ex1T ex1M ex1B ex1L)
, Syntactic Definition ex1Ract' :=(Ract' ex1T ex1M ex1B ex1L)
, Syntactic Definition ex1Tact :=(Tact ex1T)
, Syntactic Definition ex1Bact :=(Bact ex1B)
, Syntactic Definition ex1Mact :=(Mact ex1M)
, On démontre ensuite que les hypothèses sont vériées : Lemma ex1L_stable:(u:stria) (ex1L u) -> (v:stria)
,
, On verra qu'en fait la construction du graphe correspond à un raisonnement par cas sur les lettres inactives des mots. Dans notre exemple, une réduction active ne peut commencer que par une étape de l'ensemble de règles T, puisque seule la dernière lettre est active. Donc d'après les règles de T : le mot de départ est de la forme w0, le second mot d'une réduction active est soit de la forme w01 soit w11, et seules les deux dernières lettres sont actives, On obtient le graphe (incomplet) suivant : Lemma fleche1: ((u:stria) (EX v|
, |+(1)+| :: (|+(1)+| :: stre))))
, > (finite ex1Ract' u))
, > (u:stria)~(u=omega) -> (finite (union ex1R' ex1Ract') u)
, Pour prouver ce lemme, on utilise le résultat de la partie générique de la preuve : il sut de prouver que Ract' termine pour prouver que R'?Ract' termine. Le deuxième lemme correspond à un aaiblissement du premier, on introduit des expressions régulières : le mot v01 est remplacé par v01 +
, On generalise fleche1 avec les regexp *) Lemma fleche1': ((u:stria) (EX v|
,
, > (u:stria)~(u=omega) -> (finite (union ex1R' ex1Ract') u)
, Il s'agit donc maintenant de montrer (finite ex1Ract' u) avec u=XO1 + ou X11 + . Les deux lemmes suivants correspondent aux èches du graphe qui partent des deux sommets X11 + et X01 + . De X11 + on ne peut réduire que vers L
, Représentation d'algèbres non libres en théorie des types Lemma fleche_X11:(u,v:stria)(inact_word v) -> (t:stria) (pure_active t) -> u=v^t -> (Un_unplus t) ->
, on peut réduire vers X11 + et le lemme précédent permet de conclure, vers X01 + lui-même
, Donc Ract' termine : Lemma fleche_X01:(v:stria)(inact_word v) -> (u,t:stria) (pure_active t) -> u=v^t -> (zero_unplus t) ->
, termine : Theorem Ract'_finite: (u:stria)~(u=epsilon) -> (finite (union ex1R' ex1Ract') u)
, Pour la preuve, on applique les trois lemmes successivement, ce qui revient à énumérer les chemins du graphe, et à prouver pour chacun qu'il aboutit nécessairement dans L
, On applique d'abord le premier lemme, selon lequel il sut de montrer que ex1Ract' termine pour XO1 + ou X11 +
, Apply fleche1';Try Assumption
, Puis on traite les deux cas séparément en utilisant les deux lemmes fleche_X01 et fleche_X11, ce qui permet de conclure immédiatement : Intros u hyp. Decompose [ex or and] hyp. (* Séparation des deux cas *) EApply fleche_X01 with v:=x t:=x0;Auto with acthint
, 5.7) nous a servi pour prouver le premier lemme. Dans le cadre d'un environnement de preuve pour les algorithmes auto-stabilisants, on aura besoin d'un outil particulier pour trouver et prouver les lemmes. Plusieurs pistes sont possibles, l'écriture d'une tactique permettant d'engendrer et d'aider à la preuve des lemmes en développant le graphe comme ci-dessus est envisagée, On voit qu'une fois que les lemmes correspondant aux èches sont démontrés, la démonstration est relativement simple. Le théorème générique démontré plus haut
, Quel qu'il soit, l'outil devra en tout cas laisser une place à l'utilisateur pour intervenir, puisque l'étape, critique pour la réussite de la preuve, de choix des expressions régulières étiquetant le graphe ne semble pas facilement automatisable, p.149
, Chapitre 10
, Conclusion, perspectives
, permettant un meilleur traitement des quotients, et d'autre part un travail plus appliqué de formalisation dans l'assistant de preuve Coq d'une preuve d'algorithme auto-stabilisant. Concernant l'extension de CCI, nous avons déni une nouvelle représentation des quotients, à l'aide d'une fonction d'interprétation des termes du type support. Le fait que cette fonction soit exprimée dans le calcul est un des avantages principaux de cette approche, car elle permet de garantir un certain nombre de propriétés, comme la terminaison et la conuence, sans faire appel à des notions extérieures comme la réécriture. En fait, exprimer la fonction d'interprétation dans le calcul est un avantage d'un point de vue théorique
, On récapitule maintenant brièvement les fonctionnalités des types normalisés : l'égalité du quotient est inclue dans la conversion du calcul, les principes d'élimination faible et fort sont dénis sur les types normalisés, avec un comportement calculatoire acceptable et sans preuve de compatibilité à fournir
, Outre l'implantation dans une version dérivée de Coq du calcul des constructions inductives avec types normalisés, quelques perspectives nous semblent intéressantes. Concernant le dernier point ci-dessus notamment, il semble intéressant d'étudier le moyen d'engendrer les principes d'élimination automatiquement, notamment en adaptant les résultats d'induction automatique connus sur la réécriture
, Il semble aussi intéressant d'étudier les rapport existant entre notre approche et celle des quotient décidable de L. Pottier [Pot00], qui semble assez proche. Enn on peut supposer que notre méthode d'extension du calcul des constructions inductives, consistant à associer une fonction et un type, s'applique à d'autres extensions. Par exemple, il est peut-être possible de dénir un calcul des constructions inductives avec sous-types en utilisant une fonction de passage au sur-type
, On obtient alors deux représentations pour une même structure avec un moyen simple de passer de l'une à l'autre. Un exemple fourni par G. Barthe est celui des ?-termes et leurs deux représentations : la représentation classique et celle par les indices de De Bruijn ; l'une a l'avantage d'être intuitive et facile à manipuler, l'autre a l'avantage d'être une structure libre, Représentation d'algèbres non libres en théorie des types Plus directement, il semble intéressant d'étudier l'utilité d'un calcul des constructions inductives avec types normalisés dans lequel la fonction d'interprétation nf pour un type Norm
, formaliser d'autres preuves utilisant des techniques d'auto-stabilisation, et permettre ainsi la conception d'un véritable environnement de preuve spécialisé
,
, , p.27
,
,
,
, , p.88
, La conversion et les règles de typage des type normalisés, p.90
,
,
,
, Lambda calculi with types, Handbook of Logic in Computer Science, Volumes 1 (Background : Mathematical Structures) and 2 (Background : Computational Structures), vol.2, 1992.
, Extensions of pure type systems, proc TLCA'95, vol.902, 1995.
, Congruence types, Proc. Conf. Computer Science Logic, vol.1092, pp.36-51, 1995.
, Inductive-Data-Type Systems, Theoretical Computer Science, vol.277, 2001.
URL : https://hal.archives-ouvertes.fr/inria-00105578
, Automata-driven automated induction, Information and Computation, 2000.
, Denitions by rewriting in the calculus of constructions, Proceedings of LICS2001, 2001.
, Théorie des ensembles, Éléments de mathématiques. Hermann, 1966.
, Réexions sur les quotients, vol.7, 1997.
, Implementing Mathematics with the Nuprl Development System, 1986.
, The calculus of constructions. Information and Computation, vol.76, p.95120, 1988.
URL : https://hal.archives-ouvertes.fr/inria-00076024
, A formulation of the simple theory of types, Journal of Symbolic Logic, vol.5, 1940.
, Inductive proofs by specications transformation, Proc. 3rd Rewriting Techniques and Applications, Chapel Hill, vol.355, p.7691, 1989.
, Inductionless induction, 2nd International Conference in Logic For Computer Science : Automated Deduction. Lecture notes, 1994.
, Représentation d'algèbres non libres en théorie des types [Coq] The Coq Proof Assistant
, Une théorie des constructions, 1985.
, An analysis of girard's paradox, Proc. 1st IEEE Symp. Logic in Computer Science, 1986.
, Inductively dened types, Proceedings of Colog'88, vol.417, 1990.
, Lambda calculus with nameless dummies, a tool for automatic formula manipulation, with application to the Church-Rosser theorem, Proc. of the Koninklijke Nederlands Akademie, vol.75, p.380392, 1972.
, Theorem proving modulo, 1998.
URL : https://hal.archives-ouvertes.fr/inria-00077199
, Self-stabilizing systems in spite of distributed control, Communications of the ACM, vol.17, issue.11, p.643644, 1974.
, La logique. Flammarion, 1995.
URL : https://hal.archives-ouvertes.fr/inria-00150707
, La part du calcul, 1999.
, Grundgesetze der Arithmetik, Begrisschriftlich abgeleitet, p.18931903
, Untersuchungen über das logische schliessen, 1934.
, The Collected Papers of Gerhard Gentzen, 1969.
, The calculus of constructions and higher order logic
, The church rosser property for ??-reduction in typed ?-calculi, Proc. 7th IEEE Symp. Logic in Computer Science, p.453460, 1992.
, An alternative solution to a problem of system stabilization, Proceedings of TOPLAS, p.735742, 1993.
, Proofs and Types. Cambridge Tracts in Theoretical Computer Science, 1989.
, Uber formal unentscheidbare satze der principia mathematica und verwandter systeme, 1931.
, On undecidable propositions of formal mathematical systems, 1934.
, Intuitionism : An Introduction, 1956.
, Extensional concepts in intensional type theory, 1995.
, A simple model for quotient types, proc TLCA'95, vol.902, 1995.
, The formulae-as-types notion of construction, Curry : Essays on Combinatory Logic, Lambda Calculus and Formalism, p.479490, 1980.
, Proving convergence of selfstabilizing systems using rst-order rewriting and regular languages, Distributed Computing, vol.14, issue.2, p.8395, 2001.
, Term Rewriting Systems, Handbook of Logic in Computer Science, vol.2, pp.1-116, 1992.
,
, , 1984.
, Strong normalization in a typed lambda calculus with lambda structured types, 1973.
, Inductive denitions in the system COQ, Typed Lambda Calculi and Applications, vol.664, p.328345, 1993.
, Dénitions inductives en théorie des types d'ordre supérieur. thèse d'habilitation, 1996.
, Quotients dans le cci, 2000.
URL : https://hal.archives-ouvertes.fr/inria-00072584
, Natural Deduction, A Proof-Theoretical Study, 1965.
, Do-it-yourself type theory. Formal Aspects of Computing, 1989.
, Self-stabilization, ACM Computing Surveys, vol.25, issue.1, 1993.
, Lectures on the curry-howard isomorphism. Available as DIKU Rapport 98/14, 1998.
, Méta-théorie du Calcul des Constructions Inductives, 1994.