Diferencia entre revisiones de «AED2 resumen 2C-17»

De Cuba-Wiki
Etiquetas: mobile edit mobile web edit
 
(No se muestran 22 ediciones intermedias de 3 usuarios)
Línea 3: Línea 3:
=== a ===
=== a ===


duplicar: secu(α)→secu(α)
duplicar: secu(α) → secu(α)


duplicar(s)≡if vacía?(s) then ⟨⟩ else prim(s)•prim(s)•duplicar(fin(s)) fi
duplicar(s) ≡ if vacía?(s) then ⟨⟩ else prim(s) • prim(s) • duplicar(fin(s)) fi


=== b ===
=== b ===
Línea 11: Línea 11:
•≤•: secu(α) x secu(α) → bool
•≤•: secu(α) x secu(α) → bool


s &le; t &equiv; if &not;(vacía?(s) &or; vacía?(t)) then prim(s) < prim(t) &or; (prim(s)=prim(t) &and; fin(s)&le;fin(t)) else vacía?(s) fi
s &le; t &equiv; if &not;(vacía?(s) &or; vacía?(t)) then prim(s) < prim(t) &or; (prim(s) = prim(t) &and; fin(s) &le; fin(t)) else vacía?(s) fi


=== c ===
=== c ===
Línea 151: Línea 151:
ntn: conj(secu(&alpha;)) x secu(&alpha;) &rarr;  conj(secu(&alpha;))
ntn: conj(secu(&alpha;)) x secu(&alpha;) &rarr;  conj(secu(&alpha;))


blablabla
[ToDo]
 
Necesito:
 
* Ver si CADA secuencia del conjunto de entrada es o no subsecuencia de la secuencia de entrada (2do param)
*  &rarr; Definir función auxiliar '''''esSubsecuencia(a &bull; s, b &bull; t)''''', <small>a,b:&alpha;, s,t:secu(&alpha;)</small>
*  &rarr; Definir '''''ntn(Ag(a &bull; s, w), b &bull; t)'''''<small>, w: conj(secu(&alpha;))</small>
 
* Ver si CADA secuencia del conjunto DE SALIDA es o no subsecuencia de alguna otra secuencia del conjunto de salida
*  &rarr; Puedo usar la misma función auxiliar esSubsecuencia()


== Ejercicio 5 ==
== Ejercicio 5 ==
Línea 162: Línea 171:


=== b ===
=== b ===
    // Defino auxiliar que cuente cantNodos en una secuencia de arboles ternarios:
   
    cantNodos: secu( at( &alpha; ) ) -> nat
   
    cantNodos( t · <> ) &equiv; if t &ne; nil then 1 else 0
    cantNodos( t · s )  &equiv; if t &ne; nil then 1 + cantNodos(s)
                                    else cantNodos(s)


blablabla
    acotado?: at(&alpha;) x nat -> bool
   
    acotado?(nil, k) &equiv; true
   
    // Recibo el arbol ternario como sus partes separadas: (izq,medio,der,raiz)
   
    acotado?(tern(i,m,d,r), k) &equiv; if cantNodos(i · m · d · <>) &le; k then
                                    acotado?(i) &and; acotado?(m) &and; acotado?(d)
                                else
                                    false


== Ejercicio 6 ==
== Ejercicio 6 ==
Línea 169: Línea 194:
=== a ===
=== a ===


altura: rosetree(&alpha;) &rarr; nat
    altura: rosetree(&alpha;) &rarr; nat
 
   
altura(rose(r,&lang;&rang;)) &equiv; 1
    altura(rose(r, &lang;&rang;)) &equiv; 1
 
   
altura(rose(r,e &bull; s)) &equiv; 1 + altura(masAlta(r,e &bull; s))
    altura(rose(r, e &bull; s)) &equiv; 1 + altura(masAlta(r, e &bull; s))
 
   
masAlta: &alpha; x secu(rosetree(&alpha;)) &rarr; rosetree(&alpha;)
    masAlta: &alpha; x secu(rosetree(&alpha;)) &rarr; rosetree(&alpha;)
 
   
