Quelle examples.xml Sprache: XML

<Chapter Label="ch:Examples"><Heading>Examples</Heading>

<Ignore Remark="settings for the example tester">
<Example>
<![CDATA[
gap> SizeScreen([75,24]);;
gap> SetAssertionLevel(0);
]]>
</Example>
</Ignore>

This chapter discusses a number of examples of rcwa mappings
and -groups in detail. All of them show different aspects of the package,
and the order in which they appear is entirely arbitrary. In particular
they are not ordered by degree of difficulty or interest. <P/>

<Index Key="LoadRCWAExamples"><C>LoadRCWAExamples</C></Index>
<Index Key="AssignGlobals"><C>AssignGlobals</C></Index>

The rcwa mappings, rcwa groups and other objects defined in this chapter can
be found in the file <F>pkg/rcwa/examples/examples.g</F>. This file can be
read into the current &GAP; session by the function
<Ref Func="LoadRCWAExamples"/> which takes no arguments and returns the name
of a variable which the record containing the examples got assigned to.
The global variable assignments made in a section of this chapter can be
made by applying the function <C>AssignGlobals</C> to the respective
component of the examples record. The component names are given at the end
of the corresponding sections. <P/>

The discussions of the examples are typically far from being exhaustive.
It is quite likely that in many instances by just a few little modifications
or additional easy commands you can find out interesting things yourself
-- have fun!



<Section Label="sec:ThompsonsGroupV">
<Heading>
  Thompson's group V
</Heading>

Thompson's group V, also known as Higman-Thompson group, is a finitely
presented infinite simple group. This group has been found by Graham Higman,
cf. <Cite Key="Higman74"/>. We show that the group

<Example>
<![CDATA[
gap> G := Group(List([[0,2,1,4],[0,4,1,4],[1,4,2,4],[2,4,3,4]],
>                    ClassTransposition));
<(0(2),1(4)),(0(4),1(4)),(1(4),2(4)),(2(4),3(4))>
]]>
</Example>

is isomorphic to Thompson's group V.
This isomorphism has been pointed out by John P. McDermott.
We take a slightly different set of generators:

<Example>
<![CDATA[
gap> k := ClassTransposition(0,2,1,2);;
gap> l := ClassTransposition(1,2,2,4);;
gap> m := ClassTransposition(0,2,1,4);;
gap> n := ClassTransposition(1,4,2,4);;
gap> H := Group(k,l,m,n);
<(0(2),1(2)),(1(2),2(4)),(0(2),1(4)),(1(4),2(4))>
gap> G = H; # k, l, m and n generate G as well
true
]]>
</Example>

Now we verify that our four generators satisfy the relations given on
page 50 in <Cite Key="Higman74"/>, when we read <C>k</C>
as <M>\kappa</M>, <C>l</C> as <M>\lambda</M>, <C>m</C>
as <M>\mu</M> and <C>n</C> as <M>\nu</M>:

<Example>
<![CDATA[
gap> HigmanThompsonRels :=
> [ k^2, l^2, m^2, n^2,                           # (1) in Higman's book
>   l*k*m*k*l*n*k*n*m*k*l*k*m,                    # (2)        "
>   k*n*l*k*m*n*k*l*n*m*n*l*n*m,                  # (3)        "
>   (l*k*m*k*l*n)^3, (m*k*l*k*m*n)^3,             # (4)        "
>   (l*n*m)^2*k*(m*n*l)^2*k,                      # (5)        "
>   (l*n*m*n)^5,                                  # (6)        "
>   (l*k*n*k*l*n)^3*k*n*k*(m*k*n*k*m*n)^3*k*n*k*n,# (7)        "
>   ((l*k*m*n)^2*(m*k*l*n)^2)^3,                  # (8)        "
>   (l*n*l*k*m*k*m*n*l*n*m*k*m*k)^4,              # (9)        "
>   (m*n*m*k*l*k*l*n*m*n*l*k*l*k)^4,              #(10)        "
>   (l*m*k*l*k*m*l*k*n*k)^2,                      #(11)        "
>   (m*l*k*m*k*l*m*k*n*k)^2 ];                    #(12)        "
[ IdentityMapping( Integers ), IdentityMapping( Integers ),
  IdentityMapping( Integers ), IdentityMapping( Integers ),
  IdentityMapping( Integers ), IdentityMapping( Integers ),
  IdentityMapping( Integers ), IdentityMapping( Integers ),
  IdentityMapping( Integers ), IdentityMapping( Integers ),
  IdentityMapping( Integers ), IdentityMapping( Integers ),
  IdentityMapping( Integers ), IdentityMapping( Integers ),
  IdentityMapping( Integers ), IdentityMapping( Integers ) ]
]]>
</Example>

We conclude that our group is an homomorphic image of Thompson's group V.
But since Thompson's group V is simple and our group is not trivial,
this means indeed that the two groups are isomorphic. <P/>

In fact it is straightforward to show that <C>G</C> is the group
<C>CT([2],Integers)</C> which is generated by the set of all
class transpositions which interchange residue classes modulo powers
of 2. First we check that <C>G</C> contains all 11 class
transpositions which interchange residue classes modulo 2 or 4:

<Example>
<![CDATA[
gap> S := Filtered(List(ClassPairs(4),ClassTransposition),
>                  ct->Mod(ct) in [2,4]);
[ ( 0(2), 1(2) ), ( 0(2), 1(4) ), ( 0(2), 3(4) ), ( 0(4), 1(4) ),
  ( 0(4), 2(4) ), ( 0(4), 3(4) ), ( 1(2), 0(4) ), ( 1(2), 2(4) ),
  ( 1(4), 2(4) ), ( 1(4), 3(4) ), ( 2(4), 3(4) ) ]
gap> IsSubset(G,S);
true
]]>
</Example>

Then we give a function which takes a class transposition
<M>\tau \in {\rm CT}_\emptyset(&ZZ;)</M>, and which returns
a factorization of an element <M>\gamma</M> satisfying
<M>\tau^\gamma \in S</M> into <M>g_1 := \tau_{0(2),1(4)} \in S</M>,
<M>g_2 := \tau_{0(2),3(4)} \in S</M>, <M>g_3 := \tau_{1(2),0(4)} \in S</M>,
<M>g_4 := \tau_{1(2),2(4)} \in S</M>, <M>h_1 := \tau_{0(4),1(4)} \in S</M>
and <M>h_2 := \tau_{1(4),2(4)} \in S</M>:

<Listing Type="GAP code">
<![CDATA[
ReducingConjugator := function ( tau )

  local  w, F, g1, g2, g3, g4, h1, h2, h, cls, cl, r;

  g1 := ClassTransposition(0,2,1,4); h1 := ClassTransposition(0,4,1,4);
  g2 := ClassTransposition(0,2,3,4); h2 := ClassTransposition(1,4,2,4);
  g3 := ClassTransposition(1,2,0,4);
  g4 := ClassTransposition(1,2,2,4);

  F := FreeGroup("g1","g2","g3","g4","h1","h2");

  w := One(F); if Mod(tau) <= 4 then return w; fi;

  # Before we can reduce the moduli of the interchanged residue classes,
  # we must make sure that both of them have at least modulus 4.
  cls := TransposedClasses(tau);
  if Mod(cls[1]) = 2 then
    if Residue(cls[1]) = 0 then
      if Residue(cls[2]) mod 4 = 1 then tau := tau^g2; w := w * F.2;
                                   else tau := tau^g1; w := w * F.1; fi;
    else
      if Residue(cls[2]) mod 4 = 0 then tau := tau^g4; w := w * F.4;
                                   else tau := tau^g3; w := w * F.3; fi;
    fi;
  fi;

  while Mod(tau) > 4 do # Now we can successively reduce the moduli.
    if not ForAny(AllResidueClassesModulo(2),
                  cl -> IsEmpty(Intersection(cl,Support(tau))))
    then
      cls := TransposedClasses(tau);
      h := Filtered([h1,h2],
             hi->Length(Filtered(cls,cl->IsSubset(Support(hi),cl)))=1);
      h := h[1]; tau := tau^h;
      if h = h1 then w := w * F.5; else w := w * F.6; fi;
    fi;
    cl := TransposedClasses(tau)[2]; # class with larger modulus
    r  := Residue(cl);
    if   r mod 4 = 1 then tau := tau^g1; w := w * F.1;
    elif r mod 4 = 3 then tau := tau^g2; w := w * F.2;
    elif r mod 4 = 0 then tau := tau^g3; w := w * F.3;
    elif r mod 4 = 2 then tau := tau^g4; w := w * F.4; fi;
  od;

  return w;
end;
]]>
</Listing>

After assigning <C>g1</C>, <C>g2</C>, <C>g3</C>, <C>g4</C>, <C>h1</C>
and <C>h2</C> appropriately, we obtain for example:

<Listing Type="Example">
<![CDATA[
gap> ReducingConjugator(ClassTransposition(3,16,34,256));
h2*g1*h1*g1*h1*g1*h1*g1*h2*g2*h2*g4*h2*g4*h2*g3
gap> gamma := h2*g1*h1*g1*h1*g1*h1*g1*h2*g2*h2*g4*h2*g4*h2*g3;
<rcwa permutation of Z with modulus 256>
gap> ct := ClassTransposition(3,16,34,256)^gamma;;
gap> IsClassTransposition(ct);;
gap> ct;
ClassTransposition(1,4,2,4)
]]>
</Listing>

Thompson's group V can also be embedded in a natural way into CT(GF(2)[x]):

<Example>
<![CDATA[
gap> x := Indeterminate(GF(2));; SetName(x,"x");
gap> R := PolynomialRing(GF(2),1);;
gap> k := ClassTransposition(0,x,1,x);;
gap> l := ClassTransposition(1,x,x,x^2);;
gap> m := ClassTransposition(0,x,1,x^2);;
gap> n := ClassTransposition(1,x^2,x,x^2);;
gap> G := Group(k,l,m,n);
<rcwa group over GF(2)[x] with 4 generators>
]]>
</Example>

The correctness of this representation can likewise be verified by simply
checking the defining relations given above. <P/>

Enter <C>AssignGlobals(LoadRCWAExamples().HigmanThompson);</C>
in order to assign the global variables defined in this section.

</Section>



<Section Label="sec:FactoringTheCollatzPermutation">
<Heading>
  Factoring Collatz' permutation of the integers
</Heading>

In 1932, Lothar Collatz mentioned in his notebook the following permutation
of the integers:

