MANUAL DE

PROLOG
Equipo #6
N4 Jueves
25/05/2010

Breve Historia
Una de las preocupaciones ms tempranas de la computacin de los aos cincuenta
fue la posibilidad de hacer programas que llevaran a cabo demostraciones automticas
de teoremas. As empezaron los primeros trabajos de inteligencia artificial que ms de
veinte aos despus dieron lugar al primer lenguaje de programacin que contempla,
como parte del intrprete, los mecanismos de inferencia necesarios para la
demostracin automtica.
Este primer lenguaje est basado en el formalismo matemtico de la Lgica de Primer
Orden y ha dado inicio a un nuevo y activo campo de investigacin entre las
matemticas y la computacin que se ha denominado la Programacin Lgica.
Estos mecanismos de prueba fueron trabajados con mucho entusiasmo durante una
poca, pero, por su ineficiencia, fueron relegados hasta el nacimiento de PROLOG,
ocurrido en 1970 en la Universidad de Marsella, Francia, en el seno de un grupo de
investigacin en el campo de la Inteligencia Artificial.
La Programacin Lgica tiene sus orgenes ms cercanos en los trabajos de prueba
automtica de teoremas de los aos sesenta. J. A. Robinson propone en 1965 una
regla de inferencia a la que llama resolucin, mediante la cual la demostracin de un
teorema puede ser llevada a cabo de manera automtica.
La resolucin es una regla que se aplica sobre cierto tipo de frmulas del Clculo de
Predicados de Primer Orden, llamadas clusulas y la demostracin de teoremas bajo
esta regla de inferencia se lleva a cabo por reduccin al absurdo.
La programacin lgica tiene sus races en el clculo de predicados, que es una teora
matemtica que permite, entre otras cosas, lograr que un computador pueda realizar
inferencias, capacidad que es requisito para que un computador sea una "mquina
inteligente".
La realizacin del paradigma de la programacin lgica es el lenguaje Prolog. El Prolog
estuvo un tiempo diseado para ejecutarse en minicomputadoras o estaciones de
trabajo, actualmente hay versiones en Prolog que pueden instalarse en computadores
personales como IBM-PC y PC-Compatibles.
Un programa escrito en PROLOG puro, es un conjunto de clausulas. Sin embargo,
PROLOG, como lenguaje de programacin moderno, incorpora mas cosas, como
instrucciones de Entrada/Salida, etc. Una clausula puede ser una conjuncin de hechos
positivos o una implicacin con un nico consecuente (un nico termino a la derecha).
La negacin no tiene representacin en PROLOG, y se asocia con la falta de una
afirmacin (negacin por fallo), segn el modelo de suposicin de un mundo cerrado
solo es cierto lo que aparece en la base de conocimiento o bien se deriva de esta.

Las diferencias sintcticas entre las representaciones lgicas y las representaciones

PROLOG son las siguientes:
1. En PROLOG todas las variables estn implcitamente cuantificadas universalmente.
2. En PROLOG existe un smbolo explicito para la conjuncin "y" (,), pero no existe uno
para la disyuncin "o", que se expresa como una lista de sentencias alternativas.
3. En PROLOG, las implicaciones p --> q se escriben al revs q:- p, ya que el interprete
siempre trabaja hacia atrs sobre un objetivo.

FUNCIONAMIENTO
INSTALACION DE PROLOG EN PLATAFORMA DE WINDOWS
1.- Busque en la pgina ftp://ftp.amzi.com/misc/amzi_7-4-12_win.exe el
instalador que incluye JAVA+ECLIPSE+AMZI_PROLOG.*
*Nota: Esta es una versin de PROLOG de varias existentes
2.- Ejecute el archive amzi_7-4-12_win.exe

3.- Aparece la pantalla de bienvenida de clic en el botn siguiente:

4.- Aparece la licencia del software, si esta de acuerdo marque la casilla de

aceptar la licencia. Despus de clic en el botn de siguiente.

5.-Aparece la siguiente pantalla. De clic en siguiente

6.- Seleccione el directorio de instalacin y de clic en siguiente

