tema1

Programación gDeclarativa

Tema 1: Lógica Proposicional yTema 1: Lógica Proposicional y Lógica de Predicados

2

Tema 1: Lógica Proposicional y Lógica de Predicados

IntroducciónLógica de Primer Orden. Sintaxis y SemánticaRepresentación de Hechos en LPORepresentación de Hechos en LPORepresentación de HechosGrafos Y/OOperadores. Evaluación de ExpresionesProceso de UnificaciónA l i b O dAclaraciones sobre OperadoresTipos de Datos en PROLOGAcumuladoresAcumuladoresControl de FlujoPrimitivas de PROLOG (Avanzado)

Prog.Declarativa – Tema 1: Lógica Proposicional y Lógica de Predicados

3

Introducción

Operadores básicos:y = ∧y ∧o = ∨nono = ¬

implicación = →doble implicación = ↔


4

Introducción (II)

Modus Ponens:

A → BA → B

A

B

Modus Tolens:Modus Tolens:

A → B

¬B

¬AProg.Declarativa – Tema 1: Lógica Proposicional y Lógica de Predicados

A

5

Introducción (III)

Reducción al Absurdo:

A → BA → B

A → ¬B

¬A¬A

Representación de Predicados:"Só t h b ""Sócrates es un hombre"

Hombre(X) ≡ Hombre(Sócrates)

Son equivalentes ya que ambas representan el mismo hechoSon equivalentes ya que ambas representan el mismo hecho.

Cuantificadores (∀, ∃)

∀ X: Hombre(X) → Mortal(X)


∀ X: Hombre(X) → Mortal(X)

6

Representación de Predicados: Ejemplo

Siguiendo con esta idea en más detalle, podemos desarrollar:

1. Marco era un hombre.2. Marco era pompeyano.3 Todos los pompeyanos eran romanos3. Todos los pompeyanos eran romanos.4. César fue un gobernante.5 Todos los romanos o bien eran leales al César o bien le5. Todos los romanos o bien eran leales al César o bien le

odiaban.6. Todo el mundo es leal a alguien.7. La gente sólo intenta asesinar a los gobernantes a los que

no son leales.8 Marco intentó asesinar a César


8. Marco intentó asesinar a César.

7

Representación de Predicados: Ejemplo (II)

Una posible solución:Hombre(Marco).Pompeyano(Marco)Pompeyano(Marco).∀X: Pompeyano(X) → Romano(X).Gobernante(César).( )∀X: Romano(X) → ((Leal(X,César) ∧ ¬Odia(X,César)) ∨(¬Leal(X,César) ∧ Odia(X,César))).∀X ∃Y: Leal(X Y)∀X ∃Y: Leal(X,Y).∀X, ∀Y: Persona(X) ∧ Gobernante(Y) ∧Intenta_Asesinar(X,Y) → ¬Leal(X,Y).I t t A i (M Cé )Intenta_Asesinar(Marco, César).

La Programación Lógica emplea este tipo de predicados.


predicados.

8




9

Lógica de Primer Orden. Sintaxis y semántica

Podemos distinguir cuatro tipos de casos:Objetos: persona, casa, número, color...j p , , ,Propiedades: rojo, ..., redondo, ..., primo...Relaciones: hermano de..., primo de...Relaciones: hermano de..., primo de...Funciones: padre de..., madre de...

La diferencia entre "padre de" y "hermanoLa diferencia entre padre de y hermano de", a nivel lógico de predicado es:

Hermano de(X Y) ⇒ RelaciónHermano_de(X,Y) ⇒ RelaciónX = Padre_de(Y) ⇒ Función


10

Lógica de Primer Orden. Sintaxis y semántica (II)

También tendremos una serie de símbolosConstantes: Pedro, 2, rojo...De predicado: Redondo() Hermano > < =De predicado: Redondo(), Hermano, >, <, =, ...De función: Padre_de, Coseno...Variables: X, Y, A..., ,Conectores lógicos: ∧, ∨, ¬, →, ↔Cuantificadores: ∀, ∃Operadores de igualdad:Operadores de igualdad: =

Con todo esto podremos construir predicados más complejosco p ejos

Hermano(X,Y) ∧ Hermano(X,A) 'X' es hermano de 'Y' y de 'A'


11

Lógica de Primer Orden. Semántica

Símbolos constantes: Donde una constante se refiere a un único objeto.X = rojojX = verde ⇐ NO, o uno u otro valor de ‘X', pero no los dos juntos.

Sí que podremos tener dos constantes distintas con el mismo valor ⇒

X = rojoA = rojoSímbolos de predicado: nos indican a qué relación hacenSímbolos de predicado: nos indican a qué relación hacen referencia.Hermano(X,Y) ⇒ Hace referencia a la relación "Hermano".Símbolos de función: ocurre igual que en la anterior nos dice aSímbolos de función: ocurre igual que en la anterior, nos dice a qué función hace referencia.Padre(X)


12

Lógica de Primer Orden. Cuantificadores

En relación a los cuantificadores, son un poco más complejos:poco más complejos:

El universal, ∀, extiende la relación/definición para toda variablepara toda variable.

∀X,Y: Padre(X,Y) ∧ Descendiente(Y,X).

El e istencial ∃ nos indica q e al menos noEl existencial, ∃, nos indica que al menos uno cumple la propiedad.

∃X H (X M h ) G t (X) G t (M h )∃X, Hermano(X,Mancha) ∧ Gato(X) ∧ Gato(Mancha)

"Mancha tendrá al menos un hermano, 'X'".


13

Lógica de Primer Orden. Cuantificadores (II)

Los cuantificadores se pueden encadenar unos con otros:

∀X ∃Y: Quiere(X,Y)"Toda persona tiene una media naranja"

C bi d l d d d iCambiando el orden, podemos decir cosas como:∃Y ∀X: Quiere(X,Y)

"Existe una persona a la que todo el mundo quiere"Existe una persona a la que todo el mundo quiere

Luego el orden no es siempre equivalente:∀X ∃Y ≡ ∃Y ∀X∀X ∃Y ≡ ∃Y ∀X

Se garantiza su cumplimiento cuando sólo tenemos un objeto.


j

14

Lógica de Primer Orden. Cuantificadores (III)

Ejemplos de equivalencias:Ejemplo 1:

∀X, ∃Y: P(X,Y) ≡ ∀X (∃Y: P(X,Y)) Se cumple la equivalencia.Ejemplo 2:Ejemplo 2:

∀X ¬Gusta(X,B) ≡ ¬∃X: Gusta(X,B) A nadie ('X') le gusta 'B' ≡ No existe alguien ('X') a quien leA nadie ( X ) le gusta B ≡ No existe alguien ( X ) a quien le guste 'B'Ejemplo 3:

∀X Gusta(X,B) ≡ ¬∃X: ¬Gusta(X,B) A todo el mundo le gusta 'B' ≡ No existe alguien ('X') a quien no le guste 'B'


quien no le guste B

15

Lógica de Primer Orden. Cuantificadores (IV)

