OTTER

Inteligencia Artificial I Curso 2005/2006

Claudia Bernardos Gómez

Sara García Solano Berta Mª Pérez Esteban

María Pérez León

OTTER 2

1. Introducción ............................................................................................................ 3

1.1. ¿Qué es OTTER?............................................................................................ 3 1.2. Razonamiento Automático ............................................................................ 3

2. El proceso de inferencia en OTTER: ciclo de trabajo ........................................ 4 2.1. Estrategias de razonamiento en OTTER...................................................... 4 2.2. Ciclo de trabajo............................................................................................... 4

3. Reglas de inferencia adicionales: hiperresolución y paramodulación............... 6 3.1. Hiperresolución............................................................................................... 6 3.2. Paramodulación .............................................................................................. 8

4. Estrategias adicionales: demodulación y asignación de pesos.......................... 10 4.1. Demodulación ............................................................................................... 10 4.2. Asignación de pesos ...................................................................................... 12

5. Ejemplos de aplicación: ....................................................................................... 13 5.1. Búsqueda en espacio de estados .................................................................. 13 5.2. Simplificación de polinomios ....................................................................... 17 5.3. Puzzles ........................................................................................................... 23

6. Apéndice ................................................................................................................ 29 7. Bibliografía............................................................................................................ 31

OTTER 3

1. Introducción

1.1. ¿Qué es OTTER?

OTTER (Organized Techniques For Theorem-Proving And Effective Research), es un sistema de razonamiento automático que implementa el método de resolución para la lógica de primer orden con igualdad. Usa una sintaxis similar a la de Prolog. Es un demostrador por refutación, esto es, busca una contradicción a partir de un conjunto de fórmulas. OTTER no sirve para solucionar problemas de teoría de números, cálculo, geometría plana, y verificación de Hardware. Esto se debe a que requiere de inducción y funciones de alto nivel. Para lo que sí sirve es para aplicaciones de álgebra abstracta, lógica formal, lógica combinatoria y álgebras booleanas. Fue desarrollado por William McCune en el Departamento de Matemáticas y Ciencias de la Computación del “Argonne National Laboratory”, en 1988.

1.2. Razonamiento Automático

El razonamiento automático se dedica a estudiar cómo usar un ordenador para resolver problemas que requieren razonamiento. Algunos problemas que surgen durante dicho estudio son la representación del reconocimiento, las reglas para derivar nuevo conocimiento del que se tiene, y las estrategias para controlar dichas reglas. Otras cuestiones se refieren a la implementación de la teoría resultante y a las aplicaciones para las cuales el correspondiente software puede ser usado. La teoría, implementación y aplicaciones, son vitales para el razonamiento automático a la hora de proporcionar un asistente de razonamiento automático El razonamiento automático se dedica al desarrollo de programas de ordenador que sean capaces de demostrar que una conjetura es una consecuencia lógica de un conjunto de axiomas o hipótesis. El lenguaje en el que la conjetura, las hipótesis, y los axiomas son escritos, es una lógica, a menudo de primer orden, pero también puede ser no clásica o de orden superior. Las pruebas producidas por un sistema de razonamiento automático describen cómo y porqué la conjetura es una consecuencia de los axiomas y las hipótesis, usando para ello las reglas de derivación. Un sistema de razonamiento automático funciona de la siguiente forma:

1. El usuario formaliza el problema y lo pasa al sistema de demostración automática como entrada.

2. El sistema intenta resolver el problema: a. Si el sistema tiene éxito, se obtendrá una solución al problema.

OTTER 4

b. Si no, entonces el usuario puede proporcionar cierta ayuda, intentar demostrar un resultado intermedio, o revisar la formalización.

2. El proceso de inferencia en OTTER: ciclo de trabajo

2.1. Estrategias de razonamiento en OTTER

Para que un programa de razonamiento automático sea efectivo, se requiere el uso de estrategias.

• Estrategias de dirección: si decide qué regla de inferencia debe aplicarse en cierto momento del proceso.

• Estrategias de restricción: si una estrategia evita el uso de ciertas reglas de inferencia.

Ambas estrategias son necesarias para la efectividad de un programa de razonamiento automático. Entre las estrategias de restricción, una de las más importantes es la de soporte, y entre las de dirección, es la estrategia de peso. OTTER también ofrece una técnica efectiva para búsquedas de pruebas cortas, conocida como la estrategia de la razón, que fue formulada para escoger qué cláusula debe ser la siguiente en procesar.

2.2. Ciclo de trabajo

Para obtener conclusiones, OTTER razona aplicando reglas de inferencia. Toda regla de inferencia nunca usa un resultado para obtener una conclusión que no pueda ser justificado con las hipótesis que están siendo usadas. Cada conclusión obtenida por las reglas de inferencia ofrecidas por OTTER, se infiere lógica e inevitablemente de las hipótesis a las que se está aplicando la regla. Por supuesto si se le da un programa con premisas falsas, la conclusión casi seguramente también lo será. De hecho, se obtiene beneficio de esta propiedad porque el uso más frecuente de OTTER se enfoca en encontrar pruebas por contradicción. Cada regla de inferencia está basada en el uso de la unificación, un procedimiento para determinar el máximo dominio común que es relevante a la hipótesis que se está considerando. OTTER mantiene cuatro tipos de listas de cláusulas (Algunas de estas listas pueden estar vacías):

• usable: listas de cláusulas que están disponibles para hacer inferencias • sos: lista de conjunto soporte (Set Of Support). Las cláusulas de esta lista

no están disponibles para hacer inferencia por sí solas, están esperando para participar en la búsqueda de una refutación

• passive: las cláusulas de esta lista tampoco participan directamente en la búsqueda, se usan únicamente para subsumción y conflicto de unidades. (Esta lista está fijada desde el inicio y no cambia durante el proceso de búsqueda.)

OTTER 5

• demodulators: aquí están los demuladores que se utilizan para rescribir las cláusulas inferidas

A continuación aparece el ciclo de inferencia principal, que es el algoritmo de la cláusula dada que opera en las listas sos o usable.

while (sos ¡= {} and no encontrada refutacion) sea cd la cláusula más ligera de sos; sos:=sos – {cd}; usable:=UsablesU{cd}; Infiere(cd);

end while;

Mientras sos es no vacío, y no se ha encontrado refutación: Seleccionar como cláusula actual la cláusula menos pesada del sos Mover la cláusula actual de sos a usable Calcular las resolventes de la cláusula actual con las cláusulas usable Procesar cada una de las resolventes calculadas anteriormente Añadir al sos cada una de las cláusulas procesadas que supere el

procesamiento Descartar cada cláusula de usable o del sos subsumida por alguna

resolvente (subsumción hacia atrás) Factorizar las cláusulas procesadas y procesar los factores obtenidos

Para procesar cada resolvente:

Aplicar a la resolvente eliminación unitaria Aplicar a la resolvente simplificación de factores Si la resolvente es una tautología se descarta Si la resolvente es subsumida por alguna cláusula de usable o de sos

