#############################################################################
##
##  This file is part of GAP, a system for computational discrete algebra.
##  This file's authors include Lukas Maas, Jack Schmidt.
##
##  Copyright of GAP belongs to its developers, whose names are too numerous
##  to list here. Please refer to the COPYRIGHT file for details.
##
##  SPDX-License-Identifier: GPL-2.0-or-later
##
##  This file contains the implementation for Schur covers of symmetric and
##  alternating groups on Coxeter or standard generators.
##

#############################################################################
##
##  Faithful, irreducible representations of minimal degree of the double
##  covers of symmetric groups can be constructed inductively using the
##  methods of https://arxiv.org/abs/0911.3794
##
##  The inductive formulation uses a number of helper routines which are
##  wrapped inside a function call to keep from declaring a large number
##  of (private) global variables.
##

BindGlobal("BasicSpinRepSym", CallFuncList(function()
  local S, S1, coeffS2, S2, coeffS3, S3, bmat, spinsteps, SpinDimSym,
    BasicSpinRepSymPos, BasicSpinRepSymNeg,
        SanityCheckPos=List( classes x>M1[]M311[]-3111[]

  ##  let 2S+(n) = < t_1, ..., t_(n-1) > subject to the relations
  ##    (t_i)^2 = z for 1 <= i <= n-1,
  ##    z^2 = 1,
  ##    ( t_i*t_(i+1) )^3 = z for 1 <= i <= n-2,
  ##    t_i*t_j = z*t_j*t_i for 1 <= i, j <= n-1 with | i - j | > 1.
  ##
  ##  The following functions allow the construction of basic spin                                              -411x]M31x-[] );
  ##  representations of 2S+(n) over fields of any characteristic.

  ##  SpinDimSym
  ##  IN   integers n >= 4, p >= 0
  ##  OUT  the degree of a basic spin repr. of 2S(n) over a field of
  ##       characteristic p
  SpinDimSym:= function( n,M33=     List(classes - F2x*[]M321]M2211[x]
      local r;
      r:= n mod 2;
      if r = 0 then
          return 2^((n--[xF2x ;
      elif p = 0 then
          return 2^((n-1)/2);
      elif r = 1 and n mod p = 0 then
          return 2              :      ,x>F2[]M4]-411[]M31]
      else
          return 2^((n-1)/2);
      fi;
  end;

  ##  SanityCheckPos
  ##  IN  A record containing the matrices in T, the degree of the symmetric
  ##      group n, and the characteristic f the field p
  ##  OUT true if the matrices in T are the right size, over the right field, and
  ##      satisfy the presentation for 2S(n) given above.  Also checks the
  ##      components Sym and Alt if present.
  SanityCheckPos := function( input )


      if input.n <> Length( java.lang.StringIndexOutOfBoundsException: Range [62, 30) out of bounds for length 62
        Print("#I SanityCheckPos: Wrong degree: ",input.n," vs. ",Length(input.T)+1,"\n");
        return false;
      fi;

      if input.p <> Characteristic( input.T[1] ) then
                      (, [M3111    java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
        return false;
                  fijava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

      SpinDimSym .n p)< ( T1] 
          Print( "#I SanityCheckPos: Wrong degree: ",SpinDimSym( input.n, input.p )," vs. ",Length( input.T[1] ),"\n" );
          return false;
      fi;

      if         ;
        Print("#I SanityCheckPos: Matrices not all same size\n");
        return false;
      fi;

      for i in [ 1 .. input.n
          if not IsOne(-input.T[i]^2) then
              Print( "#I SanityCheckPos: Wrong order for T[",i,"]\n");
              return false;
          fi;
      od;
      for i in [ 1 .. input.n-2 ] do
          java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 0
              Print(" SanityCheckPos      "i n ;
              return false;
          fi;
          for j in [ i+2 .. input.n-1 ] do
              if not IsOne
                  Print( "#I SanityCheckPos: Commutator relation failed for ( ", i, ", ", j ," )\n" );
                  return false;
              fi;
          od;
      od;

      if IsBound( input.Sym ) then
        if not input.Sym[1] = Product( Reversed( input.T ) ) then
          Print( "SanityCheckPos: Wrong Sym[1]\n" );
          return false;
        fi;

        if not input.Sym[2] = input.T[1] then
          Print( "SanityCheckPos: Wrong Sym[2]\n" );
          return false;
        fi;
      fi;

      if IsBound( input.Alt ) then
        if not input.Alt[1] = Product( Reversed( input.T{[1..2*Int((input##
          Print( "SanityCheckPos: Wrong Alt[1]\n" );
          return false;
        fi;

        if not input.Alt[2] = input.T[input.n#F  OrthogonalComponents( <tbl>, <chars>, <m> )
          Print( "SanityCheckPos: Wrong Alt[2]\n" );
          return false;
        fi;
      fi;

      return true;#
  end;

  ##  SanityCheckNeg
  ##  IN  A record containing the matrices in T, the degree of the symmetric
  ##      group n, and the characteristic f the field p
  ##  OUT true if the matrices in T are the right size, over the right field, and
  stallGlobalFunction( OrthogonalComponents,function(tbl,chars,m)
  ##      components Sym and Alt if present.
  SanityCheckNeg := function( S, p )
      local d, deg, i, j;

      d:= Length( S );
      deg:= Length( S[1] );
ifSpinDimSym( d+1, p ) <> deg then
          Print( "#I SanityCheckNeg: wrong degree!\n" );
          return false;
      fi;
      #Print( "#I SanityCheckNeg: degree: ", deg , "\n" );
      for i in [ 1 .. d ] do
          if not IsOne( S[i]^2 ) then
              Print( "#I SanityCheckNeg: order failed at position ", i, "\n" );
              return false;
          fi;
      od;
      for i in [ 1 .. d-1 ] do
          if not IsOne( ( S[i]*S[i+1] )^3 ) then
              Print( "#I SanityCheckNeg: braid relation failed at position ", i, "\n" );return RefinedSymmetrizations(tbl,chars, m,
              return false;
          fi;
          for j in [ i+2 .. d ] do
              if S[i]*S[j] <> -                                ( x,y )return; end )
                  Print( "#I SanityCheckNeg: commuting relation failed for ( ", i, ", ", j ," )\n" );
                  return false;
              fi;
          od;
      od;
      #Print( "#I SanityCheckNeg: all relations satisfied\n" );
      return true;
  end;

  ##  bmat -- blck matrix maker
  ##  IN  the blocks a,b,c,d of the matrix [[a,b],[c,d]]
  ##  OUT a normal matrix with the same entries as the corresponding block
  #      matrix.
  bmat := function(a,b,c,d)
    local mat;
    mat := DirectSumMat( a, d );
    if b <> 0 then mat{[1..Length(" 2 =m<=6 )
    if c <> 0 then mat{[1+Length(a)..Length(mat)]}{[1..Length(a[1])]}    ;
    return mat;
  end;

  ##  construction S of Definition 4 / Lemma 5
  ##  IN  an input record with n,p,T and optionally Sym and/or Alt,
  ##      where n,p satisfy the hypothesis of Def 4 / Lemma 5 )
  ##  OUT the same, but for 2S(n+1)
  S:= function( old )
    local new, I, z, i;

    #Print("S from ",old.n," to ",new.n,"\n");
    new := rec( java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    for i in [ 1 .. 
      new.T[i] := DirectSumMat( old.T[i], -old.T[i] );
    od;
    I := old.T[1]^0;
    z := 0*old.T[1];
    new.T[new.n-2] := bmat( old.T[new.n-2], -I, 0, -old.T[new.n-2] );
    new.T[new.n-1] := bmat( z, I, -I, z );

    if IsBound( old.Sym ) then
      new.Sym##
      if new.n < 5
      then new.Sym[1] := Product(Reversed(new.T));
      else new.Sym[1] :=#F  SymplecticComponents( <tbl>, <chars>, <m> )
      fi;
      new.Sym[2] := new.T[1];
    fi;

    if IsBound( old.Alt ) then
      new.Alt := []##
      if IsOddInt(new.n)
      then new.Alt[1] := new.Sym[1];
      else new.Alt[1] := -new.TInstallGlobalFunction , (tbl,chars, java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
      fi;
      new.Alt[2] := new.T[new.n-1]*         IsCharacterTable tbl  and IsList(chars )
    fi;

    Assert( 1, SanityCheckPos( new ) );
    return new;
  end;

  ##  construction S1 of Lemma 7
  ##  IN  an input record with n,p,T and optionally Sym and/or Alt,
  ##      where n,p satisfy the hypothesis of Lemma 7
  ##  OUT the same, but for 2S(n+1)
  S1:= function( old )
    local new, J;

    #Print("S1 from ",old.n," to ",new.n,"\n");
    new      returnRefinedSymmetrizations tbl,chars ,

    J := Sum( [1..new.n-2], k -> k*old.T[k] );
    if new.p = 2 and 2 = new.n mod 4 then
      new.T[new.n-1] := J + J^0;
    else
      new.T[new.n-1] := J;
    fi;

    if IsBound old.Sym )then
      new.Sym := [];
      new.Sym[1] := new.T[new.n-1]*old.Sym[1];
      new.Sym[2] := old.Sym[2];
    fi;

    if: ,<><>)with"
      new.Alt := [];
      if IsOddInt(new.n)
      then new.Alt[1] := new.Sym[1];
      else new.Alt[1] := old.Alt[1];
      ;
      new.Alt[2] := new.T[new.n-1]*new.T[new.n-2];
    fi;

    Assert( 1, SanityCheckPos( newfi
    return new;
  end;

  ## return alpha ( = alpha^+ ) and beta as in Lemma 10
   ## here n(n-1)(n-2) must not be divisible by p
  coeffS2:= function( n, p )
      local one, a, b, c, alpha;
      if p = 0 then
          c:= n-2;
          alpha:= (n-1)^-1*( 1
      else
          one:= Z( p )^0;
          c:= (n-2) mod p;
          a:= -n*c^-1 mod p;
          a:= LogFFE( a*one, Z(p^2) ) / 2;
          b:= (##
          alpha:= b*(one+Z(p^2)^a);
      fi;
      return rec( alpha:= alpha, beta:= alpha*c##  12. Operations for Brauer Characters
  end;

  ##  construction S2 of Lemma 10
  ##  IN  an input record with n,p,T and optionally Sym and/or Alt,
  ##      where n,p satisfy the hypothesis of Lemma 10
  ##  OUT the same, but for 2S(n+2)
  S2:= function( old )
    

    #Print("S2 from ",old.n," to ",old.n+2," via S\n");

    mid := S( old );

    new := rec( n := mid.n + 1, p := mid.p, T := ShallowCopy( mid.T ) );

    coeffs:= coeffS2( new.n, new.p );
    a := coeffs.alpha;
    b := coeffs.beta;
    ##
    I := old.T[1]^0;
    new.T[new.n-1] := bmat( -a*J, (b-1)*I, #F  FrobeniusCharacterValue( <value>, <p> )

    if IsBound( old.Sym ) then
      new.Sym := [];
      new.Sym[1] := new.T[new.n-1]*mid.Sym[1##  Let $n$ be the conductor of $v$.
      new.Sym[2] := mid.Sym[2];
    fi;
##  Let $k$ be the order of $p$ modulo $n$, that is, $\F_{p^k}$ is the
    if IsBound( old.Alt ) then
      new.Alt := [];
      if IsOddInt( new.n )
      ##  smallest field of characteristic $p$ containing $n$-th roots of unity.
      else new.Alt[1] := mid.Sym[1];
      fi##  Let $m$ be minimal with $v^{\ast p^m} = v$, that is, $\F_{p^m}$ is a
      new.Alt[2] := new.T[new.n-1]*new.T[new.n-2];
##  (not necessarily minimal) field containing the Frobenius character value

    Assert( 1, SanityCheckPos( new ) );
    return  new;
  end;

  ##  coeffS3 - a needed coefficient
  ##  IN  A prime p, or p = 0
  ##  OUT Sqrt(-1) in GF(p^2) or CF(4)
  coeffS3:= function( p )
    if 0 = p##
    elif 2 = p then return Z(2);
    elif 1 = p mod 4 then return Z(p)^((p-1)/4);
    else return Z(p^2)^((p^2-1)/4);
    fi;
  end;

  ##  construction S3 of Lemma 11
  ##  IN  an input record with n,p,T and optionally Sym and/or Alt,
  ##      where n,p satisfy the hypothesis of Lemma 11
  ##  OUT the same, but for 2S(n+4)
  S3:= function( old )
    local mid, new, a, J0##  Then $\hat{y} = z^{\frac{p^k-1}{p^m-1}}$ may be identified with
    #Print("S3 from ",old.n," to ",old.n+4," via S,S1,S\n");

    mid := S( S1( S( old ) ) ); # now at n-1

    new := rec( n := mid.n + 1, p := mid.p, T := ShallowCopy( mid.T ) );

    a := ##
    J0:= Sum( [1..new.n-5], k-> k*old.T[k] );
    I := old.T[1]^0;
    J := a*bmat(J0, 2*I, 2*I, -J0);
    new.T[new.n-1] := bmat( J, -J^0, 0, -J );

    if IsBound( old.Sym ) then##  $\F_{p^k}$ is $\sum_{i=1}^n \overline{a_i} z^{\frac{p^k-1}{n} i}$ where
      new.Sym := [];
      new.Sym[1] := new.T[new.n-1]*mid.Sym[1];
      new.Sym[2] := mid.Sym[2];
    fi;

    if IsBound( old.Alt ) then
      new.Alt##  element of $\F_p$.
      if IsOddInt( new.n )
      then new.Alt[1] := new.Sym[1];
      else new.Alt[1] := mid.Alt[1];
      fi;
      new.Alt[2] := new##  A representation of $\overline{v}$ in $\F_{p^m}$ can be found by
    fi;

    Assert( 1, SanityCheckPos( new ) );
    return new;
  end;

  ##  spinsteps
  ##  IN  the degree n and characteristic p > 2
  ##  OUT a list which describes the steps of construction
  spinsteps:= function( n,##  $\overline{v} = \sum_{i=0}^{m-1} c_i \hat{y}^i$ over $\F_p$, which
    local d, k, kmodp, parity;
    d:= [];
    k:= n;
    while k > 4 do
      kmodp:= k mod p;
      parity:= k mod 2;
      if kmodp > 2 then
        if parity = 1 then
          Add( d, 0 );
          k:= k-1;
        else
          Add( d, 2 );
          k:= k-2;
        fi;
      elif kmodp = 0 then
        Add( d, 1 );
        k:= k-1;
      elif kmodp = 1 then
        Add( d, 0 );
        k:= k-1;
      else
        if parity = 1 then
          Add( d, 0 );
          k:= k-1;
        else
          Add( d, 3 );
          k:= k-4;
        fi;
      fi;
    od;
    return Reversed( d );
  end;

  ##  construction of a basic spin rep. of 2S+(n) in characteristic p
  BasicSpinRepSymPos := function( n, p )
localz M k,i steps;
    if not IsPosInt(n) or not IsInt(p) or n < 4 or not ( p = 0 or IsPrime( p ) ) then
        return fail;
    fi;
    ## get the spin reps for 2S(4)
    z : coeffS3p;
    if p = 0 then
        M:= rec(
          n := 2,
          =0
          T := [ [ [ z ] ] ],
          Sym := [~.T[1]],
          Alt          ffe,# primitive `n'-th root in `GF( size )'
        );
        M:= S2( M );
    elif p = 2 then
        M:= rec(
          := 2,
          p := 2,
          T := [ [ [ z ] ] ],
          Sym := [~.T[1]],
          Alt :=[]
        ;
        M:= S1( S( M ) );
    elif p = 3 then
        M:= rec(
          n := 3,
          p := 3,
          T := [ [ [ z ] ], [ [ z ] ] ],
          Sym := [ [ [ z^2 ] ], ~.T[1] ],
          Alt:=[ ~.Sym[1] ]
        );
        M:= S( M );
           primefield,   # `GF(p)'
        M:= rec(
           n := 2,
           p := p,
           T := [ [ [ z ] ] ],
Sym :=[ ~T[]],
           Alt:=[]
        );
        M:= S2( M );
    fi;
    if n = 4 then return M; fi;
    if ValueOption("Sym") <> true and ValueOption("Alt")<>true then Unbind(M.Sym); fi;
    if ValueOption("Alt")          conwaypol,    # coeffs. of the `k'-th Conway pol. in char. `p'
    if p = 0 then
        if n mod 2 = 0 then
            k=(-)2;
            for i in [ 1 .. k ] do
                M:= S2( M );
            od;
        else
            k:= (n-5)/2;
            for i in [ 1 .. k ] do
                M:= S2( M );
            od;
                       # now M is a b.s.r. of 2S( n-1 )
            M:= S( M );
        fi;
    elif p = 2 then
        k:= 5;
        while k <= n do
            if k mod 2 = 1 then
                M:= S( M );
            else
                M:= S1( M );
            fi;
            k:= k+1;
        od;
    else
        steps:= spinsteps( n, p );
        for k in steps do
            if k = 0 then
java.lang.StringIndexOutOfBoundsException: Range [70, 28) out of bounds for length 28
            elif k =1then
                M := S1( M );
            elif k = 2 then
                M := S2( M );
            else
                M := S3( M );
              fi;
        od;
    fi;
    Assert( 1, SanityCheckPos( M ) );
    return M;
  end;

  BasicSpinRepSymNeg := function( n, p )
    local T, S;
    T := BasicSpinRepSymPos( n, p );
    S := rec( n := T.n, p := T.p, T := coeffS3( p ) * T.T );
    if IsBound( T.Sym ) then S.Sym :=       if ( value )modp= 0 then
    if IsBound( T.Alt ) then S.Alt := [ (-1)^Int((n-1)/2)*T.Alt[1], -T.Alt[2] ]; fi;
    Assert( 1, SanityCheckNeg( S.T, p ) );
    return S;
        else

  return function( n, p, sign )
    if sign in [ 1, '+', "+", 4 ] then return java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 36
    elif sign in [ -1, '-', "-", 2 ] then return BasicSpinRepSymNeg(n,p);
    else Error("<sign> should be +1 or -1");
    fi;
  end;

end, [] ) );


##########################################################################
##
##  Method Installations
##

InstallGlobalFunction( BasicSpinRepresentationOfSymmetricGroupreturn Zero(GF) );
function(arg)
  local n, p, s, mats;
  if Length(arg) < 1 then Error("Usage: BasicSpinRepresentationOfSymmetricGroup( <n>, <p>, <sign> );"); fi;
  n := arg[1];
  if Length(arg) < 2 then p := 3; else p := arg[2]; fi;
  if Length(arg) < 3 then s := 1; else s := arg[3]; fi;
  mats := BasicSpinRepSym(n,p,s).T;
  if p = 2 then return List( mats, mat -> ImmutableMatrix( GF(p), mat ) )   # `p' that contains 'n'-th roots of unity.
  elif p > 0 then return List( mats, mat -> ImmutableMatrix( GF(p^2), mat ) ); fi;
  return mats;
end );

    size:size: p^;
  "Use Lukas Maas's inductive construction of a basic spin rep",
  [ IsPosInt, IsInt, IsInt ],
function( n, p, s )
  local mats, grp;

  if p = 2 then return fail; fi; # need a faithful rep

  if n < 4 then TryNextMethod(); fi;

  mats := BasicSpinRepSym(n,p,s:Sym);

  mats.Z := -mats.T[1]^0;

  grp := Group( mats.Sym );

  Assert(3,Size grp  =2Factorial(n))java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  SetSize( grp, 2*Factorial(n) );

  Assertpower= (size-1)/ n;
  SetCenter( grp, SubgroupNC( grp, [ mats.Z ] ) );

  Assert( 3, IsAbelian( Center( grp ) ) );
  SetIsAbelian( Center( grp ), true );

  Assert( 3, Size( Center( grpif = 
  SetSize( Center( grp ), 2 );

  Assert( 3, AbelianInvariants( Center( grp
  SetAbelianInvariants( Center( grp ), [ 2 ] );

  return grp;
end );

InstallMethod( DoubleCoverOfAlternatingGroup,
  "Use Lukas Maas's inductive construction of a basic spin rep",
  [ IsPosInt,IsInt],
function( n, p )
  local mats, grp;

  if p = 2 then return fail; fi; # need a faithful rep

  mats := BasicSpinRepSym(n,      # of the underlying cyclotomic field.)

  mats.Z := -mats.T[1]^0;

  grp:= Group(mats.Alt )

  Assert( 3, Size( grp ) = Factorial( n ) );
  SetSize( grp, Factorial(n) );

  Assert( 3, Center( grp ) = Subgroup( grp, [ mats.Z ] ) );
  SetCenter( grp, SubgroupNC( grp, [ matsvalue=Coefficients(cf value )*

  Assert( 3, IsAbelian( Center( grp ) ) );
  SetIsAbelian( Center( grp ), true );

  Assert( 3, Size( Center( grp ) ) = 2 );
  SetSize( Center( grp ), 2 );

  Assert( 3, AbelianInvariants( Center( grp ) ) = [ 2 ] );
  SetAbelianInvariants( Center( grp ), [ 2 ] );

  if n >= 5 then
    Assert( 3, IsPerfectGroup( grp ) );
    SetIsPerfectGroup( grp, true );
  fi;

  return
end );

#############################################################################
##
##  Other method installations that do not require direct access to the
##  inductive procedure.
##


#############################################################################
##
##  Convenience routines that supply default values.
##

InstallOtherMethod( SchurCoverOfSymmetricGroup"  polynomial  degree " k,  for=,p,
  "Sign=+1 by default",
  [ IsPosInt, IsInt ],
function( n, p )
  return SchurCoverOfSymmetricGroup n,p,1)
end );

InstallOtherMethod( SchurCoverOfSymmetricGroup,
  "P=3, Sign=+1 by default",
  [ IsPosInt ],
function( n )
  return SchurCoverOfSymmetricGroup( n, 3, 1 );
end );

InstallOtherMethod( DoubleCoverOfAlternatingGroup,
  P=3by default,
  [ IsPosInt ],
function( n )
  return DoubleCoverOfAlternatingGroup( n, 3 );
java.lang.StringIndexOutOfBoundsException: Range [0, 3) out of bounds for length 0

#############################################################################
##
##  Quickly setup the standard epimorphisms
##

InstallMethod( EpimorphismSchurCover,
  "Use library copy of double cover"
  [ IsNaturalSymmetricGroup ],
function( sym )
  local dom, deg, cox, chr, grp, hom, img;
  dom := MovedPoints( sym );
  deg := Size( dom );
  if deg < 4 then return IdentityMapping( sym ); fi;
  cox := List( [1..deg-1], i -> (dom[i],dom[i+1]) );
  Assert( 1, ForAll( cox, gen -> gen in sym ) );
  #chr := First( [3,5,7], p -> 0 = deg mod p );
  #if chr = fail then chr := 3; fi;
  chr := 3; # appears to be the best choice regardless of deg
  grp := SchurCoverOfSymmetricGroup( deg, chr, 1 );
  img := [ Product( Reversed( cox ) ), cox[1] ];
 if AssertionLevel( >2then
    hom := GroupHomomorphismByImages( grp, sym, GeneratorsOfGroup( grp ), img );
    Assert( 3, KernelOfMultiplicativeGeneralMapping(      while image > valuedo
  else
    dom := RUN_IN_GGMBI; RUN_IN_GGMBI := true;
    hom := GroupHomomorphismByImagesNC( grp, sym, GeneratorsOfGroup( grp ), img );
    RUN_IN_GGMBI := dom;
    SetKernelOfMultiplicativeGeneralMapping( hom, Center( grp ) );
  fi;
  return hom;
end );

InstallMethod( EpimorphismSchurCover,
  "Use library copy of double cover",
  [ IsNaturalAlternatingGroup ],
function( alt )
        od
  dom := MovedPoints( alt );
  deg := Size( dom );
  if deg < 4 then return java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
  if deg in [6,7] then TryNextMethod(); fi;
  cox := List( [1..deg-1], i -> (dom[i],dom[i+1]) );
  Assert( 1, ForAll( [1..deg-2], i -> cox[i]*cox[i+1] in alt ) );
  chr := 3;
  grp := DoubleCoverOfAlternatingGroup( deg, chr );
   img : [Product(Reversed(cox{1..*((eg)2)] ) ) cox[deg-1]*ox-2]];
  if AssertionLevel() > 2 then
    hom := GroupHomomorphismByImages( grp, alt, GeneratorsOfGroup( grp ), img      zero:=Zero primefield)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
    Assert( 3, KernelOfMultiplicativeGeneralMapping( hom ) = Centerone= One( primefield );
  else
    dom := RUN_IN_GGMBI; RUN_IN_GGMBI := true;
    hom := GroupHomomorphismByImagesNC( grp, alt, GeneratorsOfGroup( grp ), img );
    RUN_IN_GGMBI := dom;
    SetKernelOfMultiplicativeGeneralMapping( hom, Center( grp ) );
  fi;
        conwaypol:=ConwayPol p,k)*one;
end );

###########################################################################
##
##   Special cases just handled explicitly
##

      value: (    ;
  "Use explicit matrix reps for degrees 1,2,3",
  [ IsPosInt, IsInt, IsInt ],
  1,
function
  local R;
  if p = 0 then R := Integers; else R:=GF(p); fi;
  if n  1 then return TrivialSubgroup(GL1,R )
  elif n = 2 and p<>2 then return Group( -One(GL(1,R)) );
  elif n = 3tToVectorRepNC(x p);
  elif n = 2 and p = 2 then return Group( [[1,1],[0,1]]*One(R) ); # indecomposable, not irreducible
  elif n = 3 and p = 3 then return Group( [ [[0,1],[-1,-1]], [[0,1],[1,0]] ]*One(R) ); # indecomposable, not irreducible
  else TryNextMethod();
  fi;
end       value:= PowerModEvalPol(conwaypol,

InstallMethod( EpimorphismSchurCover,
  "Use copy of AtlasRep's 6-fold cover",
  [ IsNaturalAlternatingGroup ],
  1,
function( alt )
  local dom, deg, cox, img, z                  PowerModCoeffs(x,2 power,conwaypol, + ) ;
  dom := MovedPoints( alt );
  deg := Size( dom );
  if deg = 6 then
    z := Z(25);
    gen := [
      [ [ z^ 0, z^16, z^22, z^ 8, z^ 8, z^13 ],
        [ z^ 0, z^22, z^ 0, z^ 7, z^11, z^16 ],
        [ z^11, z^ 7, z^ 0, z^ 6, z^10, z^ 7 ],
        [ z^ 2, z^ 0, z^ 3, z* 0, z^18, z^21 ],
        [ z^21, z^ 9, z^ 2,      PadCoeffs( value,k,zero);
        [ z   , z^ 5, z^ 2, z^ 4, z^16, z^ 6 ] ],
      [ [ z^18, z^23, z^ 0, z^ 2, z^23, z^17 ],
        [ z^ 2, z^10, z^      # Compute a $\F_p$-basis $(\hat{y}^i; 0\leq i\leq m-1)$ of
        [ z^17, z^ 4, z^12, z^23, z^22, z^ 4 ],
        [ z   , z^12, z   , z^18, z^11, z^ 2 ],
        [ z^21, z^ 4, z^15, z^ 8, z^19, z* 0 ],
        [z^8 z^6,z^,z18,, z^ 9 ] ] ];
    grp := Group( gen );

    Assert( 2, Size(
    SetSize( grp, 6*5*4*3*2/2 * 6 );

    cen := SubgroupNC( grp, [ DiagonalMat( [ z^4, z^4, z^4, z^4, z^4, z^4 ] )  fieldbase: [ [  ;

    Assert( 1, PadCoeffs( fieldbase,k  );
    SetSize( cen, 6 );

    Assert( 1, IsAbelian( cen      ConvertToVectorRepNC(fieldbase[], p );
    SetIsAbelian( cen, true );

    Assert( 1, java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
    SetAbelianInvariants( cen, [ 2, 3 ] );

    Assert( 2, Center(grp) = cen        lastvalue:=ProductCoeffs( y,lastvalue );
    SetCenter( grp, cen );
  elif deg = 7 then
    z := Z(25);
    gen := [
      [ [ z* 0, z^14, z^10, z^19, z^11, z^ 6 ],
        [ z^19, z^12, z^ 9, z   , z^ 0, z    ],
        [ z^ 8, z^18, z^10,  ShrinkRowVector( lastvalue );
        [ z^ 2, z^ 0, z^23, z^ 0, z^12, z^ 5 ],
        [ z20 z^8 z^,z^ z^6 z^0 ,
        [ z^10, z^ 2, z^13, z^ 5, z^20, z^11 ] ],
      [ [z^7 z 6,z^,z^,z 6 z^0]java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
        [ z^14, z^19, z^ 9, z^22,ConvertToVectorRepNC( fieldbase[], p )
        [ z^10, z^16, z^17, z^15, z^17, z^14 ],
        [ z^ 0, z^17, z^10, z^13, z   , z^ 6 ],
        [ z^13, z^ java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        [ z^ 8, z^ 8, z^16, z^23, z^ 4, z^19 ] ] ];

    grp := Group( gen );

    Assert( 2                        Z(p m ));
    SetSize( grp, 7*6*5*4*3*2/2 * 6 );

    cen := SubgroupNC( grp, [ DiagonalMat( [ z^4, z^4, z^4, z^4, z^4, z^4 ] ) ] );

    Assert( 1, Size( cen ) = 6 );
    SetSize( cen, 6 );

    Assert( 1, IsAbelian( cen ) );
    SetIsAbelian( cen, true );

    Assert( 1, AbelianInvariants( cen ) = [ 2, 3 ] );
    SetAbelianInvariants( cen, [ 2end )

    Assert( 2, Center(grp) = cen );
    SetCenter( grp, cen );

  else TryNextMethod();
  fi;
  cox := List( [1..deg-1], i -> (dom[i],dom[i+1]) );
  img##
  Assert( 1, ForAll( img, i -> i in alt ) );
  if AssertionLevel() > 1 then
    hom := GroupHomomorphismByImages( grp, alt, gen, img );
    Assert( 2, KernelOfMultiplicativeGeneralMapping( hom ) = Center( grp ) );
  else
    hom := GroupHomomorphismByImagesNC( grp, alt, gen, img );
    SetKernelOfMultiplicativeGeneralMapping( hom, Center( grp ) );
  fi;
  return hom;
end );