prac1

Metodos Formales Industriales (MFI)

—practicas—

Grado de Ingenierıa en Informatica

Practica 1: Programacion, modelado yverificacion en Maude

Santiago Escobar

Despacho 237Edificio DSIC 2 piso

Curso 2012/2013

1. Introduccion

En esta practica vamos a aprender a modelar sistemas en el lenguaje de programacion de altorendimiento Maude y verificar algunas propiedades sobre dichos sistemas.

Los metodos formales en la Ingenierıa Informatica se definen sobre cuatro pilares basicos: (1) laexistencia de un modelo semantico claro y conciso sobre el comportamiento de los sistemas software,(2) la existencia de una representacion clara, detallada y sin ambiguedades que permita expresarsistemas software y asociarles una semantica concreta, (3) la existencia de un formalismo claro ydetallado en el que se puedan definir propiedades de un sistema y en el que se pueda averiguar lavalidez o falsedad de dichas propiedades en funcion del modelo semantico y (4) la existencia detecnicas eficientes y eficaces para verificar dichas propiedades.

Hasta hoy, los metodos formales se han aplicado, por un lado, como parte del proceso de desa-rrollo de software, generando software fiable y seguro simplemente por construccion, gracias a lasbuenas cualidades de una representacion y una semantica claras y concisas, pero tambien comotecnicas, en este caso aplicadas a posteriori, de especificacion y verificacion de propiedades de lossistemas software ya creados (con o sin garantıas de correccion), gracias a las buenas cualidadesde un formalismo claro para especificar propiedades y de tecnicas efectivas para comprobarlas. Enel primer caso, los lenguajes de programacion (o especificacion) denominados declarativos (entrelos que se encuentran los lenguajes algebraicos Maude y OBJ, los lenguajes funcionales Haskell yML, los lenguajes logicos Prolog y Godel, o los lenguajes logico-funcionales Curry y TOY) son muyadecuados para ser utilizados durante el proceso de produccion de software, especialmente en ladefinicion de especificaciones prototıpicas ejecutables, donde compiten con ventaja con otro tipode especificaciones mas farragosas como UML presentadas en lenguaje natural o semi-formal queno pueden ser completamente automatizadas. En el segundo caso, las tecnicas formales de especifi-cacion y verificacion de propiedades basadas en diferentes formalismos como la alcanzabilidad porreescritura, tema central de esta practica, o la verificacion de modelos (o model checking), temacentral de las siguientes practicas, han obtenido un gran exito y una notable aceptacion en el ambitoacademico pero tambien en el comercial o industrial.

Este segundo punto es justamente lo que ocurre con Maude, un lenguaje que ha sido utilizado, nocomo alternativa a lenguajes y tecnicas de especificacion como UML, sino para especificar y razonar‘a posteriori’ sobre especificaciones de sistemas realizadas usando otros lenguajes y tecnicas deespecificacion. Por ejemplo, Maude se ha utilizado para razonar sobre protocolos de comunicacionescomo el FireWire (conocido como IEEE 1394), las plataformas CORBA y SOAP, el metamodelode UML, nuevos lenguajes de programacion y lenguajes conocidos, como Java, e incluso se utilizapor la NASA para el desarrollo de sistemas de reconocimiento de objetos en el espacio.

2. El lenguaje de programacion Maude

El lenguaje de programacion Maude utiliza reglas de reescritura, como los lenguajes denomina-dos funcionales tales como Haskell, ML, Scheme, o Lisp. En concreto, el lenguaje Maude esta basadoen la logica de reescritura que permite definir multitud de modelos computacionales complejos talescomo programacion concurrente o programacion orientada a objetos. Por ejemplo, Maude permiteespecificar objetos directamente en el lenguaje, siguiendo una aproximacion declarativa a la pro-gramacion orientada a objetos que no esta disponible ni en lenguajes imperativos como C++ oJava ni en lenguajes declarativos como Haskell.

El desarrollo del lenguaje Maude parte de una iniciativa internacional cuyo objetivo consisteen disenar una plataforma comun para la investigacion, docencia y aplicacion de los lenguajesdeclarativos. Se puede encontrar mas informacion en:

2

http://maude.cs.uiuc.edu

A continuacion resumimos las principales caracterısticas del lenguaje Maude. Sin embargo, hay unextenso manual y un “primer” (libro de introduccion muy sencillo y basado en ejemplos) en ladireccion web indicada antes. Existe tambien un libro sobre Maude, con ejemplares adquiridos porla Biblioteca General y de la Escuela, y accesible online en:

http://www.springerlink.com/content/p6h32301712p

2.1. Un programa en Maude

