Ejemplos de lisp

Memoria practica 4 IA

Autores : Javier Chavarino Martínez y Carlos García Mañas

1 Segunda sesión
1.1.1 Realiza todas las pruebas posibles para conocer a fondo el funcionamiento del
motor de inferencia. ¿Qué ocurre si introducimos variables en nuestra
hipótesis, como (pertenece ?x (2 5 3 6 7))?
Que salen todos los posibles valores que se le puedan asignar a X para que éste
pertenezca ala lista dada. En este caso la respuesta obtenida por el motor de
inferencia es:
(((?X . 2)) ((?X . 5)) ((?X . 1)) ((?X . 6)) ((?X . 7)))
1.1.2 Haz trazas del código siguiendo las funciones más importantes: (trace findhypothesis-value eval-rule consulta) para el ejemplo particular (sethypothesis-list ’(pertenece 1 (2 5 1 6 7))).
Hecho. Nos salen los pasos y las funciones llamadas paraejecutar el motor de
inferencia.

1.1.3 Explica mediante un esquema de llamadas (utilizando un árbol por ejemplo)
qué pasos va haciendo el motor de inferencia hasta llegar a la solución. ¿En
qué se parece esto a Prolog? ¿En qué se diferencia?
0[1]: (CONSULTA ((PERTENECE 1 (2 5 1 6 7))))
1[1]: (FIND-HYPOTHESIS-VALUE (PERTENECE 1 (2 5 1 6 7)))
2[1]: (EVAL-RULE (PERTENECE 1 (2 5 1 6 7)) (R2(PERTENECE ?E.61 (?_ . ?XS.62))
:- ((PERTENECE ?E.61 ?XS.62))))
3[1]: (CONSULTA ((PERTENECE 1 (5 1 6 7))))
4[1]: (FIND-HYPOTHESIS-VALUE (PERTENECE 1 (5 1 6 7)))
5[1]: (EVAL-RULE (PERTENECE 1 (5 1 6 7)) (R2 (PERTENECE ?E.64 (?_ . ?XS.65))
:- ((PERTENECE ?E.64 ?XS.65))))
6[1]: (CONSULTA ((PERTENECE 1 (1 6 7))))
7[1]: (FIND-HYPOTHESIS-VALUE (PERTENECE 1 (1 6 7)))
8[1]: (EVAL-RULE (PERTENECE 1 (1 67)) (R1 (PERTENECE ?E.66 (?E.66 .
?_))))
8[1]: returned (((NIL)))
8[1]: (EVAL-RULE (PERTENECE 1 (1 6 7))
(R2 (PERTENECE ?E.67 (?_ . ?XS.68)) :- ((PERTENECE ?E.67
?XS.68))))
9[1]: (CONSULTA ((PERTENECE 1 (6 7))))
10[1]: (FIND-HYPOTHESIS-VALUE (PERTENECE 1 (6 7)))
11[1]: (EVAL-RULE (PERTENECE 1 (6 7))
(R2 (PERTENECE ?E.70 (?_ . ?XS.71)) :- ((PERTENECE ?E.70
?XS.71))))
12[1]: (CONSULTA((PERTENECE 1 (7))))
13[1]: (FIND-HYPOTHESIS-VALUE (PERTENECE 1 (7)))
14[1]: (EVAL-RULE (PERTENECE 1 (7))
(R2 (PERTENECE ?E.73 (?_ . ?XS.74)) :- ((PERTENECE ?E.73
?XS.74))))

15[1]: (CONSULTA ((PERTENECE 1 NIL)))
16[1]: (FIND-HYPOTHESIS-VALUE (PERTENECE 1 NIL))
16[1]: returned NIL
15[1]: returned NIL
14[1]: returned NIL
13[1]: returned NIL
12[1]: returned NIL
11[1]: returned NIL
10[1]:returned NIL
9[1]: returned NIL
8[1]: returned NIL
7[1]: returned (((NIL)))
7[1]: (CONSULTA NIL)
7[1]: returned (((NIL)))
6[1]: returned (((NIL)))
5[1]: returned (((NIL)))
4[1]: returned (((NIL)))
4[1]: (CONSULTA NIL)
4[1]: returned (((NIL)))
3[1]: returned (((NIL)))
2[1]: returned (((NIL)))
1[1]: returned (((NIL)))
1[1]: (CONSULTA NIL)
1[1]: returned (((NIL)))
0[1]: returned(((NIL)))
(((NIL)))

1.2 Creación de nuevos ejemplos
1.2.1 Predicado: encolar un elemento de una lista
Sintaxis:
(encolar ?Ls ?X ?Rs)
Ejemplos de prueba:

> (set-hypothesis-list ’((encolar () 2 ?Rs)))
> (motor-inferencia)
(((?RS 2)))
> (set-hypothesis-list ’((encolar (1 2 3) 4 ?Rs)))
> (motor-inferencia)
(((?RS 1 2 3 4)))
Diseño:
Se han creado 2 reglas la regla
(R3 (encolar nil ?Xs(?Xs))) que es el caso de parada
de recursión en el cual se encola el elemento a la

lista. Significa “la lista vacía que encola ¿Xs es la
lista ¿Xs.
La segunda regla es
(R4 (encolar (?x . ?Ls) ?Xs (?x . ?Rs)) :- ((encolar
?Ls ?Xs ?Rs))), la cual es la llamada iterativa y
Genera la primera la lista encolada.
Y la clausula significa “si ¿ls encola ¿Xs en ¿Rs
entonces el primer elemento de¿Ls se encola alfinal de
lista resultado ¿RS
1.2.2 Predicado concatenar dos listas.
Sintaxis:
(concatenar ?L1s ?L2s ?Rs)
Ejemplos de utilización:
> (set-hypothesis-list ’((concatenar (1 2 3) (4 5)
?Xs)))
> (motor-inferencia)
(((?XS 1 2 3 4 5)))
> (set-hypothesis-list ’((concatenar (1 2 3) ?Ys (1 2 3
4 5))))
> (motor-inferencia)
(((?YS 4 5)))
Diseño:
Es igual que encolar excepto que...