La DLV Tutorial En este tutorial, damos una introducción a Datalog disyuntivas (usando alguna de las extensiones de DLV ). El tutorial no da una descripción completa de los usos y capacidades de DLV . Para una descripción más completa de estos, consulte la DLV página de inicio y la DLV manual del usuario en línea . Los ejemplos mostrados en este trabajo tutorial con todos los últimos DLV liberación. ejecutables de la DLV sistema para varias plataformas puede ser descargado de la DLV la página principal .

El tutorial se compone de las siguientes secciones, cada una de ellas se está construyendo en torno a un ejemplo de guía:

El primer ejemplo: reglas y hechos El segundo ejemplo: La negación y la Asunción mundial completa El Árbol de la familia Ejemplo: predicados, variables, y recursión DLV como un sistema de base de datos deductivas; Operadores de Comparación El cruce ferroviario Ejemplo: La negación verdadera y la negación como

fracaso Finitos El ejemplo Broken Arm: Datalog disyuntivas y el modelo estable Semántica Fuertes restricciones Dibujos para colorear Gráfico: Adivine y Verifique la programación El ejemplo de Fibonacci: Construido en los predicados y aritmética de enteros El ejemplo 8-Queens: Adivine y Hora de programación con enteros Un simple ejemplo Física Diagnóstico Una forma diferente de poner en práctica el ejemplo Física Diagnóstico El Mono y Banana Ejemplo: Planificación

Esta página es bastante largo. Las personas que tienen prisa puede apreciar la información de que el tutorial está plenamente en esta página, no habrá ramas y no hay enlaces a las páginas siguientes.

Este tutorial está escrito para leer y escribir las personas-ordenador con un fondo diferente de las ciencias informáticas, o los nuevos estudiantes a esta área. Fue escrito originalmente para los físicos del CERN, y algunos ejemplos están adaptados a esta comunidad.

Introducción

Datalog es un lenguaje declarativo (programación) del lenguaje. Esto significa que el programador no escribe un programa que resuelve un problema, sino que especifica lo que la solución debe ser similar, y un motor de inferencia Datalog (o deductivo de base de datos del sistema) intenta encontrar la forma en que para resolver el problema y la solución en sí misma. Esto se hace con las normas y los hechos. Los hechos son los datos de entrada, y las reglas pueden ser utilizados para obtener más datos, y es de esperar, la solución del problema dado.

registro de datos disyuntivas es una extensión del registro de datos en la que la expresión lógico OR (la disyunción) se permite que figure en el reglamento - esto no está permitido en el registro de datos básicos.

DLV (= registro de datos con la disyunción) es una potente base de datos del sistema deductivo aunque disponible de forma gratuita. Se basa en el lenguaje de programación declarativa registro de datos, que se caracteriza por ser una herramienta conveniente para la representación del conocimiento. Con sus extensiones disyuntiva, es muy adecuado para todos tipos de razonamiento no monótono, incluyendo el diagnóstico y la planificación.

Por último, tenemos que mencionar al lector más avanzado que DLV es relevante para ambas comunidades. En primer lugar, como se mencionó, es un motor de base de datos deductiva y por lo tanto puede ser visto como una forma de datos de consulta de bases de datos que es estrictamente más potente que por ejemplo, SQL (todo lo que se puede hacer con el lenguaje SQL núcleo también se puede hacer con DLV , y más), pero también es a menudo descrita como un sistema para el grupo de programación respuesta (ASP). Este es un nuevo paradigma poderoso de la zona de "Razonamiento no monótono", que permite la formulación de problemas muy complicados, incluso en una forma declarativa y muy sencillo. Se puede llamar a este paradigma aún más declarativa que la lógica clásica. Por supuesto, cada lenguaje de programación que se procesados por un ordenador tiene que tener tanto la sintaxis fija (es decir, una gramática que especifica cuáles son los programas de este lenguaje tiene que mirar, y qué combinaciones de los símbolos de hacer un programa válido) y la semántica (lo que en abstracto especifica lo que el equipo tiene que ver con la programa por la que se declara cómo un programa se tiene que traducir en el directorio / un resultado correcto). Existe un amplio acuerdo (y también de emoción alguna) que tanto la sintaxis y la semántica de la lengua de DLV es muy sencillo e intuitivo. De hecho, no sé de ninguna manera de hacer que la lengua aún más simple, preservando sus características.

Tanto la sintaxis y la semántica de DLV se describe en este tutorial.

El primer ejemplo: reglas y hechos

Supongamos que queremos modelo que cada vez que alguien nos dice una broma, nos reímos. Además, ahora alguien nos dice una broma. Esto podría hacerse de la siguiente manera:

broma. reír: - broma.

La primera línea se llama un hecho y expresa que la joke es verdad (una simple palabra como joke que aparecen en una norma o de hecho que tiene un valor de verdad se llama una proposición. Un nombre más general - que vamos a utilizar en el siguiente - para los componentes de las normas y los hechos es átomo).. La segunda línea se llama una regla. Se lee como "si es cierto broma, la risa también debe ser verdad". (El signo "-" está destinado a ser una flecha para la izquierda, la programación de la versión lógica de la implicación.)

Si el autor de dicho programa que lo crea oportuno, también se puede interpretar algunos causalidad en una norma y leer éste como "de broma sigue reír". Esto es pura materia de elección de la persona humana, y DLV no se preocupa por él. El lado izquierdo de una regla que se llama su cabeza, mientras que el lado derecho se llama de su cuerpo.

