reworked the proposal

Now the declaration of `CSp` and those methods for it that do not
involve forms will be added to the GAP library.
Also, the implementation of `Sp` in GAP admits already an optional filter
that defines the representation of the matrices, and the delegation
between its methods has been changed as for `CSp` (the methods with
argument `q` delegate to those with argument `GF(q)`, not the other
way round).

For this pull request, this means that

- the files involving code and tests involving `CSp` are read only if
  GAP provides the variable `CSp`,
- the delegation between methods for `Sp` that are provided by the
  Forms package has been changed as well,
- the methods in the Forms package now support a `baseDomain` component
  in the attributes describing invariant forms,
- calls of `FieldOfMatrixGroup` are replaced by access to the new
  `baseDomain` component of form records where applicable
  (for backwards compatibility with older GAP versions, the helper
  function `Forms_FieldOfDefinition` calls `FieldOfMatrixGroup`
  if no `baseDomain` component is available).

Author: ThomasBreuer

init.g

@@ -14,4 +14,7 @@
 
 ReadPackage("forms","lib/forms.gd");
 ReadPackage("forms","lib/recognition.gd");
-ReadPackage("forms","lib/conformal.gd");
+
+if IsBound( ConformalSymplecticGroup ) then
+  ReadPackage("forms","lib/conformal.gd");
+fi;

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,
@@ -832,8 +832,8 @@ end );
 #############################################################################
 ##
 #O  SymplecticGroupCons( <filter>, <form> )
-#O  SymplecticGroupCons( <filter>, <d>, <q>, <form> )
 #O  SymplecticGroupCons( <filter>, <d>, <R>, <form> )
+#O  SymplecticGroupCons( <filter>, <d>, <q>, <form> )
 ##
 ##  '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,15 +907,32 @@ 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( <filt>, <d>, <F>, <form> )
+##
+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
+    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;
 
@@ -928,9 +945,9 @@ InstallMethod( SymplecticGroupCons,
     # 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 <form> and <wanted> differ" );
     fi;
@@ -957,18 +974,13 @@ InstallMethod( SymplecticGroupCons,
     return gg;
 end );
 
-
-#############################################################################
-##
-#M  SymplecticGroupCons( <filt>, <d>, <R>, <form> )
-##
 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 +989,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 ) );

lib/conformal.gd

@@ -1,152 +1,28 @@
 #############################################################################
 ##
-#A  InvariantBilinearFormUpToScalars( <matgrp> )
+##  conformal.gd          'Forms' package
 ##
-##  <#GAPDoc Label="InvariantBilinearFormUpToScalars">
-##  <ManSection>
-##  <Attr Name="InvariantBilinearFormUpToScalars" Arg='matgrp'/>
-##
-##  <Description>
-##  This attribute describes a bilinear form that is invariant up to scalars
-##  under the matrix group <A>matgrp</A>.
-##  The form is given by a record with the component <C>matrix</C>
-##  which is a matrix <M>J</M> such that for every generator <M>g</M> of
-##  <A>matgrp</A> the equation <M>g \cdot J \cdot g^{tr} = \lambda(g) J</M>
-##  holds, for <M>\lambda(g)</M> in the
-##  <Ref Attr="FieldOfMatrixGroup" BookName="ref"/> value of <A>matgrp</A>.
-##  </Description>
-##  </ManSection>
-##  <#/GAPDoc>
-##
-DeclareAttribute( "InvariantBilinearFormUpToScalars", IsMatrixGroup );
-
-
-#############################################################################
-##
-#P  IsFullSubgroupGLRespectingBilinearFormUpToScalars( <matgrp> )
-##
-##  <#GAPDoc Label="IsFullSubgroupGLRespectingBilinearFormUpToScalars">
-##  <ManSection>
-##  <Prop Name="IsFullSubgroupGLRespectingBilinearFormUpToScalars"
-##  Arg='matgrp'/>
-##
-##  <Description>
-##  This property tests whether the matrix group <A>matgrp</A> is the full
-##  subgroup of GL respecting, up to scalars, the form stored as the value of
-##  <Ref Attr="InvariantBilinearFormUpToScalars"/> for <A>matgrp</A>.
-##  </Description>
-##  </ManSection>
-##  <#/GAPDoc>
-##
-DeclareProperty( "IsFullSubgroupGLRespectingBilinearFormUpToScalars",
-    IsMatrixGroup );
-
-InstallTrueMethod( IsGroup,
-    IsFullSubgroupGLRespectingBilinearFormUpToScalars );
-
 
 #############################################################################
 ##
 #O  ConformalSymplecticGroupCons( <filter>, <form> )
 #O  ConformalSymplecticGroupCons( <filter>, <matrix> )
 #O  ConformalSymplecticGroupCons( <filter>, <G> )
-#O  ConformalSymplecticGroupCons( <filter>, <d>, <R> )
 #O  ConformalSymplecticGroupCons( <filter>, <d>, <R>, <form> )
 #O  ConformalSymplecticGroupCons( <filter>, <d>, <R>, <matrix> )
 #O  ConformalSymplecticGroupCons( <filter>, <d>, <R>, <G> )
-#O  ConformalSymplecticGroupCons( <filter>, <d>, <q> )
 #O  ConformalSymplecticGroupCons( <filter>, <d>, <q>, <form> )
 #O  ConformalSymplecticGroupCons( <filter>, <d>, <q>, <matrix> )
 #O  ConformalSymplecticGroupCons( <filter>, <d>, <q>, <G> )
 ##
