GAP (FinInG) - Chapter 4: Projective Spaces

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]

4 Projective Spaces
4.1 Projective Spaces and basic operations
4.1-1 IsProjectiveSpace
4.1-2 ProjectiveSpace
4.1-3 ProjectiveDimension
4.1-4 BaseField
4.1-5 UnderlyingVectorSpace
4.1-6 AmbientSpace
4.2 Subspaces of projective spaces
4.2-1 VectorSpaceToElement
4.2-2 EmptySubspace
4.2-3 ProjectiveDimension
4.2-4 ElementsOfIncidenceStructure
4.2-5 Short names for ElementsOfIncidenceStructure
4.2-6 Incidence and containment
4.2-7 StandardFrame
4.2-8 Coordinates
4.2-9 DualCoordinatesOfHyperplane
4.2-10 HyperplaneByDualCoordinates
4.2-11 EquationOfHyperplane
4.2-12 AmbientSpace
4.2-13 BaseField
4.2-14 Random
4.2-15 RandomSubspace
4.2-16 Span
4.2-17 Meet
4.2-18 FlagOfIncidenceStructure
4.2-19 IsEmptyFlag
4.2-20 IsChamberOfIncidenceStructure
4.3 Shadows of Projective Subspaces
4.3-1 ShadowOfElement
4.3-2 ShadowOfFlag
4.3-3 ElementsIncidentWithElementOfIncidenceStructure
4.3-4 Short names for `ElementsIncidentWithElementOfIncidenceStructure`
4.4 Enumerating subspaces of a projective space
4.4-1 Iterator
4.4-2 Enumerator
4.4-3 List

### 4 Projective Spaces

In this chapter we describe how to use FinInG to work with finite projective spaces.

#### 4.1 Projective Spaces and basic operations

A projective space is a point-line incidence geometry, satisfying a few well known axioms. An axiomatic treatment can be found in [VY65a] and [VY65b]. In FinInG, we deal with finite Desarguesian projective spaces. It is well known that these geometries can be described completely using vector spaces over finite fields. The elements of the projective space are all nontrivial subspaces of the vector space. So the projective points are the one-dimensional subspaces, the projective lines are the two-dimensional subspaces, and so on. From the axiomatic point of view, a projective space is a point-line geometry, and has rank at least 2. But a projective line is obtained if we start with a two dimensional vector space. Starting with a one dimensional vector space yields a single projective point. Both examples are not a projective space in the axiomatic point of view, but in FinInG they are considered as projective spaces.

##### 4.1-1 IsProjectiveSpace

`‣ IsProjectiveSpace` | ( category )

This category is a subcategory of `IsLieGeometry`, and contains all finite Desarguesian projective spaces.

We refer the reader to [HT91] for the necessary background theory in case it is not provided in the manual.

##### 4.1-2 ProjectiveSpace

`‣ ProjectiveSpace`( d, F ) | ( operation )

`‣ ProjectiveSpace`( d, q ) | ( operation )

`‣ PG`( d, q ) | ( operation )

Returns: a projective space

d must be a positive integer. In the first form, F is a field and the function returns the projective space of dimension d over F. In the second form, q is a prime power specifying the size of the field. The user may also use an alias, namely, the common abbreviation `PG(d, q)`.

    gap> ProjectiveSpace(3,GF(3));
    ProjectiveSpace(3, 3)
    gap> ProjectiveSpace(3,3);
    ProjectiveSpace(3, 3)

##### 4.1-3 ProjectiveDimension

`‣ ProjectiveDimension`( ps ) | ( attribute )

`‣ Dimension`( ps ) | ( attribute )

`‣ Rank`( ps ) | ( attribute )

Returns: the projective dimension of the projective space ps

    gap> ps := PG(5,8);
    ProjectiveSpace(5, 8)
    gap> ProjectiveDimension(ps);
    5
    gap> Dimension(ps);
    5
    gap> Rank(ps);
    5

##### 4.1-4 BaseField

`‣ BaseField`( ps ) | ( operation )

Returns: returns the base field for the projective space ps

    gap> BaseField(ProjectiveSpace(3,81));
    GF(3^4)

##### 4.1-5 UnderlyingVectorSpace

`‣ UnderlyingVectorSpace`( ps ) | ( operation )

Returns: a vector space

If ps is a projective space of dimension n over the field of order q, then this operation simply returns the underlying vector space, i.e. the n+1 dimensional vector space over the field of order q.

    gap> ps := ProjectiveSpace(4,7);
    ProjectiveSpace(4, 7)
    gap> vs := UnderlyingVectorSpace(ps);
    ( GF(7)^5 )

##### 4.1-6 AmbientSpace

`‣ AmbientSpace`( ps ) | ( attribute )

Returns: a projective space

The ambient space of a projective space ps is the projective space itself. Hence, simply ps will be returned.

#### 4.2 Subspaces of projective spaces

