PVS: Tipos abstractos de datos - Universidad de Sevilla · Generaci´on de teor´ıas Orden para generar la teor´ıa asociada a un Tipo Abstracto de Datos: M-x typecheck Fichero

PVS: Tipos abstractos de datos

Francisco J. Martın MateosJose A. Alonso Jimenez

Dpto. Ciencias de la Computacion e Inteligencia ArtificialUniversidad de Sevilla

Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos

http://pvs.csl.sri.com/


Especificacion de listas

Elementos del Tipo Abstracto de Datos lista

Tipo de los elementos: T

Constructores: null y cons

Reconocedores: null? y cons?

Accesores: car y cdr

Especificacion (lista.pvs )

lista[T: TYPE]: DATATYPE

BEGIN

null: null?cons (car: T, cdr: lista): cons?

END lista



Generacion de teorıas

Orden para generar la teorıa asociada a un Tipo Abstracto deDatos: M-x typecheck

Fichero generado: lista_adt.pvs

Teorıas generadas:

lista_adt[T: TYPE]

lista_adt_map[T: TYPE, T1: TYPE]

lista_adt_reduce[T: TYPE, range: TYPE]



La teorıa lista_adt

Signatura

lista_adt[T: TYPE]: THEORY

BEGIN

lista: TYPEnull?, cons?: [lista -> boolean]null: (null?)cons: [[T, lista] -> (cons?)]car: [(cons?) -> T]cdr: [(cons?) -> lista]

...

END lista_adt




La funcion ord enumera los tipos de datos del Tipo Abstractode Datos (en este caso, asigna 0 a la lista vacıa y 1 a las listasno vacıas)

ord(x: lista): upto(1) =CASES x OF

null: 0,cons(cons1_var, cons2_var): 1

ENDCASES




Axiomas de extensionalidad: Dos listas con las mismascomponentes son iguales

lista_null_extensionality: AXIOMFORALL (null?_var: (null?), null?_var2: (null?)):

null?_var = null?_var2;

lista_cons_extensionality: AXIOMFORALL (cons?_var: (cons?), cons?_var2: (cons?)):

car(cons?_var) = car(cons?_var2) ANDcdr(cons?_var) = cdr(cons?_var2)

IMPLIEScons?_var = cons?_var2;




El axioma eta: (cons (car l) (cdr l)) = l

lista_cons_eta: AXIOMFORALL (cons?_var: (cons?)):

cons(car(cons?_var), cdr(cons?_var)) = cons?_var;




Axioma de accesores–constructores

car(cons(x,l)) = x

lista_car_cons: AXIOMFORALL (cons1_var: T, cons2_var: lista):

car(cons(cons1_var, cons2_var)) = cons1_var;

cdr(cons(x,l)) = l

lista_cdr_cons: AXIOMFORALL (cons1_var: T, cons2_var: lista):

cdr(cons(cons1_var, cons2_var)) = cons2_var;




Axioma de particion: Toda lista es simple (null? ) ocompuesta (cons? )

lista_inclusive: AXIOMFORALL (lista_var: lista):

null?(lista_var) OR cons?(lista_var);




Axioma de induccion: Sea P un propiedad sobre listas; siP(null) y (∀x, l)[P(l) → P(cons(x, l))] entonces (∀l)P(l)

lista_induction: AXIOMFORALL (p: [lista -> boolean]):

(p(null) AND(FORALL (cons1_var: T, cons2_var: lista):

p(cons2_var) IMPLIESp(cons(cons1_var, cons2_var))))

IMPLIES (FORALL (lista_var: lista): p(lista_var));




La relacion de sublista: subterm(L1,L2) se verifica syss L1 esuna sublista de L2

subterm(x, y: lista): boolean =x = y ORCASES y OF

null: FALSE,cons(cons1_var, cons2_var): subterm(x, cons2_var)

ENDCASES;




La relacion de sublista estricta: L1 << L2 se verifica si L1 esuna sublista estricta de L2. La relacion << es bienfundamentada

<<: (well_founded?[lista]) =LAMBDA (x, y: lista):

CASES y OFnull: FALSE,cons(cons1_var, cons2_var): x = cons2_var OR

x << cons2_varENDCASES;

lista_well_founded: AXIOM well_founded?[lista](<<);



Propiedades de listas

Estructura de la teorıa list_props

list_props[T: TYPE]: THEORY

