GAP (FinInG) - Chapter 10: Geometry Morphisms

Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C Bib Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax on]

10 Geometry Morphisms
10.1 Geometry morphisms in FinInG
10.1-1 IsGeometryMorphism
10.1-2 Intertwiner
10.2 Type preserving bijective geometry morphisms
10.2-1 IsomorphismPolarSpaces
10.3 Klein correspondence and derived dualities
10.3-1 PluckerCoordinates
10.3-2 KleinCorrespondence
10.3-3 KleinCorrespondence
10.3-4 KleinCorrespondenceExtended
10.3-5 NaturalDuality
10.3-6 SelfDuality
10.4 Embeddings of projective spaces
10.4-1 NaturalEmbeddingBySubspace
10.4-2 NaturalEmbeddingBySubField
10.4-3 Embedding of projective spaces by field reduction
10.4-4 BlownUpSubspaceOfProjectiveSpace
10.4-5 NaturalEmbeddingByFieldReduction
10.5 Embeddings of polar spaces
10.5-1 NaturalEmbeddingBySubspace
10.5-2 NaturalEmbeddingBySubField
10.5-3 Embedding of polar spaces by field reduction
10.5-4 NaturalEmbeddingByFieldReduction
10.5-5 NaturalEmbeddingByFieldReduction
10.6 Projections
10.6-1 NaturalProjectionBySubspace
10.7 Projective completion
10.7-1 ProjectiveCompletion

### 10 Geometry Morphisms

Here we describe what is meant by a geometry morphism in FinInG and the various operations and tools available to the user. When using groups in GAP, we often use homomorphisms to pass from one situation to another, even though mathematically it may appear to be unnecessary, there can be ambiguities if the functionality is too flexible. This also applies to finite geometry. Take for example the usual exercise of thinking of a hyperplane in a projective space as another projective space. To conform with similar situations in GAP, the right thing to do is to embed one projective space into another, rather than having one projective space automatically as a substructure of another. The reason for this is that there are many ways one can do this embedding, even though we may dispense with this choice when we are working mathematically. So to avoid ambiguity, we stipulate that one should construct the embedding explicitly. How this is done will be described this chapter.

Suppose that S and S' are two incidence geometries. A geometry morphism from S to S' is defined to be a map from the elements of S to the elements of S' which preserves incidence and induces a function from the type set of S to the type set of S'. For instance, a correlation and a collineation are examples of geometry morphisms, but they have been dealt with in more specific ways in FinInG. We will mainly be concerned with geometry morphisms where the source and range are different. Hence, the natural embedding of a projective space in a larger projective space, the mapping induced by field reduction, and e.g. the Klein correspondence are examples of such geometry morphisms.

As a geometry morphism from S to S' preserves incidence, it also preserves the symmetry, and hence it induces also a map from the collineation group of S into the collineation group of S'. Such a map will be called an Intertwiner, and FinInG can provide these maps for some of the geometry morphisms.

Note that quite some technicalities are needed in the implementation of some geometry morphisms. This chapters deals only with the user interface. Some low level functions for geometry morphisms are described in Appendix C.

#### 10.1 Geometry morphisms in FinInG

##### 10.1-1 IsGeometryMorphism

`‣ IsGeometryMorphism` | ( family )

The category `IsGeometryMorphism` represents a special object in FinInG which carries attributes and the given element map. The element map is given as a `IsGeneralMapping`, and so has a source and range.

    gap> ShowImpliedFilters(IsGeometryMorphism);
    Implies:
       IsGeneralMapping
       IsTotal
       Tester(IsTotal)
       IsSingleValued
       Tester(IsSingleValued)

The usual operations of `ImageElm`, and `PreImageElm`, have methods installed for geometry morphisms, as well as the overload operator `\^`.

##### 10.1-2 Intertwiner

`‣ Intertwiner`( f ) | ( attribute )

Returns: a group homomorphism

The argument f is a geometry morphism. If f comes equipped with a natural intertwiner from an automorphism group of the source of f to the automorphism group to the image of f, then the user may is able to obtain the intertwiner by calling this operation (see the individual geometry morphism constructions). For most geometry morphisms, there is also an accompanying intertwiner for the automorphism groups of the source and range. Given a geometry morphism f from S to S', an intertwiner φ is a map from the automorphism group of S to the automorphism group of S', such that for every element p of S and every automorphism g of S, we have

f(pg)=f(p)φ(g).

There is no method to compute an intertwiner for a given geometry morphism, the attribute is or is not set during the construction of the geometry morphism, depending whether the Source and Range of the morphism have the appropriate automorphism group known as an attribute. When this condition is not satisfied, the user is expected to call the appropriate automorphism groups, so that they are computed, and to recompute the geometry morphism (which will not cost a lot of computation time then). This will make the attribute `Intertwiner` available. Here is a simple example of the intertwiner for the isomorphism of two polar spaces (see `IsomorphismPolarSpaces` (10.2-1)). The source of the homomorphism is dependent on the geometry.

    gap> form := BilinearFormByMatrix( IdentityMat(3,GF(3)), GF(3) );
    < bilinear form >
    gap> ps := PolarSpace(form);
    <polar space in ProjectiveSpace(2,GF(3)): x_1^2+x_2^2+x_3^2=0 >
    gap> pq := ParabolicQuadric(2,3);
    standard Q(2, 3)
    gap> iso := IsomorphismPolarSpaces(ps, pq);
    #I  Computing nice monomorphism...
    <geometry morphism from <Elements of <polar space in ProjectiveSpace(2,GF(
    3)): x_1^2+x_2^2+x_3^2=0 >> to <Elements of standard Q(2, 3)>>
    gap> KnownAttributesOfObject(iso);
    [ "Range", "Source", "Intertwiner" ]
    gap> hom := Intertwiner(iso);
    MappingByFunction( <projective semilinear group with
    3 generators>, PGammaO(3,3), function( y ) ... end, function( x ) ... end )

#### 10.2 Type preserving bijective geometry morphisms

An important class of geometry morphisms in FinInG are the isomorphisms between polar spaces of the same kind that are induced by coordinate transformations.

##### 10.2-1 IsomorphismPolarSpaces

`‣ IsomorphismPolarSpaces`( ps1, ps2 ) | ( operation )

`‣ IsomorphismPolarSpaces`( ps1, ps2, boolean ) | ( operation )

Returns: a geometry morphism

