5 Projective Spaces
In this chapter we describe how to use FinInG to work with finite projective spaces.
5.1 Creating Projective Spaces and basic operations
A projective space is a point-line incidence geometry, satisfying few well known axioms. In FinInG, we deal with finite Desarguesion projective spaces. It is well known that these geometries can be described completely using vector spaces over finite fields. Hence, the underlying vector space and matrix group are to our advantage. We refer the reader to [HT91] for the necessary background theory (if it is not otherwise provided).
5.1-1 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)
|
5.1-2 ProjectiveDimension
> ProjectiveDimension ( ps ) | ( operation ) |
> Dimension ( ps ) | ( operation ) |
> Rank ( ps ) | ( operation ) |
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
|
5.1-3 BaseField
> BaseField ( ps ) | ( operation ) |
Returns: returns the base field for the projective spaceps
gap> BaseField(ProjectiveSpace(3,81));
GF(3^4)
|
5.1-4 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 )
|
5.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 dimenion -1, corresponds with the zero dimensional vector space of the underlying vector space of PG(n,q), and is hence represented by the zero vector of lenght n+1 over the underlying field GF(q). The trivial subspace and the whole projective space are mathematically considerd as a subsace of the projective geometry, but not as elements of the incidence geometry, and hence do in FinInG not belong to the category IsSubspaceOfProjectiveSpace
.
5.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 x 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 basis vectors for the subspace. An exceptional case is when v is a zero-vector, whereby 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);
[ Z(7), Z(7)^5, Z(7)^3, 0*Z(7), Z(7), Z(7)^2, Z(7) ]
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 vectorspace called from
<function>( <arguments> ) called from read-eval-loop
Entering break read-eval-print loop ...
you can 'quit;' to quit to outer loop, or
you can 'return;' to continue
brk> quit;
|
5.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
gap> EmptySubspace;
< trivial subspace >
gap> line := Random(Lines(PG(5,9)));
<a line in ProjectiveSpace(5, 9)>
gap> EmptySubspace * line;
true
gap> EmptySubspace * PG(3,11);
true
|
5.2-3 ProjectiveDimension
> ProjectiveDimension ( sub ) | ( operation ) |
> Dimension ( sub ) | ( operation ) |
Returns: the projective dimension of a subspace of a projective space. This operation 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
|
5.2-4 ElmentsOfIncidenceStructure
> ElmentsOfIncidenceStructure ( 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, 1 lt j lt d this operation returns the collection of j-1 dimenaional subspaces.
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);
[ Z(7), Z(7)^5, Z(7)^3, 0*Z(7), Z(7), Z(7)^2, Z(7) ]
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 vectorspace called from
<function>( <arguments> ) called from read-eval-loop
Entering break read-eval-print loop ...
you can 'quit;' to quit to outer loop, or
you can 'return;' to continue
brk> quit;
|
5.2-5 StandardFrame
> StandardFrame ( ps ) | ( operation ) |
Returns: returns the standard frame in the projective space ps
gap> sf := StandardFrame(PG(5,16));
[ <a point in ProjectiveSpace(5, 16)>, <a point in ProjectiveSpace(5, 16)>,
<a point in ProjectiveSpace(5, 16)>, <a point in ProjectiveSpace(5, 16)>,
<a point in ProjectiveSpace(5, 16)>, <a point in ProjectiveSpace(5, 16)>,
<a point in ProjectiveSpace(5, 16)> ]
gap> Display(sf);
[ [ Z(2)^0, 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), Z(2)^0, 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), Z(2)^0, 0*Z(2) ],
[ 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0 ],
[ Z(2)^0, Z(2)^0, Z(2)^0, Z(2)^0, Z(2)^0, Z(2)^0 ] ]
|
5.2-6 Coordinates
> Coordinates ( p ) | ( operation ) |
Returns: the coordinates of the projective point p
gap> sf := StandardFrame(PG(5,16));
[ <a point in ProjectiveSpace(5, 16)>, <a point in ProjectiveSpace(5, 16)>,
<a point in ProjectiveSpace(5, 16)>, <a point in ProjectiveSpace(5, 16)>,
<a point in ProjectiveSpace(5, 16)>, <a point in ProjectiveSpace(5, 16)>,
<a point in ProjectiveSpace(5, 16)> ]
gap> Display(sf);
[ [ Z(2)^0, 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), Z(2)^0, 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), Z(2)^0, 0*Z(2) ],
[ 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), 0*Z(2), Z(2)^0 ],
[ Z(2)^0, Z(2)^0, Z(2)^0, Z(2)^0, Z(2)^0, Z(2)^0 ] ]
|
5.2-7 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
|
5.2-8 AmbientSpace
> AmbientSpace ( el ) | ( operation ) |
Returns: returns the ambient space an element el of a projective space
This operation is also applicable on the trivial subspace.
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)
|
5.2-9 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.
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)
|
5.2-10 AsList
> AsList ( subspaces ) | ( operation ) |
Returns: an Orb object or list
John's example works, but it is not clear whether it fits in this part of the manual. I'll ask John to explain
the difference between using orb and not using orb to list e.g. all lines of PG(3,4), is in the example projpol_Aslist.g
|
5.2-11 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(8,16);
ProjectiveSpace(8, 16)
gap> RandomSubspace(ps);
<a line in ProjectiveSpace(8, 16)>
gap> RandomSubspace(ps);
<a plane in ProjectiveSpace(8, 16)>
gap> RandomSubspace(ps);
<a proj. 7-space in ProjectiveSpace(8, 16)>
gap> RandomSubspace(ps);
<a line in ProjectiveSpace(8, 16)>
gap> RandomSubspace(ps);
<a line in ProjectiveSpace(8, 16)>
gap> RandomSubspace(ps);
<a solid in ProjectiveSpace(8, 16)>
gap> RandomSubspace(ps);
<a point in ProjectiveSpace(8, 16)>
|
5.2-12 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(9,49);
ProjectiveSpace(9, 49)
gap> Random(Points(ps));
<a point in ProjectiveSpace(9, 49)>
gap> Random(Lines(ps));
<a line 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 = Z(49)
1 . . . . . z^6 z^5 z^13 .
. 1 . . . . z^43 z^33 z^29 3
. . 1 . . . z^14 6 z^12 z^9
. . . 1 . . z^47 z^27 z^12 z^22
. . . . 1 . z^3 1 z^31 z^44
. . . . . 1 z^27 z^42 z^34 z^34
gap> RandomSubspace(ps,3);
<a solid in ProjectiveSpace(9, 49)>
gap> Display(last);
z = Z(49)
1 . . . z^25 z^3 z^31 z^44 z^38 z^5
. 1 . . z^41 z^9 1 z^31 z^23 z^45
. . 1 . z^4 z^21 z^20 z^37 4 z^25
. . . 1 z^28 z^25 2 4 z^23 z^29
gap> RandomSubspace(ps,7);
<a proj. 7-space in ProjectiveSpace(9, 49)>
gap> Display(last);
z = Z(49)
1 . . . . . . . z^6 z^6
. 1 . . . . . . 6 z^43
. . 1 . . . . . 2 z^29
. . . 1 . . . . z^4 2
. . . . 1 . . . z^1 z^2
. . . . . 1 . . 4 z^30
. . . . . . 1 . z^6 z^37
. . . . . . . 1 z^27 z^31
gap> RandomSubspace(ps);
<a proj. 6-space in ProjectiveSpace(9, 49)>
gap> RandomSubspace(ps);
<a solid in ProjectiveSpace(9, 49)>
|
5.2-13 Span
> Span ( u, v ) | ( operation ) |
> Span ( list ) | ( operation ) |
Returns: an element
When u and v are elements of a projective or polar 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 argument for this operation, also as member of the argument of the second variant of this operation.
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)
|
5.2-14 Meet
> Meet ( u, v ) | ( operation ) |
Returns: an element
When u and v are elements of a projective or polar 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 argument for this operation, also as member of the argument of the second variant of this operation.
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);
< trivial subspace >
gap> Display(s);
< trivial 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]);
< trivial subspace >
|
5.2-15 IsIncident
> IsIncident ( v, geo ) | ( operation ) |
> \* ( v, geo ) | ( operation ) |
> \in ( v, geo ) | ( operation ) |
Returns: true or false
Implentation to be reconsidered. Incidence is only applicable on elements of an Incidence structure. in must be applicable on subspaces, hence also trivial one.
gap> ps := ProjectiveSpace(5,9);
ProjectiveSpace(5, 9)
gap> p := Random(Points(ps));
<a point in ProjectiveSpace(5, 9)>
gap> r := Random(Solids(ps));
<a solid in ProjectiveSpace(5, 9)>
gap> IsIncident(p,r);
false
gap> IsIncident(r,p);
false
gap> p*r;
false
gap> r*p;
false
gap> p in r;
false
gap> r in p;
false
gap> EmptySubspace(ps) in r;
true
gap> r in ps;
true
|
5.2-16 FlagOfIncidenceStructure
> FlagOfIncidenceStructure ( ps, els ) | ( operation ) |
Returns: the flag of the projetive 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>( <arguments> ) called from read-eval-loop
Entering break read-eval-print loop ...
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)>
|
5.2-17 IsEmptyFlag
> IsEmptyFlag ( flag ) | ( operation ) |
Returns: return true if flag is the empty flag
5.2-18 IsChamberOfIncidenceStructure
> IsChamberOfIncidenceStructure ( flag ) | ( operation ) |
Returns: true if flag is a chamber flag
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
|
5.3 Shadows of Projective Subspaces
5.3-1 ShadowOfElement
> ShadowOfElement ( ps, el, i ) | ( operation ) |
> ShadowOfElement ( ps, el, str ) | ( operation ) |
Returns: the shadow elements of type i in el. The second variant determines the type i from the position of str in the list returned by TypesOfElementsOfIncidenceStructurePlural
Given the element el in the projective space ps, this operation returns the elements of ps of type i incident with el.
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)> ]
|
5.3-2 ShadowOfFlag
> ShadowOfFlag ( ps, flag, i ) | ( operation ) |
> ShadowOfFlag ( ps, flag, str ) | ( operation ) |
Returns: the shadow elements of type i in 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)>
|
5.3-3 ShadowOfFlag
> ShadowOfFlag ( ps, list, i ) | ( operation ) |
> ShadowOfFlag ( ps, list, str ) | ( operation ) |
Returns: the shadow elements of type i in the flag determined by list, i.e. the elements of type i incident with all elements of the flag. The second variant determines the type i from the position of str in the list returned by TypesOfElementsOfIncidenceStructurePlural
Internally, the function FlagOfIncidenceStructure
is used to create a flag from list. This function also performs the checking.
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)>
|
5.3-4 ElementsIncidentWithElementOfIncidenceStructure
> ElementsIncidentWithElementOfIncidenceStructure ( el, i ) | ( operation ) |
Returns: the elements of type i incident with el, in other words, the shadow of the elements of type i 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)> ]
|