[MathJax on]

3 Other functionality

3.1 The Jordan-Chevalley decomposition

3.1-1 JordanChevalleyDecMat

Returns the unique pair of matrices D, N such that the matrix A is written as A=D+N, where N is a nilpotent matrix and D is a matrix that is diagonalisable (over some extension field of the default field of A), such that D.N=N.D; the argument f is a polynomial such that f(A)=0 (e.g., the minimal polynomial of A). This is called the Jordan-Chevalley decomposition of A; the algorithm is based on [Gec22]. Note that this algorithm does not require the knowledge of the eigenvalues of A; it works over any perfect field that is available in GAP.

gap> A:=[ [  6, -2,  6,  1,  1 ],
>         [  1, -1,  2,  1, -2 ],
>         [ -2,  0, -1,  0, -1 ],
>         [ -1,  0, -2,  2, -1 ],
>         [ -4,  4, -6, -2,  3 ] ];;
gap> jc:=JordanChevalleyDecMat(A,MinimalPolynomial(A));
[ [ [  4,  0,  4, -1,  1 ], 
    [  1,  0,  1,  1, -1 ], 
    [ -1, -1,  0,  1, -1 ], 
    [  0,  0, -2,  3,  0 ], 
    [ -3,  2, -4, -1,  2 ] ], 
  [ [  2, -2,  2,  2,  0 ], 
    [  0, -1,  1,  0, -1 ], 
    [ -1,  1, -1, -1,  0 ], 
    [ -1,  0,  0, -1, -1 ], 
    [ -1,  2, -2, -1,  1 ] ] ]
gap> MinimalPolynomial(jc[1]);
x_1^3-5*x_1^2+9*x_1-5
gap> Factors(last);
[ x_1-1, x_1^2-4*x_1+5 ]  
gap> MinimalPolynomial(jc[2]);
x_1^2                     

If the input matrix is very large, then JordanChevalleyDecMatF (3.1-2) may be more efficient; this function first computes the Frobenius normal form of A and then applies JordanChevalleyDecMat to each diagonal block. (The result will be the same as that of 'JordanChevalleyDecMat(A);)'

3.1-2 JordanChevalleyDecMatF

First computes the Frobenius normal form and then applies JordanChevalleyDecMat (3.1-1) to each diagonal block.

3.2 The primary decomposition

3.2-1 PrimaryDecomposition

Returns a list containing three elements. The first element is a base change matrix B such that BAB^-1 is a primary form of the matrix A, i.e., a block diagonal matrix where the minimal polynomials of the the diagonal blocks are precisely the powers of irreducible factors of the minimal polynomial of A, in descending order. The second element is a list containing the collected irreducible factors of the minimal polynomial of A, in the same order. The last element is a list containing the the size of each block. The exact algorithm used in this function is described in [Bon26]

gap> A := [ [ Z(5)^2, 0*Z(5), Z(5)^2, Z(5)^3, Z(5) ], 
>    [ 0*Z(5), 0*Z(5), Z(5)^3, Z(5), Z(5)^0 ],  
>    [ Z(5), Z(5)^0, 0*Z(5), Z(5)^0, 0*Z(5) ],
>    [ Z(5)^0, Z(5)^0, Z(5)^0, 0*Z(5), Z(5)^3 ],
>    [ Z(5), 0*Z(5), Z(5)^3, 0*Z(5), Z(5)^3 ] ];;
gap> B := PrimaryDecomposition(A);;
gap> Display(B[3]);
[ 1, 4 ]
gap> Factors(MinimalPolynomial(A));
[ x_1-Z(5)^0, x_1^4-x_1^3+Z(5)^3*x_1+Z(5)^3 ]
gap> PrimA := A^Inverse(B[1]);;
gap> MinimalPolynomial(PrimA{[1..1]}{[1..1]});
x_1-Z(5)^0
gap> MinimalPolynomial(PrimA{[2..5]}{[2..5]});
x_1^4-x_1^3+Z(5)^3*x_1+Z(5)^3

generated by GAPDoc2HTML