Pequeño Manual de ISetL

0. Información sobre el software.
1. Introducción.
2. Ventana de Ejecución.
2.1 Definiciones y evaluación de expresiones
	2.2 Expresiones y operaciones
                        2.2.1 Cláusula if
                        2.2.2 Constantes, variables y expresiones compuestas 
			* Constantes y variables
			* Expresiones booleanas 
* Conjuntos
* Tuplas y Strings
			* Funciones:
				- Definiciones recursivas.
				- Aplicación y composición
- Definiciones locales.
            2.3 Directivas.
	2.4 Código.
3. Ventana Gráfica. 
4. Glosario
5. Referencias
6. Apéndice A: Limitaciones de ISetL.
7. Apéndice B: Situaciones de sintaxis incorrecta.
0. Información sobre el software

El programa y la documentación sobre el mismo se encuentran en el sitio de Internet: http://isetlw.muc.edu/isetlw El programa es de libre distribución.

1. Introducción
ISetL pertenece a un paradigma de lenguajes de programación, llamado lenguaje de programación matemática. Los lenguajes de este paradigma se caracterizan por poseer una sintaxis similar a la notación matemática estándar. Algunos lenguajes de este paradigma son Maple, Mathematica, Matlab, Derive, Cabri, etc, donde algunos han sido desarrollados para la investigación en matemática, por ejemplo Maple. ISetL por el contrario es específico para la enseñanza de matemática, especialmente para cursos de grado.

            ISetL  es un lenguaje de programación interactivo. Entre otras cosas esto significa que la comunicación con el usuario se realiza por medio de sesiones (ver Glosario). Para iniciar una sesión con ISetL, se hace doble “click” sobre el icono de “ISETLW”, con lo cual se arranca el programa y aparecen en pantalla dos ventanas: la ventana de ejecución y la ventana gráfica. Es en la primera donde el usuario desarrolla su sesión, en la segunda aparecen las representaciones gráficas cuando es necesario (por ejemplo, de una relación o de una función). Para abandonar una sesión, se hace “click” en la palabra exit de la barra superior, o se ingresa la directiva !quit (ver “directivas”).
 La ventana gráfica no es usada en general en un curso de matemática discreta (ver Apéndice A), por lo cual puede bajarse a la barra inferior de la pantalla cliqueando en el cuadradito superior derecho que tiene un - (ISetL no permite cerrarla).

        Para trabajar con ISetL se cuenta con objetos predefinidos. Estos son objetos que ISetL reconoce y que el usuario puede utilizar sin necesidad de definirlos previamente. Tales son por ejemplo las constantes numéricas, las operaciones aritméticas, el conjunto vacío, las operaciones básicas con conjuntos, etc.
Si bien ISetL es adecuado para la enseñanza, es necesario tener en cuenta algunas carencias que deben ser señaladas, por ejemplo que no es un lenguaje tipado, que la definición de las funciones y de los procedimientos es confusa, etc. Para más detalles ver el apéndice A.
En la barra de menú, se encuentra la palabra “Help”. Cliqueando en ella, se abren varias opciones para obtener ayuda sobre ISetL. Cliqueando en la primera de ellas, “Contents”, se accede a un manual on-line de ISetL y dentro del mismo, en “ISETL Language reference” se tiene “Predefined routines” y “Reserved words”, con una descripción de los objetos predefinidos. 

2. Ventana de Ejecución

Al iniciar una sesión en ISetL, aparece en la ventana de ejecución, el símbolo ‘>’, que indica que ISetL está pronto para interactuar con el usuario. Las frases (ver Glosario) que ISetL comprende son: expresiones, definiciones, directivas y fragmentos de código. Cada frase puede comprender más de un renglón, el símbolo ‘>>’ indica que la frase está incompleta. Cada frase debe terminar con el símbolo ‘;’. El signo ‘$’ se utiliza para introducir comentarios, los cuales son ignorados por ISetL.

2.1 Definiciones y Evaluación de expresiones

