How does the base of a group determine the "sort" of the elements in the group

Question

I'm trying to study groups in Mathematica, and I've asked a question on Mathematica.SE that perhaps only someone from Math.SE could answer.

Related: How does GroupActionBase affect the order of elements in a group?

We typically don't think of elements of groups, or even sets to have an inherent "sort order", but a computer must select one in order to operate on, and display the group. Mathematica uses a command called GroupActionBase to determine the sort order of the elements in a group, but it doesn't specify how. At first I thought the term base in this context was specific to Mathematica, but I was surprised when I looked it up and saw that it was an algebra term. That page has an example that I've copied from the help file (the help file doesn't say much more than what I've copied to that question). Can someone familiar with group bases clue me in on how Mathematica might be using them to determine what order to represent and display elements in? (Mathematica treats every group as its isomorphic subgroup of some $S_n$, so elements are represented in cycle form.)

Edit
Here are some additional examples I've generated that might help.

As noted on the other site, if I don't provide a complete base, Mathematica extends it somehow (unspecified) to form a complete base. I also note that if I'm understanding a base correctly, a base for $S_n$ would consist of $n$ (or $n-1$?) points with at most $n!$ different ways to order them, but the number of elements in $S_n$ itself is $n!$, so there are $(n!)!$ different ways to order them. This would seem to me that I can't force any order I want, and the examples below seem to follow some similar pattern indicating that.

In[1]:= GroupElements[SymmetricGroup[3], GroupActionBase -> {1}] // TableForm
Out[1]//TableForm=
        Cycles[{}]
        Cycles[{{2,3}}]
        Cycles[{{1,2}}]
        Cycles[{{1,2,3}}]
        Cycles[{{1,3,2}}]
        Cycles[{{1,3}}]

In[2]:= GroupElements[SymmetricGroup[3], GroupActionBase -> {2}] // TableForm
Out[2]//TableForm=
        Cycles[{}]
        Cycles[{{1,3}}]
        Cycles[{{1,2}}]
        Cycles[{{1,3,2}}]
        Cycles[{{1,2,3}}]
        Cycles[{{2,3}}]

In[3]:= GroupElements[SymmetricGroup[3], GroupActionBase -> {3}] // TableForm
Out[3]//TableForm=
        Cycles[{}]
        Cycles[{{1,2}}]
        Cycles[{{1,3}}]
        Cycles[{{1,2,3}}]
        Cycles[{{1,3,2}}]
        Cycles[{{2,3}}]

In[4]:= GroupElements[SymmetricGroup[3], GroupActionBase -> {1, 2}] // TableForm
Out[4]//TableForm=
        Cycles[{}]
        Cycles[{{2,3}}]
        Cycles[{{1,2}}]
        Cycles[{{1,2,3}}]
        Cycles[{{1,3,2}}]
        Cycles[{{1,3}}]

In[5]:= GroupElements[SymmetricGroup[3], GroupActionBase -> {1, 3}] // TableForm
Out[5]//TableForm=
        Cycles[{}]
        Cycles[{{2,3}}]
        Cycles[{{1,3}}]
        Cycles[{{1,3,2}}]
        Cycles[{{1,2,3}}]
        Cycles[{{1,2}}]

In[6]:= GroupElements[SymmetricGroup[3], GroupActionBase -> {2, 3}] // TableForm
Out[6]//TableForm=
        Cycles[{}]
        Cycles[{{1,3}}]
        Cycles[{{2,3}}]
        Cycles[{{1,2,3}}]
        Cycles[{{1,3,2}}]
        Cycles[{{1,2}}]

In[7]:= GroupElements[SymmetricGroup[3], GroupActionBase -> {1, 2, 3}] // TableForm
Out[7]//TableForm=
        Cycles[{}]
        Cycles[{{2,3}}]
        Cycles[{{1,2}}]
        Cycles[{{1,2,3}}]
        Cycles[{{1,3,2}}]
        Cycles[{{1,3}}]

In[8]:= GroupElements[SymmetricGroup[3], GroupActionBase -> {1, 3, 2}] // TableForm
Out[8]//TableForm=
        Cycles[{}]
        Cycles[{{2,3}}]
        Cycles[{{1,3}}]
        Cycles[{{1,3,2}}]
        Cycles[{{1,2,3}}]
        Cycles[{{1,2}}]

In[9]:= GroupElements[SymmetricGroup[3], GroupActionBase -> {2, 1, 3}] // TableForm
Out[9]//TableForm=
        Cycles[{}]
        Cycles[{{1,3}}]
        Cycles[{{1,2}}]
        Cycles[{{1,3,2}}]
        Cycles[{{1,2,3}}]
        Cycles[{{2,3}}]

In[10]:= GroupElements[SymmetricGroup[3], GroupActionBase -> {2, 3, 1}] // TableForm
Out[10]//TableForm=
        Cycles[{}]
        Cycles[{{1,3}}]
        Cycles[{{2,3}}]
        Cycles[{{1,2,3}}]
        Cycles[{{1,3,2}}]
        Cycles[{{1,2}}]

In[11]:= GroupElements[SymmetricGroup[3], GroupActionBase -> {3, 1, 2}] // TableForm
Out[11]//TableForm=
        Cycles[{}]
        Cycles[{{1,2}}]
        Cycles[{{1,3}}]
        Cycles[{{1,2,3}}]
        Cycles[{{1,3,2}}]
        Cycles[{{2,3}}]

In[12]:= GroupElements[SymmetricGroup[3], GroupActionBase -> {3, 2, 1}] // TableForm
Out[12]//TableForm=
        Cycles[{}]
        Cycles[{{1,2}}]
        Cycles[{{2,3}}]
        Cycles[{{1,3,2}}]
        Cycles[{{1,2,3}}]
        Cycles[{{1,3}}]

Answer 1

I have very little knowledge of how Mathematica does group computations. [Note: as someone who regularly uses software to do group computations, I would have to recommend GAP or Magma for this (though Magma is not free).]

With a base, one creates a chain of subgroups which gradually stabilize more of the base. For example, with your last example you could create the chain: $$S_3=G \geq G_{(3)}\geq G_{(3,2)} =1.$$ Now each subgroup must contain all the elements that stabilize each of the numbers in the subscript. For example $G_{(3)}=\{ (), (1,2)\}$. Once you include another number to fix, you've only got the trivial group (in this example). It looks as though Mathematica starts at the bottom and moves up. Organizing elements by the smallest subgroup they're contained in.

Of course this isn't the end of the story. It seems that after that sort, they sort by the some kind of hierarchy that is hard to nail down. I was thinking it was based on the order of your base, but it doesn't really seem to be the case.