KINEMATICS SOLVERCristóbal Miranda Puente – 100039108 e-mail: 100039108@alumnos.uc3m.es

Universidad Carlos III de Madrid 5º Ingeniería de Telecomunicaciones

Adrián Hurtado González – 100039131 e-mail: 100039131@alumnos.uc3m.es

Universidad Carlos III de Madrid 5º Ingeniería de Telecomunicaciones

1. INTRODUCCIÓN En este paper se describe el funcionamiento del Kinematics Solver.

Es conocida por todos la dificultad que supone resolver un problema de matemáticas, física o química de los cursos de bachiller cuando nos encontramos estudiándolos. Además, una de los métodos mas recomendados para la compresión y aprendizaje, así como para la obtención de habilidad para resolver estos problemas, es mediante la realización de ejercicios. ¿Pero cuantos de los problemas que necesitamos vienen resueltos para poder comprobar si nuestro resultado es correcto?, ¿y que hacemos cuando nos quedamos atrancados en un punto del problema y no sabemos continuar? La respuesta a todas estas preguntas es KINEMATICS SOLVER. Es un programa que a partir de los datos iniciales de un problema y los resultados que se desean obtener, es capaz de hacer un desarrollo matemático completo en el que se muestran tanto los resultados numéricos como los pasos de la resolución seguida.

Es tan sencillo como introducir los datos en una interfaz grafica que función bajo Matlab. Una vez hecho esto el planificador será el encargado de proporcionar el desarrollo seguido y Matlab los resultados numéricos y simbólicos.

2. ESTRUCTURA El programa consta de dos parte principales: � Un planificador que proporciona los pasos para llegar a los

resultados pedidos a partir de los datos dados en el enunciado. Los pasos y las ecuaciones necesarias para la resolución se muestran tanto por pantalla como en un fichero para posibles consultas posteriores. Esto facilita tanto la revisión de problemas ya resueltos como su utilización para crear colecciones de problemas resueltos. Además la presentación es lo suficientemente clara como para que todo sea entendido correctamente.

� Un conjunto de funciones en Matlab que se encargan de hacer el calculo numérico y que además permiten continuar profundizando en el problema a través de nuevas operaciones y consultas que facilitan la comprensión, tales como representaciones graficas, maximizaciones, derivadas, integrales, etc…

� Además también presenta una interfaz grafica en Matlab, que permite introducir los datos de forma muy cómoda en función del tipo de problema que se desee resolver.

3. FUNCIONAMIENTO El funcionamiento principal y mas general del programa es el que se pude ver en el diagrama de flujo de la figura 1, que se muestra a continuación.

Inicializar

Solicitar Problema

Generar Fichero PDDL

Ejecutar Panificador

Resolver Plan

Página 1

DIAGRAMA DE FLUJO PRINCIPAL

Figura 1. – Diagrama de flujo principal del programa

Toda la funcionalidad principal esta descrita en el fichero “kinematics_solver.c”, que es por tanto el encargado de hacer las llamadas y pasar los datos al planificador, a Matlab y a las funciones exteriores.

A continuación se muestra mas detalladamente los diagramas de flujo de cada una de las fases del programa principal.

Abrir el fichero del dominio

Obtener las localizaciones de

las acciones

Agragarlas a la lista de

locaclizaciones

Agregar la operación

correspondiente a la lista de

operaciones

Página 1

DIAGRAMA DE INICIALIZAR

Figura 2. – Diagrama de flujo de la fase de inicializar.

Llamada a Matlab

Activación de la interfaz de datos

El usuario inserta los datos iniciales y los que necesita

calcular

Ejecutar Panificador

Volcado de datos en el fichero

datos.txt

Página 1

DIAGRAMA DE SOLICITAR PROBLEMA

Figura 3. – Diagrama de flujo de la fase de solicitar problema.

Abre la definición de conocimiento

base

Copia la seccion delimitada por “(:objects )”.

Desarrolla los predicados de la

seccion “(:init )”.

Genera las secciones “tengo”

con los datos iniciales, y “goals” con los buscados.

Página 1

DIAGRAMA DE GENERAR FICHERO PDDL

Figura 4. – Diagrama de flujo de la fase de generar fichero

PDDL.

Generación automática del

script de llamada al planificador

Llamada al planificador

Generación de la salida del

planificador

Creación de una lista de comando

para Matlab a partir del fichero de salida anterior

Página 1

DIAGRAMA DE FLUJO EJECUTAR PLANIFICADOR

Figura 5. – Diagrama de flujo de la fase de ejecutar el

planificador.

Apertura de una comunicación con

Matlab

Copia y transferencia de

todos los datos en forma simbólica a

Matlab

Copia y transferencia solo

de los datos iniciales con su

valor numérico a Matlab

Evaluacion de todas las variables

finales e intermedias

Expresión de todas las variables

con su valor numérico,

despejadas de la función origen y en función de los datos iniciales.

Página 1

DIAGRAMA DE RESOLVER PLAN

Figura 6. – Diagrama de flujo de la fase resolver plan.

