Techniques de Rcriture et Transformations

1
Techniques de Réécriture et Transformations

• Pierre-Etienne Moreau

2
Problématique
33 ? France 333 ? Est 33383 ?
D.54 0800 ? Gratuit
33383593019
France, Est, D.54
3
Quelques améliorations possibles

• Meilleure interaction avec C, Java,
• Faciliter la communication avec lextérieur (I/O,
  Corba, )
• Sadapter aux structures de données de
  lutilisateur

4
Mise en pratique des îlots formels

• Un langage qui permet de
• Construire des structures arborescentes
• Reconnaître des motifs dans une structure de
  donnée
• Lorsquun motif est reconnu
• On dit que le motif  filtre  vers la structure
• On peut exécuter une action, écrite en C ou Java

5
Présentation de Tom
6
Système de réécriture

• rule
• one() -gt suc(zero())
• System.out.println( one one())
• gt one suc(zero)
• Une fonction Java est associée à chaque symbole
  défini

7
Système de réécriture

• rule
• one() -gt suc(zero())
• rule
• two() -gt suc(one())
• System.out.println( two two())
• gt two suc(suc(zero))
• Les règles doivent commencer par le même symbole
  de tête
• On peut définir plusieurs systèmes de réécriture

8
Questions

• Quels sont les statuts de  zero  et  suc ?
• Peut-on écrire  zero(suc) ?
• Il ya une notion de signature
• définition du nom et des profils des opérateurs

9
Signature

• vas
• module Peano
• imports
• public sorts Nat
• abstract syntax
• zero -gt Nat
• suc(Nat) -gt Nat
• fib(Nat) -gt Nat
• plus(Nat, Nat) -gt Nat

10
Système de réécriture

• rule
• plus(x, zero()) -gt x
• plus(x, suc(y)) -gt suc(plus(x,y))
• System.out.println( res plus(one(),two()))
  
• gt res suc(suc(suc(zero)))
• Un membre droit peut utiliser
• des constructeurs,
• des symboles définis et
• des variables introduites dans le membre gauche

11
Quelques remarques

• rule
• fib(zero()) -gt one()
• fib(suc(zero())) -gt one()
• fib(suc(suc(x))) -gt plus(fib(x),fib(suc(x)))
  
• Le type des variables nest pas déclaré, mais est
  inféré
• Applique une stratégie leftmost-innermost

12
Question

• Peut-on écrire le programme suivant ?
• rule
• fib(zero()) -gt one()
• fib(one()) -gt one()
• fib(suc(suc(x))) -gt plus(fib(x),fib(suc(x)))
  
• Oui
• Pourquoi cette question ?

13
Exercice

• Evaluer le terme fib(plus(one(),two()))
• Ecrire la trace dexécution
• one()
• -gt suc(zero())
• two()
• -gt suc(suc(zero()))
• plus(suc(zero()),suc(suc(zero())))
• -gt suc(plus(suc(zero()),suc(zero())))
• -gt suc(suc(plus(suc(zero()),zero())))
• -gt suc(suc(suc(zero())))
• fib(suc(suc(suc(zero()))))
• -gt plus(fib(suc(zero())),fib(suc(suc(zero()))))
• fib(suc(zero()))
• -gt ?
• -gt fib(suc(zero()))

14
Question

• Que donne lévaluation du programme suivant ?
• System.out.println( res fib(plus(one(),two(
  ))))
• gt res suc(suc(suc(zero)))
• Que donne lévaluation du programme suivant ?
• System.out.println( res suc(fib(plus(one(),
  two()))))
• ne compile pas suc nest pas une fonction Java

15
Mécanisme de base

• suc(suc(zero))
• permet de construire un terme

suc
suc
zero
Le terme doit être bien formé et bien typé
16
Utilisation de

• System.out.println( res suc(fib(plus(one()
  ,two()))))
• gt res suc(suc(suc(suc(zero))))
• Un peut contenir des constructeurs, des
  symboles définis
• À partir de la signature vas, on peut
  représenter et afficher des termes

17
Utilisation en Java

• Nat one suc(zero())
• Nat two suc(suc(zero()))
• System.out.println( one one)
• System.out.println( two two)
• gt one suc(zero)
• gt two suc(suc(zero))