The arguments ps1 and ps2 are equivalent polar spaces, i.e. up to coordinate transformation, the underlying sesquilinear or quadratic form determines the same polar space, or, ps1 is a parabolic quadric over a finite field f of even characteristic in dimension 2n and ps2 is a symplectic space over f in dimension 2n-1, then this operation returns a geometry isomorphism between them. The optional third argument boolean can take either `true` or `false` as input, and then the operation will or will not compute the intertwiner accordingly. The user may wish that the intertwiner is not computed when working with large polar spaces. The default (when calling the operation with two arguments) is set to `true`, and in this case, if at least one of ps1 or ps2 has a collineation group installed as an attribute, then an intertwining homomorphism is installed as an attribute of the resulting geometry morphism. Hence we also obtain a natural group isomorphism from the collineation group of ps1 onto the collineation group of ps2 (see also `Intertwiner` (10.1-2)).

    gap> mat1 := IdentityMat(6,GF(5));
    < mutable compressed matrix 6x6 over GF(5) >
    gap> form1 := BilinearFormByMatrix(mat1,GF(5));
    < bilinear form >
    gap> ps1 := PolarSpace(form1);
    <polar space in ProjectiveSpace(
    5,GF(5)): x_1^2+x_2^2+x_3^2+x_4^2+x_5^2+x_6^2=0 >
    gap> mat2 := [[0,0,0,0,0,1],[0,0,0,0,1,0],[0,0,0,1,0,0],
    > [0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0]]*Z(5)^0;
    [ [ 0*Z(5), 0*Z(5), 0*Z(5), 0*Z(5), 0*Z(5), Z(5)^0 ],
      [ 0*Z(5), 0*Z(5), 0*Z(5), 0*Z(5), Z(5)^0, 0*Z(5) ],
      [ 0*Z(5), 0*Z(5), 0*Z(5), Z(5)^0, 0*Z(5), 0*Z(5) ],
      [ 0*Z(5), 0*Z(5), 0*Z(5), 0*Z(5), 0*Z(5), 0*Z(5) ],
      [ 0*Z(5), 0*Z(5), 0*Z(5), 0*Z(5), 0*Z(5), 0*Z(5) ],
      [ 0*Z(5), 0*Z(5), 0*Z(5), 0*Z(5), 0*Z(5), 0*Z(5) ] ]
    gap> form2 := QuadraticFormByMatrix(mat2,GF(5));
    < quadratic form >
    gap> ps2 := PolarSpace(form2);
    <polar space in ProjectiveSpace(5,GF(5)): x_1*x_6+x_2*x_5+x_3*x_4=0 >
    gap> iso := IsomorphismPolarSpaces(ps1,ps2,true);
    #I  No intertwiner computed. One of the polar spaces must have a collineation group computed
    <geometry morphism from <Elements of Q+(5,
    5): x_1^2+x_2^2+x_3^2+x_4^2+x_5^2+x_6^2=0> to <Elements of Q+(5,
    5): x_1*x_6+x_2*x_5+x_3*x_4=0>>
    gap> CollineationGroup(ps1);
    #I  Computing collineation group of canonical polar space...
    <projective collineation group of size 58032000000 with 4 generators>
    gap> CollineationGroup(ps2);
    #I  Computing collineation group of canonical polar space...
    <projective collineation group of size 58032000000 with 4 generators>
    gap> iso := IsomorphismPolarSpaces(ps1,ps2,true);
    <geometry morphism from <Elements of Q+(5,
    5): x_1^2+x_2^2+x_3^2+x_4^2+x_5^2+x_6^2=0> to <Elements of Q+(5,
    5): x_1*x_6+x_2*x_5+x_3*x_4=0>>
    gap> hom := Intertwiner( iso );
    MappingByFunction( <projective collineation group of size 58032000000 with
    4 generators>, <projective collineation group of size 58032000000 with
    4 generators>, function( y ) ... end, function( x ) ... end )
    gap> ps1 := ParabolicQuadric(6,8);
    Q(6, 8)
    gap> ps2 := SymplecticSpace(5,8);
    W(5, 8)
    gap> em := IsomorphismPolarSpaces(ps1,ps2);
    #I  Have 36171 points.
    #I  Have 37381 points in new orbit.
    #I  Have 36171 points.
    #I  Have 37388 points in new orbit.
    <geometry morphism from <Elements of Q(6, 8)> to <Elements of W(5, 8)>>
    gap> hom := Intertwiner(em);
    MappingByFunction( PGammaO(7,8), <projective collineation group of size
    27231016821530296320 with
    3 generators>, function( el ) ... end, function( el ) ... end )

#### 10.3 Klein correspondence and derived dualities

The Klein correspondence is a well known geometry morphism from the lines of PG(3,q) to the points of a hyperbolic quadric in PG(5,q). This morphism and some derived morphisms are provided in FinInG. The bare essential of the Klein correspondence is the so-called Plücker map.

##### 10.3-1 PluckerCoordinates

`‣ PluckerCoordinates`( line ) | ( operation )

This operation takes a line of PG(3,q) as argument. It returns the plucker coordinates of the argument as list of finite field elements. The returned list can be used in operations as `vector spaceToElement`, and represents a point of the hyperbolic quadric in PG(5,q) with equation X0X5+X1X4+X2X3 = 0

    gap> pg := PG(3,169);
    ProjectiveSpace(3, 169)
    gap> l := Random(Lines(pg));
    <a line in ProjectiveSpace(3, 169)>
    gap> vec := PluckerCoordinates(l);
    [ Z(13)^0, Z(13^2)^138, Z(13^2)^93, Z(13^2)^53, Z(13^2)^71, Z(13^2)^106 ]
    gap> mat := [[0,0,0,0,0,1],[0,0,0,0,1,0],[0,0,0,1,0,0],
    > [0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0]]*Z(13)^0;
    [ [ 0*Z(13), 0*Z(13), 0*Z(13), 0*Z(13), 0*Z(13), Z(13)^0 ],
      [ 0*Z(13), 0*Z(13), 0*Z(13), 0*Z(13), Z(13)^0, 0*Z(13) ],
      [ 0*Z(13), 0*Z(13), 0*Z(13), Z(13)^0, 0*Z(13), 0*Z(13) ],
      [ 0*Z(13), 0*Z(13), 0*Z(13), 0*Z(13), 0*Z(13), 0*Z(13) ],
      [ 0*Z(13), 0*Z(13), 0*Z(13), 0*Z(13), 0*Z(13), 0*Z(13) ],
      [ 0*Z(13), 0*Z(13), 0*Z(13), 0*Z(13), 0*Z(13), 0*Z(13) ] ]
    gap> form := QuadraticFormByMatrix(mat,GF(169));
    < quadratic form >
    gap> klein := PolarSpace(form);
    <polar space in ProjectiveSpace(5,GF(13^2)): x_1*x_6+x_2*x_5+x_3*x_4=0 >
    gap> VectorSpaceToElement(klein,vec);
    <a point in Q+(5, 169): x_1*x_6+x_2*x_5+x_3*x_4=0>

##### 10.3-2 KleinCorrespondence

`‣ KleinCorrespondence`( f ) | ( operation )

`‣ KleinCorrespondence`( f, boolean ) | ( operation )

`‣ KleinCorrespondence`( q ) | ( operation )

`‣ KleinCorrespondence`( q, boolean ) | ( operation )

Returns: a geometry morphism

The argument f is a finite field, the argument q is a prime power. The first an the third version use `true` as value for boolean. When using `true` as value for the boolean, the intertwiner is computed. This variant of the operation `KleinCorrespondence` has always as ambient geometry of its range the hyperbolic quadric Q+(5,q) with equation X0X5+X1X4+X2X3 = 0 The returned geometry morphism has the lines of PG(3,q) as source and the points of Q+(5,q) as range.

    gap> k := KleinCorrespondence( 9 );
    <geometry morphism from <lines of ProjectiveSpace(3, 9)> to <points of Q+(5,
    9): x_1*x_6+x_2*x_5+x_3*x_4=0>>
    gap> Intertwiner(k);
    MappingByFunction( The FinInG collineation group PGammaL(4,9), <projective col
    lineation group with
    3 generators>, function( g ) ... end, function( g ) ... end )
    gap> pg := ProjectiveSpace(3, 9);
    ProjectiveSpace(3, 9)
    gap> AmbientGeometry(Range(k));
    Q+(5, 9): x_1*x_6+x_2*x_5+x_3*x_4=0
    gap> l := Random( Lines(pg) );
    <a line in ProjectiveSpace(3, 9)>
    gap> l^k;
    <a point in Q+(5, 9): x_1*x_6+x_2*x_5+x_3*x_4=0>

