11 Algebraic Varieties

In **FinInG** we provide some basic functionality for algebraic varieties defined over finite fields. The algebraic varieties in **FinInG** are defined by a list of multivariate polynomials over a finite field, and an ambient geometry. This ambient geometry is either a projective space, and then the algebraic variety is called a *projective variety*, or an affine geometry, and then the algebraic variety is called an *affine variety*. In this chapter we give a brief overview of the features of **FinInG** concerning these two types of algebraic varieties. The package **FinInG** also contains the Veronese varieties `VeroneseVariety`

(11.7-1), the Segre varieties `SegreVariety`

(11.6-1) and the Grassmann varieties `GrassmannVariety`

(11.8-1); three classical projective varieties. These varieties have an associated *geometry map* (the `VeroneseMap`

(11.7-3), `SegreMap`

(11.6-3) and `GrassmannMap`

(11.8-3)) and **FinInG** also provides some general functionality for these.

An *algebraic variety* in **FinInG** is an algebraic variety in a projective space or affine space, defined by a list of polynomials over a finite field.

`‣ AlgebraicVariety` ( space, pring, pollist ) | ( operation ) |

`‣ AlgebraicVariety` ( space, pollist ) | ( operation ) |

Returns: an algebraic variety

The argument `space` is an affine or projective space over a finite field `F`, the argument `pring` is a multivariate polynomial ring defined over (a subfield of) `F`, and `pollist` is a list of polynomials in `pring`. If the `space` is a projective space, then `pollist` needs to be a list of homogeneous polynomials. In **FinInG** there are two types of projective varieties: projective varieties and affine varieties. The following operations apply to both types.

gap> F:=GF(9); GF(3^2) gap> r:=PolynomialRing(F,4); GF(3^2)[x_1,x_2,x_3,x_4] gap> pg:=PG(3,9); ProjectiveSpace(3, 9) gap> f1:=r.1*r.3-r.2^2; x_1*x_3-x_2^2 gap> f2:=r.4*r.1^2-r.4^3; x_1^2*x_4-x_4^3 gap> var:=AlgebraicVariety(pg,[f1,f2]); Projective Variety in ProjectiveSpace(3, 9) gap> DefiningListOfPolynomials(var); [ x_1*x_3-x_2^2, x_1^2*x_4-x_4^3 ] gap> AmbientSpace(var); ProjectiveSpace(3, 9)

`‣ DefiningListOfPolynomials` ( var ) | ( attribute ) |

Returns: a list of polynomials

The argument `var` is an algebraic variety. This attribute returns the list of polynomials that was used to define the variety `var`.

`‣ AmbientSpace` ( var ) | ( attribute ) |

Returns: an affine or projective space

The argument `var` is an algebraic variety. This attribute returns the affine or projective space in which the variety `var` was defined.

`‣ PointsOfAlgebraicVariety` ( var ) | ( operation ) |

`‣ Points` ( var ) | ( operation ) |

Returns: a list of points

The argument `var` is an algebraic variety. This operation returns the list of points of the `AmbientSpace`

(11.1-3) of the algebraic variety `var` whose coordinates satify the `DefiningListOfPolynomials`

(11.1-2) of the algebraic variety `var`.

gap> F:=GF(9); GF(3^2) gap> r:=PolynomialRing(F,4); GF(3^2)[x_1,x_2,x_3,x_4] gap> pg:=PG(3,9); ProjectiveSpace(3, 9) gap> f1:=r.1*r.3-r.2^2; x_1*x_3-x_2^2 gap> f2:=r.4*r.1^2-r.4^3; x_1^2*x_4-x_4^3 gap> var:=AlgebraicVariety(pg,[f1,f2]); Projective Variety in ProjectiveSpace(3, 9) gap> points:=Points(var); <points of Projective Variety in ProjectiveSpace(3, 9)> gap> Size(points); 28 gap> iter := Iterator(points); <iterator> gap> for i in [1..4] do > x := NextIterator(iter); > Display(x); > od; [1...] [1..1] [1..2] [111.]

