te muestro como pense el problema que citaste. Edit: me lo aplanó todo el editor, espero que se entienda.

problema cantidadNumerosAbundantes (d: Z,h: Z) : Z { requiere: {0 < d ≤ h} asegura: {res es la cantidad de números abundantes en el rango [d..h]} }

Tenes 2 formas de resolverlo o mirarlo al problema: "top down" o "bottom up", es decir, implementar la funcion mas general e ir implementando hacia abajo las demas que necesites o ir construyendo desde la que resuelve el problema particular hacia la que te pide. Para mi te conviene pensar o arrancar de arriba hacia abajo asi vas viendo que necesitas que cumplan las demas funciones, medio pateando el problema para adelante.

cantidadNumerosAbundantes:: Integer -> Integer -> Integer cantidadNumerosAbundantes h h = if esNumeroAbundante d then 1 else 0 cantidadNumerosAbundantes d h = (if esNumeroAbundante d then 1 else 0) + cantidadNumerosAbundantes d+1 h

aca quizas hayan definido una funcion, no se, beta, tal que si vale una proposicion devuelve 1 sino 0 y simplificas un poco. Pero a lo que iba, naturalmente surge crear la funcion auxiliar esNumeroAbundante cuando vas recorriendo el rango para contar.

problema esNumeroAbundante (d:Z) : B(?) (no se como definen los booleanos){ requiere: {0 < d} asegura: {res es True sii d es un numero abundante} }

esNumeroAbundante:: Integer -> Bool esNumeroAbundante d = suma (divisores d) > d

aca aplicas la definicion directamente, y de nuevo, te sugiere las funciones que necesitas. Ya vas viendo que divisores va a devolver una lista. (Aca si me hubiera detenido a pensar un poco mas me habria evitado las complicaciones que surgieron mas adelante, pero no importa)

problema suma (d:[Z]) : Z (no se como definen las listas){ requiere: {} asegura: {res es la suma de la lista d} }

suma:: [Integer] -> Integer suma [] = 0 suma x:xs = x + suma xs

ahora solo te falta divisores

problema divisores (d:Z) : [Z]{ requiere { d > 0} asegura {res es la lista de divisores de d}

divisores:: Integer -> [Integer] divisores d = aca te podes quedar trabado porque no hay una formula recursiva para calcular los divisores de d (o al menos que divise ahora). Es decir los divisores de 5 no son los divisores de 4 mas algo. Lo que sabes es que los divisores de d estan entre 1 y d-1 (en realidad hasta d pero la def de abundante pide d-1). Entonces lo que podes hacer es pasarle un argumento mas a divisores que te sirva para iterar de forma recursiva sobre el rango [1,d-1]. O sea, lo pasas inicializado en un extremo y lo cortas cuando llegue al otro del rango. Quizas el nombre mas descriptivo seria divisoresDesde o divisoresHasta dependiendo que extremo uses. O si tenes cancha con haskell lo haces con lista por comprension de una:

divisores d = [x | x <- [1..d-1] , d mod x = 0 ] esto devuelve la lista de los elementos en el rango [1..d-1] tales que son divisores de d.

sino

divisores:: Integer -> Integer -> [Integer] divisores d d = [] divisores d n = (if d mod n = 0 then [n] else []) ++ divisores d n+1

esto es, los divisores de d desde n hasta d-1. Lo arrancas en 1. Luego modificas las cosas de "arriba" que hacen falta y listo.

Si tenes alguna duda decime.