##### 10.3-3 KleinCorrespondence

`‣ KleinCorrespondence`( quadric ) | ( operation )

`‣ KleinCorrespondence`( quadric, boolean ) | ( operation )

Returns: a geometry morphism

The argument quadric is a hyperbolic quadric in a 5 dimensional projective space. If boolean is `true` or not given, this operation returns the geometry morphism equipped with an intertwiner. The returned geometry morphism has the lines of PG(3,q) as source and the points of Q+(5,q) as range.

    gap> quadric := HyperbolicQuadric(5,3);
    Q+(5, 3)
    gap> k := KleinCorrespondence( quadric );
    <geometry morphism from <lines of ProjectiveSpace(3, 3)> to <points of Q+(5,
    3)>>
    gap> pg := ProjectiveSpace(3, 3);
    ProjectiveSpace(3, 3)
    gap> l := Random( Lines(pg) );
    <a line in ProjectiveSpace(3, 3)>
    gap> l^k;
    <a point in Q+(5, 3)>
    gap> id := IdentityMat(6,GF(13));
    < mutable compressed matrix 6x6 over GF(13) >
    gap> form := QuadraticFormByMatrix(id,GF(13));
    < quadratic form >
    gap> quadric := PolarSpace(form);
    <polar space in ProjectiveSpace(
    5,GF(13)): x_1^2+x_2^2+x_3^2+x_4^2+x_5^2+x_6^2=0 >
    gap> k := KleinCorrespondence( quadric );
    <geometry morphism from <lines of ProjectiveSpace(3, 13)> to <points of Q+(5,
    13): x_1^2+x_2^2+x_3^2+x_4^2+x_5^2+x_6^2=0>>
    gap> pg := AmbientGeometry(Source(k));
    ProjectiveSpace(3, 13)
    gap> l := Random(Lines(pg));
    <a line in ProjectiveSpace(3, 13)>
    gap> l^k;
    <a point in Q+(5, 13): x_1^2+x_2^2+x_3^2+x_4^2+x_5^2+x_6^2=0>

##### 10.3-4 KleinCorrespondenceExtended

`‣ KleinCorrespondenceExtended`( quadric ) | ( operation )

`‣ KleinCorrespondenceExtended`( quadric, boolean ) | ( operation )

Returns: a geometry morphism

The argument quadric is a hyperbolic quadric in a 5 dimensional projective space. If boolean is `true` or not given, this operation returns the geometry morphism equipped with an intertwiner. The returned geometry morphism has all the elements of PG(3,q) as source (not just the lines) and the elements of Q+(5,q) as range, hence this operation is a kind of extension of `KleinCorrespondence`.

    gap> ps := HyperbolicQuadric(5,7);
    Q+(5, 7)
    gap> em := KleinCorrespondenceExtended(ps);
    <geometry morphism from <All elements of ProjectiveSpace(3,
    7)> to <Elements of Q+(5, 7)>>
    gap> hom := Intertwiner(em);
    MappingByFunction( The FinInG collineation group PGL(4,7), <projective colline
    ation group with 2 generators>, function( g ) ... end, function( g ) ... end )
    gap> mat := [[0,0,0,0,0,1],[0,0,0,0,1,0],[0,0,0,1,0,0],
    > 	[0,0,1,0,0,0],[0,1,0,0,0,0],[1,0,0,0,0,0]]*Z(7)^0;
    [ [ 0*Z(7), 0*Z(7), 0*Z(7), 0*Z(7), 0*Z(7), Z(7)^0 ],
      [ 0*Z(7), 0*Z(7), 0*Z(7), 0*Z(7), Z(7)^0, 0*Z(7) ],
      [ 0*Z(7), 0*Z(7), 0*Z(7), Z(7)^0, 0*Z(7), 0*Z(7) ],
      [ 0*Z(7), 0*Z(7), Z(7)^0, 0*Z(7), 0*Z(7), 0*Z(7) ],
      [ 0*Z(7), Z(7)^0, 0*Z(7), 0*Z(7), 0*Z(7), 0*Z(7) ],
      [ Z(7)^0, 0*Z(7), 0*Z(7), 0*Z(7), 0*Z(7), 0*Z(7) ] ]
    gap> g := Projectivity(mat,GF(7));
    < a collineation: <cmat 6x6 over GF(7,1)>, F^0>
    gap> g in CollineationGroup(ps);
    true
    gap> PreImageElm(hom,g);
    #I  <el> is not inducing a collineation of PG(3,q)
    fail

It is well known that the classical generalised quadrangles W(3,q) and Q(4,q) are dual incidence structures, the same holds for the classical generalised quadrangles Q+(5,q) and H(3,q2). Essentially, these dual dualities are based on the Klein correspondence, and are implemented through the operation `NaturalDuality`, this operation will return a geometry morphism with `ElementsOfIncidenceStructure(gq1)` as source and `ElementsOfIncidenceStructure(gq2)` as range, in other words, it is a geometry morphism from all the elements of gq1 onto all the elements of gq2, preserving the incidence, and swapping the types.

##### 10.3-5 NaturalDuality

`‣ NaturalDuality`( gq1, gq2 ) | ( operation )

`‣ NaturalDuality`( gq1, gq2, boolean ) | ( operation )

`‣ NaturalDuality`( gq ) | ( operation )

`‣ NaturalDuality`( gq, boolean ) | ( operation )

Returns: a geometry morphism

The operation allows the construction of the duality between W(3,q) and Q(4,q), respectively Q+(5,q), in two directions. It is checked if the arguments are appropriate, i.e. the right type of generalised quadrangle(s). The first version requires two arguments: either the symplectic or parabolic quadrangle, in any order, and defined by any suitable bilinear/quadratic and bilinear form; or the elliptic or hermitian quadrangle (in dimension 3), in any order, and defined by any suitable bilinear/quadratic and hermitian form. In all cases the generalised quadrangles may be the standard one provided by the package FinInG.

The third version requires only one argument, either W(3,q), Q(4,q), Q+(5,q), or H(3,q2), standard or user specified using an appropriate bilinear, quadratic or hermitian form. The range of the returned geometry morphism will be the set of all elements of a suitable generalised quadrangle, in standard form.

