Introducción a los conjuntos
============================

Maxima dispone de funciones para realizar operaciones con conjuntos, como la intersección o la unión. Los conjuntos deben ser finitos y definidos por enumeración. Maxima trata a los conjuntos y a las listas como objectos de distinta naturaleza, lo que permite trabajar con conjuntos cuyos elementos puedan ser también conjuntos o listas.

Además de funciones para operar con conjuntos finitos, Maxima dispone también de algunas funciones sobre combinatoria, como los números de Stirling de primera y segunda especie, números de Bell, coeficientes multinomiales, particiones de enteros no negativos y algunos otros. Maxima también define la función delta de Kronecker.

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.

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.

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.

Autores
-------

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

Funciones y variables para los conjuntos
========================================

 -- Función: adjoin (X, A)

     Calcula la unión del conjunto A y {X}.

     La función adjoin emite un mensaje de error si A no es un conjunto literal.

     Las sentencias adjoin(X, A) y union(set(X), A) son equivalentes, aunque adjoin puede ser algo más rápida que union.

     Véase también disjoin.

     Ejemplos:

          (%i1) adjoin (c, {a, b});
          (%o1)                       {a, b, c}
          (%i2) adjoin (a, {a, b});
          (%o2)                        {a, b}

 -- Función: belln (N)

     Representa el n-ésimo número de Bell, de modo que belln(n) es el número de particiones de un conjunto de N elementos.

     El argumento N debe ser un entero no negativo.

     La función belln se distribuye sobre ecuaciones, listas, matrices y conjuntos.

     Ejemplos:

     belln se aplica a enteros no negativos,

          (%i1) makelist (belln (i), i, 0, 6);
          (%o1)               [1, 1, 2, 5, 15, 52, 203]
          (%i2) is (cardinality (set_partitions ({})) = belln (0));
          (%o2)                         true
          (%i3) is (cardinality (set_partitions ({1, 2, 3, 4, 5, 6}))
                                      = belln (6));
          (%o3)                         true

     Si N no es un entero no negativo, la función belln(n) no hace cálculo alguno.

          (%i1) [belln (x), belln (sqrt(3)), belln (-9)];
          (%o1)        [belln(x), belln(sqrt(3)), belln(- 9)]

 -- Función: cardinality (A)

     Devuelve el número de elementos del conjunto A.

     La función cardinality ignora los elementos redundantes, incluso cuando la simplificación está desabilitada.

     Ejemplos:

          (%i1) cardinality ({});
          (%o1)                           0
          (%i2) cardinality ({a, a, b, c});
          (%o2)                           3
          (%i3) simp : false;
          (%o3)                         false
          (%i4) cardinality ({a, a, b, c});
          (%o4)                           3

 -- Función: cartesian_product (B_1, ... , B_N)

     Devuelve un conjunto formado por listas de la forma [X_1, ..., X_N], siendo X_1, ..., X_N elementos de los conjuntos B_1, ... , B_N, respectivamente.

     La función cartesian_product emite un mensaje de error si alguno de sus argumentos no es un conjunto literal.

     Ejemplos:

          (%i1) cartesian_product ({0, 1});
          (%o1)                      {[0], [1]}
          (%i2) cartesian_product ({0, 1}, {0, 1});
          (%o2)           {[0, 0], [0, 1], [1, 0], [1, 1]}
          (%i3) cartesian_product ({x}, {y}, {z});
          (%o3)                      {[x, y, z]}
          (%i4) cartesian_product ({x}, {-1, 0, 1});
          (%o4)              {[x, - 1], [x, 0], [x, 1]}

 -- Función: disjoin (X, A)

     Devuelve el conjunto A sin el elemento X. Si X no es elemento de A, entonces el resultado es el propio A.

     La función disjoin emite un mensaje de error si A no es un conjunto literal.

     Las sentencias disjoin(X, A), delete(X, A) y setdifference(A, set(X)) son todas ellas equivalentes; pero en general, disjoin será más rápida que las otras.

     Ejemplos:

          (%i1) disjoin (a, {a, b, c, d});
          (%o1)                       {b, c, d}
          (%i2) disjoin (a + b, {5, z, a + b, %pi});
          (%o2)                      {5, %pi, z}
          (%i3) disjoin (a - b, {5, z, a + b, %pi});
          (%o3)                  {5, %pi, b + a, z}

 -- Función: disjointp (A, B)

     Devuelve true si y sólo si los conjuntos  A y B son disjuntos.

     La función disjointp emite un mensaje de error si A o B no son conjuntos literales.

     Ejemplos:

          (%i1) disjointp ({a, b, c}, {1, 2, 3});
          (%o1)                         true
          (%i2) disjointp ({a, b, 3}, {1, 2, 3});
          (%o2)                         false

 -- Función: divisors (N)

     Calcula el conjunto de divisores de N.

     La sentencia divisors(N) devuelve un conjunto de enteros si N es un entero no nulo. El conjunto de divisores incluye los elementos 1 y N. Los divisores de un entero negativo son los divisores de su valor absoluto.

     La función divisors se distribuye sobre las ecuaciones, listas, matrices y conjuntos.

     Ejemplos:

     Se puede comprobar que 28 es un número perfecto: la suma de sus divisores (excepto él mismo) es 28.

          (%i1) s: divisors(28);
          (%o1)                 {1, 2, 4, 7, 14, 28}
          (%i2) lreduce ("+", args(s)) - 28;
          (%o2)                          28

     La función divisors es simplificadora. Haciendo la sustitución de a por 8 en divisors(a) devuelve los divisores sin tener que reevaluar divisors(8),

          (%i1) divisors (a);
          (%o1)                      divisors(a)
          (%i2) subst (8, a, %);
          (%o2)                     {1, 2, 4, 8}

     La función divisors se distribuye sobre ecuaciones, listas, matrices y conjuntos.

          (%i1) divisors (a = b);
          (%o1)               divisors(a) = divisors(b)
          (%i2) divisors ([a, b, c]);
          (%o2)        [divisors(a), divisors(b), divisors(c)]
          (%i3) divisors (matrix ([a, b], [c, d]));
                            [ divisors(a)  divisors(b) ]
          (%o3)             [                          ]
                            [ divisors(c)  divisors(d) ]
          (%i4) divisors ({a, b, c});
          (%o4)        {divisors(a), divisors(b), divisors(c)}

 -- Función: elementp (X, A)

     Devuelve true si y sólo si X es miembro del conjunto A.

     La función elementp emite un mensaje de error si A no es un conjunto literal.

     Ejemplos:

          (%i1) elementp (sin(1), {sin(1), sin(2), sin(3)});
          (%o1)                         true
          (%i2) elementp (sin(1), {cos(1), cos(2), cos(3)});
          (%o2)                         false

 -- Función: emptyp (A)
     Devuelve true si y sólo si A es el conjunto vacío o la lista vacía.

     Ejemplos:

          (%i1) map (emptyp, [{}, []]);
          (%o1)                     [true, true]
          (%i2) map (emptyp, [a + b, {{}}, %pi]);
          (%o2)                 [false, false, false]

 -- Función: equiv_classes (S, F)

     Devuelve el conjunto de las clases de equivalencia del conjunto S respecto de la relación de equivalencia F.

     El argumento F es una función de dos variables definida sobre el producto cartesiano S por S. El valor devuelto por F debe ser true o false, o bien una expresión EXPR tal que is(EXPR) tome el valor true o false.

     Si F no es una relación de equivalencia, equiv_classes la acepta sin emitir ningún mensaje de error, pero el resultado será incorrecto en general.

     Ejemplos:

     La relación de equivalencia es una expresión lambda que devuelve true o false,

          (%i1) equiv_classes ({1, 1.0, 2, 2.0, 3, 3.0},
                                lambda ([x, y], is (equal (x, y))));
          (%o1)            {{1, 1.0}, {2, 2.0}, {3, 3.0}}

     La relación de equivalencia es el nombre de una función relacional en la que is evalúa a true o false,

          (%i1) equiv_classes ({1, 1.0, 2, 2.0, 3, 3.0}, equal);
          (%o1)            {{1, 1.0}, {2, 2.0}, {3, 3.0}}

     Las clases de equivalencia son números que difieren en un múltiplo de 3.

          (%i1) equiv_classes ({1, 2, 3, 4, 5, 6, 7},
                        lambda ([x, y], remainder (x - y, 3) = 0));
          (%o1)              {{1, 4, 7}, {2, 5}, {3, 6}}

 -- Función: every (F, S)
 -- Función: every (F, L_1, ..., L_N)

     Devuelve true si el predicado F vale true para todos los argumentos dados.

     Dado un conjunto como segundo argumento, every(F, S) devuelve true si is(F(A_I)) devuelve true para todos los A_I pertenecientes S. La función every puede evaluar o no F para todos los A_I pertenecientes S. Puesto que los conjuntos no están ordenados, every puede evaluar F(A_I) en cualquier orden.

     Dada una o más listas como argumentos, every(F, L_1, ..., L_N) devuelve true si is(F(X_1, ..., X_N)) devuelve true para todo X_1, ..., X_N en L_1, ..., L_N, respectivamente. La función every puede evaluar o no F para cualquier combinación de X_1, ..., X_N; además, every evalúa las listas en el orden creciente del índice.

     Dado un conjunto vacío {} o lista vacía [] como argumentos, every devuelve false.

     Si la variable global maperror vale true, todas las listas L_1, ..., L_N deben ser de igual longitud. Si maperror vale false, los argumentos en forma de listas se truncan para igualar sus longitudes a la de la lista más corta.

     Los valores que devuelve el predicado F cuando toman (mediante is) un valor diferente a true y false se controlan con la variable global prederror. Si prederror vale true, tales valores se consideran como false y la respuesta de every es false. Si prederror vale false, tales valores se consideran como desconocidos (unknown) y la respuesta de every es unknown.

     Ejemplos:

     Se aplica every a un único conjunto. El predicado es una función de un argumento.

          (%i1) every (integerp, {1, 2, 3, 4, 5, 6});
          (%o1)                         true
          (%i2) every (atom, {1, 2, sin(3), 4, 5 + y, 6});
          (%o2)                         false

     Se aplica every a dos listas. El predicado es una función de dos argumentos.

          (%i1) every ("=", [a, b, c], [a, b, c]);
          (%o1)                         true
          (%i2) every ("#", [a, b, c], [a, b, c]);
          (%o2)                         false

     Las respuestas del predicado F que se evalúan a cualquier cosa diferente de true y false están controlados por la variable global prederror.

          (%i1) prederror : false;
          (%o1)                         false
          (%i2) map (lambda ([a, b], is (a < b)), [x, y, z],
                             [x^2, y^2, z^2]);
          (%o2)              [unknown, unknown, unknown]
          (%i3) every ("<", [x, y, z], [x^2, y^2, z^2]);
          (%o3)                        unknown
          (%i4) prederror : true;
          (%o4)                         true
          (%i5) every ("<", [x, y, z], [x^2, y^2, z^2]);
          (%o5)                         false

 -- Función: extremal_subset (S, F, max)
 -- Función: extremal_subset (S, F, min)

     Calcula el subconjunto de S para el cual la función F toma sus valores mayor y menor.

     La sentencia extremal_subset(S, F, max) devuelve el subconjunto del conjunto o lista S para el cual la función real F toma su valor máximo.

     La sentencia extremal_subset(S, F, min) devuelve el subconjunto del conjunto o lista S para el cual la función real F toma su valor mínimo.

     Ejemplos

          (%i1) extremal_subset ({-2, -1, 0, 1, 2}, abs, max);
          (%o1)                       {- 2, 2}
          (%i2) extremal_subset ({sqrt(2), 1.57, %pi/2}, sin, min);
          (%o2)                       {sqrt(2)}

 -- Función: flatten (EXPR)

     Recoge los argumentos de subexpresiones con el mismo operador que EXPR y construye con ellas otra expresión a partir de estos argumentos.

     Aquellas subexpresiones en las que el operador es diferente del operador principal de expr se copian sin modificarse, incluso cuando ellas mismas contengan subexpresiones en las que el operador sea el mismo que el de expr.

     Es posible que flatten construya expresiones en las que el número de argumentos difiera del número admitido por el operador, lo cual hará que se emita un mensaje de error. La función flatten no intentará detectar estas situaciones.

     Las expresiones que tengan representaciones especiales, por ejemplo las racionales canónicas (CRE), no admiten que se aplique sobre ellas la función flatten; en tales casos se devuelve el argumento sin modificación.

     Ejemplos:

     Aplicada a una lista, flatten reune todos los elementos que son a su vez listas.

          (%i1) flatten ([a, b, [c, [d, e], f], [[g, h]], i, j]);
          (%o1)            [a, b, c, d, e, f, g, h, i, j]

     Aplicado a un conjunto, flatten reune todos los elementos que son a su vez conjuntos.

          (%i1) flatten ({a, {b}, {{c}}});
          (%o1)                       {a, b, c}
          (%i2) flatten ({a, {[a], {a}}});
          (%o2)                       {a, [a]}

     La función flatten es similar a la declaración del operador principal como n-ario. Sin embargo, flatten no tiene efecto alguno sobre subexpresiones que tengan un operador diferente del principal, mientras que sí lo tiene una declaración n-aria.

          (%i1) expr: flatten (f (g (f (f (x)))));
          (%o1)                     f(g(f(f(x))))
          (%i2) declare (f, nary);
          (%o2)                         done
          (%i3) ev (expr);
          (%o3)                      f(g(f(x)))

     La función flatten trata las funciones subindicadas como a cualquier otro operador.

          (%i1) flatten (f[5] (f[5] (x, y), z));
          (%o1)                      f (x, y, z)
                                      5

     Es posible que flatten construya expresiones en las que el número de argumentos difiera del número admitido por el operador.

          (%i1) 'mod (5, 'mod (7, 4));
          (%o1)                   mod(5, mod(7, 4))
          (%i2) flatten (%);
          (%o2)                     mod(5, 7, 4)
          (%i3) ''%, nouns;
          Wrong number of arguments to mod
           -- an error.  Quitting.  To debug this try debugmode(true);

 -- Función: full_listify (A)

     Sustituye los operadores de conjunto presentes en A por operadores de listas, devolviendo el resultado. La función full_listify sustituye operadores de conjuntos en subexpresiones anidadas, incluso cuando el operador principal no es set.

     La función listify sustituye únicamente el operador principal.

     Ejemplos:

          (%i1) full_listify ({a, b, {c, {d, e, f}, g}});
          (%o1)               [a, b, [c, [d, e, f], g]]
          (%i2) full_listify (F (G ({a, b, H({c, d, e})})));
          (%o2)              F(G([a, b, H([c, d, e])]))

 -- Función: fullsetify (A)

     Si A es una lista, sustituye el operador de lista por el de conjunto, aplicando posteriormente fullsetify a todos los elementos que son a su vez conjuntos. Si A no es una lista, se devuelve sin cambio alguno.

     La función setify sustituye solamente el operador principal.

     Ejemplos:

     En la salida (%o2) el argumento de f no se convierte en conjunto porque el operador principal de f([b]) no es una lista.

          (%i1) fullsetify ([a, [a]]);
          (%o1)                       {a, {a}}
          (%i2) fullsetify ([a, f([b])]);
          (%o2)                      {a, f([b])}

 -- Función: identity (X)

     La función identity devuelve su argumento cualquiera que sea éste.

     Ejemplos:

     La función identity puede utilizarse como predicado cuando los argumentos ya son valores booleanos.

          (%i1) every (identity, [true, true]);
          (%o1)                         true

 -- Función: integer_partitions (N)
 -- Función: integer_partitions (N, LEN)

     Devuelve particiones enteras de N, esto es, listas de enteros cuyas sumas son N.

     La sentencia integer_partitions(N) devuelve el conjunto de todas las particiones del entero N. Cada partición es una lista ordenada de mayor a menor.

     La sentencia integer_partitions(N, LEN) devuelve todas las particiones de longitud LEN o menor; en este caso, se añaden ceros a cada partición con menos de LEN términos para que todas ellas sean de longitud LEN. Las particiones son listas ordenadas de mayor a menor.

     Una lista [a_1, ..., a_m] es una partición de un entero no negativo n si (1) cada a_i es entero no nulo y (2) a_1 + ... + a_m = n. Así, 0 no tiene particiones.

     Ejemplos:

          (%i1) integer_partitions (3);
          (%o1)               {[1, 1, 1], [2, 1], [3]}
          (%i2) s: integer_partitions (25)$
          (%i3) cardinality (s);
          (%o3)                         1958
          (%i4) map (lambda ([x], apply ("+", x)), s);
          (%o4)                         {25}
          (%i5) integer_partitions (5, 3);
          (%o5) {[2, 2, 1], [3, 1, 1], [3, 2, 0], [4, 1, 0], [5, 0, 0]}
          (%i6) integer_partitions (5, 2);
          (%o6)               {[3, 2], [4, 1], [5, 0]}

     Para encontrar todas las particiones que satisfagan cierta condición, utilícese la función subset; he aquí un ejemplo que encuentra todas las particiones de 10 formadas por números primos.

          (%i1) s: integer_partitions (10)$
          (%i2) cardinality (s);
          (%o2)                          42
          (%i3) xprimep(x) := integerp(x) and (x > 1) and primep(x)$
          (%i4) subset (s, lambda ([x], every (xprimep, x)));
          (%o4) {[2, 2, 2, 2, 2], [3, 3, 2, 2], [5, 3, 2], [5, 5], [7, 3]}

 -- Función: intersect (A_1, ..., A_N)
     Es una forma abreviada de la función intersection.

 -- Función: intersection (A_1, ..., A_N)

     Devuelve el conjunto de todos los elementos que son comunes a los conjuntos  A_1 a A_N.

     Emite un mensaje de error en caso de que cualquiera de los A_I no sea un conjunto.

     Ejemplos:

          (%i1) S_1 : {a, b, c, d};
          (%o1)                     {a, b, c, d}
          (%i2) S_2 : {d, e, f, g};
          (%o2)                     {d, e, f, g}
          (%i3) S_3 : {c, d, e, f};
          (%o3)                     {c, d, e, f}
          (%i4) S_4 : {u, v, w};
          (%o4)                       {u, v, w}
          (%i5) intersection (S_1, S_2);
          (%o5)                          {d}
          (%i6) intersection (S_2, S_3);
          (%o6)                       {d, e, f}
          (%i7) intersection (S_1, S_2, S_3);
          (%o7)                          {d}
          (%i8) intersection (S_1, S_2, S_3, S_4);
          (%o8)                          {}

 -- Función: kron_delta (X, Y)

     Es la función delta de Kronecker.

     La función kron_delta devuelve 1 cuando X e Y son idénticos o equivalentes, devolviendo 0 si X e Y no son idénticos. Cuando no está claro si ambas expresiones son equivalentes, kron_delta devuelve una forma nominal. Si la diferencia X - Y es un número decimal en coma flotante, kron_delta dará como resultado una expresión nominal, aún cuando X e Y sean aparentemente equivalentes.

     Concretando, kron_delta(X, Y) devuelve 1 si is(x = y) retorna true; kron_delta también devuelve 1 si sign(abs(X - Y)) retorna zero y X - Y no es un decimal en coma flotante (ni ordinario ni bigfloat); kron_delta devuelve 0 si sign(abs(X - Y)) retorna pos.

     Cuando sign(abs(X - Y)) es cualquier otra cosa diferente a pos o zero, o si es zero siendo X - Y un decimal en coma flotante, entonces kron_delta devuelve una expresión nominal.

     La función kron_delta está declarada como simétrica, esto es, kron_delta(X, Y) es igual a kron_delta(Y, X).

     Ejemplos:

     Si los argumentos de kron_delta son idénticos, kron_delta devuelve 1,

          (%i1) kron_delta (a, a);
          (%o1)                           1
          (%i2) kron_delta (x^2 - y^2, x^2 - y^2);
          (%o2)                           1
          (%i3) float (kron_delta (1/10, 0.1));
          (%o3)                           1

     Si los argumentos de kron_delta son equivalentes y su diferencia no es un decimal en coma flotante, kron_delta devuelve 1,

          (%i1) assume (equal (x, y));
          (%o1)                     [equal(x, y)]
          (%i2) kron_delta (x, y);
          (%o2)                           1

     Si los argumentos de kron_delta no son equivalentes, kron_delta devuelve 0,

          (%i1) kron_delta (a + 1, a);
          (%o1)                           0
          (%i2) assume (a > b)$
          (%i3) kron_delta (a, b);
          (%o3)                           0
          (%i4) kron_delta (1/5, 0.7);
          (%o4)                           0

     Si no es posible determinar la equivalencia de los argumentos de kron_delta, ésta devuelve una forma nominal,

          (%i1) kron_delta (a, b);
          (%o1)                   kron_delta(a, b)
          (%i2) assume(x >= y)$
          (%i3) kron_delta (x, y);
          (%o3)                   kron_delta(x, y)

     Si los argumentos de kron_delta son equivalentes, pero su diferencia es un decimal en coma flotante, kron_delta devuelve forma nominal,

          (%i1) 1/4 - 0.25;
          (%o1)                          0.0
          (%i2) 1/10 - 0.1;
          (%o2)                          0.0
          (%i3) 0.25 - 0.25b0;
          Warning:  Float to bigfloat conversion of 0.25
          (%o3)                         0.0b0
          (%i4) kron_delta (1/4, 0.25);
                                            1
          (%o4)                  kron_delta(-, 0.25)
                                            4
          (%i5) kron_delta (1/10, 0.1);
                                            1
          (%o5)                  kron_delta(--, 0.1)
                                            10
          (%i6) kron_delta (0.25, 0.25b0);
          Warning:  Float to bigfloat conversion of 0.25
          (%o6)               kron_delta(0.25, 2.5b-1)

     La función kron_delta es simétrica.

          (%i1) kron_delta (x, y);
          (%o1)                   kron_delta(x, y)
          (%i2) kron_delta (y, x);
          (%o2)                   kron_delta(x, y)
          (%i3) kron_delta (x, y) - kron_delta (y, x);
          (%o3)                           0
          (%i4) is (equal (kron_delta (x, y), kron_delta (y, x)));
          (%o4)                         true
          (%i5) is (kron_delta (x, y) = kron_delta (y, x));
          (%o5)                         true

 -- Función: listify (A)

     Si A es un conjunto, devuelve una lista con los elementos de A; si  A no es un conjunto, devuelve A.

     La función full_listify sustituye todos los operadores de conjunto en A por operadores de lista.

     Ejemplos:

          (%i1) listify ({a, b, c, d});
          (%o1)                     [a, b, c, d]
          (%i2) listify (F ({a, b, c, d}));
          (%o2)                    F({a, b, c, d})

 -- Función: lreduce (F, S)
 -- Función: lreduce (F, S, INIT)

     Amplía la función binaria F a n-aria mediante composición, siendo S una lista.

     La sentencia  lreduce(F, S) devuelve F(... F(F(s_1, s_2), s_3), ... s_n). Si se incluye el argumento opcional S_0, el resultado equivale a lreduce(F, cons(S_0, S)).

     La función F se aplica primero a los elementos del extremo izquierdo de la lista, de ahí el nombre lreduce, (left reduce).

     Véanse también rreduce, xreduce y tree_reduce.

     Ejemplos:

     La función lreduce sin el argumento opcional,

          (%i1) lreduce (f, [1, 2, 3]);
          (%o1)                     f(f(1, 2), 3)
          (%i2) lreduce (f, [1, 2, 3, 4]);
          (%o2)                  f(f(f(1, 2), 3), 4)

     La función lreduce con el argumento opcional,

          (%i1) lreduce (f, [1, 2, 3], 4);
          (%o1)                  f(f(f(4, 1), 2), 3)

     La función lreduce aplicada a operadores binarios de Maxima. El símbolo // es el operador división.

          (%i1) lreduce ("^", args ({a, b, c, d}));
                                         b c d
          (%o1)                       ((a ) )
          (%i2) lreduce ("//", args ({a, b, c, d}));
                                          a
          (%o2)                         -----
                                        b c d

 -- Función: makeset (EXPR, X, S)

     Genera un conjunto cuyos miembros se generan a partir de la expresión EXPR, siendo X una lista de variables de EXPR y S un conjunto o lista de listas. Para generar los elementos del conjunto, se evalúa EXPR asignando a las variables de X los elementos de S en paralelo.

     Los elementos de S deben tener la misma longitud que X. La lista de variables X debe ser una lista de símbolos sin subíndices. Cuando se trate de un único símbolo, X debe expresarse como una lista de un elemento y cada elemento de S debe ser una lista de un sólo elemento.

     Véase también makelist.

     Ejemplos:

          (%i1) makeset (i/j, [i, j], [[1, a], [2, b], [3, c], [4, d]]);
                                     1  2  3  4
          (%o1)                     {-, -, -, -}
                                     a  b  c  d
          (%i2) S : {x, y, z}$
          (%i3) S3 : cartesian_product (S, S, S);
          (%o3) {[x, x, x], [x, x, y], [x, x, z], [x, y, x], [x, y, y],
          [x, y, z], [x, z, x], [x, z, y], [x, z, z], [y, x, x],
          [y, x, y], [y, x, z], [y, y, x], [y, y, y], [y, y, z],
          [y, z, x], [y, z, y], [y, z, z], [z, x, x], [z, x, y],
          [z, x, z], [z, y, x], [z, y, y], [z, y, z], [z, z, x],
          [z, z, y], [z, z, z]}
          (%i4) makeset (i + j + k, [i, j, k], S3);
          (%o4) {3 x, 3 y, y + 2 x, 2 y + x, 3 z, z + 2 x, z + y + x,
                                                 z + 2 y, 2 z + x, 2 z + y}
          (%i5) makeset (sin(x), [x], {[1], [2], [3]});
          (%o5)               {sin(1), sin(2), sin(3)}

 -- Función: moebius (N)

     Representa la función de Moebius.

     Si N es el producto de k números primos diferentes, moebius(N) devuelve (-1)^k, retornando 1 si N = 1 y 0 para cualesquiera otros enteros positivos.

     La función de Moebius se distribuye respecto de ecuaciones, listas, matrices y conjuntos.

     Ejemplos:

          (%i1) moebius (1);
          (%o1)                           1
          (%i2) moebius (2 * 3 * 5);
          (%o2)                          - 1
          (%i3) moebius (11 * 17 * 29 * 31);
          (%o3)                           1
          (%i4) moebius (2^32);
          (%o4)                           0
          (%i5) moebius (n);
          (%o5)                      moebius(n)
          (%i6) moebius (n = 12);
          (%o6)                    moebius(n) = 0
          (%i7) moebius ([11, 11 * 13, 11 * 13 * 15]);
          (%o7)                      [- 1, 1, 1]
          (%i8) moebius (matrix ([11, 12], [13, 14]));
                                     [ - 1  0 ]
          (%o8)                      [        ]
                                     [ - 1  1 ]
          (%i9) moebius ({21, 22, 23, 24});
          (%o9)                      {- 1, 0, 1}

 -- Función: multinomial_coeff (A_1, ..., A_N)
 -- Función: multinomial_coeff ()

     Calcula el coeficiente multinomial.

     Si todos los A_K son enteros no negativos, el coeficiente multinomial es el número de formas de colocar  A_1 + ... + A_N objetos diferentes en  n cajas con A_K elementos en la k-ésima caja. En general, multinomial_coeff (A_1, ..., A_N) calcula (A_1 + ... + A_N)!/(A_1! ... A_N!).

     Si no se dan argumentos, multinomial_coeff() devuelve 1.

     Se puede usar minfactorial para simplificar el valor devuelto por multinomial_coeff.

     Ejemplos:

          (%i1) multinomial_coeff (1, 2, x);
                                      (x + 3)!
          (%o1)                       --------
                                        2 x!
          (%i2) minfactorial (%);
                               (x + 1) (x + 2) (x + 3)
          (%o2)                -----------------------
                                          2
          (%i3) multinomial_coeff (-6, 2);
                                       (- 4)!
          (%o3)                       --------
                                      2 (- 6)!
          (%i4) minfactorial (%);
          (%o4)                          10

 -- Función: num_distinct_partitions (N)
 -- Función: num_distinct_partitions (N, LIST)

     Si N es un entero no negativo, devuelve el número de particiones enteras distintas de N, en caso contrario num_distinct_partitions devuelve una forma nominal.

     La sentencia num_distinct_partitions(N, list) devuelve una lista con el número de particiones distintas de 1, 2, 3, ..., N.

     Una partición distinta de N es una lista de números enteros positivos distintos k_1, ..., k_m tales que N = k_1 + ... + k_m.

     Ejemplos:

          (%i1) num_distinct_partitions (12);
          (%o1)                          15
          (%i2) num_distinct_partitions (12, list);
          (%o2)      [1, 1, 1, 2, 2, 3, 4, 5, 6, 8, 10, 12, 15]
          (%i3) num_distinct_partitions (n);
          (%o3)              num_distinct_partitions(n)

 -- Función: num_partitions (N)
 -- Función: num_partitions (N, LIST)

     Si N es un entero no negativo, devuelve el número de particiones enteras de N, en caso contrario num_partitions devuelve una expresión nominal.

     La sentencia num_partitions(N, list) devuelve una lista con los números de particiones enteras de 1, 2, 3, ..., N.

     Siendo N un entero no negativo, num_partitions(N) es igual a cardinality(integer_partitions(N)); sin embargo, num_partitions no construye el conjunto de particiones, por lo que es más rápido.

     Ejemplos:

          (%i1) num_partitions (5) = cardinality (integer_partitions (5));
          (%o1)                         7 = 7
          (%i2) num_partitions (8, list);
          (%o2)            [1, 1, 2, 3, 5, 7, 11, 15, 22]
          (%i3) num_partitions (n);
          (%o3)                   num_partitions(n)

 -- Función: partition_set (A, F)

     Particiona el conjunto A respecto del predicado F.

     La función partition_set devuelve una lista con dos conjuntos; el primer conjunto es el subconjunto de A para el cual el predicado F devuelve false y el segundo contiene al resto de elementos de A.

     La función partition_set no aplica is al valor devuelto por F.

     La función partition_set emite un mensaje de error si A no es un conjunto literal.

     Véase también subset.

     Ejemplos:

          (%i1) partition_set ({2, 7, 1, 8, 2, 8}, evenp);
          (%o1)                   [{1, 7}, {2, 8}]
          (%i2) partition_set ({x, rat(y), rat(y) + z, 1},
                            lambda ([x], ratp(x)));
          (%o2)/R/              [{1, x}, {y, y + z}]

 -- Función: permutations (A)

     Devuelve un conjunto con todas las permutaciones distintas de los miembros de la lista o conjunto  A. Cada permutación es una lista, no un conjunto.

     Si A es una lista, sus miembros duplicados no son eliminados antes de buscar sus permutaciones.

     Si A no es una lista o conjunto, permutations emite un mensaje de error.

     Véase también random_permutation.

     Ejemplos:

          (%i1) permutations ([a, a]);
          (%o1)                       {[a, a]}
          (%i2) permutations ([a, a, b]);
          (%o2)           {[a, a, b], [a, b, a], [b, a, a]}

 -- Función: powerset (A)
 -- Función: powerset (A, N)

     Devuelve el conjunto de todos los subconjuntos del conjunto A o un sunconjunto de ellos.

     La sentencia powerset(A) devuelve el conjunto de todos los subconjuntos de A, que contendrá 2^cardinality(A) elementos.

     La sentencia powerset(A, N) devuelve el conjunto de todos los subconjuntos de A de cardinalidad N.

     La función powerset emite un mensaje de error si A no es un conjunto literal o si N no es un entero no negativo.

     Ejemplos:

          (%i1) powerset ({a, b, c});
          (%o1) {{}, {a}, {a, b}, {a, b, c}, {a, c}, {b}, {b, c}, {c}}
          (%i2) powerset ({w, x, y, z}, 4);
          (%o2)                    {{w, x, y, z}}
          (%i3) powerset ({w, x, y, z}, 3);
          (%o3)     {{w, x, y}, {w, x, z}, {w, y, z}, {x, y, z}}
          (%i4) powerset ({w, x, y, z}, 2);
          (%o4)   {{w, x}, {w, y}, {w, z}, {x, y}, {x, z}, {y, z}}
          (%i5) powerset ({w, x, y, z}, 1);
          (%o5)                 {{w}, {x}, {y}, {z}}
          (%i6) powerset ({w, x, y, z}, 0);
          (%o6)                         {{}}

 -- Función: random_permutation (A)

     Devuelve una permutación aleatoria del conjunto o lista A, siguiendo el algoritmo de Knuth.

     El valor devuelto es una lista nueva distinta del argumento, incluso cuando todos los elementos son iguales. Sin embargo, los elementos del argumento no se copian.

     Ejemplos:

          (%i1) random_permutation ([a, b, c, 1, 2, 3]);
          (%o1)                  [c, 1, 2, 3, a, b]
          (%i2) random_permutation ([a, b, c, 1, 2, 3]);
          (%o2)                  [b, 3, 1, c, a, 2]
          (%i3) random_permutation ({x + 1, y + 2, z + 3});
          (%o3)                 [y + 2, z + 3, x + 1]
          (%i4) random_permutation ({x + 1, y + 2, z + 3});
          (%o4)                 [x + 1, y + 2, z + 3]

 -- Función: rreduce (F, S)
 -- Función: rreduce (F, S, INIT)

     Amplía la función binaria F a n-aria mediante composición, siendo S una lista.

     La sentencia  rreduce(F, S) devuelve F(s_1, ... F(s_{n - 2}, F(s_{n - 1}, s_n))). Si se incluye el argumento opcional S_{N + 1}, el resultado equivale a rreduce(F, endcons(S_{N + 1}, S)).

     La función F se aplica primero a los elementos del extremo derecho de la lista, de ahí el nombre rreduce, (right reduce).

     Véanse también lreduce, xreduce y tree_reduce.

     Ejemplos:

     La función rreduce sin el argumento opcional,

          (%i1) rreduce (f, [1, 2, 3]);
          (%o1)                     f(1, f(2, 3))
          (%i2) rreduce (f, [1, 2, 3, 4]);
          (%o2)                  f(1, f(2, f(3, 4)))

     La función rreduce con el argumento opcional,

          (%i1) rreduce (f, [1, 2, 3], 4);
          (%o1)                  f(1, f(2, f(3, 4)))

     La función rreduce aplicada a operadores binarios de Maxima. El símbolo // es el operador división.

          (%i1) rreduce ("^", args ({a, b, c, d}));
                                           d
                                          c
                                         b
          (%o1)                         a
          (%i2) rreduce ("//", args ({a, b, c, d}));
                                         a c
          (%o2)                          ---
                                         b d

 -- Función: setdifference (A, B)

     Devuelve el conjunto con los elementos del conjunto A que no pertenecen al conjunto B.

     La función setdifference emite un mensaje de error si A o B no son conjuntos.

     Ejemplos:

          (%i1) S_1 : {a, b, c, x, y, z};
          (%o1)                  {a, b, c, x, y, z}
          (%i2) S_2 : {aa, bb, c, x, y, zz};
          (%o2)                 {aa, bb, c, x, y, zz}
          (%i3) setdifference (S_1, S_2);
          (%o3)                       {a, b, z}
          (%i4) setdifference (S_2, S_1);
          (%o4)                     {aa, bb, zz}
          (%i5) setdifference (S_1, S_1);
          (%o5)                          {}
          (%i6) setdifference (S_1, {});
          (%o6)                  {a, b, c, x, y, z}
          (%i7) setdifference ({}, S_1);
          (%o7)                          {}

 -- Función: setequalp (A, B)

     Devuelve  true si los conjuntos A y B tienen el mismo número de elementos y is (X = Y) vale true para x perteneciente a A e y perteneciente a B, considerados en el orden que determina la función listify. En caso contrario, setequalp devuelve false.

     Ejemplos:

          (%i1) setequalp ({1, 2, 3}, {1, 2, 3});
          (%o1)                         true
          (%i2) setequalp ({a, b, c}, {1, 2, 3});
          (%o2)                         false
          (%i3) setequalp ({x^2 - y^2}, {(x + y) * (x - y)});
          (%o3)                         false

 -- Función: setify (A)

     Construye un conjunto con los miembros de la lista A. Los elementos duplicados de la lista A son borrados y ordenados de acuerdo con el predicado orderlessp.

     La función setify emite un mensaje de error si A no es un conjunto literal.

     Ejemplos:

          (%i1) setify ([1, 2, 3, a, b, c]);
          (%o1)                  {1, 2, 3, a, b, c}
          (%i2) setify ([a, b, c, a, b, c]);
          (%o2)                       {a, b, c}
          (%i3) setify ([7, 13, 11, 1, 3, 9, 5]);
          (%o3)                {1, 3, 5, 7, 9, 11, 13}

 -- Función: setp (A)

     Devuelve true si y sólo si A es un conjunto de Maxima.

     La función setp devuelve true tanto cuando el conjunto tiene como cuando no tiene elementos repetidos.

     La función setp is equivalent to the Maxima function setp(a) := not atom(a) and op(a) = 'set.

     Ejemplos:

          (%i1) simp : false;
          (%o1)                         false
          (%i2) {a, a, a};
          (%o2)                       {a, a, a}
          (%i3) setp (%);
          (%o3)                         true

 -- Función: set_partitions (A)
 -- Función: set_partitions (A, N)

     Devuelve el conjunto de todas las particiones de A o un subconjunto de ellas.

     La sentencia set_partitions(A, N) devuelve un conjunto con todas las descomposiciones de A en N conjuntos no vacíos disjuntos.

     La sentencia set_partitions(A) devuelve el conjunto de todas las particiones.

     La función stirling2 devuelve la cardinalidad del conjunto de las particiones de un conjunto.

     Se dice que un conjunto P es una partición del conjunto S si verifica

      1. cada elemento de P es un conjunto no vacío,

      2. los elementos de P son disjuntos,

      3. la unión de los elementos de P es igual a  S.

     Ejemplos:

     El conjunto vacío forma una partición de sí mismo,

          (%i1) set_partitions ({});
          (%o1)                         {{}}

     La cardinalidad del conjunto de particiones de un conjunto puede calcularse con stirling2,

          (%i1) s: {0, 1, 2, 3, 4, 5}$
          (%i2) p: set_partitions (s, 3)$
          (%o3)                        90 = 90
          (%i4) cardinality(p) = stirling2 (6, 3);

     Cada elemento de p debería tener N = 3 miembros,

          (%i1) s: {0, 1, 2, 3, 4, 5}$
          (%i2) p: set_partitions (s, 3)$
          (%o3)                          {3}
          (%i4) map (cardinality, p);

     Por último, para cada miembro de p, la unión de sus elementos debe ser igual a s,

          (%i1) s: {0, 1, 2, 3, 4, 5}$
          (%i2) p: set_partitions (s, 3)$
          (%o3)                 {{0, 1, 2, 3, 4, 5}}
          (%i4) map (lambda ([x], apply (union, listify (x))), p);

 -- Función: some (F, A)
 -- Función: some (F, L_1, ..., L_N)

     Devuelve true si el predicado F devuelve true para al menos uno de sus argumentos. Si el segundo argumento es un conjunto, some (F, A) devuelve true si F(A_I) devuelve también true para alguno de los A_I en A; puede ser que some no evalúe F para todos los A_I de S. Puesto que los conjuntos no están ordenados, some puede evaluar F(A_I) en cualquier orden.

     Dada una o más listas como argumentos, some (F, L_1, ..., L_N) devuelve true si F(X_1, ..., X_N) devuelve también true para al menos un  X_1, ..., X_N de L_1, ..., L_N, respectivamente; puede ser que some no evalúe F para todos las combinaciones X_1, ..., X_N. La función some evalúa las listas en el orden creciente de su índice

     Dado un conjunto vacío {} o una lista vacía como argumentos, some devuelve false.

     Si la variable global maperror vale true, todas las listas L_1, ..., L_N deben tener igual número de elementos. Si maperror vale false, los argumentos se truncan para tener todos el número de elementos de la lista más corta.

     Los valores que devuelve el predicado F cuando toman (mediante is) un valor diferente a true y false se controlan con la variable global prederror. Si prederror vale true, tales valores se consideran como false. Si prederror vale false, tales valores se consideran como desconocidos (unknown).

     Ejemplos:

     La función some aplicada a un único conjunto. El predicado es una función de un argumento,

          (%i1) some (integerp, {1, 2, 3, 4, 5, 6});
          (%o1)                         true
          (%i2) some (atom, {1, 2, sin(3), 4, 5 + y, 6});
          (%o2)                         true

     La función some aplicada a dos listas. El predicado es una función de dos argumentos,

          (%i1) some ("=", [a, b, c], [a, b, c]);
          (%o1)                         true
          (%i2) some ("#", [a, b, c], [a, b, c]);
          (%o2)                         false

     Las respuestas del predicado F que se evalúan a cualquier cosa diferente de true y false están controlados por la variable global prederror.

          (%i1) prederror : false;
          (%o1)                         false
          (%i2) map (lambda ([a, b], is (a < b)), [x, y, z],
                               [x^2, y^2, z^2]);
          (%o2)              [unknown, unknown, unknown]
          (%i3) some ("<", [x, y, z], [x^2, y^2, z^2]);
          (%o3)                        unknown
          (%i4) some ("<", [x, y, z], [x^2, y^2, z + 1]);
          (%o4)                         true
          (%i5) prederror : true;
          (%o5)                         true
          (%i6) some ("<", [x, y, z], [x^2, y^2, z^2]);
          (%o6)                         false
          (%i7) some ("<", [x, y, z], [x^2, y^2, z + 1]);
          (%o7)                         true

 -- Función: stirling1 (N, M)

     Es el número de Stirling de primera especie.

     Si tanto N como M son enteros no negativos, el valor que toma stirling1 (N, M) es el número de permutaciones de un conjunto de N elementos con M ciclos. Para más detalles, véase Graham, Knuth and Patashnik Concrete Mathematics. Maxima utiliza una relación recursiva para definir stirling1 (N, M) para M menor que 0; no está definida para N menor que 0 ni para argumentos no enteros.

     La función stirling1 es simplificadora. Maxima reconoce las siguientes identidades:

      1. stirling1(0, n) = kron_delta(0, n) (Ref. [1])

      2. stirling1(n, n) = 1 (Ref. [1])

      3. stirling1(n, n - 1) = binomial(n, 2) (Ref. [1])

      4. stirling1(n + 1, 0) = 0 (Ref. [1])

      5. stirling1(n + 1, 1) = n! (Ref. [1])

      6. stirling1(n + 1, 2) = 2^n  - 1 (Ref. [1])

     Estas identidades se aplican cuando los argumentos son enteros literales o símbolos declarados como enteros y el primer argumento es no negativo. La función stirling1 no simplifica para argumentos no enteros.

     Referencias:

     [1] Donald Knuth, The Art of Computer Programming, Tercera Edición, Volumen 1, Sección 1.2.6, Ecuaciones 48, 49 y 50.

     Ejemplos:

          (%i1) declare (n, integer)$
          (%i2) assume (n >= 0)$
          (%i3) stirling1 (n, n);
          (%o3)                           1

     La función stirling1 no simplifica en caso de argumentos no enteros,

          (%i1) stirling1 (sqrt(2), sqrt(2));
          (%o1)              stirling1(sqrt(2), sqrt(2))

     Maxima aplicas algunas identidades a stirling1,

          (%i1) declare (n, integer)$
          (%i2) assume (n >= 0)$
          (%i3) stirling1 (n + 1, n);
                                      n (n + 1)
          (%o3)                       ---------
                                          2
          (%i4) stirling1 (n + 1, 1);
          (%o4)                          n!

 -- Función: stirling2 (N, M)

     Es el número de Stirling de segunda especie.

     Si N y M son enteros no negativos, stirling2 (N, M) es el número de formas en las que se puede particionar un conjunto de cardinal N en M subconjuntos disjuntos. Maxima utiliza una relación recursiva para definir stirling2 (N, M) con M menor que 0; la función no está definida para  N menor que 0  ni para argumentos no enteros.

     La función stirling2 es simplificadora. Maxima reconoce las siguientes identidades:

      1. stirling2(0, n) = kron_delta(0, n) (Ref. [1])

      2. stirling2(n, n) = 1 (Ref. [1])

      3. stirling2(n, n - 1) = binomial(n, 2) (Ref. [1])

      4. stirling2(n + 1, 1) = 1 (Ref. [1])

      5. stirling2(n + 1, 2) = 2^n  - 1 (Ref. [1])

      6. stirling2(n, 0) = kron_delta(n, 0) (Ref. [2])

      7. stirling2(n, m) = 0 when m > n (Ref. [2])

      8. stirling2(n, m) = sum((-1)^(m - k) binomial(m k) k^n,i,1,m) / m! si m y n son enteros y n no negativo. (Ref. [3])

     Estas identidades se aplican cuando los argumentos son enteros literales o símbolos declarados como enteros y el primer argumento es no negativo. La función stirling2 no simplifica para argumentos no enteros.

     Referencias:

     [1] Donald Knuth. The Art of Computer Programming, Tercera Edición, Volumen 1, Sección 1.2.6, Ecuaciones 48, 49 y 50.

     [2] Graham, Knuth y Patashnik. Concrete Mathematics, Tabla 264.

     [3] Abramowitz y Stegun. Handbook of Mathematical Functions, Sección 24.1.4.

     Ejemplos:

          (%i1) declare (n, integer)$
          (%i2) assume (n >= 0)$
          (%i3) stirling2 (n, n);
          (%o3)                           1

     La función stirling2 no simplifica en caso de argumentos no enteros,

          (%i1) stirling2 (%pi, %pi);
          (%o1)                  stirling2(%pi, %pi)

     Maxima aplicas algunas identidades a stirling2,

          (%i1) declare (n, integer)$
          (%i2) assume (n >= 0)$
          (%i3) stirling2 (n + 9, n + 8);
                                   (n + 8) (n + 9)
          (%o3)                    ---------------
                                          2
          (%i4) stirling2 (n + 1, 2);
                                        n
          (%o4)                        2  - 1

 -- Función: subset (A, F)

     Devuelve el subconjunto del conjunto A que satisface el predicado F.

     La función subset devuelve el conjunto que contiene a los elementos de A para los cuales F devuelve un resultado diferente de false. La función subset no aplica is al valor retornado por F.

     La función subset emite un mensaje de error si A no es un conjunto literal.

     Véase también partition_set.

     Ejemplos:

          (%i1) subset ({1, 2, x, x + y, z, x + y + z}, atom);
          (%o1)                     {1, 2, x, z}
          (%i2) subset ({1, 2, 7, 8, 9, 14}, evenp);
          (%o2)                      {2, 8, 14}

 -- Función: subsetp (A, B)

     Devuelve true si y sólo si el conjunto A es un subconjunto de B.

     La función subsetp emite un mensaje de error si cualesquiera A o B no es un conjunto literal.

     Ejemplos:

          (%i1) subsetp ({1, 2, 3}, {a, 1, b, 2, c, 3});
          (%o1)                         true
          (%i2) subsetp ({a, 1, b, 2, c, 3}, {1, 2, 3});
          (%o2)                         false

 -- Función: symmdifference (A_1, ..., A_N)

     Devuelve el conjunto de elementos que pertenecen a un único conjunto de los  A_K.

     Dados dos argumentos, symmdifference (A, B) equivale a union (setdifference (A, B), setdifference (B, A)).

     La función symmdifference emite un mensaje de error si alguno de su argumentos no es un conjunto literal.

     Ejemplos:

          (%i1) S_1 : {a, b, c};
          (%o1)                       {a, b, c}
          (%i2) S_2 : {1, b, c};
          (%o2)                       {1, b, c}
          (%i3) S_3 : {a, b, z};
          (%o3)                       {a, b, z}
          (%i4) symmdifference ();
          (%o4)                          {}
          (%i5) symmdifference (S_1);
          (%o5)                       {a, b, c}
          (%i6) symmdifference (S_1, S_2);
          (%o6)                        {1, a}
          (%i7) symmdifference (S_1, S_2, S_3);
          (%o7)                        {1, z}
          (%i8) symmdifference ({}, S_1, S_2, S_3);
          (%o8)                        {1, z}

 -- Función: tree_reduce (F, S)
 -- Función: tree_reduce (F, S, S_0)

     Amplía la función binaria F a n-aria, siendo S una lista.

     La función tree_reduce equivale a lo suguiente: Aplicar F a pares sucesivos de elementos para formar una nueva lista [F(S_1, S_2), F(S_3, S_4), ...], llevando el elemento final sin cambiar si el número de elementos es impar; después repetir hasta que la lista se reduzca a un único elemento, que es el valor de retorno.

     Cuando está presente el argumento opcional S_0, el resultado equivale a tree_reduce(F, cons(S_0, S).

     Para la suma de números decimales en coma flotante, tree_reduce puede devolver una suma que tenga un error de redondeo menor que el conseguido por rreduce o lreduce.

     Los elementos de S y los resultados parciales pueden colocarse en un árbol binario de mínima profundidad, de ahí el nombre de tree_reduce.

     Ejemplos:

     La función tree_reduce aplicada a una lista con un número par de elementos,

          (%i1) tree_reduce (f, [a, b, c, d]);
          (%o1)                  f(f(a, b), f(c, d))

     La función tree_reduce aplicada a una lista con un número impar de elementos,

          (%i1) tree_reduce (f, [a, b, c, d, e]);
          (%o1)               f(f(f(a, b), f(c, d)), e)

 -- Function: union (A_1, ..., A_N)

     Devuelve la unión de los conjuntos A_1 hasta A_N.

     La sentencia union() (sin argumentos) devuelve el conjunto vacío.

     La función union emite un mensaje de error si alguno de sus argumentos no es un conjunto literal.

     Ejemplos:

          (%i1) S_1 : {a, b, c + d, %e};
          (%o1)                   {%e, a, b, d + c}
          (%i2) S_2 : {%pi, %i, %e, c + d};
          (%o2)                 {%e, %i, %pi, d + c}
          (%i3) S_3 : {17, 29, 1729, %pi, %i};
          (%o3)                {17, 29, 1729, %i, %pi}
          (%i4) union ();
          (%o4)                          {}
          (%i5) union (S_1);
          (%o5)                   {%e, a, b, d + c}
          (%i6) union (S_1, S_2);
          (%o6)              {%e, %i, %pi, a, b, d + c}
          (%i7) union (S_1, S_2, S_3);
          (%o7)       {17, 29, 1729, %e, %i, %pi, a, b, d + c}
          (%i8) union ({}, S_1, S_2, S_3);
          (%o8)       {17, 29, 1729, %e, %i, %pi, a, b, d + c}

 -- Función: xreduce (F, S)
 -- Función: xreduce (F, S, S_0)

     Amplía la función F a n-aria mediante composición; si F ya es n-aria, aplica F a S. Si F no es n-aria, xreduce equivale a lreduce. El argumento S debe ser una lista.

     Funciones n-arias reconocidas por Maxima son la suma +, la multiplicación *, and, or, max, min y append. Las funciones también se pueden declarar n-arias mediante declare(F, nary); para estas funciones, xreduce será más rápida que rreduce o lreduce.

     Cuando está presente el argumento opcional S_0, el resultado equivale a xreduce(S, cons(S_0, S)).

     La suma de números decimales en coma flotante no es exactamente asociativa; aún así, xreduce aplica la suma n-aria cuando S contiene números en coma flotante.

     Ejemplos:

     La función xreduce aplicada a una función n-aria; F es invocada una sóla vez, con todos sus argumentos,

          (%i1) declare (F, nary);
          (%o1)                         done
          (%i2) F ([L]) := L;
          (%o2)                      F([L]) := L
          (%i3) xreduce (F, [a, b, c, d, e]);
          (%o3)         [[[[[("[", simp), a], b], c], d], e]

     La función xreduce aplicada a una función que se desconoce si es n-aria; G es invocada varias veces, con dos argumentos de cada vez,

          (%i1) G ([L]) := L;
          (%o1)                      G([L]) := L
          (%i2) xreduce (G, [a, b, c, d, e]);
          (%o2)         [[[[[("[", simp), a], b], c], d], e]
          (%i3) lreduce (G, [a, b, c, d, e]);
          (%o3)                 [[[[a, b], c], d], e]