BEGIN% IMPORTING lista_adt[T]% La teor´ıa list es del preludio

l, l1, l2, l3: VAR list[T]x: VAR TP: VAR pred[T]

...

END list_props




Definicion de la longitud de una lista

longitud(l): RECURSIVE nat =CASES l OF

null: 0,cons(x, l1): longitud(l1) + 1

ENDCASESMEASURE l BY <<

TCC generado

% Termination TCC generated for longitud(l1)% proved - complete

longitud_TCC1: OBLIGATIONFORALL (l1: list[T], x: T, l: list[T]):

l = cons(x, l1) IMPLIES <<[T](l1, l);




Definicion de la relacion de pertenencia a una lista

pertenece(x, l): RECURSIVE bool =CASES l OF

null: FALSE,cons(y, l1): x = y OR pertenece(x, l1)


TCC generado

% Termination TCC generated for pertenece(x, l1)% proved - complete

pertenece_TCC1: OBLIGATIONFORALL (l1: list[T], y: T, l: list[T], x: T):

l = cons(y, l1) AND NOT x = y IMPLIES <<[T](l1, l);




Definicion de la concatenacion de listas

concatenacion(l1, l2): RECURSIVE list[T] =CASES l1 OF

null: l2,cons(x, l): cons(x, concatenacion(l, l2))

ENDCASESMEASURE l1 BY <<

TCC generado

% Termination TCC generated for concatenacion(l, l2)% proved - complete

concatenacion_TCC1: OBLIGATIONFORALL (l: list[T], x: T, l1: list[T]):

l1 = cons(x, l) IMPLIES <<[T](l, l1);




Definicion de la inversa de una lista

inversa(l): RECURSIVE list[T] =CASES l OF

null: l,cons(x,l1): concatenacion(inversa(l1),cons(x,null))


TCC generado

% The termination TCC in decl inversa for inversa(l1)% is subsumed by longitud_TCC1




Lema

pertenece_vacia: LEMMApertenece(x, l) IMPLIES NOT null?(l)

Lema

concatenacion_con_nulo: LEMMAconcatenacion(l, null) = l

Lema

concatenacion_lista_unitaria: LEMMAconcatenacion(cons(x,null),l) = cons(x,l)




Lema

asociatividad_concatenacion: LEMMAconcatenacion(concatenacion(l1,l2),l3) =

concatenacion(l1,concatenacion(l2,l3))

Lema

longitud_concatenacion: LEMMAlongitud(concatenacion(l1,l2)) =

longitud(l1) + longitud(l2)

Lema

inversa_de_concatenacion: LEMMAinversa(concatenacion(l1,l2)) =

concatenacion(inversa(l2),inversa(l1))




Lema

inversa_unitaria: LEMMAinversa(cons(x,null)) = cons(x,null)

Lema

longitud_inversa: LEMMAlongitud(inversa(l)) = longitud(l)

Teorema

inversa_inversa: THEOREMinversa(inversa(l)) = l



Listas de naturales

Estructura de la teorıa natlist

natlist: THEORY

BEGINIMPORTING list_adt[nat]

l, l1, l2: VAR list[nat]n, m: VAR nat

...

END natlist



Listas de naturales

Definicion de la propiedad lista ordenada

ordenada(l): RECURSIVE bool =CASES l OF

null: TRUE,cons(n, l1): CASES l1 OF

null: TRUE,cons(m, l2): n <= m AND ordenada(l1)

ENDCASESENDCASESMEASURE l BY <<

TCC generado

% Termination TCC generated for ordenada(l1)% proved - complete

ordenada_TCC1: OBLIGATIONFORALL (l1, l2: list[nat], n, m: nat, l: list[nat]):

l = cons(n, l1) AND l1 = cons(m, l2) AND n <= mIMPLIES <<[nat](l1, l);



Listas de naturales

Deficion de un procedimiento de insercion ordenada

inserta(n,l): RECURSIVE list[nat] =CASES l OF

null: cons(n,null),cons(m, l1):

IF n <= mTHEN cons(n,l)ELSE cons(m,inserta(n,l1))

ENDIFENDCASESMEASURE l BY <<

TCC generado

% Termination TCC generated for inserta(n, l1)% proved - complete

inserta_TCC1: OBLIGATIONFORALL (l1: list[nat], m: nat, l: list[nat], n: nat):