18
Question

• Peut-on écrire
• Nat one suc(zero())
• Nat two suc(one)
• Oui
• Un peut contenir des constructeurs, des
  symboles définis et des variables Java

19
Résumé

• vas permet de définir une signature
• rule permet de définir un système de réécriture
  contenant
• des constructeurs et des variables dans le lhs
• des constructeurs, des variables et des symboles
  définis dans le rhs
• permet de construire un terme à partir de
  constructeurs, symboles définis, variables et
  fonctions Java

20
Question

• Comment Java sait quil doit afficher
   suc(suc(zero))  ?
• A chaque signature correspond une implantation en
  Java

21
Bibliothèque ATerm

• Aterm
• AFun
• ATermAppl
• ATermList
• ATermInt
• ATermReal
• ATermPlaceholder
• ATermBlob
• ATermFactory

22
ATerms
23
Bibliothèque ATerm

• Aterm
• AFun
• ATermAppl
• ATermList
• ATermInt
• ATermReal
• ATermPlaceholder
• ATermBlob
• ATermFactory

• getAnnotation
• setAnnotation
• toString
• etc.

24
Bibliothèque ATerm

• Aterm
• AFun
• ATermAppl
• ATermList
• ATermInt
• ATermReal
• ATermPlaceholder
• ATermBlob
• ATermFactory

• getName
• getArity

25
Bibliothèque ATerm

• Aterm
• AFun
• ATermAppl
• ATermList
• ATermInt
• ATermReal
• ATermPlaceholder
• ATermBlob
• ATermFactory

• getAFun
• getArgument
• setArgument
• etc.

26
Bibliothèque ATerm

• Aterm
• AFun
• ATermAppl
• ATermList
• ATermInt
• ATermReal
• ATermPlaceholder
• ATermBlob
• ATermFactory

• getFirst
• getNext
• elementAt
• insert
• append
• concat
• etc.

27
Bibliothèque ATerm

• Aterm
• AFun
• ATermAppl
• ATermList
• ATermInt
• ATermReal
• ATermPlaceholder
• ATermBlob
• ATermFactory

• makeAFun
• makeAppl
• parse
• readFromFile
• etc.

28
Utilisation des ATerms

• Aterm t1 factory.parse("a")
• Aterm t2 factory.parse("f(a,b)")
• t2.getArgument(1) t1 ?
• gt true
• Aterm t3 t2.setArgument(t1,2)
• gt t3 f(a,a)
• Aterm t4 factory.parse("f(a,f(b))")
• gt f na pas de signature particulière
• Les Aterms permettent de construire des termes,
  mais il ny a pas de sécurité (signature, types)

29
ApiGen / Vas

• A partir dune signature multi-sortée
• Génère des classes, reposant sur les Aterms,
  permettant de représenter les termes
• partage maximal
• typage fort des termes
• tout terme typé est un ATerm

30
Exemple

• vas
• module Expressions
• imports String
• public sorts Bool Expr
• abstract syntax
• true -gt Bool
• false -gt Bool
• eq(lhsExpr, rhsExpr) -gt Bool
• id(valuestring) -gt Expr
• nat(valueint) -gt Expr
• add(lhsExpr, rhsExpr) -gt Expr
• mul(lhsExpr, rhsExpr) -gt Expr

31
Classes générées
32
Classes générées
33
Tom, la suite
34
Pattern non-linéaire

• Une variable peut apparaître plusieurs fois dans
  le membre gauche
• rule
• equal(x,x) -gt True()
• equal(x,y) -gt False()
• Réduire
• equal(suc(zero()), zero())
• -gt False()
• equal(fib(plus(one,two)), suc(suc(suc(zero()))))
• -gt equal(fib(suc(suc(suc(zero())))),
  suc(suc(suc(zero()))))
• -gt equal(suc(suc(suc(zero()))),
  suc(suc(suc(zero()))))
• -gt True()
• Les règles sévaluent du haut vers le bas

35
Règles conditionnelles

• rule
• fib(zero()) -gt suc(zero())
• fib(suc(x)) -gt suc(x) if x zero()
  
• fib(suc(suc(x))) -gt plus(y,fib(suc(x))) where y
  fib(x)
