Configuración del Entorno de Desarrollo Prolog

1. Requisitos Previos e Instalación del Software Base

Paso 1: Instalación de SWI-Prolog (Motor del Lenguaje)

SWI-Prolog es el interprete y compilador que ejecutará el razonamiento lógico.

  1. Ve a la página oficial de descargas: SWI-Prolog Downloads.
  2. Selecciona el instalador correspondiente a tu sistema operativo:
    • Windows: Descarga el ejecutable de 64-bit (swipl-x.x.x-x.x64.exe). Al ejecutar el instalador, asegúrate de marcar la casilla "Add swipl to the system PATH for all users" (o current user). Esto es indispensable para que VS Code reconozca Prolog desde la terminal.
    • macOS: Puedes usar Homebrew desde la terminal ejecutando brew install swi-prolog, o descargar el paquete .dmg oficial.
    • Linux (Ubuntu/Debian): Abre la terminal y ejecuta:
      Bashsudo apt update sudo apt install swi-prolog

Paso 2: Instalación de Visual Studio Code

  1. Descarga e instala Visual Studio Code (edición estándar / azul) desde code.visualstudio.com.
  2. Completa la instalación con los valores por defecto.

2. Configuración de VS Code y Extensiones

Paso 1: Instalación de la Extensión para Prolog

Para contar con resaltado de sintaxis, autodetección y atajos de ejecución:

  1. Abre Visual Studio Code.
  2. Abre la vista de extensiones presionando Ctrl + Shift + X (en Windows/Linux) o Cmd + Shift + X (en macOS).
  3. En la barra de búsqueda escribe: VSC-Prolog (desarrollada por Arthur Wang) o Prolog (desarrollada por LSS).
  4. Haz clic en Instalar.

Paso 2: Configuración del ejecutable en VS Code (Si es necesario)

Si VS Code no detecta automáticamente la ruta de SWI-Prolog:

  1. En VS Code, ve a Configuración (Ctrl + , o Cmd + ,).
  2. En la barra de búsqueda de configuraciones escribe prolog.executablePath.
  3. Asigna la ruta directa al ejecutable de SWI-Prolog:
    • Windows: C:\Program Files\swipl\bin\swipl.exe
    • macOS / Linux: /usr/bin/swipl o /usr/local/bin/swipl

3. Práctica Paso a Paso: Creación del Primer Programa (“Hola Mundo”)

El siguiente script .pl está enfocado en el ámbito legal/ético de TI para verificar la sintaxis y la carga de hechos.

1.Crear el espacio de trabajo.

Crea una carpeta en tu equipo llamada curso_logica_ti. En VS Code, selecciona Archivo > Abrir carpeta… y elige dicha carpeta.

2.Crear el archivo de código Prolog:Paso 2.

Crea un nuevo archivo llamado hola_mundo.pl e ingresa el siguiente código de prueba:

% =========================================================
% SESIÓN 0: HOLA MUNDO Y VERIFICACIÓN DE ENTORNO
% Modulo: Verificacion de Licencias y Permisos Digitales
% =========================================================

% --- HECHOS (Factores del Entorno) ---
usuario(juan).
usuario(maria).

es_dato_personal(curp).
es_dato_personal(rfc).

% --- REGLAS ---
% Regla de prueba: Un usuario tiene acceso si es un usuario registrado
tiene_acceso(X) :- usuario(X).

% Regla para saludar desde el motor de inferencia
hola_mundo :-
    write('¡Entorno de Prolog configurado exitosamente para Derecho y Ética en TI!'), nl.

3.Abrir la Terminal en VS Code:Paso 3.

