GAP (FinInG) - Chapter 4: Incidence Geometry

We follow [BC13] for the definitions of incidence structure and incidence geometry. An incidence structure consists of a set of elements, a symmetric relation on the elements and a type function from the set of elements to an index set (i.e., every element has a ``type''). It satisfies the following axiom: (i) no two elements of the same type are incident. An incidence structure without type function is in fact a multipartite graph where the adjacency is the incidence (so with a loop in each vertex). The term geometry, or incidence geometry, is interpreted braodly in this package. Particularly, an incidence geometry is an incidence structure satisfying the following axiom: (ii)every maximal flag contains an element of each type. In graph terminology, this means that every maximal clique contains an element of each type. Thus, a projective 5-space is an incidence geometry with five types of elements: points, lines, planes, solids, and hyperplanes. A finite classical polar space of rank 3 is an incidence geometry with three types of elements: points, lines, and planes. Depending on the viewpoint, the Grassman variety of the lines of a projective 4-space, is an incidence structure that is not an incidence geometry.

FinInG concerns itself primarily with the most commonly studied incidence geometries of rank at least 2: projective spaces, polar spaces, and affine spaces. Throughout, no matter the geometry, we have made the convention that an element of type 1 is a ``point'', an element of type 2 is a ``line'', and so forth. The examples we use in this section use projective spaces, which have not yet been introduced to the reader in this manual. For further information on projective spaces, see Chapter 5.

In this chapter we describe functionality that is declared for incidence structures, which does not imply that operations described here will work for arbitrarily user constructed incidence structures. Its aim is furthermore to allow the user to become a bit familiar with the general philosophy of the package, using examples that are self-explanatory. Not all details of the commands used in the examples will be explained in this chapter, therefore we refer to the relevant chapter of the commands. These can easily be found using the index.

4.1 Incidence structures

Incidence structures can be more general than incidence geometries, e.g. if they do not satisfy axiom (ii) mentioned above. We allow the construction of such objects. This explains one of the top level categories in FinInG.

4.1-1 IsIncidenceStructure

In the following example we define an incidence structure that is not an incidence geometry. The example used is the incidence structure with elements the subspaces contained in the line Grassmannian of PG(4,2). This example is not meant to create this incidence structure in an efficient way, but just to demonstrate the general philiosophy.

4.1-2 IncidenceStructure

eles is a set containing the elements of the incidence structure. inc_rel must be a function that determines if two objects in the set eles are incident. type is a function mapping any element to its type, which is a unique element in the set typeset.

gap> pg := PG(4,2);
ProjectiveSpace(4, 2)
gap> pg2 := PG(9,2);
ProjectiveSpace(9, 2)
gap> points := List(Lines(pg),x->VectorSpaceToElement(pg2,GrassmannCoordinates(x)));;
gap> flags := Concatenation(List(Points(pg),x->List(Planes(x),y->FlagOfIncidenceStructure(pg,[x,y]))));;
gap> prelines := List(flags,flag->ShadowOfFlag(pg,flag,2));;
gap> lines := List(prelines,x->VectorSpaceToElement(pg2,List(x,y->GrassmannCoordinates(y))));;
gap> flags2 := Concatenation(List(Points(pg),x->List(Solids(x),y->FlagOfIncidenceStructure(pg,[x,y]))));;
gap> preplanes := List(flags2,flag->ShadowOfFlag(pg,flag,2));;
gap> planes := List(preplanes,x->VectorSpaceToElement(pg2,List(x,y->GrassmannCoordinates(y))));;
gap> maximals1 := List(Planes(pg),x->VectorSpaceToElement(pg2,List(Lines(x),y->GrassmannCoordinates(y))));;
gap> maximals2 := List(Points(pg),x->VectorSpaceToElement(pg2,List(Lines(x),y->GrassmannCoordinates(y))));;
gap> elements := Union(points,lines,planes,maximals1,maximals2);;
gap> Length(elements);
1891
gap> type := x -> ProjectiveDimension(x)+1;
function( x ) ... end
gap> inc_rel := \*;
<Operation "*">
gap> inc := IncidenceStructure(elements,inc_rel,type,[1,2,3,4]);
Incidence structure of rank 4