4. COMPOSICIÓN DE FICHEROS DEL PROGRAMA El programa esta compuesto por los siguientes ficheros todo escrito en código C:

� aux_functions.c � Es un fichero de funciones auxiliares para el tratamiento de ficheros y de strings. Han sido desarrolladas para facilitar el manejo de funciones mas complejas.

� generate_pddl_domain.c � Se encarga de traducir el código (o pseudocódigo) en el que esta definido el problema al código en PDDL que entiende el planificador.

Como se puede ver, hemos diseñado un nuevo lenguaje de definición de dominios, con el que se pueden definir de forma sencilla y automáticamente, convirtiendo esta herramienta, en algo muy útil desde el punto de vista docente.

� kinematics_solver.h y kinematics_solver.c � Estos ficheros son el núcleo de la práctica. Son los encargados de hacer todas las llamadas al resto de programas, al planificador y a matlab.

Vamos a ver el contenido de estos fichero mas detalladamente, describiendo las funciones mas relevantes de cada uno de ellos e indicando para que se emplean:

4.1 aux_functions.c Como ya se ah dicho es una librería que contiene funciones auxiliares que se emplean en su mayor parte para tratamiento de ficheros y string en general, simplificando funciones posteriores mas complejas Hay que saber que el concepto de ‘localización’ hace referencia a instrucción de un fichero con el formato “(: )”. Las funciones principales de este fichero son: � lookForNewLocation � Esta función se encarga de

encontrar nuevas localizaciones en un fichero especificado. � ptnWord (pointer to next Word) � Es una función que se

encarga de buscar palabras. � wrdlen � Esta función devuelve la longitud de la palabra

sin espacios iniciales ni finales. � readToNextToken � Lee el fichero carácter a carácter hasta

encontrar un token. Un token es todo el texto contenido entre los símbolo “( )”.

� copyToEndToken � Copia un token desde una posición dada hasta cerrar todos los paréntesis que estén abiertos hasta el momento. Este numero de paréntesis abiertos se indica por parámetro. Además se copia el resultado en un fichero que también se pasa por parámetro.

� copyInBufferToEndToken � Es igual que “copyToEndToken”, pero en este caso se copia el resultado en un buffer para su tratamiento posterior.

� copyFromBuffer � Vuelva el contenido de un buffer en un fichero que se le indica por parámetro.

� nextWord � Es igual que “ptnWord” pero en vez de buscar palabras en ficheros lo hace en strings, y además devuelve el puntero a la posición en la que se encuentra, y guarda el resultado en otro string que se le pase como parámetro.

4.2 generate_PDDL_domain.c Este fichero se encarga de traducir el pseudocódigo en el que esta definido el problema a lenguaje PDDL. Las acciones que lleva a cabo son las siguientes: � Abre el fichero de pseudocódigo. � Copia la sección “(define (domain ))” literalmente. � También copia la sección “(:requeriments )” si existe, y sino

genera una por defecto automáticamente. � Copia literalmente la sección “(:types )”. � La sección “(:predicates )” tiene un poco de complejidad,

porque además de copiar los predicados del fichero de pseudocódigo puede encontrarse con funciones especiales. En el caso de encontrar la función “(generate-predicates)”, genera unos predicados especiales que salen de estudiar las acciones y añade “(pred-nombre_accion parametros)”.

� Y por ultimo para cada acción, guarda el nombre y los parámetros y genera las precondiciones con todas las combinaciones que se especifiquen en la sección correspondiente de esa acción.

Además de todo esto, el sistema también permite crear un fichero PDDL en función de su pseudocódigo correspondiente y de otro pseudocódigo que utiliza como ampliación, es decir, importando documentos. Hay que saber que los documentos que son importados son traducidos previamente de pseudocódigo a lenguaje pddl.

El comando que se utiliza para llevar a cabo esta funcionalidad es “import nombre_fichero”. � Para agregar los tipos del fichero importado en el nuevo hay

que escribir “(:types (add_imported_types) ... )”. � Para agregar los predicados del fichero importado en el

nuevo hay que escribir “(:predicates (add_imported_predicates) ... )”.

� Para agregar las acciones del fichero importado en el nuevo hay que escribir “(:actions add_imported_actions)”.

� Las precondiciones las copia literalmente, pero en el caso de encontrarse con la instrucción “(generate-basic-precondition)”, añade además las precondiciones estándar que agregaría si no hubiese habido precondiciones. Esto lo hace muy flexible, ya que puedes agregar las precondiciones básicas y otras mas especificas con pocas instrucciones.

� Con los efectos se hace los mismo que en las precondiciones cuando se encuentra con el comando “(generate-basic-effects)”.

� La formula se copia literalmente, salvo en el caso de encontrarse con la instrucción “interference-rule”. En este caso, significa que la formula no puede ser transmitida a Matlab, sino que solo va a ser utilizada por el planificador.

4.3 Kinematics_solver.c Realiza todas las llamadas al resto de programas, al planificador y a matlab. Tiene la siguiente estructura interna. � Inicializar � En esta sección se realizan la siguiente

