1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
|
#############################################################################
##
#F FromTheLeftCollector_Power . . . . . . . . . . . . . . . . . . . . . .
##
#BindGlobal( "FromTheLeftCollector_Power", function( coll, w, e )
#
# if e < 0 then
# w := FromTheLeftCollector_Inverse( coll, w );
# e := -e;
# fi;
#
# return BinaryPower( coll, w, e );
#end );
#
#############################################################################
##
#F ProductAutomorphisms . . . . . . . . . . . . . . . . . . . . . . . . .
##
#BindGlobal( "ProductAutomorphisms", function( coll, alpha, beta )
# local ngens, gamma, i, w, ev, g;
# ngens := NumberGeneratorsOfRws( coll );
# gamma := [];
# for i in [1..ngens] do
# if IsBound( alpha[i] ) then
# w := alpha[i];
# ev := ListWithIdenticalEntries( ngens, 0 );
# for g in [1,3..Length(w)-1] do
# if w[g+1] <> 0 then
# CollectWordOrFail( coll, ev,
# FromTheLeftCollector_Power(
# coll, beta[ w[g] ], w[g+1] ) );
# fi;
# od;
# gamma[i] := ObjByExponents( coll, ev );
# fi;
# od;
# return gamma;
#end );
#############################################################################
##
#F PowerAutomorphism . . . . . . . . . . . . . . . . . . . . . . . . . . .
##
#BindGlobal( "PowerAutomorphism", function( coll, g, e )
# local n, a, power, h, ipower;
#
# n := NumberGeneratorsOfRws( coll );
#
# # initialise automorphism
# a := [];
# power := [];
# for h in [g+1..n] do
# if e > 0 then
# if IsBound( coll![ PC_CONJUGATES][h] ) and
# IsBound( coll![ PC_CONJUGATES ][h][g] ) then
# a[h] := coll![ PC_CONJUGATES ][h][g];
# else
# a[h] := [h,1];
# fi;
# else
# if IsBound( coll![ PC_CONJUGATESINVERSE ][h] ) and
# IsBound( coll![ PC_CONJUGATESINVERSE ][h][g] ) then
# a[h] := coll![ PC_CONJUGATESINVERSE ][h][g];
# else
# a[h] := [h,1];
# fi;
# fi;
# power[h] := [h,1];
# od;
# if e < 0 then
# e := -e;
# fi;
#
# while e > 0 do
# if e mod 2 = 1 then
# power := ProductAutomorphisms( coll, power, a );
# fi;
# e := Int( e / 2 );
# if e > 0 then
# a := ProductAutomorphisms( coll, a, a );
# fi;
# od;
# ipower := [];
# for h in [g+1..n] do
# ipower[h] := FromTheLeftCollector_Inverse( coll, power[h] );
# od;
#
# return [ power, ipower ];
#end );
#
|
