La DLV Tutorial

En este tutorial, damos una introduccin a Datalog disyuntivas (usando alguna de las extensiones de DLV ). El tutorial no da una descripcin completa de los usos y capacidades de DLV . Para una descripcin ms completa de estos, consulte la DLV pgina de inicio y la DLV manual del usuario en lnea . Los ejemplos mostrados en este trabajo tutorial con todos los ltimos DLV liberacin. ejecutables de la DLV sistema para varias plataformas puede ser descargado de la DLV la pgina principal . El tutorial se compone de las siguientes secciones, cada una de ellas se est construyendo en torno a un ejemplo de gua:

El primer ejemplo: reglas y hechos El segundo ejemplo: La negacin y la Asuncin mundial completa El rbol de la familia Ejemplo: predicados, variables, y recursin DLV como un sistema de base de datos deductivas; Operadores de Comparacin El cruce ferroviario Ejemplo: La negacin verdadera y la negacin como fracaso Finitos El ejemplo Broken Arm: Datalog disyuntivas y el modelo estable Semntica Fuertes restricciones Dibujos para colorear Grfico: Adivine y Verifique la programacin El ejemplo de Fibonacci: Construido en los predicados y aritmtica de enteros El ejemplo 8-Queens: Adivine y Hora de programacin con enteros Un simple ejemplo Fsica Diagnstico Una forma diferente de poner en prctica el ejemplo Fsica Diagnstico El Mono y Banana Ejemplo: Planificacin

Esta pgina es bastante largo. Las personas que tienen prisa puede apreciar la informacin de que el tutorial est plenamente en esta pgina, no habr ramas y no hay enlaces a las pginas siguientes. Este tutorial est escrito para leer y escribir las personas-ordenador con un fondo diferente de las ciencias informticas, o los nuevos estudiantes a esta rea. Fue escrito originalmente para los fsicos del CERN, y algunos ejemplos estn adaptados a esta comunidad.

Introduccin
Datalog es un lenguaje declarativo (programacin) del lenguaje. Esto significa que el programador no escribe un programa que resuelve un problema, sino que especifica lo que la solucin 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 solucin 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 ms datos, y es de esperar, la solucin del problema dado.

registro de datos disyuntivas es una extensin del registro de datos en la que la expresin lgico OR (la disyuncin) se permite que figure en el reglamento - esto no est permitido en el registro de datos bsicos.
DLV (= registro de datos con la disyuncin) es una potente base de datos del sistema deductivo aunque disponible de forma gratuita. Se basa en el lenguaje de programacin declarativa registro de datos, que se caracteriza por ser una herramienta conveniente para la representacin del conocimiento. Con sus extensiones disyuntiva, es muy adecuado para todos tipos de razonamiento no montono, incluyendo el diagnstico y la planificacin.

Por ltimo, tenemos que mencionar al lector ms 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 ms potente que por ejemplo, SQL (todo lo que se puede hacer con el lenguaje SQL ncleo tambin se puede hacer con DLV , y ms), pero tambin es a menudo descrita como un sistema para el grupo de programacin respuesta (ASP). Este es un nuevo paradigma poderoso de la zona de "Razonamiento no montono", que permite la formulacin de problemas muy complicados, incluso en una forma declarativa y muy sencillo. Se puede llamar a este paradigma an ms declarativa que la lgica clsica. Por supuesto, cada lenguaje de programacin que se procesados por un ordenador tiene que tener tanto la sintaxis fija (es decir, una gramtica que especifica cules son los programas de este lenguaje tiene que mirar, y qu combinaciones de los smbolos de hacer un programa vlido) y la semntica (lo que en abstracto especifica lo que el equipo tiene que ver con la programa por la que se declara cmo un programa se tiene que traducir en el directorio / un resultado correcto). Existe un amplio acuerdo (y tambin de emocin alguna) que tanto la sintaxis y la semntica de la lengua de DLV es muy sencillo e intuitivo. De hecho, no s de ninguna manera de hacer que la lengua an ms simple, preservando sus caractersticas. Tanto la sintaxis y la semntica 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 remos. Adems, ahora alguien nos dice una broma. Esto podra hacerse de la siguiente manera:
broma. rer: - broma.

