Está en la página 1de 16

Universidad Nacional del Altiplano – Puno

Escuela Profesional de Ingeniería de Sistemas


CURSO: INTELIGENCIA ARTIFICIAL

GUÍA ACADÉMICA Nro. 7

TEMA: USO DEL VARIABLES ANÓNIMAS (GUIÓN BAJO) Y MANEJO DE LISTAS

OBJETIVOS:

◊ Comprender el manejo de listas


◊ Uso de Variables anónimas

REQUERIMIENTOS:

◊ PC con Windows y Visual Prolog

PROCEDIMIENTO

La presente contiene una serie de programas con respecto al uso de las listas
apoyadas por el uso del variables anónimas (guión bajo), antes de continuar
seria necesario definir Lista a un conjunto similar de valores, su equivalente en
lenguaje de programación común que vendría a ser un arreglo, pero su
administración y manejo difiere mucho del trabajo con índices que un arreglo
tiene.

PARTE 1: Variables Anónimas (Guión Bajo).

El guión bajo es una variable anónima, permiten evitar mostrar los valores de
las variables que ellas reemplazan, pero si actúan haciendo uso de estas.
A continuación se muestra un ejemplo sobre padres con sus hijos, copie el
siguiente código:

Domains
nombre = STRING
Predicates
nondeterm padre(nombre, nombre)
mostrar_ph(nombre, nombre)
Clauses
padre("Jose","Rosa").
padre("Pedro","Manuel").
padre("Carlos","Maria").
padre("Javier","Luisa").
mostrar_ph(Padre, Hijo):-padre(Padre, Hijo),
write(Padre, " es padre de ", Hijo), nl, fail.

Consultas:

Mostrar todos los padres con sus hijos:


Goal mostrar_ph(X, Y).
Resultado:
Jose es padre de Rosa

1
Universidad Nacional del Altiplano – Puno
Escuela Profesional de Ingeniería de Sistemas
CURSO: INTELIGENCIA ARTIFICIAL

Pedro es padre de Manuel


Carlos es padre de Maria
Javier es padre de Luisa
No Solution

Como se dará cuenta se muestra la lista de los padres con sus respectivos
hijos:

Agregue el siguiente código al anterior:

Predicates
mostrar_padre(nombre)
Clauses
mostrar_padre(Padre):-padre(Padre,_),
write(Padre, " es padre."), nl, fail.

Consultas:

Mostrar solo los padres:


goal mostrar_padre(X).
Resultado:
Jose es padre.
Pedro es padre.
Carlos es padre.
Javier es padre.
No Solution

Como se podrá ver en el código se esta realizando la consulta utilizando el


siguiente predicado: padre(Padre,_), como se requiere solo el nombre del
padre, utilizamos el guión bajo.

PARTE 2: Trabajando con Listas.

Las listas son unas estructuras de datos muy comunes en la programación no


numérica. Una lista es una secuencia ordenada de elementos que puede tener
cualquier longitud. Los elementos de una lista pueden ser cualquier término
(constantes, variables, estructuras) u otras listas.

Las listas pueden representarse como un tipo especial de árbol. Una lista
puede definirse recursivamente como:
• Una lista vacía [], sin elementos, o
• Una estructura con dos componentes:
o cabeza: primer argumento
o cola: segundo argumento, es decir, el resto de la lista.

El final de una lista se suele representar como una cola que contiene la lista
vacía. La cabeza y la cola de una lista son componentes de una estructura
cuyo nombre es “.”.

2
Universidad Nacional del Altiplano – Puno
Escuela Profesional de Ingeniería de Sistemas
CURSO: INTELIGENCIA ARTIFICIAL

Ejemplo:
La lista que contiene un solo elemento: ( a, [] )
La lista de tres elementos [a, b, c] podría escribirse ( a, . ( b, . ( c, [] ) ) )
Siempre terminando con la lista vacía.

En Visual Prolog utilizaremos una notación más sencilla de las listas que
dispone a los elementos de la misma separados por comas, y toda la lista
encerrada entre corchetes.