Un programa Maude esta compuesto de diferentes modulos. Cada modulo se define entre laspalabras reservadas mod y endm, si es un modulo de sistema, o entre fmod y endfm, si es un modulofuncional. Cada modulo incluye declaraciones de tipos y sımbolos, junto con las reglas, encabezadaspor rl, y las ecuaciones, encabezadas por eq, ademas de axiomas para listas o conjuntos, descritascon las palabras assoc, comm, e id. Las reglas describen transiciones entre distintas configuraciones(o estados) del modelo mientras que las ecuaciones y los axiomas describen cojo se ejecutan algunosde los sımbolos, llamadas funciones. Basicamente, los sımbolos y reglas definidos en un modulo desistema tienen un comportamiento indeterminista y ejecuciones posiblemente infinitas en el tiempo(es decir, que no terminen nunca); mientras que los sımbolos y ecuaciones definidos en un modulo desistema o en un modulo funcional, tienen un comportamiento determinista y siempre terminan suejecucion. Es decir, un modulo de sistema permite reglas indeterministas y no terminantes, ya quemodela un sistema de estados (o automata) y, claramente, pueden haber ciclos y varias posiblesacciones a tomar para cada estado del sistema. Sin embargo, un modulo funcional solo permiteecuaciones, ya que representa un programa funcional y todo programa termina y debe devolversiempre el mismo valor. Por ejemplo, el siguiente modulo de sistema simula una maquina de cafe ygalletas:

mod VENDING-MACHINE is

sorts Coin Coffee Cookie Item State .

subsorts Coffee Cookie < Item .

subsorts Coin Item < State .

op null : -> State .

op __ : State State -> State [assoc comm id: null] .

op $ : -> Coin . --- Moneda de dolar

op q : -> Coin . --- Moneda cuarto de dolar

op a : -> Cookie . --- Galleta

op c : -> Coffee . --- Cafe

var St : State .

rl St => St q . --- Modela que se ha anyadido un cuarto de dolar

rl St => St $ . --- Modela que se ha anyadido un dolar

rl $ => c . --- Modela que se ha tragado el dolar y ha devuelto un cafe

rl $ => a q . --- Devuelve una galleta y un cuarto de dolar

eq q q q q = $ . --- Cambia cuatro cuartos por un dolar (sin transicion)

endm

Este sistema es indeterminista (p.ej. para un dolar “$” hay dos posibles acciones) y no terminante(siempre se puede anadir mas dinero a la maquina), aunque incorpora una ecuacion para simplificar

3

http://maude.cs.uiuc.edu

http://www.springerlink.com/content/p6h32301712p

configuraciones y algunos axiomas. Varios comportamientos asociados a este modelo de la maquinade cafe son:

null −→ $ −→ $ $ −→ $ $ $ −→ $ $ $ $ −→∞

$ $ −→ $ c −→ a c q

q q q $ −→ $ a −→ a c

Por otro lado, podemos especificar el siguiente modulo funcional (sin reglas) que simula la funcionfactorial:

fmod FACT is

protecting INT .

op _! : Int -> Int .

var N : Int .

eq 0 ! = 1 . --- factorial de N=0 es 1

eq N ! = (N - 1)! * N [owise] . --- factorial de N>0 es N*factorial de N-1

endfm

Y este sistema es determinista y termina para cada posible ejecucion. Una ejecucion asociada aeste programa del factorial es:

4! −→ 3! * 4 −→ 2! * 3 * 4 −→ 1! * 2 * 3 * 4 −→ 1 * 2 * 3 * 4 −→ 24

En un modulo de sistema podremos incluir reglas y ecuaciones, pero en un modulo funcional solopueden aparecer ecuaciones.

2.2. Errores comunes en los programas en Maude

No finalizar las declaraciones con un espacio y un punto

sort Natural

op 0 : -> Natural.

op s : Natural -> Natural

no dejar espacios entre los argumentos y un operador infijo (o mixfix), p.ej. “0+0” es un errory hay que escribir “0 + 0”

no incluir pareentesis para desambiguar expresiones, p.ej. “p s s 0 + 0” es un error y hay queescribir “p s s (0 + 0)” o “(p s s 0) + 0” en funcion de la sintaxis apropiada.

2.3. Tipos de datos predefinidos

Maude dispone de varios tipos de datos predefinidos incluidos en el fichero prelude.maude

de la instalacion. En concreto, se dispone del tipo Bool definido en el modulo BOOL, el tipo Nat

en el modulo NAT, el tipo Int en el modulo INT, el tipo Float en el modulo FLOAT, y los tiposChar y String en el modulo STRING. Para hacer uso de alguno de esos tipos, sus operadores,deberemos importar el modulo donde se encuentran con una de las palabras reservadas1 including,protecting o extending. Por ejemplo, el modulo FACT para factorial mostrado anteriormenteimporta el modulo INT de los numeros enteros.

1El significado de estas acciones para importar modulos queda fuera del objetivo principal de esta practica, perose puede consultar en el manual. La palabra reservada protecting es la mas segura y simple.

4

2.4. Declaracion obligatoria de variables

Es obligatorio declarar el tipo de las variables antes de ser usadas en el programa, p.ej. la siguientedeclaracion de variables

var N : Nat .

var NL : NatList .

var NS : NatSet .

