Estableciendo la relación entre Programación Lógica y la Programación Imperativa

(Estudio sobre: Prolog y Visual Studio.Net (Basic.Net) y el uso del componente ©SWPlCs)

Ing. Rubén Alexander More Valencia.

Universidad Cesar Vallejo Piura.

Centro de Informática y Sistemas Piura (CIS Piura)

Resumen:

Cuando se hace el estudio de la Inteligencia artificial, como desarrollo básico se da el estudio de la lógica

bivaluada, además de la lógica formal, a través de la programación lógica como el interprete de PROLOG, la

cuestión a manejar, es como utilizar el desarrollo con otras arquitecturas de desarrollo como la

programación imperativa, que permite la manipulación de los resultados y mostrarlos de mejor forma;

visual por ejemplo, manejo de resultados para otros desarrollos que la lógica formal resuelve muy bien, pero

poco interactuantes con aplicaciones de programación más común.

El presente trabajo pretende establecer la relación del entorno del intérprete PROLOG y su Editor SWI –

Prolog, con el uso del componente SWIPlCs, para la programación en .Net (Basic .Net).

Este trabajo permitirá el conocer que cualquier desarrollo con programación lógica puede ser utilizada con

la programación Imperativa o la Programación Orientada a Objetos, observando dos arquitecturas y lógicas

distintas.

Los componentes:

El Intérprete de Prolog;

Entorno de desarrollo SWI Prolog Editor;

El componente SWIPlCs.

Visual Basic .Net

Marco Teórico Conceptual.

Los Sistemas Basados en Conocimiento

El componente principal de un sistema basado en conocimiento es un conjunto de representaciones de

hechos acerca de una realidad a modelar y describir desde la perspectiva del ser humano siempre. Nosotros

construimos una forma de comunicación con el lenguaje y por ende generamos oraciones. Las oraciones se

representan en un lenguaje que pueda representar esto como conocimientos, que puede ser un lenguaje

natural o un lenguaje formal.

Sobre esta base de conocimientos podría hacer varias acciones, como tratarla para llegar a concluir o

generar un proceso llamado inferencia o incluso hacer cambios para adaptarla a otra realidad, a esto se

llama aprendizaje.

Esquemáticamente se pueden describir las acciones que puede realizar un SBC de la siguiente forma:

Los Sistemas Basados en Conocimiento definen una Base de Conocimientos que lo que percibe.

Esta base de conocimientos, debe de permitir conocer que se debe hacer. Estas decisiones se dan por un

conjunto de reglas, o se puede necesitar de un proceso de inferencia para llegar a una decisión.

El agente (en nuestro caso un interprete como Prolog) realiza la acción que haya decidido de acuerdo a ese

proceso de inferencia (dado por una base de conocimientos de lógica Bivaluada).

Los sistemas “aprenden” y posiblemente modificar su Base de Conocimientos de acuerdo a lo el sistema ha

hecho y plantear si se ha conseguido lo que se esperaba (True o False).

La Construcción de una base de conocimientos mediante la lógica formal

En principio, un lenguaje de representación del conocimiento consta de dos aspectos básicos:

Sintaxis, que explica cómo es la forma en que se construyen las oraciones como combinación de estructuras

más sencillas (por ejemplo las palabras en un lenguaje natural).

Semántica, que explica la correspondencia entre los elementos o signos que componen un lenguaje y los

objetos que representan.

La Lógica

Podemos distinguir dos tipos dentro de lo que se llama lógica clásica (aquella que la conclusión, si es

verdadera lo es con certeza, es decir, sin ningún grado de probabilidad, mientras que hay otros tipos de

lógicas no clásicas, como puede ser la lógica difusa -o Fuzzy Lógica en el que una conclusión sólo es

verdadera con un cierto grado de certeza).

La Lógica propositiva o lógica de enunciados cuando los signos que manejamos son proposiciones

completas.

Lógica de predicados de orden superior en el que podemos hacer inferencias sobre la lógica, es decir, tener

un conocimiento que podríamos llamar meta lógico.

Éstas son las herramientas de que dispondremos para representar el conocimiento. Así que vamos a ver

cómo construir una base de conocimientos en base al lenguaje utilizado para representar los conceptos. En

principio elegiremos la lógica de predicados para definir las reglas de un juego de ajedrez como ejemplo

para desarrollarlo en Prolog.

