The command ConjugateGroup( G, p ) (see ConjugateGroup!for permutation groups in the reference manual) for a permutation group G
with stabilizer chain equips its result also with a stabilizer chain,
namely with the chain of G conjugate by p. Conjugating a stabilizer
chain by a permutation p means replacing all the points which appear in
the orbit components by their images under p and replacing every
permutation g which appears in a labels or transversal component by
its conjugate gp. The conjugate gp acts on the mapped points
exactly as g did on the original points, i.e., (pnt.p). gp = (pnt.g).p. Since the entries in the translabels components are
integers pointing to positions of the labels list, the translabels
lists just have to be permuted by p for the conjugated stabilizer. Then
generators is reconstructed as labels{ genlabels } and
transversal{ orbit } as labels{ translabels{ orbit } }.
This conjugation technique can be generalized.indexgeneralized conjugation technique Instead of mapping points and permutations under the same permutation p, it is sometimes desirable (e.g., in the context of permutation group homomorphisms) to map the points with an arbitrary mapping map and the permutations with a homomorphism hom such that the compatibility of the actions is still valid: map(pnt). hom(g) = map(pnt.g). (Of course the ordinary conjugation is a special case of this, with map(pnt) = pnt.p and hom(g) = gp.)
In the generalized case, the ``conjugated'' chain need not be a stabilizer chain for the image of hom, since the ``preimage'' of the stabilizer of map(b) (where b is a base point) need not fix b, but only fixes the preimage map-1(map(b)) setwise. Therefore the method can be applied only to one level and the next stabilizer must be computed explicitly. But if map is injective, we have map(b).hom(g) = map(b) Û b.g = b, and if this holds, then g = w(g1,¼,gn) is a word in the generators g1,¼,gn of the stabilizer of b and hom(g) = w(hom(g1),¼,hom(gn)) is in the ``conjugated'' stabilizer. If, more generally, hom is a right inverse to a homomorphism j (i.e., j(hom(g)) = g "g), equality \* holds modulo Ker j; in this case the ``conjugated'' chain can be made into a real stabilizer chain by extending each level with the generators Ker j and appending a proper stabilizer chain of Ker j at the end. These special cases will occur in the algorithms for permutation group homomorphisms (see Homomorphisms!for permutation groups in the reference manual).
To ``conjugate'' the points (i.e., orbit) and permutations (i.e.,
labels) of the Schreier tree, a loop is set up over the orbit list
constructed during the orbit algorithm, and for each vertex b with
unique edge a(l)b ending at b, the label l is mapped with
hom and b with map. We assume that the orbit list was built
w.r.t. a certain ordering of the labels, where l¢ < l means that every
point in the orbit was mapped with l¢ before it was mapped with l.
This shape of the orbit list is guaranteed if the Schreier tree is
extended only by AddGeneratorsExtendSchreierTree, and it is then also
guaranteed for the ``conjugated'' Schreier tree. (The ordering of the
labels cannot be read from the Schreier tree, however.)
In the generalized case, it can happen that the edge a(l)b bears a label l whose image is ``old'', i.e., equal to the image of an earlier label l¢ < l. Because of the compatibility of the actions we then have map(b) = map(a). hom(l)-1 = map(a).hom(l¢)-1 = map(al¢-1), so map(b) is already equal to the image of the vertex al¢-1. This vertex must have been encountered before b = al-1 because l¢ < l. We conclude that the image of a label can be ``old'' only if the vertex at the end of the corresponding edge has an ``old'' image, too, but then it need not be ``conjugated'' at all. A similar remark applies to labels which map under hom to the identity.
GAP 4 manual