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

# 30. Symmetries

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

## 30.1 Introduction to Symmetries

`sym`は多項式の対称群を扱うパッケージです。

これは Annick Valibouze (http://www-calfor.lip6.fr/~avb/) によって Macsyma-Symbolicsのために書かれました。 アルゴリズムは以下の論文に記載されています:

1. Fonctions symétriques et changements de bases. Annick Valibouze. EUROCAL'87 (Leipzig, 1987), 323-332, Lecture Notes in Comput. Sci 378. Springer, Berlin, 1989.
   http://www.stix.polytechnique.fr/publications/1984-1994.html
2. Résolvantes et fonctions symétriques. Annick Valibouze. Proceedings of the ACM-SIGSAM 1989 International Symposium on Symbolic and Algebraic Computation, ISSAC'89 (Portland, Oregon). ACM Press, 390-399, 1989.
   http://www-calfor.lip6.fr/~avb/DonneesTelechargeables/MesArticles/issac89ACMValibouze.pdf
3. Symbolic computation with symmetric polynomials, an extension to Macsyma. Annick Valibouze. Computers and Mathematics (MIT, USA, June 13-17, 1989), Springer-Verlag, New York Berlin, 308-320, 1989.
   http://www.stix.polytechnique.fr/publications/1984-1994.html
4. Théorie de Galois Constructive. Annick Valibouze. Mémoire d'habilitation à diriger les recherches (HDR), Université P. et M. Curie (Paris VI), 1994.

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

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

## 30.2 Functions and Variables for Symmetries

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

### 30.2.1 Changing bases

関数: comp2pui (n, L)

  リスト Lで与えられた与えられた完全対称関数から 0から nまでの基本対称関数への変換 (passing)を実装します。 もしリスト 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)]

  Categories: Package sym

関数: ele2pui (m, L)

  基本対称関数から完全関数に変換します。 `comp2ele`や `comp2comp`に似ています。

  基数を変える他の関数: `comp2ele`。

  Categories: Package sym

関数: ele2comp (m, L)

  基本対称関数から完全関数に変換します。 `comp2ele`や `comp2pui`に似ています。

  基数を変える他の関数: `comp2ele`。

  Categories: Package sym

関数: elem (ele, sym, lvar)

  リスト eleで与えられた基本対称関数を使って、 リスト lvarに含まれる変数に関して対称多項式 symを分解します。 もし eleの最初の要素が与えられたらそれがアルファベットのサイズで、 そうでないならサイズは多項式 symの次数です。 もし値がリスト eleにないなら、 タイプ e1, e2などの形式的値が加えられます。 多項式 symは３つの異なる形式で与えられます: contracted (`elem`はその時、デフォルト値 1であるべきです), partitioned (`elem`は 3であるべきです),または extended(すなわち多項式全体, そして `elem`は 2であるべきです)。 関数 `pui`は同じ方法で使われます。

  以下のように、サイズ 3のアルファベットと値 7を持つ最初の基本対称関数 e1上で、 (ここで変数の２つにだけ依存する)短縮された形式が 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`。

  Categories: Package sym

関数: mon2schur (L)

  リスト Lは Schur関数 S_Lを表します: 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`。

  Categories: Package sym

関数: multi_elem (l_elem, multi_pc, l_var)

  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`。

  Categories: Package sym

関数: multi_pui

  関数 `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

  Categories: Package sym

関数: pui (L, sym, lvar)

  リスト Lの中のべき関数を使って、 リスト lvarの中の変数に関して対称多項式 symを分解します。 もし Lの最初の要素が与えられるなら、それはアルファベットのサイズです。 そうでないなら、サイズは多項式 symの次数になります。 もしリスト Lの中に値がないなら、タイプ p1, p2, などの形式的な値が加えられます。 多項式 symは３つの異なる形式で与えられることができます: 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

  基数を変えるための他の関数: `comp2ele`。

  Categories: Package sym