The first and third version without a boolean as argument will, if possible return a geometry morphism equipped with an intertwiner. Using the boolean argument false will return a geometry morphism that is not equipped with an intertwiner.

    gap> w := SymplecticSpace(3,5);
    W(3, 5)
    gap> lines:=AsList(Lines(w));;
    gap> duality := NaturalDuality(w);
    <geometry morphism from <Elements of W(3, 5)> to <Elements of Q(4, 5)>>
    gap> l:=lines[1];
    <a line in W(3, 5)>
    gap> l^duality;
    <a point in Q(4, 5)>
    gap> PreImageElm(duality,last);
    <a line in W(3, 5)>
    gap> hom := Intertwiner(duality);
    MappingByFunction( PGammaSp(4,5), <projective collineation group of size
    9360000 with 4 generators>, function( g ) ... end, function( g ) ... end )
    gap> q := 5;
    5
    gap> q5q := EllipticQuadric(5,q);
    Q-(5, 5)
    gap> mat := [[0,1,0,0],[1,0,0,0],[0,0,0,Z(q)],[0,0,Z(q),0]]*Z(q)^0;
    [ [ 0*Z(5), Z(5)^0, 0*Z(5), 0*Z(5) ], [ Z(5)^0, 0*Z(5), 0*Z(5), 0*Z(5) ],
      [ 0*Z(5), 0*Z(5), 0*Z(5), Z(5) ], [ 0*Z(5), 0*Z(5), Z(5), 0*Z(5) ] ]
    gap> hform := HermitianFormByMatrix(mat,GF(q^2));
    < hermitian form >
    gap> herm := PolarSpace(hform);
    <polar space in ProjectiveSpace(
    3,GF(5^2)): x1^5*x2+x1*x2^5+Z(5)*x3^5*x4+Z(5)*x3*x4^5=0 >
    gap> duality := NaturalDuality(q5q,herm,true);
    <geometry morphism from <Elements of Q-(5, 5)> to <Elements of H(3,
    5^2): x1^5*x2+x1*x2^5+Z(5)*x3^5*x4+Z(5)*x3*x4^5=0>>
    gap> hom := Intertwiner(duality);
    MappingByFunction( PDeltaO-(6,5), <projective collineation group of size
    58968000000 with 3 generators>, function( g ) ... end, function( g ) ... end )
    gap> g := Random(CollineationGroup(q5q));
    < a collineation: <cmat 6x6 over GF(5,1)>, F^0>
    gap> g^hom;
    < a collineation: <cmat 4x4 over GF(5,2)>, F^5>

The combination of the isomorphism of the GQs W(3,q), Q(4,q) when q is even and the duality between the same GQs, yields a duality from each of these GQs itself. The operation `SelfDuality` implements this combination.

##### 10.3-6 SelfDuality

`‣ SelfDuality`( gq ) | ( operation )

`‣ SelfDuality`( gq, boolean ) | ( operation )

Returns: a geometry morphism

It is checked whether the base field of gq is a field of characteristic 2 and whether gq is a symplectic generalised quadrangle in 3-dimensional projective space or a parabolic quadric in 4-dimensional projective space. The first version will return, when possible, a geometry morphism equipped with an intertwiner. Using the boolean argument false will return a geometry morphism that is not equipped with an intertwiner. The example shows the use of the boolean argument.

    gap> q := 16;
    16
    gap> mat := [[0,1,0,0,0],[0,0,0,0,0],[0,0,1,0,0],[0,0,0,0,0],[0,0,0,1,0]]*Z(q)^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) ],
      [ 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), 0*Z(2) ],
      [ 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0, 0*Z(2) ] ]
    gap> form := QuadraticFormByMatrix(mat,GF(q));
    < quadratic form >
    gap> q4q := PolarSpace(form);
    <polar space in ProjectiveSpace(4,GF(2^4)): x_1*x_2+x_3^2+x_4*x_5=0 >
    gap> em := SelfDuality(q4q);
    #I  No intertwiner computed. The polar space must have a collineation group computed
    <geometry morphism from <Elements of Q(4,
    16): x_1*x_2+x_3^2+x_4*x_5=0> to <Elements of Q(4,
    16): x_1*x_2+x_3^2+x_4*x_5=0>>
    gap> CollineationGroup(q4q);
    #I  Computing collineation group of canonical polar space...
    <projective collineation group of size 4380799795200 with 3 generators>
    gap> em := SelfDuality(q4q);
    <geometry morphism from <Elements of Q(4,
    16): x_1*x_2+x_3^2+x_4*x_5=0> to <Elements of Q(4,
    16): x_1*x_2+x_3^2+x_4*x_5=0>>
    gap> hom := Intertwiner(em);
    MappingByFunction( <projective collineation group of size 4380799795200 with
    3 generators>, <projective collineation group of size 4380799795200 with
    3 generators>, function( el ) ... end, function( el ) ... end )
    gap> q := 16;
    16
    gap> w := SymplecticSpace(3,q);
    W(3, 16)
    gap> em := SelfDuality(w);
    <geometry morphism from <Elements of W(3, 16)> to <Elements of W(3, 16)>>

#### 10.4 Embeddings of projective spaces

The most natural of geometry morphisms include, for example, the embedding of a projective space into another via a subspace, the embedding of a projective space over a field into a projective space of the same dimension over an extended field, or the embedding of a projective space over a field into a projective space of higher dimension over a subfield through so-called field reduction.

##### 10.4-1 NaturalEmbeddingBySubspace

`‣ NaturalEmbeddingBySubspace`( geom1, geom2, v ) | ( operation )

Returns: a geometry morphism

The arguments geom1 and geom2 are both projective spaces, and v is an element of a geom2. This function returns a geometry morphism representing the natural embedding of geom1 into geom2 as the subspace v. Hence geom1 and v must be equivalent as geometries. An Intertwiner is not implemented for this geometry morphism.

    gap> geom1 := ProjectiveSpace(2, 3);
    ProjectiveSpace(2, 3)
    gap> geom2 := ProjectiveSpace(3, 3);
    ProjectiveSpace(3, 3)
    gap> planes := Planes(geom2);
    <planes of ProjectiveSpace(3, 3)>
    gap> hyp := Random(planes);
    <a plane in ProjectiveSpace(3, 3)>
    gap> em := NaturalEmbeddingBySubspace(geom1, geom2, hyp);
    <geometry morphism from <All elements of ProjectiveSpace(2,
    3)> to <All elements of ProjectiveSpace(3, 3)>>
    gap> points := Points(geom1);
    <points of ProjectiveSpace(2, 3)>
    gap> x := Random(points);
    <a point in ProjectiveSpace(2, 3)>
    gap> x^em;
    <a point in ProjectiveSpace(3, 3)>

##### 10.4-2 NaturalEmbeddingBySubField

`‣ NaturalEmbeddingBySubField`( geom1, geom2 ) | ( operation )

`‣ NaturalEmbeddingBySubField`( geom1, geom2, boolean ) | ( operation )

Returns: a geometry morphism

