|
##############################################################################
##
## subgeometries.gi FinInG package
## John Bamberg
## Anton Betten
## Jan De Beule
## Philippe Cara
## Michel Lavrauw
## Max Neunhoeffer
##
## Copyright 2020 Colorado State University, Fort Collins
## Università degli Studi di Padova
## University of St. Andrews
## University of Western Australia, Perth
## Vrije Universiteit Brussel
##
##
## Implementation stuff for subgeometries of projective spaces.
##
#############################################################################
#############################################################################
# already some general comments.
# SubgeometryOfProjectiveSpaceByFrame: creates the user defined sub geometry
# starting from a frame. sub!.projectivity: projectivity mapping the canonical
# sub geometry onto the user defined one.
# sub!.sigma: collineation fixing all elements of the sub geometry.
#
#############################################################################
## View methods
#############################################################################
#O ViewObj( <pg> )
##
InstallMethod( ViewObj,
"for a subgeometry of a projective space",
[ IsSubgeometryOfProjectiveSpace and IsSubgeometryOfProjectiveSpaceRep ],
function(pg)
Print("Subgeometry PG(",pg!.dimension,", ",Size(pg!.subfield),") of ",ViewString(pg!.ambientspace));
end );
#############################################################################
#O ViewString( <pg> )
##
InstallMethod( ViewString,
"for a subgeometry of projective space",
[ IsSubgeometryOfProjectiveSpace and IsSubgeometryOfProjectiveSpaceRep ],
function( pg )
return Concatenation("Subgeometry PG(",String(pg!.dimension),", ",String(Size(pg!.subfield)),") of ",ViewString(pg!.ambientspace));
end );
## operation to check whether a list of points is a frame of the ambient geometry
# of the points.
#############################################################################
#O IsFrameOfProjectiveSpace( <list> )
## change 22/6: IsSomething should return true or false!
InstallMethod( IsFrameOfProjectiveSpace,
"for a list of points",
[ IsList ],
function(list)
local pg, coll, base, n, i;
coll:=DuplicateFreeList(List(list,x->AmbientGeometry(x)));
# coll := Collected(List(list,x->AmbientGeometry(x))); #changed AmbientSpace into AmbientGeometry.
if Length(coll) > 1 then
#Error("all elements in <list> lie in the same projective space");
return false;
else
# pg := coll[1][1];
pg:= coll[1];
fi;
coll := Collected(List(list,x->Type(x)));
if Length(coll) > 1 then
#Error("all elements in <list> must be points");
return false;
elif coll[1][1] <> 1 then
#Error("all elements in <list> must be points");
return false;
fi;
n := Length(list);
if n <> ProjectiveDimension(pg) + 2 then
#Error("<list> does not contain the correct number of points");
return false;
fi;
for i in [1..n] do
base := list{Difference([1..n],[i])};
if not Span(base) = pg then
#Error("<list> is not a frame");
return false;
fi;
od;
return true;
end );
#############################################################################
#O RandomFrameOfProjectiveSpace( <pg> )
# This method returns a random frame of a projective space
##
InstallMethod( RandomFrameOfProjectiveSpace,
"for a projective space, and a prime power",
[ IsProjectiveSpace ],
function(pg)
local pts,mat,final,gauge,d,field;
d := ProjectiveDimension(pg)+1;
field := BaseField(pg);
mat := RandomInvertibleMat(d,field);
pts := List(mat,x->VectorSpaceToElement(pg,x));
# TODO: start with the standard frame and choose a random projectivity (#ml 18 May 2020)
gauge := Random(Points(pg));
while not IsFrameOfProjectiveSpace(Union(pts,[gauge])) do
gauge := Random(Points(pg));
od;
pts := Union(pts,[gauge]);
return Set(pts);
end );
## Constructor methods for subgeometries of projective spaces.
# note for the next two methods: it may look strange to put a vectorspace over
# the big field as vectorspace. But this makes sure that incidence can be
# tested between elements of the subgeometry and the ambient geometry.
#############################################################################
#O CanonicalSubgeometryOfProjectiveSpace( <pg>, <subfield> )
# This method requires a projective space and a subfield.
# small change on 12/9/16: we added eventually a field .projectivity in the
# returned geometry. From time to time this is useful, e.g. when comparing
# a canonical subgeometry with an arbitrary one, see e.g. code for \=
##
InstallMethod( CanonicalSubgeometryOfProjectiveSpace,
"for a projective space, and a prime power",
[ IsProjectiveSpace, IsField and IsFinite],
function(pg,subfield)
local geo, subpg, d, frame, ty, em, sigma, h, t, frob, proj;
if IsSubgeometryOfProjectiveSpace(pg) then
Error("recursive construction of subgeometries not (yet) possible");
fi;
d := ProjectiveDimension(pg);
h := DegreeOverPrimeField(subfield);
t := DegreeOverPrimeField(BaseField(pg));
if not t mod h = 0 then
Error(" <subfield> is not a subfield of the base field of <pg>");
elif t = h then #We may consider to return an error here.
return pg;
fi;
subpg := ProjectiveSpace(d,subfield);
frame := StandardFrame(pg);
em := NaturalEmbeddingBySubfield(subpg,pg);
frob := FrobeniusAutomorphism(BaseField(pg))^h;
sigma := CollineationOfProjectiveSpace(pg,frob);
proj := CollineationOfProjectiveSpace(IdentityMat(d+1,pg!.basefield),pg!.basefield);
geo := rec(dimension := d, basefield := pg!.basefield, subfield := subfield, ambientspace := pg, isomorphicsubgeometry := subpg, frame := frame,
embedding := em, vectorspace := FullRowSpace(pg!.basefield, d+1), sigma := sigma, projectivity := proj );
ty := NewType( SubgeometriesFamily,
IsSubgeometryOfProjectiveSpace and IsSubgeometryOfProjectiveSpaceRep );
Objectify( ty, geo );
SetIsCanonicalSubgeometryOfProjectiveSpace(geo, true);
SetAmbientSpace(geo, pg);
SetDefiningFrameOfSubgeometry(geo,frame);
#SetRankAttr(geo,d);
return geo;
end );
#############################################################################
#O SubgeometryOfProjectiveSpaceByFrame( <pg>, <frame>, <subfield> )
# It is checked whether <frame> is a frame. This operation requires
# a projective space, a frame of this space, and a subfield.
##
InstallMethod( SubgeometryOfProjectiveSpaceByFrame,
"for a projective space, and a prime power",
[ IsProjectiveSpace, IsList, IsField and IsFinite],
function(pg,frame,subfield)
local geo, subpg, d, ty, matrix, proj, n, i, vecs, basis, coefs, em, sigma, h, t, frob, can;
if not IsFrameOfProjectiveSpace(frame) then
Error(" <frame> must be a frame of <pg>");
fi;
if IsSubgeometryOfProjectiveSpace(pg) then
Error("recursive construction of subgeometries not (yet) possible");
fi;
d := ProjectiveDimension(pg);
h := DegreeOverPrimeField(subfield);
t := DegreeOverPrimeField(BaseField(pg));
if not t mod h = 0 then
Error(" <subfield> is not a subfield of the base field of <pg>");
elif t = h then #We may consider to return an error here.
return pg;
fi;
subpg := ProjectiveSpace(d,subfield);
frob := FrobeniusAutomorphism(BaseField(pg))^h;
if ForAll(frame,y->ForAll(Flat(y!.obj),x->x in subfield)=true) then
can := true;
proj := CollineationOfProjectiveSpace(IdentityMat(d+1 ,pg!.basefield),pg!.basefield);
sigma := CollineationOfProjectiveSpace(pg,frob);
else
can := false;
n:=Size(frame)-1;
vecs:=List(frame,x->Coordinates(x));
basis:=Basis(UnderlyingVectorSpace(Span(frame)),vecs{[1..n]});
coefs:=Coefficients(basis,vecs[n+1]);
matrix := List([1..n],i->coefs[i]*vecs[i]);
proj := CollineationOfProjectiveSpace(matrix,BaseField(pg));
sigma := proj^(-1)*CollineationOfProjectiveSpace(pg,frob)*proj;
fi;
em := NaturalEmbeddingBySubfield(subpg,pg);
geo := rec(dimension := d, basefield := pg!.basefield, subfield := subfield, ambientspace := pg, isomorphicsubgeometry := subpg,
frame := ShallowCopy(frame), embedding := em, vectorspace := FullRowSpace(pg!.basefield, d+1), sigma := sigma,
projectivity := proj );
ty := NewType( SubgeometriesFamily,
IsSubgeometryOfProjectiveSpace and IsSubgeometryOfProjectiveSpaceRep );
Objectify( ty, geo );
SetAmbientSpace(geo, pg);
SetIsCanonicalSubgeometryOfProjectiveSpace(geo, can);
SetDefiningFrameOfSubgeometry(geo,frame);
#SetRankAttr(geo,d);
return geo;
end );
#############################################################################
#O CanonicalSubgeometryOfProjectiveSpace( <pg>, <q> )
# shortcut to CanonicalSubgeometryOfProjectiveSpace( <pg>, <GF(<q>))
##
InstallMethod( CanonicalSubgeometryOfProjectiveSpace,
"for a projective space, and a prime power",
[ IsProjectiveSpace, IsPosInt],
function(pg,q)
return CanonicalSubgeometryOfProjectiveSpace(pg,GF(q));
end );
#############################################################################
#O SubgeometryOfProjectiveSpaceByFrame( <pg>, <frame>, <q> )
# shortcut to SubgeometryOfProjectiveSpaceByFrame( <pg>, <frame>, <GF(<q>))
##
InstallMethod( SubgeometryOfProjectiveSpaceByFrame,
"for a projective space, and a prime power",
[ IsProjectiveSpace, IsList, IsPosInt],
function(pg,frame,q)
return SubgeometryOfProjectiveSpaceByFrame(pg,frame,GF(q));
end );
# Basic methods for subgeometries.
#############################################################################
#############################################################################
#O \=( <sub1>, <sub2> )
# test equality of subgeometries.
# To test equality of two subgeometries, we check whether
# (0) if there ambient space equals, if not, return false
# (1) if (0)=true, then, test equality of their subfields, if not, return false
# (2) if (1)=true, test if one of them is not canonical, if so, check whether they
# are equal if p*q^1, p, s their respective projectivities,
# is a collineation over the subfield,
# note 12/9/16: checking whether all elements of mat belong to the subfield, is
# too restrictive: we must now first divded mat by the first non-zero element!
# (3) if (2)=false, then both are canonical, and return true.
##
InstallMethod( \=,
"for two subgeometries of a projective space",
[ IsSubgeometryOfProjectiveSpace, IsSubgeometryOfProjectiveSpaceRep ],
function(sub1,sub2)
local proj1, proj2, res, mat, nz;
if not AmbientSpace(sub1) = AmbientSpace(sub2) then
return false;
elif not sub1!.subfield = sub2!.subfield then
return false;
elif IsCanonicalSubgeometryOfProjectiveSpace(sub1) = false or IsCanonicalSubgeometryOfProjectiveSpace(sub2) = false then
proj1 := sub1!.projectivity;
proj2 := sub2!.projectivity;
res := proj1 * proj2^(-1);
mat := MatrixOfCollineation(res);
#return ForAll(Flat(mat), x->x in sub1!.subfield); # too restrictive!
nz := First(Flat(mat),x->x <> Zero(sub1!.basefield));
return ForAll(Flat(mat), x->x/nz in sub1!.subfield);
else
return true;
fi;
end );
# The next two methods are necessary, since a subgeometry of a projective space
# is also a projective space. Not installing these methods, would invoke the
# method for \= for two projective spaces if one of the arguments is a subgeometry
# and the other one a projective space not a subgeometry, with an incorrect answer.
#############################################################################
#O \=( <pg1>, <pg2> )
##
InstallMethod( \=,
"for two projective spaces",
[IsSubgeometryOfProjectiveSpace, IsProjectiveSpace],
function(pg1,pg2);
return false;
end );
#############################################################################
#O \=( <pg1>, <pg2> )
##
InstallMethod( \=,
"for two projective spaces",
[IsProjectiveSpace, IsSubgeometryOfProjectiveSpace],
function(pg1,pg2);
return false;
end );
#############################################################################
#O Rank( <ps> )
# Rank of a subgeometry
##
InstallMethod( Rank,
"for a projective space",
[ IsSubgeometryOfProjectiveSpace and IsSubgeometryOfProjectiveSpaceRep ],
ps -> ps!.dimension
);
# Note that UnderlyingVectorSpace and BaseField are installed for projective
# spaces and hence, are applicable to subgeometries. See introductory comments
# at top of file, for the "definition" of underlying vectorspace and base field.
#############################################################################
#O SubfieldOfSubgeometry( <sub> )
# Subfield of subgeometry.
##
InstallMethod( SubfieldOfSubgeometry,
"for a subgeometry of a projective space",
[ IsSubgeometryOfProjectiveSpace ],
sub -> sub!.subfield );
# NEW 31/5/2020 jdb
#############################################################################
#A StandardFrame( <sub> )
# if the dimension of subgeometry <sub> is n and <sub> is the canonical subgeometry,
# then StandardFrame returns a list of points of <sub> with coordinates
# (1,0,...0), (0,1,0,...,0), ..., (0,...,0,1) and (1,1,...,1). In case <sub> is not the
# canonical subgeometry, the image of these points under sub!.projectivity is returned.
# note that, due to the way we construct subgeometries of projective space,
# this is nothing else than the meet of the points of the defining frame with sub
##
InstallMethod( StandardFrame,
"for a subgeometry of a projective space",
[ IsSubgeometryOfProjectiveSpace ],
function( sub )
return List(sub!.frame,x->Meet(sub,x));
end );
#############################################################################
#A CollineationFixingSubgeometry
# For a subgeometry PG(n,q) in PG(n,q^2), we would call this the Baer involution.
# This is the collineation of PGammaL(n+1,q^t) fixing the subgeometry point wise.
# Its order is t.
##
InstallMethod( CollineationFixingSubgeometry,
"for a subgeometry of a projective space",
[ IsSubgeometryOfProjectiveSpace ],
function(pg)
return pg!.sigma;
end );
# Constructor operations for elements and basic operations for elements.
#############################################################################
#############################################################################
#O Wrap( <geo>, <type>, <o> )
# An almost classical method for Wrap, with <geo> a subgeometry. Note that
# Wrap is not a user operation.
##
InstallMethod( Wrap,
"for a projective space and an object",
[ IsSubgeometryOfProjectiveSpace, IsPosInt, IsObject],
function( geo, type, o )
local w;
w := rec( geo := geo, type := type, obj := o );
Objectify( NewType( SoSoPSFamily, IsElementOfIncidenceStructure and
IsElementOfIncidenceStructureRep and IsSubspaceOfSubgeometryOfProjectiveSpace ), w );
return w;
end );
#############################################################################
#O VectorSpaceToElementForSubgeometries( <sub>, <obj> )
# Note that a VectorSpaceToElement method must be created for every Lie geometry
# This is a helper operation to simplify the different VectorSpaceToElement
# methods for particular objects.
# It is checked whether the projectivity maps the element of the ambient projective
# space based on <obj> back to and element of the canonical subgeometry. If so,
# the element of the subgeometry based on <obj> is returned.
##
InstallMethod( VectorSpaceToElementForSubgeometries,
"for a sub geometry of a projective space and an object",
[ IsSubgeometryOfProjectiveSpace, IsObject],
function( sub, obj )
local ambient, element, newelement, proj, subfield, newobj, elements;
if IsZero(obj) then
return EmptySubspace(sub);
fi;
ambient := sub!.ambientspace;
element := VectorSpaceToElement(ambient,obj);
if element = ambient then
# newobj := Filtered(obj,x->not IsZero(x));
# elements := List(newobj,x->VectorSpaceToElement(sub,x));
return sub;
# else
# elements := [element];
fi;
if not IsCanonicalSubgeometryOfProjectiveSpace(sub) then
proj := sub!.projectivity;
newelement := element^(proj^(-1));
else
newelement := element;
fi;
subfield := sub!.subfield;
if not ForAll(Flat(newelement!.obj),a->a in subfield) then
#if not ForAll( Flat( List(newelements,x->x!.obj ) ), i -> i in subfield) then
Error( "<obj> does not determine an element in <sub>");
# elif element = ambient then
# return sub;
else
return Wrap(sub,element!.type,UnderlyingObject(element));
fi;
end);
# Now follow the different methods for VectorSpaceToElement for objects
# of particular type.
#############################################################################
#O VectorSpaceToElement( <sub>, <v> )
##
InstallMethod( VectorSpaceToElement,
"for a subgeometry of a projective space and a matrix as plist",
[IsSubgeometryOfProjectiveSpace, IsPlistRep and IsMatrix],
function( geom, v )
return VectorSpaceToElementForSubgeometries(geom,v);
end );
#############################################################################
#O VectorSpaceToElement( <sub>, <v> )
##
InstallMethod( VectorSpaceToElement,
"for a subgeometry of a projective space and a CMatRep",
[ IsSubgeometryOfProjectiveSpace, IsCMatRep],
function( geom, v )
return VectorSpaceToElementForSubgeometries(geom, Unpack(v));
end );
#############################################################################
#O VectorSpaceToElement( <sub>, <v> )
##
InstallMethod( VectorSpaceToElement,
"for a subgeometry of a projective space and a compressed GF(2)-matrix",
[IsSubgeometryOfProjectiveSpace, IsGF2MatrixRep],
function( geom, v )
return VectorSpaceToElementForSubgeometries(geom, Unpack(v));
end );
#############################################################################
#O VectorSpaceToElement( <sub>, <v> )
##
InstallMethod( VectorSpaceToElement,
"for a subgeometry of a projective space and a compressed basis of a vector subspace",
[IsSubgeometryOfProjectiveSpace, Is8BitMatrixRep],
function( geom, v )
return VectorSpaceToElementForSubgeometries(geom, Unpack(v));
end );
#############################################################################
#O VectorSpaceToElement( <sub>, <v> )
##
InstallMethod( VectorSpaceToElement,
"for a subgeometry of a projective space and a row vector as cvec",
[IsSubgeometryOfProjectiveSpace, IsCVecRep],
function( geom, v )
return VectorSpaceToElementForSubgeometries(geom, Unpack(v));
end );
#############################################################################
#O VectorSpaceToElement( <sub>, <v> )
##
InstallMethod( VectorSpaceToElement,
"for a subgeometry of a projective space and a row vector",
[IsSubgeometryOfProjectiveSpace, IsRowVector],
function( geom, v )
return VectorSpaceToElementForSubgeometries(geom, v);
end );
#############################################################################
#O VectorSpaceToElement( <sub>, <v> )
##
InstallMethod( VectorSpaceToElement,
"for a subgeometry of a projective space and an 8-bit vector",
[IsSubgeometryOfProjectiveSpace, Is8BitVectorRep],
function( geom, v )
return VectorSpaceToElementForSubgeometries(geom, Unpack(v));
end );
#############################################################################
#O \=
# Equality of two subspaces of a subgeometry
# Note that this is a test of mathematical equality: the ambient geometry
# must be equal (so not IsIdenticalObj), and
# the underlying object must be equal. Recall that due to norming the underlying
# object, this is garantueed for two equal subspaces.
##
InstallMethod( \=,
"for two subspace of subgeometry a projective space",
[IsSubspaceOfSubgeometryOfProjectiveSpace, IsSubspaceOfSubgeometryOfProjectiveSpace],
function(p1,p2);
return (p1!.obj = p2!.obj) and (p1!.geo = p2!.geo);
end );
#############################################################################
#O \=
# Equality of a subspace of a subgeometry and a subspace of a projective space
# returns always false.
##
InstallMethod( \=,
"for a subspace of subgeometry a projective space and a subspace of a projective space",
[IsSubspaceOfSubgeometryOfProjectiveSpace, IsSubspaceOfProjectiveSpace],
function(p1,p2);
return false;
end );
#############################################################################
#O \=
# Equality of a subspace of a subgeometry and a subspace of a projective space
# returns always false.
##
InstallMethod( \=,
"for a subspace of subgeometry a projective space and a subspace of a projective space",
[IsSubspaceOfProjectiveSpace, IsSubspaceOfSubgeometryOfProjectiveSpace],
function(p1,p2);
return false;
end );
#############################################################################
#O UnderlyingVectorSpace
# This operation is defined for subspaces of a projective space. However,
# for subspaces of a subgeometry, which are also subspaces of projective
# spaces, this is mathematically senseless. We have to think about this,
# but currently, we return an error.
##
InstallMethod( UnderlyingVectorSpace,
"for a subspace of subgeometry of a projective space",
[ IsSubspaceOfSubgeometryOfProjectiveSpace ],
function(el)
Error(" <el> is a subspace of a subgeometry of a projective space");
end );
#InstallMethod( BaseField,
# "for an element of a projective space",
# [IsSubspaceOfProjectiveSpace],
# sub -> sub!.basefield );
#############################################################################
#O ElementsOfIncidenceStructure
# Classical operation for Lie geometries, here for subgeometries of projective
# spaces. Note that for this method, we rely on the isomorphic subgeometry.
##
InstallMethod( ElementsOfIncidenceStructure,
"for a projective space and an integer",
[IsSubgeometryOfProjectiveSpace, IsPosInt],
function( ps, j )
local r;
r := Rank(ps);
if j > r then
Error("<ps> has no elements of type <j>");
else
return Objectify(
NewType( ElementsCollFamily, IsSubspacesOfSubgeometryOfProjectiveSpace and IsSubspacesOfSubgeometryOfProjectiveSpaceRep ),
rec( geometry := ps,
type := j,
size := Size(Subspaces(ps!.isomorphicsubgeometry!.vectorspace, j))
)
);
fi;
end);
#############################################################################
#O ExtendElementOfSubgeometry
# Particular method for subspaces of subgeometries: extend a subspace of a
# subgeometry to a subspace of the ambient projective space.
##
InstallMethod( ExtendElementOfSubgeometry,
"for an element of a subgeometry of a projective space",
[ IsSubspaceOfSubgeometryOfProjectiveSpace ],
element -> VectorSpaceToElement(AmbientSpace(element),Unpack(UnderlyingObject(element))));
# For elements of Lie geometries, incidence is based on set theoretic containment.
# therefore, a method of \in must be present. Note that we define several
# methods that return Errors if the (sub)geometries are different.
# For Lie geometries, \in is also applicable on subspaces of subgeometries
# and projective spaces.
#############################################################################
#O \in We use ExtendElementOfSubgeometry. Clearly, if the extension of an element
# is contained in the extension of another element, the first element is contained
# in the second in the subgeometry.
##
InstallMethod( \in,
"for two subspaces of a subgeometry",
[IsSubspaceOfSubgeometryOfProjectiveSpace, IsSubspaceOfSubgeometryOfProjectiveSpace],
function(x,y)
if x!.geo = y!.geo then
return ExtendElementOfSubgeometry(x) in ExtendElementOfSubgeometry(y);
else
Error("<x> and <y> do not belong to the same geometry");
fi;
end );
#############################################################################
#O \in for a subspace of a subgeometry and a subspace of a projective space.
##
InstallMethod( \in,
"for a subspace of a subgeometry and a subspace of a projective space",
[IsSubspaceOfSubgeometryOfProjectiveSpace, IsSubspaceOfProjectiveSpace],
function(x,y)
Error("<x> and <y> do not belong to the same geometry");
end );
#############################################################################
#O \in for a subspace of a projective space and a subspace of a subgeometry.
##
InstallMethod( \in,
"for a subspace of a projective space and a subspace of a subgeometry",
[IsSubspaceOfProjectiveSpace, IsSubspaceOfSubgeometryOfProjectiveSpace],
function(x,y)
Error("<x> and <y> do not belong to the same geometry");
end );
#############################################################################
#O \in for a subspace of a subgeometry of a projective space and a projective
# space. This is somehow tricky: subgeometries also belong to IsProjectiveSpace
# so the element!.geo = can really occur. The consequence is also that
# an element of a subgeometry is not in the ambient projective space. This
# complies with the basic philosophy of subgeometries.
##
InstallMethod( \in,
"for an element of a subgeometry of a projective space and a projective space",
[ IsSubspaceOfSubgeometryOfProjectiveSpace, IsProjectiveSpace],
function( element, ps )
if element!.geo = ps then
return true;
else
Error(" <element> is not an element of <ps>");
fi;
end );
#############################################################################
#O \in( <element>, <ps> )
# for a subspace of a projective space and a subgeometry.
# This is tricky as well: subspaces of subgeometries also belong to
# IsSubspaceOfProjectiveSpace so the element!.geo = ps can occur if the
# element is really a subspace of a subgeometry.
##
InstallMethod( \in,
"for an element of a subgeometry of a projective space and a projective space",
[ IsSubspaceOfProjectiveSpace, IsSubgeometryOfProjectiveSpace],
function( element, ps )
return element!.geo = ps;
end );
#############################################################################
#O Random( <subs> )
# returns a random subspace out of the collection of subspaces of given dimension
# of a subgeometry of a projective space. Note that Random has its own method
# for a collection of subspaces of a given dimension of a projective space.
# We use the isomorphic subgeometry for the method here.
##
InstallMethod( Random,
"for a collection of subspaces of a subgeometry of a projective space",
[ IsSubspacesOfSubgeometryOfProjectiveSpace ],
# chooses a random element out of the collection of subspaces of given
# dimension of a subgeometry of a projective space
function( subs )
local d, pg, w, isom, em, el;
## the underlying projective space
pg := subs!.geometry;
isom := pg!.isomorphicsubgeometry;
em := pg!.embedding;
if not IsInt(subs!.type) then
Error("The subspaces of the collection need to have the same dimension");
fi;
## the common type of elements of subs
d := subs!.type;
el := Random(ElementsOfIncidenceStructure(isom,d))^em;
if not IsCanonicalSubgeometryOfProjectiveSpace(pg) then
el := el^pg!.projectivity;
fi;
return Wrap(pg,d,UnderlyingObject(el));
end );
# Span/Meet operations. Note the basic philosophy. We allow a span of two
# subspaces of a subgeometry only if their ambient geometry is the same. So
# having the same ambient space is not sufficient. This is slightly different
# than for e.g. polar spaces.
#############################################################################
#O Span( <x>, <y> )
# for two elements of a subgeometry. We use Embed, then compute the
# span in the ambient space, and then rewrap the result as a subspace of
# the subgeometry. We are sure that if the ambient geometries of
# both subspaces are the same, the result is correct. It is checked whether
# this is true for the input.
##
InstallMethod( Span,
"for two elements of a subgeometry of a projective space",
[ IsSubspaceOfSubgeometryOfProjectiveSpace, IsSubspaceOfSubgeometryOfProjectiveSpace],
function(x,y)
local z,w,pg,span;
if x!.geo = y!.geo then
pg := AmbientSpace(x);
z := Embed(pg,x);
w := Embed(pg,y);
span := Span(z,w);
if (ProjectiveDimension(span) = ProjectiveDimension(x!.geo)) then
return x!.geo;
else
return Wrap(x!.geo,span!.type,UnderlyingObject(span));
fi;
else
Error( "<x> and <y> do not belong to the same geometry" );
fi;
end );
#############################################################################
#O Span( <l> )
# for a homogeneous lis of subspaces of a subgeometry. Note that the necessary
# checks are built in. We rely again on the Span in the ambient space.
# Compare this method with the method for Span for a homogeneous list of
# subspaces of a projective space.
##
InstallMethod( Span,
"for a homogeneous list of subspaces of a subgeometry of a projective space",
[ IsHomogeneousList and IsSubspaceOfSubgeometryOfProjectiveSpaceCollection ],
function( l )
local list, span, pg, same;
# first we check that all items in the list belong to the same ambient geometry
if Length(l)=0 then
return [];
elif not Size(AsDuplicateFreeList(List(l,x->AmbientGeometry(x))))=1 then
Error("The elements in the list do not belong to the same ambient geometry");
else
pg := AmbientSpace(l[1]);
list := List(l,x->Embed(pg,x));
span := Span(list);
same := Size(AsDuplicateFreeList(List(l,x->AmbientGeometry(x))))=1;
if (ProjectiveDimension(span) = ProjectiveDimension(l[1]!.geo)) then
return l[1]!.geo;
else
return Wrap(l[1]!.geo,span!.type,UnderlyingObject(span));
fi;
fi;
end );
#############################################################################
#O Span( <x>, <y> )
# for a subspace of subgeometry and a subspace of a projective space. Simply
# produces an error. But we need to install this method, if not, the method
# for Span for two subspaces of a projective space would return a result which
# makes, in our philosophy of subgeometries, no sense.
##
InstallMethod( Span,
"for a subspace of a projective space and a subspace of a subgeometry",
[IsSubspaceOfProjectiveSpace, IsSubspaceOfSubgeometryOfProjectiveSpace],
function(x,y)
Error("<x> and <y> do not belong to the same geometry");
end );
#############################################################################
#O Span( <x>, <y> )
# see comment on previous Span method
##
InstallMethod( Span,
"for a subspace of a subgeometry and a subspace of a projective space",
[ IsSubspaceOfSubgeometryOfProjectiveSpace, IsSubspaceOfProjectiveSpace],
function(x,y)
Error("<x> and <y> do not belong to the same geometry");
end );
#############################################################################
#O Span( <element>, <ps> )
# returns <ps> if it is the ambient geometry of element.
##
InstallMethod( Span,
"for an element of a subgeometry of a projective space and a projective space",
[ IsSubspaceOfSubgeometryOfProjectiveSpace, IsProjectiveSpace],
function( element, ps )
if element!.geo = ps then
return ps;
else
Error( "<element> does not belong to <ps>");
fi;
end );
#############################################################################
#O Span( <ps>, <element> )
# returns <ps> if it is the ambient geometry of element.
##
InstallMethod( Span,
"for a projective space and an element of a subgeometry of a projective space",
[ IsProjectiveSpace, IsSubspaceOfSubgeometryOfProjectiveSpace],
function( ps, element )
if element!.geo = ps then
return ps;
else
Error( "<element> does not belong to <ps>");
fi;
end );
#############################################################################
#O Meet( <x>, <y> )
# for two elements of a subgeometry. We use Embed, then compute the
# meet in the ambient space, and then rewrap the result as a subspace of
# the subgeometry. We are sure that if the ambient geometries of
# both subspaces are the same, the result is correct. It is checked whether
# this is true for the input.
##
InstallMethod( Meet,
"for two elements of a subgeometry of a projective space",
[ IsSubspaceOfSubgeometryOfProjectiveSpace, IsSubspaceOfSubgeometryOfProjectiveSpace],
function(x,y)
local z,w,pg,meet;
if x!.geo = y!.geo then
pg := AmbientSpace(x);
z := Embed(pg,x);
w := Embed(pg,y);
meet := Meet(z,w);
if IsEmptySubspace(meet) then
return EmptySubspace(x!.geo);
else
return Wrap(x!.geo,meet!.type,UnderlyingObject(meet));
fi;
else
Error( "<x> and <y> do not belong to the same geometry" );
fi;
end );
#############################################################################
#O Meet( <l> )
# for a homogeneous lis of subspaces of a subgeometry. Note that the necessary
# checks are built in. We rely again on the Meet in the ambient space.
# Compare this method with the method for Meet for a homogeneous list of
# subspaces of a projective space.
##
InstallMethod( Meet,
"for a homogeneous list of subspaces of a subgeometry of a projective space",
[ IsHomogeneousList and IsSubspaceOfSubgeometryOfProjectiveSpaceCollection ],
function( l )
local list, meet, pg, same;
# first we check that all items in the list belong to the same ambient geometry
if Length(l)=0 then
return [];
elif not Size(AsDuplicateFreeList(List(l,x->AmbientGeometry(x))))=1 then
Error("The elements in the list do not belong to the same ambient geometry");
else
pg := AmbientSpace(l[1]);
list := List(l,x->Embed(pg,x));
meet := Meet(list);
# same := Size(AsDuplicateFreeList(List(l,x->AmbientGeometry(x))))=1;
if IsEmptySubspace(meet) then
return EmptySubspace(l[1]!.geo);
else
return Wrap(l[1]!.geo,meet!.type,UnderlyingObject(meet));
fi;
fi;
end );
# we might consider to allow slightly more here: e.g. meet of a subspace of
# of subgeometry with a subspace of the ambient space.
#############################################################################
#O Meet( <x>, <y> )
# for a subspace of subgeometry and a subspace of a projective space. Simply
# produces an error. But we need to install this method, if not, the method
# for Meet for two subspaces of a projective space would return a result which
# makes, in our philosophy of subgeometries, no sense.
##
InstallMethod( Meet,
"for a subspace of a projective space and a subspace of a subgeometry",
[IsSubspaceOfProjectiveSpace, IsSubspaceOfSubgeometryOfProjectiveSpace],
function(x,y)
Error("<x> and <y> do not belong to the same geometry");
end );
InstallMethod( Meet,
"for a subspace of a subgeometry and a subspace of a projective space",
[ IsSubspaceOfSubgeometryOfProjectiveSpace, IsSubspaceOfProjectiveSpace],
function(x,y)
Error("<x> and <y> do not belong to the same geometry");
end );
#############################################################################
#O Meet( <element>, <ps> )
# returns <element> if <ps> is the ambient geometry of element.
##
InstallMethod( Meet,
"for an element of a subgeometry of a projective space and a projective space",
[ IsSubspaceOfSubgeometryOfProjectiveSpace, IsProjectiveSpace],
function( element, ps )
if element!.geo = ps then
return element;
else
Error( "<element> does not belong to <ps>");
fi;
end );
#############################################################################
#O Meet( <ps>, <element> )
# returns <element> if <ps> is the ambient geometry of element.
##
InstallMethod( Meet,
"for a projective space and an element of a subgeometry of a projective space",
[ IsProjectiveSpace, IsSubspaceOfSubgeometryOfProjectiveSpace],
function( ps, element )
if element!.geo = ps then
return element;
else
Error( "<element> does not belong to <ps>");
fi;
end );
#############################################################################
#O Meet( <sub>, <el> )
# for a subgeometry and a subspace of a projective space.
##
#use sigma to compute the intersection of an element of the ambient space
InstallMethod( Meet,
"for a subgeometry of a projectice space and a subspace of the ambient space",
[ IsSubgeometryOfProjectiveSpace, IsSubspaceOfProjectiveSpace],
function( sub, el)
local sigma,meet;
if not AmbientSpace(sub) = AmbientGeometry(el) then
Error( "the ambient space of <sub> is not the ambient geometry of <el>");
else
sigma := sub!.sigma;
meet := Meet(el,el^sigma);
if not IsEmptySubspace(meet) then
return Wrap(sub,meet!.type,meet!.obj);
else
return EmptySubspace(sub);
fi;
fi;
end );
#############################################################################
#O Meet( <sub>, <el> )
# for a subspace of a projective space and a subgeometry
##
InstallMethod( Meet,
"for a projective space and an element of a subgeometry of a projective space",
[ IsSubspaceOfProjectiveSpace, IsSubgeometryOfProjectiveSpace],
function( el, sub )
return Meet(sub,el);
end );
# flags and shadows
#############################################################################
#O FlagOfIncidenceStructure( <ps>, <els> )
# returns the flag of the subgeometry <ps> with elements in <els>.
# It is checked first whether the elements in <els> belong to the
# same ambient geometry. The method checks whether the input really determines a flag.
# Note that the filter for the first argument is IsProjectiveSpace. So this method
# is applicable for a projective space that is not a subgeometry and a list
# of elements of a subgeometry, but will give an appropriate error.
# Using IsSubgeometryOfProjectiveSpace would force us to install another method
# just producing an error saying that the elements do not belong to <ps>
# if called with the first argument a projective space that is not a subgeometry.
# Installing no such method in that case would result in a no method found error.
##
InstallMethod( FlagOfIncidenceStructure,
"for a projective space and list of subspaces of the projective space",
[ IsProjectiveSpace, IsSubspaceOfSubgeometryOfProjectiveSpaceCollection ],
function(ps,els)
local list,i,test,type,flag;
list := Set(ShallowCopy(els));
if Length(list) > Rank(ps) then
Error("A flag can contain at most Rank(<ps>) elements");
fi;
test := List(list,x->AmbientGeometry(x));
if not ForAll(test,x->x=ps) then
Error("not all elements have <ps> as ambient geometry");
fi;
test := Set(List([1..Length(list)-1],i -> IsIncident(list[i],list[i+1])));
if (test <> [ true ] and test <> []) then
Error("<els> do not determine a flag");
fi;
flag := rec(geo := ps, types := List(list,x->x!.type), els := list, vectorspace := ps!.vectorspace );
ObjectifyWithAttributes(flag, IsFlagsOfSgOPSType, IsEmptyFlag, false, RankAttr, Size(list) );
return flag;
end);
#############################################################################
#O ShadowOfElement( <ps>, <v>, <j> )
# returns the shadow of an element v as a record containing the subgeometry <ps>,
# the type j of the elements (type), the element v (parentflag), and
# some extra information useful to compute with the shadows, e.g. iterator
# This method relies on the isomorphic subgeometry of <ps>
# Note: we use IsProjectiveSpace, see also note at FlagOfIncidenceStructure
##
InstallMethod( ShadowOfElement,
"for a projective space, an element of a subgeometry, and an integer",
[IsProjectiveSpace, IsSubspaceOfSubgeometryOfProjectiveSpace, IsPosInt],
# returns the shadow of an element v as a record containing the projective space (geometry),
# the type j of the elements (type), the element v (parentflag), and some extra information
# useful to compute with the shadows, e.g. iterator
function( ps, v, j )
local localinner, localouter, localfactorspace, tocanonical, vs, vcanonical;
if not AmbientGeometry(v) = ps then
Error("<ps> is not the ambient geometry of <v>");
fi;
if j > ps!.dimension then
Error("<ps> has no elements of type <j>");
fi;
if not IsCanonicalSubgeometryOfProjectiveSpace(ps) then
tocanonical := (ps!.projectivity)^(-1);
vcanonical := v^tocanonical;
else
vcanonical := v;
fi;
vs := ps!.isomorphicsubgeometry!.vectorspace;
if j < v!.type then
localinner := [];
localouter := Unpack(vcanonical!.obj);
elif j = v!.type then
tocanonical := (ps!.proj)^(-1);
localinner := Unpack(vcanonical!.obj);
localouter := localinner;
else
localinner := Unpack(vcanonical!.obj);
localouter := BasisVectors(Basis(vs));
fi;
if IsVector(localinner) and not IsMatrix(localinner) then
localinner := [localinner];
fi;
if IsVector(localouter) and not IsMatrix(localouter) then
localouter := [localouter];
fi;
localfactorspace := Subspace(vs,
BaseSteinitzVectors(localouter, localinner).factorspace);
return Objectify( NewType( ElementsCollFamily, IsElementsOfIncidenceStructure and
IsShadowSubspacesOfSubgeometryOfProjectiveSpace and
IsShadowSubspacesOfSubgeometryOfProjectiveSpaceRep),
rec( geometry := ps,
type := j,
inner := localinner,
outer := localouter,
factorspace := localfactorspace,
parentflag := FlagOfIncidenceStructure(ps,[v]),
size := Size(Subspaces(localfactorspace))
)
);
end);
#############################################################################
#O ShadowOfFlag( <ps>, <flag>, <j> )
# returns the shadow elements of <flag>, i.e. the elements of <ps> of type <j>
# incident with all elements of <flag>.
# returns the shadow of a flag as a record containing the geometry,
# the type j of the elements (type), the flag (parentflag), and some extra information
# useful to compute with the shadows, e.g. iterator
# This method relies on the isomorphic subgeometry of <ps>
# Note: we use IsProjectiveSpace, see also note at FlagOfIncidenceStructure
##
InstallMethod( ShadowOfFlag,
"for a a projective space, a flag of a subgeometry of a projective space, and an integer",
[IsProjectiveSpace, IsFlagOfSubgeometryOfProjectiveSpace, IsPosInt],
function( ps, flag, j )
local localinner, localouter, localfactorspace, v, smallertypes, biggertypes, ceiling, floor, canels, vs;
if not flag!.geo = ps then
Error("<flag> is not a flag of <ps>");
fi;
if j > ps!.dimension then
Error("<ps> has no elements of type <j>");
fi;
#empty flag - return all subspaces of the right type
if IsEmptyFlag(flag) then
return ElementsOfIncidenceStructure(ps, j);
fi;
# find the element in the flag of highest type less than j, and the subspace
# in the flag of lowest type more than j.
#listoftypes:=List(flag,x->x!.type);
smallertypes:=Filtered(flag!.types,t->t <= j);
biggertypes:=Filtered(flag!.types,t->t >= j);
vs := ps!.isomorphicsubgeometry!.vectorspace;
if not IsCanonicalSubgeometryOfProjectiveSpace(ps) then
canels := List(flag!.els,x->x^(ps!.projectivity^(-1)));
else
canels := List(flag!.els);
fi;
if smallertypes=[] then
localinner := [];
ceiling:=Minimum(biggertypes);
localouter:= canels[Position(flag!.types,ceiling)];
elif biggertypes=[] then
localouter:=BasisVectors(Basis(vs));
floor:=Maximum(smallertypes);
localinner:= canels[Position(flag!.types,floor)];
else
floor:=Maximum(smallertypes);
ceiling:=Minimum(biggertypes);
localinner:= canels[Position(flag!.types,floor)];
localouter:= canels[Position(flag!.types,ceiling)];
fi;
if not smallertypes = [] then
if localinner!.type = 1 then
localinner:=[Unpack(localinner!.obj)]; #here is the cmat change
else
localinner:=Unpack(localinner!.obj);
fi;
fi;
if not biggertypes = [] then
if localouter!.type = 1 then
localouter := [Unpack(localouter!.obj)];
else
localouter := Unpack(localouter!.obj);
fi;
fi;
localfactorspace := Subspace(vs,
BaseSteinitzVectors(localouter, localinner).factorspace);
return Objectify(
NewType( ElementsCollFamily, IsElementsOfIncidenceStructure and
IsShadowSubspacesOfSubgeometryOfProjectiveSpace and
IsShadowSubspacesOfSubgeometryOfProjectiveSpaceRep),
rec(
geometry := ps,
type := j,
inner := localinner,
outer := localouter,
factorspace := localfactorspace,
parentflag := flag,
size := Size(Subspaces(localfactorspace)) #this causes a problem when localfactorspace consists of cvec/cmat.
)
);
end);
#############################################################################
#O Iterator: the classical iterator, relying completely on the isomorphic
# subgeometry and using the projectivity.
##
InstallMethod(Iterator,
"for subspaces of a projective space",
[ IsSubspacesOfSubgeometryOfProjectiveSpace ],
function( vs )
local sub, isomorphicsubgeometry, canonicalelements, j, em, proj, map;
sub := vs!.geometry;
j := vs!.type;
isomorphicsubgeometry := sub!.isomorphicsubgeometry;
canonicalelements := ElementsOfIncidenceStructure(isomorphicsubgeometry,j);
em := sub!.embedding;
if IsCanonicalSubgeometryOfProjectiveSpace(sub) then
map := x->Wrap(sub,j,UnderlyingObject(x^em));
else
proj := sub!.projectivity;
map := x->Wrap(sub,j,UnderlyingObject((x^em)^proj));
fi;
return IteratorByFunctions(
rec(
NextIterator := function(iter)
local element;
element := NextIterator(iter!.S);
return map(element);
end,
IsDoneIterator := function(iter)
return IsDoneIterator(iter!.S);
end,
ShallowCopy := function(iter)
return rec(
S := ShallowCopy(iter!.S)
);
end,
S := Iterator(canonicalelements)
));
end);
#############################################################################
#O Iterator: the classical iterator for shadows, relying completely on
# the isomorphic subgeometry and using the projectivity.
##
InstallMethod( Iterator,
"for shadow subspaces of a projective space",
[IsShadowSubspacesOfSubgeometryOfProjectiveSpace and IsShadowSubspacesOfSubgeometryOfProjectiveSpaceRep ],
function( vs )
local j, d, F, act, sub, proj;
sub := vs!.geometry;
j := vs!.type;
d := sub!.dimension;
F := sub!.basefield;
if IsCanonicalSubgeometryOfProjectiveSpace(sub) then
act := x->x;
else
proj := sub!.projectivity;
#this should be just the action of the projectivity on x, see OnProjSubspacesNoFrob, we will take over
#the code from there, OnProjSubspacesNoFrob expect that both arguments are cvec/cmat. Also note that
#x is always a matrix.
act := function(x)
local mat;
mat := OnSubspacesByCanonicalBasis(x,Unpack(proj!.mat));
TriangulizeMat(mat);
return mat;
end;
fi;
return IteratorByFunctions( rec(
NextIterator := function(iter)
local mat;
mat := NextIterator(iter!.S);
mat := MutableCopyMat(Concatenation(
BasisVectors(Basis(mat)),
iter!.innermat
));
return VectorSpaceToElement(sub,act(mat));
end,
IsDoneIterator := function(iter)
return IsDoneIterator(iter!.S);
end,
ShallowCopy := function(iter)
return rec(
innermat := iter!.innermat,
S := ShallowCopy(iter!.S)
);
end,
innermat := vs!.inner,
S := Iterator(Subspaces(vs!.factorspace,j-Size(vs!.inner)))
));
end);
## groups and actions.
InstallMethod( CollineationGroup,
"for a subgeometry of a projective space",
[ IsSubgeometryOfProjectiveSpace and IsSubgeometryOfProjectiveSpaceRep ],
function( sub )
local coll,d,f,frob,g,newgens,q,s,pow,h,baer;
f := sub!.subfield;
q := Size(f);
d := ProjectiveDimension(sub);
if d <= -1 then
Error("The dimension of the projective spaces needs to be at least 0");
fi;
g := GL(d+1,f);
frob := FrobeniusAutomorphism(sub!.basefield); #frobenius automorphism of big field
h := DegreeOverPrimeField(BaseField(sub));
newgens := List(GeneratorsOfGroup(g),x->[x,frob^0]);
#baer := frob^Length(FactorsInt(q)); #this is precisely the Baer collineation for the canonical subgeometry.
#Add(newgens,[One(g),baer]);
# new paradigm: CollineationGroup(sub) will not consider the embedding,
# if q is not prime, the frobenius automorphism of GF(q) is also a collineation.
# note that we add the frobenius automorphism of the basefield (not the subfield).
#if not IsPrime(q) then #if q is not prime, there is a frobenius automorphism.
# Add(newgens,[One(g),frob]);
# s := q^(d*(d+1)/2)*Product(List([2..d+1], i->q^i-1)) * Order(frob);
#else
# Add(newgens,[One(g),baer]);
# s := q^(d*(d+1)/2)*Product(List([2..d+1], i->q^i-1)) * Order(baer);
#fi;
Add(newgens,[One(g),frob]);
s := Size(CollineationGroup(PG(d,q)))*h;
newgens := ProjElsWithFrob(newgens,sub!.basefield); #using sub!.basefield as second argument makes sure that
# ProjElsWithFrob returns elements in the collineation group of the ambient projective space.
if not IsCanonicalSubgeometryOfProjectiveSpace(sub) then
newgens := List(newgens,x->sub!.projectivity^(-1)*x*sub!.projectivity);
fi;
coll := GroupWithGenerators(newgens);
#pow := LogInt(q, Characteristic(f)); #order of frobenius of subfield!
#s := pow * q^(d*(d+1)/2)*Product(List([2..d+1], i->q^i-1))*Order(baer); #hard coded order!
if not IsPrime(q) then
SetName( coll, Concatenation("The FinInG collineation group PGammaL(",String(d+1),",",String(q),") of ",ViewString(sub)) );
else
SetName( coll, Concatenation("The FinInG collineation group PGL(",String(d+1),",",String(q),") of ",ViewString(sub)) );
# Remark that in the prime case, PGL is returned as a FinInG collineation group with associated automorphism F^0.
fi;
SetSize( coll, s );
# only for making generalised polygons section more generic:
if d = 2 then
SetCollineationAction(coll,OnProjSubspacesOfSubgeometryNC);
fi;
SetDefaultGeometry(coll,sub);
SetParent(coll,CollineationGroup(AmbientSpace(sub)));
return coll;
end );
##
InstallMethod( ProjectivityGroup,
"for a subgeometry of a projective space",
[ IsSubgeometryOfProjectiveSpace and IsSubgeometryOfProjectiveSpaceRep ],
function( sub )
local d,f,frob,g,newgens,q,s,baer,coll;
f := sub!.subfield;
q := Size(f);
d := ProjectiveDimension(sub);
if d <= -1 then
Error("The dimension of the projective spaces needs to be at least 0");
fi;
g := GL(d+1,f);
frob := FrobeniusAutomorphism(sub!.basefield); #frobenius automorphism of big field
newgens := List(GeneratorsOfGroup(g),x->[x,frob^0]);
#baer := frob^Length(FactorsInt(q)); #this is precisely the Baer collineation for the canonical subgeometry.
#Add(newgens,[One(g),baer]);
newgens := ProjElsWithFrob(newgens,sub!.basefield); #using sub!.basefield as second argument makes sure that
# ProjElsWithFrob returns elements in the collineation group of the ambient projective space.
if not IsCanonicalSubgeometryOfProjectiveSpace(sub) then
newgens := List(newgens,x->sub!.projectivity^(-1)*x*sub!.projectivity);
fi;
coll := GroupWithGenerators(newgens);
SetName( coll, Concatenation("The FinInG projectivity group PGL(",String(d+1),",",String(q),") of ",ViewString(sub)) );
#s := q^(d*(d+1)/2)*Product(List([2..d+1], i->q^i-1)) * Order(baer);
s := Size(ProjectivityGroup(PG(d,f)));
SetSize( coll, s );
# only for making generalised polygons section more generic:
if d = 2 then
SetCollineationAction(coll,OnProjSubspacesOfSubgeometryNC);
fi;
SetDefaultGeometry(coll,sub);
return coll;
end );
InstallMethod( NiceMonomorphism,
"for a projective group of a subgeometry",
[IsProjectiveGroupWithFrob and HasDefaultGeometry],
50,
function( pg )
local hom, dom,bf, geom;
Info(InfoFinInG,4,"Using NiceMonomorphism for proj. group (feasible)");
geom := DefaultGeometry(pg);
bf := SubfieldOfSubgeometry(geom);
#dom := List(MakeAllProjectivePoints( bf, Dimension(pg) - 1),x->OnProjPointsWithFrob(x,geom!.projectivity));
dom := AsList(Points(geom));
#The use of FINING.Fast seems deprecated 25/5/2020.
#if FINING.Fast then
hom := NiceMonomorphismByDomain( pg, dom, OnProjSubspacesOfSubgeometryNC );
#else
# hom := ActionHomomorphism(pg, dom, OnProjSubspacesOfSubgeometriesNC, "surjective");
# SetIsBijective(hom, true);
#fi;
return hom;
end );
InstallGlobalFunction( OnProjSubspacesOfSubgeometryNC,
function( var, el )
local amb,geo,newvar;
geo := var!.geo;
if var!.type = 1 then
newvar := OnProjPointsWithFrob(var!.obj,el);
else
newvar := OnProjSubspacesWithFrob(var!.obj,el);
fi;
return Wrap(geo,var!.type,newvar);
end );
InstallGlobalFunction( OnProjSubspacesOfSubgeometry,
function( var, el )
local amb,geo,newvar,newel,baer;
geo := var!.geo;
if var!.type = 1 then
newvar := OnProjPointsWithFrob(var!.obj,el);
else
newvar := OnProjSubspacesWithFrob(var!.obj,el);
fi;
newel := Wrap(AmbientSpace(geo),var!.type,newvar);
baer := geo!.sigma;
if newel^baer = newel then
return Wrap(geo,var!.type,newvar);
else
return newel;
fi;
end );
InstallOtherMethod( \^,
"for an element of an incidence structure and a projective semilinear element",
[IsSubspaceOfSubgeometryOfProjectiveSpace, IsProjGrpElWithFrob],
function(x, em)
return OnProjSubspacesOfSubgeometry(x,em);
end );
InstallGlobalFunction( OnSubgeometryOfProjectiveSpace,
function( sub, el )
local frame;
frame := List(sub!.frame,x->x^el);
return SubgeometryOfProjectiveSpaceByFrame(AmbientSpace(sub),frame,SubfieldOfSubgeometry(sub));
end );
[ zur Elbe Produktseite wechseln0.58Quellennavigators
Analyse erneut starten
]
|
