3. Residue Class-Wise Affine Groups

This chapter describes the functionality provided by this package for computing with residue class-wise affine groups.

3.1 Constructing residue class-wise affine groups

Residue class-wise affine groups can be constructed using either Group, GroupByGenerators or GroupWithGenerators, as usual (see the GAP reference manual).



gap> g := RcwaMapping([[1,0,1],[1,1,1],[3,6,1],
>                      [1,0,3],[1,1,1],[3,6,1],
>                      [1,0,1],[1,1,1],[3,-21,1]]);;
gap> h := RcwaMapping([[1,0,1],[1,1,1],[3,6,1],
>                      [1,0,3],[1,1,1],[3,-21,1],
>                      [1,0,1],[1,1,1],[3,6,1]]);;
gap> List([g,h],Order);
[ 9, 9 ]
gap> G := Group(g,h);
<rcwa group over Z with 2 generators>
gap> Size(G);
infinity


There are methods for the operations Display and Print which are applicable to rcwa groups.

All rcwa groups over the ring R are subgroups of RCWA(R). The group RCWA(R) is not finitely generated, thus cannot be constructed in the way described above. It is handled as a special case:

3.1-1 RCWA
> RCWA( R )( function )

Returns: The group RCWA(R) of all residue class-wise affine permutations of the ring R.



gap> RCWA_Z := RCWA(Integers);
RCWA(Z)
gap> Size(RCWA_Z);
infinity
gap> IsFinitelyGeneratedGroup(RCWA_Z);
false
gap> One(RCWA_Z);
IdentityMapping( Integers )
gap> IsSolvable(RCWA_Z);
false
gap> IsPerfect(RCWA_Z);
false
gap> Centre(RCWA_Z);
Trivial rcwa group over Z
gap> IsSubgroup(RCWA_Z, Group(RcwaMapping((1,2,3),[1..4]),
>                             RcwaMapping(2,[[0,1],[1,0],[2,3],[3,2]])));
true


3.1-2 Random
> Random( RCWA_Z )( method )

Returns: A pseudo-random element of the group RCWA(Z).

This method is designed to be suitable for generating interesting examples. No particular distribution is guaranteed -- in fact, the author has no idea what a "reasonable" random distribution on RCWA(Z) should be.



gap> elm := Random(RCWA_Z);
<bijective rcwa mapping of Z with modulus 60>
gap> Display(elm);

Bijective rcwa mapping of Z with modulus 60

               n mod 60                |                 n^f
---------------------------------------+--------------------------------------
   0  4  6  8 10 14 16 18 20 24 26 28  | 
  30 34 36 38 40 44 46 48 50 54 56 58  | -3n - 5
   1                                   | (n - 1)/5
   2 22 42                             | (3n + 24)/5
   3  9 15 21 27 33 39 45 51 57        | (-5n + 12)/3
   5 11 17 29 35 41 47 59              | -n + 2
   7 13 19 25 37 43 49 55              | -n
  12 32 52                             | (3n + 4)/5
  23                                   | (n - 3)/5
  31                                   | (n + 19)/5
  53                                   | (n + 17)/5



The elements returned by this method are obtained by multiplying class shifts (see ClassShift (2.2-1)), class reflections (see ClassReflection (2.2-2)) and class transpositions (see ClassTransposition (2.2-3)). These factors are stored as an attribute value:



gap> Perform(FactorizationIntoCSCRCT(elm),Display);

Rcwa mapping of Z with modulus 6

                n mod 6                |    n^ClassTransposition(0,2,5,6)
---------------------------------------+--------------------------------------
  0 2 4                                | 3n + 5
  1 3                                  | n
  5                                    | (n - 5)/3


Rcwa mapping of Z with modulus 6

                n mod 6                |    n^ClassTransposition(0,2,3,6)
---------------------------------------+--------------------------------------
  0 2 4                                | 3n + 3
  1 5                                  | n
  3                                    | (n - 3)/3


Rcwa mapping of Z with modulus 10

               n mod 10                |    n^ClassTransposition(0,2,1,10)
---------------------------------------+--------------------------------------
   0  2  4  6  8                       | 5n + 1
   1                                   | (n - 1)/5
   3  5  7  9                          | n


Rcwa mapping of Z with modulus 4

                n mod 4                |          n^ClassShift(2,4)
---------------------------------------+--------------------------------------
  0 1 3                                | n
  2                                    | n + 4

Rcwa mapping of Z: n -> -n

Rcwa mapping of Z with modulus 2

                n mod 2                |        n^ClassReflection(0,2)
---------------------------------------+--------------------------------------
  0                                    | -n
  1                                    | n



Another way of constructing an rcwa group is taking the image of an rcwa representation:

3.1-3 IsomorphismRcwaGroupOverZ
> IsomorphismRcwaGroupOverZ( G )( attribute )
> IsomorphismRcwaGroup( G )( attribute )

Returns: A monomorphism from the group G to RCWA(Z).

Currently, IsomorphismRcwaGroup works for finite groups, for free products of finite groups and for free groups. The method for free products of finite groups uses the Table-Tennis Lemma (cp. e.g. Section II.B. in [H00]), and the method for free groups uses an adaptation of the construction given on page 27 in [H00] from PSL(2,C) to RCWA(Z).

In case G is a finite-degree permutation group, the image under a specific embedding can be obtained by RcwaGroupByPermGroup(G). The resulting group H satisfies the relation Action(H^ClassShift(0,1),[1..LargestMovedPoint(G)]) = G.