7.- Si est seguro solo de clic en instalar

8.- La instalacin se completo exitosamente

9.- Doble-Clic en el Icono Amzi! Eclipse IDE del men de Windows.

10.-Seleccione el directorio donde se trabajara

11.- Aparecer la pantalla donde se ingresa la informacin de la licencia, pero

en este caso como es para uso educacional y personal, presione el botn de
Salir/Correr la edicin gratuita.

12.-Aparecera la pantalla de bienvenida, cierre la ventana Welcome to eclipse

3.1

13.-Ir al men Window / Open Perspectiva / Other / Prolog

14.-Cree un proyecto, vaya al men File / New / Project

15.-Presionar el botn de siguiente e ingrese el nombre de su proyecto y de

clic en el botn de finalizar

16.-Cree un programa, vaya al men File / New / File

17.-Ingrese el nombre del archivo cats.p

Este ser el programa:

cat(tom).
cat(felix).
cat(silvestre).
Sealando cats.pro; ejectelo como: Run/Run As/Interpreted Single File
Y escriba en la consola: cat(felix).
?- cat(felix).

Escriba en la consola: cat(X). y despus 4 espacios.

?- cat(X).

Escriba en la consola: listing.

?- listing.

Para salir del programa digite: ?- quit.

INSTRUCCIONES EN PROLOG
1. Hechos
Expresan relaciones entre objetos. Supongamos que queremos expresar el hecho
de que "un coche tiene ruedas". Este hecho, consta de dos objetos, "coche" y
"ruedas", y de una relacin llamada "tiene". La forma de representarlo en PROLOG
es:
tiene(coche,ruedas).
* Los nombres de objetos y relaciones deben comenzar con una letra
minscula.
* Primero se escribe la relacin, y luego los objetos separados por

comas y encerrados entre parntesis.

Al final de un hecho debe ir un punto (el carcter ".").

El orden de los objetos dentro de la relacin es arbitrario, pero debemos

ser coherentes a lo largo de la base de hechos.
2. Variables
Representan objetos que el mismo PROLOG determina. Una variable puede estar
instanciada o no instanciada. Esta instanciada cuando existe un objeto
determinado representado por la variable. De este modo, cuando preguntamos
"Un coche tiene X ?",
PROLOG busca en los hechos cosas que tiene un coche y respondera:
X = ruedas.
instanciando la variable X con el objeto ruedas.
* Los nombres de variables comienzan siempre por una letra mayscula.
Un caso particular es la variable annima, representada por el carcter subrayado
("_"). Es una especie de comodn que utilizaremos en aquellos lugares que debera
aparecer una variable, pero no nos interesa darle un nombre concreto ya que no
vamos a utilizarla posteriormente.
3. Reglas
Las reglas se utilizan en PROLOG para significar que un hecho depende de uno o
ms hechos. Son la representacin de las implicaciones lgicas del tipo p ---> q (p
implica q).
* Una regla consiste en una cabeza y un cuerpo, unidos por el signo ":-".
* La cabeza esta formada por un nico hecho.
* El cuerpo puede ser uno o ms hechos (conjuncin de hechos), separados
por una coma (","), que acta como el "y" lgico.
* Las reglas finalizan con un punto (".").
La cabeza en una regla PROLOG corresponde al consecuente de una implicacin
lgica, y el cuerpo al antecedente. Este hecho puede conducir a errores de
representacin. Supongamos el siguiente razonamiento lgico:
tiempo(lluvioso) ----> suelo(mojado)
suelo(mojado)
Que el suelo esta mojado, es una condicin suficiente de que el tiempo
sea lluvioso, pero no necesaria. Por lo tanto, a partir de ese hecho, no
podemos deducir mediante la implicacin, que esta lloviendo (pueden haber
regado las calles). La representacin *correcta* en PROLOG, sera:
suelo(mojado) :- tiempo(lluvioso).
suelo(mojado).