<Example>
<![CDATA[
gap> Collatz := RcwaMapping([[2,0,3],[4,-1,3],[4,1,3]]);;
gap> Display(Collatz);

Rcwa mapping of Z with modulus 3

        /
        | 2n/3     if n in 0(3)
n |-> <  (4n-1)/3 if n in 1(3)
        | (4n+1)/3 if n in 2(3)
        \

gap> ShortCycles(Collatz,[-50..50],50); # There are some finite cycles:
[ [ 0 ], [ -1 ], [ 1 ], [ 2, 3 ], [ -2, -3 ], [ 4, 5, 7, 9, 6 ],
  [ -4, -5, -7, -9, -6 ],
  [ 44, 59, 79, 105, 70, 93, 62, 83, 111, 74, 99, 66 ],
  [ -44, -59, -79, -105, -70, -93, -62, -83, -111, -74, -99, -66 ] ]
]]>
</Example>

The cycle structure of Collatz' permutation has not been completely
determined yet. In particular it is not known whether the cycle
containing 8 is finite or infinite.
Nevertheless, the factorization routine included in this package can
determine a factorization of this permutation into class transpositions,
i.e. involutions interchanging two disjoint residue classes:

<Example>
<![CDATA[
gap> Collatz in CT(Integers);  # `Collatz' lies in the simple group CT(Z).
true
gap> Length(Factorization(Collatz));
212
]]>
</Example>

Setting the Info level of <C>InfoRCWA</C> equal to 2 (simply issue
<C>RCWAInfo(2);</C>) causes the factorization routine to display detailed
information on the progress of the factoring process. For reasons of saving
space, this is not done in this manual. <P/>

We would like to get a factorization into fewer factors. Firstly, we try
to factor the inverse -- just like the various options interpreted by the
factorization routine, this has influence on decisions taken during the
factoring process:

<Example>
<![CDATA[
gap> Length(Factorization(Collatz^-1));
129
]]>
</Example>

This is already a shorter product, but can still be improved.
We remember the <C>mKnot</C>'s, of which the permutation mKnot(3)
looks very similar to Collatz' permutation. Therefore it is straightforward
to try to factor both <C>mKnot(3)</C> and <C>Collatz/mKnot(3)</C>, and to
look whether the sum of the numbers of factors is less than 129:

<Example>
<![CDATA[
gap> KnotFacts := Factorization(mKnot(3));;
gap> QuotFacts := Factorization(Collatz/mKnot(3));;
gap> List([KnotFacts,QuotFacts],Length);
[ 59, 9 ]
gap> CollatzFacts := Concatenation(QuotFacts,KnotFacts);
[ ( 0(6), 4(6) ), ( 0(6), 5(6) ), ( 0(6), 3(6) ), ( 0(6), 1(6) ),
  ( 0(6), 2(6) ), ( 2(3), 4(6) ), ( 0(3), 4(6) ), ( 2(3), 1(6) ),
  ( 0(3), 1(6) ), ( 0(36), 35(36) ), ( 0(36), 22(36) ),
  ( 0(36), 18(36) ), ( 0(36), 17(36) ), ( 0(36), 14(36) ),
  ( 0(36), 20(36) ), ( 0(36), 4(36) ), ( 2(36), 8(36) ),
  ( 2(36), 16(36) ), ( 2(36), 13(36) ), ( 2(36), 9(36) ),
  ( 2(36), 7(36) ), ( 2(36), 6(36) ), ( 2(36), 3(36) ),
  ( 2(36), 10(36) ), ( 2(36), 15(36) ), ( 2(36), 12(36) ),
  ( 2(36), 5(36) ), ( 21(36), 28(36) ), ( 21(36), 33(36) ),
  ( 21(36), 30(36) ), ( 21(36), 23(36) ), ( 21(36), 34(36) ),
  ( 21(36), 31(36) ), ( 21(36), 27(36) ), ( 21(36), 25(36) ),
  ( 21(36), 24(36) ), ( 26(36), 32(36) ), ( 26(36), 29(36) ),
  ( 10(18), 35(36) ), ( 5(18), 35(36) ), ( 10(18), 17(36) ),
  ( 5(18), 17(36) ), ( 8(12), 14(24) ), ( 6(9), 17(18) ),
  ( 3(9), 17(18) ), ( 0(9), 17(18) ), ( 6(9), 16(18) ), ( 3(9), 16(18) ),
  ( 0(9), 16(18) ), ( 6(9), 11(18) ), ( 3(9), 11(18) ), ( 0(9), 11(18) ),
  ( 6(9), 4(18) ), ( 3(9), 4(18) ), ( 0(9), 4(18) ), ( 0(6), 14(24) ),
  ( 0(6), 2(24) ), ( 8(12), 17(18) ), ( 7(12), 17(18) ),
  ( 8(12), 11(18) ), ( 7(12), 11(18) ), PrimeSwitch(3)^-1,
  ( 7(12), 17(18) ), ( 2(6), 17(18) ), ( 0(3), 17(18) ),
  PrimeSwitch(3)^-1, PrimeSwitch(3)^-1, PrimeSwitch(3)^-1 ]
gap> Product(CollatzFacts) = Collatz; # Check.
true
]]>
</Example>

The factors <C>PrimeSwitch(3)</C> are products of 6 class transpositions
(cf. <Ref Func="PrimeSwitch" Label="p"/>). <P/>

Enter <C>AssignGlobals(LoadRCWAExamples().CollatzlikePerms);</C>
in order to assign the global variables defined in this section.

</Section>



<Section Label="sec:3nplus1Group">
<Heading>
  The <M>3n+1</M> group
</Heading>

The following group acts transitively on the set of positive integers
for which the <M>3n+1</M> conjecture holds and which are not divisible by 6:

<Example>
<![CDATA[
gap> a := ClassTransposition(1,2,4,6);;
gap> b := ClassTransposition(1,3,2,6);;
gap> c := ClassTransposition(2,3,4,6);;
gap> G := Group(a,b,c);
<(1(2),4(6)),(1(3),2(6)),(2(3),4(6))>
gap> LoadDatabaseOfGroupsGeneratedBy3ClassTranspositions();
"3CTsGroups6"
gap> 3CTsGroups6.Id3CTsGroup(G,3CTsGroups6.grps); # 'catalogue number' of G
44132
]]>
</Example>

To see this, consider the action of <M>G</M> on the <Q><M>3n+1</M> tree</Q>.
The vertices of this tree are the positive integers for which the <M>3n+1</M>
conjecture holds, and for every vertex <M>n</M> there is an edge from
<M>n</M> to <M>T(n)</M>, where <M>T</M> denotes the Collatz mapping
<Alt Only="LaTeX">
  <Display>
  <![CDATA[T: \ \ \mathbb{Z} \longrightarrow \mathbb{Z}, \ \ \ \
    n \ \longmapsto \
    \begin{cases}
      \frac{n}{2}    & \text{if} \ \ n \ \ \text{is even}, \\
      \frac{3n+1}{2} & \text{if} \ \ n \ \ \text{is odd}
    \end{cases}]]>
  </Display>
</Alt>
<Alt Only="HTML"><![CDATA[<center>
  <img src = "collatz.png" width = "342" height = "63"
       alt = "T: Z -> Z, n |-> (n/2 if n even, (3n+1)/2 if n odd)"/>
</center>]]></Alt>
<Alt Only="Text"><Verb><![CDATA[
                                      /
                                      | n/2 if n even,
               T:  Z -> Z,   n  |->  <
                                      | (3n+1)/2 if n odd
                                      \
]]></Verb></Alt>
(cf. Chapter <Ref Label="ch:AboutRCWA"/>).
It is easy to check that for every vertex <M>n</M>, either <M>a</M>,
<M>b</M> or <M>c</M> maps <M>n</M> to <M>T(n)</M>, and that the
other two generators either fix <M>n</M> or map it to one of its
preimages under <M>T</M>.
So the <M>3n+1</M> conjecture is equivalent to the assertion that the
group <M>G</M> acts transitively on <M>\mathbb{N} \setminus 0(6)</M>.
First let's have a look at balls of small radius about 1 under the
action of <M>G</M> -- these consist of those numbers whose trajectory
under <M>T</M> reaches 1 quickly:

<Example>
<![CDATA[
gap> Ball(G,1,5,OnPoints);
[ 1, 2, 4, 5, 8, 10, 16, 32, 64 ]
gap> Ball(G,1,10,OnPoints);
[ 1, 2, 3, 4, 5, 8, 10, 13, 16, 20, 21, 26, 32, 40, 52, 53, 64, 80, 85,
  128, 160, 170, 256, 320, 340, 341, 512, 1024, 2048 ]
gap> Ball(G,1,15,OnPoints);
[ 1, 2, 3, 4, 5, 7, 8, 10, 11, 13, 16, 17, 20, 21, 22, 23, 26, 32, 34,
  35, 40, 44, 45, 46, 52, 53, 64, 68, 69, 70, 75, 80, 85, 104, 106, 113,
  128, 136, 140, 141, 151, 160, 170, 208, 212, 213, 226, 227, 256, 272,
  277, 280, 301, 302, 320, 340, 341, 416, 424, 452, 453, 454, 512, 640,
  680, 682, 832, 848, 853, 904, 908, 909, 1024, 1280, 1360, 1364, 1365,
  1664, 1696, 1706, 1808, 1813, 1816, 2048, 2560, 2720, 2728, 4096,
  5120, 5440, 5456, 5461, 8192, 10240, 10880, 10912, 10922, 16384,
  32768, 65536 ]
gap> Ball(G,1,15,OnPoints:Spheres);
[ [ 1 ], [ 2, 4 ], [ 8 ], [ 16 ], [ 5, 32 ], [ 10, 64 ],
  [ 3, 20, 21, 128 ], [ 40, 256 ], [ 13, 80, 85, 512 ],
  [ 26, 160, 170, 1024 ], [ 52, 53, 320, 340, 341, 2048 ],
  [ 17, 104, 106, 113, 640, 680, 682, 4096 ],
  [ 34, 35, 208, 212, 213, 226, 227, 1280, 1360, 1364, 1365, 8192 ],
  [ 11, 68, 69, 70, 75, 416, 424, 452, 453, 454, 2560, 2720, 2728, 16384
     ],
  [ 22, 23, 136, 140, 141, 151, 832, 848, 853, 904, 908, 909, 5120,
      5440, 5456, 5461, 32768 ],
  [ 7, 44, 45, 46, 272, 277, 280, 301, 302, 1664, 1696, 1706, 1808,
      1813, 1816, 10240, 10880, 10912, 10922, 65536 ] ]
gap> List(Ball(G,1,50,OnPoints:Spheres),Length);
[ 1, 2, 1, 1, 2, 2, 4, 2, 4, 4, 6, 8, 12, 14, 17, 20, 26, 32, 43, 52,
  66, 81, 104, 133, 170, 211, 271, 335, 424, 542, 686, 873, 1096, 1376,
  1730, 2205, 2794, 3522, 4429, 5611, 7100, 8978, 11343, 14296, 18058,
  22828, 28924, 36532, 46146, 58399, 73713 ]
gap> FloatQuotientsList(last);
[ 2., 0.5, 1., 2., 1., 2., 0.5, 2., 1., 1.5, 1.33333, 1.5, 1.16667,
  1.21429, 1.17647, 1.3, 1.23077, 1.34375, 1.2093, 1.26923, 1.22727,
  1.28395, 1.27885, 1.2782, 1.24118, 1.28436, 1.23616, 1.26567, 1.2783,
  1.26568, 1.27259, 1.25544, 1.25547, 1.25727, 1.27457, 1.26712,
  1.26056, 1.25752, 1.26688, 1.26537, 1.26451, 1.26342, 1.26034,
  1.26315, 1.26415, 1.26704, 1.26303, 1.26317, 1.26553, 1.26223 ]
gap> Difference(Filtered([1..100],n->n mod 6 <> 0),Ball(G,1,40,OnPoints));
[ 27, 31, 41, 47, 55, 62, 63, 71, 73, 82, 83, 91, 94, 95, 97 ]
gap> T := RcwaMapping([[1,0,2],[3,1,2]]);;
gap> List(last2,n->Length(Trajectory(T,n,[1])));
[ 71, 68, 70, 67, 72, 69, 69, 66, 74, 71, 71, 60, 68, 68, 76 ]
]]>
</Example>

