Next: Groups, Previous: Number Theory [Contents][Index]
Next: Functions and Variables for Symmetries, Previous: Package sym, Up: Package sym [Contents][Index]
sym is a package for working with symmetric groups of polynomials.
It was written for Macsyma-Symbolics by Annick Valibouze (https://web.archive.org/web/20061125035035/http://www-calfor.lip6.fr/~avb/). The algorithms are described in the following papers:
Previous: Introduction to Symmetries, Up: Package sym [Contents][Index]
implements passing from the complete symmetric functions given in the list L to the elementary symmetric functions from 0 to n. If the list L contains fewer than n+1 elements, it will be completed with formal values of the type h1, h2, etc. If the first element of the list L exists, it specifies the size of the alphabet, otherwise the size is set to n.
(%i1) comp2pui (3, [4, g]);
2 2
(%o1) [4, g, 2 h2 - g , 3 h3 - g h2 + g (g - 2 h2)]
goes from the elementary symmetric functions to the complete functions.
Similar to comp2ele and comp2pui.
Other functions for changing bases: comp2ele.
Goes from the elementary symmetric functions to the compete functions.
Similar to comp2ele and comp2pui.
Other functions for changing bases: comp2ele.
decomposes the symmetric polynomial sym, in the variables
contained in the list lvar, in terms of the elementary symmetric
functions given in the list ele. If the first element of
ele is given, it will be the size of the alphabet, otherwise the
size will be the degree of the polynomial sym. If values are
missing in the list ele, formal values of the type e1,
e2, etc. will be added. The polynomial sym may be given in
three different forms: contracted (elem should then be 1, its
default value), partitioned (elem should be 3), or extended
(i.e. the entire polynomial, and elem should then be 2). The
function pui is used in the same way.
On an alphabet of size 3 with e1, the first elementary symmetric function, with value 7, the symmetric polynomial in 3 variables whose contracted form (which here depends on only two of its variables) is x^4-2*x*y decomposes as follows in elementary symmetric functions:
(%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
Other functions for changing bases: comp2ele.
The list L represents the Schur function S_L: we have L = [i_1, i_2, ..., i_q], with i_1 <= i_2 <= ... <= i_q. The Schur function S_[i_1, i_2, ..., i_q] is the minor of the infinite matrix h_[i-j], i <= 1, j <= 1, consisting of the q first rows and the columns 1 + i_1, 2 + i_2, ..., q + i_q.
This Schur function can be written in terms of monomials by using
treinat and kostka. The form returned is a symmetric
polynomial in a contracted representation in the variables
x_1,x_2,...
(%i1) mon2schur ([1, 1, 1]); (%o1) x1 x2 x3
(%i2) mon2schur ([3]);
2 3
(%o2) x1 x2 x3 + x1 x2 + x1
(%i3) mon2schur ([1, 2]);
2
(%o3) 2 x1 x2 x3 + x1 x2
which means that for 3 variables this gives:
2 x1 x2 x3 + x1^2 x2 + x2^2 x1 + x1^2 x3 + x3^2 x1
+ x2^2 x3 + x3^2 x2
Other functions for changing bases: comp2ele.
decomposes a multi-symmetric polynomial in the multi-contracted form multi_pc in the groups of variables contained in the list of lists l_var in terms of the elementary symmetric functions contained in 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
Other functions for changing bases: comp2ele.
is to the function pui what the function multi_elem is to
the function 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
decomposes the symmetric polynomial sym, in the variables in the
list lvar, in terms of the power functions in the list L.
If the first element of L is given, it will be the size of the
alphabet, otherwise the size will be the degree of the polynomial
sym. If values are missing in the list L, formal values of
the type p1, p2 , etc. will be added. The polynomial
sym may be given in three different forms: contracted (elem
should then be 1, its default value), partitioned (elem should be
3), or extended (i.e. the entire polynomial, and elem should then
be 2). The function pui is used in the same way.
(%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.
renders the list of the first n complete functions (with the
length first) in terms of the power functions given in the list
lpui. If the list lpui is empty, the cardinal is n,
otherwise it is its first element (as in comp2ele and
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
Other functions for changing bases: comp2ele.
effects the passage from power functions to the elementary symmetric functions.
If the flag pui2ele is girard, it will return the list of
elementary symmetric functions from 1 to n, and if the flag is
close, it will return the n-th elementary symmetric function.
Other functions for changing bases: comp2ele.
lpui is a list whose first element is an integer m.
puireduc gives the first n power functions in terms of the
first m.
(%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 is a polynomial in the variables of the list l_var. Each
of these variables represents a complete symmetric function. In
l_var the i-th complete symmetric function is represented by
the concatenation of the letter h and the integer i:
hi. This function expresses P in terms of Schur
functions.
(%i1) schur2comp (h1*h2 - h3, [h1, h2, h3]);
(%o1) s
1, 2
(%i2) schur2comp (a*h3, [h3]);
(%o2) s a
3
returns the partitioned polynomial associated to the contracted form pc whose variables are in 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]]
returns a contracted form (i.e. a monomial orbit under the action of the
symmetric group) of the polynomial psym in the variables contained
in the list lvar. The function explose performs the
inverse operation. The function tcontract tests the symmetry of
the polynomial.
(%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
returns the symmetric polynomial associated with the contracted form pc. The list lvar contains the variables.
(%i1) explose (a*x + 1, [x, y, z]); (%o1) a z + a y + a x + 1
goes from the partitioned form to the contracted form of a symmetric polynomial. The contracted form is rendered with the variables in lvar.
(%i1) part2cont ([[2*a^3*b, 4, 1]], [x, y]);
3 4
(%o1) 2 a b x y
psym is a symmetric polynomial in the variables of the list lvar. This function returns its partitioned representation.
(%i1) partpol (-a*(x + y) + 3*x*y, [x, y]); (%o1) [[3, 1, 1], [- a, 1, 0]]
tests if the polynomial pol is symmetric in the variables of the
list lvar. If so, it returns a contracted representation like the
function contract.
tests if the polynomial pol is symmetric in the variables of the
list lvar. If so, it returns its partitioned representation like
the function partpol.
calculates the direct image (see M. Giusti, D. Lazard et A. Valibouze, ISSAC 1988, Rome) associated to the function f, in the lists of variables lvar_1, ..., lvar_n, and in the polynomials p_1, ..., p_n in a variable y. The arity of the function f is important for the calculation. Thus, if the expression for f does not depend on some variable, it is useless to include this variable, and not including it will also considerably reduce the amount of computation.
(%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
Finding the polynomial whose roots are the sums a+u where a is a root of z^2 - e_1 z + e_2 and u is a root of 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 accepts two flags: elementaires and
puissances (default) which allow decomposing the symmetric
polynomials appearing in the calculation into elementary symmetric
functions, or power functions, respectively.
Functions of sym used in this function:
multi_orbit (so orbit), pui_direct, multi_elem
(so elem), multi_pui (so pui), pui2ele, ele2pui
(if the flag direct is in puissances).
P is a polynomial in the set of variables contained in the lists lvar_1, lvar_2, ..., lvar_p. This function returns the orbit of the polynomial P under the action of the product of the symmetric groups of the sets of variables represented in these p lists.
(%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]
Also see: orbit for the action of a single symmetric group.
returns the product of the two symmetric polynomials in n variables by working only modulo the action of the symmetric group of order n. The polynomials are in their partitioned form.
Given the 2 symmetric polynomials in x, y: 3*(x + y)
+ 2*x*y and 5*(x^2 + y^2) whose partitioned forms are [[3,
1], [2, 1, 1]] and [[5, 2]], their product will be
(%i1) multsym ([[3, 1], [2, 1, 1]], [[5, 2]], 2); (%o1) [[10, 3, 1], [15, 3, 0], [15, 2, 1]]
that is 10*(x^3*y + y^3*x) + 15*(x^2*y + y^2*x) + 15*(x^3 + y^3).
Functions for changing the representations of a symmetric polynomial:
contract, cont2part, explose, part2cont,
partpol, tcontract, tpartpol.
computes the orbit of the polynomial P in the variables in the list lvar under the action of the symmetric group of the set of variables in the list 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]
See also multi_orbit for the action of a product of symmetric
groups on a polynomial.
Let f be a polynomial in n blocks of variables lvar_1,
..., lvar_n. Let c_i be the number of variables in
lvar_i, and SC be the product of n symmetric groups of
degree c_1, ..., c_n. This group acts naturally on f.
The list orbite is the orbit, denoted SC(f), of
the function f under the action of SC. (This list may be
obtained by the function multi_orbit.) The di are integers
s.t.
c_1 <= d_1, c_2 <= d_2, ..., c_n <= d_n.
Let SD be the product of the symmetric groups S_[d_1] x
S_[d_2] x ... x S_[d_n].
The function pui_direct returns
the first n power functions of SD(f) deduced
from the power functions of SC(f), where n is
the size of SD(f).
The result is in multi-contracted form w.r.t. SD, i.e. only one element is kept per orbit, under the action of 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 ]
written by P. Esperet, calculates the Kostka number of the partition part_1 and part_2.
(%i1) kostka ([3, 3, 3], [2, 2, 2, 1, 1, 1]); (%o1) 6
returns the list of partitions of weight n and length m.
(%i1) lgtreillis (4, 2); (%o1) [[3, 1], [2, 2]]
Also see: ltreillis, treillis and treinat.
returns the list of partitions of weight n and length less than or equal to m.
(%i1) ltreillis (4, 2); (%o1) [[4, 0], [3, 1], [2, 2]]
Also see: lgtreillis, treillis and treinat.
returns all partitions of weight n.
(%i1) treillis (4); (%o1) [[4], [3, 1], [2, 2], [2, 1, 1], [1, 1, 1, 1]]
See also: lgtreillis, ltreillis and treinat.
returns the list of partitions inferior to the partition part w.r.t. the natural order.
(%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]]
See also: lgtreillis, ltreillis and treillis.
returns the polynomial in z s.t. the elementary symmetric
functions of its roots are in the list L = [n,
e_1, ..., e_n], where n is the degree of the
polynomial and e_i the i-th elementary symmetric function.
(%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.
gives the list l = [n, e_1, ..., e_n]
where n is the degree of the polynomial P in the variable
x and e_i is the i-the elementary symmetric function
of the roots of 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
The inverse: ele2polynome (l, x)
L is a list containing the elementary symmetric functions
on a set A. prodrac returns the polynomial whose roots
are the k by k products of the elements of A.
Also see somrac.
calculates the polynomial in x whose power functions of the roots are given in the list 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
See also:
polynome2ele, ele2polynome.
The list L contains elementary symmetric functions of a polynomial P . The function computes the polynomial whose roots are the k by k distinct sums of the roots of P.
Also see prodrac.
calculates the resolvent of the polynomial P in x of degree
n >= d by the function f expressed in the variables
x_1, ..., x_d. For efficiency of computation it is
important to not include in the list [x_1, ..., x_d]
variables which do not appear in the transformation function f.
To increase the efficiency of the computation one may set flags in
resolvante so as to use appropriate algorithms:
If the function f is unitary:
(x1*x2 + x2*x3 + x3*x4 + x4*x5 + x5*x1 -
(x1*x3 + x3*x5 + x5*x2 + x2*x4 + x4*x1))^2
general,
the flag of resolvante may be, respectively:
(%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
For the Cayley resolvent, the 2 last arguments are neutral and the input polynomial must necessarily be of degree 5.
See also:
resolvante_bipartite, resolvante_produit_sym,
resolvante_unitaire, resolvante_alternee1, resolvante_klein,
resolvante_klein3, resolvante_vierer, resolvante_diedrale.
calculates the transformation
P(x) of degree n by the function
product(x_i - x_j, 1 <= i < j <= n - 1).
See also:
resolvante_produit_sym, resolvante_unitaire,
resolvante, resolvante_klein, resolvante_klein3,
resolvante_vierer, resolvante_diedrale, resolvante_bipartite.
calculates the transformation of
P(x) of even degree n by the function
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
See also:
resolvante_produit_sym, resolvante_unitaire,
resolvante, resolvante_klein, resolvante_klein3,
resolvante_vierer, resolvante_diedrale, resolvante_alternee1.
calculates the transformation of P(x) by the function
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
See also:
resolvante_produit_sym, resolvante_unitaire,
resolvante_alternee1, resolvante_klein, resolvante_klein3,
resolvante_vierer, resolvante.
calculates the transformation of P(x) by the function
x_1 x_2 x_4 + x_4.
See also:
resolvante_produit_sym, resolvante_unitaire,
resolvante_alternee1, resolvante, resolvante_klein3,
resolvante_vierer, resolvante_diedrale.
calculates the transformation of P(x) by the function
x_1 x_2 x_4 + x_4.
See also:
resolvante_produit_sym, resolvante_unitaire,
resolvante_alternee1, resolvante_klein, resolvante,
resolvante_vierer, resolvante_diedrale.
calculates the list of all product resolvents of the polynomial
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
See also:
resolvante, resolvante_unitaire,
resolvante_alternee1, resolvante_klein,
resolvante_klein3, resolvante_vierer,
resolvante_diedrale.
computes the resolvent of the polynomial P(x) by the
polynomial Q(x).
See also:
resolvante_produit_sym, resolvante,
resolvante_alternee1, resolvante_klein, resolvante_klein3,
resolvante_vierer, resolvante_diedrale.
computes the transformation of
P(x) by the function x_1 x_2 -
x_3 x_4.
See also:
resolvante_produit_sym, resolvante_unitaire,
resolvante_alternee1, resolvante_klein, resolvante_klein3,
resolvante, resolvante_diedrale.
where r is the weight of the partition part. This function
returns the associate multinomial coefficient: if the parts of
part are i_1, i_2, ..., i_k, the result is
r!/(i_1! i_2! ... i_k!).
returns the list of permutations of the list L.
Next: Groups, Previous: Number Theory [Contents][Index]