La substitution identité

1. La substitution identité • Objectif : permettre de spécifier le SI simple • disposer d’une substitution qui spécifie que l’état de la machine n’est pas modifié skip • Sémantique [skip]F F • Définition du IF IF P THEN S END P==>S [] P==>skip

2. Forme générale du IF IF P1 THEN S1 P1==>S1 [] [ELSIF P2 THEN S2P1P2==>S2 [] …  … ELSIF Pn THEN Sn]P1P2…Pn-1Pn==>Sn [] [ELSE SE]P1P2…Pn-1Pn==>SE END(ou si pas de ELSE skip)

3. Select = Garde et Choix Borné • Objectif : Exprimer un choix de substitution sous condition • Idéal pour la spécification des interfaces utilisateurs SELECT P1 THEN S1 P1==>S1 [][WHEN P2 THEN S2 P2==>S2 []… …WHEN Pn THEN Sn]Pn==>Sn [][ELSE SE]P1P2…Pn==>SE END • Remarques • Substitution non déterministe lorsque les Pi ne sont pas exclusifs • Substitution infaisable lorsque la branche ELSE n’est pas présente

4. Construction d’un SELON • Soit E une expression et Li des listes de constantes toutes 2 à 2 distinctes et de même type que E CASE E OFEITHER L1 THEN S1 E{L1}==>S1 [][OR L2 THEN S2 E{L2}==>S2 []… …OR Ln THEN Sn] E{Ln}==>Sn [][ELSE SE] E{L1,L2…Ln}==>SE END(ou si pas de ELSEskip) END • Cette substitution est déterministe et toujours faisable !

5. Exemple de selon CASE x/10 OF EITHER 0 THEN x:=0 OR 2,4,8 THEN x:=1 OR 3,9 THEN x:=2 ELSE x:=-1 END END • Que vaut x après si x avant = 3 ? 37 ? 142 ? 11 ? 46 ? 71?

6. Choix non borné • Objectif : généraliser le choix borné : laisser le choix entre plusieurs valeurs satisfaisant une propriété spécifiée • On introduit une variable intermédiaire contrainte par une formule P et on exprime la substitution avec cette variable @z.(P==>S) ANY z WHERE P THEN S END • Sémantique [@z.(P==>S)]Fz.[P==>S]F z.(P=>[S]F) • Comme pour le choix borné, il s’agit d’une substitution indéterministe qui de plus peut être infaisable si le prédicat P est insatisfiable.

7. Dérivées du choix non borné • Substitution « devient élément de »  x:E @z.(zE==>x:=z) • Exemple : nbPlaceLibre:Natural • Substitution « devient tel que » x:(P) @z.([x:=z]P==>x:=z) • Exemple : x:(x<100  x>x$0)

8. Exemple MACHINE Reservation VARIABLES Capacite, nbPlaceLibre INVARIANT nbPlaceLibreNATURAL capaciteNATURAL INITIALISATION ANY n WHERE n NATURAL1 THEN capacite,nbPlaceLibre:=n,n END END

9. La substitution parallèle • Objectif : généraliser l’utilisation de la multiplicité à toutes les substitutions • Donc conserver les propriétés basiques du parallélisme [S||T] F  [T||S] F [S||(T||U)] F  [(S||T)||U] F • Mais interdire que deux substitutions « en parallèle » modifient la même variable ! • Définition inductive vis-à-vis des autre substitutions x:=e || y:=f  x,y:=e,f skip || S  S (P|S) || T  P | (S||T) S[]T || U  S||U [] T||U P==>S || T  P ==> (S||T) @x.(P==>S) || T  @x.(P==>S||T) (x non libre dans T)

10. Le bloc • Objectif : disposer d’un système de parenthésage BEGIN S END • Ce n’est pas réellement une substitution mais cela fait partie du langage de modélisation des opérations • Sémantique [BEGIN S END]F [S]F

11. Base du langage des substitutions généralisés x:=e S||T P|S skip S[]T indéterministe P==>S infaisable (dans certains cas) @x.(P==>S) indéterministe et infaisable (dans certains cas)

12. Application à la modélisation de services • Retour sur les réservations…

13. ModuleRef1.ref ModuleRef2.ref … ModuleRefn.ref Module.mch ModuleImp.imp Module.c L’outil B : Atelier B ou B4free+Balbulette • La spécification (puis la conception) = rédaction de composants rassemblés dans un projet • Composant = • Machine abstraite (MODEL ou MACHINE) • Raffinement (REFINEMENT) • Implantation (IMPLEMENTATION) • Module =

14. Activités de l’outil B • Analyse de composant • Génération des obligations de preuve • Preuve • Automatique • Interactive • Génération de code

15. Analyse(s) de composant • Analyse lexicale • Reconnaissance des différents catégories de données = les lexèmes • Remplacement des identificateurs de notions définies par la définition associée • Exemple : MOIS==1..12 • Pas de définition récursive • Un nouvel identificateur de notion pour chaque définition • Analyse syntaxique • Respect de la grammaire du B • Analyse sémantique

