This section contains an extended example to show you how a computation
in a domain may use default and special functions to achieve its goal.
Suppose you defined G, x, and y as follows.
gap> G := SymmetricGroup( 8 );;
gap> x := [ (2,7,4)(3,5), (1,2,6)(4,8) ];;
gap> y := [ (2,5,7)(4,6), (1,5)(3,8,7) ];;
Now you ask for an element of G that conjugates x to y, i.e., a
permutation on 8 points that takes (2,7,4)(3,5) to (2,5,7)(4,6) and
(1,2,6)(4,8) to (1,5)(3,8,7). This is done as follows (see
RepresentativeOperation and Other Operations).
gap> RepresentativeOperation( G, x, y, OnTuples );
(1,8)(2,7)(3,4,5,6)
Let us look at what happens step by step. First
RepresentativeOperation is called. After checking the arguments it
calls the function G.operations.RepresentativeOperation, which is the
function SymmetricGroupOps.RepresentativeOperation, passing the
arguments G, x, y, and OnTuples.
SymmetricGroupOps.RepresentativeOperation handles a lot of cases
specially, but the operation on tuples of permutations is not among them.
Therefore it delegates this problem to the function that it overlays,
which is PermGroupOps.RepresentativeOperation.
PermGroupOps.RepresentativeOperation also does not handle this special
case, and delegates the problem to the function that it overlays, which
is the default function called GroupOps.RepresentativeOperation.
GroupOps.RepresentativeOperation views this problem as a general tuples
problem, i.e., it does not care whether the points in the tuples are
integers or permutations, and decides to solve it one step at a time. So
first it looks for an element taking (2,7,4)(3,5) to (2,5,7)(4,6) by
calling RepresentativeOperation( G, (2,7,4)(3,5), (2,5,7)(4,6) ).
RepresentativeOperation calls G.operations.RepresentativeOperation
next, which is the function SymmetricGroupOps.RepresentativeOperation,
passing the arguments G, (2,7,4)(3,5), and (2,5,7)(4,6).
SymmetricGroupOps.RepresentativeOperation can handle this case. It
knows that G contains every permutation on 8 points, so it contains
(3,4,7,5,6), which obviously does what we want, namely it takes x[1]
to y[1]. We will call this element t.
Now GroupOps.RepresentativeOperation (see above) looks for an s in
the stabilizer of x[1] taking x[2] to y[2]^(t^-1), since then for
r=s*t we have x[1]^r = (x[1]^s)^t = x[1]^t = y[1] and also
x[2]^r = (x[2]^s)^t = (y[2]^(t^-1))^t = y[2]. So the next step
is to compute the stabilizer of x[1] in G. To do this it calls
Stabilizer( G, (2,7,4)(3,5) ).
Stabilizer calls G.operations.Stabilizer, which is
SymmetricGroupOps.Stabilizer, passing the arguments G and
(2,7,4)(3,5). SymmetricGroupOps.Stabilizer detects that the second
argument is a permutation, i.e., an element of the group, and calls
Centralizer( G, (2,7,4)(3,5) ). Centralizer calls the function
G.operations.Centralizer, which is SymmetricGroupOps.Centralizer,
again passing the arguments G, (2,7,4)(3,5).
SymmetricGroupOps.Centralizer again knows how centralizers in
symmetric groups look, and after looking at the permutation
(2,7,4)(3,5) sharply for a short while returns the centralizer as
Subgroup( G, [ (1,6), (1,6,8), (2,7,4), (3,5) ] ), which we will call
S. Note that S is of course not a symmetric group, therefore
SymmetricGroupOps.Subgroup gives it PermGroupOps as operations record
and not SymmetricGroupOps.
As explained above GroupOps.RepresentativeOperation needs an element of
S taking x[2] ((1,2,6)(4,8)) to y[2]^(t^-1) ((1,7)(4,6,8)).
So RepresentativeOperation( S, (1,2,6)(4,8), (1,7)(4,6,8) ) is called.
RepresentativeOperation in turn calls the function
S.operations.RepresentativeOperation, which is, since S is a
permutation group, the function PermGroupOps.RepresentativeOperation,
passing the arguments S, (1,2,6)(4,8), and (1,7)(4,6,8).
PermGroupOps.RepresentativeOperation detects that the points are
permutations and and performs a backtrack search through S. It finds
and returns (1,8)(2,4,7)(3,5), which we call s.
Then GroupOps.RepresentativeOperation returns r = s*t =
(1,8)(2,7)(3,6)(4,5), and we are done.
In this example you have seen how functions use the structure of their
domain to solve a problem most efficiently, for example
SymmetricGroupOps.RepresentativeOperation but also the backtrack search
in PermGroupOps.RepresentativeOperation, how they use other functions,
for example SymmetricGroupOps.Stabilizer called Centralizer, and how
they delegate cases which they can not handle more efficiently back to
the function they overlaid, for example
SymmetricGroupOps.RepresentativeOperation delegated to
PermGroupOps.RepresentativeOperation, which in turn delegated to to the
function GroupOps.RepresentativeOperation.
GAP 3.4.4