Cabe sealar que la regla esta "al revs". Esto es as por el mecanismo
de deduccin hacia atrs que emplea PROLOG. Si cometiramos el *error* de
representarla como:
tiempo(lluvioso) :- suelo(mojado).
suelo(mojado).
PROLOG, partiendo del hecho de que el suelo esta mojado, deducira
incorrectamente que el tiempo es lluvioso.
Para generalizar una relacin entre objetos mediante una regla, utilizaremos
variables. Por ejemplo:
Representacin lgica | Representacin PROLOG
Es un coche(X) ----> | tiene(X,ruedas) :
tiene(X,ruedas) | es un coche(X).
Con esta regla generalizamos el hecho de que cualquier objeto que sea un coche,
tendr ruedas. Al igual que antes, el hecho de que un objeto tenga ruedas, no es
una condicin suficiente de que sea un coche. Por lo tanto la representacin
inversa sera incorrecta.
4. El mbito de las variables.
Cuando en una regla aparece una variable, el mbito de esa variable es
nicamente esa regla. Supongamos las siguientes reglas:
(1) hermana_de(X,Y) :- hembra(X), padres(X,M,P), padres(Y,M,P).
(2) puede_robar(X,P) :- ladron(X), le_gusta_a(X,P), valioso(P).
Aunque en ambas aparece la variable X (y la variable P), no tiene nada que ver la
X de la regla (1) con la de la regla (2), y por lo tanto, la instanciacin de la X en
(1) no implica la instanciacin en (2). Sin embargo todas las X de *una misma
regla* si que se instanciaran con el mismo valor.
5. Operadores
Son predicados predefinidos en PROLOG para las operaciones matemticas
bsicas. Su sintaxis depende de la posicin que ocupen, pudiendo ser infijos o
prefijos. Por ejemplo el operador suma ("+"), podemos encontrarlo en forma
prefija '+(2,5)' o bien infija, '2 + 5'.
Tambin dispone de predicados de igualdad y desigualdad.
X = Y igual
X \= Y distinto
X < Y menor
X > Y mayor
X =< Y menor o igual
X >= Y mayor o igual

Al igual que en otros lenguajes de programacin es necesario tener en cuenta la

precedencia y la asociatividad de los operadores antes de trabajar con ellos.
En cuanto a precedencia, es la tpica. Por ejemplo, 3+2*6 se evala como
3+(2*6). En lo referente a la asociatividad, PROLOG es asociativo por la izquierda.
As, 8/4/4 se interpreta como (8/4)/4. De igual forma, 5+8/2/2 significa
5+((8/2)/2).
El operador 'is'.
Es un operador infijo, que en su parte derecha lleva un termino que se interpreta
como una expresin aritmtica, contrastndose con el termino de su izquierda.
Por ejemplo, la expresin '6 is 4+3.' es falsa. Por otra parte, si la expresin es 'X is
4+3.', el resultado ser la instanciacin de X:
X=7
Una regla PROLOG puede ser esta:
densidad(X,Y) :- poblacin(X,P), rea(X,A), Y is P/A.
Algunos comandos bsicos
* consult.
El predicado _consult_ esta pensado para leer y compilar un programa PROLOG o
bien para las situaciones en las que se precise aadir las clusulas existentes en
un determinado fichero a las que ya estn almacenadas y compiladas en la base
de datos. Su sintaxis puede ser una de las siguientes:
consult(fichero).
consult('fichero.ext').
consult('c:\ia\prolog\fichero').
* recon.
El predicado recon es muy parecido a consult, con la salvedad de que las clusulas
existentes en el fichero consultado, reemplazan a las existentes en la base de
hechos. Puede ser til para sustituir una nica clusula sin consultar todas las
dems, situando esa clusula en un fichero. Su sintaxis es la misma que la de
consult.
*forget.
Tiene como fin eliminar de la base de datos actual aquellos
hechos consultados de un fichero determinado. Su sintaxis es:
forget(fichero).
* exitsys.
Este predicado nos devuelve al sistema operativo.