Ejercicio: Buscar el equivalente a cada una de estas expresiones:de estas expresiones:

∀X: ¬P

¬∀X: P ≡ ∃X: P

≡ ¬∃X: P

¬∀X: P

∀X: P∀X PX P

≡ ¬∃X: ¬P

≡ ∃X: P

∃X: P ≡ ¬∀X: P≡ ¬∀X: ¬P


16

Lógica de Primer Orden. Cuantificadores (V)

Ejercicio: Expresa la siguiente oración correctamente con la lógica de predicados.correctamente con la lógica de predicados.

"Mancha tiene dos hermanos"∃X Y: Hermano(Mancha X) ∧ Hermano(Mancha Y)∃X,Y: Hermano(Mancha,X) ∧ Hermano(Mancha,Y)

∧ X ≠ YDebemos especificar que 'X' sea distinto de 'Y', p q ,

porque como hemos visto, estas dos variables, aunque distintas, podrían estar referenciando al

i t ( X Bi t Y Bi t ) É t lmismo gato (p.e., X=Bigotes, Y=Bigotes). Ésta es la manera de evitarlo.


17




18

Representación de Hechos en Lógica de Primer Orden

Ejemplo: FamiliaObjetos: personasObjetos: personas

Propiedades: género (Hombre(X), Mujer(Y))

Relación progenitor(X Y) descendiente(X Y)Relación: progenitor(X,Y), descendiente(X,Y), hijo, hija, cónyuge, esposo, esposa, abuelo...

F ió d dFunción: padre, madre...


19

Representación de Hechos en Lógica de Primer Orden (II)

Ejemplos:"La madre de alguien es su progenitor femenino"La madre de alguien es su progenitor femenino

∀M,C: Madre(C)=M ↔ Mujer(M) ∧ Progenitor(M,C).

"El esposo de alg ien es s cón ge masc lino""El esposo de alguien es su cónyuge masculino"

∀X,Y: Marido(X)=Y ↔ Hombre(Y) ∧ Mujer(X) ∧C d (X Y)Casados(X,Y).

Otra forma:

∀X,Y: Esposo(X,Y) ↔ Hombre(Y) ∧ Mujer(X) ∧Cónyuge(X,Y).


20

Representación de Hechos en Lógica de Primer Orden (III)

Ejemplos:"Masculino y femenino son dos géneros disjuntos"

∀X: Hombre(X) ↔ ¬Mujer(X).

"Progenitor y descendiente son relaciones inversas"

∀X,Y: Progenitor(X,Y) ↔ Descendiente(Y,X).

"Abuelo de alguien es un progenitor de los progenitores de alguien"

∀A,P: Abuelo(A,P) ↔ ∃C: Progenitor(A,C) ∧ Progenitor(C,P).N d id l ió d t d t íNo podemos anidar una relación dentro de otra, pero sí podemos anidar una función dentro de una relación.


21




22

Representación de Hechos

Ejemplo: Familia Real

Predicados que usaremos:Predicados que usaremos:Madre(X,Y).

Padre(X,Y).

Cónyuge(X,Y).

PROLOG no permite trabajar con funciones, así que las transformaremos en relacionesasí que las transformaremos en relaciones (p.e., Padre, Madre).


23

Representación de Hechos (II)

Base de Hechos:Padre(JuanCarlos,Elena).Padre(JuanCarlos,Cristina).JuanCarlos Sofía Padre(JuanCarlos,Cristina).Padre(JuanCarlos,Felipe).Padre(Felipe,Leonor).Padre(Felipe Sofía2)Elena Marichalar Padre(Felipe,Sofía2).Madre(Sofía,Elena).Madre(Sofía,Cristina).M d (S fí F li )

Elena MarichalarCristina IñakiFelipe Letizia

Madre(Sofía,Felipe).Madre(Letizia,Leonor).Madre(Letizia,Sofía2).Leonor

S fí 2 Cónyuge(JuanCarlos,Sofía).Cónyuge(Elena,Marichalar).Cónyuge(Cristina,Iñaki).

Sofía2


y g ( )Cónyuge(Felipe,Letizia).

24

Representación de Hechos (III)

Una posible forma de deducir el abuelo:

Progenitor(X,Y) ↔ Padre(X,Y) ∨M d (X Y)

JuanCarlos SofíaMadre(X,Y).

∀A,N: Abuelo(A,N) ↔ ∃P: Progenitor(A,P) ∧ Progenitor(P,N).

Elena MarichalarSi en PROLOG introducimos el siguiente enunciado:

Progenitor(X Felipe)

Elena MarichalarCristina IñakiFelipe Letizia

Progenitor(X,Felipe).

será capaz de decirnos quién es 'X', progenitor de Felipe, y además nos d l á l d i J C l

LeonorS fí 2 devolverá las dos opciones: Juan Carlos

y Sofía.Sofía2


25




26

Grafos Y/O

Expresan las relaciones que existen entre unos predicados y otros.Estos grafos representan las dependencias. P.e.:g p p

Progenitor

O en el ejemplo de la Familia Real

Padre Madre

Progenitor(JC, X)

P d (JC X) M d (JC X)

PROLOG nos devolverá un resultado en el momento en el que se dé uno de los casos.

Padre(JC, X) Madre(JC, X)


27

Grafos Y/O (II)

Con los grafos vamos a representar de manera gráfica las relaciones que existen entre unos predicados y otros.Ejemplo: AEjemplo:

B ∧ C → AA

B CEl grafo nos indica que son predicados dependientes.Se puede ampliar el grafo insertándole nuevas reglas.

A

A → DA

B C D

A

(F ∧ G) ∨ H → D

B C D B C D

H F G


H F G

28

Grafos Y/O (III)

Ejemplo:Base de hechos:1 g(A 20)

a(X,T)

1. g(A, 20).2. b(A).3. h(20, 10).

b(X) (X T) (Q) h(T Q)4. w(5).5. w(10).

Demostrar que se cumple:

b(X) g(X,T) w(Q) h(T,Q)

Solución:Demostrar que se cumple:∀X: b(X) ∧ g(X,T) ∧ w(Q) ∧h(T,Q)→a(X,T)

Solución:X=AT=20

¿Para qué valores de X, T y Q se cumple este predicado?

Q=5Q=10


predicado?

29




30

Cláusulas de Horn

PROLOG trabaja con cláusulas de Horn.

Una cláusula es una combinación de predicados,Una cláusula es una combinación de predicados, por medio de conjunciones y disyunciones.

Por medio de las Leyes de DeMorgan, cláusulas de y g ,distintos tipos se pueden representar como cláusulas de Horn.

En general, una cláusula de Horn tendrá la forma:(P1 ∧ P2 ∧ … ∧ Pn) → S.

en PROLOG,S :- P1, P2, …, Pn.

e O OG,

Cabeza Cola


31

Cláusulas de Horn (II)

Si la cláusula de Horn no tiene consecuente, se trata únicamente de un hecho.

S.

Si en la cláusula de Horn aparecenSi en la cláusula de Horn aparecen disyunciones (∨), la descomponemos en varias claúsulas donde sólo aparezcan a as c aúsu as do de só o apa e caconjunciones (∧).

