Fundamentos de la especificación formal

Fundamentos de la
especificación formal
Métodos Formales en
Ingeniería del Software
María Alpuente
El lenguaje Maude
• Sintaxis: se utilizan reglas de reescritura
(como Haskell, ML, Scheme o Lisp)
• Semántica: Lógica de Reescritura
(modela concurrencia y objetos)
Ejemplo
mod SIMPLE-VENDING-MACHINE is
sorts Coin Item State .
subsorts Coin Item < State .
op
op
op
op
op
op
null : -> State .
_ _ : State State -> State [assoc id: null] .
$ : -> Coin .
q : -> Coin .
c : -> Item .
b : -> Item .
var St : State .
rl $ => c .
--- da 1 café por 1 $
rl $ => b q .
--- o da 1 bollo y el cambio (1/4 de $)
rl q q q q => $ . --- cambia 4 monedas de 1/4 en 1 $
mod SIMPLE-VENDING-MACHINE is
sorts Coin Item State .
op
op
op
op
op
op
Signatura
null : -> State .
_ _ : State State -> State . [assoc id: null] .
$ : -> Coin .
q : -> Coin .
c : -> Item .
b : -> Item .
var St : State .
rl $ => c .
rl $ => b q .
rl q q q q => $ .
Presentación
Maude> rew q q q q null .
rl $ => c .
rl $ => a q .
rl q q q q => $ .
Maude> rew q q q q null .
rl $ => c .
rl $ => b q .
rl q q q q => $ .
q q q q null
$
c
b q
Maude> rew q q q q null .
rewrite in SIMPLE-VENDING-MACHINE : q q q q .
rewrites: 2 in 0ms cpu (0ms real) (~ rewrites/second)
result Item: c
q q q q
rl $ => c .
rl $ => b q .
rl q q q q => $ .
$
c
b q
Maude> search q q q q =>! X:State .
search in VENDING-MACHINE : q q q q =>! X:State .
Solution 1 (state 2)
X:State --> c
Solution 2 (state 3)
X:State --> b q
No more solutions.
q q q q
rl $ => c .
rl $ => b q .
rl q q q q => $ .
$
c
b q
Maude> search $ q q q =>! X:State .
search in VENDING-MACHINE : $ q q q =>! X:State .
Solution 1 (state 1)
X:State --> c q q q
Solution 2 (state 4)
X:State --> b c
Solution 3 (state 5)
X:State --> b b q
No more solutions.
0
Maude> show search graph .
state 0, State: $ q q q
arc 0 ===> state 1 (rl $ => c .)
arc 1 ===> state 2 (rl $ => b q .)
1
$ q q q
2
c q q q
b q q q q
state 1, State: c q q q
state 2, State: b q q q q
arc 0 ===> state 3 (rl q q q q => $ .)
state 3, State: b $
arc 0 ===> state 4 (rl $ => c .)
arc 1 ===> state 5 (rl $ => b q .)
state 4, State: b c
state 5, State: b b q
3
4
b c
b $
5
b q b
Evaluación de expresiones (i)
Reducción
e
e’
l
=>
lhs
r
rhs
Evaluación de expresiones (ii)
Reducción
e ≡
e’ ≡
b $
$
=>
b q
b b q
Evaluación de expresiones (iii)
Reducción
e ≡
sqr(inc(2))
inc(X)
e’ ≡
=>
sqr(2+1)
X + 1
sqr(inc(2))
inc(X) => X + 1
sqr(2+1)
sqr(X) => X * X
inc(2)*inc(2)
Evaluación de expresiones (iv)
Reducción
e ≡
sqr(inc(2))
sqr(X)
e’ ≡
=>
inc(2)*inc(2)
X * X
Definiciones
• Un redex es una instancia lσ de una parte
izquierda l de una regla l => r
• Una expresión e se reduce (se reescribe) a e’ si:
– contiene un redex lσ de una ecuación l = r
– e’ se obtiene reemplazando en e el redex
lσ por rσ
• El reemplazamiento, dentro de una expresión, de
una instancia de la lhs de una regla por la
correspondiente instancia de la rhs se denomina
paso de reescritura o reducción
Evaluación de expresiones (v)
Reducción
r
l
lσ
rσ
e
e’
l
=
r
• La evaluación de una expresión e consiste
en aplicar sucesivos pasos de reducción →
hasta obtener una forma normal o
irreducible n (es decir, una expresión que no
contiene redexes). En símbolos:
e →! n sii e →∗ n y n →/
• Según la estrategia de reducción escogida,
el resultado puede cambiar
Estrategias de evaluación
sqr(inc(2))
inc(X) => X + 1
sqr(2+1)
Impaciente
sqr(X) => X * X
inc(2)*inc(2)
Estrategias de evaluación
sqr(inc(2))
inc(X) => X + 1
sqr(2+1)
sqr(X) => X * X
inc(2)*inc(2)
Perezosa
Estrategias de evaluación
• Maude es un lenguaje impaciente (a diferencia
de otro lenguajes funcionales como Haskell, que
son perezosos)
• Para garantizar la terminación de los cómputos,
es necesario imponer condiciones a las reglas
Terminación
• Un programa (i.e., un conjunto de reglas) es
terminante si no existen cadenas infinitas de pasos
de reducción:
t1 → t2 → t3 … → …
• Cuando un programa es terminante, la forma
normal de cualquier término siempre existe
• La terminación es una propiedad indecidible de los
programas (pero hay condiciones suficientes)
Terminación
Ejemplos de reglas no terminantes:
inf X => X:(inf X+1) .
loop => loop .
X => a .
St => St $ .
and(X,Y) => and(Y,X)
Confluencia
• Un programa (i.e., un conjunto de reglas) es
confluente si siempre que un término se puede
reescribir a dos términos distintos, éstos, a su vez,
convergen a un mismo término. En símbolos:
∀ t, s1, s2 tal que
t →∗ R s 1 y t →∗ R s 2
∃ u tal que
s1 →∗R u y s2 →∗R us1
t
s2
u
Confluencia
• Cuando un programa es confluente, la forma
normal de cualquier término, si existe, es única
• La confluencia es una propiedad indecidible de
los programas (pero hay condiciones suficientes,
por ejemplo ortogonalidad = “linealidad por la
izquierda”+ “no solapamiento de lhs’s”)
• Ejemplo TRS no lineal donde f(c,c) tiene dos
formas nomales, a y b
f(x,x)=> a
f(x,g(x))=>b
c=>g(c)
Confluencia
Ejemplos de programa no confluentes:
$ => c .
$ => b q
.
Ecuaciones
• Las reglas que son terminantes y confluentes
(no dan resultados divergentes) se pueden escribir
como ecuaciones dentro de módulos funcionales
y se usan como reglas de simplificación ecuacional.
op nil : -> List .
op _._ : Nat List -> List .
op length: List -> Nat .
eq length(nil) = 0 .
eq length(I.L) = s length(L) .
Reescritura ecuacional
• Si tenemos un programa P = R ∪ E
t →R ∪ E s sii
t →!
E
t’ y t’ →R s’ y s’ →!E s
Ejemplo de
reescritura ecuacional
• Dado el conjunto E de ecuaciones para
las funciones length y +
y R={ inf X => X.(inf X+1) }
inf (length(0.1.nil)) →R ∪ E 2.inf(3)
Atributos
• Cuando aparecen operadores asociativos,
conmutativos, etc, la reescritura no es capaz
de computar de forma efectiva con ellos
(espacio de búsqueda infinito)
• Por ello, dichas propiedades se tratan aparte,
predefinidas como ATRIBUTOS
Ejemplo de
Reescritura con atributos
and(X,Y) = and(Y,X)
and(X,true) => X
and(X,false) => false
> rew and(true,X) →[regla1]
and(X,true) →[regla1]
and(true,X) →[regla1] … ∞ …
Ejemplo de
Reescritura con atributos
and(X,Y) = and(Y,X)
op and : Bool Bool -> Bool [comm] .
and(X,true) => X
and(X,false) => false
> rew and(true,X) →[comm]
X
Reescritura condicional
• Las reglas condicionales tienen la forma general:
crl
l
=> r
if
C
donde C es una conjunción (/\) de expresiones de
la forma
•
•
•
•
t=t’ (equation)
t:=t’ (matching equation)
t=>t’ (rule)
t: S (sort expression)
(una expresion booleana b se considera b=true)
• Ej. b(X)=>c(X*2) if a(X)=>b(Y)
Reescritura condicional
• Relación de reducción condicional:
(para expresiones t:=t’)
Un redex lσ se reescribe a la expresión rσβ
si existe una sustitución β que hace emparejar con el
patrón tσ
la forma normal de t’σ, es decir, si tσβ=t’σ↓
Ejemplo de
Reescritura condicional
crl f(X)=>X+N if X>0/\s(N):=s(0)
Ejemplo de reducción condicional:
σ={X/2}
β={N /0}
f(2)
→
2+0
Maude> search $ q q q q =>! X:State .
search in VENDING-MACHINE : $ q q q q =>! X:State .
Solution 1 (state 6)
X:State --> c c
Solution 2 (state 7)
X:State --> q b c
Solution 3 (state 8)
X:State --> q q b b
No more solutions.
Maude> show search graph .
state
arc 0
arc 1
arc 2
0, State: $ q q q q
===> state 1 (rl q q q q => $ .)
===> state 2 (rl $ => c .)
===> state 3 (rl $ => q b .)
state 1, State: $ $
arc 0 ===> state 4 (rl $ => c .)
arc 1 ===> state 5 (rl $ => q b .)
state 2, State: q q q q c
arc 0 ===> state 4 (rl q q q q => $ .)
state 3, State: q q q q q b
arc 0 ===> state 5 (rl q q q q => $ .)
state 4, State: $ c
arc 0 ===> state 6 (rl $ => c .)
arc 1 ===> state 7 (rl $ => q b .)
state 5, State: $ q b
arc 0 ===> state 7 (rl $ => c .)
arc 1 ===> state 8 (rl $ => q b .)
state 6, State: c c
state 7, State: q b c
state 8, State: q q b b
Maude> show search graph .
state
arc 0
arc 1
arc 2
0, State: $ q q q q
===> state 1 (rl q q q q => $ .)
===> state 2 (rl $ => c .)
===> state 3 (rl $ => q b .)
0
1
state 1, State: $ $
arc 0 ===> state 4 (rl $ => c .)
arc 1 ===> state 5 (rl $ => q b .)
4
$ $
2
$ c
state 3, State: q q q q q b
arc 0 ===> state 5 (rl q q q q => $ .)
state 4, State: $ c
arc 0 ===> state 6 (rl $ => c .)
arc 1 ===> state 7 (rl $ => q b .)
state 5, State: $ q b
arc 0 ===> state 7 (rl $ => c .)
arc 1 ===> state 8 (rl $ => q b .)
state 6, State: c c
state 7, State: q b c
state 8, State: q q b b
c c
c q q q q
5
state 2, State: q q q q c
arc 0 ===> state 4 (rl q q q q => $ .)
6
$ q q q q
7
q b c
3
$ q b
8
q q b c
q b q q q q