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

# 33. Symmetries

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

## 33.1 Definitions for Symmetries

Function: comp2pui (n, l)

  re'alise le passage des fonctions syme'triques comple`tes, donnee's dans la liste l, aux fonctions syme'triques e'le'mentaires de 0 a` n. Si la liste l contient moins de `n+1` e'le'ments les valeurs formelles viennent la completer. Le premier e'le'ment de la liste l donne le cardinal de l'alphabet si il existe, sinon on le met e'gal a n.

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

Function: cont2part (pc, lvar)

  rend le polyno^me partitionne' associe' a` la forme contracte'e pc dont les variables sont dans 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]]

  Autres fonctions de changements de repre'sentations :

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

Function: contract (psym, lvar)

  rend une forme contracte'e (i.e. un mono^me par orbite sous l'action du groupe syme'trique) du polyno^me psym en les variables contenues dans la liste lvar. La fonction `explose` re'alise l'ope'ration inverse. La fonction `tcontract` teste en plus la syme'trie du polyno^me.

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

  Autres fonctions de changements de repre'sentations :

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

Function: direct ([p_1, ..., p_n], y, f, [lvar_1, ..., lvar_n])

  calcul l'image directe (voir M. GIUSTI, D. LAZARD et A. VALIBOUZE, ISSAC 1988, Rome) associe'e a` la fonction f, en les listes de variables lvar_1, ..., lvar_n, et aux polyno^mes p_1, ..., p_n d'une variable y. l'arite' de la fonction f est importante pour le calcul. Ainsi, si l'expression de f ne depend pas d'une variable, non seulement il est inutile de donner cette variable mais cela diminue conside'rablement lees calculs si on ne le fait pas.

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

  Recherche du polyno^me dont les racines sont les somme a+u ou a est racine de z^2 - e1* z + e2 et u est racine de z^2 - f1* z + f2

      (%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` peut prendre deux drapeaux possibles : `elementaires` et `puissances` (valeur par de'faut) qui permettent de de'composer les polyno^mes syme'triques apparaissant dans ce calcul par les fonctions syme'triques e'le'mentaires ou les fonctions puissances respectivement.

  Fonctions de `sym` utilis'ees dans cette fonction :

  `multi_orbit` (donc `orbit`), `pui_direct`, `multi_elem` (donc `elem`), `multi_pui` (donc `pui`), `pui2ele`, `ele2pui` (si le drapeau `direct` est a` `puissances`).

Function: ele2comp (m, l)

  passe des fonctions syme'triques e'le'mentaires aux fonctions comple`tes. Similaire a` `comp2ele` et `comp2pui`.

  Autres fonctions de changements de bases :

  `comp2ele`, `comp2pui`, `ele2pui`, `elem`, `mon2schur`, `multi_elem`, `multi_pui`, `pui`, `pui2comp`, `pui2ele`, `puireduc`, `schur2comp`.

Function: ele2polynome (l, z)

  donne le polyno^me en z dont les fonctions syme'triques e'le'mentaires des racines sont dans la liste l. `l = [n, e_1, ..., e_n]` ou` n est le degre' du polyno^me et e_i la i-ie`me fonction syme'trique e'le'mentaire.

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

  La re'ciproque: `polynome2ele (P, z)`

  Autres fonctions a` voir :

  `polynome2ele`, `pui2polynome`.

Function: ele2pui (m, l)

  passe des fonctions syme'triques e'le'mentaires aux fonctions comple`tes. Similaire a` `comp2ele` et `comp2pui`.

  Autres fonctions de changements de bases :

  `comp2ele`, `comp2pui`, `ele2comp`, `elem`, `mon2schur`, `multi_elem`, `multi_pui`, `pui`, `pui2comp`, `pui2ele`, `puireduc`, `schur2comp`.

Function: elem (ele, sym, lvar)

  de'compose le polyno^me syme'trique sym, en les variables contenues de la liste lvar, par les fonctions syme'triques e'le'mentaires contenues dans la liste ele. Si le premier e'le'ment de ele est donne' ce sera le cardinal de l'alphabet sinon on prendra le degre' du polyno^me sym. Si il manque des valeurs a` la liste ele des valeurs formelles du type "ei" sont rajoute'es. Le polyno^me sym peut etre donne' sous 3 formes diffe'rentes : contracte'e (`elem` doit alors valoir 1 sa valeur par de'faut), partitionne'e (`elem` doit alors valoir 3) ou e'tendue (i.e. le polyno^me en entier) (`elem` doit alors valoir 2). L'utilsation de la fonction `pui` se re'alise sur le me^me mode`le.

  Sur un alphabet de cardinal 3 avec e1, la premie`re fonction syme'trique e'le'mentaire, valant 7, le polyno^me syme'trique en 3 variables dont la forme contracte'e (ne de'pendant ici que de deux de ses variables) est x^4-2*x*y se de'compose ainsi en les fonctions syme'triques e'le'mentaires :

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

  Autres fonctions de changements de bases :

  `comp2ele`, `comp2pui`, `ele2comp`, `ele2pui`, `mon2schur`, `multi_elem`, `multi_pui`, `pui`, `pui2comp`, `pui2ele`, `puireduc`, `schur2comp`.

Function: explose (pc, lvar)

  rend le polyno^me syme'trique associe' a` la forme contracte'e pc. La liste lvar contient les variables.

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

  Autres fonctions de changements de repre'sentations :

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