(P1 ∧ P2 ∧ … ∧ Pn) ∨ (Q1 ∧ Q2 ∧ … ∧ Qm) → S.(P1 ∧ P2 ∧ … ∧ Pn) ∨ (Q1 ∧ Q2 ∧ … ∧ Qm) → S.S :- P1, P2, …, Pn.S :- Q1 Q2 Qm


S : Q1, Q2, …, Qm.

32

Operadores. Evaluación de Expresiones

= (Igual) A = 3+2 ⇒ A = 5, en PROLOG no, el símbolo '=' sólo realiza comparaciones, y 'A' seguiría valiendo '3+2'.p , y gPara que PROLOG entienda 'A = 5', lo indicaremos por 'A is 3+2', para que evalúe la operación.Otro ejemplo:Otro ejemplo:

padre(X,Y) ⇒ padre(Juan, padre(JC, Elena)) Preguntando en PROLOG por padre(Juan, X), devolvería X = padre(JC Elena)padre(JC, Elena).

\= (Negación) \ d (JC L )\=padre(JC,Leonor).No padre(JC,Leonor).


33

Operadores. Evaluación de Expresiones (II)

=:= (Operador relacional igual) P.e.: 2+3 =:= 5 ⇒ True.

=\= (Operador relacional distinto)

Otros operadores relacionales><<>==<

Evalúan la parte derecha, evalúan la parte izquierda, y devuelve True o False en función del resultado del operador.


34

Operadores. Evaluación de Expresiones (III)

Ejemplo:precio(zx 4200 6000)precio(zx, 4200, 6000).

precio(panda, 3000, 3600).

precio(a3 18000 24000)precio(a3, 18000, 24000).

precio(r5, 1200, 1800).

compra(Coche,Dinero):- precio(Coche, Min, Max), Dinero >= Min, Dinero =< Max.


35

Operadores. Evaluación de Expresiones (IV)

Intérprete: compra(r5, 1000).Procesa:

Coche = r5Dinero = 1000

precio(r5, Min, Max)

Sigue buscando, y encuentra:Min = 1200M 1800Max = 1800

Con estos datos no pueden satisfacerse las condiciones del dinero:condiciones del dinero:

Dinero >= Min ⇒ False

El intérprete devolverá ‘no’ a nuestra pregunta


El intérprete devolverá no a nuestra pregunta.

36

Operadores. Evaluación de Expresiones (V)

Veamos otra forma de interrogar al intérprete: compra(X,4800).Procesa:

Coche=XDinero=4800

Comienza a comprobar entre los predicados:precio(zx, 4200, 6000), Dinero >=4200, Dinero <=6000

Para éste se cumple.Sigue buscando:

True True True

precio(panda, 3000, 3600), Dinero >=3000, Dinero <=3600

No se cumple.

True True False

pContinua probando con todos los demás casos y finalmente concluimos en que el único coche que podemos comprarnos es el 'zx'.


37

Operadores. Evaluación de Expresiones (VI)

Otro ejemplo. Si le preguntamos al intérprete:compra(zx X)compra(zx,X).

Tratará de procesar:precio(zx,4200,6000), Dinero>=4200, Dinero=<6000.

¿X >= 4200?

No puede evaluarlo y devolverá 'no‘.p y


38

Operadores. Evaluación de Expresiones (VII)

Ejemplo:poblacion(usa, 203).poblacion(india 548)poblacion(india, 548).poblacion(china, 800).poblacion(espania, 50).p ( p , )area(usa, 3).area(india, 1).area(china 4)area(china, 4).area(espania, 0.1).

Regla:Regla:densidad(X,Y):-poblacion(X,P),area(X,A), Y is P/A.'X' será el país e 'Y' el valor asociado a la densidad.


39

Operadores. Evaluación de Expresiones (VIII)

Pregunta:densidad(china,Y).( , )

Procesa:poblacion(china 800) area(china 4) Y is 800/4poblacion(china,800), area(china, 4), Y is 800/4.

Devuelve:Y 200Y = 200.