Un resultado de una computación Datalog se llama un modelo. El significado de esto es clara: es una explicación coherente (modelo) del mundo, por lo que el sistema de registro de datos puede derivar del mismo. Si un programa de registro de datos es incoherente, es decir, es contradictorio, no hay simplemente ningún modelo (veremos ejemplos de esto más adelante).

Por supuesto, como en este ejemplo joke es cierto (esto viene dado por el hecho), laugh también es cierto. DLV ahora trata de encontrar todos los modelos del mundo que forma correcta y coherente explicar las observaciones realizadas (= el programa). Un modelo asigna un valor de verdad (verdadero o falso) a cada átomo que aparecen en el programa, y se escribe como el conjunto de átomos que son verdaderas en un determinado modelo. El modelo del programa anterior es {joke, laugh} . Cuando todos los átomos son falsas en un modelo, hablamos de un modelo vacío (escrito como {} ). Tenga en cuenta que tener un modelo vacío es muy diferente de no encontrar el modelo. Veremos ejemplos de esto más tarde.

registro de datos simple de programas como el de arriba siempre tienen exactamente un modelo. En general, sin embargo, DLV programas pueden tener cero (como se mencionó), e incluso muchos modelos. Vamos a ver ejemplos de estos programas más adelante.

El segundo ejemplo: La negación y la Asunción mundial completa

A continuación, supongamos que no son conscientes de que les digan una broma. En este caso, el programa de registro de datos correcta es el siguiente:

reír: - broma.

El programa en sí no expresa esa broma es falso, pero los llamados Completos-(Asunción CWA) hace el. Es uno de los fundamentos DLV basa sus cálculos y dice que todo en que no se sabe nada se supone que es falso. Por lo tanto, el modelo para este programa es {} . (Esto significa que hay un modelo, pero está vacío. También es posible que para un determinado programa no existe un modelo.) Nos pondremos en contacto a la oficina central en más detalle más adelante en la sección que trata sobre DLV como un sistema de base de datos deductiva .

A continuación, elaboramos un poco en este ejemplo. En primer lugar, queremos expresar que, para ser capaz de entender una broma, una tiene que escuchar y no debe ser estúpido. Para escucharlo, no hay que ser sordo y tiene que ser una broma. Por último, para reírse de la broma, hay que entenderlo. Por otra parte, la gente estúpida puede reír sin que nos digan una broma.

broma.

hear_joke: - broma, no sordos. understand_joke: - hear_joke, no estúpidos. reír: - understand_joke. reír: - no estúpido, broma.

En dos de las normas, nos encontramos con los átomos negada. Estos son verdaderos si los átomos mismos son falsos. También encontramos normas que contienen más de un átomo en el cuerpo. En tal caso, un cuerpo es verdadera si cada uno de los literales son verdaderas (un literal es un átomo negado posiblemente). Por ejemplo, hear_joke: - broma, no sordos. se lee como "si joke es verdad y deaf es falso, entonces hear_joke debe ser verdad ".

El modelo de este programa es {joke, hear_joke, understand_joke, laugh} . Una vez más, en virtud de la Ley de Agua Limpia, deaf y stupid se supone que son falsas - no hay hechos haciendo estos verdaderos átomos y no de normas que derivan su verdad. Ahora supongamos que retire joke. del programa y añadir stupid. lugar. Entonces, el modelo resultante sería {stupid, laugh} .

Tenga en cuenta lo siguiente: (i) los átomos que aparecen no como elementos de los modelos anteriores no son las representadas automáticamente falsa. Más bien, son desconocidos. (Ii) Supongamos que el programa se vería así: estúpido. reír: - no estúpido, broma. El modelo de este programa es {stupid, laugh} . Si añadimos el hecho de joke. conseguimos el modelo {stupid, joke} , de la que el átomo de laugh se perdió. En otras palabras, usted puede agregar más información y perder información que pudiera derivarse antes porque de eso. Debido a esta propiedad, el formalismo de la DLV se llama no-monótono, así como las funciones matemáticas que no son ni aumenta ni disminuye monótonamente se llaman no-monótono. A primera vista, esto puede parecer una característica desagradable de este formalismo, pero en realidad, permite hacer muchas cosas útiles.

El Árbol de la familia Ejemplo: predicados, variables, y recursión

Hasta ahora hemos estudiado los átomos simples como los bloques de construcción de nuestras normas. De hecho, los átomos pueden ser construida para albergar un número de argumentos - que luego son también llamados predicados.

En el siguiente programa, tenemos dos predicados binarios, parent y grandparent . (Se les llama binario porque ambas tienen dos argumentos.)

Tenemos que asignar algunos semántica de los dos argumentos de los predicados. Aquí, el primer argumento se supone que es la persona mayor (padre o abuelo), mientras que el segundo argumento se refiere a la persona más joven (el hijo o nieto). Ciertamente, podríamos hacerlo de la otra manera también, pero entonces tendría que ajustar todas las reglas que se siguen.

padre (Juan, Santiago). padre (James, proyecto de ley). john abuelos (, proyecto de ley): - padre (Juan, Santiago), padre (James, proyecto de ley).

Por supuesto, el modelo de este programa es {parent(john, james), parent(james, bill), grandparent(john,bill)} .

