Tema IV Programación lógica con estructurasjmmb/declarativa/ApuntesPL2004/ProgLogicaIV.pdf · 3)...

Programación Lógica - E.T.S.I. Informática - Málaga 1

Tema IVTema IV

Programación lógica Programación lógica con estructurascon estructuras


Términos

La estructura de datos básica en PROLOG es el término.Los términos se clasifican en :

variablesno variables -> compuestos

atómicos -> átomosnúmeros

Las variables se denotan mediante palabras que comienzan por una letra mayúscula o por un guión de subrayado.

los átomos se denotan mediante palabras que comienzan por una letra minúscula.

Los números tienen la notación decimal habitual. Los términos compuestos tiene la forma general:

<funtor>(<argumentos>) , donde los argumentos también son términos separados por ‘,’ y el funtor es un átomo.


Predicados para la comprobación de tipos

Predicados predefinidos:

var(T) - Tiene éxito cuando T es una variable sin instanciar.nonvar(T) – Tiene éxito cuando T no es una variable sin instanciar.

compound(T) – Tiene éxito cuando T es un término compuesto.atomic(T) – Tiene éxito cuando T es un término atómico.

atom(T) – Tiene éxito cuando T es un átomo.number(T) - Tiene éxito cuando T es un número.

integer(T) – Tiene éxito cuando T es un número entero.float(T) - Tiene éxito cuando T es un número decimal.


Términos compuestos

Los términos compuestos se pueden ver como árbolesgenerales:

f(X,h(a,b,3)) ->f

X h

b 3a

Los términos compuestos pueden ser recursivos: cuando algún argumento es un término del mismo tipo.

Los téminos compuestos más simple son los registros, cuyos argumentos no son del mismo tipo.


Comparación de términos

PROLOG dispone de una relación de orden total @=< para la comparación de términos, consistente con el orden numérico y conel orden alfabético para los nombres de átomos (permite la aparición de variables libres)Xs == Ys éxito cuando Xs e Ys representan el mismo términoXs \== Ys éxito cuando Xs e Ys representan términos distintosXs @< Ys éxito cuando Xs representa un término menor que Ys Xs @> Ys éxito cuando Xs representa un término mayor que Ys Xs @=< Ys éxito cuando Xs representa un término menor o ig. que Ys Xs @>= Ys éxito cuando Xs representa un término mayor o ig. que Ys

(Tienen sentido para términos de la misma categoría)(No confundir con las relaciones numéricas)


Registros: fecha(Dia,Mes,Año)

% constructorcons_fecha(D,M,A,fecha(D,M,A)).% predicados de consultadia(fecha(D,_,_),D). %completar...% predicados para la modificaciónponer_dia(D,fecha(_,M,A),fecha(D,M,A)).... %completar

Ejercicios:1. Predicado para comprobar el dominio fecha:

es_fecha(fecha(D,M,A))2. Predicado para calcular la fecha siguiente a una dada:

dia_sig(fecha(D,M,A),F)


Las listas en PROLOG


Listas: . (Cabeza, Cola)

Las listas son términos compuestos recursivos que están predefinidos en PROLOG en la forma: . (Cabeza, Cola) , donde Cabeza es un término y Cola otra lista.

Hay una lista especial que no es un término compuesto: la listavacía [] .

PROLOG incorpora notaciones más simples para listas:[Cabeza | Cola] [][T1,T2, ...,Tn] []Mixtas: [T1,T2, ...,Tp | Cola]


Ejercicios de unificación de listas

[X|Y] [a,b,c][a,[b,c]] [X|Y][[a,b],c] [X|Y][a|X] [Y|a][a|X] [Y|[c]][a|X] [Y][a,b,Y] [X,T][a,b,Y] [X|T][a,b|Y] [X,T][a,b|[Y]] [a,b,c][a,b|[Y]] [a,b,c,d][a,b|Y] [a,b,c,d]


Árboles de búsqueda con listas

Desarrollar el árbol de búsqueda correspondiente al programa siguiente:

p([],[]).p([X|Xs],[Y|Ys]):-q(X,Y),p(Xs,Ys).q(a,b).q(a,Y):-s(X),s(Y).q(a,c).q(b,b).s(a).s(b).

:-p([a,X],[X,b]).


Predicados sobre listas (I)

Definir y estudiar los posibles usos de los siguientes predicados:

% dominio de listas: es_lista/1es_lista([]).es_lista([_|_]).

% prefijo(Prefijo,Lista)