(subsumción hacia delante), se descarta Añadir la resolvente al sos Si la resolvente tiene 0 literales, se ha encontrado una refutación Si la resolvente tiene un literal, entonces buscar su complementaria

(conflicto unitario) en usable y sos Si se ha encontrado una refutación, escribir la prueba obtenida

Veamos un ejemplo de cómo funciona OTTER:

list(sos). P | Q. -P | Q. P | -Q. -P | -Q. end_of_list. set(binary_res).

Al ejecutar el programa anterior, aparece la siguiente prueba: 1 [] P|Q. 2 [] -P|Q.

OTTER 6

3 [] P| -Q. 4 [] -P| -Q. 5 [binary,2.1,1.1,factor_simp] Q. 6 [binary,3.2,5.1] P. 7 [binary,4.1,6.1] -Q. 8 [binary,7.1,5.1] $F.

Se interpreta como sigue: Las 4 primeras cláusulas son cláusulas de entrada. La 5ª se obtiene de 1 y de 2, aplicando resolución binaria sobre sus primeros literales. El resto significa lo mismo. En 8 se obtiene la cláusula vacía ($F) con lo que el conjunto inicial es inconsistente.

En general, las reglas de inferencia de OTTER están basadas en resolución y paramodulación e incluye muchas otras técnicas y estrategias para dirigir y restringir la búsqueda de pruebas. Las pruebas las realiza por refutación e implementa unificación para manejar variables como ya hemos comentado. Otter usa la forma clausal para representar la información, de tal manera que todas las cláusulas forman una conjunción implícitamente.

Al aplicar el principio de resolución, se puede generar muchas cláusulas irrelevantes y redundantes. Con el fin de evitar la generación de las cláusulas innecesarias, veremos otras reglas reglas de inferencia y estrategias adicionales.

3. Reglas de inferencia adicionales: hiperresolución y paramodulación

3.1. Hiperresolución

Es una regla de inferencia que se aplica a un conjunto de cláusulas, una de las cuales debe ser una cláusula negativa o mixta, el resto deben ser cláusulas positivas, y su número debe ser igual al número de literales negativos en la cláusula negativa o mixta. El resultado de la aplicación con éxito será una cláusula positiva, es decir, eliminación de literales negativos resolviendo con cláusulas positivas

donde A1, . . . , An, B1, . . . , Bm,Mi,Mi;j son átomos y σ = umg(Ai,Mi), i Є {1,…,n} Veamos el mismo ejemplo de antes con hiperresolución:

OTTER 7

list(sos). P | Q. -P | Q. P | -Q. -P | -Q. end_of_list. set(hyper_res).

Al ejecutar el programa anterior, aparece la siguiente prueba:

1 [] P|Q. 2 [] -P|Q. 3 [] P| -Q. 4 [] -P| -Q. 5 [hyper,3,1] P. 6 [hyper,5,2] Q. 7 [hyper,4,5,6] $F.

Comparando el resultado con el obtenido mediante resolución binaria, vemos que se generan menos cláusulas. En el caso anterior se había llegado a la cláusula vacía a partir de dos cláusulas generadas en la resolución, y en este caso, la hiperresolución usa una que ya tenía en la entrada, ahorrándose la generación de otra cláusula. Con este ejemplo tan pequeño no se ve el alcance de la mejora por el cambio del método de resolución. Pongamos otro ejemplo más complejo donde queda clara la reducción de cláusulas generadas: Demostrar la validez del siguiente argumento: Los caballos son más rápidos que los perros. Algunos galgos son más rápidos que los conejos. Lucero es un caballo y Orejón es un conejo. Por tanto, Lucero es más rápido que Orejón.

formula_list(sos).

all x y (CABALLO(x) & PERRO(y) -> MAS_RAPIDO(x,y)). exists x (GALGO(x) & (all y (CONEJO(y) -> MAS_RAPIDO(x,y)))). CABALLO(Lucero). CONEJO(Orejon). all x (GALGO(x) -> PERRO(x)). all x (CONEJO(x) -> -PERRO(x)). all x (CONEJO(x) -> -CABALLO(x)). all x (PERRO(x) -> -CABALLO(x)). all x y z (MAS_RAPIDO(x,y) & MAS_RAPIDO(y,z) ->

MAS_RAPIDO(x,z)). -MAS_RAPIDO(Lucero,Orejon).

end_of_list. Prueba obtenida con hiperresolución:

1 [] -CABALLO(x)| -PERRO(y)|MAS_RAPIDO(x,y). 2 [] GALGO($c1).

OTTER 8

3 [] -CONEJO(y)|MAS_RAPIDO($c1,y). 4 [] CABALLO(Lucero). 5 [] CONEJO(Orejon). 6 [] -GALGO(x)|PERRO(x). 10 [] -MAS_RAPIDO(x,y)| -MAS_RAPIDO(y,z)|MAS_RAPIDO(x,z). 11 [] -MAS_RAPIDO(Lucero,Orejon). 12 [hyper,6,2] PERRO($c1). 13 [hyper,3,5] MAS_RAPIDO($c1,Orejon). 14 [hyper,1,4,12] MAS_RAPIDO(Lucero,$c1). 15 [hyper,10,14,13] MAS_RAPIDO(Lucero,Orejon). 16 [binary,15.1,11.1] $F.

Prueba obtenida con resolución binaria:

1 [] -CABALLO(x)| -PERRO(y)|MAS_RAPIDO(x,y). 2 [] GALGO($c1). 3 [] -CONEJO(y)|MAS_RAPIDO($c1,y). 4 [] CABALLO(Lucero). 5 [] CONEJO(Orejon). 6 [] -GALGO(x)|PERRO(x). 10 [] -MAS_RAPIDO(x,y)| -MAS_RAPIDO(y,z)|MAS_RAPIDO(x,z). 11 [] -MAS_RAPIDO(Lucero,Orejon). 12 [binary,6.1,2.1] PERRO($c1). 23 [binary,3.1,5.1] MAS_RAPIDO($c1,Orejon). 24 [binary,1.1,4.1] -PERRO(x)|MAS_RAPIDO(Lucero,x). 27 [binary,24.1,12.1] MAS_RAPIDO(Lucero,$c1). 30 [binary,10.1,27.1] -MAS_RAPIDO($c1,x)|MAS_RAPIDO(Lucero,x). 47 [binary,30.1,23.1] MAS_RAPIDO(Lucero,Orejon). 48 [binary,47.1,11.1] $F.

De obtener la resolución en 48 cláusulas pasamos a tener 16. 3.2. Paramodulación

Es la Regla de Inferencia que se aplica a un par de cláusulas y requiere que al menos una de las dos contenga una literal de igualdad positiva, produce una cláusula en la cual la sustitución de igualdad correspondiente a la literal de igualdad que ha ocurrido.

donde Li[t1] indica que el literal Li contiene el término t1 que es unificable con el término t2, s es un unificador de máxima generalidad de t1 y t2, y Li[t3] es el literal obtenido sustituyendo en L1 la ocurrencia de t1 y t3. Usando la regla de

