diff --git a/init.g b/init.g index 6f21851..7fcd697 100644 --- a/init.g +++ b/init.g @@ -14,3 +14,7 @@ ReadPackage("forms","lib/forms.gd"); ReadPackage("forms","lib/recognition.gd"); + +if IsBound( ConformalSymplecticGroup ) then + ReadPackage("forms","lib/conformal.gd"); +fi; diff --git a/lib/classic.gi b/lib/classic.gi index 7bcfc71..31e3951 100644 --- a/lib/classic.gi +++ b/lib/classic.gi @@ -109,7 +109,7 @@ BindGlobal("Forms_OrthogonalGroup", fi; mat:= matinv * InvariantBilinearForm( g ).matrix * TransposedMat( matinv ); - SetInvariantBilinearForm( gg, rec( matrix:= mat ) ); + SetInvariantBilinearForm( gg, rec( matrix:= mat, baseDomain:= gf ) ); if Characteristic( gf ) <> 2 and HasIsFullSubgroupGLorSLRespectingBilinearForm( g ) then SetIsFullSubgroupGLorSLRespectingBilinearForm( gg, @@ -784,17 +784,17 @@ InstallMethod( SpecialUnitaryGroupCons, g:= SpecialUnitaryGroupCons( filt, d, q ); stored:= InvariantSesquilinearForm( g ).matrix; - # If the prescribed form fits then just return. - if stored = form!.matrix then - return g; - fi; - # Check that 'form' lives over the intended field. F:= GF(q^2); if not IsSubset( F, form!.basefield ) then Error( "the defining field of
does not fit to " ); fi; + # If the prescribed form fits then just return. + if stored = form!.matrix then + return g; + fi; + # Compute a base change matrix. # (Check that the canonical forms are equal.) wanted:= HermitianFormByMatrix( stored, F ); @@ -832,8 +832,8 @@ end ); ############################################################################# ## #O SymplecticGroupCons( , ) -#O SymplecticGroupCons( , , , ) #O SymplecticGroupCons( , , , ) +#O SymplecticGroupCons( , , , ) ## ## 'SymplecticGroup' is a plain function that is defined in the GAP ## library. @@ -845,10 +845,10 @@ Perform( [ IsMatrixOrMatrixObj, IsBilinearForm, IsGroup and HasInvariantBilinearForm ], function( obj ) DeclareConstructor( "SymplecticGroupCons", [ IsGroup, obj ] ); - DeclareConstructor( "SymplecticGroupCons", - [ IsGroup, IsPosInt, IsPosInt, obj ] ); DeclareConstructor( "SymplecticGroupCons", [ IsGroup, IsPosInt, IsRing, obj ] ); + DeclareConstructor( "SymplecticGroupCons", + [ IsGroup, IsPosInt, IsPosInt, obj ] ); end ); @@ -875,7 +875,7 @@ InstallMethod( SymplecticGroupCons, [ IsMatrixGroup and IsFinite, IsBilinearForm ], { filt, form } -> SymplecticGroupCons( filt, NumberRows( form!.matrix ), - Size( form!.basefield ), form ) ); + form!.basefield, form ) ); ############################################################################# @@ -888,7 +888,7 @@ InstallMethod( SymplecticGroupCons, IsPosInt, IsPosInt, IsMatrixOrMatrixObj ], - { filt, d, q, mat } -> SymplecticGroupCons( filt, d, q, + { filt, d, q, mat } -> SymplecticGroupCons( filt, d, GF(q), BilinearFormByMatrix( mat, GF(q) ) ) ); InstallMethod( SymplecticGroupCons, @@ -897,7 +897,7 @@ InstallMethod( SymplecticGroupCons, IsPosInt, IsPosInt, IsGroup and HasInvariantBilinearForm ], - { filt, d, q, G } -> SymplecticGroupCons( filt, d, q, + { filt, d, q, G } -> SymplecticGroupCons( filt, d, GF(q), BilinearFormByMatrix( InvariantBilinearForm( G ).matrix, GF(q) ) ) ); @@ -907,30 +907,46 @@ InstallMethod( SymplecticGroupCons, IsPosInt, IsPosInt, IsBilinearForm ], - function( filt, d, q, form ) - local g, stored, F, wanted, mat1, mat2, mat, matinv, gens, gg; + { filt, d, q, form } -> SymplecticGroupCons( filt, d, GF(q), form ) ); + + +############################################################################# +## +#M SymplecticGroupCons( , , , ) +## +InstallMethod( SymplecticGroupCons, + "matrix group for dimension, finite field, form", + [ IsMatrixGroup and IsFinite, + IsPosInt, + IsField and IsFinite, + IsBilinearForm ], + function( filt, d, F, form ) + local q, g, stored, form_matrix, wanted, mat1, mat2, mat, matinv, gens, gg; # Create the default generators and form. - g:= SymplecticGroupCons( filt, d, q ); + q:= Size( F ); + g:= SymplecticGroupCons( filt, d, F ); stored:= InvariantBilinearForm( g ).matrix; - # If the prescribed form fits then just return. - if stored = form!.matrix then - return g; - fi; - # Check that 'form' lives over the intended field. - F:= GF(q); if not IsSubset( F, form!.basefield ) then Error( "the defining field of does not fit to " ); fi; + # If the prescribed form fits then just return. + form_matrix:= Matrix( form!.matrix, stored ); +#T This 'Matrix' call should become unnecessary. +#T For that, the functions used below have to support 'IsMatrixObj' arguments. + if stored = form_matrix then + return g; + fi; + # Compute a base change matrix. # (Check that the canonical forms are equal.) wanted:= BilinearFormByMatrix( stored, F ); - mat1:= BaseChangeToCanonical( form ); - mat2:= BaseChangeToCanonical( wanted ); - if mat1 * form!.matrix * TransposedMat( mat1 ) <> + mat1:= Matrix( BaseChangeToCanonical( form ), stored ); + mat2:= Matrix( BaseChangeToCanonical( wanted ), stored ); + if mat1 * form_matrix * TransposedMat( mat1 ) <> mat2 * stored * TransposedMat( mat2 ) then Error( "canonical forms of and differ" ); fi; @@ -947,7 +963,7 @@ InstallMethod( SymplecticGroupCons, SetName( gg, Name( g ) ); fi; - SetInvariantBilinearForm( gg, rec( matrix:= form!.matrix, + SetInvariantBilinearForm( gg, rec( matrix:= form_matrix, baseDomain:= F ) ); if HasIsFullSubgroupGLorSLRespectingBilinearForm( g ) then SetIsFullSubgroupGLorSLRespectingBilinearForm( gg, @@ -957,18 +973,13 @@ InstallMethod( SymplecticGroupCons, return gg; end ); - -############################################################################# -## -#M SymplecticGroupCons( , , , ) -## InstallMethod( SymplecticGroupCons, "matrix group for dimension, finite field, matrix of form", [ IsMatrixGroup and IsFinite, IsPosInt, IsField and IsFinite, IsMatrixOrMatrixObj ], - { filt, d, F, form } -> SymplecticGroupCons( filt, d, Size( F ), + { filt, d, F, form } -> SymplecticGroupCons( filt, d, F, BilinearFormByMatrix( form, F ) ) ); InstallMethod( SymplecticGroupCons, @@ -977,14 +988,6 @@ InstallMethod( SymplecticGroupCons, IsPosInt, IsField and IsFinite, IsGroup and HasInvariantBilinearForm ], - { filt, d, F, G } -> SymplecticGroupCons( filt, d, Size( F ), + { filt, d, F, G } -> SymplecticGroupCons( filt, d, F, BilinearFormByMatrix( InvariantBilinearForm( G ).matrix, F ) ) ); - -InstallMethod( SymplecticGroupCons, - "matrix group for dimension, finite field, form", - [ IsMatrixGroup and IsFinite, - IsPosInt, - IsField and IsFinite, - IsBilinearForm ], - { filt, d, F, form } -> SymplecticGroupCons( filt, d, Size( F ), form ) ); diff --git a/lib/conformal.gd b/lib/conformal.gd new file mode 100644 index 0000000..e943d89 --- /dev/null +++ b/lib/conformal.gd @@ -0,0 +1,28 @@ +############################################################################# +## +## conformal.gd 'Forms' package +## + +############################################################################# +## +#O ConformalSymplecticGroupCons( , ) +#O ConformalSymplecticGroupCons( , ) +#O ConformalSymplecticGroupCons( , ) +#O ConformalSymplecticGroupCons( , , , ) +#O ConformalSymplecticGroupCons( , , , ) +#O ConformalSymplecticGroupCons( , , , ) +#O ConformalSymplecticGroupCons( , , , ) +#O ConformalSymplecticGroupCons( , , , ) +#O ConformalSymplecticGroupCons( , , , ) +## +## Declare the variants involving a bilinear form as an argument. +## +Perform( + [ IsMatrixOrMatrixObj, IsBilinearForm, IsGroup ], + function( obj ) + DeclareConstructor( "ConformalSymplecticGroupCons", [ IsGroup, obj ] ); + DeclareConstructor( "ConformalSymplecticGroupCons", + [ IsGroup, IsPosInt, IsRing, obj ] ); + DeclareConstructor( "ConformalSymplecticGroupCons", + [ IsGroup, IsPosInt, IsPosInt, obj ] ); + end ); diff --git a/lib/conformal.gi b/lib/conformal.gi new file mode 100644 index 0000000..ce265c4 --- /dev/null +++ b/lib/conformal.gi @@ -0,0 +1,189 @@ +############################################################################# +## +#M ConformalSymplecticGroupCons( , ) +## +InstallMethod( ConformalSymplecticGroupCons, + "matrix group for matrix of form", + [ "IsMatrixGroup and IsFinite", "IsMatrixOrMatrixObj" ], + { filt, mat } -> ConformalSymplecticGroupCons( filt, + BilinearFormByMatrix( mat, BaseDomain( mat ) ) ) ); + +InstallMethod( ConformalSymplecticGroupCons, + "matrix group for group with form", + [ "IsMatrixGroup and IsFinite", "IsGroup and HasInvariantBilinearForm" ], + { filt, G } -> ConformalSymplecticGroupCons( filt, + BilinearFormByMatrix( + InvariantBilinearForm( G ).matrix, + Forms_FieldOfDefinition( InvariantBilinearForm( G ), G ) ) ) ); + +InstallMethod( ConformalSymplecticGroupCons, + "matrix group for group with form", + [ "IsMatrixGroup and IsFinite", + "IsGroup and HasInvariantBilinearFormUpToScalars" ], + { filt, G } -> ConformalSymplecticGroupCons( filt, + BilinearFormByMatrix( + InvariantBilinearFormUpToScalars( G ).matrix, + Forms_FieldOfDefinition( InvariantBilinearFormUpToScalars( G ), G ) ) ) ); + +InstallMethod( ConformalSymplecticGroupCons, + "matrix group for form", + [ "IsMatrixGroup and IsFinite", "IsBilinearForm" ], + { filt, form } -> ConformalSymplecticGroupCons( filt, + NumberRows( form!.matrix ), + form!.basefield, form ) ); + + +############################################################################# +## +#M ConformalSymplecticGroupCons( , , , ) +## +InstallMethod( ConformalSymplecticGroupCons, + "matrix group for dimension, finite field size, matrix of form", + [ "IsMatrixGroup and IsFinite", + "IsPosInt", + "IsPosInt", + "IsMatrixOrMatrixObj" ], + { filt, d, q, mat } -> ConformalSymplecticGroupCons( filt, d, GF(q), + BilinearFormByMatrix( mat, GF(q) ) ) ); + +InstallMethod( ConformalSymplecticGroupCons, + "matrix group for dimension, finite field size, group with form", + [ "IsMatrixGroup and IsFinite", + "IsPosInt", + "IsPosInt", + "IsGroup and HasInvariantBilinearForm" ], + { filt, d, q, G } -> ConformalSymplecticGroupCons( filt, d, GF(q), + BilinearFormByMatrix( + InvariantBilinearForm( G ).matrix, GF(q) ) ) ); + +InstallMethod( ConformalSymplecticGroupCons, + "matrix group for dimension, finite field size, group with form", + [ "IsMatrixGroup and IsFinite", + "IsPosInt", + "IsPosInt", + "IsGroup and HasInvariantBilinearFormUpToScalars" ], + { filt, d, q, G } -> ConformalSymplecticGroupCons( filt, d, GF(q), + BilinearFormByMatrix( + InvariantBilinearFormUpToScalars( G ).matrix, GF(q) ) ) ); + +InstallMethod( ConformalSymplecticGroupCons, + "matrix group for dimension, finite field size, form", + [ "IsMatrixGroup and IsFinite", + "IsPosInt", + "IsPosInt", + "IsBilinearForm" ], + { filt, d, q, form } -> ConformalSymplecticGroupCons( filt, d, GF(q), form ) ); + + +############################################################################# +## +#M ConformalSymplecticGroupCons( , , , ) +## +InstallMethod( ConformalSymplecticGroupCons, + "matrix group for dimension, finite field, matrix of form", + [ "IsMatrixGroup and IsFinite", + "IsPosInt", + "IsField and IsFinite", + "IsMatrixOrMatrixObj" ], + { filt, d, F, form } -> ConformalSymplecticGroupCons( filt, d, F, + BilinearFormByMatrix( form, F ) ) ); + +InstallMethod( ConformalSymplecticGroupCons, + "matrix group for dimension, finite field, group with form", + [ "IsMatrixGroup and IsFinite", + "IsPosInt", + "IsField and IsFinite", + "IsGroup and HasInvariantBilinearForm" ], + { filt, d, F, G } -> ConformalSymplecticGroupCons( filt, d, F, + BilinearFormByMatrix( + InvariantBilinearForm( G ).matrix, F ) ) ); + +InstallMethod( ConformalSymplecticGroupCons, + "matrix group for dimension, finite field, group with form", + [ "IsMatrixGroup and IsFinite", + "IsPosInt", + "IsField and IsFinite", + "IsGroup and HasInvariantBilinearFormUpToScalars" ], + { filt, d, F, G } -> ConformalSymplecticGroupCons( filt, d, F, + BilinearFormByMatrix( + InvariantBilinearFormUpToScalars( G ).matrix, F ) ) ); + +InstallMethod( ConformalSymplecticGroupCons, + "matrix group for dimension, finite field, form", + [ "IsMatrixGroup and IsFinite", + "IsPosInt", + "IsField and IsFinite", + "IsBilinearForm" ], + function( filt, d, F, form ) + local g, stored, wanted, mat1, mat2, mat, matinv, gens, gg; + + # Create the default generators and form. + g:= ConformalSymplecticGroupCons( filt, d, F ); + stored:= InvariantBilinearFormUpToScalars( g ).matrix; + + # If the prescribed form fits then just return. + if stored = form!.matrix then + return g; + fi; + + # Compute a base change matrix. + # (Check that the canonical forms are equal.) + wanted:= BilinearFormByMatrix( stored, F ); + mat1:= BaseChangeToCanonical( form ); + mat2:= BaseChangeToCanonical( wanted ); + if mat1 * form!.matrix * TransposedMat( mat1 ) <> + mat2 * stored * TransposedMat( mat2 ) then + Error( "canonical forms of and differ" ); + fi; + mat:= mat2^-1 * mat1; + matinv:= mat^-1; + + # Create the group w.r.t. the prescribed form. + gens:= List( GeneratorsOfGroup( g ), + x -> Matrix( matinv * x * mat, stored ) ); + gg:= GroupWithGenerators( gens ); + + UseIsomorphismRelation( g, gg ); + + if HasName( g ) then + SetName( gg, Name( g ) ); + fi; + + SetInvariantBilinearFormUpToScalars( gg, + rec( matrix:= Matrix( form!.matrix, stored ), baseDomain:= F ) ); + + if HasIsFullSubgroupGLRespectingBilinearFormUpToScalars( g ) then + SetIsFullSubgroupGLRespectingBilinearFormUpToScalars( gg, + IsFullSubgroupGLRespectingBilinearFormUpToScalars( g ) ); + fi; + + return gg; +end ); + + +############################################################################# +## +## The following methods are currently needed to make the code work +## in case one creates groups whose elements are in `IsMatrixObj`. +## Eventually we must support `IsMatrixObj` matrices in form objects. +## + +InstallOtherMethod( BilinearFormByMatrix, + "for a ffe matrix object and a field", + [ "IsMatrixObj and IsFFECollColl", "IsField and IsFinite" ], + { m, F } -> BilinearFormByMatrix( Unpack( m ), F ) ); + +InstallOtherMethod( BilinearFormByMatrix, + "for a ffe matrix object", + [ "IsMatrixObj and IsFFECollColl" ], + m -> BilinearFormByMatrix( Unpack( m ) ) ); + + +# The following is apparently needed in the tests in `tst/adv/conformal.tst`. +# Strictly speaking, the following is not correct, +# according to the definition of `DegreeFFE`. +# Eventually we should fix the use of `FieldOfMatrixList` +# and `FieldOfMatrixGroup`, then `DegreeFFE` will not be important anymore. +InstallOtherMethod( DegreeFFE, + [ "IsMatrixObj and IsFFECollColl" ], + mat -> DegreeOverPrimeField( BaseDomain( mat ) ) ); diff --git a/read.g b/read.g index abe27b6..1acdfa5 100644 --- a/read.g +++ b/read.g @@ -16,3 +16,7 @@ ReadPackage("forms", "lib/forms.gi"); ReadPackage("forms", "lib/recognition.gi"); ReadPackage("forms", "lib/classic.gi"); ReadPackage("forms", "lib/recognition_new.gi"); + +if IsBound( ConformalSymplecticGroup ) then + ReadPackage("forms", "lib/conformal.gi"); +fi; diff --git a/tst/adv/classic.tst b/tst/adv/classic.tst index 0ade472..f2b7faa 100644 --- a/tst/adv/classic.tst +++ b/tst/adv/classic.tst @@ -1,4 +1,5 @@ -#@local is_equal, q, F, d, es, e, g, stored, pi, permmat, form, gg, F2, mat +#@local is_equal, q, F, d, es, e, g, filters, filt, stored, pi, permmat +#@local form, gg, F2, mat gap> START_TEST( "Forms: classic.tst" ); @@ -164,29 +165,53 @@ gap> for q in [ 2, 3, 4, 5, 7, 8, 9, 11, 13, 16, 25 ] do > od; # Test the creation of symplectic groups. +gap> if IsBound( ConformalSymplecticGroup ) then +> # Support for matrix objects was added together with this function, +> # https://github.com/gap-system/gap/pull/6213. +> # Once we know a GAP version that decides the availability, +> # the version number can be used for the distinction. +> filters:= [ IsPlistRep, IsPlistMatrixRep ];; +> else +> filters:= [ IsPlistRep ];; +> fi; gap> for q in [ 2, 3, 4, 5, 7, 8, 9, 11, 13, 16, 17, 19, 23, 25 ] do > F:= GF(q); > for d in [ 2, 4 .. 8 ] do -> g:= SymplecticGroup( d, q ); -> stored:= InvariantBilinearForm( g ).matrix; -> pi:= PermutationMat( (1,2), d, F ); -> permmat:= pi * stored * TransposedMat( pi ); -> form:= BilinearFormByMatrix( stored, F ); -> gg:= SymplecticGroup( d, q, permmat ); -> if not ( is_equal( g, SymplecticGroup( g ) ) and -> ( is_equal( g, SymplecticGroup( stored ) ) or -> BaseDomain( stored ) <> F ) and -> is_equal( g, SymplecticGroup( form ) ) and -> is_equal( g, SymplecticGroup( d, q, g ) ) and -> is_equal( g, SymplecticGroup( d, q, stored ) ) and -> is_equal( g, SymplecticGroup( d, q, form ) ) and -> is_equal( g, SymplecticGroup( d, F, g ) ) and -> is_equal( g, SymplecticGroup( d, F, stored ) ) and -> is_equal( g, SymplecticGroup( d, F, form ) ) and -> IsSubset( gg, GeneratorsOfGroup( gg ) ) and -> IsSubset( g, List( GeneratorsOfGroup( gg ), x -> x^pi ) ) ) then -> Error( "problem with Sp(", d, ",", q, ")" ); -> fi; +> for filt in filters do +> PushOptions( rec( ConstructingFilter:= filt ) ); +> +> g:= SymplecticGroup( d, q ); +> if filt <> IsPlistRep and not filt( One( g ) ) then +> Error( "wrong repres. of matrices", [ q, d, filt ] ); +> fi; +> stored:= InvariantBilinearForm( g ).matrix; +> if filt <> IsPlistRep and not filt( stored ) then +> Error( "wrong repres. of matrices" ); +> fi; +> pi:= Matrix( PermutationMat( (1,2), d, F ), stored ); +> permmat:= pi * stored * TransposedMat( pi ); +> form:= BilinearFormByMatrix( stored, F ); +> gg:= SymplecticGroup( d, q, permmat ); +> if filt <> IsPlistRep and not filt( One( gg ) ) then +> Error( "wrong repres. of matrices" ); +> fi; +> if not ( is_equal( g, SymplecticGroup( g ) ) and +> ( is_equal( g, SymplecticGroup( stored ) ) or +> BaseDomain( stored ) <> F ) and +> is_equal( g, SymplecticGroup( form ) ) and +> is_equal( g, SymplecticGroup( d, q, g ) ) and +> is_equal( g, SymplecticGroup( d, q, stored ) ) and +> is_equal( g, SymplecticGroup( d, q, form ) ) and +> is_equal( g, SymplecticGroup( d, F, g ) ) and +> is_equal( g, SymplecticGroup( d, F, stored ) ) and +> is_equal( g, SymplecticGroup( d, F, form ) ) and +> IsSubset( gg, GeneratorsOfGroup( gg ) ) and +> IsSubset( g, List( GeneratorsOfGroup( gg ), x -> x^pi ) ) ) then +> Error( "problem with Sp(", d, ",", q, ") for ", filt ); +> fi; +> +> PushOptions( rec( ConstructingFilter:= fail ) ); +> od; > od; > od; @@ -232,4 +257,4 @@ gap> _IsEqualModScalars( mat, NullMat( 3, 2, GF(5) ) ); false ## -gap> STOP_TEST( "classic.tst" ); +gap> STOP_TEST( "Forms: classic.tst" ); diff --git a/tst/adv/conformal.tst b/tst/adv/conformal.tst new file mode 100644 index 0000000..859c2d2 --- /dev/null +++ b/tst/adv/conformal.tst @@ -0,0 +1,74 @@ +#@local is_equal, q, F, d, filt, g, stored, pi, permmat, form, gg, pg, sp + +gap> START_TEST( "Forms: conformal.tst" ); + +# Provide an auxiliary function (until GAP's '=' gets fast). +gap> is_equal:= function( G1, G2 ) +> return IsSubset( G1, GeneratorsOfGroup( G2 ) ) and +> IsSubset( G2, GeneratorsOfGroup( G1 ) ); +> end;; + +# Test the creation of conformal symplectic groups. +gap> for q in [ 2, 3, 4, 5, 7, 8, 9, 11, 13, 16, 17, 19, 23, 25 ] do +> F:= GF(q); +> for d in [ 2, 4 .. 8 ] do +> for filt in [ IsPlistRep, IsPlistMatrixRep ] do +> PushOptions( rec( ConstructingFilter:= filt ) ); +> +> g:= ConformalSymplecticGroup( d, F ); +> if filt <> IsPlistRep and not filt( One( g ) ) then +> Error( "wrong repres. of matrices", [ q, d, filt ] ); +> fi; +> stored:= InvariantBilinearFormUpToScalars( g ).matrix; +> if filt <> IsPlistRep and not filt( stored ) then +> Error( "wrong repres. of matrices" ); +> fi; +> pi:= Matrix( PermutationMat( (1,2), d, F ), stored ); +> permmat:= pi * stored * TransposedMat( pi ); +> form:= BilinearFormByMatrix( stored, F ); +> gg:= ConformalSymplecticGroup( d, F, permmat ); +> if filt <> IsPlistRep and not filt( One( gg ) ) then +> Error( "wrong repres. of matrices" ); +> fi; +> if not ( is_equal( g, ConformalSymplecticGroup( g ) ) and +> ( is_equal( g, ConformalSymplecticGroup( stored ) ) or +> BaseDomain( stored ) <> F ) and +> is_equal( g, ConformalSymplecticGroup( d, q ) ) and +> is_equal( g, ConformalSymplecticGroup( form ) ) and +> is_equal( g, ConformalSymplecticGroup( d, q, g ) ) and +> is_equal( g, ConformalSymplecticGroup( d, q, stored ) ) and +> is_equal( g, ConformalSymplecticGroup( d, q, form ) ) and +> is_equal( g, ConformalSymplecticGroup( d, F, g ) ) and +> is_equal( g, ConformalSymplecticGroup( d, F, stored ) ) and +> is_equal( g, ConformalSymplecticGroup( d, F, form ) ) and +> IsSubset( gg, GeneratorsOfGroup( gg ) ) and +> IsSubset( g, List( GeneratorsOfGroup( gg ), x -> x^pi ) ) ) then +> Error( "problem with CSp(", d, ",", q, ")" ); +> fi; +> +> if Size( g ) < 10^7 and filt = IsPlistRep then +> # Change this as soon as also `IsPlistMatrixRep` works! +> pg:= ConformalSymplecticGroup( IsPermGroup, d, q ); +> if Size( g ) <> Size( pg ) then +> Error( "problem with CSp(IsPermGroup, ", d, ",", q, ")" ); +> fi; +> fi; +> +> sp:= SymplecticGroup( d, q, permmat ); +> if filt <> IsPlistRep and not filt( One( sp ) ) then +> Error( "wrong repres. of matrices" ); +> fi; +> g:= ConformalSymplecticGroup( sp ); +> # if not IsSubset( g, sp ) then # make this fast in the GAP library +> if ForAny( GeneratorsOfGroup( sp ), x -> not x in g ) then +> Error( "problem with CSp(", d, ",", q, ")" ); +> fi; +> +> PushOptions( rec( ConstructingFilter:= fail ) ); +> od; +> od; +> od; + +## +gap> STOP_TEST( "Forms: conformal.tst" ); + diff --git a/tst/testall.g b/tst/testall.g index 8667153..1b6bd66 100644 --- a/tst/testall.g +++ b/tst/testall.g @@ -6,6 +6,11 @@ if not IsBound(DescribesInvariantQuadraticForm) then Add( exclude, "adv/classic.tst" ); fi; +if not IsBound(ConformalSymplecticGroup) then + # conformal.tst cannot run + Add( exclude, "adv/conformal.tst" ); +fi; + TestDirectory(DirectoriesPackageLibrary("forms", "tst"), rec( exitGAP := true,