Verificacion de Propiedades de un Tipo Abstracto

de Datos usando su Especificacion Algebraica

Pablo Sanchez
Departamento de Matem
aticas, Estadstica y Computaci
on
Universidad de Cantabria (Santander, Espa
na)
p.sanchez@unican.es

Resumen
El presente documento ilustra mediante un sencillo ejemplo c
omo se
pueden usar las especificaciones algebraicas para demostrar formalmente,
es decir, de forma matem
atica, ciertas propiedades de un Tipo Abstracto
de Datos. La demostraci
on rigurosa de dichas propiedades es una condici
on necesaria para la construcci
on de software de alta fiabilidad cuya
correcci
on tenga que ser verificada formalmente, certificando por tanto
que dicho software es correcto y carece de errores.

1.

Introducci
on

Cuando construimos software que usa Tipos Abstractos de Datos (TADs) es

muy frecuente que nos surja la necesidad de razonar sobre ciertas propiedades de
dichos TADs. Por ejemplo, una precondici
on de un metodo podra satisfacerse
siempre y cuando, dada una lista o secuencia cualesquiera, la inversa de la
inversa de dicha lista sea igual a dicha lista. O dicho de forma mas algebraica,
siempre y cuando la ecuaci
on invertir(invertir(l)) == l fuese verdadera para
todo valor de l, siendo l una lista. Tal propiedad, que a primera vista parece
obvia, podra no serlo. Si estamos construyendo software para un sistema crtico,
como puede ser software para un avi
on o para el control del reactor de una
central nuclear, necesitamos usar una base mas solida que nuestra mera intuici
on
en aras de asegurar que el software esta libre de fallos y por tanto podemos
confiar en el.
Partiendo de una especificacion algebraica, podemos demostrar en base a
las ecuaciones de dicha especificacion, y normalmente usando inducci
on, ciertas
propiedades de un TAD. Una vez probadas matematicamente dichas propiedades
podemos tener la certeza absoluta de que son ciertas. Una vez demostrada una
propiedad a nivel de especificacion, toda implementaci
on que sea conforme a
dicha especificacion poseera automaticamente tal propiedad, y dicha propiedad
se podr
a usar para verificar que el software esta libre de errores. Por ejemplo, se

puede usar para verificar que ninguna llamada a un metodo viola la precondici
on
de dicho metodo.
A lo largo de este documento mostraremos como probar para una lista que la
propiedad invertir(invertir(l)) == l es verdadera. La Seccion 2 proporciona la
especificacion algebraica del TAD Lista. La Seccion 3 contiene la demostracion
por inducci
on de la propiedad. La Seccion 4 contiene un breve sumario del
documento.

2.

Especificaci
on Algebraica del TAD Lista

Esta seccion contiene la especificacion algebraica del TAD Lista, la cual se

muestra en las Figuras 1, 2 y 3. Las ecuaciones de interes para este documento
son las que afectan a la operacion addHead (Figura 1, ec. 16 y 17) y a la operacion
invertir (Figura 3, ec. 44 y 45).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

espec Sequence ( L i s t )
usa Boolean , N a tu r a l , Entero
generos Sequence ( Element ) como Seq
parametro
generos Element como E
operaciones
e q u a l : Element Element > Boolean
variables
x , y , z : Element ;
ecuaciones
e q u a l ( x , x ) = TRUE
equal (x , y ) = equal (y , x)
[ e q u a l ( x , y ) and e q u a l ( y , z ) ] e q u a l ( x , z ) = TRUE;
fparametro
operaciones
emptySeq
: > Seq
addTail , addHead : Seq E > Seq
add
: Seq E N a tu r a l > Seq
g e t T a i l , getHead : Seq > E
get
: Seq N a tu r a l > E
replace
: Seq N a tu r a l E > Seq
removeAll , r e m o v e F i r s t , removeLast : Seq E > Seq
remove
: Seq N a tu r a l > Seq
contains
: Seq E > Boolean
f i n d F i r s t I n d e x , f i n d L a s t I n d e x : Seq E > Entero
size
: Seq
> N a tu r a l
number
: Seq E > N a tu r a l
isEmpty
: Seq
> Boolean
c o n c a t , e q u a l : Seq Seq > Seq
equal
: Seq Seq > Boolean
invertir
: Seq > Seq
fspec ( c o n t i n u a )