OTTER 9

paramodulación, el único axioma de la igualdad que se necesita añadir es el axioma de reflexividad. Veamos que ocurre ahora con la paramodulación con un nuevo ejemplo: Demostrar que si Francisco es igual a Curro y a Paco, entonces Curro y Paco son iguales

list(usable). francisco = curro. francisco = paco. end_of_list. list(sos). paco != curro. end_of_list. set(para_into).

La prueba quedaría:

1 [] francisco=curro. 2 [] francisco=paco. 3 [] paco!=curro. 4 [para_into,3.1.1,2.1.2] francisco!=curro. 5 [binary,4.1,1.1] $F.

Este ejemplo no se puede hacer con resolución binaria, porque la búsqueda se pararía al quedarse el conjunto sos vacío. Lo único que podemos hacer es formalizar el ejemplo con axiomas de igualdad para poder usar resolución binaria.

list(sos). x = x. % Reflexividad x != y | y = x. % Simetría x != y | y != z | x = z. % Transisitividad francisco = curro. francisco = paco. paco != curro. end_of_list. set(binary_res).

Siendo la prueba:

2 [] x!=y|y=x. 3 [] x!=y|y!=z|x=z. 4 [] francisco=curro. 5 [] francisco=paco. 6 [] paco!=curro. 8 [binary,2.1,4.1] curro=francisco. 9 [binary,2.2,6.1] curro!=paco. 10 [binary,3.1,8.1] francisco!=x|curro=x.

OTTER 10

24 [binary,10.1,5.1] curro=paco. 25 [binary,24.1,9.1] $F.

genera 25 cláusulas frente a las 5 de antes. 4. Estrategias adicionales: demodulación y asignación de pesos

4.1. Demodulación

La demodulación es un refinamiento del principio de resolución encaminado a mejorar la potencia del mismo en ciertos casos. La regla de demodulación es:

y supone una paramodulación izquierda en la cláusula dada desde una cláusula unitaria. Por tanto, la demodulación no es más que otra estrategia que permite reducir el número de cláusulas innecesarias en problemas que utilizan igualdades. Comentaremos con otro ejemplo la estrategia: Sea G un grupo y e su elemento neutro. Demostrar que si, para todo x de G, x^2=e, entonces G es conmutativo. Los axiomas de grupo que utilizaremos son los siguientes: Tenemos que demostrar que si

entonces

list(usable). e * x = x. % Ax. 1 x * e = x. % Ax. 2 x^ * x = e. % Ax. 3 x * x^ = e. % Ax. 4 (x * y) * z = x * (y * z). % Ax. 5

OTTER 11

x = x. end_of_list. list(sos). x * x = e. a * b != b * a. end_of_list. set(para_into). set(para_from).

Y la demostración obtenida es:

1 [] e*x=x. 2 [] x*e=x. 5 [] (x*y)*z=x*y*z. 7 [] x*x=e. 8 [] a*b!=b*a. 19 [para_from,7.1.2,2.1.1.2] x*y*y=x. 20 [para_from,7.1.2,1.1.1.1] (x*x)*y=y. 31 [para_into,19.1.1,5.1.2] (x*y)*y=x. 167 [para_into,20.1.1,5.1.1] x*x*y=y. 170 [para_from,20.1.1,5.1.1] x=y*y*x. 496 [para_into,167.1.1.2,31.1.1] (x*y)*x=y. 755 [para_into,496.1.1.1,170.1.2] x*y=y*x. 756 [binary,755.1,8.1] $F.

Vamos a ver cómo reducir el número de cláusulas generadas. Analizando el archivo de salida, se observa que aparecen cláusulas con términos en los que figura el elemento neutro como factor. Estas cláusulas pueden simplificarse teniendo en cuenta los axiomas del neutro. La estrategia de demodulación consiste en usar igualdades como reglas de simplificación. Las igualdades que se usen de esta forma se llaman demoduladores. En OTTER la expresión list(demodulators) indica el principio de la lista de demoduladores. Vamos a repetir la prueba usando como demoduladores los axiomas de grupo. El contenido del archivo de entrada es

list(usable). e * x = x. % Ax. 1 x * e = x. % Ax. 2 x^ * x = e. % Ax. 3 x * x^ = e. % Ax. 4 (x * y) * z = x * (y * z). % Ax. 5 x = x. end_of_list. list(sos). x * x = e. a * b != b * a. end_of_list. list(demodulators). e * x = x. % Ax. 1

OTTER 12

x * e = x. % Ax. 2 x^ * x = e. % Ax. 3 x * x^ = e. % Ax. 4 (x * y) * z = x * (y * z). % Ax. 5 end_of_list. set(para_into). set(para_from).

Y la demostración obtenida es:

1 [] e*x=x. 5 [] (x*y)*z=x*y*z. 7 [] x*x=e. 8 [] a*b!=b*a. 10 [] x*e=x. 13 [] (x*y)*z=x*y*z. 14 [para_into,7.1.1,5.1.2,demod,13,13,13] x*y*x*y=e. 20 [para_from,7.1.2,1.1.1.1,demod,13] x*x*y=y. 494 [para_from,14.1.1,20.1.1.2,demod,10] x=y*x*y. 540 [para_from,494.1.2,20.1.1.2] x*y=y*x. 541 [binary,540.1,8.1] $F.

con lo que se consigue reducir el número de cláusulas generadas de 756 a 541. Otra forma de reducir más cláusulas es adoptando la estrategia de considerar como demoduladores las igualdades que se van generando. En OTTER se indica la adopción de esta estrategia mediante la expresión set(dynamic_demod). Si añadimos dicha expresión al anterior archivo de entrada, obtenemos la siguiente demostración:

5 [] (x*y)*z=x*y*z. 7 [] x*x=e. 8 [] a*b!=b*a. 9 [] e*x=x. 10 [] x*e=x. 13 [] (x*y)*z=x*y*z. 14 [para_into,7.1.1,5.1.2,demod,13,13,13] x*y*x*y=e. 19 [para_from,7.1.1,5.1.1.1,demod,9] x*x*y=y. 31 [para_from,14.1.1,19.1.1.2,demod,10] x*y*x=y. 36 [para_from,31.1.1,19.1.1.2] x*y=y*x. 37 [binary,36.1,8.1] $F.

en la que sólo se generan 37 cláusulas frente a las 756 de la primera prueba.

4.2. Asignación de pesos

¿Cómo elige Otter una cláusula del conjunto sos? A cada cláusula Otter le asigna un peso usando las siguientes reglas:

OTTER 13

Otter siempre elige las cláusulas de menor peso, tanto desde la lista sos como desde la lista usable.

El peso de una cláusula es la suma de los pesos de sus literales componentes

El peso de un literal positivo es el peso del átomo que contiene El peso de un literal negativo es 1 más el peso del átomo que contiene El peso de un átomo es 1 más el peso de todos sus términos El peso de un término es 1 más el peso de todos sus subtérminos El peso de una constante es 1 El peso de una variable es 1

