# About cube combinations and calculators...



## Betmaster81 (Jan 16, 2017)

Hi, I'm new of the forum! 
I'm searching about the number of different combinations that can origin from start position after X moves *taking in account symmetry*. For example: after one move I can have only one positions or two (if considering M as one move), after two moves can have 9 ecc...

I ask also where to download a software that calculate *peferct algorithms* at least for simple group of positions like after F2L (perfect 1LL calculator) or also other kind of "simple" positions (for simple I mean positions that require not much calculation for a pc) or a F2L perfect calculators to multi-block insert, ecc...

Thanks


----------



## shadowslice e (Jan 16, 2017)

There's a table of roughly this in the 20 moves suffice paper and website. I believe if you divide by 6 you'll get what you're looking for (unless you're using QTM in which case this might be more useful). I don't believe any such table exists for STM as there are only conjectures of the moves and no final proof). For a very rough estimate, which takes no attempt to weed out positions which can be reached with fewer moves, use (n^12)/6 for QTM, (n^18)/6 for HTM and (n^27)/6 for STM. You might want to take into account this gets less and less accurate the more numbers you put in to the point where you might as well give up for n>10 (though I suppose it is possible to just make use of symmetry and try to go the other way).

For optimal algorithms, most people use cube explorer though if you are generating algorithms for human use it is usually a good idea to look at slightly longer algorithms which might be more fingertrickable and so can be executed quicker. I recommend watching this tutorial and this tutorial before you start. If you want to use other puzzles, try ksolve or HARCS (Here's A Replacement Cube Solver) if you want to find optimal steps for each major method.


----------



## cuBerBruce (Jan 21, 2017)

As for the first question, the answer can be found at https://oeis.org/A005452 (up to 18 moves). Allowing half turns (face turn metric), then the symmetry-reduced number of positions at each depth is known up to 15 moves deep as given here. I note that this link uses the term "mod M" to indicate the symmetry-reduced number of positions. That term comes from the early days of the cube and mathematician Dan Hoey who used the letter M to refer to the group of 48 symmetries of a cube.

If you care about slice turn metric and slice quarter turn metric, see this thread. The slice turn metric numbers are given up to distance 11 (the initial post only goes to distance 10), and I posted the values for slice quarter turn metric to distance 8.

With regard to the 2nd question, as shadowslice e mentioned, Cube Explorer can be useful. It may not be useful for some types of situations such as OLL, for example. It also not that great for dealing with situations such as solving LL pieces relative to each other instead of solving them absolutely with respect to the first two layers. (ACube is often better for such things.)

Generating all the cases can be tedious. I've sometimes used GAP to generate the cases. For a simple example, I generate all the cases that can be generated by U and sune in the GAP code in the spoiler. The output from the PrintSymReps call can be copy-pasted to a text file that can be loaded by Cube Explorer.



Spoiler





```
[PLAIN]
U := ( 1, 3, 8, 6)( 2, 5, 7, 4)( 9,33,25,17)(10,34,26,18)(11,35,27,19);
U2 := U*U;
U3 := U2*U;
L := ( 9,11,16,14)(10,13,15,12)( 1,17,41,40)( 4,20,44,37)( 6,22,46,35);
L2 := L*L;
L3 := L2*L;
F := (17,19,24,22)(18,21,23,20)( 6,25,43,16)( 7,28,42,13)( 8,30,41,11);
F2 := F*F;
F3 := F2*F;
R := (25,27,32,30)(26,29,31,28)( 3,38,43,19)( 5,36,45,21)( 8,33,48,24);
R2 := R*R;
R3 := R2*R;
B := (33,35,40,38)(34,37,39,36)( 3, 9,46,32)( 2,12,47,29)( 1,14,48,27);
B2 := B*B;
B3 := B2*B;
D := (41,43,48,46)(42,45,47,44)(14,22,30,38)(15,23,31,39)(16,24,32,40);
D2 := D*D;
D3 := D2*D;
E1 := (12,20,28,36)(13,21,29,37)(50,51,52,53);
y := U*(E1^3)*D3;
mir := (1,3)(4,5)(6,8)(9,27)(10,26)(11,25)(12,29)(13,28)
(14,32)(15,31)(16,30)(17,19)(20,21)(22,24)(33,35)(36,37)(38,40)
(41,43)(44,45)(46,48)(50,52);

EdgeReid := [ 7,18, 5,26, 2,34, 4,10, 42,23, 45,31, 47,39, 44,15, 21,28, 20,13, 36,29, 37,12 ];
CorReid := [ 8,19,25, 3,27,33, 1,35,9, 6,11,17, 43,30,24, 41,22,16, 46,14,40, 48,38,32 ];

sune := R*U*R3*U*R*U2*R3;
Gsune := Group (sune, U);

fururf := F*U*R*U3*R3*F3;
Jperm := B2*L*U*L3*B2*R*D3*R*D*R2;

GLL := Group (U, fururf, Jperm);
GLLsym := Group (y, mir);

GLLsym := Group (y, mir);

ReidStr := function (g)
  local i, h, x, sout;
  h := g^-1;
  sout := "";
  i := 1;
  while i <= 24 do
    x := EdgeReid[i]^h;
    if x <=24 then
      if x <= 8 then
        Add (sout, 'U');
      else
        if x <= 16 then
          Add (sout, 'L');
        else
          Add (sout, 'F');
        fi;
      fi;
    else
      if x <= 32 then
        Add (sout, 'R');
      else
        if x <= 40 then
          Add (sout, 'B');
        else
          Add (sout, 'D');
        fi;
      fi;
    fi;
    if i mod 2 = 0 then
      Add (sout, ' ');
    fi;
    i := i + 1;
  od;
  i := 1;
  while i <= 24 do
    x := CorReid[i]^h;
    if x <=24 then
      if x <= 8 then
        Add (sout, 'U');
      else
        if x <= 16 then
          Add (sout, 'L');
        else
          Add (sout, 'F');
        fi;
      fi;
    else
      if x <= 32 then
        Add (sout, 'R');
      else
        if x <= 40 then
          Add (sout, 'B');
        else
          Add (sout, 'D');
        fi;
      fi;
    fi;
    if (i < 24) and ((i mod 3) = 0) then
      Add (sout, ' ');
    fi;
    i := i + 1;
  od;
  Add (sout, '\n');
  return sout;
end;

SymClass := function (g, Gsym, auf)
  local h, m, n, i, j, match, Lout;
  Lout := [];
  n := Order(auf);
  match := 0;
  for m in Gsym do
    i := 0;
    while i < n do
      j := 0;
      while j < n do
        h := m*(auf^(-j))*g*(auf^j)*(m^-1)*(auf^i);
        if not (h in Lout) then
          Add (Lout, h);
        fi;
        j := j + 1;
      od;
      i := i + 1;
    od;
  od;
  return Lout;
end;

CountSymClasses := function (GAll, GSym, auf)
  local g, L, L2, n;
  L := [];
  n := 0;
  for g in GAll do
    if not (g in L) then
      L2 := SymClass(g, GSym, auf);
      L := Concatenation (L, L2);
      n := n + 1;
    fi;
  od;
  return n;
end;

PrintSymClassReps := function (GAll, GSym, auf)
  local g, L, L2;
  L := [];
  for g in GAll do
    if not (g in L) then
      L2 := SymClass(g, GSym, auf);
      L := Concatenation (L, L2);
      Print (ReidStr (g));
    fi;
  od;
end;

PrintSymClassReps (Gsune, GLLsym, ());
[/PLAIN]
```


----------