The elements of a projective space PG(n,q) are the subspaces of a suitable dimension. The empty subspace, also called the trivial subspace, has dimension -1 and corresponds to the zero dimensional vector subspace of the underlying vector space of PG(n,q), and is hence represented by the zero vector of length n+1 over the underlying field GF(q). The trivial subspace and the whole projective space are mathematically considered as a subspace of the projective geometry, but not as elements of the incidence geometry, and hence do in FinInG not belong to the category `IsSubspaceOfProjectiveSpace`.

##### 4.2-1 VectorSpaceToElement

`‣ VectorSpaceToElement`( geo, v ) | ( operation )

Returns: an element

geo is a projective space, and v is either a row vector (for points) or an m × n matrix (for an (m-1)-subspace of projective space of dimension n-1). In the case that v is a matrix, the rows represent generators for the subspace. An exceptional case is when v is a zero-vector, in which case the trivial subspace is returned.

    gap> ps := ProjectiveSpace(6,7);
    ProjectiveSpace(6, 7)
    gap> v := [3,5,6,0,3,2,3]*Z(7)^0;
    [ Z(7), Z(7)^5, Z(7)^3, 0*Z(7), Z(7), Z(7)^2, Z(7) ]
    gap> p := VectorSpaceToElement(ps,v);
    <a point in ProjectiveSpace(6, 7)>
    gap> Display(p);
    [142.131]
    gap> ps := ProjectiveSpace(3,4);
    ProjectiveSpace(3, 4)
    gap> v := [1,1,0,1]*Z(4)^0;
    [ Z(2)^0, Z(2)^0, 0*Z(2), Z(2)^0 ]
    gap> p := VectorSpaceToElement(ps,v);
    <a point in ProjectiveSpace(3, 4)>
    gap> mat := [[1,0,0,1],[0,1,1,0]]*Z(4)^0;
    [ [ Z(2)^0, 0*Z(2), 0*Z(2), Z(2)^0 ], [ 0*Z(2), Z(2)^0, Z(2)^0, 0*Z(2) ] ]
    gap> line := VectorSpaceToElement(ps,mat);
    <a line in ProjectiveSpace(3, 4)>
    gap> e := VectorSpaceToElement(ps,[]);
    Error, <v> does not represent any element called from
    <function "unknown">( <arguments> )
     called from read-eval loop at line 17 of *stdin*
    you can 'quit;' to quit to outer loop, or
    you can 'return;' to continue
    brk> quit;

##### 4.2-2 EmptySubspace

`‣ EmptySubspace`( ps ) | ( operation )

Returns: the trivial subspace in the projective ps