secuencia de procesos: o Abre el fichero que define el dominio. o Obtiene las localizaciones de las acciones y las

agrega una por una en la lista de localizaciones. o Para cada una de las localizaciones también agrega

una operación en la lista de operaciones. � Solicitar Problema � En esta sección se realizan la siguiente

secuencia de procesos: o Se hace una llamada a Matlab para activar la interfaz

de entrada de datos. o El usuario inserta los datos del enunciado y los

resultados que desea obtener en cada problema. o Toda esta información se vuelca en un fichero

llamado datos.txt que será leído desde C para mayor comodidad en el intercambio de información.

� Generar Fichero PDDL � En esta sección se realizan la siguiente secuencia de procesos: o Abre la definición del conocimiento base. o Copia literalmente la sección delimitada por

“(:objects)”. o Con la sección delimitada por “(:init )”, la lee y

desarrolla los predicados que vienen enunciados, generando los que pueden ser leídos por el planificador.

o Por ultimo añade una sección “tengo” donde irán todos los datos iniciales que haya introducido el usuario, y una sección “goals” donde irán los datos que el usuario desea calcular.

o Como se pude ver, esa sección es un traductor de código de usuario a lenguaje PDDL, lo que facilita ampliamente el desarrollo de nuevos dominios de planificación y tipos de problemas.

� Ejecutar Planificador � El planificador que hemos utilizado es el SGPLAN. En esta sección se realizan la siguiente secuencia de procesos: o Se realiza una llamada al planificador anteriormente

indicado, generando un script capaz de ser interpretado por la consola y haciendo una llamada la sistema. Así se genera la salida del planificador llamada “out.soln”.

o Con esta salida, el programa es capaz de coger el identificador de cada acción, su correspondiente cálculo para ser enviado a Matlab y los argumentos que deberá sustituir en dicho cálculo, y así generar una lista de strings (“evalStrings”), que posteriormente serán enviados como comandos a Matlab.

� Resolver Plan � Aquí se hace la llamada a Matlab. En esta sección se realizan la siguiente secuencia de procesos: o Copian en un string con todos los datos simbólicos, y

otro que solo contiene los datos iniciales introducidos por el usuario.

o Abre la comunicación con Matlab. o Conociendo el listado de comandos que resuelven el

problema almacenados anteriormente en un conjunto de strings (“evalStrings”), evalúa en matlab la planificación con un determinado orden y añadiendo otros comandos auxiliares hasta obtener almacenados en el workspace de Matlab todas y cada una de las variables finales e intermedias en formato numérico, simbólico en función de los datos iniciales y simbólico en función de la fórmula de la que proviene dicha variable.

o Imprime por pantalla y en un fichero los siguientes datos y realiza las siguientes funciones: � El dominio y el problema que se planifica y

resuelve. � Listado de los datos previamente conocidos. � El resultado de la planificación, es decir, paso a

paso la resolución del problema. Indicando para ello la fórmula de origen de cada paso, y el valor simbólico (despejando dicha formula) y numérico del dato que se obtiene en cada paso.

� Listado de los resultados pedidos en formato numérico.

� Deja abierto Matlab en modo background para que el usuario pueda seguir realizando operaciones con los resultados obtenidos.

� Cuando el usuario termina, cierra esta comunicación y libera la memoria.

5. FICHEROS DE ENTRADA Y SALIDA Además de estos ficheros de código, también son necesarios otros denominados de entrada y salida, aquellos que son transformado o modificados por la aplicación.

Los mas importantes son los ficheros del planificador, que en nuestro caso van a ser tres (la explicación de esto se vera mas adelante en la sección 6).

� Fichero de dominio � Define el mundo en el que se va a desarrollar el problema, es decir, sus normas y sus reglas. A continuación se muestra un ejemplo de definición de una regla en PDDL que representa una formula:

EJEMPLO DE REGLA PDDL s = vi*t + (1/2)*a*t^2 (:action s-vt-1-2-at-2

:parameters (?s - esp ?vi - vel-inic ?t - t ?ai - acel-inic) :precondition (and (pred-s-vt-1-2-at-2 ?s ?vi ?t ?ai) (or (and (not (tengo ?s)) (tengo ?vi) (tengo ?t) (tengo ?ai)) (and (tengo ?s) (not (tengo ?vi)) (tengo ?t) (tengo ?ai)) (and (tengo ?s) (tengo ?vi) (not (tengo ?t)) (tengo ?ai)) (and (tengo ?s) (tengo ?vi) (tengo ?t) (not (tengo ?ai))))) :effect (and (tengo ?s) (tengo ?vi) (tengo ?t) (tengo ?ai)) )

EJEMPLO FICHERO DE DOMINIO

