Rcriture pour la programmation et la preuve

1
Réécriture pour la programmation et la preuve

• Claude Kirchner
• Pierre-Etienne Moreau

2
Application à XML
3
Document XML

• XML permet de décrire des documents structurés
• lt?xml version"1.0" encoding"UTF-8"?gt
• ltPersonsgt
• ltPerson Age"30"gt ltFirstNamegt Paul lt/FirstNamegt
  lt/Persongt
• ltPerson Age"42"gt ltFirstNamegt Mark lt/FirstNamegt
  lt/Persongt
• ltPerson Age"21"gt ltFirstNamegt
  Jurgen lt/FirstNamegt lt/Persongt
• ltPerson Age"21"gt ltFirstNamegt
  Julien lt/FirstNamegt lt/Persongt
• ltPerson Age"24"gt ltFirstNamegt
  Pierre lt/FirstNamegt lt/Persongt
• lt/Personsgt
• On peut voir un document XML comme un arbre

4
Transformation de documents XML

• On a envie de pouvoir manipuler ces données
• pour y rechercher de linformation
• pour générer de nouveaux documents (HTML, LaTeX,
  PDF, XML, etc.)
• Quels sont les outils permettant de le faire
• XSLT / XPath
• Xquery
• Xduce / Cduce
• DOM
• Peu permettent de manipuler un document XML en
  Java
• Les manipulations se font souvent en utilisant
  DOM directement

5
Exemple

• On veut savoir sil existe un noeud de la forme
  ltPersongtltFirstNamegt Julien lt/FirstNamegtlt/Persongt
• lt?xml version"1.0" encoding"UTF-8"?gt
• ltPersonsgt
• ltPerson Age"30"gt ltFirstNamegt Paul lt/FirstNamegt
  lt/Persongt
• ltPerson Age"42"gt ltFirstNamegt Mark lt/FirstNamegt
  lt/Persongt
• ltPerson Age"21"gt ltFirstNamegt
  Jurgen lt/FirstNamegt lt/Persongt
• ltPerson Age"21"gt ltFirstNamegt
  Julien lt/FirstNamegt lt/Persongt
• ltPerson Age"24"gt ltFirstNamegt
  Pierre lt/FirstNamegt lt/Persongt
• lt/Personsgt

6
Filtrage

• Il faut savoir si un pattern XML filtre vers un
  noeud de document XML
• On aimerait pouvoir écrire
• match(t)
• ltPersongtltFirstNamegt Julien lt/FirstNamegtlt/Persongt
  -gt
• // Noeud trouvé
• Ou plus généralement
• ltPersongtltFirstNamegt X lt/FirstNamegtlt/Persongt -gt
  

7
Modèle de donnée (simplifié)

• ElementNode(namestr, attrListTNodeList,
• childListTNodeList) -gt TNode
• AttributeNode(namestr, valuestr) -gt TNode
• TextNode(datastr) -gt TNode
• conc(TNode) -gt TNodeList

8
XML vs. Term

• Un document XML peut se voir comme un arbre
• ltA a"at1"gtltB/gtlt/Agt
• est représenté par
• ElementNode("A",
• conc(AttributeNode("a", "at1")),
• conc(ElementNode("B",conc(),conc()))
• )

9
Pattern XML

• On veut pouvoir écrire un pattern de la forme
• ltA a"at1"gtXlt/Agt
• qui sera encodé par
• ElementNode("A",
• conc(AttributeNode("a", "at1")),
• conc(X)
• )

10
Questions

• A-t-on
• ltA a"at1"gtXlt/Agt ltlt ltA a"at1"gtltB/gtlt/Agt ?
• ltA a"at1"gtXlt/Agt ltlt ltA a"at1"gtltB/gtltC/gtlt/Agt ?
• Quel est le type de X ?
• TNode ?
• TNodeList ?
• On voudrait pouvoir écrire
• ltA a"at1"gtXlt/Agt ltlt ltA a"at1"gtltB/gtltC/gtlt/Agt
• Quelles sont les solutions ?

