This is a continuation of #5577 removing more unused function arguments

grp/glzmodmz.gi

@@ -381,7 +381,7 @@
             bas:=Basis(sub,bas);
             RUN_IN_GGMBI:=true;
             hom:=GroupGeneralMappingByImagesNC(g,fp,gens,GeneratorsOfGroup(fp));
-            hom:=LiftFactorFpHom(hom,g,"M",SubgroupNC(g,basm),rec(
+            hom:=LiftFactorFpHom(hom,g,SubgroupNC(g,basm),rec(
                   pcgs:=basm,
                   prime:=p,
                   decomp:=function(em)

lib/clashom.gi

@@ -2146,11 +2146,9 @@ BindGlobal("LiftClassesEATrivRep",
       lvec:=Concatenation(vec{range},Zero(vec{[i*ssd+1..Length(vec)]}));
       result:=OrbitMinimumMultistage(stabradgens,
            List(stabradgens,x->bas*npcgsact(x)*basinv),
-           pcisom,0,0, # solvable size not needed
            stabfacgens,
            List(stabfacgens,x->bas*npcgsact(x)*basinv),
            stabfacimgs,
-           hom,0, #gpsz not needed
            OnRight,lvec,maxorb,#Maximum(List(lcands,x->x.len)),
            Set(lcands,x->x.rep));
       a:=First(lcands,x->x.rep{range}=result.min{range});
@@ -2178,8 +2176,8 @@ BindGlobal("LiftClassesEATrivRep",
   if false and allcands[1].len>1 then
     Error();
   fi;
-    a:=OrbitMinimumMultistage(pcgs,pcgsimgs,pcisom,0,0,
-        nsgens,nsimgs,nsfgens,hom,0,
+    a:=OrbitMinimumMultistage(pcgs,pcgsimgs,
+        nsgens,nsimgs,nsfgens,
         OnRight,vec,allcands[1].len,minvecs);
     a.nclass:=First(allcands,x->x.rep=a.min);
     return a;

lib/coll.gi

@@ -3034,10 +3034,7 @@ InstallGlobalFunction(CanEasilyCompareElementsFamily,function(fam)
 end);
 
 InstallMethod(CanEasilyCompareElements,"family: default false",
-  [IsFamily],
-function(obj)
-  return false;
-end);
+  [IsFamily], ReturnFalse);
 
 InstallOtherMethod(SetCanEasilyCompareElements,"family setter",
   [IsFamily,IsObject],

lib/combinat.gi

@@ -454,13 +454,13 @@ BindGlobal( "NrCombinationsX", function ( mset, k )
     return nrs;
 end );
 
-BindGlobal( "NrCombinationsSetA", function ( set, k )
+BindGlobal( "NrCombinationsSetA", function ( set )
     local  nr;
     nr := 2 ^ Size(set);
     return nr;
 end );
 
-BindGlobal( "NrCombinationsMSetA", function ( mset, k )
+BindGlobal( "NrCombinationsMSetA", function ( mset )
     local  nr;
     nr := Product( Set(mset), i->Number(mset,j->i=j)+1 );
     return nr;
@@ -491,9 +491,9 @@ InstallGlobalFunction(NrCombinations,function ( mset, arg... )
     mset := ShallowCopy(mset);  Sort( mset );
     if Length(arg) = 0  then
         if IsSSortedList( mset )  then
-            nr := NrCombinationsSetA( mset, Length(mset) );
+            nr := NrCombinationsSetA( mset );
         else
-            nr := NrCombinationsMSetA( mset, Length(mset) );
+            nr := NrCombinationsMSetA( mset );
         fi;
     elif Length(arg) = 1  then
         if IsSSortedList( mset )  then
@@ -648,7 +648,7 @@ BindGlobal( "NrArrangementsX", function ( mset, k )
     return nrs;
 end );
 
-BindGlobal( "NrArrangementsSetA", function ( set, k )
+BindGlobal( "NrArrangementsSetA", function ( set )
     local  nr, i;
     nr := 0;
     for i  in [0..Size(set)]  do
@@ -688,7 +688,7 @@ InstallGlobalFunction(NrArrangements,function ( mset, arg... )
     mset := ShallowCopy(mset);  Sort( mset );
     if Length(arg) = 0  then
         if IsSSortedList( mset )  then
-            nr := NrArrangementsSetA( mset, Length(mset) );
+            nr := NrArrangementsSetA( mset );
         else
             nr := NrArrangementsMSetA( mset, Length(mset) );
         fi;

lib/ctblgrp.gi

@@ -628,9 +628,9 @@ end );
 
 #############################################################################
 ##
-#F  DxEigenbase(<mat>,<field>) . . . . . components of Eigenvects resp. base
+#F  DxEigenbase(<mat>) . . . . . components of Eigenvects resp. base
 ##
-BindGlobal( "DxEigenbase", function(M,f)
+BindGlobal( "DxEigenbase", function(M)
   local dim,i,eigenvalues,base,minpol,bases;
 
   minpol:=MinimalPolynomial(BaseDomain(M),M);
@@ -764,7 +764,7 @@ InstallGlobalFunction(SplitStep,function(D,bestMat)
           N[row,col]:=Row[activeCols[col]];
         od;
       od;
-      eigen:=DxEigenbase(N,f);
+      eigen:=DxEigenbase(N);
       # Base umrechnen
       base:=Matrix(BaseDomain(base[1]),base);
       eigenbase:=List(eigen.base,i->List(i,j->j*base));

lib/ctblperm.gi

@@ -16,7 +16,7 @@
 #F  FingerprintPerm( <D>, <el>, <i>, <j>, <orbitJ>, <representatives>)
 #F       Entry i,j of the matrix of el in the permutation representation of G
 ##
-BindGlobal( "FingerprintPerm", function(D,el,i,j,orbitJ,representatives)
+BindGlobal( "FingerprintPerm", function(D,el,orbitJ,representatives)
   local x,a,cycle,cycles;
   a:=0;
   #cycles:=Cycles(el,D.group.orbit);
@@ -55,7 +55,7 @@ BindGlobal("CheapIdentificationPermGroup",function(D,el)
     od;
   fi;
   if t in D.fingerprintCandidates then
-    Add(s,-FingerprintPerm(D,el,D.p1,D.p2,D.fingerprintOrbitStabilizer,
+    Add(s,-FingerprintPerm(D,el,D.fingerprintOrbitStabilizer,
                                     D.fingerprintRepresentatives));
   fi;
   return s;
@@ -205,7 +205,7 @@ local k,structures,ambiguousStructures,i,j,p,cem,ces,z,t,cen,a,
           c:=Filtered([1..D.klanz],i->IdentificationPermGroup(D,
                   D.classreps[i])=s);
           f:=List(c,i->FingerprintPerm(D,
-                    D.classreps[i],D.p1,D.p2,fos,fr));
+                    D.classreps[i],fos,fr));
           if Length(Set(f))>1 then Add(fc,s);
           fi;
         od;

lib/custom_streams.gi

@@ -200,9 +200,7 @@ end );
 InstallMethod( RewindStream,
     "input text custom",
     [ IsInputTextStream and IsInputTextCustomRep ],
-function( stream )
-    return fail;
-end );
+ReturnFail );
 
 
 #############################################################################
@@ -213,9 +211,7 @@ InstallMethod( SeekPositionStream,
     "input text custom",
     [ IsInputTextStream and IsInputTextCustomRep,
       IsInt ],
-function( stream, pos )
-    return fail;
-end );
+ReturnFail );
 
 
 #############################################################################

lib/dt.g

@@ -255,7 +255,7 @@ end );
 ##  <Dt_ConvertCoeffVecs> a pair [j, k] occurring in <evlistvec>[i] means that
 ##  <evlist>[i] occurs in f_j with coefficient k.
 ##
-BindGlobal( "Dt_ConvertCoeffVecs", function(evlistvec, pr)
+BindGlobal( "Dt_ConvertCoeffVecs", function(evlistvec)
     local i,j,res;
 
     for  i in [1..Length(evlistvec)]  do
@@ -658,7 +658,7 @@ BindGlobal( "Calcrepsn", function(n, avec, pr, max)
    # finally convert the polynomials to the final state
    pols := Dt_Convert(pols);
    if  pols <> 0  then
-      Dt_ConvertCoeffVecs(pols.evlistvec, pr);
+      Dt_ConvertCoeffVecs(pols.evlistvec);
    fi;
    return pols;
 end );

lib/factgrp.gi

@@ -1280,19 +1280,13 @@ end);
 #M  FindActionKernel(<G>)  . . . . . . . . . . . . . . . . . . . . generic
 ##
 InstallMethod(FindActionKernel,"generic for finite groups",IsIdenticalObj,
-  [IsGroup and IsFinite,IsGroup],0,
-function(G,N)
-  return GenericFindActionKernel(G,N);
-end);
+  [IsGroup and IsFinite,IsGroup],0,GenericFindActionKernel);
 
 RedispatchOnCondition(FindActionKernel,IsIdenticalObj,[IsGroup,IsGroup],
   [IsGroup and IsFinite,IsGroup],0);
 
 InstallMethod(FindActionKernel,"general case: can't do",IsIdenticalObj,
-  [IsGroup,IsGroup],0,
-function(G,N)
-  return fail;
-end);
+  [IsGroup,IsGroup],0,ReturnFail);
 
 BindGlobal("FactPermRepMaxDesc",function(g,n,maxlev)
 local lim,deg,all,c,recurse,use,start;

lib/fitfree.gd

@@ -182,9 +182,6 @@ DeclareGlobalFunction("TFMakeInducedPcgsModulo");
 DeclareGlobalFunction("OrbitsRepsAndStabsVectorsMultistage");
 DeclareGlobalFunction("OrbitMinimumMultistage");
 
-# utility function: Evaluate the homomorphism to radical factor ``by hand''.
-DeclareGlobalFunction("TFEvalRFHom");
-
 #############################################################################
 ##
 #F  FittingFreeElementarySeries( <G>, [<A>, <wholesocle>])

lib/fitfree.gi

@@ -450,28 +450,6 @@
   return f.radical;
 end );
 
-# evaluate homomorphism given by generators
-#
-InstallGlobalFunction(TFEvalRFHom,function(
-  # generators for whole group
-  pcgs,pcgsimgs, # radical part
-  freps,frimgs, # outside radical
-  quotelms, # images of freps in G/Rad
-  fgp, # Group generated by frimgs
-  elm, elmimg # element to be mapped and its image
-  )
-
-local map,fword,repeval,q,freegens;
-  map:=EpimorphismFromFreeGroup(fgp);
-  freegens:=MappingGeneratorsImages(map)[1];
-  fword:=PreImagesRepresentative(map,elmimg);
-  repeval:=MappedWord(fword,freegens,freps);
-  q:=elm/repeval; # will be trivial in factor, so in radical
-  return LinearCombinationPcgs(pcgsimgs,ExponentsOfPcElement(pcgs,q))*
-           MappedWord(fword,freegens,frimgs);
-end);
-
-
 # We will be in the situation that an IGS has been corrected only on the
 # lowest level, i.e. the only obstacle to being an IGS is on the lowest
 # level. Thus the situation is that of a vector space and we do not need to
@@ -803,8 +781,7 @@
 end);
 
 InstallGlobalFunction(OrbitMinimumMultistage,
-  function(pcgs,pcgsimgs,pcisom,solvsz,solvtriv,gens,imgs,fgens,
-           factorhom,gpsz,actfun,seed,orblen,stops)
+  function(pcgs,pcgsimgs,gens,imgs,fgens,actfun,seed,orblen,stops)
 
 #was: OrbitMinimumMultistage:=function(pcgs,pcgsimgs,gens,imgs,fgens,actfun,seed,orblen,stops)
 
@@ -960,7 +937,7 @@
       else
         # extend presentation
         RUN_IN_GGMBI:=true; # hack to skip Nice treatment
-        fphom:=LiftFactorFpHom(fphom,Source(fphom),false,false,mpcgs);
+        fphom:=LiftFactorFpHom(fphom,Source(fphom),false,mpcgs);
         RUN_IN_GGMBI:=false;
         fp:=Image(fphom);
         sp:=Concatenation(sp,mpcgs);
@@ -1286,7 +1263,7 @@
         pcgs:=List([2..Length(dser)],x->ModuloPcgs(dser[x-1],dser[x]));
         for j in pcgs do
           RUN_IN_GGMBI:=true; # hack to skip Nice treatment
-          fphom:=LiftFactorFpHom(fphom,Source(fphom),false,false,j);
+          fphom:=LiftFactorFpHom(fphom,Source(fphom),false,j);
           RUN_IN_GGMBI:=false;
         od;
         gens:=MappingGeneratorsImages(fphom);
@@ -1450,7 +1427,7 @@
         else
           # extend presentation
           RUN_IN_GGMBI:=true; # hack to skip Nice treatment
-          fphom:=LiftFactorFpHom(fphom,Source(fphom),false,false,mpcgs);
+          fphom:=LiftFactorFpHom(fphom,Source(fphom),false,mpcgs);
           RUN_IN_GGMBI:=false;
           fp:=Image(fphom);
           sp:=Concatenation(sp,mpcgs);
@@ -1571,4 +1548,3 @@
   od;
   return c;
 end);
-

lib/gpfpiso.gi

@@ -635,7 +635,7 @@ function(hom,elm)
 end);
 
 InstallGlobalFunction(LiftFactorFpHom,
-function(hom,G,M,N,mnsf)
+function(hom,G,N,mnsf)
 local fpq, qgens, qreps, fpqg, rels, pcgs, p, f, qimg, idx, nimg, decomp,
       ngen, fp, hom2, di, source, dih, dec, i, j;
   fpq:=Range(hom);
@@ -765,7 +765,7 @@ local fpq, qgens, qreps, fpqg, rels, pcgs, p, f, qimg, idx, nimg, decomp,
 end);
 
 InstallGlobalFunction(ComplementFactorFpHom,
-function(h,g,m,n,k,ggens,cgens)
+function(h,m,n,k,ggens,cgens)
 local di, hom;
   if IsBound(h!.decompinfo) then
     di:=ShallowCopy(h!.decompinfo);

lib/gprd.gi

@@ -1139,10 +1139,7 @@ end);
 ##
 InstallMethod( \in,"generic wreath product", IsCollsElms,
   [ IsGroup and HasWreathProductInfo and IsWreathProductElementCollection
-    and IsWholeFamily, IsWreathProductElement ], 0,
-function(G,e)
-  return true;
-end);
+    and IsWholeFamily, IsWreathProductElement ], 0, ReturnTrue);
 
 #
 # semidirect product

lib/grp.gd

@@ -4606,14 +4606,14 @@ DeclareOperation( "PowerMapOfGroup", [ IsGroup, IsInt, IsHomogeneousList ] );
 
 #############################################################################
 ##
-#F  PowerMapOfGroupWithInvariants( <G>, <n>, <ccl>, <invariants> )
+#F  PowerMapOfGroupWithInvariants( <n>, <ccl>, <invariants> )
 ##
 ##  <ManSection>
-##  <Func Name="PowerMapOfGroupWithInvariants" Arg='G, n, ccl, invariants'/>
+##  <Func Name="PowerMapOfGroupWithInvariants" Arg='n, ccl, invariants'/>
 ##
 ##  <Description>
 ##  is a list of integers, at position <M>i</M> the position of the conjugacy
-##  class containimg the <A>n</A>-th powers of elements in class <M>i</M>
+##  class containing the <A>n</A>-th powers of elements in class <M>i</M>
 ##  of <A>ccl</A>.
 ##  The list <A>invariants</A> contains all invariants besides element order
 ##  that shall be used before membership tests.

lib/grp.gi

@@ -5424,10 +5424,10 @@
 
 #############################################################################
 ##
-#F  PowerMapOfGroupWithInvariants( <G>, <n>, <ccl>, <invariants> )
+#F  PowerMapOfGroupWithInvariants( <n>, <ccl>, <invariants> )
 ##
 InstallGlobalFunction( PowerMapOfGroupWithInvariants,
-    function( G, n, ccl, invariants )
+    function( n, ccl, invariants )
 
     local reps,      # list of representatives
           ord,       # list of representative orders
@@ -5522,7 +5522,7 @@
     "method for a group",
     [ IsGroup, IsInt, IsHomogeneousList ],
     function( G, n, ccl )
-    return PowerMapOfGroupWithInvariants( G, n, ccl, [] );
+    return PowerMapOfGroupWithInvariants( n, ccl, [] );
     end );
 
 
@@ -5536,7 +5536,7 @@
     "method for a permutation group",
     [ IsGroup and IsPermCollection, IsInt, IsHomogeneousList ],
     function( G, n, ccl )
-    return PowerMapOfGroupWithInvariants( G, n, ccl, [CycleStructurePerm] );
+    return PowerMapOfGroupWithInvariants( n, ccl, [CycleStructurePerm] );
     end );
 
 
@@ -5550,7 +5550,7 @@
     "method for a matrix group",
     [ IsGroup and IsRingElementCollCollColl, IsInt, IsHomogeneousList ],
     function( G, n, ccl )
-    return PowerMapOfGroupWithInvariants( G, n, ccl, [ TraceMat ] );
+    return PowerMapOfGroupWithInvariants( n, ccl, [ TraceMat ] );
     end );
 
 
@@ -5570,10 +5570,7 @@
 end);
 
 InstallOtherMethod( KnowsHowToDecompose,"trivial group",true,
-  [IsGroup,IsEmpty],
-function(G,l)
-  return true;
-end);
+  [IsGroup,IsEmpty], ReturnTrue);
 
 InstallMethod( KnowsHowToDecompose,
     "group: use GeneratorsOfGroup",