gap> F := FreeProduct(Group((1,2)(3,4),(1,3)(2,4)),Group((1,2,3)),
>                     SymmetricGroup(3));
<fp group on the generators [ f1, f2, f3, f4, f5 ]>
gap> phi := IsomorphismRcwaGroup(F);
[ f1, f2, f3, f4, f5 ] -> [ <bijective rcwa mapping of Z with modulus 12>,
  <bijective rcwa mapping of Z with modulus 24>,
  <bijective rcwa mapping of Z with modulus 12>,
  <bijective rcwa mapping of Z with modulus 72>,
  <bijective rcwa mapping of Z with modulus 36> ]
gap> G := Image(phi);
<wild rcwa group over Z with 5 generators>
gap> RelatorsOfFpGroup(F); # For illustrational purposes, do some checks:
[ f1^2, f1^-1*f2*f1*f2^-1, f2^2, f3^3, f4^2, f5^2, f4*f5*f4*f5*f4*f5 ]
gap> ForAll([ G.1^2, G.1^-1*G.2*G.1*G.2^-1, G.2^2, G.3^3,
>             G.4^2, G.5^2, (G.4*G.5)^3 ], IsOne);
true
gap> S := AllResidueClassesModulo(3);
[ 0(3), 1(3), 2(3) ]
gap> nonids := grp->Difference(AsList(grp),[One(grp)]);;
gap> List(S{[2,3]},Si->List(nonids(Group(G.1,G.2)),g->Si^g));
[ [ 3(12), 6(24), 0(24) ], [ 9(12), 18(24), 12(24) ] ]
gap> Union(Flat(last));
0(3)
gap> List(S{[1,3]},Si->List(nonids(Group(G.3)),g->Si^g));
[ [ 1(12), 4(12) ], [ 7(12), 10(12) ] ]
gap> Union(Flat(last));
1(3)
gap> List(S{[1,2]},Si->List(nonids(Group(G.4,G.5)),g->Si^g));
[ [ 8(24), 5(36), 17(36), 2(24), 11(36) ],
  [ 20(24), 23(36), 35(36), 14(24), 29(36) ] ]
gap> Union(Flat(last));
2(3)




gap> phi := IsomorphismRcwaGroup(FreeGroup(2)); F2 := Image(phi);;
[ f1, f2 ] -> [ <wild bijective rcwa mapping of Z with modulus 8>, 
  <wild bijective rcwa mapping of Z with modulus 8> ]
gap> Difference(Integers,ResidueClass(0,4))^F2.1;
1(4)
gap> Difference(Integers,ResidueClass(2,4))^F2.2;
3(4)


3.2 Attributes and properties of rcwa groups

3.2-1 Modulus
> Modulus( G )( method )
> Mod( G )( method )

Returns: The modulus of the rcwa group G.

The Modulus of an rcwa group is the lcm of the moduli of its elements in case such an lcm exists and 0 otherwise.

See also IsTame (3.2-2).



gap> g1 := RcwaMapping((1,2),[1..2]);
<bijective rcwa mapping of Z with modulus 2, of order 2>
gap> g2 := RcwaMapping((1,2,3),[1..3]);
<bijective rcwa mapping of Z with modulus 3, of order 3>
gap> g3 := RcwaMapping((1,2,3,4,5),[1..5]);
<bijective rcwa mapping of Z with modulus 5, of order 5>
gap> G := Group(g1,g2,g3);
<rcwa group over Z with 3 generators>
gap> Modulus(G);
30
gap> a := RcwaMapping([[3,0,2],[3,1,4],[3,0,2],[3,-1,4]]);; SetName(a,"a");
gap> Modulus(Group(a));
0


3.2-2 IsTame
> IsTame( G )( property )

Returns: true if the rcwa group G is tame and false otherwise.

An rcwa group is called tame if its modulus is not equal to 0.



gap> b := ClassShift(1,4) * a;; SetName(b,"b");
gap> c := ClassShift(3,4) * a;; SetName(c,"c");
gap> List( [ G, Group(a,b), Group(Comm(a,b),Comm(a,c)) ], IsTame );
[ true, false, true ]


3.2-3 PrimeSet
> PrimeSet( G )( attribute )

Returns: The prime set of the rcwa group G.

The prime set of an rcwa group is the union of the prime sets of its elements.

See also PrimeSet (2.6-3) for rcwa mappings.



gap> PrimeSet(G);
[ 2, 3, 5 ]


An rcwa group is called integral resp. class-wise order-preserving if all of its elements are so. There are corresponding methods available for IsIntegral and IsClassWiseOrderPreserving.

3.3 Membership testing, order computation, permutation- / matrix representations

3.3-1 \in
> \in( g, G )( method )

Returns: true if the rcwa mapping g is an element of the rcwa group G and false if not.

This method tries to decide whether g is an element of G or not. It can always decide this question if G is tame and class-wise order-preserving. For wild groups only a number of easy cases are covered. On Info level 3 of InfoRCWA the method gives information on reasons why g is an element of G or not.

The direct product of two free groups of rank 2 can faithfully be represented as an rcwa group. In [M58] it is shown that this implies that in general the membership problem for rcwa groups is algorithmically undecidable.



gap> u := RcwaMapping([[3,0,5],[9,1,5],[3,-1,5],[9,-2,5],[9,4,5]]);;
gap> u in G;
false


3.3-2 Size
> Size( G )( method )

Returns: The order of the rcwa group G.



