Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 Bib Ind
 Top of Book   Previous Chapter   Next Chapter 

8 Classical Polar Spaces
 8.1 Creating Polar Spaces
  8.1-1 PolarSpace
 8.2 Canonical Polar Spaces
  8.2-1 SymplecticSpace

  8.2-2 HermitianVariety

  8.2-3 ParabolicQuadric

  8.2-4 HyperbolicQuadric

  8.2-5 EllipticQuadric

  8.2-6 CanonicalPolarSpace
 8.3 Basic operations finite classical polar spaces
  8.3-1 UnderlyingVectorSpace

  8.3-2 ProjectiveDimension

  8.3-3 StandardFrame

  8.3-4 Coordinates

  8.3-5 EquationOfHyperplane

  8.3-6 BaseField

  8.3-7 AsList

  8.3-8 Random

  8.3-9 RandomSubspace

  8.3-10 VectorSpaceToElement

  8.3-11 EmptySubspace

  8.3-12 \in

  8.3-13 Span

  8.3-14 Meet

  8.3-15 IsCollinear

  8.3-16 Polarity

  8.3-17 AmbientSpace

  8.3-18 TypeOfSubspace
 8.4 All the elements or just one at a time
  8.4-1 Enumerators for polar spaces

  8.4-2 Enumerator

  8.4-3 Iterators for projective spaces

  8.4-4 Iterator

8 Classical Polar Spaces

In this chapter we describe how to use FinInG to work with finite classical polar spaces.

8.1 Creating Polar Spaces

A polar space is a point-line incidence geometry, also satisfying few well known axioms. Well known examples of finite polar spaces are the geometries attached to sesquilinear and quadratic forms of vector spaces over a finite field, these geometries are called the finite classical polar spaces. As in the previous case, the underlying vector space and matrix group are to our advantage. We refer the reader to [HT91] and [Cam00] for the necessary background theory (if it is not otherwise provided), and we follow the approach of [Cam00] to introduce all different flavours.

Consider the projective space PG(n,q) with underlying vector space V(n+1,q). Consider a non-degenerate sesquilinear form f. Then f is either Hermitian, alternating or symmetric. When the characteristic of the field is odd, respectively even, a symmetric bilinear form is called orthogonal, respectively, pseudo. We do not consider the pseudo case, so we suppose that f is Hermitian, symplectic or orthogonal. It is well known that the geometry consisting of the subspaces of PG(n,q) whose underlying vector subspace is totally isotropic with relation to f, is a polar space P. We call a polar space Hermitian, respectively, symplectic, orthogonal, if the underlying sesquilinear form is Hermitian, respectively, symplectic, orthogonal.

Symmetric bilinear forms have completely different geometric properties in even characteristic than in odd characteristic. On the other hand, polar spaces geometrically comparable to orthogonal polar spaces in odd characteristic, do exist in even characteristic. The algebraic background is now established by quadratic forms on a vector space instead of bilinear forms. Consider a non-singular quadratic form q on a vector space V(n+1,q). It is well known that the geometry consisting of the subspaces of PG(n,q) whose underlying vector subspace is totally singular with relation to q, is a polar space P. The connection with orthogonal polar spaces in odd characteristic is clear, since in odd characteristic, quadratic forms and symmetric bilinear forms are equivalent. Therefore, we call polar spaces with an underlying quadratic form in even characteristic also orthogonal polar spaces.

8.1-1 PolarSpace
> PolarSpace( form )( operation )

Returns: a classical polar space

form must be a bilinear, quadratic, or hermitian form created by use of the GAP package forms.

gap> mat := [[0,0,0,1],[0,0,-2,0],[0,2,0,0],[-1,0,0,0]]*Z(5)^0;
[ [ 0*Z(5), 0*Z(5), 0*Z(5), Z(5)^0 ], [ 0*Z(5), 0*Z(5), Z(5)^3, 0*Z(5) ], 
  [ 0*Z(5), Z(5), 0*Z(5), 0*Z(5) ], [ Z(5)^2, 0*Z(5), 0*Z(5), 0*Z(5) ] ]