Ejemplos:

Otter desplaza la cláusula más ligera del sos a la lista usable, y añade a ésta algunas consecuencias inmediatas de la resolución de la cláusula más ligera. Otter se interrumpe cuando se topa con una refutación o cuando ya no quedan cláusulas en el conjunto soporte.

5. Ejemplos de aplicación:

5.1. Búsqueda en espacio de estados

Como ejemplo para la búsqueda de espacio de estados hemos elegido el problema del granjero, el lobo, la oveja, y la col. El problema consiste en los siguiente: inicialmente los cuatro están en la parte izquierda de un río. Se quiere que los cuatro pasen al otro lado del río, es decir, hay que determinar qué secuencia de desplazamientos de una orilla a la otra tiene que realizar el granjero para pasar a la otra orilla con los otros tres. En la balsa sólo pueden ir dos. La oveja no se puede quedar sola con la col, ni el lobo sólo con la oveja, y en la balsa siempre ha de ir el granjero acompañando a uno de los otros tres. El código planteado para resolver este problema en OTTER sería:

% situación(G,L,O,C). % iz // de % situación inicial: situación(iz,iz,iz,iz). % situación final?: situación(de,de,de,de). list(demodulators). op(iz) = de. op(de) = iz. end_of_list.

OTTER 14

formula_list(sos). all x (x=x). iz != de. % Operadores % El granjero se mueve solo all x a b c (situación(x,a,b,c) & a!=b & b!=c -> situación(op(x),a,b,c)). % El granjero con el lobo all x b c (situación(x,x,b,c) & b!=c -> situación(op(x),op(x),b,c)). % El granjero con la oveja all x a c (situación(x,a,x,c) -> situación(op(x),a,op(x),c)). % El granjero con las coles all x a b (situación(x,a,b,x) & a!=b -> situación(op(x),a,b,op(x))). % Situaciones invalidas all x c (-situacion(x,op(x),op(x),c)). all x a (-situación(x,a,op(x),op(x))). % situación inicial situación(iz,iz,iz,iz). % situación final? -situación(de,de,de,de). end_of_list. set(hyper_res). set(para_into). set(para_from).

La prueba quedaría:

1 [] op(iz)=de. 2 [] op(de)=iz. 4 [] iz!=de. 5 [] -situación(x,x1,x2,x3)|x1=x2|x2=x3situación(op(x),x1,x2,x3). 6 [] -situación(x,x,x4,x5)|x4=x5situación(op(x),op(x),x4,x5). 7 [] -situación(x,x6,x,x7)|situación(op(x),x6,op(x),x7). 8 [] -situación(x,x8,x9,x)|x8=x9situación(op(x),x8,x9,op(x)). 11 [] situación(iz,iz,iz,iz). 12 [] -situación(de,de,de,de). 13 [hyper,7,11,demod,1,1] situación(de,iz,de,iz). 14 [hyper,5,13,demod,2] iz=de|de=iz|situacion(iz,iz,de,iz). 15 [hyper,14,4] de=iz|situacion(iz,iz,de,iz). 17 [para_from,15.1.1,13.1.1] situación(iz,iz,de,iz). 18 [hyper,17,8,demod,1,1] iz=de|situacion(de,iz,de,de). 20 [hyper,18,4] situación(de,iz,de,de).

OTTER 15

21 [hyper,20,7,demod,2,2] situación(iz,iz,iz,de). 22 [hyper,21,6,demod,1,1] iz=de|situacion(de,de,iz,de). 36 [hyper,22,4] situación(de,de,iz,de). 37 [hyper,36,5,demod,2] de=iz|iz=de|situacion(iz,de,iz,de). 38 [hyper,37,4] de=iz|situacion(iz,de,iz,de). 41 [para_from,38.1.1,36.1.1] situación(iz,de,iz,de). 42 [hyper,41,7,demod,1,1] situacion(de,de,de,de). 43 [binary,42.1,12.1] $F.

Comentemos un poco este ejemplo: Se plantea como lista de demoduladores:

op(iz) = de. op(de) = iz.

y como fórmulas, las siguientes:

all x (x=x). iz != de.

si el granjero cruza el río sólo, entonces pasará a estar en el lado contrario al que estuviese:

all x a b c (situación(x,a,b,c) & a!=b & b!=c -> situación(op(x),a,b,c)).

si el granjero se mueve con el lobo, ambos pasan a estar en el lado contrario al que estuviesen

all x b c (situación(x,x,b,c) & b!=c -> situación(op(x),op(x),b,c)).

si el granjero se mueve con la oveja, ambos pasan a estar en el lado contrario al que estuviesen

all x a c (situación(x,a,x,c) -> situación(op(x),a,op(x),c)).

si el granjero se mueve con la col, ambos pasan a estar en el lado contrario al que estuviesen

all x a b (situación(x,a,b,x) & a!=b -> situación(op(x),a,b,op(x))).

el lobo no puede quedarse sólo con la oveja

all x c (-situacion(x,op(x),op(x),c)).

la oveja no puede quedarse sola con la col

all x a (-situación(x,a,op(x),op(x))).

inicialmente, todos están en la parte izquierda del río

OTTER 16

situación(iz,iz,iz,iz).

nos gustaría saber si es posible que todos acaben en la parte derecha del río

-situación(de,de,de,de). Y para ello usamos hiperresolución y paramodulación.

set(hyper_res). set(para_into). set(para_from).

Comentemos ahora un poco cómo hace la prueba: 1, 2, 4, 5, 6, 7, 8, 11, 12 son cláusulas o fórmulas de entrada.

13 dice que resuelve la cláusula 7 con la 11 mediante hiperresolución pues como se ve se puede aplicar ya que tenemos una cláusula mixta, la cual tiene un literal negativo, y por tanto ha de haber tantas cláusulas positivas como literales negativos tenga la mixta, es decir, una.

7 [] -situación(x,x6,x,x7)|situación(op(x),x6,op(x),x7). 11 [] situación(iz,iz,iz,iz).

con lo que quedaría como resultado, una cláusula positiva, tras la eliminación de la cláusula negativa que se ha resuelto con la positiva:

situación(op(iz),iz,op(iz),de)

pero además aplica demodulación, con lo que puede utilizar las igualdades que tiene en la lista de demoduladores para simplificar. En este caso usa la cláusula 1 para este fin,

1 [] op(iz)=de. resolviendo con el resultado anterior, con lo que nos queda como cláusula 13:

situacion(de,iz,de,iz)

De manera análoga procede para obtener las cláusulas 14 y 15. Para obtener la cláusula 17 resuelve usando paramodulación sobre el primer argumento del primer literal de la cláusula 15 y el primer argumento del primer literal de la cláusula 13:

13 situación(de,iz,de,iz). 15 de=iz|situacion(iz,iz,de,iz).

esto es posible pues como se exige, al menos una de las dos cláusulas tiene un literal de igualdad positiva. Y como resultado:

situacion(iz,iz,de,iz)

OTTER 17

El resto de cláusulas se van obteniendo de manera análoga a lo descrito anteriormente, con hiperresolución, demodulación y paramodulación. Finalmente con el primer literal de la cláusula 42 y el primer literal de la cláusula 12, hacemos resolución binaria, obteniendo la cláusula vacía:

42 situacion(de,de,de,de). 12 [] -situacion(de,de,de,de).

Y la secuencia de desplazamientos del granjero sería:

1. Granjero pasa con oveja al lado derecho 2. Granjero vuelve sólo al lado izquierdo 3. Granjero pasa con la col al lado derecho 4. Granjero vuelve con la oveja al lado izquierdo 5. Granjero pasa con el lobo al lado derecho 6. Granjero vuelve sólo al lado izquierdo 7. Granjero pasa con oveja al lado derecho

5.2. Simplificación de polinomios En 1933, E. V. Huntington presentó la siguiente base para el álgebra de Boole:

x + y = y + x. [conmutatividad] (x + y) + z = x + (y + z). [asociatividad] n(n(x) + y) + n(n(x) + n(y)) = x. [ecuación de Huntington]

Poco después, Herbert Robbins conjeturó que la ecuación de Huntington se podría simplificar así

n(n(x + y) + n(x + n(y))) = x. [ecuación de Robbins]

y conjeturó también que el álgebra de Robbins coincidiría con el álgebra de Boole. Ni Robbins ni Huntington pudieron probarlo. Esto se llama el Problema de Robbins.

op(400, xfx, [*,+]). % some infix operators op(300, yf, ^). % a postfix operator set(auto). % autonomous mode assign(max_seconds, 5). % clear(detailed_history). set(build_proof_object). set(formula_history). clear(print_given). list(usable). x = x.

OTTER 18

end_of_list. list(usable). x + y = y + x. end_of_list. list(usable). (x + y) + z = x + (y + z). end_of_list. list(usable). n(n(x + y) + n(x + n(y))) = x. end_of_list. list(usable). n(n(A + B) + n(A + n(B))) != A. end_of_list. list(usable). n(n(x) + y) + n(n(x) + n(y)) = x. end_of_list.

La prueba sería:

1 n(n(A+B)+n(A+n(B)))!=A. [] 6 n(n(x+y)+n(x+n(y)))=x. [] 8 $F. [binary,6.1,1.1]

La manera en que se procede es muy simple, por lo que con las explicaciones dadas en el apartado anterior y siguiente creemos que vale para comentar la prueba. Sí que nos gustaría explicar algunas cosas del código de entrada que no han aparecido en ejemplos anteriores: Podemos definir una serie de operadores. Con op(precedencia,tipo,símbolo). La precedencia es un entero de 0 a 1000, y el tipo puede ser: xfx, xfy, yfx (infijo), fx, fy (prefijo), xf, yf (sufijo).

op(400, xfx, [*,+]). % some infix operators op(300, yf, ^). % a postfix operator

Con set(auto), OTTER comprobará las cláusulas de entrada para alguna propiedad sintáctica simple y decidirá las reglas de inferencia y la estrategia de búsqueda. La estrategia de búsqueda que OTTER selecciona para un conjunto de cláusulas determinado es usualmente una refutación completa, pero el usuario no debería esperar que ésta fuera especialmente efectiva. Encontrará pruebas para muchos teoremas fáciles, e incluso para casos en los que no encuentra la prueba, proporciona un punto de partida razonable.

OTTER 19

El comando set(auto) se debe poner antes de cualquier cláusula de entrada, y todas las cláusulas de entrada deben ir en la lista usable. No se deben poner cláusulas de otras listas cuando estamos en modo autónomo. OTTER moverá algunas cláusulas de entrada a sos antes de empezar la búsqueda. Cuando OTTER procesa el comando set(auto), éste altera algunas opciones, incluso antes de examinar las cláusulas de entrada. Si el usuario quiere aumentar el modo autónomo incluyendo algunos comandos ordinarios, los comandos se deben colocar después de set(auto) y antes de la lista usable. Después de que la lista usable se ha leído, OTTER examina las cláusulas de entrada para algunas propiedades sintácticas y decide qué reglas de inferencia y qué estrategias usar, y qué cláusulas debe eliminar de sos. El usuario no puede anular las decisiones que OTTER haga en este punto. OTTER busca las siguientes propiedades sintácticas del conjunto de cláusulas de entrada:

1. Si es proposicional 2. Si es de Horn 3. Si hay igualdad 4. Si hay axiomas de igualdad 5. El máximo número de literales en las cláusulas

set(auto). % autonomous mode

Con assign(max_seconds, y), decimos que la búsqueda termine tras y segundos de CPU.

assign(max_seconds, 5).

Con clear(detailed_history), evitamos que aparezca toda la información de que literal de que cláusula unifica con quién.

% clear(detailed_history).

Con set(build_proof_object), cuando se encuentra una prueba, un objeto prueba tipo 1 es mostrado en el fichero de salida.

set(build_proof_object).

Con set(formula_history), si se dan fórmulas cuantificadas en la entrada, entonces las fórmulas ocurrirán en las pruebas, y las cláusulas derivadas de las fórmulas se referirán a las fórmulas con el indicador clausify.

set(formula_history).

Con clear(print_given), evitamos que muestre cláusulas cuando se usen para dar otras.

clear(print_given).

OTTER 20

Si el problema de Robbins lo planteamos sin los aspectos anteriores y planteado de forma que:

% álgebra de Robbins % % Si un álgebra de Robbins tiene un elemento c tal que % x+c=c, entonces, es booleana % % Conmutatividad, asociatividad, y el axioma de Huntington % axiomatizan un álgebra booleana set(auto). list(usable). x = x. x+y = y+x. (x+y)+z = x+y+z. n(n(x+y)+n(x+n(y))) = x. % axioma de Robbins x+C = C. % hipotesis (existe 1) n(A+n(B))+n(n(A)+n(B)) != B. % negación axioma Huntington end_of_list.

Y la prueba quedaría:

1 [] n(A+n(B))+n(n(A)+n(B))!=B. 2 [] x=x. 3 [] x+y=y+x. 4 [] (x+y)+z=x+y+z. 6 [] n(n(x+y)+n(x+n(y)))=x. 9,8 [] x+C=C. 11,10 [para_into,3.1.1,8.1.1,flip.1] C+x=C. 13 [para_from,3.1.1,1.1.1.2.1] n(A+n(B))+n(n(B)+n(A))!=B. 18 [para_into,6.1.1.1.1.1,10.1.1,demod,11] n(n(C)+n(C))=C. 20 [para_into,6.1.1.1.1.1,8.1.1] n(n(C)+n(x+n(C)))=x. 36 [para_from,18.1.1,6.1.1.1.2.1.2,demod,9] n(n(x+n(C)+n(C))+n(C))=x. 62 [para_into,20.1.1.1.2.1,3.1.1] n(n(C)+n(n(C)+x))=x. 64 [para_into,20.1.1.1,3.1.1] n(n(x+n(C))+n(C))=x. 88 [para_into,62.1.1.1.2,20.1.1] n(n(C)+x)=n(x+n(C)). 89 [para_into,62.1.1.1,3.1.1] n(n(n(C)+x)+n(C))=x. 91 [copy,88,flip.1] n(x+n(C))=n(n(C)+x). 98 [para_into,13.1.1.1.1,3.1.1] n(n(B)+A)+n(n(B)+n(A))!=B. 100,99 [para_into,64.1.1.1.1.1,4.1.1] n(n(x+y+n(C))+n(C))=x+y. 102,101 [back_demod,36,demod,100] x+n(C)=x. 106,105 [back_demod,91,demod,102,flip.1] n(n(C)+x)=n(x). 108,107 [back_demod,89,demod,106,102] n(n(x))=x. 120,119 [para_into,107.1.1.1,6.1.1,flip.1] n(x+y)+n(x+n(y))=n(x). 121 [back_demod,98,demod,120,108] B!=B. 122 [binary,121.1,2.1] $F.

OTTER 21

Podemos ver otro ejemplo de como OTTER maneja polinomios. Si un entramado de operaciones + y * satisface la ecuación x+(y*z) = (x+y)*(x+z) entonces también satisface x*(y+z) = (x*y)+(x*z) El programa quedaría:

set(knuth_bendix). clear(print_kept). clear(print_new_demod). clear(print_back_demod). clear(print_back_sub). set(sos_queue). % assign(pick_given_ratio,1). assign(max_mem,5000). assign(stats_level,1). list(usable). x=x. x+y=y+x. x*y=y*x. (x+y)+z=x+y+z. (x*y)*z=x*y*z. x+ (x*y)=x. x* (x+y)=x. end_of_list. list(sos). x+ (y*z)= (x+y)* (x+z). a* (b+c)!= (a*b)+ (a*c). end_of_list.

Y la prueba:

2 [] x+y=y+x. 6 [] (x*y)*z=x*y*z. 8 [] x+x*y=x. 11,10 [] x* (x+y)=x. 13,12 [] x+y*z= (x+y)* (x+z). 14 [] a* (b+c)!=a*b+a*c. 15 [copy,14,demod,13,flip.1] (a*b+a)* (a*b+c)!=a* (b+c). 16 [back_demod,8,demod,13] (x+x)* (x+y)=x. 18 [para_into,12.1.1.2,10.1.1,flip.1] (x+y)* (x+y+z)=x+y. 20 [para_into,12.1.1,2.1.1] x*y+z= (z+x)* (z+y).

OTTER 22

21 [copy,20,flip.1] (x+y)* (x+z)=y*z+x. 29 [para_into,15.1.1.2,2.1.1,demod,13] (a*b+a)* (c+a)* (c+b)!=a* (b+c). 43 [para_from,16.1.1,6.1.1.1,flip.1] (x+x)* (x+y)*z=x*z. 58,57 [para_into,18.1.1,16.1.1,flip.1] x+x=x. 61 [back_demod,43,demod,58] x* (x+y)*z=x*z. 129 [para_into,29.1.1.2.2,2.1.1] (a*b+a)* (c+a)* (b+c)!=a* (b+c). 357,356 [para_from,57.1.1,21.1.1.1,demod,11,flip.1] x*y+x=x. 376 [back_demod,129,demod,357] a* (c+a)* (b+c)!=a* (b+c). 397 [para_into,61.1.1.2.1,2.1.1] x* (y+x)*z=x*z. 399 [binary,397.1,376.1] $F.

Como con el problema de Robbins, comentamos los aspectos que difieren de conceptos ya vistos en apartados anteriores: Para establecer una estrategia ecuacional de búsqueda:

set(knuth_bendix).

Para no mostrar nuevas cláusulas que pasan todas las pruebas de retención:

clear(print_kept).

Para no mostrar demoduladores que se crean dinámicamente:

clear(print_new_demod).

Para no mostrar las cláusulas que se demodulan hacia atrás:

clear(print_back_demod). Para no mostrar cláusulas subsumidas hacia atrás:

clear(print_back_sub).

Para que la primera cláusula de sos se elija como la cláusula dada:

set(sos_queue).

Cantidad de memoria máxima a usar:

assign(max_mem,5000).

Para indicar el nivel de detalle de las estadísticas mostradas en el informe resultado:

assign(stats_level,1).

OTTER 23

En la prueba observamos que se aplican, a parte de las técnicas vistas, una demodulación hacia atrás.

5.3. Puzzles

Para este ejemplo de aplicación hemos escogido el siguiente puzzle: Se tienen cuatro tipos distintos de fichas, que son las siguientes: Deberíamos usar OTTER para encontrar todas las maneras posibles de colocar estas cuatro fichas en línea, sin repetir, de forma que los colores de los lados adyacentes coincidan. Las fichas se pueden girar.

% a - rojo % b - azul % c - verde formula_list(sos). all x (x=x). all x1 x2 x3 x4 y1 y2 y3 y4 y5 ((ficha(x1,y1,y2) & ficha(x2,y2,y3) & ficha(x3,y3,y4) & ficha(x4,y4,y5) & x1!=x2 & x1!=x3 & x1!=x4 & x2!=x3 & x2!=x4 & x3!=x4) -> posicion(x1,x2,x3,x4)). ficha(1,a,c). ficha(2,c,a). ficha(3,b,c). ficha(4,a,b). % Para el ejercicio 02 all x y z (ficha(x,y,z) -> ficha(x,z,y)). 1!=2. 1!=3. 1!=4. 2!=3. 2!=4. 3!=4. end_of_list. formula_list(passive). all x1 x2 x3 x4 (posicion(x1,x2,x3,x4) -> $ANS(x1,x2,x3,x4)). end_of_list.

OTTER 24

set(hyper_res). set(para_from). set(para_into). assign(max_proofs,2).

La prueba sería:

2 [] -ficha(x1,y1,y2)| -ficha(x2,y2,y3)| -ficha(x3,y3,y4)| -ficha(x4,y4,y5)|x1=x2|x1=x3|x1=x4|x2=x3|x2=x4|x3=x4|posicion(x1,x2,x3,x4). 3 [] ficha(1,a,c). 4 [] ficha(2,c,a). 5 [] ficha(3,b,c). 6 [] ficha(4,a,b). 7 [] -ficha(x,y,z)|ficha(x,z,y). 8 [] 1!=2. 9 [] 1!=3. 10 [] 1!=4. 11 [] 2!=3. 12 [] 2!=4. 13 [] 3!=4. 14 [] -posicion(x1,x2,x3,x4)|$ANS(x1,x2,x3,x4). 15 [hyper,7,6] ficha(4,b,a). 16 [hyper,7,5] ficha(3,c,b). 17 [hyper,7,4] ficha(2,a,c). 18 [hyper,7,3] ficha(1,c,a). 19 [hyper,2,18,17,16,15] 1=2|1=3|1=4|2=3|2=4|3=4|posicion(1,2,3,4). 31 [hyper,19,8] 1=3|1=4|2=3|2=4|3=4|posicion(1,2,3,4). 37 [hyper,31,9] 1=4|2=3|2=4|3=4|posicion(1,2,3,4). 42 [hyper,37,10] 2=3|2=4|3=4|posicion(1,2,3,4). 46 [hyper,42,11] 2=4|3=4|posicion(1,2,3,4). 49 [hyper,46,12] 3=4|posicion(1,2,3,4). 51 [hyper,49,13] posicion(1,2,3,4). 52 [binary,51.1,14.1] $ANS(1,2,3,4).