6. La resolucin de objetivos
Un ejemplo sencillo.
Con los datos que conocemos, ya podemos construir un programa en PROLOG.
Necesitaremos un editor de textos para escribir los hechos y reglas que lo
componen. Un ejemplo sencillo de programa PROLOG es el siguiente:

quiere_a(maria,enrique).
quiere_a(juan,jorge).
quiere_a(maria,susana).
quiere_a(maria,ana).
quiere_a(susana,pablo).
quiere_a(ana,jorge).
varon(juan).
varon(pablo).
varon(jorge).
varon(enrique).
hembra(maria).
hembra(susana).
hembra(ana).
teme_a(susana,pablo).
teme_a(jorge,enrique).
teme_a(maria,pablo).
/* Esta linea es un comentario */
quiere_pero_teme_a(X,Y) :- quiere_a(X,Y), teme_a(X,Y).
querido_por(X,Y) :- quiere_a(Y,X).
puede_casarse_con(X,Y) :- quiere_a(X,Y), varon(X), hembra(Y).
puede_casarse_con(X,Y) :- quiere_a(X,Y), hembra(X), varon(Y).

Una vez creado, lo salvaremos para su posterior consulta desde el interprete

PROLOG. Un programa PROLOG tiene como extensin por defecto '.PRO'. Le
daremos el nombre 'relacion.pro'.
Ya hemos creado un programa PROLOG [relacion.pro] y lo hemos compilado
en nuestro interprete PROLOG [consult(relacion)]. A partir de este
momento podemos interrogar la base de datos, mediante consultas.
Una consulta tiene la misma forma que un hecho.
Consideremos la pregunta:
?-quiere_a(susana,pablo).
PROLOG buscara por toda la base de datos hechos que coincidan con el anterior.
Dos hechos coinciden si sus predicados son iguales, y cada uno de sus

correspondientes argumentos lo son entre si. Si PROLOG encuentra un hecho que

coincida con la pregunta, responder yes. En caso contrario responder no.
Adems, una pregunta puede contener variables. En este caso PROLOG buscara
por toda la base de hechos aquellos objetos que pueden ser representado por la
variable. Por ejemplo:
?-quiere_a(maria, Alguien).
El resultado de la consulta es:
Alguien = enrique
More (Y/N):
El hecho 'quiere_a(maria,enrique).' coincide con la pregunta al instanciar la
variable Alguien con el objeto 'enrique'. Por lo tanto es una respuesta valida, pero
no la nica. Por eso se nos pregunta si queremos obtener m s respuestas. En caso
afirmativo, obtendramos:
Alguien = susana
More (Y/N):y
Alguien = ana
More (Y/N):y
No.
?Las consultas a una base de datos se complican cuando estas estn compuestas
por conjunciones o bien intervienen reglas en su resolucin. Conviene, por lo
tanto, conocer cual es el mecanismo de control del PROLOG, con el fin de
comprender el porque de sus respuestas.
8. El mecanismo de control de PROLOG
El mecanismo empleado por PROLOG para satisfacer las cuestiones que se le
plantean, es el de _razonamiento hacia atrs (backward) complementado con la
bsqueda en profundidad (depth first) y la vuelta atrs o reevaluacin
(backtracking).
Razonamiento hacia atrs: Partiendo de un objetivo a probar, busca las aserciones
que pueden probar el objetivo. Si en un punto caben varios caminos, se recorren
en el orden que aparecen en el programa, esto es, de arriba a abajo y de izquierda
a derecha.
Reevaluacin: Si en un momento dado una variable se instancia con determinado
valor con el fin de alcanzar una solucin, y se llega a un camino no satisfactorio, el
mecanismo de control retrocede al punto en el cual se instanci la variable, la desinstancia y si es posible,
busca otra instanciacin que supondr un nuevo camino de bsqueda.
Se puede ilustrar esta estrategia sobre el ejemplo anterior:

Supongamos la pregunta:
?-puede_casarse_con(maria,X).

PROLOG recorre la base de datos en busca de un hecho que coincida con la

