AddToIgs improvements 5: use smaller exponents when norming & sifting

CHANGES.md

@@ -40,6 +40,9 @@ This file describes changes in the GAP package 'polycyclic'.
 - Allow a finite group fallback for `RepresentativeAction` and `IsConjugate` for
   subgroups
 - Optimise `NormalIntersection`
+- Avoid needlessly large powers when norming and sifting elements at a depth
+  of finite relative order; this also changes which power `NormedPcpElement`
+  returns
 - Make more use of `NC` versions of functions, and avoid the use of generic `PreImage`
   and `Image` dispatchers to improve speed and memory usage
 - Implement a method for sorting pcp-subgroups, which prevents hangs when creating

doc/defins.xml

@@ -247,8 +247,11 @@ its relative index. For  each pcp-element <M>g</M>  there exists an integer
 <ManSection>
 <Func Name="NormingExponent" Arg="g"/>
 <Description>
-	returns an integer <M>e</M>, either positive or <M>-1</M>, such that the pcp-element
-	<A>g</A> raised to the power of <M>e</M> is normed.
+	returns an integer <M>e</M> such that the pcp-element <A>g</A> raised to the
+	power of <M>e</M> is normed.
+	For non-trivial <A>g</A> with factor order <M>r</M>, we have
+	<M>-r/2 &lt; e \leq r/2</M> if <M>r &gt; 0</M>, and
+	<M>e \in \{-1,1\}</M> if <M>r = 0</M>.
 </Description>
 </ManSection>
 

gap/basic/pcpelms.gi

@@ -217,6 +217,17 @@ function( g )
     return o;
 end );
 
+#############################################################################
+##
+#F SmallestResidue( q, r ) . . . . . . .  q mod r in (-r/2, r/2], q if r = 0
+##
+BindGlobal( "SmallestResidue", function( q, r )
+    if r = 0 then return q; fi;
+    q := q mod r;
+    if 2*q > r then q := q - r; fi;
+    return q;
+end );
+
 #############################################################################
 ##
 #F NormingExponent( g ) . . . . . . . . .returns f such that g^f is normed
@@ -234,10 +245,10 @@ BindGlobal( "NormingExponent", function( g )
     elif r = 0 then
         return 1;
     elif IsPrime( r ) then
-        return l^-1 mod r;
+        return SmallestResidue( l^-1, r );
     else
         e := Gcdex( r, l );     # = RelativeIndex
-        return e.coeff2 mod r;  # l * c2 = e mod r
+        return SmallestResidue( e.coeff2, r );  # l * c2 = e mod r
     fi;
 end );
 

gap/basic/pcppara.gi

@@ -28,10 +28,11 @@ end );
 ## Apply GcdPcp( g, h ), and apply the same operations on i and j.
 ##
 BindGlobal( "GcdPcpPara", function(g, h, i, j)
-    local x, y, a, b, q, r, t, z, w, u;
+    local x, y, a, b, q, r, t, z, w, u, rel;
 
     x := g;
     y := h;
+    rel := FactorOrder(g);
 
     a := LeadingExponent(x);
     b := LeadingExponent(y);
@@ -52,6 +53,8 @@ BindGlobal( "GcdPcpPara", function(g, h, i, j)
 
     while b <> 0 do
         q := QuoInt(a, b);
+        r := a - q * b;
+        q := SmallestResidue(q, rel);
 
         t := x * y ^ -q;
         x := y;
@@ -61,7 +64,6 @@ BindGlobal( "GcdPcpPara", function(g, h, i, j)
         z := w;
         w := u;
 
-        r := a - q * b;
         a := b;
         b := r;
     od;
@@ -183,7 +185,7 @@ function( pcs, gens, ppcs, pgens )
                 b := LeadingExponent(h);
                 if a > 0 and b > 0 and a mod b = 0 then
                     # GcdPcpPara would leave h and hh unchanged.
-                    q  := a/b;
+                    q  := SmallestResidue(a/b, rels[d]);
                     g  := g  * h^-q;
                     gg := gg * hh^-q;
                 else

gap/basic/pcppcps.gi

@@ -101,13 +101,15 @@ IGSValFun := IGSValFun4;
 ##
 ## For two non-trivial PcpElements g and h with the same depth, apply the
 ## Euclidean algorithm to the leading exponents, and do the same operations
-## on the elements themselves.
+## on the elements themselves. At a depth of finite relative order the
+## quotients are taken modulo that order.
 ##
 BindGlobal( "GcdPcp", function(g, h)
-    local x, y, a, b, q, r, t;
+    local x, y, a, b, q, r, t, rel;
 
     x := g;
     y := h;
+    rel := FactorOrder(g);
 
     a := LeadingExponent(x);
     b := LeadingExponent(y);
@@ -123,12 +125,12 @@ BindGlobal( "GcdPcp", function(g, h)
 
     while b <> 0 do
         q := QuoInt(a, b);
+        r := a - q * b;
 
-        t := x * y ^ -q;
+        t := x * y ^ -SmallestResidue(q, rel);
         x := y;
         y := t;
 
-        r := a - q * b;
         a := b;
         b := r;
     od;
@@ -190,7 +192,7 @@ InstallGlobalFunction(AddToIgs, function(igs, gens)
                 b := LeadingExponent(h);
                 if a > 0 and b > 0 and a mod b = 0 then
                     # GcdPcp would leave h unchanged.
-                    g := g * h^(-a/b);
+                    g := g * h^-SmallestResidue(a/b, rels[d]);
                 else
                     pair := GcdPcp(g, h);
                     h := pair[1];