4.1-3 IsIncidenceGeometry

Lie Geometries, i.e. geometries with a projective space as ambient space, affine spaces and generalised polygons have their category, as a subcategory of IsIncidenceGeometry.

4.1-4 Main categories in IsIncidenceGeometry

4.1-5 Main categories in IsLieGeometry

Lie geometries bundle projective spaces and classical polar spaces. In the future, more subcategories could be added since the term ``Lie geometry'' refers to a geometry whose automorphism group lies in some group of Lie type. Both classes of geometries have their category, as a subcategory of IsLieGeometry.

4.1-6 Categories in IsGeneralisedPolygon

Within IsGeneralisedPolygon, categories are declared for generalised quadrangles, generalised hexagons, and generalised octogons.

4.1-7 IsElationGQ

Within IsGeneralisedQuadrangle, this category is declared to construct elation generalised quadrangles.

4.1-8 IsClassicalGQ

4.1-9 Examples of categories of incidence geometries

gap> CategoriesOfObject(ProjectiveSpace(5,7));
[ "IsIncidenceStructure", "IsIncidenceGeometry", "IsLieGeometry", 
  "IsProjectiveSpace" ]
gap> CategoriesOfObject(HermitianPolarSpace(5,9));
[ "IsIncidenceStructure", "IsIncidenceGeometry", "IsLieGeometry", 
  "IsClassicalPolarSpace", "IsAlgebraicVariety", "IsProjectiveVariety", 
  "IsHermitianVariety" ]
gap> CategoriesOfObject(AffineSpace(3,3));
[ "IsIncidenceStructure", "IsIncidenceGeometry", "IsAffineSpace" ]
gap> CategoriesOfObject(SymplecticSpace(3,11));
[ "IsIncidenceStructure", "IsIncidenceGeometry", "IsLieGeometry", 
  "IsClassicalPolarSpace", "IsGeneralisedPolygon", "IsGeneralisedQuadrangle", 
  "IsClassicalGQ" ]
gap> CategoriesOfObject(SplitCayleyHexagon(9));
[ "IsIncidenceStructure", "IsIncidenceGeometry", "IsLieGeometry", 
  "IsGeneralisedPolygon", "IsGeneralisedHexagon" ]
gap> CategoriesOfObject(ParabolicQuadric(4,16));
[ "IsIncidenceStructure", "IsIncidenceGeometry", "IsLieGeometry", 
  "IsClassicalPolarSpace", "IsGeneralisedPolygon", "IsGeneralisedQuadrangle", 
  "IsClassicalGQ", "IsAlgebraicVariety", "IsProjectiveVariety" ]

4.1-10 TypesOfElementsOfIncidenceStructure

Both attributes are declared for objects in the category IsIncidenceStructure, but only methods are installed for the geometries that are built in FinInG. Any incidence structure contains a set of types. This set is usually just the list [1..n]. If specific names are given to each type, this attribute returns the names for the particular incidence structure inc. The second variant returns the list of plurals of these names. If no specific names are known, the list [1..n] is returned, where n equals the rank of the incidence structure.

gap> TypesOfElementsOfIncidenceStructure(ProjectiveSpace(5,4));
[ "point", "line", "plane", "solid", "proj. 4-space" ]
gap> TypesOfElementsOfIncidenceStructurePlural(AffineSpace(7,4));
[ "points", "lines", "planes", "solids", "affine. subspaces of dim. 4", 
  "affine. subspaces of dim. 5", "affine. subspaces of dim. 6" ]

4.1-11 Rank

Returns: rank of inc, an object which must belong to the categorie IsIncidenceStructure

The operation Rank returns the rank of the incidence structure inc. The highest level method for Rank, applicable to objects in IsIncidenceStructure simply refers to the attribute RankAttr. In FinInG, the rank of an incidence structure is determined upon creation, when also RankAttr is set.

gap> Rank(ProjectiveSpace(5,5));
5
gap> Rank(AffineSpace(3,5));
3
gap> Rank(SymplecticSpace(5,5));
3

4.2 Elements of incidence structures

4.2-1 Main categories for individual elements of incidence structures