gap> Size(G);
265252859812191058636308480000000


3.3-3 IsomorphismPermGroup
> IsomorphismPermGroup( G )( method )

Returns: An isomorphism from the finite rcwa group G to a finite-degree permutation group.



gap> IsomorphismPermGroup(Group(g1,g2));
[ <bijective rcwa mapping of Z with modulus 2, of order 2>, 
  <bijective rcwa mapping of Z with modulus 3, of order 3> ] -> 
[ (1,2)(3,4)(5,6), (1,2,3)(4,5,6) ]


3.3-4 IsomorphismMatrixGroup
> IsomorphismMatrixGroup( G )( attribute )

Returns: An isomorphism from the rcwa group G to a matrix group, provided that G embeds into a matrix group and that there is a suitable method available. Both conditions are fulfilled if G is tame.



gap> g := RcwaMapping([[2,2,1],[1, 4,1],[1,0,2],[2,2,1],[1,-4,1],[1,-2,1]]);;
gap> h := RcwaMapping([[2,2,1],[1,-2,1],[1,0,2],[2,2,1],[1,-1,1],[1, 1,1]]);;
gap> SetName(g,"g"); SetName(h,"h");
gap> phi := IsomorphismMatrixGroup(Group(g,h));;
gap> FieldOfMatrixGroup(Image(phi));
Rationals
gap> DegreeOfMatrixGroup(Image(phi));
14
gap> Display(GeneratorsOfGroup(Image(phi))[1]*One(GF(5)));
 . . . . . . 1 1 . . . . . .
 . . . . . . . 1 . . . . . .
 . . . . . . . . . . 3 . . .
 . . . . . . . . . . . 1 . .
 . . . . . . . . 1 3 . . . .
 . . . . . . . . . 1 . . . .
 . . . . . . . . . . . . 3 .
 . . . . . . . . . . . . . 1
 . . 1 4 . . . . . . . . . .
 . . . 1 . . . . . . . . . .
 2 2 . . . . . . . . . . . .
 . 1 . . . . . . . . . . . .
 . . . . 2 2 . . . . . . . .
 . . . . . 1 . . . . . . . .


3.4 Factoring elements into generators

3.4-1 PreImagesRepresentative
> PreImagesRepresentative( phi, g )( method )

Returns: A representative of the set of preimages of g under the homomorphism phi from a free group to an rcwa group over Z.

This method can be used for factoring elements of rcwa groups over Z into generators. It can also be used for finding nontrivial relations among the generators if the respective group is not free and the method returns a factorization which does not happen to be equal to one which is known a priori. The homomorphism phi must map the generators of the free group to the generators of the rcwa group one-by-one. This method is also suitable for wild groups. The implementation is based on RepresentativeActionPreImage (3.5-3).



gap> G := Group(g,h);
<rcwa group over Z with 2 generators>
gap> phi := EpimorphismFromFreeGroup(G);
[ g, h ] -> [ g, h ]
gap> PreImagesRepresentative(phi,h*g^3*h^2*g^-1*h*g*h^-3);
h*g^3*h^2*g^-1*h*g*h^-3
gap> nu := RcwaMapping([[1,1,1]]);
Rcwa mapping of Z: n -> n + 1
gap> SetName(nu,"nu");
gap> G := Group(a,nu);
<rcwa group over Z with 2 generators>
gap> IsTame(G);
false
gap> phi := EpimorphismFromFreeGroup(G);
[ a, nu ] -> [ a, nu ]
gap> F := Source(phi);
<free group on the generators [ a, nu ]>
gap> w := Comm(F.1,Comm(F.1,F.2^2));
a^-1*nu^-2*a^-1*nu^2*a*nu^-2*a*nu^2
gap> f := w^phi;
<bijective rcwa mapping of Z with modulus 18>
gap> IsTame(f);
false
gap> pre := PreImagesRepresentative(phi,f);
a^-2*nu^-2*a^2*nu^2
gap> one := w*pre^-1; # pre <> w --> We have a non-trivial relation!
a^-1*nu^-2*a^-1*nu^2*a*nu^-2*a^-1*nu^2*a^2
gap> one^phi;
IdentityMapping( Integers )


3.4-2 PreImagesRepresentatives
> PreImagesRepresentatives( phi, g )( operation )

Returns: A list of representatives of the set of preimages of g under the homomorphism phi from a free group to an rcwa group over Z.

Quite frequently, computing several preimages is not harder than computing just one, i.e. often several preimages are found simultaneously. This operation is called by PreImagesRepresentative (3.4-1), which simply chooses the shortest representative. For a slightly more concise description see there.