Con los predicados, es permitido el uso de variables, que comienzan con un caso de carácter superior, a diferencia de las constantes del programa anterior que comienzan con una carta de los casos inferior. El siguiente programa tiene el mismo modelo que el ejemplo anterior:

padre (Juan, Santiago). padre (James, proyecto de ley). padres abuelos (X, Y): - (X, Z), padre (Z, Y).

Este abuelo nueva regla que utiliza variables de los modelos simplemente que todos los padres de un padre es un abuelo.

Tenga en cuenta que los hechos de un programa se llaman a menudo la base de datos extensional (EDB), mientras que las normas restantes se denominan la base de datos intensional (BID). Con DLV , el EDB puede leerse de una base de datos orientada a objetos o relacional, o simplemente simplemente a partir de archivos, donde las normas y los hechos no se requiere la separación.

Ahora podemos ampliar este ejemplo un poco para mostrar cómo DLV se puede utilizar para el conocimiento del modelo de registro de datos como las normas y explotarla. Primero, añadiremos una más para añadir algunos datos más personas y para expresar su género:

padre (William, juan). padre (Juan, Santiago). padre (James, proyecto de ley). padre (demandar, proyecto de ley). padre (James, Carol). padre (demandar, villancicos).

masculino (juan). hombre (James). mujeres (una demanda). masculino (factura). femenino (villancico).

Luego podemos añadir más reglas que las relaciones modelo de familia. padres abuelos (X, Y): - (X, Z), padre (Z, Y). padre (X, Y): - padre (X, Y), hombres (X). madre (X, Y): - padre (X, Y), femenino (X). hermano (X, Y): - padre (P, X), padre (P, Y), hombres (X), X! = Y. hermana (X, Y): - padre (P, X), padre (P, Y), femenino (X), X! = Y. Las normas de hermano y hermana uso X != Y para exigir que X e Y son diferentes (uno no puede ser su propio hermano). Esto se llama un built-in predicado, ya que se podría escribir algo así como not_equal(X, Y) . DLV sabe un buen número de estos incorporado en los predicados. Para este programa, DLV encuentra el siguiente modelo (para simplificar la lectura, los hechos ya mencionados anteriormente fueron eliminados de la modelo a continuación, por supuesto, que pertenece todavía existe): (Abuelo (William James), abuelo (Juan, proyecto de ley), abuelo (juan, villancicos), padre (Juan, Santiago), padre (James, proyecto de ley), el padre (James, villancicos), madre (Sue, proyecto de ley), la madre (Sue, villancicos),

proyecto de ley hermano (Carol), la hermana de (carol, proyecto de ley)) Veamos ahora el intercambio de las normas del BID a los siguientes (los hechos siguen siendo los mismos EDB): ancestro (X, Y): - padre (X, Y). ancestro (X, Y): - padre (X, Z), ancestro (Z, Y). Estas normas son interesantes, ya que utilizan la recursividad para aplicar la transitividad. Expresan que, para empezar, cada padre es un antepasado, y, en segundo lugar, que todos los padres de un antepasado es un antepasado. Tenga en cuenta que la semántica utilizada asegura que es imposible que haya algún problema con la izquierda-la recursividad y como ocurren en las lenguas como Prolog. En DLV , el programador puede ignorar estas consideraciones.

El modelo de este programa junto con la de seis entradas parent base de datos sobre los resultados en el siguiente modelo (donde los parent fueron hechos desmontarse para facilitar su lectura):

(Ancestro (william, juan), antepasado (William James), antepasado (william, proyecto de ley), ancestro (william, villancicos), antecesor (Juan, Santiago), antecesor (Juan, proyecto de ley), antecesor (Juan, Carol), antepasado (James, proyecto de ley), antepasado (James, villancicos), ancestro (demandar, proyecto de ley), antepasado (demandar, villancicos))

Por último, algunos detalles sutiles hay que señalar que es muy útil para mejorar la legibilidad de las reglas. En el caso de que un determinado argumento de un predicado no es pertinente para una determinada norma, no variable ficticia tiene que ser insertada, pero el _ pueden ser utilizados. Por ejemplo, supongamos que queremos derivar a las personas de los hechos de los padres. Para ello, podemos escribir las siguientes reglas:

persona (X): - padre (X, _). persona (X): - padre (_, X).

Por último, por favor no llamar a un predicado, como se muestra en esta sección una proposición. (Está bien que se llaman átomos.)

DLV como un sistema de base de datos deductivas; Operadores de Comparación

Cuando se utiliza la CWA en uno de sus programas, básicamente ver la DLV sistema como un sistema de base de datos deductiva, ya que no piden lo que es lógicamente correcto, pero lo que puede ser útil para derivar de su base de datos. A raíz de este enfoque, pueden realizar consultas sobre los datos existentes (la base de los hechos), se derivan (y "store") los nuevos datos mediante consultas (= reglas), lo que también se puede utilizar para deducir más datos, incluso, y, usando la Ley de Agua Limpia, incluso pedir un formulario en la a lo que no está en (o derivable de) la base de datos.

