programación lógica (prolog) y programación imperativa (visual studio .net)
DESCRIPTION
Cuando se hace el estudio de la Inteligencia artificial, como desarrollo básico se da el estudio de la lógicabivaluada, además de la lógica formal, a través de la programación lógica como el interprete de PROLOG, lacuestión a manejar, es como utilizar el desarrollo con otras arquitecturas de desarrollo como laprogramación imperativa.TRANSCRIPT
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.