Así, las listas anteriores quedarían como [a] y [a, b, c], que es un tipo de
notación más manejable. Existe, también, una notación especial en Prolog para
representar la lista con cabeza X (elemento) y cola Y (lista):
[ X | Y ]

Ejemplos:

Lista Cabeza(Elemento) Cola(lista)


[a, b, c] a [b, c]
[a] a []
[] (no tiene) (no tiene)
[ [el, gato], maullo] [el, gato] [maullo]
[el, [gato, maullo] ] el [ [gato, maullo] ]
[el, [gato, maullo], ayer] el [ [gato, maullo], ayer]
[X+Y, x+y] X+Y [x+y]

Copie lo siguiente:

Domains
elemento = SYMBOL
lista_elementos = symbol* %Para declarar lista de Symbols
lista_numeros = integer* %Para declarar lista de números
Predicates
asignar_animales(lista_elementos)
asignar_numeros(lista_numeros)
Clauses
asignar_numeros(Lis_num):-Lis_num=[1, 2, 3, 9, -3, 2].
%Predicado que asigna una lista de numeros a la variable
Lista_num
asignar_animales(Lis_ani):-
Lis_ani=["Asno","Burro","Cabra",
"Elefante"].
%Predicado que asigna una lista de animales a la variable
Lista_animal

El programa anterior asigna una lista a la varible ingresada.

3
Universidad Nacional del Altiplano – Puno
Escuela Profesional de Ingeniería de Sistemas
CURSO: INTELIGENCIA ARTIFICIAL

Consultas:

Asignar la lista de los animales a la variable X:


Goal asignar_animales(X).
Resultado:
X=["Asno","Burro","Cabra","Elefante"]
1 Solution

Asignar la lista de los numeros a la variable Y:


Goal asignar_animales(Y).
Resultado: Y=["Asno","Burro","Cabra","Elefante"]
1 Solution

4
Universidad Nacional del Altiplano – Puno
Escuela Profesional de Ingeniería de Sistemas
CURSO: INTELIGENCIA ARTIFICIAL

Ahora agregue el siguiente código al programa anterior:

Predicates
mostrar_lisani
Clauses
mostrar_lisani:-asignar_animales(LA), LA=[Cabeza|
Cuerpo],
write("La Cabeza es: ", Cabeza, " y el cuerpo es:
",
Cuerpo).

El código muestra la cabeza y el cuerpo de la lista de los animales.

Consultas:

Consultar lo siguiente:
Goal mostrar_lisani.
Resultado:
La Cabeza es: Asno y el cuerpo es: ["Burro","Cabra","Elefante"]yes

Ahora agregue el siguiente código al programa anterior:

Predicates
nondeterm mostrar_all(lista_elementos)
nondeterm main
Clauses
mostrar_all(LA):-LA=[Cabeza|Cuerpo], Cuerpo=[],
write("El último elemento es: ", Cabeza).
mostrar_all(LA):-LA=[Cabeza|Cuerpo],write("La Cabeza
es: ",
Cabeza, " y el cuerpo es: ", Cuerpo), nl,
mostrar_all(Cuerpo).
main:-asignar_animales(LA),mostrar_all(LA).

Consultas:

Consulte lo siguiente y explique como funciona:


Goal main.
Resultado:
La Cabeza es: Asno y el cuerpo es: ["Burro","Cabra","Elefante"]
La Cabeza es: Burro y el cuerpo es: ["Cabra","Elefante"]
La Cabeza es: Cabra y el cuerpo es: ["Elefante"]
El último elemento es: Elefanteyes

Explicación: Primero, se le asigna una lista con cuerpo y cabeza y si ya no hay


cuerpo y solo cabeza se le asigna a la cabeza como ulitmo elemento.
Luego se vuelve a mostrar toda la lista de cabeza y cola esto funciona
recursivamente.