The arguments geom1 and geom2 are projective spaces of the same dimension. This function returns a geometry morphism representing the natural embedding of geom1 into geom2 as a subfield geometry. The geometry morphism also comes equipped with an intertwiner (see `Intertwiner` (10.1-2)). The optional third argument boolean can take either `true` or `false` as input, and then our operation will or will not compute the intertwiner accordingly. The default (when calling the operation with two arguments) is set to `true`. Note that the source of the intertwiner is the projectivity group of geom1 and its range is a subgroup of the projectivity group of geom2. Here is a simple example where the geometry morphism embeds PG(2,3) into PG(2,9) .

    gap> pg1 := PG(2,3);
    ProjectiveSpace(2, 3)
    gap> pg2 := PG(2,9);
    ProjectiveSpace(2, 9)
    gap> em := NaturalEmbeddingBySubfield(pg1,pg2);
    <geometry morphism from <All elements of ProjectiveSpace(2,
    3)> to <All elements of ProjectiveSpace(2, 9)>>
    gap> points := AsList(Points( pg1 ));
    [ <a point in ProjectiveSpace(2, 3)>, <a point in ProjectiveSpace(2, 3)>,
      <a point in ProjectiveSpace(2, 3)>, <a point in ProjectiveSpace(2, 3)>,
      <a point in ProjectiveSpace(2, 3)>, <a point in ProjectiveSpace(2, 3)>,
      <a point in ProjectiveSpace(2, 3)>, <a point in ProjectiveSpace(2, 3)>,
      <a point in ProjectiveSpace(2, 3)>, <a point in ProjectiveSpace(2, 3)>,
      <a point in ProjectiveSpace(2, 3)>, <a point in ProjectiveSpace(2, 3)>,
      <a point in ProjectiveSpace(2, 3)> ]
    gap> image := ImagesSet(em, points);
    [ <a point in ProjectiveSpace(2, 9)>, <a point in ProjectiveSpace(2, 9)>,
      <a point in ProjectiveSpace(2, 9)>, <a point in ProjectiveSpace(2, 9)>,
      <a point in ProjectiveSpace(2, 9)>, <a point in ProjectiveSpace(2, 9)>,
      <a point in ProjectiveSpace(2, 9)>, <a point in ProjectiveSpace(2, 9)>,
      <a point in ProjectiveSpace(2, 9)>, <a point in ProjectiveSpace(2, 9)>,
      <a point in ProjectiveSpace(2, 9)>, <a point in ProjectiveSpace(2, 9)>,
      <a point in ProjectiveSpace(2, 9)> ]
    gap> hom := Intertwiner(em);
    MappingByFunction( The FinInG projectivity group PGL(3,3), <projective colline
    ation group of size 5616 with
    2 generators>, function( x ) ... end, function( y ) ... end )
    gap> group1 := ProjectivityGroup(pg1);
    The FinInG projectivity group PGL(3,3)
    gap> gens := GeneratorsOfGroup(group1);
    [ < a collineation: <cmat 3x3 over GF(3,1)>, F^0>,
      < a collineation: <cmat 3x3 over GF(3,1)>, F^0> ]
    gap> group1_image := Group(List(gens,x->x^hom));
    <projective collineation group with 2 generators>
    gap> Order(group1_image);
    5616
    gap> group2 := ProjectivityGroup(pg2);
    The FinInG projectivity group PGL(3,9)
    gap> Order(group2);
    42456960
    gap> g := Random(group2);
    < a collineation: <cmat 3x3 over GF(3,2)>, F^0>
    gap> PreImageElm(hom,g);
    #I  <el> is not in the range of the intertwiner
    fail

##### 10.4-3 Embedding of projective spaces by field reduction

We briefly describe the mathematics behind field reduction. For more details we refer to [LVdV13]. Consider the fields GF(q) and GF(qt). The field GF(qt) is a t-dimensional vector space over GF(q). Hence, with respect to a chosen basis B for GF(qt) as a GF(q)-vector space, the bijection between the vector spaces V(n,qt) and V(tn,q) can be implemented. Consider the projective space PG(n-1,qt). The elements are represented by subspaces of V(n,qt). Clearly, a k dimensional subspace of V(n,qt) is also a kn-dimensional subspace of V(nt,q). This induces an embedding from PG(n-1,qt) into PG(nt-1,q). The embedding will be determined by the chosen basis of GF(qt) as a vector space over GF(q)

##### 10.4-4 BlownUpSubspaceOfProjectiveSpace

`‣ BlownUpSubspaceOfProjectiveSpace`( B, subspace ) | ( operation )

Returns: a subspace of a projective space

Let B be a basis for the field GF(qt) as GF(q) vector space, and let subspace be a k-1-dimensional subspace of PG(n-1,qt) represented by a k-dimensional subspace S of V(n,qt). This operation returns the kt-1-dimensional subspace of PG(nt-1,q) represented by blowing up S with respect to the base B. This operation relies on the GAP operation `BlownUpMat`. In the example, the effect of choosing a different basis is shown.

    gap> pg := PG(3,5^2);
    ProjectiveSpace(3, 25)
    gap> basis := Basis(AsVectorSpace(GF(5),GF(5^2)));
    CanonicalBasis( GF(5^2) )
    gap> line := Random(Lines(pg));
    <a line in ProjectiveSpace(3, 25)>
    gap> solid1 := BlownUpSubspaceOfProjectiveSpace(basis,line);
    <a solid in ProjectiveSpace(7, 5)>
    gap> BasisVectors(basis);
    [ Z(5)^0, Z(5^2) ]
    gap> basis := Basis(AsVectorSpace(GF(5),GF(5^2)),[Z(5),Z(5^2)^8]);
    Basis( GF(5^2), [ Z(5), Z(5^2)^8 ] )
    gap> solid2 := BlownUpSubspaceOfProjectiveSpace(basis,line);
    <a solid in ProjectiveSpace(7, 5)>
    gap> solid1 = solid2;
    false

##### 10.4-5 NaturalEmbeddingByFieldReduction

`‣ NaturalEmbeddingByFieldReduction`( geom1, f2, B ) | ( operation )

`‣ NaturalEmbeddingByFieldReduction`( geom1, f2 ) | ( operation )

`‣ NaturalEmbeddingByFieldReduction`( geom1, geom2 ) | ( operation )

`‣ NaturalEmbeddingByFieldReduction`( geom1, geom2, B ) | ( operation )

Returns: a geometry morphism

This operation comes in four flavours. For the first flavour, the argument geom1 is a projective space over a field GF(qt). The argument f2 is a subfield GF(q) of GF(qt). The argument B is a basis for GF(qt) as a GF(q)-vector space. When this argument is not given, a basis for GF(qt) over GF(q) is computed using `Basis(Asvector space(GF(q),GF(q^t)))`. It is checked whether f2 is a subfield of the base field of geom1. The third and fourth flavour are comparable, where now GF(q) is found as the base field of geom2. In fact the arguments geom1 and geom2 are the projective spaces PG(n-1,qt) and PG(nt-1,q) respectively. As in the previous flavours, the argument B is optional.