In general a category IsElementOfIncStr is declared for the individual elements of an incidence structure in the category IsIncStr, except for projective spaces and classical polar spaces. The inclusion for different categories of geometries is followed for their elements, with an exception for IsSubspaceOfClassicalPolarSpace, which is a subcategory of IsSubspaceOfProjectiveSpace, while IsClassicalPolarSpace is not a subcategory of IsProjectiveSpace.

gap> Random(Lines(SplitCayleyHexagon(3)));
#I  for Split Cayley Hexagon
#I  Computing nice monomorphism...
#I  Found permutation domain…
<a line of Split Cayley Hexagon of order 3>
gap> CategoriesOfObject(last);
[ "IsElementOfIncidenceStructure", "IsElementOfIncidenceGeometry", 
  "IsElementOfLieGeometry", "IsSubspaceOfProjectiveSpace", 
  "IsSubspaceOfClassicalPolarSpace", "IsElementOfGeneralisedPolygon" ]
gap> Random(Solids(AffineSpace(7,17)));
<a solid in AG(7, 17)>
gap> CategoriesOfObject(last);
[ "IsElementOfIncidenceStructure", "IsElementOfIncidenceGeometry", 
  "IsSubspaceOfAffineSpace" ]

4.2-2 Main categories for collections of elements of incidence structures

In general, a category IsElementsOfIncStr is declared for objects representing a set of elements of an incidence structure in the category IsIncStr, with an exception for projective spaces and polar spaces. The inclusion for different categories of geometries is followed for their collection of elements, except for IsSubspaceOfClassicalPolarSpace, which is a subcategory of IsSubspaceOfProjectiveSpace, while IsClassicalPolarSpace is not a subcategory of IsProjectiveSpace.

The object representing the set of elements of a given type can be computed using the general operation ElementsOfIncidenceStructure, of course assuming that a method is installed for the particular incidence structure.

4.2-3 ElementsOfIncidenceStructure

inc must be an incidence structure, j must be a type of element of inc. This function returns all elements of inc of type j, and an error is displayed if inc has no elements of type j. Calling the elements (of a given type) of inc yields an object in the category IsElementsOfIncidenceStructure (or the appropriate category for projective spaces and classical polar spaces), which does not imply that all elements are computed and stored. In an alternative form of this function str can be one of ``points", ``lines", ``planes" or ``solids" and the function returns the elements of type 1, 2, 3 or 4 respectively, of course if inc has elements of the deduced type. When no type is specified all elements of inc are returned.

gap> ps := ProjectiveSpace(3,3);
ProjectiveSpace(3, 3)
gap> l := ElementsOfIncidenceStructure(ps,2);
<lines of ProjectiveSpace(3, 3)>
gap> ps := EllipticQuadric(5,9);
Q-(5, 9)
gap> lines := ElementsOfIncidenceStructure(ps,2);
<lines of Q-(5, 9)>
gap> planes := ElementsOfIncidenceStructure(ps,3);
Error, <geo> has no elements of type <j> called from
<function "unknown">( <arguments> )
 called from read-eval loop at line 12 of *stdin*
you can 'quit;' to quit to outer loop, or
you can 'return;' to continue
brk> quit;
gap> as := AffineSpace(3,9);
AG(3, 9)
gap> lines := ElementsOfIncidenceStructure(as,"lines");
<lines of AG(3, 9)>

4.2-4 Short names for ElementsOfIncidenceStructure

It is possible that inc is an incidence structure where the elements of type 1, 2, 3, and 4 are not called "points", "lines", "planes", and "solids", respectively. The methods don't check if names are given, and are just shortcuts to the operation ElementsOfIncidenceStructure.

gap> Points(HermitianVariety(2,64));
<points of Hermitian Variety in ProjectiveSpace(2, 64)>
gap> Lines(EllipticQuadric(5,2));
<lines of Q-(5, 2)>
gap> Planes(SymplecticSpace(7,3));
<planes of W(7, 3)>

4.2-5 NrElementsOfIncidenceStructure

inc must be an incidence structure, j must be a type of element of inc. This function returns the number of elements of inc of type j, and an error is displayed if inc has no elements of type j. In the alternative form of this function str can be one of ``points", ``lines", ``planes" or ``solids" and the function returns the number of elements of type 1, 2, 3 or 4 respectively, of course if inc has elements of the deduced type.

