gap-system · cdwensley · May 20, 2026 · May 20, 2026 · May 20, 2026 · May 21, 2026
diff --git a/lib/algebra.gi b/lib/algebra.gi
@@ -3647,7 +3647,7 @@ InstallMethod( CentralIdempotentsOfAlgebra,
 
       until k>Length(ideals);
 
-      id:= List( ids, e -> PreImagesRepresentative( hom, e ) );
+      id:= List( ids, e -> PreImagesRepresentativeNC( hom, e ) );
 
       # Now we lift the idempotents to the big algebra `A'. The
       # first idempotent is lifted as follows:

diff --git a/lib/algfp.gi b/lib/algfp.gi
@@ -705,7 +705,7 @@ InstallHandlingByNiceBasis( "IsFpAlgebraElementsSpace", rec(
       if hom = fail then
         TryNextMethod();
       fi;
-      return PreImagesRepresentative( hom, r );
+      return PreImagesRepresentativeNC( hom, r );
       end ) );
 
 

diff --git a/lib/alghom.gi b/lib/alghom.gi
@@ -576,16 +576,29 @@ InstallMethod( ImagesRepresentative,
 
 #############################################################################
 ##
+#M  PreImagesRepresentativeNC( <map>, <elm> ) . . . . .  for algebra g.m.b.i.
 #M  PreImagesRepresentative( <map>, <elm> ) . . . . . .  for algebra g.m.b.i.
 ##
+InstallMethod( PreImagesRepresentativeNC,
+    "for algebra g.m.b.i., and element",
+    FamRangeEqFamElm,
+    [ IsGeneralMapping and IsAlgebraGeneralMappingByImagesDefaultRep,
+      IsObject ],
+    function( map, elm )
+    return PreImagesRepresentativeNC(
+               AsLeftModuleGeneralMappingByImages(map), elm );
+    end );
+
 InstallMethod( PreImagesRepresentative,
     "for algebra g.m.b.i., and element",
     FamRangeEqFamElm,
     [ IsGeneralMapping and IsAlgebraGeneralMappingByImagesDefaultRep,
       IsObject ],
     function( map, elm )
-    return PreImagesRepresentative( AsLeftModuleGeneralMappingByImages(map),
-                                    elm );
+      if not ( elm in Range( map ) ) then
+        return fail;
+    fi;
+    return PreImagesRepresentativeNC( map, elm );
     end );
 
 
@@ -902,7 +915,7 @@ InstallMethod( ImagesRepresentative,
 
 #############################################################################
 ##
-#M  PreImagesRepresentative( <ophom>, <mat> )
+#M  PreImagesRepresentativeNC( <ophom>, <mat> )
 ##
 BindGlobal( "PreImagesRepresentativeOperationAlgebraHomomorphism", function( ophom, mat )
     if not IsBound( ophom!.basisImage ) then
@@ -915,12 +928,6 @@ BindGlobal( "PreImagesRepresentativeOperationAlgebraHomomorphism", function( oph
     return mat;
 end );
 
-InstallMethod( PreImagesRepresentative,
-    "for an operation algebra homomorphism, and an element",
-    FamRangeEqFamElm,
-    [ IsOperationAlgebraHomomorphismDefaultRep, IsMatrix ],
-    PreImagesRepresentativeOperationAlgebraHomomorphism );
-
 
 #############################################################################
 ##
@@ -1074,17 +1081,6 @@ InstallMethod( ImagesRepresentative,
     end );
 
 
-#############################################################################
-##
-#M  PreImagesRepresentative( <ophom>, <mat> )
-##
-InstallMethod( PreImagesRepresentative,
-    "for an alg. hom. from f. p. algebra, and an element",
-    FamRangeEqFamElm,
-    [ IsAlgebraHomomorphismFromFpRep, IsMatrix ],
-    PreImagesRepresentativeOperationAlgebraHomomorphism );
-
-
 #############################################################################
 ##
 #M  OperationAlgebraHomomorphism( <A>, <basis>, <opr> )

diff --git a/lib/alglie.gi b/lib/alglie.gi
@@ -34,7 +34,7 @@ InstallMethod( LieUpperCentralSeries,
       # under the natural homomorphism.
       Add( S, C );
       hom:= NaturalHomomorphismByIdeal( L, C );
-      C:= PreImages( hom, LieCentre( Range( hom ) ) );
+      C:= PreImagesNC( hom, LieCentre( Range( hom ) ) );
 #T we would like to get ideals!
 #T is it possible to teach the hom. that the preimage of an ideal is an ideal?
 
@@ -1706,7 +1706,7 @@ InstallMethod( LieSolvableRadical,
       quo:= ImagesSource( hom );
       r1:= LieSolvableRadical( quo );
       B:= BasisVectors( Basis( r1 ) );
-      B:= List( B, x -> PreImagesRepresentative( hom, x ) );
+      B:= List( B, x -> PreImagesRepresentativeNC( hom, x ) );
       Append( B, BasisVectors( Basis( n ) ) );
 
     fi;
@@ -2092,7 +2092,7 @@ InstallMethod( DirectSumDecomposition,
       SetRadicalOfAlgebra( Q, Subalgebra( Q, [ Zero( Q ) ] ) );
 
       id:= List( CentralIdempotentsOfAlgebra( Q ),
-                                x->PreImagesRepresentative(hom,x));
+                                x->PreImagesRepresentativeNC(hom,x));
 
       # Now we lift the idempotents to the big algebra `A'. The
       # first idempotent is lifted as follows:
@@ -4017,9 +4017,10 @@ InstallMethod( ImagesRepresentative,
 
 ###########################################################################
 ##
+#M   PreImagesRepresentativeNC( f, x )
 #M   PreImagesRepresentative( f, x )
 ##
-InstallMethod( PreImagesRepresentative,
+InstallMethod( PreImagesRepresentativeNC,
     "for Fp to SCA mapping, and element",
     FamRangeEqFamElm,
     [ IsFptoSCAMorphism, IsSCAlgebraObj ], 0,
@@ -4095,6 +4096,19 @@ InstallMethod( PreImagesRepresentative,
 
 end);
 
+InstallMethod( PreImagesRepresentative,
+    "for Fp to SCA mapping, and element",
+    FamRangeEqFamElm,
+    [ IsFptoSCAMorphism, IsSCAlgebraObj ], 0,
+
+    function( f, x )
+    if not ( x in Range( f ) ) then
+        return fail;
+    fi;
+    return PreImagesRepresentative( f, x );
+
+end );
+
 #############################################################################
 ##
 #M  Dimension( <FpL> )
@@ -5592,8 +5606,8 @@ InstallMethod( JenningsLieAlgebra,
     T:= EmptySCTable( dim , Zero(F) , "antisymmetric" );
     pimgs := [];
     for i in [1..dim] do
-        a:= PreImagesRepresentative( Homs[pos[i]] ,
-                    PreImagesRepresentative( hom_pcg[pos[i]], gens[i] ) );
+        a:= PreImagesRepresentativeNC( Homs[pos[i]] ,
+                    PreImagesRepresentativeNC( hom_pcg[pos[i]], gens[i] ) );
 
         # calculate the p-th power image of `a':
 
@@ -5610,8 +5624,8 @@ InstallMethod( JenningsLieAlgebra,
                # Calculate the commutator [a,b], and map the result into
                # the correct homogeneous component.
 
-                b:= PreImagesRepresentative( Homs[pos[j]],
-                         PreImagesRepresentative( hom_pcg[pos[j]], gens[j] ));
+                b:= PreImagesRepresentativeNC( Homs[pos[j]],
+                       PreImagesRepresentativeNC( hom_pcg[pos[j]], gens[j] ));
                 c:= Image( hom_pcg[pos[i] + pos[j]],
                            Image(Homs[pos[i] + pos[j]], a^-1*b^-1*a*b) );
                 e:= ExtRepOfObj(c);
@@ -5788,8 +5802,8 @@ InstallMethod( PCentralLieAlgebra,
     T:= EmptySCTable( dim , Zero(F) , "antisymmetric" );
     pimgs := [];
     for i in [1..dim] do
-        a:= PreImagesRepresentative( Homs[pos[i]] ,
-                    PreImagesRepresentative( hom_pcg[pos[i]], gens[i] ) );
+        a:= PreImagesRepresentativeNC( Homs[pos[i]] ,
+                    PreImagesRepresentativeNC( hom_pcg[pos[i]], gens[i] ) );
 
 
         # calculate the p-th power image of `a':
@@ -5807,8 +5821,8 @@ InstallMethod( PCentralLieAlgebra,
                # Calculate the commutator [a,b], and map the result into
                # the correct homogeneous component.
 
-                b:= PreImagesRepresentative( Homs[pos[j]],
-                         PreImagesRepresentative( hom_pcg[pos[j]], gens[j] ));
+                b:= PreImagesRepresentativeNC( Homs[pos[j]],
+                       PreImagesRepresentativeNC( hom_pcg[pos[j]], gens[j] ));
                 c:= Image( hom_pcg[pos[i] + pos[j]],
                            Image(Homs[pos[i] + pos[j]], a^-1*b^-1*a*b) );
                 e:= ExtRepOfObj(c);

diff --git a/lib/algrep.gi b/lib/algrep.gi
@@ -1212,24 +1212,24 @@ InstallMethod( NaturalHomomorphismBySubAlgebraModule,
     if IsLeftAlgebraModuleElementCollection( V ) then
         if IsRightAlgebraModuleElementCollection( V ) then
             left_op:= function( x, v )
-                 return ImagesRepresentative( f, x^PreImagesRepresentative( f, v ) );
+                 return ImagesRepresentative( f, x^PreImagesRepresentativeNC( f, v ) );
             end;
             right_op:= function( v, x )
-                 return ImagesRepresentative( f, PreImagesRepresentative( f, v )^x );
+                 return ImagesRepresentative( f, PreImagesRepresentativeNC( f, v )^x );
             end;
             qmod:= BiAlgebraModule( LeftActingAlgebra( V ),
                            RightActingAlgebra( V ),
                            left_op, right_op, quot );
         else
             left_op:= function( x, v )
-                 return ImagesRepresentative( f, x^PreImagesRepresentative( f, v ) );
+                 return ImagesRepresentative( f, x^PreImagesRepresentativeNC( f, v ) );
             end;
             qmod:= LeftAlgebraModule( LeftActingAlgebra( V ),
                            left_op, quot);
         fi;
     else
         right_op:= function( v, x )
-             return ImagesRepresentative( f, PreImagesRepresentative( f, v )^x );
+             return ImagesRepresentative( f, PreImagesRepresentativeNC( f, v )^x );
         end;
         qmod:= RightAlgebraModule( RightActingAlgebra( V ),
                        right_op, quot );

diff --git a/lib/autsr.gi b/lib/autsr.gi
@@ -118,7 +118,7 @@ local C,M,p,all,gens,sub,q,hom,fp,rels,new,pre,i,free,cnt;
     rels:=Filtered(RelatorsOfFpGroup(fp),x->ForAll(ExponentSums(x),x->x mod p=0));
     rels:=List(rels,x->ElementOfFpGroup(FamilyObj(One(fp)),x));
     new:=RestrictedMapping(nat,C)*hom;
-    pre:=List(rels,x->PreImagesRepresentative(new,x));
+    pre:=List(rels,x->PreImagesRepresentativeNC(new,x));
     for i in [1..Length(rels)] do
       if not pre[i] in sub then
         Add(all,MappedWord(rels[i],
@@ -141,7 +141,7 @@ local ocr,fphom,fpg,free,len,dim,tmp,L0,R,rels,mat,r,RS,i,g,v,cnt;
   fpg:=FreeGeneratorsOfFpGroup(Range(fphom));
   ocr.factorpres:=[fpg,RelatorsOfFpGroup(Range(fphom))];
   ocr.generators:=List(GeneratorsOfGroup(Range(fphom)),
-                        i->PreImagesRepresentative(fphom,i));
+                        i->PreImagesRepresentativeNC(fphom,i));
   OCAddMatrices(ocr,ocr.generators);
   OCAddRelations(ocr,ocr.generators);
   OCAddSumMatrices(ocr,ocr.generators);
@@ -274,8 +274,8 @@ BindGlobal("AGSRAutomLift",function(ocr,nat,fhom,miso)
     # allow to deduce corresponding module aut.
     t:=ocr.trickrels;
     phom:=IdentityMapping(ocr.moduleauts);
-    s:=List(t.gens,x->PreImagesRepresentative(nat,x));
-    l:=List(t.gens,x->PreImagesRepresentative(nat,ImagesRepresentative(fhom,x)));
+    s:=List(t.gens,x->PreImagesRepresentativeNC(nat,x));
+    l:=List(t.gens,x->PreImagesRepresentativeNC(nat,ImagesRepresentative(fhom,x)));
     s:=List(t.rels,x->MappedWord(x,GeneratorsOfGroup(t.free),s));
     l:=List(t.rels,x->MappedWord(x,GeneratorsOfGroup(t.free),l));
 
@@ -294,7 +294,7 @@ BindGlobal("AGSRAutomLift",function(ocr,nat,fhom,miso)
       Size(Image(phom)));
   fi;
   for ep in enum do
-    e:=PreImagesRepresentative(phom,ep);
+    e:=PreImagesRepresentativeNC(phom,ep);
     psim:=e*miso;
     psim:=psim^-1;
     w:=-List(v,i->i*psim);
@@ -486,7 +486,7 @@ local S,c,hom,q,a,b,i,t,have,ups,new,u,good,abort,clim,worked,pp,
 
       cnt:=0;
       for b in t do
-        new:=PreImagesRepresentative(hom,b);
+        new:=PreImagesRepresentativeNC(hom,b);
         if (pp=false or new^pp in S) and locond(new) then
           S:=ClosureGroup(S,new);
           have:=true;
@@ -1028,7 +1028,7 @@ local ff,r,d,ser,u,v,i,j,k,p,bd,e,gens,lhom,M,N,hom,Q,Mim,q,ocr,split,MPcgs,
         b:=MTX.BasisRadical(mo);
         fratsim:=Length(b)=0;
         if not fratsim then
-          b:=List(b,x->PreImagesRepresentative(hom,PcElementByExponents(MPcgs,x)));
+          b:=List(b,x->PreImagesRepresentativeNC(hom,PcElementByExponents(MPcgs,x)));
           for j in b do
             N:=ClosureSubgroup(N,b);
           od;
@@ -1129,8 +1129,8 @@ local ff,r,d,ser,u,v,i,j,k,p,bd,e,gens,lhom,M,N,hom,Q,Mim,q,ocr,split,MPcgs,
         if perm in Aperm then
           return true;
         fi;
-        aut:=PreImagesRepresentative(AQiso,perm);
-        newgens:=List(gens,x->PreImagesRepresentative(comiso,
+        aut:=PreImagesRepresentativeNC(AQiso,perm);
+        newgens:=List(gens,x->PreImagesRepresentativeNC(comiso,
           ImagesRepresentative(aut,ImagesRepresentative(comiso,x))));
 
         mo2:=GModuleByMats(LinearActionLayer(newgens,MPcgs),mo.field);
@@ -1163,9 +1163,9 @@ local ff,r,d,ser,u,v,i,j,k,p,bd,e,gens,lhom,M,N,hom,Q,Mim,q,ocr,split,MPcgs,
         if perm in Aperm then
           return true;
         fi;
-        aut:=PreImagesRepresentative(AQiso,perm);
+        aut:=PreImagesRepresentativeNC(AQiso,perm);
         newgens:=List(GeneratorsOfGroup(Q),
-          x->PreImagesRepresentative(q,Image(aut,ImagesRepresentative(q,x))));
+          x->PreImagesRepresentativeNC(q,Image(aut,ImagesRepresentative(q,x))));
         mo2:=GModuleByMats(LinearActionLayer(newgens,MPcgs),mo.field);
         return MTX.IsomorphismModules(mo,mo2)<>fail;
       end;
@@ -1175,9 +1175,9 @@ local ff,r,d,ser,u,v,i,j,k,p,bd,e,gens,lhom,M,N,hom,Q,Mim,q,ocr,split,MPcgs,
         if perm in Aperm then
           return true;
         fi;
-        aut:=PreImagesRepresentative(AQiso,perm);
+        aut:=PreImagesRepresentativeNC(AQiso,perm);
         newgens:=List(GeneratorsOfGroup(Q),
-          x->PreImagesRepresentative(q,Image(aut,ImagesRepresentative(q,x))));
+          x->PreImagesRepresentativeNC(q,Image(aut,ImagesRepresentative(q,x))));
         mo2:=GModuleByMats(LinearActionLayer(newgens,MPcgs),mo.field);
         iso:=MTX.IsomorphismModules(mo,mo2);
         if iso=fail then
@@ -1234,12 +1234,12 @@ local ff,r,d,ser,u,v,i,j,k,p,bd,e,gens,lhom,M,N,hom,Q,Mim,q,ocr,split,MPcgs,
         # stabilize class
         k:=SmallGeneratingSet(sub);
         ac:=OrbitStabilizerAlgorithm(sub,false,false,
-          k,List(k,x->PreImagesRepresentative(AQiso,x)),
+          k,List(k,x->PreImagesRepresentativeNC(AQiso,x)),
           rec(pnt:=j,
           act:=
           function(set,phi)
           #local phi;
-            #phi:=PreImagesRepresentative(AQiso,perm);
+            #phi:=PreImagesRepresentativeNC(AQiso,perm);
             return Set(List(set,x->Image(phi,x)));
           end,
           onlystab:=true));
@@ -1367,7 +1367,7 @@ local ff,r,d,ser,u,v,i,j,k,p,bd,e,gens,lhom,M,N,hom,Q,Mim,q,ocr,split,MPcgs,
           GeneratorsOfGroup(rf),
           List(GeneratorsOfGroup(rf),
             y->ImagesRepresentative(hom,ImagesRepresentative(j,
-                 PreImagesRepresentative(hom,y)))));
+                 PreImagesRepresentativeNC(hom,y)))));
         Assert(2,IsBijective(k));
         Add(ind,k);
       od;
@@ -1390,7 +1390,7 @@ local ff,r,d,ser,u,v,i,j,k,p,bd,e,gens,lhom,M,N,hom,Q,Mim,q,ocr,split,MPcgs,
         proj:=GroupHomomorphismByImagesNC(AQP,Image(resperm),
           B[2],List(GeneratorsOfGroup(res),x->ImagesRepresentative(resperm,x)));
         C:=PreImage(proj,Image(resperm,ind));
-        C:=List(SmallGeneratingSet(C),x->PreImagesRepresentative(AQiso,x));
+        C:=List(SmallGeneratingSet(C),x->PreImagesRepresentativeNC(AQiso,x));
         AQ:=Group(C);
         SetIsFinite(AQ,true);
         SetIsGroupOfAutomorphismsFiniteGroup(AQ,true);
@@ -1416,7 +1416,7 @@ local ff,r,d,ser,u,v,i,j,k,p,bd,e,gens,lhom,M,N,hom,Q,Mim,q,ocr,split,MPcgs,
           C:=MappingGeneratorsImages(AQiso);
           if C[2]<>GeneratorsOfGroup(AQP) then
             C:=[List(GeneratorsOfGroup(AQP),
-                     x->PreImagesRepresentative(AQiso,x)),
+                     x->PreImagesRepresentativeNC(AQiso,x)),
                  GeneratorsOfGroup(AQP)];
           fi;
           for j in u do
@@ -1450,7 +1450,7 @@ local ff,r,d,ser,u,v,i,j,k,p,bd,e,gens,lhom,M,N,hom,Q,Mim,q,ocr,split,MPcgs,
           substb:=SmallGeneratingSet(substb);
           AQP:=Group(substb);
           SetSize(AQP,B);
-          C:=[List(substb,x->PreImagesRepresentative(AQiso,x)),substb];
+          C:=[List(substb,x->PreImagesRepresentativeNC(AQiso,x)),substb];
         fi;
 
       od;
@@ -1883,7 +1883,7 @@ local d,a,map,cG,nG,nH,i,j,u,v,asAutomorphism,K,L,conj,e1,e2,
           else
             gens:=SmallGeneratingSet(api);
           fi;
-          pre:=List(gens,x->PreImagesRepresentative(iso,x));
+          pre:=List(gens,x->PreImagesRepresentativeNC(iso,x));
           map:=RepresentativeAction(SubgroupNC(a,pre),u,v,asAutomorphism);
           if map=fail then
             return fail;
@@ -1904,6 +1904,6 @@ local d,a,map,cG,nG,nH,i,j,u,v,asAutomorphism,K,L,conj,e1,e2,
   fi;
 
   return GroupHomomorphismByImagesNC(G,H,GeneratorsOfGroup(G),
-    List(GeneratorsOfGroup(G),x->PreImagesRepresentative(e2,
+    List(GeneratorsOfGroup(G),x->PreImagesRepresentativeNC(e2,
          Image(conj,Image(e1,x)))));
 end);
diff --git a/lib/clas.gi b/lib/clas.gi
@@ -395,7 +395,7 @@ local H,cl,a,c;
   H:=Image(hom,G);
   cl:=[];
   for c in ConjugacyClasses(H) do
-    a:=ConjugacyClass(G,PreImagesRepresentative(hom,Representative(c)));
+    a:=ConjugacyClass(G,PreImagesRepresentativeNC(hom,Representative(c)));
     if HasStabilizerOfExternalSet(c) then
       SetStabilizerOfExternalSet(a,PreImage(hom,StabilizerOfExternalSet(c)));
     fi;