Dr. Fernando Zacarías Flores Facultad de Ciencias de la ...zacarias/FZF/DLV-fzf-OLD.pdfRestricciones. Reglas en las cuales la cabeza es vacía. El elemento neutral de la disyunción

Dr. Fernando Zacarías Flores

Facultad de Ciencias de la Computación

Benemérita Universidad Autónoma de Puebla

[email protected]

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.


{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.


{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


color(a,azul), color(b,azul), color(c,azul), color(d,azul)}


color(a,verde), color(b,azul), color(c,azul), color(d,azul)}


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



{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.


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


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


{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

e2.bat

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)}


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)}


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)}


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)

../../../../Documents and Settings/Fernando/Escritorio/Acceso directo a Cuatro.lnk

../../../../Documents and Settings/Fernando/Escritorio/Acceso directo a Domino.lnk