Algoritmos de Planning - Práctico Nro. 1

Introducción a los Algoritmos de Planning
Práctico Nro. 1

18 de Septiembre de 2008
Alumno: Martín Ignacio Pacheco
Lib.: 245214

1

Ejercicios
5. Dada la situación graficada a continuación, donde XX2 es una variable sin instanciar, y el
siguiente orden de acciones:
O = {EF > Accion3; Accion3 > Accion2; Accion3 > Accion1; Accion2 > EI; Accion1 > EI}

A๐
ss(a,h) ss(b), ss(a), ss(b,m)

ss(a,h), ss(b) ss(a)

ss(a), ss(XX2,Y) ss(XX2)

A2

A1

pe(b) not(ss(a)) algo(h)

pe(a) not(ss(XX2)) algo(Y)

pe(a) pe(b) unomas(a,XX1)
A3

predicado(a,b), not(pe(a)), not(pe(b))

predicado(a,b)
A∞
a. ¿Existen enlaces en peligro en el grafo de planning planteado? En caso afirmativo
indique como los resolvería.
2

Para verificar la existencia de una amenaza en el grafo de planning planteado, realizo el
algoritmo UCPOP con los datos respectivos, es decir que se agregaran solo los links que
posee el gráfico. De esta manera veo con que posibles valores se instancia la variable
XX2 y si ello o algunos de los links me produce un conflicto.
Entonces para el algoritmo mencionado tendré los siguientes datos (<A, O, L, B>,
agenda, actions), con A= {A๐, A∞}, O= {A∞ > A3; A3 > A2; A3 > A1; A2 > A๐; A1 >
A๐}, L= {}, B= {}, Agenda= {<predicado(a, b), A∞>} y Actions= {A1, A2, A3}).
El seguimiento del algoritmo es el siguiente:
1. Selecciono de la agenda <predicado(a, b), A∞>.
2. Elijo una acción del conjunto Actions que unifique con la dos-tupla elegida en el
paso anterior, en este caso seria A3.
Actualizo:
- L’= L U {A3—(predicado(a, b))—> A∞}
- O queda igual ya que la restricción de orden esta incluida.
- A’= A U {A3}
- Actions’= Actions – {A3}
- B’= B U {XX1= sin valor}
- Agenda’= Agenda – {<predicado(a, b), A∞>} U {<pe(a), A3>,
<pe(b), A3>, <unosmas(a,XX1), A3>}
3. Verifico los links causales y ninguno hasta ahora presenta una amenaza.
4. Hago la invocación recursiva con (<A’,O, L’, B’>, Agenda’, Actions’).
5. Selecciono de la agenda <pe(a), A3>.
6. Elijo una acción del conjunto Actions que unifique con la dos-tupla elegida en el
paso anterior, en este caso seria A1.
Actualizo:
- L’= L U {A1—(pe(a))—> A3}
- A’= A U {A1}
- B’= B U {XX2= sin valor, Y= sin valor}
- Agenda’= Agenda – {<pe(a), A3>} U {<ss(a), A1>,
<ss(XX2,Y), A1>, <ss(XX2), A1>}
8. Hago la invocación recursiva con (<A’,O, L’, B’>, Agenda’, Actions’).
9. Selecciono de la agenda <ss(a), A1>.
10. Elijo una acción del conjunto A (es en el primer conjuntos que me fijo antes de pasar
a mirar en el conjunto Actions) que unifique con la dos-tupla elegida en el paso
anterior, en este caso seria A๐.
Actualizo:
- L’= L U {A0—(ss(a))—> A1}
- A queda igual ya que la acción esta incluida.
- Actions queda igual ya que no buscamos ninguna acción en ella.
- B queda igual ya que no tengo nuevas variables y ni tampoco se
les modifica el valor a ninguna.
3

- Agenda’= Agenda – {<ss(a), A1>}
12. Hago la invocación recursiva con (<A,O, L’, B>, Agenda’, Actions).
13. Selecciono de la agenda <pe(b), A3>.
14. Nuevamente busco una acción que me unifique esta pre-condicion, en el conjunto A
no encuentro ninguno, entonces busco en el conjunto Acctions y encuentro la acción
A2.
Actualizo:
- L’= L U {A2—(pe(b))—> A3}
- A’= A U {A2}
- Agenda’= Agenda – {<pe(b), A3>} U {<ss(a,h), A2>, <ss(b),
A2>, <ss(a), A2>}
16. Hago la invocación recursiva con (<A’,O, L’, B>, Agenda’, Actions’).
17. Selecciono de la agenda <ss(a,h), A2>.
y la cumple la acción inicial A๐.
Actualizo:
- L’= L U {A๐—(ss(a,h))—> A2}
- A queda igual ya que no se agregaron mas acciones.
- Actions ya que no se quitaron mas acciones.
- Agenda’= Agenda – {<ss(a,h), A2>}
20. Hago la invocación recursiva con (<A,O, L, B>, Agenda’, Actions).
21. Ahora por últimos agrego el ultimo link, o sea selecciono de la agenda <ss(b), A2>.
y la cumple la acción inicial A๐.
Actualizo:
- L’= L U {A๐—(ss(b))—> A2}
- A queda igual ya que no se agregaron mas acciones.
- Actions ya que no se quitaron mas acciones.
- Agenda’= Agenda – {<ss(b), A2>}
Por lo tanto se pudo demostrar que en la situación en que se encuentran los links
independientemente del orden en que los selecciono no tengo amenaza alguna.
4

