Introduction to Symmetries
==========================

sym is a package for working with symmetric groups of polynomials.

It was written for Macsyma-Symbolics by Annick Valibouze (http://www-calfor.lip6.fr/~avb/). The algorithms are described in the following papers:

 1. Fonctions symétriques et changements de bases. Annick Valibouze. EUROCAL'87 (Leipzig, 1987), 323--332, Lecture Notes in Comput. Sci 378. Springer, Berlin, 1989.

     http://www.stix.polytechnique.fr/publications/1984-1994.html

 2. Résolvantes et fonctions symétriques. Annick Valibouze. Proceedings of the ACM-SIGSAM 1989 International Symposium on Symbolic and Algebraic Computation, ISSAC'89 (Portland, Oregon). ACM Press, 390-399, 1989.

     http://www-calfor.lip6.fr/~avb/DonneesTelechargeables/MesArticles/issac89ACMValibouze.pdf

 3. Symbolic computation with symmetric polynomials, an extension to Macsyma. Annick Valibouze. Computers and Mathematics (MIT, USA, June 13-17, 1989), Springer-Verlag, New York Berlin, 308-320, 1989.

     http://www.stix.polytechnique.fr/publications/1984-1994.html

 4. Théorie de Galois Constructive. Annick Valibouze. Mémoire d'habilitation à diriger les recherches (HDR), Université P. et M. Curie (Paris VI), 1994.

Categories: Group theory Polynomials Share packages Package sym

Functions and Variables for Symmetries
======================================

Changing bases
--------------

 -- Function: comp2pui (N, L)
     implements passing from the complete symmetric functions given in the list L to the elementary symmetric functions from 0 to N. If the list L contains fewer than N+1 elements, it will be completed with formal values of the type H1, H2, etc. If the first element of the list L exists, it specifies the size of the alphabet, otherwise the size is set to N.

          (%i1) comp2pui (3, [4, g]);
                                  2                    2
          (%o1)    [4, g, 2 h2 - g , 3 h3 - g h2 + g (g  - 2 h2)]

     Categories: Package sym

 -- Function: ele2pui (M, L)
     goes from the elementary symmetric functions to the complete functions. Similar to comp2ele and comp2pui.

     Other functions for changing bases: comp2ele.

     Categories: Package sym

 -- Function: ele2comp (M, L)
     Goes from the elementary symmetric functions to the compete functions. Similar to comp2ele and comp2pui.

     Other functions for changing bases: comp2ele.

     Categories: Package sym

 -- Function: elem (ELE, SYM, LVAR)
     decomposes the symmetric polynomial SYM, in the variables contained in the list LVAR, in terms of the elementary symmetric functions given in the list ELE.  If the first element of ELE is given, it will be the size of the alphabet, otherwise the size will be the degree of the polynomial SYM.  If values are missing in the list ELE, formal values of the type E1, E2, etc. will be added.  The polynomial SYM may be given in three different forms: contracted (elem should then be 1, its default value), partitioned (elem should be 3), or extended (i.e. the entire polynomial, and elem should then be 2).  The function pui is used in the same way.

     On an alphabet of size 3 with E1, the first elementary symmetric function, with value 7, the symmetric polynomial in 3 variables whose contracted form (which here depends on only two of its variables) is X^4-2*X*Y decomposes as follows in elementary symmetric functions:

          (%i1) elem ([3, 7], x^4 - 2*x*y, [x, y]);
          (%o1) 7 (e3 - 7 e2 + 7 (49 - e2)) + 21 e3

                                                   + (- 2 (49 - e2) - 2) e2

          (%i2) ratsimp (%);
                                        2
          (%o2)             28 e3 + 2 e2  - 198 e2 + 2401

     Other functions for changing bases: comp2ele.

     Categories: Package sym

 -- Function: mon2schur (L)
     The list L represents the Schur function S_L: we have L = [i_1, i_2, ..., i_q], with i_1 <= i_2 <= ... <= i_q. The Schur function S_[i_1, i_2, ..., i_q] is the minor of the infinite matrix h_[i-j], i <= 1, j <= 1, consisting of the q first rows and the columns 1 + i_1, 2 + i_2, ..., q + i_q.

     This Schur function can be written in terms of monomials by using treinat and kostka  The form returned is a symmetric polynomial in a contracted representation in the variables x_1,x_2,...

          (%i1) mon2schur ([1, 1, 1]);
          (%o1)                       x1 x2 x3

          (%i2) mon2schur ([3]);
                                            2        3
          (%o2)                x1 x2 x3 + x1  x2 + x1

          (%i3) mon2schur ([1, 2]);
                                                2
          (%o3)                  2 x1 x2 x3 + x1  x2

     which means that for 3 variables this gives:

             2 x1 x2 x3 + x1^2 x2 + x2^2 x1 + x1^2 x3 + x3^2 x1
              + x2^2 x3 + x3^2 x2

     Other functions for changing bases: comp2ele.

     Categories: Package sym

 -- Function: multi_elem (L_ELEM, MULTI_PC, L_VAR)
     decomposes a multi-symmetric polynomial in the multi-contracted form MULTI_PC in the groups of variables contained in the list of lists L_VAR in terms of the elementary symmetric functions contained in L_ELEM.

          (%i1) multi_elem ([[2, e1, e2], [2, f1, f2]], a*x + a^2 + x^3,
                [[x, y], [a, b]]);
                                                            3
          (%o1)         - 2 f2 + f1 (f1 + e1) - 3 e1 e2 + e1

          (%i2) ratsimp (%);
                                   2                       3
          (%o2)         - 2 f2 + f1  + e1 f1 - 3 e1 e2 + e1

     Other functions for changing bases: comp2ele.

     Categories: Package sym

 -- Function: multi_pui
     is to the function pui what the function multi_elem is to the function elem.

          (%i1) multi_pui ([[2, p1, p2], [2, t1, t2]], a*x + a^2 + x^3,
                [[x, y], [a, b]]);
                                                      3
                                          3 p1 p2   p1
          (%o1)              t2 + p1 t1 + ------- - ---
                                             2       2

     Categories: Package sym

 -- Function: pui (L, SYM, LVAR)
     decomposes the symmetric polynomial SYM, in the variables in the list LVAR, in terms of the power functions in the list L. If the first element of L is given, it will be the size of the alphabet, otherwise the size will be the degree of the polynomial SYM.  If values are missing in the list L, formal values of the type P1, P2 , etc. will be added. The polynomial SYM may be given in three different forms: contracted (elem should then be 1, its default value), partitioned (elem should be 3), or extended (i.e. the entire polynomial, and elem should then be 2). The function pui is used in the same way.

          (%i1) pui;
          (%o1)                           1

          (%i2) pui ([3, a, b], u*x*y*z, [x, y, z]);
                                 2
                             a (a  - b) u   (a b - p3) u
          (%o2)              ------------ - ------------
                                  6              3

          (%i3) ratsimp (%);
                                                 3
                                (2 p3 - 3 a b + a ) u
          (%o3)                 ---------------------
                                          6

     Other functions for changing bases: comp2ele.

     Categories: Package sym

 -- Function: pui2comp (N, LPUI)
     renders the list of the first N complete functions (with the length first) in terms of the power functions given in the list LPUI. If the list LPUI is empty, the cardinal is N, otherwise it is its first element (as in comp2ele and comp2pui).

          (%i1) pui2comp (2, []);
                                                 2
                                          p2 + p1
          (%o1)                   [2, p1, --------]
                                             2

          (%i2) pui2comp (3, [2, a1]);
                                                      2
                                           a1 (p2 + a1 )
                                   2  p3 + ------------- + a1 p2
                            p2 + a1              2
          (%o2)     [2, a1, --------, --------------------------]
                               2                  3

          (%i3) ratsimp (%);
                                      2                     3
                               p2 + a1   2 p3 + 3 a1 p2 + a1
          (%o3)        [2, a1, --------, --------------------]
                                  2               6

     Other functions for changing bases: comp2ele.

     Categories: Package sym

 -- Function: pui2ele (N, LPUI)
     effects the passage from power functions to the elementary symmetric functions. If the flag pui2ele is girard, it will return the list of elementary symmetric functions from 1 to N, and if the flag is close, it will return the N-th elementary symmetric function.

     Other functions for changing bases: comp2ele.

     Categories: Package sym

 -- Function: puireduc (N, LPUI)
     LPUI is a list whose first element is an integer M. puireduc gives the first N power functions in terms of the first M.

          (%i1) puireduc (3, [2]);
                                                   2
                                             p1 (p1  - p2)
          (%o1)          [2, p1, p2, p1 p2 - -------------]
                                                   2

          (%i2) ratsimp (%);
                                                     3
                                         3 p1 p2 - p1
          (%o2)              [2, p1, p2, -------------]
                                               2

     Categories: Package sym

 -- Function: schur2comp (P, L_VAR)
     P is a polynomial in the variables of the list L_VAR.  Each of these variables represents a complete symmetric function.  In L_VAR the I-th complete symmetric function is represented by the concatenation of the letter h and the integer I: hI.  This function expresses P in terms of Schur functions.

          (%i1) schur2comp (h1*h2 - h3, [h1, h2, h3]);
          (%o1)                         s
                                         1, 2

          (%i2) schur2comp (a*h3, [h3]);
          (%o2)                         s  a
                                         3

     Categories: Package sym

Changing representations
------------------------

 -- Function: cont2part (PC, LVAR)
     returns the partitioned polynomial associated to the contracted form PC whose variables are in LVAR.

          (%i1) pc: 2*a^3*b*x^4*y + x^5;
                                     3    4      5
          (%o1)                   2 a  b x  y + x

          (%i2) cont2part (pc, [x, y]);
                                             3
          (%o2)              [[1, 5, 0], [2 a  b, 4, 1]]

     Categories: Package sym

 -- Function: contract (PSYM, LVAR)
     returns a contracted form (i.e. a monomial orbit under the action of the symmetric group) of the polynomial PSYM in the variables contained in the list LVAR.  The function explose performs the inverse operation.  The function tcontract tests the symmetry of the polynomial.

          (%i1) psym: explose (2*a^3*b*x^4*y, [x, y, z]);
                   3      4      3      4      3    4        3    4
          (%o1) 2 a  b y z  + 2 a  b x z  + 2 a  b y  z + 2 a  b x  z

                                                     3      4      3    4
                                                + 2 a  b x y  + 2 a  b x  y

          (%i2) contract (psym, [x, y, z]);
                                        3    4
          (%o2)                      2 a  b x  y

     Categories: Package sym

 -- Function: explose (PC, LVAR)
     returns the symmetric polynomial associated with the contracted form PC. The list LVAR contains the variables.

          (%i1) explose (a*x + 1, [x, y, z]);
          (%o1)                  a z + a y + a x + 1

     Categories: Package sym

 -- Function: part2cont (PPART, LVAR)
     goes from the partitioned form to the contracted form of a symmetric polynomial. The contracted form is rendered with the variables in LVAR.

          (%i1) part2cont ([[2*a^3*b, 4, 1]], [x, y]);
                                        3    4
          (%o1)                      2 a  b x  y

     Categories: Package sym

 -- Function: partpol (PSYM, LVAR)
     PSYM is a symmetric polynomial in the variables of the list LVAR. This function returns its partitioned representation.

          (%i1) partpol (-a*(x + y) + 3*x*y, [x, y]);
          (%o1)               [[3, 1, 1], [- a, 1, 0]]

     Categories: Package sym

 -- Function: tcontract (POL, LVAR)
     tests if the polynomial POL is symmetric in the variables of the list LVAR.  If so, it returns a contracted representation like the function contract.

     Categories: Package sym

 -- Function: tpartpol (POL, LVAR)
     tests if the polynomial POL is symmetric in the variables of the list LVAR.  If so, it returns its partitioned representation like the function partpol.

     Categories: Package sym

Groups and orbits
-----------------

 -- Function: direct ([P_1, ..., P_N], Y, F, [LVAR_1, ..., LVAR_N])
     calculates the direct image (see M. Giusti, D. Lazard et A. Valibouze, ISSAC 1988, Rome) associated to the function F, in the lists of variables LVAR_1, ..., LVAR_N, and in the polynomials P_1, ..., P_N in a variable Y.  The arity of the function F is important for the calculation.  Thus, if the expression for F does not depend on some variable, it is useless to include this variable, and not including it will also considerably reduce the amount of computation.

          (%i1) direct ([z^2  - e1* z + e2, z^2  - f1* z + f2],
                        z, b*v + a*u, [[u, v], [a, b]]);
                 2
          (%o1) y  - e1 f1 y

                                           2            2             2   2
                            - 4 e2 f2 - (e1  - 2 e2) (f1  - 2 f2) + e1  f1
                          + -----------------------------------------------
                                                   2

          (%i2) ratsimp (%);
                        2                2                   2
          (%o2)        y  - e1 f1 y + (e1  - 4 e2) f2 + e2 f1

          (%i3) ratsimp (direct ([z^3-e1*z^2+e2*z-e3,z^2  - f1* z + f2],
                        z, b*v + a*u, [[u, v], [a, b]]));
                 6            5         2                        2    2   4
          (%o3) y  - 2 e1 f1 y  + ((2 e1  - 6 e2) f2 + (2 e2 + e1 ) f1 ) y

                                    3                               3   3
           + ((9 e3 + 5 e1 e2 - 2 e1 ) f1 f2 + (- 2 e3 - 2 e1 e2) f1 ) y

                   2       2        4    2
           + ((9 e2  - 6 e1  e2 + e1 ) f2

                              2       2       2                   2    4
           + (- 9 e1 e3 - 6 e2  + 3 e1  e2) f1  f2 + (2 e1 e3 + e2 ) f1 )

            2          2                      2     3          2
           y  + (((9 e1  - 27 e2) e3 + 3 e1 e2  - e1  e2) f1 f2

                           2            2    3                5
           + ((15 e2 - 2 e1 ) e3 - e1 e2 ) f1  f2 - 2 e2 e3 f1 ) y

                     2                   3           3     2   2    3
           + (- 27 e3  + (18 e1 e2 - 4 e1 ) e3 - 4 e2  + e1  e2 ) f2

                   2      3                   3    2   2
           + (27 e3  + (e1  - 9 e1 e2) e3 + e2 ) f1  f2

                             2    4        2   6
           + (e1 e2 e3 - 9 e3 ) f1  f2 + e3  f1

     Finding the polynomial whose roots are the sums a+u where a is a root of z^2 - e_1 z + e_2 and u is a root of z^2 - f_1 z + f_2.

          (%i1) ratsimp (direct ([z^2 - e1* z + e2, z^2 - f1* z + f2],
                                    z, a + u, [[u], [a]]));
                 4                    3             2
          (%o1) y  + (- 2 f1 - 2 e1) y  + (2 f2 + f1  + 3 e1 f1 + 2 e2

               2   2                              2               2
           + e1 ) y  + ((- 2 f1 - 2 e1) f2 - e1 f1  + (- 2 e2 - e1 ) f1

                            2                     2            2
           - 2 e1 e2) y + f2  + (e1 f1 - 2 e2 + e1 ) f2 + e2 f1  + e1 e2 f1

               2
           + e2

     direct accepts two flags: elementaires and puissances (default) which allow decomposing the symmetric polynomials appearing in the calculation into elementary symmetric functions, or power functions, respectively.

     Functions of sym used in this function:

     multi_orbit (so orbit), pui_direct, multi_elem (so elem), multi_pui (so pui), pui2ele, ele2pui (if the flag direct is in puissances).

     Categories: Package sym

 -- Function: multi_orbit (P, [LVAR_1, LVAR_2,..., LVAR_P])

     P is a polynomial in the set of variables contained in the lists LVAR_1, LVAR_2, ..., LVAR_P. This function returns the orbit of the polynomial P under the action of the product of the symmetric groups of the sets of variables represented in these P lists.

          (%i1) multi_orbit (a*x + b*y, [[x, y], [a, b]]);
          (%o1)                [b y + a x, a y + b x]

          (%i2) multi_orbit (x + y + 2*a, [[x, y], [a, b, c]]);
          (%o2)        [y + x + 2 c, y + x + 2 b, y + x + 2 a]

     Also see: orbit for the action of a single symmetric group.

     Categories: Package sym

 -- Function: multsym (PPART_1, PPART_2, N)
     returns the product of the two symmetric polynomials in N variables by working only modulo the action of the symmetric group of order N. The polynomials are in their partitioned form.

     Given the 2 symmetric polynomials in X, Y:  3*(x + y) + 2*x*y and 5*(x^2 + y^2) whose partitioned forms are [[3, 1], [2, 1, 1]] and [[5, 2]], their product will be

          (%i1) multsym ([[3, 1], [2, 1, 1]], [[5, 2]], 2);
          (%o1)         [[10, 3, 1], [15, 3, 0], [15, 2, 1]]

     that is 10*(x^3*y + y^3*x) + 15*(x^2*y + y^2*x) + 15*(x^3 + y^3).

     Functions for changing the representations of a symmetric polynomial:

     contract, cont2part, explose, part2cont, partpol, tcontract, tpartpol.

     Categories: Package sym

 -- Function: orbit (P, LVAR)
     computes the orbit of the polynomial P in the variables in the list LVAR under the action of the symmetric group of the set of variables in the list LVAR.

          (%i1) orbit (a*x + b*y, [x, y]);
          (%o1)                [a y + b x, b y + a x]

          (%i2) orbit (2*x + x^2, [x, y]);
                                  2         2
          (%o2)                 [y  + 2 y, x  + 2 x]

     See also multi_orbit for the action of a product of symmetric groups on a polynomial.

     Categories: Package sym

 -- Function: pui_direct (ORBITE, [LVAR_1, ..., LVAR_N], [D_1, D_2, ..., D_N])

     Let F be a polynomial in N blocks of variables LVAR_1, ..., LVAR_N.  Let C_I be the number of variables in LVAR_I, and SC be the product of N symmetric groups of degree C_1, ..., C_N. This group acts naturally on F. The list ORBITE is the orbit, denoted SC(F), of the function F under the action of SC. (This list may be obtained by the function multi_orbit.)  The DI are integers s.t. c_1 <= d_1, c_2 <= d_2, ..., c_n <= d_n.

     Let SD be the product of the symmetric groups S_[d_1] x S_[d_2] x ... x S_[d_n]. The function pui_direct returns the first N power functions of SD(F) deduced from the power functions of SC(F), where N is the size of SD(F).

     The result is in multi-contracted form w.r.t. SD, i.e. only one element is kept per orbit, under the action of SD.

          (%i1) l: [[x, y], [a, b]];
          (%o1)                   [[x, y], [a, b]]

          (%i2) pui_direct (multi_orbit (a*x + b*y, l), l, [2, 2]);
                                                 2  2
          (%o2)               [a x, 4 a b x y + a  x ]

          (%i3) pui_direct (multi_orbit (a*x + b*y, l), l, [3, 2]);
                                       2  2     2    2        3  3
          (%o3) [2 a x, 4 a b x y + 2 a  x , 3 a  b x  y + 2 a  x ,

              2  2  2  2      3    3        4  4
          12 a  b  x  y  + 4 a  b x  y + 2 a  x ,

              3  2  3  2      4    4        5  5
          10 a  b  x  y  + 5 a  b x  y + 2 a  x ,

              3  3  3  3       4  2  4  2      5    5        6  6
          40 a  b  x  y  + 15 a  b  x  y  + 6 a  b x  y + 2 a  x ]

          (%i4) pui_direct ([y + x + 2*c, y + x + 2*b, y + x + 2*a],
                [[x, y], [a, b, c]], [2, 3]);
                                       2              2
          (%o4) [3 x + 2 a, 6 x y + 3 x  + 4 a x + 4 a ,

                           2                   3        2       2        3
                        9 x  y + 12 a x y + 3 x  + 6 a x  + 12 a  x + 8 a ]

     Categories: Package sym

Partitions
----------

 -- Function: kostka (PART_1, PART_2)
     written by P. Esperet, calculates the Kostka number of the partition PART_1 and PART_2.

          (%i1) kostka ([3, 3, 3], [2, 2, 2, 1, 1, 1]);
          (%o1)                           6

     Categories: Package sym

 -- Function: lgtreillis (N, M)
     returns the list of partitions of weight N and length M.

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

     Also see: ltreillis treillis and treinat

     Categories: Package sym

 -- Function: ltreillis (N, M)
     returns the list of partitions of weight N and length less than or equal to M.

          (%i1) ltreillis (4, 2);
          (%o1)               [[4, 0], [3, 1], [2, 2]]

     Also see: lgtreillis treillis and treinat

     Categories: Package sym

 -- Function: treillis (N)
     returns all partitions of weight N.

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

     See also: lgtreillis ltreillis and treinat

     Categories: Package sym

 -- Function: treinat (PART)
     returns the list of partitions inferior to the partition PART w.r.t. the natural order.

          (%i1) treinat ([5]);
          (%o1)                         [[5]]

          (%i2) treinat ([1, 1, 1, 1, 1]);
          (%o2) [[5], [4, 1], [3, 2], [3, 1, 1], [2, 2, 1], [2, 1, 1, 1],

                                                           [1, 1, 1, 1, 1]]

          (%i3) treinat ([3, 2]);
          (%o3)                 [[5], [4, 1], [3, 2]]

     See also: lgtreillis ltreillis and treillis

     Categories: Package sym

Polynomials and their roots
---------------------------

 -- Function: ele2polynome (L, Z)
     returns the polynomial in Z s.t. the elementary symmetric functions of its roots are in the list L = [N, E_1, ..., E_N], where N is the degree of the polynomial and E_I the I-th elementary symmetric function.

          (%i1) ele2polynome ([2, e1, e2], z);
                                    2
          (%o1)                    z  - e1 z + e2

          (%i2) polynome2ele (x^7 - 14*x^5 + 56*x^3  - 56*x + 22, x);
          (%o2)          [7, 0, - 14, 0, 56, 0, - 56, - 22]

          (%i3) ele2polynome ([7, 0, -14, 0, 56, 0, -56, -22], x);
                            7       5       3
          (%o3)            x  - 14 x  + 56 x  - 56 x + 22

     The inverse: polynome2ele (P, Z).

     Also see: polynome2ele, pui2polynome.

     Categories: Package sym

 -- Function: polynome2ele (P, X)
     gives the list L = [N, E_1, ..., E_N] where N is the degree of the polynomial P in the variable X and E_I is the I-the elementary symmetric function of the roots of P.

          (%i1) polynome2ele (x^7 - 14*x^5 + 56*x^3 - 56*x + 22, x);
          (%o1)          [7, 0, - 14, 0, 56, 0, - 56, - 22]

          (%i2) ele2polynome ([7, 0, -14, 0, 56, 0, -56, -22], x);
                            7       5       3
          (%o2)            x  - 14 x  + 56 x  - 56 x + 22

     The inverse: ele2polynome (L, X)

     Categories: Package sym

 -- Function: prodrac (L, K)
     L is a list containing the elementary symmetric functions on a set A. prodrac returns the polynomial whose roots are the K by K products of the elements of A.

     Also see somrac.

     Categories: Package sym

 -- Function: pui2polynome (X, LPUI)
     calculates the polynomial in X whose power functions of the roots are given in the list LPUI.

          (%i1) pui;
          (%o1)                           1

          (%i2) kill(labels);
          (%o0)                         done

          (%i1) polynome2ele (x^3 - 4*x^2 + 5*x - 1, x);
          (%o1)                     [3, 4, 5, 1]

          (%i2) ele2pui (3, %);
          (%o2)                     [3, 4, 6, 7]

          (%i3) pui2polynome (x, %);
                                  3      2
          (%o3)                  x  - 4 x  + 5 x - 1

     See also: polynome2ele ele2polynome

     Categories: Package sym

 -- Function: somrac (L, K)
     The list L contains elementary symmetric functions of a polynomial P . The function computes the polynomial whose roots are the K by K distinct sums of the roots of P.

     Also see prodrac.

     Categories: Package sym

Resolvents
----------

 -- Function: resolvante (P, X, F, [X_1,..., X_D])
     calculates the resolvent of the polynomial P in X of degree n >= d by the function F expressed in the variables X_1, ..., X_D.  For efficiency of computation it is important to not include in the list [X_1, ..., X_D] variables which do not appear in the transformation function F.

     To increase the efficiency of the computation one may set flags in resolvante so as to use appropriate algorithms:

     If the function F is unitary:

       * A polynomial in a single variable,

       * linear,

       * alternating,

       * a sum,

       * symmetric,

       * a product,

       * the function of the Cayley resolvent (usable up to degree 5)

               (x1*x2 + x2*x3 + x3*x4 + x4*x5 + x5*x1 -
                    (x1*x3 + x3*x5 + x5*x2 + x2*x4 + x4*x1))^2

          general,

     the flag of resolvante may be, respectively:

       * unitaire,

       * lineaire,

       * alternee,

       * somme,

       * produit,

       * cayley,

       * generale.

          (%i1) resolvante: unitaire$

          (%i2) resolvante (x^7 - 14*x^5 + 56*x^3 - 56*x + 22, x, x^3 - 1,
                [x]);

          " resolvante unitaire " [7, 0, 28, 0, 168, 0, 1120, - 154, 7840,
                                   - 2772, 56448, - 33880,

          413952, - 352352, 3076668, - 3363360, 23114112, - 30494464,

          175230832, - 267412992, 1338886528, - 2292126760]
            3       6      3       9      6      3
          [x  - 1, x  - 2 x  + 1, x  - 3 x  + 3 x  - 1,

           12      9      6      3       15      12       9       6      3
          x   - 4 x  + 6 x  - 4 x  + 1, x   - 5 x   + 10 x  - 10 x  + 5 x

                 18      15       12       9       6      3
           - 1, x   - 6 x   + 15 x   - 20 x  + 15 x  - 6 x  + 1,

           21      18       15       12       9       6      3
          x   - 7 x   + 21 x   - 35 x   + 35 x  - 21 x  + 7 x  - 1]
          [- 7, 1127, - 6139, 431767, - 5472047, 201692519, - 3603982011]
                 7      6        5         4          3           2
          (%o2) y  + 7 y  - 539 y  - 1841 y  + 51443 y  + 315133 y

                                                        + 376999 y + 125253

          (%i3) resolvante: lineaire$

          (%i4) resolvante (x^4 - 1, x, x1 + 2*x2 + 3*x3, [x1, x2, x3]);

          " resolvante lineaire "
                 24       20         16            12             8
          (%o4) y   + 80 y   + 7520 y   + 1107200 y   + 49475840 y

                                                              4
                                                 + 344489984 y  + 655360000

          (%i5) resolvante: general$

          (%i6) resolvante (x^4 - 1, x, x1 + 2*x2 + 3*x3, [x1, x2, x3]);

          " resolvante generale "
                 24       20         16            12             8
          (%o6) y   + 80 y   + 7520 y   + 1107200 y   + 49475840 y

                                                              4
                                                 + 344489984 y  + 655360000

          (%i7) resolvante (x^4 - 1, x, x1 + 2*x2 + 3*x3, [x1, x2, x3, x4]);

          " resolvante generale "
                 24       20         16            12             8
          (%o7) y   + 80 y   + 7520 y   + 1107200 y   + 49475840 y

                                                              4
                                                 + 344489984 y  + 655360000

          (%i8) direct ([x^4 - 1], x, x1 + 2*x2 + 3*x3, [[x1, x2, x3]]);
                 24       20         16            12             8
          (%o8) y   + 80 y   + 7520 y   + 1107200 y   + 49475840 y

                                                              4
                                                 + 344489984 y  + 655360000

          (%i9) resolvante :lineaire$

          (%i10) resolvante (x^4 - 1, x, x1 + x2 + x3, [x1, x2, x3]);

          " resolvante lineaire "
                                        4
          (%o10)                       y  - 1

          (%i11) resolvante: symetrique$

          (%i12) resolvante (x^4 - 1, x, x1 + x2 + x3, [x1, x2, x3]);

          " resolvante symetrique "
                                        4
          (%o12)                       y  - 1

          (%i13) resolvante (x^4 + x + 1, x, x1 - x2, [x1, x2]);

          " resolvante symetrique "
                                     6      2
          (%o13)                    y  - 4 y  - 1

          (%i14) resolvante: alternee$

          (%i15) resolvante (x^4 + x + 1, x, x1 - x2, [x1, x2]);

          " resolvante alternee "
                      12      8       6        4        2
          (%o15)     y   + 8 y  + 26 y  - 112 y  + 216 y  + 229

          (%i16) resolvante: produit$

          (%i17) resolvante (x^7 - 7*x + 3, x, x1*x2*x3, [x1, x2, x3]);

          " resolvante produit "
                  35      33         29        28         27        26
          (%o17) y   - 7 y   - 1029 y   + 135 y   + 7203 y   - 756 y

                   24           23          22            21           20
           + 1323 y   + 352947 y   - 46305 y   - 2463339 y   + 324135 y

                    19           18             17              15
           - 30618 y   - 453789 y   - 40246444 y   + 282225202 y

                       14              12             11            10
           - 44274492 y   + 155098503 y   + 12252303 y   + 2893401 y

                        9            8            7             6
           - 171532242 y  + 6751269 y  + 2657205 y  - 94517766 y

                      5             3
           - 3720087 y  + 26040609 y  + 14348907

          (%i18) resolvante: symetrique$

          (%i19) resolvante (x^7 - 7*x + 3, x, x1*x2*x3, [x1, x2, x3]);

          " resolvante symetrique "
                  35      33         29        28         27        26
          (%o19) y   - 7 y   - 1029 y   + 135 y   + 7203 y   - 756 y

                   24           23          22            21           20
           + 1323 y   + 352947 y   - 46305 y   - 2463339 y   + 324135 y

                    19           18             17              15
           - 30618 y   - 453789 y   - 40246444 y   + 282225202 y

                       14              12             11            10
           - 44274492 y   + 155098503 y   + 12252303 y   + 2893401 y

                        9            8            7             6
           - 171532242 y  + 6751269 y  + 2657205 y  - 94517766 y

                      5             3
           - 3720087 y  + 26040609 y  + 14348907

          (%i20) resolvante: cayley$

          (%i21) resolvante (x^5 - 4*x^2 + x + 1, x, a, []);

          " resolvante de Cayley "
                  6       5         4          3            2
          (%o21) x  - 40 x  + 4080 x  - 92928 x  + 3772160 x  + 37880832 x

                                                                 + 93392896

     For the Cayley resolvent, the 2 last arguments are neutral and the input polynomial must necessarily be of degree 5.

     See also:

     resolvante_bipartite resolvante_produit_sym
     resolvante_unitaire resolvante_alternee1 resolvante_klein
     resolvante_klein3 resolvante_vierer resolvante_diedrale

     Categories: Package sym

 -- Function: resolvante_alternee1 (P, X)
     calculates the transformation P(X) of degree N by the function product(x_i - x_j, 1 <= i < j <= n - 1).

     See also:

     resolvante_produit_sym resolvante_unitaire
     resolvante  resolvante_klein resolvante_klein3
     resolvante_vierer resolvante_diedrale resolvante_bipartite

     Categories: Package sym

 -- Function: resolvante_bipartite (P, X)
     calculates the transformation of P(X) of even degree N by the function x_1 x_2 ... x_[n/2] + x_[n/2 + 1] ... x_n.

          (%i1) resolvante_bipartite (x^6 + 108, x);
                        10        8           6             4
          (%o1)        y   - 972 y  + 314928 y  - 34012224 y

     See also:

     resolvante_produit_sym resolvante_unitaire
     resolvante resolvante_klein resolvante_klein3
     resolvante_vierer resolvante_diedrale resolvante_alternee1

     Categories: Package sym

 -- Function: resolvante_diedrale (P, X)
     calculates the transformation of P(X) by the function X_1 X_2 + X_3 X_4.

          (%i1) resolvante_diedrale (x^5 - 3*x^4 + 1, x);
                 15       12       11       10        9         8         7
          (%o1) x   - 21 x   - 81 x   - 21 x   + 207 x  + 1134 x  + 2331 x

                  6         5          4          3          2
           - 945 x  - 4970 x  - 18333 x  - 29079 x  - 20745 x  - 25326 x

           - 697

     See also:

     resolvante_produit_sym resolvante_unitaire
     resolvante_alternee1 resolvante_klein resolvante_klein3
     resolvante_vierer resolvante

     Categories: Package sym

 -- Function: resolvante_klein (P, X)
     calculates the transformation of P(X) by the function X_1 X_2 X_4 + X_4.

     See also:

     resolvante_produit_sym resolvante_unitaire
     resolvante_alternee1 resolvante resolvante_klein3
     resolvante_vierer resolvante_diedrale

     Categories: Package sym

 -- Function: resolvante_klein3 (P, X)
     calculates the transformation of P(X) by the function X_1 X_2 X_4 + X_4.

     See also:

     resolvante_produit_sym resolvante_unitaire
     resolvante_alternee1 resolvante_klein resolvante
     resolvante_vierer resolvante_diedrale

     Categories: Package sym

 -- Function: resolvante_produit_sym (P, X)
     calculates the list of all product resolvents of the polynomial P(X).

          (%i1) resolvante_produit_sym (x^5 + 3*x^4 + 2*x - 1, x);
                  5      4             10      8       7       6       5
          (%o1) [y  + 3 y  + 2 y - 1, y   - 2 y  - 21 y  - 31 y  - 14 y

              4       3      2       10      8       7    6       5       4
           - y  + 14 y  + 3 y  + 1, y   + 3 y  + 14 y  - y  - 14 y  - 31 y

                 3      2       5      4
           - 21 y  - 2 y  + 1, y  - 2 y  - 3 y - 1, y - 1]

          (%i2) resolvante: produit$

          (%i3) resolvante (x^5 + 3*x^4 + 2*x - 1, x, a*b*c, [a, b, c]);

          " resolvante produit "
                 10      8       7    6        5       4       3     2
          (%o3) y   + 3 y  + 14 y  - y  - 14 y  - 31 y  - 21 y  - 2 y  + 1

     See also:

     resolvante resolvante_unitaire
     resolvante_alternee1 resolvante_klein
     resolvante_klein3 resolvante_vierer
     resolvante_diedrale

     Categories: Package sym

 -- Function: resolvante_unitaire (P, Q, X)
     computes the resolvent of the polynomial P(X) by the polynomial Q(X).

     See also:

     resolvante_produit_sym resolvante
     resolvante_alternee1 resolvante_klein resolvante_klein3
     resolvante_vierer resolvante_diedrale

     Categories: Package sym

 -- Function: resolvante_vierer (P, X)
     computes the transformation of P(X) by the function X_1 X_2 - X_3 X_4.

     See also:

     resolvante_produit_sym resolvante_unitaire
     resolvante_alternee1 resolvante_klein resolvante_klein3
     resolvante resolvante_diedrale

     Categories: Package sym

Miscellaneous
-------------

 -- Function: multinomial (R, PART)
     where R is the weight of the partition PART.  This function returns the associate multinomial coefficient: if the parts of PART are I_1, I_2, ..., I_K, the result is R!/(I_1! I_2! ... I_K!).

     Categories: Package sym

 -- Function: permut (L)
     returns the list of permutations of the list L.

     Categories: Package sym Lists