Introducción a la Inteligencia Artificial: Conceptos, Agentes y Entornos

Código en Prolog: Ejemplos y Explicaciones

A continuación, se presentan una serie de ejemplos de código en Prolog, junto con breves explicaciones de su funcionamiento:

Funciones para Máximos y Sumas

• max(X, X, X) :- !.
• max(X, Y, X) :- X > Y.
• max(X, Y, Y) :- X < Y.
• maxlist([], 0) :- !.
• maxlist([X], X) :- !.
• maxlist([X, Sec | R], Res) :- Sec > X, maxlist([Sec | R], Res), !.
• maxlist([X, _ | R], Res) :- maxlist([X | R], Res).
• sumlist([], 0) :- !.
• sumlist([X], X) :- !.
• sumlist([X | Res], J) :- (J is J + X), sumlist([Res], J).

Funciones para Ordenar y Generar Listas

• ordenatu(X, [], [X]).
• ordenatu(X, [Y | R], [X, Y | R]) :- X < Y.
• ordenatu(X, [Y | []], [Y, X]) :- X >= Y.
• ordenatu(X, [A | B], [A | L1]) :- X >= A, ordenatu(X, B, L1).
• between(F, L, F) :- F = L, !.
• between(F, _, F).
• between(F, L, X) :- F1 is F + 1, between(F1, L, X).
• gen_list(X, X, [X]) :- !.
• gen_list(X, Y, [X | List]) :- X < Y, X1 is X + 1, gen_list(X1, Y, List).
• insert_order(X, [], X).
• insert_order(X, [L | R], [X | [L | R]]) :- X =< L.
• insert_order(X, [L | R], [L | L1]) :- X > L, insert_order(X, R, L1).

Funciones para Relaciones Familiares y Pertenencia a Listas

• predecessor(X, Y) :- parent(X, Y).
• predecessor(X, Y) :- parent(X, Z), predecessor(Z, Y).
• member(X, [Y | _]) :- X = Y.
• member(X, [Y | R]) :- X \= Y, member(X, R).

Funciones para Manipular Listas

• num_elem([], 0).
• num_elem([_ | R], N) :- num_elem(R, N1), N is N + 1.
• concat([], L, L).
• concat([X], L, [X | L]).
• concat([X | R], L, [X | L1]) :- concat(R, L, L1).
• delete(X, [X | R], R).
• delete(X, [Y | R], [Y | L1]) :- X \= Y, delete(X, R, L1).
• insert(X, [], [X]).
• insert(X, L, [X | L]).

Funciones para Igualdad y Sucesión de Fibonacci

• iguales([]).
• iguales([_]) :- !.
• iguales([X, X | Xs]) :- iguales([X | Xs]).
• fibo(N, F) :- N = 0, F = 1.
• fibo(N, F) :- N = 1, F = 1.
• fibo(N, F) :- N > 1, N1 is N - 1, fibo(N1, F1), N2 is N - 2, fibo(N2, F2), F is F1 + F2.

Funciones para Partición, Longitud, Suma y Concatenación de Listas

• particion(X, [Y | Ys], [Y | Ps], Gs) :- Y < X, particion(X, Ys, Ps, Gs).
• particion(X, [Y | Ys], Ps, [Y | Gs]) :- Y >= X, particion(X, Ys, Ps, Gs).
• particion(X, [], [], []).
• length([], 0).
• length([_ | Xs], N) :- length(Xs, N1), N is N1 + 1.
• sum([], 0).
• sum([X | Xs], S) :- sum(Xs, Sc), S is Sc + X.
• append([], Ys, Ys).
• append([X | Xs], Ys, [X | Zs]) :- append(Xs, Ys, Zs).

Funciones para Partición y Encolado

• split(X, [Y | Ys], [Y | Ps], Gs) :- Y <= X, split(X, Ys, Ps, Gs).
• split(X, [Y | Ys], Ps, [Y | Gs]) :- Y > X, split(X, Ys, Ps, Gs).
• split(X, [], [], []).
• enqueue(X, [], [X]).
• enqueue(X, [Y | R], [Y | R1]) :- enqueue(X, R, R1).

Ejemplos de Juegos y sus Características

• Ajedrez sin reloj: Accesible, determinista, no episódico, discreto, estático.
• Ajedrez con reloj: Accesible, determinista, no episódico, discreto, dinámico.
• Póker: Inaccesible, no determinista, no episódico, continuo, estático.
• Taxi: Accesible, no determinista, no episódico, continuo, dinámico.

Conceptos Fundamentales de la Inteligencia Artificial

Definición de Inteligencia Artificial (IA)

La Inteligencia Artificial (IA) se refiere al estudio que permite percibir, razonar y actuar. Se trata de un sistema que intenta entender cómo trabaja la mente humana, o bien, un sistema basado en reglas.

Agente Inteligente

Un agente inteligente es una entidad capaz de percibir su entorno, procesar esas percepciones y responder o actuar en él de manera racional y correcta.

Prolog

Prolog es un lenguaje de programación funcional basado en la lógica.

Agente Racional

Un agente racional se define por la ecuación: Agente = Arquitectura + Programa. El programa depende del medio ambiente en el que se encuentre el agente.

Tipos de Programas Agente

1. Agente reflejo: Las acciones dependen de las reglas aplicadas.
2. Agente reflejo con estado interno: Considera el estado actual del entorno.
3. Agente basado en objetivos: Actúa para alcanzar objetivos específicos.
4. Agente basado en utilidad: Genera todos los estados posibles, los evalúa y elige el más adecuado.

Tipos de Entornos

1. Accesible / Inaccesible: El agente tiene acceso a toda la información del entorno / No dispone de toda la información.
2. Determinista / No determinista: Es posible obtener la mejor jugada a realizar / No es posible obtener el estado siguiente a partir del actual.
3. Episódico / No episódico: No es necesario pensar antes de actuar / Es necesario pensar antes de actuar.
4. Discreto / Continuo: Existe una cantidad discreta de jugadas posibles / No se puede determinar un camino o jugada fija.
5. Estático / Dinámico: El entorno no sufre cambios mientras el agente piensa / El entorno sufre cambios y hay un tiempo límite para actuar.

Tipos de Búsquedas

1. Búsqueda a ciegas: No existe información previa sobre la cantidad de pasos o el costo del camino desde el estado actual hasta el estado final. Primero utiliza breadth-first (búsqueda en anchura) y luego depth-first (búsqueda en profundidad).
2. Búsqueda heurística: Se basa en un número que indica el costo de la búsqueda desde el estado actual (n) hasta el estado final, representado como h(n).