Funcedilhaões e Variáveis Definidas para Simetrias
==================================================

Mudando a base do sistema de numeracedilhaão
--------------------------------------------

 -- Funcedilhaão: comp2pui (N, L)
     implementa a passagem das funções simétricas completamente simétricas fornecidas na lista L para as funções simétricas elementares de 0 a N. Se a lista L contiver menos que N+1 elementos, será completada com valores formais do tipo H1, H2, etc. Se o primeiro elemento da lista L existir, ele é interpretado como sendo o tamanho do alfabeto, de outra forma o tamanho é escolhido para N.

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

 -- Funcedilhaão: ele2pui (M, L)
     vai de funcedilhaões simétricas elementares para as funcedilhaões completas. Similar a comp2ele e comp2pui.

     Outras funcedilhaões para mudancedilhaas de base: comp2ele.

 -- Funcedilhaão: ele2comp (M, L)
     Vai de funcedilhaões simétricas elementares para funcedilhaões completas. Similar a comp2ele e a comp2pui.

     Outras funcedilhaões para mudancedilhaas de base: comp2ele.

 -- Funcedilhaão: elem (ELE, SYM, LVAR)
     decompõe o polinômio simétrico SYM, nas variáveis contidas na lista LVAR, em termos de funcedilhaões elementares simétricas fornecidas na lista ELE.  Se o primeiro elemento de ELE for fornecido, esse primeiro elemento será o tamanho do alfabeto, de outra forma o tamanho será o grau do polinômio SYM.  Se valores forem omitidos na lista ELE, valores formais do tipo E1, E2, etc. serão adicionados.  O polinômio SYM pode ser fornecido de três diferentes formas: contraída (elem pode então ser 1, seu valor padrão), particionada (elem pode ser 3), ou extendida (i.e. o polinômio completo, e elem pode então ser 2).  A funcedilhaão pui é usada então da mesma forma.

     sobre um alfabeto de tamanho 3 com E1, a primeira funcedilhaào elementar simétrica, com valor 7, o polinômio simétrico em 3 variáveis cuja forma contraída (que aqui depende de duas de suas variáveis) é X^4-2*X*Y decomposto como segue em funcedilhaões elementares simétricas:

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

     Outras funcedilhaões para mudancedilhaas de base: comp2ele.

 -- Function: mon2schur (L)
     a lsita L representa a funcedilhaão de Schur S_L: temos L = [i_1, i_2, ..., i_q], com i_1 <= i_2 <= ... <= i_q. A funcedilhaão de Schur S_[i_1, i_2, ..., i_q] é a menor da matriz infinita h_[i-j], i <= 1, j <= 1, consistindo das q primeiras linhas e as colunas 1 + i_1, +2 + i_2, ..., q + i_q.

     Essa funcedilhaão de Schur pode ser escrita em termos de monômios usando treinat e kostka.  A forma retornada é um polinômio simétrico na representacedilhaão contraída nas variáveis 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

     o qual significa que para 3 variáveis fornece:

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

     Outras funcedilhaões para mudancedilhaas de base: comp2ele.

 -- Funcedilhaão: multi_elem (L_ELEM, MULTI_PC, L_VAR)
     decompões um polinômio multi-simétrico na forma multi-contraída MULTI_PC nos grupos de variáveis contidas na lista de listas L_VAR en termos de funcedilhaões elementares simétricas contidas em 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

     Outras funcedilhaões para mudancedilhaas de base: comp2ele.

 -- Funcedilhaão: multi_pui
     é para a funcedilhaão pui o que a funcedilhaão multi_elem é para a funcedilhaão 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

 -- Funcedilhaão: pui (L, SYM, LVAR)
     decompõe o polinômio simétrico SYM, nas variáveis na lista LVAR, em termos de funcedilhaões exponenciais na lista L. Se o primeiro elemento de L for fornecido, esse primeiro elemento será o tamanho do alfabeto, de outra forma o tamanho será o grau do polinômio SYM.  Se valores forem omitidos na lista L, valores formais do tipo P1, P2 , etc. serão adicionados. O polinômio SYM pode ser fornecido de três diferentes formas: contraída (elem pode então ser 1, seu valor padrão), particionada (elem pode ser 3), ou extendida (i.e. o polinômio completo, e elem pode então ser 2). A funcedilhaão pui é usada da mesma forma.

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

     Outras funcedilhaões para mudancedilhaas de base: comp2ele.

 -- Funcedilhaão: pui2comp (N, LPUI)
     converte a dista das primeiras N funcedilhaões completas (com o comprimento em primeiro lugar) em termos de funcedilhaões exponenciais fornecidas na lista LPUI. se a lista LPUI for vazia, o cardinal é N, de outra forma o cardinal será seu primeiro elemento (como em comp2ele e em 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

     Outras funcedilhaões para mudancedilhaas de base: comp2ele.

 -- Funcedilhaão: pui2ele (N, LPUI)
     efetiva a passagem de funcedilhaões exponenciais para as funcedilhaões elementares simétricas. Se o sinalizador pui2ele for girard, pui2ele irá retornar a lista de funcedilhaões elementares simétricas de 1 a N, e se o sinalizador for close, pui2ele retornará a N-ésima funcedilhaão simétrica elementar.

     Outras funcedilhaões para mudancedilhaas de base: comp2ele.

 -- Funcedilhaão: puireduc (N, LPUI)
     LPUI é uma lista cujo primeiro elemento é um inteiro M. puireduc fornece as primeiras N funcedilhaões exponenciais em termos das primeiras M funcedilhaões.

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

 -- Funcedilhaão: schur2comp (P, L_VAR)
     P é um polinômio nas variáveis da lista L_VAR.  Cada uma dessas variáveis represetna uma funcedilhaão simétrica completa.  Na lista L_VAR o I-ésima funcedilhaão simétrica completa é representada através da concatenacedilhaão da letra h com o inteiro I: hI.  Essa funcedilhaão expressa P em termos de funcedilhaões de Schur.

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

Modificando represetnacedilhaões
--------------------------------

 -- Funcedilhaão: cont2part (PC, LVAR)
     Retorna o polinômio particionado associado à forma contraída PC cujas variáveis estão em 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]]

 -- Funcedilhaão: contract (PSYM, LVAR)
     retorna uma forma contraída (i.e. um monômio de grupo ssimétrico) do polinômio PSYM nas variáveis contidas na lista LVAR.  A funcedilhaão explose executa a operacedilhaão inversa.  A funcedilhaão tcontract testa a simétria do polinômio.

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

 -- Funcedilhaão: explose (PC, LVAR)
     retorna o polinômio simétrico associado com a forma contraída PC. A lista LVAR conté as variáveis.

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

 -- Funcedilhaão: part2cont (PPART, LVAR)
     vai da forma particionada para a forma contraída de um polinômio simétrico. A forma contraída é convertida com as variáveis em LVAR.

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

 -- Funcedilhaão: partpol (PSYM, LVAR)
     PSYM é um polinômio simétrico nas variáveis da lista LVAR. Essa funcedilhaão retorna sua represetnacedilhaão particionada.

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

 -- Funcedilhaão: tcontract (POL, LVAR)
     testa se o polinômio POL é simétrico nas variáveis da lista LVAR.  Se for, tcontract retorna uma representacedilhaão contraída como o faz a funcedilhaão contract.

 -- Funcedilhaão: tpartpol (POL, LVAR)
     testa se o polinômio POL é simétrico nas variáveis da lista LVAR.  Se for, tpartpol retorna sua represetnacedilhaão particionada como o faz a funcedilhaão partpol.