(define (domain cinematica-basica-1) (:types cuerpo - object

tiempo - object t t-inic t-fin - object

vector - object espacio - vector esp esp-inic esp-fin - vector esp-mod esp-x esp-y - esp esp-inic-mod esp-inic-x esp-inic-y - esp-inic esp-fin-mod esp-fin-x esp-fin-y - esp-fin velocidad - vector vel vel-inic vel-fin - velocidad vel-mod vel-x vel-y - vel vel-inic-mod vel-inic-x vel-inic-y - vel-inic vel-fin-mod vel-fin-x vel-fin-y - vel-fin aceleracion - vector acel acel-inic acel-fin - aceleracion acel-mod acel-x acel-y - acel acel-inic-mod acel-inic-x acel-inic-y - acel-inic acel-fin-mod acel-fin-x acel-fin-y - acel-fin

angulo - object theta alpha - angulo )

(:predicates (tengo ?o) (symbol ?parametro) (generate-predicates) )

(:action iguales :parameters (?o1 ?o2) :formula '#1 = #2' )

(:action incremento :parameters (?incr ?final ?inicial) :formula '#1 = #2 - #3' )

(:action s-vt-1-2-at-2 :parameters (?s - esp ?vi - vel-inic ?t - t ?ai - acel-inic) :formula '#1 = #2*#3 + (1/2)*#4*#3^2' )

(:action v-at :parameters (?v - vel ?ai - acel-inic ?t - t) :formula '#1 = #2*#3' )

(:action vf2-vi2-2as :parameters (?vf - vel-fin ?vi - vel-inic ?ai - acel-inic ?s - esp) :formula '#1^2 - #2^2 = 2*#3*#4' )

(:action triang-rect-pitagoras :parameters (?v ?vx ?vy - vector) :formula '#1^2 = #2^2 + #3^2' )

(:action triang-rect-tangente :parameters (?th - angulo ?vy ?vx - vector) :formula 'tan(#1) = #2/#3' )

(:action triang-rect-coseno :parameters (?th - angulo ?vx ?v - vector) :formula 'cos(#1) = #2/#3' )

(:action triang-rect-seno :parameters (?th - angulo ?vy ?v - vector) :formula 'sin(#1) = #2/#3' )

)

� Fichero de problema � Aquí se definen los datos del problema en particular, que dependerá de cada caso concreto, y que deberá pertenecer al dominio en el que este descrito. Es interno y no es de entrada.

� Fichero de conocimiento básico � Es un fichero que define un conocimiento base complementario al dominio, es decir, todos los objetos de los que dispongo y sus relaciones entre ellos. Esto es algo genérico y ha de ir siempre junto con el domino para que tenga sentido. A continuación se muestra un ejemplo:

EJEMPLO FICHERO DE CONOCIMIENTO BÁSICO

(define (problem problema1) (:domain basic-kinematics) (:objects t - t

ti - t-inic tf - t-fin s - esp-mod sx - esp-x sy - esp-y si - esp-inic-mod six - esp-inic-x siy - esp-inic-y sf - esp-fin-mod sfx - esp-fin-x sfy - esp-fin-y v - vel-mod vx - vel-x vy - vel-y vi - vel-inic-mod vix - vel-inic-x viy - vel-inic-y vf - vel-fin-mod vfx - vel-fin-x vfy - vel-fin-y a - acel-mod ax - acel-x ay - acel-y ai - acel-inic-mod aix - acel-inic-x aiy - acel-inic-y af - acel-fin-mod afx - acel-fin-x afy - acel-fin-y

th_s th_si th_sf th_v th_vi th_vf th_a th_ai th_af - theta

)

(:init (pred-iguales a ai,a af,ax aix,ax afx,ay aiy,ay afy) (pred-incremento t tf ti,sx sfx six,sy sfy siy,vx vfx vix,vy vfy viy,ax afx aix,ay afy aiy) (pred-s-vt-1-2-at-2 sx vix t aix,sy viy t aiy) (pred-v-at vx aix t,vy aiy t) (pred-vf2-vi2-2as vfx vix aix sx,vfy viy aiy sy) (pred-p-m-v cantx m vx,canty m vy,cantix m vix,cantiy m viy,cantfx m vfx,cantfy m vfy)

(pred-cartesiano-polar sx sy s th_s,six siy si th_si,sfx sfy sf th_sf) (pred-cartesiano-polar vx vy v th_v,vix viy vi th_vi,vfx vfy vf th_vf) (pred-cartesiano-polar ax ay a th_a,aix aiy ai th_ai,afx afy af th_af) ) )

6. PLANIFICADOR 6.1 Idea de qué es un planificador Un planificador es un programa que a partir de un fichero con el dominio del problema y otro con los datos del problema el estado de partida y el de llegada, es capaz de trazar la ruta mas corta desde el estado inicial al final.

6.2 Arquitectura La arquitectura del planificador es la que se muestra en la figura 7.

Figura 7. – Estructura de la arquitectura del planificador SGPLAN.

Este planificador lo que hace es coger particiones muy grandes y dividirlas en otras mas pequeñas, cada una de las cuales es un nuevo objetivo de planificación.

Este planificador generaliza las submetas para explotar de manera mas eficiente las nuevas características de los anteriores planificadores.

Se han desarrollado técnicas para que este planificador pueda resolver las restricciones, optimizándolas preferencias de los objetivos, y alcanzando submetas en una representación multivalor.

Esta implementación que hemos usado, utiliza una modificación de la métrica básica del panificador FF