• calcul de la substitution
• instanciation et évaluation des conditions/wheres
• instanciation du membre droit et réduction

36
Codage de la non-linéarité

• rule
• equal(x,x) -gt True()
• equal(x,y) -gt False()
• peut également sécrire
• rule
• equal(x,y) -gt True() if xy
• equal(x,y) -gt False() if x! y
• il faut disposer de légalité sur les termes

37
Remarques

• la construction rule peut contenir des variables
  et des fonctions Java (dans le membre droit)
• sinon, pour utiliser rule il faudrait que tout
  soit défini avec des rule

38
Exercice

• Définir une fonction
• plusInt(Nat, Nat) -gt int
• Qui retourne laddition de deux Nat sous forme
  dentier
• System.out.println( res plusInt(one,two))
  
• gt res 3

39
Solution

• vas
• imports int
• plusInt(Nat, Nat) -gt int
• rule
• plusInt(zero(),zero()) -gt 0
• plusInt(suc(x),y) -gt increment(plusInt(x,y))
  
• plusInt(x,suc(y)) -gt increment(plusInt(x,y))
  
• public int increment(int a) return a1

40
Pour combiner filtrage et Java

• public Nat plus(Nat n1, Nat n2)
• match(Nat n1, Nat n2)
• x, zero() -gt return x
• x, suc(y) -gt return suc(plus(x,y))
• plus nest plus un symbole défini, mais une
  fonction Java
• x et y sont des variables instanciées par
  filtrage
• elles deviennent des variables Java locales à
  chaque règle

41
On aurait pu écrire

• public Nat plus(Nat n1, Nat n2)
• match(Nat n2)
• zero() -gt return n1
• suc(y) -gt return suc(plus(n1,y))

42
Exercice

• Ecrire le programme qui affiche le résultat sous
  forme dentier
• System.out.println( res entier(suc(plus(on
  e,two))))
• gt res 4

43
Solution

• public int entier(Nat n)
• match(Nat n)
• zero() -gt return 0
• suc(x) -gt return 1 entier(x)
• Le membre droit peut mélanger Tom et Java

44
Sémantique du match

• Sélectionne le premier pattern qui filtre
• Evalue laction associée
• Lexécution reprend
• après laction (i.e. sélectionne le pattern
  suivant) sil ny a pas eu de break ou de return
• en fonction du flot de contrôle

45
Question

• Peut-on encoder un système de réécriture
  conditionnelle avec le match ?

46
Réponse

• Oui, il suffit de mettre une condition dans la
  partie action
• public int entier(Nat n)
• match(Nat n)
• zero() -gt return 0
• suc(x) -gt
• if(x ! zero() ) return 1 entier(x)
• suc(zero()) -gt return 1

47
Pattern non-linéaire

• rule
• f(x,x) -gt rhs
• peut aussi sécrire
• rule
• f(x,y) -gt rhs if x y
• match()
• f(x,y) -gt if( x y ) return rhs

48
Exemple Polynôme
49
Problème

• On veut pouvoir calculer des dérivées de
  polynômes
• Comment représenter un polynôme ?
• Comment calculer un polynôme dérivé ?

50
1er essai de signature

• vas
• module expression
• imports
• publicsorts Expression
• abstract syntax
• diff(eExpression,vExpression) -gt Expression
• X() -gt Expression
• a() -gt Expression
• zero() -gt Expression
• one() -gt Expression
• mult(arg1Expression,arg2Expression) -gt
  Expression
• plus(arg1Expression,arg2Expression) -gt
  Expression

51
Signature plus générique

• vas
• module expression
• imports
• publicsorts Expression
• abstract syntax
• zero() -gt Expression
• one() -gt Expression
• mult(arg1Expression,arg2Expression) -gt
  Expression
• plus(arg1Expression,arg2Expression) -gt
  Expression
• exp(arg1Expression) -gt Expression
• variable(stringString) -gt Expression
• constant(stringString) -gt Expression
• number(integerInt) -gt Expression
• diff(eExpression,vExpression) -gt Expression

52
Dérivation de polynomes

• rule
• diff(variable(v1),variable(v1)) -gt one()
• diff(plus(a1,a2),vx) -gt plus(diff(a1,vx),
  diff(a2,vx))
  