-DeclareConstructor( "ConformalSymplecticGroupCons", [ IsGroup, IsBilinearForm ] );
-DeclareConstructor( "ConformalSymplecticGroupCons", [ IsGroup, IsMatrixOrMatrixObj ] );
-DeclareConstructor( "ConformalSymplecticGroupCons", [ IsGroup, IsGroup ] );
-DeclareConstructor( "ConformalSymplecticGroupCons", [ IsGroup, IsPosInt, IsRing ] );
-DeclareConstructor( "ConformalSymplecticGroupCons", [ IsGroup, IsPosInt, IsRing, IsBilinearForm ] );
-DeclareConstructor( "ConformalSymplecticGroupCons", [ IsGroup, IsPosInt, IsRing, IsMatrixOrMatrixObj ] );
-DeclareConstructor( "ConformalSymplecticGroupCons", [ IsGroup, IsPosInt, IsRing, IsGroup ] );
-DeclareConstructor( "ConformalSymplecticGroupCons", [ IsGroup, IsPosInt, IsPosInt ] );
-DeclareConstructor( "ConformalSymplecticGroupCons", [ IsGroup, IsPosInt, IsPosInt, IsBilinearForm ] );
-DeclareConstructor( "ConformalSymplecticGroupCons", [ IsGroup, IsPosInt, IsPosInt, IsMatrixOrMatrixObj ] );
-DeclareConstructor( "ConformalSymplecticGroupCons", [ IsGroup, IsPosInt, IsPosInt, IsGroup ] );
-
-
-#############################################################################
-##
-#F  ConformalSymplecticGroup( [<filt>, ]<d>, <q>[, <form>] ) conf. sympl. gp.
-#F  ConformalSymplecticGroup( [<filt>, ]<d>, <R>[, <form>] ) conf. sympl. gp.
-#F  ConformalSymplecticGroup( [<filt>, ]<form> )   conformal symplectic group
-#F  CSp( [<filt>, ]<d>, <q>[, <form>] )            conformal symplectic group
-#F  CSp( [<filt>, ]<d>, <R>[, <form>] )            conformal symplectic group
-#F  CSp( [<filt>, ]<form> )                        conformal symplectic group
-##
-##  <#GAPDoc Label="ConformalSymplecticGroup">
-##  <ManSection>
-##  <Heading>ConformalSymplecticGroup</Heading>
-##  <Func Name="ConformalSymplecticGroup" Arg='[filt, ]d, R[, form]'
-##   Label="for dimension and a ring"/>
-##  <Func Name="ConformalSymplecticGroup" Arg='[filt, ]d, q[, form]'
-##   Label="for dimension and field size"/>
-##  <Func Name="ConformalSymplecticGroup" Arg='[filt, ]form'
-##   Label="for form"/>
-##  <Func Name="CSp" Arg='[filt, ]d, R[, form]'
-##   Label="for dimension and a ring"/>
-##  <Func Name="CSp" Arg='[filt, ]d, q[, form]'
-##   Label="for dimension and field size"/>
-##  <Func Name="CSp" Arg='[filt, ]form'
-##   Label="for form"/>
-##
-##  <Description>
-##  constructs a group isomorphic to the conformal symplectic group
-##  CSp( <A>d</A>, <A>R</A> ) of those <M><A>d</A> \times <A>d</A></M>
-##  matrices over the ring <A>R</A> or the field with <A>q</A> elements,
-##  respectively,
-##  that respect a fixed nondegenerate symplectic form up to scalars,
-##  in the category given by the filter <A>filt</A>.
-##  <P/>
-##  Currently only finite fields <A>R</A> are supported.
-##  <P/>
-##  If <A>filt</A> is not given it defaults to
-##  <Ref Filt="IsMatrixGroup" BookName="ref"/>,
-##  and the returned group is the conformal symplectic group itself.
-##  Another supported value for <A>filt</A> is
-##  <Ref Filt="IsPermGroup" BookName="ref"/>;
-##  in this case, the argument <A>form</A> is not supported.
-##  <P/>
-##  If the arguments describe a matrix group over a finite field then
-##  the desired bilinear form can be specified via <A>form</A>,
-##  which can be either a matrix
-##  or a form object in <Ref Filt="IsBilinearForm"/>
-##  or a group with stored
-##  <Ref Attr="InvariantBilinearForm" BookName="ref"/> or
-##  <Ref Attr="InvariantBilinearFormUpToScalars"/> value
-##  (and then this form is taken).
-##  <P/>
-##  A given <A>form</A> determines and <A>d</A>, and also <A>R</A>
-##  except if <A>form</A> is a matrix that does not store its
-##  <Ref Attr="BaseDomain" Label="for a matrix object" BookName="ref"/> value.
-##  These parameters can be entered, and an error is signalled if they do
-##  not fit to the given <A>form</A>.
-##  <P/>
-##  If <A>form</A> is not given then a default is chosen as described in the
-##  introduction to Section <Ref Sect="Classical Groups" BookName="ref"/>.
-##  <P/>
-##  <Example><![CDATA[
-##  gap> g:= ConformalSymplecticGroup( 4, 2 );
-##  CSp(4,2)
-##  gap> Size( g );
-##  720
-##  gap> StructureDescription( g );
-##  "S6"
-##  gap> ConformalSymplecticGroup( IsPermGroup, 4, 2 );
-##  Perm_CSp(4,2)
-##  ]]></Example>
-##  </Description>
-##  </ManSection>
-##  <#/GAPDoc>
-##
-DeclareGlobalFunction( "ConformalSymplecticGroup" );
-
-DeclareSynonym( "CSp", ConformalSymplecticGroup );
-
+##  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 );