Comentamos un poco el ejemplo: Tenemos como fórmulas:

all x (x=x).

con ficha(x,y,z) queremos decir que la ficha x tiene a la izquierda el color y, y a la derecha el color z. Con posicion(a,b,c,d) queremos decir que las fichas a, b, c, d se pueden colocar en línea de forma que los colores de los lados adyacentes coinciden

all x1 x2 x3 x4 y1 y2 y3 y4 y5 ((ficha(x1,y1,y2) & ficha(x2,y2,y3) & ficha(x3,y3,y4) & ficha(x4,y4,y5) &

OTTER 25

x1!=x2 & x1!=x3 & x1!=x4 & x2!=x3 & x2!=x4 & x3!=x4) -> posicion(x1,x2,x3,x4)).

Esta sería la situación inicial, siendo a=rojo, b=azul, y c=verde:

ficha(1,a,c). ficha(2,c,a). ficha(3,b,c). ficha(4,a,b).

Para el caso de que las fichas se puedan girar:

all x y z (ficha(x,y,z) -> ficha(x,z,y)).

Planteamos la diferencia de fichas: 1!=2. 1!=3. 1!=4. 2!=3. 2!=4. 3!=4.

Indicamos también una fórmula en la lista passive para la subsumción y conflicto de unidades. El literal que comienza por $ANS es un literal respuesta:

all x1 x2 x3 x4 (posicion(x1,x2,x3,x4) -> $ANS(x1,x2,x3,x4)).

Y usamos hiperresolución y paramodulación set(hyper_res). set(para_from). set(para_into).

Diciendo que en cuanto encuentre una prueba, pare:

assign(max_proofs,1).

Comentemos ahora un poco cómo hace la prueba:

2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14 son cláusulas o fórmulas de entrada. 15 dice que resuelve la cláusula 7 con la 6 mediante hiperresolución pues como se ve se puede aplicar ya que tenemos una cláusula mixta, la cual tiene un literal negativo, y por tanto ha de haber tantas cláusulas positivas como literales negativos tenga la mixta, es decir, una.

6 [] ficha(4,a,b). 7 [] -ficha(x,y,z)|ficha(x,z,y).

OTTER 26

con lo que quedaría como resultado, una cláusula positiva, tras la eliminación de la cláusula negativa que se ha resuelto con la positiva:

ficha(4,b,a).

El resto de cláusulas se van obteniendo de manera análoga a lo descrito anteriormente, con hiperresolución.

Finalmente con el primer literal de la cláusula 51 y el primer literal de la cláusula 14, hacemos resolución binaria, obteniendo la cláusula vacía:

14 [] -posicion(x1,x2,x3,x4)|$ANS(x1,x2,x3,x4). 51 [hyper,49,13] posicion(1,2,3,4).

Como le hemos dicho que sólo haga una prueba, sólo nos da una manera de colocar que respete las restricciones del problema:

1. Giramos ficha 4 2. Giramos ficha 3 3. Giramos ficha 2 4. Giramos ficha 1

Si quisiéramos encontrar todas las formas posibles tendríamos que modificar el parámetro del assign:

assign(max_proofs,5).

Los puzzles no son sólo una fuente de entretenimiento y retos, sino también abstracciones de problemas reales. Vamos a ver otro ejemplo que pone de manifiesto todo esto: Juan y Ana tienen, entre ambos, dos trabajos. Cada uno tiene sólo un trabajo. Los trabajos son profesor y ATS. El trabajo de ATS sólo lo desempeña un hombre. ¿Qué trabajo desempeña cada uno? Por supuesto, Ana es una profesora y Juan un ATS. Parece que esta respuesta no necesita razonamiento, pero si nos obligaran a justificarla, se podría dar la siguiente explicación: Ana debe ser mujer y no debe ser hombre. Como el trabajo de ATS sólo lo desempeñan hombres, Ana no puede ser ATS. Y como cada una de las dos personas sólo tiene un trabajo, Ana debe ser profesora, dejando así el trabajo de ATS para Juan. Esta justificación nos lleva cinco pasos. Si damos este puzzle a un programa de razonamiento, nos dará la solución, en un número, más o menos similar de pasos. En nuestro caso queremos saber qué trabajo desempeña cada uno, pero podríamos también tener cómo teorema a demostrar por ejemplo, si Juan es un ATS. Veamos cómo conseguimos resolverlo con OTTER.

OTTER 27

formula_list(sos). TRABAJA_DE(Ana,Ats) | TRABAJA_DE(Ana,Profesor). TRABAJA_DE(Juan,Ats) | TRABAJA_DE(Juan,Profesor). -TRABAJA_DE(Ana,Ats) | -TRABAJA_DE(Ana,Profesor). -TRABAJA_DE(Ana,Ats) | -TRABAJA_DE(Ana,Profesor). TRABAJA_DE(Ana,Profesor) | TRABAJA_DE(Juan,Profesor). TRABAJA_DE(Ana,Ats) | TRABAJA_DE(Juan,Ats). -TRABAJA_DE(Ana,Profesor) | -TRABAJA_DE(Juan,Profesor). -TRABAJA_DE(Ana,Ats) | -TRABAJA_DE(Juan,Profesor). all x (-TRABAJA_DE(x,Ats) | HOMBRE(x)). all x (MUJER(x) | HOMBRE(x)). all x (-MUJER(x) | -HOMBRE(x)). MUJER(Ana). HOMBRE(Juan). end_of_list. formula_list(passive). all x (TRABAJA_DE(Juan,x)->$ANS(x)). all y (TRABAJA_DE(Ana,y)->$ANS(y)). end_of_list. set(hyper_res). assign(max_proofs,2). Con las dos primeras cláusulas queremos representar que, Ana y Juan, o son ATS, o son profesor; y con las dos siguientes decimos que no pueden ser ambas cosas a la vez. Con las cuatro siguientes cláusulas, decimos que cada trabajo, o lo desempeña Ana, o lo desempeña Juan, pero no ambos. La cláusula que viene a continuación dice que el trabajo de ATS sólo lo puede desempeñar un hombre; las dos siguientes representan información implícita, esto es, que una persona, o es hombre, o es mujer, pero no ambas cosas, algo que parece obvio pero que necesitamos usar. Nos queda por decir que Ana es mujer y Juan hombre, información implícita en sus respectivos nombres. Y esto lo hacemos con las dos últimas cláusulas. Sin información adicional sobre los nombres, un sistema de razonamiento automático no podrá deducir lo deseado. Ya hemos descrito para que servía la lista passive, sin embargo, esta lista viene siendo más útil para monitorizar el progreso de la búsqueda. Digamos que lo que colocamos ahí es la cláusula respuesta, en la que OTTER nos mostrará las respuestas en caso de que existan. Pero no hay que olvidar que se ha de dar un valor apropiado a max_proofs, porque sino OTTER parará cuando encuentre la primera prueba. En nuestro caso, como sabemos que Ana y Juan tiene cada uno un trabajo y sólo uno, con que busque dos pruebas nos vale, pero esto es algo a tener en cuenta. Primero vamos a aplicar hiperresolución. Las pruebas quedarían: 1 [] TRABAJA_DE(Ana,Ats)|TRABAJA_DE(Ana,Profesor). 9 [] -TRABAJA_DE(x,Ats)|HOMBRE(x).

