TPFA - Ecosistema Marino

Algoritmos y Estructuras de Datos I

Segundo cuatrimestre de 2004

1. Introducción
En esta parte del Trabajo Práctico, demostraremos la terminación de las funciones: maximoIdKS :: Superficie →Id y
producidFungusMN :: Superficie →Superficie. Para ello, tendremos en cuenta todas las funciones auxiliares utilizadas
asi como también las especificaciones de cada algoritmo presentadas en el TPEA y TPFA.

2. Terminación de MaximoIdKS
2.1. maximoIdKS
Para demostrar la terminación de la función MaximoIdKS, recurriremos al famoso método de Jack el Destripador
e iremos “ por partes”. Primero, mostraremos la funcion maximoIdKS y la traduciremos a lenguaje ecuacional:
maximoIdKS :: Superficie → Id
maximoIdKS sup@(S tor dic) = maximoIdKSPRE sup (nuevoEnteroNT tor) (−1)

maximoIdKS sup@(S tor dic) / (T rue,True) = maxIdKSPRE sup (nuevoEnteroNT tor) (-1)

Como bien se ve en las ecuaciones anteriores, maximoIdKS llama siempre a la función maxIdKSPRE. Luego, como no
tiene ningun paso recursivo, analizaremos que se cumpla la regla 1 y 2 de terminación de maximoIdKS y después nos
dedicaremos a demostrar la terminación de maxIdKSPRE.

R1. Debido a que no hay ninguna restricción con respecto a la Superficie, entonces, cualquier entrada “matchea”
con la ecuación.
R2. La precondición de nuevoEnteroNT es True, mientras que la de maxIdKSPRE es que el NavegadorToroide
tenga la forma de la Superficie y sea de tipo Entero, lo cual se cumple claramente, ya que se le ingresa como
parámetro una Superficie y un NavegadorToroide de tipo Entero en base al toroide descripto por la Superficie.

2.2. maxIdKSPRE
Ahora, probaremos lo más importante: la terminación de maxIdKSPRE, función principal que se utiliza en maxi-
moIdKS. Para ello, primero la expondremos en Haskell y en lenguaje ecuacional, y luego analizaremos el cumplimiento
de cada una de las reglas de Terminación.
maxIdKSPRE :: Superficie → NavegadorToroide → Int → Id
maxIdKSPRE sup nt i
| (termineNT nt) = i
| not(termineNT(nt)) && (hayKrillS sup (actualNT nt)) && (idK(krillS sup (actualNT nt)) > i) =
maxIdKSPRE sup (avanzarNT nt) (idK(krillS sup (actualNT nt)))
| otherwise = maxIdKSPRE sup (avanzarNT nt) i

maxIdKSPRE sup nt i / (¬hayActual(nt),termineNT nt) = i

maxIdKSPRE sup nt i / (hayActual(nt) ∧ hayKrill(celda(sup, actual(nt)))∧
(idKrill(krill(celda(sup, actual(nt)))) > i), not(termineNT(nt)) && (hayKrillS sup (actualNT nt)) &&
(idK(krillS sup (actualNT nt)) > i)) = maxIdKSPRE sup (avanzarNT nt) (idK(krillS sup (actualNT nt)))
maxIdKSPRE sup nt i / (T rue,True) = maxIdKSPRE sup (avanzarNT nt) i

La especificación es la siguiente:

1. maxIdKSPRE :: Superficie →NavgadorToroide →Int →Id

∆ : Id = maxIdKSP RE(sup : Superf icie, nt : N avegadorT oroide, k : Id)
P ≡ {tipoN avegador(nt) = Entero ∧ toroide(nt) = f orma(sup)}

1
 Q ≡ {(∃noRecorrido : ConjuntohCoordenadai)(esN oRecorrido(noRecorrido, sup, nt) ∧
((noHayKrillenN oRecorrido(nt, noRecorrido) ∧ ∆ = k) ∨ ((∃h :
Z)(maxIdKrillenN oRecorrido(sup, nt, h))) ∧ ∆ = max(h, k)))}