masAlta(a,s) &equiv; if vacía?(s) then rose(a,&lang;&rang;) else if altura(prim(s)) > altura(masAlta(a,fin(s))) then prim(s) else masAlta(a,fin(s)) fi fi
    masAlta(a, s) &equiv; if vacía?(s) then
                        rose(a,&lang;&rang;)
                    else if altura(prim(s)) > altura(masAlta(a, fin(s))) then
                            prim(s)
                        else
                            masAlta(a, fin(s))
                        fi
                    fi


=== b ===
=== b ===


cantHojas: rosetree(&alpha;) &rarr; nat
    cantHojas: rosetree(&alpha;) &rarr; nat
 
   
cantHojas(r) &equiv; if esHoja?(r) then 1 else sumarHojas(hijos(r)) fi
    cantHojas(r) &equiv; if esHoja?(r) then  
 
                      1
esHoja?: rosetree(&alpha;) &rarr; bool
                  else
 
                      sumarHojas(hijos(r))
esHoja?(r) &equiv; vacía?(hijos(r))
                  fi
 
   
sumarHojas: secu(rosetree(&alpha;)) &rarr; nat
   
 
    esHoja?: rosetree(&alpha;) &rarr; bool
sumarHojas(s) &equiv; if vacía?(s) then 0 else cantHojas(prim(s)) + sumarHojas(fin(s)) fi
   
    esHoja?(r) &equiv; vacía?(hijos(r))
   
   
    sumarHojas: secu( rosetree(&alpha;) ) &rarr; nat
   
    sumarHojas(s) &equiv; if vacía?(s) then  
                        0
                    else
                        cantHojas(prim(s)) + sumarHojas(fin(s))
                    fi


=== c ===
=== c ===


podar: rosetree(&alpha;) a &rarr; rosetree(&alpha;) {&not;esHoja?(a)}
    podar: rosetree(&alpha;) a &rarr; rosetree(&alpha;) {&not;esHoja?(a)}
 
   
podar(r) &equiv; rose(raíz(r),podadora(hijos(r)))
    podar(r) &equiv; rose(raíz(r), podadora(hijos(r)))
 
   
podadora: secu(rosetree(&alpha;)) &rarr; secu(rosetree(&alpha;))
   
 
    podadora: secu(rosetree(&alpha;)) &rarr; secu(rosetree(&alpha;))
podadora(s) &equiv; if vacía?(s) then s else if esHoja?(prim(s)) then podadora(fin(s)) else podar(prim(s)) &bull; podadora(fin(s)) fi fi
   
    podadora(s) &equiv; if vacía?(s) then
                      s
                  else
                      if esHoja?(prim(s)) then
                          podadora(fin(s))
                      else
                          podar(prim(s)) &bull; podadora(fin(s))
                      fi
                  fi


=== d ===
=== d ===