gap> ps:=ProjectiveSpace(4,3);
ProjectiveSpace(4, 3)
gap> NrElementsOfIncidenceStructure(ps, 2);
1210
gap> NrElementsOfIncidenceStructure(ps, "points");
121

4.2-6 IsIncident

u and v must be elements of an incidence structure. This function returns true if and only if u is incident with v. Recall that IsIncident is a symmetric relation, while in is not. A method for the operation \* is installed, applicable to objects in IsElementOfIncidenceStructure. It just calls IsIncident.

gap> ps := ProjectiveSpace(4,7);
ProjectiveSpace(4, 7)
gap> p := VectorSpaceToElement(ps,[1,0,1,0,1]*Z(7)^0);
<a point in ProjectiveSpace(4, 7)>
gap> l := VectorSpaceToElement(ps,[[0,0,1,0,0],[1,0,0,0,1]]*Z(7)^0);
<a line in ProjectiveSpace(4, 7)>
gap> pl := VectorSpaceToElement(ps,[[1,1,1,0,0],[0,1,0,0,0],
>                                [0,-1,0,0,1]]*Z(7)^0);
<a plane in ProjectiveSpace(4, 7)>
gap> p in l;
true
gap> l in pl;
false
gap> p in pl;
true
gap> IsIncident(p,l);
true
gap> IsIncident(l,p);
true
gap> IsIncident(pl,p);
true
gap> pl in p;
false

4.2-7 Random

C is a collection of elements of an incidence structure, i.e. an object in the category IsElementsOfIncidenceStructure. Random(C) will return a random element in C provided there is a method installed. Our methods may refer to methods for random selection of e.g. subspaces of the underlying vector space, as in the example here, or refer to the use of a psuedo random element of an appropriate group, as is the case for subspaces of classical polar spaces.

gap> Random(Hyperplanes(PG(5,7)));
<a proj. 4-space in ProjectiveSpace(5, 7)>

4.2-8 AmbientGeometry

If v is an element of an incidence geometry currently implemented in FinInG, then this operation returns the ambient geometry of v, i.e. in general the geometry in which v was created. If an incidence structure is created with elements that are a subset of elements of another incidence structure, the ambient geometry might stay unchanged.

gap> plane := Random(Planes(HyperbolicQuadric(5,2)));
<a plane in Q+(5, 2)>
gap> AmbientGeometry(plane);
Q+(5, 2)
gap> l := Random(Lines(SplitCayleyHexagon(3)));
#I  for Split Cayley Hexagon
#I  Computing nice monomorphism...
#I  Found permutation domain…
<a line of Split Cayley Hexagon of order 3>
gap> Print(l);
[ [ Z(3)^0, 0*Z(3), 0*Z(3), Z(3), Z(3)^0, Z(3)^0, Z(3) ], 
  [ 0*Z(3), 0*Z(3), Z(3)^0, Z(3)^0, Z(3), 0*Z(3), Z(3)^0 ] ]
gap> AmbientGeometry(l);
Split Cayley Hexagon of order 3
gap> p := Random(Points(EGQByBLTSet(BLTSetByqClan(LinearqClan(3)))));
#I  No intertwiner computed. One of the polar spaces must have a collineation group computed
#I  Now embedding dual BLT-set into W(5,q)...
#I  Computing points(1) of Knarr construction...
#I  Computing lines(1) of Knarr construction...
#I  Computing points(2) of Knarr construction...
#I  Computing lines(2) of Knarr construction...please wait
#I  Computing elation group...
<a point of <EGQ of order [ 9, 3 ] and basepoint 
[ Z(3)^0, 0*Z(3), 0*Z(3), 0*Z(3), 0*Z(3), 0*Z(3) ]>>
gap> Print(p);
[ 0*Z(3), Z(3)^0, 0*Z(3), Z(3)^0, Z(3), 0*Z(3) ]
gap> AmbientGeometry(p);
<EGQ of order [ 9, 3 ] and basepoint [ Z(3)^0, 0*Z(3), 0*Z(3), 0*Z(3), 0*Z(3),
  0*Z(3) ]>

4.3 Flags of incidence structures