`‣ Iterator` ( pts ) | ( operation ) |

Returns: an iterator

The argument `pts` is the set of `PointsOfAlgebraicVariety`

(11.1-4) of an algebraic variety `var`. This operation returns an iterator for the points of an algebraic variety.

`11.1-6 \in`

`‣ \in` ( x, var ) | ( operation ) |

`‣ \in` ( x, pts ) | ( operation ) |

Returns: true or false

The argument `x` is a point of the `AmbientSpace`

(11.1-3) of an algebraic variety `AlgebraicVariety`

(11.1-1). This operation also works for a point `x` and the collection `pts` returned by `PointsOfAlgebraicVariety`

(11.1-4).

A *projective variety* in **FinInG** is an algebraic variety in a projective space defined by a list of homogeneous polynomials over a finite field.

`‣ ProjectiveVariety` ( pg, pring, pollist ) | ( operation ) |

`‣ ProjectiveVariety` ( pg, pollist ) | ( operation ) |

`‣ AlgebraicVariety` ( pg, pring, pollist ) | ( operation ) |

`‣ AlgebraicVariety` ( pg, pollist ) | ( operation ) |

Returns: a projective algebraic variety

gap> F:=GF(9); GF(3^2) gap> r:=PolynomialRing(F,4); GF(3^2)[x_1,x_2,x_3,x_4] gap> pg:=PG(3,9); ProjectiveSpace(3, 9) gap> f1:=r.1*r.3-r.2^2; x_1*x_3-x_2^2 gap> f2:=r.4*r.1^2-r.4^3; x_1^2*x_4-x_4^3 gap> var:=AlgebraicVariety(pg,[f1,f2]); Projective Variety in ProjectiveSpace(3, 9) gap> DefiningListOfPolynomials(var); [ x_1*x_3-x_2^2, x_1^2*x_4-x_4^3 ] gap> AmbientSpace(var); ProjectiveSpace(3, 9)

Quadrics (`QuadraticVariety`

(11.3-2)) and Hermitian varieties (`HermitianVariety`

(11.3-1)) are projective varieties that have the associated quadratic or hermitian form as an extra attribute installed. Furthermore, we provide a method for `PolarSpace`

taking as an argument a projective algebraic variety.

`‣ HermitianVariety` ( pg, pring, pol ) | ( operation ) |

`‣ HermitianVariety` ( pg, pol ) | ( operation ) |

`‣ HermitianVariety` ( n, F ) | ( operation ) |

`‣ HermitianVariety` ( n, q ) | ( operation ) |

Returns: a hermitian variety in a projective space

For the first two methods, the argument `pg` is a projective space, `pring` is a polynomial ring, and `pol` is polynomial. For the third and fourth variations, the argument `n` is an integer, the argument `F` is a finite field, and the argument `q` is a prime power. These variations of the operation return the hermitian variety associated to the standard hermitian form in the projective space of dimension n over the field F of order q.

gap> F:=GF(25); GF(5^2) gap> r:=PolynomialRing(F,3); GF(5^2)[x_1,x_2,x_3] gap> x:=IndeterminatesOfPolynomialRing(r); [ x_1, x_2, x_3 ] gap> pg:=PG(2,F); ProjectiveSpace(2, 25) gap> f:=x[1]^6+x[2]^6+x[3]^6; x_1^6+x_2^6+x_3^6 gap> hv:=HermitianVariety(pg,f); Hermitian Variety in ProjectiveSpace(2, 25) gap> AsSet(List(Lines(pg),l->Size(Filtered(Points(l),x->x in hv)))); [ 1, 6 ] gap> hv:=HermitianVariety(5,4); Hermitian Variety in ProjectiveSpace(5, 4) gap> hps:=PolarSpace(hv); <polar space in ProjectiveSpace( 5,GF(2^2)): x_1^3+x_2^3+x_3^3+x_4^3+x_5^3+x_6^3=0 > gap> hf:=SesquilinearForm(hv); < hermitian form > gap> PolynomialOfForm(hf); x_1^3+x_2^3+x_3^3+x_4^3+x_5^3+x_6^3

