Application d’une suite de commandes à un ensemble d’obligations de preuve
te(f, m.n.p)
te(f,m.n’)
te(f,n”)
te(f)
avec :
ta(f) est équivalent à te(f, Remplace.Gen.Unproved)
Cette commande permet d’essayer d’appliquer une démonstration à toutes les obligations de
preuve du composant en ne mémorisant cette démonstration que sur les obligations de preuve
qu’elle a permis de prouver. Généralement, l’opérateur aura préparé cette suite de commandes
à l’occasion de la preuve de l’une des obligations de preuve. Différents modes sont proposés,
pour pouvoir agencer la nouvelle démonstration par rapport à celles déjà existantes sur chaque
obligation de preuve.
Des messages envoyés à l’opérateur indiquent quelles sont les obligations de preuve qui ont
changé d’état.
La ligne de commande des obligations de preuve qui sont devenues prouvées est aussi modifiée.
Seules les commandes qui auront été efficaces (action non nulle sur l’état de la preuve) seront
sauvegardées.
La suite de commandes peut comprendre au plus une commande de force. L’emplacement de la
commande de force est indifférent puisque toute la ligne de commande est exécutée à force
constante.
te(f) est équivalent à te(f, Replace.Loc.Unproved).
te(f,n”) est équivalent à te(f,Replace.n”.Unproved) pour n” distinct de List(L) et
O.I.
te(f,List(L)) est équivalent à te(f, m.List(L).All). De plus l’option Unproved n’est pas
disponible avec List(L).
te(f,O.I) est équivalent à te(f,O[I..I]).
te(f,m.n’) est équivalent à te(f,m.n’.Unproved) pour n’ distinct de List(L).
te(f,m.List(L)) est équivalent à te(f,m.List(L).All).
Soit le composant contenant la clause Initialisation, l’opération Calcul1 et sept obligations de
preuve, toutes non prouvées. On affiche la situation grâce à la commande gs (voir chapitre 4.22
page §) :
PRI> gs
|
On obtient :
State of all PO Initialisation PO1 Unproved 1: 1..10 PO2 Unproved 1: 1..100 PO3 Unproved not(e5 = e1) PO4 Unproved e1 = e5 Calcul PO1 Unproved xx+yy-1: 1..100 PO2 Unproved not(uu = e1) PO3 Unproved e1 = e5 End
|
L’opérateur tente d’appliquer la ligne de commande dd & pr pour toutes les obligations de
preuve du composant, en remplaçant en cas de preuve réussie la ligne de commande existante
par dd & pr. La ligne de commande existante est ignorée (argument Replace).
PRI> te((dd & pr), Replace.Gen.All)
|
Les obligations de preuve Initialisation.1, Initialisation.2, Initialisation.3, Initialisation.4 et
Calcul.1 sont prouvées et sauvegardées.
Begin TryEveryWhere ++++---
|
Le résultat de l’application de la ligne de commandes est alors affiché.
Summary Calcul.1 : Unproved --> Proved, pr Initialisation.4 : Unproved --> Proved, pr Initialisation.3 : Unproved --> Proved, pr Initialisation.2 : Unproved --> Proved, pr Initialisation.1 : Unproved --> Proved, pr End TryEveryWhere
|
On vérifie, grâce à la commande gs (voir chapitre 4.22 page §), que cinq obligations de preuve
ont été effectivement prouvées.
PRI> gs State of all PO Initialisation PO1 Proved 1: 1..10 PO2 Proved 1: 1..100 PO3 Proved not(e5 = e1) PO4 Proved e1 = e5 Calcul PO1 Proved xx+yy-1: 1..100 PO2 Unproved not(uu = e1) PO3 Unproved e1 = e5 End
|
Soit le composant suivant contenant la clause Initialisation, l’opération Analyse et six
obligations de preuve, toutes non prouvées. On affiche la situation grâce à la commande gs (voir
chapitre 4.22 page §) :
PRI> gs
|
On obtient :
State of all PO Initialisation PO1 Unproved ff: INTEGER +-> BOOL PO2 Unproved ff(1) = TRUE PO3 Unproved xx: dom(ff) Analyse PO1 Unproved a1: 1..10 PO2 Unproved a1 = a2 PO3 Unproved a2 <= 11 End
|
L’opérateur tente d’appliquer la ligne de commande dd & pr sur les obligations de preuve
numéro 1 d’Initialisation et numéros 2 et 3 d’Analyse. Il utilise le mode par défaut soit Replace
et All :
PRI> te((dd & pr),List(Initialisation.1 & Analyse.2 & Analyse.3)) Begin TryEveryWhere +++ Summary Initialisation.1 transformed Unproved --> Proved, dd & pr Analyse.2 transformed Unproved --> Proved, dd & pr Analyse.3 transformed Unproved --> Proved, dd & pr End TryEveryWhere
|
L’opérateur utilise ensuite la démonstration sauvegardée de l’obligation de preuve Analyse.2
pour l’essayer sur Analyse.1 :
PRI> te(Analyse.2,Analyse.1) Begin TryEveryWhere + Summary Analyse.1 transformed Unproved --> Proved, dd & pr End TryEveryWhere
|
L’opérateur décide alors de tenter à nouveau la commande dd puis la commande pr sur les
obligations de preuve non prouvées de la clause Initialisation :
PRI> te((dd & pr),Replace.Op(Initialisation).Unproved) Begin TryEveryWhere ++ Summary Initialisation.2 transformed Unproved --> Proved, dd & pr Initialisation.3 transformed Unproved --> Proved, dd & pr End TryEveryWhere
|
On remarque donc que dans notre cas, en repartant d’obligations de preuve toutes non prouvées,
il aurait été judicieux d’appliquer les commandes dd et pr sur toutes les obligations de preuve de
la clause Initialisation par exemple :
PRI> te((dd & pr),Replace.Initialisation[1..3].All)
Begin TryEveryWhere +++ Summary Initialisation.1 transformed Unproved --> Proved, dd & pr Initialisation.2 transformed Unproved --> Proved, dd & pr Initialisation.3 transformed Unproved --> Proved, dd & pr End TryEveryWhere
|
Enfin on aurait aussi pu utiliser les commandes de preuve précédentes seulement sur les
obligations de preuve dont le but coïncide avec la formule x : y, soit :
PRI> te((dd & pr),Replace.Patt(x : y).All)
Begin TryEveryWhere +++ Summary Initialisation.1 transformed Unproved --> Proved, dd & pr Initialisation.3 transformed Unproved --> Proved, dd & pr Analyse.1 transformed Unproved --> Proved, dd & pr End TryEveryWhere
|