Grupos e órbitas
----------------

 -- Funcedilhaão: direct ([P_1, ..., P_N], Y, F, [LVAR_1, ..., LVAR_N])
     calcula a imagem direta (see M. Giusti, D. Lazard et A. Valibouze, ISSAC 1988, Rome) associada à funcedilhaão F, na lista de variáveis LVAR_1, ..., LVAR_N, e nos polinômios P_1, ..., P_N na variável Y.  A quantidade de argumetnos que a funcedilhaào F pode receber é importante para o cálculo.  Dessa forma, se a expressão para F não depende de alguma variável, é inútil incluir essa variável, e não incluir essa variável irá também reduzir consideravelmente o montante cálculos efetuados.

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

     Encontrando um polinômio cujas raízes são somatórios a+u onde a é uma raíz de z^2 - e_1 z + e_2 e u é uma raíz de 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 aceita dois sinalizadores: elementaires (elementares) e puissances (exponenciais - valor padrão) que permitem a decomposicedilhaão de polinômios simétricos que aparecerem nesses cálculos em funcedilhaões simétricas elementares ou em funcedilhaões exponenciais respectivamente.

     Funcedilhaões de sym utilizadas nesta funcedilhaão :

     multi_orbit (portanto orbit), pui_direct, multi_elem (portanto elem), multi_pui (portanto pui), pui2ele, ele2pui (se o sinalizador direct for escolhido para puissances).

 -- Funcedilhaão: multi_orbit (P, [LVAR_1, LVAR_2,..., LVAR_P])

     P é um polinômio no conjunto de variáveis contidas nas lista LVAR_1, LVAR_2, ..., LVAR_P. Essa funcedilhaão retorna a órbita do polinômio P sob a acedilhaão do produto dos grupos simétricos dos conjuntos de variáveis represetnadas nas P listas.

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

     Veja também: orbit para a acedilhaão de um grupo simétrico simples.

 -- Funcedilhaão: multsym (PPART_1, PPART_2, N)
     retorna oproduto de dois polinômios simétricos em N varieis trabalhando somente módulo a acedilhaão do grupo simétrico de ordem N. O polinômios estão em sua forma particionada.

     Dados 2 polinômio simétricos em X, Y:  3*(x + y) + 2*x*y e 5*(x^2 + y^2) cujas formas particionadas são [[3, 1], [2, 1, 1]] e [[5, 2]], seu produto irá ser

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

     isso é 10*(x^3*y + y^3*x) + 15*(x^2*y + y^2*x) + 15*(x^3 + y^3).

     Funcedilhaões para mudar as representacões de um polinômio simétrico:

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

 -- Funcedilhaão: orbit (P, LVAR)
     calcula a órbita do polinômio P nas variáveis na lista LVAR sob a acedilhaão do grupo simétrico do conjunto das variáveis na lista 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]

     Veja também multi_orbit para a acedilhaão de um produto de grupos simétricos sobre um polinômio.

 -- Funcedilhaão: pui_direct (ORBITE, [LVAR_1, ..., LVAR_N], [D_1, D_2, ..., D_N])

     Tomemos F para ser um polinômio em N blocos de variáveis LVAR_1, ..., LVAR_N.  Facedilhaamos C_I ser o n;umero de variáveis em LVAR_I, e SC ser o produto de N grupos simétricos de grau C_1, ..., C_N. Essas acedilhaões dos grupos naturalmente sobre F. A lista ORBITE é a órbita, denotada SC(F), da funcedilhaão F sob a acedilhaão de SC. (Essa lista pode ser obtida através da funcedilhaão multi_orbit.)  Os DI são inteiros de forma que c_1 \le d_1, c_2 \le d_2, \ldots, c_n \le d_n.

     Tomemos SD para ser o produto dos grupos simétricos S_[d_1] x S_[d_2] x ... x S_[d_n]. A funcedilhaão pui_direct retorna as primeiras N funcedilhaões exponenciais de SD(F) deduzidas das funcedilhaões exponenciais de SC(F), onde N é o tamanho de SD(F).

     O resultado está na multi-forma contraída com relacedilhaão a SD, i.e. somente um elemento é mantido por órbita, sob a acedilhaão 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 ]