Decimos que una variable queda i t i d d t l (instanciada cuando toma un valor (se instancia), que no se puede cambiar.


40




41

Proceso de Unificación

Dados dos términos cualesquiera, T1 y T2, para que se unifiquen en PROLOG uno de ellos, p.e, T1, debe ser una variable no instanciada, y al final acabará tomando el valor de T2.

T1, T2 ⇒ 2 términos

T1 ⇒ variable no instanciada ⇒ T1 = T2 ⇒ Se unifican.

Si tanto T1 como T2 son dos variables no instanciadas, entonces tendremos dos nombres

l i i blpara la misma variable.


42

Proceso de Unificación (II)

Si T1 es una constante, sólo se unificará con T2 si tiene el mismo valor que la constante.T2 si tiene el mismo valor que la constante.

Si T1 es una estructura,(A j )pepe(A, rojo)

jose(B, rojo)

No unifican porque el nombre es distinto.

pepe(A rojo)Coinciden el nombre y el número de argumentos, y se unifican. A pepe(A, rojo)

pepe(B, rojo)

g yy B se unifican porque ambas son variables no instanciadas, y las constantes tiene el mismo valor


valor.

43

Proceso de Unificación (III)

Un caso particular es el de la variable anónima o blanca, que se representa conanónima o blanca, que se representa con un guión bajo ( _ ).

is 3+2_ is 3+2

_ = 5 ⇒ se pierde el valor 5.

Unifica con casi todo, pero no te dice con qué.


44

Proceso de Unificación (IV)Proceso de Unificación (IV)

Pasos básicos del Algoritmo de Unificación:Tomamos como entrada dos cláusulas, R y S., y1. Si R = S, entonces R y S son unificables.

2. Si no, localizar el símbolo más a la izquierda de R que se diferencia de su homólogo en Sdiferencia de su homólogo en S.1. Si es el primero (predicado), entonces R y S no son unificables.2. Si es uno de los argumentos, entonces sean t1, t2 los términos en

l difilos que difieren.1. Si ninguno de los dos (t1, t2) es una variable, entonces las

cláusulas no son unificables.2. Si t1 es una variable X, entonces haremos la sustitución: s =

{X/t2}

3. Volver al paso 1.


45

Proceso de Unificación (y V)Proceso de Unificación (y V)

Normas generales:Una variable siempre unifica con un término, quedando ésta ligada a dicho término.

Dos variables siempre unifican entre sí, además, cuando una de ellas se liga a un término todas las que unifican seuna de ellas se liga a un término, todas las que unifican se ligan a dicho término.

Para que dos términos unifiquen, deben tener el mismo functor y la misma aridad. Después se comprueba que los argumentos unifican uno a uno manteniendo las ligaduras que se produzcan en cada uno.que se produzcan en cada uno.

Si dos términos no unifican, ninguna variable queda ligada.


46




47

Aclaración sobre Operadores

Operador de unificación (=) ⇒ comprueba si las dos expresiones son unificables.

expresión1 = expresión2expresión1 expresión2

A = 3+2 ⇒ Si 'A' no está instanciada unifica, pero si lo está, no d f llse puede y falla.

A is 3+2 ⇒ En este caso, si 'A' no está instanciada, evalúa '3+2' y unifica como 'A is 5'.

Operador de no unificación (\=) ⇒ comprueba si las dos expresiones son no unificables.

A \= 1 ⇒ Si 'A' no está instanciada y por tanto pueden unificar,A \ 1 ⇒ Si A no está instanciada y por tanto pueden unificar, fallará. Pero si 'A' está instanciada a cualquier valor que no sea '1', el operador indica entonces que no se pueden unificar y seguirá evaluando.


g

48

Aclaración sobre Operadores (II)

Operador de identidad (==) ⇒ comprueba si las dos expresiones son exactamente la misma.

2 == 2 ⇒ True.X X TX == X ⇒ True.En el caso:X = 2X == 2 ⇒ FalseX == 2 ⇒ False.No evalúa la expresión.Se usa en casos muy concretos, p.e.:X = 2. X == Y ⇒ FalseY = 1+1.

Operador de no identidad (\=) ⇒ comprueba si las dos expresiones no son exactamente la misma.

X \ 2 T

X == Y ⇒ False.

X \== 2 ⇒ True.2 \== 2 ⇒ False.


49

Aclaración sobre Operadores (III)

Operador "tiene el mismo valor" (=:=) 2 =:= 2 ⇒ True.

X =:= X ⇒ Dependiendo del intérprete, si no están instanciadas podría dar un error, y si lo están, evalúa

b i l l i d l Tambas y si su valor es el mismo devuelve True, en caso contrario devuelve False.

X = 2X = 2.

Y = 3-1.

Operador "no tiene el mismo valor" (=\=)

X =:= Y ⇒ True.

Operador no tiene el mismo valor (=\=) X = 2.

X =\= 2 ⇒ False


X =\= 2 ⇒ False.

50

Aclaración sobre Operadores (IV)

Operadores aritméticos ⇒ +, –, *, /, mod, // (cociente de la división entera), ^, ...

Para que estos operadores tengan efecto, deben ir precedidos por el operador 'is', de lo contrario PROLOG lo i t t á t t Pinterpretará como una estructura. P.e.,

A = 3+2

⇓ PROLOG⇓ PROLOG

A = +(3,2) = 3+2

Además, si en el operador 'anterior // posterior' no están , p pinstanciados los valores 'anterior' y 'posterior', dará fallo.


51


IntroducciónLógica de Primer Orden. Sintaxis y SemánticaRepresentación de Hechos en LPORepresentación de Hechos en LPORepresentación de HechosGrafos Y/OOperadores. Evaluación de ExpresionesProceso de UnificaciónAclaraciones sobre OperadoresAclaraciones sobre OperadoresTipos de Datos en PROLOGAcumuladoresControl de FlujoPrimitivas de PROLOG (Avanzado)


52

Tipos de datos en PROLOG

Números: 1, 3, 23, 7E3 (7·103)...Decimales: 3.33347...Cadenas: hola adios pepeCadenas: hola, adios, pepe...Listas: En PROLOG, una lista es cualquier cosa encerrada entre corchetes.

[cualquier cosa][cualquier_cosa][a, 1, _ ] ⇒ lista con tres elementos[ ] ⇒ lista vacía[a 1 [c d]] ⇒ lista con tres elementos[a, 1, [c, d]] ⇒ lista con tres elementosCasos particulares:

[A | X] ⇒ operador barra, que separa la lista en dos partes, la izquierda 'A' (Cabeza) y la derecha 'X‘ (Cola)izquierda A (Cabeza) y la derecha X (Cola).A = a.X = [1, [c, d]].La parte izquierda representa un elemento y la derecha una lista


La parte izquierda representa un elemento, y la derecha una lista.

53

Tipos de datos en PROLOG (II)

Ejemplo:[a, 1, [c, d]][A, B, C | X][A, B, C | X]A = aB = 1C = [c, d]C [c, d]X = [ ]

Si tenemos [a, b],[A|X][A|X]donde A = aX = [b]

En el caso [a]En el caso [a][A|X]A = aX = [ ]


X = [ ]

54

Tipos de datos en PROLOG (III)

Ejemplo de unificación de lista:[X, Y, Z] = [Pepe, Juan, 15]Como las dos listas tienen el mismo número de elementos, podemos preguntarnos si unifican de la formapreguntarnos si unifican de la formaX = PepeY = JuanZ = 15

En cambio,[X, Y, Z] = [Pepe, Juan]No se podría unificar debido a que no coincide el número de elementos de l li tla lista.

Ejemplo:[X, Y | Z] = [Pepe, gusta, vino]X = PepeX = PepeY = gustaZ = [vino]


55

Tipos de datos en PROLOG (IV)

Ejemplo:[X, Y | Z, J] ⇒ NONo se puede hacer, sólo puede haber un elemento detrás de laNo se puede hacer, sólo puede haber un elemento detrás de la barra.

Ejemplo:[[el, Y]| Z] = [[X, perro], [a, b]][[el, Y]| Z] [[X, perro], [a, b]][el, Y] = [X, perro]

el = XY = perro

y después,Z =[[a, b]]

Ejemplo:j p[X, Y | Z] = [A | B]Va a depender del intérprete (queda propuesto para probarlo en prácticas).


p )

56

Cálculo del factorial en PROLOG

Función factorial3! = 3·2!2! = 2·1!1! = 1·0!0! 10! = 1

Caso base: 0! = 1Fórmula: N! = N (N 1)!Fórmula: N! = N·(N-1)!Así quedaría la regla en PROLOG:

fact(0 1)fact(0,1).fact(N, Salida):- T is N-1, fact(T, S1), Salida is N*S1.

¿Factorial de 3? ¿fact(3 X)?Prog.Declarativa – Tema 1: Lógica Proposicional y Lógica de Predicados

¿Factorial de 3? ¿fact(3, X)?

57

1.- fact(0,1).2.- fact(N,Salida):-T is N-1, fact(T,S1),Salida is N*S1.

?- fact(3,X).

1.- fact(3,X) – fact(0,1)

2 fact(3 X) fact(N Salida) UNIFICA X S lid

2. fact(N,Salida): T is N 1, fact(T,S1),Salida is N S1.

2.- fact(3,X) – fact(N,Salida) UNIFICA: X = SalidaN = 3

fact(3,Salida):-T is 3-1, fact(T,S1),Salida is 3*S1.

T = 2T 2

1.- fact(2,S1) – fact(0,1)

2 - fact(2 S1) – fact(N Salida) UNIFICA: S1 = Salida2.- fact(2,S1) – fact(N,Salida) UNIFICA: S1 = SalidaN = 2


T = 1


58

?- fact(3,X).1.- fact(1,S1) – fact(0,1)

2 fact(1 S1) fact(N Salida) UNIFICA S1 S lid2.- fact(1,S1) – fact(N,Salida) UNIFICA: S1 = SalidaN = 1


T = 0T 0

