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 IFIF P THEN S END P==>S [] P==>skip

Forme générale du IF

IF P1 THEN S1 P1==>S1 [][ELSIF P2 THEN S2 P1P2==>S2 []… …ELSIF Pn THEN Sn] P1P2…Pn-1Pn==>Sn

[][ELSE SE] P1P2…Pn-1Pn==>SE END (ou si pas de ELSE

skip)

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] P1P2…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

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 ELSE skip)

END

Cette substitution est déterministe et toujours faisable !

Exemple de selon

CASE x/10 OFEITHER 0 THEN

x:=0OR 2,4,8 THEN

x:=1OR 3,9 THEN

x:=2ELSE

x:=-1END

END

Que vaut x après si x avant =3 ? 37 ? 142 ? 11 ? 46 ? 71?

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.

Dérivées du choix non borné

Substitution « devient élément de » x:E @z.(zE==>x:=z)

Exemple : nbPlaceLibre:Natural

Substitution « devient tel que »x:(P) @z.([x:=z]P==>x:=z)

Exemple : x:(x<100 x>x$0)

Exemple

MACHINEReservation

VARIABLESCapacite, nbPlaceLibre

INVARIANTnbPlaceLibreNATURALcapaciteNATURAL

INITIALISATIONANY n WHERE

n NATURAL1THEN

capacite,nbPlaceLibre:=n,nEND

END

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)

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

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)

Application à la modélisation de services

Retour sur les réservations…

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 =

ModuleRef1.refModuleRef2.ref

…ModuleRefn.ref

Module.mch

ModuleImp.imp

Module.c

Activités de l’outil B

Analyse de composant Génération des obligations de preuve Preuve

Automatique Interactive

Génération de code

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

Exemples d’application de définitions

OPERATIONSinitialiser = valeur := VAL_INIT ; incrementer = valeur := succ(valeur)

END

DEFINITIONSVAL_INIT == 1 ;succ(x) == x + 1 

END

OPERATIONSinitialiser = valeur := 1 ;incrementer = valeur := valeur+1

END

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

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

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

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))

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 idE avec type(E)=P(T) type(id)=T idE ou idE type(id)=type(E) id=e type(id)=type(e)

Cas particulier des paramètres de sortie Typés par la substitution

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)

Génération des obligations de preuve

1. Construction des formules à prouver

2. Application des substitutions

3. Normalisation

4. Simplification

Les formules à prouver

Chaque assertion Ai doit être déductible des propriétés invariantes I=>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 

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

Exemple

declarerSiPossible(s)=PRE

sSEXETHEN

IF x.(xPERSONNE-personne) THEN ANY p WHERE

pPERSONNE-personneTHEN

personne,sexe(p) :=personne{p},s END

ENDEND

Exemple

[IF x.(xPERSONNE-personne) THEN @p.(pPERSONNE-personne ==> personne,sexe(p) :=personne{p},s) END] (personnePERSONNE sexepersonneSEXE)

[x.(xPERSONNE-personne) ==> @p.(pPERSONNE-personne ==> personne,sexe(p) :=personne{p},s)] (personnePERSONNE sexepersonneSEXE) [x.(xPERSONNE-personne) ==> skip] (personnePERSONNE sexepersonneSEXE)

(x.(xPERSONNE-personne) => [@p.(pPERSONNE-personne ==> personne,sexe(p) :=personne{p},s)] (personnePERSONNE sexepersonneSEXE)) (x.(xPERSONNE-personne) => [skip] (personnePERSONNE sexepersonneSEXE))

(x.(xPERSONNE-personne) => p.(pPERSONNE-personne => [personne,sexe(p) :=personne{p},s)] (personnePERSONNE sexepersonneSEXE)) (x.(xPERSONNE-personne) => personnePERSONNE sexepersonneSEXE)

(x.(xPERSONNE-personne) => p.(pPERSONNE-personne => [new :=personne{p}][sexe :=sexe<+{p|->s}] [personne :=new](personnePERSONNE sexepersonneSEXE)) (x.(xPERSONNE-personne) => personnePERSONNE sexepersonneSEXE)

(x.(xPERSONNE-personne) => p.(pPERSONNE-personne => [new :=personne{p}][sexe :=sexe<+{p|->s}] (newPERSONNE sexenewSEXE)) (x.(xPERSONNE-personne) => personnePERSONNE sexepersonneSEXE)

(x.(xPERSONNE-personne) => p.(pPERSONNE-personne => [new :=personne{p}] (newPERSONNE sexe<+{p|->s}newSEXE)) (x.(xPERSONNE-personne) => personnePERSONNE sexepersonneSEXE)

(x.(xPERSONNE-personne) => p.(pPERSONNE-personne =>personne{p}PERSONNE sexe<+{p|->s}personne{p}SEXE) (x.(xPERSONNE-personne) => personnePERSONNE sexepersonneSEXE)

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 mnm<n+1 mna<=>b (a=>b)(b=>a)aN aZ 0aAB AP(B)aB aB{x,y} {x}{y}rDA rD+->A dom(r)=D

Simplifications

Les preuves à faire sont des formules de la formeH1H2…Hm =>P1P2…Pn

On peut décomposer la preuve en n preuves plus simplesH1H2…Hm =>P1H1H2…Hm =>P2

…H1H2…Hm =>Pn

On peut éliminer les preuves dont le but apparaît comme une des hypothèses

H1H2…P … Hn=>P

Preuves triviales

Preuves

Séquents Règles d’inférences Axiomes Démonstration Théories Tactiques

Avant, arrière, « Ping-Pong »

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]

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

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

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

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

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)

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]