Interfases Hombre Maquina

Interfases Hombre-Máquina:
Basadas en el
Lenguaje Natural
Alejandro Peña Ayala
INSTITUTO POLITÉCNICO NACIONAL

Cursó la licenciatura en Informática en la UPIICSA del IPN. Posteriormente obtuvo el Diplomado en

Java y Aplicaciones Web en el ITAM, la Especialidad y la Maestría en Inteligencia Artificial en la
Fundación Arturo Rosenblueth. Actualmente es candidato al grado de Doctor en Ciencias de la
Computación por el Centro de Investigación en Computación del IPN, contando para ello del respaldo
del CONACYT y del IPN a través de una beca.
Entre sus distinciones académicas están: El haberse titulado por la opción de escolaridad en 1981,
conforme al reglamento del IPN. El reconocimiento hecho por el CONCACYT y el Diario de México
en el evento: “Los mejores estudiantes de México generación 1981”, como el mejor estudiante en la
Licenciatura en Informática del IPN. Además de haber obtenido el grado de de Maestría en Inteligencia
Artificial con mención honorífica. A la par de su desarrollo académico, Alejandro Peña ha ejercido la
carrera magisterial, profesional, de investigación y ministerial.
En 1981 ingresó a la planta docente de la UPIICSA, donde actualmente es profesor titular C e

investigador. Durante el lapso 1989-1994 ofreció cátedra en la Maestría en Sistemas Computacionales
del ITESM-CEM. Además de haber hecho lo propio en las Maestrías en Sistemas de Información y
Ciencias de la Computación en la Fundación Arturo Rosenblueth.
En el ámbito profesional de la Informática, desde 1978 se ha desenvuelto en los sectores privado,

público, bancario y empresarial, desempeñando cargos como: Programador, analista y líder de proyecto
en la entonces Secretaría de Comercio. Jefe de Soporte Técnico en el (desaparecido) Instituto
Mexicano de Comercio Exterior. Subdirector de Sistemas en la Secretaría de Salud. Subgerente de
Proyectos Especiales en el Banco Nacional de Comercio Exterior. Coordinador de Sistemas en
Banamex. Fue fundador y Director General de la empresa Neuralware, dedicada a las Tecnologías de la
Información.
Como resultado de sus estudios doctorales orientados al ámbito de la Educación basada en Web, ha
publicado: varios Reportes Técnicos, y presentado diversos trabajos en congresos nacionales e
internacionales celebrados en ciudades de cuatro continentes, como por ejemplo: Washington-USA.,
Vancouver Canáda, Melbourne Australia, Bensaçon – Francia, Grindelwald – Suiza, y Bali –
Indonesia. Las memorias de sus artículos han sido editadas por organizaciones como IEEE y Springer.
Así mismo es autor de una colección de libros relacionados con la Informática y la Inteligencia
Artificial.
Actualmente, Alejandro Peña es Apóstol y Director General del World Outreach Light to the Nations
Ministries (WOLNM), cuya visión es la formación de discípulos, mediante el uso de las Tecnologías
de la Información y del Conocimiento, a nivel mundial dedicados a predicar el Evangelio.
Por sus ocupaciones académicas, profesionales y ministeriales, Alejandro Peña ha tenido la

oportunidad de visitar diversos países y regiones del mundo, amén de haber arribado a sitios extremos
del planeta como: La Antártida, el océano glaciar Ártico, y el centro del desierto de Australia.
También ha explorado islas exóticas como Hawai, Tahití, y Rarotonga; y otras remotas como
Spitsbergen y Baffin. A raíz de tales experiencias, Alejandro Peña ofrece el testimonio de las
maravillas naturales que Dios ha hecho en el mundo para deleite del ser humano, y en particular de sus
hijos que son salvos a través de Jesucristo y llenos de su Espíritu Santo, quien les anima a clamar:
¡Abba, Padre!
Basadas en el
Lenguaje Natural
Basadas en el
Lenguaje Natural
- México -
PRIMERA EDICIÓN 2006.
D.R. © 2006, Alejandro Peña Ayala

Dirección de Publicaciones
Revillagigedo 83, Centro Histórico, 06070, México, D.F.
ISBN: 970-94797-2-5
Impreso en: México / Printed in México
El autor reconoce que esta obra ha sido inspirada de manera especial por su Padre, Hermano
Jesús y Consolador como parte de los proyectos de investigación de World Outreach Light to the
Nations Ministries (WOLNM). Así mismo, el trabajo es el resultado de su experiencia
profesional, como investigador y docente en la Unidad Profesional Interdisciplinaria de
Ingeniería y Ciencias Sociales y Administrativas (UPIICSA) del Instituto Politécnico Nacional
(IPN) y fruto del desarrollo de su tesis doctoral en el Centro de Investigación en Computación del
Instituto Politécnico Nacional.
PRÓLOGO
En este material se basa en el estudio de la disciplina denominada Inteligencia Artificial y en el empleo del lenguaje de
programación lógica Prolog. Con esta plataforma se procede a la concepción de interfaces ergonómicas y amigables que
usan técnicas de representación y manipulación del Lenguaje Natural. Con este tipo de interfase se enriquece el empleo
de modelos tradicionales de implementación de interfaces por medio de texto y gráficas. Esto contribuye a que los
sistemas de información sean más productivos y los tiempos de capacitación disminuyan.
TABLA DE CONTENIDO
INTRODUCCIÓN............................................................................................................................................................... 3
1. CONTROL EN LA PROGRAMACIÓN LÓGICA ........................................................................................................ 7
1.1 Control métodos de búsqueda e inferencia .............................................................................................................. 7
1.2 Recursividad normal y tipo de cola (TAIL)........................................................................................................... 10
1.3 BackTrak uso del corte (CUT) y de falla (FAIL) .................................................................................................. 13
1.4 Aplicaciones: factorial, creación y búsqueda en listas, etc. ................................................................................... 16
1.5 Predicados: declarativos, aritméticos, de comparación, entrada y salida .............................................................. 18
1.6 Rastreo................................................................................................................................................................... 23
1.6.1 Manipulación de la base de datos, creación, borrado y actualización ............................................................ 23
1.6.2 Carga y aplicación de la base de datos ........................................................................................................... 26
1.6.3 Operaciones especializadas para uso de archivos........................................................................................... 26
2. PROCESO DE LENGUAJE NATURAL ..................................................................................................................... 31
2.1 Descripción del proceso de Lenguaje Natural ....................................................................................................... 31
2.2 Complejidad en la representación del Lenguaje Natual .......................................................................................... 31
2.2.1 Forma de representación................................................................................................................................. 31
2.2.2 Tipo de mapeo ................................................................................................................................................ 32
2.2.3 Nivel de interacción entre componentes......................................................................................................... 33
3. PROCESO LEXICO ..................................................................................................................................................... 37
3.1 Elementos del lenguaje: Alfabeto, Morfología, Diccionario ................................................................................. 37
3.2 Unidades léxicas.................................................................................................................................................... 39
3.3 Procedimiento........................................................................................................................................................ 41
3.4 Manejo y recuperación de errores.......................................................................................................................... 43
3.5 Implementación ..................................................................................................................................................... 44
4. PROCESO DE LA SINTAXIS ..................................................................................................................................... 47
4.1 Elementos del análisis gramáticas, redes de trasformación, Parsers...................................................................... 47
4.2 Teorías de “Chomsky” sobre estructuras sintácticas y de teoría de sintaxis.......................................................... 51
4.3 Redes de transición aumentadas ............................................................................................................................ 58
4.4 Implementación de un modelo sintáctico .............................................................................................................. 60
5. PROCESO SEMÁNTICO............................................................................................................................................. 67
5.1 Componentes: contexto, significado y relación..................................................................................................... 67
5.2 Estudio de gramáticas semánticas ......................................................................................................................... 68
5.3 Análisis de gramáticas Case DCGS semánticas .................................................................................................... 74
5.4 Aplicación de redes semánticas ............................................................................................................................. 78
5.5 Manejo de dependencia conceptual ...................................................................................................................... 82
5.6 Implementación de un esquema de tratamiento semántico.................................................................................... 87
6. PROCESO DE LA INTERPRETACIÓN ................................................................................................................... 107
6.1 Descripción del análisis pragmático .................................................................................................................... 107
6.2 Complejidad en el proceso y entendimiento........................................................................................................ 109
6.3 Estudio de la técnica sobre “Espacio de enfoques” ............................................................................................. 110
6.4 Análisis del método de dirección por metas ........................................................................................................ 111
6.5 Aplicación de Scripts........................................................................................................................................... 113
6.5.1 Evaluación de aplicaciones sobre Scripts ..................................................................................................... 113
6.6 Comprensión de historias “PAM” ....................................................................................................................... 113
6.7 Aplicación de Scripts........................................................................................................................................... 114
6.8 Evaluación de aplicaciones sobre “Comprensión de historias” PAM ................................................................. 115
6.9 Implementación de un prototipo interpretador de textos ..................................................................................... 117
7. DESARROLLO DE UNA APLICACIÓN.................................................................................................................. 123
7.1 Integración de la documentación......................................................................................................................... 123
7.2 Presentación de sistemas ..................................................................................................................................... 125
7.3 Evaluación y discusión de propuestas ................................................................................................................. 127
CONCLUSIONES........................................................................................................................................................... 121
BIBLIOGRAFÍA............................................................................................................................................................. 125
TABLA DE FIGURAS
Figura. 1.1 Imposibilidad de demostración ....................................................................................................................... 9
Figura. 2.1 Composición del ser humano ......................................................................................................................... 31
Figura. 2.2 Mapeo 1 : 1 .................................................................................................................................................... 32
Figura. 2.3 Tipos de Mapeo.............................................................................................................................................. 33
Figura. 2.4 Nivel de interacción entre componentes, 1 .................................................................................................... 33
Figura. 2.5 Nivel de interacción entre componentes, 2 .................................................................................................... 34
Figura. 3.1 Aplicación de Unidades Léxicas .................................................................................................................... 40
Figura. 3.2 Procedimiento de entrada del analizador léxico............................................................................................. 42
Figura. 3.3 Procedimiento de salida del analizador léxico ............................................................................................... 43
Figura. 4.1 “RTEF” para una simple gramática ............................................................................................................... 48
Figura. 4.2 “RTEF” para una gramática complicada........................................................................................................ 48
Figura. 4.3 “RTEF” no determinística.............................................................................................................................. 49
Figura 4.4 “RTR” una sencilla gramática del inglés. ...................................................................................................... 50
Figura. 4.5 “Árbol de Traducción” para la oración “Juan tomó la pelota roja”................................................................ 51
Figura. 4.6 Oración y Frase marcada emitida por una gramática de “Estructura de Frase” ............................................. 53
Figura. 4.7 Desarrollo de etapas y estructuras por una gramática transformacional ........................................................ 54
Figura. 4.8 Conjugación de oraciones con gramática generativa de transformaciones generalizadas.............................. 55
Figura. 4.9 Atributos de los símbolos complejos de una frase marcada........................................................................... 56
Figura. 4.10 Mecanismo de Funcionamiento de la teoría de sintaxis. .............................................................................. 57
Figura. 4.11 Estructura Ligada para una frase .................................................................................................................. 61
Figura. 4.12 Programa general para gramáticas tipo RTA ............................................................................................... 63
Figura. 5.1 Ejemplos de contexto en un lenguaje............................................................................................................. 67
Figura. 5.2 Ejemplo de marcadores usados en la teoría semántica................................................................................... 68
Figura. 5.3 Ejemplo de marcadores semánticos ............................................................................................................... 69
Figura. 5.4 Ejemplo de distinguidores.............................................................................................................................. 69
Figura. 5.5 Proceso de “Rutas Amalgamadas” en la interpretación de una oración ......................................................... 70
Figura. 5.6 Frases emitidas por una Semántica Generativa .............................................................................................. 71
Figura. 5.7 Frases marcadas por una Semántica Generativa ............................................................................................ 72
Figura. 5.8 Frases marcadas por una Semántica Generativa, de “ The sauce thickened”................................................. 73
Figura. 5.9 Representación de una oración por medio de una Gramática Case................................................................ 74
Figura. 5.10 Representación de oraciones acusativas por medio de “Case Frames” ........................................................ 75
Figura. 5.11 Representación de oraciones dativas por medio de “Case Frames” ............................................................. 76
Figura. 5.12 Representación de oraciones en voz activa .................................................................................................. 77
Figura. 5.13 Representación de oraciones en voz pasiva ................................................................................................. 77
Figura. 5.14 Red semántica “binaria”............................................................................................................................... 78
Figura. 5.15 Red Semántica “n-aria”................................................................................................................................ 79
Figura. 5.16 Red semántica “relacional” ......................................................................................................................... 79
Figura. 5.17 Relación de entidades................................................................................................................................... 79
Figura. 5.18 Representación de objetos............................................................................................................................ 80
Figura. 5.19 Representación de comparaciones ............................................................................................................... 80
Figura. 5.20 Herencia Simple ........................................................................................................................................... 81
Figura. 5.21 Herencia Múltiple ........................................................................................................................................ 81
Figura. 5.22 Representación de excepciones.................................................................................................................... 82
Figura. 5.23 Una sencilla representación en Dependencia Conceptual ............................................................................ 82
Figura. 5.24 Primitivas de la Dependencia Conceptual (grupo1) ..................................................................................... 83
Figura 5.25 Primitivas de la Dependencia Conceptual (grupo2) ..................................................................................... 84
Figura. 5.26 Uso de los tiempos conceptuales.................................................................................................................. 85
Figura. 5.27 La representación en Dependencia Conceptual de una amenaza. ................................................................ 86
Figura. 5.28 Esquema de integración de un SLN ............................................................................................................. 88
Figura. 5.29 Generación del significado para una frase ................................................................................................... 89
Figura. 6.1 Resultado Del Análisis Sintáctico ................................................................................................................ 107
Figura. 6.2 Red semántica particionada que muestra espacios de creencias .................................................................. 112
Figura 6.3 escena 2, del Scprit del Restaurant................................................................................................................ 115
Figura. 6.4 Interpretación de Textos Fuente................................................................................................................... 118
Figura. 6.5 Expresión de Respuestas por el intérprete.................................................................................................... 119
Figura. 7.1 Esquema de un Sistema de Lenguaje Natural .............................................................................................. 123
Figura. 7.2 Evolución de un SLN ................................................................................................................................... 124
Figura. 7.3 Lenguaje natural como medio de comunicación independiente del tema .................................................... 126
Figura. 7.4 Flujo de conversación a partir de la expresión del usuario........................................................................... 129
Figura. 7.5 Flujo de conversación a partir del subsistema de conversación ................................................................... 130
Figura. 7.6 Procedimiento de la generación de lenguaje ................................................................................................ 131
LISTA DE TABLAS
Tabla. 1.1 Recursividad normal........................................................................................................................................ 12
Tabla. 1.2 Recursividad tail............................................................................................................................................... 13
Tabla. 2.1 Limitaciones y ventajas del lenguajes ............................................................................................................. 32
Tabla. 3.1 Alfabeto de la lengua castellana ...................................................................................................................... 37
Tabla. 3.2 Ejemplos de palabras compuestas ................................................................................................................... 37
Tabla. 3.3 Uso de tiempos ................................................................................................................................................ 38
Tabla. 3.4 Derivados irregulares....................................................................................................................................... 38
Tabla. 3.5 Opciones en genero y número ........................................................................................................................ 38
Tabla. 3.6 Comparativos................................................................................................................................................... 38
Tabla. 3.7 Generación de raíces incorrectas ..................................................................................................................... 39
Tabla. 3.8 Formato de diccionario.................................................................................................................................... 39
Tabla. 3.9 Tipos de organización y acceso ....................................................................................................................... 39
Tabla. 3.10 Formato de la “estructura temporal fuente”................................................................................................... 40
Tabla. 3.11 Formato de la “unidad léxica” ....................................................................................................................... 41
Tabla. 4.1 Secuencia de recorrido de árboles ................................................................................................................... 61
INTRODUCCIÓN
INTRODUCCIÓN
Los sistemas de cómputo se han convertido en un compañero de labores profesionales, académicas, comerciales,
sociales, deportivas, culturales y domésticas del ser humano; gracias a los beneficios que brindan en el tratamiento de
información de una manera confiable, rápida y precisa. Su popularidad ha crecido aceleradamente gracias a la evolución
de la electrónica y las comunicaciones, que han aportado avances y mejoras significativas en la fabricación de equipo
cada día más poderoso pero a la vez económico, que acompañado por la robustez y facilidad en el empleo de los
programas de cómputo, han hecho en conjunto una herramienta muy valiosa para el bienestar de la sociedad.
Las tendencias mundiales de automatización, globalización y modernización, obligan a los sectores productivos de los
países ha invertir en el desarrollo, generación, producción e implementación de bienes con un alto nivel de contenido
tecnológico, en donde el factor común es facilitar el uso de los productos e incrementar su utilidad. Un ejemplo
contundente es la generalización de aplicaciones de cómputo como el uso de un sistema operativo estándar en los
computadores personales y el intercambio de información a través de internet por medio de un protocolo universal.
Proveer un vehículo de comunicación sencillo y natural entre el operador y el sistema ha sido un factor determinante del
éxito de estas aplicaciones, lo cual ha motivado a profundizar en el uso de instrumentos y tecnologías que tiendan cada
vez más a emular el diálogo natural entre los usuarios sin menoscabo que uno de los parlantes sean una máquina.
Para crear este tipo de proyectos se requiere la intervención de varios campos especializados, entre los que destaca el
“informático” que aporta un conocimiento valioso, organizado en algunas materias específicas. Una de ellos se conoce
como “Lenguaje Natural”, disciplina que basa sus fundamentos en las matemáticas, la lingüística y la inteligencia
artificial; con ella se aborda el reto de construir sistemas de cómputo orientados al manejo, comprensión y respuesta del
lenguaje natural que expresa un usuario y la aplicación que opera.
Es por ello, que como parte de la formación de un especialista en sistemas de información se le brindan los elementos
logísticos y experiencias apropiadas para el diseño de aplicaciones basadas en el uso del lenguaje natural, por tal motivo,
uno de los temas integrantes de su “mapa curricular” se concentra a proveer todos los conceptos, técnicas y
procedimientos necesarios en la concepción, diseño e implementación de sistemas para el proceso de lenguaje natural
escrito.
Para enriquecer y facilitar la impartición de este tipo de cursos, se ha compilado un material que es el resultado de
estudios, investigación y enseñanza (a nivel licenciatura y maestría) por más de diez años en el campo del “lenguaje
natural”. Este acervo se presenta a manera de “apuntes” que respaldan la cátedra del profesor y el estudio a cargo de los
alumnos, donde podrán conocer, evaluar y aplicar los temas expuestos, conforme al programa, En ellos se ofrece las
explicaciones e ilustraciones necesarias para ayudar a comprender y exponer los diversos temas en cuestión.
En su contenido se aborda un perfil de la naturaleza y alcances del lenguaje natural; para que a partir del tercer capítulo
al octavo, se concentre en la exposición detallada de los componentes, funcionamiento y técnicas para la construcción de
los módulos especializados integrantes de un sistema de lenguaje natural escrito, como son el “análisis léxico”,
“sintáctico”, “semántico”, la “interpretación”, “conversación” y “generación del lenguaje”. El material incluye al final
la presentación de una metodología basada en “Lisp” para la implementación de esta clase de aplicaciones.
El anhelo del documento es “participar en el proceso de enseñanza como fuente de consulta, que aunada a los textos y
cátedras del profesor venga a enriquecer la formación del profesional informático”. Por tal motivo, serán bienvenidas
las observaciones y sugerencias para corregir y mejorar su contenido, procurando la oportuna actualización del
documento.
Se agradece el apoyo brindando por las autoridades académicas de la U.P.I.I.C.S.A. para facilitar el desarrollo de este
tipo de material, así como a los alumnos que participaron en la recolección y edición de varias secciones, pero sobretodo
a Dios por hacer del ser humano su obra maestra a través de su palabra.
CAPÍTULO 1. CONTROL EN LA PROGRAMACIÓN
LÓGICA
1. CONTROL EN LA PROGRAMACIÓN LÓGICA
1.1 Control métodos de búsqueda e inferencia
Prolog es un lenguaje orientado a programar aplicaciones para la Inteligencia Artificial que requieren representar
conocimiento a través de predicados en forma de hechos y reglas, procurando encontrar soluciones a problemas
mediante el ejercicio de búsquedas ciegas en sentido hacia atrás (backward) y a profundidad, realizando inferencias a
través del método de Resolución. En suma, Prolog representa una “máquina de inferencia” que tiene implementadas
estas técnicas de almacenamiento y explotación del conocimiento para ponerlas al alcance del usuario liberándolo de la
carga de implementar por sí mismo estas funciones. De esta manera el programador se puede concentrar en codificar los
elementos relacionados con el problema, dejando a Prolog la búsqueda de la solución.
Prolog como lenguaje de “Programación Lógica”emplea una sintaxis muy sencilla para codificar las instrucciones que
el usuario le proporciona mediante las convenciones del Cálculo de Predicados y de las “Cláusulas de Horn”,
representa los hechos y reglas conforme a los siguientes postulados:
Un programa Prolog se compone de cláusulas

Hay dos tipos de cláusulas, hechos y reglas
Los hechos son afirmaciones compuestas por un predicado
Las reglas son cláusulas de Horn
Las reglas se componen por una conclusión y una condición
La conclusión consta de un solo predicado que está afirmado
La condición se integra por al menos un predicado
Cuando la condición tienen varios predicados, generalmente estos se encuentran unidos por el conjuntivo “and”
Para que sea valida una regla, es necesario que todas las condiciones se prueben como válidas (en el orden en que
aparecen) para que la conclusión también así resulte y por lo tanto la regla como un todo
Los predicados se componen por un nombre “reservado” o “definido por el usuario” (comenzado por una letra en
minúscula o símbolo especial) y opcionalmente pueden ir acompañados por uno o más términos los cuales van entre
paréntesis
Los términos son variables, constantes o funciones (equivalentes a predicados), separados por comas
Las variables utilizan como primer carácter una letra mayúscula
Las constantes son literales que inician con minúscula, pueden ir entre comillas, son números y caracteres especiales
Las funciones son equivalentes a los predicados, es decir llevan un nombre que comienza con una letra en minúscula y
pueden ir acompañadas por términos
Generalmente el punto se utiliza para indicar el término de una instrucción
Normalmente los símbolos.- separan la conclusión de la(s) condición(es), la cual aparece primero (de izquierda a
derecha)
La , (coma) separa a las condiciones de una regla, representando el “and”, mientras que el ; representa al “or”
Los hechos y las reglas terminan con un punto
Para efectos de ilustración de la forma en que Prolog representa conocimiento, se muestra a continuación los siguientes
ejemplos, basados en la sintaxis, convenciones y elementos de la versión Prolog V-Plus desarrollada por Chalcedony
Software, Inc; en donde se usa el carácter > para editar una instrucción directamente sobre el ambiente de trabajo y el
símbolo % para identificar un comentario:
>!.
>fail.
>write(“hola”).
>padre(juan, mario).
>padre(mario, carlos).
>abuelo (X, Z) :- padre(X, Y), padre(Y, Z).
La codificación de un programa Prolog, consta de reglas y hechos esencialmente, representando en conjunto una “Base
de Conocimientos” (otros la denominan Base de Datos), para procesarlas se emplea un predicado que se inserta en
forma negada. Esta cláusula representa el “teorema a demostrar” o el “problema a resolver” conforme a lo
estipulado por el método de inferencia de “reducción a lo absurdo” – en donde se introduce una preposición negada
que se refuta contra las afirmaciones existentes, hasta generar la preposición “nula”, momento en el cual se demuestra
la veracidad de la afirmación -.
8 Interfases Hombre-Máquina: Basadas en el Lenguaje Natural
Debido a que Prolog maneja predicados en lugar de preposiciones, emplea el método de Resolución propuesto por
Robinson - el cual aprovecha los fundamentos del reducción a lo absurdo -, por lo que su activación también parte de
la formulación de los postulados originales (hechos y reglas) y de un predicado negado (el teorema o problema). Este
último se inserta a la Base de Datos para producir nuevas cláusulas, que al trabajar con ellas generarán otras, hasta que
produzcan a una vacía conocida en el argot como “nil”, obteniendo así la demostración del teorema o la solución del
problema.
Cuando se desea comprobar un teorema, el predicado que se introduce no lleva términos o bien todos ellos deben
estar instanciados, es decir todas sus variables tienen valores previamente asignados, ninguna de ellas se encuentra
“libre” al ser introducida, como se aprecia en la siguiente reseña:
Teorema: demostrar que: “Juan es abuelo de Carlos”

La Base de Datos (conocimiento) de postulados iniciales es:
>padre (juan, mario).

>padre (mario, carlos).
>abuelo (X, Z) :- padre (X, Y), padre (Y, Z).
Se introduce el teorema negado con el símbolo ? :
>abuelo (juan, carlos)?
Se relaciona contra la regla:
>abuelo (X, Z) :- padre (X, Y), padre (Y, Z).
Se pretende unificar: abuelo(juan, carlos)? == abuelo (X, Z) :- padre (X, Y), padre (Y, Z)
Se refuta contra la conclusión (ya que está afirmada) y se propagan los valores de las variables, generando una lista de
sustitución: { juan / X, carlos / Z }
La cual al propagarse (sustituir los valores por las variables de la lista) en los predicados restantes de la regla, genera una
nueva cláusula conocida como “Resolvente”: padre (juan, Y), padre (Y, carlos)
Ahora, se deberá probar las condiciones resultantes (recordar que están negadas), repitiendo el proceso:
Al relacionarse con el hecho:
>padre (juan, mario)
Pretendiendo unificar: padre(juan, mario). == padre (juan, Y), padre (Y, carlos)
La nueva lista de sustitución que se genera: { mario/Y, carlos/Z }
Al propagarse a la condición restante produce como nuevo Resolvente: padre (mario, carlos)
Como esta es la última condición restante y también está negada, se relaciona con el hecho:
>padre (mario, carlos)
Se trata de unificar: padre (mario, carlos) == padre (mario, carlos)

Y como el hecho está afirmado y la condición es negada, entonces se produce la contradicción generando así la cláusula
vacía “nil”
Con lo cual queda demostrado el teorema que declara: “Juan es abuelo de Carlos”
Si en cambio lo que se desea es resolver un problema, este se plantea como un predicado que se introduce con cuando
menos un término no instanciado, es decir, debe tener al menos una variable sin valor previamente asignados, es decir
que está “libre” al ser introducida. El mecanismo de inferencia que se aplica es el mismo que para la demostración de
teoremas por lo que solo se muestra a continuación el proceso aplicado a las cláusulas:
Problema: “¿Quién es el nieto de Juan”
Se emplea la misma Base de Datos
Proceso de Lenguaje Natural 9
>padre (juan, mario).

>padre (mario, carlos).
>abuelo (X,Z):- padre (X, Y), padre (Y, Z).
Se introduce el problema negado con :

>abuelo (juan, K)?
Al relacionarse con la regla: abuelo(juan, K)? == abuelo (X, Z) :- padre (X, Y), padre (Y, Z)
Genera la lista de sustitución: { juan / X, K / Z }
Emitiendo el “Resolvente”: padre(juan, Y), padre(Y, K)
Al relacionarse con el hecho: padre (juan, mario). == padre (juan, Y), padre (Y, K)
Genera una nueva lista de sustitución: { mario/Y }
Emitiendo el “Resolvente”: padre (mario, K)
La condición restante se relaciona con el hecho: padre (mario, carlos) == padre (mario, K)
Genera una nueva lista de sustitución: { carlos / K }
Se produce la contradicción. “nil”
Al propagar el valor de K hasta el postulado introducido: abuelo(juan, carlos)?
Se obtiene la solución al problema: “Carlos es el nieto de Juan”
Cuando en una demostración de teorema o solución de problema no se llega a generar la cláusula vacía nil entonces no
se puede afirmar el postulado o bien no existe solución, como se muestra en la siguiente figura 1.1:
Demostrar que “Juan es abuelo de carlos”
abuelo (juan, carlos)
1 3 5
padre(juan, carlos) padre(juan, carlos) abuelo (X, Z) :- padre(X, Y), padre(Y, Z)
2 4 6
XX XX XX
No es demostrable que “Juan es abuelo de carlos”, ya que no se generó la cláusula NIL
Figura. 1.1 Imposibilidad de demostración
Para que dos cláusulas se puedan relacionar, es necesario que exista la “Unificación” entre un predicado de cada una de
ellas. Para ello se aplica el método denominado ”Unificación”, el cual exige la observancia de una serie de criterios para
permitir una inferencia – es decir, la generación de un nuevo conocimiento a partir de otro – representada por la “lista
de sustitución” y el “Resolvente”. Los requisitos que dos cláusulas deben cubrir para ser unificables son:
Los predicados deben tener el mismo nombre