Las definiciones permiten extender el conjunto de objetos predefinidos con otros definidos por el usuario. Ejemplo:

>                        $ este es un comentario
>    x:=2;               $ se define la variable x y se le asocia el                             
                         $ valor 2
>    A:={0,2,4,6};       $ se define la variable A y se le asocia el 
                         $ conjunto (valor) {0,2,4,6}
>    p:= x in A;         $ se define p como el valor de la expresión 
                         $ x Î A (true)

     El símbolo := se lee “se define como”. La sintaxis de una definición es:

nombre := expresión;

donde nombre es cualquier palabra no reservada (ver “reserved words” en el manual on-line) y expresión es cualquiera de las que se describen mas adelante.

Evaluación de expresiones
 
Las expresiones son evaluadas por ISetL hasta su  forma canónica (valor). Si ésta existe, ISetL la imprime en pantalla, si no, imprime la palabra OM, que representa el objeto indefinido, o imprime un mensaje de error. Ejemplos:

> 2 + 3;                  $ la función suma aplicada a 2 y 3
  5;                      $ ISetL evalúa la expresión e imprime su 
                          $ valor
> 2 / 0;                  $ al intentar evaluar esta expresión
  ¡Error: Divide by zero  $ no llega a la forma canónica y reconoce 
                          $ el error

> 2 * y;                  $ y es una variable indefinida
  ¡Error : 2 * OM         $ por lo tanto la expresión no tiene forma 
                            $ canónica

2.2 Expresiones y operaciones

Las expresiones pueden ser:

•	cláusula if
•	constantes 
•	variables
•	expresiones formadas por operaciones aplicadas a expresiones

Cada tipo de expresión tiene operaciones que le corresponden, que pueden ser o bien predefinidas o bien definidas por el usuario. Por ejemplo, podemos sumar dos expresiones enteras o hallar la unión entre dos conjuntos, pero no tiene sentido pretender hacer la unión de un número y un conjunto. El usuario puede definir una función que halle el máximo común divisor de dos números, y no tiene sentido que defina esa función para objetos de otro tipo.

 2.2.1 Cláusula if

 Las expresiones que llamamos Cláusula if se describen a continuación:

La cláusula condicional if,  puede escribirse de dos formas :

•	if  condición then lista de frases de ISetL ; end;

•	if condición  then lista de frases de ISetL ;
         else lista de frases de ISetL ; end;    

La ejecución de esta cláusula requiere la evaluación de la expresión booleana condición. Si esta expresión es verdadera, se ejecuta la lista de frases inmediatamente posterior a then. En caso contrario, se termina la ejecución de la cláusula if exitosamente o se ejecuta la lista de frases inmediatamente posterior a else, según corresponda.

Observar que en ambos casos las cláusulas if, finalizan con la palabra reservada end.
 La lista de frases de ISetL indicada después del then o del else es cualquiera válida, inclusive un if, como se ve en la definición de la función mcd (máximo común divisor) más adelante.

     2.2.2 Constantes, variables y expresiones compuestas

* Las constantes pueden ser:

•	constantes booleanas: true, false
•	constantes numéricas: naturales, enteros, reales (en su representación decimal)
•	conjuntos finitos
•	tuplas finitas
•	funciones

* Las variables en ISetL pueden denotar cualquier expresión. Como ISetL no es un lenguaje tipado, las variables no tienen tipo (o los tienen todos) y lo que determina el tipo de la expresión en algunos casos, es la operación involucrada. Por ejemplo en las expresiones, 

                         not p                              
                         p and q                           
                         p or q                             
                         p impl q

se deduce por las operaciones lógicas (no, y, o e implica) que las variables son booleanas. Sin embargo como en algunas operaciones están sobrecargadas (se usa el mismo símbolo para operaciones distintas) no siempre es claro que tipo tiene la expresión. Por ejemplo en 

                m + n 

m y n podrían ser variables numéricas, conjuntos o tuplas (ver Apéndice A).
 
A las expresiones formadas por operaciones aplicadas a otras expresiones les llamamos expresiones compuestas.

