1. Tipos 2. Cebra

A continuación se presenta la especificación de la cátedra para resolver el RTPF.
1.
Tipos
tipo
tipo
tipo
tipo
tipo
tipo
tipo
Cantidad = R ;
Distancia = Z ;
Edad = Z ;
Peso = R ;
Tasa = R ;
Posicion = (Z,Z) ;
Dia = Domingo, Lunes, Martes, Miércoles, Jueves, Viernes ;
2.
Cebra
tipo Cebra {
observador peso (c: Cebra) : Peso ;
observador edad (c: Cebra) : Edad ;
invariante pesoPositivo : peso(c) > 0 ;
invariante edadPositiva : edad(c) ≥ 1 ;
}
problema nuevaC (p: Peso, e: Edad) = result : Cebra {
requiere p > 0 ;
requiere e ≥ 1 ;
asegura peso(result) == p ;
asegura edad(result) == e ;
}
problema pesoC (c: Cebra) = result : Peso {
asegura result == peso(c) ;
}
problema edadC (c: Cebra) = result : Edad {
asegura result == edad(c) ;
}
problema estaDesnutridaC (c: Cebra, t : Tasa) = result : Bool {
requiere t > 0 ;
asegura result == estaDesnutridaCebra(c, t) ;
}
problema estaEmbarazadaC (c: Cebra, p: Peso) = result : Bool {
requiere p > 0 ;
asegura result == estaEmbarazadaCebra(c, p) ;
}
problema crecerC (c: Cebra) = result : Cebra {
asegura peso(result) == peso(c) ;
asegura edad(result) == edad(c) + 1 ;
}
problema comerC (c: Cebra, cantPasto:Cantidad) = result : Cebra {
requiere cantP asto ≥ 0 ;
asegura peso(result) == pesoDspDComer(c, cantP asto) ;
asegura edad(result) == edad(c) ;
}
problema parirC (c: Cebra, pcria: Peso, pembarazo: Peso) = result : (Cebra, Cebra) {
requiere pcria > 0 ∧ pembarazo > pcria ;
requiere estaEmbarazadaCebra(c, pembarazo) ;
asegura peso(prm(result)) == pembarazo − pcria ;
asegura edad(prm(result)) == edad(c) ;
asegura peso(sgd(result)) == pcria ;
1
asegura edad(sgd(result)) == 1 ;
}
2
3.
Leon
tipo Leon {
observador peso (l: Leon) : Peso ;
observador edad (l: Leon) : Edad ;
observador esperanzaDeVida (l: Leon) : Edad ;
invariante pesoPositivo : peso(l) > 0 ;
invariante edadPositiva : edad(l) ≥ 1 ;
invariante noSuperaEsperanzaDeVida : edad(l) ≤ esperanzaDeV ida(l) ;
}
problema nuevoL (p: Peso, e: Edad, v: Edad) = result : Leon {
requiere p > 0 ;
requiere e ≥ 1 ;
requiere e ≤ v ;
asegura peso(result) == p ;
asegura edad(result) == e ;
asegura esperanzaDeV ida(result) == v ;
}
problema pesoL (l: Leon) = result : Peso {
asegura result == peso(l) ;
}
problema edadL (l: Leon) = result : Edad {
asegura result == edad(l) ;
}
problema esperanzaDeVidaL (l: Leon) = result : Edad {
asegura result == esperanzaDeV ida(l) ;
}
problema estaDesnutridoL (l: Leon, t: Tasa) = result : Bool {
requiere t > 0 ;
asegura result == estaDesnutridoLeon(l, t) ;
}
problema estaEmbarazadoL (l: Leon, p: Peso) = result : Bool {
requiere p > 0 ;
asegura result == estaEmbarazadoLeon(l, p) ;
}
problema crecerL (l: Leon) = result : Leon {
requiere edad(l) < esperanzaDeV ida(l) ;
asegura peso(result) == peso(l) ;
asegura edad(result) == edad(l) + 1 ;
asegura esperanzaDeV ida(result) == esperanzaDeV ida(l) ;
}
problema comerL (l: Leon, pesoCebras: Peso) = result : Leon {
requiere pesoCebras ≥ 0 ;
asegura peso(result) == peso(l) + pesoCebras/2 ;
asegura edad(result) == edad(l) ;
asegura esperanzaDeV ida(result) == esperanzaDeV ida(l) ;
}
problema parirL (l: Leon, pcria: Peso, pembarazo: Peso) = result : (Leon, Leon) {
requiere pcria > 0 ∧ pembarazo > pcria ;
requiere estaEmbarazadoLeon(l, pembarazo) ;
asegura peso(prm(result)) == pembarazo − pcria ;
asegura edad(prm(result)) == edad(l) ;
asegura esperanzaDeV ida(prm(result)) == esperanzaDeV ida(l) ;
asegura peso(sgd(result)) == pcria ;
asegura edad(sgd(result)) == 1 ;
asegura esperanzaDeV ida(sgd(result)) == esperanzaDeV ida(l) + 1 ;
3
}
4
4.
Mundo Toroidal
tipo MundoToroidal {
observador dimensiones (m: MundoToroidal) : (Z, Z) ;
observador cantPasto (m: MundoToroidal, p: Posicion) : Cantidad ;
requiere enRango(m, p) ;
observador crecimientoSemanalPasto (m: MundoToroidal, p: Posicion) : Cantidad ;
requiere enRango(m, p) ;
observador cantMateriaOrganica (m: MundoToroidal, p: Posicion) : Cantidad ;
requiere enRango(m, p) ;
observador capacidadAbsorcionMateriaOrganica (m: MundoToroidal, p: Posicion) : Tasa ;
requiere enRango(m, p) ;
invariante dimensionesPositivas : prm(dimensiones(m)) > 0 ∧ sgd(dimensiones(m)) > 0 ;
invariante pastoNoNegativo : (∀p ← posicionesV alidas(m))cantP asto(m, p) ≥ 0 ;
invariante crecimientoSemanalPastoNoNegativo :
(∀p ← posicionesV alidas(m))crecimientoSemanalP asto(m, p) ≥ 0 ;
invariante materiaOrganicaNoNegativa : (
(∀p ← posicionesV alidas(m))cantM ateriaOrganica(m, p) ≥ 0 ;
invariante capAbsorcionNoNegativa :
(∀p ← posicionesV alidas(m))capacidadAbsorcionM ateriaOrganica(m, p) ≥ 0 ;
}
problema nuevoM (cantFil: Z, cantCol: Z, fact: [(Cantidad, Tasa)], pasto: Cantidad) = result : MundoToroidal {
requiere 0 < cantF il ∧ 0 < cantCol ;
requiere |f act| == cantF il × cantCol ;
requiere (∀t ← f act)(prm(t) ≥ 0 ∧ sgd(t) ≥ 0) ;
requiere pasto ≥ 0 ;
asegura dimensiones(result) == (cantF il, cantCol) ;
asegura (∀p ← posicionesV alidas(result))cantM ateriaOrganica(result, p) == 0 ∧
cantP asto(result, p) == pasto ∧
crecimientoSemanalP asto(result, p) == prm(f act[f ila(p) × cantCol + columna(p)]) ∧
capacidadAbsorcionM ateriaOrganica(result, p) == sgd(f act[f ila(p) × cantCol + columna(p)]) ;
}
problema dimensionesM (m: MundoToroidal) = result : (Z,Z) {
asegura result == dimensiones(m) ;
}
problema cantPastoM (m: MundoToroidal, pos: Posicion) = result : Cantidad {
requiere enRango(m, pos) ;
asegura result == cantP asto(m, pos) ;
}
problema crecimientoSemanalPastoM (m: MundoToroidal, pos: Posicion) = result : Cantidad {
requiere enRango(m, pos) ;
asegura result == crecimientoSemanalP asto(m, pos) ;
}
problema cantMateriaOrganicaM (m: MundoToroidal, pos: Posicion) = result : Cantidad {
requiere enRango(m, pos) ;
asegura result == cantM ateriaOrganica(m, pos) ;
}
problema capacidadAbsorcionMateriaOrganicaM (m: MundoToroidal, pos: Posicion) = result : Tasa {
requiere enRango(m, pos) ;
asegura result == capacidadAbsorcionM ateriaOrganica(m, pos) ;
}
problema quemaDePastizalesM (m: MundoToroidal) = result : MundoToriodal {
asegura dimensiones(result) == dimensiones(m) ;
asegura (∀p ← posicionesV alidas(result))
crecimientoSemanalP asto(result, p) == crecimientoSemanalP asto(m, p) ∧
cantM ateriaOrganica(result, p) == cantM ateriaOrganica(m, p) ∧
capacidadAbsorcionM ateriaOrganica(result, p) == capacidadAbsorcionM ateriaOrganica(m, p) ;
5
asegura (∀p ← posicionesV alidas(result))cantP asto(result, p) == minCantP asto(m) ;
}
problema distanciaM (m: MundoToroidal, desde: Posicion, hasta: Posicion) = result : Distancia {
requiere enRango(m, desde) ;
requiere enRango(m, hasta) ;
asegura result == distanciaM T (m, desde, hasta) ;
}
problema modificarCantMateriaOrganicaM (m: MundoToroidal, pos: Posicion, c: Cantidad) = result : MundoToriodal {
requiere enRango(m, pos) ;
requiere c ≥ 0 ;
asegura dimensiones(result) == dimensiones(m) ;
asegura (∀p ← posicionesV alidas(result))
cantP asto(result, p) == cantP asto(m, p) ∧
crecimientoSemanalP asto(result, p) == crecimientoSemanalP asto(m, p) ∧
capacidadAbsorcionM ateriaOrganica(result, p) == capacidadAbsorcionM ateriaOrganica(m, p) ;
asegura (∀p ← posicionesV alidas(result), p 6= pos)cantM ateriaOrganica(result, p) == cantM ateriaOrganica(m, p) ;
asegura cantM ateriaOrganica(result, p) == c ;
}
problema modificarCantPastoM (m: MundoToroidal, pos: Posicion, c: Cantidad) = result : MundoToriodal {
requiere enRango(m, pos) ;
requiere c ≥ 0 ;
asegura dimensiones(result) == dimensiones(m) ;
asegura (∀p ← posicionesV alidas(result))
cantM ateriaOrganica(result, p) == cantM ateriaOrganica(m, p) ∧
crecimientoSemanalP asto(result, p) == crecimientoSemanalP asto(m, p) ∧
capacidadAbsorcionM ateriaOrganica(result, p) == capacidadAbsorcionM ateriaOrganica(m, p) ;
asegura (∀p ← posicionesV alidas(result), p 6= pos)cantP asto(result, p) == cantP asto(m, p) ;
asegura cantP asto(result, pos) == c ;
}
6
5.
Ecosistema
tipo Ecosistema {
observador habitat (e: Ecosistema) : MundoToroidal ;
observador cebras (e: Ecosistema, p: Posicion) : [Cebra] ;
requiere enRango(habitat(e), p) ;
observador hayLeon (e: Ecosistema, p: Posicion) : Bool ;
requiere enRango(habitat(e), p) ;
observador leon (e: Ecosistema, p: Posicion) : Leon ;
requiere enRango(habitat(e), p) ∧ hayLeon(e, p) ;
observador diaActual (e: Ecosistema) : Dia ;
observador tasaDesnutricionCebras (e: Ecosistema) : Tasa ;
observador tasaDesnutricionLeones (e: Ecosistema) : Tasa ;
observador pesoEmbarazoCebras (e: Ecosistema) : Peso ;
observador pesoEmbarazoLeones (e: Ecosistema) : Peso ;
observador pesoInicialCebras (e: Ecosistema) : Peso ;
observador pesoInicialLeones (e: Ecosistema) : Peso ;
invariante tasaDesnutricionCebrasPositivo : tasaDesnutricionCebras(e) > 0 ;
invariante tasaDesnutricionLeonesPositivo : tasaDesnutricionLeones(e) > 0 ;
invariante pesoEmbarazoCebrasPositivo : pesoEmbarazoCebras(e) > 0 ;
invariante pesoEmbarazoLeonesPositivo : pesoEmbarazoLeones(e) > 0 ;
invariante pesoInicialCebrasPositivo : pesoInicialCebras(e) > 0 ;
invariante pesoInicialLeonesPositivo : pesoInicialLeones(e) > 0 ;
invariante noNacenCebrasEmbarazadas : pesoInicialCebras(e) < pesoEmbarazoCebras(e) ;
invariante noNacenLeonesEmbarazados : pesoInicialLeones(e) < pesoEmbarazoLeones(e) ;
invariante noHayLeonesYCebrasJuntos : (∀p ← posicionesV alidas(habitat(e)))
(hayLeon(e, p) → ¬hayCebraEnP os(e, p)) ;
invariante domingoOK : hoyEs(e, Domingo) →
noHayM ateriaOrganica(e) ∧ noHayCebrasEmbarazadas(e) ∧
noHayLeonesEmbarazados(e) ∧ noHayDesnutridos(e)) ;
invariante lunesOK : hoyEs(e, Lunes) → noHayCebrasEmbarazadas(e) ∧ noHayDesnutridos(e) ;
invariante martesOK : hoyEs(e, M artes) → noHayCebrasEmbarazadas(e) ∧ noHayDesnutridos(e) ;
invariante miercolesOK : hoyEs(e, M iercoles) → noHayDesnutridos(e) ;
invariante juevesOK : hoyEs(e, Jueves) →
noHayCebrasEmbarazadas(e) ∧ noHayLeonesEmbarazados(e) ;
invariante viernesOK : hoyEs(e, V iernes) →
noHayCebrasEmbarazadas(e) ∧ noHayLeonesEmbarazados(e) ∧ noHayDesnutridos(e) ;
}
problema bigBangE (m: MundoToroidal, cs: [(Cebra,Posicion)], ls: [(Leon,Posicion)], tDC, tDL : Tasa ,
pEC, pEL, pIC, pIL : Peso ) = result : Ecosistema {
requiere sonP osicionesV alidas(m, cs) ;
requiere sonP osicionesV alidas(m, ls) ;
requiere noHayMateriaOrganica : (∀p ← posicionesV alidas(m))cantM ateriaOrganica(m, p) == 0 ;
requiere sinCebrasDesnutridas : (∀c ← cs)¬estaDesnutridaCebra(prm(c), tDC) ;
requiere sinLeonesDesnutridos : (∀l ← ls)¬estaDesnutridoLeon(prm(l), tDL) ;
requiere unLeonPorCelda : (∀i, j ← [0..longitud(ls)), i 6= j)sgd(lsi ) 6= sgd(lsj ) ;
requiere noHayCebrasEmbarazadas : (∀c ← cs)¬estaEmbarazadaCebra(prm(c), pEC) ;
requiere noHayLeonesEmbarazados : (∀l ← ls)¬estaEmbarazadoLeon(prm(l), pEL) ;
requiere tasasYPesosPositivos : tDC > 0 ∧ tDL > 0 ∧ pEC > 0 ∧ pEL > 0 ∧ pIC > 0 ∧ pIL > 0 ;
requiere nadieNaceEmbarazado : pIC < pEC ∧ pIL < pEL ;
requiere noHayLeonesYCebrasJuntos : (∀posl ← segundas(ls))posl ∈
/ segundas(cs) ;
asegura habitat(result) == m ;
asegura (∀p ← posicionesV alidas(m))mismos(cebras(result, p), lasCebrasDe(cs, p)) ;
asegura (∀p ← posicionesV alidas(m))hayLeon(result, p) == hayLeonEn(ls, p) ;
asegura (∀p ← posicionesV alidas(m), hayLeon(ls, p))leon(result, p) == elLeonDe(ls, p) ;
asegura diaActual(result) == Domingo ;
asegura tasaDesnutricionCebras(result) == tDC ;
asegura tasaDesnutricionLeones(result) == tDL ;
asegura pesoEmbarazoCebras(result) == pEC ;
asegura pesoEmbarazoLeones(result) == pEL ;
asegura pesoInicialCebras(result) == pIC ;
asegura pesoInicialLeones(result) == pIL ;
7
aux elLeonDe (ls: [(Leon,Posicion)], pos: Posicion) : Leon = cab([prm(l)|l ← ls, sgd(l) == pos]) ;
aux hayLeonEn (ls:[(Leon, Posicion)], pos: Posicion) : Bool = (∃p ← segundas(ls))p == pos ;
aux lasCebrasDe (cs: [(Cebra,Posicion)], pos: Posicion) : [Cebra] = [prm(c)|c ← cs, sgd(c) == pos] ;
}
problema habitatE ( e: Ecosistema ) = result : MundoToroidal {
asegura result == habitat(e) ;
}
problema cebrasE ( e: Ecosistema, p: Posicion) = result : [Cebra] {
requiere enRango(habitat(e), p) ;
asegura mismos(result, cebras(e, p)) ;
}
problema hayLeonE ( e: Ecosistema, p: Posicion) = result : Bool {
requiere enRango(habitat(e), p) ;
asegura result == hayLeon(e, p) ;
}
problema leonE ( e: Ecosistema, p: Posicion) = result : Leon {
requiere enRango(habitat(e), p) ;
requiere hayLeon(e, p) ;
asegura result == leon(e, p) ;
}
problema diaActualE ( e: Ecosistema ) = result : Dia {
asegura result == diaActual(e) ;
}
problema tasaDesnutricionCebrasE ( e: Ecosistema ) = result : Tasa {
asegura result == tasaDesnutricionCebras(e) ;
}
problema tasaDesnutricionLeonesE ( e: Ecosistema ) = result : Tasa {
asegura result == tasaDesnutricionLeones(e) ;
}
problema pesoEmbarazoCebrasE ( e: Ecosistema ) = result : Peso {
asegura result == pesoEmbarazoCebras(e) ;
}
problema pesoEmbarazoLeonesE ( e: Ecosistema ) = result : Peso {
asegura result == pesoEmbarazoLeones(e) ;
}
problema pesoInicialCebrasE ( e: Ecosistema ) = result : Peso {
asegura result == pesoInicialCebras(e) ;
}
problema pesoInicialLeonesE ( e: Ecosistema ) = result : Peso {
asegura result == pesoInicialLeones(e) ;
}
problema mejorPastizalE (e: Ecosistema, pO: Posicion) = result : Posicion {
requiere enRango(habitat(e), pO) ;
asegura result == elM ejorP astizal(e, [ p | p ← posicionesAlcanzables(e, p0), ¬hayLeon(e, p) ]) ;
}
problema moverCebrasE ( e: Ecosistema ) = result : Ecosistema {
requiere diaActual(e) == Lunes ;
asegura diaActual(result) == M artes ;
asegura lasConstantesN oCambian(result, e) ;
asegura habitat(result) == habitat(e) ;
asegura (∀p ← posicionesV alidas(habitat(result)))
mismos(cebras(result, p), cebrasEnN uevaP os(e, p)) ∧
hayLeon(result, p)) ↔ hayLeon(e, p) ∧
hayLeon(result, p)) → leon(result, p) == leon(e, p) ;
8
aux cebrasEnNuevaPos (e: Ecosistema, pos: Posicion) : [Cebra] =
concat[cebras(e, origen(p))|p ← posicionesV iejasY N uevas(e), destino(p) == pos] ;
aux posicionesViejasYNuevas (e: Ecosistema) : [(Posicion, Posicion)] =
[(p, nuevaP osicion(e, p))|p ← posicionesV alidas(habitat(e)), |cebras(e, p)| > 0] ;
aux nuevaPosicion (e: Ecosistema, pOrigen: Posicion) : Posicion =
elM ejorP astizal(e, [ p | p ← posicionesAlcanzables(e, pOrigen), ¬hayLeon(e, p) ]) ;
}
problema alimentarCebrasE ( e: Ecosistema ) = result : Ecosistema {
requiere diaActual(e) == M artes ;
asegura diaActual(result) == M iercoles ;
asegura lasConstantesN oCambian(result, e)) ;
asegura dimensiones(habitat(e)) == dimensiones(habitat(result)) ;
asegura (∀p ← posicionesV alidas(habitat(result)))
crecimientoSemanalP asto(habitat(e), p) == crecimientoSemanalP asto(habitat(result), p) ∧
cantM ateriaOrganica(habitat(e), p) == cantM ateriaOrganica(habitat(result), p) ∧
capacidadAbsorcionM ateriaOrganica(habitat(e), p) == capacidadAbsorcionM ateriaOrganica(habitat(result), p) ;
asegura (∀p ← posicionesV alidas(habitat(result)))hayLeon(e, p) ↔ hayLeon(result, p) ;
asegura (∀p ← posicionesV alidas(habitat(result)), hayLeon(result, p))leon(result, p) == leon(e, p) ;
asegura cebrasAlimentadas(e, result)) ;
aux cebrasAlimentadas (pe, e: Ecosistema) : Bool =
((∀p ← posicionesV alidas(habitat(e)), hayCebraEnP os(pe, p))
cebrasComenP asto(pe, e, p) ∧ cantP asto(habitat(e), p) == 0) ∧
((∀p ← posicionesV alidas(habitat(e)), ¬hayCebraEnP os(pe, p))
¬hayCebraEnP os(e, p) ∧ cantP asto(habitat(pe), p) == cantP asto(habitat(e), p)) ;
aux cebrasComenPasto (pe, e: Ecosistema, p: Posicion) : Bool =
|cebras(pe, p)| == |cebras(e, p)| ∧
(∀pc ← cebras(pe, p))(∃c ← cebras(e, p))
asto(habitat(pe),p)
(peso(c) == peso(pc) + cantP
cantCebrasEnP os(pe,p) ∧ edad(c) == edad(pc) ∧
cuenta(pc, cebras(pe, p)) == cuenta(c, cebras(e, p))) ;
}
problema reproducirE ( e: Ecosistema ) = result : Ecosistema {
requiere diaActual(e) == M iercoles ;
asegura diaActual(result) == Jueves ;
asegura lasConstantesN oCambian(result, e) ;
asegura dimensiones(habitat(e)) == dimensiones(habitat(result)) ;
asegura (∀p ← posicionesV alidas(habitat(result)))
(cantP asto(habitat(e), p) == cantP asto(habitat(result), p) ∧
crecimientoSemanalP asto(habitat(e), p) == crecimientoSemanalP asto(habitat(result), p) ∧
capacidadAbsorcionM ateriaOrganica(habitat(e), p) == capacidadAbsorcionM ateriaOrganica(habitat(result), p)) ;
asegura habitatConM asM ateriaOrganica(e, e) ;
asegura cantidadDeCebrasCorrecta :
|todasLasCebras(e)| + |todasLasCebrasEmbarazadas(e)| == |todasLasCebras(result)| ;
asegura (∀p ← posicionesV alidas(habitat(e)), ¬hayCebraEmbarazada(e, p))
mismos(cebras(e, p), cebras(result, p)) ;
asegura (∀p ← posicionesV alidas(habitat(e)), hayCebraEmbarazada(e, result))
aparecenLasCrias(e, result, p)) ∧ lasN oEmbarazadasConOtroP esoQuedan(e, result, p) ∧
lasN oEmbarazadasConP esoQuedanY AdelgazanLasEmbarazadas(e, result, p) ;
asegura cantidadDeLeonesCorrecta :
|todosLosLeones(e)| + |posLeonesEmbarazadosP uedenP arir(e)| − cantCriasExplotadas(e) −
|posLeonesEmbarazadosN oP uedenP arir(e)| == |todosLosLeones(result)| ;
asegura losLeonesNoEmbarazadosQuedanIgual :
(∀p ← posicionesV alidas(habitat(e)), hayLeon(e, p) ∧
¬estaEmbarazadoLeon(leon(e, p), pesoEmbarazoLeones(e)))hayLeon(result, p) ∧ leon(e, p) == leon(result, p) ;
asegura losEmbarazadosQueNoPudieronParirExplotan :
(∀p ← posicionesV alidas(habitat(e)), hayLeon(e, p) ∧
estaEmbarazadoLeon(leon(e, p), pesoEmbarazoLeones(e)) ∧ ¬puedeP arirL(e, p))¬hayLeon(result, p) ;
asegura losLeonesEmbarazadosQuePudieronParirTuvieronCria :
(∀p ← posLeonesEmbarazadosP uedenP arir(e))
hayLeonM asF laco(e, result, p) ∧
(((posCriaLeon(e, p) ∈
/ posConM asDeU naCria(e)) →
9
hayCriaLeon(e, result, posCriaLeon(e, p), p)) ∧
(posCriaLeon(e, p) ∈ posConM asDeU naCria(e) → ¬hayLeon(result, posCriaLeon(e, p)))) ;
asegura enElRestoDeLasPosicionesNoHayLeones :
(∀p ← posicionesV alidas(habitat(e)), ¬hayLeon(e, p) ∧ noEsP osibleLugarDeP arto(p, e))
¬hayLeon(result, p) ;
aux todasLasCebrasEmbarazadas (e: Ecosistema) : [Cebra] =
[ c | c ← todasLasCebras(e), estaEmbarazadaCebra(c, pesoEmbarazoCebras(e)) ] ;
aux noEsPosibleLugarDeParto (p: Posicion, e: Ecosistema) : =
p∈
/ [posCriaLeon(e, pos)|pos ← posLeonesEmbarazadosP uedenP arir(e)] ;
aux habitatConMasMateriaOrganica (pe, e: Ecosistema) : Bool = (∀p ← posicionesV alidas(habitat(e)))
cantM ateriaOrganica(habitat(e), p) == cantM ateriaOrganica(habitat(pe), p) +
materiaP orLeonesExplotados(pe, e, p) ;
aux hayCebraEmbarazada (e: Ecosistema, p: Posicion) : Bool =
(∃c ← cebras(e, p))estaEmbarazadaCebra(c, pesoEmbarazoCebras(e)) ;
aux hayLeonMasFlaco (pe, e: Ecosistema, p: Posicion) : Bool =
hayLeon(e, p) ∧ edad(leon(pe, p)) == edad(leon(e, p)) ∧
esperanzaDeV ida(leon(e, p)) == esperanzaDeV ida(leon(pe, p)) ∧
peso(leon(e, p)) == pesoEmbarazoLeones(e) − pesoInicialLeones(e) ;
aux materiaPorLeonesExplotados (pe, e: Ecosistema, p: Posicion) : Cantidad =
beta(p ∈ posLeonesEmbarazadosN oP uedenP arir(pe)) × peso(leon(pe, p)) +
beta(p ∈ posConM asDeU naCria(pe)) × pesosCriasExplotadas(pe, p) ;
aux beta (b : bool) : Z = if b then 1 else 0 ;
aux lasQueNoConflictuanQuedan (pe, e: Ecosistema, p: Posicion) : Bool =
mismos(noConf lictuan(pe, p), noConf lictuan(e, p)) ;
aux noConflictuan (e: Ecosistema, p : Posicion) : [Cebra] = [ c | c ← cebras(e, p), peso(c) 6= pesoInicialCebras(e) ∧
peso(c) 6= pesoEmbarazoCebra(e) − pesoInicialCebra(e) ] ;
aux aparecenLasCrias (pe, e: Ecosistema, p: Posicion) : Bool =
|[ c | c ← cebras(e, p), peso(c) == pesoInicialCebras(e) ∧ edad(c) == 1 ]| ==
cantCebrasEmbarazadas(pe, p) + |[ c | c ← cebras(pe, p), peso(c) == pesoInicialCebras(e) ∧ edad(c) == 1 ]| ;
aux lasNoEmbarazadasConOtroPesoQuedan (pe, e: Ecosistema, p: Posicion) : Bool =
(∀c ← cebras(pe, p), ¬estaEmbarazadaCebra(pe, pesoEmbarazoCebras(pe)) ∧
peso(c) 6= pesoEmbarazoCebras(e) − pesoInicialCebras(e))
c ∈ cebras(e, p) ∧ cuenta(c, cebras(e, p)) == cuenta(c, cebras(pe, p)) ;
aux lasNoEmbarazadasConPesoQuedanYAdelgazanLasEmbarazadas (pe, e: Ecosistema, p: Posicion) : Bool =
(∀pc ← cebrasEmbarazadas(pe, p) ++cebrasN oEmbarazadasConP esoF ijo(pe, p))
((∃c ← cebras(e, p))edad(c) == edad(pc) ∧ peso(c) == pesoEmbarazoCebras(e) − pesoInicialCebras(e) ∧
cuenta(c, cebras(e, p)) == cuenta(pc, cebras(pe, p))) ;
aux cebrasNoEmbarazadasConPesoFijo (e: Ecosistema, p: Posicion) : Z =
[ c | c ← cebras(e, p), ¬estaEmbarazadaCebra(e, pesoEmbarazoCebras(e)) ∧
peso(c) == pesoEmbarazoCebras(e) − pesoInicialCebras(e) ] ;
aux cebrasEmbarazadas (e: Ecosistema, p: Posicion) : [Cebra] =
[ c | c ← cebras(e, p), estaEmbarazadaCebra(e, pesoEmbarazoCebras(e)) ] ;
aux cantCebrasEmbarazadas (e: Ecosistema, p: Posicion) : Z = |cebrasEmbarazadas(e, p)| ;
aux hayCriaLeon (pe, e: Ecosistema, posHijo, posPadre: Posicion) : Bool =
hayLeon(e, posHijo) ∧ edad(leon(e, posHijo)) == 1 ∧ peso(leon(e, posHijo)) == pesoInicialLeones(e) ∧
esperanzaDeV ida(leon(e, posHijo)) == esperanzaDeV ida(leon(pe, posP adre)) + 1 ;
auxPcantCriasExplotadas (pe: Ecosistema) : Cantidad =
[ cuenta(p, posicionesT odasLasCrias(pe)) | p ← posConM asDeU naCria(pe) ] ;
aux pesosCriasExplotadas (pe: Ecosistema, p: Posicion) : Peso =
cuenta(p, posicionesT odasLasCrias(pe)) × pesoInicialLeones(pe) ;
aux posConMasDeUnaCria (pe: Ecosistema) : [Posicion] =
[ p | p ← posicionesT odasLasCrias(pe), cuenta(p, posicionesT odasLasCrias(pe)) > 1 ] ;
aux posicionesTodasLasCrias (pe: Ecosistema) : [Posicion] =
[ posCriaLeon(pe, p) | p ← posLeonesEmbarazadosP uedenP arir(pe) ] ;
aux posLeonesEmbarazadosPuedenParir (pe: Ecosistema) : [Posicion] =
[ p | p ← posicionesV alidas(habitat(pe)), hayLeon(pe, p) ∧
estaEmbarazadoLeon(leon(pe, p), pesoEmbarazoLeones(pe)) ∧ puedeP arirL(pe, p) ] ;
aux posLeonesEmbarazadosNoPuedenParir (pe: Ecosistema) : [Posicion] =
[ p | p ← posicionesV alidas(habitat(pe)), hayLeon(pe, p) ∧
estaEmbarazadoLeon(leon(pe, p), pesoEmbarazoLeones(pe)) ∧ ¬puedeP arirL(pe, p) ] ;
aux posCriaLeon (pe: Ecosistema, p: Posicion) : Posicion =
cab([ v | v ← posV ecinas(pe, p), estaLibre(pe, p) ]) ;
}
10
problema crecerAnimalesE ( e: Ecosistema ) = result : Ecosistema {
requiere diaActual(e) == Jueves ;
asegura diaActual(result) == V iernes ;
asegura lasConstantesN oCambian(result, e) ;
asegura dimension(habitat(result)) == dimension(habitat(e)) ;
asegura (∀p ← posicionesV alidas(habitat(result)))
crecimientoSemanalP asto(habitat(e), p) == crecimientoSemanalP asto(habitat(result), p) ∧
cantP asto(habitat(e), p) == cantP asto(habitat(result), p) ∧
capacidadAbsorcionM ateriaOrganica(habitat(e), p) == capacidadAbsorcionM ateriaOrganica(habitat(result), p) ;
asegura (∀p ← posicionesV alidas(habitat(result)))
cantM ateriaOrganica(habitat(result), p) == cantM ateriaOrganica(habitat(e), p) +
elP esoDelLeonSiEsQueM uere(e, p) +
elP esoDeLasCebrasQueM ueran(e, p) ;
asegura (∀p ← posicionesV alidas(habitat(result)))
|cebras(result, p)| == |cebras(e, p)| − cuantasCebrasM ueren(e, p) ∧
((∀c ← cebras(e, p), ¬muereCebra(e, c))
((∃cp ← cebras(result, p))peso(cp) == peso(c) ∧ edad(cp) == edad(c) + 1 ∧
cuenta(c, cebras(e, p)) == cuenta(cp, cebras(result, p)))) ;
asegura (∀p ← posicionesV alidas(habitat(result)))
hayLeon(result, p) ↔ hayLeon(e, p) ∧ ¬muereLeon(e, leon(e, p)) ;
asegura (∀p ← posicionesV alidas(habitat(result))), hayLeon(result, p))
peso(leon(result, p)) == peso(leon(e, p)) ∧
edad(leon(result, p)) == edad(leon(e, p)) + 1 ∧
esperanzaDeV ida(leon(result, p)) == esperanzaDeV ida(leon(e, p)) ;
aux elPesoDelLeonSiEsQueMuere (e: Ecosistema, p : Posicion) : Z =
if hayLeon(e, p) ∧ muereLeon(leon(e, p)) then peso(leon(e, p)) else 0 ;
auxPelPesoDeLasCebrasQueMueran (e: Ecosistema, p : Posicion) : Z =
[ peso(c) | c ← cebras(e, p), muereCebra(e, c) ] ;
}
11
problema posMejorPresaE (e: Ecosistema, pO: Posicion) = result : Posicion {
requiere enRango(habitat(e), pO) ;
requiere hayCebras(e) ;
asegura result ∈ posicionesV alidas(habitat(e)) ∧ hayCebraEnP os(e, result) ∧
esLaP osDeLaP resaM asCercana(e, pO, result) ;
}
problema crecerPastoE ( e: Ecosistema ) = result : Ecosistema {
requiere diaActual(e) == V iernes ;
asegura diaActual(result) == Domingo ;
asegura lasConstantesN oCambian(result, e) ;
asegura dimension(habitat(result)) == dimension(habitat(e)) ;
asegura (∀p ← posicionesV alidas(habitat(result)))
crecimientoSemanalP asto(habitat(e), p) == crecimientoSemanalP asto(habitat(result), p) ∧
capacidadAbsorcionM ateriaOrganica(habitat(e), p) == capacidadAbsorcionM ateriaOrganica(habitat(result), p) ;
asegura (∀p ← posicionesV alidas(habitat(result)))cantM ateriaOrganica(habitat(result), p) == 0 ;
asegura (∀p ← posicionesV alidas(habitat(result)))
cantP asto(habitat(result), p) == cantP asto(habitat(e), p) + incrementoP asto(habitat(e), p) ;
asegura (∀p ← posicionesV alidas(habitat(result)))mismos(cebras(result, p), cebras(e, p)) ;
asegura (∀p ← posicionesV alidas(habitat(result)))hayLeon(result, p) ↔ hayLeon(e, p) ;
asegura (∀p ← posicionesV alidas(habitat(result)), hayLeon(result, p))leon(result, p) == leon(e, p) ;
}
12
6.
Auxiliares
6.1.
aux
aux
aux
aux
aux
aux
aux
aux
aux
Tipos Básicos
min (e1, e2: Z) : Z = if e1 < e2 then e1 else e2 ;
primeras (ls: [(T1,T2)]) : [T1] = [prm(x)|x ← ls] ;
segundas (ls: [(T1,T2)]) : [T2] = [sgd(x)|x ← ls] ;
fila (p: Posicion) : Z = prm(p) ;
columna (p: Posicion) : Z = sgd(p) ;
origen (p: Posicion) : Z = prm(p) ;
destino (p: Posicion) : Z = sgd(p) ;
origen (posOyD: (Posicion, Posicion)) : Posicion = prm(posOyD) ;
destino (posOyD: (Posicion, Posicion)) : Posicion = sgd(posOyD) ;
6.2.
Tipo Cebra
aux pesoDspDComer (c:Cebra, cantPasto:Cantidad) : Peso = peso(c) + cantP asto ;
aux estaEmbarazadaCebra (c: Cebra, p: Peso) : Bool = peso(c) ≥ p ;
peso(c)
< t;
aux estaDesnutridaCebra (c: Cebra, t: Tasa) : Bool = edad(c)
6.3.
Tipo Leon
aux estaEmbarazadoLeon (l: Leon, p: Peso) : Bool = peso(l) ≥ p ;
peso(l)
aux estaDesnutridoLeon (l: Leon, t: Tasa) : Bool = edad(l)
< t;
6.4.
Tipo MundoToroidal
aux enRango (m: MundoToroidal, p: Posicion) : Bool =
0 ≤ prm(p) < prm(dimensiones(m)) ∧ 0 ≤ sgd(p) < sgd(dimensiones(m)) ;
aux posicionesValidas (m: MundoToroidal) : [Posicion] =
[ (i, j) | i ← [0..prm(dimensiones(m))), j ← [0..sgd(dimensiones(m))) ] ;
aux sonPosicionesValidas (m: MundoToroidal, ls: [(T,Posicion)]) : Bool = (∀l ← ls)enRango(m, sgd(l)) ;
aux distanciaMT (m: MundoToroidal, d: Posicion, h: Posicion) : Distancia =
distanciaF ilas(m, f ila(d), f ila(h)) + distanciaColumnas(m, columna(d), columna(h)) ;
aux distanciaFilas (m: MundoToroidal, fd, fh: Z) : Distancia =
min((f d − f h) %prm(dimensiones(m)) , (f h − f d) %prm(dimensiones(m))) ;
aux distanciaColumnas (m: MundoToroidal, cd, ch: Z) : Distancia =
min((cd − ch) %sgd(dimensiones(m)) , (ch − cd) %sgd(dimensiones(m))) ;
aux posVecinas (m: MundoToriodal, p: Posicion) : [Posicion] = [norte(m, p)] ++[este(m, p)] ++[sur(m, p)] ++[oeste(m, p)] ;
aux norte (m: MundoToriodal, p: Posicion) : Posicion = ((prm(p) − 1) %prm(dimensiones(m)), sgd(p)) ;
aux sur (m: MundoToriodal, p: Posicion) : Posicion = ((prm(p) + 1) %prm(dimensiones(m)), sgd(p)) ;
aux este (m: MundoToriodal, p: Posicion) : Posicion = (prm(p), (sgd(p) + 1) %sgd(dimensiones(m))) ;
aux oeste (m: MundoToriodal, p: Posicion) : Posicion = (prm(p), (sgd(p) − 1) %sgd(dimensiones(m))) ;
aux incrementoPasto (m: MundoToroidal, p: Posicion) : Cantidad =
crecimientoSemanalP asto(m, pos) + cantM ateriaOrganica(m, pos) × capacidadAbsorcionM ateriaOrganica(m, pos) ;
aux minCantPasto (m: MundoToroidal) : Cantidad =
cab([cantP asto(m, p)|p ← posicionesV alidas(p), esLaQueT ieneM enosP asto(m, p)]) ;
aux esLaQueTieneMenosPasto (m: MundoToroidal, pos: Posicion) : Bool =
(∀p ← posicionesV alidas(m))cantP asto(m, pos) ≤ cantP asto(m, p) ;
6.5.
Tipo Ecosistema
aux cantCebrasEnPos (e: Ecosistema, p: Posicion) : Z = |cebras(e, p)| ;
aux hayCebraEnPos (e: Ecosistema, p: Posicion) : Bool = cantCebrasEnP os(e, p) > 0 ;
aux hoyEs (e: Ecosistema, d: Dia) : Bool = (diaActual(e) == d) ;
aux noHayCebrasEmbarazadas (e: Ecosistema) : Bool =
(∀c ← todasLasCebras(e))¬estaEmbarazadaC(c, pesoEmbarazoCebras(e)) ;
aux noHayLeonesEmbarazados (e: Ecosistema) : Bool =
(∀l ← todosLosLeones(e))¬estaEmbarazadoLeon(l, pesoEmbarazoLeones(e)) ;
aux noHayDesnutridos (e: Ecosistema) : Bool = noHayCebrasDesnutridas(e) ∧ noHayLeonesDesnutridos(e) ;
aux noHayCebrasDesnutridas (e: Ecosistema) : Bool =
(∀c ← todasLasCebras(e))¬estaDesnutridaCebra(c, tasaDesnutricionCebras(e)) ;
aux noHayLeonesDesnutridos (e: Ecosistema) : Bool =
(∀l ← todosLosLeones(e))¬estaDesnutridoLeon(l, tasaDesnutricionLeones(e)) ;
13
aux noHayMateriaOrganica (e: Ecosistema) : Bool =
(∀p ← posicionesV alidas(habitat(e)))cantM ateriaOrganica(habitat(e), p) == 0 ;
aux todasLasCebras (e: Ecosistema) : [Cebra] = concat([ cebras(e, p) | p ← posicionesV alidas(habitat(e)) ]) ;
aux todosLosLeones (e: Ecosistema) : [Leon] = [ leon(e, p) | p ← posicionesV alidas(p), hayLeon(e, p) ] ;
aux hayCebras (e: Ecosistema) : Bool = (∃p ← posicionesV alidas(habitat(e)))hayCebraEnP os(e, p) ;
aux puedeParirL (e: Ecosistema, p: Posicion) : Bool = (∃v ← posV ecinas(habitat(e), p))estaLibre(e, p) ;
aux estaLibre (e:Ecosistema, p: Posicion) : Bool = |cebras(e, p)| == 0 ∧ ¬hayLeon(e, p) ;
aux esLaPosDeLaPresaMasCercana (e: Ecosistema, pLeon, pPresa: Posicion) : Bool =
(∀p ← posicionesV alidas(habitat(e)), hayCebraEnP os(e, p))
distanciaM T (habitat(e), pP resa, pLeon) ≤ distanciaM T (habitat(e), p, pLeon) ;
aux lasConstantesNoCambian (e, pe: Ecosistema) : Bool =
tasaDesnutricionCebras(e) == tasaDesnutricionCebras(pe) ∧
tasaDesnutricionLeones(e) == tasaDesnutricionLeones(pe) ∧
pesoEmbarazoCebras(e) == pesoEmbarazoCebras(pe) ∧
pesoEmbarazoLeones(e) == pesoEmbarazoLeones(pe) ∧
pesoInicialCebras(e) == pesoInicialCebras(pe) ∧
pesoInicialLeones(e) == pesoInicialLeones(pe) ;
aux posicionesAlcanzables (e: Ecosistema, pos: Posicion) : [Posicion] = posV ecinas(habitat(e), pos) ++[pos] ;
aux muereLeon (e: Ecosistema, l: Leon) : Bool = muereP orV iejo(l) ∨ muereDesnutridoL(e, l) ;
aux muerePorViejo (l: Leon) : Bool = edad(l) + 1 > esperanzaDeV ida(l) ;
peso(l)
< tasaDesnutricionLeones(e)) ;
aux muereDesnutridoL (e: Ecosistema, l: Leon) : Bool = ( edad(l)+1
peso(c)
< tasaDesnutricionCebras(e)) ;
aux muereCebra (e: Ecosistema, c: Cebra) : Bool = ( edad(c)+1
aux cuantasCebrasMueren (e: Ecosistema, p: Posicion) : Z = |[ c | c ← cebras(e, p), muereCebra(e, c) ]| ;
aux elMejorPastizal (e: Ecosistema, ps : [Posicion]) : Posicion =
[ p | p ← ps, cantP asto(e, p) == maxCantP asto(e, ps) ]0 ;
aux maxCantPasto (e: Ecosistema, ps : [Posicion]) : Cantidad = max([ cantP asto(e, p) | p ← ps ]) ;
aux edadesC (cs : [Cebra]) : [Z] = [ edad(c) | c ← cs ] ;
14