Function: kostka (part_1, part_2)

  e'crite par P. ESPERET, calcule le nombre de Kostka associe' aux partition part_1 et part_2.

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

Function: lgtreillis (n, m)

  rend la liste des partitions de poids n et de longueur m.

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

  Voir e'galement : `ltreillis`, `treillis` et `treinat`.

Function: ltreillis (n, m)

  rend la liste des partitions de poids n et de longueur infe'rieure ou e'gale a` m.

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

  Voir e'galement : `lgtreillis`, `treillis` et `treinat`.

Function: mon2schur (l)

  la liste l repre'sente la fonction de Schur S_l: On a l = [i_1, i_2, ..., i_q] avec i_1 <= i_2 <= ... <= i_q. La fonction de Schur est S_[i_1, i_2, ..., i_q] est le mineur de la matrice infinie (h_{i-j}) i >= 1, j >= 1 compose' des q premie`res lignes et des colonnes i_1 + 1, i_2 + 2, ..., i_q + q.

  On e'crit cette fonction de Schur en fonction des formes monomiales en utilisant les fonctions `treinat` et `kostka`. La forme rendue est un polyno^me syme'trique dans une de ses repre'sentations contracte'es avec les 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

  ce qui veut dire que pour 3 variables cela donne :

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

  Autres fonctions de changements de bases :

  `comp2ele`, `comp2pui`, `ele2comp`, `ele2pui`, `elem`, `multi_elem`, `multi_pui`, `pui`, `pui2comp`, `pui2ele`, `puireduc`, `schur2comp`.

Function: multi_elem (l_elem, multi_pc, l_var)

  de'compose un polyno^me multi-syme'trique sous la forme multi-contracte'e multi_pc en les groupes de variables contenue dans la liste de listes l_var sur les groupes de fonctions syme'triques e'le'mentaires contenues dans 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

  Autres fonctions de changements de bases :

  `comp2ele`, `comp2pui`, `ele2comp`, `ele2pui`, `elem`, `mon2schur`, `multi_pui`, `pui`, `pui2comp`, `pui2ele`, `puireduc`, `schur2comp`.

Function: multi_orbit (P, [lvar_1, lvar_2, ..., lvar_p])

  P est un polyno^me en l'ensemble des variables contenues dans les listes lvar_1, lvar_2, ..., lvar_p. Cette fonction rame`ne l'orbite du polyno^me P sous l'action du produit des groupes syme'triques des ensembles de variables repre'sente's par ces p listes.

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

  Voir e'galement : `orbit` pour l'action d'un seul groupe syme'trique.

Function: multi_pui

  est a` la fonction `pui` ce que la fonction `multi_elem` est a` la fonction `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

Function: multinomial (r, part)

  ou` r est le poids de la partition part. Cette fonction rame`ne le coefficient multinomial associe' : si les parts de la partitions part sont i_1, i_2, ..., i_k, le re'sultat de `multinomial` est `r!/(i_1! i_2! ... i_k!)`.

Function: multsym (ppart_1, ppart_2, n)

  re'alise le produit de deux polyno^mes syme'triques de n variables en ne travaillant que modulo l'action du groupe syme'trique d'ordre n. Les polyno^mes sont dans leur repre'sentation partitionne'e.

  Soient les 2 polyno^mes syme'triques en `x`, `y`: `3*(x + y) + 2*x*y` et `5*(x^2 + y^2)` dont les formes partitionne'es sont respectivement `[[3, 1], [2, 1, 1]]` et `[[5, 2]]`, alors leur produit sera donne' par :

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

  soit `10*(x^3*y + y^3*x) + 15*(x^2*y + y^2*x) + 15*(x^3 + y^3)`.

  Fonctions de changements de repre'sentations d'un polyno^me syme'trique :

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

Function: orbit (P, lvar)

  calcul l'orbite du polyno^me P en les variables de la liste lvar sous l'action du groupe syme'trique de l'ensemble des variables contenues dans la liste 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]

  Voir e'galement : `multi_orbit` pour l'action d'un produit de groupes syme'triques sur un polyno^me.

Function: part2cont (ppart, lvar)

  passe de la forme partitionne'e a` la forme contracte'e d'un polyno^me syme'trique. La forme contracte'e est rendue avec les variables contenues dans lvar.

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

  Autres fonctions de changements de repre'sentations :

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