* Las expresiones booleanas son aquellas que al ser evaluadas, dan un valor del conjunto Bool, es decir, true o false. Ejemplos:

>  2*3  > 4;
true;
>  forall n in [1..100] | not (n div 10) = 9;
false;
>  exists n in [1..100] | not (n div 10) = 9;
true;
>  y div 10 = 9;
!Error: Bad arguments in: OM div 10;

 Observar que si la expresión contiene variables, estas deben estar o bien definidas (tener un valor asociado), o ser ligadas por el cuantificador forall (para todo) o el cuantificador exists (existe) para que pueda ser evaluada, si no el valor es indefinido.

* Conjuntos

En ISetL se pueden representar conjuntos finitos solamente, ya sea por extensión o por comprensión. Por extensión se indican los elementos entre llaves y separados por comas como en matemática; si los elementos están en progresión aritmética, se indican los dos primeros, dos puntos seguidos y el último elemento (o uno inmediatamente mayor, ver tercer ejemplo a continuación); si la razón es 1 se indican solo el primero y el último, separados por dos puntos. Ejemplos:

>    {0,7,2,-1,5};
>    {1 .. 10};         $ es el conjunto de números naturales 
                          $ consecutivos del 1 al 10
>    {-0.4,0.4 .. 3}    $ es el conjunto {-0.4,0.4, 1.2, 2.0, 2.8}

Por comprensión, también la notación es similar a la matemática: por ejemplo, el conjunto { x : x Î {1,2,...,50} | x es múltiplo de 2} se puede escribir en ISetL de las siguientes maneras, entre otras:

>    { x : x in {1..50} | even(x)};
>    { x : x in {1..50} | x mod 2 = 0};
>    { 2 * x : x in {1..25}};

even es una función predefinida que testa si un número es par, mod es una función predefinida que devuelve el resto de la división entera de un número por otro (ver “predefined routines” en el manual on-line). En el último caso se muestra que no es necesario indicar la condición que deben cumplir los elementos, pues ya se indica en la expresión 2*x. 

Observar que no se puede indicar como dominio N o Z por ejemplo, ya que ISetL no permite trabajar con conjuntos infinitos.

La sintaxis general es: 

{ expresión : especificador de dominio | condición};

donde el especificador de dominio indica el conjunto al que pertenece la o las variable/s, que aparecen en expresión, y la condición debe ser una expresión booleana, es decir que al ser evaluada sea verdadera o falsa.

Operaciones predefinidas para los conjuntos:

A union B o A + B (unión de A y B)
A inter B o A * B (intersección de A y B)
A – B             (conjunto de elementos de A que no  
                   están en B)
	A subset B (true si A es subconjunto de B,false si no)
     x in A (true si x Î A, false si no)
     #A     (número de elementos de A)
     pow(A) (conjunto de subconjuntos de A)

* Tuplas y strings

La sintaxis es similar a la de conjuntos pero se escriben corchetes en vez de llaves:
Ejemplos: [2,3] es un par ordenado.
                         [“a”,1, {}] es una terna.

Los caracteres pertenecen a un conjunto de símbolos que pueden representarse en la computadora. En ISetL se denotan entre comillas. Ejemplo: “$”, “ ”, “a”, “A”, “0”, “1”, etc. Observar que el carácter “1” no es el número natural 1 y que el espacio en blanco es un carácter.

Los strings son tuplas de caracteres y para denotarlos, se usa una  abreviación como sigue:
[“I”,”S”,”e”,”t”,”L”] se escribe “ISetL”.

Operaciones predefinidas para  tuplas:

El símbolo + se utiliza para denotar la concatenación de tuplas, por ejemplo:
“cuarenta “ + “y” + “ seis” es “cuarenta y seis”.

Podemos acceder a los elementos de una tupla, de a uno o en un intervalo:
>	[1,2](1);
1;	
>	[1,2,3,4,5](1..3);
[1, 2, 3];

 En general : [a1, a2, …, an] (i) es el i-ésimo elemento de la tupla, con 1 ≤ i ≤ n.
 [a1, a2, …, an] (i ..j) es la tupla de los elementos de [a1, a2, …, an] entre i y j.

