67.18 ClassicalForms

ClassicalForms( G )

Given as input, a classical, irreducible group G, ClassicalForms will try to find an invariant classical form for G (that is, an invariant symplectic or unitary bilinear form or an invariant symmetric bilinear form together with an invariant quadratic form, invariant modulo scalars in each case) or try to prove that no such form exists. The dimension of the underlying vector space must be at least 3.

The function may find a form even if G is a proper subgroup of a classical group; however, it is likely to fail for subgroups of {Gamma}L. In these cases "unknown" (see below) is returned.

The results "linear", "symplectic", "unitary", "orthogonal..." and "absolutely reducible" are always correct, but "unknown" can either imply that the algorithm failed to find a form and it could not prove the linear case or that G is not a classical group.

[ "unknown" ]:

it is not known if G fixes a form.

[ "unknown", "absolutely reducible" ]:

G acts absolutely reducible on the underlying vector space. The function does not apply in this case.

[ "linear" ]:

it is known that G does not fix a classical form modulo scalars.

[ "symplectic", form, scalars ]:

G fixes a symplectic form modulo scalars. The form is only unique up to scalar multiplication. In characteristic two this also implies that no quadratic form is fixed.

[ "unitary", form, scalars ]:

G fixes a unitary form modulo scalars. The form is only unique up to scalar multiplication.

[ "orthogonalcircle", form, scalars, quadratic, ... ]
[ "orthogonalplus", form, scalars, quadratic, ... ]

[ "orthogonalminus", form, scalars, quadratic, ... ]:

G fixes a orthogonal form with corresponding quadratic form modulo scalars. The forms are only unique up to scalar multiplication.

The function might return more than one list. However, in characteristic 2 it will not return "symplectic" if G fixes a quadratic form.

A bilinear form is returned as matrix F such that g * F * g^{tr} equals F modulo scalars for all elements g of G. A quadratic form is returned as upper triangular matrix Q such that g * Q * g^{tr} equals Q modulo scalars after g * Q * g^{tr} has been normalized into an upper triangular matrix. See the following example.

vbox

    gap> G := O( 0, 9, 9 );
    gap> f := ClassicalForms(G);;
    gap> Q := f[1][4];;
    gap> DisplayMat(Q);
     . 1 . . . . . . .
     . . . . . . . . .
     . . 1 . . . . . .
     . . . 1 . . . . .
     . . . . 1 . . . .
     . . . . . 1 . . .
     . . . . . . 1 . .
     . . . . . . . 1 .
     . . . . . . . . 1 

vbox

    gap> DisplayMat( G.1 * Q * TransposedMat(G.1) );
     . 1 . . . . . . .
     . . . . . . . . .
     . . 1 . . . . . .
     . . . 1 . . . . .
     . . . . 1 . . . .
     . . . . . 1 . . .
     . . . . . . 1 . .
     . . . . . . . 1 .
     . . . . . . . . 1

vbox

    gap> DisplayMat( G.2 * Q * TransposedMat(G.2) );
     . . . . . . . . .
     1 . . . . . . . 1
     . . 1 . . . . . .
     . . . 1 . . . . .
     . . . . 1 . . . .
     . . . . . 1 . . .
     . . . . . . 1 . .
     . . . . . . . 1 .
     . 2 . . . . . . 1

Note that in general g * Q * TransposedMat(g) is not equal to Q for an element of an orthogonal group because you have to normalise the quadratic form such that it is an upper triangular matrix. In the above example for G.1 you have to move the 1 in position (9,2) to position (2,9) adding it to the 2 which gives a 0, and you have to move the 2 in position (1,2) to position (2,1) thus obtaining the original quadratic form.

Examples

    gap> G := SP( 4, 2 );
    SP(4,2)
    gap> ClassicalForms( G );
    [ [ "symplectic", 
      [ [ 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0 ],
        [ 0*Z(2), 0*Z(2), Z(2)^0, 0*Z(2) ],
        [ 0*Z(2), Z(2)^0, 0*Z(2), 0*Z(2) ], 
        [ Z(2)^0, 0*Z(2), 0*Z(2), 0*Z(2) ] ],
      [ Z(2)^0, Z(2)^0 ] ] ] 