Particedilhaões
---------------

 -- Funcedilhaão: kostka (PART_1, PART_2)
     escrita por P. Esperet, calcula o número de Kostka da particedilhaão PART_1 e PART_2.

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

 -- Funcedilhaão: lgtreillis (N, M)
     retorna a lista de particedilhaões de peso N e comprimento M.

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

     Veja também: ltreillis, treillis e treinat.

 -- Funcedilhaão: ltreillis (N, M)
     retorna a lista de particedilhaões de peso N e comprimento menor que ou igual a M.

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

     Veja também: lgtreillis, treillis e treinat.

 -- Funcedilhaão: treillis (N)
     retorna todas as particedilhaões de peso N.

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

     Veja também: lgtreillis, ltreillis e treinat.

 -- Funcedilhaão: treinat (PART)
     retorna a lista de particedilhaões inferiores à particedilhaào PART com relacedilhaão à ordem natural.

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

     Veja também: lgtreillis, ltreillis e treillis.

Polinômios e suas raízes
------------------------

 -- Funcedilhaão: ele2polynome (L, Z)
     retorna o polinômio em Z de forma que as funcedilhaões elementares simétricas de suas raízes estejam na lista L = [N, E_1, ..., E_N], onde N é o grau dos polinômios e E_I é a I-ésima funcedilhaão simétrica elementar.

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

     o inverso: polynome2ele (P, Z).

     Veja também: polynome2ele, pui2polynome.

 -- Funcedilhaão: polynome2ele (P, X)
     fornece a lista L = [N, E_1, ..., E_N] onde N é o grau do polinômio P na variável X e E_I é a I-ésima funcedilhaão simétrica elementar das raízes 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

     A inversa: ele2polynome (L, X)

 -- Funcedilhaão: prodrac (L, K)
     L é uma lista contendo as funcedilhaões simétricas elementares sobre um conjunto A. prodrac retorna o polinômio cujas raízes são os produtos K por K dos elementos de A.

     Veja também somrac.

 -- Funcedilhaão: pui2polynome (X, LPUI)
     calcula o polinômio em X cujas funcedilhaões exponenciais das raízes são dadas na lista 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

     Veja também: polynome2ele, ele2polynome.

 -- Funcedilhaão: somrac (L, K)
     A lista L contains funcedilhaão simétrica elementars de um polynomial P . The function computes the polinômio whose roots are the K by K distinct sums of the roots of P.

     Also see prodrac.