Un predicado debe estar afirmado y el otro negado
Deben tener la misma cantidad de términos
Los términos de los predicados deberán ser correspondientes, es decir, se comparan entre sí de acuerdo con la posición
en la que aparecen (el uno contra el primero, el dos contra el segundo, ...)
Si los dos son constantes, ambas deben ser las mismas
Si son variables instanciadas, sus valores asignados deberán ser los mismos
Si un término es una variable libre y el otro es una constante o función, el primero tomará el valor del segundo
Si un término es una variable libre y el otro es una variable instanciada, la primera tomará el valor de la segunda
Si un término es una variable libre y el otro también, la primera sustituye a las ocurrencias de la segunda
Si un término es una función el otro deberá ser una variable libre o bien otra función con el mismo nombre, número de
términos y estos deberán ser correspondientes como se marca para los predicados (es recursivo)
Cuando todos estos criterios son observados con éxito, por las predicados contendientes de las cláusulas que se pretende
relacionar, entonces existirá Unificación entre ellas, procediendo a generar la lista de sustitución a partir de la
asignación de valores que se deriva de los criterios 7, 8 y 9. Estas sustituciones son propagadas en el resto de predicados
de las dos cláusulas que se van a relacionar, procediendo a eliminar a los predicados que se unificaron (por haber
contradicción, ya que uno está afirmado y el otro negado) para generar la cláusula resolvente con la unión de los
predicados restantes de las dos partes, los cuales ya tienen los nuevos valores resultantes de las dos sustituciones.
Al incumplirse cualquiera de los criterios se impide que las dos cláusulas se relacionen como ocurrió en el ejemplo de la
figura 1.1, en donde por usar distintas constantes (en los primeros dos intentos) y no poder unificar un mismo
predicado afirmado contra otro negado (tercer caso) no fue posible demostrar el teorema.
Por lo que respecta a la búsqueda que Prolog automáticamente emplea, esta es ciega, ya que no se emplea algún criterio
en particular, información o conocimiento especializado – conocido como heurística – para orientar la dirección de la
búsqueda, la selección de las declaraciones (hechos y reglas); limitándose únicamente a tratar de relacionar las cláusulas
con base al orden en que aparecen, tal como se ilustró en la figura anterior, al observar los números del proceso se
aprecia su correspondencia con respecto a la secuencia de los postulados en la Base de Datos previamente declaradas; es
decir, que primero se compara el teorema negado contra los hechos y al final contra la regla.
En cuanto a la dirección de la búsqueda que Prolog utiliza esta es backward ya que el procedimiento arranca a partir
del teorema (conclusión) que supuestamente se deriva de los postulados iniciales; lo cual implica que a partir de estos
(la Base de Datos) se deduce el teorema (dirección forward). Por ese motivo, el teorema o problema a resolver se
introduce negado para procurar relacionarlo con cualesquiera de las declaraciones iniciales para generar un nuevo
resolvente, y con él repetir el proceso hasta producir la cláusula vacía nil y obtener la respuesta deseada o bien agotar
todas las posibilidades sin satisfacer la expectativa inicial.
Con respecto a la expansión de la búsqueda que Prolog realiza, se emplea el método a Profundidad en donde se
privilegia desarrollar la primer alternativa en cada nivel de búsqueda hasta llegar al final, alcanzar la solución o bien
llegar a un punto donde no se puede progresar más, con lo cual se obliga a dar un paso atrás denominado backtrack en
donde se regresa al estado en el que se tomó la última decisión para considerar otra alternativa que no se habían
contemplado antes por ser la segunda, tercera, ... opción. En caso de que en ese nivel no existan más o bien que todas
ellas ya fueron exploradas sin haber resultado exitosas, entonces se hace un nuevo retroceso al siguiente nivel inmediato
anterior, para procurar otras rutas. Este proceso se repite hasta encontrar el primer caso de éxito o bien agotar todo el
posible universo de búsqueda, lo cual ocurre cuando al realizar el backtrack se arriba al estado inicial (primer nivel) y
ya no hay más caminos por explorar.
Prolog se orienta a realizar búsquedas exhaustivas, en donde no conforme con haber encontrado la primer solución,
continua buscando más, aplicando el mecanismo de backtrack hasta cubrir el universo completo de búsqueda o agotar
los recursos de proceso disponibles. Con este lineamiento, se pueden generar todas las posibles soluciones de un
problema, elegir entre ellas o bien tener la certidumbre de que no existe una solución satisfactoria o que es necesario
ampliar los recursos o replantar el problema para hacer viable encontrar una respuesta a satisfacción. En contraparte, si
el usuario solo se interesa en conocer la primer solución, habrá un desgaste de recursos durante la ejecución de la
aplicación, el cual se podrá evitar con el empleo del predicado ! (cut).
1.2 Recursividad normal y tipo de cola (TAIL)

En computación un proceso recursivo es aquel que se llama así mismo, generando una nueva “versión” de las
variables de estado del programa independientes al que tienen al momento de que ocurre el llamado. Este proceso es
cíclico y debe estar controlado por una condición que limite el término de las llamadas de lo contrario se vuelve
infinito. Cuando se alcanza esa condición que da por terminado el ciclo (después de “n” interacciones), se genera un
retroceso en el que puede o debe (según el caso) ocurrir un “envío de parámetros hacia arriba” para trasladar los
valores de interés que generó el último ciclo al inmediato anterior (“n-1”, el penúltimo)– es decir, al ciclo que lo llamó –.
Para que este los procese y genere con ellos un nuevo resultado, o bien simplemente los pase al ciclo inmediato anterior
que le corresponde (“n-2” el antepenúltimo). Este proceso se hace de manera sucesiva hasta regresar al estado original
del programa (nivel 0) en el punto en que ocurrió la llamada, para que la aplicación continúe a partir de la siguiente
instrucción a la que hizo el llamado.
Al iniciar el ciclo recursivo se pueden enviar ciertos parámetros con valores previamente definidos y otros libres sin
instanciar, cuando se ingresa al primer ciclo recursivo este los recibe, procesa y procede a generar nuevos valores, los
cuales pueden “perderse”, grabarse en el algún dispositivo, enviarse al siguiente ciclo recursivo o bien en el “envío de
parámetros hacia arriba”, trasmitirse al nivel que los llamó para asignarse a las variables libres originales. De esta
manera ocurre el “paso de parámetros hacia abajo” (en cada llamada recursiva).
En Prolog la recursividad ocurre cuando un predicado aparece como la conclusión de una regla y también como una de
las condiciones de la misma, es decir que la regla se define así misma en términos de ella. A nivel de implementación de
la recursividad, Prolog emplea estructuras de datos tipo “pila” para registrar, almacenar y recuperar los valores de las
variables de estado para cada ciclo.
La recursividad normal es precisamente la que se ha definido hasta el momento, enfatizando el hecho que una vez
concluida, al volver al estado inicial el resultado final que se obtuvo es recuperado para ser empleado a continuación por
otro predicado que está después del que hizo el llamado en el mismo “cuerpo” de condiciones de la regla. Como
ejemplo de aparece el cálculo del factorial el cual es implementado por medio de las siguientes declaraciones:
>% Programa 1
>% Recursividad Normal
>factorial (N, 1) :- 1 >= N. % cláusula 1
>factorial (W, X) :- W > 1, Y is W - 1, factorial (Y, Z), X is W * Z. % cláusula 2
En el programa 1, se aprecian comentarios en las dos primeras líneas, mientras que la tercera es una regla cuya
conclusión se representa por medio del predicado “factorial” con dos términos, mientras que la conclusión dispone de un
solo predicado. La última instrucción también es una regla con el mismo predicado como conclusión y con cuatro
predicados en la parte de condición, en donde el tercero de ellos también es el predicado “factorial”, representando con
ello una regla recursiva, cuya condición terminal ocurrirá cuando sea satisfecha la primera.
El programa se activa digitando la instrucción que represente al factorial a calcular, como por ejemplo, si se desea
estimar el factorial del número 3, se introduce la cláusula negada:
>factorial(3, X)?
Con ella se plantea el problema, negando el predicado factorial con el símbolo ? declarando como primer término el
número 3, y la variable libre X como medio para obtener el resultado. El “envío de parámetros hacia abajo” se
realiza a través de los dos términos del predicado factor, en cada llamado recursivo el valor del primer de ellos – el cual
representa el número cuyo factorial ha calcularse - se altera debido al decremento que calcula la segunda condición de la
segunda regla. Mientras que el segundo término permanece como una variable libre. Cuando en la primer regla el
valor del primer término de la conclusión es 1, entonces se cumple su única condición, poniendo fina a las llamadas.
Una vez satisfecha la condición que controla la recursividad, la conclusión de la regla 1, devuelve como valor de
sustitución para el segundo término del predicado “factorial” el número 1 el cual instanciará a la variable libre del
segundo término del predicado que hizo la llamada correspondiente a la tercer condición de la segunda regla, con ello se
obtiene el valor final del último nivel recursivo para dar comienzo al “paso de parámetros hacia arriba”. Con 1 como
primer valor retornado al penúltimo nivel recursivo.
Este procede a ejecutar el predicado que sigue al responsable de la llamada recursiva ubicado en la segunda regla, dicha
condición se encarga de calcular el factorial de un número ( n! ) al multiplicarlo por el factorial del número inmediato
inferior ( n * (n-1)! ). El producto obtenido es propagado a la variable libre del segundo término del predicado de la
conclusión de la segunda regla, para que se retorne al nivel en que se hizo el llamado recursivo. Este procedimiento se
repite tantas veces como ciclos recursivos se hayan realizado hasta alcanzar el estado inicial y reanudar la validación de
la regla que provocó la recursividad, la cual calculará el valor final del factorial para ser devuelto al predicado que
planteó el problema a través de la conclusión de la segunda regla.
En la siguiente tabla (1.1) se muestra la cronología de la transferencia de valores hacia abajo, cálculo, envío de valores
hacia arriba, generación de valores finales y el resultado de la unificación con fracaso “fail” o éxito “true”. Para facilitar
la interpretación se abrevió al predicado “factorial” por “f”, las celdas que representan a los predicados que no se han
procesado hasta ese momento por haberse presentado el llamado “recursivo” aparecen con un fondo oscuro, mientras
que las ya procesadas al retorno recursivo se identifican con una asurado en diagonal.
En las columnas se muestran los valores de los términos o bien las variables libres para los predicados de la conclusión y
de las condiciones de las dos reglas. En los renglones se muestra los valores que toman los predicados del problema, de
la regla 1 y de la 2, según el orden de operación que se realiza. Mientras que la columna “nivel” señala el estado de
ejecución del programa (0 el normal, mayor a 0 constituye el nivel de recursividad) y la de “resultado” indica el fracaso,
éxito, llamado (“lla. rec.”) o retorno recursivo (“return”) de la operación.
Nive Proble Regla 1 Regla 1 Regla 2 Regla 2 Regla 2 Regla 2 Regla 2 Resulta
l ma conclusi condició conclusi condició condició condició condició do
ón n1 ón n1 n2 n3 n4
0 f(3,X)
0 f(3,1) 1 >= 3 fail
0 f(3, X) 3>1 Y =3-1 F(2, Z) lla. rec. 1
1 f(2,1) 1 >= 2 fail
1 f(2, X) 2>1 Y =2-1 F(1, Z) lla. rec. 2
2 f(1,1) 1 >= 1 true,
return
1 F(1, 1) X=2*1 return
0 F(2, 2) X=3*2 true
0 f(3,3) fin
Tabla. 1.1 Recursividad normal
La recursividad tail representa una variante de la “normal”, procurando que el valor que se calculó en el último nivel de
recursividad alcanzado ya no se altere más durante el “retorno de valores hacia arriba” y una vez que se ha vuelto al
nivel original donde ocurrió la primer llamada, el predicado responsable sea el último de la condición de la regla, es
decir la “cola”, o bien que en caso de haber otros predicados después, estos no utilicen en lo absoluto ninguno de los
valores retornados por el llamado recursivo. Para ilustrar este concepto se procede a modificar el programa original 1
para dar vida a la versión 2:
>% Programa 2
>factorial (N, 1) :- N =< 1. % cláusula 1
>factorial (2, 2). % cláusula 2
>factorial (N, V) :- N > 2, fa (N, 3, 6, V). % cláusula 3
>fa (L, L, Va, Va). % cláusula 4
>fa (L, Na, Va, Vf) :- L > Na, Nn is Na + 1, Vn is Nn * Va, fa (L, Nn, Vn, Vf). % cláusula 5
>factorial (4, X)? % problema
Esta nueva versión computa el factorial en dirección “forward”, es decir en sentido opuesto al programa original, ya que
parte de los valores iniciales 1, 2, 3, .... y así sucesivamente hasta alcanzar el número solicitado; su activación emplea al
mismo predicado acompañado por el valor del número del factorial a calcular y la variable libre donde se almacenará el
resultado, tal como aparece en la última instrucción (“problema”).
La cláusula 1 se emplea para el cálculo del factorial de números menores o iguales a 1, la segunda ofrece el valor del
factorial para el número 2, la tercera se ocupa de generar el factorial para números mayores a 2, invocando al predicado
“fa” por medio de cuatro términos. El primero corresponde al número “original” cuyo factorial se desea obtener
(variable instanciada “N”), el segundo constituye el número “actual” (valor 3) a partir del cual comenzará la estimación,
acompañado por su factorial (valor 6) como tercer término, mientras que como cuarto aparece la variable libre donde se
depositará el factorial producido para el número “original”.
La cláusula 4 representa un “hecho” con el propósito de establecer la condición terminal de la recursión al momento en
el que el valor del primer término es igual al segundo (es decir, que el número “original” es igual al número “actual”)
por lo que el factorial del número “actual” –representado por el tercer término- instanciará a la variable libre del cuarto
término, devolviendo este como el resultado final del ciclo recursivo.
La última cláusula es una regla recursiva y procede a calcular el factorial del número “actual” inmediato posterior al
obtener el producto de este por el factorial del número “actual”, para después hacer un llamado recursivo con el número
“actual” incrementado en 1, acompañado por su factorial recién calculado. Este ciclo se repite hasta satisfacer la
condición terminal expresada por el “hecho”; sin embargo, para evitar que el “backtrack” impulsado por el espíritu de
búsqueda exhaustiva característico en Prolog, continué procurando encontrar más soluciones es necesario emplear la
primer condición de la última regla que evita procesar el factorial de números mayores al “original”. Aplicando la
misma mecánica del ejercicio anterior y las convenciones adoptadas en la representación de la tabla 1.1; a continuación
se muestra la tabla 1.2 para la “ejecución” del segundo programa, con la salvedad de dedicar una columna para la
conclusión de las reglas de las cláusulas 3 y 5, etiquetándolas con el nombre del predicado.
Nive Proble Cláusul Cláusul Cláusul Cláusul Cláusul Cláusul Cláusul Resulta
l ma a1/2 a3 a3 a4 a5 a5 a5 do
factorial condició fa condició condició
n n 1, 2, 3 n 5 (fac)
0 f(4,X)
0 fail fail
0 fail fail
0 f(4, V) 4 > 2 lla. rec. 1
fa(4,3,6,V)
1 fa(4,3,6,6) fail
1 fa 4 > 3 fa (4,4, lla. rec. 2
(4,3,6,Vf) 4=3+6 24, Vf)
2 fa (4,4, true,
24,24) return
1 fa fa (4,4, true,
(4,3,6,24) 24, 24) return
0 f(4, 24) 4>2 true
fa (4,3,
6,24)
0 f (4,24) fin
Tabla. 1.2 Recursividad tail

El principal atributo de la recursividad “tail” es evitar el “postproceso” sobre los valores calculados en cada ciclo
recursivo, haciendo ágil el retorno de valores hasta el llamado original y menos complicado el rastreo y depuración del
programa. En suma el modelo de recursividad “tail” es equivalente a las iteraciones clásicas carentes de recursividad
puesto que esencialmente no requieren del empleo del mecanismo y sobrecarga de trabajo tradicional que exige la
recursividad normal.
1.3 BackTrak uso del corte (CUT) y de falla (FAIL)

Por “default” Prolog se encarga de realizar una búsqueda exhaustiva de soluciones a lo largo (profundidad) y ancho
(amplitud) del universo de búsqueda que se genera para el problema. Esto significa que al encontrar la primer solución
activa su mecanismo de backtrack (retroceso) para optar por otras rutas aún no exploradas en búsqueda de nuevas
soluciones.
Cuando la solución a un problema exige conocer todas las posibles respuestas, el retroceso natural de Prolog las produce
en forma automática siempre y cuando los recursos de proceso y memoria se lo permitan. Sin embargo no siempre el
usuario se interesa por enterarse de todas las posibles opciones y se conforma con la primera o con alguna conjunto de
ellas sin necesidad de ser exhaustivo; o bien se enfrenta a problemas que tienen una sola posible solución.
Al carecer de una heurística que facilite encontrar soluciones o bien que las evalué para recomendar la mejor conforme a
ciertos criterios específicos, Prolog simplemente expondrá las respuestas en el orden “casual” (basado en el estilo de
programación y secuencia de las cláusulas) conforme las vaya encontrando (si es que existe alguna o la capacidad de
recursos se lo permite).
Al momento en que el diseñador de la aplicación decide ofrecer la primer respuesta que satisfaga al problema o una
parte de este (representado a través de hechos o condiciones de reglas), el programador entonces podrá emplear el
predicado “cut” mediante el símbolo ! para indicarle a Prolog evitar la activación del backtrack al momento que regrese
a buscar nuevas opciones de satisfacción para las condiciones que se encuentran antes de él en la misma regla y para el
predicado de la conclusión a la que pertenece.
Para comprender mejor este concepto, es conveniente revisar el primer programa presentado en la sección anterior,
partiendo del ejemplo que se desea calcular el factorial de 1, 0 o de cualquier número negativo. La respuesta la
proporciona Prolog al momento de unificar el problema negado factorial(1, X)? con la primer cláusula, sin embargo una
vez que presenta el resultado x = 1 el programa activa el backtrack para continuar buscando más soluciones y encuentra
como una nueva ruta a la segunda regla, logrando unificar al predicado de su conclusión, pero fallando en satisfacer a su
primer condición (w > 1). Como ya no hay mas opciones de búsqueda concluye el proceso.
Para evitar este sobretrabajo “overhead” innecesario, bastará con modificar el programa agregando una condición más a
la primer regla, representada por el predicado “cut” mediante su símbolo !. Como esta regla es la condición que controla
la recursividad, una vez que satisfaga la primer condición (1 >= N) ya no habrá más retroceso para satisfacer al
predicado (factorial) tanto a través de esa regla como de cualquier otra más que exista en el código (en este caso
únicamente hay 2). Con estos elementos de edita el programa 3 que se comparte a continuación:
>% Programa 3
>% Empleo del cut !
>factorial (N, 1) :- 1 >= N, !. % cláusula 1

>factorial (W, X) :- W > 1, Y is W - 1, factorial (Y, Z), X is W * Z. % cláusula 2
Al aplicar el predicado “cut” al segundo programa de recursividad “tail”, se agrega el símbolo ! como última condición
de la primer regla; la segunda cláusula se transforma de “hecho” a “regla” al insertar como única condición el !; y de
igual forma la cuarta también es convertida en regla para emitir la nueva versión del programa denominada 4, la cual
consta de las siguientes instrucciones:
>% Programa 4
>% Recursividad Tail
>% Empleo del cut !
>factorial (N, 1) :- N =< 1, !. % cláusula 1

>factorial (2, 2):- !. % cláusula 2
>factorial (N, V) :- N > 2, fa (N, 3, 6, V). % cláusula 3
>fa (L, L, Va, Va):- !. % cláusula 4
>fa (L, Na, Va, Vf) :- L > Na, Nn is Na + 1, Vn is Nn * Va, fa (L, Nn, Vn, Vf). % cláusula 5
Con estos ajustes el cut evita al backtrack de la siguiente forma:

Cuando el problema consiste en calcular el factorial de un número igual o menor a 1, el ! de la primer regla impide que
el bactrack intente explorar nuevas soluciones a través de las cláusulas restantes
Si el objetivo es obtener el factorial de 2, el ! de la segunda regla evita el retroceso que pretende buscar mas soluciones
por medio de las cláusulas faltantes
Y para el resto de casos (factorial de números igual o mayor a 3), el ! es el responsable de evitar mas overhead
Como recomendación final al usuario, se observa el cuidado que debe ejercer en el manejo de búsqueda exhaustiva o
bien limitada, ya sea por el estilo de programación natural de Prolog –aquel que no emplea el cut – o bien el contrastado
por el que explota el !, el cual puede generar resultados inesperados e inclusive impedir el descubrimiento de posibles
soluciones por un apropiado manejo, algo que provoca graves problemas al momento de depurar la aplicación.
Debido a que las cláusulas que normalmente integran un programa Prolog se componen por “hechos” y “reglas” y la
única negación es la cláusula que se introduce para representar el teorema o problema a resolver - propiamente dicho, no
hay más cláusulas negadas en una aplicación – el programador se encuentra ocasionalmente con la necesidad de
implementar un “hecho negado” es decir una aseveración de la falsedad de una declaración, como por ejemplo: “maría
es padre de pedro” o inclusive el negar la veracidad de la conclusión resultante de una regla tal que diga: “si X es mujer
entonces X es padre de Y”.
Para representar estas situaciones Prolog ofrece el predicado fail el cual una vez satisfecho provocará el efecto inverso,
es decir negará lo que se está afirmando; como por ejemplo para negar el hecho:
>padre (maría, pedr0). % cláusula 1
La cláusula se convierte en regla y se agrega como única condición fail, el cual una vez probado producirá el rechazo de
la afirmación, por lo que el proceso aplicará el backtrack para descubrir otra solución.
>padre (maría, pedr0):- fail. % cláusula 1
De la misma forma se procede a modificar la regla que se preocupa por validar el género del término que caracteriza la
paternidad y cuya conclusión debe ser rechazada al adicionar el fail como segundo predicado de la condición.
>padre (X, Y):- mujer(X), fail. % cláusula 1
Si esta regla la probamos junto con el hecho de que maría es mujer y el problema es determinar la paternidad de pedro,
tenemos la siguiente secuencia de instrucciones que conforman al programa 5:
>% Programa 5
>% Ejemplo del empleo del “fail”
> mujer(maria). % cláusula 1

>padre (X, Y):- mujer(X), fail. % cláusula 2
Al plantea el problema “maría es padre de pedro ?” mediante el hecho negado:
> padre(maria, pedro)? % problema a resolver
Prolog rechazará cualquier intento de instanciar a maría como padre de alguien por la regla cuya primer condición
valida su genero.
Finalmente, volviendo a la naturaleza exhaustiva de Prolog, en el caso anterior buscará otras soluciones al problema de
“paternidad en una mujer” pero esto es un absurdo, por lo que si la base de datos de la aplicación es muy voluminosa
entonces habrá un gran overhead gastado inútilmente en algo que no tiene solución por ser en este caso inverosímil. Por
tal motivo se deber emplear la combinación cut and fail (es decir secuenciar los predicados !, fail ) en el cuerpo de la
condición para que de esta forma se cancele el intento de backtrack. Al aplicar este concepto al programa, se inserta en
la segunda regla el cut antes del fail para generar una nueva versión representada por el programa 6:
>% Programa 6
>% Ejemplo del empleo del “cut - fail” para el manejo de absurdos
> mujer(maria). % cláusula 1

>padre (X, Y):- mujer(X), !, fail. % cláusula 2
Esta combinación es muy útil en aplicaciones complejas del campo de la Inteligencia Artificial en donde se puede
intentar prever la exploración de rutas que representan “absurdos” o bien en problemas que no son solubles, y que al
identificar estos casos se evita un desgaste inútil de recursos de procesamiento, las cuales se denominan “escépticos”.
1.4 Aplicaciones: factorial, creación y búsqueda en listas, etc.

Durante el proceso de aprendizaje del lenguaje de Programación Lógica “Prolog” es una práctica común el
implementar el cálculo del factorial como una forma de entender el manejo de la recursividad a través del empleo de
cláusulas en forma de hechos y reglas. Como ya se ha vista anteriormente a lo largo de las secciones 1.2 y 1.3, existen
variantes en su diseño, por lo que en este apartado se expresan algunos aspectos destacados.
En primer lugar por lo que respecta a la representación de conocimiento, todos los programas usan bases de datos
compuestas por reglas, salvo el segundo que emplea un par de hechos
Todos emplean mecanismos de recursividad
Aplican búsqueda ciega a profundidad
La dirección de búsqueda es hacia atrás para todos los casos
Sin embargo el cálculo del factorial en los programas 3 y 4 es hacia delante – a partir del número 1, 2, 3 .... y así
sucesivamente hasta alcanzar el número deseado -. Mientras que en el 1 y 2, la orientación es hacia atrás, debido a que
comienza decrementando el número deseado hasta llegar al 1, y a partir de él se computa el factorial respectivo durante
los retornos de cada nivel recursivo hasta llegar al original donde se genera el valor del factorial solicitado
Existen condiciones que evitan el overhead al impedir el calculo de factoriales menores a 1 – como sucede con la
condición (1 >= N) de la primer regla del programa # 1- o la estimación del factorial de números superiores al requerido
– tal como se encarga la primer condición (L > Na) de la quinta cláusula del cuarto programa –
En suma, los cuatro ejercicios ofrecen conceptos adicionales al proceso del factorial como es el empleo de los tipos de
recursividad, el uso del cut y el manejo del backtrack; los cuales son indispensables aplicar en programas más complejos
Por lo que respecta al manejo de listas, en primer lugar es conveniente considerar su naturaleza. Una lista es una
estructura de datos lineal, compuesta por varios, uno o ningún elemento; los cuales pueden ser otras listas o átomos
(constantes y variables) y que únicamente puede ser accesada a partir del primero. Como por ejemplo, para representar
una lista de colores en Prolog, se digita la siguiente instrucción:
>colores ( [rojo, azul, verde] ). % cláusula 1
>colores ( [ ] ). % cláusula 2
En la primer cláusula se aprecia que el único término del predicado colores es una lista compuesta por 3 elementos
separados por comas, los cuales aparecen entre los corchetes [ ]. Mientras que la segunda cláusula representa un hecho
cuyo predicado consta de un termino caracterizado por una lista vacía es decir nula.
Para acceder a los elementos de una lista existen varias opciones, la mas elemental es mediante el establecimiento de una
correspondencia entre dos predicados a unificar, en donde uno de ellos contiene como término a una lista con “n”
número de elementos y el otro emplea una variable libre que será sustituida por la lista completa o bien por un elemento
específico de ella como se muestra en el programa 7, donde a partir del hecho “colores” que contiene una lista con 3
elementos (atómicos) se plantean dos problemas; el primero dedicado a recuperar la lista completa en una sola variable
(X) y el otro que emplea tres variables contenidas dentro de los corchetes [A, B, C] con la intención de obtener el valor
individual de cada uno de ellos:
>% Programa 7
>% Ejemplo de acceso a listas