gap> G := Group(g,h);
<rcwa group over Z with 2 generators>
gap> phi := EpimorphismFromFreeGroup(G);
[ g, h ] -> [ g, h ]
gap> f := g^3*h*g^-4*h^5*g;
<bijective rcwa mapping of Z with modulus 12>
gap> RCWAInfo(2);
gap> pre := PreImagesRepresentatives(phi,f);
#I  Orbit lengths after extension step 1: [ 4, 5 ]
#I  |Candidates| = 1
#I  Orbit lengths after extension step 1: [ 5, 5 ]
#I  Orbit lengths after extension step 2: [ 17, 15 ]
#I  Orbit lengths after extension step 3: [ 52, 39 ]
#I  |Candidates| = 1
#I  Orbit lengths after extension step 1: [ 5, 5 ]
#I  Orbit lengths after extension step 2: [ 17, 15 ]
#I  Orbit lengths after extension step 3: [ 53, 43 ]
#I  Orbit lengths after extension step 4: [ 158, 119 ]
#I  |Candidates| = 1
#I  Orbit lengths after extension step 1: [ 5, 5 ]
#I  Orbit lengths after extension step 2: [ 17, 17 ]
#I  Orbit lengths after extension step 3: [ 53, 53 ]
#I  Orbit lengths after extension step 4: [ 159, 158 ]
#I  Orbit lengths after extension step 5: [ 472, 462 ]
#I  Orbit lengths after extension step 6: [ 1356, 1309 ]
#I  Orbit lengths after extension step 7: [ 3822, 3643 ]
#I  |Candidates| = 11
[ g^3*h*g^3*h^5*g, g^-3*h^-4*g^-3*h^-1*g*h*g, g^3*h*g^-4*h^5*g ]
gap> RCWAInfo(0);
gap> List(pre,Length);
[ 13, 14, 14 ]
gap> Set(List(pre,w->w^phi)) = [f];
true
gap> w := pre[1]*pre[2]^-1;
g^3*h*g^3*h^4*g^-1*h*g^3*h^4*g^3
gap> Length(w);
23
gap> w^phi; # A relation of length 23.
IdentityMapping( Integers )


3.5 The action of an rcwa group on the underlying ring R

The support (set of moved points) of an rcwa group can be determined by Support or MovedPoints (these are synonyms). Sometimes testing for transitivity on the underlying ring is feasible. This is e.g. the case for tame groups over Z. Further it is often possible to determine group elements which map a given tuple of elements of the underlying ring to a given other tuple, if such elements exist.

3.5-1 IsTransitive
> IsTransitive( G, Integers )( method )

Returns: true if the rcwa group G acts transitively on Z and false otherwise.

If G is wild, this may fail or run into an infinite loop.



gap> G := Group(g,h);;
gap> RCWAInfo(3);
gap> IsTransitive(G,Integers);
#I  IsTransitive: testing for finiteness and searching short orbits ...
#I  IsTame: balancedness criterion.
#I  IsTame:`dead end' criterion.
#I  IsTame: loop criterion.
#I  IsTame:`finite order or integral power' criterion.

  [ ... ]

#I  Order: the 4th power of the argument is RcwaMapping(
[ [ 1, 12, 1 ], [ 1, 12, 1 ], [ 1, -6, 2 ], [ 2, -10, 1 ], [ 1, -7, 1 ],
  [ 2, -8, 1 ], [ 1, 12, 1 ], [ 1, 12, 1 ], [ 1, -10, 2 ], [ 2, -10, 1 ],
  [ 1, -7, 1 ], [ 2, -8, 1 ] ] );