o anadirles el tipo directamente a las variables cuando vamos a usarlas, p.ej. “X:Nat + Y:Nat” .

2.5. Declaraciones de Tipos (Sorts), Sımbolos Constructores y Variables

Una declaracion de tipo tiene la forma:

sort T .

e introduce un nuevo tipo de datos T. Si queremos introducir varios tipos a la vez, escribiremos

sorts T1 · · · Tn .

Despues se definen los constructores que formaran los datos asociados a ese tipo de la forma:

op C : T1 T2 · · · Tn -> T .

donde T1, T2, . . . , Tn son los tipos de los parametros de ese sımbolo. Tambien podremos escribir

ops C1 · · · Cn : T1 T2 · · · Tn -> T .

y denota que todos los sımbolos C1, . . . , Cn tienen el mismo tipo. Por ejemplo, las declaraciones detipo:

sort Bool .

ops true false : -> Bool .

sort NatList .

op nil : -> NatList .

op _:_ : Nat NatList -> NatList .

introducen el tipo Bool con dos constantes true y false, y el tipo NatList (listas cuyos elementosson naturales, es decir de tipo Nat). Hay que tener en cuenta que Maude no soporta tipos de datosparametricos, como Haskell, por lo tanto no se pueden2 definir listas parametricas sino especıficaspara cada tipo, como en el caso de NatList. Sin embargo, es interesante fijarse en la forma dedefinir el operador binario infijo de construccion de una lista, “_:_”, donde se indica que el primerargumento debe aparecer antes de los dos puntos mientras que el segundo detras de los dos puntos.Una lista de enteros se podra definir por lo tanto en notacion infija como 0 : (1 : (2 : nil))

en vez de la notacion prefija :(0,:(1,:(2,nil))) simplemente indicando que el sımbolo a utilizares “_:_”. Esto es muy practico y versatil ya que simplemente debemos indicar con un “ ” dondeva a aparecer el argumento, p.ej., se pueden definir sımbolos tan versatiles como

op if_then_else_fi : Bool Exp Exp -> Exp

op for(_;_;_) {_} : Nat Bool Bool Exp -> Exp

2En realidad sı se puede pero los detalles tecnicos estan fuera de lugar para esta practica. De hecho, el marcoexistente en Maude es mas potente que los tipos polimorficos de Haskell.

5

En concreto en el ejemplo VENDING-MACHINE tenemos el sımbolo

op __ : State State -> State

que denota que el caracter “vacıo” es un sımbolo valido usado para concatenar estados. Y en elejemplo FACT tenemos


que denota el sımbolo factorial en notacion postfija.

2.5.1. Tipos de datos ordenados y sobrecarga de operadores

En Maude se pueden crear tipos de datos ordenados o divididos en jerarquıas. Por ejemplo,podemos indicar que los numeros naturales se dividen en numeros naturales positivos y el cerousando la palabra reservada subsort de la siguiente forma:

sorts Nat Zero NzNat .

subsort Zero < Nat .

subsort NzNat < Nat .

op 0 : -> Zero .

op s : Nat -> NzNat .

De esta forma, la expresion s(0) es de tipo NzNat y a la vez es de tipo Nat, mientras que no es detipo Zero. E igualmente, la expresion 0 es de tipo Zero y Nat, pero no es de tipo NzNat.

Otra caracterıstica interesante del sistema de tipos de Maude es la sobrecarga de operadores.Por ejemplo, podemos reutilizar el sımbolo 0 en el tipo de datos Binary sin ningun problema:

sorts Nat Zero NzNat .

subsort Zero < Nat .

subsort NzNat < Nat .

op 0 : -> Zero .

op s : Nat -> NzNat .

sort Binary .

op 0 : -> Binary .

op 1 : -> Binary .

En este caso, pueden surgir ambiguedades sobre algun termino que se resuelven especificando el tipodetras del termino, por ejemplo (0).Zero o (0).Binary. El sistema informara solo de ambiguedadesque no pueda resolver por su cuenta.

La union de la sobrecarga de sımbolos y los tipos ordenados le confiere una gran flexibilidad allenguaje. Por ejemplo, podemos redefinir el anterior tipo de datos de lista de numeros naturales dela siguiente forma, donde ENatList denota lista vacıa (es decir nil) y NeNatList denota lista novacıa de elementos:

sorts NatList ENatList NeNatList .

subsort ENatList < NatList .

op nil : -> ENatList .

subsort NeNatList < NatList .

op _:_ : Nat NeNatList -> NeNatList .

op _:_ : Nat ENatList -> NeNatList .

6

2.5.2. Propiedades avanzadas (o algebraicas) de los sımbolos

El lenguaje Maude incorpora la posibilidad de especificar sımbolos con propiedades algebraicasextra como asociatividad, conmutatividad, elemento neutro, etc. que facilitan mucho la creacion deprogramas.

Asociatividad X + (Y + Z) = (X + Y ) + Z

Conmutatuvidad X + Y = Y + X