5
Universidad Nacional del Altiplano – Puno
Escuela Profesional de Ingeniería de Sistemas
CURSO: INTELIGENCIA ARTIFICIAL

PARTE 2: Buscar elementos en una Lista

A continuación se muestra la búsqueda de un elemento en una lista, como no


se conoce con exactitud el tamaño de la lista se utilizara la recursividad para
recorrer toda la lista en busca del elemento.

a) Copie el siguiente código:

DOMAINS
lis_num = INTEGER*
numero = INTEGER
PREDICATES
nondeterm es_miembro1(numero, lis_num)
CLAUSES
es_miembro1(Elem, Lista):- Lista=[Cab|Cuer], Cab=Elem.
es_miembro1(Elem, Lista):- Lista=[Cab|Cuer],
es_miembro1(Elem, Cuer).

Consultas:

Verificar si 3 es miembro de la Lista [1, 2, 3, 4, 5]:


GOAL es_miembro1(3, [1, 2, 3, 4, 5]).
Resultado: yes

b) Agregue el siguiente código:

PREDICATES
nondeterm es_miembro2(numero, lis_num)
CLAUSES
es_miembro2(Elem, [Cab|Cuer]):- Cab=Elem.
es_miembro2(Elem, [Cab|Cuer]):- es_miembro2(Elem,
Cuer).

Consultas:

Verificar si 4 es miembro de la Lista [1, 2, 3, 4, 5]:


GOAL es_miembro2(4, [1, 2, 3, 4, 5]).
Resultado:yes

c) Agregue el siguiente código:

PREDICATES
nondeterm es_miembro3(numero, lis_num)
CLAUSES
es_miembro3(Elem, [Elem|Cuer]).
es_miembro3(Elem, [Cab|Cuer]):- es_miembro3(Elem,
Cuer).

Consultas:

6
Universidad Nacional del Altiplano – Puno
Escuela Profesional de Ingeniería de Sistemas
CURSO: INTELIGENCIA ARTIFICIAL

Verificar si 2 es miembro de la Lista [1, 2, 3, 4, 5]:


GOAL es_miembro3(2, [1, 2, 3, 4, 5]).
Resultado: yes

d) Agregue el siguiente código:

PREDICATES
nondeterm es_miembro4(numero, lis_num)
CLAUSES
es_miembro4(Elem, [Elem|_]).
es_miembro4(Elem, [_|Cuer]):- es_miembro4(Elem, Cuer).

Consultas:

Verificar si 5 es miembro de la Lista [1, 2, 3, 4, 5]:


GOAL es_miembro4(5, [1, 2, 3, 4, 5]).
Resultado: yes

Explique como funciona cada Predicado, cual es la diferencia entre ellos, cual
es el mejor y porque:
Es_miembro1:

es_miembro1(Elem, Lista):- Lista=[Cab|Cuer], Cab=Elem.


es_miembro1(Elem, Lista):- Lista=[Cab|Cuer],
es_miembro1(Elem, Cuer).
CONCLUSION: Se utiliza mas espacio para agregar la lista
Es_miembro2:
es_miembro2(Elem, [Cab|Cuer]):- Cab=Elem.
es_miembro2(Elem, [Cab|Cuer]):- es_miembro2(Elem,
Cuer).
Conclusión lista es sustituido por [Cab|Cuer], directamente.

Es_miembro3:
es_miembro3(Elem, [Elem|Cuer]).
es_miembro3(Elem, [Cab|Cuer]):- es_miembro3(Elem,
Cuer).

Conclusion: cabeza ya no se iguala a elemento, sino ya directamente.

Es_miembro4:

es_miembro4(Elem, [Elem|_]).
es_miembro4(Elem, [_|Cuer]):- es_miembro4(Elem, Cuer).
Conclusión: se trabaja las listas ya con anonimas con el
cual tb se hace mas eficiente el programa.

Diferencia:
La diferencia entre las tecnicas para ver si es miembro, es su eficiencia en la
cual se realizan menos llamadas , y la reduccion del codigo tb.