l = cons(m, l1) ANDNOT n <= m IMPLIES <<[nat](l1, l);



Listas de naturales

Deficion de un procedimiento de ordenacion por insercion

isort(l): RECURSIVE list[nat] =CASES l OF

null: null,cons(n, l1): inserta(n,isort(l1))


TCC generado

% Termination TCC generated for isort(l1)% proved - complete

isort_TCC1: OBLIGATIONFORALL (l1: list[nat], n: nat, l: list[nat]):

l = cons(n, l1) IMPLIES <<[nat](l1, l);



Listas de naturales

Propiedades del procedimiento de ordenacion

ordenada_unitaria: LEMMAordenada(cons(n,null))

inserta_en_ordenada: LEMMAordenada(l) IMPLIES ordenada(inserta(n,l))

isort_ordena: THEOREMordenada(isort(l))



Especificacion de arboles binarios

Elementos del Tipo Abstracto de Dato arbol binario

Tipo de los nodos: T

Constructores: hoja y nodo

Reconocedores: hoja? y nodo?

Accesores: val , izquierda y derecha

Especificacion (arbol_binario.pvs )

arbol_binario[T: TYPE]: DATATYPE

BEGIN

hoja: hoja?nodo(val: T, izquierda: arbol_binario,

derecha: arbol_binario): nodo?

END arbol_binario



Generacion de teorıas

Orden para generar la teorıa asociada a un Tipo Abstracto deDatos: M-x typecheck

Fichero generado: arbol_binario_adt.pvs

Teorıas generadas:

arbol_binario_adt[T: TYPE]

arbol_binario_adt_map[T: TYPE, T1: TYPE]

arbol_binario_adt_reduce[T: TYPE, range: TYPE]



La teorıa arbol_binario_adt

Signatura

arbol_binario_adt[T: TYPE]: THEORY

BEGIN

arbol_binario: TYPEhoja?, nodo?: [arbol_binario -> boolean]hoja: (hoja?)nodo: [[T, arbol_binario, arbol_binario] -> (nodo?)]val: [(nodo?) -> T]izquierda: [(nodo?) -> arbol_binario]derecha: [(nodo?) -> arbol_binario]

...

END arbol_binario_adt




La funcion ord enumera los tipos de datos del Tipo Abstractode Datos (en este caso, asigna 0 a las hojas y 1 a los nodos)

ord(x: arbol_binario): upto(1) =CASES x OF

hoja: 0,nodo(nodo1_var, nodo2_var, nodo3_var): 1

ENDCASES




Axiomas de extensionalidad: Dos arboles con las mismascomponentes son iguales

arbol_binario_hoja_extensionality: AXIOMFORALL (hoja?_var: (hoja?), hoja?_var2: (hoja?)):

hoja?_var = hoja?_var2;

arbol_binario_nodo_extensionality: AXIOMFORALL (nodo?_var: (nodo?), nodo?_var2: (nodo?)):

val(nodo?_var) = val(nodo?_var2) ANDizquierda(nodo?_var) = izquierda(nodo?_var2) ANDderecha(nodo?_var) = derecha(nodo?_var2)

IMPLIESnodo?_var = nodo?_var2;




El axioma eta: El arbol construido con el valor, la ramaizquierda y la rama derecha de otro arbol es identico al original

arbol_binario_nodo_eta: AXIOMFORALL (nodo?_var: (nodo?)):

nodo(val(nodo?_var), izquierda(nodo?_var),derecha(nodo?_var)) =

nodo?_var;


val(nodo(v,A,B)) = v

arbol_binario_val_nodo: AXIOMFORALL (nodo1_var: T, nodo2_var: arbol_binario,

nodo3_var: arbol_binario):val(nodo(nodo1_var, nodo2_var, nodo3_var)) =nodo1_var;





izquierda(nodo(v,A,B)) = A

arbol_binario_izquierda_nodo: AXIOMFORALL (nodo1_var: T, nodo2_var: arbol_binario,

nodo3_var: arbol_binario):izquierda(nodo(nodo1_var, nodo2_var, nodo3_var)) =nodo2_var;

derecha(nodo(v,A,B)) = B

arbol_binario_derecha_nodo: AXIOMFORALL (nodo1_var: T, nodo2_var: arbol_binario,

nodo3_var: arbol_binario):derecha(nodo(nodo1_var, nodo2_var, nodo3_var)) =nodo3_var;