* Funciones

Las funciones pueden representarse en ISetL como conjuntos de pares ordenados (smap) o como reglas de transformación (func), o sea como elementos de un conjunto A ® B, donde A es el conjunto de elementos a los cuales puede aplicarse la regla (dominio) y B es el conjunto de elementos que resultan al aplicar la regla (co-dominio). Notar que esta manera de definir funciones es incompleta, ya que no se explicita el dominio y el co-dominio (ver Apéndice A).

Ejemplos:

>   $ smap
>   f := {[1,3],[3,5],[6,7]};  $ se define f como un conjunto de   
                               $ pares
>   is_map(f);                 $ is_map es una función predefinida
true; 

>   $ regla de transformación
>   doble:=func(x);
>>       if is_number (x) then 
>>           return 2 *x;
>>       end;
>>   end;

Esta última definición se lee así: “se define doble como una función que toma un número x y devuelve 2*x”. Las palabras reservadas func, return y end siempre deben aparecer en la definición de una función. A continuación de func, se indica la lista de argumentos, en este caso x (de existir más de 1 argumento, éstos se separan con coma), a continuación de return se indica lo que devuelve y se termina la definición con end;
En este caso, la regla de transformación (método o algoritmo) está descrita por la expresión 2*x.

>   is_func(doble);              $ is_func es una función 
                                   $ predefinida
true; 
>   is_map(doble);              $ is_map es una función 
                                $ predefinida
false; 

Como desgraciadamente en ISetL no se exige indicar el dominio y co-dominio como parte de la definición de la función, comenzamos con la cláusula “if is_number (x)” etc, de modo de asegurar que x pertenece al dominio correcto (ver Apéndice A). En caso de que x no sea un número, la función devuelve OM, lo cual es coherente con el concepto matemático de existencia.

La operación predefinida en ISetL para las funciones es la aplicación de una función a un argumento Los argumentos de una función también son expresiones.

Ejemplos:

>   f(1)                   $ quién es el correspondiente de 1 en f?
3;

>   doble(-3);            $ aplicación de doble a -3
-6;
>   doble(“a”);           $ aplicación de doble a “a”
OM;

- Definiciones recursivas de funciones

Los algoritmos recursivos se implementan en ISetL muy fácilmente. Por ejemplo, el algoritmo de Euclides para hallar el máximo común divisor de dos números, que llamamos mcd, se escribe en ISetL como sigue:

>   mcd:=func(x,y);
>>      if is_number(x) and is_number(y) then
>>          if y = 0 then
>>              return x;                 $ paso base
>>          else
>>              return mcd(y, x mod y);   $ paso inductivo
>>          end;    $ fin del segundo if
>>      end;        $ fin del primer if
>>   end;           $ fin de la definición de la función

Esta definición es recursiva (pues el algoritmo de Euclides lo es), lo que significa que hay al menos un caso base y un caso inductivo.

En este ejemplo, tenemos el caso base cuando el segundo número del par de argumentos es 0 (y el resultado es el primero) y un caso inductivo en el que el algoritmo se aplica recursivamente a otro par de argumentos, tal que el segundo número es menor.

De esta forma, se asegura que el algoritmo llegue al caso base y devuelva un resultado (termine). Para cada caso (base e inductivo) debe haber un return en la definición de la función.

Ejemplo de aplicación: 

>    mcd(18,15);   $ esta expresión es la aplicación de la función 
                   $ mcd a 18 y 15
3;                 $ resultado de la aplicación

La definición en ISetL asocia el nombre mcd con un elemento del conjunto de funciones Z x Z ® Z, descrito por la regla correspondiente (algoritmo). Cuando se aplica una función, ISetL usa la regla asociada al nombre para realizar el cómputo y obtener el resultado.

>    mcd;   $ preguntamos a ISetL qué es mcd
!func(17)!; $ responde que es una función. Los signos ! y el
            $ número 17 los usa ISetL para su organización interna