Consideremos el siguiente ejemplo en SQL en la conocida dominio del negocio (que muchos sistemas de bases de datos relacionales utilizar ejemplos). EMP es una tabla relacional que contiene la información del empleado, y sección contiene datos sobre departmens de una sociedad en la que el trabajo de los empleados. e.name SELECT, e.salary, d.location De emp e, dept d DONDE e.dept = d.dept_id Y e.salary> 31000; Cuando las tablas relacionales se codifican como una base de datos, podemos reescribir la consulta anterior en una norma de registro de datos: énfasis ("Jones", 30000, 35, "Contabilidad"). énfasis ("Miller", 38000, 29, "Marketing"). énfasis ("Koch", 2000000, 24, "IT"). EMP ("Nguyen", 35000, de 42 años, "Marketing"). énfasis ("Gruber", 32000, de 39 años, "IT").

departamento ("IT", "Atlanta"). departamento ("Marketing", "Nueva York"). departamento ("Contabilidad", "Los Angeles").

q1 (Ename, Esalary, Dlocation): - EMP (Ename, Esalary, _, D), departamento (D, Dlocation), Esalary> 31000.

Como puede ver, se une se logran mediante la unión de variables (se utiliza la misma variable D, tanto en el énfasis y en departamento), las selecciones por ejemplo, puede ser alcanzado por los operadores de comparación, y las proyecciones (es decir, cuando las columnas de datos no deseados son excluidos de una consulta resultado) se puede lograr mediante el uso de _ o una variable independiente.

Usted puede utilizar DLV de hacer todas las consultas que son posibles en el lenguaje SQL básico. Por otra parte, (como se verá cuando el poder expresivo lleno de DLV se dio a conocer más adelante en este tutorial) también puede codificar muchas consultas útiles que no se pueden expresar en SQL.

En este ejemplo se utiliza otra característica de DLV que no ha sido introducido todavía: los operadores de comparación. DLV apoya la <operadores,>,> =, <=, = y para los enteros, valores en coma flotante, y cuerdas. Esta es una extensión que no es parte del registro de datos básicos, pero es conveniente y también es compatible con la filosofía de registro de datos, como se puede pensar en una expresión X> Y como un predicado greater_than(X,Y) para los que la base de datos de todos los mayores-las relaciones que entre símbolos constantes en su programa se generan automáticamente. Por lo tanto, llamamos a estos operadores de comparación incorporado en los predicados.

Tenga en cuenta que también podría reescribir q1 utilizar el operador = para la combinación. La regla a continuación obtiene el mismo resultado que la mostrada:

q1 (Ename, Esalary, Dlocation): - EMP (Ename, Esalary, _, D1), D2 departamento (, Dlocation), D1 = D2, Esalary> 31000.

Descargar el programa ejemplo.

El cruce ferroviario Ejemplo: La negación verdadera y la negación como fracaso Finitos

DLV admite dos tipos de negación. Aquí, hacemos hincapié en la diferencia entre expresar explícitamente la falsedad de un átomo y de haberlo hecho por la completa Asunción Mundial. El programa siguiente se utiliza la Ley de Agua Limpia. Tiene el modelo de {cross} porque train_approaching se supone que es falsa (como verdadero ser no se dice en cualquier lugar). Este tipo de negación se llama negación como (finita) Fallo o NAF.

cruz: - No train_approaching.

El siguiente programa utiliza o negación clásica llamada cierto modo. Desde -train_approaching no se sabe para ser verdad, el siguiente programa sólo tiene un modelo vacío. cruz: --train_approaching. La diferencia entre los dos tipos de negación es muy importante: En el primer ejemplo, cruzamos la vía del tren si no tenemos información sobre los trenes que se aproximan, lo cual es muy peligroso, mientras que en el segundo ejemplo, sólo cruzar si sabemos a ciencia asegurarse de que ningún tren viene. En particular, el lado izquierdo de la regla anterior, sólo podrá lograrse si -Train_approaching. está en la base de datos del programa.

negación verdadera es más fuerte que la negación como fallo finito. Si algo es verdad a través de la negación verdad, que siempre es también cierto si negada por la negación como fallo finito. Por ejemplo, el programa

cruz: - No train_approaching. -Train_approaching.

tiene el modelo {cross, -train_approaching} .

Es cierto también permite uso de la negación para construir programas que son contradictorias y carecen de modelos. Consideremos el siguiente ejemplo:

cruz. -Cross.

Sin duda, este programa no puede tener un modelo. Esto es muy diferente de un programa que tiene un modelo de vacío, que sólo significaría que el programa representa una situación posible, pero que todos sus átomos se supone que son falsas.

El ejemplo Broken Arm: Datalog disyuntivas y el modelo estable Semántica

Supongamos que usted ha cumplido con un amigo hace poco y usted sabe que él tuvo uno de sus brazos rotos, pero no sé cuál. Ahora usted no recibió una tarjeta de felicitación por su cumpleaños y me pregunto si usted debe estar enojado con él o si él no puede escribir a causa de su brazo roto. Por último, usted sabe que escribe con la

mano derecha. El siguiente programa calcula el DLV dos posibles explicaciones para las observaciones que ha realizado. left_arm_broken right_arm_broken v. can_write: - left_arm_broken. be_angry: - can_write. La primera regla se llama regla disyuntiva; La v se lee como "o" y la norma general se lee como "Por supuesto, la izquierda o el brazo derecho roto." Como podemos ver aquí, una regla disyuntiva de mayo ( pero no tiene que) tienen un cuerpo vacío (= falta un cuerpo). Es todavía se llama una regla, ya que ciertamente no es un hecho. (No se sabe si la izquierda o el brazo derecho está roto.)