`‣ QuadraticVariety` ( pg, pring, pol ) | ( operation ) |

`‣ QuadraticVariety` ( pg, pol ) | ( operation ) |

`‣ QuadraticVariety` ( n, F, type ) | ( operation ) |

`‣ QuadraticVariety` ( n, q, type ) | ( operation ) |

`‣ QuadraticVariety` ( n, F ) | ( operation ) |

`‣ QuadraticVariety` ( n, q ) | ( operation ) |

Returns: a quadratic variety in a projective space

In the first two methods, the argument `pg` is a projective space, `pring` is a polynomial ring, and `pol` is a polynomial. The latter four return a standard non-degenerate quadric. The argument `n` is a projective dimension, `F` is a field, and `q` is a prime power that gives just the order of the defining field. If the `type` is given, then it will return a quadric of a particular type as follows:

variety | standard form | characteristic p | proj. dim. | type |

hyperbolic quadric | X_{0} X_{1} + ... + X_{n-1}X_{n} |
p ≡ 3 mod 4 or p=2 | odd | "hyperbolic", "+", or "1" |

hyperbolic quadric | 2(X_{0} X_{1} + ... + X_{n-1}X_{n} ) |
p ≡ 1 mod 4 | odd | "hyperbolic", "+", or "1" |

parabolic quadric | X_{0}^{2} + X_{1} X_{2} + ... + X_{n-1}X_{n} |
p ≡ 1,3 mod 8 or p=2 | even | "parabolic", "o", or "0" |

parabolic quadric | t(X_{0}^{2} + X_{1} X_{2} + ... + X_{n-1}X_{n}), t a primitive element of GF(p) |
p ≡ 5,7 mod 8 | even | "parabolic", "o", or "0" |

elliptic quadric | X_{0}^{2} + X_{1}^{2} + X_{2} X_{3} + ... + X_{n-1}X_{n} |
p ≡ 3 mod 4 | odd | "elliptic", "-", or "-1" |

elliptic quadric | X_{0}^{2} + tX_{1}^{2} + X_{2} X_{3} + ... + X_{n-1}X_{n}, t a primitive element of GF(p) |
p ≡ 1 mod 4 | odd | "elliptic", "-", or "-1" |

elliptic quadric | X_{0}^{2} + X_{0}X_{1} + d X_{1}^{2} + X_{2} X_{3} + ... + X_{n-1}X_{n} , Tr(d) = 1 |
even | odd | "elliptic", "-", or "-1" |

If no type is given, and only the dimension and field/field order are given, then it is assumed that the dimension is even and the user wants a standard parabolic quadric.

gap> F:=GF(5); GF(5) gap> r:=PolynomialRing(F,4); GF(5)[x_1,x_2,x_3,x_4] gap> x:=IndeterminatesOfPolynomialRing(r); [ x_1, x_2, x_3, x_4 ] gap> pg:=PG(3,F); ProjectiveSpace(3, 5) gap> Q:=x[2]*x[3]+x[4]^2; x_2*x_3+x_4^2 gap> qv:=QuadraticVariety(pg,Q); Quadratic Variety in ProjectiveSpace(3, 5) gap> AsSet(List(Planes(pg),z->Size(Filtered(Points(z),x->x in qv)))); [ 1, 6, 11 ] gap> qf:=QuadraticForm(qv); < quadratic form > gap> Display(qf); Quadratic form Gram Matrix: . . . . . . 1 . . . . . . . . 1 Polynomial: [ [ x_2*x_3+x_4^2 ] ] gap> IsDegenerateForm(qf); #I Testing degeneracy of the *associated bilinear form* true gap> qv:=QuadraticVariety(3,F,"-"); Quadratic Variety in ProjectiveSpace(3, 5) gap> PolarSpace(qv); <polar space in ProjectiveSpace(3,GF(5)): x_1^2+Z(5)*x_2^2+x_3*x_4=0 > gap> Display(last); <polar space of rank 3 over GF(5)> Non-singular elliptic quadratic form Gram Matrix: 1 . . . . 2 . . . . . 1 . . . . Polynomial: [ [ x_1^2+Z(5)*x_2^2+x_3*x_4 ] ] Witt Index: 1 Bilinear form Gram Matrix: 2 . . . . 4 . . . . . 1 . . 1 . gap> qv:=QuadraticVariety(3,F,"+"); Quadratic Variety in ProjectiveSpace(3, 5) gap> Display(last); Quadratic Variety in ProjectiveSpace(3, 5) Polynomial: [ Z(5)*x_1*x_2+Z(5)*x_3*x_4 ]