It is convenient to define an epimorphism from the free group of rank 3
to <M>G</M>:

<Example>
<![CDATA[
gap> F := FreeGroup("a","b","c");
<free group on the generators [ a, b, c ]>
gap> phi := EpimorphismByGenerators(F,G);
[ a, b, c ] -> [ ( 1(2), 4(6) ), ( 1(3), 2(6) ), ( 2(3), 4(6) ) ]
]]>
</Example>

We can compute balls about 1 in <M>G</M>:

<Example>
<![CDATA[
gap> B := Ball(G,One(G),7:Spheres);;
gap> List(B,Length);
[ 1, 3, 6, 12, 24, 48, 96, 192 ]
gap> List(B[3],Order);
[ 12, infinity, infinity, infinity, infinity, 12 ]
gap> List(B[3],g->PreImagesRepresentative(phi,g));
[ b*a, c*b, c*a, b*c, a*c, a*b ]
gap> g := a*b;; Order(g);;
gap> Display(g);

Rcwa permutation of Z with modulus 18, of order 12

( 1(6), 8(36), 4(18), 2(12) ) ( 3(6), 20(36), 10(18) )
( 5(6), 32(36), 16(18) )

]]>
</Example>

Spending some more time to compute <C>B := Ball(G,One(G),12:Spheres);;</C>,
one can check that <M>(ab)^{12}</M> is the shortest word in the generators
of <M>G</M> which does not represent the identity in the free product of
3 cyclic groups of order 2, but which represents the identity in <M>G</M>.
However, the group <M>G</M> has elements of other finite orders as well --
for example:

<Example>
<![CDATA[
gap> g := (b*a)^3*b*c;; Order(g);;
gap> Display(g);

Rcwa permutation of Z with modulus 36, of order 105

( 8(9), 16(18), 64(72), 256(288), 85(96), 128(144), 32(36) )
( 7(12), 11(18), 22(36) ) ( 5(18), 10(36), 40(144), 13(48),
  20(72) ) ( 1(24), 2(36), 4(72) ) ( 14(36), 28(72), 112(288),
  37(96), 56(144) )

gap> Order(a*c*b*a*b*c*a*c);
60
]]>
</Example>

With some more efforts, one finds that e.g. <M>(abc)^2c^b</M> has order
616, that <M>(abc)^2b</M> has order 2310, that <M>(ab)^2a^ca^bc</M> has
order 27720, and that <M>a(c(ab)^2)^2</M> has order 65520.
Of course <M>G</M> has many elements of infinite order as well.
Some of them have infinite cycles, like e.g.

<Example>
<![CDATA[
gap> g := b*c;;
gap> Display(g);

Rcwa permutation of Z with modulus 12

        /
        | 4n  if n in 1(3)
        | 2n  if n in 5(6)
n |-> <  n/2 if n in 2(12)
        | n/4 if n in 8(12)
        | n   if n in 0(3)
        \

gap> Sinks(g);
[ 4(12) ]
gap> Trajectory(g,last[1],10);
[ 4(12), 16(48), 64(192), 256(768), 1024(3072), 4096(12288),
  16384(49152), 65536(196608), 262144(786432), 1048576(3145728) ]
gap> Trajectory(g,4,20);
[ 4, 16, 64, 256, 1024, 4096, 16384, 65536, 262144, 1048576, 4194304,
  16777216, 67108864, 268435456, 1073741824, 4294967296, 17179869184,
  68719476736, 274877906944, 1099511627776 ]
]]>
</Example>

Others seem to have only finite cycles. Some of these appear to have
<Q>on average</Q> comparatively <Q>short</Q> cycles, like e.g.

<Example>
<![CDATA[
gap> g := a*b*a*c*b*c;
<rcwa permutation of Z with modulus 144>
gap> cycs := ShortCycles(g,[0..10000],100,10^20);;
gap> Difference([0..10000],Union(cycs));
[  ]
gap> Collected(List(cycs,Length));
[ [ 1, 2222 ], [ 3, 1945 ], [ 4, 1111 ], [ 5, 93 ], [ 6, 926 ],
  [ 7, 31 ], [ 8, 864 ], [ 9, 10 ], [ 10, 289 ], [ 11, 4 ], [ 12, 95 ],
  [ 13, 1 ], [ 14, 31 ], [ 16, 12 ], [ 18, 4 ], [ 20, 1 ] ]
]]>
</Example>

If the cycle of <M>g</M> containing some <M>n \in &ZZ;</M> is finite
and has a certain length <M>l</M>, then there is some <M>m \in &ZZ;</M>
such that for every <M>k \in &ZZ;</M> the cycle of <M>g</M> containing
<M>n + km</M> has length <M>l</M> as well. Thus, in other words, every
finite cycle of <M>g</M> <Q>belongs to</Q> a cycle of residue classes.
(This is a special property of <M>g</M> which is not shared by every
rcwa permutation -- cf. e.g. Collatz' permutation from
Section <Ref Label="sec:FactoringTheCollatzPermutation"/>.)
We can find some of these infinitely many <Q>residue class cycles</Q>:

<Example>
<![CDATA[
gap> cycsrc := ShortResidueClassCycles(g,Mod(g),20);
[ [ 0(6) ], [ 3(6), 160(288), 20(36) ],
  [ 7(18), 352(864), 44(108), 28(72) ],
  [ 11(18), 544(864), 2896(4608), 362(576), 68(108), 88(144) ],
  [ 13(18), 640(864), 80(108), 52(72) ], [ 10(36) ], [ 34(36) ],
  [ 1(54), 64(2592), 8(324), 4(216), 16(1152), 2(144) ],
  [ 5(54), 256(2592), 1360(13824), 170(1728), 32(324), 40(432),
      208(2304), 26(288) ],
  [ 17(54), 832(2592), 4432(13824), 23632(73728), 2954(9216), 554(1728),
      104(324), 136(432) ],
  [ 37(54), 1792(2592), 224(324), 148(216), 784(1152), 98(144) ],
  [ 41(54), 1984(2592), 10576(13824), 1322(1728), 248(324), 328(432),
      1744(2304), 218(288) ],
  [ 53(54), 2560(2592), 13648(13824), 72784(73728), 9098(9216),
      1706(1728), 320(324), 424(432) ], [ 38(72), 58(108), 304(576) ],
  [ 62(72), 94(108), 496(576) ] ]
gap> List(cycsrc,Length);
[ 1, 3, 4, 6, 4, 1, 1, 6, 8, 8, 6, 8, 8, 3, 3 ]
gap> Sum(List(Flat(cycsrc),cl->1/Mod(cl)));
97459/110592
gap> Float(last); # about 88% 'coverage'
0.881248
gap> cycsrc := ShortResidueClassCycles(g,3*Mod(g),20);
[ [ 0(6) ], [ 3(6), 160(288), 20(36) ],
  [ 7(18), 352(864), 44(108), 28(72) ],
  [ 11(18), 544(864), 2896(4608), 362(576), 68(108), 88(144) ],
  [ 13(18), 640(864), 80(108), 52(72) ], [ 10(36) ], [ 34(36) ],
  [ 1(54), 64(2592), 8(324), 4(216), 16(1152), 2(144) ],
  [ 5(54), 256(2592), 1360(13824), 170(1728), 32(324), 40(432),
      208(2304), 26(288) ],
  [ 17(54), 832(2592), 4432(13824), 23632(73728), 2954(9216), 554(1728),
      104(324), 136(432) ],
  [ 37(54), 1792(2592), 224(324), 148(216), 784(1152), 98(144) ],
  [ 41(54), 1984(2592), 10576(13824), 1322(1728), 248(324), 328(432),
      1744(2304), 218(288) ],
  [ 53(54), 2560(2592), 13648(13824), 72784(73728), 9098(9216),
      1706(1728), 320(324), 424(432) ], [ 38(72), 58(108), 304(576) ],
  [ 62(72), 94(108), 496(576) ],
  [ 23(162), 1120(7776), 5968(41472), 746(5184), 140(972), 184(1296),
      976(6912), 5200(36864), 650(4608), 122(864) ],
  [ 35(162), 1696(7776), 9040(41472), 48208(221184), 257104(1179648),
      32138(147456), 6026(27648), 1130(5184), 212(972), 280(1296) ],
  [ 73(162), 3520(7776), 440(972), 292(648), 1552(3456), 8272(18432),
      1034(2304), 194(432) ],
  [ 77(162), 3712(7776), 19792(41472), 2474(5184), 464(972), 616(1296),
      3280(6912), 17488(36864), 2186(4608), 410(864) ],
  [ 89(162), 4288(7776), 22864(41472), 121936(221184), 650320(1179648),
      81290(147456), 15242(27648), 2858(5184), 536(972), 712(1296) ],
  [ 127(162), 6112(7776), 764(972), 508(648), 2704(3456), 14416(18432),
      1802(2304), 338(432) ],
  [ 14(216), 22(324), 112(1728), 592(9216), 74(1152) ],
  [ 86(216), 130(324), 688(1728), 3664(9216), 458(1152) ] ]
gap> List(cycsrc,Length);
[ 1, 3, 4, 6, 4, 1, 1, 6, 8, 8, 6, 8, 8, 3, 3, 10, 10, 8, 10, 10, 8, 5,
  5 ]
gap> Sum(List(Flat(cycsrc),Density));
5097073/5308416
gap> Float(last); # already about 96% 'coverage'
0.960187
]]>
</Example>

There are also some elements of infinite order whose cycles seem to be
all finite, but <Q>on average</Q> pretty <Q>long</Q> -- e.g.