16. Exemples d’application de définitions OPERATIONS initialiser = valeur := VAL_INIT ; incrementer = valeur := succ(valeur) END DEFINITIONS VAL_INIT == 1 ; succ(x) == x + 1  END OPERATIONS initialiser = valeur := 1 ; incrementer = valeur := valeur+1 END

17. Analyse sémantique • Contrôle de typage • Détermination du type de chaque identificateur • Vérification de la bonne composition des expressions, prédicats et substitutions • Résolution des portées • Rattachement de chaque identificateur à son « introducteur » • Test de non-homonymie (nom de machine avec nom de variable…) • Contrôle de visibilité • Respect des règles de réutilisation des autres composants

18. Le typage B = les ensembles • Types de base • Ensembles prédéfinis • Z (INTEGER) • BOOL = {TRUE,FALSE} • STRING • Ensembles abstraits et énumérés • clause SETS • paramètres formels majuscules de la machine) • Types complexes = des types construits à partir des types de bases à l’aide des opérateurs • x produit cartésien • P ensemble des parties d’un ensemble

19. Règles de détermination du type d’une expression • Si e est un scalaire, type(e)= type de base auquel il appartient • Si e est identificateur, type(e) = déterminé par le prédicat de typage • Si e est de la forme e1|->e2, type(e)=T1xT2 où type(e1)=T, type(e2)= T2 • Si e est un type de base E, type(e)=P(E) • Si e est un ensemble {e1,…}, type(e)=P(T) où T est le type des éléments de e • Si e est de la forme E1xE2, type(e)=P(T1xT2) où type(E1)=P(T1) et type(E2)=P(T2) • Si e est de la forme P(E) (ou un dérivé de cette notion : -->, <->,+->…), type(e)=P(T) où T est le type de E

20. Exemples : type(e)= • 3 • Z • Z • P(Z) • {-5,2,-25} • P(Z) • TRUE|->2 • BOOL x Z • {2|->4,2|->5,3|->6} • P(Z x Z) • {(5|->tom)|->TRUE, (3|->jean)|->TRUE} (avec tom et jean étant du type PERSONNE) • P((Z x PERSONNE) x BOOL) • (0..10) x PERSONNE --> BOOL • P(P((Z x PERSONNE) x BOOL))

21. Typage des identificateurs • Nécessité d’un prédicat de typage • dès l’apparition de l’identificateur • VARIABLES  INVARIANT • CONSTANTS  PROPERTIES • Paramètres de MACHINE  CONSTRAINTS • ,…  après la parenthèse ouvrante • ANY, LET, VAR  dès le WHERE • 4 prédicats possibles • idE avec type(E)=P(T)  type(id)=T • idE ou idE  type(id)=type(E) • id=e  type(id)=type(e) • Cas particulier des paramètres de sortie • Typés par la substitution

22. Exemples : type(v)=? • v  Z • Z • v  (2000..2010) x ETUDIANT • Z x ETUDIANT • v  (2000..2010)<-->ETUDIANT • P(Z x ETUDIANT) • v  MODULE-->BOOL • P(P(MODULExBOOL)) • v = (0..4) x BOOL • P(Z x BOOL)

23. Génération des obligations de preuve • Construction des formules à prouver • Application des substitutions • Normalisation • Simplification

24. Les formules à prouver • Chaque assertion Ai doit être déductible des propriétés invariantesI=>Ai • L’initialisation Init doit respecter les propriétés invariantes [Init]I • Chaque opération simple Op doit maintenir les propriétés invariantes I => [Op]I • Chaque opération pré-conditionnée P|Op doit maintenir les propriétés invariantes sous la pré-condition P I P => [Op]I 

25. Application des substitutions • On se ramène à des substitutions simples en utilisant les définitions du LSG • [x<0==>x:=0 || y:=x] x<y • [x<0==> (x:=0||y:=x)] x<y • x<0 => [x:=0||y:=x] x<y • x<0 => [z:=x][x:=0][y:=z] x<y • On applique les substitutions simples • x<0 => [z:=x][x:=0]x<z • x<0 => [z:=x]0<z • x<0 => 0<x

26. Exemple declarerSiPossible(s)= PRE sSEXE THEN IF x.(xPERSONNE-personne) THEN ANY p WHERE pPERSONNE-personne THEN personne,sexe(p) :=personne{p},s END END END