gap> form := BilinearFormByMatrix(mat,GF(25));
< bilinear form >
gap> ps := PolarSpace(form);
<polar space of rank 3 over GF(5^2)>
gap> r := PolynomialRing(GF(32),4);
PolynomialRing(..., [ x_1, x_2, x_3, x_4 ])
gap> poly := r.3*r.2+r.1*r.4;
x_1*x_4+x_2*x_3
gap> form := QuadraticFormByPolynomial(poly,r);
< quadratic form >
gap> ps := PolarSpace(form);
<polar space of rank 3 over GF(2^5)>
 

FinInG relies on the package forms for its facility with sesquilinear and quadratic forms. One can specify a polar space with a user-defined form, and we refer to the documention for forms for information on how one can create and use forms. Here we just display a worked example.

gap> id := IdentityMat(7, GF(3));;
gap> form := QuadraticFormByMatrix(id, GF(3));
< quadratic form >
gap> ps := PolarSpace( form );
<polar space of dimension 6 over GF(3)>
gap> ## The construction of the ovoid: ##
gap> psl32 := PSL(3,2);
Group([ (4,6)(5,7), (1,2,4)(3,6,5) ])
gap> reps:=[[1,1,1,0,0,0,0], [-1,1,1,0,0,0,0],
[1,-1,1,0,0,0,0], [1,1,-1,0,0,0,0]]*Z(3)^0;;
gap> ovoid := Union( List(reps, x-> Orbit(psl32, x, Permuted)) );;
gap> ovoid := List(ovoid, x -> VectorSpaceToElement(ps, x));;
gap> planes := AsList( Planes( ps ) );;
gap> ForAll(planes, p -> Number(ovoid, x -> x in p) = 1);
true

8.2 Canonical Polar Spaces

To introduce the classification of polar spaces, we use the classification of the underlying forms in similarity classes. We follow mostly the approach and terminology of [KL90], as we did in the manual of the package Forms.

