Previous: Introduction to Symmetries, Up: Symmetries [Contents][Index]
リストLで与えられた与えられた完全対称関数から 0からnまでの基本対称関数にパスすることを実装します。 もしリストLが n+1個より少ない要素を含むなら、 タイプh1, h2などの 形式的な値で完成されます。 もし リストLの最初の要素が存在するなら、 それはアルファベットのサイズを指定します。 そうでないなら、サイズはnに設定されます。
(%i1) comp2pui (3, [4, g]);
                        2                    2
(%o1)    [4, g, 2 h2 - g , 3 h3 - g h2 + g (g  - 2 h2)]
基本対称関数から完全関数に行きます。
comp2eleやcomp2compに似ています。
基数を変える他の関数: comp2ele.
基本対称関数から完全関数に行きます。
comp2eleやcomp2puiに似ています。
基数を変える他の関数: comp2ele.
リストlvarに含まれる変数に関して、
リストeleで与えられた基本対称関数を使って、
対称多項式symを分解します。
もしeleの最初の要素が与えられたら、
アルファベットのサイズで、
そうでないなら、サイズは多項式symの次数です。
もし値がリストeleになければ、
タイプe1, e2などの形式的値が加えられます。
多項式symは3つの異なる形式で与えられます:
contracted (elemはその時、デフォルト値1であるべきです),
partitioned (elemは3であるべきです),または
extended(すなわち、多項式全体, かつ、elemは2であるべきです)。
関数puiは同じ方法で使われます。
サイズ3のアルファベットと値7を持つ最初の基本対称関数e1上で、 (ここで変数の2つにだけ依存する)短縮された形式がx^4-2*x*yである 3変数の対称多項式が以下のように基本対称関数で分解されます:
(%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
基数を変える他の関数: comp2ele.
リストLは Schur関数S_Lを表します: we have i_1 <= i_2 <= ... <= i_q成るL = [i_1, i_2, ..., i_q] を持ちます。 Schur関数S_[i_1, i_2, ..., i_q]は、 最初のq個の行と列1 + i_1, 2 + i_2, ..., q + i_q から成る無限行列h_[i-j], i <= 1, j <= 1 の小行列式です。
このSchur関数は
treinatとkostkaを使うことで
単項式の項で書かれることができます。
返される形式は、
変数
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
以上は、3つの変数に関してこれが与えることを意味します:
   2 x1 x2 x3 + x1^2 x2 + x2^2 x1 + x1^2 x3 + x3^2 x1
    + x2^2 x3 + x3^2 x2
基数を変えるための他の関数: comp2ele.
l_elemに含まれる基本対称関数を使って、リストl_varのリストに含まれる 変数のグループに関して、 多重対称多項式を 多重短縮形multi_pcに分解します。
(%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
基数を変えるための他の関数: comp2ele.
関数multi_elemが関数elemに対するものであるように、
関数puiに対するものです。
(%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
リストLの中のべき関数を使って、
リストlvarの中の変数に関して、
対称多項式symを分解します。
もしLの最初の要素が与えられるなら、
アルファベットのサイズです。
そうでないなら、サイズは多項式symの次数になります。
もしリストLの中に値がないなら、
タイプp1, p2 , などの形式的な値が加えられます。
多項式symは、
3つの異なる形式で与えられることができます:
contracted (elemは1でなければならず、デフォルト値です),
partitioned (elemは3でなければいけません),
extended (すなわち、多項式全体、そしてelemは2でなければいけません)。
関数puiは同じ方法で使われます。
(%i1) pui; (%o1) 1
(%i2) pui ([3, a, b], u*x*y*z, [x, y, z]);
                       2
                   a (a  - b) u   (a b - p3) u
(%o2)              ------------ - ------------
                        6              3
(%i3) ratsimp (%);
                                       3
                      (2 p3 - 3 a b + a ) u
(%o3)                 ---------------------
                                6
Other functions for changing bases: comp2ele.
リストlpuiで与えられたべき関数を使って、
(最初に長さを持ち)最初のn個の完全関数のリストを返します。
もしリストlpuiが空なら、
基数はnで、
そうでないなら、基数は(comp2eleや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
基数を変えるための他の関数: comp2ele.
べき関数から基本対称関数への変転に影響します。
もしフラグpui2eleがgirardなら、
1からnまでの基本対称関数のリストを返し、
もしフラグがcloseなら、
n番目の基本対称関数を返します。
基数を変えるための他の関数: comp2ele.
lpuiは
最初の要素が整数mのリストです。
puireducは
最初のm個を使って最初のn個のべき関数を与えます。
(%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
Pはリストl_varの変数の多項式です。
これらの変数のそれぞれは完全対称関数を表します。
l_varの中で、
i番目の完全対称関数は
文字hと整数iの連結hiによって表されます。
この関数は
PをSchur関数を使って表現します。
(%i1) schur2comp (h1*h2 - h3, [h1, h2, h3]);
(%o1)                         s
                               1, 2
(%i2) schur2comp (a*h3, [h3]);
(%o2)                         s  a
                               3
変数がlvarの中に含まれている短縮形pcに 関連付けられた分割多項式を返します。
(%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]]
リストlvarに含まれる変数に関する
多項式psymの
短縮形(すなわち、対称群の作用の下での単項軌道)を返します。
関数exploseは逆演算を実行します。
関数tcontractは多項式の対称性をテストします。
(%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
短縮形pcに関連付けられた対称多項式を返します。 リストlvarは変数を含みます。
(%i1) explose (a*x + 1, [x, y, z]); (%o1) a z + a y + a x + 1
対称式を分割形から短縮形に変換します。 短縮形はlvarの中の変数で表されます。
(%i1) part2cont ([[2*a^3*b, 4, 1]], [x, y]);
                              3    4
(%o1)                      2 a  b x  y
psymは リストlvarの変数に関する対称多項式です。 この関数は分割表現を返します。
(%i1) partpol (-a*(x + y) + 3*x*y, [x, y]); (%o1) [[3, 1, 1], [- a, 1, 0]]
多項式polが
リストlvarの変数に関して対称かテストします。
もしそうなら、関数contractのように短縮表現を返します。
多項式polが
リストlvarの中の変数に関して
対称かテストします。
もしそうなら
関数partpolのように
分割表現を返します。
変数lvar_1, ..., lvar_nのリストと 変数yについての多項式p_1, ..., p_nに関して、 関数fに関連付けられた順像 (M. Giusti, D. Lazard et A. Valibouze, ISSAC 1988, Romeを参照してください) を計算します。 関数fのアリティが計算にとって重要です。 例えば、 fについての式がある変数に依存しないなら、 この変数を含むことは役に立たず、含めなければ、 計算量を相当に減らすことにもなるでしょう。
(%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
根が和a+uである多項式を見つけること。 ただし、aはz^2 - e_1 z + e_2の根で、 uは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は2つのフラグを受け付けます:
elementairesとpuissances (デフォルト)
これらは、計算の中に現れる対称多項式を
それぞれ基本対称関数またはべき関数に分解することを許します。
この関数で使われるsymの関数は以下の通りです:
multi_orbit (だからorbit), pui_direct, multi_elem
(だからelem), multi_pui (だからpui), pui2ele, ele2pui
(もしフラグdirectがpuissancesの中にあれば)。
Pは リストlvar_1, lvar_2, ..., lvar_pに含まれる 変数の集合に関する 多項式です。 この関数は これらpリストで表された変数の集合の対称群の積の作用の下で 多項式Pの 軌道を返します。
(%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]
以下も参照してください: 単対称群の作用に関するorbit。
次数nの対称群の作用を法としてのみ働くことで、 n個の変数に関する2つの対称多項式の積を返します。 多項式は分割形式です。
x, yに関する鵜2つの対称多項式:
分割形式が[[3, 1], [2, 1, 1]]と[[5, 2]]である
3*(x + y) + 2*x*yと5*(x^2 + y^2)
が与えられたとして、それらの積は、
(%i1) multsym ([[3, 1], [2, 1, 1]], [[5, 2]], 2); (%o1) [[10, 3, 1], [15, 3, 0], [15, 2, 1]]
、すなわち、10*(x^3*y + y^3*x) + 15*(x^2*y + y^2*x) + 15*(x^3 + y^3)です。
対称多項式の表現を変える関数は以下の通りです:
contract, cont2part, explose, part2cont,
partpol, tcontract, tpartpol。
リストlvarの変数の集合の対称群の作用の下で リストlvarの変数に関する多項式Pの軌道を計算します。
(%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]
多項式に関する対称群の積の作用に関してはmulti_orbitも参照してください。
fを
変数のn個のブロックlvar_1, ..., lvar_nに関する多項式とします。
c_iを
lvar_iの中の変数の数とし、
SCを
次数c_1, ..., c_nの
n個の対称群の積とします。
この群は自然にfに作用します。
リストorbiteは
SCの作用の下での関数fの軌道で、SC(f)を意味します。
(このリストは
関数multi_orbitによって得られます。)
diは
c_1 <= d_1, c_2 <= d_2, ..., c_n <= d_n.
を満たすような整数です。
SDを
対称群
S_[d_1] x S_[d_2] x ... x S_[d_n]
の積とします。
関数pui_directは
SC(f)のべき関数から演繹された
SD(f)の
最初のn個のべき関数を返します。
ここで、nはSD(f)のサイズです。
結果はSDに関する多重短縮された形式です。 すなわち、SDの作用の下で、軌道毎にただ1つの要素が保持されます。
(%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 ]
P. Esperetによって書かれ、 分割part_1とpart_2のKostka数を計算します。
(%i1) kostka ([3, 3, 3], [2, 2, 2, 1, 1, 1]); (%o1) 6
重みnと長さmの分割のリストを返します。
(%i1) lgtreillis (4, 2); (%o1) [[3, 1], [2, 2]]
以下も参照してください: ltreillis, treillis, treinat。
重みnとm以下の長さの分割のリストを返します。
(%i1) ltreillis (4, 2); (%o1) [[4, 0], [3, 1], [2, 2]]
以下も参照してください: lgtreillis, treillis, treinat。
重みnの分割すべてを返します。
(%i1) treillis (4); (%o1) [[4], [3, 1], [2, 2], [2, 1, 1], [1, 1, 1, 1]]
以下も参照してください: lgtreillis, ltreillis, treinat。
自然な順序に関する分割partより低い分割のリストを返します。
(%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]]
以下も参照してください: lgtreillis, ltreillis, treillis。
根の基本対称関数が
リストL = [n, e_1, ..., e_n]の中にあるような
zに関する多項式を返します。
ここでnは多項式の次数であり、
e_iはi番目の基本対称関数です。
(%i1) ele2polynome ([2, e1, e2], z);
                          2
(%o1)                    z  - e1 z + e2
(%i2) polynome2ele (x^7 - 14*x^5 + 56*x^3 - 56*x + 22, x); (%o2) [7, 0, - 14, 0, 56, 0, - 56, - 22]
(%i3) ele2polynome ([7, 0, -14, 0, 56, 0, -56, -22], x);
                  7       5       3
(%o3)            x  - 14 x  + 56 x  - 56 x + 22
The inverse: polynome2ele (P, z).
Also see:
polynome2ele, pui2polynome.
リストl = [n, e_1, ..., e_n]を与えます。
ここでnは
変数xに関する多項式Pの次数であり、
e_iは
Pの根のi番目の基本対称関数です。
(%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
逆: ele2polynome (l, x)
Lは
集合A上の基本対称関数を含む
リストです。
prodracは、
根が
Aの要素の
k掛けるkの積の
多項式を返します。
somracも参照してください。
根のべき関数がリストlpuiで与えられる xに関する多項式を計算します。
(%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
以下も参照してください:
polynome2ele, ele2polynome。
リストLは 多項式Pの基本対称関数を含みます。 関数は 根がPの根のk掛けるkの別個の和である 多項式を計算します。
prodracも参照してください。
変数x_1, ..., x_dで表現された関数fによって
次数n >= dの
xに関する多項式P
の解核を計算します。
計算の効率のため、
変換関数fに現れない変数の
リスト[x_1, ..., x_d]に含まれないことが重要です。
計算の効率を増すためには、
適切なアルゴリズムを使うように
resolvanteに関するフラグを設定することができます:
もし関数fがユニタリなら:
(x1*x2 + x2*x3 + x3*x4 + x4*x5 + x5*x1 -
     (x1*x3 + x3*x5 + x5*x2 + x2*x4 + x4*x1))^2
一般的,
resolvanteのフラグはそれぞれ:
(%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
Cayley解核に関して、最後の2つの引数は中立で、 入力多項式は必然的に次数5でなければいけません。
以下も参照してください:
resolvante_bipartite, resolvante_produit_sym,
resolvante_unitaire, resolvante_alternee1, resolvante_klein, 
resolvante_klein3, resolvante_vierer, resolvante_diedrale。
関数
product(x_i - x_j, 1 <= i < j <= n - 1).
によって
次数nの
変換P(x)を計算します。
以下も参照してください:
resolvante_produit_sym, resolvante_unitaire,
resolvante , resolvante_klein, resolvante_klein3,
resolvante_vierer, resolvante_diedrale, resolvante_bipartite。
関数
によって
偶次数nのP(x)の変換を計算します。
x_1 x_2 ... x_[n/2] + x_[n/2 + 1] ... x_n.
(%i1) resolvante_bipartite (x^6 + 108, x);
              10        8           6             4
(%o1)        y   - 972 y  + 314928 y  - 34012224 y
以下も参照してください:
resolvante_produit_sym, resolvante_unitaire,
resolvante, resolvante_klein, resolvante_klein3,
resolvante_vierer, resolvante_diedrale, resolvante_alternee1.
関数x_1 x_2 + x_3 x_4によって
P(x)の変換を計算します。
(%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
以下も参照してください:
resolvante_produit_sym, resolvante_unitaire,
resolvante_alternee1, resolvante_klein, resolvante_klein3,
resolvante_vierer, resolvante。
関数x_1 x_2 x_4 + x_4によって
P(x)の変換を計算します。
以下も参照してください:
resolvante_produit_sym, resolvante_unitaire,
resolvante_alternee1, resolvante, resolvante_klein3,
resolvante_vierer, resolvante_diedrale。
関数x_1 x_2 x_4 + x_4によって
P(x)の変換を計算します。
以下も参照してください:
resolvante_produit_sym, resolvante_unitaire,
resolvante_alternee1, resolvante_klein, resolvante,
resolvante_vierer, resolvante_diedrale。
多項式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
以下も参照してください:
resolvante, resolvante_unitaire,
resolvante_alternee1, resolvante_klein,
resolvante_klein3, resolvante_vierer,
resolvante_diedrale。
多項式Q(x)によって
多項式P(x)の解核を計算します。
以下も参照してください:
resolvante_produit_sym, resolvante,
resolvante_alternee1, resolvante_klein, resolvante_klein3,
resolvante_vierer, resolvante_diedrale。
関数x_1 x_2 - x_3 x_4によって
P(x)の変換を計算します。
以下も参照してください:
resolvante_produit_sym, resolvante_unitaire,
resolvante_alternee1, resolvante_klein, resolvante_klein3,
resolvante, resolvante_diedrale。
ここでrは分割partの重みです。
この関数は、同類の多項係数を返します:
もしpartの部分が
i_1, i_2, ..., i_kなら、
結果は
r!/(i_1! i_2! ... i_k!)
です。
リストLの置換のリストを返します。
Previous: Introduction to Symmetries, Up: Symmetries [Contents][Index]