6.3 Lenguaje de planificación PDDL PDDL es un lenguaje de planificación. Se utiliza para la representación del conocimiento.

Para el funcionamiento de PDDL son necesarios dos ficheros: � Uno para definir el dominio, es decir, como se comporta el

mundo, que tipos de objetos hay, las posibles relaciones entre ellos (predicados) y las reglas que rigen dicho mundo (acciones). En nuestro caso va a ser el mundo de la física y as matemáticas.

� Y otro para definir un problema concreto definido para un dominio determinado, en el se especifican el dominio al que pertenece, los objetos de los que partimos y sus tipos, y lo mas importante, la definición de un estado inicial y otro final.

Todo estado viene representado por un conjunto de predicados y un planificador, que lo que hace es buscar una sucesión de acciones que permitan ir saltando de estado a estado, partiendo del inicial y buscando la meta, mientras pasa por otros intermedios. Además un planificador intenta siempre que puede encontrar una solución con el menor numero de transiciones posibles, es decir, una solución de un planificador no es mas que una sucesión de acciones (lo mas corta posible) que permiten llegar al estado final a partir del inicial.

Todo esto que hemos visto sirve para un sistema de planificación generalizado. PDDL no es mas que un lenguaje para la definición de esos dominós y problemas. Para el caso que nos ocupa, que no es mas que resolver problemas con formulas, vemos que PDDL se ajusta muy bien a nuestro propósito, ya que no hay mas que poner todas las combinaciones posibles y siempre nos dará una solución. Ahora bien, esto puede resultar un labor realmente tediosa desde le punto de vista de programación, ya que existen numerosas combinaciones par una única formula, y con toda seguridad se dispondrá de varias. En general lo que ocurre y para lo que se utilizan los planificadores es para casos en los que hay muy pocos objetos y muchas reglas y predicados, lo que conlleva una solución muy larga en la mayoría de los casos. En nuestro caso, lo que ocurre es que además de tener muchas reglas, también tenemos muchos objetos (planificadores menos potentes como el caso de Prodigy no eran capaces de dar una solución de implementación a nuestro problema). Por eso este tipo de representación no era el adecuado. La solución es dar la vuelta a esta idea, que aunque parece mas complicada en realidad es mucho mas eficaz. Lo que se hace es asignar con predicados cada una de las posibilidades para una formula, es decir, en lugar de definir en las precondiciones de una regla que un objeto ‘Vix’ sea del tipo velocidad, del eje-x y del instante inicial y tener después en el problema definir también estos predicados, lo que hacemos es definir un único predicado, por ejemplo (pred-v-at ?v ?a ?t), y decir que todo aquel conjunto de variables que cumplan eso, pueden usarse para dicha formula ("v = a*t"). Eso si, hay que especificar en el problema cada una de las combinaciones, por ejemplo: (pred-v-at vx aix t)

(pred-v-at vy aiy t) Por ese motivo nos inclinamos por la creación de PSPDDL.

6.4 Lenguaje de planificación PSPDDL Este lenguaje ha sido desarrollado por nosotros con el fin de hacer mas flexible y sencilla la programación de nuevos dominios para la solución de problemas. Vistas las limitaciones que nos impone PDDL, debido a que para la resolución de una ecuación con n parámetros, necesitábamos ncombinaciones, decidimos desarrollar PSPDDL. PSPDDL no es mas que un traductor. Esta basado en PDDL, pero por su condición, pertenece a un nivel de programación superior a este. Con este nuevo lenguaje ya no hace falta repetir cada una de las combinaciones manualmente, sino que las generar él automáticamente. Solo con indicar el nombre de la acción ya seria suficiente en un primer momento. Ahora bien, además de esto, PSPDDL tiene algunos complementos que facilitan a un mas si cabe, la flexibilidad y sencillez a la hora de programar. Da la opción de añadir precondiciones, de sustituirlas completamente sin mas que escribiéndolas, permite poner tus propias precondiciones y efectos o bien añadir los estándares, etc… Pero lo mas importante es que permite la definición matemática de la formula, que en principio no es relevante para el planificador, pero nos sirve para pasarlas como comandos a Matlab e ir teniendo un desarrollo matemático de todo el proceso. Hemos visto que un planificador genérico siempre utiliza dos ficheros, el que define el dominio y el que define el problema. Sin embargo ahora se van a usar 2+1 ficheros. Esto quiere decir que además de los dos habituales que eran externos, se va a usar uno mas de tipo interno que se va a generar a partir de los datos iniciales. En lo respectivo al dominio, éste se va a ver simplificado gracias a la nueva instrucción para la importación de otros ficheros, y como gran parte del código es repetitivo, también existe la opción de generarse automáticamente. Es decir, tenemos un predicado especial para cada una de las reglas y se va generando automáticamente usando la instrucción (generate-predicates) dentro de la definición de los predicados. Lo que hacemos con esto es tener un fichero de dominio mucho mas organizado, mas claro, mas simplificado, y mas flexible. Con la importación de ficheros ahorramos escribir muchísimo código. Digamos que nuestro lenguaje permite la definición de dominios utilizando la idea de herencia, por ello permite la herencia de la definición de tipos de objetos, de predicados y/o acciones, sin implicar que haya que heredarlo todo Por otro lado el fichero de definición de problema, ahora tiene dos funciones, la general y la de crear el fichero interno del problema ya en lenguaje PDDL y no en PSPDDL. Las acción y formulas que se definen en un dominio son generales, pero necesitan unos predicados especiales, sin los cuales no funcionaria nada, es decir, en un mundo donde solo supongamos tiros parabólicos sea cual sea el problema a resolver,

