35.1.1 Utilización

Para construir un conjunto cuyos elementos sean a_1, ..., a_n, se utiliza la instrucción set(a_1, ..., a_n) o {a_1, ..., a_n}; para formar un conjunto vacío, basta con hacer set() o {}. Para introducir conjuntos en Maxima, set (...) y { ... } son equivalentes. Los conjuntos se muestran siempre con llave.

Si un elemento se indica más de una vez, el proceso de simplificación elimina los elementos redundantes.

(%i1) set();
(%o1)                          {}
(%i2) set(a, b, a);
(%o2)                        {a, b}
(%i3) set(a, set(b));
(%o3)                       {a, {b}}
(%i4) set(a, [b]);
(%o4)                       {a, [b]}
(%i5) {};
(%o5)                          {}
(%i6) {a, b, a};
(%o6)                        {a, b}
(%i7) {a, {b}};
(%o7)                       {a, {b}}
(%i8) {a, [b]};
(%o8)                       {a, [b]}

Dos elementos candidatos a formar parte de un conjunto, x e y, son redundantes, esto es, se consideran el mismo elemento a efectos de consruir el conjunto, si y sólo si is (x = y) devuelve el valor true. Nótese que is (equal (x, y)) puede devolver true y is (x = y) retornar false; en cuyo caso los elementos x e y se considerarían distintos.

(%i1) x: a/c + b/c;
                              b   a
(%o1)                         - + -
                              c   c
(%i2) y: a/c + b/c;
                              b   a
(%o2)                         - + -
                              c   c
(%i3) z: (a + b)/c;
                              b + a
(%o3)                         -----
                                c
(%i4) is (x = y);
(%o4)                         true
(%i5) is (y = z);
(%o5)                         false
(%i6) is (equal (y, z));
(%o6)                         true
(%i7) y - z;
                           b + a   b   a
(%o7)                    - ----- + - + -
                             c     c   c
(%i8) ratsimp (%);
(%o8)                           0
(%i9) {x, y, z};
                          b + a  b   a
(%o9)                    {-----, - + -}
                            c    c   c

Para formar un conjunto a partir de los miembros de una lista úsese setify.

(%i1) setify([b, a]);
(%o1)                        {a, b}

Los elementos x e y de un conjunto se consideran iguales si is(x = y) devuelve el valor true. Así, rat(x) y x se consideran el mismo elemento de un conjunto; consecuentemente,

(%i1) {x, rat(x)};
(%o1)                          {x}

Además, puesto que is((x-1)*(x+1) = x^2 - 1) devuelve false, (x-1)*(x+1) y x^2-1 se consideran elementos diferentes; así

(%i1) {(x - 1)*(x + 1), x^2 - 1};
                                       2
(%o1)               {(x - 1) (x + 1), x  - 1}

Para reducir este conjunto a otro unitario, aplicar rat a cada elemento del conjunto:

(%i1) {(x - 1)*(x + 1), x^2 - 1};
                                       2
(%o1)               {(x - 1) (x + 1), x  - 1}
(%i2) map (rat, %);
                              2
(%o2)/R/                    {x  - 1}

Para eliminar redundancias con otros conjuntos, será necesario utilizar otras funciones de simplificación. He aquí un ejemplo que utiliza trigsimp:

(%i1) {1, cos(x)^2 + sin(x)^2};
                            2         2
(%o1)                {1, sin (x) + cos (x)}
(%i2) map (trigsimp, %);
(%o2)                          {1}

Se entiende que un conjunto está simplificado cuando entre sus elementos no hay redundancias y se hayan ordenados. La versión actual de las funciones para conjuntos utiliza la función orderlessp de Maxima para ordenar sus elementos; sin embargo, futuras versiones de las funciones para operar con conjuntos podrán utilizar otras funciones de ordenación.

Algunas operaciones con conjuntos, tales como la sustitución, fuerzan automáticamente una re-simplificación; por ejemplo,

(%i1) s: {a, b, c}$
(%i2) subst (c=a, s);
(%o2)                        {a, b}
(%i3) subst ([a=x, b=x, c=x], s);
(%o3)                          {x}
(%i4) map (lambda ([x], x^2), set (-1, 0, 1));
(%o4)                        {0, 1}

Maxima considera a las listas y conjuntos como objetos diferentes; funciones tales como union y intersection emitirán un error si alguno de sus argumentos no es un conjunto. Si se necesita aplicar una función de conjunto a una lista, se deberá utilizar la función setify para convertirla previamente en conjunto. Así,

(%i1) union ([1, 2], {a, b});
Function union expects a set, instead found [1,2]
 -- an error.  Quitting.  To debug this try debugmode(true);
(%i2) union (setify ([1, 2]), {a, b});
(%o2)                     {1, 2, a, b}