A flag of an incidence structure S is a set F of elements of S that are two by two incident. This implies that all elements in F have a different type. A flag is maximal if it cannot be extended with more elements. FinInG provides a basic category IsFlagOfIncidenceStructure. For different types of incidence structures, methods to create a flag can be installed. A chamber is a flag of size n, where n is the rank of the incidence structure. Recall that an incidence structure is an incidence geometry if every maximal flag is a chamber.

4.3-1 FlagOfIcidenceStructure

It is checked if all elements in l are incident and belong to the same incidence structure. An empty list is allowed.

gap> ps := PG(3,7);
ProjectiveSpace(3, 7)
gap> point := VectorSpaceToElement(ps,[1,2,0,0]*Z(7)^0);
<a point in ProjectiveSpace(3, 7)>
gap> line := VectorSpaceToElement(ps,[[1,0,0,0],[0,1,0,0]]*Z(7)^0);
<a line in ProjectiveSpace(3, 7)>
gap> plane := VectorSpaceToElement(ps,[[1,0,0,0],[0,1,0,0],[0,0,0,1]]*Z(7)^0);
<a plane in ProjectiveSpace(3, 7)>
gap> flag := FlagOfIncidenceStructure(ps,[point,line,plane]);
<a flag of ProjectiveSpace(3, 7)>

4.3-2 IsChamberOfIncidenceStructure

gap> ps := PG(3,7);
ProjectiveSpace(3, 7)
gap> point := VectorSpaceToElement(ps,[1,2,0,0]*Z(7)^0);
<a point in ProjectiveSpace(3, 7)>
gap> line := VectorSpaceToElement(ps,[[1,0,0,0],[0,1,0,0]]*Z(7)^0);
<a line in ProjectiveSpace(3, 7)>
gap> plane := VectorSpaceToElement(ps,[[1,0,0,0],[0,1,0,0],[0,0,0,1]]*Z(7)^0);
<a plane in ProjectiveSpace(3, 7)>
gap> flag1 := FlagOfIncidenceStructure(ps,[point,plane]);
<a flag of ProjectiveSpace(3, 7)>
gap> IsChamberOfIncidenceStructure(flag1);
false
gap> flag2 := FlagOfIncidenceStructure(ps,[point,line,plane]);
<a flag of ProjectiveSpace(3, 7)>
gap> IsChamberOfIncidenceStructure(flag2);
true

4.4 Shadow of elements

4.4-1 ShadowOfElement

inc is an incidence structure, v must be an element of inc, str must be a string which is the plural of the name of one of the types of the elements of inc. For the second variant, j is an integer representing one of the types of the elements of inc. This first variant relies on TypesOfElementsOfIncidenceStructurePlural and on a particular method installed for the second variant for particular incidence structures. The use of the argument inc makes it flexible, i.e. if the element v can belong to different incidence structures, its shadow can be different, as the second example shows.

gap> ps := ProjectiveSpace(3,3);
ProjectiveSpace(3, 3)
gap> pi := Random(Planes(ps));
<a plane in ProjectiveSpace(3, 3)>
gap> lines := ShadowOfElement(ps,pi,"lines");
<shadow lines in ProjectiveSpace(3, 3)>
gap> Size(lines);
13

gap> p := Random(Points(PG(3,3)));
<a point in ProjectiveSpace(3, 3)>
gap> lines1 := ShadowOfElement(SymplecticSpace(3,3),p,2);
<shadow lines in W(3, 3)>
gap> Size(lines1);
4
gap> lines2 := ShadowOfElement(PG(3,3),p,2); 
<shadow lines in ProjectiveSpace(3, 3)>
gap> Size(lines2);
13

4.4-2 ShadowOfFlag

Returns: The collection of elements of type str or type j incident with the elements of flag, or with the elements of list

Variants 2 and 4 convert list to a flag of inc, using FlagOfIcidenceStructure, which performs the necessary checks. Variants 1 and 2 rely on variants 3 and 4 respectively, for which a method must be installed for the particular incidence structure inc.