las reglas y las combinaciones siempre van a ser las mismas, solo variaran los valores del estado inicial y final. Por eso creamos un fichero que define un conocimiento base complementario al dominio, es decir, todos los objetos de los que dispongo y sus relaciones entre ellos. Esto es algo genérico y ha de ir siempre junto con el domino para que tenga sentido. Por ultimo vamos a ver el porqué de existen tantos tipos de objetos. Lo que ocurre es que hay una gran limitación de los planificadores porque requieren muchísima memoria. El consumo de esta es exponencial, ya que necesita almacenar todos y cada uno de los estados (con todos los predicados en cada momento) hasta llegar al final. Y no solo hasta llegar el final, porque ha de buscar otras posibilidades por si encuentra otra mas corta. Entonces, el planificador, ante una regla, lo que hace es probar todas las posibilidades para ver cual cumple la precondición. Por supuesto esto es muy lento. Por eso cuando implementaron PDDL2, ya incluyeron la definición de tipos, que añade la ventaja que en lugar de probar con todos los objetos en todas las posibilidades, solo lo hace con aquellos objetos del tipo que se define en los parámetros de la acción o regla.

6.4.1 BNF de PSPDDL

Domains <import> ::= (import <name>) <domain> ::= (define (domain <name>)

[<require-def>] [<types-def>]:typing [<predicates-

def>] <structure-def>∗ )

<require-def> ::= (:requirements <require-key>+ )

<require-key> ::= ver sección de requirements <types-def> ::= (:types [(add-imported-types)] <typed

list (name)>) <predicates-def> ::= (:predicates <atomic

formula skeleton>+ )

<atomic formula skeleton> ::= (add-imported-predicates) <atomic formula skeleton> ::= (generate-predicates) <atomic formula skeleton> ::= (<predicate> <typed

list (variable)>) <predicate> ::= <name> <variable> ::= ?<name> <structure-def> ::= <action-def>

<typed list (x)> ::= x∗

<typed list (x)> ::= :typing x+ - <type> <typed list(x)>

<primitive-type> ::= <name>

<type> ::= (either <primitive-type>+ )

<type> ::= <primitive-type> <emptyOr (x)> ::= () <emptyOr (x)> ::= x

<action-def> ::= (:action add-imported-actions) <action-def> ::= (:action <action-symbol> :parameters

(<typed list (variable)>) <action-def body>)

<action-symbol> ::= <name> <action-def body> ::= [:precondition <emptyOr (pre-GD)>]

[:effect <emptyOr (effect)>] [:formula <formula>+]

<pre-GD> ::= (generate-basic-precondition) <pre-GD> ::= <pref-GD>

<pre-GD> ::= (and <pre-GD>∗ )

<pre-GD> ::= :universal−preconditions (forall (<typed list(variable)>) <pre-GD>)

<pref-GD> ::= <GD> <pref-name> ::= <name> <GD> ::= <atomic formula(term)>

<GD> ::= :negative−preconditions <literal(term)>

<GD> ::= (and <GD>∗ )

<GD> ::= :disjunctive−preconditions (or <GD>∗ )

<GD> ::= :disjunctive−preconditions (not <GD>)

<GD> ::= :disjunctive−preconditions (imply <GD> <GD>)

<GD> ::= :existential−preconditions (exists (<typed list(variable)>) <GD> )

<GD> ::= :universal−preconditions (forall (<typed list(variable)>) <GD> )

<literal(t)> ::= <atomic formula(t)> <literal(t)> ::= (not <atomic formula(t)>)

<atomic formula(t)> ::= (<predicate> t∗ )

<term> ::= <name> <term> ::= <variable> <f-exp> ::= <number>

<effect> ::= (and <c-effect>∗ )

<effect> ::= <c-effect> <c-effect> ::= (generate-basic-effect)

<c-effect> ::= :conditional−effects (forall

(<typed list (variable)>∗ ) <effect>)

<c-effect> ::= :conditional−effects (when <GD> <cond-effect>)

<c-effect> ::= <p-effect> <p-effect> ::= (not <atomic formula(term)>) <p-effect> ::= <atomic formula(term)>

<cond-effect> ::= (and <p-effect>∗ )

<cond-effect> ::= <p-effect>

<formula> ::= ' <caracter>+ '

<formula> ::= “ <caracter>+ ”

Knowledge_bases <knowledge> ::= (define (knowledge <name>)

(:domain <name>) <object declaration> <knowledge>)

<object declaration> ::= (:objects <typed list (name)>)