Mejor:
Es_miembro4

7
Universidad Nacional del Altiplano – Puno
Escuela Profesional de Ingeniería de Sistemas
CURSO: INTELIGENCIA ARTIFICIAL

Por que?
porque solo utiliza lo necesario. Realizando las mismas tareas que las demas.

PARTE 3: OPERACIONES CON LISTAS

A continuación se desarrollaran operaciones con Listas, observara que no


existe Advertencia (Warning) de ningún tipo:

a) Predicado que devuelve la cantidad de elementos de una lista

DOMAINS
lis_num = INTEGER*
numero = INTEGER
PREDICATES
nondeterm contar_lis(lis_num, numero)
CLAUSES
contar_lis([], 0).
contar_lis([_|Cuer], Can):- contar_lis(Cuer, NewCan),
Can=Newcan+1.

Consultas:

Ejecutar la siguiente consulta:


GOAL contar_lis([1, 2, 3, 4, 5], Can).
Resultado: Can=5
1 Solution

Explique como funciona el predicado contar_lis:


El conteo lo realiza de cabeza a cola, agregando de uno en uno

b) Predicado que devuelve el último elemento de la lista:

PREDICATES
nondeterm ultimo_lis(lis_num, numero)
CLAUSES
ultimo_lis([Elem], Elem).
ultimo_lis([_|Cuer], Elem):- ultimo_lis(Cuer, Elem).

Consultas:

Ejecutar la siguiente consulta:


GOAL ultimo_lis([1, 4, 7, 1, 9, 16, 13], Ult).
Resultado: Ult=13
1 Solution

Explique como funciona el predicado ultimo_lis:


El ultimo de la lista vendaría aser como la cabeza de la lista , por lo tanto la
operación se realiza recursivamente.

8
Universidad Nacional del Altiplano – Puno
Escuela Profesional de Ingeniería de Sistemas
CURSO: INTELIGENCIA ARTIFICIAL

c) Predicado que devuelve yes cuando el dato ingresado es una lista:

PREDICATES
nondeterm es_lista(lis_num).
CLAUSES
es_lista([]).
es_lista([_|_]).

Consultas:

Ejecutar la siguiente consulta:


GOAL es_lista([1, 4, 7, 1, 9, 16, 13]).
Resultado: yes

Explique como funciona el predicado es_lista:


Es_lista ci tiene cabeza, o cabeza y cuerpo.

d) Predicado que concatena 2 listas en una tercera lista:

PREDICATES
nondeterm concat_lis(lis_num, lis_num, lis_num)
CLAUSES
concat_lis([], Lista, Lista).
concat_lis([Cab|Cuer], Lista, [Cab|ListaDes]):-
concat_lis(Cuer, Lista, ListaDes).

Consultas:

Ejecutar la siguiente consulta:


goal concat_lis([1, 4, 7 ], [ 6, 2, 98], NewLista).
Resultado:
goal concat_lis([1, 4, 7 ], [ 6, 2, 98], NewLista).

Ejecutar la siguiente consulta:


goal concat_lis(ListaOri, [1, 4, 7 ], [56, 23, 89, 1, 4,
7 ]).
Resultado:
ListaOri=[56,23,89]
1 Solution

Ejecutar la siguiente consulta:


goal concat_lis(ListaOri1, Listaori2, [ 2, 5, 9, 1, 6, 2,
8]).
Resultado:
ListaOri1=[], Listaori2=[2,5,9,1,6,2,8]
ListaOri1=[2], Listaori2=[5,9,1,6,2,8]
ListaOri1=[2,5], Listaori2=[9,1,6,2,8]
ListaOri1=[2,5,9], Listaori2=[1,6,2,8]
ListaOri1=[2,5,9,1], Listaori2=[6,2,8]
ListaOri1=[2,5,9,1,6], Listaori2=[2,8]
ListaOri1=[2,5,9,1,6,2], Listaori2=[8]