Figura 1: Especificacion Algebraica del TAD Lista (0)

2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54

espec Sequence ( L i s t ) ( c o n t i n u a c i o
n )
vars
s , s 2 : Seq ; n : N a tu r a l ; x , y : Element ;
precondiciones
[ 0 <= n <= s i z e ( s ) ] add ( s , n )
[ isEmpty ( s ) == FALSE ] g e t T a i l ( s ) , getHead ( s )
[ 0 <= n < s i z e ( s ) ] g e t ( s , n ) , remove ( s , n ) , r e p l a c e s ( s , n , x )
ecuaciones
// Las g e n e r a d o r a s son emptySeq y addT ai l y son l i b r e s
// Los p a t r o n e s d e l t i p o son :
//
emptySeq
//
addT ai l ( s , x )
addHead ( emptySeq , x ) = a d d T a i l ( emptySeq , x )
addHead ( a d d T a i l ( s , x ) , y ) = a d d T a i l ( addHead ( s , y ) , x )
s i z e ( emptySeq ) = 0
s i z e ( addTail ( s , x ) ) = 1 + s i z e ( s )
add ( emptySeq , x , 0 ) = a d d T a i l ( emptySeq , x )
[ n == s i z e ( a d d T a i l ( s , x ) ) ]
add ( a d d T a i l ( s , x ) , y , n ) = a d d T a i l ( a d d T a i l ( s , x ) , y )
[ n < s i z e ( addTail ( s , x ) ) ]
add ( a d d T a i l ( s , x ) , y , n ) = a d d T a i l ( add ( s , y , n ) , x )
g e t T a i l ( addTail ( s , x ) ) = x
getHead ( a d d T a i l ( emptySeq , x ) ) = x
getHead ( a d d T a i l ( a d d T a i l ( s , x ) ) ) = getHead ( a d d T a i l ( s , x ) )
[ n == ( s i z e ( s ) 1 ) ] g e t ( a d d T a i l ( s , x ) , n ) = x
[ n < ( s i z e ( s ) 1 ) ] g e t ( a d d T a i l ( s , x ) , n ) = g e t ( s , n1)
r e m o v e A l l ( emptySeq , x ) = emptySeq
[ e q u a l ( x , y ) == TRUE]
removeAll ( addTail ( s , x ) , y ) = removeAll ( s , y )
[ e q u a l ( x , y ) != TRUE]
removeAll ( addTail ( s , x ) , y ) = addTail ( removeAll ( s , y ) , x )
[ n == ( s i z e ( s ) 1 ) ]
remove ( a d d T a i l ( s , x ) , n ) = s
[ n < ( s i z e ( s ) 1) ]
remove ( a d d T a i l ( s , x ) , n ) = a d d T a i l ( remove ( s , n ) , x )
r e p l a c e ( s , n , y ) = add ( remove ( s , n ) , y , n )
c o n t a i n s ( emptySeq , x ) = FALSE
[ e q u a l ( x , y ) == TRUE]
c o n t a i n s ( a d d T a i l ( s , x ) , y ) = TRUE
[ e q u a l ( x , y ) != TRUE]
con tai n s ( addTail ( s , x ) , y ) = con tai n s ( s , y )
fspec ( c o n t i n u a )

Figura 2: Especificacion Algebraica del TAD Lista (1)

3