<Example>
<![CDATA[
gap> g := (b*a*c)^2*a;;
gap> Display(g);

Rcwa permutation of Z with modulus 288

        /
        | (16n-1)/3   if n in 1(3)
        | (9n+5)/4    if n in 3(24) U 11(24)
        | (27n+19)/4  if n in 15(24) U 23(24)
        | (3n+1)/4    if n in 5(24)
        | (n-3)/6     if n in 21(24)
        | (27n+29)/8  if n in 9(48) U 41(48)
        | (9n+7)/8    if n in 17(48) U 33(48)
        | (2n-7)/9    if n in 8(36)
n |-> <  (4n-11)/9   if n in 32(36)
        | (27n+38)/8  if n in 14(48)
        | (3n+2)/8    if n in 26(48)
        | (9n+10)/8   if n in 38(48)
        | (3n+4)/4    if n in 20(72)
        | n/4         if n in 56(72)
        | (9n+14)/16  if n in 2(96)
        | (27n+58)/16 if n in 50(96)
        | n           if n in 0(6)
        \

gap> List([1..100],n->Length(Cycle(g,n)));
[ 6, 1, 6, 6, 6, 1, 194, 6, 216, 26, 26, 1, 26, 194, 65, 26, 26, 1, 216,
  26, 6, 216, 46, 1, 640, 26, 70, 194, 216, 1, 70, 26, 216, 216, 26, 1,
  194, 216, 73, 26, 110, 1, 194, 216, 194, 111, 39, 1, 194, 640, 640,
  194, 26, 1, 171, 194, 204, 640, 216, 1, 111, 70, 91, 26, 194, 1, 216,
  216, 26, 111, 65, 1, 50, 194, 26, 216, 640, 1, 502, 26, 111, 40, 110,
  1, 26, 194, 385, 640, 88, 1, 100, 111, 65, 110, 416, 1, 171, 194, 194,
  640 ]
gap> Length(Cycle(g,25));
640
gap> Maximum(Cycle(g,25));
323270249684063829
gap> Length(Cycle(g,25855));
4751
gap> Maximum(Cycle(g,25855));
507359605810239426786254778159924369135184044618585904603866210104085
gap> cycs := ShortCycles(g,[0..50000],10000,10^100);;
gap> S := [0..50000];;
gap> for cyc in cycs do S := Difference(S,cyc); od;
gap> S; # no cycle containing some n in [0..50000] has length > 10000
[  ]
]]>
</Example>

Taking a look at the lengths of the trajectories of the Collatz mapping
<M>T</M> starting at the points in a cycle, we can see how a cycle of
<M>g</M> goes <Q>up and down</Q> in the <M>3n+1</M> tree:

<Example>
<![CDATA[
gap> List(Cycle(g,25),n->Length(Trajectory(T,n,[1])));
[ 17, 21, 25, 29, 33, 31, 35, 34, 32, 33, 37, 41, 45, 44, 42, 39, 43,
  41, 45, 44, 42, 43, 40, 38, 35, 39, 37, 41, 40, 44, 48, 46, 50, 49,
  47, 48, 45, 42, 46, 44, 48, 47, 45, 46, 50, 49, 47, 43, 41, 38, 39,
  36, 34, 30, 27, 31, 29, 33, 32, 30, 31, 35, 33, 37, 36, 40, 39, 43,
  41, 45, 44, 42, 43, 47, 51, 55, 53, 57, 56, 54, 55, 59, 58, 62, 66,
  64, 68, 67, 65, 66, 63, 60, 64, 62, 66, 65, 63, 64, 68, 67, 65, 61,
  59, 56, 52, 49, 53, 51, 55, 54, 52, 53, 57, 55, 59, 58, 56, 57, 54,
  50, 48, 45, 49, 47, 51, 50, 54, 52, 56, 55, 53, 54, 58, 62, 66, 70,
  74, 72, 76, 75, 79, 83, 87, 91, 90, 94, 93, 97, 95, 99, 98, 96, 97,
  94, 91, 88, 85, 89, 87, 91, 90, 88, 89, 86, 84, 81, 85, 83, 87, 86,
  90, 94, 98, 97, 101, 105, 109, 107, 111, 110, 108, 109, 113, 117, 115,
  119, 118, 122, 126, 125, 123, 120, 124, 122, 126, 125, 123, 124, 121,
  119, 116, 117, 114, 111, 115, 113, 117, 116, 114, 115, 119, 123, 122,
  120, 117, 121, 119, 123, 122, 120, 121, 118, 116, 112, 110, 106, 103,
  107, 105, 109, 108, 106, 107, 111, 109, 113, 112, 116, 114, 118, 117,
  115, 116, 113, 110, 111, 108, 104, 102, 99, 103, 101, 105, 104, 108,
  106, 110, 109, 107, 108, 112, 111, 109, 105, 102, 103, 100, 98, 95,
  92, 96, 94, 98, 97, 95, 96, 93, 91, 88, 92, 90, 94, 93, 97, 101, 105,
  109, 108, 106, 103, 107, 105, 109, 108, 106, 107, 104, 102, 99, 103,
  101, 105, 104, 108, 112, 110, 114, 113, 111, 112, 116, 115, 113, 109,
  106, 110, 108, 112, 111, 109, 110, 114, 112, 116, 115, 113, 114, 111,
  107, 105, 102, 103, 100, 98, 95, 99, 97, 101, 100, 104, 103, 107, 105,
  109, 108, 106, 107, 104, 101, 98, 99, 96, 94, 91, 92, 89, 87, 84, 85,
  82, 80, 77, 81, 79, 83, 82, 86, 85, 89, 88, 86, 83, 80, 81, 78, 76,
  73, 74, 71, 68, 72, 70, 74, 73, 71, 72, 76, 80, 79, 83, 87, 91, 90,
  88, 85, 89, 87, 91, 90, 88, 89, 86, 84, 81, 85, 83, 87, 86, 90, 94,
  92, 96, 95, 93, 94, 98, 96, 100, 99, 97, 98, 102, 106, 110, 114, 113,
  111, 108, 112, 110, 114, 113, 111, 112, 109, 107, 104, 108, 106, 110,
  109, 113, 117, 115, 119, 118, 116, 117, 114, 111, 115, 113, 117, 116,
  114, 115, 119, 118, 116, 112, 110, 107, 108, 105, 103, 100, 104, 102,
  106, 105, 109, 108, 112, 110, 114, 113, 111, 112, 116, 115, 113, 109,
  106, 103, 104, 101, 99, 95, 91, 88, 92, 90, 94, 93, 91, 92, 96, 94,
  98, 97, 95, 96, 100, 98, 102, 101, 105, 104, 102, 99, 100, 97, 93, 89,
  87, 84, 85, 82, 80, 77, 74, 78, 76, 80, 79, 77, 78, 75, 73, 69, 67,
  64, 68, 66, 70, 69, 73, 71, 75, 74, 72, 73, 70, 67, 68, 65, 63, 60,
  64, 62, 66, 65, 69, 68, 66, 63, 64, 61, 59, 56, 60, 58, 62, 61, 65,
  64, 62, 59, 60, 57, 55, 51, 48, 49, 46, 44, 40, 37, 34, 35, 32, 28,
  26, 23, 27, 25, 29, 28, 32, 30, 34, 33, 31, 32, 36, 35, 33, 29, 26,
  27, 24, 22, 19, 23, 21, 25, 24, 28, 27, 25, 22, 23, 20, 18, 14, 18,
  22, 20, 24, 23, 21, 22, 19, 16, 20, 18, 22, 21, 19, 20, 24, 23, 21,
  17, 15, 17, 15, 19, 18, 16 ]
gap> lngs := List(Cycle(g,25855),n->Length(Trajectory(T,n,[1])));;
gap> Minimum(lngs);
55
gap> Maximum(lngs);
521
gap> Position(lngs,55);
15
gap> Position(lngs,521);
2807
]]>
</Example>

Finally let's have a look at elements of G with small modulus:

<Example>
<![CDATA[
gap> B := RestrictedBall(G,One(G),20,36:Spheres);;
gap> List(B,Length);
[ 1, 3, 6, 12, 4, 6, 6, 4, 4, 4, 6, 6, 3, 3, 2, 0, 0, 0, 0, 0, 0 ]
gap> Sum(last);
70
gap> Position(last2,0)-2;
14
]]>
</Example>

So we have 70 elements of modulus 36 or less in <M>G</M> which
can be reached from the identity by successive multiplication with
generators without passing elements with mudulus exceeding 36.
Further we see that the longest word in the generators yielding an
element with modulus at most 36 has length 14.
Now we double our bound on the modulus:

<Example>
<![CDATA[
gap> B := RestrictedBall(G,One(G),100,72:Spheres);;
gap> List(B,Length);
[ 1, 3, 6, 12, 22, 14, 18, 22, 24, 26, 26, 34, 35, 32, 37, 38, 46, 58,
  65, 73, 82, 91, 93, 96, 110, 121, 114, 117, 146, 138, 148, 168, 174,
  196, 215, 214, 232, 255, 280, 305, 315, 359, 377, 371, 363, 366, 397,
  419, 401, 405, 405, 401, 407, 415, 435, 424, 401, 359, 338, 330, 332,
  281, 278, 271, 269, 254, 255, 257, 258, 258, 233, 215, 202, 185, 154,
  121, 88, 55, 35, 20, 10, 5, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  0, 0, 0, 0, 0 ]
gap> Sum(last);
15614
gap> Position(last2,0)-2;
83
gap> Collected(List(Flat(B),Modulus));
[ [ 1, 1 ], [ 6, 3 ], [ 12, 4 ], [ 18, 2 ], [ 24, 4 ], [ 36, 56 ],
  [ 48, 4 ], [ 72, 15540 ] ]
]]>
</Example>

We observe that there are 15540 elements in <M>G</M> with modulus 72
which are <Q>reachable</Q> from the identity by successive
multiplication with generators without passing elements with mudulus
exceeding 72. Further we see that the longest word in the generators
yielding an element with modulus at most 72 has length 83. <P/>

It is obvious that many questions regarding the group <M>G</M>
remain open.

</Section>



<Section Label="sec:GroupWithHugeFiniteOrbits">
<Heading>
  A group with huge finite orbits
</Heading>

In this section we investigate a group which has huge finite orbits on &ZZ;.

<Example>
<![CDATA[
gap> a := ClassTransposition(0,2,1,2);;
gap> b := ClassTransposition(0,5,4,5);;
gap> c := ClassTransposition(1,4,0,6);;
gap> G := Group(a,b,c);
<(0(2),1(2)),(0(5),4(5)),(1(4),0(6))>
gap> LoadDatabaseOfGroupsGeneratedBy3ClassTranspositions();
"3CTsGroups6"
gap> 3CTsGroups6.Id3CTsGroup(G,3CTsGroups6.grps); # 'catalogue number' of G
1284
]]>
</Example>