The object returned by this operation is contained in every projective subspace of the projective space ps, but is not an element of ps. Hence, testing incidence results in an error message.

    gap> e := EmptySubspace(PG(5,9));
    < empty subspace >
    gap> p := VectorSpaceToElement(PG(5,9),[1,0,0,0,0,0]*Z(9)^0);
    <a point in ProjectiveSpace(5, 9)>
    gap> e*p;
    Error, no method found! For debugging hints type ?Recovery from NoMethodFound
    Error, no 1st choice method found for `*' on 2 arguments called from
    <function "HANDLE_METHOD_NOT_FOUND">( <arguments> )
     called from read-eval loop at line 10 of *stdin*
    you can 'quit;' to quit to outer loop, or
    you can 'return;' to continue
    brk> quit;
    gap> e in p;
    true

##### 4.2-3 ProjectiveDimension

`‣ ProjectiveDimension`( sub ) | ( operation )

Returns: the projective dimension of a subspace of a projective space. The operation `ProjectiveDimension` is also applicable on the EmptySubspace.

    gap> ps := PG(2,5);
    ProjectiveSpace(2, 5)
    gap> v := [[1,1,0],[0,3,2]]*Z(5)^0;
    [ [ Z(5)^0, Z(5)^0, 0*Z(5) ], [ 0*Z(5), Z(5)^3, Z(5) ] ]
    gap> line := VectorSpaceToElement(ps,v);
    <a line in ProjectiveSpace(2, 5)>
    gap> ProjectiveDimension(line);
    1
    gap> Dimension(line);
    1
    gap> p := VectorSpaceToElement(ps,[1,2,3]*Z(5)^0);
    <a point in ProjectiveSpace(2, 5)>
    gap> ProjectiveDimension(p);
    0
    gap> Dimension(p);
    0
    gap> ProjectiveDimension(EmptySubspace(ps));
    -1

##### 4.2-4 ElementsOfIncidenceStructure

`‣ ElementsOfIncidenceStructure`( ps, j ) | ( operation )

Returns: the collection of elements of the projective space ps of type j

For the projective space ps of dimension d and the type j (where 1 ≤ j ≤ d), this operation returns the collection of j-1 dimensional subspaces. An error message is produced when the projective space ps has no elements of the required type.

    gap> ps := ProjectiveSpace(6,7);
    ProjectiveSpace(6, 7)
    gap> ElementsOfIncidenceStructure(ps,1);
    <points of ProjectiveSpace(6, 7)>
    gap> ElementsOfIncidenceStructure(ps,2);
    <lines of ProjectiveSpace(6, 7)>
    gap> ElementsOfIncidenceStructure(ps,3);
    <planes of ProjectiveSpace(6, 7)>
    gap> ElementsOfIncidenceStructure(ps,4);
    <solids of ProjectiveSpace(6, 7)>
    gap> ElementsOfIncidenceStructure(ps,5);
    <proj. 4-subspaces of ProjectiveSpace(6, 7)>
    gap> ElementsOfIncidenceStructure(ps,6);
    <proj. 5-subspaces of ProjectiveSpace(6, 7)>
    gap> ElementsOfIncidenceStructure(ps,7);
    Error, <ps> has no elements of type <j> called from
    <function "unknown">( <arguments> )
     called from read-eval loop at line 15 of *stdin*
    you can 'quit;' to quit to outer loop, or
    you can 'return;' to continue
    brk> quit;

##### 4.2-5 Short names for ElementsOfIncidenceStructure

`‣ Points`( ps ) | ( operation )

`‣ Lines`( ps ) | ( operation )

`‣ Planes`( ps ) | ( operation )

`‣ Solids`( ps ) | ( operation )

`‣ Hyperplanes`( ps ) | ( operation )

Returns: The elements of ps of respective type 1, 2, 3, 4, and the hyperplanes

An error message is produced when the projective space ps has no elements of a required type.

    gap> ps := PG(6,13);
    ProjectiveSpace(6, 13)
    gap> Points(ps);
    <points of ProjectiveSpace(6, 13)>
    gap> Lines(ps);
    <lines of ProjectiveSpace(6, 13)>
    gap> Planes(ps);
    <planes of ProjectiveSpace(6, 13)>
    gap> Solids(ps);
    <solids of ProjectiveSpace(6, 13)>
    gap> Hyperplanes(ps);
    <proj. 5-subspaces of ProjectiveSpace(6, 13)>
    gap> ps := PG(2,2);
    ProjectiveSpace(2, 2)
    gap> Hyperplanes(ps);
    <lines of ProjectiveSpace(2, 2)>

##### 4.2-6 Incidence and containment

`‣ IsIncident`( el1, el2 ) | ( operation )

`‣ \*`( el1, el2 ) | ( operation )

`‣ \in`( el1, el2 ) | ( operation )

Returns: true or false

Recall that for projective spaces, incidence is symmetrized containment, where the empty subspace and the whole projective space are excluded as arguments for this operation, since they are not considered as elements of the geometry, but both the empty subspace and the whole projective space are allowed as arguments for `\in`.

    gap> ps := ProjectiveSpace(5,9);
    ProjectiveSpace(5, 9)
    gap> p := VectorSpaceToElement(ps,[1,1,1,1,0,0]*Z(9)^0);
    <a point in ProjectiveSpace(5, 9)>
    gap> l := VectorSpaceToElement(ps,[[1,1,1,1,0,0],[0,0,0,0,1,0]]*Z(9)^0);
    <a line in ProjectiveSpace(5, 9)>
    gap> plane := VectorSpaceToElement(ps,[[1,0,0,0,0,0],[0,1,0,0,0,0],[0,0,1,0,0,0]]*Z(9)^0);
    <a plane in ProjectiveSpace(5, 9)>
    gap> p * l;
    true
    gap> l * p;
    true
    gap> IsIncident(p,l);
    true
    gap> p in l;
    true
    gap> l in p;
    false
    gap> p * plane;
    false
    gap> l * plane;
    false
    gap> l in plane;
    false
    gap> e := EmptySubspace(ps);
    < empty subspace >
    gap> e * l;
    Error, no method found! For debugging hints type ?Recovery from NoMethodFound
    Error, no 1st choice method found for `*' on 2 arguments called from
    <function "HANDLE_METHOD_NOT_FOUND">( <arguments> )
     called from read-eval loop at line 21 of *stdin*
    you can 'quit;' to quit to outer loop, or
    you can 'return;' to continue
    brk> quit;
    gap> e in l;
    true
    gap> l in ps;
    true

##### 4.2-7 StandardFrame

`‣ StandardFrame`( ps ) | ( operation )