27. Exemple [IFx.(xPERSONNE-personne) THEN @p.(pPERSONNE-personne ==> personne,sexe(p) :=personne{p},s) END] (personnePERSONNE  sexepersonneSEXE) [x.(xPERSONNE-personne)==> @p.(pPERSONNE-personne ==> personne,sexe(p) :=personne{p},s)] (personnePERSONNE  sexepersonneSEXE) [x.(xPERSONNE-personne)==>skip] (personnePERSONNE  sexepersonneSEXE)  (x.(xPERSONNE-personne) => [@p.(pPERSONNE-personne ==> personne,sexe(p) :=personne{p},s)] (personnePERSONNE  sexepersonneSEXE))  (x.(xPERSONNE-personne) => [skip] (personnePERSONNE  sexepersonneSEXE))  (x.(xPERSONNE-personne) => p.(pPERSONNE-personne => [personne,sexe(p) :=personne{p},s)] (personnePERSONNE  sexepersonneSEXE))  (x.(xPERSONNE-personne) => personnePERSONNE  sexepersonneSEXE)  (x.(xPERSONNE-personne) => p.(pPERSONNE-personne => [new :=personne{p}][sexe :=sexe<+{p|->s}] [personne :=new](personnePERSONNE  sexepersonneSEXE))  (x.(xPERSONNE-personne) => personnePERSONNE  sexepersonneSEXE)  (x.(xPERSONNE-personne) => p.(pPERSONNE-personne => [new :=personne{p}][sexe :=sexe<+{p|->s}] (newPERSONNE  sexenewSEXE))  (x.(xPERSONNE-personne) => personnePERSONNE  sexepersonneSEXE)  (x.(xPERSONNE-personne) => p.(pPERSONNE-personne => [new :=personne{p}] (newPERSONNE sexe<+{p|->s}newSEXE))  (x.(xPERSONNE-personne) => personnePERSONNE  sexepersonneSEXE)  (x.(xPERSONNE-personne) => p.(pPERSONNE-personne =>personne{p}PERSONNE  sexe<+{p|->s}personne{p}SEXE)  (x.(xPERSONNE-personne) => personnePERSONNE  sexepersonneSEXE)

28. Normalisation • Objectif : limiter le nombre de règles à considérer • Réécrire certains prédicats ou expressions des formules à prouver par des prédicats ou expressions (sémantiquement) équivalents • Quelques exemples : n>m-1  mn m<n+1  mn a<=>b  (a=>b)(b=>a) aN  aZ  0a AB  AP(B) aB aB {x,y}  {x}{y} rDA  rD+->A  dom(r)=D

29. Simplifications • Les preuves à faire sont des formules de la forme H1H2…Hm =>P1P2…Pn • On peut décomposer la preuve en n preuves plus simples H1H2…Hm =>P1 H1H2…Hm =>P2 … H1H2…Hm =>Pn • On peut éliminer les preuves dont le but apparaît comme une des hypothèses H1H2…P … Hn=>P • Preuves triviales

30. Preuves • Séquents • Règles d’inférences • Axiomes • Démonstration • Théories • Tactiques • Avant, arrière, « Ping-Pong »

31. Preuves interactives • Différents prouveurs • [pr] le prouveur « théorie des ensembles » • Idem p0 et p1 extérieurs à [ip] • [pp] le prouveur « FOL » • p0 et p1 internes à [ip] • Sélection des hypothèses prises en compte • Introduction de lemme [ah] • Preuve par cas [dc] • Application de l’égalité [eh] [he]

32. Management des hypothèses Hidden,Searched,Cached,Selected|-- Goal • [sh] recherche d’hypothèses dans Hidden • Hidden  Searched • [sg] recherche d’hypothèses dans Searched • Searched  Searched • [sl] sélection d’hypothèses • Searched  Selected ou Cached Selected • [ds] désélection d’hypothèses • Selected  Cached • [dl] « suppression » d’hypothèses • Cached  Hidden

33. Effet des prouveurs pp et pr • Ils travaillent • Sur un ensemble réduit d’hypothèses • Selected|-- Goal • En temps limité et interruptibles [it] • Résultats • Bfalse : la formule n’est pas valide • Fail to … : le but n’est pas démontrable avec cette théorie et ces hypothèses • Out of time… : on est certainement dans une boucle infinie • Success : la formule est démontrée

34. Réduire/Augmenter les hypothèses • Si trop d’hypothèses • Risque de time-out  [ds] • Si pas assez d’hypothèses • Impossible à démontrer  [sl] • Sélectionner juste les hypothèses nécessaires • p1 sélectionne en + les hypothèses ayant un identificateur commun avec ceux de selected et goal

35. Indication de lemme [ah] • Objectif : forcer un chemin dans l’arbre de preuve • Le prouveur essai d’abord de prouver le lemme à partir des hypothèses • Le lemme devient donc le but courant • Puis le but final en utilisant le lemme comme hypothèse • Alternative : [as] fait l’inverse

36. La preuve par cas [dc] • Objectif : Lorsque le but est prouvable par des arguments différents selon les cas • [dc] condition • on démontre le but sous cette condition • puis on redémontre le but sous la condition opposée : non(condition)

37. Application de l’égalité • Lorsque qu’une hypothèse est de la forme e1=e2 • On peut remplacer dans selected et goal toutes les occurrences • de e1 par e2 [eh] • ou de e2 par e1 [he]