| Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/GAP/pkg/fining/lib/ (GAP Algebra Version 4.15.1©) Datei vom 27.6.2023 mit Größe 114 kB |
|
Quelle polarspace.gi Sprache: Shell |
|||||||||||||||
|
############################################################################# ## ## polarspace.gi FinInG package ## John Bamberg ## Anton Betten ## Jan De Beule ## Philippe Cara ## Michel Lavrauw ## Max Neunhoeffer ## ## Copyright 2018 Colorado State University ## Sabancı Üniversitesi ## Università degli Studi di Padova ## Universiteit Gent ## University of St. Andrews ## University of Western Australia ## Vrije Universiteit Brussel ## ## ## Implementation stuff for polar spaces ## ############################################################################# ############################################################################# # Low level help methods: ############################################################################# FINING.LimitForCanComputeActionOnPoints := 1000000; FINING.Fast := true; ############################################################################# # Constructor method (not for users)!: ############################################################################# # CHECKED 20/09/11 jdb ############################################################################# #O Wrap( <geo>, <type>, <o> ) # This is an internal subroutine which is not expected to be used by the user; # they would be using VectorSpaceToElement. Recall that Wrap is declared in # geometry.gd. ## InstallMethod( Wrap, "for a polar space and an object", [IsClassicalPolarSpace, IsPosInt, IsObject], function( geo, type, o ) local w; w := rec( geo := geo, type := type, obj := o ); Objectify( NewType( SoPSFamily, IsElementOfIncidenceStructure and #Objectify( NewType( SoCPSFamily, IsElementOfIncidenceStructure and #keep this, maybe fo IsElementOfIncidenceStructureRep and IsSubspaceOfClassicalPolarSpace ), w ); return w; end ); ############################################################################# # Constructor methods for polar spaces. ############################################################################# # CHECKED 11/10/11 jb + jdb ############################################################################# #O PolarSpace( <m>, <f>, <g>, <act> ) # This method returns a polar space with a lot of knowledge. most likely not for user. # <m> is a sesquilinear form. Furthermore, a field <f>, a group <g> and an action # function <act> are given. ## InstallMethod( PolarSpace, "for a sesquilinear form, a field, a group and an action function", [ IsSesquilinearForm, IsField, IsGroup, IsFunction ], function( m, f, g, act ) local geo, ty, gram, eq, r, i1, i2, r2, fam, j, flag; if IsDegenerateForm( m ) then Error("Form is degenerate"); elif IsPseudoForm( m ) then Error("No Polar space can be associated with a pseudo form"); fi; gram := m!.matrix; geo := rec( basefield := f, dimension := Length(gram)-1, vectorspace := FullRowSpace(f,Length(gram)) ); if IsHermitianForm(m) then flag := IsHermitianVariety; else flag := IsQuadraticVariety; fi; if not IsAlternatingForm(m) then if WittIndex(m) = 2 then ty := NewType( GeometriesFamily, IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsClassicalGQ and flag); else ty := NewType( GeometriesFamily, IsClassicalPolarSpace and IsClassicalPolarSpaceRep and flag); fi; else if WittIndex(m) = 2 then ty := NewType( GeometriesFamily, IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsClassicalGQ); else ty := NewType( GeometriesFamily, IsClassicalPolarSpace and IsClassicalPolarSpaceRep); fi; fi; # at this stage, we are sure that if m is a bilinear form and the characteristic is even, # then m will be symplectic and PolynomialOfForm(m) will produce an error. # on the other hand, if m is symplectic and the characteristic is odd, then PolynomialOfForm # will produce a 0*Z(q). if IsEvenInt(Size(f)) and IsBilinearForm(m) then eq := Zero(f); else eq := PolynomialOfForm( m ); fi; if IsZero(eq) then i1 := List([1..Length(gram)],i->Concatenation("x",String(i))); i2 := List([1..Length(gram)],i->Concatenation("y",String(i))); #r := PolynomialRing(f,Concatenation(i1,i2):old); ## there was an error here for gap4r5 #i2 := IndeterminatesOfPolynomialRing(r){[Length(gram)+1..2*Length(gram)]}; #there was a proble with the above lines. If say x_4 existed already, and i1 just ran until 3, than # x_4 got changed by y_1, which caused all polynomials in r to change also, which caused funny pri # the 10000 is completely arbitrary, I guess nobody will use the first 10000 variables in forms, # will work in a 10000-dimensional vector space (I guess...). r := PolynomialRing(f,i1:old); ## there was an error here for gap4r5 i1 := IndeterminatesOfPolynomialRing(r){[1..Length(gram)]}; r2 := PolynomialRing(f,[10001..10000+Length(gram)]:old); fam := FamilyObj(r2.1); for j in [1..Length(gram)] do SetIndeterminateName(fam,10000+j,i2[j]); od; i2 := IndeterminatesOfPolynomialRing(r2); eq := i1*gram*i2; fi; ObjectifyWithAttributes( geo, ty, SesquilinearForm, m, CollineationGroup, g, CollineationAction, act, AmbientSpace, ProjectiveSpace(geo.dimension, f), EquationForPolarSpace, eq ); return geo; end ); # CHECKED 11/10/11 jb + jdb ############################################################################# #O PolarSpaceStandard( <m>, <bool> ) # Method to crete a polar space using sesquilinear form <m>, where we know # that this form is the standard one used in Fining. Not intended for users, # all checks are removed. ## InstallMethod( PolarSpaceStandard, "for a sesquilinear form", [ IsSesquilinearForm, IsBool ], function( m, bool ) local geo, ty, gram, f, eq, r, i1, i2, r2, fam, j, flag; gram := m!.matrix; f := m!.basefield; geo := rec( basefield := f, dimension := Length(gram)-1, vectorspace := FullRowSpace(f,Length(gram)) ); if IsHermitianForm(m) then flag := IsHermitianVariety; else flag := IsQuadraticVariety; fi; if not IsAlternatingForm(m) then if WittIndex(m) = 2 then ty := NewType( GeometriesFamily, IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsClassicalGQ and flag); else ty := NewType( GeometriesFamily, IsClassicalPolarSpace and IsClassicalPolarSpaceRep and flag); fi; else if WittIndex(m) = 2 then ty := NewType( GeometriesFamily, IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsClassicalGQ); else ty := NewType( GeometriesFamily, IsClassicalPolarSpace and IsClassicalPolarSpaceRep); fi; fi; # at this stage, we are sure that if m is a bilinear form and the characteristic is even, # then m will be symplectic and PolynomialOfForm(m) will produce an error. # on the other hand, if m is symplectic and the characteristic is odd, then PolynomialOfForm # will produce a 0*Z(q). if IsEvenInt(Size(f)) and IsBilinearForm(m) then eq := Zero(f); else eq := PolynomialOfForm( m ); fi; if IsZero(eq) then #Print("eq is zero\n"); i1 := List([1..Length(gram)],i->Concatenation("x",String(i))); i2 := List([1..Length(gram)],i->Concatenation("y",String(i))); #r := PolynomialRing(f,Concatenation(i1,i2):old); ## there was an error here for gap4r5 #i2 := IndeterminatesOfPolynomialRing(r){[Length(gram)+1..2*Length(gram)]}; #there was a proble with the above lines. If say x_4 existed already, and i1 just ran until 3, than # x_4 got changed by y_1, which caused all polynomials in r to change also, which caused funny pri # the 10000 is completely arbitrary, I guess nobody will use the first 10000 variables in forms, # will work in a 10000-dimensional vector space (I guess...). r := PolynomialRing(f,i1:old); ## there was an error here for gap4r5 i1 := IndeterminatesOfPolynomialRing(r){[1..Length(gram)]}; r2 := PolynomialRing(f,[10001..10000+Length(gram)]:old); fam := FamilyObj(r2.1); for j in [1..Length(gram)] do SetIndeterminateName(fam,10000+j,i2[j]); od; i2 := IndeterminatesOfPolynomialRing(r2); eq := i1*gram*i2; fi; ObjectifyWithAttributes( geo, ty, SesquilinearForm, m, AmbientSpace, ProjectiveSpace(geo.dimension, f), EquationForPolarSpace, eq ); if bool then SetIsStandardPolarSpace(geo,true); #if bool is false, we can use this operation to construc fi; return geo; end ); ############################################################################# #O PolarSpaceStandard( <m>, <bool> ) # general method to create a polar space using quadratic form. Not intended # for the user. no checks. ## InstallMethod( PolarSpaceStandard, "for a quadratic form", [ IsQuadraticForm, IsBool ], function( m, bool ) local geo, ty, gram, polar, f, flavour, eq, flag; f := m!.basefield; gram := m!.matrix; polar := AssociatedBilinearForm( m ); geo := rec( basefield := f, dimension := Length(gram)-1, vectorspace := FullRowSpace(f,Length(gram)) ); if WittIndex(m) = 2 then ty := NewType( GeometriesFamily, IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsClassicalGQ and IsProjectiveV else ty := NewType( GeometriesFamily, IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsProjectiveVariety); fi; eq := PolynomialOfForm( m ); ObjectifyWithAttributes( geo, ty, QuadraticForm, m, SesquilinearForm, polar, AmbientSpace, ProjectiveSpace(geo.dimension, f), EquationForPolarSpace, eq ); if bool then SetIsStandardPolarSpace(geo,true); fi; return geo; end ); # CHECKED 20/09/11 jdb ############################################################################# #O PolarSpace( <m> ) # general method to crete a polar space using sesquilinear form <m>. It is checked # whether the form is not pseudo.## ## InstallMethod( PolarSpace, "for a sesquilinear form", [ IsSesquilinearForm ], function( m ) local geo, ty, gram, f, eq, r, i1, i2, r2, fam, j, flag; if IsDegenerateForm( m ) then Error("Form is degenerate"); elif IsPseudoForm( m ) then Error("No Polar space can be associated with a pseudo form"); fi; gram := m!.matrix; f := m!.basefield; geo := rec( basefield := f, dimension := Length(gram)-1, vectorspace := FullRowSpace(f,Length(gram)) ); if IsHermitianForm(m) then flag := IsHermitianVariety; else flag := IsQuadraticVariety; fi; if not IsAlternatingForm(m) then if WittIndex(m) = 2 then ty := NewType( GeometriesFamily, IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsClassicalGQ and flag); else ty := NewType( GeometriesFamily, IsClassicalPolarSpace and IsClassicalPolarSpaceRep and flag); fi; else if WittIndex(m) = 2 then ty := NewType( GeometriesFamily, IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsClassicalGQ); else ty := NewType( GeometriesFamily, IsClassicalPolarSpace and IsClassicalPolarSpaceRep); fi; fi; # at this stage, we are sure that if m is a bilinear form and the characteristic is even, # then m will be symplectic and PolynomialOfForm(m) will produce an error. # on the other hand, if m is symplectic and the characteristic is odd, then PolynomialOfForm # will produce a 0*Z(q). if IsEvenInt(Size(f)) and IsBilinearForm(m) then eq := Zero(f); else eq := PolynomialOfForm( m ); fi; if IsZero(eq) then #Print("eq is zero\n"); i1 := List([1..Length(gram)],i->Concatenation("x",String(i))); i2 := List([1..Length(gram)],i->Concatenation("y",String(i))); #r := PolynomialRing(f,Concatenation(i1,i2):old); ## there was an error here for gap4r5 #i2 := IndeterminatesOfPolynomialRing(r){[Length(gram)+1..2*Length(gram)]}; #there was a proble with the above lines. If say x_4 existed already, and i1 just ran until 3, than # x_4 got changed by y_1, which caused all polynomials in r to change also, which caused funny pri # the 10000 is completely arbitrary, I guess nobody will use the first 10000 variables in forms, # will work in a 10000-dimensional vector space (I guess...). r := PolynomialRing(f,i1:old); ## there was an error here for gap4r5 i1 := IndeterminatesOfPolynomialRing(r){[1..Length(gram)]}; r2 := PolynomialRing(f,[10001..10000+Length(gram)]:old); fam := FamilyObj(r2.1); for j in [1..Length(gram)] do SetIndeterminateName(fam,10000+j,i2[j]); od; i2 := IndeterminatesOfPolynomialRing(r2); eq := i1*gram*i2; fi; ObjectifyWithAttributes( geo, ty, SesquilinearForm, m, AmbientSpace, ProjectiveSpace(geo.dimension, f), IsStandardPolarSpace, false, EquationForPolarSpace, eq ); return geo; end ); # CHECKED 20/09/11 jdb ############################################################################# #O PolarSpace( <m> ) #general method to create a polar space using quadratic form. Possible in even #and odd char. ## InstallMethod( PolarSpace, "for a quadratic form", [ IsQuadraticForm ], function( m ) local geo, ty, gram, polar, f, flavour, eq; if IsSingularForm( m ) then Error("Form is singular"); fi; f := m!.basefield; gram := m!.matrix; polar := AssociatedBilinearForm( m ); geo := rec( basefield := f, dimension := Length(gram)-1, vectorspace := FullRowSpace(f,Length(gram)) ); if WittIndex(m) = 2 then ty := NewType( GeometriesFamily, IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsClassicalGQ and IsQuadraticVa else ty := NewType( GeometriesFamily, IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsQuadraticVariety); fi; eq := PolynomialOfForm(m); ObjectifyWithAttributes( geo, ty, QuadraticForm, m, SesquilinearForm, polar, AmbientSpace, ProjectiveSpace(geo.dimension, f), IsStandardPolarSpace, false, EquationForPolarSpace, eq ); return geo; end ); # CHECKED 20/09/11 jdb ############################################################################# #O PolarSpace( <m> ) # general method to setup a polar space using hermitian form. Is this method # still necessary? Maybe not necessary, but maybe usefull, since we know slightly # more properties of the polar space if we start from a hermitian form rather than # from a sesquilinear form. ## InstallMethod( PolarSpace, "for a hermitian form", [ IsHermitianForm ], function( m ) local geo, ty, gram, f, eq; if IsDegenerateForm( m ) then Error("Form is degenerate"); fi; gram := m!.matrix; f := m!.basefield; geo := rec( basefield := f, dimension := Length(gram)-1, vectorspace := FullRowSpace(f,Length(gram)) ); if WittIndex(m) = 2 then ty := NewType( GeometriesFamily, IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsClassicalGQ and IsHermitianVa else ty := NewType( GeometriesFamily, IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsHermitianVariety); fi; eq := PolynomialOfForm(m); ObjectifyWithAttributes( geo, ty, SesquilinearForm, m, AmbientSpace, ProjectiveSpace(geo.dimension, f), IsStandardPolarSpace, false, EquationForPolarSpace, eq ); return geo; end ); ############################################################################# ## Constructions of Canonical finite classical Polar Spaces ## Important remark. We use "Canonical" in the mathematical sense, i.e, a polar ## space that equals one of the "standard" polar spaces constructed by the methods ## below. So "Standard" refers to a particular form used to construct the polar space. ## It is well known that two forms that are similar, i.e. differe on a constant factor, ## will yield the same polar space. So a polar space is canonical iff its forms is similar with ## the form of one of the polar spaces constructed with a method below. A polar space is ## "standard" iff it is constructed with one of the methods below. So if the user ## uses his favorite form, his polar space can become canonical, but it can never become standar ############################################################################# ############################################################################# # Part I: A method to setup the representative of the maximal # subspaces for polar spaces of each type. # Recall that the methods for methods for canonical gram matrices and canonical # quadratic forms are found in group.gi. All these methods are not intended for the user. ############################################################################# # CHECKED 21/09/11 jdb ############################################################################# #O CanonicalOrbitRepresentativeForSubspaces( <type>, <d>, <f> ) ## This function returns representatives for the ## maximal totally isotropic (singular) subspaces ## of the given canonical polar space ## InstallMethod( CanonicalOrbitRepresentativeForSubspaces, "for a string, an integer and a field", [IsString, IsPosInt, IsField], function( type, d, f ) local b, i, id, one, w, q, sqrtq; q := Size(f); id := IdentityMat(d, f); if type = "symplectic" then b := List([1..d/2], i-> id[2*i-1] + id[2*i]); elif type = "hermitian" then one := One(f); sqrtq := Sqrt(q); ## find element with norm -1 w := First(AsList(f), t -> IsZero( t^(sqrtq+1) + one ) ); if IsEvenInt(d) then b := List([1..d/2], i-> w * id[2*i] + id[2*i-1]); else b := List([1..(d-1)/2], i-> w * id[2*i] + id[2*i-1]); fi; elif type = "parabolic" then b := id{List([1..(d-1)/2], i -> 2*i)}; elif type = "hyperbolic" then b := id{List([1..d/2], i -> 2*i-1)}; elif type = "elliptic" then b := id{List([1..(d/2-1)],i -> 2*i+1)}; else Error( "type is unknown or not implemented"); fi; return [b]; end ); ############################################################################# # Part II: constructor methods, for the user of course. ############################################################################# # CHECKED 21/09/11 jdb # Cmat adapted 20/3/14 ############################################################################# #O EllipticQuadric( <d>, <f> ) # returns the standard elliptic quadrac. See CanonicalQuadraticForm and CanonicalGramMatr # for details on the standard. ## InstallMethod( EllipticQuadric, "for an integer and a field", [ IsPosInt, IsField ], function( d, f ) local eq,m,types,max,reps,q,form,creps; q := Size(f); if IsEvenInt(d) then Error("dimension must be odd"); return; fi; if IsEvenInt(q) then m := CanonicalQuadraticForm("elliptic", d+1, f); form := QuadraticFormByMatrix(m, f); else m := CanonicalGramMatrix("elliptic", d+1, f); form := BilinearFormByMatrix(m, f); fi; eq := PolarSpaceStandard( form, true ); SetRankAttr( eq, (d-1)/2 ); types := TypesOfElementsOfIncidenceStructure( AmbientSpace(eq) ); SetTypesOfElementsOfIncidenceStructure(eq, types{[1..(d-1)/2]}); SetIsEllipticQuadric(eq, true); SetIsCanonicalPolarSpace(eq, true); SetPolarSpaceType(eq, "elliptic"); if RankAttr(eq) = 2 then SetOrder( eq, [q, q^2]); fi; max := CanonicalOrbitRepresentativeForSubspaces("elliptic", d+1, f)[1]; ## Here we take the maximal totally isotropic subspace rep ## max and make representatives for lower dimensional subspaces ## it could be that max is empty, not Max of course, but the variable max. if not IsEmpty(max) then reps := [ [max[1]] ]; #small change Append(reps, List([2..(d-1)/2], j -> max{[1..j]})); ## We would like the representative to be stored as ## compressed matrices. Then they will be more efficient ## to work with. creps := List(reps,x->NewMatrix(IsCMatRep, f, d+1, x)); creps[1] := creps[1][1]; #max is not empty, first element should always be a 1xn matrix->cvec. #for m in reps do # if IsMatrix(m) then # ConvertToMatrixRep(m,f); # else # ConvertToVectorRep(m,f); # fi; #od; ## Wrap 'em up #can be done without using VectorSpaceToElement (and hence withou computations reps := List([1..(d-1)/2], j -> Wrap(eq, j, creps[j]) ); #one more small change :-) SetRepresentativesOfElements(eq, reps); else; SetRepresentativesOfElements(eq, []); fi; SetClassicalGroupInfo( eq, rec( degree := (q^((d+1)/2)+1)*(q^((d+1)/2-1)-1)/(q-1) ) ); return eq; end ); # CHECKED 21/09/11 jdb ############################################################################# #O EllipticQuadric( <d>, <q> ) # returns the standard elliptic quadric. See EllipticQuadric method above. ## InstallMethod( EllipticQuadric, "for two positive inteters <d> and <q>", [ IsPosInt, IsPosInt ], function( d, q ) return EllipticQuadric(d,GF(q)); end ); # CHECKED 21/09/11 jdb # Cmat adapted 20/3/14 ############################################################################# #O SymplecticSpace( <d>, <f> ) # returns the standard symplectic space. See CanonicalGramMatrix # for details on the standard. ## InstallMethod( SymplecticSpace, "for an integer and a field", [ IsPosInt, IsField ], function( d, f ) local w,frob,m,types,max,reps,q,form,creps; if IsEvenInt(d) then Error("dimension must be odd"); return; fi; ## put compressed matrices here also q := Size(f); m := CanonicalGramMatrix("symplectic", d+1, f); w := PolarSpaceStandard( BilinearFormByMatrix(m, f), true ); SetRankAttr( w, (d+1)/2 ); types := TypesOfElementsOfIncidenceStructure(AmbientSpace(w)); if RankAttr(w) = 2 then SetOrder( w, [q, q]); fi; SetTypesOfElementsOfIncidenceStructure(w,types{[1..(d+1)/2]}); SetIsSymplecticSpace(w,true); SetIsCanonicalPolarSpace(w, true); SetPolarSpaceType(w, "symplectic"); max := CanonicalOrbitRepresentativeForSubspaces("symplectic", d+1, w!.basefield)[1]; ## Here we take the maximal totally isotropic subspace rep ## max and make representatives for lower dimensional subspaces reps := [ [ max[1] ] ]; #small change Append(reps, List([2..(d+1)/2], j -> max{[1..j]})); ## We would like the representative to be stored as ## compressed matrices. Then they will be more efficient ## to work with. creps := List(reps,x->NewMatrix(IsCMatRep, f, d+1, x)); creps[1] := creps[1][1]; #max is not empty, first element should always be a 1xn matrix->cvec. #for m in reps do # if IsMatrix(m) then # ConvertToMatrixRep(m,f); # else # ConvertToVectorRep(m,f); # fi; #od; ## Wrap 'em up reps := List([1..(d+1)/2], j -> Wrap(w, j, creps[j]) ); #one more small change :-) SetRepresentativesOfElements(w, reps); SetClassicalGroupInfo( w, rec( degree := (q^(d+1)-1)/(q-1) ) ); return w; end ); # CHECKED 21/09/11 jdb ############################################################################# #O SymplecticSpace( <d>, <q> ) # returns the standard symplectic space. See SymplecticSpace method above. ## InstallMethod(SymplecticSpace, "for an integer and an integer", [ IsPosInt, IsPosInt ], function( d, q ) return SymplecticSpace(d, GF(q)); end ); # CHECKED 21/09/11 jdb # Cmat adapted 20/3/14 ############################################################################# #O ParabolicQuadric( <d>, <f> ) # returns the standard parabolic quadric. See CanonicalQuadraticForm and CanonicalGramMat # for details on the standard. ## InstallMethod( ParabolicQuadric, "for an integer and a field", [ IsPosInt, IsField ], function( d, f ) local pq,m,types,max,reps,q,form,creps; if IsOddInt(d) then Error("dimension must be even"); return; fi; q := Size(f); if IsEvenInt(q) then m := CanonicalQuadraticForm("parabolic", d+1, f); form := QuadraticFormByMatrix(m, f); else m := CanonicalGramMatrix("parabolic", d+1, f); form := BilinearFormByMatrix(m, f); fi; pq := PolarSpaceStandard( form, true ); SetRankAttr( pq, d/2 ); types := TypesOfElementsOfIncidenceStructure( AmbientSpace(pq) ); SetTypesOfElementsOfIncidenceStructure(pq, types{[1..d/2]}); SetIsParabolicQuadric(pq, true); SetIsCanonicalPolarSpace(pq, true); SetPolarSpaceType(pq, "parabolic"); if RankAttr(pq) = 2 then SetOrder( pq, [q, q]); fi; max := CanonicalOrbitRepresentativeForSubspaces("parabolic", d+1, f)[1]; ## Here we take the maximal totally isotropic subspace rep ## max and make representatives for lower dimensional subspaces reps := [ [ max[1] ] ]; #small change Append(reps, List([2..d/2], j -> max{[1..j]})); ## We would like the representative to be stored as ## compressed matrices. Then they will be more efficient ## to work with. creps := List(reps,x->NewMatrix(IsCMatRep, f, d+1, x)); creps[1] := creps[1][1]; #max is not empty, first element should always be a 1xn matrix->cvec. #for m in reps do # if IsMatrix(m) then # ConvertToMatrixRep(m,f); # else # ConvertToVectorRep(m,f); # fi; #od; ## Wrap 'em up reps := List([1..d/2], j -> Wrap(pq, j, creps[j]) ); #one more small change :-) SetRepresentativesOfElements(pq, reps); SetClassicalGroupInfo( pq, rec( degree := (q^(d/2)-1)/(q-1)*(q^((d+2)/2-1)+1) ) ); return pq; end ); # CHECKED 21/09/11 jdb ############################################################################# #O ParabolicQuadric( <d>, <q> ) # returns the standard parabolic quadric. See ParabolicQuadric method above. ## InstallMethod( ParabolicQuadric, "for two integers", [ IsPosInt, IsPosInt ], function( d, q ) return ParabolicQuadric(d, GF(q)); end ); # CHECKED 21/09/11 jdb # Cmat adapted 20/3/14 ############################################################################# #O HyperbolicQuadric( <d>, <f> ) # returns the standard hyperbolic quadric. See CanonicalQuadraticForm and CanonicalGramMa # for details on the standard. ## InstallMethod( HyperbolicQuadric, "for an integer and a field", [ IsPosInt, IsField ], function( d, f ) local hq,m,types,max,reps,q,form,creps; q := Size(f); if IsEvenInt(d) then Error("dimension must be odd"); return; fi; if IsEvenInt(q) then m := CanonicalQuadraticForm("hyperbolic", d+1, f); form := QuadraticFormByMatrix(m, f); else m := CanonicalGramMatrix("hyperbolic", d+1, f); form := BilinearFormByMatrix(m, f); fi; hq := PolarSpaceStandard( form, true ); SetRankAttr( hq, (d+1)/2 ); types := TypesOfElementsOfIncidenceStructure( AmbientSpace(hq) ); SetTypesOfElementsOfIncidenceStructure(hq, types{[1..(d+1)/2]}); SetIsCanonicalPolarSpace(hq, true); SetIsHyperbolicQuadric(hq, true); SetPolarSpaceType(hq, "hyperbolic"); if RankAttr(hq) = 2 then SetOrder( hq, [q, 1]); fi; max := CanonicalOrbitRepresentativeForSubspaces("hyperbolic", d+1, f)[1]; ## Here we take the maximal totally isotropic subspace rep ## max and make representatives for lower dimensional subspaces reps := [ [ max[1] ] ]; #small change Append(reps, List([2..(d+1)/2], j -> max{[1..j]})); ## We would like the representative to be stored as ## compressed matrices. Then they will be more efficient ## to work with. creps := List(reps,x->NewMatrix(IsCMatRep, f, d+1, x)); creps[1] := creps[1][1]; #max is not empty, first element should always be a 1xn matrix->cvec. #for m in reps do # if IsMatrix(m) then # ConvertToMatrixRep(m,f); # else # ConvertToVectorRep(m,f); # fi; #od; ## Wrap 'em up reps := List([1..(d+1)/2], j -> Wrap(hq, j, creps[j]) ); #one more small change :-) SetRepresentativesOfElements(hq, reps); SetClassicalGroupInfo( hq, rec( degree := (q^((d+1)/2)-1)/(q-1)*(q^((d+1)/2-1)+1)) ); return hq; end ); # CHECKED 21/09/11 jdb ############################################################################# #O HyperbolicQuadric( <d>, <q> ) # returns the standard hyperbolic quadric. See HyperbolicQuadric method above. ## InstallMethod(HyperbolicQuadric, "for a two integers", [ IsPosInt, IsPosInt ], function( d, q ) return HyperbolicQuadric(d, GF(q)); end ); # CHECKED 21/09/11 jdb # Cmat adapted 20/3/14 ############################################################################# #O HermitianPolarSpace( <d>, <f> ) # returns the standard hermitian variety. See CanonicalGramMatrix # for details on the standard. ## InstallMethod( HermitianPolarSpace, "for an integer and a field", [ IsPosInt, IsField ], function( d, f ) local h,m,types,max,reps,q,creps,degree; if IsOddInt(DegreeOverPrimeField(f)) then Error("field order must be a square"); return; fi; q := Sqrt(Size(f)); m := CanonicalGramMatrix("hermitian", d+1, f); h := PolarSpaceStandard( HermitianFormByMatrix(m, f), true ); if d mod 2 = 0 then SetRankAttr( h, d/2 ); else SetRankAttr( h, (d+1)/2 ); fi; types := TypesOfElementsOfIncidenceStructure( AmbientSpace(h) ); SetTypesOfElementsOfIncidenceStructure(h, types{[1..RankAttr(h)]}); SetIsHermitianPolarSpace(h, true); SetIsCanonicalPolarSpace(h, true); SetPolarSpaceType(h, "hermitian"); if RankAttr(h) = 2 then if d = 3 then SetOrder( h, [q^2, q]); fi; if d = 4 then SetOrder( h, [q^2, q^3]); fi; fi; max := CanonicalOrbitRepresentativeForSubspaces("hermitian", d+1, f)[1]; ## Here we take the maximal totally isotropic subspace rep ## max and make representatives for lower dimensional subspaces reps := [ [ max[1] ] ]; #small change Append(reps, List([2..RankAttr(h)], j -> max{[1..j]})); ## We would like the representative to be stored as ## compressed matrices. Then they will be more efficient ## to work with. creps := List(reps,x->NewMatrix(IsCMatRep, f, d+1, x)); creps[1] := creps[1][1]; #max is not empty, first element should always be a 1xn matrix->cvec. #for m in reps do # if IsMatrix(m) then # ConvertToMatrixRep(m,f); # else # ConvertToVectorRep(m,f); # fi; #od; ## Wrap 'em up reps := List([1..RankAttr(h)], j -> Wrap(h, j, creps[j]) ); #one more small change :-) SetRepresentativesOfElements(h, reps); if d = 3 then degree := (q^3+1)*(q+1); else degree := (q^d-(-1)^d)*(q^(d+1)-(-1)^(d+1))/(q^2-1); fi; #SetClassicalGroupInfo( h, rec( degree := (q^d-(-1)^d)*(q^(d+1)-(-1)^(d+1))/(q^2-1)) ) SetClassicalGroupInfo( h, rec( degree := degree )); return h; end ); # CHECKED 21/09/11 jdb ############################################################################# #O HermitianPolarSpace( <d>, <q> ) # returns the standard hermitian polar space. See HermitianPolarSpace method above. ## InstallMethod(HermitianPolarSpace, "for an two integers", [ IsPosInt, IsPosInt ], function( d, q ) return HermitianPolarSpace(d, GF(q)); end ); # ADDED 7/11/12 jdb ############################################################################# #O StandardPolarSpace( <ps> ) # returns the standard polar space isomorphic with <ps>. ## InstallMethod( StandardPolarSpace, "for a polar space", [ IsClassicalPolarSpace ], function( ps ) local type, standard,d,f; d := ps!.dimension; f := ps!.basefield; type := PolarSpaceType( ps ); if type = "hermitian" then standard := HermitianPolarSpace(d, f); SetIsHermitianPolarSpace(ps, true); elif type = "symplectic" then standard := SymplecticSpace(d, f); SetIsSymplecticSpace(ps, true); elif type = "elliptic" then standard := EllipticQuadric(d, f); SetIsEllipticQuadric(ps, true); elif type = "parabolic" then standard := ParabolicQuadric(d, f); SetIsParabolicQuadric(ps, true); elif type = "hyperbolic" then standard := HyperbolicQuadric(d, f); SetIsHyperbolicQuadric(ps, true); fi; return standard; end ); # ADDED 30/3/14 jdb ############################################################################# #O IsCanonicalPolarSpace( <ps> ) # returns true if <ps> is canonical. Remind that canonical means similar to # standard: in geometrical terms: the same geometry as a standard polar space # with an underlying form that differs a factor with a standard form. # Calling this operation also makes sure the ClassicalGroupInfo is set and # the correct property. This mechanism makes sure that when a user constructs # his favorite-non-standard-but-canonical polar space, it is recognised by # FinInG, and only once a base change computation by forms will be done. ## InstallMethod( IsCanonicalPolarSpace, "for a polar space", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep ], function( ps ) local type, form, d, bf, st, gram, c1, c2, order, q, result; type := PolarSpaceType(ps); #a base change is computed in forms. d := ps!.dimension; bf := ps!.basefield; if HasQuadraticForm(ps) then form := QuadraticForm(ps); gram := GramMatrix(form); st := CanonicalQuadraticForm(type, d+1, bf); #returns a matrix. else form := SesquilinearForm(ps); gram := GramMatrix(form); st := CanonicalGramMatrix(type, d+1, bf); fi; q := Size(bf); if type = "elliptic" then SetIsEllipticQuadric(ps,true); order := (q^((d+1)/2)+1)*(q^((d+1)/2-1)-1)/(q-1); elif type = "parabolic" then SetIsParabolicQuadric(ps,true); order := (q^(d/2)-1)/(q-1)*(q^((d+2)/2-1)+1); elif type = "hyperbolic" then SetIsHyperbolicQuadric(ps,true); order := (q^((d+1)/2)-1)/(q-1)*(q^((d+1)/2-1)+1); elif type = "symplectic" then SetIsSymplecticSpace(ps,true); order := (q^(d+1)-1)/(q-1); elif type = "hermitian" then SetIsHermitianPolarSpace(ps,true); q := Sqrt(q); if d=3 then order := (q^3+1)*(q+1); else order := (q^d-(-1)^d)*(q^(d+1)-(-1)^(d+1))/(q^2-1); fi; fi; c1 := First(gram[1],x->not IsZero(x)); if c1 = fail then return false; fi; c2 := First(st[1],x->not IsZero(x)); result := c1*st = c2*gram; if result then SetClassicalGroupInfo( ps, rec( degree := order ) ); fi; return result; end ); # ADDED 7/11/12 jdb # Cmat adapted 20/3/14 ############################################################################# #O CanonicalPolarSpace( <ps> ) # assume that f is the form determining <ps>, then this operation returns a # polar space <geo> determined by a form isometric with f, so <geo> is canonical # but not necessarily standard. ## InstallMethod( CanonicalPolarSpace, "for a polar space", [ IsClassicalPolarSpace ], function( ps ) local type, canonicalps,d,f,form1,form2,isometric,b,mat1,mat2,canonicalmatrix,cano d := ps!.dimension; f := ps!.basefield; q := Size(f); type := PolarSpaceType( ps ); if type = "hermitian" then canonicalps := HermitianPolarSpace(d, f); SetIsHermitianPolarSpace(ps, true); elif type = "symplectic" then canonicalps := SymplecticSpace(d, f); SetIsSymplecticSpace(ps, true); elif type = "elliptic" then canonicalps := EllipticQuadric(d, f); SetIsEllipticQuadric(ps, true); elif type = "parabolic" then canonicalps := ParabolicQuadric(d, f); SetIsParabolicQuadric(ps, true); elif type = "hyperbolic" then canonicalps := HyperbolicQuadric(d, f); SetIsHyperbolicQuadric(ps, true); fi; if IsOddInt(Size(f)) and type in ["parabolic"] then form1 := QuadraticForm( ps ); isometric := IsometricCanonicalForm(form1); #be careful with the notion Canonical in Forms gram := GramMatrix(isometric); canonicalmatrix := gram[1,1]*CanonicalGramMatrix("parabolic", d+1, f); canonicalform := BilinearFormByMatrix(canonicalmatrix, f); canonicalps := PolarSpaceStandard( canonicalform, false ); SetRankAttr( canonicalps, d/2 ); types := TypesOfElementsOfIncidenceStructure( AmbientSpace(canonicalps) ); SetTypesOfElementsOfIncidenceStructure(canonicalps, types{[1..d/2]}); SetIsParabolicQuadric(canonicalps, true); SetIsCanonicalPolarSpace(canonicalps, true); SetIsStandardPolarSpace(canonicalps, false); SetPolarSpaceType(canonicalps, "parabolic"); if RankAttr(canonicalps) = 2 then SetOrder( canonicalps, [q, q]); fi; max := CanonicalOrbitRepresentativeForSubspaces("parabolic", d+1, f)[1]; ## Here we take the maximal totally isotropic subspace rep ## max and make representatives for lower dimensional subspaces reps := [ [ max[1] ] ]; #small change Append(reps, List([2..d/2], j -> max{[1..j]})); ## We would like the representative to be stored as ## compressed matrices. Then they will be more efficient ## to work with. creps := List(reps,x->NewMatrix(IsCMatRep, f, d+1, x)); creps[1] := creps[1][1]; #max is not empty, first element should always be a 1xn matrix->cvec. #for m in reps do # if IsMatrix(m) then # ConvertToMatrixRep(m,f); # else # ConvertToVectorRep(m,f); # fi; #od; ## Wrap 'em up reps := List([1..d/2], j -> Wrap(canonicalps, j, creps[j]) ); #one more small change :-) SetRepresentativesOfElements(canonicalps, reps); SetClassicalGroupInfo( canonicalps, rec( degree := (q^(d/2)-1)/(q-1)*(q^((d+2)/2-1)+1 fi; return canonicalps; end ); ############################################################################# # methods for some attributes. ############################################################################# # CHECKED 25/09/11 jdb ############################################################################# #A QuadraticForm( <ps> ) # returns the quadratic form of which the polar space <ps> is the geometry. # this is usefull since there are generic methods (q odd and even) thinkable # for orthogonal polar spaces. In such a case, we must use the quadratic form # in the even case, and we can use it in the odd case. A typical example are # the enumerators. # IMPORTANT: this method will only be used when q is odd (and <ps> is orthogonal # of course). In the q even case, the attribute will be set upon creation of the # polar space. ## InstallMethod( QuadraticForm, "for a polar space", [ IsClassicalPolarSpace ], function(ps) local form; form := SesquilinearForm(ps); if form!.type <> "orthogonal" then Error( "No quadratic form can be associated to this polar space" ); fi; return QuadraticFormByBilinearForm(SesquilinearForm(ps)); end ); # CHECKED 20/09/11 jdb ############################################################################# #A PolarSpaceType( <ps> ) # type of a polar space: see manual and conventions for orthogonal polar spaces. ## InstallMethod( PolarSpaceType, "for a polar space", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep ], function( ps ) local ty, form, sesq; if HasQuadraticForm( ps ) then form := QuadraticForm( ps ); else form := SesquilinearForm( ps ); fi; ty := form!.type; if ty = "orthogonal" or ty = "quadratic" then if IsParabolicForm( form ) then ty := "parabolic"; elif IsEllipticForm( form ) then ty := "elliptic"; else ty := "hyperbolic"; fi; fi; return ty; end ); # CHECKED 20/09/11 jdb ############################################################################# #A CompanionAutomorphism( <ps> ) # companion automorphism of polar space, i.e. the companion automorphism of # the sesquilinear form determining the polar space. If the form is quadratic, # or not hermitian, then the trivial automorphism is returned. ## InstallMethod( CompanionAutomorphism, "for a polar space", [ IsClassicalPolarSpace ], function( ps ) local aut, type; type := PolarSpaceType( ps ); aut := FrobeniusAutomorphism(ps!.basefield); if type = "hermitian" then aut := aut ^ (Order(aut)/2); else aut := aut ^ 0; fi; return aut; end ); ############################################################################# # jdb and ml will change ViewObj/PrintObj/Display methods now.` # The ViewString is used e.g. in the ViewObj for flags. ############################################################################# InstallMethod( ViewObj, "for a polar space", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep ], function( p ) Print("<polar space in ",AmbientSpace(p),": ",EquationForPolarSpace(p),"=0 >"); end ); InstallMethod( ViewString, "for a polar space", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep ], function( p ) return Concatenation("<polar space in ",ViewString(AmbientSpace(p)),": ",String(Equati end ); InstallMethod( ViewObj, "for an elliptic quadric", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsEllipticQuadric], function( p ) Print("Q-(",p!.dimension,", ",Size(p!.basefield),"): ",EquationForPolarSpace(p),"= end ); InstallMethod( ViewObj, "for a standard elliptic quadric", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsEllipticQuadric and IsStanda function( p ) Print("Q-(",p!.dimension,", ",Size(p!.basefield),")"); end ); InstallMethod( ViewString, "for a standard elliptic quadric", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsEllipticQuadric and IsStanda function( p ) return Concatenation("Q-(",String(p!.dimension),", ",String(Size(p!.basefield)),") end ); InstallMethod( ViewString, "for an elliptic quadric", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsEllipticQuadric], function( p ) return Concatenation("Q-(",String(p!.dimension),", ", String(Size(p!.basefield)),"): ",String(EquationForPolarSpace(p)),"=0"); end ); InstallMethod( ViewObj, "for a symplectic space", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsSymplecticSpace], function( p ) Print("W(",p!.dimension,", ",Size(p!.basefield),"): ",EquationForPolarSpace(p),"=0 end ); InstallMethod( ViewObj, "for a standard symplectic space", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsSymplecticSpace and IsStanda function( p ) Print("W(",p!.dimension,", ",Size(p!.basefield),")"); end ); InstallMethod( ViewString, "for a standard symplectic space", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsSymplecticSpace and IsStanda function( p ) return Concatenation("W(",String(p!.dimension),", ",String(Size(p!.basefield)),")" end ); InstallMethod( ViewString, "for a symplectic space", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsSymplecticSpace], function( p ) return Concatenation("W(",String(p!.dimension),", ",String(Size(p!.basefield)),"): EquationForPolarSpace(p),"=0"); end ); InstallMethod( ViewObj, "for a parabolic quadric", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsParabolicQuadric ], function( p ) Print("Q(",p!.dimension,", ",Size(p!.basefield),"): ",EquationForPolarSpace(p),"=0 end); InstallMethod( ViewObj, "for a standard parabolic quadric", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsParabolicQuadric and IsStand function( p ) Print("Q(",p!.dimension,", ",Size(p!.basefield),")"); end); InstallMethod( ViewString, "for a standard parabolic quadric", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsParabolicQuadric and IsStand function( p ) return Concatenation("Q(",String(p!.dimension),", ",String(Size(p!.basefield)),")" end ); InstallMethod( ViewString, "for a standard parabolic quadric", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsParabolicQuadric ], function( p ) return Concatenation("Q(",String(p!.dimension),", ",String(Size(p!.basefield)),"): String(EquationForPolarSpace(p)),"=0"); end ); InstallMethod( ViewObj, "for a parabolic quadric", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsParabolicQuadric ], function( p ) Print("Q(",p!.dimension,", ",Size(p!.basefield),"): ",EquationForPolarSpace(p),"=0 end); InstallMethod( ViewObj, "for a hyperbolic quadric", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsHyperbolicQuadric ], function( p ) Print("Q+(",p!.dimension,", ",Size(p!.basefield),"): ",EquationForPolarSpace(p),"= end); InstallMethod( ViewObj, "for a standard hyperbolic quadric", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsHyperbolicQuadric and IsStan function( p ) Print("Q+(",p!.dimension,", ",Size(p!.basefield),")"); end); InstallMethod( ViewString, "for a standard hyperbolic quadric", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsHyperbolicQuadric and IsStan function( p ) return Concatenation("Q+(",String(p!.dimension),", ",String(Size(p!.basefield)),") end ); InstallMethod( ViewString, "for a hyperbolic quadric", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsHyperbolicQuadric], function( p ) return Concatenation("Q+(",String(p!.dimension),", ", String(Size(p!.basefield)),"): ",String(EquationForPolarSpace(p)),"=0"); end ); InstallMethod( ViewObj, "for a hermitian variety", [IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsHermitianPolarSpace ], function( p ) Print("H(",p!.dimension,", ",Sqrt(Size(p!.basefield)),"^2): ",EquationForPolarSpac end); InstallMethod( ViewObj, "for a standard hermitian variety", [IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsHermitianPolarSpace and IsSt function( p ) Print("H(",p!.dimension,", ",Sqrt(Size(p!.basefield)),"^2)"); end); InstallMethod( ViewString, "for a standard hermitian quadric", [IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsHermitianPolarSpace and IsSt function( p ) return Concatenation("H(",String(p!.dimension),", ",String(Sqrt(Size(p!.basefield) end ); InstallMethod( ViewString, "for a hermitian quadric", [IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsHermitianPolarSpace], function( p ) return Concatenation("H(",String(p!.dimension),", ",String(Sqrt(Size(p!.basefield) EquationForPolarSpace(p),"=0"); end ); InstallMethod( PrintObj, [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep ], function( p ) Print("PolarSpace(\n"); if HasQuadraticForm(p) then Print(QuadraticForm(p)); else Print(SesquilinearForm(p)); fi; Print(", ", p!.basefield, " )"); end ); InstallMethod( Display, [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep ], # fixed the output for rank (11/11/14 ml) function( p ) Print("<polar space of rank ",RankAttr(p)," in PG(", p!.dimension, ", ", Size(p!.basefield) if HasQuadraticForm(p) then Display(QuadraticForm(p)); fi; Display(SesquilinearForm(p)); #if HasDiagramOfGeometry( p ) then # Display( DiagramOfGeometry( p ) ); #fi; end ); InstallMethod( PrintObj, [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsEllipticQuadric ], function( p ) Print("EllipticQuadric(",p!.dimension,",",p!.basefield,"): ",EquationForPolarSpac end ); InstallMethod( Display, [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsEllipticQuadric ], function( p ) Print("Q-(",p!.dimension,", ",Size(p!.basefield),")\n"); if HasQuadraticForm(p) then Display(QuadraticForm(p)); fi; Display(SesquilinearForm(p)); #if HasDiagramOfGeometry( p ) then # Display( DiagramOfGeometry( p ) ); #fi; end ); InstallMethod( PrintObj, [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsSymplecticSpace ], function( p ) Print("SymplecticSpace(",p!.dimension,",",p!.basefield,"): ",EquationForPolarSpac end); InstallMethod( Display, [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsSymplecticSpace ], function( p ) Print("W(",p!.dimension,", ",Size(p!.basefield),")\n"); Display(SesquilinearForm(p)); #if HasDiagramOfGeometry( p ) then # Display( DiagramOfGeometry( p ) ); #fi; end ); InstallMethod( PrintObj, [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsParabolicQuadric ], function( p ) Print("ParabolicQuadric(",p!.dimension,",",p!.basefield,"): ",EquationForPolarSpa end); InstallMethod( Display, [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsParabolicQuadric ], function( p ) Print("Q(",p!.dimension,", ",Size(p!.basefield),")\n"); if HasQuadraticForm(p) then Display(QuadraticForm(p)); fi; Display(SesquilinearForm(p)); #if HasDiagramOfGeometry( p ) then # Display( DiagramOfGeometry( p ) ); #fi; end ); InstallMethod( PrintObj, [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsHyperbolicQuadric ], function( p ) Print("HyperbolicQuadric(",p!.dimension,",",p!.basefield,"): ",EquationForPolarSp end); InstallMethod( Display, [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsHyperbolicQuadric ], function( p ) Print("Q+(",p!.dimension,", ",Size(p!.basefield),")\n"); if HasQuadraticForm(p) then Display(QuadraticForm(p)); fi; Display(SesquilinearForm(p)); #if HasDiagramOfGeometry( p ) then # Display( DiagramOfGeometry( p ) ); #fi; end ); InstallMethod( PrintObj, [IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsHermitianPolarSpace ], function( p ) Print("HermitianPolarSpace(",p!.dimension,",",p!.basefield,"): ",EquationForPolar end); InstallMethod( Display, [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep and IsHermitianPolarSpace ], function( p ) Print("H(",p!.dimension,", ",Size(p!.basefield),")\n"); Display(SesquilinearForm(p)); #if HasDiagramOfGeometry( p ) then # Display( DiagramOfGeometry( p ) ); #fi; end ); ############################################################################# ## The following methods are needed for "naked" polar spaces; those ## that on conception are devoid of many of the attributes that ## the "canonical" polar spaces exhibit (see the code for the ## "SymplecticSpace" as an example). ############################################################################# # CHECKED 21/09/11 jdb ############################################################################# #O IsomorphismCanonicalPolarSpace( <ps> ) # This method returns a geometry morphism that is in fact the coordinate transformation # going FROM the standard polar space TO the given polar space <ps> ## InstallMethod( IsomorphismCanonicalPolarSpace, "for a polar space", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep ], function( ps ) local d, f, type, canonical, iso, info; d := ps!.dimension; f := ps!.basefield; type := PolarSpaceType( ps ); if type = "hermitian" then canonical := HermitianPolarSpace(d, f); SetIsHermitianPolarSpace(ps, true); elif type = "symplectic" then canonical := SymplecticSpace(d, f); SetIsSymplecticSpace(ps, true); elif type = "elliptic" then canonical := EllipticQuadric(d, f); SetIsEllipticQuadric(ps, true); elif type = "parabolic" then canonical := ParabolicQuadric(d, f); SetIsParabolicQuadric(ps, true); elif type = "hyperbolic" then canonical := HyperbolicQuadric(d, f); SetIsHyperbolicQuadric(ps, true); fi; iso := IsomorphismPolarSpacesNC(canonical, ps, false); ## jb: no longer computes nice monom info := ClassicalGroupInfo( canonical ); SetClassicalGroupInfo( ps, rec( degree := info!.degree ) ); return iso; end ); ############################################################################# #O IsomorphismCanonicalPolarSpaceWithIntertwiner( <ps> ) # This method returns a geometry morphism that is in fact the coordinate transformation # going FROM the standard polar space TO the given polar space <ps>, with intertwiner ## InstallMethod( IsomorphismCanonicalPolarSpaceWithIntertwiner, "for a polar space", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep ], function( ps ) local d, f, type, canonical, iso, info; d := ps!.dimension; f := ps!.basefield; type := PolarSpaceType( ps ); if type = "hermitian" then canonical := HermitianPolarSpace(d, f); SetIsHermitianPolarSpace(ps, true); elif type = "symplectic" then canonical := SymplecticSpace(d, f); SetIsSymplecticSpace(ps, true); elif type = "elliptic" then canonical := EllipticQuadric(d, f); SetIsEllipticQuadric(ps, true); elif type = "parabolic" then canonical := ParabolicQuadric(d, f); SetIsParabolicQuadric(ps, true); elif type = "hyperbolic" then canonical := HyperbolicQuadric(d, f); SetIsHyperbolicQuadric(ps, true); fi; iso := IsomorphismPolarSpacesNC(canonical, ps, true); info := ClassicalGroupInfo( canonical ); SetClassicalGroupInfo( ps, rec( degree := info!.degree ) ); return iso; end ); ############################################################################# #More attributes... ############################################################################# # CHECKED 21/09/11 jdb ############################################################################# #O RankAttr( <ps> ) # returns the rank of the polar space <ps>, which is the Witt index of the # defining form. ## InstallMethod( RankAttr, "for a polar space", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep ], function( ps ) local iso; iso := IsomorphismCanonicalPolarSpace( ps ); return RankAttr(Source(iso)!.geometry); end ); # CHECKED 21/09/11 jdb ############################################################################# #O TypesOfElementsOfIncidenceStructure( <ps> ) # Well known method that returns a list with the names of the elements of # the polar space <ps> ## InstallMethod( TypesOfElementsOfIncidenceStructure, "for a polar space ", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep ], function( ps ) local iso; iso := IsomorphismCanonicalPolarSpace( ps ); return TypesOfElementsOfIncidenceStructure(Source(iso)!.geometry); end ); #The next two methods are wrong. THe TypesOfElementsOfIncidenceStructure are determined by #rank of the polar space, not the projective dimenion. #InstallMethod( TypesOfElementsOfIncidenceStructure, "for a polar space", # [IsClassicalPolarSpace], # function( ps ) # local d,i,types; # types := ["point"]; # d := ProjectiveDimension(ps); # if d >= 2 then Add(types,"line"); fi; # if d >= 3 then Add(types,"plane"); fi; # if d >= 4 then Add(types,"solid"); fi; # for i in [5..d] do # Add(types,Concatenation("proj. subspace of dim. ",String(i-1))); # od; # return types; # end ); #InstallMethod( TypesOfElementsOfIncidenceStructurePlural, "for a polar space", # [IsClassicalPolarSpace], # function( ps ) # local d,i,types; # types := ["points"]; # d := ProjectiveDimension(ps); # if d >= 2 then Add(types,"lines"); fi; # if d >= 3 then Add(types,"planes"); fi; # if d >= 4 then Add(types,"solids"); fi; # for i in [5..d] do # Add(types,Concatenation("proj. subspaces of dim. ",String(i-1))); # od; # return types; # end ); # CHECKED 22/09/11 jdb ############################################################################# #O TypesOfElementsOfIncidenceStructurePlural( <ps> ) # Well known method that returns a list with the names of the elements of # the polar space <ps> ## InstallMethod( TypesOfElementsOfIncidenceStructurePlural, "for a polar space", [IsClassicalPolarSpace], function( ps ) local d,i,types; types := ["points"]; d := Rank(ps); if d >= 2 then Add(types,"lines"); fi; if d >= 3 then Add(types,"planes"); fi; if d >= 4 then Add(types,"solids"); fi; for i in [5..d] do Add(types,Concatenation("proj. subspaces of dim. ",String(i-1))); od; return types; end ); # CHECKED 21/09/11 jdb ############################################################################# #O Order( <ps> ) # If <ps> has rank two, then it is a GQ, and we can ask its order. ## InstallOtherMethod( Order, "for a polar space", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep ], function( ps ) if RankAttr(ps) = 2 then return Order(Source(IsomorphismCanonicalPolarSpace(ps) )!.geometry ); else Error("Rank is not 2"); fi; end ); # CHECKED 21/09/11 jdb ############################################################################# #O RepresentativesOfElements( <ps> ) # returns an element of each type of the polar space <ps> ## InstallMethod( RepresentativesOfElements, "for a polar space", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep ], function( ps ) local iso, reps; iso := IsomorphismCanonicalPolarSpace( ps ); reps := RepresentativesOfElements( Source( iso )!.geometry ); return ImagesSet(iso, reps); end ); ############################################################################# # one more operation... ############################################################################# # CHECKED 21/09/11 jdb ############################################################################# #O \/( <ps>, <v> ) # returns the quotien space of the element <v>, which must be an element of the # polar space <ps> ## InstallOtherMethod(\/, "for a polar space and an element of a polar space", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep, IsSubspaceOfClassicalPolarSpac function( ps, v ) if not v in ps then Error( "Subspace does not belong to the polar space" ); fi; return Range( NaturalProjectionBySubspace( ps, v ) )!.geometry; end ); ############################################################################# # Counting the number of elements of the polar spaces ############################################################################# # CHECKED 21/09/11 jdb # question: can we not use the NumberOfTotallySingularSubspaces for this? ############################################################################# #O Size( <vs> ) # returns the number of elements on <vs>, a collection of elements of a polar # space of a given type. ## InstallMethod( Size, "for a collection of elements of a polar space", [IsSubspacesOfClassicalPolarSpace], function( vs ) local geom, q, d, m, ovnum, ordominus, numti, gauss, flavour; geom := vs!.geometry; q := Size(vs!.geometry!.basefield); d := vs!.geometry!.dimension + 1; m := vs!.type; flavour := PolarSpaceType(geom); if flavour = "symplectic" then return Product(List([0..(m-1)],i->(q^(d-2*i)-1)/(q^(i+1)-1))); fi; if flavour = "elliptic" then gauss:=Product(List([0..(m-1)],i->(q^(d/2-1)-q^i)/(q^m-q^i))); numti:=gauss * Product(List([0..(m-1)],j->q^(d/2-j)+1)); return numti; fi; if flavour = "hyperbolic" then gauss:=Product(List([0..(m-1)],i->(q^(d/2)-q^i)/(q^m-q^i))); numti:=gauss * Product(List([0..(m-1)],j->q^(d/2-1-j)+1)); return numti; fi; if flavour = "parabolic" then gauss:=Product(List([0..(m-1)],i->(q^((d-1)/2)-q^i)/(q^m-q^i))); numti:=gauss * Product(List([0..(m-1)],j->q^( (d+1)/2-1-j)+1)); return numti; fi; if flavour = "hermitian" then return Product(List([(d+1-2*m)..d],i->(Sqrt(q)^i-(-1)^i)))/ Product(List([1..m],j->q^j-1 )); fi; Error("Unknown polar space type!"); end ); ############################################################################# # Elements -- Subspaces ############################################################################# ## The following needs more work: I think it's ok now. jdb ## jb 19/02/2009: Just changed the compressed matrix methods ## so that length 1 matrices are allowed. ###cmat methods need to be added here. VectorSpaceToElement checks wheter # a vectorspace really makes an element of a polar space by checking # whether it is totally isotropic. Therefore we need some forms functionality. # Since forms is not working with cmat/cvecs, and this will not change, we have # to unpack a cmat before piping it to forms. Hence it makes sens to create VectorSpaceToElement # methods the lazy way: just unpack and pipe to an existing VectorSpaceToElement method. ### # Added 20/3/14 jdb ############################################################################# #O VectorSpaceToElement( <geom>, <v> ) returns the elements in <geom> determined # by the vectorspace <v>. ## InstallMethod( VectorSpaceToElement, "for a polar space and a CMat", [IsClassicalPolarSpace, IsCMatRep], function( geom, v ) return VectorSpaceToElement(geom,Unpack(v)); end ); # Added 20/3/14 jdb ############################################################################# #O VectorSpaceToElement( <geom>, <v> ) returns the elements in <geom> determined # by the vectorspace <v>. ## InstallMethod( VectorSpaceToElement, "for a polar space and a cvec", [IsClassicalPolarSpace, IsCVecRep], function( geom, v ) return VectorSpaceToElement(geom,Unpack(v)); end ); # CHECKED 21/09/11 jdb # cmat change 20/3/14. # changed 19/01/16 (jdb): by a change of IsPlistRep, this method gets also # called when using a row vector, causing a problem with TriangulizeMat. # a solution was to add IsMatrix. ############################################################################# #O VectorSpaceToElement( <geom>, <v> ) returns the elements in <geom> determined # by the vectorspace <v>. Several checks are built in. ## # JB: Fixed a strange error in here # I had Q+(11,3) (with a different form than usual) and tried to wrap # [ [ 0*Z(3), 0*Z(3), Z(3)^0, 0*Z(3), 0*Z(3), 0*Z(3), Z(3), 0*Z(3), 0*Z(3), 0*Z(3), 0*Z(3), 0* # It kept on returning 0*Z(3). # JDB: I kept John's historical note, but the code where the bug was, has disappeared with the cma # Information on NewMatrix us here can be found in projectivespaces.gi, method for VectorSpac # InstallMethod( VectorSpaceToElement, "for a polar space and a Plist", [IsClassicalPolarSpace, IsPlistRep and IsMatrix], function( geom, v ) local x, n, i, y; ## when v is empty... if IsEmpty(v) then Error("<v> does not represent any element"); fi; if not IsMatrix(v) then #next 3 lines: patch of Max Horn (16/2/16) TryNextMethod(); fi; x := MutableCopyMat(v); TriangulizeMat(x); ## dimension should be correct if Length(v[1]) <> geom!.dimension + 1 then Error("Dimensions are incompatible"); fi; ## Remove zero rows. It is possible the the user ## has inputted a matrix which does not have full rank n := Length(x); i := 0; while i < n and ForAll(x[n-i], IsZero) do i := i+1; od; if i = n then return EmptySubspace(geom); fi; x := x{[1..n-i]}; #if we check later on the the subspace is an element of the polar space, then #the user cannot create the whole polar space like this, so I commented out the # next three lines. #if Length(x)=ProjectiveDimension(geom)+1 then # return geom; #fi; ## check here that it is in the polar space. if HasQuadraticForm(geom) then if not IsTotallySingularSubspace(QuadraticForm(geom),x) then Error("<x> does not generate an element of <geom>"); fi; else if not IsTotallyIsotropicSubspace(SesquilinearForm(geom),x) then Error("<x> does not generate an element of <geom>"); fi; fi; y := NewMatrix(IsCMatRep,geom!.basefield,Length(x[1]),x); if Length(y) = 1 then return Wrap(geom, 1, y[1]); else return Wrap(geom, Length(y), y); fi; end ); # CHECKED 21/09/11 # cmat changed 20/3/14. ############################################################################# #O VectorSpaceToElement( <geom>, <v> ) returns the elements in <geom> determined # by the vectorspace <v>. Several checks are built in. ## InstallMethod( VectorSpaceToElement, "for a compressed GF(2)-matrix", [IsClassicalPolarSpace, IsGF2MatrixRep], function( geom, v ) local x, n, i, y; if IsEmpty(v) then Error("<v> does not represent any element"); fi; x := MutableCopyMat(v); TriangulizeMat(x); ## remove zero rows n := Length(x); i := 0; while i < n and ForAll(x[n-i], IsZero) do i := i+1; od; if i = n then return EmptySubspace(geom); fi; x := x{[1..n-i]}; #x := x{[1..n-i]}; #if we check later on the the subspace is an element of the polar space, then #the user cannot create the whole polar space like this, so I commented out the # next three lines. #if Length(x)=ProjectiveDimension(geom)+1 then # return geom; #fi; ## check here that it is in the polar space. if HasQuadraticForm(geom) then if not IsTotallySingularSubspace(QuadraticForm(geom),x) then Error("<x> does not generate an element of <geom>"); fi; else if not IsTotallyIsotropicSubspace(SesquilinearForm(geom),x) then Error("<x> does not generate an element of <geom>"); fi; fi; y := NewMatrix(IsCMatRep,geom!.basefield,Length(x[1]),x); if Length(y) = 1 then return Wrap(geom, 1, y[1]); else return Wrap(geom, Length(y), y); fi; end ); # CHECKED 21/09/11 # cmat changed 20/3/14. ############################################################################# #O VectorSpaceToElement( <geom>, <v> ) returns the elements in <geom> determined # by the vectorspace <v>. Several checks are built in. ## InstallMethod( VectorSpaceToElement, "for a compressed basis of a vector subspace", [IsClassicalPolarSpace, Is8BitMatrixRep], function( geom, v ) local x, n, i,y; if IsEmpty(v) then Error("<v> does not represent any element"); fi; x := MutableCopyMat(v); TriangulizeMat(x); ## dimension should be correct if Length(v[1]) <> geom!.dimension + 1 then Error("Dimensions are incompatible"); fi; ## remove zero rows n := Length(x); i := 0; while i < n and ForAll(x[n-i], IsZero) do i := i+1; od; if i = n then return EmptySubspace(geom); fi; x := x{[1..n-i]}; #if we check later on the the subspace is an element of the polar space, then #the user cannot create the whole polar space like this, so I commented out the # next three lines. #if Length(x)=ProjectiveDimension(geom)+1 then # return geom; #fi; ## check here that it is in the polar space. if HasQuadraticForm(geom) then if not IsTotallySingularSubspace(QuadraticForm(geom),x) then Error("<x> does not generate an element of <geom>"); fi; else if not IsTotallyIsotropicSubspace(SesquilinearForm(geom),x) then Error("<x> does not generate an element of <geom>"); fi; fi; y := NewMatrix(IsCMatRep,geom!.basefield,Length(x[1]),x); if Length(y) = 1 then return Wrap(geom, 1, y[1]); else return Wrap(geom, Length(y), y); fi; end ); # CHECKED 21/09/11 jdb # cvec version 20/3/14 ############################################################################# #O VectorSpaceToElement( <geom>, <v> ) returns the elements in <geom> determined # by the rowvector <v>. Several checks are built in. ## InstallMethod( VectorSpaceToElement, "for a row vector", [IsClassicalPolarSpace, IsRowVector], function( geom, v ) local x,y; ## dimension should be correct if Length(v) <> geom!.dimension + 1 then Error("Dimensions are incompatible"); fi; x := ShallowCopy(v); if IsZero(x) then return EmptySubspace(geom); else if HasQuadraticForm(geom) then if not IsSingularVector(QuadraticForm(geom),x) then Error("<v> does not generate an element of <geom>"); fi; else if not IsIsotropicVector(SesquilinearForm(geom),x) then Error("<v> does not generate an element of <geom>"); fi; fi; MultVector(x,Inverse( x[PositionNonZero(x)] )); y := NewMatrix(IsCMatRep,geom!.basefield,Length(x),[x]); return Wrap(geom, 1, y[1]); fi; end ); # CHECKED 22/09/11 jdb # cvec version 20/3/14 ############################################################################# #O VectorSpaceToElement( <geom>, <v> ) returns the elements in <geom> determined # by the rowvector <v>. Several checks are built in. ## InstallMethod( VectorSpaceToElement, "for a polar space and an 8-bit vector", [IsClassicalPolarSpace, Is8BitVectorRep], function( geom, v ) local x, n, i,y; ## when v is empty... if IsEmpty(v) then return EmptySubspace(geom); fi; x := ShallowCopy(v); ## dimension should be correct if Length(v) <> geom!.dimension + 1 then Error("Dimensions are incompatible"); fi; ## We must also compress our vector. #ConvertToVectorRep(x, geom!.basefield); ## bad characters, such as jdb, checked this with input zero vector... if IsZero(x) then return EmptySubspace(geom); else if HasQuadraticForm(geom) then if not IsSingularVector(QuadraticForm(geom),x) then Error("<v> does not generate an element of <geom>"); fi; else if not IsIsotropicVector(SesquilinearForm(geom),x) then Error("<v> does not generate an element of <geom>"); fi; fi; MultVector(x,Inverse( x[PositionNonZero(x)] )); y := NewMatrix(IsCMatRep,geom!.basefield,Length(x),[x]); return Wrap(geom, 1, y[1]); fi; end ); # CHECKED 22/09/11 jdb # Changed 28/11/11 jdb + pc, according to remark in tiny optimalisations. # added a comment 30/11/11 # cmat version: Unpack before piping to forms. (20/3/14) ############################################################################# #O \in( <w>, <ps> ) true if the element <w> is contained in <ps> # remarks: should we change this? I mean: this method makes a projective subspace # suddenly into a polar space subspace, if this thest is true. Can cause weird thing # when displaying objects. We changed it, see commented out stuff below. # 30/11/11: caveat: just doing w!.geo := ps; changes the ambient geometry of x, # but it does not change the categories of x. So maybe x belongs to the polar space then # but not to the category IsSubspaceOfClassicalPolarSpace. So some operations might stay # unapplicable anyway. So changing w!.geo has no advantages. ## #I changed this, I now use the built in functions of forms to perform the test. #jdb 6/1/8 InstallMethod( \in, "for an element of a polar space and a polar space", [IsElementOfIncidenceStructure, IsClassicalPolarSpace], function( w, ps ) local form, r, ti; # if the vector spaces don't agree we can't go any further if w!.geo!.dimension <> ps!.dimension or not IsSubset(ps!.basefield, w!.geo!.basefield) then return false; fi; r := Unpack(w!.obj); #here is the cmat change. if w!.type = 1 then r := [r]; fi; # check if the subspace is totally isotropic/singular if HasQuadraticForm(ps) then form := QuadraticForm(ps); ti := IsTotallySingularSubspace(form,r); else form := SesquilinearForm(ps); ti:= IsTotallyIsotropicSubspace(form,r); fi; # if yes, make it an element of the polar space. # if not IsSubspaceOfClassicalPolarSpace(w) and ti then # w!.geo := ps; # fi; return ti; end ); #ADDED 30/11/2011 jdb. ############################################################################# #O Span( <x>, <y>, <b> ) # returns <x,y>, <x> and <y> two subspaces of a polar space and a boolean ## InstallMethod( Span, "for two subspaces of a polar space", [IsSubspaceOfProjectiveSpace, IsSubspaceOfProjectiveSpace, IsBool], function( x, y, b ) ## This method is quicker than the old one local ux, uy, typx, typy, span, vec, spanel; if not b then return Span(x,y); fi; typx := x!.type; typy := y!.type; vec := x!.geo!.vectorspace; if vec = y!.geo!.vectorspace then ux := Unwrap(x); uy := Unwrap(y); if typx = 1 then ux := [ux]; fi; if typy = 1 then uy := [uy]; fi; span := SumIntersectionMat(ux, uy)[1]; if Length(span) < vec!.DimensionOfVectors then spanel := VectorSpaceToElement( AmbientSpace(x!.geo), span); if IsIdenticalObj(x!.geo,y!.geo) then if spanel in x!.geo then return VectorSpaceToElement( x!.geo, span); else return spanel; fi; else return spanel; fi; else return AmbientSpace(x!.geo); fi; else Error("Subspaces belong to different ambient spaces"); fi; end ); #ADDED 30/11/2011 jdb. # cvec note (20/3/14): SumIntersectionMat seems to be incompatible with # cvecs. So I will Unpack, do what I have to do, and get what I want # since VectorSpaceToElement is helping here. ############################################################################# #O Meet( <x>, <y> ) # returns the intersection of <x> and <y>, two subspaces of a polar space. ## InstallMethod( Meet, "for two subspaces of a polar space", [IsSubspaceOfClassicalPolarSpace, IsSubspaceOfClassicalPolarSpace], function( x, y ) local ux, uy, typx, typy, int, f, rk; typx := x!.type; typy := y!.type; if x!.geo!.vectorspace = y!.geo!.vectorspace then ux := Unpack(Unwrap(x)); uy := Unpack(Unwrap(y)); if typx = 1 then ux := [ux]; fi; if typy = 1 then uy := [uy]; fi; f := x!.geo!.basefield; int := SumIntersectionMat(ux, uy)[2]; if not int=[] then if IsIdenticalObj(x!.geo,y!.geo) then return VectorSpaceToElement(x!.geo,int); else return VectorSpaceToElement( AmbientSpace(x), int); fi; else return EmptySubspace(AmbientSpace(x)); fi; else Error("Subspaces belong to different ambient spaces"); fi; end ); ############################################################################# # Collection of elements (of given type) ############################################################################# # CHECKED 22/09/11 jdb ############################################################################# #O ElementsOfIncidenceStructure( <ps>, <j> ) # returns the elements of the polar space <ps> of type <j> ## InstallMethod( ElementsOfIncidenceStructure, "for a polar space and an integer", [IsClassicalPolarSpace and IsClassicalPolarSpaceRep, IsPosInt], function( ps, j ) local r; r := Rank(ps); if j > r then Error("<geo> has no elements of type <j>"); else #Print("grapje\n"); return Objectify( NewType( ElementsCollFamily, IsSubspacesOfClassicalPolarSpace and IsSubspacesOfClassicalPolarSpaceRep ), rec( geometry := ps, type := j, size := NumberOfTotallySingularSubspaces(ps, j) ) ); fi; end); # CHECKED 22/09/11 jdb ############################################################################# #O ElementsOfIncidenceStructure( <ps> ) # returns all the elements of the polar space <ps> ## InstallMethod( ElementsOfIncidenceStructure, "for a polar space", [IsClassicalPolarSpace and IsClassicalPolarSpaceRep], function( ps ) return Objectify( NewType( ElementsCollFamily, IsAllElementsOfIncidenceStructure ), rec( geometry := ps ) ); end); #the next four operations are not necessary any more, the generic methods for them # in Lie geometry are used. #InstallMethod( Points, [IsClassicalPolarSpace], # function( ps ) # return ElementsOfIncidenceStructure(ps, 1); # end); #InstallMethod( Lines, [IsClassicalPolarSpace], # function( ps ) # return ElementsOfIncidenceStructure(ps, 2); # end); #InstallMethod( Planes, [IsClassicalPolarSpace], # function( ps ) # return ElementsOfIncidenceStructure(ps, 3); # end); #InstallMethod( Solids, [IsClassicalPolarSpace], # function( ps ) # return ElementsOfIncidenceStructure(ps, 4); # end); # CHECKED 22/09/11 jdb # question: can we use this function for Size? ############################################################################# #O NumberOfTotallySingularSubspaces( <ps>, <j> ) # returns the number of elements of type <j> of the polar space <ps> ## InstallMethod( NumberOfTotallySingularSubspaces, "for a polar space and an integer", [IsClassicalPolarSpace, IsPosInt], function(ps, j) ## In a classical finite polar space of rank r with parameters (q,q^e), ## the number of subspaces of algebraic dimension j is given by ## [d, n] Prod_{i=1}^{n} (q^{r+e-i}+1) local r, d, type, e, q, qe; r := RankAttr(ps); d := ps!.dimension; type := PolarSpaceType(ps); q := Size(ps!.basefield); if type = "elliptic" then e := 2; qe := q^e; elif type = "hyperbolic" then e:= 0; qe := q^e; elif type = "parabolic" or type = "symplectic" then e:=1; qe := q^e; elif type = "hermitian" and IsEvenInt(ps!.dimension) then e:=3; qe := Sqrt(q)^e; elif type = "hermitian" and IsOddInt(ps!.dimension) then e:=1; qe := Sqrt(q)^e; else Error("Polar space doesn't know its type!"); fi; return Size(Subspaces(GF(q)^r, j)) * Product(List([1..j], i -> q^(r-i) * qe +1)); end); # CHECKED 17/03/14 jdb # cmat version. Same consideration as elsewhere: forms does not use cmats, so unpack before pip ############################################################################# #O TypeOfSubspace( <ps>, <w> ) # returns the type of the polar space induced by <ps> in the projective subspace # <w> ## InstallMethod( TypeOfSubspace, "for a polar space and a subspace of a projective geometry", [ IsClassicalPolarSpace, IsSubspaceOfProjectiveSpace ], function( ps, w ) ## At the moment, this is a helper operation, but perhaps ## it could be used by the user. This operation returns ## "degenerate", "hermitian", "symplectic", "elliptic", ## "hyperbolic", or "parabolic". local pstype, dim, type, mat, gf, q, form, newform,uw; pstype := PolarSpaceType( ps ); gf := ps!.basefield; q := Size(gf); dim := w!.type; if pstype in ["elliptic", "parabolic", "hyperbolic"] and IsEvenInt(q) then form := QuadraticForm( ps ); uw := Unpack(w!.obj); #here is an unpack cmat change mat := uw * form!.matrix * TransposedMat(uw); newform := QuadraticFormByMatrix( mat, gf ); # jdb makes a change here. it was 'IsDegenerateForm( newform )' but it is clear that we want to tes # the quadratic form is *singular*, according to the definition in forms about degenerecy and s if IsSingularForm( newform ) then return "degenerate"; elif IsOddInt(dim) then return "parabolic"; else if IsHyperbolicForm( newform ) then return "hyperbolic"; else return "elliptic"; fi; fi; else form := SesquilinearForm( ps ); #mat := w!.obj * form!.matrix * TransposedMat(w!.obj); #I will use something more advanced to uw := Unpack(w!.obj); #here is an unpack cmat change mat := [uw,uw]^form; if pstype = "symplectic" then newform := BilinearFormByMatrix( mat, gf ); if IsDegenerateForm( newform ) then return "degenerate"; else return "symplectic"; fi; elif pstype = "hermitian" then #if IsHermitianMatrix( mat, gf ) then #I think this is a mistake newform := HermitianFormByMatrix(mat,gf); if IsDegenerateForm( newform ) then return "degenerate"; else return "hermitian"; fi; elif pstype in ["elliptic", "parabolic", "hyperbolic"] then newform := BilinearFormByMatrix( mat, gf ); if IsDegenerateForm( newform ) then return "degenerate"; else if IsEllipticForm(newform) then return "elliptic"; elif IsHyperbolicForm(newform) then return "hyperbolic"; else return "parabolic"; fi; fi; fi; fi; Print("Polar space does not have a recognisable type\n"); return; end ); ############################################################################# # Methods to create flags. ############################################################################# # ADDED 31/3/2014 jdb # checks added 17/12/14 jdb ############################################################################# #O FlagOfIncidenceStructure( <ps>, <els> ) # returns the flag of the projective space <ps> with elements in <els>. # the method checks whether the input really determines a flag. # Compare the checks with the same method for projective space and a list of elements. # I can't get CategoryCollections work for cps, but on the other hand, it is # useful to allow els to be a list of subspaces of the ambient space of <ps>. ## InstallMethod( FlagOfIncidenceStructure, "for a projective space and list of subspaces of the projective space", [ IsClassicalPolarSpace, IsSubspaceOfProjectiveSpaceCollection ], 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->AmbientSpace(x)); if not ForAll(test,x->x=AmbientSpace(ps)) then Error("not all elements have the ambient space of <ps> as ambient space"); fi; test := Set(List(list,x->x in ps)); if (test <> [ true ] and test <> []) then Error("not all elements in <els> belong to <ps>"); fi; test := Set(List([1..Length(list)-1],i -> IsIncident(list[i],list[i+1]))); if (test <> [ true ] and test <> []) then Error("<els> does not determine a flag>"); fi; flag := rec(geo := ps, types := List(list,x->x!.type), els := list, vectorspace := ps!.vectors ObjectifyWithAttributes(flag, IsFlagOfCPSType, IsEmptyFlag, false, RankAttr, Size(lis return flag; end); # ADDED 31/3/2014 jdb ############################################################################# #O FlagOfIncidenceStructure( <ps>, <els> ) # returns the empty flag of the projective space <ps>. ## InstallMethod( FlagOfIncidenceStructure, "for a projective space and an empty list", [ IsClassicalPolarSpace, IsList and IsEmpty ], function(ps,els) local flag; flag := rec(geo := ps, types := [], els := [], vectorspace := ps!.vectorspace ); ObjectifyWithAttributes(flag, IsFlagOfCPSType, IsEmptyFlag, true, RankAttr, 0 ); return flag; end); ############################################################################# # View/Print/Display methods for flags ############################################################################# InstallMethod( ViewObj, "for a flag of a classical polar space", [ IsFlagOfClassicalPolarSpace and IsFlagOfIncidenceStructureRep ], function( flag ) Print("<a flag of ",ViewString(flag!.geo)," >"); end ); InstallMethod( PrintObj, "for a flag of a classical polar space", [ IsFlagOfClassicalPolarSpace and IsFlagOfIncidenceStructureRep ], function( flag ) PrintObj(flag!.els); end ); InstallMethod( Display, "for a flag of a classical polar space", [ IsFlagOfClassicalPolarSpace and IsFlagOfIncidenceStructureRep ], function( flag ) if IsEmptyFlag(flag) then Print("<empty flag of ",flag!.geo,")>\n"); else Print("<a flag of ",flag!.geo,"with elements of types ",flag!.types,"\n"); Print("respectively spanned by\n"); Display(flag!.els); fi; end ); ############################################################################ ## Methods for random stuff ## Since it is quick to find a pseudo-random element ## of a group (a random subproduct of the generators), ## we just find a random collineation and take the image ## of the associated element representative (see RepresentativesOfElements). ############################################################################# # CHECKED 22/09/2011 jdb. # CAHNGED 20/08/2014 jdb. ############################################################################# #O RandomSubspace( <ps>, <d> ) # returns a random subspace of projective dimension <d> in the polar space <ps> ## InstallMethod( RandomSubspace, "for a polar space and a projective dimension", [ IsClassicalPolarSpace, IsPosInt ], function( ps, d ) local x, rep, enum; if HasCollineationGroup(ps) then x := PseudoRandom( CollineationGroup(ps) ); rep := RepresentativesOfElements(ps)[d+1]; return OnProjSubspaces(rep, x); else enum := Enumerator(ElementsOfIncidenceStructure(ps,d)); return Random(enum); fi; end ); # CHECKED 22/09/2011 jdb ############################################################################# #O Random( <subs> ) # returns a random subspace of projective dimension <d> in the polar space <ps> ## InstallMethod( Random, "for a collection of subspaces of a polar space", [ IsSubspacesOfClassicalPolarSpace ], function( subs ) local ps, x, rep, enum; ps := subs!.geometry; if HasCollineationGroup(ps) then x := PseudoRandom( CollineationGroup(ps) ); rep := RepresentativesOfElements(ps)[subs!.type]; return OnProjSubspaces(rep, x); else enum := Enumerator(subs); return Random(enum); fi; end ); # CHECKED 16/12/2011 jdb + ml CHECKED and CORRECTED ############################################################################# #O just return IteratorList(Enumerator(vs)); InstallMethod(Iterator, "for subspaces of a polar space", [IsSubspacesOfClassicalPolarSpace], vs -> IteratorList(Enumerator(vs)) ); ############################################################################# # # Shadows of elements and flags # ############################################################################# # CHECKED 22/09/11 jdb # cmat notice. in this case just the ConvertToMatrixRep causes trouble. # added "parentflag" field in creation of collection. This happens # also for ShadowSubspacesOfProjectiveSpace. Now generic method for \in # for "an element of a Lie geometry and a collection of shadow elements" works. ############################################################################# #O ShadowOfElement(<ps>, <v>, <j> ). Recall that for every particular Lie # geometry a method for ShadowOfElement must be installed. ## InstallMethod( ShadowOfElement, "for a polar space, a subspace of a projective space, and an integer", [IsClassicalPolarSpace, IsSubspaceOfProjectiveSpace, IsPosInt], function( ps, v, j ) local localinner, localouter, localfactorspace, pstype, psdim, f, vdim, sz; pstype := PolarSpaceType(ps); psdim := ps!.dimension; f := ps!.basefield; vdim := v!.type; if not AmbientSpace(ps) = AmbientSpace(v) then Error("<v> is not a subspace of (the ambient space) of <ps>"); elif not v in ps then Error("<v> is not a subspace contained in <ps>"); fi; if j > Rank(ps) then Error("<ps> has no elements of type <j>"); elif j < vdim then localinner := []; localouter := Unpack(v!.obj); if IsVector(localouter) and not IsMatrix(localouter) then localouter := [localouter]; fi; #ConvertToMatrixRep( localouter, f ); localfactorspace := Subspace(ps!.vectorspace, localouter); sz := Size(Subspaces(localfactorspace, j)); elif j = vdim then localinner := Unpack(v!.obj); if IsVector(localinner) and not IsMatrix(localinner) then localinner := [localinner]; fi; localouter := localinner; localfactorspace := TrivialSubspace(ps!.vectorspace); sz := 1; else localinner := Unpack(v!.obj); localouter := Unpack(PolarMap(ps)(v)!.obj); #actually, this is not a polarity when q is even #localouter := UnderlyingObject(v^PolarityOfProjectiveSpace(ps)); if pstype = "symplectic" then localfactorspace := SymplecticSpace( psdim- 2*vdim, f ); elif pstype = "hermitian" then localfactorspace := HermitianPolarSpace( psdim-2*vdim, f ); elif pstype = "elliptic" then localfactorspace := EllipticQuadric( psdim-2*vdim, f ); elif pstype = "parabolic" then localfactorspace := ParabolicQuadric( psdim-2*vdim, f ); elif pstype = "hyperbolic" then localfactorspace := HyperbolicQuadric( psdim-2*vdim, f ); fi; sz := Size(ElementsOfIncidenceStructure(localfactorspace, j - vdim)); fi; return Objectify( NewType( ElementsCollFamily, IsElementsOfIncidenceStructure and IsShadowSubspacesOfClassicalPolarSpace and IsShadowSubspacesOfClassicalPolarSpaceRep), rec( geometry := ps, type := j, inner := localinner, outer := localouter, factorspace := localfactorspace, parentflag := FlagOfIncidenceStructure(ps,[v]), #added 5/4/2018, see remark above size := sz ) ); end ); # CHECKED 18/4/2011 jdb # 25/3/14 It turns out that there is a problem when we do not Unpack # cvec/cmat with Size(Subspaces(localfactorspace)). As there is never an action # on shadow of flag objects, it is not unreasonable to store the matrices as # GAP matrices rather than cvec/cmats. ############################################################################# #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 projective space (geometry), # the type j of the elements (type), the flag (parentflag), and some extra information # useful to compute with the shadows, e.g. iterator ## InstallMethod( ShadowOfFlag, "for a classical polar space, a flag and an integer", [IsClassicalPolarSpace, IsFlagOfClassicalPolarSpace, IsPosInt], function( ps, flag, j ) local localinner, localouter, localfactorspace, v, smallertypes, biggertypes, ceiling, f 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); if smallertypes=[] then localinner := []; ceiling:=Minimum(biggertypes); localouter:=flag!.els[Position(flag!.types,ceiling)]; elif biggertypes=[] then localouter:=BasisVectors(Basis(ps!.vectorspace)); floor:=Maximum(smallertypes); localinner:=flag!.els[Position(flag!.types,floor)]; vdim := localinner!.type; else floor:=Maximum(smallertypes); ceiling:=Minimum(biggertypes); localinner:=flag!.els[Position(flag!.types,floor)]; localouter:=flag!.els[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; if not biggertypes = [] then localfactorspace := Subspace(ps!.vectorspace, BaseSteinitzVectors(localouter, localinner).factorspace); if Dimension(localfactorspace) = 0 then sz := 1; else sz := Size(Subspaces(localfactorspace,j-Size(localinner))); fi; else pstype := PolarSpaceType(ps); psdim := ps!.dimension; f := ps!.basefield; if pstype = "symplectic" then localfactorspace := SymplecticSpace( psdim- 2*vdim, f ); elif pstype = "hermitian" then localfactorspace := HermitianPolarSpace( psdim-2*vdim, f ); elif pstype = "elliptic" then localfactorspace := EllipticQuadric( psdim-2*vdim, f ); elif pstype = "parabolic" then localfactorspace := ParabolicQuadric( psdim-2*vdim, f ); elif pstype = "hyperbolic" then localfactorspace := HyperbolicQuadric( psdim-2*vdim, f ); fi; sz := Size(ElementsOfIncidenceStructure(localfactorspace, j - vdim)); fi; return Objectify( NewType( ElementsCollFamily, IsElementsOfIncidenceStructure and IsShadowSubspacesOfClassicalPolarSpace and IsShadowSubspacesOfClassicalPolarSpaceRep), rec( geometry := ps, type := j, inner := localinner, outer := localouter, factorspace := localfactorspace, parentflag := flag, size := sz ) ); end); # added 3/9/14. This was necessary since there is a generic method now # for Iterator of shadow elements of a generic incidence structure which # is too generic for particular incidence geometries. The method here # is based on the standard GAP method that was used before we introduce the # generic method. ############################################################################# #O just return IteratorList(Enumerator(vs)); InstallMethod(Iterator, "for shadow subspaces of a polar space", [ IsShadowSubspacesOfClassicalPolarSpace ], vs -> IteratorList(Enumerator(vs)) ); # CHECKED 22/09/11 jdb ############################################################################# #O Size( <vs> ) returns the number of elements in a shadow collection ## InstallMethod( Size, "for a collection of shadow elements of a polar space", [IsShadowSubspacesOfClassicalPolarSpace and IsShadowSubspacesOfClassicalPolarSpace function( vs ) return vs!.size; end); # checked 7/4/2018 jdb. ############################################################################# #O IsCollinear( <ps>, <a>, <b> ) returns true if <a> and <b> are collinear in # <ps> ## InstallMethod( IsCollinear, "for a polar space and two points of its ambient space", [IsClassicalPolarSpace and IsClassicalPolarSpaceRep, IsSubspaceOfProjectiveSpace, IsSubspaceOfProjectiveSpace], function( ps, a, b ) if not a!.type=1 and b!.type=1 then Error("<a> and <b> should be points"); elif not AmbientSpace(a) = AmbientSpace(ps) and AmbientSpace(b) = AmbientSpace(ps) then Error("<a> and <b> should belong to the ambientspace of <ps>"); else return (a in ps) and (b in ps) and IsZero( [Unwrap(a),Unwrap(b)]^SesquilinearForm(ps) ); fi; end ); ############################################################################# # Polarities and polar spaces. ############################################################################# # CHECKED 22/09/11 jdb ############################################################################# #O PolarityOfProjectiveSpace( <ps> ) #the next method returns the polarity associated to a polar space. #recall that polarspaces and associated polarities are equivalent, except #when q is even and the polar space is orthogonal, in this case, the associated #symplectic polarity is returned, so usable to compute tangent hyperplanes etc. #When q is even and the projective dimension is even, this associated sesquilinear form #is degenerate, so not usable to construct a polarity, because we ask a non-degenerate form #So, the above condition is, due to definitions in Fining, and the definition of #the "associated sesquilinear form of a polar space, equivalent with cheking #whether the form returned by SesquilinearForm(ps) is degenerate. If not, we go! #all necessary algebraic stuff is in the forms package. ## InstallMethod(PolarityOfProjectiveSpace, "for a polar space", [IsClassicalPolarSpace], function(ps) local form; form := SesquilinearForm(ps); if IsDegenerateForm(form) then Error("no polarity of the ambient projective space can be associated to <ps>"); else return PolarityOfProjectiveSpace(form); fi; end ); # CHECKED 22/09/11 jdb ############################################################################# #O PolarSpace( <polarity> ) returns the polar space associated to the polarity. # returns an error if <polarity> is pseudo. Of course, orthogonal polar spaces # in even characteristic cannot be reached with this method. ## InstallMethod( PolarSpace, "from a polarity of a projective space", [ IsPolarityOfProjectiveSpace ], function( polarity ) local form, ps; form := SesquilinearForm(polarity); if not IsPseudoForm(form) then ps := PolarSpace( form ); else Error("<polarity> is pseudo and does not induce a polar space"); fi; return ps; end ); # CHECKED 22/09/11 jdb ############################################################################# #O GeometryOfAbsolutePoints( <polarity> ) returns the geometry of absolute # points of <polarity>. This is in most cases a polar space, which explains why this # method is found here. ## InstallMethod( GeometryOfAbsolutePoints, "for a polarity of a projective space", [ IsPolarityOfProjectiveSpace ], function( polarity ) local form, geom, ps, vect, mat, n, sub; form := SesquilinearForm(polarity); if IsPseudoForm(form) then mat := polarity!.mat; n := NrRows(mat); vect := List([1..n],i->mat[i,i]); sub := NullspaceMat(TransposedMat([vect])); ps := ProjectiveSpace(n-1,polarity!.fld); return VectorSpaceToElement(ps,sub); else return PolarSpace(form); fi; return ps; end ); # CHECKED 22/09/11 jdb ############################################################################# #O AbsolutePoints( <polarity> ) returns the collection of points of the # geometry of absolute points of <polarity> ## InstallMethod( AbsolutePoints, "for a polarity of a projective space", [ IsPolarityOfProjectiveSpace ], function( polarity ) return Points(GeometryOfAbsolutePoints(polarity)); end ); # added 31/07/2014 jdb ############################################################################# #O TangentSpace( <polarspace>, <el> ) returns the collection of points of the # geometry of absolute points of <polarity> ## InstallMethod( AbsolutePoints, "for a polarity of a projective space", [ IsPolarityOfProjectiveSpace ], function( polarity ) return Points(GeometryOfAbsolutePoints(polarity)); end ); #I think the next method is obsolete. We have a method \in for a subspace of a projective space # and a polar space, and this does the job. I leave as is, comment out, and if there are no complains # it can be deleted. #InstallMethod( IsTotallySingular, # "for a elementen variety w.r.t a polarity", # [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep, IsSubspaceOfProjectiveSpace ], # function( ps, v ) # local uv, bi, f, ty, localaut, m, form, # flag, bsum, count1, count2; ## Suppose the polar space is defined by a quadratic form Q. Then ## a subspace of the ambient projective space is totally singular if ## it computes zero under Q. If we have only a sesquilinear form b, ## then let the map b(v,v) take the role of Q. # # form := SesquilinearForm(ps); # m := form!.matrix; # f := form!.basefield; # ty := form!.type; # uv := v!.obj; # if v!.type = 1 then uv := [uv]; fi; # if ty = "hermitian" then # localaut := CompanionAutomorphism(ps); # return IsZero( uv * m * (TransposedMat(uv)^localaut) ); # else ## A subspace with basis B is totally singular w.r.t the quadratic form ## Q(v) = vMv^T if for all pairs b_i and b_j in B we have Q(b_i+b_j) = 0. # check first that everything in uv is t.s. # flag := ForAll(uv, x -> IsZero(x * m * x)); # if v!.type > 1 and flag then ## just a shorter way to go through combinations # count1 := 1; count2 := 2; # repeat # repeat # bsum := uv[count1]+uv[count2]; # flag := IsZero(bsum * m * bsum); # count2 := count2 + 1; # until flag or count2 > Length(uv); # count1 := count1 + 1; # count2 := count1 + 1; # until flag or count1 >= Length(uv); # fi; # return flag; # fi; # end ); # this is obsolete now #InstallMethod( IsTotallyIsotropic, "for a projective variety w.r.t a polarity", # [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep, IsSubspaceOfProjectiveSpace ], # function( ps, v ) # local perp, perpv; # perp := Polarity(ps); # perpv := perp(v); # return perpv!.type >= v!.type and v in perp(v); # end ); #CHECKED 20/3/14 # cmat notice: for some computations it seems necessary to Unpack the cmats. ############################################################################# #O PolarMap( <ps> ) returns the polar map associated to the polar space <ps>. # in most cases this polar map is just the polarity. Actually, this operation is # only for internal use. InstallMethod( PolarMap, "for a polar space", [IsClassicalPolarSpace], function( ps ) local perp, m, ty, f, form, bi; ## If we have only a quadratic form Q, then we must remember ## to use let the map b(v,w) := Q(v+w)-Q(v)-Q(w) be the polarisation of Q, ## and consider the polarity induced from this map. This can be computed using AssociatedBilin form := SesquilinearForm(ps); m := form!.matrix; f := form!.basefield; ty := form!.type; if ty = "hermitian" then perp := function(v) local perpv, uv, rk, aut; aut := CompanionAutomorphism(ps); uv := Unpack(v!.obj); #cmat unpack. if v!.type = 1 then uv := [uv]; fi; perpv := MutableCopyMat(TriangulizedNullspaceMat( m * TransposedMat(uv)^aut )); #rk := Rank(perpv); # if rk = 1 then perpv := perpv[1]; fi; return VectorSpaceToElement(AmbientSpace(ps), perpv); #cmat notice: now Wrap cannot be us end; else if IsEvenInt(Size(f)) and (ty = "elliptic" or ty = "hyperbolic" or ty = "parabolic") then ## recover bilinear form from quadratic form bi := m + TransposedMat(m); else bi := m; fi; perp := function(v) local perpv, uv, rk; uv := Unpack(v!.obj); #cmat unpack. if v!.type = 1 then uv := [uv]; fi; perpv := MutableCopyMat(TriangulizedNullspaceMat( bi * TransposedMat(uv) )); #rk := Rank(perpv); #if rk = 1 then # perpv := perpv[1]; #ConvertToVectorRep( perpv, f ); #else #ConvertToMatrixRep( perpv, f ); #fi; return VectorSpaceToElement(AmbientSpace(ps), perpv); #cmat notice: now Wrap cannot be us end; fi; return perp; ## should we return a correlation here? No. end ); ############################################################################# # # Groups: (special) isometry groups and similarity group of finite classical # polar spaces # ############################################################################# ############################################################################# #O CollineationGroup( <ps> ) returns collineation group of <ps> ## InstallMethod( CollineationGroup, "for a polar space", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep ], function( ps ) local iso, twiner, g, info, x, points, hom, d, f, coll, type, act; d := ps!.dimension + 1; f := ps!.basefield; if HasIsCanonicalPolarSpace(ps) and IsCanonicalPolarSpace(ps) then type := PolarSpaceType( ps ); info := ClassicalGroupInfo( ps ); if type = "symplectic" then g := GammaSp(d,f); elif type = "elliptic" then g := GammaOminus(d,f); elif type = "hyperbolic" then g := GammaOplus(d,f); elif type = "parabolic" then g := GammaO(d,f); elif type = "hermitian" then g := GammaU(d, f); fi; else iso := IsomorphismCanonicalPolarSpaceWithIntertwiner( ps ); Info(InfoFinInG, 1, "Computing collineation group of canonical polar space..."); coll := CollineationGroup( Source(iso)!.geometry ); info := ClassicalGroupInfo( ps ); twiner := Intertwiner( iso ); g := Image(twiner, coll); fi; ## Setting up the NiceMonomorphism x := RepresentativesOfElements( ps ); # We need to know in the case that d = 2 whether we have a # hermitian polar space. If it is hermitian, then for 2.PGammaU(d, q^2), # the NiceMonomorphism will just use that for PGammaL(d, q) type := PolarSpaceType( ps ); if type ="hermitian" and d = 2 and not IsPrime(Sqrt(Size(f))) then Info(InfoFinInG, 1, "No nice monomorphism computed."); Info(InfoFinInG, 2, "This really pisses me off, John!"); else if not IsEmpty(x) then if type = "hermitian" and d=4 then x := x[2]; act := OnProjSubspacesWithFrob; else x := x[1]; act := OnProjPointsWithFrob; fi; if FINING.Fast then hom := NiceMonomorphismByOrbit( g, x!.obj, act, info!.degree); else points := Orbit(g, x, OnProjSubspaces); hom := ActionHomomorphism(g, points, OnProjSubspaces, "surjective"); SetIsBijective(hom, true); SetNiceObject(g, Image(hom) ); fi; SetNiceMonomorphism(g, hom ); fi; fi; # only for making generalised polygons section more generic: if IsClassicalGQ(ps) then SetCollineationAction(g,OnProjSubspaces); fi; return g; end ); ############################################################################# #O SpecialIsometryGroup( <ps> ) returns the special isometry group of <ps> ## InstallMethod( SpecialIsometryGroup, "for a classical polar space", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep ], function( ps ) local iso, twiner, g, info, coll, d, f, type; if HasIsCanonicalPolarSpace(ps) and IsCanonicalPolarSpace(ps) then type := PolarSpaceType( ps ); info := ClassicalGroupInfo( ps ); coll := CollineationGroup( ps ); d := ps!.dimension + 1; f := ps!.basefield; if type = "symplectic" then g := Spdesargues(d,f); elif type = "elliptic" then g := SOdesargues(-1,d,f); elif type = "hyperbolic" then g := SOdesargues(1,d,f); elif type = "parabolic" then g := SOdesargues(0,d,f); elif type = "hermitian" then g := SUdesargues(d, f); fi; SetParent(g, coll); else iso := IsomorphismCanonicalPolarSpaceWithIntertwiner( ps ); twiner := Intertwiner( iso ); g := Image(twiner, SpecialIsometryGroup(Source(iso)!.geometry) ); SetParent(g, CollineationGroup(ps)); fi; return g; end ); ############################################################################# #O IsometryGroup( <ps> ) returns the isometry group of <ps> ## InstallMethod( IsometryGroup, "for a classical polar space", [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep ], function( ps ) local iso, twiner, g, info, coll, d, f, type; if HasIsCanonicalPolarSpace(ps) and IsCanonicalPolarSpace(ps) then #Print("yes!"); type := PolarSpaceType( ps ); info := ClassicalGroupInfo( ps ); coll := CollineationGroup( ps ); d := ps!.dimension + 1; f := ps!.basefield; if type = "symplectic" then g := Spdesargues(d,f); elif type = "elliptic" then g := GOdesargues(-1,d,f); elif type = "hyperbolic" then g := GOdesargues(1,d,f); elif type = "parabolic" then g := GOdesargues(0,d,f); elif type = "hermitian" then g := GUdesargues(d, f); fi; SetParent(g, coll); else iso := IsomorphismCanonicalPolarSpaceWithIntertwiner( ps ); twiner := Intertwiner( iso ); g := Image(twiner, IsometryGroup(Source(iso)!.geometry) ); SetParent(g, CollineationGroup(ps)); fi; return g; end ); ############################################################################# #O SimilarityGroup( <ps> ) returns the similarity group of <ps> ## InstallMethod( SimilarityGroup, [ IsClassicalPolarSpace and IsClassicalPolarSpaceRep ] function( ps ) local iso, twiner, g, info, coll, d, f, type; if HasIsCanonicalPolarSpace(ps) and IsCanonicalPolarSpace(ps) then type := PolarSpaceType( ps ); info := ClassicalGroupInfo( ps ); coll := CollineationGroup( ps ); d := ps!.dimension + 1; f := ps!.basefield; if type = "symplectic" then g := GSpdesargues(d,f); elif type = "elliptic" then g := DeltaOminus(d,f); elif type = "hyperbolic" then g := DeltaOplus(d,f); elif type = "parabolic" then g := GOdesargues(0,d,f); elif type = "hermitian" then g := GUdesargues(d, f); fi; SetParent(g, coll); else iso := IsomorphismCanonicalPolarSpaceWithIntertwiner( ps ); twiner := Intertwiner( iso ); g := Image(twiner, SimilarityGroup(Source(iso)!.geometry) ); SetParent(g, CollineationGroup(ps)); fi; return g; end ); ############################################################################# ############################################################################# #P IsParabolicQuadric( <ps> ) # returns true if <ps> is a parabolic quadric ## InstallMethod( IsParabolicQuadric, "for a polar space having HasQuadraticForm", [IsClassicalPolarSpace], 1, function( ps ) if HasQuadraticForm(ps) then return IsParabolicForm(QuadraticForm(ps)); else TryNextMethod(); fi; end); ############################################################################# #P IsParabolicQuadric( <ps> ) # returns true if <ps> is a parabolic quadric ## InstallMethod( IsParabolicQuadric, "for a polar space", [IsClassicalPolarSpace], function( ps ) return IsParabolicForm(SesquilinearForm(ps)); end); ############################################################################# #P IsHyperbolicQuadric( <ps> ) # returns true if <ps> is a hyperbolic quadric ## InstallMethod( IsHyperbolicQuadric, "for a polar space having HasQuadraticForm", [IsClassicalPolarSpace], 1, function( ps ) if HasQuadraticForm(ps) then return IsHyperbolicForm(QuadraticForm(ps)); else TryNextMethod(); fi; end); ############################################################################# #P IsHyperbolicQuadric( <ps> ) # returns true if <ps> is a hyperbolic quadric ## InstallMethod( IsHyperbolicQuadric, "for a polar space", [IsClassicalPolarSpace], function( ps ) return IsHyperbolicForm(SesquilinearForm(ps)); end); ############################################################################# #P IsEllipticQuadric( <ps> ) # returns true if <ps> is an elliptic quadric ## InstallMethod( IsEllipticQuadric, "for a polar space having HasQuadraticForm", [IsClassicalPolarSpace], 1, function( ps ) if HasQuadraticForm(ps) then return IsEllipticForm(QuadraticForm(ps)); else TryNextMethod(); fi; end); ############################################################################# #P IsEllipticQuadric( <ps> ) # returns true if <ps> is an elliptic quadric ## InstallMethod( IsEllipticQuadric, "for a polar space", [IsClassicalPolarSpace], function( ps ) return IsEllipticForm(SesquilinearForm(ps)); end); ############################################################################# #P IsSymplecticSpace( <ps> ) # returns true if <ps> is an elliptic quadric ## InstallMethod( IsSymplecticSpace, "for a polar space", [IsClassicalPolarSpace], function( ps ) return PolarSpaceType(ps)="symplectic"; end); ############################################################################# #P IsHermitianPolarSpace( <ps> ) # returns true if <ps> is an elliptic quadric ## InstallMethod( IsHermitianPolarSpace, "for a polar space", [IsClassicalPolarSpace], function( ps ) return PolarSpaceType(ps)="hermitian"; end); ############################################################################# # A litte extra since we put some quadrics and hermitian varieties in # IsProjectiveVariety. ############################################################################# ############################################################################# #P DefiningListOfPolynomials( <ps> ) # returns all the elements of the polar space <ps> ## InstallMethod( DefiningListOfPolynomials, "for a polar space", [IsProjectiveVariety and IsClassicalPolarSpace and IsClassicalPolarSpaceRep], function( ps ) return [EquationForPolarSpace(ps)]; end); ############################################################################# # Elementary analytic geometry. ############################################################################# #added 26/4/2014 jdb ############################################################################# #A NucleusOfParabolicQuadric( <ps> ) # returns the nuclues of a parabolic quadric (even characteristic). ## InstallMethod( NucleusOfParabolicQuadric, "for a polar space", [ IsClassicalPolarSpace ], function( ps ) if not IsParabolicQuadric(ps) and IsEvenInt(Size(BaseField(ps))) then Error(" <ps> has no nucleus" ); else return VectorSpaceToElement( AmbientSpace(ps), RadicalOfFormBaseMat( SesquilinearFor fi; end); #added 01/08/2014 jdb ############################################################################# #A TangentSpace( <el> ) # returns the tangent space at <el>, <el> must be a subspace of a polar space. ## InstallMethod( TangentSpace, "for a subspace of a polar space", [ IsSubspaceOfClassicalPolarSpace ], function( el ) local form, vec; form := SesquilinearForm(el!.geo); if not IsDegenerateForm(form) then return el^PolarityOfProjectiveSpace(form); else vec := Unpack(el!.obj)*form!.matrix; if el!.type = 1 then return HyperplaneByDualCoordinates(AmbientSpace(el),vec); else return VectorSpaceToElement(AmbientSpace(el), NullspaceMat(TransposedMat(vec))); fi; fi; end); #added 01/08/2014 jdb ############################################################################# #A TangentSpace( <el> ) # returns the tangent space at <el>, <el> must be a subspace of a polar space. ## InstallMethod( TangentSpace, "for a subspace of a polar space", [ IsClassicalPolarSpace, IsSubspaceOfProjectiveSpace ], function( ps, el ) local form, vec; if not el in ps then Error("<el> should lie in <ps>"); fi; form := SesquilinearForm(ps); if not IsDegenerateForm(form) then return el^PolarityOfProjectiveSpace(form); else vec := Unpack(el!.obj)*form!.matrix; if el!.type = 1 then return HyperplaneByDualCoordinates(AmbientSpace(el),vec); else return VectorSpaceToElement(AmbientSpace(el), NullspaceMat(TransposedMat(vec))); fi; fi; end); #added 01/08/2014 jdb ############################################################################# #A Pole(<ps>, <el> ) # returns the pole of <el> with respect to <ps>. ## InstallMethod( Pole, "for a subspace of a polar space", [ IsClassicalPolarSpace, IsSubspaceOfProjectiveSpace ], function( ps, el ) local form, vec; if not el in AmbientSpace(ps) then Error("<el> should lie in the ambient space of <ps>"); fi; form := SesquilinearForm(ps); if not IsDegenerateForm(form) then return el^PolarityOfProjectiveSpace(form); else vec := Unpack(el!.obj)*form!.matrix; if el!.type = 1 then return HyperplaneByDualCoordinates(AmbientSpace(el),vec); else return VectorSpaceToElement(AmbientSpace(el), NullspaceMat(TransposedMat(vec))); fi; fi; end); ############################################################################# #O IncidenceGraph( <gp> ) # Note that computing the collineation group of a projective space is zero # computation time. So useless to print the warning here if the group is not # yet computed. ### InstallMethod( IncidenceGraph, "for a projective space", [ IsClassicalPolarSpace ], function( ps ) local elements, graph, adj, coll, sz; if IsBound(ps!.IncidenceGraphAttr) then return ps!.IncidenceGraphAttr; fi; if not HasCollineationGroup(ps) then Error("No collineation group computed. Please compute collineation group before computing else coll := CollineationGroup(ps); elements := Concatenation(List([1..Rank(ps)], i -> List(AsList(ElementsOfIncidenceStru adj := function(x,y) if x!.type <> y!.type then return IsIncident(x,y); else return false; fi; end; graph := Graph(coll,elements,OnProjSubspaces,adj,true); Setter( IncidenceGraphAttr )( ps, graph ); return graph; fi; end );
¤ Diese beiden folgenden Angebotsgruppen bietet das Unternehmen0.98Angebot (Wie Sie bei der Firma Beratungs- und Dienstleistungen beauftragen können 2026-10-12) ¤*Bot Zugriff |
|
||||||||||||||
2026-10-11