We look for orbits of length at most 100 containing an integer in the
range <C>[0..1000]</C>:

<Example>
<![CDATA[
gap> orbs := ShortOrbits(G,[0..1000],100);;
gap> List(orbs,Length);
[ 16, 2, 24, 2, 2, 2, 8, 2, 8, 2, 2, 8, 2, 8, 2, 2, 2, 40, 2, 8, 24, 2,
  8, 2, 2, 8, 2, 24, 8, 2, 56, 2, 2, 2, 8, 2, 8, 2, 2, 8, 2, 8, 2, 2, 2,
  24, 2, 8, 2, 8, 2, 2, 8, 2, 8, 2, 24, 2, 2, 2, 8, 2, 8, 2, 2, 8, 2, 8,
  2, 2, 2, 2, 8, 24, 2, 8, 2, 2, 8, 2, 24, 8, 2, 2, 2, 2, 8, 2, 8, 2, 2,
  8, 2, 8, 2, 2, 2, 24, 2, 8, 2, 8, 2, 2, 8, 2, 8, 2, 24, 2, 2 ]
gap> Collected(last);
[ [ 2, 67 ], [ 8, 32 ], [ 16, 1 ], [ 24, 9 ], [ 40, 1 ], [ 56, 1 ] ]
gap> Length(Difference([0..1000],Union(orbs)));
491
]]>
</Example>

So almost half of the integers in the range <C>[0..1000]</C> lie in
orbits of length larger than 100. In fact there are much larger orbits.
For example:

<Example>
<![CDATA[
gap> B := Ball(G,32,500,OnPoints:Spheres);; # compute ball about 32
gap> Position(B,[]); # <> fail -> we have exhausted the orbit
354
gap> Sum(List(B,Length)); # the orbit length
6296
gap> Maximum(Flat(B)); # the largest integer in the orbit
3301636381609509797437679
gap> B := Ball(G,736,5000,OnPoints:Spheres);; # the same for 736 ...
gap> Position(B,[]);
2997
gap> Sum(List(B,Length)); # the orbit length for this time
495448
gap> Maximum(Flat(B));
2461374276522713949036151811903149785690151467356354652860276957152301465\
0546360696627187194849439881973442451686685024708652634593861146709752378\
847078493406287854573381920553713155967741550498839
]]>
</Example>

It seems that the cycles of <M>abc</M> completely traverse all orbits
of <M>G</M>, with the only exception of the orbit of 0. Let's check this
in the above examples:

<Example>
<![CDATA[
gap> g := a*b*c;;
gap> Display(g);

Rcwa permutation of Z with modulus 60

        /
        | n-1       if n in 3(30) U 9(30) U 17(30) U 23(30) U 27(30) U
        |                   29(30)
        | 3n/2      if n in 0(20) U 12(20) U 16(20)
        | n+1       if n in 2(20) U 6(20) U 10(20)
        | (2n+1)/3  if n in 7(30) U 13(30) U 19(30)
        | n+3       if n in 1(30) U 11(30)
n |-> <  n-5       if n in 15(30) U 25(30)
        | (3n+12)/2 if n in 4(20)
        | (3n-12)/2 if n in 8(20)
        | n+5       if n in 14(20)
        | n-3       if n in 18(20)
        | (2n-7)/3  if n in 5(30)
        | (2n+9)/3  if n in 21(30)
        \

gap> Length(Cycle(g,32));
6296
gap> Length(Cycle(g,736));
495448
]]>
</Example>

Representatives and lengths of the cycles of <M>g</M> which intersect
nontrivially with the range <C>[0..1000]</C> are as follows:

<Example>
<![CDATA[
gap> CycleRepresentativesAndLengths(g,[0..1000]:notify:=50000);
n = 736: after 50000 steps, the iterate has 157 binary digits.
n = 736: after 100000 steps, the iterate has 135 binary digits.
n = 736: after 150000 steps, the iterate has 131 binary digits.
n = 736: after 200000 steps, the iterate has 507 binary digits.
n = 736: after 250000 steps, the iterate has 414 binary digits.
n = 736: after 300000 steps, the iterate has 457 binary digits.
n = 736: after 350000 steps, the iterate has 465 binary digits.
n = 736: after 400000 steps, the iterate has 325 binary digits.
n = 736: after 450000 steps, the iterate has 534 binary digits.
n = 896: after 50000 steps, the iterate has 359 binary digits.
n = 896: after 100000 steps, the iterate has 206 binary digits.
[ [ 1, 15 ], [ 2, 2 ], [ 16, 24 ], [ 22, 2 ], [ 26, 2 ], [ 32, 6296 ],
  [ 46, 2 ], [ 52, 8 ], [ 56, 296 ], [ 62, 2 ], [ 76, 8 ], [ 82, 2 ],
  [ 86, 2 ], [ 92, 8 ], [ 106, 2 ], [ 112, 104 ], [ 116, 8 ],
  [ 122, 2 ], [ 136, 440 ], [ 142, 2 ], [ 146, 2 ], [ 152, 40 ],
  [ 166, 2 ], [ 172, 8 ], [ 176, 24 ], [ 182, 2 ], [ 196, 8 ],
  [ 202, 2 ], [ 206, 2 ], [ 212, 8 ], [ 226, 2 ], [ 232, 24 ],
  [ 236, 8 ], [ 242, 2 ], [ 256, 56 ], [ 262, 2 ], [ 266, 2 ],
  [ 272, 408 ], [ 286, 2 ], [ 292, 8 ], [ 296, 104 ], [ 302, 2 ],
  [ 316, 8 ], [ 322, 2 ], [ 326, 2 ], [ 332, 8 ], [ 346, 2 ],
  [ 352, 264 ], [ 356, 8 ], [ 362, 2 ], [ 376, 1304 ], [ 382, 2 ],
  [ 386, 2 ], [ 392, 24 ], [ 406, 2 ], [ 412, 8 ], [ 416, 200 ],
  [ 422, 2 ], [ 436, 8 ], [ 442, 2 ], [ 446, 2 ], [ 452, 8 ],
  [ 466, 2 ], [ 472, 104 ], [ 476, 8 ], [ 482, 2 ], [ 496, 24 ],
  [ 502, 2 ], [ 506, 2 ], [ 512, 696 ], [ 526, 2 ], [ 532, 8 ],
  [ 536, 3912 ], [ 542, 2 ], [ 556, 8 ], [ 562, 2 ], [ 566, 2 ],
  [ 572, 8 ], [ 586, 2 ], [ 592, 888 ], [ 596, 8 ], [ 602, 2 ],
  [ 616, 728 ], [ 622, 2 ], [ 626, 2 ], [ 632, 2776 ], [ 646, 2 ],
  [ 652, 8 ], [ 656, 24 ], [ 662, 2 ], [ 676, 8 ], [ 682, 2 ],
  [ 686, 2 ], [ 692, 8 ], [ 706, 2 ], [ 712, 24 ], [ 716, 8 ],
  [ 722, 2 ], [ 736, 495448 ], [ 742, 2 ], [ 746, 2 ], [ 752, 1272 ],
  [ 766, 2 ], [ 772, 8 ], [ 776, 376 ], [ 782, 2 ], [ 796, 8 ],
  [ 802, 2 ], [ 806, 2 ], [ 812, 8 ], [ 826, 2 ], [ 832, 120 ],
  [ 836, 8 ], [ 842, 2 ], [ 856, 2264 ], [ 862, 2 ], [ 866, 2 ],
  [ 872, 24 ], [ 886, 2 ], [ 892, 8 ], [ 896, 132760 ], [ 902, 2 ],
  [ 916, 8 ], [ 922, 2 ], [ 926, 2 ], [ 932, 8 ], [ 946, 2 ],
  [ 952, 456 ], [ 956, 8 ], [ 962, 2 ], [ 976, 24 ], [ 982, 2 ],
  [ 986, 2 ], [ 992, 1064 ] ]
]]>
</Example>

So far the author has checked that all positive integers less than
173176 lie in finite cycles of <M>g</M>. Several of them are longer
than 1000000, and the cycle containing 25952 has length 245719352.
Whether the cycle containing 173176 is finite or infinite has not
been checked so far -- in any case it is longer than 5700000000, and
it exceeds <M>10^{40000}</M>. Presumably it is finite as well, but
checking this may require a lot of computing time. <P/>

On the one hand the cycles of <M>g</M> seem to behave <Q>randomly</Q>,
perhaps as if they would ascend or descend from one point to the next
by a certain factor depending on which side a thrown coin falls on.
-- In this <Q>model</Q>, cycles would be finite with probability 1
since the simple random walk on &ZZ; is recurrent.
On the other, there seems to be quite some structure on them,
however little is known so far. <P/>

First we observe that each orbit under the action of <M>G</M>
seems to split into two cycles of <M>h := abcacb</M> of the same
length (of course this has been checked for many more orbits than
those shown here):

<Example>
<![CDATA[
gap> h := a*b*c*a*c*b;
<rcwa permutation of Z with modulus 360>
gap> List(CyclesOnFiniteOrbit(G,h,32),Length);
[ 3148, 3148 ]
gap> List(CyclesOnFiniteOrbit(G,h,736),Length);
[ 247724, 247724 ]
]]>
</Example>

One cycle seems to contain the points at the odd positions and the
other seems to contain the points at the even positions in the
cycle of <M>g</M>:

<Example>
<![CDATA[
gap> cycle_g := Cycle(g,32);;
gap> positions1 := List(Cycle(h,32),n->Position(cycle_g,n));;
gap> Collected(positions1 mod 2);
[ [ 1, 3148 ] ]
gap> positions2 := List(Cycle(h,33),n->Position(cycle_g,n));;
gap> Collected(positions2 mod 2);
[ [ 0, 3148 ] ]
]]>
</Example>

However the ordering in which these points are traversed looks
pretty <Q>scrambled</Q>:

<Example>
<![CDATA[
gap> positions1{[1..200]};
[ 1, 6271, 6291, 6281, 6285, 6287, 6283, 6289, 6273, 6275, 6277, 6279,
  6293, 5, 15, 17, 19, 6259, 6261, 6263, 6265, 21, 23, 25, 41, 6227,
  6229, 6231, 6233, 6235, 6237, 6239, 43, 53, 55, 57, 63, 59, 61, 65,
  45, 47, 49, 51, 67, 6223, 6221, 69, 6163, 6215, 6205, 6209, 6211,
  6207, 6213, 6165, 6171, 6177, 6179, 6181, 6183, 6175, 6173, 6185,
  6189, 6191, 6187, 6193, 6169, 6167, 6195, 6199, 6201, 6197, 6203,
  6217, 73, 83, 85, 87, 103, 113, 115, 117, 4357, 4361, 4363, 4359,
  4365, 4371, 4373, 4375, 4377, 4369, 4367, 4379, 119, 121, 123, 125,
  129, 131, 127, 133, 139, 141, 143, 145, 137, 135, 147, 149, 151, 153,
  155, 159, 161, 157, 163, 169, 175, 4283, 4281, 177, 4271, 4273, 4275,
  4277, 181, 4255, 4257, 4259, 4261, 4263, 4265, 4267, 183, 2161, 2163,
  4195, 4199, 4201, 4197, 4203, 4209, 4211, 4213, 4215, 4207, 4205,
  4217, 2165, 2167, 2169, 2171, 2175, 2177, 2173, 2179, 2185, 2187,
  2189, 2191, 2183, 2181, 2193, 2195, 2197, 2199, 2201, 2467, 2469,
  4117, 4121, 4123, 4119, 4125, 4131, 4133, 4135, 4137, 4129, 4127,
  4139, 2471, 2473, 2475, 2477, 2487, 2489, 2491, 2507, 2517, 2519,
  2521, 2537, 3923, 3925, 3941, 3943 ]
]]>
</Example>

</Section>



<Section Label="sec:FourTransitiveGroup">
<Heading>
  A group which acts 4-transitively on the positive integers
</Heading>

In this section, we would like to show that the group <M>G</M> generated
by the two permutations

<Example>
<![CDATA[
gap> a := RcwaMapping([[3,0,2],[3,1,4],[3,0,2],[3,-1,4]]);;
gap> u := RcwaMapping([[3,0,5],[9,1,5],[3,-1,5],[9,-2,5],[9,4,5]]);;
gap> SetName(a,"a"); SetName(u,"u"); G := Group(a,u);;
]]>
</Example>

which we have already investigated in earlier examples acts 4-transitively
on the set of positive integers.

Obviously, it acts on the set of positive integers.
First we show that this action is transitive.

We start by checking in which residue classes sufficiently large positive
integers are mapped to smaller ones by a suitable group element:

<Example>
<![CDATA[
gap> List([a,a^-1,u,u^-1],DecreasingOn);
[ 1(2), 0(3), 0(5) U 2(5), 2(3) ]
gap> Union(last);
Z \ 4(30) U 16(30) U 28(30)
]]>
</Example>

We see that we cannot always choose such a group element from the set of
generators and their inverses -- otherwise the union would be
<C>Integers</C>.

<Example>
<![CDATA[
gap> List([a,a^-1,u,u^-1,a^2,a^-2,u^2,u^-2],DecreasingOn);
[ 1(2), 0(3), 0(5) U 2(5), 2(3), 1(8) U 7(8), 0(3) U 2(9) U 7(9),
  0(25) U 12(25) U 17(25) U 20(25), 2(3) U 1(9) U 3(9) ]
gap> Union(last); # Still not enough ...
Z \ 4(90) U 58(90) U 76(90)
gap> List([a,a^-1,u,u^-1,a^2,a^-2,u^2,u^-2,a*u,u*a,(a*u)^-1,(u*a)^-1],
>         DecreasingOn);
[ 1(2), 0(3), 0(5) U 2(5), 2(3), 1(8) U 7(8), 0(3) U 2(9) U 7(9),
  0(25) U 12(25) U 17(25) U 20(25), 2(3) U 1(9) U 3(9),
  3(5) U 0(10) U 7(20) U 9(20), 0(5) U 2(5), 2(3), 3(9) U 4(9) U 8(9) ]
gap> Union(last); # ... but that's it!
Integers
]]>
</Example>

Finally, we have to deal with <Q>small</Q> integers. We use the notation for
the coefficients of rcwa mappings introduced at the beginning of this manual.
Let <M>c_{r(m)} > a_{r(m)}</M>. Then we easily see that
<M>(a_{r(m)}n+b_{r(m)})/c_{r(m)} > n</M> implies
<M>n < b_{r(m)}/(c_{r(m)}-a_{r(m)})</M>.
Thus we can restrict our considerations to integers
<M>n < b_{\rm max}</M>, where <M>b_{\rm max}</M> is the largest
second entry of a coefficient triple of one of the group elements
in our list:

<Example>
<![CDATA[
gap> List([a,a^-1,u,u^-1,a^2,a^-2,u^2,u^-2,a*u,u*a,(a*u)^-1,(u*a)^-1],
>         f->Maximum(List(Coefficients(f),c->c[2])));
[ 1, 1, 4, 2, 7, 7, 56, 28, 25, 17, 17, 11 ]
gap> Maximum(last);
56
]]>
</Example>

Thus this upper bound is 56. The rest is easy -- all we have to do is
to check that the orbit containing 1 contains also all other positive
integers less than or equal to 56:

<Example>
<![CDATA[
gap> S := [1];;
gap> while not IsSubset(S,[1..56]) do
>      S := Union(S,S^a,S^u,S^(a^-1),S^(u^-1));
>    od;
gap> IsSubset(S,[1..56]);
true
]]>
</Example>

Checking 2-transitivity is computationally harder, and in the sequel we
will omit some steps which are in practice needed to find out
<Q>what to do</Q>.

The approach taken here is to show that the stabilizer of 1
in <M>G</M> acts transitively on the set of positive integers greater
than 1. We do this by similar means as used above for showing the
transitivity of the action of <M>G</M> on the positive integers.

We start by determining all products of at most 5 generators and their
inverses, which stabilize 1 (taking at most 4-generator products would
not suffice!):

<Example>
<![CDATA[
gap> gens := [a,u,a^-1,u^-1];;
gap> tups := Concatenation(List([1..5],k->Tuples([1..4],k)));;
gap> Length(tups);
1364
gap> tups := Filtered(tups,tup->ForAll([[1,3],[3,1],[2,4],[4,2]],
>                                      l->PositionSublist(tup,l)=fail));;
gap> Length(tups);
484
gap> stab := [];;
gap> for tup in tups do
>      n := 1;
>      for i in tup do n := n^gens[i]; od;
>      if n = 1 then Add(stab,tup); fi;
>    od;
gap> Length(stab);
118
gap> stabelm := List(stab,tup->Product(List(tup,i->gens[i])));;
gap> ForAll(stabelm,elm->1^elm=1); # Check.
true
]]>
</Example>

The resulting products have various different not quite small moduli:

<Example>
<![CDATA[
gap> List(stabelm,Modulus);
[ 4, 3, 16, 25, 9, 81, 64, 100, 108, 100, 25, 75, 27, 243, 324, 243,
  256, 400, 144, 400, 100, 432, 324, 400, 80, 400, 625, 25, 75, 135,
  150, 75, 225, 81, 729, 486, 729, 144, 144, 81, 729, 1296, 729, 6561,
  1024, 1600, 192, 1600, 400, 576, 432, 1600, 320, 1600, 2500, 100, 100,
  180, 192, 192, 108, 972, 1728, 972, 8748, 1600, 400, 320, 80, 1600,
  2500, 300, 2500, 625, 625, 75, 675, 75, 75, 135, 405, 600, 120, 600,
  1875, 75, 225, 405, 225, 225, 675, 243, 2187, 729, 2187, 216, 216,
  243, 2187, 1944, 2187, 19683, 576, 144, 576, 432, 81, 81, 729, 2187,
  5184, 324, 8748, 243, 2187, 19683, 26244, 19683 ]
gap> Lcm(last);
12597120000
gap> Collected(Factors(last));
[ [ 2, 10 ], [ 3, 9 ], [ 5, 4 ] ]
]]>
</Example>

Similar as before, we determine for any of the above mappings the
residue classes whose elements larger than the largest <M>b_{r(m)}</M>
- coefficient of the respective mapping are mapped to smaller integers:

<Example>
<![CDATA[
gap> decs := List(stabelm,DecreasingOn);;
gap> List(decs,Modulus);
[ 2, 3, 8, 25, 9, 9, 16, 100, 12, 50, 25, 75, 27, 81, 54, 81, 64, 400,
  48, 200, 100, 72, 108, 400, 80, 200, 625, 25, 75, 45, 75, 75, 225, 81,
  243, 81, 243, 144, 144, 81, 243, 216, 243, 243, 128, 1600, 64, 400,
  400, 48, 144, 1600, 320, 400, 2500, 100, 100, 60, 96, 192, 108, 324,
  144, 324, 972, 400, 400, 80, 80, 400, 2500, 100, 1250, 625, 625, 25,
  75, 75, 75, 45, 135, 600, 120, 150, 1875, 75, 225, 135, 225, 225, 675,
  243, 729, 243, 729, 108, 216, 243, 729, 162, 729, 2187, 144, 144, 144,
  144, 81, 81, 243, 729, 1296, 324, 972, 243, 729, 2187, 1458, 2187 ]
gap> Lcm(last);
174960000
]]>
</Example>

Since the least common multiple of the moduli of these unions of residue
classes is as large as 174960000, directly forming their union and
checking whether it is equal to the set of integers would take relatively
much time and memory. However, starting with the set of integers and
subtracting the above sets one-by-one in a suitably chosen order is cheap:

<Example>
<![CDATA[
gap> SortParallel(decs,stabelm,
>      function(S1,S2)
>        return First([1..100],k->Factorial(k) mod Modulus(S1)=0)
>             < First([1..100],k->Factorial(k) mod Modulus(S2)=0);
>      end);
gap> S := Integers;;
gap> for i in [1..Length(decs)] do
>      S_old := S; S := Difference(S,decs[i]);
>      if S <> S_old then ViewObj(S); Print("\n"); fi;
>      if S = [] then maxind := i; break; fi;
>    od;
0(2)
2(6) U 4(6)
<union of 19 residue classes (mod 60) (6 classes)>
<union of 8 residue classes (mod 30)>
<union of 120 residue classes (mod 720)>
<union of 112 residue classes (mod 720)>
<union of 80 residue classes (mod 720)>
<union of 24 residue classes (mod 720)>
<union of 16 residue classes (mod 720) (12 classes)>
<union of 8 residue classes (mod 720)>
<union of 6 residue classes (mod 720)>
4(720) U 94(720) U 148(720) U 238(720)
<union of 24 residue classes (mod 5760)>
<union of 72 residue classes (mod 51840)>
<union of 48 residue classes (mod 51840)>
<union of 204 residue classes (mod 259200)>
<union of 144 residue classes (mod 259200)>
<union of 120 residue classes (mod 259200)>
<union of 84 residue classes (mod 259200)>
<union of 72 residue classes (mod 259200)>
<union of 48 residue classes (mod 259200)>
<union of 24 residue classes (mod 259200)>
<union of 12 residue classes (mod 259200) (6 classes)>
<union of 30 residue classes (mod 777600)>
54004(64800) U 151204(259200) U 216004(259200)
[  ]
]]>
</Example>

