In this chapter we describe how to use FinInG to work with finite classical 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.
> 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 |
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.
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 |
> 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 |
> 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 |
> 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 . |
> 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 . |
> 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 . |
> 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
> UnderlyingVectorSpace ( ps ) | ( operation ) |
Returns: a vector space
Equality of projective spaces? Projective dimension of a projective space and of an element
> ProjectiveDimension ( ps ) | ( operation ) |
> Dimension ( ps ) | ( operation ) |
> Rank ( ps ) | ( operation ) |
> StandardFrame ( ps ) | ( operation ) |
> Coordinates ( v ) | ( operation ) |
> EquationOfHyperplane ( ps ) | ( operation ) |
> BaseField ( ps ) | ( operation ) |
> AsList ( subspaces ) | ( operation ) |
Returns: an Orb object or list
> Random ( subspaces ) | ( operation ) |
> RandomSubspace ( pg, i ) | ( operation ) |
> 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; |
> 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 |
> \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 |
> 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) |
> 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.
> 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.
> 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)> |
> AmbientSpace ( ps ) | ( operation ) |
Returns: the ambient projective space
ps is a polar space. This function returns the ambient projective spce of ps.
> 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" |
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.
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.
> 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)> |
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.
> 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 |
generated by GAPDoc2HTML