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 + \ldots + X_{n-1}X_n\) | \(p \equiv 3 \pmod{4}\) or \(p=2\) | odd | "hyperbolic", "+", or "1" |

hyperbolic quadric | \(2(X_0 X_1 + \ldots + X_{n-1}X_n)\) | \(p \equiv 1 \pmod{4}\) | odd | "hyperbolic", "+", or "1" |

parabolic quadric | X_{0}^{2} + X_{1} X_{2} + ... + X_{n-1}X_{n} |
\(p \equiv 1,3 \pmod{8}\) or \(p=2\) | even | "parabolic", "o", or "0" |

parabolic quadric | \(t(X_0^2 + X_1X_2 + \ldots + X_{n-1}X_n)\), \(t\) a primitve element of \(\mathrm{GF}(p)\) | \(p \equiv 5,7 \pmod{8}\) | even | "parabolic", "o", or "0" |

elliptic quadric | \(X_0^2 + X_1^2 + X_2X_3 + \ldots + X_{n-1}X_n\) | \(p \equiv 3 \pmod{4}\) | odd | "elliptic", "-", or "-1" |

elliptic quadric | \(X_0^2 + tX_1^2 + X_2X_3 + \ldots + X_{n-1}X_n\), \(t\) a primitive element of \(\mathrm{GF}(p)\) | \(p \equiv 1 \pmod{4}\) | odd | "elliptic", "-", or "-1" |

elliptic quadric | \(X_0^2 + X_0X_1 + dX_1^2 + X_2X_3 + \ldots + X_{n-1}X_n\), \(\mathrm{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