La composición de funciones NO es predefinida en ISetL y se define en el curso.

-	Definiciones locales

 La sintaxis general de definición de funcion es:

nombre := func(lista de argumentos);
                          descripción del algoritmo;
                          return expresión;
          end;

Sin embargo, pueden usarse definiciones locales, en cuyo caso, la sintaxis es:

nombre := func(lista de argumentos);
                    definiciones locales  
                    descripción del algoritmo;
                    return expresión;
          end;

Al igual que en matemática podemos usar definiciones locales en una definición de una función. Ejemplo: calcular las raíces de una ecuación de segundo grado de coeficientes a, b, c. En la fórmula matemática se utiliza una variable local usualmente llamada “delta” para el discriminante. Podemos representarlo en ISetL como sigue:

>    raíces:=func(a,b,c);
>>      local  delta:=b**2-4*a*c;  $ definición de variable local                     
                                   $ (en matemática decimos ¨sea    
                                   $ delta …”)
>>      if delta < 0 then
>>          print “no existen raíces reales”;
>>      else if delta = 0 then
>>               return –b/2*a;
>>           else
>>               return [(–b + sqrt(delta))/ 2*a, (-b – 
                           sqrt(delta))/2*a];
>>           end;
>>      end;
>>   end;

sqrt es una función predefinida que calcula la raíz cuadrada de un número. Dentro de la definición de la función raíces, se define una variable local, delta, que se utiliza para abreviar y clarificar el resto de la definición. La variable es local ya que no existe fuera de la definición de la función raíces. La sentencia que comienza con print en el programa arriba, es lo que llamamos “fragmentos de código” y se explica en la sección Código, un poco más adelante.

2.3 Directivas

Las directivas son frases con las que ISetL se comunica con el sistema operativo (Windows, en este caso). Se escriben comenzando con el símbolo ! y sin el punto y coma final. Las más usadas son:

>    !include pepe         $ las definiciones en el
                           $ archivo “pepe” se agregan a las 
                           $ predefinidas
>    !clear                $ borra la pantalla
>    !quit                 $ se abandona la sesión

2.4 Código

En este curso utilizaremos muy pocas veces fragmentos de código, ya que para los conceptos del curso, son innecesarios y lo que es más importante, no tienen una interpretación matemática sencilla. Son herramientas propias de un paradigma de programación llamado imperativo, donde los programas son secuencias de frases imperativas. Uno de los fragmentos de código que aparece en este documento es la iteración por medio de una cláusula for y la sentencia print de la definición en ISetL de la función raíces (ver arriba).

En el curso utilizaremos un paradigma más cercano a la matemática, llamado funcional, donde los programas son implementaciones de funciones matemáticas.

ISetL no es un lenguaje funcional, aunque tiene algunas características de este paradigma. Una de las cosas que hacen que no sea funcional, es que permite escribir funciones que no se corresponden con el concepto de función matemática, por ejemplo, se puede escribir una función que contenga código. 

Ejemplo:

>    fac := func(x);
>>      tmp:=1;
>>      for i in [1..x] do      $ comando de iteración
>>         tmp:=tmp * i;        $ la vble. tmp se “actualiza” en 
                                $ cada iteración
>>      end;
>>      return tmp;
>>   end;
>    fac(6);
720;

Observar que para calcular el factorial de un número de esta forma, necesitamos definir y “actualizar” una variable temporal, que llamamos tmp, y que interviene una variable de iteración i. Esta es una definición de la función factorial en código ISetL, que difiere mucho de la definición matemática usual, que es:

fac(x) = 1                          ; si x =0
          = x * fac(x-1)          ; si x >0

En ISetL podemos escribir esta definición tal cual, sin usar código.

>    fac := func(x);
>>      if x = 0 then return 1;
>>      else if x > 0 then return x * fac(x-1); end;     
>>      end;    
>>   end;       
>    fac(6);
720;