>colores ( X )? % problema 1: acceso a toda la lista
X = [rojo, azul, verde] % solución al problema 1
>colores ( [A, B, C] )? % problema 2: acceso a cada elemento de la lista

A = rojo
B = azul
C = verde % solución al problema 2
Con respecto al ejemplo anterior las líneas que no comienzan con el símbolo > corresponden a la respuesta que Prolog
genera al problema que previamente se le plantea mediante la cláusula negada (predicado (términos) ?). Ahora bien, si
el usuario solo se interesa en acceder a un elemento específico bastará con reconocer la posición que ocupa para que le
corresponda una variable que será sustituida al momento de la unificación.
Mientras que a los elementos que no son de interés, se podrá usar una variable distinta para cada uno de ellos (como en
el ejemplo anterior) o bien se podrá emplear la variable anónima representada por el símbolo _ en el lugar
correspondiente a los términos que no importa recuperar, tal como se muestra en el programa 8:
>% Programa 8
>% Ejemplo de acceso a listas

>colores ( [ D, _, _ )? % problema 1 : acceso al p 1er. elemento
D = rojo % solución al problema 1
>colores ( [ _, E, _ )? % problema 2 : acceso al 2do. elemento

E = azul % solución al problema 2
>colores ( [F,_, G )? % problema 3 : acceso al 1er y 3. elementos
F = rojo % solución al problema 3
G = verde
Por lo que respecta al manejo tradicional de las listas y conforme al estilo que el lenguaje de “Proceso de Listas” LISP
realiza, la búsqueda de elementos se hace únicamente a través del primer elemento de ellas conocido como “cabeza”
(“CAR” en el ambiente LISP) dejando el resto, es decir la “cola” (denominado “CDR” en LISP) sin acceder. Para
representar y ejemplificar el funcionamiento de las dos funciones “primitivas” de LISP en Prolog se ofrece la siguiente
sección de código del programa 9:
>% Programa 9
>% Implementación del “CAR” y “DR”
>colores ( [ A | B ] )? % problema 1 : acceso al CAR y CDR de la lista
A = rojo % solución al problema 1: valor CAR
B = [azul, verde] % solución al problema 1: valor CDR
>colores ( [ C |_ ] )? % problema 2 : acceso al CAR

C = rojo % solución al problema 2: valor CAR
>colores ( [ _ | D ] )? % problema 3 : acceso al CDR

D =[ azul, verde] % solución al problema 3: valor CDR
En este ejemplo se aprecia el uso del símbolo | para separar la “cabeza” de la “cola”, además que cuando se accede al
CAR, Prolog devuelve únicamente al primer elemento (ya se lista o átomo), mientras que tratándose del CDR se obtiene
como respuesta un lista con los elementos restantes después del primero. Ahora bien, cuando se trata de acceder a los
elementos de una lista nula Prolog responde negativamente “no”, pero al tratar de acceder al CDR de una lista que ya no
tiene más elementos mas que el CAR, entonces devuelve una respuesta afirmativa con el valor de una lista vacía, tal y
como se muestra en el programa 10:
>% Programa 10
>% Acceso a CDR y lista vacía

>colores ( [ A, _, B | D ] )? % problema 1 : acceso al CAR, al 3er elemento y al CDR restante
A = rojo % solución al problema 1: valor CAR
B = verde % solución al problema 1: valor del 3er elemento
D =[] % solución al problema 1: valor del CDR
>nombres ( [ ] ). % cláusula 2
>colores ( [ X | Y ] )? % problema 2 : acceso al CAR y al CDR
NO % no hay solución al problema 2
Por lo que respecta a la creación de listas, desde el enfoque de LISP hay tres funciones primitivas que se pueden
implementar en su equivalente Prolog tal como se muestra en el programa 11, las cuales se denominan:
CONS.- agrega un elemento a la cabeza de una lista, es decir en la posición CAR
LIST.- crea una lista a partir de dos elementos
APPEND.- genera una nueva lista a partir de la fusión de dos listas
>% Programa 11
>% Implementación de “CONS”, “LIST” y “APPEND”
>cons (A, B, [A | B ] ) . % cláusula 1
>cons (1, [2, 3], C )? % problema 1: CONS, inserta un elemento en la cabeza de una lista
C = [1, 2, 3] % solución al problema 1: elemento insertado en el CAR de la lista
>cons ([1], [2, 3], C )? % problema 2: CONS, inserta una lista en la cabeza de una lista
C = [[1], 2, 3] % solución al problema 2: lista insertada en el CAR de la lista
>list (D, E, [D, E ] ) . % cláusula 2

>list ([1], [2, 3], F )? % problema 2: LIST, crea una lista con dos listas
F = [[1], [2, 3]] % solución al problema 2: devuelve una lista con 2 listas como elementos
>list (1, [2, 3], G )? % problema 3: LIST, crea una lista con un átomo y una lista
G = [1, [2, 3]] % solución al problema 3: devuelve una lista con un átomo y una lista
>list ([1], 2, H )? % problema 4: LIST, crea una lista con una lista y un átomo
H = [[1], 2] % solución al problema 4: devuelve una lista con una lista y un átomo
>list (1, 2, J )? % problema 5: LIST, crea una lista con dos átomos
J = [1, 2] % solución al problema 5: devuelve una lista con dos átomos
>append ([ ], L, L) . % cláusula 3
>append ([ Car | Cdr], L2, [Car | L3]):- append(Cdr, L2, L3) . % cláusula 4
>append ([1], [2, 3], K )? % problema 6: APPEND, crea una lista a partir de listas
K = [1, 2, 3] % solución al problema 6: devuelve una lista con los elementos de las listas originales
>append (1, [2, 3], M )? % problema 7: APPEND, crea una lista a partir de un átomo y una lista
NO % no hay solución al problema 7: pues el 1er. Elemento no es una lista
>append ([ ], [ ], N )? % problema 8: APPEND, crea una lista a partir de 2 listas vacías

N=[ ] % solución al problema 8: devuelve una lista vacía
Finalmente, entre las funciones clásicas de LISP en la manipulación de listas se encuentra “member” avocada a
determinar si un elemento es miembro o no de una lista, como se muestra en el programa 12:
>% Programa 12
>% Implementación de “Member”
>member (_, [ ] ) :-!, fail. % cláusula 1: No se encontró el elemento
>member (E, [ E | _]):- !. % cláusula 2: Si se encontró
>member (E, [ _ | Cdr ] ):- member(E, Cdr) . % cláusula 3: regla recursiva de búsqueda
>member (1, [2, 1] )? % problema 1: búsqueda de un elemento que SI es miembro de una lista
YES % solución al problema 1: si es miembro
>member (5, [2, 1] )? % problema 2: búsqueda de un elemento que NO es miembro de una lista
NO % no hay solución al problema 2: ya que NO es miembro
En el ámbito de la Inteligencia Artificial el uso de listas es ampliamente aprovechado para efectos de representación de
conocimiento y procesamiento simbólico, por lo que se sugiere profundizar en su comprensión y aplicación a efecto de
estar en condición de aprovecha mejor la literatura, programas y aplicaciones que forman parte del acervo.
1.5 Predicados: declarativos, aritméticos, de comparación, entrada y salida

Prolog como cualquier lenguaje de programación dispone de un repertorio de palabras reservadas para fines
específicos de proceso y declaración de elementos; en el caso particular, corresponde al conjunto de predicados
reservados representados por palabras o símbolos especiales encargados de probar una condición particular o ejecutar
una tarea específica, los cuales pudieran acompañarse de términos obligatorios u opcionales. En lo que respecta a los
predicados declarativos, prácticamente son mínimos y se orientan a expresar directivas a la máquina de inferencia en
cuanto a controlar la búsqueda de soluciones, el manejo de predicados y la terminación del proceso de una aplicación, tal
y como se describen e ilustran en el programa 13 presentado a continuación:
Solveone.- instruye a Prolog para que una vez encontrada la primer solución al problema planteado, concluya la
exploración de adicionales
Solveall.- anima a buscar todas las posibles soluciones
>% Programa 13
>% Ilustración de predicados declarativos
>color(rojo). % cláusula 1:
>color(verde). % cláusula 2:
>color(azul). % cláusula 3:
>color(X)? % problema 1: busca todas las posibles soluciones

X = rojo % solución al problema 1: ofrece todas las soluciones
X = verde
X = azul
>solveone?. % cláusula 4: se introduce una directiva a Prolog

YES
>color(X)? % problema 2: busca la primer respuesta
X = rojo % solución al problema 2: brinda una sola respuesta
More?>; % al responder con el símbolo ? busca otra solución
X = verde % solución al problema 2: segunda respuesta encontrada
>solveall?. % cláusula 5: se introduce una directiva a Prolog
YES
>color(X)? % problema 3: busca todas las posibles soluciones

X = rojo % solución al problema 3: ofrece todas las soluciones
X = verde
X = azul
El predicado functor (T, F, N) es muy útil para el análisis y construcción de estructuras, se compone de tres términos; el
primero (T) es una estructura, el segundo (F) es el predicado o función de la estructura, mientras que F refleja la
“aridad” (es decir el número de términos que contiene el predicado dentro de la estructura). Los primeros dos
argumentos (T, F) no pueden ser listas, ni tampoco se pueden usar variables para definir al segundo y tercer término (F,
N). Por lo que respecta a su aplicación es posible aprovecharlo como lo hace el programa 14 de la siguiente forma:
Descomposición.- cuando T está instanciado por un átomo o estructura (predicado con términos), F retorna el nombre
del predicado y N la aridad
Creación.- produce una estructura en la variable libre T, formada por el nombre del predicado expresado por F y por el
número de variables libres (_1, _2, .....) que señala el número identificado por N
>% Programa 14
>% Ejemplo del manejo del predicado “functor”
>functor (amigo (juan, pedro)), F, N)? %problema 1: descomposición de una estructura
F = amigo % solución al problema 1
N=2
>functor (T, amigo, 2)? %problema 2: descomposición de una estructura

T = amigo (_1, _2) % solución al problema 2
Sin embargo, antes de mostrar un ejemplo relacionado con su aplicación en la generación de código dinámico, es
conveniente presentar un par de predicados más que contribuirán a editar el ejemplo; el primero de ellos es la función
call (P) orientado a invocar la prueba del predicado contenido en la estructurada almacenada por la variable P, para que
pueda tener éxito. Es decir, si por ejemplo P = amigo(juan, carlos) se puede probar esta declaración mediante el
predicado call(P) claro está que antes P debió haber sido instanciada. Esta función es equivalente a invocar el examen
del predicado amigo(juan, carlos) su ventaja radica en liberar al programador de editar el nombre del predicado antes de
la ejecución del programa, lo que significa hacer código estático clásico. En complemento a la edición de código
dinámico se puede emplear el predicado univ representado por los símbolos concatenados =.. los cuales funcionan
acompañados por un par de términos de acuerdo con el formato X =.. Y encargándose X de instanciar a un término,
mientras que Y a una lista. Como por ejemplo, amigo(juan, carlos)=.. Y instanciará a la variable libre Y con el valor
[amigo, juan, carlos].
En cambio si el planteamiento es X =.. [amigo, pedro, ana] dará vida a una estructura con el predicado amigo
acompañado por los términos pedro, ana es decir: amigo (pedro, ana). Dicho a lo anterior se procede a mostrar el
programa 15 el cual es capaz de responder a diversos tipos de consulta por medio de un predicado único al momento de
plantear la consulta:
>% Programa 15
>% Consultas a diversos tipos de conceptos de una base de datos
>amigo (raul, mario). % cláusula 1: hecho

>amigo (raul, ana). % cláusula 2: hecho
>esposo (raul, elena). % cláusula 3: hecho
>padres (david, raul, elena). % cláusula 4: hecho
%cláusula 5: hace consultas con predicados dinámicos, de acuerdo con los siguientes roles:
% R.- nombre del predicado a consultar
% T.- número de términos que tiene el predicado
% V.- variable libre donde se deposita el resultado de la búsqueda
% P.- variable libre donde se deposita el predicado que se genera dinámicamente
% V.- variable libre donde se deposita una lista con la cual se representa a la cláusula con la que se
unificó el predicado P para de esa forma generar una respuesta a la consulta
>relacion(R, T, V):- functor (P, R, T), call(P), P=..V.
>relacion (amigo, 2, X)? %problema 1. consulta las relaciones entre “amigos”
X =[ amigo, raul, mario] % solución al problema 1
X =[ amigo, raul, ana]
>relacion (esposo, 2, Y)? %problema 2. consulta las relaciones entre “esposos”
Y =[esposo, raul, elena] % solución al problema 2
>relacion (padres, 3, Z)? %problema 3. consulta las relaciones entre “padres”
Z =[ padres, david, raul, elena] % solución al problema 3
En complemento al uso de predicados declarativos, el % representa un comentario, exit indicar a Prolog dar por
terminada la ejecución del programa y de la sesión, mientras que halt suspende el proceso que se esté realizando sin dar
por concluida la sesión.
Con relación a los predicados aritméticos Prolog no es un lenguaje orientado al cálculo matemático por lo que el
usuario deberá implementar sus propios predicados o bien de realizar alguna interfaz con otra herramienta más
especializada, sin embargo se pueden hacer cómputos numéricos elementales de asignación mediante el predicado is
suma, resta, multiplicación, división y el residuo mediante los símbolos + - * / mod respectivamente, tal como se
muestra en el programa 16:
>% Programa 16
>% Uso de predicados aritméticos
>suma (E1, E2, R):- R is E1 + E2 % cláusula 1: suma

>resta (E1, E2, R):- R is E1 - E2 % cláusula 2:resta
>multiplica (E1, E2, R):- R is E1 * E2 % cláusula 3: multiplicación
>divide (E1, E2, R):- R is E1 / E2 % cláusula 4: división
>residuo (E1, E2, R):- R is E1 mod E2 % cláusula 5: residuo
%problema 1. operaciones aritméticas

>suma (1, 2, R1), resta (R, 0, R2), multiplica (R2, 3, R3), divide (R3, 4, R4), residuo(R3, 4, R5)?
R1 = 3 % solución al problema 1
R2 = 3
R3 = 9
R4 = 2
R5 = 1
En lo concerniente a los predicados de comparación Prolog emplea símbolos convencionales, abreviaturas y palabras
reservadas, los cuales son presentados y ejemplificados por el programa 17 que se muestra a continuación:
= igualdad entre dos términos: X = Y
eq igualdad entre dos términos: X eq Y
<> desigualdad entre dos términos: X <> Y

neq desigualdad entre dos términos: X neq Y
> mayor que: X > Y
< menor que: X < Y
>= mayor o igual que: X >= Y
=< menor o igual que: X =< Y
var determina si el término es una variable libre: var( X)
nonvar determina si el término no es una variable libre: nonvar (X)
atom identifica si el término es atómico (constante, variable instanciada con un valor constante): atom (X)
integer precisa si el término es un valor entero: integer (X)
, representa al operador lógico “and” para relacionar a los predicados que son condiciones de una regla
; corresponde al operador lógico “or” para relacionar a los predicados que son condiciones de una regla
not niega al resultado generado por la prueba hecha a un predicado
>% Programa 17
>% Uso de predicados de comparación
>igual1 (A, B):- A = B. % cláusula 1: =

>igual2 (A, B):- A eq B. % cláusula 2: eq
>diferente1 (A, B):- A <> B. % cláusula 3: <>
>diferente2 (A, B):- A neq B. % cláusula 4: neq
>mayor (A, B):-A > B. % cláusula 5: >
>menor (A, B):-A < B. % cláusula 6: <
>mayorIgual (A, B):- A >= B. % cláusula 7: >=
>menorIgual (A, B):- A =< B. % cláusula 8: =<
> variable (A):- var (A). % cláusula 9: var

> nonvariable (A):- nonvar (A). % cláusula 10: nonvar
>atomo(A):- atom(A). % cláusula 11: atom
>entero(A):- integer(A). % cláusula 12: integer
>falso(A):- not(A). % cláusula 13: not
>y(A):- A > 2, A < 9. % cláusula 14: and , mediante el rango abierto (2, 9)
>o(A):- A < 2; A > 9. % cláusula 15: or ; fuera del rango abierto (2, 9)
%serie 1 de problemas: comparación de igualdad con sus respuestas

>igual1 (1, 2)?
NO
>igual (ana, ana)?
YES
>diferente1 (1,2)?
YES
>diferente2 (ana, ana)?
NO
% serie 2 de problema. comparación de menor - mayor con sus respuestas

>mayor (1, 2)?
NO
> menor (1, 2)?
YES
> mayorIgual (3,3)?
YES
> menorIgual (4,5)?
NO
%serie 3 de problemas. comparación de variable, átomos y enteros con sus respuestas

>var (X)?
YES
> var (2)?
NO
>nonvar (X)?
NO
> nonvar (2)?
YES
>atomo (3)?
YES
>atomo ( [a, b])?
NO
>entero (3)?
YES
>entero (5.5)?
NO
% serie 4 de problemas. comparación con falso, and or con sus respuestas

>falso (o(11))?
> y (5)?
YES
> y (11)?
NO
> o (1)?
YES
>o (4)?
NO
> o (11)?
YES
>falso (o(4))?
YES
>falso (o(11))?
NO
En cuanto a los predicados de “entrada” y ”salida” que Prolog pone al alcance del usuario para captar información de
dispositivos de “entrada” como el teclado y enviar datos a unidades de “salida” como el video, los más comunes son
representados por una serie de predicados reservados con la siguientes características y forma de aplicación ilustrada por
el programa 18:
con: y see(con: ) representa al teclado como unidad de “entrada” y a la consola como medio de “salida”
read(X) lee el carácter, cadena o cadenas cuya terminación emplea un punto provenientes de la unidad de
“entrada”,depositando el valor en la variable libre X
getc(X) obtiene el siguiente carácter de la cadena de “entrada” actual, almacenando el valor en la variable libre X
write(X) y print(X) escribe el valor del término X en el dispositivo actual de “salida”
putc(X) envía el valor representado por el término X al dispositivo actual de “salida”
tab(N) envía N caracteres en blanco “espacios” a la unidad actual de “salida”
nl da por terminada la línea de salida actual para posicionarse al comienzo de la siguiente
ascii (C, N) cuando C está instanciado por cualquier carácter, deposita en N su valor de representación decimal,
mientras que si es N el término que contiene un valor numérico, almacena en la variable libre C el carácter
correspondiente
>% programa 18
>% empleo de predicados de entrada y salida
>% serie 1 de ejercicios que declaran dispositivos

>consult (“con:”)? %declara el teclado y consola como dispositivos de e/s
| amigo (carlos, raul). % se introduce un hecho por medio del teclado
| amigo (jose, pedro). % se introduce otro hecho por el mismo medio
| end_of_file. % identifica el fin de la cadena de entrada y el empleo de la unidad
>% serie 2 de ejercicios que emplean predicados de “ entrada” por cadena

>% lee(V):- read(V). % brinda el valor de una variable que se lee
>%lee(X)? % solicita un valor que debe ser alimentado de “entrada”
hola. % es el valor proporcionado, terminado con un punto
X = hola % valor leído
>% serie 3 de ejercicios que emplean predicados de “ entrada” por carácter

> prueba :- see(“con:”), getc(A), getc(B), A = B. % declara unidad, lee 2 caracteres y los compara
>prueba? % ejecuta prueba 1
vv. % se digitan 2 caracteres con el punto al final
YES % comparación exitosa
>prueba? % ejecuta prueba 2
gh.
NO % comparación desigual
>% serie 4 de ejercicios que emplean predicados de “salida” y que aprovechan el predicado “amigo”
>% introducido como hecho durante la 1er. serie
> lista:- amigo(A, B), write (“amigos”), nl, print(A), tab(5), print(B), nl.
‘amigos’ % despliega el letrero del 1er. Resultado y salta de renglón
c r % imprime los 2 caracteres con 5 espacios de separación
YES % 1er. búsqueda exitosa
‘amigos’ % despliega el letrero del 2do. Resultado y salta de renglón

YES % 2da. búsqueda exitosa
>% serie 5 de ejercicios que emplean predicados de “salida” y que aprovechan el predicado “amigo”
>% introducido como hecho durante la 1er. serie
> lista:- amigo(A, B), write (“amigos”), nl, print(A), tab(5), print(B), nl.
‘amigos’ % despliega el letrero del 1er. Resultado y salta de renglón
YES % 1er. búsqueda exitosa
>% serie 6 de ejercicios que emplean predicados de “salida” a partir de la creación de caracteres
>numero(N):- ascii (C, N), putc( C ), nl.

>numero(64)? % solicita imprimir el carácter correspondiente al # ascii 64
@ % imprime el carácter deseado
YES
>numero(50)? % solicita imprimir el carácter correspondiente al # ascii 50
2 % imprime el carácter deseado
YES
1.6 Rastreo
1.6.1 Manipulación de la base de datos, creación, borrado y actualización
La manipulación de la base de datos inicia cuando el usuario edita las cláusulas que representan su aplicación
mediante el empleo de un Procesador de Textos respetando la sintaxis de la Prolog para codificar hechos y reglas, tal
como se ha expuesto en la sección 1.1 “Control Métodos de búsqueda”, o bien introduciendo las instrucciones
directamente al ambiente de proceso de Prolog.
Cuando se opta por la primer vía, entonces la creación de la base de datos es realizada por medio de un “ambiente
externo” mediante el empleo del programa Editor que el Usuario haya seleccionado (como por ejemplo Note Pad), en
cambio al aprovechar la segunda alternativa se opta por la forma denominada “en tiempo real” en el que el código que
integra la base de datos reside temporalmente en la “memoria de trabajo” de Prolog.
Una vez que se ejecutan procesos para demostrar teoremas o resolver problemas, la base de datos puede sufrir
alteraciones provocadas en tiempo de ejecución por el tipo de instrucciones que son capaces de borrar y actualizar las
cláusulas originales, además de agregar nuevas. Una vez concluido los procesos que el usuario ha ejecutado en su
sesión de Prolog, existe la opción de almacenar la base de datos en su estado actual (el que conserve al final después de
las modificaciones que haya sufrido), para ello deberá usar el predicado save indicando la ruta y nombre de archivo que
desea crear en el medio de almacenamiento para preservar la base de datos y poder aprovecharla posteriormente.
Con la opción de almacenar la versión disponible de base de datos existente en la memoria de trabajo se otorga al
usuario una tercer manera para crear bases de datos a partir de los formas iniciales; por lo que en resumen el
programador dispone de tres caminos para crear una base de datos.
Por lo que respecta al borrado de cláusulas contenidas en la base de datos, hay dos medios, el primero está representado
por la vía del ambiente externo donde el archivo que la almacena es editado mediante el Procesador de Textos que
ofrece facilidades para eliminar las instrucciones indeseadas. La segunda vertiente aparece en tiempo real mediante el
empleo de los predicados retract y retractall acompañados por el nombre del predicado a dar de baja, para que al
momento de ejecutar esa instrucción Prolog elimine las ocurrencias de dicho predicado en la base de datos.
De la misma forma, la actualización de la base de datos se implementa a través de dos vías, la conocida como ambiente
externo editando el archivo y alternado las instrucciones al gusto del usuario para proceder a guardarlo con los nuevos
cambios; y la segunda opción en tiempo real mediante el empleo del retract y retractall para borrar las ocurrencias del
predicado a modificar y luego a través del uso de la instrucción asserta y assertz en el que se introducen nuevas
instancias del predicado que previamente se borró pero ya con el nuevo formato, términos y valores deseados acordes a
los cambios requeridos.
Inclusive para agregar nuevas declaraciones para predicados ya existentes en la base de datos original o actual, así como
para incorporar nuevos en tiempo de ejecución se puede emplear la pareja de predicados asserta y assertz con lo cual se
podrá incorporar código dinámicamente en tiempo de ejecución, haciendo aplicaciones más sofisticadas e interesantes.
Para ilustrar el empleo de los predicados reservados Prolog para la manipulación en tiempo real de la base de datos se
presenta a continuación el programa número 19, compuesto por varias cláusulas originales, de las cuales algunas de ellas
son borradas o actualizadas posteriormente, para que al final se proceda a salvar la versión resultante de la base de
datos.
Finalmente por lo que respecta al rastreo que en momentos de depuración el usuario se ve en la necesidad de
implementar a efecto de monitorear el funcionamiento de su aplicación, analizar el flujo de trabajo, la instanciación de
valores en las variables y comprender la generación de los resultados que arroja el programa, Prolog ofrece el empleo de
los predicados trace y notrace sin argumentos para habilitar el rastreo o inhibirlo a lo largo de la ejecución de la
aplicación, tal como lo muestra el programa 19:
>% Programa 19
>% Uso de predicados de comparación
>amigo (juan, raul). % cláusula 1: hecho

>amigo (juan, tomas). % cláusula 2 hecho
>amigo (juan, lala). % cláusula 3: hecho
>%problema 1: borrado de cláusulas

>% problema 1: borra las ocurrencias del predicado “amigo” que tengan “raul” como 2do término
>retract (amigo(_, raul ) )?
YES
>% borra la cláusula 1, pues es la única que tiene como 2do término “raul”
>% problema 2: borrar las ocurrencias del predicado “amigo” que tengan “juan” como 1er término
>retract (amigo(juan, _ ) )?
YES
>% borra la cláusula 1 y 3, pues tienen como 1er término “juan”, dejando vacía la base de datos
>% problema 3: inserta hechos con el predicado “amigo” al inicio de la base de datos
>asserta (amigo(maria, juan ) )?
YES
>% agregó la cláusula 1, con el predicado “amigo”
>asserta (amigo(maria, tomas ) )?

YES
>% agregó la cláusula 2, con el predicado “amigo” al inicio de la base de datos
>assertz (amigo(maria, pedro ) )?

YES
>% agregó la cláusula 3, con el predicado “amigo” al final de la base de datos
>% problema 4: modifica los hechos cambiando el predicado “amigo”por el de “amiga”

>% e intercambiando los dos términos. Para cada cláusula de la base de datos
>% recupera un hecho con el predicado “amigo” e instancia las variables libres A, B con los términos
>% constantes de la cláusula con la que unifica borra la cláusula con la que se unificó
>% inserta una nueva cláusula al inicio de la base de datos con el predicado “amiga” y los términos
>% preservados en las variables A, B en un orden inverso: B, A
>invierte:- amigo(A, B), retract(amigo(A, B)), asserta (amiga(B, A ) ).
>invierte? %procede a la actualización de la base de datos

YES
YES
YES
>% se modificaron las cláusulas originales “amigo” por el predicado “amiga” invirtiendo términos
>% problema 5: Rastreo de la ejecución de una regla que restaura la base de datos original
>invierte:- trace, amiga (A, B), retract(amiga(A, B)), untrace, asserta (amigo(B, A ) ).
CALL (0) > amiga (_0. _1)
EXIT (0) > amiga (maria, tomas)
CALL (0) > rertract (amiga (maria, tomas))
EXIT (0) > rertract (amiga (maria, tomas))
:
:
YES
CALL (0) > amiga (_0. _1)

EXIT (0) > amiga (maria, juan)
CALL (0) > rertract (amiga (maria, juan))
EXIT (0) > rertract (amiga (maria, juan))
:
:
YES
CALL (0) > amiga (_0. _1)
EXIT (0) > amiga (maria, pedro)
CALL (0) > rertract (amiga (maria, pedro))
EXIT (0) > rertract (amiga (maria, pedro))
:
:
YES
>% se han alterado los predicados con el despliegue del rastreo correspondiente
>% problema 6: almacenamiento de la base de datos, salvándola en el archivo “p18.txt”
>save (“p19.txt”)?
YES
>% problema 7: borrado de todos los predicados “amigo” de la base de datos

>retractall (amigo(_, _) )?
YES
>% con ellos se ha vuelto a limpiar la base de datos, quedando vacía
1.6.2 Carga y aplicación de la base de datos

En las secciones anteriores se apreciaron diversas formas de crear una base de datos, tanto en el ambiente exterior
como en tiempo real, lo importante es que al final existe un archivo con las cláusulas originales o actualizadas que
representan la base de datos de la aplicación que posteriormente interesa aprovechar para la solución de nuevos
problemas, por tal motivo es necesario que independientemente del origen de la base de datos, al final exista o se genere
un archivo físico donde residan las instrucciones que más tarde volverán emplearse.
Durante una sesión de Prolog se puede cargar una base de datos previamente creada por medio del predicado consult
(X) en el que el término representa la ruta y el nombre del archivo donde reside la base de datos que se desea explotar al
cargarla a la memoria de trabajo del ambiente de ejecución. Una vez realizada esta operación se pueden emplear
algunos predicados para ejercer diversas aplicaciones sobre la base de datos, como por ejemplo el listarla mediante la
cláusula listall y el acceso a las partes de una regla mediante clause(X, Y) en donde el primer término X representa a la
conclusión y el segundo Y a la condición; tal como se aprecia en el programa 20:
>% Programa 20
>% Carga y apliaci{on de la Base de datos
>consult(“p19.txt”)? % este planteamiento carga las cláusulas del archivo 19

YES
>listall? % exhibe las cláusulas recién cargadas
amiga (maria, juan).
amiga (maria, tomas).
amiga (maria, pedro).
invierte:- amigo(A, B), retract(amigo(A, B)), asserta (amiga(B, A ) ).
YES
>clause(invierte, Y)? % solicita la condición de la regla cuya conclusión es “invierte”

Y = amigo(_7, 6), retract(amigo(_7, 6)), asserta (amiga(_6, _7))
1.6.3 Operaciones especializadas para uso de archivos

Si bien Prolog no es un lenguaje orientada al proceso de información masiva, si cuenta con facilidades para el acceso a
archivos que contienen información en el formato preestablecido por el usuario, así como para grabar los resultados
intermedios y finales que le interesan bajo las convenciones que el propio diseñador establezca. Para tal efecto se
cuentan con un repertorio de predicados con las siguientes características y formas de empleo, tal como aparece en el
programa 21:
tell(X) abre el archivo especificado por X como de “salida”

telling(X) determina si el valor de X corresponde al archivo que actualmente funge como de “salida”
told cierra el archivo de “salida” declarado por X
see (X) abre el archivo especificado por X como de “entrada”
seeing(X) determina si el valor de X corresponde al archivo que actualmente funge como de “entrada”
seen cierra el archivo de “entrada” declarado por X
eof detecta el final del archivo que se está leyendo
>% Programa 21
>%Operaciones especializadas para uso de archivos
>% Serie 1 de ejercicios de grabación

>amiga (maria, juan). % declaración de hechos
>amiga (luisa, tomas).
>abre(X):- tell(X), !. % abre archivo X de salida
>% ciclo encargado de acceder las cláusulas “amiga”, para grabar los términos con salto de renglón
>% en cada uno de ellos en el archivo de salida, gracias al uso del predicado “fail” encargado
>% de provocar el retroceso para acceder a todos los hechos
>graba :- amiga(X, Y), write(X), nl, write(Y), nl, fail.
>% hecho usado para concluir el ciclo “graba”, una vez que se han grabado todos los valores
>graba.
>cierra :- told, !. % cierra el archivo de salida
>% ciclo encargado de acceder las cláusulas “amiga”, para grabar los términos con salto de renglón
>% en cada uno de ellos en el archivo de salida, gracias al uso del predicado “fail” encargado
>% de provocar el retroceso para acceder a todos los hechos
>graba :- amiga(X, Y), write(X), nl, write(Y), nl, fail.
>% hecho usado para concluir el ciclo “graba”, una vez que se han grabado todos los valores
>graba.
>cierra :- told, !. % cierra el archivo de salida
>% invoca la apertura de archivo, acceso y grabación de hechos y el cierre del archivo
>abre(datos), graba, cierra?
YES % problema resuelto, archivo “datos” creado
%> estos son los datos grabados
maria
juan
luisa
tomas
>% Serie 2, ejercicios de lectura, se limpia la base de datos, se lee el archivo con los términos
>% se insertan nuevos hechos con el predicado “amigos” y se despliegan
>retractall(amiga(_, _))? % se borran todos los hechos para limpiar la base de datos
>listall? % se demuestra que está vacia la base de datos
YES
>abre (X):- see(X), !. % abre el archivo X de “entrada”
>cierra :- seen, !. % cierra el archivo de “entrada” X
>% ciclo encargado de leer la pareja de términos a grabar con el predicado “amiga” como un hecho
>ciclo :- read (V), V <> “end_of_file”, read (W), W <> “end_of_file”, asserta (amiga(W)), ciclo.
>ciclo.
>control (X) :- abre(X), ciclo, cierra, !. % control de la apertura, lectura y clausura del archivo
>control(datos)? % se invoca al proceso de lectura y carga de un archivo

YES % proceso ejecutado
YES
>listall? %muestra los hechos generados

amiga (maria, juan).
amiga (luisa, tomas).
abre (X):- see(X), !. % y las cláusulas previas
cierra :- seen, !.
ciclo :- read (V), V <> “end_of_file”, read (W), W <> “end_of_file”, asserta (amiga(W)), ciclo.
ciclo.
control (X) :- abre(X), ciclo, cierra, !.
YES
CAPÍTULO 2. PROCESO DEL
LENGUAJE NATURAL
2. PROCESO DE LENGUAJE NATURAL
2.1 Descripción del proceso de Lenguaje Natural
El lenguaje natural “LN” es la forma de comunicación que el humano aprende de su ambiente y usa para comunicarse
con los demás, para expresar sus ideas, emociones y necesidades, esperando cierta clase de respuesta por parte de su
interlocutor a partir de su naturaleza tripartita compuesta por los elementos identificados en la figura 2.1.
Espíritu Conciencia
Comunión
El ser humano Mente

es Alma Sentimientos
Tripartito Voluntad
Cuerpo Exterior: cabello, ojos, piel, ...

Interior: venas, tejidos, huesos, ..
Figura. 2.1 Composición del ser humano
2.2 Complejidad en la representación del Lenguaje Natual

2.2.1 Forma de representación
El ser humano usa el lenguaje natural para satisfacer la necesidad de transmitir sus "conceptos internos" a su prójimo a
través de representarlos por un medio (llamado lenguaje) compuesto de elementos y reglas (para interrelacionarlos), del
cual selecciona aquellas unidades que mejor los ilustran, con el propósito de lograr que el receptor "entienda" lo que
realmente desea expresar. Para cumplir con el objetivo de hacerse entender, es necesario considerar 4 dominios:
La estructura lingüística, que está enfocada a regular los elementos estructurales del lenguaje.
La correspondencia entre las estructuras lingüísticas y el mundo
Proceso cognoscitivo, involucra las estructuras de conocimiento y su manipulación por el procesador del lenguaje.
La acción humana y su interacción con el mundo, la cual asocia al lenguaje dentro del contexto del tiempo relativo a
hechos y expectativas
Amén de considerar estos dominios es necesario reconocer algunas limitaciones al comprender el lenguaje, pero también
las ventajas al hacer uso de él como las que se presentan en la tabla 2.1:
# LIMITACIONES VENTAJAS
1 Expresiones breves o vagas: Es flexible al permitir el uso de las expresiones necesarias
- "Subió el índice de la bolsa” con el grado de detalle requerido permitiendo que el
- "El candidato de P_ _ se pronunció por interlocutor genere su inferencia
desterrar la corrupción del ..."
2 La misma expresión significa diferentes cosas Permite expresiones de un mundo infinito, usando un finito
en distintos contextos: número de símbolos
-"Levanta el gato"
(al cambiar una llanta o cargar a la
mascota).
3 Es imposible editar un programa o diccionario Es evolutivo y adaptativo con base a los deseos de la gente
completo del lenguaje:
- "Tírame un bipaso"
- "Faxeamelo".
4 Hay distintas formas de expresar lo mismo: El lenguaje es muy rico en su forma de expresión
- “Juan brinca mucho”
- “Se eleva mucho Juan”
Tabla. 2.1 Limitaciones y ventajas del lenguajes
2.2.2 Tipo de mapeo

Para llevar a cabo tanto la representación del lenguaje, como su entendimiento es necesario reconocer el proceso de
“mapeo” que existe tanto de parte del que expresa el mensaje como de aquel que lo recibe; en donde la idea básica es
convertir la forma original de un concepto a otra; existiendo entonces varias relaciones de “mapeo”, tal como se muestra
en las figura 2.2 y 2.3 que se ilustran dos de las siguientes tres clases de relaciones:
1 a 1: Una expresión matemática: A=B*2+8 traducida a un árbol
A +
* 8
B 2
Figura. 2.2 Mapeo 1 : 1
n * 1: Por ejemplo un "Query" puede expresarse de varias formas:

“Dame los clientes con ventas superiores a $10,000 en Enero”.

“Proporciona una lista de los clientes que compraron mas de $10,000 el mes pasado”.
SELECT * FOR VENTA > 10,000 AND MES = "ENERO"
1 * n: Son situaciones que obligan a emplear mucho conocimiento del dominio para entender correctamente su
significado: "Juan le grita a Pedro ¡pásamela!"
“El balón durante el partido de basketball”

“El ovoide durante el partido de football americano”
“La goma durante la clase”
n * m: Representa al hecho de haber muchas formas de expresar distintas cosas:
Se cayó la bolsa hubo pérdidas en el mercado financiero
La bolsa cerro a la baja la bolsa se cayó al piso.
Figura. 2.3 Tipos de Mapeo
2.2.3 Nivel de interacción entre componentes

Debido a que la expresión a representar está compuesta por varios elementos, es necesario reconocer el "rol" de ellas y la
relación que guardan entre sí, considerando las diversas alternativas de significado en función de su naturaleza y
contexto. Por ejemplo, en la declaración “Pedro vio a su novia en el parque con una cámara”. Surgen varias
interpretaciones, dos de ellas son esquematizadas por los árboles representados en las figuras 2.4 y 2.5 en donde cada
uno de ellos caracteriza diversos planteamientos:
S ¿ Quién tenía la cámara ?
Si fue Pedro:
NP VP
Pedro V NP PP
Vio DET NOM PP con una cámara
a su novia en el parque
Figura. 2.4 Nivel de interacción entre componentes, 1

S ¿ Quién tenía la cámara ?
Pero si fue la novia de Pedro
NP VP
Pedro V NP
Vió DET NOM PP
a su novia en el parque con una con una cámara
Figura. 2.5 Nivel de interacción entre componentes, 2

CAPÍTULO 3. PROCESO LÉXICO
3. PROCESO LEXICO
3.1 Elementos del lenguaje: Alfabeto, Morfología, Diccionario
El primer elemento del lenguaje es el “alfabeto” Constituye el repertorio de símbolos válidos como los que aparecen en
la tabla 31, que a interrelacionarlos forman el universo de palabras, frases, oraciones y textos con significado propio
dentro del lenguaje al que pertenecen.
LETRAS DIGITOS ESPECIALES

A 0 +
B 1 =
: 2 )
: : #
Z : ;
A Ç
B !
: 9 ¿
Tabla. 3.1 Alfabeto de la lengua castellana
La “morfología” es un elemento más del lenguajes orientado a identificar la raíz de los verbos, sustantivos,
pronombres, etc., de tal forma que se pueda distinguir la esencia del significado de la palabra analizada, entre las
situaciones más comunes están los siguientes conceptos:
Los prefijos y sufijos: Son las partículas que anteceden o van después de la raíz de la palabra, como las mostradas en
la tabla 3.2:
TÉRMINO PREFIJO RAÍZ SUFIJO

Desunión des unión
Juegos juego s
Infidelidades in fidelidad es
Tabla. 3.2 Ejemplos de palabras compuestas
Las conjugaciones son el resultado de asociar los verbos a los pronombres en un solo tiempo a efecto de expresar un
concepto en forma y tiempo, obteniendo derivaciones como las siguientes:
Yo como
Tú corres
El /ella corre
Nosotros corremos
Vosotros corréis
Ellos /ellas corren
Los Tiempos, al usar un mismo verbo para una persona específica, pero con distintos tiempos se expresan mensajes en
pasado, presente y futuro entre otos tiempos, como los mostrados por la tabla 3.3:
SUJETO SIMPLE PROGRESIVO PARTICIPIO

Pronombre Presente Pasado Futuro Presente Pasado Presente Pasado
Yo Leo leí leeré Leyendo leyendo leído leído
Tú Amas amaste amarán Amando amando amado amado
Ellas Oyen oyeron oirán Oyendo oyendo oído oído
Tabla. 3.3 Uso de tiempos
Las palabras irregulares derivadas de la raíz no observan un patrón ordinario como las mostradas en la tabla 3.4:
Raíz Derivada
Comida comensal, comedor
Saber sabio, sabiduría
Sonar suena, sonaja, sonido
Hablar hablador, habla
Tabla. 3.4 Derivados irregulares
El género y número son una consecuencia de la adaptación del término al género y número del vocablo original se
altera, tal como los representan los ejemplos de la tabla 3.5:
Raíz Opciones
Portería portero, portera, porteros
Elevador elevadorista
Misión Misionero, misionera, misiones
Tabla. 3.5 Opciones en genero y número
Los diminutivos y aumentativos son todas aquellas palabras que se usan para expresar una comparación a partir de una
referencia, tal como aparece en la tabla 3.6
Diminutivo Raíz Superlativo

Pelotita Pelota pelotota
Camioncito Camión camionzote
Corralito Corral corralón
Tabla. 3.6 Comparativos
Las incongruencias son sólo algunos de los casos más comunes al tratar de identificar la raíz de la palabra, proceso en
el cual se puede incurrir en errores al generar raíces que no correspondan y que representan otra cosa, como los ejemplo
mostrados en la tabla 3.7:
Proceso de Léxico 39
Palabra Raíz
pelotón Pelota
Piñín Piña
Corrido Correr
Ramos Ramo
Universo Verso
Tabla. 3.7 Generación de raíces incorrectas
El diccionario es otro elemento importante del lenguaje encargo de representar el acervo de morfemas y derivados
oficialmente aceptados para una lengua, por lo que un sistema incluye para cada "término" su significado, información
para identificar su información estructural, referencia a la raíz o sus derivados. El diccionario determina la capacidad
del sistema y debe describirse adecuadamente su formato, tipo de organización y representación, así como los métodos
de acceso, para lograr la eficiencia en su manejo. También debe considerar la separación de homónimos para asignar un
registro distinto para cada significado, tal como se describe en la tabla 3.8:
Regis- Identifi- Sinóni

Cabeza Significado Función Estructural Asociación
tro cador mo
Tipo Tiempo ... Raíz Derivado
300 C0450 cuanto apuntador x2 ap.540 ––– –– ––– ap.1...
700 A712 agosto ap. A671 ap. N47 ––– –– 0 –––
1032 C0877 caer ap. C71 ap. V71 ap. TP ... 0 ap.3...
5721 F0141 falda ap F721 ap. 571 ––– ... 0 ap. 82
Tabla. 3.8 Formato de diccionario
Por lo que respecta a la organización y acceso al diccionario se debe elegir la representación apropiada, clase de
estructura y métodos de búsqueda o combinación de estos como los mostrados en la tabla 3.9:
ORGANIZACIÓN ACCESO
Secuencial, frecuencia de uso Secuencial
Secuencial con acceso directo Por # de registro, binario, hash
Indexado Acceso aleatorio y dinámico, llave única, llave compuesta, llave duplicada
Jerárquica, relacional, distribuida Combinación de los métodos de acceso
Tabla. 3.9 Tipos de organización y acceso

3.2 Unidades léxicas
Las "Unidades Léxicas" o "UL" son las estructuras de información que representan a cada palabra del texto a procesar
por los módulos del sistema, cuyo formato contiene la identificación precisa del término, su asociación con la raíz o
vocablo al que corresponde en el diccionario y también su referencia con la “estructura temporal del texto fuente" en
donde aparece la palabra original y sus atributos propios resultantes del análisis morfológico. Estas piezas de
información conocidas como “unidades léxicas” o “tokens” deben ser manipuladas fácilmente por los analizadores
sintácticos y semánticos para producir la "Representación Interna" apropiada al texto, así como también tienen que ser lo
suficiente expresivas para que el "generador" produzca el texto de salida apropiado, tal como se ilustra en la figura 3.1:
¿CUÁNTO SE VENDIO EN AGOSTO?
ANALIZADOR
LÉXICO
UNIDADES LÉXICAS
¿ CUANTO SE VENDIO EN AGOSTO ?
ESTRUCTURA
DICCIONARIO TEMPORAL
FUENTE
Figura. 3.1 Aplicación de Unidades Léxicas
Ahora bien, una muestra del formato para la “Estructura Temporal Fuente” a generar se muestra en la tabla 3.10:
# Registro Termino Ap. Diccionario Persona Genero Número Tiempo ...

15 cuanto c0450 indef. mas. sin. pasado
19 agosto a712 3era. mas. sin. pasado
20 ? 89714 89714 –––– –––– ––––
Tabla. 3.10 Formato de la “estructura temporal fuente”
Finalmente, el contenido del “Token” o “Unidad Léxica” debe ser lo suficiente conciso pero a la vez completo para
eficientar su manejo tal como lo indica la tabla 3.11, la cual describe los datos de la siguiente forma:
APUNTADORES FUNCIÓN ......
Identificador Diccionario ETF Tipo Categoría Clase ... ......

42B C0450 15 INTERROG. CERRADA NOMINAL
87I A712 19 NOMBRE ABIERTA PREGUNTA
Tabla. 3.11 Formato de la “unidad léxica”
Finalmente, es necesario conocer las tres categorías de unidades léxicas:
Abiertas identifican la función primaria de la palabra, abarcan la mayoría de términos del diccionario,
agrupándose en las siguientes clases:
Nominales.- sustantivos y nombres propios que identifican entidades u objetos animados o no
Acción.- típicamente verbos que ilustran eventos
Modificador nominal.- abarcan a los adjetivos
Modificador de acción.- incluye a los adverbios
Cerradas son aquellas palabras con un número restringido de instancias y son de carácter funcional por depender
de otros para adquirir un significado preciso dentro del texto. El repertorio de clases cerradas es:
Conjunciones: y, o, pero,...
Asociación: antes, si, porque,...
Preposición: a, para, por,...
Pronombre: yo, tú, él,...
Número: 0, 1, 2, ..., 1000, ...
Ordinal: 1er. , 2do. , 3er.,...
Determinante: un, una, la, los, aquellos
Negación: no,...
Comparativo: mas, menos, mayor,...
Operador: más, veces,...
Pregunta: Quién, Cómo, Qué,...
Cuantificador: algunos, muchos, ninguno,...
Exclamativo: oh, claro,...
3.3 Procedimiento
Esencialmente son dos direcciones de procesamiento de texto a cargo del Analizador Léxico y cuya descripción se
detalla a continuación:
Conversión del texto de entrada a Unidades Léxicas

Generación del texto de salida a partir de Unidades Léxicas
El procedimiento de entrada se esquematiza en la figura 3.2 a partir del texto alimentado al SLN en modo carácter el
analizador léxico activa sus módulos secuencial o simultáneamente para generar las “UL” correspondientes:
La esencia de las tareas realizadas por los módulos integrantes del analizador léxico son:
Analizador Fonológico: ejecuta cuatro tareas:
Acceso de cada uno de los caracteres integrantes del texto

Identificación del tipo de carácter conforme al alfabeto
Manejo de errores para los caracteres no registrados en el alfabeto
Generación de la “Unidad de palabra” correspondiente
ANALIZADOR
LÉXICO
Unidades de Morfemas Unidades
Texto Palabra Léxicas
Analizador Analizador Generador

Fonológico Morfológico Léxico
Alfabeto Estructura Diccionario

Temporal
Figura. 3.2 Procedimiento de entrada del analizador léxico
Analizador Morfológico: realiza las siguientes tareas:
Emisión de cadenas de palabras o símbolos, compuestos por uno o varios caracteres, considerando los delimitadores,
separadores (. , : ; ! ¿ ? ...) y cualquier otra convención que ayude a delimitar los “strings”; los cuales se almacenan en la
“Estructura Temporal Fuente”
Selección del morfema para las cadenas que contienen un palabra, a través de alguno de algún método
Búsqueda en el diccionario, proceso encargado de encontrar el morfema correspondiente a la palabra deseada
Procesos especiales para la detección y tratamiento de: prefijos, conjugaciones, tiempos, géneros, aumentativos, etc.
Actualización del diccionario al aceptar una nueva palabra, ya sea morfema o derivado, además de registrar sus
asociaciones con otras nuevas y ya existentes. Esta opción puede ser interactiva con el usuario o automatizada con las
limitaciones del caso y la supervisión del administrador del SLN.
Generación del morfema correspondiente a la cadena
Generador Léxico: Conforme a la naturaleza del morfema (número, símbolo, palabra,...) crea la “Unidad Léxica”
correspondiente registrando los datos y ligas necesarios acorde con la información pertinente y las estructuras de datos
empleados (“E. T. F”, Diccionario,...).
El procedimiento de salida es el encargado de proporcionar los elementos y pautas del texto a producir, valiéndose de
la “Base de Conocimientos” y de la emisión y actualización de las estructuras de datos denominadas “Representación
Interna”. Dicho módulo deberá incluir un procedimiento que emita “cadenas” con unidades léxicas, sintácticamente y
semánticamente correctas para alimentar al “Analizador Léxico” conforme al esquema de la figura 3.3
ANALIZADOR LÉXICO
Palabra Morfemas Unidades

Texto Léxicas
Expositor Generador de Generador de

Fonológico Palabras Morfemas
Estructura Base de Base de Diccionario

Temporal Salida Conocimientos Conocimientos
Figura. 3.3 Procedimiento de salida del analizador léxico
En resumen, las funciones a ejercer por los módulos son:
Generador de morfemas.- accede a las “UL” y “RI” producidas por el subsistema “generador”, aprovecha la
información del diccionario y base de conocimientos para emitir el morfema mas adecuado a la representación.
Generador de palabras.- manipula el morfema y estructuras de datos que empleó el módulo antecesor, procura de ser
necesario, agregar la palabra, hacer su transformación o reemplazo por aquel término que satisfaga las condiciones de
tiempo, persona, número, género, comparación, etc. que se espera esté representada, registrando en la “estructura
temporal de salida” la palabra propuesta.
Expositor fonológico.- Es el encargado de ensamblar el texto compuesto por las cadenas de palabras, símbolos y
números, incorporando los separadores y símbolos especiales para editar el mensaje.
3.4 Manejo y recuperación de errores

Existen dos tipos de errores en la fase léxica del sistema, el primero, es el resultado de la interacción del usuario donde
él proporciona texto con palabras o caracteres impropios del lenguaje manejado por el sistema. Mientras que la segunda
clase es técnica, motivada por los clásicos errores de programación, la emisión de inferencias erróneas (sobre todo el
análisis morfológico) y el empleo de conocimientos incompletos o erróneos representados en el diccionario y base de
conocimientos
Por lo tanto, es necesario el diálogo con el usuario para detectar inconsistencias durante el análisis fonológico y
morfológico para que las evalúe, modifique por otras que el sistema maneje o bien las confirme. De esta forma el
sistema será capaz de adoptarlas, realizando la incorporación a las estructuras de datos correspondientes (alfabeto,
diccionario, ...), integre las “ligas” entre los términos involucrados (raíz con sus derivadas) y sobre todo realice las
pruebas de consistencia para identificar y manejar adecuadamente las contradicciones o sinónimos.
Por ejemplo, al usar la palabra “canto” en varios ejemplos con distintos contextos, provocaría actualizar el diccionario
agregando registros y asociaciones diversas para los siguientes significados:
canto.- acción de cantar, conjugada en presente, primera persona singular, raíz cantar,...
canto.- nombre, asignado a la orilla de un objeto de forma ....
Canto.- nombre propio, apellido de persona....
canto.- nombre, expresión artística musical
La emisión del texto de salida será evaluada por el usuario hasta el final, al momento de su exposición, en donde lo
primero a observar es la naturaleza de la declaración expuesta por el sistema (pregunta, respuesta, comentario,
afirmación, rechazo, ...), su contexto, estructura sintáctica y consistencia en el vocabulario empleado.
Sin embargo, la identificación de los ajustes a realizar es más difícil ya que deberá revisar el ciclo completo del
funcionamiento del SLN, comenzando por confirmar que el texto de entrada haya sido representado léxica y
sintácticamente bien, su análisis semántico e interpretación haya sido correcta y que el funcionamiento del generador
reaccione con eficacia al mandato que se espera realice. Después se podrá verificar el buen desempeño de los módulos
de salida del analizador léxico, correspondiendo al personal técnico la modificación al sistema.
3.5 Implementación
Es recomendable aplicar una estrategia de desarrollo “incremental” y de “ensayo y error” para el subsistema del
analizador léxico; a partir de las definiciones conceptuales de la estructura y funcionamiento de todo el sistema, así
como del ámbito de aplicación y dominio de conocimiento que explotará.
Por lo tanto, una vez creadas las estructuras de datos iniciales para los elementos básicos del lenguaje, se inicia la
construcción y prueba del primer módulo de entrada; a partir de las unidades de palabra que genere, evalúa el
desempeño del analizador morfológico y realiza una prueba exhaustiva de casos. Finalmente el generador léxico haga
su parte. A su vez, con base en estos resultados, se agregan las estructuras de datos que otros subsistemas crean como
las “RI”, se prueban en orden inverso los módulos de salida, comenzando por el “generador de morfemas” y
concluyendo con el “expositor fonológico”.
Naturalmente, esta estrategia se puede alterar desarrollando en paralelo los módulos, creando estructuras de datos y
casos ad-hoc para cada uno de ellos con el propósito de evaluarlos independientemente para integrarlos al final. El
desarrollo incremental es con el fin de abordar problemas sencillos con estructuras de texto simples y cortas en una
primer etapa, para gradualmente aumentar el grado de riqueza y profundidad del lenguaje.
CAPÍTULO 4. PROCESO DE LA SINTAXIS
4. PROCESO DE LA SINTAXIS
4.1 Elementos del análisis gramáticas, redes de trasformación, Parsers
La gramática de un lenguaje natural representa el “núcleo” que define la naturaleza de los componentes (verbos,
sustantivos, artículos, etc.), sus variantes (conjugación, tiempos, genero, número, etc.) y reglas para su interrelación
(frases, enunciados, interrogaciones, negaciones, etc.). Constituye el fundamento para regular el uso del lenguaje dentro
de la sociedad. Los sistemas de lenguaje natural (SLN) dedican una atención especial a la representación y uso de
aquella parte gramatical del lenguaje natural que pretenden procesar, por lo que es necesario determinar el subconjunto
de componentes, variantes y reglas que se van a utilizar dentro del universo del propio lenguaje. Para implementar la
gramática de un lenguaje se usa una parte de las matemáticas conocida como “lenguajes formales”, cuya representación
clásica es a través de reglas que evalúan o generan un “espacio de estados“ para el análisis o producción de oraciones.
Dentro de este marco, existe una variedad de “representaciones” gramaticales acordes con el nivel de alcance (finitas),
considerando el entorno (libre de contexto) y formas de procesamiento (generativa), entre otros enfoques, por lo que es
necesario interpretar correctamente la naturaleza de ellas para elegir la más apropiada a la aplicación en turno., como el
ejemplo que se presenta a continuación, para una gramática “libre de contexto” para el idioma español.
O --> FN FV
FN --> Art FN1 | Pro | NomPer | FN1
FN1 --> Nom Adj
Adj --> e | Adjs Adj
Adjs --> pequeño | largo | rápido | .....
Art --> el | la | los | los | en | a
Pro --> yo | tú | él | ...
NomPer --> juan | maría | pedro | ...
Nom --> archivo | impresora | monitor |....
FV --> Verbo | FN
Verbo --> Imprime | copia | despliega
Las redes de transformación son un modelo ampliamente usado en los sistemas para implementar gramáticas se
conoce por “Redes de transición”, cuyo fundamento descansa en la “Teoría de Grafos” y en las “Máquinas de Estados
Finitos”. Existen varios tipos de redes que difieren en complejidad y eficacia, entre los que se encuentran:
De estados finitos
Recursivas
Aumentadas
Es esencial reconocer que la gramática indica las siguientes asociaciones con el lenguaje:
Una débil capacidad generativa, para identificar el significado del conjunto de oraciones contenidas en un lenguaje
(sentencias gramaticales) y que pueden ser completamente “empatadas” por las reglas gramaticales
Una fuerte capacidad para identificar el tipo de estructura que corresponde a cada oración gramatical del lenguaje.
Cada una de estas clases de redes tienen en común los siguientes elementos:
Máquina.- Es un módulo de proceso que arranca a partir de un “estado inicial” hacia otros cuando una condición en
particular ocurre conforme a las transformaciones que se van procesando.
Estados Finitos.- Se dice de aquellas máquinas donde a partir de cualquier punto de transición el siguiente estado puede
determinarse a partir del estado actual y las condiciones que provocan la transición. Puesto que es conocido el número
de estados posibles a generar, se considera “finito”.
Estado.- Es una descripción del componente gramatical que está representado como un “lugar” dentro de la red de
alternativas caracterizada por la transición que provoca el cumplimiento de las condiciones asociadas al estado, para
generar uno nuevo.
Arcos.- Ilustran la condición que produce la transición desde un estado a otro, siendo etiquetadas por el identificador
de la condición.
Red.- Es la representación gráfica y de estructura de datos, integrada por estados (“nodos”) y condiciones (“arcos”) que
se recorren o generan a lo largo de la evaluación o emisión de un texto.
Ruta.- Es el camino formado por un conjunto de nodos y arcos, a partir de un estado dado hasta otro determinado.
A continuación se describen los primeros dos tipos de redes, mientras que la tercera se hará posteriormente.
La red de transición de estados finitos (RTEF). Es la red más elemental que conecta los nodos por medio de arcos
dirigidos, para representar la secuencia en la cual las palabras pueden aparecer en una oración mediante el recorrido de
una ruta a través de la red. Por ejemplo: La red de una gramática que represente la secuencia: “ Artículo Nombre
Verbo”. Para evaluar oraciones tipo: “ El gato corre”, “El niño llora”; Se representa gráficamente tal como lo
muestra la figura 4.1:
Art Nom Verbo

Q0 q1 q2 q3
Figura. 4.1 “RTEF” para una simple gramática
En éste diagrama los círculos identifican a los “nodos” o “estados” mientras que los arcos a las “condiciones”, es decir,
al “símbolo terminal” que produce la transición entre un estado actual y el subsecuente. Gracias al uso de la cabeza de
flecha se reconoce la dirección de la transición. Las redes empleadas en este modelo son dirigidas, tienen un sólo
“estado inicial” y uno o varios finales (identificados por una diagonal). Al ampliar los elementos de la gramática
anterior de acuerdo con la red mostrada por la figura 4.2, en la que se pueden reconocer oraciones más amplias como:
”El niño gordo corre”, “ La niña juega”.
Art Nom Adjetivo Q3 Q4
Q0 Q1 Q2 Verbo
Verbo
Figura. 4.2 “RTEF” para una gramática complicada
Los ejemplos presentados de gramáticas son “deterministicos” porque sólo se produce un estado específico a partir de un
mismo tipo de palabra, sin embargo hay casos donde pudieran generarse diversos estados a partir del mismo tipo,
convirtiendo la red a la categoría de las “no deterministicas” como se ilustra en la figura 4.3, en donde evalúa las
declaraciones: “ El joven ha corrido”, “ Los niños corrieron”, “ El jugador corrió mucho”
Proceso de la Sintaxis 49
Art Nom Auxiliar Q3 Q4
Q0 Q1 Q2 Verbo
Verbo
Complemento
Verbo
Q5 Q6
Figura. 4.3 “RTEF” no determinística
La red de transición recursiva (RTR) Amen de las características y elementos que las “RTEF” incorporan a las
condiciones, el tratamiento de estados (además de los “símbolos terminales”), la evaluación de pruebas, el manejo de
repeticiones consecutivas o discontinuas de símbolos terminales y también de estados; incorporan a la red otras
condiciones para representar a cada estado que etiqueta a los arcos de la red, tal como lo muestra figura 4.4 en donde se
muestra un ejemplo de una “RTR” para el idioma inglés. En ésta gramática se evalúan oraciones como: “The dog eats”,
“The little black dog run on the street” y “The american young boy at the fifth street has played tha electric guitar with
his old papa”.
Recorrer una “RTR” involucra evaluar los arcos de cada nodo. Si corresponde a un “Nombre de Estado” el control se
traslada a la red que lo representa comenzando a visitarla desde su estado inicial hasta alcanzar un estado final o hallar
un error, entonces el control retorna al arco etiquetado, si regresó con éxito transita al estado que apunta, de lo contrario
se rechaza el arco y se evalúan los otros que salen del estado actual, hasta que alguno tenga éxito, de lo contrario, se
hace “ backtrack” en los estados explorados para recorrer otras rutas aún no evaluadas, si ninguna de ellas tiene éxito,
entonces se rechaza el texto que está siendo evaluado, porque su estructura o elementos no corresponden a la gramática
representada.
Sin embargo pueden aparecer casos en los que la oración evaluada tiene palabras pendientes de ser analizadas y ya se
alcanzó un estado final o bien, el caso contrario, ya se evaluaron todas las palabras de la oración original y aún no se
llega a una estado final.
FP
FN VER FN
S Q1 Q4 Q5
AUX
AUX VER
Q3
Q2
Adj
Det Nom FP
FN Q6 Q7
Nom
Q8
Prep FN
FP Q9 Q10
S: Oración FN: Frase Nominal Aux: Auxiliar Verbal Ver: Verbo

FP: Frase Preposicional Det: Determinante Adj: Adjetivo Nom: Nombre
Prep: Preposición
Figura 4.4 “RTR” una sencilla gramática del inglés.
Los parsers independientemente de la gramática el proceso de ”traducción” comparan las reglas contra las palabras del
texto de entrada, cada regla que empata agrega un elemento a la estructura o la termina de generar. La estructura más
sencilla que produce es el “árbol de traducción “ en donde aparecen las reglas y el resultado del “empate”. Sus niveles
corresponden a la aplicación de una regla gramatical cuyos nodos representan una palabra o un nodo no terminal, tal
como se ilustra en la figura 4.5. Al traducir una oración hay dos direcciones en que se puede llevar a cabo:
Ascendente: Comienza con el símbolo “inicial” aplicando las reglas que puedan empatarse hasta alcanzar uno de los
estados finales, generando un árbol cuyos nodos terminales representan las palabras del texto evaluado
Descendente: Parte de la oración de entrada, aplicando a sus elementos las reglas en forma inversa, es decir, de las
condiciones al estado
FN FV
NOM VERBO FN
juan tomó ARTICULO NOM ADJETIVO
la pelota roja
Figura. 4.5 “Árbol de Traducción” para la oración “Juan tomó la pelota roja”
La elección del sentido depende del factor de ramificación, la evaluación heurística, la información disponible y el
mecanismo de traducción; siendo conveniente en ocasiones combinar las dos direcciones dentro del módulo traductor.
Otro aspecto relevante a considerar es la cantidad y variedad de traducciones que se pueden generar a partir del mismo
texto y gramática siendo necesario decidir si:
Se van a explorar todas las alternativas

Se acepta como única a la primer interpretación generada
Al obtener varias, cómo se reconocerá a la mejor
Cómo aprovechar la heurística para lograr que la mejor solución es la primer interpretación hallada.
Es necesario reconocer que el proceso de traducción de un texto es equivalente al problema de hallar una representación
idéntica a otra, por lo que obliga a desarrollar una “ Búsqueda” dentro de un espacio de estados, exigiendo emplear las
herramientas de búsqueda ciega y heurística clásicas.
4.2 Teorías de “Chomsky” sobre estructuras sintácticas y de teoría de sintaxis

Las estructuras sintácticas fueron concebidas en 1957, cuando Chomsky publicó un libro intitulado “Reglas para la
generación del lenguaje”, basado en las teorías formales del lenguaje expuestas por Bloomfield, expone una
representación de “estructuras” que pretenden modelar el mecanismo natural inherente del ser humano en el aprendizaje
y generación del lenguaje.
El fundamento de su teoría descansa en el hecho de que el lenguaje natural es infinito, pero que sin embargo la
capacidad de entendimiento y expresión por el hombre, no depende únicamente de las palabras y oraciones que haya
escuchado y hablado, sino que siempre hay términos y frases que aunque no integren su repertorio y experiencia en
comunicación será capaz de comprenderlas y emitirlas llegado el momento.
El núcleo de tal teoría es la observación de que el aprendizaje del lenguaje no sólo depende de memorizar todas las
oraciones que el ser humano escucha y dice, sino que ante todo está dotado por un mecanismo capaz de interpretar y
producir “estructuras del lenguaje”. Chomsky desarrolló el concepto de “gramáticas generativas” para representar a
las estructuras naturales que el hombre emplea en el manejo del lenguaje, definiéndolas como:
“Una estructura formalizada con precisión matemática que genera sin un parámetro específico cualquier información
que no está representada explícitamente en el sistema, dando vida a oraciones gramaticales que en conjunto integran un
lenguaje, describiendo y asociando a cada una de ellas su descripción estructural o análisis gramatical “.
A lo largo del trabajo desarrolla las siguientes clases de gramáticas generativas:
Gramática Generativa de Estado Finitos.- se concibe como una máquina capaz de representar y transitar por un
conjunto de estados finitos, emitiendo un “símbolo específico” al pasar de un estado a otro. El proceso arranca a partir
de un estado específico “inicial”, transita por diversas rutas generando palabras, para llegar a un estado dado,
denominado “final”. A la secuencia de palabras emitidas se le llama “oración” y al conjunto de ellas se identifica como
lenguaje, mientras que a la máquina se le conoce como “gramática de estados finitos”.
Gramática Generativa de Estructuras de Frase.- en lugar de manejar “palabras” específicas durante la transición de
un estado a otro, se emplean “constituyentes” (verbos, sustantivos,....), las cuales pueden estar definidos por otros, y
éstos a su vez por algunos más específicos hasta llegar a especificarse por “palabras”. Como por ejemplo:
O -> FN + FV
FN -> ART + NOM
FV -> VERBO + FN
ART -> el, la, los, .....
NOM -> casa, juan, perro,....
VERBO -> pinta, come, juega, cuida
La oración que se evalúa o genera tiene una representación estructural denominada “frase marcada”. Por ejemplo al
aplicar la gramática anterior se produce la oración y frase marcada mostrada en la figura 4.6:
O-> FN + FV
ART + NOM + FV
el + NOM + FV
el + perro + FV
el + perro + VERBO + FN
el + perro + cuida + FN
el + perro + cuida + ART + NOM
el + perro + cuida + la + NOM
el + perro + cuida + la + casa
FN FV
ART NOM V FN
el pelota cuida ART NOM
la casa
Figura. 4.6 Oración y Frase marcada emitida por una gramática de “Estructura de Frase”
Gramática Generativa Transformacional.- además de producir la “estructura de frase” como resultado de la primera
etapa en el proceso, desarrolla a partir de dicha estructura una nueva denominada “componente transformacional” y
concluye emitiendo otra llamada “componente morfémica”. Estas transformaciones sucesivas sobre la estructura frase
permiten identificar ciertos aspectos que solamente aparecen a ese nivel de representación. Por ejemplo, una declaración
en “voz activa” puede convertirse a “voz pasiva” para después “afinarse” y presentarse como una frase final, tal como lo
muestra la figura 4.7 a continuación:
Aplicación de la gramática
Estructura de la frase
Jhon will break the window
Aplicación de las reglas
Componente
transformacional
Aplicación de reglas morfémicas
Componente morfémico
The window will be broken
by Jhon
Figura. 4.7 Desarrollo de etapas y estructuras por una gramática transformacional
La “estructura de frase” dentro de este desarrollo viene a jugar el papel de “estructura de fundamento”, mientras que el
“componente morfémico” desempeña el de “estructura frontal”. Muchas veces, la aplicación de reglas de transformación
tratan con la relación existente entre el verbo y el sustantivo. También manejan los casos de negación o interrogación de
la oración.
Gramática Generativa de Transformaciones Generalizadas.- maneja aspectos más interesantes y complejos que las
antecesoras. Por ejemplo, si dos oraciones tienen el sustantivo en común se combinan por medio de una serie de
transformaciones como se ilustra en la figura 4.8:
1 2
Integrando las oraciones

se producen
[the girl [the girl has lovely voice]is singing] [the girl [the girl is singin] has a lovely voice]
Al transformarse produce Al transformarse produce
The girl with a lovely voice is singing The girl who is singing has a lovley voice
The singing girl has a lovley voice
Figura. 4.8 Conjugación de oraciones con gramática generativa de transformaciones generalizadas
Como resultado de las experiencias al aplicar esta gramática se observó la separación del nivel sintáctico de las
oraciones producidas con respecto al contexto semántico en el que se expresan, provocando la emisión de oraciones sin
sentido, contradictorias o tergiversadas, como por ejemplo:
I am going to work -> I am not going to work.

the chickens are ready to eat -> The chickens have been prepared for us to eat them.
-> The chickens are hungry and ready to eat their food.
Teoría De Sintaxis
Como producto de las experiencias en la aplicación de las “estructuras sintácticas”, Chomsky expuso en 1965 la “teoría
de sintaxis” en donde la gramática consta de los siguientes componentes:
Sintáctico, se integra por una “base” que se compone por reglas que producen la estructura de la frase y reglas de
intersección léxica y por un proceso denominado “transformación”
Semántico
Fonológico
El componente sintáctico es “generativo” pues produce las “estructuras fundamento” que alimentan a otros dos
componentes de carácter “interpretativo” ya que el sintáctico asocia a la “estructura de la frase” su significado, mientras
que el fonológico la “maquilla” para su exposición.
Durante la fase desarrollada por el componente sintáctico su analizador léxico proporciona para cada palabra
información de interés para los módulos sintáctico, semántico y fonológico. Por ejemplo, en la figura 4.9 se muestra una
“frase marcada” con atributos asociados a sus elementos, en donde los nodos que terminan con esa lista se denominan
“símbolos complejos”.
FN FV
ART NOM V F
N
Género Nombre tipo tipo Género Nombre

Número animado tiempo tiempo Número Animado
. persona sujeto objeto animal
. numero . . . Número
. . . . . .
. . . . . .
Figura. 4.9 Atributos de los símbolos complejos de una frase marcada
Cuando la descripción y rol del verbo ignora la naturaleza de las frases nominales que lo rodean (sujeto y objeto) se dice
que es una gramática de “contexto libre”, pero si las toma en cuenta e inclusive produce listas de atributos para cada una
de ellas, se dice entonces que es una gramática “sensitiva al contexto”.
Por lo que concierne a la transformación de la “estructura fundamento” a otras como las interrogaciones y preguntas que
provocan una diferente interpretación, se procura que no tengan la misma “estructura de la frase” mediante la adición de
identificadores; como por ejemplo:
Estructura Frontal Estructura Fundamento

The tree is growing <- The tree grow - (+ progresivo)
The tree is not growing <- NEG The tree grow -(+ progresivo)
Is the tree growing <- Q the tree grow -(+ progresivo)
El componente semántico emplea reglas de producción y marcadores semánticos para formar rutas amalgamadas que
identifican varios sentidos de la oración. La interrelación de los componentes se ilustra en la figura 4.10, en donde se
separa la función del semántica con respecto a la transformación, con el objeto de no cambiar el significado.
BASE
Reglas
Análisis léxico
Reglas de inserción léxica
“Estructura Fundamento”
SEMÁNTICO TRANSFORMACIÓN
Reglas de proyección Transformaciones

Marcadores
Estructuras semánticas
Estructura Transformacional
Rutas almagamadas
Representaciones semánticas
Fonológico
Componentes
Maquillaje
Estructura frontal
Figura. 4.10 Mecanismo de Funcionamiento de la teoría de sintaxis.
A pesar de las previsiones para evitar la “degeneración” del significado de una oración, aún se puede presentar el
problema, cuando una oración se genera de otra, que a su vez tienen la misma “estructura de frase”, como por ejemplo:
“John sprayed paint on the wall”-------->“The wall sprayed with paint by John”
4.3 Redes de transición aumentadas

Las “RTR” emplean más condiciones y acciones para recorrer una red, usan un “Árbol de traducción” como estructura
de las palabras de la oración que “empata” con los elementos de la red. También varias partes de la oración son
mantenidas como registros hasta que la estructura completa pueda ser determinada.
Por ejemplo, cuando se encuentra un verbo, éste se almacena en un registro tipo “V” (Verbo); similarmente, todas las
palabras de una “FN” (Frase Nominal) se guardan en un registro clase “FN”, las “RTA” usan la nomenclatura siguiente:
< Red Transición > --> (< arcos > < arcos > * )
< arcos > --> (< estado > < arco > * )
< arco > --> (CAT < categoría > < prueba > < acción > * < acci_term > |
(PUSH < estado > < prueba > < acción > * < acci_term > |
(TST < etiqueta > < prueba > < acción > * < acci_term > |
(POP < forma > < prueba > ) o
< acción > --> (SETR < registro > < forma > ) |
(SENDR < registro > < forma > ) |
(LIFTR < registro > < forma > )
< acci_term> --> (TO < estado >) |
(JUMP < estado >)
< forma > --> (GETR < registro >) |
* |
(GETF < característica >) |
(APPEND <registro> <forma>) |
(BUILD <fragmento> <registro> *)
* indica un elemento repetible en la especificación del lenguaje.

& actual valor de entrada, palabra o frase, el elemento con el que se está trabajando.
PUSH inserta elementos en la pila
POP saca elementos de la pila
<arcos> una RTA se define por uno o más conjunto de arcos
( *) donde un arco es un estado con sus arcos asociados, como en las “RTR”.
En las “RTA” hay cuatro clases de arcos:
CAT es el arco original en el símbolo terminal que identifica la clase de palabra o categoría que causó que el arco
haya sido considerado.
PUSH es el arco con un nombre de estado. Al usar la función PUSH implica moverse a un nivel más bajo de la red de
transición comenzando en el estado cuyo nombre es especificado.
TST permite usar un arco de acuerdo a una condición arbitraria y no solamente porque una palabra específica es
encontrada. Se pueden hacer pruebas sobre parte de la oración que ha sido construida, como por ejemplo si es pasiva o
interrogativa.
POP es un arco “Dummy” usado para determinar si un estado terminal ha sido alcanzado y cómo será en la
construcción final.
Los arcos CAT, TST y PUSH tienen una prueba y acción terminada al menos que debe ocurrir. Hay tres posibles
acciones usadas para construir las partes de la oración:
SETR asignan un valor al registro especificado.

SENDR transfiere el valor al siguiente nivel inferior de la red para asignarlo a un registro.
LIFT transfiere el valor el siguiente valor superior de la red para su asignamiento.
Las acciones terminales TO y JUMP especifican si el proceso debe ser terminado con la palabra actual o frase, si el
apuntador a la entrada deberá se movido o deberá permanecer donde está y cual estado será procesado a continuación.
TO indica que el apuntador de entrada será movido a la siguiente palabra del texto de entrada y que nodo
será procesado a continuación
JUMP señala el nodo a procesar sin mover el apuntador del texto de entrada, ya que las palabras aún no han sido
“empatadas”
Las funciones usadas para describir los datos manipulados son:
GETR regresa el valor de un registro específico

GETF determina el valor de un atributo específico de la palabra de entrada actual
APPEND adhiere valores al contenido del registro especificado. Por ejemplo, se puede agregar una frase preposicional
al final de una nominal que ya ha sido formada y colocada en el registro “FN”
BUILD construye partes o toda la frase final a partir del contenido de los registros especificados. Señala primero el
fragmento a construir, seguido de uno o mas signos “+” para indicar los nodos a ser incluidos y finalmente los atributos
y registros cuyos valores sean derivados, por ejemplo:
(SET FV (BUILD (FV ( V + ) & ) V ) )
Primero construye el fragmento FV colocando el valor actual en la posición de “&”, y el contenido del registro “V” en
la posición de “+”, y a continuación asigna el fragmento al registro “FV”.
La frase: “El niño come un helado” genera la “FN” “El niño” que asigna al registro “Sujeto” y el verbo “Come” al
registro “V”. Después identifica que la entrada actual “un helado” es una “FN” luego encuentra la regla de arriba,
construyendo la “FV” “come un helado”, para que al final genere la siguiente estructura:
( S DCL (FN (Dete el) (Adje) (Nomb niño) ) (FV (V come) (FN (Dete un) (Adj) (Nomb helado) ) ) )
Conforme a la gramática de la figura 4.5 se describe a continuación el lenguaje tipo “RTA” que corresponde al “nivel
superior” utilizando el “/” para señalar el comienzo de una “RTA” cuyo nombre aparece antes:
( (S / (PUSH FN /T
(SETR SUJETO &)
(SETR TIPO “DCL”)
(TO Q1) )
(CAT AUX T
(SETR AUX &)
(SETR TIPO “Q”)
(TO Q2) ) )
(Q1 (CAT V T
(SETR AUX NIL )
(SETR V & )
(TO Q4) )
(CAT AUX T
(SETR AUX & )
(TO Q3) ) )
(Q2 (PUSH FN/T

(SETR SUJETO &)
(TO Q3) ) )
(Q3 (CAT V T
(SETR V &)
(TO Q4) ) )
(Q4 (PUSH FN/T

(SETR FV (BUILD (FV (V +) &) V) )
(SETR CFP NIL)
(TO Q5) )
(POP (BUILD (S+++(FV +) ) TIPO SUJETO AUX V) T ) )

(Q5 (PUSH FP/T
(SETR CFP (APPEND (GETR CFP) FPR ) )
(TO Q5) )
(POP (BUILD (S++++) TIPO SUJETO AUX FV) T) )
(FN/ (CAT Name T
(SETR NAME &)
(TO Q8) )
(CAT Det T
(SETR DETER &)
(SETR ADJE NIL)
(TO Q6) ) )
(Q6 (CAT Adj T

(SETR ADJE (APPEND (GETR ADJE) (LIST &) ) )
(TO Q6) )
(CAT Name T
(SETR NAME &)
(SETR CFP NIL)
(TO Q7) ) )
(Q7 (PUSH FP/T

(SETR CFP (APPEND (GETR CFP) FPR ) )
(TO Q7)
(POP (BUILD (FN (Dete +) (Adje +) (Nomb+)+) DETER ADJE NAME CPF ) T ) )
(Q8 (POP (BUILD (FN (Nomb + ) ) Name ) T ) )
(FP / (CAT Prep T

(SETR PREP &)
(TO Q9) ) )
(Q9 (PUSH FN/T

( POP (SETR FPR(BUILD (FP (Prep +) &) PREP) ) T ) ) )
Otras frases que son validadas generan un resultado:
“John run “ ----Æ ( S DCL (FN (Nomb John) ) ( FV (V run) ) )
“Will Marie drink the milk and coffe” -Æ

(S Q (FB (Nomb Marie) ) Will (FV (V drink) (FN (Dete the) (Adje) (Nomb milk) (FP (Prep and) (FN (Nomb coffe) ) ) )
))
Ejercicio: Obtén la estructura correspondiente a las oraciones siguientes:
“ The black boy with the yellow girl would go to the new movie with their pareents in the red car”
“Will you and your current boyfriend travel to USA next summer ?
4.4 Implementación de un modelo sintáctico

El desarrollador debe elegir el tipo de gramática que más se ajuste a la naturaleza y componentes del lenguaje a
representar, para después proceder al diseño de las reglas y redes correspondientes. También deberá elegir el medio de
programación más flexible que disponga para el manejo de funciones, algoritmos y estructuras de datos necesarias en la
construcción del subsistema de análisis sintáctico.
Entre los elementos más útiles al momento de la implementación del módulo están: las estructuras ligadas, tablas, reglas,
listas, pilas, recursividad, compiladores e intérpretes. Por tal motivo a continuación se ofrece una descripción de su
aprovechamiento:
Estructuras ligadas.- los diversos tipos de estructuras (de frase, frontal,....) pueden representarse por medio de nodos
con el siguiente formato de registro:
Constituyente.- (Oración, FN, FV, Artículo, Adverbio, ....)
Descendiente:.-apuntador
Hermano.- apuntador
Antecesor.- apuntador
Unidad Léxica.- apuntador
El árbol ligado con esta clase de registros tiene la siguiente ilustración, en donde la “X” representa nulo y “Ç “ el
llamado a la función que identifica la palabra reconocida (símbolo terminal).El campo “Unidad Léxica” almacena el
apuntador a la descripción léxica del símbolo terminal reconocido como se aprecia en la figura 4.11:
O X X X
FN X FV X X
ART El N X perro v come
Ç Ç Ç FN
Figura. 4.11 Estructura Ligada para una frase
Recorrido de las Estructuras: El análisis y generación de oraciones almacenadas en las estructuras ligadas debe
apoyarse en un eficiente mecanismo de creación y acceso, en donde el orden en el recorrido entre nodos puede o no
facilitar la tarea. Para ello existen tres direcciones y órdenes clásicas a considerar al momento de visitar un nodo
“padre”, su “hijo” y “hermano” conforme a la tabla 4.1 donde se indica la secuencia a explorar de nodos y ramas:
Visita al Nodo Preorder Inorder Postorder

Padre 1 2 3
El árbol del hijo 2 1 1
El árbol del padre 3 3 2
Tabla. 4.1 Secuencia de recorrido de árboles

Representación de las reglas.- el almacenamiento, acceso, interpretación y manipulación de las reglas es un factor
determinante en la eficiencia del subsistema de análisis sintáctico por lo que se debe diseñar estructuras y mecanismos
de acceso adecuados, explotando las capacidades del lenguaje de programación empleado. Dentro de las alternativas de
representación de reglas tenemos las siguientes:
Listas.- mediante el uso de “CAR” como etiqueta del arco y condiciones en el “CDR” se almacena cada regla:
( ó (FN FV) ) ( FN ( Art Nombre ) ) ( Art ( el la los .... ) )
Tablas.- los estados y arcos de la red se relacionan con una tripleta en cada localidad, de acuerdo con el formato: ( Ni, a,
Ns). Donde “Ni” es el nodo del cual sale el arco y “Ns” es el nodo a donde llega el arco “a”. Por ejemplo:
(Qo, Art, Q1) (Q1, Nom,Q2) (Q2, Adjetivo, Q3) (Q2, Verbo, Q4) (Q3, Verbo, Q4)
Reglas.- mientras que la relación entre los elementos de una regla (estado actual-->arco) y los nodos de una red se
representan por medio de un arreglo de cuatro campos con el formato: (Ni, a, Ns, T), en donde:
T indica el Tipo de arco que se usa:

E de estado (se compone por su propia red)
T terminal (se divide en símbolos terminales)
F estado final de la red.
(Qo, Art, Q1, T) (Q1, Nom, Q2, E) (Q2, Adjetivo, Q3, T) (Q2, Verbo, Q4, F) (Q3, Verbo, Q4, F)
Implementación de RTA.- se puede concebir el análisis de una oración como un proceso que atraviesa por dos
etapas. En la primera se compila la gramática generando varias tablas y estructuras de datos y en la otra se interpreta,
usando dicha información al contrastar el texto a evaluar, tal como se ilustra en la figura 4.12. En ella se muestra en
proceso en el que durante la primer fase se producen las siguientes tablas:
Gramática que se introduce al “compilador” de la fase 1.- usa una estructura del tipo “lista de listas”. Al más alto
nivel es una lista de un conjunto de arcos representados por listas. Estos son nodos acompañados por la descripción de
condiciones y pruebas definidas para él. Dentro de cada arco (lista) hay un “nombre de estado” y a continuación un
nuevo nivel de listas que define “posibles arcos”. Cada arco proporciona una lista de acciones a ser ejecutadas si el arco
es tomado. Las acciones son concluidas por una acción terminal (o símbolo).
Almacenamiento de la gramática.- es conveniente grabarla como una lista observando el mismo formato de entrada,
aplicando las funciones clásicas de acceso de listas del lenguaje LISP como CAR, CDR, Member, etc.
Tabla de comandos: Cada localidad tiene un nombre de comando distinto a la gramática alimentada al momento de ser
“analizada”, en función del índice que se le asigne será ejecutada por la función “case” construida en la segunda fase.
Gramática Texto de entrada
FASE 1
Compilador
Gramatical
FASE 2 Oración analizada
Gramatical Interpretador En sus componentes
estructurales
Gramaticalmente
Almacenada como
una lista
Gramaticalmente
Tabla de comandos Almacenada como
una lista
Gramaticalmente
Almacenada como
una lista
Gramaticalmente
Almacenada como
una lista
Figura. 4.12 Programa general para gramáticas tipo RTA
Tabla de nombres de estado, ATN y de registros.- son inicializados conforme la gramática es leída, identificando
fácilmente a cada tipo de elemento por su posición en la lista de la gramática de entrada, ya que:
Un nombre de estado es el “car” de cada conjunto de arcos (Q1,....

Los nombres ATN van seguidos por el “/”
Los nombres de registro ocurren en las declaraciones de acción y varía el lugar que ocupan acorde con el formato de la
instrucción: (SETR AUX &).
El formato de las tablas es idéntico, el nombre del estado, ATN o registro y su apuntador
Mientras que en la fase de “interpretación” la “clave” está en usar un proceso “case” para ejecutar los comandos
indexados por la tabla. También se emplea un “contador de localidad” para señalar el nodo a procesar, inicializándose al
comienzo de la gramática para actualizarse apuntando al siguiente nodo asignando el valor del “apuntador next” del
nodo que actualmente está procesando. Cuando un arco terminal es alcanzado (ya sea TO o JUMP) el nombre de estado
al cual se apunta será encontrado en la “tabla de estado” y el apuntador del nodo al que corresponderá será el nuevo
valor del contador de localidad.
Cada rutina de comando explota los parámetros requeridos de la gramática y llama a la rutina apropiada. Por ejemplo
“CAT” al determinar que categoría asociada es “verdad”, entonces las acciones del arco son ejecutadas, la acción
terminal causará el retorno de la rutina con el “contador de localidad” apuntando al siguiente nodo a ser ejecutado.
CAPÍTULO 5. PROCESO SEMÁNTICO
5. PROCESO SEMÁNTICO
5.1 Componentes: contexto, significado y relación
El contexto es el ámbito social en donde se circunscribe el lenguaje que se emplea (raza, país, religión,...) y por lo tanto
el significado particular que se asocia a sus elementos. Reconociendo que dentro de este marco existen otros dominios
más pequeños y específicos en función de ciertas particularidades (región, nivel cultural, área profesional, ámbito
familiar, actividad, edad,...). Por lo que el significado o valor real de un elemento o asociación del lenguaje va
íntimamente ligado al “contexto” en que es expresado y a quién va dirigido, tal como se ilustra en figura 5.1.
Lengua castellana
En México
Popular
En el norte
Eventos
Computación Medios
Figura. 5.1 Ejemplos de contexto en un lenguaje
El significado es el concepto, idea, fin, razón o conocimiento que está detrás del símbolo o expresión oral, que le
proporciona una “personalidad” específica dentro del contexto que usa, otorgándole “vida” y razón de existir. El
significado tiene atributos de:
Alcance.- universal, regional, ...

Tiempo.- permanente, largo, corto, de moda, ...
Contexto.- cultural, educacional, actividad, ...
Circunstancia.- necesidad, urgencia, rutinaria, guerra, …
Tipo de ser.- humano, animal, ...
Emisor.- funcionario, padre, niño, ...
Receptor.- empleado, hijo, ...
También debemos reconocer que al momento de “compilar” significados a expresiones verbales o escritas, surgen las
variantes de: sinónimos, homónimos, antónimos, acrónimos, modismos, etc., los cuales vienen a alterar el manejo del
lenguaje.
La relación, de igual forma que los elementos del alfabeto al permanecer separados entre sí no tendrían utilidad alguna,
tampoco lo sería para las palabras al estar aisladas unas de otras. Inclusive al formar frases y estar desunidas no
alcanzarían la riqueza expresiva de un texto. Por tal motivo, es conveniente concebir al lenguaje como un “sistema” con
elementos específicos e interrelacionados con el propósito de compartir conceptos.
Si bien la relación que guardan los caracteres del alfabeto para integrar “palabras” es observada en el subsistema de
análisis léxico y la asociación entre sujetos, verbos y objetos es evaluada por el análisis sintáctico; en el semántico se
cuida la correspondencia entre el contexto y el significado de cada elemento de la oración para atribuirle un valor
específico conforme a la naturaleza de la expresión. Este es en resumen el objetivo del analizador semántico.
5.2 Estudio de gramáticas semánticas

La teoría semántica fue concebida por Jerrold Katz y Jerry Fodor en 1964 cuando publicaron “La Teoría de la
Estructura de una Semántica” enfatizando la distinción de los niveles de análisis sintáctico del semántico, su pretensión
fue a través de la teoría semántica describir la “habilidad interpretativa” de las personas en consideración a su capacidad
para reconocer a los componentes de una oración, detectar anomalías en su significado e identificar asociaciones entre
las oraciones. Dicha teoría emplea dos componentes:
Diccionario.- a cada “Unidad Léxica” le acompaña una descripción fonológica, otra sintáctica y una semántica con sus
diversos significados.
Reglas de proyección.- generan distintas interpretaciones de la oración.
La descripción sintáctica usa “marcadores gramaticales” para identificar los posibles usos de una palabra, mientras que
la semántica incluye “marcadores semánticos” y “distinguidores” para hacer diferenciaciones esenciales de “rol” del
significado así como para describir a este, como se ilustra en la figura 5.2.
DRIVER COCINA ROJO
nombre adjetivo nombre verbo nombre adjetivo
Driver
NOTA:
( ) Marcador Gramatical
{ } Marcador Semántico
(nombre) (verbo) [] Distinguidor
{humano} {humano}
{ocasional} {profesional} {ejecutable} {configuración}

[capaz de manejar [ocupación: [instrucciones [declaraciones de
un vehículo cuya conductor de de cómputo] las características
ocupación no es la autos] de los recursos
de conducir autos] de cómputo]
Figura. 5.2 Ejemplo de marcadores usados en la teoría semántica
Los “marcadores semánticos” describen los elementos del lenguaje y se emplean al correlacionar el significado entre las
palabras, tal como se representa en la figura 5.3:
Proceso Semántico 69
marcador semántico:
requiere
VERBO: cantar palabra con
un sujeto
sujeto animado
Figura. 5.3 Ejemplo de marcadores semánticos
Pero si el único sujeto es la palabra “árbol” entonces será desechada la interpretación clásica del verbo, al menos que el
contexto de la oración sea el de un “cuento” entonces los “distinguidores” deberán estar descritos acordes con cada
contexto en los cuales la palabra puede ser protagonista, ofreciendo el sentido apropiado para cada uno de ellos,
clarificando las ambigüedades.
Las “reglas de proyección” comparan el significado de las palabras de una oración con los posibles significados de esta,
asociando los “marcadores semánticos” con los “distinguidores”, tal como se muestra en la figura 5.4:
THIS SUIT IS TOO LIGHT
El saco es de color claro Reglas de proyección El saco esta hecho de un material ligero
Interpretaciones
Figura. 5.4 Ejemplo de distinguidores
A este proceso de aplicación de reglas se le conoce como “rutas amalgamadas”, en el cual se genera un universo de
interpretaciones del significado para una oración, como se ilustra en la figura 5.5. El formato de las “reglas de
proyección” es equivalente al de las “reglas de producción”, compuesta de condiciones conjuntas que al cumplirse todas
emiten una conclusión específica “interpretación” equivalente a desarrollar un “espacio de estados” en donde se emiten
cero o varias interpretaciones finales, procurando alcanzar la “mejor” de la forma más económica posible.
THE MAN HITS THE COLORFUL BALL
Se generan interpretaciones
1. Colorful: Adjetivo, (color), [Abundancia A. Ball: Nombre, {actividad social},

de colores contrastantes]<(objeto físico) V [propósito de recreación a través del
(actividad social) > baile] < (Evento) >
B. Ball. Nombre, {objeto físico}, [forma

esférica de material ligero] < (juguete) V
(instrumento deportivo) >
2. Colorful: Adjetivo, (evaluativo), C. Ball. Nombre, {objeto físico},
[Distintos caracteres y expresiones]< [forma esférica de material pesado]
(objetos conceptual) v (actividad social)> < (armamento) >
Al continuar el proceso
de rutas amalgamadas
1.1 + A 11.1 + B 111.2 + A IV.2 + B

Al considerar que el verbo “hit” requiere un objeto con un “marcador semántico” {objeto físico}
II IV
Al considerar mas la naturaleza de “hit”
quedaría la interpretación
II
Figura. 5.5 Proceso de “Rutas Amalgamadas” en la interpretación de una oración
Las semánticas generativas propuestas por Fillmore, destacan la similitud entre la “estructura base” de una oración y
la “representación de su significado”, ya que al producirse la primera debe registrar todo el significado que sea posible
asociar, por lo tanto comienza con la representación del significado, lo interpreta para emitir la “estructura frontal” y
aplica las “reglas fonológicas” para arrivar a la representación fonológica. La “estructura base” contiene los
componentes esenciales pero no necesariamente las palabras que aparecerán en la “estructura frontal”.
Por ejemplo, la palabra “nacer” será base tipo: “causa”, “llegar a ser”, “vivir”, “crear”, ... dicha situación “léxica” será
una de tantas transformaciones aplicadas durante la generación de una oración como se aprecia en la figura 5.6:
Frase Marcada (Estructura base) Frase Frontal
“We exterminated Whales” “We caused whales to become dead”

“We caused whales to die”
S
S
NP VP
NP VP
We V NP
We V NP
cause S
cause V whales
NP VP
become V
S V
dead
NP VP become
whales Mod V
not alive
Figura. 5.6 Frases emitidas por una Semántica
Generativa
Estas semánticas observan las similitudes entre ciertos adjetivos y verbos, como por ejemplo:
El metal esta duro | El metal endureció

The sauce is thick | The sauce thickened
Estas semejanzas pueden explicarse por las transformaciones léxicas que se aplican, como en el ejemplo de las figuras
5.7 y 5.8, donde se muestra la progresión desde el más bajo nivel de la estructura base hasta su mas alto nivel. En esta
interpretación thicken significa llegar a hacerse thick, la cual se indica por la combinación del significado “thick” y las
características del verbo [+ PRO] e [+ INCHOATIVE], o progresivo e inicial o formativo. Dicho de otra manera, la
oración expresa que la “sauce thickens” ( ) transformándose paulatinamente desde un estado inicial al estado del ser
"thick".
FN AUX FV
S PASADO V
+V
For the sauce
To be thick + PRO
+ INCHOATIVE
Figura. 5.7 Frases marcadas por una Semántica Generativa

FN AUX FV S
ART N PASADO V
For to be thick
+V
the sauce
+ PRO
+ INCHOATIVE
FN AUX FV
ART N PASADO V
thicked
the sauce [+ INCHOATIVE]
Figura. 5.8 Frases marcadas por una Semántica Generativa, de “ The sauce thickened”
5.3 Análisis de gramáticas Case DCGS semánticas

En 1967 Charles Fillmore presentó el trabajo intitulado “Un caso para un caso” donde ofrece una “estructura case” para
nombres y pronombres mostrando la relación de una palabra con otras, conforme a la siguiente clasificación:
Agente.- se emplea para el sujeto, predicado nominativo o un nombre ligado al sujeto por un verbo copulativo. “Aquel
pollo tiene una lombriz”
Instrumental.- fuerza inanimada u objeto envuelto en la acción. “Juan le pego al niño con un balón”
Posesivo genitivo.- muestra membresía o pertenencia. “El auto rojo de Carlos”
Localidad: Indica el lugar u orientación espacial de la acción. “El policía disparó hacia arriba”
Objetivo.- usado para nombres y pronombres que correspondan al objeto del verbo en forma directa. “La pelota rompió
el vidrio”
Dativo.- aplicada para objetos indirectos que resultan afectados por la acción. “María prestó a Lourdes su vestido”
Neutral.- es el objeto sobre el que se actúa. "Juan puso el vaso sobre la mesa”
Su énfasis se orienta a la estructura básica de una oración compuesta de un verbo y una o más frases nominales; cada
una asociada a una particular relación “case”:
Oración ---------> Modalidad + Preposición

Modalidad ---------> Modo, Tiempo, Aspecto, Forma, Esencia, Momento, Manera, Modales
Preposición ---------> V+C1+C2+...+ Cn
La preposición es el verbo acompañado de uno más estructuras “case” distintas.
V ---------> Correr beber, amar, ....
Ci ---------> K + FN
K ---------> (preposición)
FN ---------> (preposición) + ( Art) + (Adj | N)* + N + (oración | FN)
Donde * significa repetición, ( opcional, | alternativo.
Por ejemplo, la figura 5.9 ilustra la aplicación de la estructura a una oración:
“Peter will not steal the dog”
Modalidad “Peter steal the dog”
Negativa Verbo C1 C2
Futuro
Declarativo
steal Peter the dog
Figura. 5.9 Representación de una oración por medio de una Gramática Case.
La modalidad de la oración es definida por la combinación de varios modos, que individualmente identifican un aspecto
de la frase verbal de acuerdo a los siguientes criterios:
Tiempo.- presente, pasado, ...
Aspecto.- agrega valor al tiempo indicando si la acción es continua: perfecto “El niño esta llorando” o si ha sido
completada imperfecto “La niña estuvo cantando”
Forma.- agrega información de la intensidad del verbo: simple “El perro ladra”, estática “Ella si esta trabajando” y
progresiva “Los muchachos están jugando”
Modo.- expresa la naturaleza de la oración: declarativa, interrogativa,..
Esencia.- muestra el sentido de la oración: positiva “El niño juega”, negativa “Carezco de dinero” e indeterminada
“quizás llueva”
Modales.- son los verbos auxiliares: he, has, hube,...
Manera.- indica partes adverbiales de la oración: “El señor cerró la puerta fuertemente”
Momento.- señala el tiempo en que ocurre la acción: “Juan tomó el vuelo a la última hora”
Los mecanismos que identifican los específicos “cases” adecuados para un verbo se conocen por “Case Frames” e
indican cuales estructuras son “no permitidas”, requeridas y opcionales; como se muestran en los siguientes ejemplos y
figuras 5.10 y 5.11:
Abrir [Objetivo (Agente) (Instrumental)]
Juan abrió la puerta A: Juan

O: La puerta
La llave no abrió la puerta I: La llave
O: La puerta
Juan abrió la puerta con la llave A: Juan
I: La llave
O: La puerta
Golpear [Objetivo (Instrumental) (Agente)]
Acusativo: Pedro golpeó al niño con el balón
M P
Pasado
Declarativo Verbo Agente Instrumento Objetivo
Simple
Negativa
Indeterminada
golpear Pedro el balón al niño
Figura. 5.10 Representación de oraciones acusativas por medio de “Case Frames”
Dar [Objetivo (Agente) (Dativo)]

Dativo: María le dió su libro a Raquel en agradecimiento
M P
Pasado
Imperfecto
Simple Verbo Agente Dativo Objetivo
Declarativa dar
Positiva
María Raquel su libro agradecimiento
Figura. 5.11 Representación de oraciones dativas por medio de “Case Frames”
Los verbos se asocian a “case frame” por medio de un identificador en el diccionario, donde un mismo “case frame” se
puede aprovechar para varios verbos. Las preposiciones ayudan a expresar la relación entre el verbo y la frase nominal,
en el idioma inglés se reconocen preposiciones específicas para cada estructura “case”.
By Agente
By o With Instrumental
To Agente
At, on, in Localidad
Of, from Posesivo
Aunque no es indispensable que exista una preposición para ayudar a identificar al tipo de estructura, como se muestra
en las siguientes 5.12 y 5.13.
La generación de oraciones que emplean “estructuras case” aplican 3 reglas:

Sujeto.- si el “case” mas a la izquierda del “case frame” es obligatorio, debe ser entonces el sujeto
Objeto.- los objetos no tienen preposiciones y debe situarse el “case” en el extremo derecho del “case frame”
Frases Preposicionales.- los “cases” restantes son agregados en función al tipo de preposición
Mientras que el análisis de oraciones procura identificar los “cases” correspondientes a las preposiciones y comenzar a
“llenar” los “huecos” del “case frame” correspondiente al verbo. Por ejemplo, al interpretar la oración:
“Juan rompió el vidrio con el balón” , se haría el siguiente tratamiento:
La preposición “con” identifica “el balón” como un case tipo “instrumental”

Para identificar el sujeto y objeto de la frase no hay preposiciones que auxilien, por lo que se usa el conocimiento
asociado a las palabras en sus unidades léxicas y evalúan el tipo de sujeto asociado al verbo de la oración, que en este
caso debe ser un ente animado
Por lo tanto, si la FN que precede al verbo es de un ser animado, se puede asumir que se trata del “agente”, entonces la
FN que sigue al verbo será el “objeto”
Pero si dos frases nominales siguen al verbo, la primera es el objeto y la segunda el instrumento
Si no existe el ”agente”, el “instrumental” puede ser el sujeto en una oración activa
“Alguien golpeó la puerta con el balón” (Voz activa)

M P
V C1 C2 C3
golpear
K Agente K Inst K Objeto
nil alguien con el balón nil la puerta
Figura. 5.12 Representación de oraciones en voz activa
“La puerta fue golpeada con el balón por alguien” (Voz pasiva)
M P
V C1 C2 C3
golpear
K Agente K Inst K Objeto
por alguien con el balón nil la puerta

Figura. 5.13 Representación de oraciones en voz pasiva
5.4 Aplicación de redes semánticas

Una red semántica es un tipo de estructura de ranura y relleno, resulta adecuada para soportar la herencia a lo largo de
los enlaces ”es – un” e “instancia”. La herencia monótona se puede manejar mejor con este tipo de estructura que con la
lógica pura, y la herencia no monótona puede soportarse muy fácilmente. La razón por la que la herencia se ejecuta de
un modo sencillo, es que en los sistemas de ranura y relleno el conocimiento está estructurado como un conjunto de
entidades acompañadas por sus atributos. Esta estructura tiene una gran utilidad además de soportar la herencia, por las
siguientes razones:
Indexa los predicados binarios en función de su primer argumento

Describe las relaciones de las propiedades fácilmente
Se implementa mediante la programación orientada a objetos
A continuación se describe el enfoque de redes semánticas, sus representaciones y las técnicas para razonar con ellas. A
este tipo de estructura se le conoce como de “relleno fuerte”, ya que se establecen compromisos en la relación con el
contenido de las representaciones.
Una de las primeras formas de usar las redes semánticas fue para encontrar relaciones entre objetos, dividiendo la
activación a partir de cada uno de los dos nodos, observando donde se encontraba dicha activación. Este proceso se
llamó búsqueda de intersección. Con este proceso es posible usar la red de la figura 5.14 de manera que se puedan
responder preguntas tales como ¿Cuál es la conexión entre Brooklyn Dodgers y azul?.
Esta clase de razonamiento utiliza una de las grandes ventajas de las estructuras de ranura y relleno sobre las
presentaciones puramente lógicas, ya que tienen la ventaja de organizar conocimiento en función a las entidades que
proporcionan las representaciones de ranura y relleno.
Mamifero
es-un
tiene-parte
Persona Nariz
instancia
equipo
azul Pee-Wee-Reese Brooklin-Dodgers
Figura. 5.14 Red semántica “binaria”
Las redes semánticas se pueden considerar como un modo natural de representar las relaciones que podrían aparecer
como instancias de los predicados binarios en la lógica de predicados. Por ejemplo, algunos de los arcos de la figura
anterior se podrían representar en lógica como :
es-un (Persona, Mamífero)
instancia (Pee-Wee-Reese, Persona)
equipo (Pee-Wee-Reese, Brooklyn-Dodgers)
color-del-uniforme (Pee-Wee-Reese, Azul)
También el conocimiento expresado en predicados de mayor aridad, se puede expresar en redes semánticas. Así por
ejemplo: hombre(Marco) se podría reescribir como: instancia(Marco, hombre) y de este modo es mucho más fácil
hacer la representación en una red semántica.
Los predicados de tres o más argumentos también pueden convertirse a forma binaria creando un nuevo objeto que
represente todo el predicado, y después introduciendo predicados binarios para describir la relación con este nuevo
objeto de cada uno de los argumentos originales. Supóngase que se sabe: marcador(Cubs, Dodgers, 5-3) Se representa
en una red semántica creando un nodo que muestre el juego específico G23 y se relacionan las tres partes de la
información con dicho nodo. La figura 5.15 muestra la red que surge al hacer esto.
PARTIDO
Equipo_visitante Es un
Marcador
CUBS G23 5-2
Equipo Local
DODGERS
Figura. 5.15 Red Semántica “n-aria”
Esta técnica es útil para representar los contenidos de una oración declarativa típica que describa distintos aspectos de un
evento en concreto. La frase “Juan le dio el libro a Mary” Se podría representar por medio de una red como la que se
muestra en la figura 5.16, en donde el nodo etiquetado como LB23 representa el libro concreto al que se refiere la frase
“el libro”, descubrir el libro concreto al que se refiere la frase es similar al problema de decidir el antecedente correcto
de un pronombre, y puede ser un problema muy complicado. De hecho, algunas de las primeras aplicaciones de las redes
semánticas fueron en programas de comprensión del inglés.
Dar Libro
agente Es un
objeto
Juan EV7 LB23
beneficiario
Mary
Figura. 5.16 Red semántica “relacional”
En las redes que se han descrito hasta ahora se han hecho comentarios sobre distinciones que son importantes en el
razonamiento. Por ejemplo, debería haber una diferencia entre un enlace que defina una nueva entidad y otro que
relacione dos entidades ya existentes, tal como lo muestra la figura 5.17:
altura
JUAN 1.72
Figura. 5.17 Relación de entidades

Ambos nodos representan objetos que existen independientemente de la relación que pueda existir entre ellos. Pero
ahora supóngase que se desea modelar el hecho de que “Juan” es más alto que “Bíll”:
JUAN BILL
altura altura
mayor-que
A1 A2
Figura. 5.18 Representación de objetos
Los nodos Al y A2 son dos nuevos conceptos para representar la estatura de “Juan” y la estatura de “Bill”
respectivamente; están definidos por sus relaciones con los nodos “Juan” y “Bill”. Utilizando estos conceptos definidos
es posible representar algunos hechos como el aumento de la estatura de “Juan”, que antes no se podía hacer.
(¿aumentaría el número 1.72?). Algunas veces resulta útil introducir el arco valor para hacer más clara esta distinción,
así se podría utilizar la siguiente red para representar que “Juan mide 1.72 m y que es más alto que Bill”, tal como
aparece en la figura 5.19:
JUAN BILL
altura altura
mayor-que
A1 A2
valor
1.72
Figura. 5.19 Representación de comparaciones
Los procedimientos que operan en redes como estas pueden utilizar el hecho de que algunos arcos (como por ejemplo
estatura) definen nuevas entidades, mientras que otros (como más grande que y valor) únicamente describen relaciones
entre entidades que ya existen.
Otro ejemplo de una importante distinción que se ha ignorado es la diferencia entre las propiedades de un nodo en sí
mismo y las propiedades que un nodo únicamente sostiene y pasa a sus instancias. Por ejemplo, una propiedad del nodo
“persona” es el hecho de que es una subclase del nodo “mamífero”. Pero el nodo “persona” tiene como una de sus partes
una raíz. Las instancias del nodo “persona” si la tienen, y lo que se quiere es que la hereden.
Es difícil capturar estas distinciones sin asignar más estructura a nuestras nociones de nodo, enlace y valor. Sin embargo,
si ejemplificamos una solución orientada a redes semánticas para un problema más sencillo; se puede ilustrar lo que se
hace en un modelo de red, teniendo en cuenta el costo y la complejidad, pero esto ya es otro apartado.
La herencia simple ofrece una ventaja de las redes semánticas es apropiarse de las características de un objeto por otro
que esta relacionado con él a través de un arco tipo “is-a”, “a kind of ” o “a instance of ”, tal como se ilustra en la figura
5.20:
nace, crece,
SER VIVO reproduce y muere
is-a
procreado en óvulo
procreado
a-kind-of ANIMAL VEGETAL
en semilla
nace en
a-instance- MAMIFERO OVIPARO nace en huevo

of
PERRO guardia GATO trepado
Figura. 5.20 Herencia Simple
El gato aprovecha las características de los mamíferos, es decir nace en placenta al igual que el perro es procreado en
óvulo y por lo tanto, de la misma forma que las aves y las plantas crecen, reproducen y mueren.
Mientras que la herencia múltiple es considerada en los casos en los cuales un objeto puede aprovechar propiedades de
otros, tal como aparece en la figura 5.21, en donde la red ilustra un patrón clásico de muchos estudiantes a nivel
licenciatura: jóvenes, practicantes de algún deporte, solteros y que se las ingenian para trabajar.
JOVEN DEPORTISTA TRABAJADOR HIJO DE FAMILIA
Edad 16-28
Juega ocupación empleado soltero
Basket-
Ball
is-a
ESTUDIANTE DE PROFESIONAL
Figura. 5.21 Herencia Múltiple
Las excepciones, hay situaciones en que no deben ser apropiadas las características de otro objeto a pesar de la
herencia, por lo que dichas propiedades deberán especificarse explícitamente en el objeto que presenta la excepción,
como se ilustra en la figura 5.22:
Mamifero ((Nace en placenta) . . . )
is - a
Ornitorrinco ((Nace en huevo) . . . )
Figura. 5.22 Representación de excepciones
La propiedad “nace en” asignada al los “mamíferos” no se asocia al objeto “ornitorrínco” ya que este cuenta con la
propia, y se da preferencia a ella.
5.5 Manejo de dependencia conceptual

La dependencia conceptual (CD), es una teoría enfocada a representar el tipo de conocimiento de los eventos que
normalmente aparecen en las frases de lenguaje natural, facilitando extraer inferencias de ellas con independencia del
lenguaje en el que estén expresadas.
La representación en CD de una frase no se construye con las primitivas que corresponden a las palabras que aparecen
en la frase, sino con “primitivas conceptuales” que pueden combinarse para formar el significado de las palabras de
cualquier lenguaje concreto. La figura 5.23 muestra un ejemplo de la forma en que se representa el conocimiento en CD
para la frase “le di un libro al hombre".
P 0 R hombre
P o
ATRANS libro de
I
Figura. 5.23 Una sencilla representación en Dependencia Conceptual
Donde los símbolos tienen los siguientes significados:

Las flechas.- indican direcciones de la dependencia.
Las flechas dobles.- señala los tipos de enlaces entre el actor y la acción
P tiempo pasado.
ATRANS es una de las acciones primitivas utilizadas por la teoría, indica una transferencia de posesión, muestra la
relación OBJECT CASE
R ilustra la relación RECIPIENT CASE.
En CD las representaciones de las acciones se construyen a partir de un conjunto de acciones primitivas. Un conjunto
típico de primitivas tomado de Schank y Abelson (1977) es el siguiente:
ATRANS.- transferencias de una relación abstracta (p. ej., dar)
PTRANS.- transferencia de una localización física de un objeto (p. ej., ir)
PROPEL.- aplicación de fuerza física a un objeto (p. ej., empujar)
MOVE.- movimiento de una parte del cuerpo por su dueño (p. ej., patear)
GRASP.- asimiento de un objeto por un actor (p. ej., empuñar)
INGESTA.- ingestión de un objeto por parte de un animal (p. ej., comer)
EXPEL.- expulsión de algo del cuerpo de un animal (p. ej., llorar)
MTRANS.- transferencia de información mental (p. ej., decir)
MBUILD.- construcción de información nueva a partir de la vieja (p. ej., decidir)
SPEAK.- producción de sonidos (p. ej., hablar)
ATTEND.- concentración de un órgano sensorial hacia un estímulo (p. ej., escuchar)
Un segundo conjunto de bloques construidos de CD es el conjunto de las dependencias permitidas entre las
conceptualizaciones descritas en un frase, existen 4 categorías conceptuales primitivas a partir de las cuales se pueden
construir estructuras de dependencia. Estas son:
ACTs acciones
PPs Objetos (productores de imágenes)
Aas Modificadores de acciones (asistentes de acciones)
Pas Modificadores de PPs (asistentes de imágenes)
Las estructuras de dependencia son conceptualizaciones y serven como componentes de estructuras de dependencia más
grandes. En las figuras 5.24 y 5.25 se proporciona una lista de las estructuras más importantes empleadas en la CD,
mostrando los símbolos que emplean, un ejemplo de su aplicación y la oración en lenguaje natural que representan.
P
John PTRANS John corrió
1 PP ACT
PP PA John altura(>media) John es alto

2
3 PP PA John doctor John es un

doctor
PP niño
Un niño
4 agradable
PA agradable
PP perro
El perro de
5 Poseído-por john
PA John
o o
carrito John empujo
6 Act PP John PROPEL
el carito
Figura. 5.24 Primitivas de la Dependencia Conceptual (grupo1)
En la figura 5.26 muestra un ejemplo del uso de estos tiempos cuya frase tomada es “como fumar puede matarte, lo
deje. Las conceptualizaciones que representan eventos pueden modificarse de varias formas para aportar información a
un frase conforme al tiempo verbal, cuyas variantes son:
p pasado f futuro
t transición ts transición de comienzo tf transición finalizada
k continuación
? interrogativa / negativa
nil presente delta atemporal
c condicional
R PP o R Joh
ATRANS John le
7 Act John
cogió el libro
Mary a Mary
PP o
libro
Joh
I P I
8 Act John INGEST John se
comió el
o hacer helado con
la cuchara
helado o
cuchara
o D campo
P
9 PP John PTRANS John
P saco fertilizo el
o
fertilizante
D PP D tamaño > x
plantas Las plantas
10 Act
crecieron
PP tamaño = x
ayer
John corrió
John PTRAN ayer
11
P
12 Escuchó una
rana en el
bosque bosque
o R C
MTRANS niñ
oídos
Figura 5.25 Primitivas de la Dependencia Conceptual (grupo2)

c R uno
uno INGEST humo
cigarrillo
c R 1
INGEST humo
muerto cigarrillo
uno
vivo
Figura. 5.26 Uso de los tiempos conceptuales
En el enlace vertical de causalidad indica que “fumar mata”. Sin embargo, está marcada con “c”, sabemos sólo que
fumar puede matar, no que necesariamente lo haga. El enlace horizontal de causalidad indica que la primera me hace
dejar de fumar la cuantificación “tfp“ asignada a la dependencia entre “I” en “INGEST” indican que fumar (una
instancia de “INGEST”) ha acabado y que esto ocurrió en el pasado.
Las representaciones sólo necesitan usarse una vez por cada primitiva ACT, en lugar de una ocasión por cada palabra
que describe este ACT. Por ejemplo todos los verbos siguientes implican una transferencia de posesión de un objeto:
Dar, Tomar, Robar, Donar.
Las inferencias sobre quién posee un objeto actualmente y sobre quién los poseyó antes, puede ser importante. En una
representación de CD estas posibles inferencias pueden establecerse una vez y asociarse con la primitiva ACT
ATRANS.
Para construirla no sólo debe utilizarse la información que explícitamente se establece en una frase, sino que también
debe emplearse las inferencias asociadas con la información específica. Una vez aplicadas, se almacenan los resultados
como parte de la representación y por lo tanto pueden utilizarse repetidas veces. Por ejemplo en la fig. 5.27 se considera
la frase: “bill, amenazo a john con romperle la nariz”.
John Bill
Bill nariz
poseída-por
P
Bill M TRANS John
C hace rota
John cree
John hace
Bill hace
nariz rota
poseída-por
John
Figura. 5.27 La representación en Dependencia Conceptual de una amenaza.
La representación dice “Bill” informó a “John” de que él hará algo para romperle la nariz de “John”. “Bill” hizo esto de
forma que “John” creerá que si él hace alguna otra cosa (diferente de lo que “Bill” hará para romper su nariz), entonces
“Bill” romperá la nariz de “John”. En esta representación, la palabra “creé” se utiliza para simplificar el ejemplo. Pero
la idea que hay debajo de “creé” puede representarse en CD como un MTRANS de un hecho en la memoria de “John”.
Las acciones “hace 1” y “hace 2” son poseedores postizos que se refieren a algo como acciones aún no especificadas.
Los elementos no especificados por la representación de una parte de información pueden utilizarse como un centro de
atención para la comprensión de eventos posteriores conforme se van produciendo. Por ejemplo después de escuchar que
“Bill” amenazó a “John” con romperle la nariz. Podríamos esperar averiguar que acción está intentando evitar “Bill”
que “John” lleve a cabo. Esta acción se podría sustituir por la postiza “hacer 2” representada en la figura 5.27. La
presencia de estos objetos postizos da pista sobre por ejemplo que otros objetos o eventos son importantes para
comprender el caso de estudio.
5.6 Implementación de un esquema de tratamiento semántico

El subsistema semántico debe aprovechar el trabajo, estructuras de datos y de significado que los módulos predecesores
generan en su labor: unidades léxicas y estructuras de soporte de la frase, así como las “estructuras temporal fuente”, “el
diccionario” y “estructuras transformacional” y “frontal” como se aprecia en la figura 5.28.
El desarrollador debe elegir cuidadosamente los procedimientos y estructuras de datos para implementar el subsistema
de “análisis semántico” insistiendo en concebir la aplicación como un proceso de “búsqueda” en donde a partir de los
resultados emitidos por los analizadores léxico y sintáctico se generan diversas trayectorias para derivar la interpretación
más adecuada tanto a las palabras como al texto, tal como se indica en la figura 5.29.
Cada interpretación del texto inferida crea su propia “estructura semántica” para la oración y cada una de sus palabras
actualizando inclusive las definiciones y contenidos registrados en las “unidades léxicas”, “estructuras temporales
fuente” y la “estructura frase”, de ser necesario a efecto de conservar congruencia con ellas.
Esto último implica la replica de las definiciones originales para producir tantas versiones como interpretaciones
distintas se generen, y para ello, al considerar al “contexto” limitaría la explosión de significados derivados al permitir la
producción de aquellos que satisfagan los requerimientos.
Análisis Análisis Análisis

Texto
Léxico Sintáctico Semántico
Unidades Estructura de Estructura del

Léxicas la frase Contexto
Estructura de Estructura de
la frase la frase
Estructura
Temporal
Fuente
Estructura de Estructura de
la frase la frase
Atributos de Redes
Diccionario frase marcadas Semánticas.
Marcos.
D. Concep
Flujo de Datos
Representación
Semántica
Subsistema
Estructura de Datos
Base de Datos
Figura. 5.28 Esquema de integración de un SLN

CONTEXTO TEXTO
Definición
UL1 UL2 ... ULN
UL Unidad Léxica (Estructura de la frase)

IS Interpretación Semántica
( ) Estructura de la Oración
[ ] Estructura de Conocimiento
IS1 IS2 ISm

Estructura Semántica Estructura Semántica Estructura Semántica
Figura. 5.29 Generación del significado para una frase

CAPÍTULO 6. PROCESO DE LA INTERPRETACIÓN
6. PROCESO DE LA INTERPRETACIÓN
6.1 Descripción del análisis pragmático
Al reconocer que el módulo de “Interpretación” forma parte de un sistema de lenguaje natural es importante identificar
el rol de los módulos que le acompañan y que cuyos resultados en el procesamiento de texto deberá aprovechar o
proveer. Por ejemplo la oración: “I want to print Bill’s doc file”
Al ser procesada por el subsistema de análisis sintáctico arroja el árbol ilustrado en la figura 6.1:
S
(RMI)
FN FV
V S
PRO (RM3)
l WANT FN FN
(RM2) (RM4)
(RMI) (RMI) FN
l BILL’S ADJS N
(RMI) (RMI)
DOC FILE
Figura. 6.1 Resultado Del Análisis Sintáctico
El subsistema del análisis semántico al hacer su función de:
Mapear palabras individuales en objetos apropiados de la base de conocimientos

Crear las estructuras correctas que correspondan al significado de las palabras individuales combinadas entre sí
Emplea una base de conocimientos que contiene “frames” para objetos los cuales tienen la siguiente descripción:
User.-
isa: persona
nombre: debe ser <string>
User: 068
instance: User
nombre: Susan
User: 073
instance: User
nombre: Bill
File - Struct
isa: Informatión - Object
F1:
instance: File - Struc
nombre: carta
extensión: doc
owner: User 073
en-directorio: / Bill /
Printing:
isa: Evento Físico
*agente: debe-ser (animado y programa)
*objeto: debe-ser (información - objeto)
Wanting:
isa: Evento Mental
*agente: debe-ser (animado)
*objeto: debe-ser (estado o evento)
Commanding:
isa: Evento Mental
*agente: debe-ser (animado o programa)
*ejecutante: debe-ser (animado o programa)
*objeto: debe-ser (evento)
This - System:
intance: Programa
A partir del cual se genera el significado de los elementos de la oración en forma congruente a la base de conocimientos
de acuerdo con la siguiente descripción:
RM1 { La oración completa }

instance: Wanting
agente: RM2 {I}
objeto: RM3 { un evento de impresión}
RM2 {I}
RM3 { un evento de impresión }
instance: Printing
agente: RM2 {I}
objeto: RM4 { Bill’s .doc file }
RM4
instance: File-Struct
extensión: doc
owner: RM5 { Bill }
RM5
instance: Persona
nombre: Bill
Los marcadores de referencia “RM” corresponden al evento de más alto nivel de la oración. Hay un evento de “querer”
en el quién habla (identificado como “ I ”) desea que una acción de “impresión” ocurra, donde el mismo se encarga de
imprimir un archivo con extensión “doc” cuyo propietario es “Bill”. Con estos elementos el subsistema de interpretación
procura discernir el tipo de oración a la cual se refiere el texto y también identifica a los individuos relacionados ( “ I ”, “
Bill ”, “ doc ” ).
Por medio del análisis pragmático se buscan las respuestas a dichas interrogantes, haciendo uso de un modelo de
discurso con base al contexto al que pertenece, desde el cual pueda relacionar que el usuario identificado por el
pronombre “I” es la instancia “User 068” y que la única persona a la que se refiere el nombre propio “Bill”
corresponde a el objeto “User 073”. Una vez que la referencia correcta para “Bill” es conocida, se puede determinar que
archivo está siendo referenciado a “F 1” al ser el único con extensión “doc” y cuyo propietario es “Bill ”.
Una vez completada la descripción en términos de congruencia con la base de conocimientos empleada se prosigue al
paso final del proceso de “interpretación” que es: “decidir que hacer como resultado de la oración evaluada”, o sea
debemos reconocer su interpretación.
Una estrategia es registrar lo expresado como un hecho y que se hará con él, por lo que se deben reconocer oraciones
declarativas, de las imperativas, interrogativas o negativas. Para descubrir su naturaleza se pueden aplicar reglas que
caracterizan diálogos cooperativos.
En el ejemplo que se está desarrollando, se usa el hecho que cuando el usuario expresa lo que quiere hacer y que el
sistema es capaz de realizar, entonces el sistema debería ir adelante y hacerlo, produciendo el significado final, tal como
se muestra a continuación:
Significado:
instancia: Commanding
agente: User 068
ejecutante: This-System
objeto: P2 7
P27
instancia: Printing
agente: This-System
objeto: F1
El paso final en el análisis pragmático es traducir (cuando es necesario) desde la base de conocimientos a la
representación adecuada que implemente la acción que corresponda a la “intención” de la oración, como en este caso
sería la emisión del comando: Lpr /bill/carta.doc
6.2 Complejidad en el proceso y entendimiento

Para interpretar una oración sencilla es indispensable tomar en cuenta el contexto en que se expresa. Cuanto más
importante resulta considerarlos al tratarse de textos y diálogos que deben ser interpretados. Por lo que se requieren
advertir distintos tipos de relaciones que ligan frases y partes del discurso, como son las siguientes:
Entidades idénticas.- observar el ejemplo, “Juan habló con María, le dijo que la quería”. Al considerar el uso de
referencias “anafóricas” se obtienen los siguientes elementos:
le ==> Juan
dijo ==> Juan a María
la ==> María
quería ==> Juan y María
Parte de las entidades.- una oración puede usar entidades que pertenecen a otras que fueron expresadas en otras
oraciones: “Rubén estrena casa, en el jardín hay muchos árboles”
Parte de las acciones: un evento está ligado con otros: “Pedro jugó el domingo y anotó dos goles”
Elementos de conjuntos.- integrantes de un grupo expresado participan en otra oración: “Los empleados de la fábrica se
declararon en huelga, el líder del sindicato lo anunció ayer”
Nombres propios.- cada uno de ellos representa a una instancia de cierta clase de “entidades”: “Juan corre rápido” y
“Montreal es una ciudad bilingüe”
Ligas casuales.- un evento se asocia con otro: “Hubo un alto índice de contaminación ayer, hoy los carros con
calcomanía color rojo no circulan”
Secuencia de eventos.- Son acciones que ocurren cronológicamente: “José invitó a cenar a su novia” y “pagó con su
tarjeta de crédito”
Forzar eventos.- Una acción anima a realizar otras: “Jaime le dice a su mamá que tiene hambre”
Asumir condiciones y estados.- de manera implícita se hace referencias a ciertas a condiciones y atributos de los
protagonistas: “Dame un beso”. El hombre pide a una mujer, son novios,...
Para que el sistema sea capaz de reconocer estas clases de relaciones entre las oraciones, debe usar una gran cantidad de
conocimiento ordinario, del lenguaje y del contexto en que se expresa el discurso y sus oraciones. Las aplicaciones que
interpretan múltiples oraciones deben usar gran cantidad de conocimiento y limitar estrechamente las condiciones del
dominio al que pertenece el discurso.
6.3 Estudio de la técnica sobre “Espacio de enfoques”

El empleo de la “atención” facilita la interpretación de texto es útil identificar aquellas partes que “llaman la atención”,
como frases, palabras o símbolos clave. Por ejemplo al observar el siguiente texto:
Contexto: “instalación del Sistema Operativo Unix”; primero “booteas” con el disco de arranque, después eliges una
instalación “fresh” y proporcionan los parámetros de: medios, tarjeta de red, monitor, teclado, mouse y C.D. ! No
olvides respaldar el contenido original del disco, pues sí perderá!
Destacan los siguientes elementos:

Frase: Instalación del Sistema...
Palabras: “Primero”, “después”, “y” (indican la secuencia de procedimiento) “booteas” (palabra clave que indica una
acción indica una acción técnica a realizar) “fresh” (palabra clave que indica a partir de cero la instalación), “perderá”
(alarma).
Símbolos: ¡ ! Llamar la atención.
Tales elementos son representados en la base de conocimientos de una manera apropiada para que a partir de ellos se
generen búsquedas que infieran:
La información faltante, no expresada en la oración que se maneja implícitamente o se expresa en otra parte del discurso
Precisar a que objeto específico se está haciendo referencia por medio de los nombres propios, pronombres, adjetivos,...
Identificar el tipo de oración y sobre todo su intención
El modelo de creencias es un concepto abstracto que pretende “caracterizar” la naturaleza y rol de las entidades y de
sus interrelaciones con otras, además de representar estados y eventos que particularizan una situación dada. En un
sistema durante la fase de “interpretación” se puede generar modelos de creencia del dominio, discurso y frase que está
siendo evaluada.
También existen variantes del modelo de creencia de lo que considera el propio sistema sobre el tema, lo que supone que
se imagina el usuario al respecto, lo que se pudiera el usuario pensar que el sistema considera,... y así sucesivamente.
Para generar modelos es útil clasificarlos en 2 partes: aquellas creencias comunes entre los protagonistas y las que son
individuales:
Modelos de creencias compartidas se representan como “hechos” (verdades generales) en la base de conocimientos,
así como por medio de “frames” y “scripts”. Estos últimos se aplican para ilustrar situaciones estereotipadas, dirigir la
búsqueda o inferencia de información faltante e ilustrar razonamiento monotónico
Modelos de creencias individuales: Se pueden implementar por medio del uso de la “lógica modal” quien está
interesada en los diversos “modos” en que una acción puede ser “verdadera” y el momento (pasado, presente,
futuro,...) en que se le asocia dicho valor o falsedad bajo circunstancias específicas que pudieran presentarse, al llegar a
ocurrir (“lógica condicional”). Estas clases de lógicas representan el valor de verdad concerniente a creencias,
conocimiento, deseos, intenciones y obligaciones, que pudieran ser falsas injustificadas, insatisfechas, irracional o
contradictorias. Proporcionan medios para interpretar variantes del lenguaje que involucran referencias a otros tiempos,
circunstancias y estados mentales de la gente.
Se utiliza el operador modal “BELIEVE” que permite representar afirmaciones de la forma: BELIEVE (A,P) la cual es
verdadera siempre y cuando “A” crea que “P” es verdadera, a pesar de que “P” pudiera ser creída como falsa por otra
aserción. También se usa el operador KNOW-WHAT (A,P) el cual es verdadero si “A” conoce el valor de la función
“P”.
Otra forma de representar creencias individuales es particionar la base de conocimientos para organizar las creencias
compartidas separándolas de las individuales. Las primeras creencias no deben duplicarse en la representación, pero las
individuales se registrarán por separado por cada personaje involucrado.
A través del uso de redes semánticas particionadas se puede representar tales requerimientos, como se ilustra en la figura
6.2, donde aparecen tres espacios de creencias:
S1 cree que María golpeó a Bill

S2 cree que Silvia golpeó a Bill
S3 cree que alguien golpeó a Bill
6.4 Análisis del método de dirección por metas

Otra técnica que ayuda a interpretar el sentido del texto evaluado es el reconocer la intención que el protagonista
persigue alcanzar “meta” y el “plan” que considera aplicar para lograrla. Por ejemplo, en el texto: “Juan quiere
comprar una P.C. para su hijo”
Se reconoce:
Meta: El hijo de Juan tiene su P.C.

Plan: Compuesto de los subplanes:
Juan ahorra dinero
Juan investiga opciones
Juan compra cotizaciones
Juan elige
Juan adquiere la P. C.
Entre las metas comunes redactadas en historias, reportajes y libros están:
Satisfacción de necesidades.- comer, trabajar,...

Conquista de deseos.- amar, cantar,....
Logro de objetivos.- titularse, adquirir, conquistar, ...
Preservación de estados.- salud, posesiones,...
Metas de placer.- paz, gozo,...
Metas instrumentales.- cumplen condiciones para habilita metas superiores: “Obtén tu pasaporte, para que viajes al
extranjero”.
GOLPEAR
INSTANCIA MARIA
ACTO 1 AGENTE
BILL
DATIVO S1
S3
SILVIA AGENTE
S2
Figura. 6.2 Red semántica particionada que muestra espacios de creencias
Para lograr esos objetivos se representan planes en la base de conocimientos, permitiendo formar una representación del
texto evaluado aunque haya información omitida, puesto que especifican elementos que deben participar en el tema en
cuestión. En la interpretación de la oración se usa el operador USE (por A, de P, para realizar G), que se describe como:
USE ( A, P, G ):
Precondición: KNOW-WHAT (A, LOCATION (P) ) .
NEAR (A,P)
READY (P)
Postcondición: DONE (G)
Esta descripción representa para que “A” (“Juan”) use “P” (“PC”) debe realizar “G” (“comprar”), debiéndose cumplir
las condiciones:
“A” debe saber donde esta “P” (donde venden “PC’s”)
“A” debe estar cerca de “P”
“P” debe estar disponible para usarse y cuyo resultado es el cumplimiento “DONE” de la meta “G”
Para adquirir la PC, “Juan” necesita cumplir submetas, una de ellas es conocer donde comprar una P.C., por lo que se
hace uso del operador “LOOK-FOR (A,P)” en donde “A” busca a “P”, cumpliendo ciertas condiciones y generando
resultados específicos, como:
LOOK-FOR (A, P):
precondición : CAN-RECOGNITE (A,P)
postcondición: KNOW-WHAT (A, LOCATION (P) ).
El módulo interpretador debe asociar el objetivo de adquirir la P.C. con la actividad de buscar un almacén distribuidor,
reconociendo que “Juan” está buscando un lugar donde comprarla, así que el sistema puede usar esta meta como parte de
la principal. Regularmente hay varios operadores y planes alternativos para alcanzar el mismo objetivo, por lo que
pudieran desarrollarse distintas alternativas de interpretación con sus variantes respectivas. Por lo que el problema de
generar coherentes interpretaciones de un texto o discurso puede involucrar considerar muchos planes parciales y
operadores.
6.5 Aplicación de Scripts

6.5.1 Evaluación de aplicaciones sobre Scripts
Los guiones son mecanismos de representación del conocimiento que pueden ser utilizados para comprender conjuntos
de eventos o historias estereotipadas en un contexto en particular. En los guiones se parte de la idea que en el mundo
real existen patrones de secuencia de eventos como cuando se sale de viaje, se va a comer a un restaurante, etc.
Los guiones tienen un conjunto de condiciones de entrada que hacen posible la ocurrencia de sus eventos, al final arrojan
una serie de resultados que provocan la ocurrencia de eventos posteriores (posiblemente descritos por otros guiones), es
decir, dentro de la cadena los eventos están conectados a otros anteriores que los hacen posibles, como a posteriores que
ellos provocan que ocurran.
Podemos ver a un guión como una lista de descripciones de eventos que contienen variables a las que se les da el
nombre de “huecos” y asociado a ellos puede haber información acerca de los tipos de valores que contiene; así como
valores que son usados si no hay otra información disponible. Los elementos que se especifican en un guión son:
Condiciones de entrada.- requisitos que deben ser satisfechos para que los eventos descritos en el guión puedan ocurrir
Apoyos.- huecos que representan objetos involucrados en los eventos descritos en el guión. La presencia de estos
objetos puede ser inferida aún si ellos son mencionados explícitamente en la historia o secuencia de eventos a analizar
Papeles.- son los huecos que representa a la gente involucrada en los eventos descritos en el guión. La presencia de este
elemento también puede ser inferida, aunque no sean menciona. Si se identifican individuos específicos estos pueden ser
insertados en los huecos apropiados
Pista.- corresponde a una variación específica en un patrón mas general. Las diferentes pistas de un mismo guión
compartirán patrones, aunque no a todos sus componentes
Escenas.- Son secuencias de eventos que ocurren en un momento dado. Los eventos pueden ser representados con
dependencia conceptual
6.6 Comprensión de historias “PAM”

Si un guión en particular es reconocido como apropiado en una situación dada entonces puede ser muy útil en la
predicción de la ocurrencia de eventos que no fueron mencionados explícitamente. Los guiones pueden también ser
útiles indicando las relaciones entre los eventos que fueron mencionados. Los dos primeros pasos en un proceso de
utilización de guiones son:
La selección entre los guiones que se encuentran en memoria, del guión o guiones apropiados
La utilización del guión para completar las partes no especificadas del texto a comprender
Hay dos formas en las que puede ser útil activar un guión, como guión auxiliar (aquel que se menciona brevemente y
puede ser referido de nuevo pero no en la situación central), en cuyo caso puede ser suficiente guardar el apuntador al
guión, de tal forma que sea accesado más tarde si es necesario, esta podría ser una estrategia apropiada para señalar el
guión del restaurante cuando se trata de analizar una historia como la siguiente: “Susana pasó por su restaurante
favorito camino al museo. Ella realmente disfrutó del nuevo Picasso exhibido”.
Como guión principal, en cuyo caso es apropiado activar el guión completamente y tratar de llenar sus huecos con los
objetos particulares y la gente involucrada que aparezca explícitamente en la historia que se esté analizando. La
coincidencia en precondiciones, apoyos, papeles y/o eventos de un guión pueden servir como indicadores que este guión
puede ser activado.
Cuando un guión ha sido activado para una situación en particular, es útil en:
La predicción de eventos que no han sido explícitamente mencionados, ejemplo: “Juan salió al restaurante anoche. El
ordeno una hamburguesa. Pagó y se fue a su casa”
La respuesta a Cenó Juan anoche ? sería afirmativa aunque no se haya mencionado explícitamente. El guión del
restaurante se activó por la coincidencia de los eventos de la historia con los del guión, por lo que el programa de
comprensión infiere que la secuencia completa previa ocurrió normalmente.
La interpretación coherente de un conjunto de observaciones, si un guión es una gran cadena causal puede
proporcionar información sobre las relaciones entre los eventos por ejemplo:
“Juan salió a cenar, se sentó y llamó a la mesera. La mesera trajo el menú y él ordenó una hamburguesa”.
A la pregunta: Porqué le llevo la mesera el menú a Juan? . El guión puede proporcionar dos respuestas:
Porque “Juan” se lo pidió (analizando hacia atrás en la cadena causal, para ver lo que provocó la acción)
Porque “Juan” se lo pidió (analizando hacia atrás en la cadena causal, para encontrar el evento o acción que provocará).
Para enfocar la atención en eventos poco usuales:
“Juan salió a cenar, se sentó y llamó a la mesera. La mesera trajo el menú y él ordeno una hamburguesa”.
“Juan fue a un restaurante, se le mostró una mesa, ordenó una hamburguesa, se sentó y espero largo tiempo, se enojo y
se fue”.
La parte importante de esta historia es la salida de la secuencia esperada de eventos en un restaurante. Una vez que la
secuencia típica de eventos se irrumpe no puede seguir utilizándose el guión para predecir eventos posteriores. Puede
suponerse que vio la carta, pues esto ocurrió antes de la interrupción pero no puede inferirse si pagó la cuenta.
Entre las principales ventajas de los guiones en la compresión de historias e implementación de Scripts están:
Predecir eventos que no han sido explícitamente mencionados

Una interpretación coherente de la situación presentada en el texto
Enfocar la atención en eventos poco usuales
Su desventaja es que no son adecuados para representar cualquier clase de conocimiento, ya que no son estructuras
generales que funcionan adecuadamente para modelar los tipos específicos de conocimiento para los cuales fueron
diseñados.
6.7 Aplicación de Scripts

Para entender mejor el empleo de Scripts, se presenta a continuación una parte del guión del restaurante (Schank 1997),
compuestos por elementos generales, escenas y el árbol de representación que generan:
Guión: Restaurante
Pista: Cafetería
Apoyos: Mesas, Menú, F= comida, Cuenta, dinero
Papeles: L = Cliente, M = Mesero, O = Cocinero, J = Cajero, P = Propietario
Condiciones de entrada: Si tiene hambre, Si tiene dinero
Escena 1: Entrada
L PTRANS L a el restaurante
L ATTEND ojos a las mesas
L MBUILD donde sentarse
L PTRANS a la mesa
L MOVE L a posición sentado
Escena 2: Pedir
L PTRANS menú L L MTRANS seña a M
M PTRANS M a la mesa
M ATRANS menú a L
*L MBUILD elección de C
L MTRANS seña a M
M PTRANS M a la mesa
L MTRANS ‘quiero C’ a M
M PTRANS a M o
M MTRANS (ATRANS C) a O
o MTRANS ‘no hay C’ a M o (guión Preparar C)

M PTRANS a M L ir a la escena 3
M MTRANS ‘no hay C’ a L
(VOLVER * ) o
(ir a la escena 4 por el camino de no pagar)
Escena 3: Comer
O ATRANS C a M
M ATRANS C a L
L INGEST C
(opción: volver a la escena 2 para pedir más; en caso contrario, ir a la escena 4)
Escena 4: Salir
L MTRANS a M (la cuenta)
M MOVE (escribe la cuenta)
M PTRANS M a L
M ATRANS “la cuenta “ a L
L ATRANS “la propina“ a M
L PTRANS L a J
L ATRANS dinero a J
PTRANS L fuera del restaurante
Figura 6.3 escena 2, del Scprit del Restaurant
6.8 Evaluación de aplicaciones sobre “Comprensión de historias” PAM

El “interés” es uno de los problemas centrales en el entendimiento del lenguaje natural ha sido la creación de
inferencias y el control de las mismas, considerando que cada una de ellas es creada y tratada a su vez como entrada del
mismo sistema generando un número infinito de combinaciones. Una pregunta que surge al analizar este problema es:
¿ Qué tan extensas deben ser nuestras búsquedas de inferencias ? “
Para generar su respuesta debemos crear inferencias que ayuden a unir entre sí el texto analizado; tal habilidad depende
de nuestro conocimiento acumulado, el cual nos marca las rutas a seguir de manera natural, esta meta no se logra a
menos que conozcamos el lugar en donde podemos buscar información que sea útil para ligar el nuevo conocimiento con
el texto antes analizado. Para un nivel mas elevado de planes y objetivos el problema es “identificar los objetivos y
planes que debemos seguir”. Una respuesta es: “debemos seguir el camino mas interesante”. El interés significa
“poner atención en ciertas cosas o acciones”, lo que en forma abstracta se traduce en “dejar libre nuestro sistema de
inferencias”.
A continuación se presenta una oración incompleta que puede ir ligada con los conceptos que aparecen después:
“Juan iba caminando por la calle cuando .....”
vio un gato
decidió amarrarse un zapato
se comió una galleta
escuchó una explosión
Es obvio que los primeros incisos son poco relevantes en comparación al último, lo cual nos indica que:
Las cosas poco comunes son mas interesantes que las ordinarias
El interés es una propiedad dinámica fuertemente dependiente del contexto
En general, para representar esta capacidad de evaluación de interés se requiere de un módulo especial llamado
“Understander” quien trata de analizar y calificar el texto de entrada con relación al contexto del diálogo que se está
desarrollando. El punto crítico es decidir que tema es más interesante que otro conforme a diversos puntos de vista y en
situaciones cambiantes, por lo que se deben usar criterios heurísticos dinámicos para caracterizar esta situación.
En la comprensión de historias destaca el uso del concepto de “interés” como solución al problema del manejo de
inferencias es “PAM”, construido por Schann y Abelson en 1977, implementaron “scripts” para facilitar la
interpretación de ciertas oraciones y palabras claves contenidas en un texto, de tal manera que podía emitir juicios sobre
“supuestos” que argumentan ciertas acciones e intenciones, como se muestra en el siguiente diálogo:
John quería la bicicleta de Bill

El se acercó a Bill y le pregunto si estaba dispuesto a darle la bicicleta
Bill se opuso
John le dijo a Bill que daría treinta dólares por ella, pero Bill no estuvo de acuerdo
Entonces John le dijo a Bill que le rompería un brazo si no le permitía tenerla
Bill le dio la bicicleta
Las inferencias que “PAM” es capaz de generar son:
Porqué John se dirigió a Bill ? Porque quería tener su bicicleta

Porqué Bill le dio su bicicleta ? Porque no quería ser lastimado
PAM hace uso de “planes” como estructuras de conocimiento para tipificar metas comunes de la gente y de los medios
característicos que emplean para alcanzarlas, a su vez “entiende” historias basadas en objetivos (como las respuestas que
se ofrecieron en el texto analizado anteriormente) y asume que todos los planes y objetivos de los actores en una historia
pueden ser constantemente monitoreados.
6.9 Implementación de un prototipo interpretador de textos

El subsistema “interpretador” al formar parte de un sistema de lenguaje natural aprovecha las estructuras de datos y
bases de conocimiento que el resto de módulos crean, actualizan y explotan para cumplir la función sustantiva de la
aplicación acorde con el flujo de “conversación” sostenida con el usuario conforme se ilustra en las figura 6.4 y 6.5
En el flujo de entrada el “intérprete” se valoren los siguientes aspectos:
Enriquece las definiciones semánticas de los elementos del texto que es evaluado
Precisa la naturaleza y propósito de la oración
Deduce los elementos, estados y acciones involucradas explícitamente en la frase, conforme al discurso y dominio de la
aplicación
Identifica el tipo de reacción del sistema: saludo, pregunta, declaración, instrucción, negación, despedida
Mientras que la exposición de la respuesta el “intérprete”:
Instruye al módulo “generador de lenguaje” para realizar el tipo de respuesta adecuada al texto fuente
Evalúa las respuesta ofrecidas por el módulo “generador” conforme a los requisitos manifestados
Ordena la ejecución correspondiente al tipo de respuesta seleccionada
Presenta la respuesta al usuario
Al integrar el “Interprete” al SLN se obtiene el siguiente esquema de resultados y estructuras de datos:

ANALISIS
TEXTO DE LEXICO
ENTRADA
ANALISIS
USUARIO SINTACTICO
ANALISIS
SEMANTICO
INTERPRETE
-CONCEPTOS
-SIGNIFICADO
-ORACION
-PROPOSITO
-RESPUESTA
Figura. 6.4 Interpretación de Textos Fuente

ANALISIS
SEMANTICO RESPUESTA
ANALISIS GENERADOR
SINTACTICO DE INTERPRETE
LENGUAJE
ANALISIS
LEXICO
EXPOSICIÓN DE
RESPUESTA
USUARIO
Figura. 6.5 Expresión de Respuestas por el intérprete

CAPÍTULO 7. DESARROLLO DE UNA
APLICACIÓN
7. DESARROLLO DE UNA APLICACIÓN
7.1 Integración de la documentación
Un sistema de información inteligente está diseñado para entender y manipular lenguaje, aceptar como entrada texto en
lenguaje natural, almacenar conocimiento ligado al dominio de la aplicación, desarrollar inferencias a partir de tal
conocimiento y texto alimentado, contestar preguntas y generar respuestas. Conceptualmente está integrado por las
siguientes etapas que se muestran en la figura 7.1:
Representació
n
Texto
de Traductor Interpretador Generador
Entrada
Base de Texto de
conocimiento
Figura. 7.1 Esquema de un Sistema de Lenguaje Natural
El Traductor integra los siguientes subsistemas:
Analizador léxico.- dividido en tres etapas, fonología (descompone el texto en unidades de palabra), analizador
morfológico (identifica la raíz de las palabras) y generador léxico (asocia información a los morfemas)
Analizador sintáctico.- valida la estructura gramatical del texto y asocia un significado a la declaración
Analizador semántico.- relaciona el texto con la base de conocimientos del contexto para emitir una representación del
significado del texto alimentado
Interpretador.- lo constituye un responsable de interactuar con la base de conocimientos en función al tipo de texto
alimentado. Si es una pregunta, esta debe ser contestada, pero si es una afirmación (hecho o negación) se agrega a la
base y actualiza en un caso a otras entidades. También desarrolla inferencias a partir del conocimiento almacenado
Generador.- es el subsistema encargado de producir el texto de salida dirigido al usuario en función a la naturaleza del
texto de entrada, puede emitir
Representación Interna (“RI”) es el mapeo del texto de entrada en un formato adecuado para la manipulación de los
módulos del SLN y consiste en las estructuras almacenadas en la base de conocimientos
La Base de Conocimientos (“BC”).- se constituye por 3 tipos de elementos interrelacionados entidades, eventos y
situaciones
Entidades.- son personas, animales, objetos o lugares que deben ser descritos y que protagonizan los eventos
Eventos:- son acciones que pueden ocurrir involucrando entidades con roles de actor, objeto, instrumento, origen y
destino; además de poder involucrar a otras acciones
Situaciones:- combinan entidades y eventos con condiciones y resultados
Se puede conceptualizar como un sistema a desarrollar con alcances incrementales, como círculos concéntricos que
ilustran cada fase, tal como aparece en la figura 7.2
Traducción
Inferencia
Respuesta
Aprendizaje
Figura. 7.2 Evolución de un SLN
Traducción.- los textos recibidos son procesados hasta generar su representación interna “RI” para después, a partir de
ella, emitir el texto de salida.
Inferencia.- una vez obtenida la RI del texto recibido, se hacen todas las inferencias posibles al asociar el RI con la
base de conocimientos “BC”. Las conclusiones son representadas como RI para que el “Generador” emita el texto de
salida.
Respuesta.- después de haber emitido la RI equivalente a la pregunta alimentada, se activan los mecanismos de
inferencia que explotan la BC para satisfacer el requerimiento. Una vez obtenida la respuesta en su forma de RI se le
encomienda al “Generador” su exposición.
Aprendizaje.- las declaraciones introducidas al sistema son representadas internamente y confrontadas con la BC
actual, para determinar casos de:
Integración.- agregando o actualizando el conocimiento

Contradicción.- requiriendo contradicción, confirmación, renovación, convivencia o rechazo
Confusión.- al no poder comprender el significado o contexto del texto
El sistema incluye un subsistema especializado en la emisión de lenguaje natural como respuesta a la iniciativa del
propio SLN para iniciar, controlar o terminar una sesión con el usuario el cual realiza funciones de:
Dar respuesta a una petición, orden, consulta u observación expresada por el propio usuario
Reaccionar a un estado de la sesión: pausa, actualización de conocimiento, contradicción y desconocimiento en la
información expuesta
Desarrollo de una Aplicación 125
La frase u oración que el subsistema genera debe considerar los siguientes requerimientos:
La orden, propósito y condiciones que el subsistema “interpretador” emite para responder a la expresión alimentada por
el usuario
El requerimiento, objetivo y restricciones que el subsistema de “conversación” establece en la coordinación del proceso
de diálogo entre el SLN y el usuario
El “discurso” que durante ese momento de la sesión se expresa a través de las oraciones que el usuario y el SLN han
expresado alternadamente
El “dominio” de especialidad que el SLN maneja y que el usuario desea explotar
El “universo” del idioma que se utiliza para expresar la comunicación: alfabeto, diccionario, sintaxis,..
El “conocimiento mundano” que caracteriza la expresión del lenguaje: afirmaciones, negaciones, dudas, saludos,...
7.2 Presentación de sistemas

La conversación es la habilidad del ser humano para comunicarse con otros mediante sonidos, señales y símbolos
expresados en un código común. El intercambio de sonidos e imágenes emplea un patrón familiar entre el emisor y
receptor, existiendo un entendimiento entre los protagonistas que comparten ideas, pensamientos, sentimientos, etc. En
un sistema la exposición y comprensión de palabras, frases y textos entre el usuario y el sistema es la parte esencial
adjetiva de la aplicación. Es decir, representa el vehículo de comunicación entre los protagonistas y es independiente
al tema o dominio especialidad del sistema (parte sustantiva) , como se aprecia en la figura 7.3:
El contexto de una conversación está en función a de la situación que se está tratando. Por ejemplo, si se habla a cerca de
carreras de caballos, boxeo, natación, etc., el contexto es el deportivo. Al considerar al contexto se establece la
orientación sustantiva de la aplicación; es decir se precisa si el sistema está destinado a emplearse como:
Compilador/Traductor .- convierte expresiones descritas bajo un lenguaje en otro, en uno o dos sentidos
Intérprete.- identifica el significado de las oraciones, brindando la respuesta esperada
Forma parte de un sistema mas complejo.- es el módulo de comunicación de un sistema mayor, como por ejemplo un
lenguaje de consulta para una base de datos, sistema experto, sistema tutorial y un sistema de planeación
El tema de una conversación es el asunto sobre el cual se está tratando, este forma parte del contexto y puede tener
relación con algún otro que se encuentra en otro contexto en particular. El lenguaje natural como medio de expresión
debe considerar e incluir las exigencias de comunicación propias del tema sustantivo de la aplicación, es decir su
estructura y vocabulario debe ser flexible y amplio para manejar las frases, términos y significados inherentes y muy
particulares del tema, considerando los formatos que hay en común, por ejemplo:
Computación.- “Calcula el espacio en disco”

Ingeniería.- “Calcula la tensión de los cables”
Economía:- “Calcula el impacto de una alza en los CETES”
Medicina:- “Calcula la presión arterial”
Leyes:- “Calcula el monto de la sanción”
Artes:- “Calcula el precio de la pintura”
Historia:- “Calcula el número de muertes provocadas por la 2° guerra mundial”
Computación Ingenierí Economía Medicina Leye Arte Historia

a s s
Lenguaje
Natural
SLN
Diccionario L.N./Adjetiv Usuario

Sintaxis a
Estructuras
Semánticas
Figura. 7.3 Lenguaje natural como medio de comunicación independiente del tema
El protagonista representa a las personas que intervienen en una conversación asumiendo los siguientes roles
alternativamente:
Emisor.- es quien envía un mensaje (iniciando así una conversación), esperando una respuesta para convertirse en
receptor
Receptor.- al recibir el mensaje y entenderlo hay retroalimentación para así tomar el lugar del emisor
Una conversación no se puede dar en caso de estar ausente alguno de estos elementos. En una conversación puede haber
mas de dos protagonistas. Se debe considerar el rol que el sistema y el propio usuario van a desempeñar durante la
conversación, determinando los siguientes criterios:
Quién controla la sesión
Quién es el especialista del tema
Quién pregunta
Quién evalúa
Quién corrige
Si los roles son alternos
La forma de expresión en un sistema, explota las formas para expresar intenciones específicas propias del lenguaje
natural definidas por su gramática, a través de ella se emplean formatos para comunicar oraciones del tipo:
Declarativas.- exposición de comentarios que no requieren una réplica

Imperativas.- formulación de ordenes que exigen respuesta
Interrogativas.- cuestionamientos que deben responderse
Negaciones.- rechazos a ordenes recién expresadas
Condicionales.- presentación de intenciones sujetas al cumplimiento de ciertos requerimientos
Dudas.- es el reconocimiento de incertidumbre sobre el significado o intención de frases expuestas
Desacuerdos.- la identificación de otro punto de vista sobre las oraciones expuestas
Respuestas.- afirmativas o negativas a una propuesta
Formal.- la expresión está carente de modismos y frases que son consideradas como inexistentes en el lenguaje. En
ocasiones se utiliza vocabulario técnico o enfocado a un tema en particular. Se caracteriza por la expresión de oraciones
completas que observan la estructura gramatical. Comúnmente la comunicación formal se da entre personas relacionadas
por el trabajo (jefe - subordinado), en una relación maestro - alumno o entre personas que acaban de conocerse
Informal.- generalmente se emplea entre familiares, amigos y personas que son aproximadamente de la misma edad,
estrato social y similares en sus gustos y forma de pensar. Utilizan expresiones que son consideradas “de moda” y en
algunos casos palabras que no son muy comunes en su idioma. En ocasiones utilizan expresiones gramaticalmente
incompletas
Una conversación generalmente sigue un tipo de formato, aunque con su particular estilo dependiendo de las
particularidades del evento. Se inicia con un saludo y en ocasiones con una breve introducción para llegar al tema que se
va a tratar. En el desarrollo del tema se abarcan los puntos que en ese momento se consideran mas importantes. Se puede
llegar al caso de que en la conversación se aborden diferentes temas a parte del inicial. Finalmente hay unas palabras de
terminación de la conversación en donde aparte de la despedida puede haber una introducción para un tema que se pueda
llegar a tratar posteriormente. El sistema incluye estructuras, términos y símbolos específicos del tema y del lenguaje
natural para facilitar la interpretación, como por ejemplo:
Inicio y despedida: hola, adiós,...

Afirmación y confirmación: si, claro,...
Exclamación: ¡... !
Precaución.- cuidado...
Rechazo.- no, porque..
Interrogación y duda.- ¿... ?, cómo,...
Identificar al protagonista.- usa un “prompt” especial para exhibir el autor de la oración desplegada
El módulo “conversador” de un sistema debe incluir los procedimientos y formas de comunicación apropiados a las
etapas de diálogo a lo largo de una sesión con el usuario, haciéndose cargo de:
Iniciar la sesión
Presentar al usuario los sistemas de conversación
Invitar a responder al usuario
Evaluar las oraciones alimentadas
Asistir las dudas que el usuario tenga en la operación del sistema
Presentar las respuestas apropiadas al usuario
Registrar una bitácora de la conversación
Actualizar el espacio de estados que se genera durante la conversación
Formular las interrogaciones y órdenes apropiadas al usuario
Actualizar las bases de conocimiento del tema y del lenguaje
Interrupción, cancelación y conclusión de la conversación.
7.3 Evaluación y discusión de propuestas

El sistema “Intellect” traduce oraciones en instrucciones de búsqueda en una base de datos, por medio de una interfaz de
comunicación que aplica gramáticas semánticas para la manipulación de oraciones descritas en lenguaje natural. Por
ejemplo, al consultar una base de datos con información empresarial se desarrolla esta clase de conversación :
u> How many electronics companies are there among the 500 largest industrial companies in the
world ?
s> 39 electronics companies exists
u> what were the sales and earnings of these companies along 96?
Name Sales Net Income

(thousands) (thousands)
General Electric 97,478,985 17,403,205
Siemms 78,413,214 12,187,234
: : :
what was the average of these concepts ?
s> Sales Net Income
(thousands) (thousands)
62,432,180 9,032,421
u> what was the best selling company ?
s> Xola Basic with 103,576,120 (thousands dollars)
La operación de un sistema se logra por medio de la conversación que el usuario establece con la aplicación y del
control que esta última asume, por lo que el subsistema de “conversación” aparece en la parte superior de la
coordinación tanto de la sesión como del control del llamado a los módulos restantes. Constituye también la única puerta
de entrada y de salida de comunicación desde y hacia el mundo exterior, por lo que la implementación del sistema
considera el esquema que aparece en las siguientes figuras 7.4 y 7.5:
Usuario
Oraciones Oraciones
fuente generadas
CONVERSADOR
Control de la Proceso de Proceso de

sesión oraciones fuente oraciones
generales
LEXICO
Unidades léxicas Oraciones frontales
SINTACTICO
Estructura sintáctica Ración base
SEMANTICO
Estructura semántica Oración de significado
INTERPRETE
Estructura de significado Estructura de respuesta
Ejecución de respuesta Presentación de respuesta
Figura. 7.4 Flujo de conversación a partir de la expresión del usuario

Usuario
Oración generada
CONVERSADOR
Control de la sesión
Proceso para generar oración Exposición de la oración
INTERPRETE
Tipo de oración a generar
Estructura de la oración
SEMANTICO
Oración de significado
SINTACTICO
Oración base
LEXICO
Oración frontal
Figura. 7.5 Flujo de conversación a partir del subsistema de conversación
El sistema interactúa con el usuario durante la sesión no solamente como medio de comunicación para el control de la
sesión e interpretación de las expresiones del usuario, sino también al ofrecer las respuestas apropiadas a sus
requerimientos, por lo cual interactúa con el resto de subsistemas como se ilustra en la Fig.7.6 En dicha ilustración se
observa como puerta de comunicación al subsistema de “conversación” para recibir las expresiones del usuario y
presentar las frases de exposición (respuesta, preguntas, etc.) del sistema. Las oraciones fuente son procesadas hasta
llegar al subsistema intérprete se traduce en directivas que se transmiten al “generador del lenguaje”, también se reciben
los requerimientos de expresión que el módulo conversador emplea. La interpretación de estos insumos.
Este último interactúa con la base de conocimientos y los subsistemas semántico, sintáctico y léxico para producir las
frases en lenguaje natural acordes a la respuesta o expresión deseada. Las oraciones de salida son interpretadas y de ser
necesario corregidas antes de transferirse al “conversador” para su exposición al usuario.
Usuario
exposición
CONVERSADOR
oración fuente
requerimiento de
expresión
respuesta/expresión
INTERPRETE
respuesta/expresión
requerimiento de expresión
de
respuesta
GENERADOR
DE LENGUAJE
generación de
lenguaje natural
SUBSISTEMAS
base de
semántico sintáctico léxico
conocimientos
Figura. 7.6 Procedimiento de la generación de lenguaje

CONCLUSIONES
CONCLUSIONES
La tendencia que persigue la operación de los sistemas de información y programas de cómputo es facilitar su
explotación, procurando hacerla lo mas transparente posible al usuario, liberándolo de barreras técnicas y del empleo de
medios ajenos a su cuerpo para hacerse comprender. Es por ello, que la creación de aplicaciones que consideren este
requerimiento será un estándar permanente en el campo de la informática.
Los sistemas de lenguaje natural pueden considerarse como la “capa exterior” de una aplicación mayor, ya sea para el
clásico sistema de información empresarial, comercial o bancario; o bien como protocolo de operación paro los
programas de cómputo orientados a la explotación de base de datos y paquetes especializados.
Se anima al profesional mexicano a incursionar en este campo de investigación aplicada con altas expectativas de
aprovechamiento comercial, donde podrá emplear su ingenio y creatividad en el desarrollo de productos con un alto
nivel tecnológico, que al difundirse en el mercado no se limitará al nacional, sino que podrá aspirar a trascender en todo
el mundo hispano parlante.
BIBLIOGRAFÍA
BIBLIOGRAFÍA
“Artificial Intelligence”, 2da. edition
Elaine Rich,
McGraw Hill.
“Implementing Japanese Artificial Intelligence Techiques”

Richard Tabor Greene,
McGraw Hill.
“Introduction to Natural Language Processing”

Mary Dee Harris,
Prentice Hall.
“Knowledge Processing & Applied Artificial Intelligence”

Soumitra Dutta,
Butterworth Heinemann.
“La Quinta Generación”

Edward A. Feigenbaum & Pamela McCorduck,
Planetal.
“LISP”, 3ra. edition

Patrick Henry Winston & Berthold Klaus Paul Horn,
Addison Wesley.
“Natural Language Processing”

Rowman & Littlefield,
Publishers.
“Artificial Intelligence”, 2da. edition

Winston, Patrick Henry,
Addisson Wesley.
“Expert Systems and Applied Artificial Intelligence”

Turban, Efraim,
Mcmillan Publishing.
“Programming for Artificial Intelligence”

Ivan Bratko,
Addisson Wesley.
“Natural Languaje processing for Prolog programmers”

Covington, Michaela,.
Prentice Hall Inc.
Impreso en los Talleres Gráficos
de la Dirección de Publicaciones
del Instituto Politécnico Nacional
Revillagigedo 83, Centro Histórico, 06070, México, D.F.
Enero de 2006. Edición: 1,000 ejemplares
Diseño Portada. Alejandro Peña Ayala

Fotografía de la Portada:
Red de observatorios, Volcán Mauanakea, Isla de Hawaii, Agosto 2004
Los sistemas de información emplean diversas interfases
para implementar la comunicación hombre-máquina al
considerar una diversidad de convenciones de lenguaje,
iconos y estructura. Sin embargo, la tendencia es
privilegiar el uso del Lenguaje Natural basada en los
procesos de interpretación y generación automática.
El proceso que manipula Lenguaje Natural inicia a partir

de que el usuario introduce un texto a través del teclado.
La oración alimentada es descompuesta en unidades
léxicas, y su estructura es evaluada por medio de
gramáticas. Posteriormente, se infiere el significado
semántico de la sentencia, y se interpreta con base al
contexto de la conversión entre el usuario y el sistema. En
atención a la oración introducida, el sistema procede a
generar la respuesta apropiada a través de un proceso
inverso encargado de generar un texto que se exhibe en el
monitor.
En este ejemplar, se ofrece al lector una descripción de

las etapas involucradas en el ciclo de comunicación
hombre-máquina que soporta la interacción con el
sistema de información. En sus capítulos se describen las
actividades involucradas en cada etapa, se precisan los
procedimientos y se identifican las estructuras de datos
empleadas para almacenar los elementos del lenguaje.
La obra se dirige a los estudiantes, profesionistas y

especialistas del ámbito de los sistemas, la Informática y
la Computación, que están interesados en diseñar y
desarrollar interfases que faciliten la comunicación entre
el hombre y un sistema de información.
ISBN: 970-94797-2-5 # 001

Interfases Hombre Maquina

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Interfases Hombre Maquina

Cargado por

Copyright:

Formatos disponibles

Interfases Hombre-Máquina:

Alejandro Peña Ayala

INSTITUTO POLITÉCNICO NACIONAL

Cursó la licenciatura en Informática en la UPIICSA del IPN. Posteriormente obtuvo el Diplomado en

En 1981 ingresó a la planta docente de la UPIICSA, donde actualmente es profesor titular C e

En el ámbito profesional de la Informática, desde 1978 se ha desenvuelto en los sectores privado,

Por sus ocupaciones académicas, profesionales y ministeriales, Alejandro Peña ha tenido la

Alejandro Peña Ayala

INSTITUTO POLITÉCNICO NACIONAL

D.R. © 2006, Alejandro Peña Ayala

INSTITUTO POLITÉCNICO NACIONAL

Un programa Prolog se compone de cláusulas

Teorema: demostrar que: “Juan es abuelo de Carlos”

>padre (juan, mario).

Se introduce el teorema negado con el símbolo ? :

>abuelo (juan, carlos)?

Se relaciona contra la regla:

>abuelo (X, Z) :- padre (X, Y), padre (Y, Z).

>padre (juan, mario)

>padre (mario, carlos)

Se trata de unificar: padre (mario, carlos) == padre (mario, carlos)

>padre (juan, mario).

Se introduce el problema negado con :

Demostrar que “Juan es abuelo de carlos”

abuelo (juan, carlos)

padre(juan, carlos) padre(juan, carlos) abuelo (X, Z) :- padre(X, Y), padre(Y, Z)

No es demostrable que “Juan es abuelo de carlos”, ya que no se generó la cláusula NIL

Figura. 1.1 Imposibilidad de demostración

Los predicados deben tener el mismo nombre

1.2 Recursividad normal y tipo de cola (TAIL)

Tabla. 1.1 Recursividad normal

Tabla. 1.2 Recursividad tail

1.3 BackTrak uso del corte (CUT) y de falla (FAIL)

>factorial (N, 1) :- 1 >= N, !. % cláusula 1

>factorial (N, 1) :- N =< 1, !. % cláusula 1

Con estos ajustes el cut evita al backtrack de la siguiente forma:

>padre (maría, pedr0). % cláusula 1

>padre (maría, pedr0):- fail. % cláusula 1

>padre (X, Y):- mujer(X), fail. % cláusula 1

> mujer(maria). % cláusula 1

Al plantea el problema “maría es padre de pedro ?” mediante el hecho negado:

> padre(maria, pedro)? % problema a resolver

> mujer(maria). % cláusula 1

1.4 Aplicaciones: factorial, creación y búsqueda en listas, etc.

>colores ( [rojo, azul, verde] ). % cláusula 1

>colores ( [A, B, C] )? % problema 2: acceso a cada elemento de la lista

>colores ( [rojo, azul, verde] ). % cláusula 1

>colores ( [ _, E, _ )? % problema 2 : acceso al 2do. elemento

>colores ( [ C |_ ] )? % problema 2 : acceso al CAR

>colores ( [ _ | D ] )? % problema 3 : acceso al CDR

>colores ( [rojo, azul, verde] ). % cláusula 1

>list (D, E, [D, E ] ) . % cláusula 2

>append ([ ], [ ], N )? % problema 8: APPEND, crea una lista a partir de 2 listas vacías

1.5 Predicados: declarativos, aritméticos, de comparación, entrada y salida

>color(X)? % problema 1: busca todas las posibles soluciones

>solveone?. % cláusula 4: se introduce una directiva a Prolog

>color(X)? % problema 3: busca todas las posibles soluciones

>functor (T, amigo, 2)? %problema 2: descomposición de una estructura

>amigo (raul, mario). % cláusula 1: hecho

>suma (E1, E2, R):- R is E1 + E2 % cláusula 1: suma

%problema 1. operaciones aritméticas

<> desigualdad entre dos términos: X <> Y

>igual1 (A, B):- A = B. % cláusula 1: =

> variable (A):- var (A). % cláusula 9: var