`‣ QuadraticForm` ( var ) | ( attribute ) |

Returns: a quadratic form

When the argument `var` is a `QuadraticVariety`

(11.3-2), this returns the associated quadratic form.

`‣ SesquilinearForm` ( var ) | ( attribute ) |

Returns: a hermitian form

If the argument `var` is a `HermitianVariety`

(11.3-1), this returns the associated hermitian form.

`‣ PolarSpace` ( var ) | ( operation ) |

the argument `var` is a projective algebraic variety. When its list of definining polynomial contains exactly one polynomial, depending on its degree, the operation `QuadraticFormByPolynomial`

or `HermitianFormByPolynomial`

is used to compute a quadratic form or a hermitian form. These operations check whether this is possible, and produce an error message if not. If the conversion is possible, then the appropriate polar space is returned.

gap> f := GF(25); GF(5^2) gap> r := PolynomialRing(f,4); GF(5^2)[x_1,x_2,x_3,x_4] gap> ind := IndeterminatesOfPolynomialRing(r); [ x_1, x_2, x_3, x_4 ] gap> eq1 := Sum(List(ind,t->t^2)); x_1^2+x_2^2+x_3^2+x_4^2 gap> var := ProjectiveVariety(PG(3,f),[eq1]); Projective Variety in ProjectiveSpace(3, 25) gap> PolarSpace(var); <polar space in ProjectiveSpace(3,GF(5^2)): x_1^2+x_2^2+x_3^2+x_4^2=0 > gap> eq2 := Sum(List(ind,t->t^4)); x_1^4+x_2^4+x_3^4+x_4^4 gap> var := ProjectiveVariety(PG(3,f),[eq2]); Projective Variety in ProjectiveSpace(3, 25) gap> PolarSpace(var); Error, <poly> does not generate a Hermitian matrix called from GramMatrixByPolynomialForHermitianForm( pol, gf, n, vars ) called from HermitianFormByPolynomial( pol, pring, n ) called from HermitianFormByPolynomial( eq, r ) called from <function "unknown">( <arguments> ) called from read-eval loop at line 16 of *stdin* you can 'quit;' to quit to outer loop, or you can 'return;' to continue brk> quit; gap> eq3 := Sum(List(ind,t->t^6)); x_1^6+x_2^6+x_3^6+x_4^6 gap> var := ProjectiveVariety(PG(3,f),[eq3]); Projective Variety in ProjectiveSpace(3, 25) gap> PolarSpace(var); <polar space in ProjectiveSpace(3,GF(5^2)): x_1^6+x_2^6+x_3^6+x_4^6=0 >

An *affine variety* in **FinInG** is an algebraic variety in an affine space defined by a list of polynomials over a finite field.

`‣ AffineVariety` ( ag, pring, pollist ) | ( operation ) |

`‣ AffineVariety` ( ag, pollist ) | ( operation ) |

`‣ AlgebraicVariety` ( ag, pring, pollist ) | ( operation ) |

`‣ AlgebraicVariety` ( ag, pollist ) | ( operation ) |

Returns: an affine algebraic variety

