4.54 Try everywhere

Application dune suite de commandes à un ensemble dobligations de preuve

Syntaxe

  te(f, m.n.p)
  te(f,m.n’)
  te(f,n”)
  te(f)
avec :

Alias

  ta(f) est équivalent à te(f, Remplace.Gen.Unproved)

Utilisation

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

Exemple1

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  
 


Exemple2

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