Techniques de R

1
Techniques de Réécriture et Transformations

• Pierre-Etienne Moreau

2
Manipulation de listes
3
Représentation des listes

• Habituellement, on considère une liste vide nil,
  et un opérateur de concaténation cons
• nil ? L
• cons E x L ? L
• On représente ainsi la liste a.b.c par
• cons(a,cons(b,cons(c,nil)))

4
Question

• Comment retrouver un élément donné ?
• appartient(cons(a,cons(b,cons(c,nil))),a) ? ?
• appartient(cons(a,cons(b,cons(c,nil))),b) ? ?
• appartient(cons(a,cons(b,cons(c,nil))),d) ? ?

5
Une réponse

• appartient(cons(x,l),x) ? true
• appartient(cons(y,l),x) ? appartient(l,x)
• appartient(nil,x) ? false

6
Une autre réponse

• Dans Tom on peut écrire
• appartient( (_,x,_) , x) ? true
• appartient( l , x) ? false

7
Symboles associatifs

• f est associatif si
• f(x,f(y,z)) f(f(x,y),z)
• Dans ce cas, a-t-on
• f(a,f(b,f(c,d))) f(f(a,b),f(c,d)) ?
• ? tel que ?f(x,f(c,y)) f(f(a,b),f(c,d)) ?
• f(x,f(c,y)) ltlt f(f(a,b),f(c,d)) ?
• f(x,f(c,y)) ltlt f(a,f(b,f(c,d))) ?
• f(x,f(d,y)) ltlt f(a,f(b,f(c,d))) ?

8
Associativité avec élément neutre

• f(x,f(y,z)) f(f(x,y),z)
• f(x,e) f(e,x) x
• Dans ce cas, a-t-on
• f(x,f(c,y)) ltlt f(a,f(b,f(c,d))) ?
• f(x,f(d,y)) ltlt f(a,f(b,f(c,d))) ?

9
Associativité dans Tom

• On considère les formes aplaties
• f(a,b,c,d)
• f(x,c,y)
• On peut écrire
• f(x,c,y) ltlt f(a,b,c,d)
• f(x,d,y) ltlt f(a,b,c,d)

10
Questions

• Comment savoir sil y a un a suivi dun b ?
• f(x,a,y,b,z) ltlt f(a,b,c,d)
• Avec exactement un terme entre les deux ?
• On ne peut pas lexprimer

11
Signature

• f est darité variable et a pour profil
• f E x x E -gt L
• On le note
• f( E ) -gt L
• Cela permet décrire
• f(a(),b(),c(),d())
• f(x,a(),y,b(),z)

12
Questions

• Quel est le type de x,y et z dans
  f(x,a(),y,b(),z) ?
• réponse E
• Comment exprimer f(x,c(),y) tel que cela filtre
  vers f(a(),b(),c(),d()) ?
• Il faut des variables de type L
• On les note f(x,c(),y)

13
Exercice

• Exprimer la fonction dappartenance sur des
  listes associatives
• appatient(f(_,x,_),x) -gt True
• appatient(f(_),x) -gt False

14
Exercice

• Comment éliminer les doublons ?
• f(X,e,e,Z) -gt f(X,e,Z)
• élimine les doublons consécutifs
• Comment éliminer les doublons distants
• f(X,e,Y,e,Z) -gt f(X,e,Y,Z)

15
Exercice

• Etant donné un ordre sur les éléments
• Exprimer un algorithme de tri
• f(X,e1,e2,Y) -gt f(X,e2,e1,Y) if e2lte1
• Implanter le en Tom

16
Demo
17
Implantation dun algorithme de filtrage
syntaxique

• Utiliser des symboles associatifs
• Quelle signature choisir ?
• Variable(nameString) -gt Term
  
• Appl(nameString, argsTermList) -gt Term
• conc( Term ) -gt TermList
• True -gt Term
• False -gt Term
• Match(patternTerm, subjectTerm) -gt Term
• And( lTermList ) -gt Term

18
Codage des règles et des termes

• rule
• // PropagateClash
• And(conc(_,False(),_)) -gt False()
• // PropagateSuccess
• And(conc(X,True(),Y)) -gt And(conc(X,Y))
• And(conc(X,True(),Y)) -gt And(conc(X,Y))
• And(conc(X,c,Y,c,Z)) -gt And(conc(X,c,Y,Z))
• And(conc()) -gt True()
• Term p2 Appl("f",conc(Variable("x"),Appl("g",co
  nc(Variable("y")))))
• Term s2 Appl("f",conc(Appl("a",conc()),Appl("g"
  ,conc(Appl("b",conc())))))
  

19
Stratégies
20
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

21
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))
• And(Or(a,b),c)
• ? Or(And(a,c),And(b,c))
• ? And(Or(a, And(b,c)),Or(c, And(b,c)))
• ?

22
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 eval(l) ? r
• on normalise un terme eval(t)
• lopérateur f permet de contrôler les règles à
  appliquer

23
Encodage du contrôle

• eval(And(x,y)) ? and(x,y)
• eval(Or(x,y)) ? Or(eval(x),eval(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)
• eval(And(Or(a,b),c))
• ? and(Or(a,b),c))
• ? Or(and(a,c),and(b,c))
• ? Or(And(a,c),And(b,c))