El uso de código en ISetL resulta útil en algunos casos, por ejemplo si queremos imprimir en pantalla tablas, como las tablas de verdad del cálculo proposicional:

>    for p, q in [true, false] do
>>       writeln p, q, p and q, p or q, p impl q, not p;
>>   end;

3. Ventana gráfica

Cuando se inicia una sesión con ISetL, se abre una ventana de ejecución y una ventana gráfica. Para obtener la representación gráfica de una función, usar el comando plot, cuya sintaxis es:     
          plot(f);
          plot(f,a,b);
          plot(f,a,b,c,d);

El comando plot(f); produce la gráfica de la función f en el dominio (por defecto) 
[-10,10] y con la escala vertical elegida automáticamente. El comando plot(f,a,b); usa [a,b] como escala horizontal y el comando plot(f,a,b,c,d); usa [a,b] como escala horizontal y [c,d] como escala vertical.

Ejemplo:

>    cuad := func(x);
>>       if is_number(x) then
>>         if x < 100 then
>>           return x*x;
>>         end;
>>       end;
>>    end;
>    plot(cuad);

Produce:

•	Para incluir texto en el gráfico, poner el cursor en el lugar deseado, apretar Ctrl-Enter, escribir el texto y apretar Ctrl-Enter otra vez.
•	Se puede imprimir un gráfico como cualquier otro archivo.
•	Para abandonar la ventana gráfica y pasar a la de ejecución, usar la tecla q. Para volver a la ventana gráfica apretar Ctrl-g.

Para usar el procedimiento Cayley, se escribe en la ventana de ejecución:

>    !include Cayley
>    Cayley(R);                            

Aparece en la ventana gráfica la representación de la relación binaria R, con la carencia de que los bucles NO aparecen. También resulta una carencia que los vértices del grafo debe colocarlos el usuario como texto. Si la relación es medianamente grande, no resulta cómodo.
4. Glosario

cláusula. Usada como sinónimo de comando.
comentarios. Frases cuyo único uso es la mejor comprensión para el usuario humano. Los comentarios no son nunca analizados ni ejecutados por ISetL.
frase. Instrucciones o requerimientos realizados a ISetL y que son comprendidos como una única solicitud por el sistema.
sesión. Período durante el cual el sistema está ejecutándose. También son las acciones que tienen lugar durante dicho período.

5. Referencias: 

“Introduction to Discrete Mathematics with ISETL” , Ed Dubinsky, William Fenton, Springer–Verlag, 1996. ISBN 0-387-94782-5

6. Apéndice A

Limitaciones de ISetL

Como se ha mencionado antes, ISetL tiene algunas carencias. Las mismas derivan principalmente del hecho de que no es un lenguaje tipado, es decir, un lenguaje en el cual a cada expresión sintácticamente válida del lenguaje se le asigna un tipo (entero, booleano, función, etc) y para cada tipo se definen operaciones válidas.

 ISetL no es tipado, por ejemplo se puede definir

>        doble:=func(x);
>>	           return 2 * x;
>>	end;

donde x puede ser cualquier objeto para el cual la operación 2 * este definida. Así tenemos que 
>        doble(2);
4:

>	doble ("a");
"aa";

O sea que lo que se esta definiendo en realidad es una familia de funciones, ya que no se tiene en cuenta que una función matemática es una terna formada por un conjunto dominio, un conjunto co-dominio y una regla de transformación.
Para especificar el dominio utilizamos las cláusulas if como se indicó anteriormente y de esta forma vemos que si x no es un numero la función para ese argumento esta indefinida, lo cual coincide con el concepto matemático.
El símbolo * se usa para operaciones distintas. Se dice que esta “sobrecargado”. Otro ejemplo de símbolo sobrecargado es el +, que se usa para la suma de números, la concatenación de strings y la unión de conjuntos.

Estas limitaciones derivan en realidad del hecho de que ISetL ha sido diseñado para trabajar con matemática tradicional donde se trabaja principalmente con el conjunto de los números reales. Así, la ventana gráfica está hecha para representar funciones sobre los números reales y no tiene utilidad para un curso de matemática discreta.

