Embed Size (px)
Citation preview
Dr. Fernando Zacarías Flores
Facultad de Ciencias de la Computación
Benemérita Universidad Autónoma de Puebla
Sistema DLV
DLV es un sistema de base de datos deductivas
basado en programación lógica
ofreciendo varios Front-Ends
.ctE
TLD
K-VLD
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: Panorama General
-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
DLV: Front-Ends
-- 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 Generales
-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.
Opciones de Salida
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.-OM- Modo checador de modelos especiales. No para uso general!-OMb[-] El chequeo de Modelos emplea una nueva tecnica de backtracking.-OP- Disable partial model checking.-OPf Chequeo parcial de modelos "hacia adelante".-OPb Chequeo parcial de modelos durante el backtracking.
-OR -OGp -OGo2 -OGs -OH -OMb -OPb
El lenguaje de DLV es Datalog Disyunctivo extendido con
restricciones
negación verdadera
queries
Opciones de Default
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.
DLV: El corazón del lenguaje
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:
a b d
c arc(a,b). arc(b,c). arc(b,d).
$ DLV -silent e1.dlv
{arc(a,b), arc(b,c), arc(b,d)}
$ DLV -silent -nofacts e1.dlv
{}
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).
:- color(apple,red), color(apple,green).
:- -saludable(X), not enfermo(X).
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.
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.
$ 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)}
comparc(X,Y) :- node(X), node(Y), not arc(X,Y).
node(X) :- arc(X,_).
node(Y) :- arc(_,Y).
DLV: Reglas disyuntivas
node(X) :- arc(X,_). node(Y) :- arc(_,Y).
$ 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)}
color(X,rojo) v color(X,verde) v color(X,azul) :- node(X).
DLV: Reglas negativas
node(X) :- arc(X,_). node(Y) :- arc(_,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)}
comparc(X,Y) :- node(X), node(Y), not arc(X,Y).
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.
DLV: Reglas negativas y recursión
bad :- not bad. $ DLV -silent bad
cruza_calle :- not viene_auto.
DLV: Negacion cierta vs. Negación como falla
$ 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.
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).
Solución:
$ dlv –silent nodo5
col(Edo,rojo) v col(Edo,azul) v col(Edo,verde):- estado(Edo).
:- colindan(Edo1,Edo2), col(Edo1,Color), col(Edo2,Color).
DLV: Criterio de consistencia
$ DLV -silent –nodo2
El programa tiene inconsistencias por tanto no tiene
modelos.
Sea P el programa siguiente:
a.
-a.
DLV: Restricciones de integridad
Las reglas disyuntivas sirven como generadores de diferentes
modelos y las restricciones son usadas para seleccionar solo
los modelos deseados.
:- arc(X,Y), color(X,C), color(Y,C).
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).
Espacio de
busqueda
$ 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.
• 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.
Sintácticamente son:
:~ Conj. [Weight:Level]
• Su violación no elimina los modelos
• Estas restricciones se deben satisfacer de ser posible.
• Son llamados los mejores modelos de (P, W).
DLV: Restricciones débiles (cont.)
Sintácticamente son:
:~ Conj. [Weight:Level]
• Los pesos y los niveles de prioridad pueden ser variables
donde Conj es una conjunción de (posiblemente negados)
literales, y Weight y Level son enteros positivos.
DLV: Restricciones débiles Ejemplo
Sea P. a v b.
c :- b.
:~ a.
:~ 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.
Dado que sus pesos y
niveles son omitidos, el
valor de default es 1
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). DEBE CONTENER
A TODOS LOS NODOS
:~ in_tree(X,Y,C). [C:1]
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).
b) Ningún matrimonio debe estar en el mismo grupo.
:~ assign(X,P), assign(Y,P), married(X,Y).
c) Los miembros de un grupo deben conocerle en lo posible.
:~ assign(X,P), assign(Y,P), X<>Y, not know(X,Y).
d) Es más importante a) que b) y c)
EJECUTAR EQUIPO.DLV
[:1]
[:2]
[:1]
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.
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
number(X) :- #int(X).
lessthan(A,B) :- #succ(A,B).
lessthan(A,C) :- lessthan(A,B), #succ(B,C).
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
weekday(1..7).
Es equivalente a:
weekday(1). weekday(2). weekday(3).
weekday(4). weekday(5). weekday(6).
weekday(7).
Podemos usar en lugar de -N
#maxint=19.
bignumber(#maxint).
pred(X..Y).
DLV: Predicados de agregación
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
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.
DLV: Predicados de agregación (cont.)
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.
Los terminos 0, 2, 3, G, W son llamados guardias
Los guardias pueden ser numeros o variables
DLV: Conjuntos simbólicos
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
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) .
DLV: Significado informal de conjunto
simbólico
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)>}
{V : d(V,3)}
DLV: ODBC interface
#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
El comando #import y #export
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 SQL-
Condition 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.
Agent: General architecture
Simple Strategy
Complex Strategy
The game’s board
Available cells
Busy cells
Tokens to move
Execute DLV
Agent’s Knowledge
Action to execute
Front-End
JAVA
Back-End DLV
g(X,Y,r), se trata de un tiro ganador.
b(X,Y,r), se trata de un bloqueo a una línea de 3.
c(X,Y,r), se trata de un bloqueo a una línea de 2.
t(X,Y,r), se trata de avanzar una línea de 2 a 3.
s(X,Y,r), se trata de avanzar una línea de 1 a 2.
p(X,0,r), se trata hacer un tiro en la primera línea.
Ejemplos:
Conecta 4 (FOUR)
Dominó (Colaborativo)