9
Universidad Nacional del Altiplano – Puno
Escuela Profesional de Ingeniería de Sistemas
CURSO: INTELIGENCIA ARTIFICIAL

ListaOri1=[2,5,9,1,6,2,8], Listaori2=[]
8 Solutions

Explique como funciona el predicado concat_lista:


Se tiene al inicio una lista donde se va a reservar las dos listas anteriores.

10
Universidad Nacional del Altiplano – Puno
Escuela Profesional de Ingeniería de Sistemas
CURSO: INTELIGENCIA ARTIFICIAL

CONCLUSIONES

RECOMENDACIONES

Trabajo Aplicativo:

1. Realice un programa que invierta una lista.

DOMAINS
lis_num = INTEGER*
numero = INTEGER
PREDICATES
nondeterm invertir(lis_num,lis_num)
nondeterm borrar(numero,lis_num,lis_num)
nondeterm insertar(numero,lis_num,lis_num)
nondeterm permutar(lis_num,lis_num)
nondeterm no_es_miembro(numero,lis_num)
nondeterm hazconjunto(lis_num,lis_num)
nondeterm union(lis_num,lis_num,lis_num)
nondeterm interseccion(lis_num,lis_num,lis_num)
nondeterm miembro(numero,lis_num)

11
Universidad Nacional del Altiplano – Puno
Escuela Profesional de Ingeniería de Sistemas
CURSO: INTELIGENCIA ARTIFICIAL

CLAUSES
invertir([],[]).
invertir([X|L],Z):-invertir(L,Lis), concat_lis(Lis,[X],Z).
borrar(X,[X|C],C).
borrar(X,[Y|C1],[Y|C2]):-elimina(X,C1,C2).
insertar(E,L,[E|L]).
insertar(E,[X|Y],[X|Z]) :-insertar(E,Y,Z).
permutar([],[]).
permutar([X|Y],Z) :- permutar(Y,L),insertar(X,L,Z).
no_es_miembro(Elemento,Lista):- Lista=[X|Y], X=Elemento, not(Y=[]),write("->",X),nl.
no_es_miembro(Elemento,Lista):- Lista=[_|Y], no_es_miembro(Elemento,Y).
agregar([],L,L).
agregar([C|T],L,[C|Li]):-agregar(T,L,Li).
hazconjunto(S,L):-agregar(_,S,P),agregar(P,_,L).
union([],L,L).
union([X|L1],L2,L3):-miembro(X,L2),!,union(L1,L2,L3).
union([X|L1],L2,[X|L3]):-union(L1,L2,L3).
interseccion([X|L1],L2,[X|L3]):-miembro(X,L2),!,interseccion(L1,L2,L3).
interseccion([_|L1],L2,L3):-!,interseccion(L1,L2,L3).
interseccion(_,_,[]).

GOAL
%invertir([1, 4, 7, 1, 9, 16, 13],Lista).
%borrar(9,[1, 4, 7, 1, 9, 16, 13],Lista).
%insertar(5,[1, 4, 7, 1, 9, 16, 13],Lista).
%permutar([1,2,4,14,6], X).
%no_es_miembro(1,[1, 2, 3, 9, -3, 2]).
%hazconjunto(SubConjuntos,[1, 2, 3, 9]).
%union([1,2,3,9,-3,2],[1,2,4,14,6],Union).
interseccion([1,7,3,9,-3,2],[1,2,7,4,14,6],Interseccion).

2.- Realice un programa que borre un elemento de una lista.

12
Universidad Nacional del Altiplano – Puno
Escuela Profesional de Ingeniería de Sistemas
CURSO: INTELIGENCIA ARTIFICIAL

DOMAINS
lis_num = INTEGER*
numero = INTEGER
PREDICATES
nondeterm invertir(lis_num,lis_num)
nondeterm borrar(numero,lis_num,lis_num)
nondeterm insertar(numero,lis_num,lis_num)
nondeterm permutar(lis_num,lis_num)
nondeterm no_es_miembro(numero,lis_num)
nondeterm hazconjunto(lis_num,lis_num)
nondeterm union(lis_num,lis_num,lis_num)
nondeterm interseccion(lis_num,lis_num,lis_num)
nondeterm miembro(numero,lis_num)