La capacidad de procesar información incompleta (es decir, ser seguro de si la izquierda o el brazo derecho se rompe) es una de las grandes fortalezas de DLV . El resultado de los modelos de esta consulta son {left_arm_broken, can_write, be_angry} y {right_arm_broken} .

De hecho, la disyunción left_arm_broken v right_arm_broken. también permite que tanto left_arm_broken y right_arm_broken para ser verdad al mismo tiempo. Sin embargo, DLV no muestra el modelo {left_arm_broken, right_arm_broken, can_write, be_angry} debido al paradigma de computación que utiliza para hacer frente a la incertidumbre, y que se llama el modelo estable Semántica. Bajo esta semántica, un modelo no es estable si hay es un modelo más pequeño que es un subconjunto de ella (que es el caso de los dos modelos estables se muestra arriba con respecto a la "gran" modelo que contiene left_arm_broken y right_arm_broken ). Si bien esto puede parecer complicado, es una potente característica muy de DLV que es muy útil para todo tipo de razonamiento. Volveremos a esto más adelante en este tutorial. (Por el momento, queremos hacer hincapié en que este "gran" modelo que no es estable sería manifiestamente erróneo en esta aplicación.)

Tenga en cuenta que la misma incertidumbre también se puede expresar por el siguiente programa:

left_arm_broken: - No right_arm_broken. right_arm_broken: - No left_arm_broken. can_write: - left_arm_broken. be_angry: - can_write.

Este programa da como resultado el mismo par de modelos. El método utilizado aquí se llama negación no estratificado y se considera menos elegante que el primer método. Además, hay ciertos problemas de razonamiento interesante que DLV puede resolver y que sólo se puede expresar con la disyunción verdadera, pero no con la negación no estratificada.

Por último, debe tenerse presente que los órganos de gobierno o bien puede contener positivo (nonnegated) los átomos, los átomos de la negación negada por cierto, y los átomos negada por la negación como fracaso, mientras los jefes regla sólo puede contener átomos positivos y la negación cierto, pero no la negación como fracaso. En otras palabras, una norma como la

no una: - b. NO VÁLIDO%!

no es válido! (El signo% en un DLV programa se inicia un comentario que va hacia la derecha hasta el final de la línea.)

Fuertes restricciones

DLV también es compatible con las restricciones de integridad (restricciones fuertes). Una restricción es una regla con una cabeza vacía. Si su cuerpo es verdadero (que por supuesto es el caso exactamente si todos los literales en el cuerpo se cumplen al mismo tiempo), un modelo que se haga incompatible y se elimina. Por ejemplo, en el ejemplo de árbol genealógico que se presentó anteriormente, fácilmente podemos escribir una restricción de integridad para asegurar que la base de hechos no contradicen los hechos erróneamente contienen diciendo que una persona es de sexo masculino y femenino al mismo tiempo.

: - Hombre (X), femenino (X).

Este tipo de limitaciones se llama fuertes restricciones porque hay también un tipo diferente (restricciones débil) con el apoyo de DLV que no se trata en este tutorial. Este tipo de limitaciones es muy útil para resolver problemas de optimización.

Dibujos para colorear Gráfico: Adivine y Verifique la programación

Gráfico 3-colorabilidad es un duro (NP-completo) problema. Es el problema de decidir si existe una coloración de un mapa de los países correspondientes a la gráfica dada usando no más de tres colores en los que no hay dos países vecinos (nodos conectados por un arco) tienen el mismo color. Se sabe que cada mapa se puede colorear dadas estas limitaciones si cuatro colores están disponibles.

nodo (Minnesota). nodo (Wisconsin). nodo (Illinois). nodo (Iowa). nodo (Indiana). nodo (Michigan). nodo (Ohio).

Minnesota arco (Wisconsin). arco (Illinois, Iowa). arco (Illinois, Michigan). arco (Illinois, Wisconsin). arco (Illinois, Indiana). Indiana arco (Ohio). Michigan arco (, Indiana). Michigan arco (Ohio). Michigan arco (Wisconsin). Minnesota arco (, Iowa). Wisconsin arco (, Iowa). Minnesota arco (Michigan).