1.- fact(0,S1) – fact(0,1) UNIFICA: S1 = 1( , ) ( , )


59

1.- fact(0,1).2.- fact(N,Salida):-T is N-1, fact(T,S1),Salida is N*S1.

?- fact(3,X).

1.- fact(3,X) – fact(0,1)

2 fact(3 X) fact(N Salida) UNIFICA X S lid

2. fact(N,Salida): T is N 1, fact(T,S1),Salida is N S1.X = 6

2.- fact(3,X) – fact(N,Salida) UNIFICA: X = SalidaN = 3


T = 2T 2

1.- fact(2,S1) – fact(0,1)

2 - fact(2 S1) – fact(N Salida) UNIFICA: S1 = Salida2.- fact(2,S1) – fact(N,Salida) UNIFICA: S1 = SalidaN = 2


T = 1


60

Operaciones con listas

Supongamos una lista con tres valores cualesquiera, queremos comprobar si un valor concreto pertenece a dicha lista. P.e.,

¿ 27 ∈ [a 1 27] ?¿ 27 ∈ [a, 1, 27] ?Para resolver el problema en PROLOG, vamos a definir la función pertenece.

t (X L)pertenece(X,L)donde 'X' es el elemento que buscamos y 'L' la lista donde buscamos.Sabiendo que si el elemento buscado es el primero de la lista ya habremos terminado, el caso base va a ser:

pertenece(X [ X | ])pertenece(X, [ X | _ ]).Si no estamos en el caso base, necesitaremos definir una regla:

pertenece(X,[ _ | Cola ]):- pertenece(X, Cola).


61

Operaciones con listas (II)Veamos un ejemplo:

pertenece(27, [a, 1, 27]).X = 27[27 | ] [ 1 27]

1. pertenece(X, [ X | _ ]).2 pertenece(X [ | Cola ]):NO ifi

1. pertenece(X, [ X | _ ]).2 pertenece(X [ | Cola ]):1. pertenece(X, [ X | _ ]).2 pertenece(X [ | Cola ]):[27 | _ ] = [a, 1, 27]

X = 27[ _ | Cola] = [a, 1, 27]Cola = [1 27]

2. pertenece(X,[ _ | Cola ]):-pertenece(X, Cola).

⇒ NO unifica 2. pertenece(X,[ _ | Cola ]):-pertenece(X, Cola).2. pertenece(X,[ _ | Cola ]):-pertenece(X, Cola).

Cola = [1, 27]pertenece(27, [1, 27]).

X = 27[27 | ] = [1, 27] ⇒ NO unifica[ | _ ] [ , ]X = 27[ _ | Cola] = [1, 27]Cola = [27]

⇒ O u ca

pertenece(27, [27]).X = 27[27 | _ ] = [27] ⇒ UNIFICAN. Y terminamos.


62

Operaciones con listas (III)

Longitud de una listalongitud(Lista, X).

E t t lEstructura general:[ ] ⇒ 0[a] ⇒ 1[a] ⇒ 1[a, b] ⇒ 2...

La regla en PROLOG sería:longitud([ ], 0). ⇒ caso base.longitud([ | Cola] N): longitud(Cola X) N is X+1longitud([ _ | Cola], N):- longitud(Cola, X), N is X+1.

Queremos comprobar:longitud([a, 1, pepe], N).


g ([ , , p p ], )

63

Operaciones con listas (IV)longitud([a, 1, pepe], N).[ ] = [a, 1, pepe] ⇒ NO unifica[ _ | Cola] = [a, 1, pepe] ⇒ Unifica

= a

N is X+1 ⇒ N = 3N = 3

_ = aCola = [1, pepe]

longitud([1, pepe], N).[ ] = [1, pepe] ⇒ NO unifica

| C fN is X+1 ⇒ N = 2

[ _ | Cola] = [1, pepe] ⇒ Unifica_ = 1Cola = [pepe]

longitud([pepe], N).g ([p p ], )[ ] = [pepe] ⇒ NO unifica[ _ | Cola] = [pepe] ⇒ Unifica

_ = pepeCola = []

N is X+1 ⇒ N = 1

Cola = []

longitud([ ], N).[ ] = [ ] ⇒ UnificaX = 0

• longitud([ ], 0). • longitud([ _ | Cola], N):-longitud(Cola, X), N is X+1.


g ( , ),

64

Operaciones con listas (V)

Ejercicio: Traducir una serie de listas formadas por caracteres alfabéticos a numéricos.

[a, e, i, o, u] ⇒ [1, 2, 3, 4, 5]

Para simplificar, nos centraremos sólo en las pvocales.

a ⇒ 1

e ⇒ 2

i ⇒ 3

o ⇒ 4

u ⇒ 5


65

Operaciones con listas (VI)

Sabemos los cambios, y se los proporcionamos a PROLOG como hechos.

cambia(a, 1).

cambia(e, 2).

cambia(i, 3).

cambia(o, 4).

cambia(u, 5).

Reglas:traduce([ ], [ ]).

traduce([H|J],[X|Y]) :- cambia(H,X), traduce(J,Y).


66




67

AcumuladoresAcumulador es una variable que va acumulando valores por medio de la recursividad.Ejemplo:

longitud([ ], 0).longitud([ _ | Cola], N) :- longitud(Cola, T), N is T+1.

Aquí programamos sin acumuladores. Primero se hace el paso recursivo y luego todo lo demásrecursivo y luego todo lo demás. Con acumuladores, se hace justo al revés.

longitudA([ ], A, A).longitudA([ |Cola] A Salida) :-longitudA([ _ |Cola], A, Salida) :-

A2 is A+1, longitudA(Cola, A2, Salida).Cuando llegamos al caso base, longitudA([ ], A, A) (cuando la lista está vacía), el valor de salida (longitud de la lista), toma el valor del ) ( g )acumulador.Cuando la lista tiene aún algún elemento, la longitud de la lista vale lo que halla en el acumulador más 1.


68

Acumuladores (II)Ejemplo de funcionamiento:

longitudA([a, 1, 27], 0, X).Cola = [1, 27]A = 0

1. longitudA([ ], A, A).2. longitudA([ _ |Cola], A, Salida) :-

A = 0X = SalidaA2 is A+1 = 1

longitudA([1, 27], 1, Salida) C

A2 is A+1, longitudA(Cola, A2, Salida).

⇒ X = 3

Cola = [27]A = 1Salida = SalidaA2 is A+1 = 2

Nota: En estos casos, debemos

inicializar el l dlongitudA([27], 2, Salida)

Cola = [ ]A = 2Salida = Salida

acumulador.

Salida = SalidaA2 is A+1 = 3

longitudA([ ], 3, Salida) A = 3S lid 3


Salida = 3

69

Acumuladores (III)

Consideraciones: Si no inicializamos correctamente el acumulador, el resultado puede no tener nada que ver con la longitud real de la lista.

P t d d l l l d lPara que esto no ocurra, podemos declarar las reglas del siguiente modo, para que el usuario no tenga que introducir el valor inicial del acumulador:

longitudA([ ], A, A).