Axiomas de particion: Todo arbol binario es simple (hoja? ) ocompuesto (nodo? )

arbol_binario_inclusive: AXIOMFORALL (arbol_binario_var: arbol_binario):

hoja?(arbol_binario_var) ORnodo?(arbol_binario_var);




Axioma de induccion: Sea P un propiedad sobre los arboles.Si P(hoja) y(∀v, A1, A2)[P(A1) ∧ P(A2) → P(nodo(v, A1, A2))],entonces (∀A)P(A)

arbol_binario_induction: AXIOMFORALL (p: [arbol_binario -> boolean]):

(p(hoja) AND(FORALL (nodo1_var: T, nodo2_var: arbol_binario,

nodo3_var: arbol_binario):p(nodo2_var) AND p(nodo3_var) IMPLIES

p(nodo(nodo1_var, nodo2_var, nodo3_var))))IMPLIES

(FORALL (arbol_binario_var: arbol_binario):p(arbol_binario_var));




La relacion de subarbol: subterm(A,B) se verifica syss A es unsubarbol de B

subterm(x, y: arbol_binario): boolean =x = y ORCASES y OF

hoja: FALSE,nodo(nodo1_var, nodo2_var, nodo3_var):

subterm(x, nodo2_var) OR subterm(x, nodo3_var)ENDCASES;




La relacion de subarbol estricto: A << B se verifica si A es unsubarbol estricto de B. La relacion << es bien fundamentada

<<: (well_founded?[arbol_binario]) =LAMBDA (x, y: arbol_binario):

CASES y OFhoja: FALSE,nodo(nodo1_var, nodo2_var, nodo3_var):

(x = nodo2_var OR x << nodo2_var) ORx = nodo3_var OR x << nodo3_var

ENDCASES;

arbol_binario_well_founded: AXIOMwell_founded?[arbol_binario](<<);



Propiedades de arboles binarios

Estructura de la teorıa list_props

arbol_binario_props[T: TYPE]: THEORY

BEGINIMPORTING arbol_binario_adt[T]

A: VAR arbol_binario

...

END arbol_binario_props




Definicion del numero de hojas de un arbol binario

hojas(A): RECURSIVE nat =CASES A OF

hoja: 1,nodo(v,A1,A2): hojas(A1) + hojas(A2)

ENDCASESMEASURE A BY <<




Definicion del numero de hojas de un arbol binario

TCCs generados

% Termination TCC generated for hojas(A1)% proved - complete

hojas_TCC1: OBLIGATIONFORALL (A1, A2: arbol_binario[T],

v: T, A: arbol_binario[T]):A = nodo(v, A1, A2) IMPLIES <<[T](A1, A);

% Termination TCC generated for hojas(A2)% proved - complete

hojas_TCC2: OBLIGATIONFORALL (A1, A2: arbol_binario[T],

v: T, A: arbol_binario[T]):A = nodo(v, A1, A2) IMPLIES <<[T](A2, A);




Definicion del numero de nodos internos de un arbol binario

nodos(A): RECURSIVE nat =CASES A OF

hoja: 0,nodo(v,A1,A2): 1 + nodos(A1) + nodos(A2)


TCC generado

% The termination TCC in decl nodos for nodos(A1)% is subsumed by hojas_TCC1

% The termination TCC in decl nodos for nodos(A2)% is subsumed by hojas_TCC2




Definicion del simetrico de un arbol binario

simetrico(A): RECURSIVE arbol_binario =CASES A OF

hoja: A,nodo(v,A1,A2): nodo(v,simetrico(A2),simetrico(A1))


TCC generado

% The termination TCC in decl simetrico for simetrico(A2)% is subsumed by hojas_TCC2

% The termination TCC in decl simetrico for simetrico(A1)% is subsumed by hojas_TCC1




Propiedades del simetrico de un arbol binario

simetrico_simetrico: LEMMAsimetrico(simetrico(A)) = A

hojas_simetrico: LEMMAhojas(simetrico(A)) = hojas(A)

nodos_simetrico: LEMMAnodos(simetrico(A)) = nodos(A)



Documents

PVS: Tipos abstractos de datos - Universidad de Sevilla · Generaci´on de teor´ıas Orden para generar la teor´ıa asociada a un Tipo Abstracto de Datos: M-x typecheck Fichero