The argument `ag` is an affine space over a finite field `F`, the argument `pring` is a multivariate polynomial ring defined over (a subfield of) `F`, and `pollist` is a list of polynomials in `pring`.

A `geometry map` is a map from a set of elements of a geometry to a set of elements of another geometry, which is not necessarily a geometry morphism. Examples are the `SegreMap`

(11.6-3), the `VeroneseMap`

(11.7-3), and the `GrassmannMap`

(11.8-3).

`‣ Source` ( gm ) | ( operation ) |

Returns: the source of a geometry map

The argument `gm` is a geometry map.

`‣ Range` ( gm ) | ( operation ) |

Returns: the range of a geometry map

The argument `gm` is a geometry map.

`‣ ImageElm` ( gm, x ) | ( operation ) |

Returns: the image of an element under a geometry map

The argument `gm` is a geometry map, the element `x` is an element of the `Source`

(11.5-1) of the geometry map `gm`.

`‣ ImagesSet` ( gm, elms ) | ( operation ) |

Returns: the image of a subset of the source under a geometry map

The argument `gm` is a geometry map, the elements `elms` is a subset of the `Source`

(11.5-1) of the geometry map `gm`.

`11.5-5 \^`

`‣ \^` ( x, gm ) | ( operation ) |

Returns: the image of an element of the source under a geometry map

The argument `gm` is a geometry map, the element `x` is an element of the `Source`

(11.5-1) of the geometry map `gm`.

A *Segre variety* in **FinInG** is a projective algebraic variety in a projective space over a finite field. The set of points that lie on this variety is the image of the *Segre map*.

`‣ SegreVariety` ( listofpgs ) | ( operation ) |

`‣ SegreVariety` ( listofdims, field ) | ( operation ) |

`‣ SegreVariety` ( pg1, pg2 ) | ( operation ) |

`‣ SegreVariety` ( d1, d2, field ) | ( operation ) |

`‣ SegreVariety` ( d1, d2, q ) | ( operation ) |

Returns: a Segre variety

The argument `listofpgs` is a list of projective spaces defined over the same finite field, say [PG(n_{1 }-1,q), PG(n_{2 }-1,q), ..., PG(n_{k }-1,q)]. The operation also takes as input the list of dimensions (`listofdims`) and a finite field `field` (e.g. [n_{1}, n_{2}, ..., n_{k},GF(q)]). A Segre variety with only two factors (k=2), can also be constructed using the operation with two projective spaces `pg1` and `pg2` as arguments, or with two dimensions `d1`, `d2`, and a finite field `field`(or a prime power `q`). The operation returns a projective algebraic variety in the projective space of dimension n_{1} n_{2} ... n_{k}-1.

`‣ PointsOfSegreVariety` ( sv ) | ( operation ) |

`‣ Points` ( sv ) | ( operation ) |

Returns: the points of a Segre variety

The argument `sv` is a Segre variety. This operation returns a set of points of the `AmbientSpace`

(11.1-3) of the Segre variety. This set of points corresponds to the image of the `SegreMap`

(11.6-3).

`‣ SegreMap` ( listofpgs ) | ( operation ) |

`‣ SegreMap` ( listofdims, field ) | ( operation ) |

`‣ SegreMap` ( pg1, pg2 ) | ( operation ) |

`‣ SegreMap` ( d1, d2, field ) | ( operation ) |

`‣ SegreMap` ( d1, d2, q ) | ( operation ) |

`‣ SegreMap` ( sv ) | ( operation ) |

Returns: a geometry map

The argument `listofpgs` is a list of projective spaces defined over the same finite field, say [PG(n_{1 }-1,q), PG(n_{2 }-1,q), ..., PG(n_{k }-1,q)]. The operation also takes as input the list of dimensions (`listofdims`) and a finite field `field` (e.g. [n_{1}, n_{2}, ..., n_{k},GF(q)]). A Segre map with only two factors (k=2), can also be constructed using the operation with two projective spaces `pg1` and `pg2` as arguments, or with two dimensions `d1`, `d2`, and a finite field `field`(or a prime power `q`). The operation returns a function with domain the product of the point sets of projective spaces in the list [PG(n_{1 }-1,q), PG(n_{2 }-1,q), ..., PG(n_{k }-1,q)] and image the set of points of the Segre variety (`PointsOfSegreVariety`

(11.6-2)) in the projective space of dimension n_{1} n_{2} ... n_{k}-1. When a Segre variety `sv` is given as input, the operation returns the associated Segre map.

