b, c - Facultad de Ciencias de la Computación

Sistema DLV
Dr. Fernando Zacarías Flores
Facultad de Ciencias de la Computación
Benemérita Universidad Autónoma de Puebla
[email protected]
DLV: Panorama General
DLV es un sistema de base de datos deductivas
basado en programación lógica
ofreciendo varios Front-Ends
DLV-K
DLT
Etc.
DLV: Panorama General
Uso: DLV {FRONTEND} {OPTIONS} [filename [filename [...]]]
dlv -help
Muestra los diferentes parametros permitidos
Front-Ends
Opciones generales
Opciones de salida
Optimizaciones
Opciones de default
DLV: Front-Ends
-FB
Rasonamiento Bravo
-FC
Rasonamiento Cauteloso
-FD
Diagnostico Abductive
-FDmin
Diagnostico Abductive, subconjunto minimo
-FDsingle
Diagnostico Abductive, error simple
-FR
Diagnostico de Reiter
-FRmin
Diagnostico de Reiter, subconjunto minimo
-FRsingle
Diagnostico de Reiter, error simple
-FP
Planeacion con Languajes de accion "K"
-FPopt
...encuentra planes optimistas por lotes
-FPsec
...encuentra planes seguros por lotes
-FPc
Planeación con lenguajes de acción "C"
-FPcheck=<n>
Método de chequeo seguro <n>.
-FPsoundcheck=<n>
Metodo de chequeo seguro sólido.
-FPcompletecheck=<n> Método de chequeo completamente seguro.
-planlength=<N>
Longitud maxima del plan por planear el frontend.
-plancache=<N> Tamaño del plan (numero de planes, defaults a 10000)
-FS
SQL3
Opciones Generales
-Lee entrada desde stdin.
-costbound=<N,..,N> Encuentra modelos con costo <= <N,..,N>
(N=_ indica que ningun límite es requerido).
-det
Solo calcula las consecuencias deterministicas.
-instantiate
Solo establece e imprime la instanciacion.
-n=<n>
Calcula a lo más <n> modelos estables
(-n=0 y -n=all da todos).
-N=<N>
Limita los enteros a [0,<N>].
-wait
Antes de terminar, espera hasta que Return es presionado.
Opciones de Salida
-filter=<X> Incluye solo instancias de predicado <X> en la salida.
-pfilter=<X> Incluye solo instancias positivas del predicado <X>
en la salida.
-facts
Incluye hechos como parte deola salida.
-nofacts
No incluye hechos como parte de la salida.
-license
Imprime la licencia de este programa.
-silent
Suprime el encabezado superior y lineas en blanco.
-stats
Imprime estadisticas y tiempos considerando el computo.
-v
Es un poco mas verboso que el usual.
-wctrace
Imprime todos (posiblemente no optimos) los modelos
durante el calculo de restricciones debiles.
Optimizaciones
-O0
Desabilita todas las optimizaciones.
-OR[-]
Reescribe la entrada.
-OGp[-] Usa instanciador especial para entradas proposicionales.
-OGo(0|1|2) Ejecuta instanciación (no|simple|advanced)
dinamica reordenando el cuerpo.
-OGs
Emplea instanciación con evaluación semi-ingenua.
-OH[-]
Heuristicas.
-OMModo checador de modelos especiales. No para uso general!
-OMb[-] El chequeo de Modelos emplea una nueva tecnica de
backtracking.
-OPDisable partial model checking.
-OPf
Chequeo parcial de modelos "hacia adelante".
-OPb
Chequeo parcial de modelos durante el backtracking.
Opciones de Default
-OR -OGp -OGo2 -OGs -OH -OMb -OPb
El lenguaje de DLV es Datalog Disyunctivo extendido con
restricciones
negación verdadera
queries
DLV: El corazón del lenguaje
Constantes .- letra_minuscula, underscores y digitos.
Numeros.
Nota 1: not es una palabra reservada y no una constante valida.
Variables.- letra_mayuscula, underscores y digitos.
variable anonima denotada por "_" (underscore)
Nota 2; Cada ocurrencia de _ representa una nueva y unica variable,
Término: Es o una constante o una variable.
Constantes: a1, 1, 9862, aBc1, c__
Variables:
A, V2f, Vi_X3
DLV: El Lenguaje
Predicados
ord, oBp, r2D2, E_mc2
Atomos
a, b(8,K), weight(X,1,kg)
Literales
-a
not ~b(8,K)
not weight(X,1,kg)
Hechos
weight(apple,100,gram).
-valid(1,equals,0).
DLV: EDB
Combina las base de datos y la programación lógica. Por
esta razón, DLV puede ser visto como un sistema de base
de datos deductiva.
Podemos importar hechos de bases de datos relacionales
usando el ODBC
La EDB puede contener solo hechos:
arc(a,b).
c
arc(b,c).
arc(b,d).
$ DLV
-silent
e1.dlv
$ DLV
-silent
-nofacts
e1.dlv
a
b
d
{} {arc(a,b), arc(b,c), arc(b,d)}
DLV: IDB
El conocimiento contenido en IDB puede depender de EDB
-ok :- not -hazard.
male(X) v female(X) :- person(X).
fruit(P) v vegetable(P) :- plant_food(P).
true v false :- .
employee(P) :- personnel_info(_,P,_,_,_).
$ DLV -silent e2.dlv
{-ok, false}
{-ok, true}
DLV: Hechos disyuntivos
true v false.
comestible(apple) v sucio(apple).
Restricciones. Reglas en las cuales la cabeza es vacía.
El elemento neutral de la disyunción es la falsedad.
El cuerpo de una restricción no puede llegar a ser verdad
Porque la cabeza no puede nunca ser verdad.
Estas dan la seguridad a las bases de datos.
:- color(apple,red), color(apple,green).
:- -saludable(X), not enfermo(X).
En resumen: un programa
DLV consiste de hechos,
reglas y restricciones
DLV: Reglas definite (positivas)
Hechos:
horno_caliente.
valvula_cerrada.
Supongamos ahora la siguiente regla positiva:
alarma_on :- horno_caliente, valvula_cerrada.
$ DLV -silent –nofacts engine alarm
{alarm_on}
DLV: Reglas definite (cont.)
Hechos:
horno_caliente.
valvula_cerrada.
Supongamos ahora la siguiente regla positiva:
alarma_on :- horno_caliente, valvula_cerrada.
$ DLV -silent –nofacts engine alarm
{alarm_on}
DLV: Reglas definite (positivas)
path(X,Y) :- arc(X,Y).
path(X,Y) :- path(X,Z), arc(Z,Y).
Note que X, Y, y Z son variables. El nombre de una
variable es una secuencia de letras, underscores y
digitos, iniciando con una letra mayuscula. El nombre de
un predicado puede ser cualquier secuencia de letras,
underscores y digitos, iniciando con una letra minuscula.
$ DLV -silent –nofacts engine alarm
{alarm_on}
DLV: Enmascaramiento y variables anónimas
node(X) :- arc(X,Y).
node(Y) :- arc(X,Y).
Algunas veces deseamos usar una variable para enmascarar
un argumento que no es usado en el resto de la regla.
comparc(X,Y) :- node(X), node(Y), not arc(X,Y).
node(X) :- arc(X,_).
node(Y) :- arc(_,Y).
$ DLV -silent –nodo
{arc(a,b), arc(b,c), arc(b,d), node(a), node(b), node(c), node(d),
comparc(a,a), comparc(a,c), comparc(a,d), comparc(b,a), comparc(b,b),
comparc(c,a), comparc(c,b), comparc(c,c), comparc(c,d), comparc(d,a),
comparc(d,b), comparc(d,c), comparc(d,d)}
DLV: Reglas disyuntivas
node(X) :- arc(X,_). node(Y) :- arc(_,Y).
color(X,rojo) v color(X,verde) v color(X,azul) :- node(X).
$ DLV -silent –nodo1
{arc(a,b), arc(b,c), arc(b,d), node(a), node(b), node(c), node(d),
color(a,azul), color(b,azul), color(c,azul), color(d,azul)}
{arc(a,b), arc(b,c), arc(b,d), node(a), node(b), node(c), node(d),
color(a,verde), color(b,azul), color(c,azul), color(d,azul)}
{arc(a,b), arc(b,c), arc(b,d), node(a), node(b), node(c), node(d),
color(a,rojo), color(b,azul), color(c,azul), color(d,azul)}
DLV: Reglas negativas
Aquí comparc describe el conjunto de arcos en el grafo
complementario. Uno nodo debe ir de un nodo a otro
(posiblemente a el mismo), y este arco no debe estar contenido
en el conjunto de arcos original. Las variables de una literal
negada tambien deben aparecer en una literal positiva.
node(X) :- arc(X,_). node(Y) :- arc(_,Y).
comparc(X,Y) :- node(X), node(Y), not arc(X,Y).
$ DLV -silent –nodo2
{arc(a,b), arc(b,c), arc(b,d), node(a), node(b), node(c),
node(d), comparc(a,a), comparc(a,c), comparc(a,d),
comparc(b,a), comparc(b,b), comparc(c,a), comparc(c,b),
comparc(c,c), comparc(c,d), comparc(d,a), comparc(d,b),
comparc(d,c), comparc(d,d)}
DLV: Reglas negativas y recursión
bad :- not bad.
$ DLV -silent bad
DLV: Negacion cierta vs. Negación como falla
cruza_calle :- not viene_auto.
$ DLV –silent nodo4
{cruza_calle}
cruza_calle :- -viene-auto.
$ DLV –silent nodo4
{}
En nuestro contexto los
modelos inconsistentes no
existen
Problema:
Colorear un mapa de tal forma que podamos distinguir
los límites de cada uno de los estados, para esto asignar un color de
tres posibles a cada estado, talque dos estados colindantes siempre
tengan colores diferentes.
Solución:
node(X)
col(Edo,rojo)
:- arc(X,_).
v col(Edo,azul)
node(Y) :-v arc(_,Y).
col(Edo,verde):- estado(Edo).
color(X,red)
:- colindan(Edo1,Edo2),
v color(X,green)
col(Edo1,Color),
v color(X,blue)
col(Edo2,Color).
:- node(X).
:- arc(X,Y), color(X,C), color(Y,C).
$ dlv –silent nodo5
DLV: Criterio de consistencia
Sea P el programa siguiente:
a.
-a.
$ DLV -silent –nodo2
El programa tiene inconsistencias por tanto no tiene
modelos.
DLV: Restricciones de integridad
Las reglas disyuntivas sirven como generadores de diferentes
modelos y las restricciones son usadas para seleccionar solo
los modelos deseados.
Espacio de
busqueda
Retomemos el ejemplo anterior de colorear el mapa
node(X) :- arc(X,_).
node(Y) :- arc(_,Y).
color(X,red) v color(X,green) v color(X,blue) :- node(X).
:- arc(X,Y), color(X,C), color(Y,C).
$ DLV -silent –nodo2
{node(1), node(2), node(3), node(4), color(1,red), color(2,green),
color(3,red), color(4,red)}
[... Etc. ...]
DLV: Restricciones y negación
Sea P el siguiente programa:
a v b.
:- not a.
{a} es un modelo de P pero, {b} no lo es
a v b.
:- -a.
{a} y {b} son modelos dado que –a no esta en
ningun modelo
Paradigma Suposición & Chequeo
Idea: codificar un problema de búsqueda PROB mediante
un programa ASP denominado P.
– Los answer sets de P corresponden uno a uno a las soluciones
de PROB.
• Metodología:
– Programación basada en generación y prueba.
• Genera: posibles estructuras
• Elimina las soluciones no deseadas agregando restricciones
• Separa datos del programa
Suposición & Chequeo: ASP
• Reglas disyuntivas suponen soluciones candidatas
• Restricciones de integridad checan su admisibilidad
Desde otra perspectiva
Reglas disyuntivas definen el espacio de búsqueda
Restricciones de integridad podan ramas ilegales
Optimización y Restricciones
Expresa deseos – Restricciones que deben ser
satisfechas, como restricciones suaves en CSP.
:~ B.
• Evite B si es posible.
Restricciones débiles pueden ser de peso y prioritizadas:
:~ B. [w:p]
• más alto peso(w)/prioridad(p)  más alta importancia
Una herramienta útil para codificar problemas de
optimización.
DLV: Restricciones débiles
• Nos permite formular problemas de optimización de una
manera fácil y natural.
• Estas restricciones se deben satisfacer de ser posible.
• Su violación no elimina los modelos
• Los answer sets de un programa P con un conjunto W
de restriccions débiles son aquellos answer sets de P los
cuales minimizan el número de restriccions débiles violadas.
• Son llamados los mejores modelos de (P, W).
Sintácticamente son:
:~ Conj. [Weight:Level]
DLV: Restricciones débiles (cont.)
Sintácticamente son:
:~ Conj. [Weight:Level]
donde Conj es una conjunción de (posiblemente negados)
literales, y Weight y Level son enteros positivos.
• Los pesos y los niveles de prioridad pueden ser variables
DLV: Restricciones débiles Ejemplo
Sea P. a v b.
c :- b.
:~ a.
Dado que sus pesos y
niveles son omitidos, el
valor de default es 1
:~ b.
:~ c.
Note que los answer sets de { a v b. c :- b. } son {a} y {b, c}.
Pero, la presencia de restricciones débiles descarta {b, c}
porque este viola dos restricciones débiles
mientras {a} solo viola una restricción débil.
DLV: Restricciones débiles con pesos
Calcula el árbol de expansión mínima de un grafo dirigido con pesos
root(a).
RAÍZ
node(a). node(b). node(c). node(d). node(e). edge(a,b,4). edge(a,c,3).
edge(c,b,2). edge(c,d,3). edge(b,e,4). edge(d,e,5).
NODOS Y EJES
in_tree(X,Y,C) v out_tree(X,Y) :- edge(X,Y,C), reached(X). ESPACIO DE
BUSQUEDA
:- root(X), in_tree(_,X,C).
RAÍZ FUERA
:- in_tree(X,Y,C), in_tree(Z,Y,C), X != Z.
CHECA UNICIDAD
reached(X):- root(X).
BUSCA CAMINO
reached(Y):- reached(X), in_tree(X,Y,C).
:- node(X), not reached(X).
:~ in_tree(X,Y,C). [C:1]
DEBE CONTENER
A TODOS LOS NODOS
Calcula el árbol de expansión mínima de un grafo dirigido con pesos
(CONT.)
$ DLV -silent -nofacts min_sp_tree
Best model: {reached(a), out_tree(a,b), in_tree(a,c,3), reached(b),
reached(c), in_tree(b,e,4), in_tree(c,b,2), in_tree(c,d,3), reached(e),
reached(d), out_tree(d,e)}
Cost ([Weight:Level]): <[12:1]>
Restricciones con pesos y prioridades
$ DLV -silent -nofacts min_sp_tree
Best model: {reached(a), out_tree(a,b), in_tree(a,c,3), reached(b),
reached(c), in_tree(b,e,4), in_tree(c,b,2), in_tree(c,d,3), reached(e),
reached(d), out_tree(d,e)}
Cost ([Weight:Level]): <[12:1]>
Construcción de equipos
Dividir los empleados en dos grupos para los proyectos p1 y p2.
assign(X,proj1) v assign(X,proj2) :- employee(X).
a)
Las habilidades de los miembros de un grupo deben ser diferentes
:~ assign(X,P), assign(Y,P), same_skill(X,Y). [:2]
b)
Ningún matrimonio debe estar en el mismo grupo.
:~ assign(X,P), assign(Y,P), married(X,Y). [:1]
c)
Los miembros de un grupo deben conocerle en lo posible.
:~ assign(X,P), assign(Y,P), X<>Y, not know(X,Y). [:1]
d)
Es más importante a) que b) y c)
EJECUTAR EQUIPO.DLV
Planificación de exámenes
1.
Asignar los exámenes del curso cronometrándolos para
evitar traslape de exámenes de alumnos comunes a varios
de éstos.
assign(X,time1) v ... v assign(X,time5) :- course(X).
:- assign(X,Time), assign(Y,Time), commonStuds(X,Y,N), N>0.
2.
Si el traslape es inevitable, entonces reducirlo
“tanto como sea posible”
encontrando una solución aproximada:
:~ assign(X,S), assign(Y,S), commonStudents(X,Y,N). [N:]
Los escenarios que minimicen el número total de “pérdida” de
examenes son preferidos.
EJECUTAR EJEM2.DLV
Programación GCO:
Guess/Check/Optimize
Generalización of los paradigmas Guess y Check.
Los programas consisten de 3 módulos:
[Parte suposición] define el espacio de búsqueda;
[Parte Chequeo] checa solución admisible;
[Parte Optimización] especifica criterio de preferencia
(por medio de restricciones débiles).
Tip: Desarrolle la codificación incrementalmente!
Agente viajero
inPath(X,Y) v outPath(X,Y) :- arc(X,Y,Cost). Guess
:- inPath(X,Y), inPath(X,Y1), Y <> Y1.
:- inPath(X,Y), inPath(X1,Y), X <> X1. Check
:- node(X), not reached(X).
reached(X) :- start(X).
Predicado auxiliar
reached(X) :- reached(Y), inPath(Y,X).
+ Optimización
:~ inPath(X,Y), arc(X,Y,Cost). [Cost:]
Optimiza
DLV: Optimización -costbound
Si especifica -costbound=weight[,weight]
Todos los modelos con un costo  costbound seran
calculados.
Note que no todos los modelos calculados seran los
mejores modelos.
_ especifica que el peso no tiene limite
Por ejemplo:
DLV -costbound=13 spanning.dlv
DLV: Predicados comparativos
Las constantes pueden ser comparadas usando:
<, >, <=, >=, =, !=
Construcción de predicados comparativos:
in_range(X,A,B) :- X>=A, <(X,B).
pair(X,Y) :- Y>X, color(X,green), color(Y,green).
Pair es una relación asimétrica.
Si pair(A,B) sucede, pair(B,A) no.
No existe ningún “A” talque pair(A,A) suceda.
DLV: Predicados aritméticos
#int, #succ, +, *
• #int(X) es cierto, iff X es un entero conocido
(i.e.0<=X<=N).
• #succ(X, Y) is true, iff X+1=Y sucede
• +(X,Y,Z), o alternativamente: Z=X+Y es cierto,
iff Z=X+Y sucede.
• *(X,Y,Z), o alternativamente: Z=X*Y es cierto, iff
Z=X*Y sucede.
DLV: Predicados aritméticos Ejemplos
fibonacci(1, 1).
fibonacci(1, 2).
fibonacci(F, Index) :- +(F1, F2, F),
fibonacci(F1, Index1), fibonacci(F2, Index2),
#succ(Index1, Index2), #succ(Index2, Index).
Si ejecutamos:
dlv –N=235 a
{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), fibonacci(144,12), fibonacci(233,13)}
DLV: Predicados aritméticos Ejemplos
cont.
weight(X,KG,kilogram) :- weight(X,G,gram),*(G,1000,KG).
product(X) :- X=P*Q.
productOfPrimes(X) :- X=P*Q, P>1, Q>1.
prime(A) :- #int(A), not productOfPrimes(A).
Si ejecutamos: DLV –N=10 a
{productOfPrimes(4), productOfPrimes(6),
productOfPrimes(8), productOfPrimes(9),
productOfPrimes(10)}
DLV: Predicados aritméticos Ejemplos
cont.
weight(X,KG,kilogram) :- weight(X,G,gram),*(G,1000,KG).
product(X) :- X=P*Q.
productOfPrimes(X) :- X=P*Q, P>1, Q>1.
prime(A) :- #int(A), not productOfPrimes(A).
Si ejecutamos: DLV –N=10 a
{productOfPrimes(4), productOfPrimes(6),
productOfPrimes(8), productOfPrimes(9),
productOfPrimes(10)}
DLV: Predicados aritméticos Ejemplos
cont.
number(X) :- #int(X).
lessthan(A,B) :- #succ(A,B).
lessthan(A,C) :- lessthan(A,B), #succ(B,C).
Ejercicio:
Construir la función división y módulo
División y módulo
div(X,Y,Z) :- XminusDelta = Y*Z, X = XminusDelta +
Delta, Delta < Y.
mod(X,Y,Z) :- div(X,Y,XdivY), XminusZ = XdivY * Y,
X = XminusZ + Z.
EJECUTAR B
Camino Hamiltoniano
Entrada: Un grafo dirigido representado por node(_) y
arc(_,_), y un nodo inicial start(_).
Problema: Encontrar un camino partiendo del nodo inicial start(_) que
contenga todos los nodos del grafo.
Codificación: CAMINO HAMILTONIANO
inPath(X,Y) v outPath(X,Y) :- arc(X,Y). Espacio búsqueda
:- inPath(X,Y), inPath(X,Y1), Y <> Y1.
:- inPath(X,Y), inPath(X1,Y), X <> X1. Checar
:- node(X), not reached(X).
reached(X) :- start(X). Predicados Auxiliares
reached(X) :- reached(Y), inPath(Y,X).
Compañía estratégica
Entrada: Hay varios productos, cada uno es producido por varias
compañías.
Problema: Tenemos que vender algunas compañías.
Cuáles son los conjuntos mínimos de las compañías estratégicas, tales
que todos los productos puedan todavía ser producidos?
Una compañía también pertenece al conjunto, si todas sus compañías
controladas pertenecen a esta.
strategic(Y) v strategic(Z) :- produced_by(X, Y, Z). Esp. Bús.
strategic(W) :- controlled_by(W, X, Y, Z), Restricciones
strategic(X), strategic(Y), strategic(Z).
DLV: Hechos sobre un rango fijo
pred(X..Y).
weekday(1..7).
Es equivalente a:
weekday(1).
weekday(4).
weekday(7).
weekday(2).
weekday(5).
Podemos usar en lugar de -N
#maxint=19.
bignumber(#maxint).
weekday(3).
weekday(6).
DLV: Predicados de agregación
Los predicados de agregación premiten expresar
propiedades sobre un conjunto de elementos. Pueden
ocurrir en los cuerpos de las reglas, restricciones y
posiblemente negados usando negación como fallo.
q(X) :- 0 <= #count{X,Y : a(X,Z,k),b(1,Z,Y)} <= 3.
q(Y) :- 2 < #sum{V : d(V,Z)}, c(Z).
p(W) :- #min{S : c(S)} = W.
:- #max{V : d(V,Z)} >G, c(G).
Los conjuntos que aparecen entre llaves se llaman
CONJUNTOS SIMBOLICOS
#count, #sum, #times, #min, y #max son llamadas
funciones de agregación
DLV: Predicados de agregación (cont.)
Los terminos 0, 2, 3, G, W son llamados guardias
Los guardias pueden ser numeros o variables
Los guardias proveen un rango para comparar el valor
regresado por la función de agregado.
Si el valor esta en el rango entonces el predicado de
agregación es cierto, de otra manera es falso.
Si el guardia es una asignación, la función de
agregado es siempre cierto.
DLV: Conjuntos simbólicos
La sintaxis de un conjunto simbólico es:
{Vars : Conj}
Donde Vars es una lista de variables locales y Conj es una
conjuncción de literales (non-aggregate) .
Ejemplo:
q(Z) :- 1 < #count{X : a(X,Y,Z), not d(2,Y,goofie)}, c(Z).
La variable X y Y son locales
Aparecen en al menos una literal de Conj y no
aparece en cualquier parte fuera del conjunto
simbolico.
La variable Z es una variable global
2 y goofie son constantes
DLV: Significado informal de conjunto
simbólico
{V : d(V,3)}
La instanciación ground de este conjunto simbólico
consiste de los pares V,d(V,3) tal que d(V,3) es
cierto w.r.t. la interpretación actual.
Given an interpretation
I = {d(1,1), d(1,3), d(3,3)} the true instances of d(V,3)
w.r.t. I are
d(1,3)d(3,3)
hence the symbolic set is given by S = {<1,d(1,3)>,
<3,d(3,3)>}
DLV: ODBC interface
El comando #import y #export
#import Lee tuplas de una tabla especificada de una bd
relacional y almacena estos como hechos con un
nombre de predicado p definido por el usuario.
#export Permite exportar la magnitud de un predicado en
un AS a una BD
Todo predicado que sea cierto en el AS sera pioritario para
su insercion en la BD
DLV: #import
#import (databasename,"username","password","query",
predname, typeConv).
where:
1. databasename es el nombre del servidor de BD
2. username define el nombre del usuario quien se conecta a
la BD (la cadena debe ser encerrada entre " ");
3. password define el password del usuario (la cadena debe
ser encerrada entre " ");
4. query es una sentencia SQL que construye la tabla que
sera importda (y debe ser encerrada por " ");
5. predname define el nombre del predicado que sera usado;
6. typeConv especifica la conversion para mapear los tipos
de datos DBMS al tipo DLV; este provee una conversion
para cada columna importada por la BD
DLV: #export
Hay dos variantes, la primera es:
#export(databasename, "username", "password", predname,
tablename).
La segunda agrega otro parametro que es:
"REPLACE where SQL-Condition", which replaces the tuples in
the table tablename for which SQL-Condition holds
#export(databasename,"username","password",predname,
tablename,"REPLACE where SQL-Condition").
DLV: #export
#import (databasename,"username","password","query",
predname, typeConv).
•
databasename es el nombre del servidor de BD
•
username es el nombre del usuario quien se conecta a la
BD (la cadena encerrada entre " ");
•
password provee el password del usuario (cadena entre " ");
•
predname define el nombre del predicado que sera
exportedo
•
tablename define el nombre de la tabla;
•
"REPLACE where SQL-Condition" contienelas palabras
clave REPLACE y where seguida por una condicion SQLCondition que indica las tuplas que seran borradas de la
tabla de la BD antes de la exportacion
•
Remark: Export debe ser usada con la opcion -n=1.
Back-End DLV
Available cells
Simple Strategy
Complex Strategy
Busy cells
Agent’s Knowledge
Execute DLV
Action to execute
Agent: General architecture
Front-End
JAVA
The game’s board
Tokens to move
g(X,Y,r),
b(X,Y,r),
c(X,Y,r),
t(X,Y,r),
s(X,Y,r),
p(X,0,r),
se trata de un tiro ganador.
se trata de un bloqueo a una línea de 3.
se trata de un bloqueo a una línea de 2.
se trata de avanzar una línea de 2 a 3.
se trata de avanzar una línea de 1 a 2.
se trata hacer un tiro en la primera línea.
Ejemplos:
Conecta 4 (FOUR)
Dominó (Colaborativo)