CLAUSES
invertir([],[]).
invertir([X|L],Z):-invertir(L,Lis), concat_lis(Lis,[X],Z).
borrar(X,[X|C],C).
borrar(X,[Y|C1],[Y|C2]):-elimina(X,C1,C2).
insertar(E,L,[E|L]).
insertar(E,[X|Y],[X|Z]) :-insertar(E,Y,Z).
permutar([],[]).
permutar([X|Y],Z) :- permutar(Y,L),insertar(X,L,Z).
no_es_miembro(Elemento,Lista):- Lista=[X|Y], X=Elemento, not(Y=[]),write("->",X),nl.
no_es_miembro(Elemento,Lista):- Lista=[_|Y], no_es_miembro(Elemento,Y).
agregar([],L,L).
agregar([C|T],L,[C|Li]):-agregar(T,L,Li).
hazconjunto(S,L):-agregar(_,S,P),agregar(P,_,L).
union([],L,L).
union([X|L1],L2,L3):-miembro(X,L2),!,union(L1,L2,L3).
union([X|L1],L2,[X|L3]):-union(L1,L2,L3).
interseccion([X|L1],L2,[X|L3]):-miembro(X,L2),!,interseccion(L1,L2,L3).
interseccion([_|L1],L2,L3):-!,interseccion(L1,L2,L3).
interseccion(_,_,[]).

13
Universidad Nacional del Altiplano – Puno
Escuela Profesional de Ingeniería de Sistemas
CURSO: INTELIGENCIA ARTIFICIAL

GOAL
%invertir([1, 4, 7, 1, 9, 16, 13],Lista).
%borrar(9,[1, 4, 7, 1, 9, 16, 13],Lista).
%insertar(5,[1, 4, 7, 1, 9, 16, 13],Lista).
%permutar([1,2,4,14,6], X).
%no_es_miembro(1,[1, 2, 3, 9, -3, 2]).
%hazconjunto(SubConjuntos,[1, 2, 3, 9]).
%union([1,2,3,9,-3,2],[1,2,4,14,6],Union).
interseccion([1,7,3,9,-3,2],[1,2,7,4,14,6],Interseccion).
3.- Realice un programa que inserte un elemento en una lista.
DOMAINS
lis_num = INTEGER*
numero = INTEGER
PREDICATES
nondeterm invertir(lis_num,lis_num)
nondeterm borrar(numero,lis_num,lis_num)
nondeterm insertar(numero,lis_num,lis_num)
nondeterm permutar(lis_num,lis_num)
nondeterm no_es_miembro(numero,lis_num)
nondeterm hazconjunto(lis_num,lis_num)
nondeterm union(lis_num,lis_num,lis_num)
nondeterm interseccion(lis_num,lis_num,lis_num)
nondeterm miembro(numero,lis_num)

CLAUSES
invertir([],[]).
invertir([X|L],Z):-invertir(L,Lis), concat_lis(Lis,[X],Z).
borrar(X,[X|C],C).
borrar(X,[Y|C1],[Y|C2]):-elimina(X,C1,C2).
insertar(E,L,[E|L]).
insertar(E,[X|Y],[X|Z]) :-insertar(E,Y,Z).
permutar([],[]).

14
Universidad Nacional del Altiplano – Puno
Escuela Profesional de Ingeniería de Sistemas
CURSO: INTELIGENCIA ARTIFICIAL