Function: partpol (psym, lvar)

  psym est un polyno^me syme'trique en les variables de lvar. Cette fonction rame`ne sa repre'sentation partitionne'e.

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

  Autres fonctions de changements de repre'sentations :

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

Function: permut (l)

  rame`ne la liste des permutations de la liste l.

Function: polynome2ele (P, x)

  donne la liste `l = [n, e_1, ..., e_n]` ou` n est le degre' du polyno^me P en la variable x et e_i la i-ieme fonction syme'trique e'le'mentaire des racines de 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

  La re'ciproque : `ele2polynome (l, x)`

Function: prodrac (l, k)

  l est une liste contenant les fonctions syme'triques e'le'mentaires sur un ensemble A. `prodrac` rend le polyno^me dont les racines sont les produits k a` k des e'le'ments de A.

Function: pui (l, sym, lvar)

  de'compose le polyno^me syme'trique sym, en les variables contenues de la liste lvar, par les fonctions puissances contenues dans la liste l. Si le premier e'le'ment de l est donne' ce sera le cardinal de l'alphabet sinon on prendra le degre' du polyno^me sym. Si il manque des valeurs a` la liste l, des valeurs formelles du type "pi" sont rajoute'es. Le polyno^me sym peut etre donne' sous 3 formes diffe'rentes : contracte'e (`pui` doit alors valoir 1 sa valeur par de'faut), partitionne'e (`pui` doit alors valoir 3) ou e'tendue (i.e. le polyno^me en entier) (`pui` doit alors valoir 2). La fonction `elem` s'utilise de la me^me manie`re.

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

  Autres fonctions de changements de bases :

  `comp2ele`, `comp2pui`, `ele2comp`, `ele2pui`, `elem`, `mon2schur`, `multi_elem`, `multi_pui`, `pui2comp`, `pui2ele`, `puireduc`, `schur2comp`.

Function: pui2comp (n, lpui)

  rend la liste des n premie`res fonctions comple`tes (avec en te^te le cardinal) en fonction des fonctions puissance donne'es dans la liste lpui. Si la liste lpui est vide le cardinal est N sinon c'est son premier e'le'ment similaire a` `comp2ele` et `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

  Autres fonctions de changements de bases :

  `comp2ele`, `comp2pui`, `ele2comp`, `ele2pui`, `elem`, `mon2schur`, `multi_elem`, `multi_pui`, `pui`, `pui2ele`, `puireduc`, `schur2comp`.

Function: pui2ele (n, lpui)

  re'alise le passage des fonctions puissances aux fonctions syme'triques e'le'mentaires. Si le drapeau `pui2ele` est `girard`, on re'cupe`re la liste des fonctions syme'triques e'le'mentaires de 1 a` n, et s'il est e'gal a` `close`, la n-ie`me fonction syme'trique e'le'mentaire.

  Autres fonctions de changements de bases :

  `comp2ele`, `comp2pui`, `ele2comp`, `ele2pui`, `elem`, `mon2schur`, `multi_elem`, `multi_pui`, `pui`, `pui2comp`, `puireduc`, `schur2comp`.

Function: pui2polynome (x, lpui)

  calcul le polyno^me en x dont les fonctions puissances des racines sont donne'es dans la liste 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

  Autres fonctions a` voir : `polynome2ele`, `ele2polynome`.

Function: pui_direct (orbite, [lvar_1, ..., lvar_n], [d_1, d_2, ..., d_n])

  Soit f un polynome en n blocs de variables lvar_1, ..., lvar_n. Soit c_i le nombre de variables dans lvar_i . Et SC le produit des n groupes syme'triques de degre' c_1, ..., c_n. Ce groupe agit naturellement sur f. La liste orbite est l'orbite, note'e `SC(f)`, de la fonction f sous l'action de SC. (Cette liste peut e^tre obtenue avec la fonction : `multi_orbit`). Les di sont des entiers tels que c_1 <= d_1, c_2 <= d_2, ..., c_n <= d_n. Soit SD le produit des groupes syme'triques S_d1 x S_d2 x ... x S_dn.

  La fonction `pui_direct` rame`ne les n premie`res fonctions puissances de `SD(f)` de'duites des fonctions puissances de `SC(f)` ou` n est le cardinal de `SD(f)`.

  Le re'sultat est rendue sous forme multi-contracte'e par rapport a SD. i.e. on ne conserve qu'un e'le'ment par orbite sous l'action de 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 ]