An intertwiner is always available for this geometry morphism, and has source the homography group of geom1 and as range a subgroup of the homography group of geom2 (or the projective space of the appropriate dimension over f2. Notice in the example below the difference of a factor 2 in the orders of the group, which comes of course from restricting the homomorphism to the homography group, which differs a factor 2 from the collineation group of the projective line, that has an extra automorphism of order two, corresponding with the Frobenius automorphism.

    gap> pg1 := ProjectiveSpace(2,81);
    ProjectiveSpace(2, 81)
    gap> f2 := GF(9);
    GF(3^2)
    gap> em := NaturalEmbeddingByFieldReduction(pg1,f2);
    <geometry morphism from <All elements of ProjectiveSpace(2,
    81)> to <All elements of ProjectiveSpace(5, 9)>>
    gap> f2 := GF(3);
    GF(3)
    gap> em := NaturalEmbeddingByFieldReduction(pg1,f2);
    <geometry morphism from <All elements of ProjectiveSpace(2,
    81)> to <All elements of ProjectiveSpace(11, 3)>>
    gap> pg2 := ProjectiveSpace(11,3);
    ProjectiveSpace(11, 3)
    gap> em := NaturalEmbeddingByFieldReduction(pg1,pg2);
    <geometry morphism from <All elements of ProjectiveSpace(2,
    81)> to <All elements of ProjectiveSpace(11, 3)>>
    gap> pg1 := PG(1,9);
    ProjectiveSpace(1, 9)
    gap> em := NaturalEmbeddingByFieldReduction(pg1,GF(3));
    <geometry morphism from <All elements of ProjectiveSpace(1,
    9)> to <All elements of ProjectiveSpace(3, 3)>>
    gap> i := Intertwiner(em);
    MappingByFunction( The FinInG projectivity group PGL(2,9), <projective colline
    ation group of size 720 with
    2 generators>, function( m ) ... end, function( m ) ... end )
    gap> spread := List(Points(pg1),x->x^em);
    [ <a line in ProjectiveSpace(3, 3)>, <a line in ProjectiveSpace(3, 3)>,
      <a line in ProjectiveSpace(3, 3)>, <a line in ProjectiveSpace(3, 3)>,
      <a line in ProjectiveSpace(3, 3)>, <a line in ProjectiveSpace(3, 3)>,
      <a line in ProjectiveSpace(3, 3)>, <a line in ProjectiveSpace(3, 3)>,
      <a line in ProjectiveSpace(3, 3)>, <a line in ProjectiveSpace(3, 3)> ]
    gap> stab := Stabilizer(CollineationGroup(PG(3,3)),Set(spread),OnSets);
    <projective collineation group of size 5760 with 3 generators>
    gap> hom := HomographyGroup(pg1);
    The FinInG projectivity group PGL(2,9)
    gap> gens := GeneratorsOfGroup(hom);;
    gap> group := Group(List(gens,x->x^i));
    <projective collineation group with 2 generators>
    gap> Order(group);
    2880
    gap> IsSubgroup(stab,group);
    true

#### 10.5 Embeddings of polar spaces

##### 10.5-1 NaturalEmbeddingBySubspace

`‣ NaturalEmbeddingBySubspace`( geom1, geom2, v ) | ( operation )

Returns: a geometry morphism

The arguments geom1 and geom2 both polar spaces, and v is an element of a projective space. This function returns a geometry morphism representing the natural embedding of geom1 into the intersection of geom2 and v. Hence the intersection of geom2 and v must induce a polar space of the same type as geom1 in v. This operation performs all necessary checks. An Intertwiner is not implemented for this geometry morphism.

    gap> h1 := HermitianPolarSpace(2, 3^2);
    H(2, 3^2)
    gap> h2 := HermitianPolarSpace(3, 3^2);
    H(3, 3^2)
    gap> pg := AmbientSpace( h2 );
    ProjectiveSpace(3, 9)
    gap> pi := VectorSpaceToElement( pg, [[1,0,0,0],[0,1,0,0],[0,0,1,0]] * Z(9)^0 );
    <a plane in ProjectiveSpace(3, 9)>
    gap> em := NaturalEmbeddingBySubspace( h1, h2, pi );
    <geometry morphism from <Elements of H(2, 3^2)> to <Elements of H(3, 3^2)>>
    gap> ps1 := ParabolicQuadric(4,4);
    Q(4, 4)
    gap> ps2 := ParabolicQuadric(6,4);
    Q(6, 4)
    gap> pg := AmbientSpace( ps2 );
    ProjectiveSpace(6, 4)
    gap> pi := VectorSpaceToElement( pg, [[1,0,0,0,0,0,0],[0,1,0,0,0,0,0],[0,0,1,0,0,0,0],
    > [0,0,0,1,0,0,0],[0,0,0,0,1,0,0]] * Z(4)^0 );
    <a proj. 4-space in ProjectiveSpace(6, 4)>
    gap> em := NaturalEmbeddingBySubspace( ps1, ps2, pi );
    <geometry morphism from <Elements of Q(4, 4)> to <Elements of Q(6, 4)>>
    gap> List(Lines(ps1),x->x^em);
    [ <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)>, <a line in Q(6, 4)>, <a line in Q(6, 4)>,
      <a line in Q(6, 4)> ]

##### 10.5-2 NaturalEmbeddingBySubField

`‣ NaturalEmbeddingBySubField`( geom1, geom2 ) | ( operation )

`‣ NaturalEmbeddingBySubField`( geom1, geom2, boolean ) | ( operation )

Returns: a geometry morphism

The arguments geom1 and geom2 are projective or polar spaces with an underlying vector space of the same dimension and the base field L of geom2 is an extension of the base field K of geom1. The form f determining geom1 also defines a form over L, and determines a polar space. By considering the underlying vector spaces determining the elements of geom1 over the extension field L, there is an obvious embedding of geom1 in the polar space over the extension field. Considering f over a field extension might change its type. The possible embeddings, where the polar spaces may be chosen up to equivalent form, are listed in the table below (see [KL90]):

Table: Subfield embeddings of polar spaces
Polar Space 1 | Polar Space 2 | Conditions
W(2n-1,q) | W(2n-1,qa) | --
W(2n-1,q) | H(2n-1,qa) | --
H(d,q2) | H(d,q2r) | r odd
Oε(d,q) | H(d,q2) | q odd
Oε(d,q) | Oε'(d,qr) | ε=(ε')r

The geometry morphism also comes equipped with an intertwiner (see `Intertwiner` (10.1-2)). The optional third argument boolean can take either `true` or `false` as input, and then our operation will or will not compute the intertwiner accordingly. When set `true`, the intertwiner will be computed if `HasCollineationGroup(geom1)` is true. The user may wish that the intertwiner is not computed when embedding large polar spaces. The default (when calling the operation with two arguments) is set to `true`.

    gap> w := SymplecticSpace(5, 3);
    W(5, 3)
    gap> h := HermitianPolarSpace(5, 3^2);
    H(5, 3^2)
    gap> em := NaturalEmbeddingBySubfield(w, h);
    #I  No intertwiner computed. <geom1> must have a collineation group computed
    <geometry morphism from <Elements of W(5, 3)> to <Elements of H(5, 3^2)>>
    gap> points := AsList(Points(w));;
    gap> image := ImagesSet(em, points);;
    gap> ForAll(image, x -> x in h);
    true
    gap> hq:=HyperbolicQuadric(3,4);
    Q+(3, 4)
    gap> eq:=EllipticQuadric(3,2);
    Q-(3, 2)
    gap> em:=NaturalEmbeddingBySubfield(eq,hq);
    #I  No intertwiner computed. <geom1> must have a collineation group computed
    <geometry morphism from <Elements of Q-(3, 2)> to <Elements of Q+(3, 4)>>
    gap> eqpts:=ImagesSet(em,AsList(Points(eq)));
    [ <a point in Q+(3, 4)>, <a point in Q+(3, 4)>, <a point in Q+(3, 4)>,
      <a point in Q+(3, 4)>, <a point in Q+(3, 4)> ]

##### 10.5-3 Embedding of polar spaces by field reduction

Field reduction for polar spaces is somewhat more involved than for projective spaces, and we give a brief description. Let L be the field GF(qt) and let K be the field GF(q) Let P be a polar space over a field L. Let f be the form on the r dimensional vector space V over L determining P. Consider the trace map