b. ¿Qué sucede al agregar el link desde el estado inicial a Accion1 mediante ss(b,m)?
En este caso al agregar el link de A๐—(ss(b,m))—> A1 si se produce una amenaza (ver
línea punteada del gráfico). Lo que sucede aquí es que el conjunto de variables, B, que
teníamos sin instanciar se unifican con esta post-condición de A๐, por lo que XX2 tendría
como valor b e Y tendría como valor m.
Esto me produce un efecto negador (¬Q) si se ejecuta A1 antes que A2. La amenaza
surge de que como bien decimos que A1 podria ejecutarse antes que A2, ya que no hay
ninguna restricción al respecto en el conjunto O, lo que me produce la post-condición
not(ss(XX2)) unificada not(ss(b)) logrando el efecto negador para la pre-condición ss(b)
requerida por la acción A2. De esta manera me rompe el planning, ya que de no ejecutar
A2 no puedo cumplir con las pre-condiciones de A3 y por ende no alcanzo mi estado
final.
Para salvar esta amenaza se debe agregar la restricción de orden en el conjunto O,
aplicando una promición, osea O’= O U {A2<A1}. De manera tal que cuando ejecute A1,
A2 ya habra ejecutado y pierdo la ameanza.

5

6. De una representación UCPOP para los siguientes problemas, y discuta las soluciones
propuestas.
c. Torres de Hanoi: El problema consiste en mover n discos desde un poste hasta otro con
la ayuda de un poste auxiliar. Existen dos reglas: solamente se puede mover un disco por
vez y un disco nunca puede ser colocado sobre un disco más pequeño.
Para simplificar utilizo dos discos. En el gráfico siguiente muestro como los enumero.

A

B

C

A

B

C

D1

D1

D2

D2

Estado inicial

Estado final

Los elementos que se tienen son: D = {d1, d2, a, b, c}, donde D es el conjuntos de discos
y A, B, C también los considero como discos porque me facilita la cantidad de predicados
extras.
Los predicados extras que voy a usar son:
less(X, Y)= {X, Y ∈ D and X < Y}
clean(X)= {:X ∈ D} # Quiere decir que X no tiene elementos encima de el.
on(X, Y)= {X, Y ∈ D and less(X, Y) and clean(X) and clean(Y)}
Estado inicial
A๐ : on(d1, d2), on(d2, a), clear(d1), clear(b), clear(c), less(d1, d2), less(d2, a), less(d2,
b), less(d2, c)
Estado final
A∞ : on(d1,d2), on(d2,c), clean(d1), clean(b), clean(a) ), less(d1, d2), less(d2, a),
less(d2, b), less(d2, c)
Las acciones que voy a tener son:
A1 : move(X, Y, Z) # Mueve el disco X que esta sobre Y hacia Z. Se tiene en cuenta que
Y es distinto a Z.
6

Pre-condiciones:
notEqual(Y, Z), notEqual(X, Z), notEqual(X,Y), clean(X), clean(Z), less(X, Y),
less(X, Z), on(X, Y)
Efectos:
clean(X), on(X, Z), clean(Y), not(clean(Z))
Unas de las consideraciones que se podrían haber tomado seria la de distinguir entre
postes y discos puesto que se podría usar la clausula or para dar la opción de mover sobre
un disco o a un poste solo, pero la complejidad me aumenta.
d. El mono y las bananas es un problema que se realizo en un laboratorio con algunas
bananas colgadas del techo. Se encuentra disponible una caja que le permite al mono
alcanzarlas siempre y cuando se suba a ella. Sin embargo existen solo algunas posiciones
en las que puede alcanzarlas, subir a la caja no implica que llegue, sino que la caja y la
banana se deben encontrar en el mismo espacio (etiquetado de alguna forma). Cada
objeto además de la posición tiene una altura, por ejemplo las bananas que están en el
techo están altas, la caja esta baja, etc.
Inicialmente el mono se encuentra en A, las bananas en B y la caja en C. El mono y la
caja se encuentran bajos, pero si el mono trepa a la caja su altura será alta (igual que las
bananas)
Modelar las acciones disponibles, para que el mono pueda alcanzar las bananas, así como
el estado inicial y final del plan.
Altura
alta

baja
Posiciones:

1

2

3

4