% sufijo(Sufijo,Lista)

% sublista(Sublista,Lista)

% miembro(Termino,Lista)

% seleccion(Termino,Lista,ListaResto)


Prefijo

% La lista vacía es prefijo de cualquier lista:

prefijo([],L):- es_lista(L).

% Una lista no vacía es prefijo de otra lista:

prefijo([X|Xs], )

no vacía

[ | ]

con el mismo primer elemento

X

si su cola es prefijo de la cola de la otra lista

Ls :- prefijo(Xs,Ls).


Predicados sobre listas (II)

Predicado para encadenar dos listas:encadena(As,Bs,AsBs)

Definición atendiendo a la estructura del primer argumento:

% La lista vacía encadenada con otra lista produce la otra:

encadena([],Bs,Bs).

% Una lista no vacía encadenada con otra lista produce una lista:

encadena([A|As],Bs, )

no vacía

[ | ]

con el mismo primer elemento

A

cuya cola es la concatenación de su cola con la otra lista

AsBs :-

encadena(As,Bs,AsBs).


Tabla de comportamiento de encadena/3

Genera listas de variables libres para As, Bs queda libre y paraAsBs la concatenación de ambas.

Generador infinito (anómalo)

(-,-,-)

Genera todas las posibles particiones de AsBs en As y Bs

Generador acotado

(-,-,+)

Genera el sufijo Bs que encadenado tras As da AsBs

Generador único(+,-,+)

Genera el prefijo As que encadenado con Bs da AsBs

Generador único(-,+,+)

Genera AsBs a partir de As y de Bs

Generador único(+,+,-)

Comprueba si AsBs es la concatenación de As y Bs

test(+,+,+)encadena(As,Bs,AsBs)


Predicados sobre listas (III)

Redefinir los predicados siguientes utilizando encadena/3 y construir sus tablas de comportamiento teniendo en cuenta el comportamiento de encadena:

% prefijo(As,AsBs)% sufijo(Bs,AsBs)% sublista(Bs,AsBsCs)% miembro(X,AsXBs)% seleccion(X,AsXBs,AsBs)

Definir:% ultimo(X,AsX)% adyacentes(X,Y,AsXYBs)% inversa(L,Linvertida)% permutacion(L,Lpermutada)% aplanada(L,Lplana)


Predicados aritméticos sobre listas

Definir predicados para calcular:La longitud de una lista.La suma de todos los elementos de una lista de números.El máximo elemento de una lista de números.La lista con todos los elementos del intervalo definido por dos

números dados.

Dar definiciones iterativas para cada uno de los predicados anteriores


Comparación de términos

PROLOG dispone de una relación de orden total @=< para la comparación de términos, consistente con el orden numérico y conel orden alfabético para los nombres de átomos (permite la aparición de variables libres)Xs == Ys éxito cuando Xs e Ys representan el mismo términoXs \== Ys éxito cuando Xs e Ys representan términos distintosXs @< Ys éxito cuando Xs representa un término menor que Ys Xs @> Ys éxito cuando Xs representa un término mayor que Ys Xs @=< Ys éxito cuando Xs representa un término menor o ig. que Ys Xs @>= Ys éxito cuando Xs representa un término mayor o ig. que Ys

(Tienen sentido para términos de la misma categoría)(No confundir con las relaciones numéricas)


Comparación de términos sobre listas

Definir predicados para 1) Determinar si un elemento, posiblemente una variable libre,

pertenece a una lista. 2) Borrar un elemento de una lista.3) Calcular el mínimo de una lista (de números o de nombres de

átomos).4) Comprobar si todos los elementos de una lista son iguales.5) Sustituir todas las apariciones de un elemento, por otro, en

una lista dada.


Listas ordenadas

ordenada([]).ordenada([_]).ordenada([X,Y|Ls]):- X @=< Y,

ordenada([Y|Ls]).ordenacion(L,Lord):- permutacion(L,Lord),

ordenada(Lord).

Definir predicados para:1) Insertar un elemento en una lista ordenada.2) Ordenar los elementos de una lista por inserciones.3) Separar los elementos de una lista con ayuda de un pivote.4) Ordenar una lista por el procedimiento del pivote.


Cadenas de caracteres

Las cadenas de caracteres son listas de caracteres.Prolog permite la representación habitual de cadenas entre

comillas dobles, dentro de un programa o en una entrada, p.e. “¡Hola!”.

Prolog almacena las cadenas como listas de códigos ASCII correspondientes a los caracteres