Returns: the standard frame of the projective space ps

    gap> StandardFrame(PG(5,4));
    [ <a point in ProjectiveSpace(5, 4)>, <a point in ProjectiveSpace(5, 4)>,
      <a point in ProjectiveSpace(5, 4)>, <a point in ProjectiveSpace(5, 4)>,
      <a point in ProjectiveSpace(5, 4)>, <a point in ProjectiveSpace(5, 4)>,
      <a point in ProjectiveSpace(5, 4)> ]
    gap> Display(last);
    [ NewRowVector(IsCVecRep,GF(2,2),[Z(2)^0,0*Z(2),0*Z(2),0*Z(2),0*Z(2),0*Z(2),])
        , NewRowVector(IsCVecRep,GF(2,2),[0*Z(2),Z(2)^0,0*Z(2),0*Z(2),0*Z(2),
        0*Z(2),]), NewRowVector(IsCVecRep,GF(2,2),[0*Z(2),0*Z(2),Z(2)^0,0*Z(2),
        0*Z(2),0*Z(2),]), NewRowVector(IsCVecRep,GF(2,2),[0*Z(2),0*Z(2),0*Z(2),
        Z(2)^0,0*Z(2),0*Z(2),]), NewRowVector(IsCVecRep,GF(2,2),[0*Z(2),0*Z(2),
        0*Z(2),0*Z(2),Z(2)^0,0*Z(2),]), NewRowVector(IsCVecRep,GF(2,2),[0*Z(2),
        0*Z(2),0*Z(2),0*Z(2),0*Z(2),Z(2)^0,]), NewRowVector(IsCVecRep,GF(2,2),[
        Z(2)^0,Z(2)^0,Z(2)^0,Z(2)^0,Z(2)^0,Z(2)^0,]) ]

##### 4.2-8 Coordinates

`‣ Coordinates`( p ) | ( attribute )

Returns: the homogeneous coordinates of the projective point p

    gap> p := Random(Points(PG(5,16)));
    <a point in ProjectiveSpace(5, 16)>
    gap> Coordinates(p);
    [ Z(2)^0, Z(2^4)^13, Z(2)^0, Z(2^4)^8, Z(2^4)^3, Z(2^4)^7 ]

##### 4.2-9 DualCoordinatesOfHyperplane

`‣ DualCoordinatesOfHyperplane`( hyp ) | ( operation )

Returns: a list

The argument hyp is a hyperplane of a projective space. This operation returns the dual coordinates of the hyperplane hyp, i.e. the list with the coefficients of the equation defining the hyperplane hyp as an algebraic variety.

##### 4.2-10 HyperplaneByDualCoordinates

`‣ HyperplaneByDualCoordinates`( pg, list ) | ( operation )

Returns: a hyperplane of a projective space

The argument pg is a projective space, and list is the coordinate vector of a point of pg. This operation returns the hyperplane that has list as the list of coefficients of the equation defining the hyperplane as an algebraic variety.

##### 4.2-11 EquationOfHyperplane

`‣ EquationOfHyperplane`( h ) | ( operation )

Returns: the equation of the hyperplane h of a projective space

    gap> hyperplane := VectorSpaceToElement(PG(3,2),[[1,1,0,0],[0,0,1,0],[0,0,0,1]]*Z(2)^0);
    <a plane in ProjectiveSpace(3, 2)>
    gap> EquationOfHyperplane(hyperplane);
    x_1+x_2

##### 4.2-12 AmbientSpace

`‣ AmbientSpace`( el ) | ( operation )

Returns: returns the ambient space of an element el of a projective space

This operation is also applicable on the empty subspace and the whole space.

    gap> ps := PG(3,27);
    ProjectiveSpace(3, 27)
    gap> p := VectorSpaceToElement(ps,[1,2,1,0]*Z(3)^3);
    <a point in ProjectiveSpace(3, 27)>
    gap> AmbientSpace(p);
    ProjectiveSpace(3, 27)

##### 4.2-13 BaseField

`‣ BaseField`( el ) | ( operation )

Returns: returns the base field of an element el of a projective space

This operation is also applicable on the trivial subspace and the whole space.

    gap> ps := PG(5,8);
    ProjectiveSpace(5, 8)
    gap> p := VectorSpaceToElement(ps,[1,1,1,0,0,1]*Z(2));
    <a point in ProjectiveSpace(5, 8)>
    gap> BaseField(p);
    GF(2^3)

##### 4.2-14 Random

`‣ Random`( elements ) | ( operation )

Returns: a random element from the collection elements