T: L -> K: x ↦ xqt + xqt-1 + … + x.

Define for any α ∈ L the map

Tα: L: → K: x↦ Tα = T(α x).

Consider the rt dimensional vector space W over K. There is a bijective map Φ: V -> W and Tα • f • Φ -1 defines a quadratic or sesquilinear form (depending on α, and f being quadratic or sesquilinear) acting on W, and hence, if not singular or degenerate, inducing a polar space S over the finite field GF(q). An element of P can be mapped onto an element of S by simply blowing up P using field reduction for projective spaces. So the resulting polar space S is dependent on the original form f, the parameter α and the blowing up of elements by field reduction, the latter being dependent on the basis of L as a K vector space. FinInG provides two approaches. The first approach starts from P and the parameters K, α and a basis for L as K vector space. Then the resulting form Tα • f • Φ -1 is determined, and the associated polar space S will be the range of the embedding. Note that the resulting polar space will not necessarily be canonical. The second approach starts from two given polar spaces P and S. Based on this input, it is determined whether an embedding based on the above described principle is possible, and the necessary parameters are computed. The resulting embedding is a geometry morphism from P to S. Note that the polar spaces used as an argument may be freely chosen and are not required to be in the canonical form.

For more information on the embeddings by field reduction of polar spaces, including conditions on the parameter α, we refer to [Gil08] and [LVdV13]. The possible embeddings are listed in the following table.

Table: Field reduction of polar spaces
Polar Space 1 | Polar Space 2 | Conditions
W(2n-1,qt) | W(2nt-1,q) | --
Q+(2n-1,qt) | Q+(2nt-1,q) | --
Q-(2n-1,qt) | Q-(2nt-1,q) | --
Q(2n,q2a+1) | Q((2a+1)(2n+1)-1,q) | q odd
Q(2n,q2a) | Q-(2a(2n+1)-1,q) | q ≡ 1 mod 4
Q(2n,q4a+2) | Q+((4a+2)(2n+1)-1,q) | q ≡ 3 mod 4
Q(2n,q4a) | Q-(4a(2n+1)-1,q) | q ≡ 3 mod 4
H(n,q2a+1) | H((2a+1)(n+1)-1,q) | q square
H(n,q2a) | W(2a(n+1)-1,q) | q even
H(2n,q2a) | Q-(2a(2n+1)-1,q) | q odd
H(2n+1,q2a) | Q+(2a(2n+2)-1,q) | q odd

##### 10.5-4 NaturalEmbeddingByFieldReduction

`‣ NaturalEmbeddingByFieldReduction`( ps1, f2, alpha, basis, bool ) | ( operation )

`‣ NaturalEmbeddingByFieldReduction`( ps1, f2, alpha, basis ) | ( operation )

`‣ NaturalEmbeddingByFieldReduction`( ps1, f2, alpha, bool ) | ( operation )

`‣ NaturalEmbeddingByFieldReduction`( ps1, f2, alpha ) | ( operation )

`‣ NaturalEmbeddingByFieldReduction`( ps1, f2, bool ) | ( operation )

`‣ NaturalEmbeddingByFieldReduction`( ps1, f2 ) | ( operation )

Returns: a geometry morphism

ps1 is a polar space over a field extension L of f2, basis is a basis for L over f2, alpha is a non-zero element of L. The version of `NaturalEmbeddingByFieldReduction` implements the first approach as explained in 10.5-3. When no argument basis is given, a basis for L over f2 is computed using `Basis(Asvector space(K,L))`. When no argument alpha is given, `One(f2)` is used as value for alpha. When bool is true or not given, an intertwiner is computed, when bool is false, no intertwiner is computed. This intertwiner has as its domain the isometry group of ps1. The user may wish that the intertwiner is not computed when embedding large polar spaces. The default (when calling the operation with two arguments) is set to `true`. In the first example, we construct a spread of maximal subspaces (solids) in a 7 dimensional symplectic space. We compute a subgroup of its stabilizer group using the intertwiner. In the second example, we construct a linear blocking set of the symplectic generalised quadrangle over GF(9) .

    gap> ps1 := SymplecticSpace(1,3^3);
    W(1, 27)
    gap> em := NaturalEmbeddingByFieldReduction(ps1,GF(3),true);
    <geometry morphism from <Elements of W(1,
    27)> to <Elements of <polar space in ProjectiveSpace(
    5,GF(3)): -x1*y6-x2*y5-x3*y4-x3*y6+x4*y3+x5*y2+x6*y1+x6*y3=0 >>>
    gap> ps2 := AmbientGeometry(Range(em));
    <polar space in ProjectiveSpace(
    5,GF(3)): -x1*y6-x2*y5-x3*y4-x3*y6+x4*y3+x5*y2+x6*y1+x6*y3=0 >
    gap> spread := List(Points(ps1),x->x^em);;
    gap> i := Intertwiner(em);
    MappingByFunction( PSp(2,27), <projective collineation group of size
    9828 with 2 generators>, function( m ) ... end, function( m ) ... end )
    gap> coll := CollineationGroup(ps2);
    #I  Computing collineation group of canonical polar space...
    <projective collineation group of size 9170703360 with 4 generators>
    gap> stab := Group(ImagesSet(i,GeneratorsOfGroup(IsometryGroup(ps1))));
    <projective collineation group with 2 generators>
    gap> IsSubgroup(coll,stab);
    true
    gap> List(Orbit(stab,spread[1]),x->x in spread);
    [ true, true, true, true, true, true, true, true, true, true, true, true,
      true, true, true, true, true, true, true, true, true, true, true, true,
      true, true, true, true ]

    gap> ps1 := SymplecticSpace(3,9);
    W(3, 9)
    gap> em := NaturalEmbeddingByFieldReduction(ps1,GF(3),true);
    <geometry morphism from <Elements of W(3,
    9)> to <Elements of <polar space in ProjectiveSpace(
    7
     ,GF(3)): -x1*y3+x1*y4+x2*y3+x3*y1-x3*y2-x4*y1-x5*y7+x5*y8+x6*y7+x7*y5-x7*y6-x8
    *y5=0 >>>
    gap> ps2 := AmbientGeometry(Range(em));
    <polar space in ProjectiveSpace(
    7
     ,GF(3)): -x1*y3+x1*y4+x2*y3+x3*y1-x3*y2-x4*y1-x5*y7+x5*y8+x6*y7+x7*y5-x7*y6-x8
    *y5=0 >
    gap> pg := AmbientSpace(ps2);
    ProjectiveSpace(7, 3)
    gap> spread := List(Points(ps1),x->x^em);;
    gap> el := Random(ElementsOfIncidenceStructure(pg,5));
    <a proj. 4-space in ProjectiveSpace(7, 3)>
    gap> prebs := Filtered(spread,x->Meet(x,el) <> EmptySubspace(pg));;
    gap> bs := List(prebs,x->PreImageElm(em,x));;
    gap> Length(bs);
    118
    gap> lines := List(Lines(ps1));;
    gap> Collected(List(lines,x->Length(Filtered(bs,y->y * x))));
    [ [ 1, 702 ], [ 4, 117 ], [ 10, 1 ] ]

##### 10.5-5 NaturalEmbeddingByFieldReduction

`‣ NaturalEmbeddingByFieldReduction`( ps1, ps2, bool ) | ( operation )