gap> ps := PG(3,7);
ProjectiveSpace(3, 7)
gap> point := VectorSpaceToElement(ps,[1,2,0,0]*Z(7)^0);
<a point in ProjectiveSpace(3, 7)>
gap> plane := VectorSpaceToElement(ps,[[1,0,0,0],[0,1,0,0],[0,0,0,1]]*Z(7)^0);
<a plane in ProjectiveSpace(3, 7)>
gap> flag := FlagOfIncidenceStructure(ps,[point,plane]);
<a flag of ProjectiveSpace(3, 7)>
gap> lines := ShadowOfFlag(ps,flag,"lines");
<shadow lines in ProjectiveSpace(3, 7)>

4.4-3 ElementsIncidentWithElementOfIncidenceStructure

This operation is declared for objects v belonging to IsElementOfIncidenceStructure, but relies on particular methods installed for particular incidence structures, and refers always to ShadowOfElement, where the ambient geometry is derived from the element v, and using the integer j.

4.4-4 Short names for ElementsIncidentWithElementOfIncidenceStructure

Returns: The collections of elements of inc of respective type 1, 2, 3 and 4, that are incident with v

It is possible that inc is an incidence structure where the elements of type 1, 2, 3 and 4 respectively are not called "points", "lines", "planes", and "solids" respectively. The methods don't check whether names are given, and are just shortcuts to the operation ShadowOfElement. The second variant derives the incidence structure to be used as the ambient geometry of v. Please keep in mind that these methods are shortcuts to ShadowOfElement, which implies that asking e.g. Lines(v) with v a point, will indeed return the lines incident with a point.

gap> line := Random(Lines(AG(5,4)));
<a line in AG(5, 4)>
gap> Points(line);
<shadow points in AG(5, 4)>
gap> Planes(line);
<shadow planes in AG(5, 4)>

4.5 Enumerating elements of an incidence structure

In several situations, it can be usful to compute a complete list of objects statisfying one or more conditions. To list all elements of a given type of an incidence structure, is a typical example. FinInG provides functionality that is common in GAP for this purpose. 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. 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. We give basic examples of enumerators and iterators here. For AsList, we refer to the appropriate sections in the chapters on the particular geometries, since methods for AsList always refer to the group, and make use of the package orb. An iterator is a GAP object that gives a user friendly way to loop over all elements without repetition. Only three operations are applicable on an iterator: NextIterator, IsDoneIterator and ShallowCopy.

4.5-1 Iterator

C is a collection of elements of an incidence structure. An iterator is returned.

gap> ps := PG(3,7);
ProjectiveSpace(3, 7)
gap> planes := Planes(ps);
<planes of ProjectiveSpace(3, 7)>
gap> iter := Iterator(planes);
<iterator>
gap> NextIterator(iter);
<a plane in ProjectiveSpace(3, 7)>
gap> IsDoneIterator(iter);
false

For a collection of elements of a given type of certain incidence structures, FinInG also provides methods to compute an enumerator. In its simpliest form, an enumerator is just a list containing all the elements of the collection. Given any object in the list, it is possible to retrieve its number in the list (which is then just its position). Also, given any number between 1 and the length of the list, it is possible to get the corresponding element. For some collections of elements of particular incidence structures, a more advanced version of enumerators is implemented. Such an advanced version is an object containing the two functions ElementNumber and NumberElement. Such functions are able to compute directly, without listing all elements, the element with a given number, or, conversely, compute directly the number of a given element. Clearly, using an enumerator, it is possible to obtain a list containing all elements of a collection.

4.5-2 Enumerator

C is a collection of elements of an incidence structure. An enumerator is returned.

gap> enum := Enumerator(Lines(ParabolicQuadric(6,2)));
EnumeratorOfSubspacesOfClassicalPolarSpace( <lines of Q(6, 2)> )
gap> s := Size(enum);
315
gap> n := Random([1..s]);
284
gap> l := enum!.ElementNumber(s,n);
<a line in Q(6, 2)>
gap> enum!.NumberElement(s,l);
278

4.6 Lie geometries

The category IsLieGeometry contains the categories IsProjectiveSpace and IsClassicalPolarSpace, and is bundling projective spaces and classical polar spaces. One common fact of these geometries is that their elements are represented by subspaces of a vector space. In these geometries, incidence is symmetrized set-theoretic containment. In this section we describe methods that are declared in a generic way for (elements of) Lie geometries. Again, having a declaration does not imply that methods are installed for all particular Lie geometries.

