ProLog 2

Document Sample
ProLog 2 Powered By Docstoc
					ProLog 2
                     Listas
• ¿Cómo se arma una lista?
• Lista vacía []
• Lista no vacía [X, Y, Z, … ] donde X,Y,Z
  son elementos.
• Lista no vacía [X, Y, Z, …| L ] donde X,Y,Z
  son elementos y L es una lista.
• Ejemplos [1], [1 | [ ] ], [1,2 | [3] ],
           [ [1], [1 | [ ] ], [1,2 | [3] ] | [4,5] ]
                       Listas
lista([]).
lista([X|XS]) :- lista(XS).
long([],cero).
long([X|XS],suc(Z)) :- long(XS,Z).
long([],cero).
long([X|XS],Z) :- long(XS,Z), Z is Y+1.
long([],0).
long([X|XS],Z) :- long(XS,Z) , Z is Y+1.
long([],0).
long([X|XS],Z) :- , Z is Y+1, long(XS,Z).
                 Listas

• append(-X,+Y,+Z).
                 Listas
append([],L,L).
append([X|XS],L,[X|R]) :- append(XS,L,R).
            Generate & test
La intuición es aprovechar el orden de evaluación
    de Prolog (de arriba para abajo y de derecha a
    izquierda con DFS), para definir la siguiente
    estrategia para resolver problemas:

1. Generar todas las posibles candidatas a
   soluciones.
2. Filtrar las respuestas obtenidas en 1
   verificando que realmente cumplen las
   condiciones de solución y obteniendo la
   respuesta buscada.
               Generate & test
Esto a veces es más sencillo que crear la solución
   ya formada.

•   Es más fácil verificar la primalidad, antes que hallar un
    número primo.
•   Ver si un conjunto de números es una factorización en
    primos de un número dado, antes que factorizarlo.
•   Ver si una matriz es un cuadrado latino, antes que
    obtener un cuadrado latino.
•   Ver que una sucesión de proposiciones es una
    demostración, antes que encontrar una demostración.
            Generate & test
Esquema general
Un predicado que utiliza generate & test
   consta de dos partes:

predicado(X) :- generate(X), test(X).
•   “generate” instanciará la variable X.
•   “test” verificará si X es o no una solución
    válida, puede asumir que la variable está
    instanciada.
           Generate & test
Ejemplo de un generador (Entre)

El predicado
entre(+X, +Y, -Z)
devuelve todos los Z entre X e Y.

Pensarlo unos minutos…
           Generate & test
Solución

entre(X,Y,X):- X=<Y.
entre(X,Y,Z):-
   X<Y,
   W is X+1,
   entre(W,Y,Z).
            Generate & test
Un problema
Generar los pares menores a X.

Nuevamente unos minutos para pensarlo, con la
   siguiente ayudita:

par(X):- 0 is X mod 2.
         Generate & test
Una solución

paresMenoresA(X, Y) :-
   entre(0,X,Y),      %generación
   par(Y).            %testeo
 Soluciones repetidas repetidas
usaJogging(pablo).
usaJogging(alejo).
programaBien(pablo).
programaBien(diego).
programaBien(alejo).
esWinner(pablo).
esWinner(diego).
puedeSerGroso(X) :- programaBien(X).
puedeSerGroso(X) :- esWinner(X).
esGroso(X):- puedeSerGroso(X),usaJogging(X).
 Soluciones repetidas repetidas
Consulta

?- esGroso(X).

Pensar unos minutos qué respuestas daría
  y en qué orden.
Soluciones repetidas repetidas
Respuestas:

X = pablo ;
X = alejo ;
X = pablo ;
No
   ¿Cómo evitar repeticiones?
1. Usar cláusulas excluyentes

puedeSerGroso2(X):- programaBien (X).
puedeSerGroso2(X):- esWinner(X),
   not(programaBien(X)).


(¡OJO CON EL ORDEN! primero instanciamos los
    Winners y luego los filtramos)

esGroso2(X) :- puedeSerGroso2(X),
   usaJogging(X).
  ¿Cómo evitar repeticiones?
probemos…

?- esGroso2(X).
X = pablo ;
X = alejo ;
No
   ¿Cómo evitar repeticiones?
El metapredicado “not”

El not es un metapredicado (recibe un
    predicado cómo parámetro).
Falla si P tiene éxito.
Tiene éxito si P falla.
Pertenece al los aspectos extralógicos del
    lenguaje.
   ¿Cómo evitar repeticiones?
2. Otra forma de evitar repeticiones
usando setOf y member

setof(X, p(X), L) devuelve en L todos
   los valores de X que cumplen con el
   predicado p.

member(X, L) dice si X es miembro de L.
  ¿Cómo evitar repeticiones?
esGroso3(X):-
  setof(Y, puedeSerGroso(Y), L),
    member(X,L),
    usaJogging(X).
 Soluciones repetidas repetidas
Analizar la siguiente definición.

Queremos definir el predicado
  imparOPrimo(X,N), que es
  verdadero si X es impar o primo
  menor que N.

imparOPrimo(X,N) :- entre(0,N,X), impar(X).
imparOPrimo(X,N) :- entre(0,N,X), primo(X).
Soluciones repetidas repetidas
?- imparOPrimo(X,5).
X = 1;
X = 3;
X = 5;
X = 2;
X = 3;
X = 5;
Soluciones repetidas repetidas
?- imparOPrimo(X,5).
X = 1;
X = 3;
X = 5;
X = 2;
X = 3;
X = 5;

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:5
posted:11/26/2011
language:Spanish
pages:23