Este problema se pueden encontrar soluciones con un registro de datos del programa muy simple, en donde primero se adivina una coloración mediante una regla disyuntiva y controle que mediante la adición de un fuerte) limitación (que borra todos los colorantes que no satisfacen nuestros requisitos (que no puede que no haya arco entre dos nodos de color igual): Supongo% para colorear col (País, rojo) col v (País, verde) col v (País, azul): - nodo (País).

echa% colorear : - Arco (Country1, país2), col (Country1, CommonColor), col (país2, CommonColor). Esta instancia tiene 6 soluciones problema (modelos estables), por lo tanto, es 3-colorable. A continuación, una solución se muestra, en la que tiene la base otra vez hechos retirarse para facilitar su lectura: (Col (Minnesota, verde), col (Wisconsin, rojo), col (Illinois, verde), col (Iowa, azul), col (Indiana, rojo), col (Michigan, azul), col (Ohio, verde))

Este método (supongo y echa de programación) permite codificar un gran número de problemas complicados de una forma intuitiva. DLV continuación, puede utilizar como una codificación para resolver los problemas sorprendentemente eficaz.

Descargar el programa ejemplo.

Como ejercicio, puede utilizar DLV para probar que un mapa de Alemania, Bélgica, Luxemburgo y Francia no es el 3-colorable.

El ejemplo de Fibonacci: Construido en los predicados y aritmética de enteros

Tenga en cuenta que este apartado se presentan algunas características de DLV que no forman parte del registro de datos estándar.

En el siguiente ejemplo, la función de Fibonacci se define, que es pertinente en áreas tan dispares como la Teoría del Caos y Botánica. Su comienza con los siguientes valores: 1, 1, 2, 3, 5, 8, 13, 21, 34, 55 , 89, 144, 233, 377, ... (Aparte de los dos primeros valores, cada valor se define como la suma de las dos anteriores.)

cierto. Fibonacci (1, 1): - cierto. Fibonacci (1, 2): - cierto. fibonacci (F, índice): - + (F1, F2, F), fibonacci (F1, index1), fibonacci (F2, index2), # Succ (index1, index2), # Succ (index2, índice).

Este programa utiliza el built-in predicados + (que añade o resta números enteros) y #succ (la función sucesor). Tenga en cuenta que para facilitar la lectura, también es correcto escribir F = F1 + F2 en vez de +(F1, F2, F) y Index2 = Index1 + 1 en lugar de #succ(Index1, Index2) . Sin embargo, estas ecuaciones simples siempre se asignan a la incorporada en los predicados y no podrá prolongarse más allá. (No es permitido escribir A = B + C + D , esto tiene que ser dividido en dos partes.)

El segundo tema que tiene que ser discutido en este momento es por qué el hecho true. fue presentado. La razón de esto es la fuerte separación que se hace entre EDB y los predicados del BID. Desde fibonacci se utiliza en la mano izquierda de una regla, es en el BID. predicados BID no puede ser utilizado en los hechos (porque entonces tendrían que estar en el EDB). Por eso, un hecho se introduce y las reglas son construcciones que son siempre verdaderos y por tanto sean equivalentes a los hechos. Tenga en cuenta que esta distinción entre el BID y predicados EDB ya no es necesario en la mayoría de versiones recientes de DLV . Por lo tanto, ahora puede declarar fibonacci(1, 1) y fibonacci(1, 2) simplemente como hechos.

Cada vez que la aritmética entera se utilizan, el rango de valores posibles tiene que ser restringida, ya que DLV requiere el espacio de posibles soluciones a ser finito. Esto se hace invocando DLV con la opción -N . (Para una descripción completa de DLV uso, se refieren a la DLV manual .) Por ejemplo, invocando DLV con

fibonacci.dl dl-N = 100

resultados en el modelo (Verdadero, fibonacci (1,1), fibonacci (1,2), fibonacci (2,3), fibonacci (3,4),

fibonacci (5,5), fibonacci (8,6), fibonacci (13,7), fibonacci (21,8), fibonacci (34,9), fibonacci (55,10), fibonacci (89,11)) Estos no son todos los números de Fibonacci mayor que 100.

Descargar el programa ejemplo.

Haga clic aquí para algunos materiales interesantes sobre los números de Fibonacci.

El ejemplo 8-Queens: Adivine y Hora de programación con enteros

Las reinas problema 8 pide una solución en la que ocho reinas se colocan en un tablero de ajedrez 8 x 8 sin poner en peligro unos de otros. Una reina amenaza a otra si se encuentra en la misma fila, columna o en diagonal. % Adivinar la posición horizontal de cada fila q (x, 1) vq (X, 2) vq (X, 3) vq (X, 4) vq (X, 5) vq (X, 6) vq (X, 7) vq (X, 8): - # int (X), X> 0.

echa%

% Afirman que cada columna sólo puede contener (como máximo) una reina : - Q (X1, Y), q (X2, Y), X1 <> X2.

% Afirman que no hay dos reinas se encuentran en una diagonal desde la esquina superior izquierda hasta abajo a la derecha : - Q (X1, Y1), q (X2, Y2), X2 = X1 + N, Y2 = Y1 + N, N> 0.

% Afirman que no hay dos reinas se encuentran en una diagonal desde la parte superior derecha de abajo a la izquierda : - Q (X1, Y1), q (X2, Y2), X2 = X1 + N, Y1 = Y2 + N, N> 0. Para ejecutar este programa con DLV , escriba lo siguiente: dl-n = 1-N = 8 8queens.dl Esto devolverá un resultado como (Q (1,3), Q (2,7), Q (3,2), Q (4,8), Q (5,5), Q (6,1), Q (7,4), q (8,6)) Para obtener las 92 respuestas correctas, escriba dl-N = 8 8queens.dl

Descargar el programa ejemplo.

Un simple ejemplo Física Diagnóstico

Ahora mostraremos cómo utilizar DLV hacer el diagnóstico. Elegimos un dominio de aplicación física, una versión simplificada de ECAL pre-calibración.

Como se muestra en la imagen, una pieza de prueba se dirige hacia un cristal de centelleo cuya emisión de luz se mide con un fotodiodo de avalancha (APD). La medida se entenderán con algo de electrónica de lectura. Como alternativa a la lectura del haz, la APD puede recibir una prueba señal de pulso, que permite comprobar el correcto funcionamiento de la APD de forma independiente del cristal. El siguiente programa permite diagnosticar mal funcionamiento automáticamente partes: ok (testpulse_reading). ok (beam_reading).

bueno (cristal) v mal (cristal). bueno (APD) v malo (APD).

: - Bien (X), malo (X).

bueno (cristal): - ok (beam_reading). bueno (APD): - ok (beam_reading). malo (APD) v mal (cristal): - no se puede (beam_reading). bueno (APD): - ok (testpulse_reading). ok mala (APD): - (no testpulse_reading). El programa comienza con dos hechos expresando nuestras observaciones. Aquí, tanto la lectura y la lectura testpulse viga se encuentra correcto, a continuación, vamos a evaluar el programa con diferentes observaciones. Las siguientes dos reglas indican al sistema que los cristales y APD son de trabajo o roto. Después de esto sigue una restricción que asegura que no pueden ser ambas cosas a la vez. Por último, hay cinco reglas que son una colección de conocimientos expertos. Ellos modelar el conocimiento sobre el dominio y mostrar con toda claridad por qué el impulso de prueba está disponible como un entrada independiente a la APD: permite averiguar si el APD funciona correctamente sin tener que hacer ninguna suposición sobre el cristal. Si el reaout de la viga en el otro lado, no eran correctos, no se podía estar seguro de si la parte responsable es el cristal o la DPA.

Aquí, el único resultado es el modelo {good(crystal), good(apd)} . Supongamos que el intercambio de los dos hechos DBE (las dos primeras líneas de este programa) que ok(testpulse_reading). entonces el resultado de cambios {good(apd), bad(crystal)} . El conjunto diferentes casos que se muestra es en el conjunto de la tabla siguiente:

EDB Modelo (s) {ok(testpulse_reading). ok(beam_reading).} {good(crystal), good(apd)} {ok(testpulse_reading).} {good(apd), bad(crystal)} {ok(beam_reading).} ningún modelo

{} {bad(apd), good(crystal)},

{bad(apd), bad(crystal)}

El caso que la base de hechos es {ok(beam_reading).} también es interesante: De acuerdo a nuestro programa, si ok(beam_reading) es cierto, ok(testpulse_reading) también tiene que ser verdad. Por lo tanto, no existe un modelo coherente en este caso. En otras palabras, de acuerdo con nuestro programa, tales observaciones no se pueden hacer.

Una forma diferente de poner en práctica el ejemplo Física Diagnóstico

La manera de hacer el diagnóstico que se presentó en la sección anterior tiene dos inconvenientes: Se requiere que el conocimiento más de lo necesario tiene que ser codificada en el programa, y como resultado de esto, el programa no hace realmente nada original. Además, es difícil para ampliar. Aquí, se muestra diferente (mejor) manera de hacer el diagnóstico en el mismo dominio de aplicación. Nosotros representamos el sistema como un gráfico de sus unidades: conectados (haz, cristal). conectados (cristal, APD). conectados (testpulse_injector, APD). conectados (APD, lectura).

good_path (X, Y): - No está mal (X), no está mal (Y), conectado (X, Y). good_path (X, Z): - good_path (X, Y), good_path (Y, Z).

mal (cristal) v malo (APD).

testpulse_readout_ok: - good_path (testpulse_injector, lectura). beam_readout_ok: - good_path (viga, lectura). En este programa de ejemplo, hemos dejado fuera todas las observaciones posibles, lo que ponemos en práctica las limitaciones, como se muestra en la siguiente tabla: Observaciones (limitaciones) Modelo (s) (predicados good_path omitido)

{} {bad(crystal), testpulse_readout_ok},

{bad(apd)} {:- testpulse_readout_ok.} {bad(apd)}

{:- beam_readout_ok.} {bad(crystal), testpulse_readout_ok},

{bad(apd)} {:- beam_readout_ok. :- testpulse_readout_ok.} {bad(apd)}

{:- not testpulse_readout_ok.} {bad(crystal), testpulse_readout_ok} {:- not beam_readout_ok.} ningún modelo {:- not beam_readout_ok. :- not testpulse_readout_ok.} ningún modelo

Descargar el programa ejemplo.

El Mono y Banana Ejemplo: Planificación

En el ejemplo siguiente dará una idea de cómo DLV se puede utilizar para hacer la planificación.

Tenga en cuenta que hay un DLV interfaz de planificación que usa una conveniente para fines de planificación lenguaje especial y que no se describe en este tutorial. En su lugar, utilizamos normal disyuntiva de registro de datos para resolver problemas de planificación aquí. Si usted está interesado en este interfaz, consulte el DLV página de inicio para más información.

Consideremos el clásico problema de planificación siguiente. Un mono está en una habitación con una silla y un plátano, que se fija al techo. El mono no puede alcanzar el plátano, a menos que está en la silla, sino que es simplemente demasiado alto. The chair is now at a position different from the place where the banana is hung up, and the monkey itself initially is at again a different place.

Since the program is quite long compared to the earlier examples, it will be explained step by step.

walk(Time) v move_chair(Time) v ascend(Time) v idle(Time) :- #int(Time).

At each discrete point in time, the monkey performs one of the following for actions: it walks, it moves the chair (while doing this, it also moves through the room), it climbs up the chair, or it does nothing. #int is again a built-in predicate which is true exactly if its argument is an integer value. monkey_motion(T) :- walk(T).monkey_motion(T) :- move_chair(T).

stands_on_chair(T2) :- ascend(T), T2 = T + 1.:- stands_on_chair(T), ascend(T).:- stands_on_chair(T), monkey_motion(T).stands_on_chair(T2) :- stands_on_chair(T), T2 = T + 1.After climbing up the chair, it is on it. If is is already on it, it cannot climb up any further. While on the chair, it cannot walk around. If it was on the chair earlier, it will be there in the future. chair_at_place(X, T2) :- chair_at_place(X, T1), T2 = T1 + 1, not move_chair(T1).chair_at_place(Pos, T2) :- move_chair(T1), T2 = T1 + 1, monkey_at_place(Pos, T2).If the chair is not moved, it will stay at the same place. If the monkey moves the chair, it changes its position. monkey_at_place(monkey_starting_point, T) vmonkey_at_place(chair_starting_point, T) vmonkey_at_place(below_banana, T) :- #int(T).The monkey is somewhere in the room. (For simplicity, only three positions are possible.) :- monkey_at_place(Pos1, T2), monkey_at_place(Pos2, T1), T2 = T1 + 1, Pos1 != Pos2, not monkey_motion(T1).

:- monkey_at_place(Pos, T2), monkey_at_place(Pos, T1), T2 = T1 + 1,

monkey_motion(T1).

:- ascend(T), monkey_at_place(Pos1, T), chair_at_place(Pos2, T), Pos1 != Pos2.

:- move_chair(T), monkey_at_place(Pos1, T), chair_at_place(Pos2, T), Pos1 != Pos2.The monkey cannot change its position without moving. The monkey cannot stay at the same place if it moves. It cannot climb up the chair if it is somewhere else. It cannot move the chair if it is somewhere else. monkey_at_place(monkey_starting_point, 0) :- true.chair_at_place(chair_starting_point, 0) :- true. cierto.Initially, the monkey and the chair are at different positions. can_reach_banana :- stands_on_chair(T), chair_at_place(below_banana, T).eats_banana :- can_reach_banana.happy :- eats_banana.

:- not happy.The monkey can only reach the banana if it stands on the chair and the chair is below the banana. If it can reach the banana, it will eat it, and this will make it happy. Our goal is to make the monkey happy. step(N, walk, Destination) :- walk(N), monkey_at_place(Destination, N2), N2 = N + 1.step(N, move_chair, Destination) :- move_chair(N), monkey_at_place(Destination, N2), N2 = N + 1.step(N, ascend, " ") :- ascend(N).The step rules collect all the things we can derive from the situation and build a consistent plan. (There is no step rule for the action idle since we are not interested in it.)

This program again uses integer arithmetics; to find a plan, the maximum integer variable has to be set to at least 3:

dl -N=3 banana.dl

This results in the following model (If N is set to a value greater than 3, DLV will find other plans that make the monkey happy.) {chair_at_place(chair_starting_point,0),monkey_at_place(monkey_starting_point,0),monkey_at_place(chair_starting_point,1),monkey_at_place(below_banana,2),monkey_at_place(below_banana,3),walk(0), move_chair(1), ascend(2), idle(3),chair_at_place(chair_starting_point,1),chair_at_place(below_banana,2),chair_at_place(below_banana,3),monkey_motion(0), monkey_motion(1),step(0,walk,chair_starting_point),step(1,move_chair,below_banana),step(2,ascend," "),stands_on_chair(3), can_reach_banana, eats_banana, happy}

UN PROGRAMA DE EJEMPLO:

% Planning example.% run with% dl -N=3 -filter=step banana.dl

walk(Time) v move_chair(Time) v ascend(Time) v idle(Time) :- #int(Time).

monkey_motion(T) :- walk(T).monkey_motion(T) :- move_chair(T).

stands_on_chair(T2) :- ascend(T), T2 = T + 1.:- stands_on_chair(T), ascend(T).:- stands_on_chair(T), monkey_motion(T).stands_on_chair(T2) :- stands_on_chair(T), T2 = T + 1.

chair_at_place(X, T2) :- chair_at_place(X, T1), T2 = T1 + 1, not move_chair(T1).chair_at_place(Pos, T2) :- move_chair(T1), T2 = T1 + 1, monkey_at_place(Pos, T2).

monkey_at_place(monkey_starting_point, T) vmonkey_at_place(chair_starting_point, T) vmonkey_at_place(below_banana, T) :- #int(T).

:- monkey_at_place(Pos1, T2), monkey_at_place(Pos2, T1), T2 = T1 + 1, Pos1 != Pos2, not monkey_motion(T1).

:- monkey_at_place(Pos, T2), monkey_at_place(Pos, T1), T2 = T1 + 1, monkey_motion(T1).

:- ascend(T), monkey_at_place(Pos1, T), chair_at_place(Pos2, T), Pos1 != Pos2.

:- move_chair(T), monkey_at_place(Pos1, T), chair_at_place(Pos2, T), Pos1 != Pos2.

monkey_at_place(monkey_starting_point, 0) :- true.chair_at_place(chair_starting_point, 0) :- true.true.

can_reach_banana :- stands_on_chair(T), chair_at_place(below_banana, T).eats_banana :- can_reach_banana.happy :- eats_banana.

:- not happy.

step(N, walk, Destination) :- walk(N), monkey_at_place(Destination, N2), N2 = N + 1.step(N, move_chair, Destination) :- move_chair(N), monkey_at_place(Destination, N2), N2 = N + 1.step(N, ascend, " ") :- ascend(N).step(N, idle, " ") :- idle(N).