longitudA([ _ |Cola], A, Salida) :-

A2 is A+1, longitudA(Cola, A2, Salida).

longitud(Lista, A) :- longitudA(Lista, 0, A).


70

Acumuladores (IV)

Ejemplo: Función factorial.La primera versión del factorial que vimos teníaLa primera versión del factorial que vimos tenía recursividad por la cola. Veamos ahora la versión con acumuladores.co acu u ado es

factorial(0, A, A).

factorial(N, A, Salida) :-factorial(N, A, Salida) :

N>0, M is N – 1,

A2 is A*N, s ,

factorial(M, A2, Salida).


71

Acumuladores (V)

Funcionamiento:factorial(3 1 X)

1. factorial(0, A, A).2. factorial(N, A, Salida) :-

N>0, M is N – 1, A2 is A*N⇒ X = 6factorial(3, 1, X).

N = 3

A = 1

A2 is A N, factorial(M, A2, Salida).

⇒ X 6

factorial(2, 3, Salida) A = 1

Salida = X

M = 2

N = 2A = 3Salida = Salida

factorial(1, 6, Salida) N = 1

M = 2

A2 = 3Salida = SalidaM = 1A2 = 6

A = 6Salida = SalidaM 0factorial(0, 6, Salida)A2 6 M = 0A2 = 6

factorial(0, 6, Salida)A = 6Salida = 6


72




73

Control de Flujo

Supongamos que tenemos el siguiente problema:y = f(x)

2

4

E t ti ti l d bl t ú i3 6

En este tipo particular de problemas tenemos una única solución.Dado que PROLOG trata de demostrar hechos hasta que no puede más, en los casos en los que solamente hay una solución, nos seguirá preguntando si queremos más soluciones.


74

Control de Flujo (II)

Para evitar esto, usaremos el control de flujo mediante el corte. Vamos a tener dos tipos:mediante el corte. Vamos a tener dos tipos:

Corte rojo: El uso de este corte, !, modifica la lógica del programalógica del programa.

Corte verde: No sólo no modifica la lógica del programa sino que además consigue mayorprograma, sino que además consigue mayor eficiencia. Es aplicable sólo cuando exista una única solución.única solución.


75

Control de Flujo (III)

Ejemplo:f(X,0):- X=<3.f(X 2): X >=3 X=<6

2

4

f(X,2):- X >=3, X=<6.f(X,4):- X >=6.

Así se podría implementar en PROLOG la función anterior.3 6

f(2,Y).X = 20 = Y

2 =< 3 ⇒ Satisface la regla⇓0 = Y ⇓Yes.

Y=0More?

No tiene sentido que PROLOG siga evaluando en busca de más soluciones cuando sabemos que ésta es única, ya que el valor de la función es único. Aplicaremos entonces el control de flujo.


de la función es único. Aplicaremos entonces el control de flujo.

76

Control de Flujo (IV)

2

4

Si modificamos el programa metiendo las

3 6

Si modificamos el programa metiendo las primitivas de corte verde al final de cada regla conseguiremos el efecto deseadoregla, conseguiremos el efecto deseado.

f(X,0):- X=<3, !.f(X 2) X 3 X 6 !f(X,2):- X >=3, X=<6, !.f(X,4):- X >=6, !.


77




78

Primitivas de PROLOG (Avanzado)

1. Respecto al tipo de datos.Primitivas de comparación (I):

var(X)

Comprueba si 'X' es una variable sin instanciar, si lo fuera, devolverá True y en otro caso Falsedevolverá True, y en otro caso, False.

atom(X)

Si el argumento 'X' es un átomo, es decir, un número o unSi el argumento X es un átomo, es decir, un número o un literal, devolverá True. En otro caso, False.

integer(X)

Si el argumento es un entero devuelve True, si es unavariable instanciada a un entero devolverá también True. En cualquier otro caso, devuelve False.


En cualquier otro caso, devuelve False.

79

Primitivas de PROLOG (Avanzado) (II)

1. Respecto al tipo de datos.Primitivas de comparación (II):

float(X)float(X) Si el argumento es un real devuelve True, si es una variable instanciada a un real devolverá también True. En cualquier otro caso devuelve Falsecualquier otro caso, devuelve False.nonvar(X) Comprueba si 'X' es una variable instanciada, si lo fuera, devolverá True y en otro caso Falsedevolverá True, y en otro caso, False.number(X) Si el argumento es un número, entero o real devuelve T i i bl i t i d t lTrue, si es una variable instanciada a un entero o real devolverá también True. En cualquier otro caso, devuelve False.


80

Primitivas de PROLOG (Avanzado) (III)

2. Respecto a la base de hechos.Estática: Uno detrás de otro.Dinámica: En tiempo de ejecución la base de hechosDinámica: En tiempo de ejecución la base de hechospuede ir aumentando o disminuyendo en función de lo quevaya necesitando nuestro programa.C t i itiContamos con primitivas para

Insertar:asserta( _ ): Inserta al principio de la base de hechos (se

i t l i di d lt á PROLOG)convierte en el primer predicado que consultará PROLOG).assertz( _ ): Inserta al final de la base de hechos (será nuestroúltimo predicado).

Recuperar:Recuperar:retract( _ ): Lo borra de la base de hechos y además devuelve el dato.


81

Primitivas de PROLOG (Avanzado) (IV)

Ejemplo: Invertir una listaVamos a usar nuestra base de hechos. Definimos:

invierte([C | Resto] Salida) :-invierte([C | Resto], Salida) :-asserta(elemento(C)), invierte(Resto,Salida).

Mi t h l t l li t l i t lMientras haya elementos en la lista, los insertamos al principio y seguimos con el resto de la lista.

invierte([ ],[C | Resto]) :-t t( l t (C)) i i t ([ ] R t )retract(elemento(C)), invierte([ ], Resto).

Cuando ya no tengamos elementos en la lista, sacaremos o recuperaremos el elemento de la base de hechos y lo insertaremos al principioinsertaremos al principio.

invierte([ ],[ ]).


82

Primitivas de PROLOG (Avanzado) (V)

Ejemplo: Invertir una listaEn la base de hechos, tendríamos.,

invierte([ C | Resto], Salida) :-asserta(elemento(C)), ( ( )),invierte(Resto,Salida).invierte([ ],[ C | Resto]) :-([ ],[ | ])retract(elemento(C)), invierte([ ], Resto).invierte([ ],[ ]).([ ],[ ])


83

Primitivas de PROLOG (Avanzado) (VI)

Ejemplo: Invertir una listaQueremos invertir la lista [a b c]Queremos invertir la lista [a, b, c].

invierte([a, b, c], Salida).

Nuestra base de hechos se ampliaría:Nuestra base de hechos se ampliaría:elemento(c).

elemento(b)

invierte([ C | Resto], Salida) :-asserta(elemento(C)), invierte(Resto,Salida).invierte([ ] [ C | Resto]) :-elemento(b).

elemento(a).

Quedaría así ya que conforme se van insertando se