esN oRecorrido(noRecorrido : ConjuntohCoordenadai, sup : Superf icie, nt : N avegadorT oroide) ≡

{(∀c : Coordenada)(contiene(f orma(s), c) ∧ ¬(c ∈ yaRecorrido(nt)) ↔ c ∈ noRecorrido)}

noHayKrillenN oRecorrido(noRecorrido : ConjuntohCoordenadai, nt : N avegadorT oroide) ≡

{¬(∃q : Coordenada)(q ∈ noRecorrido ∧ hayKrillC(celda(sup, q)))}

maxIdKrillenN oRecorrido(sup : Superf icie, nt : N avegadorT oroide, h : Z) ≡

{(∃q : Coordenada)(q ∈ noRecorrido ∧ hayKrillC(celda(sup, q)) ∧
idKrill(krillC(celda(sup, q))) = h ∧ ((∀otraq : Coordenada)(otraq ∈
noRecorrido ∧ hayKrillC(celda(sup, otraq)) → idKrill(krillC(celda(sup, otraq))) ≤ h))}

Seguidamente, analizaremos la terminación de maxIdKSPRE segun las reglas:

R1. Las variables de entrada son de tres tipos distintos: NavegadorToroide, Superficie, y Entero. Luego, para
ver que siempre existirá una ecuación para cualquier variable de entrada que cumpla con la precondición de la
especificación de maxIdKSPRE, analizaremos cada uno de los valores posibles que pueden tomar estas variable
por separado:

• R1.1 El NavegadorToroide (en este caso solo el tipo Entero y aquel que describe un toroide de la forma de
la Superficie ingresada como parametro, segun especificado por la Precondicion) puede dividirse segun su
“estado” en dos formas diferentes: Terminado y No Terminado. Terminado se refiere al NavegadorToroide que
hace que ¬hayActual (NavegadorToroide) evalue True, es decir, que ya haya finalizado de recorrer cada
una de las coordenadas del Toroide. No Terminado, por su parte, indica exactamente lo opuesto a Terminado,
el NavegadorToroide esta recorriendo las coordenadas y se encuentra en alguna entre la ultima y la primera
y, por lo tanto, es posible averiguar en cual de ellas se encuentra usando actual (NavegadorToroide).
Luego, para todo valor de NavegadorToroide que cumple con la Precondicion (expuesta arriba), existe por
lo menos un Bi (1 ≤ i ≤ 3, ya que son tres las guardas utilizadas al definir la función maxIdKSPRE) que
se hace verdadero. En B1 se filtra el estado Terminado del NavegadorToroide, es decir, cuando se haya
terminado de recorrer todas las coordenadas correspondientes al toroide. Por otra parte, en B2 se analiza el
caso en que el NavegadorToroide se encuentra en estado No Terminado y haya un Krill sobre la coordenada
donde se encuentra posicionado en ese momento (determinada por actual (NavegadorToroide)) y su Id
sea mayor que el Entero ingresado como variable de entrada. Finalmente, en B3 se “matchea” el resto de los
casos no especulados por las anteriores guardas, y como B3 ≡ {True}, completamos la totalidad de valores
que puede tener NavegadorToroide (siempre teniendo en cuenta que se satisface la Precondición).

• R1.2 La Superficie solo tiene una restricción por parte de la Precondición: su forma debe ser igual al toroide
que recorre el NavegadorToroide. Por lo tanto, se la debe analizar en Bi (1 ≤ i ≤ 3), viendo si “matchea” en
alguna de las guardas. Este paso es trivial, ya que en ningun Bi se pide alguna condicion con respecto a la
Superficie, sino que se la utiliza para matchear los casos que corresponden. Luego, se concluye que Supericie
“matcheará” siempre con alguna guarda (además hay que tener en cuenta la guarda B3 , la cual evalua True
siempre y, entonces, se corresponderá con cualquier valor de entrada de Superficie que se le ingrese a la
función.

• R1.3 El Entero (Z) ingresado como variable de entrada no tiene ninguna restricción, es decir, su valor puede
ser cualquiera dentro de su tipo (Int). Del mismo modo que Superficie, las guardas no estan directamente
condicionadas sobre él, sino que lo utilizan para separar ecuaciones de la función. En B1 y B3 siempre
evaluara True, por lo tanto, ya sabemos de entrada que para cualquier valor que tenga, siempre habra una
guarda que le corresponda. Ahora, en B2 sólo se “matcheará” si su valor es mayor que el del Id del Krill
que esta en la coordenada actual donde esta posicionado el NavegadorToroide sobre la el Toroide (que es la
forma de la Superficie). Por lo tanto, se puede concluir que para todo valor del Entero, siempre tendrá una
guarda con la cual evaluará True.

R2. Aqui probaremos que ninguna función utilizada en las ecuaciones se evalua fuera de su Precondición y que,
por lo tanto, todas terminan. Tanto en G1 como en R1 , termineNT cumple su precondición ya que esta es True.
En G2 hayKrillS tiene precondición que la coordenada este en el Toroide, pero como la forma de la Superficie es
igual al Toroide que recorre el NavegadorToroide, entonces siempre evaluará True. Por su lado, IdK tiene como
precondición True, mientras que KrillS tiene como restricción que haya algun Krill en la celda correspondiente

2
 a la coordenada donde esta posicionado el NavegadorToroide, pero eso ya esta verificado con la función booleana
hayKrillS, que se evalua primero que KrillS y por lo tanto filtra el caso en que no haya Krill en la coordenada,
impidiendo que la función se indefina. En R2 avanzarNT pide como precondición que el NavegadorToroide no
haya terminado de recorrer todas las coordenadas del Toroide (estado Terminado, verificado en G2 ) y maxIdKSPRE
exige que el NavegadorToroide sea de tipo Entero y el toroide sea igual a la forma de la Superficie (condiciones
verificadas en el contexto de evaluación de la función maxIdKSPRE, puesto que avanzarNT no modifica estos
parámetros). En R3 se llama a la misma función que en R2 , la cual ya explicamos anteriormente y verificamos
que se utiliza en base a su precondición. Como en R1 y G3 no se utilizan funciones, no debemos analizarlas, y
concluimos que toda función utilizada en el contexto de maxIdKSPRE satisfará su precondición.
R3. La función variante propuesta para esta función es:

Fv (sup : Superf icie, nt : N avegadorT oroide, n : Z) ≡

{rodajas(f orma(sup)) ∗ porciones(f orma(sup)) − |yaRecorrido(nt)|}

Esta función nunca se indefine porque se cumplen todas las precondiciones de las funciones utilizadas (todas son
True). Se puso como variable de entrada el entero n, aunque no haya sido utilizado para hacer la función variante,
ya que la definición de esta dice que deben pasarse como parámentros de entrada todas las variables.
R4. El unico caso base en la funcion maxIdKSPRE es R1 , ya que R2 y R3 son recursivos (notar que el caso base
es anterior a los recursivos, por lo tanto, como el interprete de Haskell (especificamente para nuestro TP, Hugs)
evalua de arriba hacia abajo, es decir, desde la primera ecuación avanzando una por una hasta encontrar una
guarda que evalue verdadera, el caso base no dejará que la función continue en un “loop” infinito).
R5. La cota que proponemos es k = 0, ya que se cumple que la función variante evaluada en cualquier valor de
entrada que no “matchee” con el caso base (es decir, solo casos recursivos) siempre tendrá un valor mayor que
k. Vemos que rodajas(f orma(sup)) ∗ porciones(f orma(sup)) > |yaRecorrido(nt)| siempre que nos encontremos
en una recursión, ya que el NavegadorToroide no puede recorrer más coordenadas de las que estan en el Toroide.
Luego, rodajas(f orma(sup)) ∗ porciones(f orma(sup)) − |yaRecorrido(nt)| > 0, entonces vemos que la cota es
el cero.
R6. Aqui probaremos que cada vez que se entre en un caso recursivo, la función variante corespondiente a las
variables de entrada del paso recursivo será estrictamente decreciente. Luego, analizamos los dos pasos recursivos
R2 y R3 . En R2 el NavegadorToroide representa una cantidad finita de coordenadas por recorrer, y se llama
a la función avanzarNT la cual en cada iteración estará más cerca de terminar de recorrer el Toroide (ya que
avanza una coordenada), por lo tanto, en cada paso de la recursión nos faltan menos pasos para que el estado
del NavegadorToroide pase de No Terminado a Terminado (es decir, que haya terminado de recorrer todas las
coordenadas, el cual es el caso base). En R3 sucede exactamente lo mismo que en R2 , por lo tanto, también
decrecerá el valor de la función variante con cada iteración. En lenguaje matemático se prueba asi:
Debemos probar que la funcion variante decrece a medida que avanza el NavegadorToroide, es decir, que Fvn >
Fv(n+1) , siendo n un paso cualquiera de la recursion y (n+1) el siguiente. Luego:

Fvn (sup : Superf icie, nt : N avegadorT oroide, n : Z) ≡

{rodajas(f orma(sup)) ∗ porciones(f orma(sup)) − |yaRecorrido(nt)|}

Fv(n+1) (sup : Superf icie, nt : N avegadorT oroide, n : Z) ≡

{rodajas(f orma(sup)) ∗ porciones(f orma(sup)) − |yaRecorrido(avanzarN T (nt))|}

Vemos la especificación de avanzarNT:

2. avanzarNT :: NavegadorToroide →NavegadorToroide

∆ : NavegadorToroide = avanzarN T (nt : N avegadorT oroide)
P ≡ {hayActual(nt)}
Q ≡ {tipoN avegador(∆) = tipoN avegador(nt) ∧ toroide(∆) = toroide(nt) ∧ (∀c :
Coordenada)(c ∈ yaRecorrido(∆) ↔ (c = actual(nt) ∨ c ∈ yaRecorrido(nt))) ∧
(tipoN avegador(nt) = Anillo → (radio(∆) = radio(nt) ∧ centro(∆) = centro(nt)))}

3
 Como se puede notar, cada vez que se llama a avanzarNT, |yaRecorrido(avanzarN T (nt))| va a tener todas las
coordenadas que tenia hasta el paso anterior más la actual, por lo tanto su cardinal será claramente mayor que
|yaRecorrido(nt)|. Entonces:

|yaRecorrido(nt)| < |yaRecorrido(avanzarN T (nt))| →

−|yaRecorrido(nt)| > −|yaRecorrido(avanzarN T (nt))| →
rodajas(f orma(sup)) ∗ porciones(f orma(sup)) − |yaRecorrido(nt)| >
rodajas(f orma(sup)) ∗ porciones(f orma(sup)) − |yaRecorrido(avanzarN T (nt))|

Y ası́ llegamos a demostrar que Fvn > Fv(n+1) , es decir que a medida que recorre más coordenadas y avanza el
NavegadorToroide, la función variante decrece.

Ahora, analizaremos la terminación de cada una de las funciones que utiliza maxIdKSPRE (las que son del módulo
de Superficie): hayKrillS, krillS, celdaS y formaS. Como ningunda de ellas es recursiva, solamente veremos que
sucede con las reglas 1 y 2 de Terminación.

2.3. hayKrillS
Primero, vemos la funcion en Haskell y en lenguaje ecuacional:
hayKrillS :: Superficie → Coordenada → Bool
hayKrillS sup@(S tor dic) c | (contieneT (formaS sup) c) = hayKrillC (celdaS sup c)
| otherwise = error

hayKrillS sup c / (contiene(f orma(sup), c), contieneT (formaS sup) c) = hayKrillC (celdaS sup c)
hayKrillS sup c / (T rue, True) = error

Luego, analizamos las reglas:

R1. Si la coordenada está en la superficie (Precondición), cualquier superficie va a entrar en la primer ecuación.
Si, por el contrario, la coordenada no se encuentra en la superficie ingresada, entonces le regresará el control al
usuario con un error.

R2. La precondición de hayKrillC, contieneT y formaS es True, por lo tanto, todas son usadas sin ningun
tipo de restricción. Por tu parte, celdaS exige que la coordenada este contenida en el Toroide, y esto siempre
será ası́ ya que lo estamos asegurando con la primer guarda.

2.4. krillS
Primero, vemos la funcion en Haskell y en lenguaje ecuacional:
krillS :: Superficie → Coordenada → Krill
krillS sup@(S tor dic) c | (contieneT (formaS sup) c) && hayKrillC (celdaS sup c) = krillC (celdaS sup c)
| otherwise = error

hayKrillS sup c / (contiene(f orma(sup), c) ∧ hayKrill(celda(sup, c)),

(contieneT (formaS sup) c) && hayKrillC (celdaS sup c)) = KrillC (celdaS sup c)
hayKrillS sup c / (T rue, True) = error

Luego, analizamos las reglas:

R1. Si la coordenada está en la superficie, y la celda que está en esa coordenada contiene Krill, entonces cualquier
valor de superficie satisfará la primera ecuación. Por otro lado, si no se cumple esto, se “matcheará” la segunda
ecuación la cual devuelve un error porque no se ha cumplido la precondición de krillS.
R2. La precondición de contieneT y hayKrillC es True; la de celdaS igual a la de krillS, por lo tanto se cumple,
y la de krillC es que hayKrillC sea verdadero, lo cual se verifica en la guarda.

2.5. celdaS
Primero, vemos la funcion en Haskell y en lenguaje ecuacional:
celdaS sup@(S tor dic) c | (contieneT (formaS sup) c) = definicionD dic c
| otherwise = error

4
 celdaS sup@(S tor dic) c / (contiene(f orma(sup), c), contieneT (formaS sup) c) = definicionD dic c
celdaS sup@(S tor dic) c / (T rue, True) = error

Luego, analizamos las reglas:

R1. Si se cumple la precondición (que la coordenada este en el toroide), entonces toda superficie y coordenada
posible entra en la primer guarda. De lo contrario, se “matchea” la segunda ecuación que tira un error.
R2. La precondición de contieneT es True, la de definicionD es que la coordenada este en el Toroide; si
la superficie está bien definida y la coordenada está en el Toroide (esto ultimo por la precondición), entonces
tiene que estar en el diccionario puesto que debe haber una celda para cada coordenada que este en el Toroide
(observador celda(s, c) de superficie restringido a contiene(f orma(s), c)).

2.6. formaS
Primero, vemos la funcion en Haskell y en lenguaje ecuacional:
formaS (S tor dic) = tor
formaS (S tor dic) / (T rue,True) = tor

Luego, analizamos las reglas:

R1. Toda superficie bien definida va a entrar en la primer (y única) ecuacion.

R2. No se usan funciones auxiliares o recursivas.

3. Terminación de ProducidFungusMN
3.1. producidFungusMN
Para empezar a analizar la terminación de producidFungusMN conviene primero que la escribamos tanto en Haskell
como en lenguaje ecuacional:
producidFungusMN :: Superficie → Superficie
producidFungusMN sup = prodFPRE sup (nuevoEnteroNT (formaS sup))

producidFungusMN sup / (T rue, True) = prodFPRE sup (nuevoEnteroNT (formaS sup))

Como bien se ve claramente, la función no es recursiva, por lo tanto nos dedicaremos a demostrar las reglas 1 y 2
de terminación:

R1. Cualquier superficie bien definida, “matcheará” con la primer (y única) guarda. Por lo tanto, la función
siempre se evaluará correctamente para toda superficie ingresada.
R2. La función prodFPRE tiene como precondición que la forma de la superficie sea igual al toroide que describe
el NavegadorToroide y que el tipo de este sea Entero. Esto se cumple ya que en R1 se utiliza un nuevo Navegador
Entero al cual se le ingresa la forma de la Superficie (Toroide) como parámetro. Por su parte, la precondición de
nuevoEnteroNT es True; luego, pasarle como variable la forma de la Superficie no viola ninguna restricción.

3.2. prodFPRE
Ahora probaremos la terminación de la función principal utiliza en producidFungusMN: prodFPRE. Primero, veremos
la función en Haskell y traducida a lenguaje ecuacional:
prodFPRE :: Superficie → NavegadorToroide → Superficie
prodFPRE sup nt | (termineNT nt) = sup
| otherwise = prodFPRE (producirFungusS sup (actualNT nt)) (avanzarNT nt)

prodFPRE sup nt / (¬hayActual(nt), termineNT nt) = sup

prodFPRE sup nt / (T rue, True) = prodFPRE (producirFungusS sup (actualNT nt)) (avanzarNT nt)

La especificación es la siguiente:

3. prodFPRE :: Superficie →NavgadorToroide →Superficie

∆ : Superficie = maxIdKSP RE(sup : Superf icie, nt : N avegadorT oroide)
P ≡ {tipoN avegador(nt) = Entero ∧ toroide(nt) = f orma(sup)}

5
 Q ≡ {(∃noRecorrido : ConjuntohCoordenadai)(esN oRecorrido(noRecorrido, sup, nt) ∧ (∀c :
Coordenada)(c ∈ noRecorrido → esF ungusCrecido(celda(sup, c), celda(∆, c)))) ∧ (∀c :
Coordenada)(contiene(f orma(sup, c)) ∧ c ∈ yaRecorrido(nt) → celda(∆, c) = celda(sup, c))}

esN oRecorrido(noRecorrido : ConjuntohCoordenadai, s : Superf icie, nt : N avegadorT oroide) ≡

{(∀c : Coordenada)(contiene(f orma(s), c) ∧ ¬(c ∈ yaRecorrido(nt)) ↔ c ∈ noRecorrido)}

esF ungusCrecido(c : Celda, c0 : Celda) ≡

{(hayBallena(c) ↔ hayBallena(c0 )) ∧ (hayKrill(c) ↔ hayKrill(c0 )) ∧ (prodDiaria(c) =
prodDiaria(c0 )) ∧ (hayBallena(c) → ballena(c) = ballena(c0 )) ∧ (hayKrill(c) → krill(c) =
krill(c0 )) ∧ (prodDiaria(c) = prodDiaria(c0 )) ∧ (cantF ungus(c0 ) =
cantF ungus(c) + prodDiaria(c))}

Seguidamente, analizaremos la terminación de prodFPRE segun las reglas:

R1. Mientras la superficie y el NavegadorToroide cumplan con la precondición, siempre habrá alguna ecuación
Bi (con 1 ≤ i ≤ 3) con la que “matcheen”. La demostración es trivial: bien se ve que B1 filtra el caso en el que
el NavegadorToroide haya terminado de recorrer todas las coordenadas (es decir, ¬hayActual) y B2 “matchea”
con cualquier cosa, que en este caso serı́a cuando el NavegadorToroide continúa recorriendo las coordenadas.
R2. En B1 la precondición de termineNT es True, por lo tanto esta función no se utiliza fuera de su precondición.
En R2 se hace el llamado recursivo utilizando ahora como parámetros la superficie con fungus producido (esto es
producirFungusS sup (actualNT nt), que claramente no viola su precondición ya que en producidFungusMN
creamos un nuevo NavegadorToroide de tipo Entero en base a la forma de la superficie, por lo tanto todas las
coordenadas que navegue el NavegadorToroide estarán en la superficie pasada como parámetro) y el Navegador-
Toroide avanzado en una coordenada (la precondición de avanzarNT es hayActual(nt) lo cual siempre se cumple
ya que lo pedimos en la guarda).
R3. La función variante propuesta para esta función es:

Fv (sup : Superf icie, nt : N avegadorT oroide) ≡

{rodajas(f orma(sup)) ∗ porciones(f orma(sup)) − |yaRecorrido(nt)|}

Como se ve, es idéntica a la de maxIdKSPRE, ya que ambas estan basadas en el recorrido de coordenadas del
NavegadorToroide. Esta función nunca se indefine porque se cumplen todas las precondiciones de las funciones
utilizadas (todas son True).

R4. El único caso base de la función prodFPRE es R1 ya que R2 es recursivo. Como se ve en la función, el caso
base está ubicado anteriormente al recursivo, por lo tanto, el interprete de Haskell “matcheará” con el caso base
y no dejará que la función entre en una recursión infinita.
R5. Proponemos como cota k = 0, debido a que cuando la función variante alcanza este valor, prodFPRE se
encuentra en el caso base. Vemos que rodajas(f orma(sup))∗porciones(f orma(sup)) > |yaRecorrido(nt)| siempre
que nos encontremos en una recursión, ya que el NavegadorToroide no puede recorrer más coordenadas de las que
estan en el Toroide. Luego, rodajas(f orma(sup)) ∗ porciones(f orma(sup)) − |yaRecorrido(nt)| > 0, entonces
vemos que la cota es el cero.
R6. Debido a que la función variante es igual a la de maxIdKSPRE, la demostración de que es estrictamente
decreciente es idéntica. Sea n un paso en el que se evalua la función prodFPRE y (n+1) el siguiente, nos proponemos
analizar como se comporta la función variante:

Fvn (sup : Superf icie, nt : N avegadorT oroide, n : Z) ≡

{rodajas(f orma(sup)) ∗ porciones(f orma(sup)) − |yaRecorrido(nt)|}

Fv(n+1) (sup : Superf icie, nt : N avegadorT oroide, n : Z) ≡

{rodajas(f orma(sup)) ∗ porciones(f orma(sup)) − |yaRecorrido(avanzarN T (nt))|}

6
 Vemos la especificación de avanzarNT:

4. avanzarNT :: NavegadorToroide →NavegadorToroide

∆ : NavegadorToroide = avanzarN T (nt : N avegadorT oroide)
P ≡ {hayActual(nt)}
Q ≡ {tipoN avegador(∆) = tipoN avegador(nt) ∧ toroide(∆) = toroide(nt) ∧ (∀c :
Coordenada)(c ∈ yaRecorrido(∆) ↔ (c = actual(nt) ∨ c ∈ yaRecorrido(nt))) ∧
(tipoN avegador(nt) = Anillo → (radio(∆) = radio(nt) ∧ centro(∆) = centro(nt)))}

Como se puede notar, cada vez que se llama a avanzarNT, |yaRecorrido(avanzarN T (nt))| va a tener todas las
coordenadas que tenia hasta el paso anterior más la actual, por lo tanto su cardinal será claramente mayor que
|yaRecorrido(nt)|. Entonces:

|yaRecorrido(nt)| < |yaRecorrido(avanzarN T (nt))| →

−|yaRecorrido(nt)| > −|yaRecorrido(avanzarN T (nt))| →
rodajas(f orma(sup)) ∗ porciones(f orma(sup)) − |yaRecorrido(nt)| >
rodajas(f orma(sup)) ∗ porciones(f orma(sup)) − |yaRecorrido(avanzarN T (nt))|

Y ası́ llegamos a demostrar que Fvn > Fv(n+1) , es decir que a medida que recorre más coordenadas y avanza el
NavegadorToroide, la función variante decrece.

Como no se usa ninguna función del módulo de MadreNaturaleza dentro de prodFPRE, damos por concluı́da la
demostración de terminación de prodFPRE y, debido que es la única función utilizada en producidFungusMN, también
demostramos la terminación de esta última.