7.  Apéndice B

Situaciones de sintaxis incorrecta

Se recomienda usar archivos e incluirlos en la sesión con el intérprete y si hay errores, corregirlos en el archivo y volver a incluirlo. De esta forma, los mensajes de Isetl y otras líneas innecesarias, no serán guardados. 
Si ud, realiza los cambios directamente en la sesión con el intérprete, trate de observar lo que recomendamos a través del siguiente ejemplo:
Supongamos que ud. incluye un archivo llamado pepe.txt y le aparecen errores:

>	!include pepe.txt
    >	5/7;
0.714;
>	2*3
>>	;
6;
>	forall n in [1..10] ! n mod 2 = 0;
Unknown compiler directive "! n" ignored
>>	;

!Syntax error - clearing input from:

forall n in [1..10] ! n mod 2 = 0;
;

!clear
!clear complete
 >              ð

Lo que recomendamos es reconocer los errores, corregirlos en el archivo y volver a incluirlo. Si ud. quiere corregir en la misma sesión, es decir, sin ir al archivo, el procedimiento es: corregir la expresión,  luego “pintarla” y cliquear la opción “Run” de la barra superior de Isetl.

Los mensajes de error
El primer mensaje de error indica un error en la sintaxis de la expresión: en vez del ¡ va un | . 
El segundo mensaje de error se debe a que la línea es vacía. La directiva ¡clear borra el error anterior y deja el programa esperando una nueva interacción, es decir el cursor queda en el lugar del ð en el ejemplo. 

Si el programa se “tranca” por algún motivo (lo cual no es raro que ocurra), se pueden hacer dos cosas: 1) usar la directiva ¡clear o 2) pintar la última expresión correcta y ejecutar “Run”. Es común que el programa “se tranque” porque ud. ha continuado trabajando en una situación incorrecta, o sea en la cual por ejemplo, no le aparecía el > o en la cual el cursor estaba inmediatamente después de > y no a unos espacios como debe ser.  
Una vez corregido el error, si Ud. quiere guardar su trabajo, debe primero eliminar lo que ya no es útil. En este caso concreto, lo que guardamos es:
     >	5/7;
0.714;
>	2*3
>>	;
6;
>	forall n in [1..10] | n mod 2 = 0;
false;
>	
O sea, borramos todo lo que era incorrecto y los mensajes de error.
También es útil borrar lo superfluo para trabajar mas cómodamente en la misma sesión, es decir, aunque no guardemos el trabajo.

Los archivos
Se recomienda crear archivos de texto y no usar tildes ni eñes y crear los archivos en el mismo directorio en el que se corre el programa. Supongamos que creamos un archivo de texto y lo nombramos “raices”. El sistema operativo lo guardará con la extensión .txt. En este archivo definimos una función como sigue:

     raices:=func(a,b,c);
             if is_num(a) and 
                is_num(b) and 
                is_num(c) then
             delta:=b**2-4*a*c;                    
             if delta < 0 then
                 print “no existen raices reales”;
             else if delta = 0 then
                  return –b/2*a;
             else
                 return [(–b + sqrt(delta))/2*a,  
                         (-b - sqrt(delta))/2*a];
              end;
             end;
        end;
     end;
En la ventana de ejecución de Isetl escribimos la primera y la tercera de las líneas siguientes y obtenemos como respuestas la segunda y la cuarta y la quinta.

>	!include raices.txt
!include raices.txt completed
>	raices(1,1,1);
"no existen raices reales";
OM;
>	
Resumiendo: en el archivo raices.txt, hemos implementado una definición de la función raices. En la ventana de ejecución hemos incluido el archivo, (con la directiva ¡include), con lo cual la definición de la función ha quedado accesible. Luego, le hemos pedido al intérprete (al programa), que evalúe la expresión raices (1,1,1), para lo cual el, computador usa la definición que le hemos dado como regla de transformación de esa expresión, es decir como algoritmo para realizar el cálculo.