There is a `class shift' on the residue class 0(12).
#I  Trying probabilistic random walk, initial m = 12
#I  checking modulus ...
#I  Size: use action on respected partition.
#I  KernelOfActionOnRespectedPartition: gen. #1, lng = 1
#I  KernelOfActionOnRespectedPartition: gen. #2, lng = 2

                       [ ... ]

#I  KernelOfActionOnRespectedPartition: gen. #14, lng = 10
#I  Searching for class shifts ...
#I  ... in generators
#I  ... in commutators of the generators
#I  The cyclic group generated by RcwaMapping(
[ [ 1, -9, 1 ], [ 1, 0, 1 ], [ 1, 6, 1 ], [ 1, -3, 1 ], [ 1, 0, 1 ],
  [ 1, 6, 1 ] ] ) acts transitively on the residue class 2(6).
#I  OrbitUnion: initial set = ResidueClassUnion( Integers, 6, [ 2 ] )
#I  Image = Integers
true
gap> RCWAInfo(0);


3.5-2 RepresentativeAction
> RepresentativeAction( G, src, dest, act )( method )

Returns: An element of G which maps src to dest under the action given by act.

If an element satisfying this condition does not exist, this method either returns fail or runs into an infinite loop. The problem of whether src and dest lie in the same orbit under the action of G in general seems to be hard. The method is based on RepresentativeActionPreImage (3.5-3), and it basically just computes an image under an epimorphism. As this involves multiplications of rcwa mappings, this can be quite expensive if the group G is wild, the preimage is a rather long word and coefficient explosion happens to occur.



gap> G := Group(a,b);
<rcwa group over Z with 2 generators>
gap> elm := RepresentativeAction(G,[7,4,9],[4,5,13],OnTuples);
<bijective rcwa mapping of Z with modulus 12>
gap> Display(elm);

Bijective rcwa mapping of Z with modulus 12

               n mod 12                |                 n^f
---------------------------------------+--------------------------------------
   0  2  3  6  8 11                    | n
   1  7 10                             | n - 3
   4                                   | n + 1
   5  9                                | n + 4

gap> List([7,4,9],n->n^elm);
[ 4, 5, 13 ]
gap> elm := RepresentativeAction(G,[5,4,9],[13,5,4],OnTuples);
<bijective rcwa mapping of Z with modulus 9>
gap> Display(elm);

Bijective rcwa mapping of Z with modulus 9

                n mod 9                |                 n^f
---------------------------------------+--------------------------------------
  0                                    | 4n/9
  1                                    | (8n - 26)/9
  2                                    | (8n + 2)/9
  3                                    | (8n + 3)/9
  4                                    | (16n - 19)/9
  5                                    | (16n + 37)/9
  6                                    | (8n + 33)/9
  7                                    | (16n - 49)/9
  8                                    | (16n + 7)/9

gap> List([5,4,9],n->n^elm);
[ 13, 5, 4 ]
gap> RepresentativeAction(G,[7,4,9],[4,5,8],OnTuples);
<bijective rcwa mapping of Z with modulus 256>


3.5-3 RepresentativeActionPreImage
> RepresentativeActionPreImage( G, src, dest, act, F )( operation )

Returns: The result of RepresentativeAction(G,src,dest,act) as word in generators.

The argument F is a free group whose generators are used as letters of the returned word. Note that the dependency is just in the opposite direction than suggested above (RepresentativeAction calls RepresentativeActionPreImage) and that the evaluation of the word sometimes takes much more time than its determination. This causes RepresentativeActionPreImage sometimes to be much faster than RepresentativeAction. The used algorithm is not inefficient, as the last two of the examples below suggest. It is based on computing balls of increasing radius around src and dest until they intersect nontrivially. It avoids multiplying rcwa mappings. Of course the other warnings given in the description of RepresentativeAction (3.5-2) apply to this operation as well.



gap> F := FreeGroup("a","b");;
gap> w := RepresentativeActionPreImage(G,[7,4,9],[4,5,13],OnPoints,F);
b^-1*a*b*a^-1
gap> w := RepresentativeActionPreImage(G,[5,4,9],[13,5,4],OnTuples,F);
b^-1*a^-1*b*a^-1
gap> w := RepresentativeActionPreImage(G,[7,4,9],[4,5,8],OnPoints,F);
b^2*a^2
gap> phi := GroupHomomorphismByImages(F,G,[F.1,F.2],[a,b]);
[ a, b ] -> [ a, b ]
gap> w^phi;
<bijective rcwa mapping of Z with modulus 256>
gap> w^phi = RepresentativeAction(G,[7,4,9],[4,5,8],OnPoints);
true
gap> List([7,4,9],n->n^(w^phi));
[ 4, 5, 8 ]
gap> w := RepresentativeActionPreImage(G,[37,4,9],[4,51,8],OnPoints,F);
a^-1*b^-1*a*b^4*a
gap> w^phi;
<bijective rcwa mapping of Z with modulus 4608>
gap> w := RepresentativeActionPreImage(G,[37,4,9],[4,51,8],OnTuples,F);
b*a^6*b*a^-3*b^-3*a^-1*b*a^2
gap> w := RepresentativeActionPreImage(G,[17,14,9],[4,51,8],OnPoints,F);
a^-1*b^-1*a^3*b^2*a*b*a*b^-1*a^2


3.5-4 RepresentativeAction
> RepresentativeAction( RCWA_Z, P1, P2 )( method )

Returns: An element of RCWA(Z) which maps the partition P1 to P2.

The arguments P1 and P2 must be partitions of the underlying ring R into the same number of disjoint unions of residue classes. The method recognizes the option IsTame. If this option is set, the returned mapping is tame provided that there is a tame mapping which satisfies the given condition. If the option IsTame is not set and the partitions P1 and P2 both consist entirely of single residue classes, then the returned mapping is affine on any residue class in P1.



gap> rc := function(r,m) return ResidueClass(DefaultRing(m),m,r); end;;
gap> P1 := [rc(0,3),rc(1,3),rc(2,9),rc(5,9),rc(8,9)];
[ 0(3), 1(3), 2(9), 5(9), 8(9) ]
gap> P2 := [rc(0,2),rc(1,8),rc(5,16),rc(3,4),rc(13,16)];
[ 0(2), 1(8), 5(16), 3(4), 13(16) ]
gap> elm := RepresentativeAction(RCWA(Integers),P1,P2);
<rcwa mapping of Z with modulus 9>
gap> Display(elm);

Rcwa mapping of Z with modulus 9

                n mod 9                |                 n^f
---------------------------------------+--------------------------------------
  0 3 6                                | 2n/3
  1 4 7                                | (8n - 5)/3
  2                                    | (16n + 13)/9
  5                                    | (4n + 7)/9
  8                                    | (16n - 11)/9

gap> P1^elm = P2;
true
gap> elm := RepresentativeAction(RCWA(Integers),P1,P2:IsTame);
<tame rcwa mapping of Z with modulus 1152>
gap> P := RespectedPartition(elm);;
gap> Length(P);
313
gap> elm := RepresentativeAction(RCWA(Integers),
>                                [rc(1,3),Union(rc(0,3),rc(2,3))],
>                                [Union(rc(2,5),rc(4,5)),
>                                 Union(rc(0,5),rc(1,5),rc(3,5))]);
<rcwa mapping of Z with modulus 6>
gap> [rc(1,3),Union(rc(0,3),rc(2,3))]^elm;
[ 2(5) U 4(5), Z \ 2(5) U 4(5) ]


3.5-5 ShortOrbits
> ShortOrbits( G, S, maxlng )( operation )

Returns: A list of all finite orbits of the rcwa group G of maximal length maxlng, which intersect nontrivially with the set S.



gap> A5 := RcwaGroupByPermGroup(AlternatingGroup(5));;
gap> ShortOrbits(A5,[-10..10],100);
[ [ -10, -9, -8, -7, -6 ], [ -5, -4, -3, -2, -1 ], [ 0, 1, 2, 3, 4 ], 
  [ 5, 6, 7, 8, 9 ], [ 10, 11, 12, 13, 14 ] ]
gap> Action(A5,last[2]);
Group([ (1,2,3,4,5), (3,4,5) ])




gap> G := Group(Comm(a,b),Comm(a,c));;
gap> orb := ShortOrbits(G,[-15..15],100);
[ [ -15, -12, -7, -6, -5, -4, -3, -2, -1, 1 ], 
  [ -33, -30, -24, -21, -16, -14, -13, -11, -10, -8 ], [ -9 ], [ 0 ], 
  [ 2, 3, 4, 5, 6, 7, 8, 10, 12, 15 ], [ 9 ], 
  [ 11, 13, 14, 16, 17, 19, 21, 24, 30, 33 ] ]
gap> Action(G,orb[1]);
Group([ (2,5,8,10,7,6), (1,3,6,9,4,5) ])
gap> ShortOrbits(Group(u),[-30..30],100);
[ [ -13, -8, -7, -5, -4, -3, -2 ], [ -10, -6 ], [ -1 ], [ 0 ], [ 1, 2 ], 
  [ 3, 5 ], [ 24, 36, 39, 40, 44, 48, 60, 65, 67, 71, 80, 86, 93, 100, 112, 
      128, 138, 155, 167, 187, 230, 248, 312, 446, 520, 803, 867, 1445 ] ]


3.5-6 OrbitsModulo
> OrbitsModulo( G, m )( method )

Returns: A partition of [0..m-1] such that i and j lie in the same subset if and only if there is an element g of G which moves an element from the residue class i(m) to the residue class j(m).

The argument G must be an rcwa group over Z. See also OrbitsModulo (2.8-2) for rcwa mappings.



gap> OrbitsModulo(G,36);
[ [ 0 ], [ 1, 11, 13, 14, 16, 17, 19, 21, 24, 29, 30, 31, 32, 33, 34, 35 ], 
  [ 2, 3, 4, 5, 6, 7, 8, 10, 12, 15, 20, 22, 23, 25, 26, 28 ], [ 9 ], [ 18 ], 
  [ 27 ] ]


3.5-7 Ball
> Ball( G, p, d, act )( method )
> Ball( G, g, d )( method )

Returns: The ball of radius d around the point p under the action act of the group G, resp. the ball of radius d around the element g in the group G.

All balls are understood w.r.t. GeneratorsOfGroup(G). As element tests can be expensive, the latter method does not check whether g is indeed an element of G. The methods require that point comparisons resp. element comparisons are cheap. They are not only applicable to rcwa groups.



gap> for d in [1..4] do Print(Ball(G,1,d,OnPoints),"\n"); od;
[ -3, -2, 1 ]
[ -5, -4, -3, -2, 1 ]
[ -15, -12, -7, -6, -5, -4, -3, -2, -1, 1 ]
[ -15, -12, -7, -6, -5, -4, -3, -2, -1, 1 ]
gap> List([1..11],d->Length(Ball(G,[1,2,3],d,OnSets)));
[ 5, 17, 51, 127, 245, 324, 343, 357, 360, 360, 360 ]




gap> List([1..11],d->Length(Ball(G,[1,2,3],d,OnTuples)));
[ 5, 17, 51, 143, 325, 557, 662, 695, 713, 720, 720 ]
gap> Ball(Group((1,2),(2,3),(3,4),(4,5),(5,6)),(),2);
[ (), (5,6), (4,5), (4,5,6), (4,6,5), (3,4), (3,4)(5,6), (3,4,5), (3,5,4), 
  (2,3), (2,3)(5,6), (2,3)(4,5), (2,3,4), (2,4,3), (1,2), (1,2)(5,6), 
  (1,2)(4,5), (1,2)(3,4), (1,2,3), (1,3,2) ]


3.6 Conjugacy in RCWA(R)

3.6-1 IsConjugate
> IsConjugate( RCWA_Z, f, g )( method )

Returns: true if the bijective rcwa mappings f and g are conjugate in RCWA(Z), and false otherwise.

This may fail or run into an infinite loop. In particular the support for wild rcwa mappings is currently very poor, since the author does not know a way to solve the conjugacy problem for these. Some easy cases are handled anyway.



gap> IsConjugate(RCWA(Integers),g,h);
false
gap> IsConjugate(RCWA(Integers),g,g^a);
true
gap> IsConjugate(RCWA(Integers),a,b);
false


3.6-2 RepresentativeAction
> RepresentativeAction( RCWA_Z, f, g )( method )

Returns: An rcwa mapping x such that f^x = g, if such an x exists and fail otherwise.

This method currently works only for tame rcwa mappings of Z, since the author does not know a way to solve the conjugacy problem for wild rcwa mappings.



gap> elm := RepresentativeAction(RCWA(Integers),h,h^g);
<bijective rcwa mapping of Z with modulus 12>
gap> h^elm = h^g; # check ...
true
gap> Order(elm);
infinity
gap> cent := g*elm^-1;
<bijective rcwa mapping of Z with modulus 12>
gap> Comm(cent,h); # cent must lie in the centralizer of h in RCWA(Z).
IdentityMapping( Integers )




gap> Order(cent);; Display(cent);

Bijective rcwa mapping of Z with modulus 12, of order 12

               n mod 12                |                 n^f
---------------------------------------+--------------------------------------
   0  4  6 10                          | n - 1
   1  7                                | 2n
   2                                   | (n - 2)/2
   3  9                                | 2n + 2
   5 11                                | n + 2
   8                                   | n/2

gap> cent in Group(h); # This particular element is even a power of h.
true


3.6-3 ShortCycles
> ShortCycles( f, maxlng )( operation )

Returns: All "single" finite cycles of the rcwa mapping f of length at most maxlng.

In this context, "single" finite cycles are finite cycles which do not belong to an infinite series. This means that there is no constant m such that adding any multiple of m to the elements of the cycle always yields another cycle. Since GAP-permutations cannot move negative integers, rationals or polynomials, the cycles are returned as lists. For example, the list [-3,1,2,-2] denotes the cycle (-3,1,2,-2). Permutations with different sets of finite cycle lengths are obviously not conjugate.



gap> ShortCycles(a,5);
[ [ 0 ], [ 1 ], [ -1 ], [ 2, 3 ], [ -3, -2 ], [ 4, 6, 9, 7, 5 ], 
  [ -9, -7, -5, -4, -6 ] ]
gap> ShortCycles(u,2);
[ [ 0 ], [ -1 ], [ 1, 2 ], [ 3, 5 ], [ -10, -6 ] ]
gap> ShortCycles(Comm(a,b),10);
[  ]
gap> ShortCycles(a*b,2);
[ [ 0 ], [ 2 ], [ 3 ], [ -26 ], [ 7 ], [ -3 ], [ -1 ] ]
gap> v := RcwaMapping([[-1,2,1],[1,-1,1],[1,-1,1]]);;
gap> w := RcwaMapping([[-1,3,1],[1,-1,1],[1,-1,1],[1,-1,1]]);;
gap> List( [ v, w ], Order );
[ 6, 8 ]
gap> [ ShortCycles(v,10), ShortCycles(w,10) ];
[ [ [ 0, 2, 1 ] ], [ [ 0, 3, 2, 1 ] ] ]


3.6-4 NrConjugacyClassesOfRCWAZOfOrder
> NrConjugacyClassesOfRCWAZOfOrder( ord )( function )

Returns: The number of conjugacy classes of RCWA(Z) of elements of order ord.



gap> NrConjugacyClassesOfRCWAZOfOrder(2);
infinity
gap> NrConjugacyClassesOfRCWAZOfOrder(105);
218


3.7 Restriction and induction

3.7-1 Restriction
> Restriction( g, f )( operation )

Returns: The restriction of the rcwa mapping g by the injective rcwa mapping f.

By definition, the restriction g_f of the rcwa mapping g by the injective rcwa mapping f is the uniquely determined rcwa mapping which satisfies f * g_f = g * f and fixes the complement of the image of f pointwisely. If f is bijective, the restriction of g by f is just the conjugate of g under f. See also Restriction (3.7-2) for rcwa groups.



gap> Comm(Restriction(a,RcwaMapping([[2,0,1]])),
>         Restriction(u,RcwaMapping([[2,1,1]])));
IdentityMapping( Integers )


3.7-2 Restriction
> Restriction( G, f )( operation )

Returns: The restriction of the rcwa group G by the injective rcwa mapping f.

By definition, the restriction of the rcwa group G by the injective rcwa mapping f consists of the restrictions of the elements of G by f. The restriction of G by f acts on the image of f and fixes its complement pointwisely. See also Restriction (3.7-1) for rcwa mappings.



gap> G := Restriction(Group(a,b),RcwaMapping([[5,3,1]]));
<rcwa group over Z with 2 generators>
gap> MovedPoints(G);
3(5) \ [ -2, 3 ]


3.7-3 Induction
> Induction( g, f )( operation )
> Induction( G, f )( operation )

Returns: The induction of the rcwa mapping g resp. the rcwa group G by the injective rcwa mapping f.

By definition, induction is the right inverse of restriction. This means that it is Induction(Restriction(g,f),f) = g resp. Induction(Restriction(G,f),f) = G. The mapping g resp. the group G must not move points outside the image of f.



gap> Induction(G,RcwaMapping([[5,3,1]])) = Group(a,b);
true


Restriction monomorphisms permit forming direct products and wreath products of rcwa groups, regardless of whether they are tame or not:

3.7-4 DirectProduct
> DirectProduct( G1, G2, ... )( method )

Returns: An rcwa group isomorphic to the direct product of the rcwa groups over Z given as arguments.

There is certainly no unique or canonical way to embed a direct product of rcwa groups into RCWA(Z). This method chooses to embed the groups G1, G2, G3 ... via restrictions by n -> mn, n -> mn+1, n -> mn+2 ..., where m denotes the number of groups given as arguments.



gap> G := DirectProduct(Group(g,h),Group(a,b),Group(u));;
gap> Embedding(G,1);
[ g, h ] -> [ <bijective rcwa mapping of Z with modulus 18, of order 7>, 
  <bijective rcwa mapping of Z with modulus 18, of order 12> ]
gap> List([1..3],i->MovedPoints(Image(Embedding(G,i))));
[ 0(3), 1(3) \ [ -2, 1 ], 2(3) \ [ -1, 2 ] ]
gap> Image(Projection(G,2)) = Group(a,b);
true


3.7-5 WreathProduct
> WreathProduct( G, P )( method )
> WreathProduct( G, Z )( method )

Returns: An rcwa group isomorphic to the wreath product of the rcwa group G over Z with the finite permutation group P, resp. with the infinite cyclic group Z.

There is certainly no unique or canonical way to embed a wreath product of rcwa groups into RCWA(Z). The first-mentioned method embeds the DegreeAction(P)th direct power of G using the method for DirectProduct, and lets the permutation group P act naturally on the set of residue classes modulo DegreeAction(P). The second-mentioned method restricts the group G to the residue class 3(4), and maps the generator of the infinite cyclic group Z to ClassTransposition(0,2,1,2) * ClassTransposition(0,2,1,4).



gap> G := Group(g,h);;
gap> IsTame(G); Size(G);    
true
infinity
gap> H := WreathProduct(G,AlternatingGroup(5));
<tame rcwa group over Z with 12 generators, of size infinity>




gap> Embedding(H,1);
[ g, h ] -> [ <bijective rcwa mapping of Z with modulus 30, of order 7>, 
  <bijective rcwa mapping of Z with modulus 30, of order 12> ]
gap> Embedding(H,2);
[ (1,2,3,4,5), (3,4,5) ] -> 
[ <bijective rcwa mapping of Z with modulus 5, of order 5>, 
  <bijective rcwa mapping of Z with modulus 5, of order 3> ]
gap> H := WreathProduct(G,Group(ClassShift(0,1)));
<wild rcwa group over Z with 3 generators>
gap> Support(Image(Embedding(H,1)));
3(4)
gap> Embedding(H,2);
[ ClassShift(0,1) ] -> [ <wild bijective rcwa mapping of Z with modulus 4> ]


3.8 Special attributes for tame rcwa groups

There is a couple of attributes which a priori make only sense for tame rcwa groups. In the sequel, these attributes are described in detail.

With their help, various structural information about a given tame rcwa group can be obtained. For example there are methods for IsSolvable and IsPerfect available for tame rcwa groups (the latter works in some cases by other means also for wild groups). Often it is also feasible to compute the derived subgroup of a tame rcwa group.

3.8-1 RespectedPartition
> RespectedPartition( G )( attribute )
> RespectedPartition( sigma )( attribute )

Returns: A respected partition of G resp. sigma.

A respected partition of G resp. sigma is a partition of the underlying ring R into a finite number of residue classes on which G resp. the cyclic group generated by sigma acts in a natural way as a permutation group, and on whose elements all elements of G resp. all powers of sigma are affine. In the author's thesis it is shown that such a partition exists if and only if G resp. sigma is tame (see Theorem 2.5.8).



gap> G := Group(g,h);; Size(G);
infinity
gap> P := RespectedPartition(G);
[ 0(6), 1(6), 3(6), 4(6), 5(6), 2(12), 8(12) ]
gap> Permutation(g,P);
(1,6,2,5,3,7,4)


3.8-2 ActionOnRespectedPartition
> ActionOnRespectedPartition( G )( attribute )

Returns: The action of the tame rcwa group G on RespectedPartition(G).



gap> H := ActionOnRespectedPartition(G);
Group([ (1,6,2,5,3,7,4), (1,6,2,5)(3,7,4) ])
gap> H = Action(G,P);
true
gap> StructureDescription(H);
"S7"


3.8-3 IntegralConjugate
> IntegralConjugate( G )( attribute )
> IntegralConjugate( f )( attribute )

Returns: Some integral conjugate of the tame rcwa group G resp. of the tame bijective rcwa mapping f in the group RCWA(Z).

In the author's thesis it is shown that such a conjugate exists (see Theorem 2.5.14). There are usually infinitely many such conjugates, and methods for this operation may choose any of them.



gap> Display(IntegralConjugate(g));

Bijective rcwa mapping of Z with modulus 7, of order 7

                n mod 7                |                 n^f
---------------------------------------+--------------------------------------
  0                                    | n + 5
  1                                    | n + 3
  2                                    | n + 4
  3 6                                  | n - 3
  4                                    | n - 2
  5                                    | n - 4

gap> RespectedPartition(IntegralConjugate(G));
[ 0(7), 1(7), 2(7), 3(7), 4(7), 5(7), 6(7) ]
gap> Action(IntegralConjugate(G),last);
Group([ (1,6,2,5,3,7,4), (1,6,2,5)(3,7,4) ])
gap> last = ActionOnRespectedPartition(G);
true


3.8-4 IntegralizingConjugator
> IntegralizingConjugator( G )( attribute )
> IntegralizingConjugator( f )( attribute )

Returns: An rcwa mapping mapping x such that G^x resp. f^x is integral.

While there are usually infinitely many such rcwa mappings, it is taken care that the returned ones always satisfy the relations G^IntegralizingConjugator(G) = IntegralConjugate(G) resp. f^IntegralizingConjugator(f) = IntegralConjugate(f).



gap> Display(IntegralizingConjugator(g));

Bijective rcwa mapping of Z with modulus 12

               n mod 12                |                 n^f
---------------------------------------+--------------------------------------
   0  6                                | 7n/6
   1  7                                | (7n - 1)/6
   2                                   | (7n + 46)/12
   3  9                                | (7n - 9)/6
   4 10                                | (7n - 10)/6
   5 11                                | (7n - 11)/6
   8                                   | (7n + 16)/12



3.9 The categories of rcwa groups

3.9-1 IsRcwaGroup
> IsRcwaGroup( G )( filter )
> IsRcwaGroupOverZ( G )( filter )
> IsRcwaGroupOverZ_pi( G )( filter )
> IsRcwaGroupOverGFqx( G )( filter )

Returns: true if G is an rcwa group resp. an rcwa group over the ring of integers resp. an rcwa group over a semilocalization of the ring of integers resp. an rcwa group over a polynomial ring in one variable over a finite field, and false otherwise.




generated by GAPDoc2HTML