Elemento neutro X + 0 = X

De hecho, permiten definir estructuras de datos basadas en listas y conjuntos de forma muy sencillae integrada dentro del lenguaje, mejorando el rendimiento de la ejecucion y la compresion delprograma o modelo. Por ejemplo, podemos redefinir el tipo de datos lista de numeros naturales dela siguiente forma:

sorts NatList ENatList NeNatList .

subsort ENatList < NatList .

op nil : -> ENatList .

subsort Nat < NeNatList < NatList .

op _:_ : NatList NatList -> NeNatList [assoc] .

donde _:_ es un sımbolo asociativo, es decir no hacen falta los parentesis para separar los terminos.Notese que los dos argumentos del sımbolo _:_ tienen que ser del mismo tipo para poder indicar queel sımbolo es asociativo. Ahora Maude entiende que las siguientes expresiones significan exactamentelo mismo

s(0) : s(s(0)) : nil

s(0) : (s(s(0)) : nil)

(s(0) : s(s(0))) : nil

Otra posibilidad es anadir un elemento neutro al operador asociativo:

sorts NatList .

subsort Nat < NatList .


op _:_ : NatList NatList -> NatList [assoc id: nil] .

donde ahora _:_ es un sımbolo asociativo y el termino nil es el elemento neutro del tipo dedatos, que por lo tanto se puede eliminar salvo cuando aparece solo. Ahora Maude entiende que lassiguientes expresiones significan exactamente lo mismo

s(0) : s(s(0)) : nil

s(0) : s(s(0))

nil : s(0) : nil : s(s(0)) : nil

Y podemos anadir la propiedad de conmutatividad a la lista, creando el tipo de datos multiconjunto:

sorts NatMultiSet .

subsort Nat < NatMultiSet .

op nil : -> NatMultiSet .

op _:_ : NatMultiSet NatMultiSet -> NatMultiSet [assoc comm id: nil] .

donde la propiedad de conmutatividad indica que se puede intercambiar el orden de los elementos.Ahora Maude entiende que las siguientes expresiones significan exactamente lo mismo

7

0 : s(0) : s(s(0)) : s(0)

0 : s(0) : s(0) : s(s(0)) : nil

s(0) : 0 : s(s(0)) : s(0) : nil

nil : s(0) : nil : s(s(0)) : nil : s(0) : nil : 0 : nil

Y finalmente podemos anadir la propiedad de que no pueden haber elementos iguales, convirtiendoel multiconjunto en un conjunto:

sorts NatSet .

subsort Nat < NatSet .

op nil : -> NatSet .

op _:_ : NatSet NatSet -> NatSet [assoc comm id: nil] .

eq X:Nat : X:Nat = X:Nat .

donde la ecuacion elimina aquellas ocurrencias repetidas de un termino. Ahora Maude entiende quelas siguientes expresiones significan exactamente lo mismo

0 : s(0) : s(s(0))

0 : s(0) : s(0) : s(0) : s(0) : s(s(0)) : nil

s(0) : 0 : s(s(0)) : s(0) : nil

nil : s(0) : nil : s(s(0)) : nil : s(0) : nil : 0 : nil

2.6. Declaracion de Funciones

Aquellos operadores o sımbolos que dispongan de reglas o ecuaciones que los definan son de-nominados funciones mientras que los que no dispongan de reglas o ecuaciones son denominadosconstructores. Las reglas de una funcion se definen con el operador reservado “rl_=>_.” y las ecua-ciones con el operador reservado “eq_=_.”. Notese que es obligatorio en Maude declarar el tipo detodas las funciones, el tipo de todas las variables, etc. En otros lenguajes funcionales, como Haskell,esto no es necesario aunque se recomienda. En particular, esto puede ayudar a detectar facilmenteerrores en el programa, cuando se definen funciones que no se ajustan al tipo declarado.

Respecto a las reglas/ecuaciones que definen las funciones, estas pueden ser de la forma

rl f(t1, . . . , tn) => e .eq f(t1, . . . , tn) = e .

donde t1, . . . , tn y e son terminos. Las ecuaciones pueden etiquetarse con la palabra reservadaowise (otherwise) y en ese caso se indica que solo se aplicara si ninguna otra ecuacion para esesımbolo es aplicable. Cuidado porque el owise solo se puede aplicar a una ecuacion, nunca a unaregla ya que tienen un significado indeterminista. Por ejemplo, podemos escribir

fmod FACT is

protecting INT .


var N : Int .

eq 0 ! = 1 .

eq N ! = (N - 1)! * N [owise] .

endfm

Las funciones se pueden definir tambien mediante reglas/ecuaciones condicionales

crl f(t1, . . . , tn) => e if c .ceq f(t1, . . . , tn) = e if c .

8

