33. Simetrias

33.1 Definições para Simetrias

Função: comp2pui (n, l)

realiza a passagem das funções simétricas completas, dadas na lista l, às funções simétricas elementares de 0 a n. Se a lista l contém menos de n+1 elementos os valores formais vêm completá-los. O primeiro elemento da lista l fornece o cardinal do alfabeto se ele existir, se não existir coloca-se igual a n.

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

Função: cont2part (pc, lvar)

Torna 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]]

Outras funções de mudança de representação :

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

Função: contract (psym, lvar)

torna uma forma contraída (i.e. um monômio por órbita sobre a ação do grupo simétrico) do polinômio psym em variáveis contidas na lista lvar. A função explose realisa a operação inversa. A função tcontract testa adicionalmente a simetria 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

Outras funções de mudança de representação :

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

Função: direct ([p_1, ..., p_n], y, f, [lvar_1, ..., lvar_n])

calcula a imágem direta (veja M. GIUSTI, D. LAZARD et A. VALIBOUZE, ISSAC 1988, Rome) associada à função f, nas listas de variáveis lvar_1, ..., lvar_n, e nos polinômios p_1, ..., p_n de uma variável y. l'arite' da função f é importante para o cálculo. Assim, se a expressão de f não depende de uma variável, não somente é inútil fornecer essa variável como também diminui consideravelmente os cálculos se a variável não for fornecida.

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

Pesquisa de polinômios cujas raízes são a soma a+u ou a é a raíz de z^2 - e1* z + e2 e u é a raíz 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 pode assumir dois sinalizadores: elementaires (elementares) e puissances (exponenciais - valor padrão) que permitem a decomposição de polinômios simétricos que aparecerem nesses cálculos pelas funções simétricas elementares ou pelas funções exponenciais respectivamente.

Funções de sym utilizadas nesta funçã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).

Função: ele2comp (m, l)

passa das funções simétricas elementares para funções completas. Semelhante a comp2ele e a comp2pui.

Outras funções de mudanças de base :

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

Função: ele2polynome (l, z)

fornece o polinômio em z cujas funções simétricas elementares das raízes estiverem na lista l. l = [n, e_1, ..., e_n] onde n é o grau do polinômio e e_i é a i-ésima funçã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

A recíproca: polynome2ele (P, z)

Veja também:

polynome2ele, pui2polynome.

Função: ele2pui (m, l)

passa de funções simétricas elementares para funções completas. Similar a comp2ele e comp2pui.

Outras funções de mudanças de base :

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

Função: elem (ele, sym, lvar)

decompõe o polinômio simétrico sym, nas variáveis contínuas da lista lvar, em funções simétricas elementares contidas na lista ele. Se o primeiro elemento de ele for fornecido esse será o cardinal do alfabeto se não for utilizado o grau do polinômio sym. Se falta valores para a lista ele valores formais do tipo "ei" são novamente colocados para completar a lista. O polinômio sym pode ser fornecido de 3 formas diferentes : contraída (elem deve protanto valer 1 que é seu valor padrão), particionada (elem deve valer 3) ou extendida (i.e. o polinômio por completo) (elem deve valer 2). A utilização da função pui se realiza sobre o mesmo modelo.

Sob um alfabeto de cardinal 3 com e1, a primeira função simétrica elementar, valendo 7, o polinômio simétrico em 3 variáveis cuja forma contraída (aqui, só depende de duas de suas variáveis) é x^4-2*x*y decompõe-se em funções simétricas elementares :

