Prolog el lenguaje de programación lógico

Hoy en día cuando queremos estudiar o realizar un proyecto tenemos una gran cantidad de lenguajes a nuestra disposición. Pero hay muchos de ellos cuyas características principales son similares. Sin embargo dentro de ese grupo de lenguajes distintos y poco conocidos está Prolog.

¿Qué es Prolog?

Prolog es un lenguaje lógico, utilizado para programar en el campo de la inteligencia artificial. Sus características son bastante peculiares ya que no sigue la filosofía estructurada ni la orientada a objetos. Algunas de las cosas llamativas que podemos encontrar en el mismo es que no hay bucles.

El lenguaje se basa principalmente en:

• hechos algo que siempre es verdadero.
• reglas algo que para que sea verdadero se tienen que cumplir aquellas condiciones del cuerpo de la regla.

El proceso de resolución

La solución que suele ofrecer es verdadero o falso y para ello intenta buscar el objetivo que le indicamos analizando las cláusulas (hechos y reglas) de arriba a abajo. Además utiliza el algoritmo de backtracking para intentar al alcanzar la solución aunque sea utilizando múltiples reglas.

Ejemplo en Prolog

Un ejemplo sencillo que podemos hacer en Prolog es buscar si hay un camino entre dos ciudades, sabiendo que hay carreteras en un único sentido que conectan una ciudad con otra.

domains
  list=symbol*
  
predicates
  conectado(symbol,symbol)
  resuelve(list,symbol)
  escribe(list)
  
clauses
         /*Escritura de la lista */
        escribe([]).
        escribe([H|T]):- /* Escritura recursiva */
            escribe(T),
            write(H,'\n').

    conectado(salamanca,avila).
    conectado(avila,madrid).
    conectado(salamanca,valladolid).
    conectado(valladolid,zamora).
    conectado(valladolid,madrid).
    conectado(madrid,bilbao).
    conectado(madrid,sevilla).
    conectado(madrid,valencia).
    resuelve(Pila,B):-
        Pila=[Cabeza|Cola],
        Cabeza=B,
        escribe(Pila).
        
    resuelve(Pila,B):-
        Pila=[Cabeza|Cola],
        conectado(Cabeza,C), /* C sera una ciudad conectada con el 1º elemento de la pila  */
        NuevaPila=[C|Pila], /* Añadimos a la pila */
        resuelve(NuevaPila,B). /* Llamada recursiva */
        
goal
  resuelve([salamanca],sevilla).

En este ejemplo podéis ver que escribe([]) es un hecho, pero escribe([H|T]) es una regla puesto que para que sea verdadera se tiene que cumplir el cuerpo que se define debajo.

Los predicados que hemos incluidos son:

• escribe, para escribir la solución.
• conectado, para indicarle cómo están conectadas nuestras ciudades.
• resuelve, para que busque caminos que no sean directos, esto es, encuentre caminos entre dos ciudades pasando por otra (u otras).

El objetivo como podéis ver es buscar un camino entre Salamanca y Sevilla.

La solución que nos propone el sistema es la siguiente:

Si nosotros comprobamos nuestro código veremos que Salamanca y Ávila están conectadas, Ávila y Madrid también y lo mismo ocurre con Madrid y Sevilla. El yes que muestra, es que hay cláusulas que hacen cierto nuestro objetivo.