donde la condicion c es un conjunto de emparejamientos de la forma t := t’ separados por eloperador /\. Un emparejamiento t := t’ indica que el termino t’ debe tener la forma del terminot, instanciando las variables de t si es necesario, ya que las variables de t pueden ser usadas en laexpresion e de la regla para extraer informacion de t’. Las ecuaciones condicionales solo puedenaplicarse si la condicion tiene exito. Tambien es posible definir una ecuacion condicional en la quelas guardas sean expresiones de tipo Bool en vez de t := t’; en ese caso se interpretan comotrue := t. Por ejemplo, podemos escribir la anterior funcion factorial de la siguiente forma:

ceq N ! = 1 if N == 0 .

ceq N ! = (N - 1)! * N if N =/= 0 .

donde la igualdad ‘==’ se evalua a true si ambas expresiones son iguales y ‘=/=’ se evalua a true

si ambas expresiones son distintas. Notese que en este caso, se puede usar tambien el operadorcondicional if_then_else_fi:

eq N ! = if N == 0 then 1 else (N - 1)! * N fi .

Ademas, debido a los tipos de datos ordenados, se permiten expresiones logicas de la format :: T que se evaluan a true si la expresion t es del tipo T. Por ejemplo, esto puede ser util enecuaciones condicionales como:

op emptyList : NatList -> Bool .

eq emptyList(NL) = NL :: ENatList .

donde se dice que una lista NL esta vacıa, es decir emptyList retorna true, si NL es del tipoENatList.

2.6.1. Busqueda eficiente de elementos en listas y conjuntos

Una ventaja de disponer de listas, multiconjuntos y conjuntos es que determinadas operacionesde busqueda y emparejamiento de patrones resultan mucho mas rapidas. De hecho, mas rapidas queen otros lenguajes declarativos como Prolog o Haskell. Por ejemplo, la pertenencia de un elementoa una lista se realiza de forma secuencial en muchos lenguajes declarativos:

sort NatList .


op _:_ : Nat NatList -> NatList .

op _in_ : Nat NatList -> Bool .

eq N:Nat in nil

= false .

eq N:Nat in (X:Nat : XS:NatList)

= (N:Nat == X:Nat) or-else (N:Nat in XS:NatList) .

Sin embargo, cuando disponemos de un operador asociativo con un elemento neutro, esta operacionse hace de forma mucho mas elegante y eficiente como sigue a continuacion:

sort NatList .

subsort Nat < NatList .


op _:_ : NatList NatList -> NatList [assoc id: nil] .

9

op _in_ : Nat NatList -> Bool .

eq N:Nat in (L1:NatList : N:Nat : L2:NatList)

= true .

eq N:Nat in L:NatList

= false [owise] .

La expresion “1 in 1 : 2 : 3” se puede ver como “1 in nil : 1 : 2 : 3” gracias a la pro-piedad del elemento neutro, donde “L1:NatList” se emparejarıa con “nil”, “N:Nat” con “1” y“L2:NatList” con “2 : 3”; ocurre algo parecido con “2 in 1 : 2 : 3” y “3 in 1 : 2 : 3”.Esto tiene la ventaja de que es el propio sistema el que decide la mejor tecnica de busqueda y ası noesta restringido al mecanismo usado por el programador. Ademas, en el caso de un conjunto (omulticonjunto) es aun mas simple gracias a la conmutatividad:

sort NatSet .

subsort Nat < NatSet .

op empty : -> NatSet .

op _:_ : NatSet NatSet -> NatSet [assoc comm id: nil] .

op _in_ : Nat NatSet -> Bool .

eq N:Nat in (N:Nat : L:NatSet)

= true .

eq N:Nat in L:NatSet

= false [owise] .

2.7. Entorno de Trabajo: el sistema Maude

El sistema Maude no dispone en la actualidad de un compilador a codigo maquina, aunqueexisten varias versiones en pruebas. Solo se dispone de un interprete que se carga con el comando:

$ maude

mostrando el siguiente texto de presentacion:

\||||||||||||||||||/

--- Welcome to Maude ---

/||||||||||||||||||\

Maude 2.2 built: Jun 15 2005 15:23:40

Copyright 1997-2004 SRI International

Wed Oct 14 19:53:21 2005

Maude>

El sistema esta disponible para diferentes versiones de UNIX (incluyendo Linux y Mac OS X).Existe, ademas, una version de Maude para Windows descargable siguiendo el enlace “Maude forWindows” de la pagina http://moment.dsic.upv.es. Una vez arrancado el sistema, disponemosde los siguientes comandos:

load < name > . Lee y carga los distintos modulos almacenados en el archivo <name>. Los ar-chivos de Maude se suelen crear con la extension .maude.

show modules . Muestra los modulos cargados actualmente en el sistema.

show module < module > . Muestra el modulo <module> en pantalla.

10

http://moment.dsic.upv.es

select < module > . Selecciona un nuevo modulo para ser el modulo actual de ejecucion deexpresiones.

rewrite < expression > . Evalua la expresion <expression> con respecto al modulo actual.Tambien puede escribirse “rew < expression > .”.

rewrite in < module > : < expresion > . Evalua la expresion <expression> con respecto almodulo <module>.