24
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

25
Ce quon voudrait

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

26
Solution

• Utiliser des stratégies
• Combiner des transformations élémentaires
• Exemples
• disjunctive normal form
• dnf innermost(DAOL lt DAOR 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))
• conjunctive normal form
• cnf innermost(DOAL lt DOAR lt )

27
Stratégies élémentaires
28
Règle de réécriture

• Une règle R g ? d est une stratégie élémentaire
• Exemples R a ? b
• (R)a b
• (R)b fail
• (R)f(a) fail

29
Identité et échec

• id ne fait rien, mais néchoue pas
• fail échoue tout le temps
• Exemples
• (id)a a
• (id)b b
• (fail)a fail

30
Composition

• S1 S2
• Applique S1, puis S2
• Echoue si S1 ou S2 échoue
• Exemples
• (a ? b b ? c)a c
• (a ? b c ? d)a fail
• (b ? c a ? b)a fail

31
Choix

• S1 lt S2
• Applique S1. Si cela échoue, applique S2
• Exemples
• (a ? b lt b ? c)a b
• (b ? c lt a ? b)a b
• (b ? c lt c ? d)a fail
• (b ? c lt id)a a

32
Quelques lois

• id s s
• s id s
• id lt s s
• s lt id ?s
• fail lt s s
• s lt fail s
• fail s fail
• s fail ?fail (pourquoi ?)

33
Exercice

• Définir les opérateurs
• Try(s)
• Repeat(s)

34
Stratégies paramétrées

• try(s) s lt id
• repeat(s) try(s repeat(s))
• Exemples
• (try(b ? c))a a
• (repeat(a ? b))a b
• (repeat(b ? c lt a ? b))a c
• (repeat(b ? c))a a

35
Primitives pour traverser

• applique une stratégie à un ou plusieurs fils
  directes
• Congruence
• applique une stratégie différente à chaque fils
  dun constructeur
• all
• applique une stratégie à tous les fils
• one
• applique une stratégie à un fils

36
Congruence

• c(S1,,Sn) pour chaque constructeur c
• Exemples
• (f(a ? b))a fail
• (f(a ? b))f(a) f(b)
• (f(a ? b))f(b) fail
• (g(try(b ? c) lt try(a ? b)))g(a,a) g(a,b)
• Exercice
• définir la stratégie map sur les liste (cons,nil)

37
Congruence générique

• all(S), échoue si S échoue sur un des fils
• Exemples
• (all(a ? b))f(a) f(b)
• (all(a ? b))g(a,a) g(b,b)
• (all(a ? b))g(a,b) fail
• (all(a ? b))a a
• (all(try(a ? b)))g(a,c) g(b,c)

38
Congruence générique

• one(S), échoue si S ne peut pas sappliquer sur
  un des fils
• Exemples
• (one(a ? b))f(a) f(b)
• (one(a ? b))g(a,a) g(a,b)
• (one(a ? b))g(b,a) g(b,b)
• (one(a ? b))a fail

39
Stratégies de parcours

• bottomup(S) all(bottomup(S)) S
• topdown(S) S all(topdown(S))
• innermost(S) bottomup(try(S innermost(S)))
• oncebu(S) one(oncebu(S)) lt S
• oncetd(S) S lt one(oncetd(S))
• innermost(S) repeat(oncebu(innermost(S)))
• outermost(S) repeat(oncetd(outermost(S)))

40
Stratégies en Tom
41
Constructeurs élémentaires

• Identity
• Fail
• Sequence
• Choice
• All
• One
• mu

42
Utilisation

• Une stratégie est de type Strategy
• Strategy s Identity()
• Un terme est de type Visitable
• Visitable t a()
• Une stratégie peut sappliquer sur un terme
• Visitable result s.visit(t)
• Une stratégie préserve le type
• Term t a()
• Term result (Term) s.visit(t)

43
Définition de stratégies

• Strategy Try(Strategy S)
• return Choice(S,Identity())
• Strategy Repeat(Strategy S)
• return mu(MuVar("x"),Choice(Sequence(S,MuVar("x"
  )),Identity()))
• Strategy OnceBottomUp(Strategy S)
• return mu(MuVar("x"),Choice(One(MuVar("x")),S))
  
  
• Exercice
• implanter innermost(a ?b)

44
Stratégie élémentaire en Tom

• strategy RewriteSystem extends Fails()
• visit Term
• a() -gt return b()
• Strategy S Repeat(OnceBottomUp(RewriteSystem())
  )
• Term result S.visit(f(a(),g(b(),a())))

45
Utilisations

• Strategy 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)

46
(mode paranoïaque)

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

47
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

48
Solution

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

49
Codage

• strategy RewriteSystem(cCollection) extends
  Identity()
• visit Term
• g(x,b()) -gt collection.add(x)
• Collection collection new HashSet()
• Strategy rule RewriteSystem(collection)
• Term subject f(g(g(a,b),g(c,b)))
• Try(BottomUp(rule)).visit(subject)
• System.out.println("collect " collection)
  
  

50
Stratégie Oméga

• Oméga
• Position

51
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