4.7 Loop

Application de commandes interactives lors dune division de la preuve

Syntaxe

  bb(f)

avec :

Utilisation

Cette commande permet d’appliquer une suite de commandes sur toutes les branches d’une partie de l’arbre de preuve, lorsqu’il y a division de la preuve. Elle évite ainsi à l’utilisateur de saisir et d’exécuter plusieurs fois la même suite de commandes.

Si la série de commandes ne réussit pas à prouver une des branches, la boucle s’arrête.

La commande bb s’applique aussi lorsqu’il n’y a pas de division de preuve, mais l’intérêt de bb est, dans ce cas là, bien moindre.

La présence de ll au sein de la boucle permet d’appliquer des commandes interactives, dans le cas où une branche de preuve ne peut pas être prouvée automatiquement. Dans ce cas, les commandes (d1 & d2 & ... & dm) vont être essayées. Si la preuve de la branche aboutit, on change de branche et l’on réapplique c1 & c2 & .. & cn. Si la preuve n’aboutit pas, ce sont les commandes suivantes qui seront essayées. Ce processus est itéré jusqu’à ce que la preuve de la branche aboutisse ou que les commandes z1 & z2 & ... & zp.

Exemple 1

Soit l’obligation de preuve suivante :


 
     ENS = {e1, e2, e3, e4, e5} &  
     ENS: FIN(NATURAL*{ENS.enum}) &  
     not(ENS = {}) &  
     xx: ENS &  
     not(xx = e5)  
     =>  
     xx = e1 or xx = e2 or xx = e3 or xx = e4  
 
 


On peut exécuter une preuve par cas :


 
     dc(xx, ENS)  
 
 


Pour éviter de saisir 5 fois la commande pr, on peut exécuter :


 
     bb(pr)  
 
 


On obtient alors les messages :


 
     Starting Prover Call  
     Starting Prover Call  
     Starting Prover Call  
     Starting Prover Call  
     Starting Prover Call  
 
 


et l’obligation de preuve est démontrée.

La fenêtre Commands (Executed / Next) contient alors :


 
    dc(xx,ENS) &  
      fc(1) &  
        pr &  
      fc(1) &  
        pr &  
      fc(1) &  
        pr &  
      fc(1) &  
        pr &  
      fc(1) &  
        pr &  
  Next  
 
 


Chaque fc(1) 3 indique le début d’exécution de la commande pr (paramètre de la commande de boucle). Le numéro (ici 1) indique le nombre de boucles imbriquées.

On retrouve bien les 5 cas de la preuve par cas (fc(1)).

Exemple 2

Soit l’obligation de preuve suivante :


 
     ENS = {e1, e2 e3, e4, e5} &  
     ENS: FIN(NATURAL*{ENS.enum}) &  
     not(ENS = {}) &  
     xx: ENS &  
     not(xx = e5)  
     =>  
     xx = e1 or xx = e2 or xx = e3 or xx = e4  
 
 


On peut exécuter une preuve par cas :


 
     dc(xx, ENS)  
 
 


Si l’on exécute la commande :


 
     bb(ch & bb(dd & bb(pr)))  
 
 


on obtient :


 
Starting creating hyp  
Starting Deduction  
Starting Prover Call  
Starting creating hyp  
Starting Deduction  
Starting Prover Call  
Starting creating hyp  
Starting Deduction  
Starting Prover Call  
Starting creating hyp  
Starting Deduction  
Starting Prover Call  
Starting creating hyp  
Starting Deduction  
Starting Prover Call  
 
 


et l’obligation de preuve est démontrée.

La fenêtre Commands (Executed / Next) contient alors :


 
    dc(xx,ENS) &  
      fc(3) &  
        ch &  
          fc(2) &  
            dd &  
              fc(1) &  
                pr &  
      fc(3) &  
        ch &  
          fc(2) &  
            dd &  
              fc(1) &  
                pr &  
      fc(3) &  
        ch &  
          fc(2) &  
            dd &  
              fc(1) &  
                pr &  
      fc(3) &  
        ch &  
          fc(2) &  
            dd &  
              fc(1) &  
                pr &  
      fc(3) &  
        ch &  
          fc(2) &  
            dd &  
              fc(1) &  
                pr &  
  Next  
 
 


Chaque fc() 4 indique le début d’exécution d’une suite de commandes (paramètre de la commande de boucle). Le numéro (1, 2 ou 3) indique le nombre de boucles imbriquées.

On retrouve bien les 5 cas de la preuve par cas (fc(3)).

Après sauvegarde, la ligne de commande sauvegardée est :


 
     dc(xx,ENS) &  
     bb(ch & bb(dd & bb(pr & ll(?)) & ll(?)) & ll(?))  
 
 


La commande ll() a été ajoutée à la sauvegarde et contient les éventuelles commandes interactives ajoutées par l’utilisateur, au cours de la preuve et à l’intérieur de boucles. Dans ce cas, aucune commande n’a été ajoutée et on obtient donc ll( ?).

Cette ligne de commande peut d’ailleurs être saisie directement par l’utilisateur : elle conduira au même résultat. Il faut par contre que la commande ll() soit à la fin de la ligne de commandes contenue dans bb().
Par exemple, la ligne de commandes suivant est incorrecte :


 
     bb(ch & ll(dd) & pr)  
 
 


et donne à l’exécution :


 
Starting creating hyp  
Unknown command ll(dd)  
Starting Prover Call  
Starting creating hyp  
Unknown command ll(dd)  
Starting Prover Call  
Starting creating hyp  
Unknown command ll(dd)  
Starting Prover Call  
Starting creating hyp  
Unknown command ll(dd)  
Starting Prover Call  
Starting creating hyp  
Unknown command ll(dd)  
Starting Prover Call  
 
 


Par contre, la ligne de commandes suivante est correcte :


 
     bb(ch & pr & ll(dd))  
 
 


et donne à l’exécution :


 
Starting creating hyp  
Starting Prover Call  
Starting creating hyp  
Starting Prover Call  
Starting creating hyp  
Starting Prover Call  
Starting creating hyp  
Starting Prover Call  
Starting creating hyp  
Starting Prover Call  
 
 


On s’aperçoit que la commande dd contenue dans ll n’a pas été exécutée.