(%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 funções de mudanças de base :

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

Função: explose (pc, lvar)

toma o polinômio simétrico associado à forma contraída pc. A lista lvar contém variáveis.

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

Outras funções de mudança de representação :

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

Função: kostka (part_1, part_2)

escrita por P. ESPERET, calcula o número de Kostka associado às partições part_1 e part_2.

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

Função: lgtreillis (n, m)

torna a lista de partições de peso n e de largura m.

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

Veja também : ltreillis, treillis e treinat.

Função: ltreillis (n, m)

torna a lista de partições de peso n e largura menor ou igual a m.

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

Veja também : lgtreillis, treillis e treinat.

Função: mon2schur (l)

A lista l representa a função de Schur S_l: Temos l = [i_1, i_2, ..., i_q] com i_1 <= i_2 <= ... <= i_q. A função de Schur é S_[i_1, i_2, ..., i_q] é a menor da mariz infinita (h_{i-j}) i >= 1, j >= 1 composta das q primeiras linhas e de colunas i_1 + 1, i_2 + 2, ..., i_q + q.

Escreve-se essa função de Schur em função das formas monomiais utilizando as funções treinat e kostka. A forma retornada é um polinômio simétrico em uma de suas representações contraídas com as variáveis 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

queremos dizer que para 3 variáveis tem-se :

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

Outras funções de mudanças de base :

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

Função: multi_elem (l_elem, multi_pc, l_var)

decompõe um polinômio multi-simétrico sob a forma multi-contraída multi_pc nos grupos de variáveis contidas na lista de listas l_var sobre os groupos de funções simétricas elementares 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 funções de mudanças de base :

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

Função: multi_orbit (P, [lvar_1, lvar_2, ..., lvar_p])

P é um polinômio no conjunto das variáveis contidas nas listas lvar_1, lvar_2, ..., lvar_p. Essa função leva novamente na órbita do polinômio P sob a ação do do produto dos grupos simétricos dos conjuntos de variáveis representados por essas 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 pela ação de um só grupo simétrico.

Função: multi_pui

está para a função pui da mesma forma que a função multi_elem está para a funçã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

Função: multinomial (r, part)

onde r é o peso da partição part. Essa função reporta ao coeficiente multinomial associado : se as partes das partições part forem i_1, i_2, ..., i_k, o resultado de multinomial é r!/(i_1! i_2! ... i_k!).

Função: multsym (ppart_1, ppart_2, n)

realiza o produto de dois polinômios simétricos de n variáveis só trabalhando o módulo da ação do grupo simétrico de ordem n. Os polinômios estão em sua representação particionada.

Sejam os 2 polinômios simétricos em x, y: 3*(x + y) + 2*x*y e 5*(x^2 + y^2) cujas formas particionada são respectivamente [[3, 1], [2, 1, 1]] e [[5, 2]], então seu produto será dado por :

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

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

Funções de mudança de representação de um polinômio simétrico :

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

Função: orbit (P, lvar)

calcula a órbita de um polinômio P nas variáveis da lista lvar soba a ação do grupo simétrico do conjunto das variáveis contidas 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 ação de um produto de grupos simétricos sobre um polinômio.

Função: part2cont (ppart, lvar)

passa da form particionada à forma contraída d um polinômio simétrico. A forma contraída é conseguida com as variáveis contidas em lvar.

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

Outras funções de mudança de representação :

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

Função: partpol (psym, lvar)

psym é um polinômio simétrico nas variáveis de lvar. Esta função retoma sua representação particionada.

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

Outras funções de mudança de representação :

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

Função: permut (l)

retoma a lista de permutações da lista l.

Funçã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-ézima funçã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 recíproca : ele2polynome (l, x)

Função: prodrac (l, k)

l é uma lista que contém as funções simétricas elementares sob um conjunto A. prodrac produz o polinômio cujas raízes são os produtos k a k dos elementos de A.

Função: pui (l, sym, lvar)

decompõe o polinômio simétrico sym, nas variáveis contidas a lista lvar, nas funções exponenciais contidas na lista l. Se o primeiro elemento de l for dado ele será o cardinal do alfabeto se não for dado toma-se o grau do polinômio sym para ser o cardinal do alfabeto. Se faltarem valores na lista l, valores formais do typo "pi" serão colocados na lista. O polinômio sym pode ser dado sob 3 formas diferentes : contraída (pui deve valer 1 - seu valor padrão), particionada (pui deve valer 3) ou estendida (i.e. o polinômio por completo) (pui deve valer 2). A função elem se utiliza da mesma maneira.

(%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 funções de mudanças de base :

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

Função: pui2comp (n, lpui)

produz a lista das n primeiras funções completas (com o cardinal em primeiro lugar) em função das funções exponenciais dadas na lista lpui. Se a lista lpui estiver vazia o cardianl será N, se não estiver vazia, será o primeiro elemento de forma análoga a comp2ele e a 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 funções de mudanças de base :

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

Função: pui2ele (n, lpui)

realiza a transformação das funções exponenciais em funções simétricos elementares. Se o sinalizador pui2ele for girard, recupera-se a lista de funções simétricos elementares de 1 a n, e se for igual a close, recupera-se a n-ézima função simétrica elementar.

Outras funções de mudanças de base :

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

Função: pui2polynome (x, lpui)

calcula o polinômio em x cujas funçõ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

Autres funções a` voir : polynome2ele, ele2polynome.

Função: pui_direct (orbite, [lvar_1, ..., lvar_n], [d_1, d_2, ..., d_n])

Seja f um polinômio em n blocos de variáveis lvar_1, ..., lvar_n. Seja c_i o número de variáveis em lvar_i . E SC o produto dos n grupos simétricos de grau c_1, ..., c_n. Esse grupo age naturalmente sobre f. A Lista orbite é a órbita, anotada de SC(f), da função f sob a ação de SC. (Essa lista pode ser obtida com a função : multi_orbit). Os d_i são inteiros tais que c_1 <= d_1, c_2 <= d_2, ..., c_n <= d_n. Seja SD o produto dos grupos simétricos S_d1 x S_d2 x ... x S_dn.

A função pui_direct retorna as n premeiras funções exponenciais de SD(f) dedzidas das funções exponenciais de SC(f) onde n é o cardinal de SD(f).

O resultado é produzido sob a forma multi-contraída em relação a SD. i.e. apenas se conserva um elemento por órbita sob a açã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 ]

Função: puireduc (n, lpui)

lpui é uma lista cujo primeiro elemento é um inteiro m. puireduc fornece as n primeiras funções exponenciais em função das m primeira.

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

Função: resolvante (P, x, f, [x_1, ..., x_d])

calcula a resolvente do polinômio P em relação à variável x e de grau n >= d pela função f expressa nas variáveis x_1, ..., x_d. É importante para a eficácia dos cálculos não colocar na lista [x_1, ..., x_d] as variáveis não interferindo na função de transformação f.

Afim de tornar mais eficazes os cálculos pode-se colocar sinalizadores na variável resolvante para que os algorítmos adequados sejam utilizados :

Se a função f for unitária :

• um polinômio de uma variável,
• linear ,
• alternado,
• uma soma de variáveis,
• simétrico nas variáveis que aparecem em sua expressão,
• um produto de variáveis,
• a função da resolvente de Cayley (utilisável no grau 5)

  (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

Pela resolvente de Cayley, os 2 últimos arguments 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.

Função: resolvante_alternee1 (P, x)

calcula a transformação de P(x) de grau n pela função $\prod_{1\leq i<j\leq n-1} (x_i-x_j)$.

Veja também :

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

Função: resolvante_bipartite (P, x)

calcule la transformation de P(x) de degre n (n pair) par la função $x_1x_2\ldots x_{n/2}+x_{n/2+1}\ldotsx_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.

Função: resolvante_diedrale (P, x)

calcule la transformation de P(x) par la funçã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.

Função: resolvante_klein (P, x)

calcule la transformation de P(x) par la função 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.

Função: resolvante_klein3 (P, x)

calcule la transformation de P(x) par la funçã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.

Função: resolvante_produit_sym (P, x)

calcula a lista de todas as resolventes 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.

Função: resolvante_unitaire (P, Q, x)

calcul a resolvente do polinômio P(x) pelo polinômio Q(x).

Veja também :

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

Função: resolvante_vierer (P, x)

calcula a transformação de P(x) pela funçã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.

Função: schur2comp (P, l_var)

P é um polinômio nas variáveis contidas na lista l_var. Cada uma das variáveis de l_var representa uma função simétrica completa. Representa-se em l_var a enésia função simétrica completa como a concatenação da letra h com o inteiro i : hi. Essa função fornece a expressão de P em função das funções de Schur.

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

Função: somrac (l, k)

a lista l contém as funções simétricas elementares de um polinômio P . Calcula-se o polinômo cujas reízes são as somas K a K distintos das raízes de P.

Veja também prodrac.

Função: tcontract (pol, lvar)

teste si le polinômio pol est simétrico en les variáveis contenues dans la liste lvar. Si oui il rend une forme contracte'e comme la função contract.

Outras funções de mudança de representação :

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

Função: tpartpol (pol, lvar)

testa se o polinômio pol é simétrico nas variáveis contidas na lista lvar. Se for simétrico tpartpol produz a forma particionada como a função partpol.

Outras funções de mudança de representação :

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

Função: treillis (n)

retorna todas as partiçõ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.

Função: treinat (part)

retorna a lista das partições inferiores à partição part pela 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.

This document was generated by root on Outubro, 18 2006 using texi2html 1.76.