• diff(mult(a1,a2),vx) -gt plus(mult(a1,diffa2,vx)),
  mult(a2,diff(a1,vx)))
  
• diff(exp(a1),vx) -gt mult(diff
  (a1,vx),exp(a1))
  
• diff(variable(_),_) -gt zero()
• diff(constant(_),_) -gt zero()
• diff(number(_),_) -gt zero()
• diff(zero(),_) -gt zero()
• diff(one(),_) -gt zero()

53
Dérivation de polynomes

• rule
• diff(variable(v1),variable(v1)) -gt one()
• diff(plus(a1,a2),vx) -gt plus(diff(a1,vx),
  diff(a2,vx))
  
• diff(mult(a1,a2),vx) -gt plus(mult(a1,diffa2,vx)),
  mult(a2,diff(a1,vx)))
  
• diff(e_at_exp(a1),vx) -gt mult(diff (a1,vx),e)
  
• diff(variable(_),_) -gt zero()
• diff(constant(_),_) -gt zero()
• diff(number(_),_) -gt zero()
• diff(zero(),_) -gt zero()
• diff(one(),_) -gt zero()

54
Dérivation de polynomes

• rule
• diff(variable(v1),variable(v1)) -gt one()
• diff(plus(a1,a2),vx) -gt plus(diff(a1,vx),
  diff(a2,vx))
  
• diff(mult(a1,a2),vx) -gt plus(mult(a1,diffa2,vx)),
  mult(a2,diff(a1,vx)))
  
• diff(e_at_exp(a1),vx) -gt mult(diff (a1,vx),e)
  
• diffevariable(_) -gt zero()
• diff(constant(_),_) -gt zero()
• diff(number(_),_) -gt zero()
• diff(zero(),_) -gt zero()
• diff(one(),_) -gt zero()

55
Dérivation de polynomes

• rule
• diff(variable(v1),variable(v1)) -gt one()
• diff(plus(a1,a2),vx) -gt plus(diff(a1,vx),
  diff(a2,vx))
  
• diff(mult(a1,a2),vx) -gt plus(mult(a1,diffa2,vx)),
  mult(a2,diff(a1,vx)))
  
• diff(e_at_exp(a1),vx) -gt mult(diff (a1,vx),e)
  
• diff(variable,_) -gt zero()
• diff(constant,_) -gt zero()
• diff(number,_) -gt zero()
• diff(zero(),_) -gt zero()
• diff(one(),_) -gt zero()

56
Dérivation de polynomes

• rule
• diff(variable(v1),variable(v1)) -gt one()
• diff(plus(a1,a2),vx) -gt plus(diff(a1,vx),
  diff(a2,vx))
  
• diff(mult(a1,a2),vx) -gt plus(mult(a1,diffa2,vx)),
  mult(a2,diff(a1,vx)))
  
• diff(e_at_exp(a1),vx) -gt mult(diff (a1,vx),e)
  
• diff(variable,_) -gt zero()
• diff(constant,_) -gt zero()
• diff(number,_) -gt zero()
• diff(zero,_) -gt zero()
• diff(one,_) -gt zero()

57
Dérivation de polynomes

• rule
• diff(variable(v1),variable(v1)) -gt one()
• diff(plus(a1,a2),vx) -gt plus(diff(a1,vx),
  diff(a2,vx))
  
• diff(mult(a1,a2),vx) -gt plus(mult(a1,diffa2,vx)),
  mult(a2,diff(a1,vx)))
  
• diff(e_at_exp(a1),vx) -gt mult(diff (a1,vx),e)
  
• diff( (variableconstantnumberzeroone),_)
  -gt zero()

58
Exécution

• diff(mult(variable("X"),plus(variable("X"),constan
  t("a"))), variable("X"))
• gt plus(
• mult(variable("X"),plus(zero,zero)),
• mult(plus(variable("X"),constant("a")),zero))
• Exercice on voudrait simplifier le résultat,
  pour obtenir
• gt zero

59
Filtrage syntaxique
60
Règles

• Decompose (f P1Pn) ltlt (f A1An) ? ?i1n
  PiltltAi
