Capitulo 3, Ejercicio Prolog. Pedro

Capitulo 3, sucesión de Fibonacci, aritmética. Pedro

Ejercicio 2.5 Prolog. Pedro

El problema del mono y la banana se utiliza como un ejemplo sencillo de solución de problemas. El siguiente programa en Prolog mostrará como se pueden utilizar los mecanismos de 'matching' y 'backtracking'. Utilizaremos la siguiente versión del problema: Existe un mono en la puerta de un cuarto; enmedio del cuarto cuelga una banana del techo; el mono está hambriento y desea capturar la banana, pero no puede alcanzarla desde el piso. En la ventana del cuarto hay una caja que el mono puede usar.

El mono puede realizar solamente las siguientes acciones: caminar sobre el piso, subir a la caja, empujar la caja (si el mono está junto a la caja), y, agarrar la banana (si el mono está sobre la caja y bajo la banana).

¿Cómo puede el mono llegar a capturar la banana?

Análisis del problema.

Una tarea importante en programación es encontrar una representación del problema en términos del lenguaje de programación utilizado.

En este caso podemos pensar del 'mundo del mono' en términos de 'estados' que cambian con el tiempo. El estado actual se determina por la posición actual de los objetos.

Por ejemplo, el estado inicial del mundo está determinado por:

1). El mono está en la puerta.

2). El mono está sobre el piso.

3). La caja está en la ventana.

4). El mono no tiene la banana.

Es conveniente combinar todas estas piezas de información en un solo

objeto estructurado. Escogeremos la palabra 'estado' como el functor que

retendrá los cuatro componentes anteriores :

 

El estado final es una situación en que el mono tiene la banana, es decir, cualquier estado en cuyo componente último sea :

estado( _, _, _, silatiene)

Las transiciones permitidas que cambian el mundo de un estado a otro son

las siguientes :

(1). agarrar la banana.

(2). subir a la caja.

(3). empujar la caja.

(4). caminar en el cuarto.

No todas las transiciones son posibles en cada estado posible del mundo del mono. Por ejemplo, la transición 'agarrar la banana' es solamente posible si el mono está sobre la caja y bajo la banana y si no tiene todavía la banana. Estas transiciones ó reglas se pueden formalizar en Prolog como una relación de tres componentes que llamaremos 'mover':

El movimiento 'agarrar' es una precondición necesaria antes de la meta final y lo podemos definir con la cláusula:

mover( estado( enmedio, sobrelacaja, enmedio, nolatiene),

agarrarlabanana,

estado( enmedio, sobrelacaja, enmedio, silatiene)).

Esta cláusula nos dice que después de ejecutarse, el mono tendrá la banana y permanece sobre la caja y enmedio del cuarto.

De una forma similar a la anterior podemos expresar el hecho de que el mono estando sobre el piso puede caminar de la posición P1 a cualquier posición P2. El mono puede realizar esta acción sin importar la posición de la caja y si tiene ó no la banana:

% caminar de P1 a P2

mover( estado( P1, sobreelpiso, B, H),

caminar( P1, P2 ),

estado( P2, sobreelpiso, B, H)).

Esta cláusula nos dice entre otras cosas:

-El movimiento realizado fue: 'caminar de una posición P1 a otra P2'.

-El mono está sobre el piso antes y después del movimiento.

-La caja está en algún lugar B y permanece en el mismo lugar.

-El estado de tiene ó no tiene la banana permanece igual después del movimiento.

La cláusula especifica un conjunto de movimientos posibles porque es aplicable a cualquier situación que se apareje ('matching') al estado antes del movimiento.

Hasta aquí hemos definido los movimientos 'agarrar la banana' (1) y 'caminar de P1 a P2' (4). Los otros dos tipos de movimientos 'empujar la caja' (3) y 'subir a la caja' (2) se pueden definir de manera similar.

Finalmente, la pregunta que nuestro programa debe contestar es: ¿Puede el mono, desde algún estado inicial 'S', capturar la banana ?