In this case G leaves a symplectic (and symmetric) form invariant but does not fix a quadratic form.

    gap> G := O( -1, 4, 2 );
    O(-1,4,2)
    gap> ClassicalForms( G );
    [ [ "orthogonalminus", 
        [ [ 0*Z(2), Z(2)^0, 0*Z(2), 0*Z(2) ],
          [ Z(2)^0, 0*Z(2), 0*Z(2), 0*Z(2) ],
          [ 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0 ], 
          [ 0*Z(2), 0*Z(2), Z(2)^0, 0*Z(2) ] ],
        [ Z(2)^0, Z(2)^0 ], 
        [ [ 0*Z(2), Z(2)^0, 0*Z(2), 0*Z(2) ],
          [ 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2) ],
          [ 0*Z(2), 0*Z(2), Z(2)^0, Z(2)^0 ], 
          [ 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0 ] ] ] ] 

In this case G leaves a symplectic and symmetric form invariant and there exists also an invariant quadratic form.

    gap> m1 :=
    [ [ Z(2^2), Z(2)^0, 0*Z(2), Z(2^2) ],
      [ Z(2^2)^2, Z(2^2), Z(2^2)^2, Z(2^2) ], 
      [ 0*Z(2), Z(2^2)^2, Z(2^2)^2, Z(2)^0 ], 
      [ Z(2^2), Z(2^2)^2, Z(2^2), Z(2^2)^2 ] ];;
    gap> m2 := 
    [ [ 0*Z(2), 0*Z(2), 0*Z(2), Z(2^2) ],
      [ 0*Z(2), 0*Z(2), Z(2^2)^2, 0*Z(2) ],
      [ 0*Z(2), Z(2^2)^2, 0*Z(2), Z(2^2) ],
      [ Z(2^2), 0*Z(2), Z(2^2)^2, 0*Z(2) ] ];;
    gap> G := Group( m1, m2 );;
    gap> ClassicalForms( G );
    [ [ "unknown" ], 
      [ "symplectic",
        [ [ 0*Z(2), Z(2)^0, Z(2)^0, Z(2^2)^2 ],
          [ Z(2)^0, 0*Z(2), Z(2^2), Z(2)^0 ],
          [ Z(2)^0, Z(2^2), 0*Z(2), Z(2)^0 ], 
          [ Z(2^2)^2, Z(2)^0, Z(2)^0, 0*Z(2) ] ],
        [ Z(2)^0, Z(2)^0 ] ] ] 

The "symplectic" indicates that an invariant symplectic form exists, the "unknown" indicates that an invariant "unitary" form might exist. Using the test once more, one gets:

    gap> ClassicalForms( G );
    [ [ "symplectic", 
        [ [ 0*Z(2), Z(2^2)^2, Z(2^2)^2, Z(2^2) ],
          [ Z(2^2)^2, 0*Z(2), Z(2)^0, Z(2^2)^2 ],
          [ Z(2^2)^2, Z(2)^0, 0*Z(2), Z(2^2)^2 ], 
          [ Z(2^2), Z(2^2)^2, Z(2^2)^2, 0*Z(2) ] ],
        [ Z(2)^0, Z(2)^0 ] ], 
      [ "unitary",
        [ [ 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0 ],
          [ 0*Z(2), 0*Z(2), Z(2)^0, 0*Z(2) ],
          [ 0*Z(2), Z(2)^0, 0*Z(2), 0*Z(2) ], 
          [ Z(2)^0, 0*Z(2), 0*Z(2), 0*Z(2) ] ],
        [ Z(2)^0, Z(2)^0 ] ] ] 

So G indeed fixes both a symplectic and unitary form but no quadratic form.

    gap> ReadDataPkg ("matrix", "data", "a5d4.gap");
    gap> ClassicalForms( G );
    [ [ "unknown", "absolutely reducible" ] ] 

G acts irreducibly, however ClassicalForms is not able to check if an invariant bilinear or quadratic form exists.

    gap> ReadDataPkg ("matrix", "data", "a5d5.gap" );  
    gap> ClassicalForms( G );
    [ [ "unknown" ] ]
    gap> IsAbsolutelyIrreducible(GModule(G));
    true 

Although G fixes a symmetric form, ClassicalForms is not able to find an invariant form because G is not a classical group.

Previous Up Top Next
Index