Elementos de una base de conocimientos

Predicados: atributos de los elementos

Elementos: proposiciones.

Constantes: se escriben en minúsculas, por ejemplo pedro, gripe.

Variables lógicas: Las variables en Prolog no son variables en el sentido habitual, por eso las llamamos

variables lógicas. Se escriben como una secuencia de caracteres alfabéticos comenzando siempre por

mayúscula o subrayados. Por ejemplo Persona, X, _

La variable anónima: todas ellas se representan mediante el símbolo de subrayado _.

Operadores. El operador Y se representa por “,”

Hechos: expresan relaciones (predicados) entre elementos (proposiciones). Deben acabar en punto.

Por ejemplo es (ruben, alto).

Reglas: condiciones si-entonces. Se escribe primero el consecuente y luego el/los antecedentes.

Por ejemplo: es(X, Peruano):-nace (X, Piura).

(Piura es un departamento del Perú). Se infiere por lo tanto que si Piura es del Perú quien nace en Piura es

de nacionalidad Peruana, así funciona la lógica no?

Se establecerá un conjunto de reglas para cada pieza de un juego de ajedrez, un ejemplo clásico para el uso

de listas en Prolog.

En el estudio se ha construido un archivo llamado p6.pl, guardado en la unidad C: \, que contiene la

definición de la lógica formal a través de reglas y hechos, por ejemplo;

Parte del Código de Prolog “Archivo se debe de definir en C:\p6.pl”, dentro de los archivos del proyecto que

acompaña al estudio del proyecto lo podrán descargar.

celda(X1,X2):- member(X1,[1,2,3,4,5,6,7,8]), member(X2,[1,2,3,4,5,6,7,8]).

estadoCelda(E1,E2,E):- member(E,[ocupada, desocupada]),

member(E1,[1,2,3,4,5,6,7,8]),member(E2,[1,2,3,4,5,6,7,8]).

Se establece en estas líneas celda(X1, X2), esta se restringe para el interprete de Prolog, de tal manera que

pertenecen a una lista que se establece del 1 al 8 para cada valor de celda, esto permite poder definir el

tablero con los 8X8=64 celdas de un tablero.

¿Cómo se hubiera hecho con la programación imperativa?, en la programación lógica se establecen los

predicados a través del manejo de Listas y se usa member para la pertenecía de un elemento de la lista.

Esto es un ejemplo de la programación lógica formal, ahora ¿cómo aprovecharla para definir la lógica para

saber a qué celdas de un tablero una pieza de ajedrez se ha de mover?

Este es el inicio del programa en las imágenes se podrán observar las siguientes reglas.

La Programación:

Se crea un proyecto del tipo Biblioteca de Clases (una DLL), que a su vez utilizara el componente SWIPlCs, el

proyecto se llamara MovimientoPiezas, utiliza la referencia a SWIPlCs, y además se construirán dos clases

que se definen a continuación;

Imagen: El proyecto y las propiedades del componente SWIPlCs

Proyecto MovimientoPiezas

Public Class MovPiezas

Inherits System.Object

Miembro de: MovimientoPiezas

Resumen:

MovPiezas, clase que controla el inicio de la programación lógica genera el entorno y para cada pieza

retorna por función las celdas donde la pieza puede moverse.

Public Sub iniciar()

Miembro de: MovimientoPiezas.MovPiezas

Resumen:

Iniciar: Permite definir el entorno para la variable SWI_HOME_DIR, que es el directorio por defecto para

PROLOG. Además permite el control por la Excepción, si no se puede inicializar el entorno.

Dim s As PlTermV

Dim q As PlQuery = Nothing

Public Sub iniciar()

Environment.SetEnvironmentVariable("SWI_HOME_DIR", "C:\Archivos de programa\pl")

Try

If Not PlEngine.IsInitialized Then

Dim param As String() = {"-q"}

PlEngine.Initialize(param)

q = New PlQuery("member(A, [r,u,b,e,n]).")

For Each s In q.Solutions

‘ Console.WriteLine(s(0).ToString)

Next

Console.WriteLine("------")

End If

Catch ex As Exception

Console.WriteLine("Horror" & ex.ToString)

Console.ReadLine()

Finally

q.Dispose()

Console.ReadLine()

End Try

End Sub

Explicación

El procedimiento iniciar(), permite el uso siguiente;