1 espec Sequence ( L i s t ) ( c o n t i n u a c i o
n )
2
3
f i n d L a s t I n d e x ( emptySeq , x ) = 1
4
[ ( e q u a l ( x , y ) == TRUE) ]
5
f i n d L as tIn d ex ( addTail ( s , x ) , y ) = s i z e ( s ) ;
6
[ ( e q u a l ( x , y ) != TRUE) ]
7
f i n d L as tIn d ex ( addTail ( s , x ) , y ) = f i n d L as tIn d ex ( s , y ) ;
8
9
f i n d F i r s t I n d e x ( emptySeq , x ) = 1
10
[ ( e q u a l ( x , y ) != TRUE) ]
11
f i n d F i r s t I n d e x ( addTail ( s , x ) , y ) = f i n d F i r s t I n d e x ( s , y ) ;
12
[ ( e q u a l ( x , y ) == TRUE) and ( c o n t a i n s ( s , y ) == TRUE) ]
13
f i n d F i r s t I n d e x ( addTail ( s , x ) , y ) = f i n d F i r s t I n d e x ( s , y ) ;
14
[ ( e q u a l ( x , y ) == TRUE) and ( c o n t a i n s ( s , y ) != TRUE) ]
15
f i n d F i r s t I n d e x ( addTail ( s , x ) , y ) = s i z e ( s ) ;
16
17
[ f i n d F i r s t I n d e x ( s , x ) != 1]
18
r e m o v e F i r s t ( s , x ) = remove ( s , f i n d F i r s t I n d e x ( s , x ) ) ;
19
[ f i n d F i r s t I n d e x ( s , x ) == 1] r e m o v e F i r s t ( s , x ) = s ;
20
21
[ f i n d L a s t I n d e x ( s , x ) != 1]
22
removeLast ( s , x ) = remove ( s , f i n d L a s t I n d e x ( s , x ) ) ;
23
[ f i n d L a s t I n d e x ( s , x ) == 1] removeLast ( s , x ) = s ;
24
25
number ( emptySeq , x ) = 0
26
[ e q u a l ( x , y ) == TRUE]
27
number ( a d d T a i l ( s , x ) , y ) = 1 + number ( s , y )
28
[ e q u a l ( x , y ) != TRUE]
29
number ( a d d T a i l ( s , x ) , y ) = number ( s , y )
30
31
isEmpty ( emptySeq )
= TRUE
32
isEmpty ( a d d T a i l ( s , x ) ) = FALSE
33
34
c o n c a t ( s , emptySeq ) = s
35
c o n c a t ( s , a d d T a i l ( s2 , x ) ) = a d d T a i l ( c o n c a t ( s , s 2 ) , x )
36
37
e q u a l ( emptySeq , emptySeq )
= TRUE
38
e q u a l ( a d d T a i l ( s , x ) , emptySeq ) = FALSE
39
e q u a l ( emptySeq , a d d T a i l ( s , x ) ) = FALSE
40
[ e q u a l ( x , y ) == TRUE]
41
e q u a l ( a d d T a i l ( s , x ) , a d d T a i l ( s2 , y ) ) = e q u a l ( s , s 2 )
42
[ e q u a l ( x , y ) != TRUE] e q u a l ( a d d T a i l ( s , x ) , a d d T a i l ( s2 , y ) ) =
FALSE
43
44
i n v e r t i r ( emptySeq ) = emptySeq
45
i n v e r t i r ( a d d T a i l ( s , x ) ) = addHead ( i n v e r t i r ( s ) , x )
46 f e s p e c

Figura 3: Especificacion Algebraica del TAD Lista (2)

3.

Demostraci
on por Inducci
on

En esta seccion demostraremos la propiedad enunciada en la introducci

on
de este documento, y que se muestra en la ec. (1). Usaremos para ello inducci
on
matematica. Por tanto, debemos demostrar que dicha propiedad se cumple para
un caso base, que sera la secuencia vaca; asumiremos que es verdad para listas
de tama
no n (hip
otesis de inducci
on); y lo demostraremos para listas de tama
no
n + 1 usando para ello la hip
otesis de inducci
on.
invertir(invertir(l, x)) = l

(1)

Caso Base Tenemos que demostrar la ecuacion (1) es verdadera para la lista
vaca, tal como muestra la ecuacion (2).
invertir(invertir(emptySeq)) == emptySeq

(2)

Para ello reducimos el termino izquierdo de la ecuacion (2), comprobando

que al reducirse se iguala al termino derecho de dicha ecuacion. Dicha reduccion
se muestra en (3).
invertir(invertir(emptySeq)) =
[Aplica F igura 3, ec. 44] = invertir(emptySeq)
[Aplica F igura 3, ec. 44] = emptySeq

(3)

Hip
otesis de Inducci
on Asumimos, de acuerdo con la tecnica de demostraci
on por inducci
on, que la ecuacion (4) es verdadera para lista de tama
no
n.
invertir(invertir(l)) = l

(4)

Paso Inductivo Demostramos ahora, apoy

andonos en la hip
otesis de inducci
on, que la ecuacion (1) es verdadera para lista de tama
no n + 1. Es decir,
debemos igualar los terminos de la ecuacion (5).
invertir(invertir(addT ail(l, x))) = addT ail(l, x)