Similar as above, it remains to check that the <Q>small</Q> integers all
lie in the orbit containing 2. Obviously, it is sufficient to check
that any integer greater than 2 is mapped to a smaller one by some
suitably chosen element of the stabilizer under consideration:

<Example>
<![CDATA[
gap> Maximum(List(stabelm{[1..maxind]},
>                 f->Maximum(List(Coefficients(f),c->c[2]))));
6581
gap> Filtered([3..6581],n->Minimum(List(stabelm,elm->n^elm))>=n);
[ 4 ]
]]>
</Example>

We have to treat 4 separately:

<Example>
<![CDATA[
gap> 1^(u*a*u^2*a^-1*u);
1
gap> 4^(u*a*u^2*a^-1*u);
3
]]>
</Example>

Now we know that any positive integer greater than 1 lies in the same
orbit under the action of the stabilizer of 1 in <M>G</M>
as 2, thus that this stabilizer acts transitively on
<M>&NN; \setminus \{1\}</M>. But this means that we have established
the 2-transitivity of the action of <M>G</M> on &NN;. <P/>

In the following, we essentially repeat the above steps to show that
this action is indeed 3-transitive:

<Example>
<![CDATA[
gap> tups := Concatenation(List([1..6],k->Tuples([1..4],k)));;
gap> tups := Filtered(tups,tup->ForAll([[1,3],[3,1],[2,4],[4,2]],
>                                      l->PositionSublist(tup,l)=fail));;
gap> stab := [];;
gap> for tup in tups do
>      l := [1,2];
>      for i in tup do l := List(l,n->n^gens[i]); od;
>      if l = [1,2] then Add(stab,tup); fi;
>    od;
gap> Length(stab);
212
gap> stabelm := List(stab,tup->Product(List(tup,i->gens[i])));;
gap> decs := List(stabelm,DecreasingOn);;
gap> SortParallel(decs,stabelm,function(S1,S2)
>      return First([1..100],k->Factorial(k) mod Mod(S1)=0)
>           < First([1..100],k->Factorial(k) mod Mod(S2)=0); end);
gap> S := Integers;;
gap> for i in [1..Length(decs)] do
>      S_old := S; S := Difference(S,decs[i]);
>      if S <> S_old then ViewObj(S); Print("\n"); fi;
>      if S = [] then break; fi;
>    od;
Z \ 1(8) U 7(8)
<union of 424 residue classes (mod 720)>
<union of 169 residue classes (mod 720)>
<union of 51 residue classes (mod 720)>
<union of 45 residue classes (mod 720)>
<union of 42 residue classes (mod 720)>
<union of 35 residue classes (mod 720)>
<union of 30 residue classes (mod 720)>
<union of 16 residue classes (mod 720) (10 classes)>
<union of 11 residue classes (mod 720) (7 classes)>
<union of 8 residue classes (mod 720) (6 classes)>
148(360) U 238(360) U 4(720) U 454(720)
238(360) U 4(720) U 148(720) U 454(720)
<union of 28 residue classes (mod 5760)>
<union of 24 residue classes (mod 5760)>
<union of 23 residue classes (mod 5760)>
<union of 22 residue classes (mod 5760)>
<union of 20 residue classes (mod 5760) (14 classes)>
<union of 19 residue classes (mod 5760) (14 classes)>
<union of 16 residue classes (mod 5760) (12 classes)>
<union of 112 residue classes (mod 51840)>
<union of 96 residue classes (mod 51840)>
<union of 90 residue classes (mod 51840)>
<union of 51 residue classes (mod 51840)>
<union of 21 residue classes (mod 51840)>
<union of 19 residue classes (mod 51840) (15 classes)>
<union of 16 residue classes (mod 51840) (12 classes)>
<union of 54 residue classes (mod 259200)>
<union of 53 residue classes (mod 259200)>
<union of 50 residue classes (mod 259200)>
<union of 38 residue classes (mod 259200)>
<union of 35 residue classes (mod 259200)>
<union of 32 residue classes (mod 259200)>
<union of 24 residue classes (mod 259200)>
<union of 22 residue classes (mod 259200)>
<union of 20 residue classes (mod 259200) (16 classes)>
<union of 18 residue classes (mod 259200) (15 classes)>
<union of 16 residue classes (mod 259200) (13 classes)>
<union of 15 residue classes (mod 259200) (12 classes)>
<union of 12 residue classes (mod 259200) (10 classes)>
<union of 7 residue classes (mod 259200)>
2164(259200) U 66964(259200) U 228964(259200)
[  ]
gap> Maximum(List(stabelm,f->Maximum(List(Coefficients(f),c->c[2]))));
515816
gap> smallnum := [4..515816];;
gap> for i in [1..Length(stabelm)] do
>      smallnum := Filtered(smallnum,n->n^stabelm[i]>=n);
>    od;
gap> smallnum;
[  ]
]]>
</Example>

The same for 4-transitivity:

<Example>
<![CDATA[
gap> tups := Concatenation(List([1..8],k->Tuples([1..4],k)));;
gap> tups := Filtered(tups,tup->ForAll([[1,3],[3,1],[2,4],[4,2]],
>                                      l->PositionSublist(tup,l)=fail));;
gap> stab := [];;
gap> for tup in tups do
>      l := [1,2,3];
>      for i in tup do l := List(l,n->n^gens[i]); od;
>      if l = [1,2,3] then Add(stab,tup); fi;
>    od;
gap> Length(stab);
528
gap> stabelm := [];;
gap> for i in [1..Length(stab)] do
>      elm := One(G);
>      for j in stab[i] do
>        if Modulus(elm) > 10000 then elm := fail; break; fi;
>        elm := elm * gens[j];
>      od;
>      if elm <> fail then Add(stabelm,elm); fi;
>    od;
gap> Length(stabelm);
334
gap> decs := List(stabelm,DecreasingOn);;
gap> SortParallel(decs,stabelm,
>      function(S1,S2)
>        return First([1..100],k->Factorial(k) mod Modulus(S1) = 0)
>             < First([1..100],k->Factorial(k) mod Modulus(S2) = 0);
>      end);
gap> S := Integers;;
gap> for i in [1..Length(decs)] do
>      S_old := S; S := Difference(S,decs[i]);
>      if S <> S_old then ViewObj(S); Print("\n"); fi;
>      if S = [] then maxind := i; break; fi;
>    od;
Z \ 1(8) U 7(8)
<union of 24 residue classes (mod 72)>
<union of 22 residue classes (mod 72)>
<union of 17 residue classes (mod 72) (9 classes)>
4(18)
<union of 28 residue classes (mod 576)>
<union of 26 residue classes (mod 576)>
<union of 21 residue classes (mod 576)>
<union of 20 residue classes (mod 576) (7 classes)>
<union of 18 residue classes (mod 576) (8 classes)>
<union of 16 residue classes (mod 576) (6 classes)>
<union of 15 residue classes (mod 576) (6 classes)>
<union of 120 residue classes (mod 5184)>
<union of 45 residue classes (mod 5184)>
<union of 30 residue classes (mod 5184)>
<union of 28 residue classes (mod 5184)>
<union of 6 residue classes (mod 1296)>
<union of 116 residue classes (mod 32400)>
<union of 104 residue classes (mod 32400)>
<union of 92 residue classes (mod 32400)>
<union of 84 residue classes (mod 32400)>
<union of 80 residue classes (mod 32400)>
<union of 210 residue classes (mod 129600)>
<union of 189 residue classes (mod 129600)>
<union of 160 residue classes (mod 129600)>
<union of 136 residue classes (mod 129600)>
<union of 133 residue classes (mod 129600)>
<union of 122 residue classes (mod 129600)>
<union of 114 residue classes (mod 129600)>
<union of 106 residue classes (mod 129600)>
<union of 104 residue classes (mod 129600)>
<union of 100 residue classes (mod 129600)>
<union of 96 residue classes (mod 129600)>
<union of 60 residue classes (mod 129600)>
<union of 52 residue classes (mod 129600)>
<union of 48 residue classes (mod 129600)>
<union of 40 residue classes (mod 129600)>
<union of 36 residue classes (mod 129600)>
<union of 32 residue classes (mod 129600)>
<union of 24 residue classes (mod 129600)>
<union of 16 residue classes (mod 129600) (10 classes)>
<union of 12 residue classes (mod 129600)>
<union of 10 residue classes (mod 129600)>
<union of 8 residue classes (mod 129600)>
<union of 6 residue classes (mod 129600)>
57406(129600) U 63076(129600) U 115006(129600) U 120676(129600)
57406(129600) U 115006(129600) U 192676(259200) U 250276(259200)
<union of 15 residue classes (mod 777600) (6 classes)>
<union of 9 residue classes (mod 777600) (6 classes)>
<union of 30 residue classes (mod 3110400)>
<union of 26 residue classes (mod 3110400)>
<union of 22 residue classes (mod 3110400)>
<union of 19 residue classes (mod 3110400) (10 classes)>
<union of 14 residue classes (mod 3110400) (8 classes)>
705406(777600) U 2007076(3110400) U 2649406(3110400) U 2784676(3110400)
<union of 14 residue classes (mod 9331200) (8 classes)>
1483006(2332800) U 2649406(9331200) U 2784676(9331200) U 5117476(9331200)
<union of 16 residue classes (mod 27993600) (6 classes)>
2784676(9331200) U 5117476(9331200)
[  ]
gap> Maximum(List(stabelm{[1..maxind]},
>                 f->Maximum(List(Coefficients(f),c->c[2]))));
37387
gap> smallnum := [5..37387];;
gap> for i in [1..maxind] do
>      smallnum := Filtered(smallnum,n->n^stabelm[i]>=n);
>    od;
gap> smallnum;
[  ]
]]>
</Example>

There is even some evidence that the degree of transitivity of the action of
<M>G</M> on the positive integers is higher than 4:

<Example>
<![CDATA[
gap> phi := EpimorphismFromFreeGroup(G);
[ a, u ] -> [ a, u ]
gap> F := Source(phi);
<free group on the generators [ a, u ]>
gap> List([5..20],
>         n->RepresentativeActionPreImage(G,[1,2,3,4,5],
>                                           [1,2,3,4,n],OnTuples,F));
[ <identity ...>, a^-3*u^4*a*u^-2*a^2, a^-1*(a^-1*u)^4*a^-1*u^-1*a,
  a^4*u^-2*a^-4, a^-1*u^-4*a, (u^2*a^-1)^2*u^-2, u^-2*a^-2*u^4,
  a^-1*u^2*a, a^-1*u^-6*a, a^2*u^4*a^2*u^2, u^-4*a*u^-2*a^-3,
  a^-1*u^-2*a^-3*u^4*a^2, a^2*(a*u^2)^2, (a*u^-4)^2*a^-2,
  u^-2*a*u^2*a*u^-2, u^-4*a^2*u^2 ]
]]>
</Example>