The collection elements is an object in the category `IsElementsOfIncidenceStructure`, i.e. an object representing the set of elements of a certain incidence structure of a given type. The latter information can be derived e.g. using `AmbientSpace` and `Type`.

    gap> ps := PG(9,49);
    ProjectiveSpace(9, 49)
    gap> Random(Lines(ps));
    <a line in ProjectiveSpace(9, 49)>
    gap> Random(Points(ps));
    <a point in ProjectiveSpace(9, 49)>
    gap> Random(Solids(ps));
    <a solid in ProjectiveSpace(9, 49)>
    gap> Random(Hyperplanes(ps));
    <a proj. 8-space in ProjectiveSpace(9, 49)>
    gap> elts := ElementsOfIncidenceStructure(ps,6);
    <proj. 5-subspaces of ProjectiveSpace(9, 49)>
    gap> Random(elts);
    <a proj. 5-space in ProjectiveSpace(9, 49)>
    gap> Display(last);
    [[Z(7)^0,0*Z(7),0*Z(7),0*Z(7),0*Z(7),0*Z(7),Z(7^2)^14,Z(7^2)^44,Z(7^2)^14,
    Z(7)^5,]
     [0*Z(7),Z(7)^0,0*Z(7),0*Z(7),0*Z(7),0*Z(7),Z(7^2)^29,Z(7^2)^13,Z(7^2)^19,
    Z(7^2)^27,]
     [0*Z(7),0*Z(7),Z(7)^0,0*Z(7),0*Z(7),0*Z(7),Z(7^2)^20,Z(7^2)^10,Z(7^2)^18,
    Z(7^2)^27,]
     [0*Z(7),0*Z(7),0*Z(7),Z(7)^0,0*Z(7),0*Z(7),Z(7),Z(7^2)^30,Z(7^2)^18,Z(7^2)^
    14,]
     [0*Z(7),0*Z(7),0*Z(7),0*Z(7),Z(7)^0,0*Z(7),Z(7^2)^10,Z(7^2)^28,Z(7^2)^47,
    Z(7^2)^29,]
     [0*Z(7),0*Z(7),0*Z(7),0*Z(7),0*Z(7),Z(7)^0,Z(7^2)^9,Z(7^2)^42,Z(7^2)^34,
    Z(7^2)^25,]
    ]
    gap> RandomSubspace(ps,3);
    <a solid in ProjectiveSpace(9, 49)>
    gap> Display(last);
    [[Z(7)^0,0*Z(7),0*Z(7),0*Z(7),Z(7^2)^17,Z(7^2)^33,Z(7^2)^4,0*Z(7),Z(7^2),
    Z(7^2)^33,]
     [0*Z(7),Z(7)^0,0*Z(7),0*Z(7),Z(7^2)^30,Z(7)^2,Z(7)^3,Z(7)^0,Z(7^2)^20,Z(7^2)^
    42,]
     [0*Z(7),0*Z(7),Z(7)^0,0*Z(7),Z(7^2)^20,Z(7^2)^30,Z(7^2)^11,Z(7^2)^39,Z(7)^3,
    Z(7),]
     [0*Z(7),0*Z(7),0*Z(7),Z(7)^0,Z(7^2)^21,Z(7)^0,Z(7^2)^11,Z(7^2)^45,Z(7^2),
    Z(7^2)^9,]
    ]
    gap> RandomSubspace(ps,7);
    <a proj. 7-space in ProjectiveSpace(9, 49)>
    gap> Display(last);
    [[Z(7)^0,0*Z(7),0*Z(7),0*Z(7),0*Z(7),0*Z(7),0*Z(7),0*Z(7),Z(7^2)^42,Z(7^2)^
    35,]
     [0*Z(7),Z(7)^0,0*Z(7),0*Z(7),0*Z(7),0*Z(7),0*Z(7),0*Z(7),Z(7^2)^43,Z(7^2),]
     [0*Z(7),0*Z(7),Z(7)^0,0*Z(7),0*Z(7),0*Z(7),0*Z(7),0*Z(7),Z(7^2)^44,Z(7)^4,]
     [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^2)^41,Z(7^2)^
    10,]
     [0*Z(7),0*Z(7),0*Z(7),0*Z(7),Z(7)^0,0*Z(7),0*Z(7),0*Z(7),Z(7^2)^37,Z(7^2)^
    12,]
     [0*Z(7),0*Z(7),0*Z(7),0*Z(7),0*Z(7),Z(7)^0,0*Z(7),0*Z(7),Z(7^2)^11,Z(7^2)^
    39,]
     [0*Z(7),0*Z(7),0*Z(7),0*Z(7),0*Z(7),0*Z(7),Z(7)^0,0*Z(7),Z(7^2)^22,Z(7^2)^
    10,]
     [0*Z(7),0*Z(7),0*Z(7),0*Z(7),0*Z(7),0*Z(7),0*Z(7),Z(7)^0,Z(7^2)^43,Z(7^2)^
    22,]
    ]
    gap> RandomSubspace(ps);
    <a plane in ProjectiveSpace(9, 49)>
    gap> RandomSubspace(ps);
    <a proj. 6-space in ProjectiveSpace(9, 49)>

##### 4.2-15 RandomSubspace

`‣ RandomSubspace`( ps, i ) | ( operation )

`‣ RandomSubspace`( ps ) | ( operation )

Returns: the first variant returns a random element of type i of the projective space ps. The second variant returns a random element of a random type of the projective space ps

    gap> ps := PG(8,16);
    ProjectiveSpace(8, 16)
    gap> RandomSubspace(ps);
    <a point in ProjectiveSpace(8, 16)>
    gap> RandomSubspace(ps);
    <a proj. 5-space in ProjectiveSpace(8, 16)>
    gap> RandomSubspace(ps);
    <a proj. 7-space in ProjectiveSpace(8, 16)>
    gap> RandomSubspace(ps);
    <a proj. 4-space in ProjectiveSpace(8, 16)>
    gap> RandomSubspace(ps);
    <a plane in ProjectiveSpace(8, 16)>
    gap> RandomSubspace(ps);
    <a plane in ProjectiveSpace(8, 16)>
    gap> RandomSubspace(ps);
    <a plane in ProjectiveSpace(8, 16)>