search < expresion1 > => ∗ < expression2 > . Donde busca algun camino de ejecucionque lleve del termino <expression1> al termino <expression2>. El termino <expression2>

puede tener variables mientras que <expression1> no. La expresion “=>*” puede entendersecomo buscar un camino de ejecucion de <expression1> a <expression2> utilizando tantospasos de ejecucion como sean necesarios. Sin embargo se puede sustituir por “=>1” indicandoun unico paso de ejecucion.

search in < module > : < expresion1 > => ∗ < expression2 > . Busca algun camino deejecucion con respecto al modulo <module>.

search [< limit >] < expresion1 > => ∗ < expression2 > . Busca varios caminos de eje-

cucion, hasta un maximo de <limit>. Esto permite verificar propiedades de alcanzabilidadde forma positiva en sistemas con un numero infinito de estados. Cuidado porque si no hayninguna solucion y el espacio de busqueda es infinito el sistema no parara.

cd < dir > Permite cambiar de directorio (cuidado porque no lleva espacio ni punto al final).

ls Ejecuta el comando UNIX ls y muestra todos los ficheros en el directorio actual (cuidadoporque no lleva espacio ni punto al final)

quit Salir del sistema (cuidado porque no lleva espacio ni punto al final).

La semantica operacional de Maude se basa en la logica de reescritura y basicamente consisteen reescribir la expresion de entrada usando las reglas y ecuaciones del programa hasta que no hayamas posibilidad. Maude utiliza una estrategia de ejecucion impaciente, como ocurre en los lenguajesde programacion imperativos como C o Pascal y en algunos lenguajes funcionales como ML, en vezde una estrategia de ejecucion perezosa, como en el lenguaje funcional Haskell. Por ejemplo, dadala funcion _! mostrada anteriormente, y asumiendo que esta almacenada en el fichero fact.maude

escribiremos

$ maude

\||||||||||||||||||/


/||||||||||||||||||\

Maude 2.1.1 built: Jun 15 2004 15:23:40


Wed Oct 14 19:53:21 2005

Maude> load fact.maude

Maude> rew 4 ! .

rewrite in FACT : 4 ! .

rewrites: 23 in 0ms cpu (0ms real) (~ rewrites/second)

result NzNat: 24

Maude> quit

11

A diferencia de las ecuaciones, las reglas tienen un significado indeterminista, por lo tanto el co-mando rewrite escoge una regla al azar cuando hay mas de una posibilidad y nos devuelve una delas posibles ejecuciones del programa. En el caso de tener un conjunto de reglas que no terminan,no podremos lanzar el comando rewrite y deberemos usar el comando search, que nos indica sien el espacio de posibles ejecuciones del programa existe una ejecucion que satisfaga ciertas condi-ciones. Por ejemplo, dado el modulo VENDING-MACHINE mostrado anteriormente y asumiendo queesta almacenado en el fichero vending.maude escribiremos

$ maude

\||||||||||||||||||/


/||||||||||||||||||\

Maude 2.1.1 built: Jun 15 2004 15:23:40


Fri Nov 25 17:34:33 2005

Maude> load vending.maude

Maude> search [1] $ =>* c c .

search [1] in VENDING-MACHINE : $ =>* c c .

Solution 1 (state 22)

states: 23 rewrites: 79 in 0ms cpu (10ms real) (~ rewrites/second)

empty substitution

Maude> show path 22 .

state 0, Coin: $

===[ rl St => $ St . ]===>

state 2, State: $ $

===[ rl $ => c . ]===>

state 10, State: $ c

===[ rl $ => c . ]===>

state 22, State: c c

Maude> quit

Bye.

donde buscamos si es posible ir de un estado con un dolar a un estado con dos cafes. En este casotenemos que restringir la busqueda a la primera solucion (parte [1] del comando) ya que el espaciode busqueda es infinito. Notese que el comando “show path N .” muestra la solucion encontradaen el proceso de busqueda, donde N es el numero con el que Maude identifica cada solucion, esdecir, “Solution i (state N)”.

3. Verificacion en Maude

Una forma de verificacion menos potente que el model checking se consigue a traves del comandode busqueda search, que nos permitira especificar propiedades de alcanzabilidad, e incluso deseguridad (negacion de alcanzabilidad) si el espacio de busqueda es finito. A continuacion mostramosun ejemplo sobre dos procesos y un semaforo para entrar a la zona crıtica compartida y comopodemos verificar algunas propiedades de alcanzabilidad.

El codigo en Maude que describe el problema de dos procesos accediendo a una zona compartidapodrıa ser el siguiente:

12

mod SEMAPHORE is

protecting NAT .

protecting BOOL .

--- Declaraciones de tipos para los procesos

sorts Process PState .

--- Un proceso tiene un identificador y su estado

op p_{_} : Nat PState -> Process .

--- Hay cuatro posibles estados

ops idle entering critical exiting : -> PState .

--- Ponemos todos los procesos juntos en un conjunto