cuestin planteada. Lo que halla es la regla:
puede_casarse_con(X,Y) :- quiere_a(X,Y), varon(X), hembra(Y).
Producindose una coincidencia con la cabeza de la misma, y una instanciacion de
la variable X de la regla con el objeto 'maria'.
Tendremos por lo tanto:
(1) puede_casarse_con(maria,Y) :- quiere_a(maria,Y), varon(maria), hembra(Y).
A continuacin, se busca una instanciacin de la variable Y que haga cierta la
regla, es decir, que verifique los hechos del cuerpo de la misma. La nueva meta
ser :
(2) quiere_a(maria,Y).
De nuevo PROLOG recorre la base de datos. En este caso encuentra un hecho que
coincide con el objetivo:
quiere_a(maria,enrique).
instanciando la variable Y con el objeto 'enrique'. Siguiendo el orden dado por la
regla (1), quedan por probar dos hechos una vez instanciada la variable Y:
varon(maria), hembra(enrique).
Se recorre de nuevo la base de datos, no hallando en este caso ninguna
coincidencia con el hecho varn(maria)'. Por lo tanto, PROLOG recurre a la vuelta
atrs, desistanciando valor de la variable Y, y retrocediendo con el fin de encontrar
una nueva instanciacin de la misma que verifique el hecho (2). Un nuevo
recorrido de la base de hechos da como resultado la coincidencia con:
quiere_a(maria,susana).
Se repite el proceso anterior. La variable Y se instancia con el objeto 'susana' y se
intentan probar los hechos restantes:
varn(maria), hembra(susana).
De nuevo se produce un fallo que provoca la desinstanciacin de la variable Y, as
como una vuelta atrs en busca de nuevos hechos que coincidan con (2).
Una nueva reevaluacin da como resultado la instanciacin de Y con
el objeto 'ana' (la ultima posible), y un nuevo fallo en el hecho
varn(maria)'.
Una vez comprobadas sin xito todas las posibles instanciaciones del hecho (2),
PROLOG da por imposible la regla (1), se produce de nuevo la vuelta atrs y una

nueva bsqueda en la base de datos que tiene como resultado la coincidencia con
la regla:
(3) puede_casarse_con(maria,Y) :- quiere_a(maria,Y), hembra(maria), varon(Y).
Se repite todo el proceso anterior, buscando nuevas instanciaciones de la variable
Y que verifiquen el cuerpo de la regla. La primera coincidencia corresponde al
hecho
quiere_a(maria,enrique).
que provoca la instanciacin de la variable Y con el objeto 'enrique'. PROLOG tratar
de probar ahora el resto del cuerpo de la regla con las instanciaciones actuales:
hembra(mara), varn(enrique).
Un recorrido de la base de datos, da un resultado positivo en ambos hechos,
quedando probado en su totalidad el cuerpo de la regla (3) y por lo tanto su
cabeza, que no es ms que una de las soluciones al objetivo inicial.
X = enrique
PROLOG utiliza un mecanismo de bsqueda independiente de la base de datos.
Aunque pueda parecer algo ilgico, es una buena estrategia puesto que garantiza
el proceso de todas las posibilidades. Es til para el programador conocer dicho
mecanismo a la hora de depurar y optimizar los programas.
9. Entrada/Salida
PROLOG, al igual que la mayora de lenguajes de programacin modernos
incorpora predicados predefinidos para la entrada y salida de datos. Estos son
tratados como reglas que siempre se satisfacen.
* write.
Su sintaxis es:
write('Hello world').
Las comillas simples encierran constantes, mientras que todo lo que se encuentra
entre comillas dobles es tratado como una lista. Tambin podemos mostrar el
valor de una variable, siempre que este instanciada:
write(X).
* nl.
El predicado nl fuerza un retorno de carro en la salida. Por ejemplo:
write('linea 1'), nl, write('linea 2').
tiene como resultado:
linea 1
linea 2
* read.

Lee un valor del teclado. La lectura del comando read no finaliza hasta que se
introduce un punto ".". Su sintaxis es:
read(X).
Instancia la variable X con el valor ledo del teclado.
read(ejemplo).
Se evala como cierta siempre que lo tecleado coincida con la constante entre
parntesis (en este caso 'ejemplo').