invierte([ ],[ C | Resto]) :-retract(elemento(C)), invierte([ ], Resto).invierte([ ],[ ]).

Quedaría así, ya que conforme se van insertando, se van desplazando, al usar ‘asserta’, y pasan al principio.


p p

84

Primitivas de PROLOG (Avanzado) (VII)

Ejemplo: Invertir una listaUna vez que la lista se ha quedado sin elementos, procedemos a recuperarlos de la base de hechos.

Toma el elemento ‘a’, y unifica C=a, colocando ‘a’ al principio de la listaprincipio de la lista.

Vuelve a por el siguiente elemento, encuentra ‘b’ y lo inserta al principio de la lista.p p

Se repite el proceso hasta vaciar la base de hechos.invierte([ C | Resto], Salida) :-asserta(elemento(C)) invierte(Resto Salida)asserta(elemento(C)), invierte(Resto,Salida).invierte([ ],[ C | Resto]) :-retract(elemento(C)), invierte([ ], Resto).invierte([ ],[ ]).


85

Primitivas de PROLOG (Avanzado) (VIII)

Para que PROLOG sea eficiente, necesita agrupar todos los predicados que tengan el mismo nombre y número de argumentosmismo nombre y número de argumentos.

Cuando insertamos datos en nuestra base de hechos, no conviene usar una variable a secas, yahechos, no conviene usar una variable a secas, ya que a la hora de recuperarla nos daría muchos problemas. P e si usamos retract(X) con 'X' sin instanciarP.e., si usamos retract(X), con X sin instanciar, podría unficar con cualquier predicado, incluso con una regla completa.


86

Primitivas de PROLOG (Avanzado) (IX)

Ejemplo: Generador de números aleatorios.semilla(13).

random(R,N) :- semilla(C). → donde R es el último valor y N el siguiente valor.

La regla quedaría de la forma siguiente:random(R, N) :-

semilla(S), N is (S mod R)+1,

retract(semilla(S)),

S1 is (125*S+1) mod 4096,

asserta(semilla(S1)), !.


87

Primitivas de PROLOG (Avanzado) (X)

Sintaxis para assert() y retract() asserta( _ )

Si pretendemos insertar un hecho en la base de hechos loSi pretendemos insertar un hecho en la base de hechos, lo escribiremos tal cual,

elemento(3). ⇒ asserta(elemento(3)).Si l t d ibi l tSi lo que pretendemos es escribir una regla entera, tendríamos que meterla entre paréntesis.

asserta((regla)).asserta((inv([C | Cola], Sal) :-asserta(elemento(C)), inv(Cola, Sal))).

Existe una primitiva especial respecto a la base de hechos:Existe una primitiva especial respecto a la base de hechos:retractall(X): Borra todo lo que unifique con ‘X’ en la base de hechos. Si ‘X’ es una variable no instanciada, borra toda la base de hechos.


la base de hechos.

88

Primitivas de PROLOG (Avanzado) (XI)

3. Primitivas de Entrada/Salida.write(X): Muestra por pantalla el valor de ‘X’.nl: (nl = 'new line') Retorno de carro. Es similar a '\n' de C.tab(N): Escribe N espacios en blanco en pantalla.

d(X) S l d d t l d Si 'X'read(X): Se usa para leer desde teclado. Si 'X' es unavariable libre, unificará con lo que leamos de teclado, perosi ya está instanciada, sólo se satisfará cuando lo queentre por teclado sea exactamente lo mismo que lo quevalga 'X'.


89

Primitivas de PROLOG (Avanzado) (XII)

3. Primitivas de Entrada/Salida.put(X): Muestra un carácter por pantalla. Necesita que el p ( ) p p qvalor de 'X' sea el código ASCII del carácter.

get(X): Lectura binaria. Lee caracteres no imprimibles. Se l t it fi husa para lectura y escritura en ficheros,

fundamentalmente.

get0(X): Lee cualquier carácter y lo unifica con 'X'get0(X): Lee cualquier carácter y lo unifica con X .

Ejemplo: Regla para emular la primitiva 'tab'.tab(0)tab(0).

tab(N) :- N>0, put(32), M is N – 1, tab(M).


90

Primitivas de PROLOG (Avanzado) (XIII)

4. Bucles en PROLOGPrimitivas:

repeatfail: Primitiva de PROLOG que siempre falla, y que se usa paradefinir los repeat.definir los repeat.true: Al contrario que fail, esta primitiva siempre se satisface.

Ejemplo: Uso de 'repeat'd h A B C D Z f ilderecha :- ..., repeat, A, B, C, D, ..., Z, fail.

Usamos la primitiva 'repeat' para implementar los bucles. Siempre va a satisfacerse, hasta tal punto de que podríamosp p q psubstituirla directamente por 'true'.


91

Primitivas de PROLOG (Avanzado) (XIV)

4. Bucles en PROLOGSe irán ejecutando cada una de las condiciones, mientras éstassean ciertas, hacia la derecha. Cuando encuentra una que falle, como p.e., 'fail', vuelve hacia atrás, es decir, hacia la izquierda.Cuando llega al 'repeat', vuelve hacia la derecha, y asíg p , , ysucesivamente. Se trata por tanto de un bucle infinito, mientrasno usemos el corte:

derecha :- repeat A B C D Z ! failderecha : ..., repeat, A, B, C, D, ..., Z, !, fail.Pero esto no es un bucle, ya que va repitiendo las condicioneselemento a elemento, cuando en realidad debería repetirlo todocomo un bloque Para ello lo que debemos hacer es que fallencomo un bloque. Para ello, lo que debemos hacer es que fallen las condiciones durante el backtracking.


92

Primitivas de PROLOG (Avanzado) (XV)

4. Bucles en PROLOGEjemplo: Implementación de un bucle 'for' en PROLOG usando'repeat'repeat .

f(N,N).for(I,N) :- asserta(contador(I)),

repeatrepeat,retract(contador(C)),H is C + 1,asserta(contador(H)),

Este enunciado es equivalente al siguiente bucle 'for' en C,asserta(contador(H)),

cuerpo,f(H, N),retract(contador( )),

gfor( i=I; i<n; i++ ) {

cuerpo; }retract(contador( _ )),

!,fail.

}


93

Primitivas de PROLOG (Avanzado) (XVI)

4. Bucles en PROLOGSi la condición de parada no se cumple descartamos

Ejemplo: Implementación de un bucle 'for' en PROLOG usando 'repeat'.

se cumple, descartamoshacia atrás. Si la parada escierta (en el ejemplo de antes será porque ‘H’ y ‘N’

f(N,N).for(I,N) :-

asserta(contador(I)),p q yson iguales), continúa haciaadelante y saca de la base de hechos todo lo que tengaque unifique con el contador

repeat,retract(contador(C)),H is C + 1,

que unifique con el contador(en el ejemplo, '_').

asserta(contador(H)),cuerpo,f(H, N),retract(contador( _ )),!,fail.


94


4. Bucles en PROLOGEl corte (!) va antes que el 'fail' por temas de eficiencia


fail por temas de eficiencia. Dado que el flujo va de izquierda a derecha, cuandoencontramos el corte, lo da