La primera lnea 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 proposicin. Un nombre ms general - que vamos a utilizar en el siguiente - para los componentes de las normas y los hechos es tomo).. La segunda lnea se llama una regla. Se lee como "si es cierto broma, la risa tambin debe ser verdad". (El signo "-" est destinado a ser una flecha para la izquierda, la programacin de la versin lgica de la implicacin.)

Si el autor de dicho programa que lo crea oportuno, tambin se puede interpretar algunos causalidad en una norma y leer ste como "de broma sigue rer". Esto es pura materia de eleccin 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 computacin Datalog se llama un modelo. El significado de esto es clara: es una explicacin 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 ningn modelo (veremos ejemplos de esto ms adelante). Por supuesto, como en este ejemplo joke es cierto (esto viene dado por el hecho), tambin 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 vaco (escrito como {} ). Tenga en cuenta que tener un modelo vaco es muy diferente de no encontrar el modelo. Veremos ejemplos de esto ms tarde.
laugh

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 ms adelante.

El segundo ejemplo: La negacin y la Asuncin mundial completa

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

El programa en s no expresa esa broma es falso, pero los llamados Completos(Asuncin CWA) hace el. Es uno de los fundamentos DLV basa sus clculos 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 vaco. Tambin es posible que para un determinado programa no existe un modelo.) Nos pondremos en contacto a la oficina central en ms detalle ms adelante en la seccin que trata sobre DLV como un sistema de base de datos deductiva . A continuacin, 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 estpido. Para escucharlo, no hay que ser sordo y tiene que ser una broma. Por ltimo, para rerse de la broma, hay que entenderlo. Por otra parte, la gente estpida puede rer sin que nos digan una broma.
broma.

hear_joke: - broma, no sordos. understand_joke: - hear_joke, no estpidos. rer: - understand_joke. rer: - no estpido, broma.

En dos de las normas, nos encontramos con los tomos negada. Estos son verdaderos si los tomos mismos son falsos. Tambin encontramos normas que contienen ms 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 ms, 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 aadir stupid. lugar. Entonces, el modelo resultante sera {stupid, laugh} . Tenga en cuenta lo siguiente: (i) los tomos que aparecen no como elementos de los modelos anteriores no son las representadas automticamente falsa. Ms bien, son desconocidos. (Ii) Supongamos que el programa se vera as:
estpido. rer: - no estpido, broma. El modelo de este programa es {stupid, laugh} . Si aadimos el hecho de joke. conseguimos el modelo {stupid, joke} , de la que el tomo de laugh se perdi. En

otras palabras, usted puede agregar ms informacin y perder informacin que pudiera derivarse antes porque de eso. Debido a esta propiedad, el formalismo de la DLV se llama no-montono, as como las funciones matemticas que no son ni aumenta ni disminuye montonamente se llaman no-montono. A primera vista, esto puede parecer una caracterstica desagradable de este formalismo, pero en realidad, permite hacer muchas cosas tiles.

El rbol de la familia Ejemplo: predicados, variables, y recursin

Hasta ahora hemos estudiado los tomos simples como los bloques de construccin de nuestras normas. De hecho, los tomos pueden ser construida para albergar un nmero de argumentos - que luego son tambin 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 semntica 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 ms joven (el hijo o nieto). Ciertamente, podramos hacerlo de la otra manera tambin, pero entonces tendra 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 carcter 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 separacin. Ahora podemos ampliar este ejemplo un poco para mostrar cmo DLV se puede utilizar para el conocimiento del modelo de registro de datos como las normas y explotarla. Primero, aadiremos una ms para aadir algunos datos ms personas y para expresar su gnero:
padre padre padre padre padre padre (William, juan). (Juan, Santiago). (James, proyecto de ley). (demandar, proyecto de ley). (James, Carol). (demandar, villancicos).

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