permutar([X|Y],Z) :- permutar(Y,L),insertar(X,L,Z).
no_es_miembro(Elemento,Lista):- Lista=[X|Y], X=Elemento,
not(Y=[]),write("->",X),nl.
no_es_miembro(Elemento,Lista):- Lista=[_|Y], no_es_miembro(Elemento,Y).
agregar([],L,L).
agregar([C|T],L,[C|Li]):-agregar(T,L,Li).
hazconjunto(S,L):-agregar(_,S,P),agregar(P,_,L).
union([],L,L).
union([X|L1],L2,L3):-miembro(X,L2),!,union(L1,L2,L3).
union([X|L1],L2,[X|L3]):-union(L1,L2,L3).
interseccion([X|L1],L2,[X|L3]):-miembro(X,L2),!,interseccion(L1,L2,L3).
interseccion([_|L1],L2,L3):-!,interseccion(L1,L2,L3).
interseccion(_,_,[]).

GOAL
%invertir([1, 4, 7, 1, 9, 16, 13],Lista).
%borrar(9,[1, 4, 7, 1, 9, 16, 13],Lista).
%insertar(5,[1, 4, 7, 1, 9, 16, 13],Lista).
%permutar([1,2,4,14,6], X).
%no_es_miembro(1,[1, 2, 3, 9, -3, 2]).
%hazconjunto(SubConjuntos,[1, 2, 3, 9]).
%union([1,2,3,9,-3,2],[1,2,4,14,6],Union).
interseccion([1,7,3,9,-3,2],[1,2,7,4,14,6],Interseccion).
4.- Realice un programa que realice la permutación de una lista
DOMAINS
lis_num = INTEGER*
numero = INTEGER
PREDICATES
nondeterm invertir(lis_num,lis_num)
nondeterm borrar(numero,lis_num,lis_num)
nondeterm insertar(numero,lis_num,lis_num)
nondeterm permutar(lis_num,lis_num)
nondeterm no_es_miembro(numero,lis_num)
nondeterm hazconjunto(lis_num,lis_num)
nondeterm union(lis_num,lis_num,lis_num)

15
Universidad Nacional del Altiplano – Puno
Escuela Profesional de Ingeniería de Sistemas
CURSO: INTELIGENCIA ARTIFICIAL

nondeterm interseccion(lis_num,lis_num,lis_num)
nondeterm miembro(numero,lis_num)

CLAUSES
invertir([],[]).
invertir([X|L],Z):-invertir(L,Lis), concat_lis(Lis,[X],Z).
borrar(X,[X|C],C).
borrar(X,[Y|C1],[Y|C2]):-elimina(X,C1,C2).
insertar(E,L,[E|L]).
insertar(E,[X|Y],[X|Z]) :-insertar(E,Y,Z).
permutar([],[]).
permutar([X|Y],Z) :- permutar(Y,L),insertar(X,L,Z).
no_es_miembro(Elemento,Lista):- Lista=[X|Y], X=Elemento, not(Y=[]),write("->",X),nl.
no_es_miembro(Elemento,Lista):- Lista=[_|Y], no_es_miembro(Elemento,Y).
agregar([],L,L).
agregar([C|T],L,[C|Li]):-agregar(T,L,Li).
hazconjunto(S,L):-agregar(_,S,P),agregar(P,_,L).
union([],L,L).
union([X|L1],L2,L3):-miembro(X,L2),!,union(L1,L2,L3).
union([X|L1],L2,[X|L3]):-union(L1,L2,L3).
interseccion([X|L1],L2,[X|L3]):-miembro(X,L2),!,interseccion(L1,L2,L3).
interseccion([_|L1],L2,L3):-!,interseccion(L1,L2,L3).
interseccion(_,_,[]).

GOAL
%invertir([1, 4, 7, 1, 9, 16, 13],Lista).
%borrar(9,[1, 4, 7, 1, 9, 16, 13],Lista).
%insertar(5,[1, 4, 7, 1, 9, 16, 13],Lista).
%permutar([1,2,4,14,6], X).
%no_es_miembro(1,[1, 2, 3, 9, -3, 2]).
%hazconjunto(SubConjuntos,[1, 2, 3, 9]).
%union([1,2,3,9,-3,2],[1,2,4,14,6],Union).
interseccion([1,7,3,9,-3,2],[1,2,7,4,14,6],Interseccion).

16