conception d`un langage de specification semantique

LIFO
OASIS S
DEA INFORMATIQUE
TAGE
CONCEPTION D'UN LANGAGE DE
SPECIFICATION SEMANTIQUE
EX E C U T A B L E ET
PROUVABLE
Présenté par :
Dirigé par :
Hamoudi KALLA
Mme. Isabelle ATTALI
05 Septembre 2001
1
CONCEPTION D'UN LANGAGE DE SPECIFICATION SEMANTIQUE EXECUTABLE ET PROUVABLE
PLAN de la présentation
•
•
•
•
•
•
Introduction.
Présentation de l'outil SmartTools.
Présentation du système de preuves Coq.
Présentation du langage FSem (Functional Semantic).
Implémentation.
Conclusion.
Hamoudi Kalla
2
CONCEPTION D'UN LANGAGE DE SPECIFICATION SEMANTIQUE EXECUTABLE ET PROUVABLE
INTRODUCTION
Pour la conception des langages de programmation qui fournit des programmes :
• Corrects,
• Fiables,
• Qui respectent des propriétés du langage.
⇒ Spécifier, prouver et vérifier des propriétés de ce langage dans un système
de preuves.
Il est intéressant de :
⇒ Disposer des outils sémantiques (compilateur, interpréteur,…) pour ces
langage qui permettent :
• D'aider le programmeur à écrire ces programmes.
• D'exécuter les programmes avec animation graphique afin de contrôler
l'exécution.
05 Septembre 2001
3
CONCEPTION D'UN LANGAGE DE SPECIFICATION SEMANTIQUE EXECUTABLE ET PROUVABLE
Spécifier, exécuter et prouver des langages de programmation
Permettant
La spécification syntaxique
et sémantique
Preuves seulement : Isabelle/HOL, PVS.
Outils
Permettant
Permettant
Preuves des propriétés
Exécution seulement : AsmGofer, Centaur.
Preuves & Exécution : Coq, KIV, Elan.
Exécution des programmes
Hamoudi Kalla
4
CONCEPTION D'UN LANGAGE DE SPECIFICATION SEMANTIQUE EXECUTABLE ET PROUVABLE
Exemple : le langage Exp
•
Langage de programmation impératif.
•
Déclarations : type entier & type booléen.
•
Instructions : affectation & contrôle ( IF-THEN-ELSE ).
Une affectation de Exp change la valeur d'une variable par la valeur d'une expression.
Une expression de Exp est un entier ou un booléen ou l'addition de deux expressions.
Hamoudi Kalla
5
CONCEPTION D'UN LANGAGE DE SPECIFICATION SEMANTIQUE EXECUTABLE ET PROUVABLE
Présentation de l'outil SmartTools
La spécification syntaxique
«Le langage AST»
Les actions sémantiques
«visiteurs Java»
Permet
Permet
SmartTools
Permet
Permet
Exécution des programmes
Animation graphique
Preuves des propriétés des
programmes
Hamoudi Kalla
6
CONCEPTION D'UN LANGAGE DE SPECIFICATION SEMANTIQUE EXECUTABLE ET PROUVABLE
Le langage AST & l'environnement SmartTools
Hamoudi Kalla
7
CONCEPTION D'UN LANGAGE DE SPECIFICATION SEMANTIQUE EXECUTABLE ET PROUVABLE
Visiteurs SmartTools « Actions Sémantiques »
public abstract class AbstractExpVisitor extends Visitor {…
abstract public java.lang.Object visit (exp.ast.AddTree node, java.lang.Object params) throws
VisitorException ;
…}
Automatique
SmartTools
Public class DefaultExpVisitor extends AbstractExpVisitor { …
public java.lang.Object visit(exp.ast.AddTree node, java.lang.Object params) throws VisitorException
{
visit(node.getGaucheNode(), params);
visit(node.getDroiteNode(), params);
return null; }
…}
Programmeur
Public class EvalExpVisitor extends DefaultExpVisitor { …
public java.lang.Object visit(exp.ast.AddTree node, java.lang.Object params) throws VisitorException
{
Integer x = (Integer) visit(node.getGaucheNode(), params) ;
Integer y = (Integer) visit(node.getDroiteNode(), params) ;
return IntegerPlus ( x , y ) ;
} …}
Hamoudi Kalla
8
CONCEPTION D'UN LANGAGE DE SPECIFICATION SEMANTIQUE EXECUTABLE ET PROUVABLE
Présentation du système de preuves Coq
•
Développé par le Projet LogiCal à l'INRIA.
•
Système interactif pour le développement des preuves.
a. Spécification syntaxique en Coq « les définitions Inductives »
Inductive Expression : Set :=
int : Z → Expression
| add : Expression → Expression → Expression
| coer_Expression_Bool : bool → Expression
Hamoudi Kalla
9
CONCEPTION D'UN LANGAGE DE SPECIFICATION SEMANTIQUE EXECUTABLE ET PROUVABLE
b. Spécification sémantique en Coq
Approche Relationnelle
Inductive Eval_Expression : Environnement → Expression → VALEUR → Prop :=
addExpression : (x,y:Z) (env1:Environnement)(exp1,exp2:Expression)
(Eval_Expression env1 exp1 (coer_VALEUR_Z x) )
→ (Eval_Expression env1 exp2 (coer_VALEUR_Z y) )
→ (Eval_Expression env1 (add exp1 exp2) (coer_VALEUR_Z (Zplus x y)) )
|….
Approche Fonctionnelle
Fixpoint Eval_Expression [env1:Environnement; exp':Expression] : (Exc VALEUR) :=
Cases exp' of
(add exp1 exp2) ⇒ Cases (Eval_Expression env1 exp1) (Eval_Expression env1 exp2) of
(value (coer_VALEUR_Z x)) (value (coer_VALEUR_Z y)) ⇒
(value VALEUR (coer_VALEUR_Z (Zplus x y)))
|
_
_
⇒ (error VALEUR)
end
| ……end.
Hamoudi Kalla
10
CONCEPTION D'UN LANGAGE DE SPECIFICATION SEMANTIQUE EXECUTABLE ET PROUVABLE
Connexion : SmartTools <-> Coq
• Preuves des propriétés des programmes SmartTools ⇒ Connecter
SmartTools au système de preuves Coq.
SmartTools
Connexion
Système de
preuves Coq
• Deux solutions sont proposées pour connecter SmartTools au système de
preuves Coq.
Hamoudi Kalla
11
CONCEPTION D'UN LANGAGE DE SPECIFICATION SEMANTIQUE EXECUTABLE ET PROUVABLE
Solution 1.
Spécifications sémantiques
écrites en Coq
Traducteur «A»
Traducteur «B»
Visiteurs
SmartTools
Problèmes. «A» Spécifier en Coq ? & «B» programmes Java ⇒ fonctions Coq !
Solution 2. Développer un nouveau langage de spécification sémantique FSem.
Langage de spécifications
sémantiques FSem
implémenter
Connecter
Système de preuves Coq
SmartTools
Hamoudi Kalla
12
CONCEPTION D'UN LANGAGE DE SPECIFICATION SEMANTIQUE EXECUTABLE ET PROUVABLE
Présentation du langage FSem
(Functional Semantic) (1)
Langage de spécification
sémantique FSem
Traduction
Traduction
Coq
SmartTools
Spécifications fonctionnelles
Visiteurs Java
La même exécution ?
exécution
exécution
Hamoudi Kalla
13
CONCEPTION D'UN LANGAGE DE SPECIFICATION SEMANTIQUE EXECUTABLE ET PROUVABLE
Présentation du langage FSem
(Functional Semantic) (2)
La syntaxe d'un programme FSem est de la forme suivante :
Import imports ;
Type types ;
Use déclarations ;
Judgement Judgements ; { chaque jugement définit un ensemble de Règles }
Hamoudi Kalla
14
CONCEPTION D'UN LANGAGE DE SPECIFICATION SEMANTIQUE EXECUTABLE ET PROUVABLE
Spécification sémantique du langage Exp en FSem
Import
Type
Type
Type
PlusInteger ( Integer, Integer ) = Integer ;
VALEUR = Integer, Bool ;
Environnement = env ( PairEnvironnement [] ) ;
PairEnvironnement = pairEnv ( VAR, VALEUR ) ;
Use x, y, som : Integer & exp1, exp2 : Expression & b : Bool & env1 : Environnement ;
Judgement Eval_Expression ( Environnement , Expression ) =? VALEUR ;
Eval_Expression ( env1, add ( exp1 , exp2 ) ) =
Cases Eval_Expression ( env1, exp1 ) & Eval_Expression ( env1, exp2 ) of
x
&
y
⇒ som
Where som := PlusInteger ( x, y)
OR
Otherwise & Otherwise ⇒ ERROR
EndCases
EndRule
Eval_Expression ( env1, int ( x ) ) = x
EndRule
Eval_Expression ( env1, b ) = b
EndRule .
Hamoudi Kalla
15
CONCEPTION D'UN LANGAGE DE SPECIFICATION SEMANTIQUE EXECUTABLE ET PROUVABLE
Comparaison entre FSem et Coq
Le langage de spécification FSem :
•
permet la spécification de sous-typage.
•
permet la manipulation de sous-typage.
•
facilite l'écriture des fonctions partielles.
•
Est déclaratif
•
L'ordre de spécification des fonctions n'est pas important.
•
L'ordre de spécification des type de données n'est pas important.
Hamoudi Kalla
16
CONCEPTION D'UN LANGAGE DE SPECIFICATION SEMANTIQUE EXECUTABLE ET PROUVABLE
Preuves et exécution des spécifications FSem
Exp.fsem + Exp.ast
Spécification syntaxique Coq
+
Spécification sémantique
fonctionnelle Coq
=
«Exp.v»
Génération
Génération
Génération
automatique
Classe et interface Java par opérateur
& Interface Java par type «*.java»
+
«AbstractExpVisitor.Java»
«DefaultExpVisitor.Java»
«EvalExpVisitor.Java»
Preuves : Interface Pcoq
Exécution : SmartTools
Hamoudi Kalla
17
CONCEPTION D'UN LANGAGE DE SPECIFICATION SEMANTIQUE EXECUTABLE ET PROUVABLE
Implémentation
AST
SmartTools
Spécifications
FSem
Spécifications
FSem
Traducteur
Traducteur
Traducteur
Définitions
inductives Coq
Spécifications
fonctionnelles Coq
Visiteurs Java
SmartTools
n9
o
p
Hamoudi Kalla
18
CONCEPTION D'UN LANGAGE DE SPECIFICATION SEMANTIQUE EXECUTABLE ET PROUVABLE
Traduction de l'AST SmartTools vers définitions inductives Coq
1. Chaque type de l'AST est représenté en Coq par un type inductif Set (ensemble).
AST :
Expression = … ;
Coq :
Inductive Expression : Set := … .
2. Chaque opérateur SmartTools est représenté par un opérateur en Coq.
AST :
Expression = add ( Expression gauche, Expression droite ),
…… ;
Coq :
Inductive Expression : Set :=
add : Expression → Expression → Expression
| ….
Hamoudi Kalla
19
CONCEPTION D'UN LANGAGE DE SPECIFICATION SEMANTIQUE EXECUTABLE ET PROUVABLE
3. Sous-typage : Opérateurs de coercion.
AST :
Coq :
Expression = %Bool ,
…… ;
Inductive Expression : Set :=
coer_Expression_Bool : bool → Expression
| ….
Formalism of Exp is
Root is %TOP ;
…..
Expression = add ( Expression gauche, Expression droite),
%Bool,
int as Integer ; ………...
End.
Traduction
Exp.ast
automatique
(* File Generated by fr.smarttools.vtp.visitorpattern.GenCoqFile *)
Mutual Inductive
Expression : Set :=
int : Z → Expression
| add : Expression → Expression → Expression
| coer_Expression_Bool : bool → Expression
…………..
Hamoudi Kalla
Exp.v
20
CONCEPTION D'UN LANGAGE DE SPECIFICATION SEMANTIQUE EXECUTABLE ET PROUVABLE
Conclusion
FSem est :
• un langage de spécification sémantique statique et dynamique.
• un langage de spécification sémantique exécutable en SmartTools et
prouvable en Coq.
• un langage de spécification sémantique fonctionnel permet la spécification
des fonctions partielles.
• un langage déclaratif.
• basé sur les jugements et les règles.
• permet la définition des types de données.
Hamoudi Kalla
21
CONCEPTION D'UN LANGAGE DE SPECIFICATION SEMANTIQUE EXECUTABLE ET PROUVABLE
Perspectives
1.
Confirmer le langage FSem sur des exemples plus réalistes.
2.
Ecrire les deux traducteurs :
• Spécifications FSem vers spécifications fonctionnelles Coq.
• Spécifications FSem vers visiteurs Java SmartTools.
3.
Ecrire un traducteur spécifications FSem vers spécifications Coq en utilisant
l'approche relationnelle.
Hamoudi Kalla
22
CONCEPTION D'UN LANGAGE DE SPECIFICATION SEMANTIQUE EXECUTABLE ET PROUVABLE
4. Evolution du langage : Réduire la taille des spécifications de FSem !!!
Exp.
Ajouter l'instruction IF-THEN-ELSE
Ecrire :
Eval_Expression ( env1, ifZeroExpression ( exp1 ) ) =
IF Eval_Expression ( env1, exp1 ) = x
THEN isZero ( x )
ELSE ERROR
EndRule
Au lieu d'écrire :
Eval_Expression ( env1, ifZeroExpression ( exp1 ) ) =
Cases Eval_Expression ( env1, exp1 ) of
x
⇒ isZero ( x )
OR
Otherwise
⇒ ERROR
EndCases
EndRule
Hamoudi Kalla
23
CONCEPTION D'UN LANGAGE DE SPECIFICATION SEMANTIQUE EXECUTABLE ET PROUVABLE
Spécification sémantique du langage Exp en Coq
Require Import ZArith.
Inductive VALEUR : Set :=
coer_VALEUR_Z : Z -> VALEUR
| coer_VALEUR_bool : bool -> VALEUR.
Inductive Pair_Environnement : Set :=
pair_Environnement : VAR -> VALEUR -> Pair_Environnement.
Inductive Environnement : Set :=
env : (list Pair_Environnement) -> Environnement.
Fixpoint Eval_Expression [env1:Environnement; exp':Expression] : (Exc VALEUR) :=
Cases exp' of
(add exp1 exp2) => Cases (Eval_Expression env1 exp1) (Eval_Expression env1 exp2) of
(value (coer_VALEUR_Z x)) (value (coer_VALEUR_Z y)) => [som:=(Zplus x y)]
(value VALEUR (coer_VALEUR_Z som))
|_
_
=> (error VALEUR)
end
|
(int x)
=> (value VALEUR (coer_VALEUR_Z x))
| (coer_Expression_bool b1) => (value VALEUR (coer_VALEUR_bool b1))
end.
Hamoudi Kalla
24
CONCEPTION D'UN LANGAGE DE SPECIFICATION SEMANTIQUE EXECUTABLE ET PROUVABLE
Actions sémantiques du langage Exp en SmartTools
public java.lang.Object visit(exp.ast.AddTree node, Environnement env1) throws VisitorException
{
Exp.ast.Expression exp1 = (Exp.ast.Expression) node.getGaucheNode ( ) ;
Exp.ast.Expression exp2 = (Exp.ast.Expression) node.getDroiteNode ( ) ;
Java.lang.Object Obj1 = visit (exp1, env1) ;
Java.lang.Object Obj2 = visit (exp2, env1) ;
if ((Obj1 instanceof Java.lang.Integer) && (Obj2 instanceof Java.lang.Integer))
{
Java.lang.Integer x = (Java.lang.Integer) Obj1;
Java.lang.Integer y = (Java.lang.Integer) Obj2;
Java.lang.Integer som = new Java.lang.Integer( x.intValue() + y.intValue() ) ;
return som;
}
else return null;
return null;
}
public java.lang.Object visit(exp.ast.IntTree node, Environnement env1) throws VisitorException
{
java.lang.Integer x = node.getValue() ;
return x ;
}
Hamoudi Kalla
25
CONCEPTION D'UN LANGAGE DE SPECIFICATION SEMANTIQUE EXECUTABLE ET PROUVABLE
INTRODUCTION
Pour la conception d'un langage de programmation qui fournit des programmes :
• Corrects,
• Fiables,
• Qui respectent des propriétés du langage.
⇒ Spécifier, prouver et vérifier des propriétés de ce langage dans un système
de preuves.
Il est intéressant de :
⇒ Disposer d'un environnement de programmation (compilateur,
interpréteur,…) pour ce langage qui permet :
• D'aider le programmeur à écrire ces programmes.
• D'exécuter les programmes avec animation graphique afin de contrôler
l'exécution.
Hamoudi Kalla
26