Las acciones disponibles para el mono son:
- moveMonkeyIzq(A, E1, E2), el mono se movería del espacio donde se
encuentra al espacio contiguo izquierdo.
- moveMonkeyDer(A, E1, E2), idem al anterio pero hacia la derecha.
- jumpIzq(A, C, E1, E2, E3), el mono salta la caja hacia la izquierda.
- jumpDer(A, C, E1, E2, E3), idem al anterior pero hacia la derecha
7

- moveBoxDerMi(A, C, E1), el mono mueve la caja hacia la derecha estando el
mono en la izquierda de la caja.
- moveBoxIzqMi(A, C, E1), idem al anterior pero el mono se lleva la caja hacia
la izquierda.
- moveBoxDerMd(A, C, E1), el mono mueve la caja hacia la derecha estando el
mono a la derecha de la caja.
- moveBoxIzqMd(A, C, E1), idem al anterior pero el mono empuja la caja hacia
la izquierda.
- onBox(A, C, B), el mono se sube a la caja para tomar las bananas, estando el
mismo a la izquierda o derecha de la posición de la caja.
- downBox(A, C, E1), el mono se baja de la caja estando este sobre la misma. Se
baja hacia cualquier lado, osea que el mono toma la posición del espacio E1
estando obviamente este libre.
Los predicados auxiliares que utilizo son para describir los estados del mundo y también
defino unos conjuntos para describir los estados para los diferentes objetos.
I= {A, C, B1, B2, …, Bn}
A= {alta, baja}
C={colgada, tomada}
Predicados auxiliares:
-

pos(X,Y)= {X ∈ I and Y ∈ Naturales}
alt(X,Y)= {X ∈ {A} and Y ∈ A}
libre(X)= {X ∈ Naturales}
izq(X,Y)= {X, Y ∈ Naturales : X= Y - 1}
catch(X, Y)= {X ∈ {B1, B2,…, Bn and Y ∈ C}

Estado inicial
A๐ : pos(A, 1), pos(C, 3), pos(B1, 2), pos(B2, 4), alt(M, baja), catch(B1, colgada),
catch(B2, colgada)
Estado final
A∞ : pos(A, 2), pos(C,2), alt(A, alta), catch(B1, tomada), catch(B2, tomada)
Acciones:
moveMonkeyIzq(A, E1, E2)
Pre-condiciones: libre(E2), pos(A,E1), alt(A,baja), izq(E2,E1)
Efectos: not(libre(E2)), pos(A, E2), libre(E1)
8

moveMonkeyDer(A, E1, E2)
Pre-condiciones: libre(E2), pos(A,E1), alt(A,baja), izq(E1,E2)
jumpIzq(A, C, E1, E2, E3)
Pre-condiciones: libre(E3), pos(A, E1), pos(C, E2), izq(E3, E2), izq(E2, E1), alt(A, baja)
jumpDer(A, C, E1, E2, E3)
Pre-condiciones: libre(E3), pos(A, E1), pos(C, E2), izq(E1, E2), izq(E2, E3), alt(A, baja)
moveBoxDerMi(A, C, E1)
Pre-condiciones: libre(E1), izq(A, C), izq(C, E1), alt(A, baja)
Efectos: not(libre(E1)), pos(A, C), pos(C, E1)
moveBoxIzqMi(A, C, E1)
Pre-condiciones: libre(E1), izq(A, C), izq(E1, A), alt(A, baja)
Efectos: not(libre(E1)), pos(C, A), pos(A, E1)
moveBoxDerMd(A, C, E1)
Pre-condiciones: libre(E1), izq(C, A), izq(A, E1), alt(A, baja)
Efectos: not(libre(E1)), pos(C, A), pos(A, E1)
moveBoxIzqMd(A, C, E1)
Pre-condiciones: libre(E1), izq(C, A), izq(E1, C), alt(A, baja)
Efectos: not(libre(E1)), pos(A, C), pos(C, E1)
onBox(A, C, B)
Pre-condiciones: or(izq(A,C), izq(C, A)), alt(A, baja), catch(B, colgada), pos(B, C)
Efectos: cath(B, tomada), alt(A, alta)
downBox(A, C, E1)
Pre-condiciones: libre(E1), equal(C, A), or(izq(E1,C), izq(C, E1)), alt(A, alta)
Efectos: not(libre(E1)), pos(A, E1), alt(A, baja)
Lo que tuve en cuenta es que la altura de la caja y de las bananas es siempre la misma por
lo que no lo modele para esos objetos. En el caso de las bananas simplemente cambian su
estado de colgada a tomada. Otra acción que doy por implícita es que el mono cuando se
sube a la caja es porque esta en condiciones de tomar la banana o sea que se encuentra
posicionada la caja por debajo del plátano. Con respecto a que algún elemento como el
mono o la caja tomen valores inválidos queda solucionado porque simplemente ese valor
no estará libre.
9

Algoritmos de Planning - Práctico Nro. 1

Más contenido relacionado

La actualidad más candente (19)

Destacado (10)

Similar a Algoritmos de Planning - Práctico Nro. 1 (20)

Más de martinp (11)

Último (20)

Algoritmos de Planning - Práctico Nro. 1