<knowledge> ::= (:knowledge <know-el>∗ )

<know-el> ::= <literal(name)> <know-el> ::= (<predicate> <combination> [

, <combination>]∗ )

<combination> ::= <name>+

Allowed requirementsRequirement Description :strips Basic STRIPS-style adds and

deletes :typing Allow type names in declarations

of variables :negative-preconditions Allow not in goal descriptions :disjunctive-preconditions Allow or in goal descriptions :equality Support = as built-in predicate :existential-preconditions Allow exists in goal descriptions :universal-preconditions Allow forall in goal descriptions :quantified-preconditions = :existential-preconditions +

:universal-preconditions :conditional-effects Allow when in action effects :adl = :strips + :typing + :negative-preconditions + :disjunctive-preconditions + :equality + :quantified-preconditions + :conditional-effects

7. MANEJO Y UTILIZACIÓN DE LA APLICACIÓN Este programa ha sido desarrollado con la idea de hacer muy sencillo para el usuario su utilización.

El programa hace todos los cálculos, traducciones de código, y cambios en los ficheros internamente y en una única ejecución, con lo que se consigue que el usuario no perciba ninguna de estas actividades.

Por el contrario, alguien que quiera utilizar el programa, lo único que tendrá que hacer es rellenar los datos que una interfaz grafica le ira facilitando, de forma que solo tendrá que indicar que datos se dan en el enunciado del problema y sus respectivos valores, y cuales son los que se poden calcular.

Una vez hecho esto, lo que aparecerá por pantalla, y también se escribirá en un fichero de texto, será el resultado de la planificación paso a paso, y los resultado numéricos de las variables pedidas.

La interfaz es la que se muestra en la figura 8.

Figura 8. – Captura de la interfaz de entrada de datos del programa.

8. PRESTACIONES Hemos creado un nuevo lenguaje de definición de dominios para planificación basada en PDDL, de forma que permite introducir ecuaciones de forma muy sencilla. Con esto conseguimos crear dominios para nuevos problemas de una manera rápida y sencilla.

Además la estructura de este nuevo lenguaje es muy flexible, ya que permite importar ficheros, utilizar generación automática de predicados y acciones y en muchos casos no importa el orden en el que e desarrollen las cosas, porque automáticamente lo ordena.

Permite, a partir de un dominio y un conocimiento bases, obtener una solución a un problema (que pertenezca al dominio definido), de forma detallada.

No solo resuelve el problema (cosa que podría hacerse con Matlab directamente), sino que además proporciona los pasos y las formulas utilizadas para dicha resolución, utilizando una lógica similar a la humana, lo que lo convierte en una herramienta muy eficaz desde el punto de vista docente

Una vez resulto el problema, el usuario tiene varias posibilidades:

� Puede consultar el resultado numérico de los datos que pidió resolver tantas veces como desee.

� Puede también consultar los resultados de forma simbólica, de forma que se expresen despejados en una formula.

� O puede pedir que el resultado simbólico se exprese en una formula en función de los datos iniciales.

� Además permite utilizar otras funciones que también definimos para profundizar mas en la solución:

o Integrar. o Derivar.

o Maximizar. o Minimizar. o Representar gráficamente

� Todo esto vale para tanto para los valores finales como para todos los intermedios.