obtenerRamas: rosetree(&alpha;) &rarr; secu(secu((&alpha;))
    obtenerRamas: rosetree(&alpha;) &rarr; secu(secu((&alpha;))
 
   
obtenerRamas(r) &equiv; if esHoja?(r) then (raíz(r) &bull; &lang;&rang;) &bull; &lang;&rang; else if long(hijos(r)) = 1 then insertarTodos(raíz(r),obtenerRamas(prim(hijos(r)))) else insertarTodos(raíz(r),obtenerRamas(prim(hijos(r)))) & obtenerRamas(rose(raíz(r),fin(hijos(r)))) fi fi
    obtenerRamas(r) &equiv; if esHoja?(r) then
 
                          (raíz(r) &bull; &lang;&rang;) &bull;&lang;&rang;  
insertarTodos: &alpha; x secu(secu(&alpha;)) &rarr; secu(secu(&alpha;))
                      else
 
                          if long(hijos(r)) = 1 then
insertarTodos(a,s) &equiv; if vacía(s) then &lang;&rang; else (a &bull; prim(s)) &bull; insertarTodos(a,fin(s)) fi
                              insertarTodos(raíz(r), obtenerRamas(prim(hijos(r))))
                          else
                              insertarTodos(raíz(r),obtenerRamas(prim(hijos(r)))) & obtenerRamas(rose(raíz(r),fin(hijos(r))))
                          fi
                      fi
   
    insertarTodos: &alpha; x secu(secu(&alpha;)) &rarr; secu(secu(&alpha;))
   
    insertarTodos(a,s) &equiv; if vacía(s) then
                            &lang;&rang;
                        else
                            (a &bull; prim(s)) &bull; insertarTodos(a,fin(s))
                        fi


=== e ===  
=== e ===  

Revisión actual - 01:34 19 sep 2019

Ejercicio 1

a

duplicar: secu(α) → secu(α)

duplicar(s) ≡ if vacía?(s) then ⟨⟩ else prim(s) • prim(s) • duplicar(fin(s)) fi

b

•≤•: secu(α) x secu(α) → bool

s ≤ t ≡ if ¬(vacía?(s) ∨ vacía?(t)) then prim(s) < prim(t) ∨ (prim(s) = prim(t) ∧ fin(s) ≤ fin(t)) else vacía?(s) fi

c

reverso: secu(α)→secu(α)

reverso(s) ≡ if vacía?(s) then s else reverso(fin(s)) º prim(s) fi

d

capicúa: secu(α)→bool

capicúa(s) ≡ s = reverso(s)

e

esPrefijo?: secu(α) x secu(α) → bool

esPrefijo?(⟨⟩,t) ≡ true

esPrefijo?(e • s,t) ≡ if vacía?(t) then false else e = prim(t) ∧ esPrefijo?(s,fin(t)) fi

f

buscar: secu(α) x secu(α) → nat

buscar(⟨⟩,t) ≡ 0

buscar(s, t) ≡ if esPrefijo?(s, t) then 0 else 1 + buscar(s, fin(t)) fi

g

estaOrdenada?: secu(α) → bool

estaOrdenada?(⟨⟩) ≡ true

estaOrdenada?(e • s) ≡ if vacía?(s) then true else e ≤ prim(s) ∧ estaOrdenada?(s) fi

h

InsertarOrdenada, que dados una secuencia so (que debe estar ordenada) y un elemento e (de género α) inserta e en so de manera ordenada.

insertarOrdenada: secu(α) so x α → secu(α) {estaOrdenada?(so)}

insertarOrdenada(⟨⟩, e) ≡ e • ⟨⟩

insertarOrdenada(a • s, e) ≡ if e ≤ a then e • a • s else a • insertarOrdenada(s, e) fi

i

cantidadApariciones: secu(α) x α → nat

cantidadApariciones(⟨⟩,a) ≡ 0

cantidadApariciones(e • s,a) ≡ if e = a then 1 + cantidadApariciones(s,a) else cantidadApariciones(s,a) fi

j

aux(s,s,t): secu(α) x secu(α) x secu(α) → bool

aux(⟨⟩,s,t) ≡ true

aux(e • u,s,t) ≡ cantidadApariciones(s,e) = cantidadApariciones(t,e) ∧ aux(u,s,t)

esPermutación?: secu(α) x secu(α) → bool

esPermutación?(s,t) ≡ if long(s) = long(t) then aux(s,s,t) else false

k

combinar: secu(α) a x secu(α) b → secu(α) {estaOrdenada?(a) ∧ estaOrdenada?(b)}

combinar(s,t) ≡ if vacía(s) then t else combinar(fin(s),insertarOrdenada(t,prim(s)) fi

Ejercicio 2

a

#hojas: ab(α) → nat
#hojas(nil) ≡ 0
#hojas(bin(a,e,b)) ≡ if esHoja?(bin(a,e,b)) then 1 else #hojas(a) + #hojas(b) fi

b

degeneradoAIzquierda: ab(α) → bool

degeneradoAIzquierda(a) ≡ nil?(a) ∨L if esHoja?(a) then true else nil?(der(a)) ∧ degeneradoAIzquierda(izq(a)) fi

c

zigZag: ab(α) → bool

zigZag(a) ≡ nil?(a) ∨L esHoja?(a) ∨L if nil?(izq(a)) then nil?(der(der(a))) ∧ zigZag(der(a)) else if nil?(izq(a)) then nil?(izq(izq(a))) ∧ zigZag(izq(a)) else false fi fi

d

ultimoNivelCompleto: ab(α) → nat

ultimoNivelCompleto(nil) ≡ 0

ultimoNivelCompleto(bin(a,e,b)) ≡ 1 + min(ultimoNivelCompleto(a),ultimoNivelCompleto(b))

e

espejo: ab(α) → ab(α)

espejo(a) ≡ if nil?(a) then a else bin(espejo(der(a)),raiz(a),espejo(izq(a)) fi

f

esSimétrico?: ab((α) → bool

esSimétrico?(a) ≡ a = espejo(a)

Ejercicio 3

a

agregarTodos: α x conj(conj(α)) → conj(conj(α))

agregarTodos(n,c) ≡ if ∅?(c) then Ag(Ag(n,∅),∅) else Ag(Ag(n,dameUno(c)),agregarTodos(n,sinUno(c))) fi

partesDe: conj(nat) → conj(conj(nat))

partesDe(c) ≡ if ∅?(c) then c else agregarTodos(dameUno(c),partesDe(sinUno(c))) ∪ partesDe(sinUno(c)) fi

b

combinacionesDeK: conj(α) x nat → conj(conj(α))

combinacionesDeK(∅, k) ≡ ∅

combinacionesDeK(Ag(e,c), k) ≡ if k = 0 ∨ #(Ag(e,c)) < k then ∅ else agregarTodos(e,combinacionesDeK(c,k-1)) ∪ combinacionesDeK(c,k) fi

Ejercicio 4

ntn: conj(secu(α)) x secu(α) → conj(secu(α))

[ToDo]

Necesito:

  • Ver si CADA secuencia del conjunto de entrada es o no subsecuencia de la secuencia de entrada (2do param)
  • → Definir función auxiliar esSubsecuencia(a • s, b • t), a,b:α, s,t:secu(α)
  • → Definir ntn(Ag(a • s, w), b • t), w: conj(secu(α))
  • Ver si CADA secuencia del conjunto DE SALIDA es o no subsecuencia de alguna otra secuencia del conjunto de salida
  • → Puedo usar la misma función auxiliar esSubsecuencia()

Ejercicio 5

a

nivelNormal?: at(α) x nat k → bool { ¬ k = 0 }

nivelNormal?(a,k) ≡ nil?(a) ∨L if k = 1 then ¬(nil?(izq(a)) ∨ nil?(med(a)) ∨ nil?(der(a))) else nivelNormal?(izq(a),k-1) ∧ nivelNormal?(med(a),k-1) ∧ nivelNormal?(der(a),k-1) fi

b

   // Defino auxiliar que cuente cantNodos en una secuencia de arboles ternarios: 
   
   cantNodos: secu( at( α ) ) -> nat
   
   cantNodos( t · <> ) ≡ if t ≠ nil then 1 else 0
   cantNodos( t · s )  ≡ if t ≠ nil then 1 + cantNodos(s)
                                    else cantNodos(s)
   acotado?: at(α) x nat -> bool
   
   acotado?(nil, k) ≡ true
   
   // Recibo el arbol ternario como sus partes separadas: (izq,medio,der,raiz)
   
   acotado?(tern(i,m,d,r), k) ≡ if cantNodos(i · m · d · <>) ≤ k then
                                    acotado?(i) ∧ acotado?(m) ∧ acotado?(d)
                                else
                                    false

Ejercicio 6

a

   altura: rosetree(α) → nat
   
   altura(rose(r, ⟨⟩)) ≡ 1
   
   altura(rose(r, e • s)) ≡ 1 + altura(masAlta(r, e • s))
   
   masAlta: α x secu(rosetree(α)) → rosetree(α)
   
   masAlta(a, s) ≡ if vacía?(s) then
                       rose(a,⟨⟩)
                   else if altura(prim(s)) > altura(masAlta(a, fin(s))) then
                           prim(s)
                       else
                           masAlta(a, fin(s))
                       fi
                   fi

b

   cantHojas: rosetree(α) → nat
   
   cantHojas(r) ≡ if esHoja?(r) then 
                      1
                  else
                      sumarHojas(hijos(r))
                  fi
   
   
   esHoja?: rosetree(α) → bool
   
   esHoja?(r) ≡ vacía?(hijos(r))
   
   
   sumarHojas: secu( rosetree(α) ) → nat
   
   sumarHojas(s) ≡ if vacía?(s) then 
                       0
                   else
                       cantHojas(prim(s)) + sumarHojas(fin(s))
                   fi

c

   podar: rosetree(α) a → rosetree(α) {¬esHoja?(a)}
   
   podar(r) ≡ rose(raíz(r), podadora(hijos(r)))
   
   
   podadora: secu(rosetree(α)) → secu(rosetree(α))
   
   podadora(s) ≡ if vacía?(s) then
                     s
                 else
                     if esHoja?(prim(s)) then
                         podadora(fin(s))
                     else
                         podar(prim(s)) • podadora(fin(s))
                     fi
                 fi

d

   obtenerRamas: rosetree(α) → secu(secu((α))
   
   obtenerRamas(r) ≡ if esHoja?(r) then
                         (raíz(r) • ⟨⟩) •⟨⟩ 
                     else
                         if long(hijos(r)) = 1 then
                             insertarTodos(raíz(r), obtenerRamas(prim(hijos(r))))
                         else
                             insertarTodos(raíz(r),obtenerRamas(prim(hijos(r)))) & obtenerRamas(rose(raíz(r),fin(hijos(r))))
                         fi
                     fi
   
   insertarTodos: α x secu(secu(α)) → secu(secu(α))
   
   insertarTodos(a,s) ≡ if vacía(s) then
                           ⟨⟩
                        else
                            (a • prim(s)) • insertarTodos(a,fin(s))
                        fi

e

devolverNivel: nat n x rosetree(α) → secu(α) {¬ n = 0}

devolverNivel(n,r) ≡ agarrador(n,obtenerRamas(r))

agarrador: nat n x secu(secu(α)) → secu(α) {¬ n = 0}

agarrador(n,s) ≡ if vacía(s) then ⟨⟩ else if long(prim(s)) ≥ n then obtener(n,prim(s)) • agarrador(n,fin(s)) else agarrador(n,fin(s)) fi fi

obtener: nat n x secu(&alpha) s → α {(¬ n = 0) ∧ long(s) ≥ n}

obtener(n,s) ≡ if n = 1 then prim(s) else obtener(n-1,fin(s)) fi

f

masLargasConRepetidos: rosetree(α) → conj(secu(α))

masLargasConRepetidos(r) ≡ soloConRepetidos(soloUnTam(altura(r),obtenerRamas(r)))

tieneRepetido: secu(α) → bool

tieneRepetido(s) ≡ (¬ vacía(s)) ∧L (esta?(prim(s),fin(s)) ∨ tieneRepetido(fin(s)))

soloConRepetidos: secu(secu(α)) → conj(secu(α))

soloConRepetidos(s) ≡ if vacía(s) then ∅ else if tieneRepetido(prim(s)) then Ag(prim(s),soloConRepetidos(fin(s))) else soloConRepetidos(fin(s)) fi fi

soloUnTam: nat n x secu(secu(α)) → secu(secu(α)) {¬ n = 0}

soloUnTam(n,s) ≡ if vacía?(s) then ⟨⟩ else if long(s) = n then prim(s) • soloUnTam(n,fin(s)) else soloUnTam(n,fin(s)) fi fi

Ejercicio 7

evaluar(cte(a),n) ≡ a

evaluar(x,n) ≡ n

evaluar(a + b, n) ≡ evaluar(a,n) + evaluar(b,n)

evaluar(a . b, n) ≡ evaluar(a,n) . evaluar(b,n)

esRaíz: polinomio x nat → bool

esRaíz(a,n) ≡ 0 = evaluar(a,n)

Ejercicio 8

trayectoria(ubicar(c)) ≡ c • ⟨⟩

trayectoria(arriba(r)) ≡ ⟨π1(posiciónActual(r)),π2(posiciónActual(r)) + 1⟩ • trayectoria(r)

trayectoria(abajo(r)) ≡ ⟨π1(posiciónActual(r)),π2(posiciónActual(r)) - 1⟩ • trayectoria(r)

trayectoria(derecha(r)) ≡ ⟨π1(posiciónActual(r)) + 1,π2(posiciónActual(r))⟩ • trayectoria(r)

trayectoria(izquierda(r)) ≡ ⟨π1(posiciónActual(r)) - 1,π2(posiciónActual(r))⟩ • trayectoria(r)

posiciónActual(r) ≡ prim(trayectoria(r))

cuántasVecesPasó(c,r) ≡ cantidadApariciones(Trayectoria(r),c)

másALaDerecha(r) ≡ maxX(trayectoria(r))

maxX: secu(coordenada) s → coordenada {¬ vacía?(s)}

maxX(e • s) ≡if vacía?(s) then π1(e) else max(π1(e),π1(maxX(s)) fi

Ejercicio 9

TAD Electroimán

Igualdad observacional

(∀ i1:electroimán)((∀ i2:electroimán)(i1 =obs i2 ⇔ ((cinta(i1) = cinta(i2) ∧ imánPrendido?(i1) = imánPrendido?(i2)) ∧L (imánPrendido?(i1) ⇒L (imánCargado?(i1) = imánCargado?(i2))))))

Genero electroimán

Usa Bool, Nat, Cinta

Exporta Genero, Generadores, Observadores básicos, Otras operaciones

Axiomas

cinta(arrancar(c)) ≡ c

cinta(prender(e)) ≡ if celdaActualOcupada?(cinta(e)) then sacarElem(cinta(e)) else cinta(e) fi

cinta(apagar(e)) ≡ if imánCargado?(e) then ponerElem(cinta(e)) else cinta(e) fi

cinta(←(e)) ≡ ←(cinta(e))

cinta(→(e)) ≡ →(cinta(e))

imánPrendido?(arrancar(c)) ≡ false

imánPrendido?(prender(e)) ≡ true

imánPrendido?(apagar(e)) ≡ false

imánPrendido?(→(e)) ≡ imánPrendido?(e)

imánPrendido?(←(e)) ≡ imánPrendido?(e)

imánCargado?(prender(e)) ≡ celdaActualOcupada?(e)

imánCargado?(→(e)) ≡ imánCargado?(e) ∨ celdaActualOcupada?(→(e))

imánCargado?(←(e)) ≡ imánCargado?(e) ∨ celdaActualOcupada?(←(e))

celdaActualOcupada?(e) ≡ celdaActualOcupada?(cinta(e))

#giros←(arrancar(c) ≡ 0
#giros←(prender(e) ≡  #giros←(e)
#giros←(apagar(e) ≡  #giros←(e)
#giros←(→(e) ≡  #giros←(e)
#giros←(←(e) ≡ 1 + #giros←(e)
#giros→(arrancar(c) ≡ 0
#giros→(prender(e) ≡  #giros→(e)
#giros→(apagar(e) ≡  #giros→(e)
#giros→(→(e) ≡ 1 + #giros→(e)
#giros→(←(e) ≡ #giros→(e)

Fin TAD

TAD Cinta

Igualdad observacional

(∀ c1:cinta)((∀ c2:cinta)(c1 =obs c2 ⇔ (#celdas(c1) = #celdas(c2) ∧L (celdaActual(c1) = celdaActual(c2) ∧ #giros←(c1) = #giros←(c2) ∧ #giros→(c1) = #giros→(c2) ∧ (∀i:nat)(i<#celdas(c1) ⇒(celdaOcupada?(i,c1) = celdaOcupada?(i,c2)))))))

Genero cinta

Usa Bool, Nat

Exporta Genero, Generadores, Observadores básicos, Otras operaciones

Otras operaciones

cuentaOcupados: nat x cinta → nat

Axiomas

#celdas(arrancar(n)) ≡ n
#celdas(ponerElem(c)) ≡ #celdas(c)
#celdas(sacarElem(c)) ≡ #celdas(c)
#celdas(←(c)) ≡ #celdas(c)
#celdas(→(c)) ≡ #celdas(c)
#giros←(arrancar(n)) ≡ 0
#giros←(ponerElem(c)) ≡ #giros←(c)
#giros←(sacarElem(c)) ≡ #giros←(c)
#giros←(←(c)) ≡ 1 + #giros←(c)
#giros←(→(c)) ≡ #giros←(c)
#giros→(arrancar(n)) ≡ 0
#giros→(ponerElem(c)) ≡ #giros→(c)
#giros→(sacarElem(c)) ≡ #giros→(c)
#giros→(←(c)) ≡ #giros→(c)
#giros→(→(c)) ≡ 1 + #giros→(c)

celdaActual(arrancar(n)) ≡ 0

celdaActual(ponerElem(c)) ≡ celdaActual(c)

celdaActual(sacarElem(c)) ≡ celdaActual(c)

celdaActual(←(c)) ≡ if celdaActual(c) = 0 then #celdas(c) - 1 else celdaActual(c) - 1 fi

celdaActual(→(c)) ≡ if celdaActual(c) = #celdas(c) - 1 then 0 else celdaActual(c) + 1 fi

celdaOcupada?(n,arrancar(a)) ≡ false

celdaOcupada?(n,ponerElem(c)) ≡ if n = celdaActual(c) then true else celdaOcupada?(n,c) fi

celdaOcupada?(n,sacarElem(c)) ≡ if n = celdaActual(c) then false else celdaOcupada?(n,c) fi

celdaOcupada?(n,←(c)) ≡ celdaOcupada?(n,c)

celdaOcupada?(n,→(c)) ≡ celdaOcupada?(n,c)

celdaActualOcupada?(c) ≡ celdaOcupada?(celdaActual(c),c)

#elem(c) ≡ cuentaOcupados(0,c)

cuentaOcupados(n,c) ≡ if n < #celdas(c) then if celdaOcupada?(n,c) then 1 + cuentaOcupados(n+1,c) else cuentaOcupados(n+1,c) fi else 0 fi

Fin TAD

Ejercicio 10

Ejercicio 11

Ejercicio 12

TAD Producto es String

TAD Stock

Igualdad observacional

(∀ s1:stock)((∀ s2:stock)(s1 =obs s2 ⇔ ((∀ p:producto)(estaRegistrado(p,s1) ⇔ estaRegistrado(p,s2)) ∧L (∀ p1:producto)((∀ p2:producto)((estaRegistrado(p1,s1) ∧ estaRegistrado(p2,s1)) ⇒L (mínimo(p1,s1) = mínimo(p1,s2) ∧ compras(p1,s1) = compras(p1,s2) ∧ ventas(p1,s1) = ventas(p1,s2) ∧ esSus(p1,p2,s1) = esSus(p1,p2,s2)))))))

Genero stock

Usa Bool, Nat, Conj(α)

Exporta Genero, Generadores, Observadores básicos, stocksBajos

Observadores básicos

estaRegistrado: producto x stock → bool

esSus: producto a x producto b x stock s → bool {estaRegistrado(a,s) ∧ estaRegistrado(b,s)}

compras: producto p x stock s → nat {estaRegistrado(p,s)}

ventas: producto p x stock s → nat {estaRegistrado(p,s)}

mínimo: producto p x stock s → nat {estaRegistrado(p,s)}

Generadores

crearStock: . → stock

registrarProducto: producto p x nat x stock s → stock {¬ estaRegistrado(p,s)}

comprar: nat x producto p x stock s → stock {estaRegistrado(p,s)}

vender: nat n x producto p x stock s → stock {estaRegistrado(p,s) ∧L compras(p,s) ≥ n}

infSus: producto a x producto b x stock s → stock {(estaRegistrado(a,s) ∧ estaRegistrado(b,s)) ∧L ¬(∃ p:producto)(esSus(p,b,s)) ∧ a ≠ b}

OtrasOperaciones

stocksBajos: stock → conj(producto)

tieneSus: producto p x stock s → bool {estaRegistrado(p,s)}

obtenerSus: producto p x stock s → producto {estaRegistrado(p,s) ∧L tieneSus(p,s)}

productos: stock → conj(producto)

quitarBuenos: conj(producto) x stock → conj(producto)

Axiomas

estaRegistrado(p,crearStock) ≡ false

estaRegistrado(p,registrarProducto(a,n,s)) ≡ p = a ∨ estaRegistrado(p,s)

estaRegistrado(p,comprar(n,a,s)) ≡ estaRegistrado(p,s)

estaRegistrado(p,vender(n,a,s)) ≡ estaRegistrado(p,s)

estaRegistrado(p,infSus(a,b,s)) ≡ estaRegistrado(p,s)

compras(p,comprar(n,a,s)) ≡ if p = a then n + compras(p,s) else compras(p,s) fi

compras(p,registrarProducto(a,n,s)) ≡ if p = a then 0 else compras(p,s) fi

compras(p,vender(n,a,s)) ≡ compras(p,s)

compras(p,infSus(a,b,s)) ≡ compras(p,s)

ventas(p,vender(n,a,s)) ≡ if p = a then n + ventas(p,s) else ventas(p,s) fi

ventas(p,registrarProducto(a,n,s)) ≡ if p = a then 0 else ventas(p,s) fi

ventas(p,comprar(n,a,s)) ≡ ventas(p,s)

ventas(p,infSus(n,a,s)) ≡ ventas(p,s)

esSus(a,b,registrarProducto(c,n,s)) ≡ if a = c ∨ b = c then false else esSus(a,b,s) fi

esSus(a,b,infSus(c,d,s)) ≡ (a = c ∧ b = d) ∨ esSus(a,b,s)

esSus(a,b,comprar(n,c,s)) ≡ esSus(a,b,s)

esSus(a,b,vender(n,c,s)) ≡ esSus(a,b,s)

mínimo(p,registrarProducto(a,n,s)) ≡ if p = a then n else mínimo(p,s) fi

mínimo(p,comprar(n,a,s)) ≡ mínimo(p,s)

mínimo(p,vender(n,a,s)) ≡ mínimo(p,s)

mínimo(p,infSus(a,b,s)) ≡ mínimo(p,s)

stocksBajos(s) ≡ quitarBuenos(productos(s),s)

productos(crearStock) ≡ ∅

productos(comprar(n,a,s)) ≡ productos(s)

productos(vender(n,a,s)) ≡ productos(s)

productos(registrarProducto(a,n,s)) ≡ Ag(a,productos(s))

productos(infSus(a,b,s)) ≡ productos(s)

tieneSus(p,registrarProducto(a,n,s)) ≡ (¬ p = a) ∧L tieneSus(p,s)

tieneSus(p,comprar(n,a,s)) ≡ tieneSus(p,s)

tieneSus(p,vender(n,a,s)) ≡ tieneSus(p,s)

tieneSus(p,infSus(a,b,s)) ≡ p = b ∨ tieneSus(p,s)

obtenerSus(p,infSus(a,b,s)) ≡ if p = b then a else obtenerSus(p,s) fi

obtenerSus(p,registrarPruducto(a,n,s)) ≡ obtenerSus(p,s)

obtenerSus(p,comprar(n,a,s)) ≡ obtenerSus(p,s)

obtenerSus(p,vender(n,a,s)) ≡ obtenerSus(p,s)

quitarBuenos(∅,s) ≡ ∅

quitarBuenos(Ag(p,c),s) ≡ if tieneSus(p,s) then if mínimo(p,s) > compras(p,s) + compras(obtenerSus(p,s),s) - ventas(p,s) - ventas(obtenerSus(p,s),s) then Ag(p,quitarBuenos(c,s)) else quitarBuenos(c,s) fi else if mínimo(p,s) > compras(p,s) - ventas(p,s) then Ag(p,quitarBuenos(c,s)) else quitarBuenos(c,s) fi

Fin TAD

Ejercicio 13

Ejercicio 14

Ejercicio 15

Ejercicio 16

Ejercicio 17

Ejercicio 18

Ejercicio 19

Ejercicio 20

Ejercicio 21

Ejercicio 22