`‣ NaturalEmbeddingByFieldReduction`( ps1, ps2 ) | ( operation )

Returns: a geometry morphism

If ps1 and ps2 are two polar spaces which are suitable for field reduction as listed in the table with possible embeddings in Section 10.5-3, then this operation returns the corresponding embedding. An intertwiner is computed if the third argument bool is true, or if there is no third argument. This intertwiner has as its domain the isometry group of ps1. The example shows two cases where a spread is computed, including a subgroup of its stabiliser group using the intertwiner.

    gap> ps1 := SymplecticSpace(1,5^3);
    W(1, 125)
    gap> ps2 := SymplecticSpace(5,5);
    W(5, 5)
    gap> em := NaturalEmbeddingByFieldReduction(ps1,ps2);
    #I  These polar spaces are suitable for field reduction
    <geometry morphism from <Elements of W(1, 125)> to <Elements of W(5, 5)>>
    gap> pts := Points(ps1);
    <points of W(1, 125)>
    gap> spread := List(pts,x->x^em);;
    gap> test := Union(List(spread,x->List(Points(x))));;
    gap> Set(test)=Set(AsList(Points(ps2)));
    true
    gap> hom := Intertwiner(em);
    MappingByFunction( PSp(2,125), <projective collineation group of size
    976500 with 2 generators>, function( m ) ... end, function( m ) ... end )
    gap> group := IsometryGroup(ps1);
    PSp(2,125)
    gap> Order(group);
    976500
    gap> gens := List(GeneratorsOfGroup(group),x->x^hom);
    [ < a collineation: <cmat 6x6 over GF(5,1)>, F^0>,
      < a collineation: <cmat 6x6 over GF(5,1)>, F^0> ]
    gap> group2 := Range(hom);
    <projective collineation group of size 976500 with 2 generators>
    gap> Order(group2);
    976500
    gap> biggroup := CollineationGroup(ps2);
    PGammaSp(6,5)
    gap> stab := FiningSetwiseStabiliser(biggroup,spread);
    #I  Computing adjusted stabilizer chain...
    <projective collineation group with 7 generators>
    gap> time;
    6907
    gap> Order(stab);
    5859000
    gap> ps1 := HermitianPolarSpace(2,7^2);
    H(2, 7^2)
    gap> ps2 := EllipticQuadric(5,7);
    Q-(5, 7)
    gap> em := NaturalEmbeddingByFieldReduction(ps1,ps2);
    #I  These polar spaces are suitable for field reduction
    <geometry morphism from <Elements of H(2, 7^2)> to <Elements of Q-(5, 7)>>
    gap> pts := Points(ps1);
    <points of H(2, 7^2)>
    gap> spread := List(pts,x->x^em);;
    gap> test := Union(List(spread,x->List(Points(x))));;
    gap> Set(test)=Set(AsList(Points(ps2)));
    true
    gap> hom := Intertwiner(em);
    MappingByFunction( PGU(3,7^2), <projective collineation group of size
    5663616 with 2 generators>, function( m ) ... end, function( m ) ... end )
    gap> group := IsometryGroup(ps1);
    PGU(3,7^2)
    gap> Order(group);
    5663616
    gap> gens := List(GeneratorsOfGroup(group),x->x^hom);
    [ < a collineation: <cmat 6x6 over GF(7,1)>, F^0>,
      < a collineation: <cmat 6x6 over GF(7,1)>, F^0> ]
    gap> group2 := Range(hom);
    <projective collineation group of size 5663616 with 2 generators>
    gap> Order(group2);
    5663616
    gap> biggroup := CollineationGroup(ps2);
    PDeltaO-(6,7)
    gap> stab := FiningSetwiseStabiliser(biggroup,spread);
    #I  Computing adjusted stabilizer chain...
    <projective collineation group with 10 generators>
    gap> time;
    3438
    gap> Order(stab);
    90617856

#### 10.6 Projections

##### 10.6-1 NaturalProjectionBySubspace

`‣ NaturalProjectionBySubspace`( ps, v ) | ( operation )

Returns: a geometry morphism

The argument ps is a projective or polar space, and v is a subspace of ps. In the case that ps is a projective space, the geometry of subspaces containing v is a projective space of lower dimension over the same base field, and this operation returns the corresponding geometry morphism. In the case that ps is a polar space, the geometry of elements pf ps containing v is a polar space of lower rank and of the same type over the same base field, and this operation returns the corresponding geometry morphism. It is checked whether v is a subspace of ps, and whether the input of the function and preimage of the returned geometry morphism is valid or not. There is a shorthand for this operation which is basically an overload of the quotient operation. So, for example, `ps / v` achieves the same thing as `AmbientGeometry(Range(NaturalProjectionBySubspace(ps, v)))`. An intertwiner is not available for this geometry morphism.

    gap> ps := HyperbolicQuadric(5,3);
    Q+(5, 3)
    gap> x := Random(Points(ps));;
    gap> planes_on_x := AsList( Planes(x) );
    [ <a plane in Q+(5, 3)>, <a plane in Q+(5, 3)>, <a plane in Q+(5, 3)>,
      <a plane in Q+(5, 3)>, <a plane in Q+(5, 3)>, <a plane in Q+(5, 3)>,
      <a plane in Q+(5, 3)>, <a plane in Q+(5, 3)> ]
    gap> proj := NaturalProjectionBySubspace(ps, x);
    <geometry morphism from <Elements of Q+(5,
    3)> to <Elements of <polar space in ProjectiveSpace(
    3,GF(3)): x_1*x_2+x_3*x_4=0 >>>
    gap> image := ImagesSet(proj, planes_on_x);
    [ <a line in Q+(3, 3): x_1*x_2+x_3*x_4=0>,
      <a line in Q+(3, 3): x_1*x_2+x_3*x_4=0>,
      <a line in Q+(3, 3): x_1*x_2+x_3*x_4=0>,
      <a line in Q+(3, 3): x_1*x_2+x_3*x_4=0>,
      <a line in Q+(3, 3): x_1*x_2+x_3*x_4=0>,
      <a line in Q+(3, 3): x_1*x_2+x_3*x_4=0>,
      <a line in Q+(3, 3): x_1*x_2+x_3*x_4=0>,
      <a line in Q+(3, 3): x_1*x_2+x_3*x_4=0> ]

#### 10.7 Projective completion

##### 10.7-1 ProjectiveCompletion

`‣ ProjectiveCompletion`( as ) | ( operation )

Returns: a geometry morphism

The argument as is an affine space. This operation returns an embedding of as into the projective space ps of the same dimension, and over the same field. For example, the point (x, y, z) is mapped onto the projective point with homogeneous coordinates (1, x, y, z). An intertwiner is unnecessary, `CollineationGroup(as)` is a subgroup of `CollineationGroup(ps)`.

    gap> as := AffineSpace(3,5);
    AG(3, 5)
    gap> map := ProjectiveCompletion(as);
    <geometry morphism from <Elements of AG(3,
    5)> to <All elements of ProjectiveSpace(3, 5)>>
    gap> p := Random( Points(as) );
    <a point in AG(3, 5)>
    gap> p^map;
    <a point in ProjectiveSpace(3, 5)>

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C Bib Ind

generated by GAPDoc2HTML