Consider a vector space V=V(n+1,q) and a sequilinear form f on V. The couple (V,f) is called a formed space. Consider now two formed spaces (V,f) and (V,f'), where f and f' are two sesquilinear forms on V. A non-degenerate linear map φ from V to itself induces a similarity of the formed space (V,f) to the formed space (V,f') if and only if f(v,w) = λ (f'(φ(v),φ(w))), for all vectors v,w some non-zero λ in GF(q). Up to similarity, there is only one class of non-degenerate Hermitian forms, and one class of non-degenerate symplectic forms on a given vector space V. For symmetric bilinear forms in odd characteristic, the number of similarity classes is dependent of the dimension of V. In odd dimension, there is only one similarity class, and non-degenerate forms in this class are called parabolic (bilinear) forms. In even dimension, there are two similarity classes, and non-degenerate forms are either elliptic (bilinear) forms or hyperbolic (bilinear) forms.

Consider now a vector space V and a quadratic form q on V. The couple (V,q) is called a formed space. Consider now two formed spaces (V,q) and (V,q'), where q and q' are two quadratic forms on V. A non-degenerate linear map φ from V to itself induces a similarity of the formed space (V,q) to the formed space (V,q') if and only if f(v) = λ (f'(φ(v))), for all vectors v some non-zero λ in GF(q). For quadratic forms in even characteristic, the number of similarity classes is dependent of the dimension of V. In odd dimension, there is only one similarity class, and non-degenerate forms in this class are called parabolic (bilinear) forms. In even dimension, there are two similarity classes, and non-degenerate forms are either elliptic (bilinear) forms or hyperbolic (bilinear) forms.

In the following table, we summerize the above information on polar spaces, together with the canonical forms that are chosen in FinInG.

Table: finite classical polar spaces
polar space canonical form characteristic projective dimension
hermitian variety X0q+1 + X1q+1 ... + Xnq+1 = 0 odd and even odd and even
symplectic space X0 Y1 - X1Y0 + ... + Xn-1Yn - XnYn-1 = 0 odd and even odd
hyperbolic quadric X0 X1 + ... + Xn-1Xn-1 = 0 odd and even odd
parabolic quadric X02 + X1 X2 + ... + Xn-1Xn-1 = 0 odd and even even
elliptic quadric ν X02 + X12 + X2 X3 + ... + Xn-1Xn-1 = 0, ν a non-square odd odd
elliptic quadric d X02 + X0X1 + X12 + X2 X3 + ... + Xn-1Xn-1 = 0, Tr(d) = 1 even odd

 


8.2-1 SymplecticSpace
> SymplecticSpace( d, F )( operation )
> SymplecticSpace( d, q )( operation )

Returns: a symplectic polar space

This function returns the symplectic polar space of dimension d over F for a field F or over GF(q) for a prime power q.

gap> ps := SymplecticSpace(3,4);
W(3, 4)
gap> Display(ps);
W(3, 4)
Non-degenerate symplectic form
Gram Matrix:
 . 1 . .
 1 . . .
 . . . 1
 . . 1 .
Witt Index: 2
 

8.2-2 HermitianVariety
> HermitianVariety( d, F )( operation )
> HermitianVariety( d, q )( operation )

Returns: a Hermitian variety

This function returns the Hermitian variety of dimension d over F for a field F or over GF(q) for a prime power q.

gap> ps := HermitianVariety(2,25);
H(2, 5^2)
gap> Display(ps);
H(2, 25)
Hermitian form
Gram Matrix:
 1 . .
 . 1 .
 . . 1
Witt Index: 1
 

8.2-3 ParabolicQuadric
> ParabolicQuadric( d, F )( operation )
> ParabolicQuadric( d, q )( operation )

Returns: a parabolic quadric

d must be an even positive integer. This function returns the parabolic quadric of dimension d over F for a field F or over GF(q) for a prime power q.

gap> ps := ParabolicQuadric(2,9);
Q(2, 9)
gap> Display(ps);
Q(2, 9)
Non-degenerate parabolic bilinear form
Gram Matrix:
 1 . .
 . . 2
 . 2 .
Witt Index: 1
gap> ps := ParabolicQuadric(4,16);
Q(4, 16)
gap> Display(ps);
Q(4, 16)
Non-singular parabolic quadratic form
Gram Matrix:
 1 . . . .
 . . 1 . .
 . . . . .
 . . . . 1
 . . . . .
Witt Index: 2
Bilinear form
Gram Matrix:
 . . . . .
 . . 1 . .
 . 1 . . .
 . . . . 1
 . . . 1 .
 

8.2-4 HyperbolicQuadric
> HyperbolicQuadric( d, F )( operation )
> HyperbolicQuadric( d, q )( operation )

Returns: a hyperbolic quadric

d must be an odd positive integer. This function returns the hyperbolic quadric of dimension d over F for a field F or over GF(q) for a prime power q.

gap> ps := HyperbolicQuadric(5,3);
Q+(5, 3)
gap> Display(ps);
Q+(5, 3)
Non-degenerate hyperbolic bilinear form
Gram Matrix:
 . 2 . . . .
 2 . . . . .
 . . . 2 . .
 . . 2 . . .
 . . . . . 2
 . . . . 2 .
Witt Index: 3
gap> ps := HyperbolicQuadric(3,4);
Q+(3, 4)
gap> Display(ps);
Q+(3, 4)
Non-singular hyperbolic quadratic form
Gram Matrix:
 . 1 . .
 . . . .
 . . . 1
 . . . .
Witt Index: 2
Bilinear form
Gram Matrix:
 . 1 . .
 1 . . .
 . . . 1
 . . 1 .
 

8.2-5 EllipticQuadric
> EllipticQuadric( d, F )( operation )
> EllipticQuadric( d, q )( operation )

Returns: an elliptic quadric

d must be an odd positive integer. This function returns the elliptic quadric of dimension d over F for a field F or over GF(q) for a prime power q.

gap> ps := EllipticQuadric(3,27);
Q-(3, 27)
gap> Display(ps);
Q-(3, 27)
Non-degenerate elliptic bilinear form
Gram Matrix:
 1 . . .
 . 1 . .
 . . . 2
 . . 2 .
Witt Index: 1
gap> ps := EllipticQuadric(5,8);
Q-(5, 8)
gap> Display(ps);
Q-(5, 8)
Non-singular elliptic quadratic form
Gram Matrix:
 1 1 . . . .
 . 1 . . . .
 . . . 1 . .
 . . . . . .
 . . . . . 1
 . . . . . .
Witt Index: 2
Bilinear form
Gram Matrix:
 . 1 . . . .
 1 . . . . .
 . . . 1 . .
 . . 1 . . .
 . . . . . 1
 . . . . 1 .
 

8.2-6 CanonicalPolarSpace
> CanonicalPolarSpace( form )( operation )
> CanonicalPolarSpace( P )( operation )

Returns: a classical polar space

the canonical polar space similar to the given polar space P of the classical polar space with underlying form form

8.3 Basic operations finite classical polar spaces

8.3-1 UnderlyingVectorSpace
> UnderlyingVectorSpace( ps )( operation )

Returns: a vector space

Equality of projective spaces? Projective dimension of a projective space and of an element

8.3-2 ProjectiveDimension
> ProjectiveDimension( ps )( operation )
> Dimension( ps )( operation )
> Rank( ps )( operation )

8.3-3 StandardFrame
> StandardFrame( ps )( operation )

8.3-4 Coordinates
> Coordinates( v )( operation )

8.3-5 EquationOfHyperplane
> EquationOfHyperplane( ps )( operation )

8.3-6 BaseField
> BaseField( ps )( operation )

8.3-7 AsList
> AsList( subspaces )( operation )

Returns: an Orb object or list

 

8.3-8 Random
> Random( subspaces )( operation )

8.3-9 RandomSubspace
> RandomSubspace( pg, i )( operation )

8.3-10 VectorSpaceToElement
> VectorSpaceToElement( geo, v )( operation )

Returns: an element

geo is a projective space or a polar space, such as ProjectiveSpace(3,3) or EllipticQuadric(7,5), and v is either a row vector (for points) or an m x n matrix (for an (m-1)-subspace of a geometry of projective dimension n-1). In the case that v is a matrix, the rows represent basis vectors for the subspace. An exceptional case is when v is a zero-vector, whereby the trivial subspace [] is returned (note: by convention, the empty set is the unique subspace of projective dimension -1). When geo is a polar space, it is checked whether v determines a point or an element geo.

gap> ps := ProjectiveSpace(6,7);
ProjectiveSpace(6, 7)
gap> v := [3,5,6,0,3,2,3]*Z(7)^0;
[ Z(7), Z(7)^5, Z(7)^3, 0*Z(7), Z(7), Z(7)^2, Z(7) ]
gap> p := VectorSpaceToElement(ps,v);
<a point in ProjectiveSpace(6, 7)>
gap> Display(p);
[ Z(7), Z(7)^5, Z(7)^3, 0*Z(7), Z(7), Z(7)^2, Z(7) ]
gap> ps := ProjectiveSpace(3,4);
ProjectiveSpace(3, 4)
gap> v := [1,1,0,1]*Z(4)^0;
[ Z(2)^0, Z(2)^0, 0*Z(2), Z(2)^0 ]
gap> p := VectorSpaceToElement(ps,v);
<a point in ProjectiveSpace(3, 4)>
gap> mat := [[1,0,0,1],[0,1,1,0]]*Z(4)^0;
[ [ Z(2)^0, 0*Z(2), 0*Z(2), Z(2)^0 ], [ 0*Z(2), Z(2)^0, Z(2)^0, 0*Z(2) ] ]
gap> line := VectorSpaceToElement(ps,mat);
<a line in ProjectiveSpace(3, 4)>
gap> e := VectorSpaceToElement(ps,[]);
Error, <v> does not represent any vectorspace called from
<function>( <arguments> ) called from read-eval-loop
Entering break read-eval-print loop ...
you can 'quit;' to quit to outer loop, or
you can 'return;' to continue
brk> quit;
 

8.3-11 EmptySubspace
> EmptySubspace( global variable )

Returns: a GAP object

EmptySubspace is a GAP object which represents the ubiquitous trivial subspace of a projective or polar space, and is contained in every projective space.

gap> EmptySubspace;
< trivial subspace >
gap> line := Random(Lines(PG(5,9)));
<a line in ProjectiveSpace(5, 9)>
gap> EmptySubspace * line;
true
gap> EmptySubspace * PG(3,11);
true
 

8.3-12 \in
> \in( v, geo )( operation )

Returns: true or false

v is an element of an incidence structure. It is checked whether v is a subspace of the polar space geo.

gap> ps := ProjectiveSpace(5,9);
ProjectiveSpace(5, 9)
gap> p := Random(Points(ps));
<a point in ProjectiveSpace(5, 9)>
gap> r := Random(Solids(ps));
<a solid in ProjectiveSpace(5, 9)>
gap> IsIncident(p,r);
false
gap> IsIncident(r,p);
false
gap> p*r;
false
gap> r*p;
false
gap> p in r;
false
gap> r in p;
false
gap> EmptySubspace(ps) in r;
true
gap> r in ps;
true
 

8.3-13 Span
> Span( u, v )( operation )

Returns: an element

u and v are elements of a projective or polar space. This function returns the join of the two elements, that is, the span of the two subspaces.

ProjectiveSpace(3, 3)
gap> p := Random(Planes(ps));
<a plane in ProjectiveSpace(3, 3)>
gap> q := Random(Planes(ps));
<a plane in ProjectiveSpace(3, 3)>
gap> s := Span(p,q);
ProjectiveSpace(3, 3)
gap> s = Span([p,q]);
true
gap> t := Span(EmptySubspace(ps),p);
<a plane in ProjectiveSpace(3, 3)>
gap> t = p;
true
gap> Span(ps,p);
ProjectiveSpace(3, 3)
 

8.3-14 Meet
> Meet( u, v )( operation )

Returns: an element

u and v are elements of a projective or polar space. This function returns the meet of the two elements. If two elements do not meet, then Meet returns EmptySubspace, which in FinInG, is an element with projective dimension -1. (Note that the poset of subspaces of a polar space is a meet-semilattice, but not closed under taking spans).

gap> ps := HyperbolicQuadric(5,3);;
gap> pi := Random( Planes(ps) );;
gap> tau := Random( Planes(ps) );;
gap> Meet(pi,tau);
<a point in Q+(5, 3)>

Note: the above example will return different answers depending on the two planes chosen at random.

8.3-15 IsCollinear
> IsCollinear( ps, u, v )( operation )

Returns: Boolean

u and v are elements of the polar space ps. This function returns True if u and v are incident with a common line and False otherwise.

8.3-16 Polarity
> Polarity( ps )( operation )

Returns: a function for the polarity

ps must be a polar space. This operation returns the polarity of the polar space ps in the form of a function. (Put more here when Jan has implemented polarities).

gap> pq := ParabolicQuadric(4,3);
Q(4, 3)
gap> perp := Polarity(pq);
function( v ) ... end
gap> lines := Lines(ps);
<lines of Q(4, 3)>
gap> l:=Random(lines);
<a line in Q(4, 3)>
gap> perp(l);
<a plane in PG(4, 3)>

8.3-17 AmbientSpace
> AmbientSpace( ps )( operation )

Returns: the ambient projective space

ps is a polar space. This function returns the ambient projective spce of ps.

8.3-18 TypeOfSubspace
> TypeOfSubspace( ps, v )( operation )

Returns: a string

This operation is a convenient way to find out the intersection type of a projective subspace with a polar space. The argument ps is a nondegenerate polar space, and the argument v is a subspace of the ambient projective space. The operation returns a string in accordance with the type of subspace: "degenerate", "symplectic", "hermitian", "elliptic", "hyperbolic" or "parabolic".

gap> h1 := HermitianVariety(2, 3^2);
H(2, 3^2)
gap> h2 := HermitianVariety(3, 3^2);
H(3, 3^2)
gap> pg := AmbientSpace( h2 );    
PG(3, 9)
gap> pi := VectorSpaceToElement( pg, [[1,0,0,0],[0,1,0,0],[0,0,1,0]] * Z(9)^0 );
<a plane in PG(3, 9)>
gap> TypeOfSubspace(h2, pi);
"hermitian"
gap> pi := VectorSpaceToElement( pg, [[1,0,0,0],[0,1,0,0],[0,0,1,Z(9)]] * Z(9)^0 );
<a plane in PG(3, 9)>
gap> TypeOfSubspace(h2, pi);
"degenerate"
 

8.4 All the elements or just one at a time

In FinInG, we can either use AsList to get all of the elements of a projective/polar space efficiently, or we can ask for an iterator or enumerator of a collection of elements. The word collection is important here. Subspaces of a vector space are not calculated on calling Subspaces, rather primitive information is stored in an IsComponentObjectRep. So for example

gap> v:=GF(31)^5;
( GF(31)^5 )
gap> subs:=Subspaces(v,1);
Subspaces( ( GF(31)^5 ), 1 )

takes almost no time at all. But if you want a random element from this set, you could be waiting a while. Instead, the user is better off using an iterator or an enumerator to access elements of this collection. So too do we have such a facility for the elements of a projective or polar space. At the moment, we have made available iterators for projective spaces, and enumerators for polar spaces.

8.4-1 Enumerators for polar spaces

If you are not familiar with ``enumerators'' in GAP, it is worthy to explain a little bit about them in this section. An enumerator is a particular object in GAP which allows the user to compute the i-th entry in a collection. Mathematically speaking, it is a bijection from the positive integers to the given collection. So for example, the rationals are totally ordered and there is an enumerator in GAP so that the user can access rational numbers one at a time:

gap> enum:=Enumerator(Rationals);
<enumerator of Rationals>
gap> enum[10];
3/2

For more on enumerators, see the relevant section in the GAP manual.

8.4-2 Enumerator
> Enumerator( elements )( operation )

Returns: an enumerator

elements is a collection of elements, such as Points( ParabolicQuadric( 4, 3 )). This function returns an enumerator for elements.

gap> lines := Lines( ParabolicQuadric(6, 3) );
<lines of Q(6, 3)>
gap> enum := Enumerator( lines );
EnumeratorOfSubspacesOfClassicalPolarSpace( <lines of Q(6, 3)> )
gap> enum[10];
<a line in Q(6, 3)>

8.4-3 Iterators for projective spaces

An iterator is a particular object in GAP which allows the user to compute the next entry in a collection. So iterators are a way to loop over the elements of a (countable) collection or a list, without repetition. The most important operations for the user are NextIterator and IsDoneIterator. We show an example of how this works with the rationals.

gap> iter := Iterator( Rationals );                                   
<iterator>
gap> x := NextIterator( iter );
0
gap> x := NextIterator( iter );
1
gap> x := NextIterator( iter );
-1
gap> x := NextIterator( iter );
1/2
gap> x := NextIterator( iter );
2
gap> IsDoneIterator( iter );
false

For more on iterators, see the relevant section in the GAP manual.

8.4-4 Iterator
> Iterator( elements )( operation )

Returns: an iterator

elements is a collection of elements, such as Points( ProjectiveSpace( 4, 3 )). This function returns an iterator for elements.

gap> lines := Lines( ProjectiveSpace(6, 3) );
<lines of PG(6, 3)>
gap> iter := Iterator(lines);
<iterator>
gap> x := NextIterator( iter );
<a line in PG(6, 3)>
gap> x := NextIterator( iter );
<a line in PG(6, 3)>
gap> Display( x );
 1 . . . . . .
 . 1 . . . . 1
gap> IsDoneIterator( iter );
false
 Top of Book   Previous Chapter   Next Chapter 
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 Bib Ind

generated by GAPDoc2HTML