f(N,N).for(I,N) :-

asserta(contador(I)),como cierto. Justo después, encontramos 'fail', falla, vuelve hacia atrás y, por el corte se interrumpe el flujo

repeat,retract(contador(C)),H is C + 1,

corte, se interrumpe el flujo. asserta(contador(H)),cuerpo,f(H, N),retract(contador( _ )),!,fail.


95


4. Bucles en PROLOG'asserta' es un predicadoespecial en el sentido de


especial, en el sentido de que siempre se satisfacecuando el flujo sigue sucurso normal, pero falla en el

f(N,N).for(I,N) :-

asserta(contador(I)),pbacktracking. repeat,

retract(contador(C)),H is C + 1,asserta(contador(H)),cuerpo,f(H, N),retract(contador( _ )),!,fail.


96

Primitivas de PROLOG (Avanzado) (XVII)

5. Manejo de ficheros

Es posible trabajar con ficheros en PROLOG. En CEs posible trabajar con ficheros en PROLOG. En C existen primitivas, como p.e., fopen, fclose, ... En PROLOG tenemos:

see("_"): Abre un fichero en modo lectura.

seen: Cierra un fichero que esté activado en modo lectura. No necesita argumentos. Cuando hay varios archivosabiertos, cierra el último que se había activado.

tell(" "): Abre un fichero para escrituratell("_"): Abre un fichero para escritura.

told: Cierra un fichero abierto en modo escritura.


97

Primitivas de PROLOG (Avanzado) (XVIII)

5. Manejo de ficheros"user": palabra reservada que se refiere al flujo de datos

tá d (E/S tá d )estándar (E/S estándar).see("user") equivale al stdin de C. Entrada estándar porteclado.tell("user") equivale al stdout de C. Salida estándar porpantalla.

Cuando usamos 'see' y 'tell' se abren los ficheros laCuando usamos 'see' y 'tell' se abren los ficheros la primera vez que los llamamos y se activan lassiguientes veces que los llamamos.siguientes veces que los llamamos.Si usamos 'see' y no existe el fichero, dará un error. Si usamos 'tell' y no existe el fichero, se crea.


y ,

98

Primitivas de PROLOG (Avanzado) (XIX)

Ejemplo: Cómo trabajar con más de un fichero:leer(N1, N2, S) :-

see(N1)see(N1),read(Ter1),see(N2),

( 2)read(Ter2),tell(S),write(Ter1),( ),write(Ter2),...

Si hacemos un 'seen' con varios ficheros activos seSi hacemos un seen con varios ficheros activos, se cerraría el último que se hubiera activado.


99

Primitivas de PROLOG (Avanzado) (XX)

Ejercicio: Definir un predicado que lea un fichero y sobre dicho fichero, busque yfichero y sobre dicho fichero, busque y substituya el carácter #97 de la tabla ASCII por el #98ASCII por el #98.

Considerar como fichero de entrada el t l d fi h d lid l t llteclado y fichero de salida la pantalla.

97 → 98

X ≠ 97 → X


100


Ejercicio: Definir un predicado que lea un fichero y sobre dicho fichero, busque y

b tit l á t #97 d l t bl ASCIIsubstituya el carácter #97 de la tabla ASCII por el #98.A diferencia de lo hecho anteriormente esteA diferencia de lo hecho anteriormente, este predicado no va a necesitar ningún argumento.

cambiar :- cambiar c, cambiar.ca b a ca b a _c, ca b acambiar_c :- get0(X), X=97, put(98).cambiar_c :- get0(X), put(X).

¿Por qué no hacer directamente 'cambiar(X)'? Porque a Xse le da valor con la primitiva get0, y hay que leerlo primero.


p

101


Ejercicio: Definir un predicado que lea un fichero y sobre dicho fichero, busque yfichero y sobre dicho fichero, busque y substituya el carácter #97 de la tabla ASCII por el #98ASCII por el #98.

Otra solución:cambia :- get0(X), escribe(X).

escribe(97) :- put(98).

escribe(X) :- put(X).


102

Primitivas de PROLOG (Avanzado) (XXI)

Ejercicio: Suponer que queremos leer un fichero suponiendo que en él tenemos una base de hechos y reglas.Hay dos formas de hacerlo La primera la haremos cargando esaHay dos formas de hacerlo. La primera la haremos cargando esa base de hechos en una lista.cargar_fichero( Nombre, Lista ) :-

(N b )see(Nombre),read(Termino),leer fichero(Termino, Lista),_ ( , ),seen.

leer_fichero(end_of_file, [ ]).l fi h (T i [T i | R])leer_fichero(Termino, [Termino | R]) :-

read(Termino1),leer_fichero(Termino1, R).


_ ( , )

103


Ejercicio: Suponer que queremos leer un fichero suponiendo que en él tenemos una base de hechos y reglas.Aclaraciones:

read → Lee sólo una línea, y por tanto de nuestro fichero leeremos un término.see → Activamos un fichero en modo lectura. Si el fichero no existe en la ruta que le indicamos, dará error (la primitiva falla).seen → Cerramos el fichero que tenemos activo en modo lectura. De no tener ningún archivo activo, PROLOG da por

t d l i ( d t ) li b lsentado que las acciones (read, etc.) se realizan sobre los ficheros predeterminados:

Teclado ⇒ fichero de entradaPantalla ⇒ fichero de salidaPantalla ⇒ fichero de salida

Por esta razón hemos de tener cuidado de dónde usamos el predicado 'seen', ya que puede cerrar los ficheros de teclado y pantalla que considere abiertos


y pantalla que considere abiertos.

104


Ejercicio: Suponer que queremos leer un fichero suponiendo que en él tenemos una base de hechos y reglas.La segunda posibilidad no almacena el contenido del fichero enLa segunda posibilidad no almacena el contenido del fichero en una lista, sino que se inserta directamente en la base de hechos.

cargar_fichero(Nombre) :-(N b )see(Nombre),

read(Termino),leer_fichero2(Termino),seen.

leer_fichero2(end_of_file).leer_fichero2(Termino) :-_ ( )

assertz(Termino),read(Termino1),leer fichero2(Termino1)


leer_fichero2(Termino1).

105

Primitivas de PROLOG (Avanzado) (XXII)

Ejercicios propuestos:Pensar en la manera de hacer el ejercicio de ' fi h ' d it ti ( ' t')'cargar_fichero' de manera iterativa (con 'repeat').Pensar en la manera de hacer 'cargar_fichero' con la modificación de que en caso de que no pueda abrir el q q pfichero, lo diga. Y en el caso de que no pueda cargar el fichero porque esté vacío, que devuelva un código de error Es decir que creemos por ejemplo una serie deerror. Es decir, que creemos por ejemplo una serie de códigos:

0 ⇒ El fichero no existe (no se puede cargar).1 Fi h í1 ⇒ Fichero vacío.…


Programación gDeclarativa

Tema 1: Lógica Proposicional yTema 1: Lógica Proposicional y Lógica de Predicados

tema1

Documents