(5)

Para ello tendremos que hacer uso de una nueva propiedad, que parece razonable, pero que hemos tambien de demostrar matematicamente.
En (7) se muestra la reduccion llevada a cabo para igualar el termino izquierdo de la ecuacion (11) con el termino derecho de la misma. Para realizar el
segundo paso de dicha reduccion hemos asumido que la propiedad de la ecuaci
on (6) es verdadera. Dicha propiedad dice que la inversa de una lista cuyo
elemento en la cabeza es x es igual a la inversa de la lista sin la cabeza, y con
dicha cabeza x como cola.
invertir(addHead(l, x)) = addT ail(invertir(l), x)
5

(6)

invertir(invertir(addT ail(l, x))) =

[F igura 3, ec. 45] = invertir(addHead(invertir(l), x))
[P rop. a demostrar] = addT ail(invertir(invertir(l)), x)

(7)

[Hip. inductiva] = addT ail(l, x)

La reduccion (7) se basa en la propiedad de la ecuacion (6). Por tanto,
para que dicha reduccion sea correcta debemos demostrar que tal propiedad es
correcta. Para ello procedemos nuevamente por inducci
on sobre el tama
no de la
lista.
Caso Base Hemos de demostrar que la propiedad es cierta para listas vacas,
tal como muestra la ecuacion (8).
invertir(addHead(emptySeq, x)) = addT ail(invertir(emptySeq), x)

(8)

Para ello reducimos los terminos derechos e izquierdo hasta llegar a un mismo
termino, tal como muestran las ecuaciones (??) y (10).
invertir(addHead(emptySeq, x)) =
[Aplica F igura 2, ec. 16] = invertir(addT ail(emptySeq, x))
[Aplica F igura 3, ec. 45] = addHead(invertir(emptySeq), x) (9)
[Aplica F igura 3, ec. 44] = addHead(emptySeq, x)
[Aplica F igura 2, ec. 16] = addT ail(emptySeq, x)
addT ail(invertir(emptySeq), x) =
[Aplica F igura 3, ec44] = addT ail(emptySeq, x)
Hip
otesis de Inducci
on
listas de tama
no n.

(10)

Asumimos como verdadera la ecuacion (6) para

Paso Inductivo Demostramos que la ecuacion (11) es verdadera haciendo uso

de la hip
otesis de inducci
on. Para ello reducimos el termino izquierdo de la ecuaci
on (11) para igualarlo con el termino derecho de la misma. La ecuacion (12)
muestra dicha reduccion.
invertir(addHead(addT ail(l, y), x)) = addT ail(invertir(addT ail(l, y)), x)
(11)

invertir(addHead(addT ail(l, y), x)) =

[Aplica F igura 1, ec. 17] = invertir(addT ail(addHead(l, x), y))
[Aplica F igura 3, ec. 45] = addHead(invertir(addHead(l, x)), y)
[Aplica Hip. Inductiva] = addHead(addT ail(invertir(l), x), y)
[Aplica F igura 1, ec. 17] = addT ail(addHead(invertir(l), y), x)
[Aplica F igura 3, ec. 45] = addT ail(invertir(addT ail(l, y)), x)
(12)
Por tanto, demostrada la propiedad principal y la auxiliar que era necesaria
para demostrar la principal, podemos concluir sin lugar a dudas que la inversa
de la inversa de una lista es la propia lista. Dicha propiedad esta demostrada
matematica y sera verdad para toda implementaci
on que satisfaga o se corresponda con la especificacion usada para demostrar la propiedad.

4.

Sumario

Este documento ha presentado un sencillo ejemplo que ilustra como se pueden utilizar las especificaciones algebraicas para demostrar mediante inducci
on
matematica ciertas propiedades de un Tipo Abstracto de Datos. Demostrar dichas propiedades puede resultar crucial de cara a la elaboraci
on de software
fiable que necesitemos verificar que se encuentra libre de errores. Por desgracia, estos procedimientos de verificacion requieren tiempo y cierta habilidad, lo
que los hace bastante costosos. Por tanto, se suelen emplear exclusivamente en
sistemas software crticos, donde un mnimo fallo puede acarrear consecuencias
funestas.