##### 4.2-16 Span

`‣ Span`( u, v ) | ( operation )

`‣ Span`( list ) | ( operation )

Returns: an element or the empty subspace or the whole space

When u and v are elements of a projective space. This function returns the span of the two elements. When list is a list of elements of the same projective space, then this function returns the span of all elements in list. It is checked whether the elements u and v are elements of the same projective space. Although the trivial subspace and the whole projective space are not objects in the category `IsSubspaceOfProjectiveSpace`, they are allowed as arguments for this operation, and also for the second variant of this operation.

    gap> ps := ProjectiveSpace(3,3);
    ProjectiveSpace(3, 3)
    gap> p := Random(Planes(ps));
    <a plane in ProjectiveSpace(3, 3)>
    gap> q := Random(Planes(ps));
    <a plane in ProjectiveSpace(3, 3)>
    gap> s := Span(p,q);
    ProjectiveSpace(3, 3)
    gap> s = Span([p,q]);
    true
    gap> t := Span(EmptySubspace(ps),p);
    <a plane in ProjectiveSpace(3, 3)>
    gap> t = p;
    true
    gap> Span(ps,p);
    ProjectiveSpace(3, 3)

##### 4.2-17 Meet

`‣ Meet`( u, v ) | ( operation )

`‣ Meet`( list ) | ( operation )

Returns: an element or the empty subspace or the whole space

When u and v are elements of a projective space. This function returns the intersection of the two elements. When list is a list of elements of the same projective space, then this function returns the intersection of all elements in list. It is checked whether the elements u and v are elements of the same projective space. Although the trivial subspace and the whole projective space are not objects in the category `IsSubspaceOfProjectiveSpace`, they are allowed as arguments for this operation, and also for the second variant of this operation. We remark that the result of a `Meet` operation can be the empty subspace.

    ProjectiveSpace(7, 8)
    gap> p := Random(Solids(ps));
    <a solid in ProjectiveSpace(7, 8)>
    gap> q := Random(Solids(ps));
    <a solid in ProjectiveSpace(7, 8)>
    gap> s := Meet(p,q);
    < empty subspace >
    gap> Display(s);
    < empty subspace >
    gap> r := Random(Hyperplanes(ps));
    <a proj. 6-space in ProjectiveSpace(7, 8)>
    gap> Meet(p,r);
    <a plane in ProjectiveSpace(7, 8)>
    gap> Meet(q,r);
    <a plane in ProjectiveSpace(7, 8)>
    gap> Meet([p,q,r]);
    < empty subspace >

##### 4.2-18 FlagOfIncidenceStructure

`‣ FlagOfIncidenceStructure`( ps, els ) | ( operation )

Returns: the flag of the projective space ps, determined by the subspaces of ps in the list els. When els is empty, the empty flag is returned.

    gap> ps := ProjectiveSpace(12,11);
    ProjectiveSpace(12, 11)
    gap> s1 := RandomSubspace(ps,8);
    <a proj. 8-space in ProjectiveSpace(12, 11)>
    gap> s2 := RandomSubspace(s1,6);
    <a proj. 6-space in ProjectiveSpace(12, 11)>
    gap> s3 := RandomSubspace(s2,4);
    <a proj. 4-space in ProjectiveSpace(12, 11)>
    gap> s4 := Random(Solids(s3));
    <a solid in ProjectiveSpace(12, 11)>
    gap> s5 := Random(Points(s4));
    <a point in ProjectiveSpace(12, 11)>
    gap> flag := FlagOfIncidenceStructure(ps,[s1,s3,s2,s5,s4]);
    <a flag of ProjectiveSpace(12, 11)>
    gap> ps := PG(4,5);
    ProjectiveSpace(4, 5)
    gap> p := Random(Points(ps));
    <a point in ProjectiveSpace(4, 5)>
    gap> l := Random(Lines(ps));
    <a line in ProjectiveSpace(4, 5)>
    gap> v := Random(Solids(ps));
    <a solid in ProjectiveSpace(4, 5)>
    gap> flag := FlagOfIncidenceStructure(ps,[v,l,p]);
    Error, <els> does not determine a flag> called from
    <function "unknown">( <arguments> )
     called from read-eval loop at line 19 of *stdin*
    you can 'quit;' to quit to outer loop, or
    you can 'return;' to continue
    brk> quit;
    gap> flag := FlagOfIncidenceStructure(ps,[]);
    <a flag of ProjectiveSpace(4, 5)>

##### 4.2-19 IsEmptyFlag

`‣ IsEmptyFlag`( flag ) | ( operation )

Returns: return true if flag is the empty flag

##### 4.2-20 IsChamberOfIncidenceStructure