Ejercicios y ejemplos
/*1-Determina si lo que recibe es una lista*/
lista([]):-!.
lista([X|Y]):-lista(Y).
/*------------------------------------------------------------------*/
/*2-Concatena dos listas*/
concatenar([],L,L).
concatenar([X|M],L,[X|Z]):-concatenar(M,L,Z).
/*------------------------------------------------------------------*/
/*3-Invierte la lista que recibe en el primer nivel*/
invertir([X],[X]).
invertir([X|M],Z):-invertir(M,S), concatenar(S,[X],Z).
/*------------------------------------------------------------------*/
/*4-Calcula la longitud de la lista*/
long([],0):-!.
long([X|Y],S):-long(Y,T),!, S is T + 1.
/*------------------------------------------------------------------*/

/*5-Suma los elementos de la lista*/

suma_elem([X],X):-!.
suma_elem([X|Y],S):-suma_elem(Y,T), S is T + X.
/*------------------------------------------------------------------*/
/*6-Devuelve el elemento que se encuentra en la enesima posicion*/
posicion_n([],N,[]):-!.
posicion_n([X|N],1,X):-!.
posicion_n([X|R],N,S):-M is N - 1,posicion_n(R,M,S).
/*------------------------------------------------------------------*/
/*7-Dan como resultado el primer y el ultimo elemento de la lista*/
primer_elem([X|Y],X):-!.
ultimo_elem(L,S):-invertir(L,T),primer_elem(T,S).
/*------------------------------------------------------------------*/
/*8-Calcula la primer posicion donde aparece el elemento X en la lista*/
prim_pos(X,[],0):-!.
prim_pos(X,[X|M],1):-!.
prim_pos(X,[Y|M],S):-prim_pos(X,M,T),S is T + 1.
/*------------------------------------------------------------------*/
/*9-Elimina el elemento x de la lista en todos los niveles*/
elimina_x([],X,[]):-!.
elimina_x([X],X,[]):-!.
elimina_x([X|M],X,S):-elimina_x(M,X,S),!.
elimina_x([R|M],X,S):-lista(R), elimina_x(R,X,T), elimina_x(M,X,P), concatenar([T],P,S).
elimina_x([R|M],X,S):-elimina_x(M,X,T), concatenar([R],T,S).
/*------------------------------------------------------------------*/

/*10-Invierte una lista en todos sus niveles*/

invertir_tot([],[]):-!.
invertir_tot([X|M],S):-lista(X),invertir_tot(X,P),invertir_tot(M,T),concatenar(T,[P],S).
invertir_tot([X|M],S):-invertir_tot(M,T),concatenar(T,[X],S),!.
/*------------------------------------------------------------------*/
/*11-Saca los n primeros elementos de una lista y devuelve el resto*/
sac_n_pri([],N,[]):-!.
sac_n_pri([X|M],1,M):-!.
sac_n_pri([X|M],N,S):-N1 is N-1,sac_n_pri(M,N1,S).
/*------------------------------------------------------------------*/
/*12-Da como resultado los n primeros elementos de una lista*/
da_n_pri(L,0,[]):-!.
da_n_pri([],N,[]):-!.
da_n_pri([X|M],1,[X]):-!.
da_n_pri([X|M],N,S):-N1 is N - 1,da_n_pri(M,N1,T),concatenar([X],T,S).
/*------------------------------------------------------------------*/
/*13-Muestra los ultimos n elementos de la lista*/
da_n_ultim(L,N,S):-invertir_tot(L,T),da_n_pri(T,N,R),invertir_tot(R,S).
/*------------------------------------------------------------------*/
/*14-Determina si dos listas son iguales en todos los niveles*/
lista_igual([],[]):-!.
lista_igual([X|M],[X|R]):-lista_igual(M,R).
lista_igual([X|M],[T|R]):-lista(X), lista(T), lista_igual(X,T),lista_igual(M,R).
/*------------------------------------------------------------------*/

/*15-Determina si la primer lista es prefijo de la segunda*/