OTTER 28

11 [] -MUJER(x)| -HOMBRE(x). 12 [] MUJER(Ana). 15 [] -TRABAJA_DE(Ana,y)|$ANS(y). 16 [hyper,1,9] TRABAJA_DE(Ana,Profesor)|HOMBRE(Ana). 17 [hyper,16,11,12] TRABAJA_DE(Ana,Profesor). 18 [binary,17.1,15.1] $ANS(Profesor). Ana es profesora. 1 [] TRABAJA_DE(Ana,Ats)|TRABAJA_DE(Ana,Profesor). 4 [] -TRABAJA_DE(Ana,Ats)| -TRABAJA_DE(Ana,Profesor). 6 [] TRABAJA_DE(Ana,Ats)|TRABAJA_DE(Juan,Ats). 9 [] -TRABAJA_DE(x,Ats)|HOMBRE(x). 11 [] -MUJER(x)| -HOMBRE(x). 12 [] MUJER(Ana). 14 [] -TRABAJA_DE(Juan,x)|$ANS(x). 16 [hyper,1,9] TRABAJA_DE(Ana,Profesor)|HOMBRE(Ana). 17 [hyper,16,11,12] TRABAJA_DE(Ana,Profesor). 20 [hyper,6,4,17] TRABAJA_DE(Juan,Ats). 21 [binary,20.1,14.1] $ANS(Ats). Y Juan ATS. Podíamos pensar en usar paramodulación, pero si lo hacemos, OTTER no encuentra una prueba porque el conjunto sos se queda vacío. Con resolución binaria, el número de cláusulas generadas es más o menos el mismo.

OTTER 29

6. Apéndice

Subsumción Una cláusula C 1 subsume a otra C 2 si existe una sustitución σ tal que σ (C 1) es un subconjunto de C 2. Ejemplos:

• {q(x)} subsume a { p(x); q(y)} con la sustitución { x/y } • {p(x), q(y)} subsume a {p(a), q(g(a)), ┐ r(x, b)} con la sustitución{ x/a,

y/g(a) } • {p(a, x), p(y, b)} subsume a {p(a, b) } con la sustitución

{ x/b,y/a } Factorización Una cláusula C1 tiene un factor binario C2, si C1 contiene dos literales L1 yL2 unificables, (es decir, existe una sustitución σ tal que σ (L1) = σ (L2)) y C2 es σ (C1). La factorización se define como una operación sobre cualquier número de literales. Ejemplos:

La cláusula {p(x, y), p(a, z), p(x, b), ┐q(a, y, x), ┐q(z, b, z)} tiene cuatro factores binarios:

• { p(a, z), p(a, b),┐q(a, z, a), ┐q(z, b, z)} con la sustitución { x/a, y/z}

• { p(x, b), p(a, z), ┐q(a, b, x), ┐q(z, b, z)} con la sustitución {y/b} • {p(a, y), p(a, b),┐q(a, y, a), ┐q(b, b, b)} con la sustitución {x/a,

z/b} • {p(a, b), p(a, a),┐q(a, b, a)} con la sustitución {x/a, y/b, z/a}

Eliminación Unitaria Una cláusula C se reduce por eliminación unitaria con respecto al literal L1 Є C si existe una cláusula unitaria formada por el literal L 2 y una sustitución σ tal que σ( L 2 ) = L 1 . El resultado de la reducción es C – {L1}. Ejemplos:

• La cláusula {p(x, y), q(a, a)} se reduce por eliminación unitaria con respecto al literal q(a, a) , la cláusula {┐q(x, x)} y la sustitución {x/a}. El resultado de la reducción es {p(x, y)}.

OTTER 30

• La cláusula f{p(x, y),┐q(a, a)} se reduce por eliminación unitaria con

respecto al literal ┐q(a, a) , la cláusula {q(x, y)} y la sustitución {x/a , y/a} . El resultado de la reducción es {p(x, y)} • La cláusula {p(x, y), ┐q(a, y)} no se reduce por eliminación unitaria con respecto al literal ┐q(a, y) y la cláusula {q(x, x)} .

Simplificación de Factores La cláusula C 1 se reduce a la cláusula C 2 por simplificación de factores si existen dos literales L1, L2 Є C1 y una sustitución σ tales que σ (L1) = L2 y C2 = σ (C1) es un subconjunto de C1. Ejemplos:

• La cláusula {q (z), p(x, y), p(a, y)} se reduce a la cláusula {q (z), p(a, y)} por simplificación de factores con la sustitución {x/a}.

• La cláusula {q(x),p (x, y), p(a, y)}no se puede reducir por simplificación de factores.

Eliminación de Tautologías La cláusula C 1 es una tautología si contiene literales complementarios. Ejemplos:

• La cláusula {p(x), ┐p(x), q (z, a)} es una tautología. • La cláusula {p(x), ┐p (y)} no es una tautología.

OTTER 31

7. Bibliografía Libros Larry Wos, Ros Overbeek, Ewing Lusk, Jim Boyle.

“Automated Reasoning: introduction and applications”.

Second Edition. McGraw-Hill, 1992.

Enlaces web pub.ufasta.edu.ar/ohcop/ClaseCap10.ppt

http://www.cs.us.es/cursos/dat-2002/temas/tema-1.pdf

http://www.cs.us.es/cursos/ra/temas/tema-OTTER-2c.pdf

http://www.dc.fi.udc.es/ai/~barreiro/iadocen/p2ia302/animals.in

http://www.dc.fi.udc.es/ai/~barreiro/iadocen/p2ia302/OtterKR.html

http://www.lcc.uma.es/~eva/asignaturas/lic/practicas/p109.pdf

http://www-unix.mcs.anl.gov/AR/otter/

http://www-unix.mcs.anl.gov/AR/sobb/

www.mathematik.uni-muenchen.de/ ~ratiu/Articles/ND_Theorema.pdf

www.pue.udlap.mx/~tesis/msp/carmona_f_me/indice.html