4.6-1 AmbientSpace

gap> AmbientSpace(PG(3,4));
ProjectiveSpace(3, 4)
gap> AmbientSpace(ParabolicQuadric(4,4));
ProjectiveSpace(4, 4)
gap> AmbientSpace(SplitCayleyHexagon(3));
ProjectiveSpace(6, 3)

4.6-2 UnderlyingVectorSpace

gap> UnderlyingVectorSpace(PG(5,4));
( GF(2^2)^6 )
gap> UnderlyingVectorSpace(HermitianPolarSpace(4,4));
( GF(2^2)^5 )

4.6-3 ProjectiveDimension

gap> ProjectiveDimension(PG(7,7));
7
gap> ProjectiveDimension(EllipticQuadric(5,2));
5

Mathematically, it makes sense to implement an object representing the empty subspace, since this is typically obtained as a result of a Meet operation, which computes the intersection of two or more elements. On the other hand, we do not consider the empty subspace as an element of the incidence geometry. Hence, using the empty subspace as an argument of IsIncident (and consequently of \*), will result in a ``no method found'' error.

4.6-4 IsEmptySubspace

Category for objects representing the empty subspace of a particular Lie geometry. Empty subspaces of different geometries will be different objects, and have a different ambient geometry.

4.7 Elements of Lie geometries

Elements of a Lie geometry are constructed using a list of vectors. The methods installed for the particular Lie geometries check whether the subspace of the vector space represents an element of the Lie geometry.

4.7-1 VectorSpaceToElement

Returns: the element of ig, represented by the subspace spanned by v or l, or returns the empty subspace.

The first variant of this operation takes as second argument a vector of the underlying vector space of ig. Such a vector possibly represents a point of ig. The second variant takes as second argument a list of vectors in the underlying vector space of ig. Such a list represents a subspace of the vector space. If the dimension of the subspace generated by l is larger than zero and strictly less than the dimension of the vector space, it is checked if the subspace represents an element of ig, except when ig is a projective space. If l is a list of vectors generating the whole vector space, then ig is returned if and only if ig is a projective space, otherwise an error is produced. An empty list is not allowed as second argument.

gap> v := [1,1,1,0,0,0]*Z(7)^0;
[ Z(7)^0, Z(7)^0, Z(7)^0, 0*Z(7), 0*Z(7), 0*Z(7) ]
gap> w := [0,0,0,1,1,1]*Z(7)^0;
[ 0*Z(7), 0*Z(7), 0*Z(7), Z(7)^0, Z(7)^0, Z(7)^0 ]
gap> VectorSpaceToElement(PG(5,7),v);
<a point in ProjectiveSpace(5, 7)>
gap> VectorSpaceToElement(PG(5,7),[v,w]);
<a line in ProjectiveSpace(5, 7)>
gap> VectorSpaceToElement(SymplecticSpace(5,7),v);
<a point in W(5, 7)>
gap> VectorSpaceToElement(SymplecticSpace(5,7),[v,w]);
Error, <x> does not generate an element of <geom> called from
<function "unknown">( <arguments> )
 called from read-eval loop at line 13 of *stdin*
you can 'quit;' to quit to outer loop, or
you can 'return;' to continue
brk> quit;
gap> VectorSpaceToElement(HyperbolicQuadric(5,7),v);
Error, <v> does not generate an element of <geom> called from
<function "unknown">( <arguments> )
 called from read-eval loop at line 13 of *stdin*
you can 'quit;' to quit to outer loop, or
you can 'return;' to continue
brk> quit;
gap> VectorSpaceToElement(HyperbolicQuadric(5,7),0*v);
< empty subspace >

4.7-2 ElementToVectorSpace

The argument v must be an element, so it is not allowed that v is the empty subspace, or just a projective space.

gap> l := Random(Lines(PG(4,3)));
<a line in ProjectiveSpace(4, 3)>
gap> ElementToVectorSpace(l);
[ [ Z(3)^0, Z(3), 0*Z(3), 0*Z(3), Z(3) ], 
  [ 0*Z(3), 0*Z(3), Z(3)^0, Z(3)^0, 0*Z(3) ] ]