Function: puireduc (n, lpui)

  lpui est une liste dont le premier e'le'ment est un entier m. `puireduc` donne les n premie`res fonctions puissances en fonction des m premie`res.

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

Function: resolvante (P, x, f, [x_1, ..., x_d])

  calcule la re'solvante du polyno^me P de la variable x et de degre' n >= d par la fonction f exprime'e en les variables x_1, ..., x_d. Il est important pour l'efficacite' des calculs de ne pas mettre dans la liste `[x_1, ..., x_d]` les variables n'intervenant pas dans la fonction de transformation f.

  Afin de rendre plus efficaces les calculs on peut mettre des drapeaux a` la variable `resolvante` afin que des algorithmes ade'quates soient utilise's :

  Si la fonction f est unitaire :

  - un polyno^me d'une variable,
  - line'aire ,
  - alterne'e,
  - une somme de variables,
  - syme'trique en les variables qui apparaissent dans son expression,
  - un produit de variables,
  - la fonction de la re'solvante de Cayley (utilisable qu'en degre' 5)

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

    generale,

  le drapeau de `resolvante` pourra e^tre respectivement :

  - 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

  Pour la re'solvante de Cayley, les 2 derniers arguments sont neutres et le polyno^me donne' en entre'e doit ne'cessairement e^tre de degre' 5.

  Voir e'galement :

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

Function: resolvante_alternee1 (P, x)

  calcule la transformation de `P(x)` de degre n par la fonction $\prod_{1\leq i<j\leq n-1} (x_i-x_j)$.

  Voir e'galement :

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

Function: resolvante_bipartite (P, x)

  calcule la transformation de `P(x)` de degre n (n pair) par la fonction $x_1x_2\ldots x_{n/2}+x_{n/2+1}\ldotsx_n$

  Voir e'galement :

  `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

  Voir e'galement :

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

Function: resolvante_diedrale (P, x)

  calcule la transformation de `P(x)` par la fonction `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

  Voir e'galement :

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

Function: resolvante_klein (P, x)

  calcule la transformation de `P(x)` par la fonction `x_1 x_2 x_4 + x_4`.

  Voir e'galement :

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

Function: resolvante_klein3 (P, x)

  calcule la transformation de `P(x)` par la fonction `x_1 x_2 x_4 + x_4`.

  Voir e'galement :

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

Function: resolvante_produit_sym (P, x)

  calcule la liste toutes les r\'esolvantes produit du polyn\^ome `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

  Voir e'galement :

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

Function: resolvante_unitaire (P, Q, x)

  calcule la r\'esolvante du polyn\^ome `P(x)` par le polyn\^ome `Q(x)`.

  Voir e'galement :

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

Function: resolvante_vierer (P, x)

  calcule la transformation de `P(x)` par la fonction `x_1 x_2 - x_3 x_4`.

  Voir e'galement :

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

Function: schur2comp (P, l_var)

  P est un polyno^mes en les variables contenues dans la liste l_var. Chacune des variables de l_var repre'sente une fonction syme'trique comple`te. On repre'sente dans l_var la ie`me fonction syme'trique comple`te comme la concate'nation de la lettre `h` avec l'entier i : `hi`. Cette fonction donne l'expression de P en fonction des fonctions de Schur.

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

Function: somrac (l, k)

  la liste l contient les fonctions syme'triques e'le'mentaires d'un polyno^me P . On calcul le polyno^mes dont les racines sont les sommes K a` K distinctes des racines de P.

  Voir e'galement `prodrac`.

Function: tcontract (pol, lvar)

  teste si le polyno^me pol est syme'trique en les variables contenues dans la liste lvar. Si oui il rend une forme contracte'e comme la fonction `contract`.

  Autres fonctions de changements de repre'sentations :

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

Function: tpartpol (pol, lvar)

  teste si le polyno^me pol est syme'trique en les variables contenues dans la liste lvar. Si oui il rend sa forme partionne'e comme la fonction `partpol`.

  Autres fonctions de changements de repre'sentations :

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

Function: treillis (n)

  rame`ne toutes les partitions de poids n.

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

  Voir e'galement : `lgtreillis`, `ltreillis` et `treinat`.

Function: treinat (part)

  rame`ne la liste des partitions infe'rieures a` la partition part pour l'ordre naturel.

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

  Voir e'galement : `lgtreillis`, `ltreillis` et `treillis`.

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

This document was generated on March, 19 2006 using texi2html 1.76.