Resolvents
----------

 -- Funcedilhaão: resolvante (P, X, F, [X_1,..., X_D])
     calcula a resilvente do polinômio P em X de grau N >= D através da fFuncedilhaão F expressa nas variáveis X_1, ..., X_D.  Para eficiência de computacedilhaão é importante não incluir na lista as variáveis [X_1, ..., X_D] que não aparecem na funcedilhaão de transformacedilhaão F.

     Para melhorar a eficiência do cálculo se pode escolher sinalizadores em resolvante de forma a usar os algorítmos apropriados:

     Se a funcedilhaão F for unitária :

       * um polinômio em uma variável simples,

       * linear ,

       * alternando,

       * um somatório,

       * simétrico,

       * um produto,

       * a funcedilhaão da resolvente de Cayley (utilizável de grau 5 em diante)

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

          geral,

     o sinalizador da resolvante poderá ser respectivamente :

       * 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, []);

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

                                                                 + 93392896

     Para a resolvente de Cayley, os 2 últimos argumentos são neutros e o polinômio fornecido na entrada deve ser necessáriamente de grau 5.

     Veja também :

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

 -- Funcedilhaão: resolvante_alternee1 (P, X)
     calcula a transformacedilhaão de P(X) de grau N pela funcedilhaão $\prod_{1\leq i<j\leq n-1} (x_i-x_j)$. product(x_i - x_j, 1 <= i < j <= n - 1).

     Veja também :

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

 -- Funcedilhaão: resolvante_bipartite (P, X)
     calcula a trasformacedilhaão de P(X) de mesmo grau N através da funcedilhaão x_1 x_2 ... x_[n/2] + x_[n/2 + 1] ... x_n.

     Veja também :

     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

     Veja também :

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

 -- Funcedilhaão: resolvante_diedrale (P, X)
     calcula a transformacedilhaão de P(X) através da funcedilhaão 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

     Veja também :

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

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

     Veja também :

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

 -- Funcedilhaão: resolvante_klein3 (P, X)
     calcula a transformacedilhaão de P(X) através da funcedilhaão X_1 X_2 X_4 + X_4.

     Veja também :

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

 -- Funcedilhaão: resolvante_produit_sym (P, X)
     calcula a lista de todas as resolventes de produto do polinômio 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]);

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

     Veja também :

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

 -- Funcedilhaão: resolvante_unitaire (P, Q, X)
     calcula a resolvente do polinômio P(X) através do polinomio Q(X).

     Veja também :

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

 -- Funcedilhaão: resolvante_vierer (P, X)
     calcula a transformacedilhaão de P(X) pela funcedilhaão X_1 X_2 - X_3 X_4.

     Veja também :

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

Miscelânia
----------

 -- Funcedilhaão: multinomial (R, PART)
     onde R é o peso da particedilhaão PART.  Essa funcedilhaão retorna o coefinciente multinomial associado: se as partes de PART forem I_1, I_2, ..., I_K, o resultado é R!/(I_1! I_2! ... I_K!).

 -- Funcedilhaão: permut (L)
     retorna a lista de permutacedilhaões da lista L.