Para extraer todos los elementos de un conjunto s que satisfagan un predicado f, úsese subset(s,f). (Un predicado es una función booleana.) Por ejemplo, para encontrar las ecuaciones en un conjunto dado que no dependan de la variable z, se hará

(%i1) subset ({x + y + z, x - y + 4, x + y - 5},
              lambda ([e], freeof (z, e)));
(%o1)               {- y + x + 4, y + x - 5}

La sección Funciones y variables para los conjuntos incluye una lista completa de funciones para operar con conjuntos en Maxima.

35.1.2 Iteraciones con elementos

Hay dos formas para operar iterativamente sobre los elementos de un conjunto. Una es utilizar map; por ejemplo:

(%i1) map (f, {a, b, c});
(%o1)                  {f(a), f(b), f(c)}

La otra forma consiste en hacer uso de la construcción for x in s do

(%i1) s: {a, b, c};
(%o1)                       {a, b, c}
(%i2) for si in s do print (concat (si, 1));
a1 
b1 
c1 
(%o2)                         done

Las funciones de Maxima first y rest funcionan también con conjuntos. En este caso, first devuelve el primer elemento que se muestra del conjunto, el cual puede depender de la implementación del sistema. Si s es un conjunto, entonces rest(s) equivale a disjoin (first(s), s). Hay otras funciones que trabajan correctamente con conjuntos. En próximas versiones de las funciones para operar con conjuntos es posible que first y rest trabajen de modo diferente o que ya no lo hagan en absoluto.

35.1.3 Fallos

Las funciones para operar con conjuntos utilizan la función orderlessp de Maxima para ordenar los elementos de los conjuntos, así como la función like de Lisp para decidir sobre la igualdad de dichos elementos. Ambas funciones tienen fallos que son conocidos y que pueden aflorar si se trabaja con conjuntos que tengan elementos en formato de listas o matrices y que contengan expresiones racionales canónicas (CRE). Un ejemplo es

(%i1) {[x], [rat (x)]};
Maxima encountered a Lisp error:

  The value #:X1440 is not of type LIST.

Automatically continuing.
To reenable the Lisp debugger set *debugger-hook* to nil.

Esta expresión provoca una parada de Maxima junto con la emisión de un mensaje de error, el cual dependerá de la versión de Lisp que utilice Maxima. Otro ejemplo es

(%i1) setify ([[rat(a)], [rat(b)]]);
Maxima encountered a Lisp error:

  The value #:A1440 is not of type LIST.

Automatically continuing.
To reenable the Lisp debugger set *debugger-hook* to nil.

Estos fallos son causados por fallos en orderlessp y like, no por fallos cuyo origen se encuentre en las funciones para conjuntos. Para ilustrarlo, se pueden ejecutar las siguientes expresiones

(%i1) orderlessp ([rat(a)], [rat(b)]);
Maxima encountered a Lisp error:

  The value #:B1441 is not of type LIST.

Automatically continuing.
To reenable the Lisp debugger set *debugger-hook* to nil.
(%i2) is ([rat(a)] = [rat(a)]);
(%o2)                         false

Hasta que estos errores no se corrijan, no es aconsejable construir conjuntos que tengan por elementos listas o matrices que contengan expresiones en forma CRE; sin embargo, un conjunto con elementos de la forma CRE no deberían dar problemas:

(%i1) {x, rat (x)};
(%o1)                          {x}

La función orderlessp de Maxima tiene otro fallo que puede causar problemas con las funciones para conjuntos, en concreto, que el predicado de ordenación orderlessp no es transitivo. El ejemplo más simple que ilustra este punto es

(%i1) q: x^2$
(%i2) r: (x + 1)^2$
(%i3) s: x*(x + 2)$
(%i4) orderlessp (q, r);
(%o4)                         true
(%i5) orderlessp (r, s);
(%o5)                         true
(%i6) orderlessp (q, s);
(%o6)                         false

El fallo puede causar problemas con todas las funciones para conjuntos, así como también con otras funciones de Maxima. Es probable, pero no seguro, que este fallo se puede evitar si todos los elementos del conjunto están en la forma de expresión racional canónica (CRE) o han sido simplificados con ratsimp.

Los mecanismos orderless y ordergreat de Maxima son incompatibles con las funciones para conjuntos. Si se necesitan utilizar orderless o ordergreat, hágase antes de construir los conjuntos y no se utilice la instrucción unorder.

Se ruega a todo usuario que crea haber encontrado un fallo en las funciones para conjuntos que lo comunique en la base de datos de Maxima. Véase bug_report.

35.1.4 Autores

Stavros Macrakis de Cambridge, Massachusetts y Barton Willis de la University of Nebraska at Kearney (UNK).