• SymbolClash (f P1Pn) ltlt (g A1An) ? False
• Delete P ltlt P ? True
• PropagageClash S ? False ? False
• PropagateSuccess S ? True ? S
• f(x,g(y)) ltlt f(a,g(b))
• xltlta ? g(y)ltltg(b)
• xltlta ? yltltb
• f(b,g(y)) ltlt f(a,g(b))
• bltlta ? g(y)ltltg(b)
• False ? yltltb
• False

61
Implantation en Tom

• Quelle signature choisir ?
• Variable(nameString) -gt Term
  
• Appl(nameString, argsTermList) -gt Term
• cons(headTerm,tailTermList ) -gt TermList
• nil -gt
  TermList
  
• True -gt Term
• False -gt Term
• Match(patternTerm, subjectTerm) -gt Term
• And(a1Term, a2Term) -gt Term

62
Codage des règles

• rule
• // Delete
• Match(P,P) -gt True()
• // Decompose
• Match(Appl(name,a1),Appl(name,a2)) -gt
  decomposeList(a1,a2)
• // SymbolClash
• Match(Appl(name1,a1),Appl(name2,a2)) -gt False()

63
Décomposition - Simplification

• rule
• decomposeList(nil(),nil()) -gt True()
• decomposeList(cons(h1,t1),cons(h2,t2)) -gt
  And(Match(h1,h2),decomposeList(t1,t2))
  
• rule
• // PropagateClash
• And(False(),_) -gt False()
• And(_,False()) -gt False()
• // PropagateSuccess
• And(True(),x) -gt x
• And(x,True()) -gt x
• And(x,x) -gt x

64
Démo
65
Ancrage formel

• Mapping

66
Problématique

• Comment faciliter lutilisation du filtrage dans
  les programmes existants ?
• en permettant un mélange des syntaxes
• en permettant de filtrer vers des structures du
  langage hôte
• Nous avons donc besoin de filtrer  modulo des
  vues 

67
Solution adoptée

• Tom permet de  voir  les objets en mémoire
  comme des termes algébrique
• Il faut pour cela définir un  ancrage formel 
  permettant
• de savoir si un terme commence par un symbole
  donné
• daccéder à un sous terme donné

68
Plus formellement

• On considère les ensembles
• N, la représentation des entiers naturels
• B, la représentation des booléens
• F, la représentation des symboles
• T(F), la représentation des termes clos
• X, la représentation des variables

69
Contraintes à respecter

• ?t1,t2?T(F),
• eq(t1,t2) t1t2
• ?f?F, ?t?T(F),
• is_fsym(t,f) Symb(t)f
• ?f?F, ?i?1..ar(f), ?t?T(F)
• subtermf(t,i) ti

70
Structure de données

• struct term
• int symb
• struct term subterm
• On représente les symboles par des entiers
  (zero,3), (suc,5), (plus,7),

71
Mapping de Nat vers une structure C

• typeterm Nat
• implement
• equals(t1,t2)
• op Nat zero
• is_fsym(t)
• op Nat suc(pNat)
• is_fsym(t)
• get_slot(p,t)

struct term term_equals(t1,t2)
t!null t-gtsymb3 t!null t-gtsymb5
t-gtsubterm0
72
Mapping

• Permet de voir une structure arborescente comme
  un terme
• Plus généralement, permet de voir nimporte
  quelle structure de donnée comme un terme
• Permet de filtrer vers des objets en mémoire

73
Exercice

• Peut-on voir les entiers machine comme des
  entiers de Peano ?
• typeterm Nat
• implement int
• op Nat zero
• is_fsym(t) t0
• op Nat suc(pNat)
• is_fsym(t) tgt0
• get_slot(p,t) t-1

74
Peut-on filtrer vers des objets ?

• class A int a
• class B extends A int b
• typeterm A
• implement A
• equals(t1,t2) t1.equals(t2)
• typeterm B
• implement B
• equals(t1,t2) t1.equals(t2)

75
Mapping objet

• op A A(aint)
• is_fsym(t) t instanceof A
• get_slot(a,t) t.a
• op A B(aint,bint)
• is_fsym(t) t instanceof B
• get_slot(a,t) t.a
• get_slot(b,t) t.b
• Aax ltlt new A(3)
• Bbx ltlt new B(2,3)
• Aax ltlt new B(2,3)