[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

# 32. Symmetries

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 32.1 Introduction to Symmetries

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

Categories: Group theory · Polynomials · Share packages · Package sym

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

## 32.2 Functions and Variables for Symmetries

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 32.2.1 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,\ldots.

      (%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

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 32.2.2 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 retturns 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

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 32.2.3 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 calulation. 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 \le d_1, c_2 \le d_2, \ldots, c_n \le 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

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 32.2.4 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)

  retruns 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

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 32.2.5 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

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 32.2.6 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.

  See also:

  `resolvante_produit_sym`, `resolvante_unitaire`, `resolvante` , `resolvante_klein`, `resolvante_klein3`, `resolvante_vierer`, `resolvante_diedrale`, `resolvante_alternee1`.

      (%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

[ < ] | [ > ] |  | [ << ] | [ Up ] | [ >> ] |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

### 32.2.7 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

[ << ] | [ >> ] |  |  |  |  |  | [Top] | [Contents] | [Index] | [ ? ]

This document was generated by Robert Dodier on August, 24 2008 using texi2html 1.76.