Esta pregunta se puede formular con el predicado:

Puede tener(S)

Donde el argumento 'S' es un estado del mundo del mono. El programa para satisfacer el predicado 'puede tener' lo podemos basar en dos observaciones:

(1). Para cualquier estado 'S' en el cual el mono ya tiene la banana, el predicado 'puede tener' debe ser cierto:

puedetener( estado( _, _, _, sila tiene)) :- !.

(2). De otro modo, el mono puede tener la banana desde un estado S1 si existe algún movimiento M del estado S1 a otro estado S2, tal que el mono pueda tener la banana en el estado S2 :

Puede tener( S1) :-

mover( S1, M, S2),

puede tener(S2).

Ejercicio de Aritmética, Factorial de un número. Pedro

La aritmética es la rama de las matemáticas que se ocupa del estudio de los números, sus 

propiedades y las habilidades necesarias para trabajar con ellos.

Existen cuatro operaciones fundamentales en la aritmética: adición o suma, sustracción o resta, 

multiplicación, división y el caso del ” Factorial”:

Ejercicio 3.2 de Prolog Pedro Francisco

1. Escriba una meta, usando concat, para eliminar los tres últimos elementos de una lista L 

produciendo otra lista L1. Recomendación: L es la concatenación de L1 y una lista de tres 

elementos.  

 eliminar3elementos([m,n,j,l,a,k,a],L1).

2 ?-  eliminar3elementos([1,2,3,4,5,5],L1).

L1 = [4, 5, 5].

3 ?-  eliminar3elementos([Rosa,Amarillo,Azul,Verde,Cafe,negro],L1).

L1 = [Verde, Cafe, negro].

4 ?- 

2. Escriba una secuencia de metas para eliminar los tres primeros elementos y los tres 

últimos elementos de una lista L produciendo la lista L2. 

elimina([a,b,c,d,e,f],d,L2).

3. Defina la relación:  

          ultimo( Elemento, Lista)

  

de tal modo que Elemento sea el último elemento de la lista Lista. Escriba dos versiones: 

(a) usando la relación concat, y

 (b) sin usarla. 

1 ?-  ultimo(d,[a,c,e,f,d,f]).

false.

2 ?- ultimo(a,[d,e,g,h,f,a]).

true .

3 ?- ultimo(a,[a,a,a,a,a,a,a,a]).

true .

4 ?- ultimo(6,[2,3,4,5,1,7,6,2]).

false.

5 ?- ultimo(pedro,[alejandro,carlos,alberto,antonio,pedro]).

true .

Ejercicio 2.3 dos y tres

2. El siguiente programa dice que dos personas son parientes si,  

(a). uno es predecesor del otro, ó   

(b). ambos tienen un predecesor común, ó   

(c). ambos tienen un sucesor común :      

parientes( X, Y) :- predecesor( X, Y).      

parientes( X, Y) :- predecesor( Y, X).      

parientes( X, Y) :- predecesor( Z, X), predecesor( Z, Y).      

parientes( X, Y) :- predecesor( X, Z), predecesor( Y, Z).  

¿ puede usted acortar el programa usando la notación de ';' ?  

3. Reescriba el siguiente programa sin utilizar la notación de ';' :  

traducir( Numero, Palabra) :-  

Numero = 1, Palabra = uno; 

Numero = 2, Palabra = dos;

Numero = 3, Palabra = tres. 

Ejercicio 2.3 prolog Pedro Francisco

1. Considere el siguiente programa:  

f( 1, uno).    

f( s(1), dos).      

f( s(s(1)), tres).      

f( s(s(s(X))), N) :- f( X, N).  

¿cómo contestará Prolog las siguientes preguntas? Cuando sean posibles varias respuestas, dé al 

menos dos de ellas.  

(a). ?- f( s(1), A). 

(b). ?- f( s(s(1)), dos). 