gap> sv:=SegreVariety(2,2,9); Segre Variety in ProjectiveSpace(8, 9) gap> sm:=SegreMap(sv); Segre Map of [ <points of ProjectiveSpace(2, 9)>, <points of ProjectiveSpace(2, 9)> ] gap> cart1:=Cartesian(Points(PG(2,9)),Points(PG(2,9)));; gap> im1:=ImagesSet(sm,cart1);; gap> Span(im1); ProjectiveSpace(8, 9) gap> l:=Random(Lines(PG(2,9))); <a line in ProjectiveSpace(2, 9)> gap> cart2:=Cartesian(Points(l),Points(PG(2,9)));; gap> im2:=ImagesSet(sm,cart2);; gap> Span(im2); <a proj. 5-space in ProjectiveSpace(8, 9)> gap> x:=Random(Points(PG(2,9))); <a point in ProjectiveSpace(2, 9)> gap> cart3:=Cartesian(Points(PG(2,9)),Points(x));; gap> im3:=ImagesSet(sm,cart3);; gap> pi:=Span(im3); <a plane in ProjectiveSpace(8, 9)> gap> AsSet(List(Points(pi),y->y in sv)); [ true ]

`‣ Source` ( sm ) | ( operation ) |

Returns: the source of a Segre map

The argument `sm` is a `SegreMap`

(11.6-3). This operation returns the cartesian product of the list consisting of the pointsets of the projective spaces that were used to construct the `SegreMap`

(11.6-3).

A *Veronese variety* in **FinInG** is a projective algebraic variety in a projective space over a finite field. The set of points that lie on this variety is the image of the *Veronese map*.

`‣ VeroneseVariety` ( pg ) | ( operation ) |

`‣ VeroneseVariety` ( n-1, field ) | ( operation ) |

`‣ VeroneseVariety` ( n-1, q ) | ( operation ) |

Returns: a Veronese variety

The argument `pg` is a projective space defined over a finite field, say PG(n-1,q). The operation also takes as input the dimension and a finite field `field` (e.g. [n-1,q]). The operation returns a projective algebraic variety in the projective space of dimension (n^2+n)/2-1, known as the (quadratic) Veronese variety. It is the image of the map (x_{0},x_{1},...,x_{n})→ (x_{0}^{2},x_{0}x_{1},...,x_{0}x_{n},x_{1}^{2},x_{1}x_{2},...,x_{1}x_{n},...,x_{n}^{2})

`‣ PointsOfVeroneseVariety` ( vv ) | ( operation ) |

`‣ Points` ( vv ) | ( operation ) |

Returns: the points of a Veronese variety

The argument `vv` is a Veronese variety. This operation returns a set of points of the `AmbientSpace`

(11.1-3) of the Veronese variety. This set of points corresponds to the image of the `VeroneseMap`

(11.7-3).

`‣ VeroneseMap` ( pg ) | ( operation ) |

`‣ VeroneseMap` ( n-1, field ) | ( operation ) |

`‣ VeroneseMap` ( n-1, q ) | ( operation ) |

`‣ VeroneseMap` ( vv ) | ( operation ) |

Returns: a geometry map

The argument `pg` is a projective space defined over a finite field, say PG(n-1,q). The operation also takes as input the dimension and a finite field `field` (e.g. [n-1,q]). The operation returns a function with domain the product of the point set of the projective space PG(n-1,q) and image the set of points of the Veronese variety (`PointsOfVeroneseVariety`

(11.7-2)) in the projective space of dimension (n^2+n)/2-1. When a Veronese variety `vv` is given as input, the operation returns the associated Veronese map.