prefijo([],M):-!.
prefijo([X],[X|M]):-!.
prefijo([X|L],[X|M]):-prefijo(L,M).
prefijo([X|T],[L|M]):-lista(X),prefijo(X,L),prefijo(T,M).
/*------------------------------------------------------------------*/
/*16-Determina si la primer lista es sublista de la segunda*/
sublista([],L):-!.
sublista(L,[X|M]):-prefijo(L,[X|M]).
sublista(L,[X|M]):-lista(X), sublista(L,X).
sublista(L,[X|M]):-sublista(L,M).
/*------------------------------------------------------------------*/
/*17-Elimina todos los elementos de la lista 1 que est n en la 2*/
elim_l1_de_l2([],L,L):-!.
elim_l1_de_l2([X|M],L,S):-elimina_x(L,X,T),elim_l1_de_l2(M,T,S).
/*------------------------------------------------------------------*/
/*18-Elimina los elementos repetidos que est n en una lista*/
elim_repet([],[]):-!.
elim_repet([X|M],S):-not lista(X), elimina_x(M,X,T),elim_repet(T,Y),
concatenar([X],Y,S).
elim_repet([X|M],S):-lista(X), elim_l1_de_l2(X,M,T),elim_repet(X,Y),
elim_repet(T,J),concatenar([Y],J,S).
/*------------------------------------------------------------------*/

/*19-Arma una lista con todos los elementos que se encuentran antes */
/*de elemento x en la lista*/
hasta_x([X|M],X,[]):-!.
hasta_x([Y|M],X,[Y|S]):-hasta_x(M,X,S).
/*------------------------------------------------------------------*/
/*20-Arma una lista con todos los elementos que se encuentran despues*/
/*del elemento x*/
desde_x([Y|M],X,S):-X=\=Y,desde_x(M,X,S),!.
desde_x([X,Y|M],X,[Y|M]):-X=\=Y,!.
desde_x([Y|M],X,S):-desde_x(M,X,S),!.
/*------------------------------------------------------------------*/
/*21-Determina si una lista se encuentra en orden creciente o decreciente*/
creciente([X,Y|Z]):- X<Y,
creciente([Y|Z]).
creciente([X]).

decreciente([X,Y|Z]):- X>Y,
decreciente([Y|Z]).
decreciente([X]).
/*------------------------------------------------------------------*/

/*22-Cuenta la ocurrencia de una lista atmica en otra lista*/

secuencia([],L,L):-!.
secuencia([X|Y],[X|L],[X|L]):-secuencia(Y,L,L).

cta_ocurr(L,[],0):-!.
cta_ocurr([X|Y],[X|M],N):-secuencia(Y,M,L1), cta_ocurr([X|Y],L1,T), N is T + 1.
cta_ocurr([X|Y],[R|M],N):-cta_ocurr([X|Y],M,N),!.
/*------------------------------------------------------------------*/

/*23-Determina si una lista puede analizarse del derecho o del revs*/

reversible([]):-!.
reversible(L):-invertir(L,R),lista_igual(L,R).
/*------------------------------------------------------------------*/

/*24-Calcula la cantidad de elementos que se encuentran en la misma*/

/*posicion en dos listas*/

orden(L,[],0):-!.
orden([],L,0):-!.
orden([X],[X],1):-!.
orden([X|Y],[X|Z],S):-orden(Y,Z,T),!, S is T+1.
orden([X|Y],[R|Z],S):-orden(Y,Z,S).
/*------------------------------------------------------------------*/

/*25-Arma una lista con todas las posiciones del elemento X en la lista*/

list_posic(X,[],N,[]):-!.
list_posic(X,[X|M],N,L):-N1 is N + 1,list_posic(X,M,N1,G),P is N + 1,
concatenar([P],G,L).
list_posic(X,[Y|M],N,L):-N1 is N + 1,list_posic(X,M,N1,L).

concatenar([],L,L):-!.
concatenar([X|Y],L,[X|Z]):-concatenar(Y,L,Z).
/*------------------------------------------------------------------*/