PVS: Tipos abstractos de datos - Universidad de Sevilla · Generaci´on de teor´ıas Orden para...
Transcript of PVS: Tipos abstractos de datos - Universidad de Sevilla · Generaci´on de teor´ıas Orden para...
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
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
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
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]
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
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
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
La teorıa 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
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
La teorıa lista_adt
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;
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
La teorıa lista_adt
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;
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
La teorıa lista_adt
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;
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
La teorıa lista_adt
Axioma de particion: Toda lista es simple (null? ) ocompuesta (cons? )
lista_inclusive: AXIOMFORALL (lista_var: lista):
null?(lista_var) OR cons?(lista_var);
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
La teorıa lista_adt
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));
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
La teorıa lista_adt
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;
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
La teorıa lista_adt
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](<<);
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
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
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
Propiedades de listas
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);
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
Propiedades de listas
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)
ENDCASESMEASURE l BY <<
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);
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
Propiedades de listas
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);
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
Propiedades de listas
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))
ENDCASESMEASURE l BY <<
TCC generado
% The termination TCC in decl inversa for inversa(l1)% is subsumed by longitud_TCC1
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
Propiedades de listas
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)
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
Propiedades de listas
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))
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
Propiedades de listas
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
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
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
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
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);
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
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);
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
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))
ENDCASESMEASURE l BY <<
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);
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
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))
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
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
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
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]
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
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
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
La teorıa 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
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
La teorıa arbol_binario_adt
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;
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
La teorıa arbol_binario_adt
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;
Axioma de accesores–constructores
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;
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
La teorıa arbol_binario_adt
Axioma de accesores–constructores
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;
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
La teorıa arbol_binario_adt
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);
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
La teorıa arbol_binario_adt
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));
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
La teorıa arbol_binario_adt
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;
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
La teorıa arbol_binario_adt
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](<<);
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
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
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
Propiedades de arboles binarios
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 <<
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
Propiedades de arboles binarios
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);
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
Propiedades de arboles binarios
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)
ENDCASESMEASURE A BY <<
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
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
Propiedades de arboles binarios
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))
ENDCASESMEASURE A BY <<
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
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos
Propiedades de arboles binarios
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)
Razonamiento Automatico – 2008/2009 PVS: Tipos abstractos de datos