1 / 58

Opciones de Default

Opciones de Default. 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.

rupali
Download Presentation

Opciones de Default

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Opciones de Default

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

  3. 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).

  4. c a d b 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). arc(b,c). arc(b,d). $ DLV -silent e1.dlv {arc(a,b), arc(b,c), arc(b,d)} $ DLV -silent -nofacts e1.dlv {}

  5. 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}

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

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

  8. 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}

  9. 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}

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

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

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

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

  14. Restricciones de integridad 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) :- 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). col(Edo,rojo) v col(Edo,azul) v col(Edo,verde):- estado(Edo). :- colindan(Edo1,Edo2), col(Edo1,Color), col(Edo2,Color). $ dlv –silent nodo5

  15. DLV: Criterio de consistencia Sea P el programa siguiente: a. -a. $ DLV -silent –nodo2 El programa tiene inconsistencias por tanto no tiene modelos.

  16. 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: 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). $ DLV -silent –nodo2 {node(1), node(2), node(3), node(4), color(1,red), color(2,green), color(3,red), color(4,red)} [... Etc. ...]

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

  18. 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 • Eliminalas soluciones no deseadas agregando restricciones • Separa datos del programa

  19. Suposición & Chequeo: ASP • Reglas disyuntivas suponen soluciones candidatas • Restricciones de integridad checansu admisibilidad Desde otra perspectiva Reglas disyuntivas definen el espacio de búsqueda Restricciones de integridad podan ramas ilegales

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

  21. 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]

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

  23. DLV: Restricciones débiles Ejemplo Sea P. a v b. c :- b. :~ a. :~ b. :~ c. Dado que sus pesos y niveles son omitidos, el valor de default es 1 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.

  24. 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]

  25. 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]>

  26. 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]>

  27. 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). • Las habilidades de los miembros de un grupo deben ser diferentes :~ assign(X,P), assign(Y,P), same_skill(X,Y). • Ningún matrimonio debe estar en el mismo grupo. :~ assign(X,P), assign(Y,P), married(X,Y). • Los miembros de un grupo deben conocerle en lo posible. :~ assign(X,P), assign(Y,P), X<>Y, not know(X,Y). • Es más importante a) que b) y c) EJECUTAR EQUIPO.DLV [:2] [:1] [:1]

  28. Planificación de exámenes • 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. • 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

  29. 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!

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

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

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

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

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

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

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

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

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

  39. 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).

  40. 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).

  41. DLV: Hechos sobre un rango fijo pred(X..Y). 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).

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

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

More Related