4.7-3 \in

Returns: true if and only if the element u is set-theoretically contained in the element w

Both arguments must be elements of the same Lie geometry. The empty subspace and a Lie geometry are also allowed as arguments. This relation is not symmetric, and the methods for IsIncident use this method to test incidence between elements.

gap> p := VectorSpaceToElement(PG(3,3),[1,0,0,0]*Z(3)^0);
<a point in ProjectiveSpace(3, 3)>
gap> l := VectorSpaceToElement(PG(3,3),[[1,0,0,0],[0,1,0,0]]*Z(3)^0);
<a line in ProjectiveSpace(3, 3)>
gap> p in l;
true
gap> p in p;
true
gap> l in p;
false
gap> l in PG(3,3);
true

4.7-4 More short names for ElementsIncidentWithElementOfIncidenceStructure

Returns: the elements of type j-1 incident with v, which is an element of type j

This operation is a shortcut to the operation ShadowOfElement, where the geometry is taken from v, and where the elements of type one less than the type of v are asked. v is allowed to be a complete projective space here, yielding the hyperplanes of that space.

gap> pg := PG(3,7);
ProjectiveSpace(3, 7)
gap> hyp := Random(Hyperplanes(pg));
<a plane in ProjectiveSpace(3, 7)>
gap> h1 := Random(Hyperplanes(hyp));
<a line in ProjectiveSpace(3, 7)>
gap> h2 := Random(Hyperplanes(h1));
<a point in ProjectiveSpace(3, 7)>
gap> ps := SymplecticSpace(7,3);
W(7, 3)
gap> solid := Random(Solids(ps));
<a solid in W(7, 3)>
gap> plane := Random(Hyperplanes(solid));
<a plane in W(7, 3)>

4.8 Hard wired embeddings and converting elements

A Lie geometry, i.e. an object in the category IsLieGeometry, is naturally embedded in a projective space. This is of course in a mathematical sense. In FinInG, certain embeddings are implemented by providing a mapping between geometries. The Lie geometries are hard wired embedded, just simply because a category containing elements of a Lie geometry, is always a subcategory of IsSubspaceOfProjectiveSpace. As a consequence, operations applicable to objects in the category IsSubspaceOfProjectiveSpace are by default applicable to objects in any subcategory, so to elements of any Lie geometry. When dealing with elements of e.g. different polar spaces in the same projective space, this yields a natural way of working with them, and investigating relations between them, without bothering about all necessary mappings. On the other hand, in some situations, it is impossible to decide in which geometry an element has to be considered. An easy example is the following. Consider two different quadrics in the same projective space. The intersection of two elements, one of each quadric, is clearly an element of the ambient projective space. But also of both quadrics. Without extra input of the user, the system cannot decide in which geometry to construct the intersection. To avoid complicated methods with many arguments, in such situations, the resulting element will be constructed in the common ambient projective space. Only in clear situations, where the ambient geometry of all elements is the same, and equal to the geometry of the resulting element, the resulting element will be constructed in this common geometry. We provide however conversion operations for elements of Lie gometries.

4.8-1 ElementToElement

Let ps be any Lie geometry. This method returns VectorSpaceToElement(ps,ElementToVectorSpace(el)), if the conversion is possible. Embed is declared as a synonym of ElementToElement.

gap> p := VectorSpaceToElement(PG(3,7),[0,1,0,0]*Z(7)^0);
<a point in ProjectiveSpace(3, 7)>
gap> q := ElementToElement(HyperbolicQuadric(3,7),p);
<a point in Q+(3, 7)>
gap> r := VectorSpaceToElement(PG(3,7),[1,1,0,0]*Z(7)^0);
<a point in ProjectiveSpace(3, 7)>
gap> ElementToElement(HyperbolicQuadric(3,7),r);
Error, <v> does not generate an element of <geom> called from
VectorSpaceToElement( ps, ElementToVectorSpace( el ) ) called from
<function "unknown">( <arguments> )
 called from read-eval loop at line 11 of *stdin*
you can 'quit;' to quit to outer loop, or
you can 'return;' to continue
brk> quit;

4 Incidence Geometry