(c). ?- f( s(s(s(s(s(s(1)))))), C). 

(d). ?- f( D, tres). 

Ejercicio 2.4 de prolog Pedro Francisco

1. Considere el programa anterior y realice la traza de ejecución

a  la pregunta : 

 enorme(X), oscuro(X).

Analizando:

(a). Pregunta.   

?- oscuro( X), enorme( X).        % Quién es oscuro y enorme ?

Traza de la ejecución.
(1). Lista inicial de metas : oscuro(X), enorme(X).
(2). Examina el programa de arriba hacia abajo  buscando  una  cláusula cuya cabeza empate con la primera meta : oscuro(X). Se encuentra la cláusula 7 : 

               oscuro( Z) :- negro( Z).

se reemplaza la primera meta con el cuerpo instanciado de la cláusula 7, dando una nueva lista de metas :  

               negro(X), enorme(X).

(3). Examina el programa para encontrar un empatamiento de negro(X). Se encuentra la cláusula 5: negro( gato). Esta cláusula no  tiene  cuerpo, así que la lista de metas, luego de instanciarse se convierte en :

               enorme(gato)

(4). Examina el programa para buscar la meta enorme(gato), no se encuentra ninguna cláusula. Por lo tanto se realiza un proceso de backtracking al paso 3) y se elimina la instanciación X = gato. Ahora la lista de metas es de nuevo:
               negro(X), enorme(X).

Se continúa examinando el programa a partir de la cláusula 5. No se encuentra ninguna cláusula. Por lo tanto se realiza un proceso de backtracking nuevamente al paso (2) y se continúa examinando a partir de la cláusula 7. Se encuentra la cláusula 8:
               oscuro(Z) :- cafe(Z).

Se reemplaza la primera meta en la lista de metas por cafe(X), dando:
               cafe(X), enorme(X)

(5). Examina el programa buscando empatar cafe(X), encuentra cafe(oso). Esta cláusula no tiene cuerpo, así que la lista de metas es ahora:
               enorme(oso)

(6). Examina el programa  y  encuentra  la  cláusula  enorme(oso).  Esta cláusula no tiene cuerpo, así que la lista de metas se queda vacía. Esto indica una terminación exitosa y la instanciación correspondiente a la variable queda como :

               X = oso. 

b) Pregunta.      

?- enorme(X), oscuro(X).       % Quién es oscuro y enorme ?

Traza de la ejecución.
(1). Lista inicial de metas: enorme(X), oscuro(X).
(2). Examina el programa de arriba hacia abajo  buscando  una  cláusula cuya cabeza empate con la primera meta : enorme(X). Se encuentra en la cláusula 1:

enorme(oso).

Esta cláusula no  tiene  cuerpo, así que la lista de metas, luego de instanciarse se convierte en : 

oscuro(oso)

(3). Examina el programa para encontrar un empatamiento de oscuro(oso). Se encuentra la cláusula 7:

oscuro( Z) :- negro( Z).  

se reemplaza la primera meta con el cuerpo instanciado de la cláusula 7, dando una nueva lista de metas :  

               enorme(oso), negro(oso). 

(4). Examina el programa para buscar la meta negro(oso), no se encuentra ninguna cláusula. Por 

lo tanto se realiza un proceso de backtracking al paso 3) y se elimina la instanciación negro(oso). 

Ahora la lista de metas es de nuevo:  

               enorme(oso), oscuro(oso). 

Se continúa examinando el programa a partir de la cláusula 7. Se encuentra la cláusula 8:  

               oscuro(Z) :- cafe(Z).

Se reemplaza la segundo meta en la lista de metas por cafe(X), dando:  

               enorme(oso), cafe(oso). 

(5). Examina el programa buscando empatar cafe(X), encuentra cafe(oso). Esta cláusula no tiene 

cuerpo, así que la lista de metas se queda vacía. Esto indica una terminación exitosa y la 

instanciación correspondiente a la variable queda como :  

               X = oso.