Luego podemos aadir ms 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 podra escribir algo as como not_equal(X, Y) . DLV sabe un buen nmero 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 continuacin, por supuesto, que pertenece todava 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 semntica utilizada asegura que es imposible que haya algn problema con la izquierdala 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 sealar 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 seccin una proposicin. (Est bien que se llaman tomos.)

como un sistema de base de datos deductivas; Operadores de Comparacin

DLV

Cuando se utiliza la CWA en uno de sus programas, bsicamente ver la DLV sistema como un sistema de base de datos deductiva, ya que no piden lo que es lgicamente correcto, pero lo que puede ser til para derivar de su base de datos. A raz 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 tambin se puede utilizar para deducir ms 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 informacin del empleado, y seccin 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 aos, "Marketing"). nfasis ("Gruber", 32000, de 39 aos, "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 unin 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 comparacin, 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 bsico. Por otra parte, (como se ver cuando el poder expresivo lleno de DLV se dio a conocer ms adelante en este tutorial) tambin puede codificar muchas consultas tiles que no se pueden expresar en SQL. En este ejemplo se utiliza otra caracterstica de DLV que no ha sido introducido todava: los operadores de comparacin. DLV apoya la <operadores,>,> =, <=, = y para los enteros, valores en coma flotante, y cuerdas. Esta es una extensin que no es parte del registro de datos bsicos, pero es conveniente y tambin es compatible con la filosofa de registro de datos, como se puede pensar en una expresin X> Y como un predicado greater_than(X,Y) para los que la base de datos de todos los mayores-las relaciones que entre smbolos constantes en su programa se generan automticamente. Por lo tanto, llamamos a estos operadores de comparacin incorporado en los predicados. Tenga en cuenta que tambin podra reescribir q1 utilizar el operador = para la combinacin. La regla a continuacin 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 negacin verdadera y la negacin como fracaso Finitos

admite dos tipos de negacin. Aqu, hacemos hincapi en la diferencia entre expresar explcitamente la falsedad de un tomo y de haberlo hecho por la completa Asuncin 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 negacin se llama negacin como (finita) Fallo o NAF.
cruz: - No train_approaching. DLV

El siguiente programa utiliza o negacin clsica llamada cierto modo. Desde no se sabe para ser verdad, el siguiente programa slo tiene un modelo vaco.
train_approaching cruz: --train_approaching.

La diferencia entre los dos tipos de negacin es muy importante: En el primer ejemplo, cruzamos la va del tren si no tenemos informacin sobre los trenes que se aproximan, lo cual es muy peligroso, mientras que en el segundo ejemplo, slo cruzar si sabemos a ciencia asegurarse de que ningn tren viene. En particular, el lado izquierdo de la regla anterior, slo podr lograrse si
-Train_approaching.

est en la base de datos del programa. negacin verdadera es ms fuerte que la negacin como fallo finito. Si algo es verdad a travs de la negacin verdad, que siempre es tambin cierto si negada por la negacin como fallo finito. Por ejemplo, el programa
cruz: - No train_approaching. -Train_approaching.

tiene el modelo {cross, -train_approaching} . Es cierto tambin permite uso de la negacin 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 vaco, que slo significara que el programa representa una situacin posible, pero que todos sus tomos se supone que son falsas.

El ejemplo Broken Arm: Datalog disyuntivas y el modelo estable Semntica

Supongamos que usted ha cumplido con un amigo hace poco y usted sabe que l tuvo uno de sus brazos rotos, pero no s cul. Ahora usted no recibi una tarjeta de felicitacin por su cumpleaos 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 vaco (= falta un cuerpo). Es todava 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 informacin 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 disyuncin left_arm_broken v right_arm_broken. tambin 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 computacin que utiliza para hacer frente a la incertidumbre, y que se llama el modelo estable Semntica. Bajo esta semntica, un modelo no es estable si hay es un modelo ms pequeo 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 caracterstica muy de DLV que es muy til para todo tipo de razonamiento. Volveremos a esto ms adelante en este tutorial. (Por el momento, queremos hacer hincapi en que este "gran" modelo que no es estable sera manifiestamente errneo en esta aplicacin.) Tenga en cuenta que la misma incertidumbre tambin 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 mtodo utilizado aqu se llama negacin no estratificado y se considera menos elegante que el primer mtodo. Adems, hay ciertos problemas de razonamiento interesante que DLV puede resolver y que slo se puede expresar con la disyuncin verdadera, pero no con la negacin no estratificada. Por ltimo, debe tenerse presente que los rganos de gobierno o bien puede contener positivo (nonnegated) los tomos, los tomos de la negacin negada por cierto, y los tomos negada por la negacin como fracaso, mientras los jefes regla slo puede contener tomos positivos y la negacin cierto, pero no la negacin como fracaso. En otras palabras, una norma como la
no una: - b. NO VLIDO%!

no es vlido! (El signo% en un DLV programa se inicia un comentario que va hacia la derecha hasta el final de la lnea.)

Fuertes restricciones
tambin es compatible con las restricciones de integridad (restricciones fuertes). Una restriccin es una regla con una cabeza vaca. 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 genealgico que se present anteriormente, fcilmente podemos escribir una restriccin de integridad para asegurar que la base de hechos no contradicen los hechos errneamente contienen diciendo que una persona es de sexo masculino y femenino al mismo tiempo.
: - Hombre (X), femenino (X). DLV

Este tipo de limitaciones se llama fuertes restricciones porque hay tambin un tipo diferente (restricciones dbil) con el apoyo de DLV que no se trata en este tutorial. Este tipo de limitaciones es muy til para resolver problemas de optimizacin.

Dibujos para colorear Grfico: Adivine y Verifique la programacin

Grfico 3-colorabilidad es un duro (NP-completo) problema. Es el problema de decidir si existe una coloracin de un mapa de los pases correspondientes a la grfica dada usando no ms de tres colores en los que no hay dos pases vecinos (nodos conectados por un arco) tienen el mismo color. Se sabe que cada mapa se puede colorear dadas estas limitaciones si cuatro colores estn disponibles.

nodo nodo nodo nodo nodo nodo nodo

(Minnesota). (Wisconsin). (Illinois). (Iowa). (Indiana). (Michigan). (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 coloracin mediante una regla disyuntiva y controle que mediante la adicin de un fuerte) limitacin (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 (Pas, rojo) col v (Pas, verde) col v (Pas, azul): - nodo (Pas). echa% colorear : - Arco (Country1, pas2), col (Country1, CommonColor), col (pas2, CommonColor).

Esta instancia tiene 6 soluciones problema (modelos estables), por lo tanto, es 3colorable. A continuacin, una solucin 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 mtodo (supongo y echa de programacin) permite codificar un gran nmero de problemas complicados de una forma intuitiva. DLV continuacin, puede utilizar como una codificacin para resolver los problemas sorprendentemente eficaz. Descargar el programa ejemplo.

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

El ejemplo de Fibonacci: Construido en los predicados y aritmtica de enteros

Tenga en cuenta que este apartado se presentan algunas caractersticas de DLV que no forman parte del registro de datos estndar. En el siguiente ejemplo, la funcin de Fibonacci se define, que es pertinente en reas tan dispares como la Teora del Caos y Botnica. 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 aade o resta nmeros enteros) y #succ (la funcin sucesor). Tenga en cuenta que para facilitar la lectura, tambin 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 ms 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 razn de esto es la fuerte separacin 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 tendran 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 distincin entre el BID y predicados EDB ya no es necesario en la mayora 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 aritmtica 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 opcin -N . (Para una descripcin 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 nmeros de Fibonacci mayor que 100. Descargar el programa ejemplo.

Haga clic aqu para algunos materiales interesantes sobre los nmeros de Fibonacci.

El ejemplo 8-Queens: Adivine y Hora de programacin con enteros

Las reinas problema 8 pide una solucin 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 posicin 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 slo puede contener (como mximo) 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 Fsica Diagnstico

Ahora mostraremos cmo utilizar DLV hacer el diagnstico. Elegimos un dominio de aplicacin fsica, una versin simplificada de ECAL pre-calibracin.

Como se muestra en la imagen, una pieza de prueba se dirige hacia un cristal de centelleo cuya emisin de luz se mide con un fotodiodo de avalancha (APD). La medida se entendern con algo de electrnica de lectura. Como alternativa a la lectura del haz, la APD puede recibir una prueba seal de pulso, que permite comprobar el correcto funcionamiento de la APD de forma independiente del cristal. El siguiente programa permite diagnosticar mal funcionamiento automticamente 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 continuacin, 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. Despus de esto sigue una restriccin que asegura que no pueden ser ambas cosas a la vez. Por ltimo, hay cinco reglas que son una coleccin 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 suposicin sobre el cristal. Si el reaout de la viga en el otro lado, no eran correctos, no se poda 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 lneas 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
{ok(testpulse_reading).}

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

{ok(testpulse_reading). ok(beam_reading).} {good(crystal), good(apd)}

{ok(beam_reading).} {}

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

El caso que la base de hechos es {ok(beam_reading).} tambin es interesante: De acuerdo a nuestro programa, si ok(beam_reading) es cierto, ok(testpulse_reading) tambin 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 prctica el ejemplo Fsica Diagnstico

La manera de hacer el diagnstico que se present en la seccin anterior tiene dos inconvenientes: Se requiere que el conocimiento ms de lo necesario tiene que ser codificada en el programa, y como resultado de esto, el programa no hace realmente nada original. Adems, es difcil para ampliar. Aqu, se muestra diferente (mejor) manera de hacer el diagnstico en el mismo dominio de aplicacin. Nosotros representamos el sistema como un grfico de sus unidades:
conectados conectados conectados conectados (haz, cristal). (cristal, APD). (testpulse_injector, APD). (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 prctica las limitaciones, como se muestra en la siguiente tabla: Observaciones (limitaciones) Modelo (s) (predicados good_path omitido)
{} {:- testpulse_readout_ok.} {:- beam_readout_ok.} {:- beam_readout_ok. :- testpulse_readout_ok.} {:- not beam_readout_ok.} {:- not beam_readout_ok. :- not testpulse_readout_ok.} {bad(crystal), testpulse_readout_ok}, {bad(apd)} {bad(apd)} {bad(crystal), testpulse_readout_ok}, {bad(apd)} {bad(apd)}

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

ningn modelo ningn modelo

Descargar el programa ejemplo.

El Mono y Banana Ejemplo: Planificacin

En el ejemplo siguiente dar una idea de cmo DLV se puede utilizar para hacer la planificacin. Tenga en cuenta que hay un DLV interfaz de planificacin que usa una conveniente para fines de planificacin lenguaje especial y que no se describe en este tutorial. En su lugar, utilizamos normal disyuntiva de registro de datos para resolver problemas de planificacin aqu. Si usted est interesado en este interfaz, consulte el DLV pgina de inicio para ms informacin. Consideremos el clsico problema de planificacin siguiente. Un mono est en una habitacin con una silla y un pltano, que se fija al techo. El mono no puede alcanzar el pltano, 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) ::- stands_on_chair(T), :- stands_on_chair(T), stands_on_chair(T2) :ascend(T), T2 = T + 1. ascend(T). monkey_motion(T). 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) v monkey_at_place(chair_starting_point, T) v monkey_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) ::- stands_on_chair(T), :- stands_on_chair(T), stands_on_chair(T2) :ascend(T), T2 = T + 1. ascend(T). monkey_motion(T). 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) v monkey_at_place(chair_starting_point, T) v monkey_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).