“¡Hola!” [161, 72, 111, 108, 97, 33]Para mantener la representación textual puede ser conve-

niente utilizar átomos o texto entre comillas simples que no se puede descomponer en caracteres.:-write(“¡Hola!”). produce la salida:

[161,72,111,108,97,33]:-write(‘¡Hola!’). produce la salida:

¡Hola!


Conjuntos representados con listas

Los conjuntos se pueden representar en PROLOG mediante listas ordenadas y definir las distintas operaciones en función de dicha representación:% pertenece(Elemento,Conjunto)

pertenece(X,[X|_]).pertenece(X,[Y|Cs]):- X @> Y, pertenece(X,Cs).

% subconjunto(SubCj,Conjunto)% union(C1,C2,C1oC2)% interseccion(C1,C2,C1yC2)% diferencia(C1,C2,C1\C2)


Árboles en PROLOG


Árboles binarios

En PROLOG pueden representarse los distintos tipos de árboles binarios mediante estructuras recursivas:

ArbolB = vacio | arbol(ArbolB, Termino, ArbolB)ArbolH = hoja(Termino) | arbol(ArbolH, ArbolH)

Definir predicados para:

1) Reconocer estos dominios. 2) Determinar si dos árboles son simétricos y si son isomorfos.3) Producir los distintos recorridos en profundidad de un ArbolB.4) Producir el listado de hojas de un ArbolH.5) Sustituir un elemento en un árbol.


Árboles binarios de búsqueda (I)

Los árboles binarios de búsqueda se corresponden con los árboles del tipo ArbolB, cuyo listado en inorden está ordenado:

ordenado(A):- inorden(A,Lin), ordenada(Lin).

Predicado para buscar un elemento (no genera):esta(X,arbolB(_,Y,_)):- X==Y.esta(X,arbolB(I,R,_)):- X @< R,esta(X,I).

esta(X,arbolB(_,R,D)):- X @> R,esta(X,D).

Definir un predicado para insertar un elemento.


Árboles binarios de búsqueda (II)

Elemento máximo de un árbol ordenado:maxArb(arbolB(_,R,vacio),R).

maxArb(arbolB(_,R,D),M):- maxArb(D,M).

Predicado para borrar un elemento:borra(X,vacio,vacio).borra(X,arbolB(vacio,R,D),D):- X == R.borra(X,arbolB(I,R,D),arbolB(I’,M,D)):- X == R,

maxArb(I,M),borra(M,I,I’).borra(X,arbolB(I,R,D),arbolB(I’,R,D)):- X @< R,

borra(X,I,I’).borra(X,arbolB(I,R,D),arbolB(I,R,D’)):- X @> R,

borra(X,D,D’).


Árboles de expresiones booleanas

Booleano = cierto | falso | and(Booleano,Booleano) | or(Booleano,Booleano)| not(Booleano)

1) Definir un predicado que reconozca este dominio.

2) Definir predicados que reconozcan las expresiones satisfactibles y las no satisfactibles.


Árboles de expresiones aritméticas

Predicado para reconocer expresiones aritméticas simples:expA(N):- number(N).expA(X):- var(X).expA(E1 + E2):- expA(E1), expA(E2).expA(E1 - E2):- expA(E1), expA(E2).expA(E1 * E2):- expA(E1), expA(E2).expA(E1 / E2):- expA(E1), expA(E2).

Definir un predicado para evaluar expresiones aritméticas con parámetros, dada una lista de valores para los parámetros.


Árboles generales (I)

Los árboles generales se pueden representar en PROLOG mediante la siguiente estructura recursiva:

ArbolG = vacio | arbol(Termino, [ArbolG])

Predicado para reconocer el dominio de los árboles generalesarbolG(vacio).

arbolG(arbol(_,[])).

arbolG(arbol(R,[A|As])):- arbolG(A),arbolG(arbol(R,As)).


Árboles generales (II)

Definir predicados sobre árboles generales para:

1. Calcular el recorrido en preorden.2. Determinar si un elemento es miembro de un árbol.3. Determinar si dos árboles son isomorfos.4. Sustituir las apariciones de un elemento por otro.

Tema IV Programación lógica con estructurasjmmb/declarativa/ApuntesPL2004/ProgLogicaIV.pdf · 3)...

Documents

Transcript of Tema IV Programación lógica con estructurasjmmb/declarativa/ApuntesPL2004/ProgLogicaIV.pdf · 3)...