Enter <C>AssignGlobals(LoadRCWAExamples().CollatzlikePerms);</C>
in order to assign the global variables defined in this section.

</Section>



<Section Label="sec:ThreeButNotFourTransitiveGroup">
<Heading>
  A group which acts 3-transitively, but not 4-transitively on &ZZ;
</Heading>

In this section, we would like to show that the group <M>G</M> generated
by the two permutations <M>n \mapsto n + 1</M> and <M>\tau_{1(2),0(4)}</M>
acts 3-transitively, but not 4-transitively on the set of integers.

<Example>
<![CDATA[
gap> G := Group(ClassShift(0,1),ClassTransposition(1,2,0,4));
<rcwa group over Z with 2 generators>
gap> IsTame(G);
false
gap> (G.1^-2*G.2)^3*(G.1^2*G.2)^3; # G <> the free product C_infty * C_2.
IdentityMapping( Integers )
gap> Display(G:CycleNotation:=false);

Wild rcwa group over Z, generated by

[
Tame rcwa permutation of Z: n -> n + 1

Rcwa permutation of Z with modulus 4, of order 2

        /
        | 2n-2    if n in 1(2)
n |-> <  (n+2)/2 if n in 0(4)
        | n       if n in 2(4)
        \

]
]]>
</Example>

This group acts transitively on &ZZ;, since already the cyclic
group generated by the first of the two generators does so. Next we have to
show that it acts 2-transitively. We essentially proceed as in the example
in the previous section, by checking that the stabilizer of 0
acts transitively on <M>&ZZ; \setminus \{0\}</M>.

<Example>
<![CDATA[
gap> gens := [ClassShift(0,1)^-1,ClassTransposition(1,2,0,4),
>             ClassShift(0,1)];;
gap> tups := Concatenation(List([1..6],k->Tuples([-1,0,1],k)));;
gap> tups := Filtered(tups,tup->ForAll([[0,0],[-1,1],[1,-1]],
>                                      l->PositionSublist(tup,l)=fail));;
gap> Length(tups);
189
gap> stab := [];;
gap> for tup in tups do
>      n := 0;
>      for i in tup do n := n^gens[i+2]; od;
>      if n = 0 then Add(stab,tup); fi;
>    od;
gap> stabelm := List(stab,tup->Product(List(tup,i->gens[i+2])));;
gap> Collected(List(stabelm,Modulus));
[ [ 4, 6 ], [ 8, 4 ], [ 16, 3 ] ]
gap> decs := List(stabelm,DecreasingOn);
[ 0(4), 3(4), 0(4), 3(4), 2(4), 0(4), 4(8), 2(4), 2(4), 0(4), 1(4),
  0(8), 3(8) ]
gap> Union(decs);
Integers
]]>
</Example>

Similar as in the previous section, it remains to check that the integers
with <Q>small</Q> absolute value all lie in the orbit containing 1 under
the action of the stabilizer of 0:

<Example>
<![CDATA[
gap> Maximum(List(stabelm,f->Maximum(List(Coefficients(f),
>                                         c->AbsInt(c[2])))));
21
gap> S := [1];;
gap> for elm in stabelm do S := Union(S,S^elm,S^(elm^-1)); od;
gap> IsSubset(S,Difference([-21..21],[0])); # Not yet ..
false
gap> for elm in stabelm do S := Union(S,S^elm,S^(elm^-1)); od;
gap> IsSubset(S,Difference([-21..21],[0])); # ... but now!
true
]]>
</Example>

Now we have to check for 3-transitivity. Since we cannot find for every
residue class an element of the pointwise stabilizer of <M>\{0,1\}</M>
which properly divides its elements, we also have to take additions and
subtractions into consideration. Since the moduli of all of our stabilizer
elements are quite small, simply looking at sets of representatives is cheap:

<Example>
<![CDATA[
gap> tups := Concatenation(List([1..10],k->Tuples([-1,0,1],k)));;
gap> tups := Filtered(tups,tup->ForAll([[0,0],[-1,1],[1,-1]],
>                                      l->PositionSublist(tup,l)=fail));;
gap> Length(tups);
3069
gap> stab := [];;
gap> for tup in tups do
>      l := [0,1];
>      for i in tup do l := List(l,n->n^gens[i+2]); od;
>      if l = [0,1] then Add(stab,tup); fi;
>    od;
gap> Length(stab);
10
gap> stabelm := List(stab,tup->Product(List(tup,i->gens[i+2])));;
gap> Maximum(List(stabelm,Modulus));
8
gap> Maximum(List(stabelm,
>                 f->Maximum(List(Coefficients(f),c->AbsInt(c[2])))));
8
gap> decsp := List(stabelm,elm->Filtered([9..16],n->n^elm<n));
[ [ 9, 13 ], [ 10, 12, 14, 16 ], [ 12, 16 ], [ 9, 13 ], [ 12, 16 ],
  [ 9, 11, 13, 15 ], [ 9, 11, 13, 15 ], [ 12, 16 ], [ 12, 16 ],
  [ 9, 11, 13, 15 ] ]
gap> Union(decsp);
[ 9 .. 16 ]
gap> decsm := List(stabelm,elm->Filtered([-16..-9],n->n^elm>n));
[ [ -15, -13, -11, -9 ], [ -16, -12 ], [ -16, -12 ], [ -15, -11 ],
  [ -16, -14, -12, -10 ], [ -15, -11 ], [ -15, -11 ],
  [ -16, -14, -12, -10 ], [ -16, -14, -12, -10 ], [ -15, -11 ] ]
gap> Union(decsm);
[ -16 .. -9 ]
gap> S := [2];;
gap> for elm in stabelm do S := Union(S,S^elm,S^(elm^-1)); od;
gap> IsSubset(S,Difference([-8..8],[0,1]));
true
]]>
</Example>

At this point we have established 3-transitivity.
It remains to check that the group <M>G</M> does not act 4-transitively.
We do this by checking that it is not transitive on 4-tuples (mod 4).
Since <M>n</M> mod 8 determines the image of <M>n</M> under
a generator of <M>G</M> (mod 4), it suffices to compute (mod 8):

<Example>
<![CDATA[
gap> orb := [[0,1,2,3]];;
gap> extend := function ()
>      local gen;
>      for gen in gens do
>        orb := Union(orb,List(orb,l->List(l,n->n^gen) mod 8));
>      od;
>    end;;
gap> repeat
>      old := ShallowCopy(orb);
>      extend(); Print(Length(orb),"\n");
>    until orb = old;
7
27
97
279
573
916
1185
1313
1341
1344
1344
gap> Length(Set(List(orb,l->l mod 4)));
120
gap> last < 4^4;
true
]]>
</Example>

This shows that <M>G</M> acts not 4-transitively on &ZZ;.
The corresponding calculation for 3-tuples looks as follows:

<Example>
<![CDATA[
gap> orb := [[0,1,2]];;
gap> repeat
>      old := ShallowCopy(orb);
>      extend(); Print(Length(orb),"\n");
>    until orb = old;
7
27
84
207
363
459
503
512
512
gap> Length(Set(List(orb,l->l mod 4)));
64
gap> last = 4^3;
true
]]>
</Example>

Needless to say that the latter kind of argumentation is not suitable
for proving, but only for disproving <M>k</M>-transitivity.

</Section>



<Section Label="sec:SlowlyContractingMapping">
<Heading>
  An rcwa mapping which seems to be contracting, but very slow
</Heading>

The iterates of an integer under the Collatz mapping <M>T</M> seem to
approach its contraction centre -- this is the finite set where all
trajectories end up after a finite number of steps -- rather quickly and
do not get very large before doing so (of course this is a purely heuristic
statement as the <M>3n+1</M> conjecture has not been proved so far!):

<Example>
<![CDATA[
gap> T := RcwaMapping([[1,0,2],[3,1,2]]);;
gap> S0 := LikelyContractionCentre(T,100,1000);
#I  Warning: `LikelyContractionCentre' is highly probabilistic.
The returned result can only be regarded as a rough guess.
See ?LikelyContractionCentre for more information.
[ -136, -91, -82, -68, -61, -55, -41, -37, -34, -25, -17, -10, -7, -5,
  -1, 0, 1, 2 ]
gap> S0^T = S0; # This holds by definition of the contraction centre.
true
gap> List([1..30],n->Length(Trajectory(T,n,S0)));
[ 1, 1, 5, 2, 4, 6, 11, 3, 13, 5, 10, 7, 7, 12, 12, 4, 9, 14, 14, 6, 6,
  11, 11, 8, 16, 8, 70, 13, 13, 13 ]
gap> Maximum(List([1..1000],n->Length(Trajectory(T,n,S0))));
113
gap> Maximum(List([1..1000],n->Maximum(Trajectory(T,n,S0))));
125252
]]>
</Example>

The following mapping seems to be contracting as well, but its trajectories
are much longer:

<Log>
<![CDATA[
gap> f6 := RcwaMapping([[ 1,0,6],[ 5, 1,6],[ 7,-2,6],
>                       [11,3,6],[11,-2,6],[11,-1,6]]);;
gap> Display(f6);

Rcwa mapping of Z with modulus 6

        /
        | n/6       if n in 0(6)
        | (5n+1)/6  if n in 1(6)
        | (7n-2)/6  if n in 2(6)
n |-> <  (11n+3)/6 if n in 3(6)
        | (11n-2)/6 if n in 4(6)
        | (11n-1)/6 if n in 5(6)
        |
        \

gap> S0 := LikelyContractionCentre(f6,1000,100000);;
#I  Warning: `LikelyContractionCentre' is highly probabilistic.
The returned result can only be regarded as a rough guess.
See ?LikelyContractionCentre for more information.
gap> Trajectory(f6,25,S0);
[ 25, 21, 39, 72, 12, 2 ]
gap> List([1..100],n->Length(Trajectory(f6,n,S0)));
[ 1, 1, 3, 4, 1, 2, 3, 2, 1, 5, 7, 2, 8, 17, 3, 16, 1, 4, 17, 6, 5, 2,
  5, 5, 6, 1, 4, 2, 15, 1, 1, 3, 2, 5, 13, 3, 2, 3, 4, 1, 8, 4, 4, 2, 7,
  19, 23517, 3, 9, 3, 1, 18, 14, 2, 20, 23512, 14, 2, 6, 6, 1, 4, 19,
  12, 23511, 8, 23513, 10, 1, 13, 13, 3, 1, 23517, 7, 20, 7, 9, 9, 6,
--> --------------------

--> maximum size reached

--> --------------------

quality96%

¤ Dauer der Verarbeitung: 0.37 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.