Establecer a través de Environment, la definición en el entorno de la variable del sistema SWI_HOME_DIR.

Esta es igual al lugar donde hemos instalado Prolog.

Verifica si no se inicializado el interprete, para luego si no se da la condición se inicialice.

Se genera una prueba a través de la variable q, que determina la consulta de manera directa en el

interprete explicábamos que member consulta la pertenencia de la variable (Mayúsculas en Prolog), por

tanto los valores se establecen para el termino se usa un for each, para recorrer las soluciones.

Por supuesto, en lo posible se controlan las excepciones.

La función MuevePieza

Public Function MuevePieza(ByVal PX1 As Integer, ByVal PX2 As Integer, ByVal pieza As String) As

System.Collections.Generic.List(Of MovimientoPiezas.PuntoCelda)

Miembro de: MovimientoPiezas.MovPiezas

Resumen:

MuevePieza: Permite encontrar los puntos para donde la pieza puede moverse a través de las reglas o

Predicados lógicos. Aquí se define la consulta para el archivo que contiene la Programación Lógica ("Para el

ejemplo es consult('C:/p6.pl')")

Parámetros:

PX1: Coordenada 1 del tablero donde esta actualmente el Trebejo (Pieza de Ajedrez)

PX2: Coordenada 2 del tablero donde esta actualmente el Trebejo (Pieza de Ajedrez)

Pieza: Es la Pieza para la que se consulta: "peon" o "caballo" o "torre" o "alfil"

Valores devueltos:

Devuelve una colección de Objetos de la clase PuntoCelda (Coordenadas de Salida).

Public Function MuevePieza(ByVal PX1 As Integer, ByVal PX2 As Integer, ByVal pieza As String) As

Collections.Generic.List(Of PuntoCelda)

Dim v As Collections.Generic.List(Of PuntoCelda)

v = New Collections.Generic.List(Of PuntoCelda)

q.Dispose()

Select Case pieza

Case "peon"

PlQuery.PlCall("consult('C:/p6.pl').")

q = New PlQuery("peon_Mueve(" & PX1.ToString & "," & PX2.ToString & ",X,Y).")

Case "caballo"

PlQuery.PlCall("consult('C:/p6.pl').")

q = New PlQuery("caballo(" & PX1.ToString & "," & PX2.ToString & ",X,Y).")

Case "torre"

PlQuery.PlCall("consult('C:/p6.pl').")

q = New PlQuery("torre(" & PX1.ToString & "," & PX2.ToString & ",X,Y).")

Case "alfil"

PlQuery.PlCall("consult('C:/p6.pl').")

q = New PlQuery("alfil(" & PX1.ToString & "," & PX2.ToString & ",X,Y).")

End Select

For Each s In q.Solutions

Dim celda As New PuntoCelda

celda.X = s(2).ToString

celda.Y = s(3).ToString

'Console.WriteLine("X:" & s(2).ToString)

'Console.WriteLine("Y:" & s(3).ToString)

v.Add(celda)

celda.Destruyete()

Next

Return v

End Function

Public Class PuntoCelda

Inherits System.Object

Miembro de: MovimientoPiezas

Resumen:

Consigue definir una celda por clase de .Net esta luego puede definir por ejemplo si esta ocupada o no por

una pieza de algún color u otros parámetros '''

Public Class PuntoCelda

Private i As Integer

Private j As Integer

Public Property X() As Integer

Get

Return i

End Get

Set(ByVal value As Integer)

i = value

End Set

End Property

Public Property Y() As Integer

Get

Return j

End Get

Set(ByVal value As Integer)

j = value

End Set

End Property

Public Sub Destruyete()

Me.Finalize()

End Sub

End Class

El Formulario

Imports MovimientoPiezas

Public Class Form2

Friend WithEvents b As System.Windows.Forms.Button

Dim c As New MovPiezas

Dim punto As PuntoCelda

Private Sub Form2_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles

MyBase.Load

'Me.Controls.Clear()

Me.AgregaCeldas()

c.iniciar()

End Sub

El método pintar lo que hace es recibir como argumentos la colección de lista de Puntos de celda donde una

pieza para estas pruebas puede moverse, define los colores del control como el color de la fuente de texto.

Esta Colección es la que se manejara por el método MuevePieza, explicado anteriormente.

Sub pintar(ByVal v As Collections.Generic.List(Of PuntoCelda))

despintar()

Me.Controls("btn" & Me.nudX.Value.ToString & Me.nudY.Value.ToString).BackColor = Color.Red

For i As Integer = 0 To v.Count - 1

Me.Controls("btn" & v.Item(i).X.ToString & v.Item(i).Y.ToString).BackColor = Color.Blue

Me.Controls("btn" & v.Item(i).X.ToString & v.Item(i).Y.ToString).ForeColor = Color.White

'Console.WriteLine("Celda {0} {1}", vec.Item(i).X, vec.Item(i).Y)

Next

End Sub

El método despintar lo que hace es volver a pintar las celdas con características y color comunes para Luego

permitir la visualización del ejercicio.

“b”, es un control button, compartido como Friend WithEvents b As System.Windows.Forms.Button, para

lograr su construcción y definición de propiedades en tiempo de ejecución.

Sub despintar()

Dim i, j As Integer

For i = 0 To 7

For j = 0 To 7

Me.Controls("btn" & i.ToString + 1 & j.ToString + 1).BackColor = Color.Cyan

Me.Controls("btn" & i.ToString + 1 & j.ToString + 1).ForeColor = Color.Black

Next

Next

End Sub

Con el Procedimiento AgregaCeldas se logra, agregar los controles por primera vez, en el evento Load, del

formulario. Luego despintar logra cambiar y definir propiedades comunes en tiempo de ejecución.

Sub AgregaCeldas()

Dim i, j As Integer

For i = 0 To 7

For j = 0 To 7

Me.b = New Button

Me.Controls.Add(b)

b.Height = 40

b.Width = 40

b.Left = j * b.Width

b.Top = i * b.Height

b.BackColor = Color.Cyan

b.Name = "btn" & j.ToString + 1 & i.ToString + 1

b.Text = "(" & (j + 1).ToString & "-" & (i + 1).ToString & ")"

Next

Next

End Sub

Private Sub Form2_FormClosed(ByVal sender As System.Object, ByVal e As

System.Windows.Forms.FormClosedEventArgs) Handles MyBase.FormClosed

c.liberarVariable()

End Sub

Private Sub btnPintarp_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles

btnPintarp.Click

pintar(c.MuevePieza(Me.nudX.Value, Me.nudY.Value, "peon"))

End Sub

La lógica de Predicados para el movimiento del Peón, estas reglas producen como resultado el conjunto de

celdas desde una celda preguntada, inclusive si el peón esta en una posición inicial como es la fila 2 podrá

moverse dos celdas por delante, la regla identifica la posición de la pieza y muestra sus posibles

movimientos (recuerde que no es una implementación completa del juego, solo es para mostrar la relación

entre programación lógica y .Net)

Como puede observarse en el editor de SWI-Prolog, se determina las celdas donde el peón puede moverse.

Luego estos resultados son vistos en .Net, con el correspondiente control a través de una colección de

Objetos de la clase PuntoCelda, si ya se tienen los resultados de una lógica estos pueden ser usados por la

lógica imperativa para seguir construyendo nuestras aplicaciones, sosteniendo una relación que define todo

el potencial de la lógica (bivaluada) proposicional y la lógica definida por algoritmia.

En el siguiente código se muestral el llamado para la pieza torre, implementado la lógica de predicados y la

lógica imperativa. Se muestran los resultados también de las piezas alfil y caballo.

Private Sub btnpintart_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles

btnpintart.Click

pintar(c.MuevePieza(Me.nudX.Value, Me.nudY.Value, "torre"))

End Sub

En el siguiente código se muestral el llamado para la pieza alfil

Private Sub btnPintarA_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles

btnPintarA.Click

pintar(c.MuevePieza(Me.nudX.Value, Me.nudY.Value, "alfil"))

End Sub

En el siguiente código se muestral el llamado para la pieza caballo.

Private Sub btnPintarC_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles

btnPintarC.Click

pintar(c.MuevePieza(Me.nudX.Value, Me.nudY.Value, "caballo"))

End Sub

End Class

Se ha demostrado con el ejercicio que, los resultados del estudio de la programación de lógica de

predicados, estudiados como bases de la inteligencia artificial pueden ser desarrollados con el fin tener un

control y una forma de mostrarlos o visualizarlos a través de arquitecturas con lenguajes visuales u

orientados a objetos de manera que permitan su mejor desarrollo y visualización.