gap> pg:=PG(2,5); ProjectiveSpace(2, 5) gap> vv:=VeroneseVariety(pg); Veronese Variety in ProjectiveSpace(5, 5) gap> Size(Points(vv))=Size(Points(pg)); true gap> vm:=VeroneseMap(vv); Veronese Map of <points of ProjectiveSpace(2, 5)> gap> r:=PolynomialRing(GF(5),3); GF(5)[x_1,x_2,x_3] gap> f:=r.1^2-r.2*r.3; x_1^2-x_2*x_3 gap> c:=AlgebraicVariety(pg,r,[f]); Projective Variety in ProjectiveSpace(2, 5) gap> pts:=List(Points(c)); [ <a point in ProjectiveSpace(2, 5)>, <a point in ProjectiveSpace(2, 5)>, <a point in ProjectiveSpace(2, 5)>, <a point in ProjectiveSpace(2, 5)>, <a point in ProjectiveSpace(2, 5)>, <a point in ProjectiveSpace(2, 5)> ] gap> Dimension(Span(ImagesSet(vm,pts))); 4

`‣ Source` ( vm ) | ( operation ) |

Returns: the source of a Veronese map

The argument `vm` is a `VeroneseMap`

(11.7-3). This operation returns the pointset of the projective space that was used to construct the `VeroneseMap`

(11.7-3).

A *Grassmann variety* in **FinInG** is a projective algebraic variety in a projective space over a finite field. The set of points that lie on this variety is the image of the *Grassmann map*.

`‣ GrassmannVariety` ( k, pg ) | ( operation ) |

`‣ GrassmannVariety` ( subspaces ) | ( operation ) |

`‣ GrassmannVariety` ( k, n, q ) | ( operation ) |

Returns: a Grassmann variety

The argument `pg` is a projective space defined over a finite field, say PG(n,q), and argument `k` is an integer (k at least 1 and at most n-2) and denotes the projective dimension determining the Grassmann Variety. The operation also takes as input the set `subspaces` of subspaces of a projective space, or the dimension `k`, the dimension `n` and the size `q` of the finite field (k at least 1 and at most n-2). The operation returns a projective algebraic variety known as the Grassmann variety.

`‣ PointsOfGrassmannVariety` ( gv ) | ( operation ) |

`‣ Points` ( gv ) | ( operation ) |

Returns: the points of a Grassmann variety

The argument `gv` is a Grassmann variety. This operation returns a set of points of the `AmbientSpace`

(11.1-3) of the Grassmann variety. This set of points corresponds to the image of the `GrassmannMap`

(11.8-3).

`‣ GrassmannMap` ( k, pg ) | ( operation ) |

`‣ GrassmannMap` ( subspaces ) | ( operation ) |

`‣ GrassmannMap` ( k, n, q ) | ( operation ) |

`‣ GrassmannMap` ( gv ) | ( operation ) |

Returns: a geometry map

The argument `pg` is a projective space defined over a finite field, say PG(n,q), and argument `k` is an integer (k at least 1 and at most n-2), and denotes the projective dimension determining the Grassmann Variety. The operation also takes as input the set `subspaces` of subspaces of a projective space, or the dimension `k`, the dimension `n` and the size `q` of the finite field (k at least 1 and at most n-2). The operation returns a function with domain the set of subspaces of dimension k in the n-dimensional projective space over GF(q), and image the set of points of the Grassmann variety (`PointsOfGrassmannVariety`

(11.8-2)). When a Grassmann variety `gv` is given as input, the operation returns the associated Grassmann map.

`‣ Source` ( gm ) | ( operation ) |

Returns: the source of a Grassmann map

The argument `gm` is a `GrassmannMap`

(11.8-3). This operation returns the set of subspaces of the projective space that was used to construct the `GrassmannMap`

(11.8-3).

This is the chapter of the documentation describing generalised polygons. -->

generated by GAPDoc2HTML