`‣ IsChamberOfIncidenceStructure`( flag ) | ( operation )

Returns: true if flag is a chamber

    gap> ps := PG(3,13);
    ProjectiveSpace(3, 13)
    gap> plane := Random(Planes(ps));
    <a plane in ProjectiveSpace(3, 13)>
    gap> line := Random(Lines(plane));
    <a line in ProjectiveSpace(3, 13)>
    gap> point := Random(Points(line));
    <a point in ProjectiveSpace(3, 13)>
    gap> flag := FlagOfIncidenceStructure(ps,[point,line,plane]);
    <a flag of ProjectiveSpace(3, 13)>
    gap> IsChamberOfIncidenceStructure(flag);
    true

#### 4.3 Shadows of Projective Subspaces

##### 4.3-1 ShadowOfElement

`‣ ShadowOfElement`( ps, el, i ) | ( operation )

`‣ ShadowOfElement`( ps, el, str ) | ( operation )

Returns: the elements of type i incident with el. The second variant determines the type i from the position of str in the list returned by `TypesOfElementsOfIncidenceStructurePlural`

    gap> ps := PG(4,3);
    ProjectiveSpace(4, 3)
    gap> plane := Random(Planes(ps));
    <a plane in ProjectiveSpace(4, 3)>
    gap> shadowpoints := ShadowOfElement(ps,plane,1);
    <shadow points in ProjectiveSpace(4, 3)>
    gap> List(shadowpoints);
    [ <a point in ProjectiveSpace(4, 3)>, <a point in ProjectiveSpace(4, 3)>,
      <a point in ProjectiveSpace(4, 3)>, <a point in ProjectiveSpace(4, 3)>,
      <a point in ProjectiveSpace(4, 3)>, <a point in ProjectiveSpace(4, 3)>,
      <a point in ProjectiveSpace(4, 3)>, <a point in ProjectiveSpace(4, 3)>,
      <a point in ProjectiveSpace(4, 3)>, <a point in ProjectiveSpace(4, 3)>,
      <a point in ProjectiveSpace(4, 3)>, <a point in ProjectiveSpace(4, 3)>,
      <a point in ProjectiveSpace(4, 3)> ]
    gap> shadowlines := ShadowOfElement(ps,plane,2);
    <shadow lines in ProjectiveSpace(4, 3)>
    gap> List(shadowlines);
    [ <a line in ProjectiveSpace(4, 3)>, <a line in ProjectiveSpace(4, 3)>,
      <a line in ProjectiveSpace(4, 3)>, <a line in ProjectiveSpace(4, 3)>,
      <a line in ProjectiveSpace(4, 3)>, <a line in ProjectiveSpace(4, 3)>,
      <a line in ProjectiveSpace(4, 3)>, <a line in ProjectiveSpace(4, 3)>,
      <a line in ProjectiveSpace(4, 3)>, <a line in ProjectiveSpace(4, 3)>,
      <a line in ProjectiveSpace(4, 3)>, <a line in ProjectiveSpace(4, 3)>,
      <a line in ProjectiveSpace(4, 3)> ]

##### 4.3-2 ShadowOfFlag

`‣ ShadowOfFlag`( ps, flag, i ) | ( operation )

`‣ ShadowOfFlag`( ps, flag, str ) | ( operation )

Returns: the type i shadow elements of the flag flag, i.e. the elements of type i incident with all elements of flag. The second variant determines the type i from the position of str in the list returned by `TypesOfElementsOfIncidenceStructurePlural`.

    gap> ps := PG(5,7);
    ProjectiveSpace(5, 7)
    gap> p := VectorSpaceToElement(ps,[1,0,0,0,0,0]*Z(7)^0);
    <a point in ProjectiveSpace(5, 7)>
    gap> l := VectorSpaceToElement(ps,[[1,0,0,0,0,0],[0,1,0,0,0,0]]*Z(7)^0);
    <a line in ProjectiveSpace(5, 7)>
    gap> v := VectorSpaceToElement(ps,[[1,0,0,0,0,0],[0,1,0,0,0,0],[0,0,1,0,0,0]]*Z(7)^0);
    <a plane in ProjectiveSpace(5, 7)>
    gap> flag := FlagOfIncidenceStructure(ps,[v,l,p]);
    <a flag of ProjectiveSpace(5, 7)>
    gap> s := ShadowOfFlag(ps,flag,4);
    <shadow solids in ProjectiveSpace(5, 7)>
    gap> s := ShadowOfFlag(ps,flag,"solids");
    <shadow solids in ProjectiveSpace(5, 7)>

##### 4.3-3 ElementsIncidentWithElementOfIncidenceStructure

`‣ ElementsIncidentWithElementOfIncidenceStructure`( el, i ) | ( operation )

Returns: the elements of type i incident with el, in other words, the type i shadow of the element el