関数: pui2comp (n, lpui)

  リスト 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`。

  Categories: Package sym

関数: pui2ele (n, lpui)

  べき関数から基本対称関数への変換 (passage)に影響します。 もしフラグ `pui2ele`が `girard`なら 1から nまでの基本対称関数のリストを返し、 もしフラグが `close`なら n番目の基本対称関数を返します。

  基数を変えるための他の関数: `comp2ele`。

  Categories: Package sym

関数: puireduc (n, lpui)

  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

  Categories: Package sym

関数: schur2comp (P, l_var)

  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

  Categories: Package sym

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

### 30.2.2 Changing representations

関数: cont2part (pc, lvar)

  変数が 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]]

  Categories: Package sym

関数: contract (psym, lvar)

  リスト 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

  Categories: Package sym

関数: explose (pc, lvar)

  短縮形 pcに関連付けられた対称多項式を返します。 リスト lvarは変数を含みます。

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

  Categories: Package sym

関数: part2cont (ppart, lvar)

  対称式を分割形から短縮形に変換します。 短縮形は lvarの中の変数で表されます。

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

  Categories: Package sym

関数: partpol (psym, lvar)

  psymはリスト lvarの変数に関する対称多項式です。 この関数は分割表現を返します。

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

  Categories: Package sym

関数: tcontract (pol, lvar)

  多項式 polがリスト lvarの変数に関して対称かテストします。 もしそうなら関数 `contract`のように短縮表現を返します。

  Categories: Package sym

関数: tpartpol (pol, lvar)

  多項式 polがリスト lvarの中の変数に関して対称かテストします。 もしそうなら関数 `partpol`のように分割表現を返します。

  Categories: Package sym

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

### 30.2.3 Groups and orbits

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

  変数 lvar_1, ..., lvar_nのリストと変数 yについての多項式 p_1, ..., p_nに関して、 関数 fに関連付けられた順像 (direct image) (M. Giusti, D. Lazard et A. Valibouze, ISSAC 1988, Romeを参照してください) を計算します。 関数 fのアリティ (arity)が計算にとって重要です。 例えば、 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`は２つのフラグを受け付けます: `elementaires`と `puissances` (デフォルト)。 これらは計算の中に現れる対称多項式をそれぞれ基本対称関数またはべき関数に分解することを 許します。

  この関数で使われる `sym`の関数は以下の通りです:

  `multi_orbit` (仲間 `orbit`), `pui_direct`, `multi_elem` (仲間 `elem`), `multi_pui` (だから`pui`), `pui2ele`, (もしフラグ `direct`が `puissances`の中にあるなら) `ele2pui`。

  Categories: Package sym

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

  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`。

  Categories: Package sym

関数: multsym (ppart_1, ppart_2, n)

  次数 nの対称群の作用を法としてのみ働くことで、 n個の変数に関する２つの対称多項式の積を返します。 多項式は分割形式です。

  x, yに関する鵜２つの対称多項式: 分割形式が `[[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`。

  Categories: Package sym

関数: orbit (P, lvar)

  リスト 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]

  多項式に関する対称群の積の作用 (action)に関しては `multi_orbit`も参照してください。

  Categories: Package sym

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

  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の作用の下で軌道毎にただ１つの要素が保持されます。

      (%i1) l: [[x, y], [a, b]];
      (%o1)                   [[x, y], [a, b]]
      (%i2) pui_direct (multi_orbit (a*x + b*y, l), l, [2, 2]);
                                             2  2
      (%o2)               [a x, 4 a b x y + a  x ]
      (%i3) pui_direct (multi_orbit (a*x + b*y, l), l, [3, 2]);
                                   2  2     2    2        3  3
      (%o3) [2 a x, 4 a b x y + 2 a  x , 3 a  b x  y + 2 a  x ,

          2  2  2  2      3    3        4  4
      12 a  b  x  y  + 4 a  b x  y + 2 a  x ,

          3  2  3  2      4    4        5  5
      10 a  b  x  y  + 5 a  b x  y + 2 a  x ,

          3  3  3  3       4  2  4  2      5    5        6  6
      40 a  b  x  y  + 15 a  b  x  y  + 6 a  b x  y + 2 a  x ]
      (%i4) pui_direct ([y + x + 2*c, y + x + 2*b, y + x + 2*a],
            [[x, y], [a, b, c]], [2, 3]);
                                   2              2
      (%o4) [3 x + 2 a, 6 x y + 3 x  + 4 a x + 4 a ,

                       2                   3        2       2        3
                    9 x  y + 12 a x y + 3 x  + 6 a x  + 12 a  x + 8 a ]

  Categories: Package sym

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

### 30.2.4 Partitions

関数: kostka (part_1, part_2)

  P. Esperetによって書かれ、分割 part_1と part_2のKostka数を計算します。

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

  Categories: Package sym

関数: lgtreillis (n, m)

  重み nと長さ mの分割のリストを返します。

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

  以下も参照してください: `ltreillis`, `treillis`, `treinat`。

  Categories: Package sym

関数: ltreillis (n, m)

  重み nと m以下の長さの分割のリストを返します。

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

  以下も参照してください: `lgtreillis`, `treillis`, `treinat`。

  Categories: Package sym

関数: treillis (n)

  重み nの分割すべてを返します。

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

  以下も参照してください: `lgtreillis`, `ltreillis`, `treinat`。

  Categories: Package sym

関数: treinat (part)

  自然な順序に関する分割 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`。

  Categories: Package sym

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

### 30.2.5 Polynomials and their roots

関数: ele2polynome (L, z)

  根の基本対称関数がリスト `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

  逆: `polynome2ele (P, z)`。

  次も参照してください: `polynome2ele`, `pui2polynome`。

  Categories: Package sym

関数: polynome2ele (P, x)

  リスト `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)`

  Categories: Package sym

関数: prodrac (L, k)

  Lは集合 A上の基本対称関数を含むリストです。 `prodrac`は、根が Aの要素の k掛ける kの積の多項式を返します。

  `somrac`も参照してください。

  Categories: Package sym

関数: pui2polynome (x, lpui)

  根のべき関数がリスト 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`。

  Categories: Package sym

関数: somrac (L, k)

  リスト Lは多項式 Pの基本対称関数を含みます。 関数は根が Pの根の k掛ける kの別個の和である多項式を計算します。

  `prodrac`も参照してください。

  Categories: Package sym

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

### 30.2.6 Resolvents

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

  変数 x_1, ..., x_dで表現された関数 fによって次数 n >= dの xに関する多項式 Pの解核を計算します。 計算の効率のため、変換関数 fに現れない変数のリスト `[x_1, ..., x_d]`に含まれないことが重要です。

  計算の効率を増すためには、適切なアルゴリズムを使うように `resolvante`に関するフラグを設定することができます:

  もし 関数fがユニタリなら:

  - 単変数の多項式,
  - 線形,
  - 交互の,
  - 和,
  - 対照的,
  - 積,
  - (次数 5まで使用に向く) Cayley解核の関数。

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

    一般的,

  `resolvante`のフラグはそれぞれ:

  - 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

  Cayley解核に関しては、最後の2つの引数は中立であり、入力多項式は必然的に次数 5でなければいけません。

  以下も参照してください:

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

  Categories: Package sym

関数: resolvante_alternee1 (P, x)

  関数 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`。

  Categories: Package sym

関数: resolvante_bipartite (P, x)

  関数 によって 偶次数 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`.

  Categories: Package sym

関数: resolvante_diedrale (P, x)

  関数 `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`。

  Categories: Package sym

関数: resolvante_klein (P, x)

  関数 `x_1 x_2 x_4 + x_4`によって `P(x)`の変換を計算します。

  以下も参照してください:

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

  Categories: Package sym

関数: resolvante_klein3 (P, x)

  関数 `x_1 x_2 x_4 + x_4`によって `P(x)`の変換を計算します。

  以下も参照してください:

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

  Categories: Package sym

関数: resolvante_produit_sym (P, x)

  多項式 `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`。

  Categories: Package sym

関数: resolvante_unitaire (P, Q, x)

  多項式 `Q(x)`によって 多項式 `P(x)`の解核を計算します。

  以下も参照してください:

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

  Categories: Package sym

関数: resolvante_vierer (P, x)

  関数 `x_1 x_2 - x_3 x_4`によって `P(x)`の変換を計算します。

  以下も参照してください:

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

  Categories: Package sym

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

### 30.2.7 Miscellaneous

関数: multinomial (r, part)

  ここで rは分割 partの重みです。 この関数は、同類の多項係数を返します: もし partの部分が i_1, i_2, ..., i_kなら、 結果は `r!/(i_1! i_2! ... i_k!)`です。

  Categories: Package sym

関数: permut (L)

  リスト Lの置換のリストを返します。

  Categories: Package sym · Lists

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

This document was generated by 市川雄二 on June, 21 2016 using texi2html 1.76.