11
Questions

• En fonction du parseur, ltA a"at1"gtltB/gtlt/Agt peut
  être reconnu comme ltA a"at1"gt?ltB/gt?lt/Agt
• A-t-on
• ltA a"at1"gtXlt/Agt ltlt ltA a"at1"gt?ltB/gt?lt/Agt ?
• ltA a"at1"gtXlt/Agt ltlt ltA a"at1"gt?ltB/gt?lt/Agt ?
• Comment est encodé ltA a"at1"gt?ltB/gt?lt/Agt ?
• ElementNode("A",
• conc(AttributeNode("a", "at1")),
• conc(
• TextNode("?"),
• ElementNode("B",conc(),conc()),
• TextNode("?"))
• )
• Est-ce que cela filtre ?

12
Notation explicite

• ltA a"at1"gt(_,X,_)lt/Agt
• qui correspond à
• ltA a"at1"gtconc(_,X,_)lt/Agt
• A-t-on ltA a"at1"gt(_,X,_)lt/Agt ltlt ltA
  a"at1"gt?ltB/gt?lt/Agt ?
• Oui, il y a 3 solutions

13
Notation implicite

• ltA a"at1"gt(_,X,_)lt/Agt
• qui correspond à
• ltA a"at1"gtXlt/Agt
• qui correspond également à
• ltA a"at1"gtXlt/Agt
• A-t-on ltA a"at1"gtXlt/Agt ltlt ltA a"at1"gt?ltB/gt?lt/Agt
  ?
• Oui, il y a 3 solutions

14
Attributs

• Les attributs sont représentés par une liste de
  couples (nom,valeur)
• Il existe également des notations implicites et
  explicites
• Ainsi
• ltA a"at1"gt correspond à ltA a"at1"gt
• qui correspond à ltA (_,a"at1",_)gt

15
Questions

• A-t-on
• ltA a"at1"gtlt/Agt ltlt ltA a"at1"gtlt/Agt ?
• ltA a"at1"gtlt/Agt ltlt ltA a"at1" b"at2"gtlt/Agt ?
• Pourquoi ?
• car ltA (_,a"at1",_)gtlt/Agt ltlt ltA (a"at1"
  b"at2 )gtlt/Agt ?
• A-t-on
• ltA a"at1" b"at2"gtlt/Agt ltlt ltA a"at1"
  b"at2"gtlt/Agt ?
• ltA a"at1" b"at2"gtlt/Agt ltlt ltA b"at2"
  a"at1"gtlt/Agt ?
• Non, car
• (_, a"at1", _, b"at2", _) !ltlt (b"at2",
  a"at1")
• Il faudrait du filtrage AC avec élément neutre!

16
Attributs dans Tom

• On considère un ordre sur les noms dattributs
• et les formes canoniques où les attributs sont
  triés
• Ainsi, ltA b"at2" a"at1"gtlt/Agt est représenté par
• ElementNode("A",
• conc( AttributeNode("a", "at1"),
• AttributeNode("b", "at2")),
• conc())
• De même, pour les motifs

17
Utilisation dans Tom

• Node sort(Node subject)
• match(subject)
• ltPersonsgt(X1,p1,X2,p2,X3)lt/Personsgt -gt
  
• if(compare(p1,p2) gt 0)
• return sort(xml(ltPersonsgt
• X1 p2 X2 p1 X3
• lt/Personsgt))
• return subject

18
Comparaison dattributs

• int compare(Node t1, Node t2)
• match(t1, t2)
• ltPerson Agea1gtltFirstNamegt n1
  lt/FirstNamegtlt/Persongt,
• ltPerson Agea2gtltFirstNamegt n2
  lt/FirstNamegtlt/Persongt
• -gt return a1.compareTo(a2)
• return 0

19
Ancrage formel

• Mapping

20
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 

21
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é

22
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

23
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

24
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),

25
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
26
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

27
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

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

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