Despliega la terminal integrada en VS Code con el atajo Ctrl + ` (o Terminal > Nueva terminal en el menú superior).

4. Ejecución de Consultas y Depuración en Consola

Sigue estos pasos para cargar tu archivo .pl en la consola interactiva de SWI-Prolog y hacer tus primeras consultas lógicas:

1.Iniciar la Consola de SWI-Prolog:Terminal integrada.

En la terminal de VS Code, escribe el comando para iniciar la consola interactiva de Prolog:

swipl

Verification: El prompt de la terminal cambiará a ?-, indicando que el interprete está listo.

2.Cargar el Archivo .pl (Consulting):Comando consult.

Carga tu archivo de código escribiendo exactamente el nombre del archivo entre corchetes (sin la extensión .pl o con ella) finalizando siempre con un punto .:

?- [hola_mundo].

Verification: Deberás ver un mensaje como true. o % hola_mundo compiled 0.00 sec.

3.Probar el Predicado Principal:Hola Mundo.

Ejecuta el predicado de prueba para confirmar la salida estándar de texto:

?- hola_mundo.

Verification: Se imprimirá en pantalla el texto ¡Entorno de Prolog configurado exitosamente para Derecho y Ética en TI! seguido de true..

4.Realizar Consultas de Inferencia Lógica:Verificación de Hechos.

Prueba realizar preguntas a la base de conocimiento cargada:

  • Consulta 1: ¿Es el CURP un dato personal?
?- es_dato_personal(curp).

(Devolverá true.)

  • Consulta 2: ¿Tiene acceso Juan?
?- tiene_acceso(juan).

(Devolverá true.)

  • Consulta 3: ¿Tiene acceso Carlos? (no registrado)
?- tiene_acceso(carlos).

(Devolverá false.)

  • Consulta 4: Buscar qué usuarios tienen acceso (uso de variables en mayúscula):
?- tiene_acceso(X).

(Presiona ; en tu teclado para ver los siguientes resultados: X = juan ; X = maria)

5.Salir de la Consola de Prolog: Cierre de sesión.

Para finalizar la sesión de SWI-Prolog y volver a la terminal normal del sistema operativo:

?- halt.

Desglose del archivo “hola_mundo.pl”

1. Encabezado y Comentarios (Líneas 1 a 5)

% =========================================================
% SESIÓN 0: HOLA MUNDO Y VERIFICACIÓN DE ENTORNO
% Modulo: Verificacion de Licencias y Permisos Digitales
% =========================================================
  • % (Signo de porcentaje): Indica un comentario de una sola línea.

2. Sección de Hechos / Base de Conocimiento

En Prolog, un hecho (fact) es una afirmación que declaramos como incondicionalmente verdadera dentro de nuestro universo o dominio del problema (en este caso, un sistema de control de acceso y privacidad).

% --- HECHOS (Factores del Entorno) ---
usuario(juan).
usuario(maria).
  • usuario(juan).:
    • usuario: Es el predicado (o functor). Representa una propiedad o categoría. Debe comenzar obligatoriamente con letra minúscula.
    • (juan): Es el argumento del predicado. Como comienza en minúscula, Prolog lo interpreta como un átomo (una constante o entidad específica).
    • . (Punto final): Es el terminador de cláusula. Indica que la afirmación ha terminado.
    • Traducción lógica:Usuario(juan)\text{Usuario}(\text{juan}) — “Juan es un usuario.”
  • usuario(maria).: Declara exactamente la misma propiedad para una segunda constante llamada maria.
es_dato_personal(curp).
es_dato_personal(rfc).
  • es_dato_personal(curp).:
    • es_dato_personal: Predicado unario (recibe 1 argumento) que utiliza guiones bajos (_) para separar palabras, siguiendo la convención snake_case estándar en Prolog.
    • curp: Átomo que representa la Clave Única de Registro de Población (dato identificativo conforme a la Ley Federal de Protección de Datos Personales en Posesión de los Particulares en México).
    • Traducción lógica:EsDatoPersonal(curp)\text{EsDatoPersonal}(\text{curp}) — “El CURP es un dato personal.”
  • es_dato_personal(rfc).: Declara que el Registro Federal de Contribuyentes (rfc) también pertenece a la categoría de dato personal.

3. Sección de Reglas e Inferencia

Una regla (rule) permite deducir nuevo conocimiento a partir de los hechos existentes. Su estructura es:
Cabeza :- Cuerpo.
(se lee: “La Cabeza es verdadera SI el Cuerpo es verdadero”).

% --- REGLAS ---
% Regla de prueba: Un usuario tiene acceso si es un usuario registrado
tiene_acceso(X) :- usuario(X).
  • tiene_acceso(X): Es la cabeza de la regla (la conclusión o consecuencia jurídica/técnica).
    • X: Al comenzar con letra MAYÚSCULA, Prolog la reconoce como una variable lógica (un espacio reservado que puede tomar el valor de cualquier constante).
  • : - (dos puntos seguidos de un guion): Es el operador de implicación lógica inversa (←\leftarrow). En lenguaje natural significa “si” (if).
  • usuario(X).: Es el cuerpo de la regla (la condición o premisa) terminado en punto.
  • Traducción matemática completa:∀X(Usuario(X)→TieneAcceso(X))\forall X \, (\text{Usuario}(X) \rightarrow \text{TieneAcceso}(X)).
  • Funcionamiento interno: Si consultas ?- tiene_acceso(juan)., Prolog sustituye (unifica) X = juan y busca en su base si existe el hecho usuario(juan).. Como existe, responde true..
% Regla para saludar desde el motor de inferencia
hola_mundo :-
    write('¡Entorno de Prolog configurado exitosamente para Derecho y Ética en TI!'), nl.
  • hola_mundo :-: Define una regla sin argumentos (predicado de aridad 0). Cuando invocas ?- hola_mundo., Prolog intenta satisfacer las condiciones de su cuerpo.
  • write('...'): Es un predicado predefinido (built-in) de entrada/salida. Todo lo que está entre comillas simples '...' se imprime textualmente en la consola de terminal. Este predicado siempre evalúa a true como efecto secundario de imprimir.
  • , (coma): Representa el operador lógico de conjunción Y (∧\land). Indica que después de ejecutar write(...), Prolog debe ejecutar la siguiente instrucción.
  • nl: Significa New Line (salto de línea). Es otro predicado predefinido que inserta un retorno de carro en la consola para que el mensaje true. aparezca en el renglón siguiente y no pegado al texto.
  • .: Marca el fin de la definición de la regla hola_mundo.

Resumen Visual de Sintaxis Clave

Elemento en el CódigoTipo SintácticoRegla en Prolog
usuario, curp, juanÁtomo / PredicadoInicia con minúscula. Representa nombres fijos o constantes.
XVariableInicia con MAYÚSCULA (o _). Representa incógnitas a resolver.
:-Operador condicionalSe lee como “si” (conecta la conclusión a la izquierda con las condiciones a la derecha).
,Conjunción lógica (∧\land)Se lee como “y” (separa múltiples condiciones o acciones secuenciales).
.TerminadorCierra obligatoriamente cada hecho, regla o consulta.

Aridad

En lógica matemática y en programación lógica (Prolog), la aridad (arity) es simplemente el número de argumentos (o parámetros) que recibe un predicado o función.

Se representa habitualmente mediante la notación nombre_predicado/N, donde N es un número entero (0,1,2,3,…0, 1, 2, 3, \dots) que indica cuántos elementos participan en esa propiedad o relación.

1. Concepto Legal/Ético, Formalización y Código en Prolog

En un contexto de Derecho y Ética en TI, la aridad define qué tan compleja es la norma o relación jurídica que estamos modelando:

  • Aridad 0 (predicado/0): Representa una acción o estado global sin sujetos específicos.
    • En tu script hola_mundo.pl: hola_mundo/0 (no lleva paréntesis ni argumentos).
  • Aridad 1 — Predicado Unario (predicado/1): Describe una propiedad o cualidad de un solo sujeto u objeto.
    • Concepto normativo: “El CURP es un dato personal”.
    • Lógica Matemática: EsDatoPersonal(x)\text{EsDatoPersonal}(x)
    • Prolog: es_dato_personal(curp).→\rightarrowes_dato_personal/1
  • Aridad 2 — Predicado Binario (predicado/2): Establece una relación entre dos entidades (sujeto-objeto o sujeto-sujeto).
    • Concepto normativo: “El usuario xx realiza tratamiento del dato dd“.
    • Lógica Matemática: Trata(x,d)\text{Trata}(x, d)
    • Prolog: trata(juan, curp).→\rightarrowtrata/2
  • Aridad 3 — Predicado Ternario (predicado/3): Modela relaciones que involucran tres elementos simultáneamente.
    • Concepto normativo: “El administrador AA otorga permiso de lectura PP al usuario UU“.
    • Lógica Matemática: OtorgaPermiso(A,U,P)\text{OtorgaPermiso}(A, U, P)
    • Prolog: otorga_permiso(admin, maria, lectura).→\rightarrowotorga_permiso/3

2. Regla Clave en SWI-Prolog: Identidad por Aridad

Para SWI-Prolog, dos predicados con el mismo nombre pero diferente aridad son completamente independientes y distintos.

Por ejemplo, puedes tener en el mismo archivo .pl:

% autor/1: Indica únicamente que alguien tiene la calidad de autor (1 argumento)
autor(cervantes).

% autor/2: Relaciona a un autor con una obra específica (2 argumentos)
autor(cervantes, don_quijote).

Si consultas ?- autor(cervantes)., Prolog buscará exclusivamente en las definiciones de autor/1 y no se confundirá con autor/2.

3. Ejercicio Rápido de Verificación

Observa las siguientes cláusulas de auditoría de software e indica cuál es la notación de aridad (nombre/N) de cada predicado:

  1. licencia_gpl(linux).
  2. software_derivado(mi_app, linux, gpl_v3).
  3. auditoria_completada.