Internally, the function `FlagOfIncidenceStructure` is used to create a flag from list. This function also performs the checking.

    gap> ps := PG(6,9);
    ProjectiveSpace(6, 9)
    gap> p := VectorSpaceToElement(ps,[1,0,1,0,0,0,0]*Z(9)^0);
    <a point in ProjectiveSpace(6, 9)>
    gap> els := ElementsIncidentWithElementOfIncidenceStructure(p,3);
    <shadow planes in ProjectiveSpace(6, 9)>
    gap> line := VectorSpaceToElement(ps,[[1,1,1,1,0,0,0],[0,0,0,0,1,1,1]]*Z(9)^0);
    <a line in ProjectiveSpace(6, 9)>
    gap> els := ElementsIncidentWithElementOfIncidenceStructure(line,1);
    <shadow points in ProjectiveSpace(6, 9)>
    gap> List(els);
    [ <a point in ProjectiveSpace(6, 9)>, <a point in ProjectiveSpace(6, 9)>,
      <a point in ProjectiveSpace(6, 9)>, <a point in ProjectiveSpace(6, 9)>,
      <a point in ProjectiveSpace(6, 9)>, <a point in ProjectiveSpace(6, 9)>,
      <a point in ProjectiveSpace(6, 9)>, <a point in ProjectiveSpace(6, 9)>,
      <a point in ProjectiveSpace(6, 9)>, <a point in ProjectiveSpace(6, 9)> ]

##### 4.3-4 Short names for `ElementsIncidentWithElementOfIncidenceStructure`

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

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

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

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

`‣ Hyperplanes`( inc, v ) | ( operation )

`‣ Points`( v ) | ( operation )

`‣ Lines`( v ) | ( operation )

`‣ Planes`( v ) | ( operation )

`‣ Solids`( v ) | ( operation )

`‣ Hyperplanes`( v ) | ( operation )

Returns: The elements of the incidence geometry of the according type. If ps is not given as an argument, it is deduced from v as its ambient geometry.

    gap> ps := PG(6,13);
    ProjectiveSpace(6, 13)
    gap> plane := Random(Planes(ps));
    <a plane in ProjectiveSpace(6, 13)>
    gap> Points(plane);
    <shadow points in ProjectiveSpace(6, 13)>
    gap> Lines(plane);
    <shadow lines in ProjectiveSpace(6, 13)>
    gap> Solids(plane);
    <shadow solids in ProjectiveSpace(6, 13)>
    gap> Hyperplanes(plane);
    <shadow lines in ProjectiveSpace(6, 13)>
    gap> ElementsIncidentWithElementOfIncidenceStructure(plane,6);
    <shadow proj. 5-subspaces in ProjectiveSpace(6, 13)>

#### 4.4 Enumerating subspaces of a projective space

##### 4.4-1 Iterator

`‣ Iterator`( subspaces ) | ( operation )

Returns: an iterator for the collection subspaces

We refer to the GAP operation `Iterator` for the definition of an iterator.

    gap> pg := PG(5,7);
    ProjectiveSpace(5, 7)
    gap> planes := Planes(pg);
    <planes of ProjectiveSpace(5, 7)>
    gap> iter := Iterator(planes);
    <iterator>
    gap> NextIterator(iter);
    <a plane in ProjectiveSpace(5, 7)>
    gap> NextIterator(iter);
    <a plane in ProjectiveSpace(5, 7)>
    gap> NextIterator(iter);
    <a plane in ProjectiveSpace(5, 7)>

##### 4.4-2 Enumerator

`‣ Enumerator`( subspaces ) | ( operation )

Returns: an enumerator for the collection subspaces

For complete collections of subspaces of a given type of a projective space, currently, no non-trivial enumerator is installed, i.e. this operation just returns a list containing all elements of the collection subspaces. Such a list can, of course, be used as an enumerator, but this might be time consuming.

    gap> pg := PG(3,4);
    ProjectiveSpace(3, 4)
    gap> lines := Lines(pg);
    <lines of ProjectiveSpace(3, 4)>
    gap> enum := Enumerator(lines);;
    gap> Length(enum);
    357

##### 4.4-3 List

`‣ List`( subspaces ) | ( operation )

`‣ AsList`( subspaces ) | ( operation )

Returns: the complete list of elements in the collection subspaces

The operation `List` will return a complete list, the operation `AsList` will return an orb object, representing a complete orbit, i.e. representing in this case a complete list. To obtain the elements explicitly, one has to issue the `List` operation with as argument the orb object again. Applying `List` directly to a collection of subspaces, refers to the enumerator for the collection, while using `AsList` uses the orb to compute all subspaces as an orbit.

    gap> pg := PG(3,4);
    ProjectiveSpace(3, 4)
    gap> lines := Lines(pg);
    <lines of ProjectiveSpace(3, 4)>
    gap> list := List(lines);;
    gap> Length(list);
    357
    gap> aslist := AsList(lines);
    <closed orbit, 357 points>
    gap> list2 := List(aslist);;
    gap> Length(list2);
    357

[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