30
Demo
31
Questions

• Doit-on écrire des mappings ?
• Que fait vas au juste ?

32
Outils autour de Tom

• Aterm, SDF, ApiGen, Vas

33
Bibliothèque ATerm

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

34
ATerms
35
Bibliothèque ATerm

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

• getAnnotation
• setAnnotation
• toString
• etc.

36
Bibliothèque ATerm

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

• getName
• getArity

37
Bibliothèque ATerm

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

• getAFun
• getArgument
• setArgument
• etc.

38
Bibliothèque ATerm

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

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

39
Bibliothèque ATerm

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

• makeAFun
• makeAppl
• parse
• readFromFile
• etc.

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

41
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

42
Exemple

• Module Expressions
• true -gt Bool
• false -gt Bool
• eq(lhsExpr, rhsExpr) -gt Bool
• id(valuestr) -gt Expr
• nat(valueint) -gt Expr
• add(lhsExpr, rhsExpr) -gt Expr
• mul(lhsExpr, rhsExpr) -gt Expr

43
Classes générées
44
Classes générées
45
Stratégies
46
Programmation par réécriture

• Avantages
• le filtrage est un mécanisme expressif
• les règles expriment des transformations
  élémentaires
• Limitations
• les systèmes de règles sont souvent non-terminant
  et/ou non confluent
• en général, on ne veut pas appliquer toutes les
  règles en même temps

47
Exemple de système non terminant

• And(Or(x,y),z) ? Or(And(x,z),And(y,z))
• And(z,Or(x,y)) ? Or(And(z,x),And(z,y))
• Or(And(x,y),z) ? And(Or(x,z),Or(y,z))
• Or(z,And(x,y)) ? And(Or(z,x),Or(z,y))
• Not(Not(x)) ? x
• Not(And(x,y)) ? Or(Not(x),Not(y))
• Not(Or(x,y)) ? And(Not(x),Not(y))

48
Codage du contrôle dans les règles

• Solution classique
• introduire un nouvel opérateur f pour restreindre
  lensemble de règles permettant de normaliser
• l ? r devient f(l) ? r
• on normalise un terme f(t)
• lopérateur f permet de contrôler les règles à
  appliquer

49
Encodage du contrôle

• f(And(x,y)) ? and(x,y)
• f(Not(x)) ? not(x)
• f(Or(x,y)) ? Or(f(x),f(y))
• and(Or(x,y),z) ? Or(and(x,z),and(y,z))
• and(z,Or(x,y)) ? Or(and(z,x),and(z,y))
• and(x,y) ? And(x,y)
• not(Not(x)) ? x
• not(And(x,y)) ? Or(not(x),not(y))
• not(Or(x,y)) ? and(not(x),not(y))
• not(x) ? Not(x)

50
Conséquences

• Il faut définir la congruence explicitement, pour
  chaque règle et chaque constructeur
• Il ny a plus de séparation entre transformation
  et contrôle
• cela rend la compréhension plus difficile
• les règles sont moins réutilisables

51
Ce quon voudrait

• pouvoir contrôle lapplication des règles
• pouvoir spécifier simplement le  traversée 
  dune terme (I.e. appliquer une règles dans les
  sous-termes)
• tout en séparant règle et contrôle

52
Solution

• Utiliser des stratégies
• Combiner des transformations élémentaires
• Exemples
• disjunctive normal form
• dnf innermost(DAOL lt DAOR lt DN lt)
• DAOL And(Or(x,y),z) ? Or(And(x,z),And(y,z))
• DAOR And(z,Or(x,y)) ? Or(And(z,x),And(z,y))
• DN Not(Not(x)) ? x
• conjunctive normal form
• cnf innermost(DOAL lt DOAR lt DN lt)

53
Autres stratégies de traverse

• simplify bottomup(repeat(R1 lt ))
• simplify topdown(repeat(R1 lt ))
• Slide 14

54
(No Transcript)
55
Stratégies en Tom
56
Constructeurs élémentaires