9. ANEXO.- EJEMPLO DE FICHERO PDDL (define (domain cinematica-basica-1)

(:requirements :adl) (:types cuerpo - object

tiempo - object t t-inic t-fin - object

vector - object espacio - vector esp esp-inic esp-fin - vector esp-mod esp-x esp-y - esp esp-inic-mod esp-inic-x esp-inic-y - esp-inic esp-fin-mod esp-fin-x esp-fin-y - esp-fin velocidad - vector vel vel-inic vel-fin - velocidad vel-mod vel-x vel-y - vel vel-inic-mod vel-inic-x vel-inic-y - vel-inic vel-fin-mod vel-fin-x vel-fin-y - vel-fin aceleracion - vector acel acel-inic acel-fin - aceleracion acel-mod acel-x acel-y - acel acel-inic-mod acel-inic-x acel-inic-y - acel-inic acel-fin-mod acel-fin-x acel-fin-y - acel-fin

angulo - object theta alpha - angulo )

(:predicates (tengo ?o) (symbol ?parametro) (pred-iguales ?o1 ?o2) (pred-incremento ?incr ?final ?inicial) (pred-s-vt-1-2-at-2 ?s - esp ?vi - vel-inic ?t - t ?ai - acel-inic) (pred-v-at ?v - vel ?ai - acel-inic ?t - t) (pred-vf2-vi2-2as ?vf - vel-fin ?vi - vel-inic ?ai - acel-inic ?s - esp) (pred-triang-rect-pitagoras ?v ?vx ?vy - vector) (pred-triang-rect-tangente ?th - angulo ?vy ?vx - vector) (pred-triang-rect-coseno ?th - angulo ?vx ?v - vector) (pred-triang-rect-seno ?th - angulo ?vy ?v - vector))

(:action iguales :parameters (?o1 ?o2) :precondition (and (pred-iguales ?o1 ?o2)

(or (and (not (tengo ?o1)) (tengo ?o2)) (and (tengo ?o1) (not (tengo ?o2))))) :effect (and (tengo ?o1) (tengo ?o2)) ;:formula '#1 = #2' )

(:action incremento :parameters (?incr ?final ?inicial) :precondition (and (pred-incremento ?incr ?final ?inicial) (or (and (not (tengo ?incr)) (tengo ?final) (tengo ?inicial)) (and (tengo ?incr) (not (tengo ?final)) (tengo ?inicial)) (and (tengo ?incr) (tengo ?final) (not (tengo ?inicial))))) :effect (and (tengo ?incr) (tengo ?final) (tengo ?inicial)) ;:formula '#1 = #2 - #3' )

(:action s-vt-1-2-at-2 :parameters (?s - esp ?vi - vel-inic ?t - t ?ai - acel-inic) :precondition (and (pred-s-vt-1-2-at-2 ?s ?vi ?t ?ai) (or (and (not (tengo ?s)) (tengo ?vi) (tengo ?t) (tengo ?ai)) (and (tengo ?s) (not (tengo ?vi)) (tengo ?t) (tengo ?ai)) (and (tengo ?s) (tengo ?vi) (not (tengo ?t)) (tengo ?ai)) (and (tengo ?s) (tengo ?vi) (tengo ?t) (not (tengo ?ai))))) :effect (and (tengo ?s) (tengo ?vi) (tengo ?t) (tengo ?ai)) ;:formula '#1 = #2*#3 + (1/2)*#4*#3^2' )

(:action v-at :parameters (?v - vel ?ai - acel-inic ?t - t) :precondition (and (pred-v-at ?v ?ai ?t) (or (and (not (tengo ?v)) (tengo ?ai) (tengo ?t)) (and (tengo ?v) (not (tengo ?ai)) (tengo ?t)) (and (tengo ?v) (tengo ?ai) (not (tengo ?t))))) :effect (and (tengo ?v) (tengo ?ai) (tengo ?t)) ;:formula '#1 = #2*#3' )

(:action vf2-vi2-2as :parameters (?vf - vel-fin ?vi - vel-inic ?ai - acel-inic ?s - esp) :precondition (and (pred-vf2-vi2-2as ?vf ?vi ?ai ?s) (or (and (not (tengo ?vf)) (tengo ?vi) (tengo ?ai) (tengo ?s)) (and (tengo ?vf) (not (tengo ?vi)) (tengo ?ai) (tengo ?s)) (and (tengo ?vf) (tengo ?vi) (not (tengo ?ai)) (tengo ?s)) (and (tengo ?vf) (tengo ?vi) (tengo ?ai) (not (tengo ?s))))) :effect (and (tengo ?vf) (tengo ?vi) (tengo ?ai) (tengo ?s)) ;:formula '#1^2 - #2^2 = 2*#3*#4' )

(:action triang-rect-pitagoras :parameters (?v ?vx ?vy - vector) :precondition (and (pred-triang-rect-pitagoras ?v ?vx ?vy) (or (and (not (tengo ?v)) (tengo ?vx) (tengo ?vy)) (and (tengo ?v) (not (tengo ?vx)) (tengo ?vy)) (and (tengo ?v) (tengo ?vx) (not (tengo ?vy))))) :effect (and (tengo ?v) (tengo ?vx) (tengo ?vy)) ;:formula '#1^2 = #2^2 + #3^2' )

(:action triang-rect-tangente :parameters (?th - angulo ?vy ?vx - vector) :precondition (and (pred-triang-rect-tangente ?th ?vy ?vx)

(or (and (not (tengo ?th)) (tengo ?vy) (tengo ?vx)) (and (tengo ?th) (not (tengo ?vy)) (tengo ?vx)) (and (tengo ?th) (tengo ?vy) (not (tengo ?vx))))) :effect (and (tengo ?th) (tengo ?vy) (tengo ?vx)) ;:formula 'tan(#1) = #2/#3' )

(:action triang-rect-coseno :parameters (?th - angulo ?vx ?v - vector) :precondition (and (pred-triang-rect-coseno ?th ?vx ?v) (or (and (not (tengo ?th)) (tengo ?vx) (tengo ?v)) (and (tengo ?th) (not (tengo ?vx)) (tengo ?v)) (and (tengo ?th) (tengo ?vx) (not (tengo ?v))))) :effect (and (tengo ?th) (tengo ?vx) (tengo ?v)) ;:formula 'cos(#1) = #2/#3' )

(:action triang-rect-seno :parameters (?th - angulo ?vy ?v - vector) :precondition (and (pred-triang-rect-seno ?th ?vy ?v) (or (and (not (tengo ?th)) (tengo ?vy) (tengo ?v)) (and (tengo ?th) (not (tengo ?vy)) (tengo ?v)) (and (tengo ?th) (tengo ?vy) (not (tengo ?v))))) :effect (and (tengo ?th) (tengo ?vy) (tengo ?v)) ;:formula 'sin(#1) = #2/#3' )

)