Orbits, stabilizers, actions

Goal

Compute the orbit of a point, the stabilizer of a point, and all orbits of a group. Then we'll see the orbit–stabilizer theorem fall out as an arithmetic check!

Concept

A group acts on a set when each element permutes it. The orbit of a point x is everywhere the group can send x; the stabilizer is the subgroup fixing x. Orbit–stabilizer: |orbit(x)| · |Stab(x)| = |G|. For a permutation group the default action is on points 1..n, so Orbit(G, x) and Stabilizer(G, x) need no extra arguments - but the same functions take an explicit action (on sets, tuples, subspaces…) when you supply one. This is the machinery behind every "centralizer contains that factor" reading later.

Commands to try

G := Group( (1,2,3), (3,4,5) );
Orbit(G, 1);

Predict the orbit of 1 first. These generators move 1 through {1,2,3} and 3 into {3,4,5}, so the orbit should be all of 1..5. Expect [ 1, 2, 3, 4, 5 ] (some order). A group whose action has a single orbit is transitive.

Size(G);

Note this number; we'll divide by it.

S := Stabilizer(G, 1);
Size(S);

The subgroup fixing point 1. Now the theorem:

Size(Orbit(G,1)) * Size(Stabilizer(G,1)) = Size(G);

Expect true. That's orbit–stabilizer as a one-line GAP assertion: predict each factor, then watch them multiply to |G|.

Orbits(G, [1..5]);

All orbits on the listed points, as a list of lists. For this transitive G, one orbit covering everything.

H := Group( (1,2), (3,4,5) );
Orbits(H, [1..5]);
IsTransitive(H, [1..5]);

Predict: H keeps {1,2} and {3,4,5} separate, so two orbits and not transitive. Expect [ [ 1, 2 ], [ 3, 4, 5 ] ] and false.

Predict-then-check

For A5 = AlternatingGroup(5) acting on 1..5:

A5 := AlternatingGroup(5);;
Orbit(A5, 1);
Size(Stabilizer(A5, 1));

Predict both: A5 is transitive on 5 points (one orbit of size 5), so by orbit–stabilizer the point-stabilizer has order 60/5. What group of that order is it? (Name it before checking - it's a familiar small group.)

Exercise

1. For G := Group( (1,2,3,4,5) ) (a single 5-cycle), compute Orbit(G,1) and Stabilizer(G,1). Verify orbit–stabilizer. What is the stabilizer's size, and why does that make sense for a regular cyclic action?
2. Take D := Group( (1,2,3,4), (1,3) ) (a dihedral group on a square). Compute its orbit on 1, its size, and Stabilizer(D,1); check the theorem.
3. Build a group acting with exactly three orbits on 1..6 and confirm with Orbits. (Pick generators that keep three blocks separate.)
4. Predict the size of Stabilizer(SymmetricGroup(5), 5) and identify the group.

Pitfalls

• Orbit/Stabilizer default to the natural action on points. For actions on sets, pairs, or subspaces you pass the points and an action function (e.g. OnSets, OnTuples), a later need; know the default for now.
• Orbit(G, x) returns the orbit as a list in traversal order, not sorted. Use Set(Orbit(...)) if you want it canonical.
• IsTransitive(G, dom) and Orbits(G, dom) need the domain dom when it isn't just "the moved points" - pass [1..n] to be explicit.
• Orbit–stabilizer is exact only when orbit and stabilizer are of the same action and point; mixing a point's orbit with another point's stabilizer won't multiply to |G|.
• For a regular action (group acting on itself), every stabilizer is trivial and every orbit has size |G|, quite a useful sanity anchor.