• Identity
• Fail
• Not
• Sequence
• Choice
• All
• One
• Some
• IfThenElse
• Omega
• mu

57
Définition de stratégies

• op VisitableVisitor Try(s1VisitableVisitor)
  
• make(v) Choice(v,Identity)
• op VisitableVisitor Repeat(s1VisitableVisitor)
  
  
• make(v) mu(MuVar("x"),Choice(Sequence(v,MuVar(
  "x")),Identity()))
  
• op VisitableVisitor TopDown(s1VisitableVisitor)
  
  
• make(v) mu(MuVar("x"),Sequence(v,All(MuVar("x
  "))))
• op VisitableVisitor OnceBottomUp(s1VisitableVisi
  tor)
  
• make(v) mu(MuVar("x"),Choice(One(MuVar("x")),v
  ))
  
• op VisitableVisitor Innermost(s1VisitableVisitor
  )
  
• make(v) mu(MuVar("x"), Sequence(All(MuVar("x"
  )),
• Try(Sequence(v,MuVar("x")))))

58
Stratégie élémentaire en Tom

• class RewriteSystem extends strategy.term.termVisi
  tableFwd
• public RewriteSystem()
• super(Fail())
• public Term visit_Term(Term arg) throws
  VisitFailure
• match(Term arg)
• a() -gt return b()
• b() -gt return c()
• g(c(),c()) -gt return c()
• throw new VisitFailure()

59
Utilisations

• VisitableVisitor rule new RewriteSystem()
• Term subject f(g(g(a,b),g(a,a)))
• OnceBottomUp(rule).visit(subject)
• Innermost(rule).visit(subject)
• Repeat(OnceBottomUp(rule)).visit(subject)

60
(mode paranoïaque)

• VisitableVisitor rule new RewriteSystem()
• Term subject f(g(g(a,b),g(a,a)))
• VisitableVisitor onceBottomUp
• mu(MuVar("x"),Choice(One(MuVar("x")),rule))
• onceBottomUp.visit(subject))
• VisitableVisitor innermostSlow
• mu(MuVar("y"),Choice(Sequence(onceBottomUp,MuVar(
  "y")),Identity()))
• innermostSlow.visit(subject))
• VisitableVisitor innermost
• mu(MuVar("x"),Sequence(All(MuVar("x")),Choice(Seq
  uence(rule,MuVar("x")),Identity)))
  
• innermost.visit(subject))

61
Questions

• Comment calculer des ensembles de résultats
• Exemples
• f(g(g(a,b),g(a,b)))
• trouver les x tels que g(x,b) filtre un sous
  terme

62
Solution

• considerer
• s(col) g(x,b) ? col.add(x)
• appliquer
• Try(BottomUp(s(col)))
• énumérer col

63
Codage

• class RewriteSystem extends strategy.term.termVis
  itableFwd
  
• Collection collection
• public RewriteSystem(Collection c)
• super(Fail())
• this.collection c
• public Term visit_Term(Term arg) throws
  VisitFailure
  match(Term arg)
• g(x,b()) -gt collection.add(x)
• return arg

64
Codage

• Collection collection new HashSet()
• VisitableVisitor rule new RewriteSystem(collecti
  on)
  
• Term subject f(g(g(a,b),g(c,b)))
• Try(BottomUp(rule)).visit(subject)
• System.out.println("collect " collection)
  
  

65
Stratégie Oméga

• Oméga
• Position

66
Replace et Subterm

• Etant donnée une position p
• getReplace(t) retourne une stratégie qui,
  appliquée sur un terme donné, remplace le
  sous-terme à la position p donnée par le terme t
• getSubterm() retourne une stratégie qui retourne
  le sous-terme à la position p
• ces stratégies encodent les laccès à un
  sous-terme et lopération de remplacement
• cela permet dencoder de lexploration traversée
  non-déterministe

67
Exemple complexe

• Xmas

68
(No Transcript)
69
Principales applications