sort PSet .

subsort Process < PSet .

op empty : -> PSet .

op __ : PSet PSet -> PSet [assoc comm id: empty] .

eq X:Process X:Process = X:Process .

--- Definimos el tipo semaforo

sort Semaphore .

subsort Bool < Semaphore .

--- Juntamos todos los procesos con un semaforo a compartir

--- que define la situacion global de todo nuestro sistema

sort GlobalState .

op _||_ : Semaphore PSet -> GlobalState .

--- Y ahora damos la reglas que definen el comportamiento de cada proceso

var S : Semaphore .

var PS : PSet .

var Id : Nat .

rl S || p Id {idle} PS --- El proceso sigue en idle

=> S || p Id {idle} PS .

rl S || p Id {idle} PS --- El proceso pasa a entering

=> S || p Id {entering} PS .

rl false || p Id {entering} PS --- El proceso entra en la zona critica

=> true || p Id {critical} PS .

rl S || p Id {critical} PS --- El proceso sale de la zona critica

=> S || p Id {exiting} PS . --- Solo un proceso estaba en su zona critica

rl S || p Id {exiting} PS --- El proceso sale de la zona critica

=> false || p Id {idle} PS .

endm

Este programa tiene un espacio de busqueda finito, es decir, tiene un numero finito de estadossi se proporciona un conjunto finito de procesos. Por lo tanto, podemos especificar una propiedadde seguridad (negacion de alcanzabilidad).

$ maude

13

\||||||||||||||||||/


/||||||||||||||||||\

Maude 2.1.1 built: Jun 15 2004 15:23:40


Fri Nov 25 19:29:56 2005

Maude> load semaphore.maude

Maude> search false || p 1 {idle} p 2 {idle} =>* S || p 1 {critical} p 2 {critical} .

search in SEMAPHORE : false || p 1{idle} p 2{idle} =>* S || p 1{critical} p 2{critical} .

No solution.

states: 12 rewrites: 28 in 0ms cpu (5ms real) (~ rewrites/second)

Maude> quit

Bye.

En este caso Maude devuelve que no es posible ir del estado “false || p 1 {idle} p 2 {idle}”con dos procesos que comienzan en “idle” a un estado donde los dos procesos estan en su zona crıti-ca. Por lo tanto esta propiedad es cierta en todas las posibles ejecuciones.

4. Objetivo de la practica

El objetivo de esta practica consiste en realizar la especificacion de los siguientes problemasen Maude y comprobar algunas propiedades de alcanzabilidad o seguridad. En todos los ejem-plos hay que especificar modulos de sistema con reglas para especificar acciones indeterministas y,posiblemente, con ecuaciones para acciones deterministas.

Evaluacion: La evaluacion de practicas se realizara con un examen tipo test en la fecha con-cretada. Antes del dıa del examen hay que ensenarle al profesor los ejercicios realizados como partede la nota de seguimiento.

4.1. Problema del lobo, la oveja y la col (tıpico de Inteligencia Artificial)

Un hombre tiene un lobo, una oveja y una col que debe transportar desde un lado del rıo hastael otro lado. Para transportarlos solo tiene una barca en la que cabe un unico animal, aparte de elmismo. Ademas, si deja solos en uno de los lados al lobo y a la oveja, el lobo se come a lo oveja, ysi deja solos a la oveja y a la col, la oveja se come la col. Por lo tanto, debe transportar el lobo, laoveja y la col de uno de los lados del rıo al otro sin que ninguno sea comido.

Se debera modelar este problema como un programa Maude. Se puede considerar que cadaunidad de tiempo del sistema implica que el hombre se encuentra en un lado u otro del rıo, habiendopasado de uno de los lados al otro, solo o con uno de ellos.

La propiedad a verificar es si es posible ir desde el estado en que todos los animales estan en unlado del rıo a otro estado en que estan en el otro lado (propiedad de alcanzabilidad). Se entiendeque ninguno ha sido comido.

El caso en el que un animal se come a otro, hay que indicarlo con una ecuacion y no con unaregla, ya que la accion de comer no es una opcion a considerar entre otras opciones, sino que es unasimplificacion de un estado. Si se especifica como una regla en vez de una ecuacion, entonces puedenhaber caminos que pasen por un estado donde se hubieran comido, siendo el modelo incorrecto conrespecto a la realidad.

Nota: Un conjunto de tipos, sımbolos y reglas como el siguiente puede simplificar mucho elcodigo, donde tenemos un conjunto a ambos lados de la barra vertical.

14

mod Ejercicio1 is

sorts Animal Hombre Pasajeros Rio .

subsort Animal < Pasajeros . subsort Hombre < Pasajeros .

ops lobo oveja col : -> Animal .

op pastor : -> Hombre .

op vacio : -> Pasajeros .

op __ : Pasajeros Pasajeros -> Pasajeros [assoc comm id: vacio] .

op _|_ : Pasajeros Pasajeros -> Rio .

...

rl [pastor-derecha] : pastor X:Pasajeros | Y:Pasajeros

=> X:Pasajeros | Y:Pasajeros pastor .

...

endm

4.2. Un ascensor (tıpico de modelado de Sistemas Concurrentes)

El problema consiste en modelar el comportamiento de un ascensor de 4 plantas. Cada una delas plantas tiene un boton de llamada. El recorrido del ascensor de una planta a otra durara unaunica unidad de tiempo, es decir, el cambio de la planta 2 a la planta 3 debe realizarse en un unicocambio de estado. Cuando llega a una de las plantas, el ascensor abre las puertas y las mantieneabiertas durante una unidad de tiempo, luego las cierra y procede a servir otra peticion. El ascensordebera mantener una direccion hasta satisfacer todas las peticiones existentes en esa direccion.

Debereis especificar el problema como un programa Maude que satisfaga las siguientes propie-dades:

1. si se pulsa un boton de llamada de una planta, este es eventualmente satisfecho en algunaejecucion (propiedad de alcanzabilidad), y

2. el ascensor nunca se movera con las puertas abiertas (propiedad de seguridad).

Nota: Se puede escribir =>1 en vez de =>* para indicar una unica transicion de tiempo. Nota:Un conjunto de tipos, sımbolos y reglas como el siguiente puede simplificar mucho el codigo.

mod Ejercicio2 is

protecting NAT .

sorts Planta Boton Pulsado Puertas Direccion Botones Ascensor .

ops x o : -> Pulsado .

ops <> >< : -> Puertas .

ops up down : -> Direccion .

op b_[_] : Nat Pulsado -> Boton .

subsort Boton < Botones .

op vacio : -> Botones .

op __ : Botones Botones -> Botones [assoc comm id: vacio] .

op _‘(_,_,_‘) : Botones Nat Direccion Puertas -> Ascensor .

rl [cerrar] : X:Botones (Piso:Nat,Dir:Direccion,<>)

=> X:Botones (Piso:Nat,Dir:Direccion,><) .

crl [subir] : X:Botones (Piso:Nat,Dir:Direccion,P:Puertas)

=> X:Botones (Piso:Nat + 1,Dir:Direccion,P:Puertas)

if Piso:Nat < 3 .

...

endm

15

4.3. Alternating-bit-protocol (tıpico de modelado de Redes)

El protocolo de bit de alternancia es un protocolo muy simple pero efectivo que evita la aparicionde mensajes duplicados o perdidos. Considerese un emisor A, un receptor B y un canal de A a B,que suponemos que inicialmente no transmite ningun mensaje. Cada mensaje contiene un bit deprotocolo (valores 0 o 1).

Cuando A tiene un mensaje para enviar a B, lo repite indefinidamente por el canal de A a Butilizando el mismo bit de protocolo hasta que recibe una confirmacion (acknowledgement) de B conel mismo bit de protocolo. Al recibir la confirmacion, A empieza a transmitir el siguiente mensajedisponible con el bit de protocolo cambiado, es decir, mensaje anterior: 0, siguiente mensaje: 1 oal reves. Cuando B recibe un mensaje, lo acepta para procesar y manda a A una confirmacionincluyendo el mismo bit de protocolo del mensaje recibido. Ante sucesivos mensajes con el mismobit de protocolo, lo unico que hace es mandar la misma confirmacion con el mismo bit de protocolo.

Es decir, basicamente, el bit de protocolo identifica cada uno de los mensajes y el emisor repiteel mensaje hasta que recibe una confirmacion del receptor, a su vez el receptor repite siempre laconfirmacion del mensaje que le llega.

Debereis especificar el problema como un programa Maude. Para modelar la perdida de men-sajes, el canal de comunicacion debera escoger de forma indeterminista entre copiar el mensaje enla salida o desecharlo. La propiedad a satisfacer es

si dado un estado en que A envia un dato a B y B le devuelve algo, ese dato devueltoes justamente el mismo que A envio (propiedad de alcanzabilidad).

Hay que darse cuenta que la propiedad de que cuando A quiere enviar un 0, en algun momento lellegara una confirmacion de vuelta no se puede probar completamente, ya que hay caminos dondelos mensajes se pierden indefinidamente.

Nota: Un conjunto de tipos, sımbolos y reglas como el siguiente puede simplificar mucho elcodigo.

mod Ejercicio3 is

sorts Bit Mensaje Canal Estado .

ops 0 1 : -> Bit .

ops _>> <<_ : Bit -> Mensaje .

subsort Mensaje < Canal .

op perdido : -> Canal .

op A{_}_B{_} : Bit Canal Bit -> Estado .

rl [perdida] : A{X:Bit} X:Mensaje B{Y:Bit}

=> A{X:Bit} perdido B{Y:Bit} .

rl [B-repite] : A{X:Bit} >>Z:Bit B{Y:Bit}

=> A{X:Bit} Z:Bit<< B{Z:Bit} .

...

endm

16

prac1

Documents

Transcript of prac1