Discussions on the mathematics of the cube

## Commutator elements of the cube

I was wondering if the number of commutator elements of the cube is known?

Commutator elements are of the form ABA'B' where A and B are some sequences.

It seems that the subgroup generated by the commutator elements is half the size of the cube, but is it the case that every element of the commutator subgroup is a commutator element? if not how many are they and how far they are from solved?

## Conjugacy classes of the cube

I was reading the following :

http://en.wikipedia.org/wiki/Conjugacy_class

and wondered if the number of conjugacy classes of the cube is known?

## Challenge with three faces

Ok, I think you all can solve the cube without thinking. So here is a new challenge. First scramble the cube. Next, make the 2x2x2 cube on your 3x3x3 cube. After that, solve the rest of the cube by using three faces only. I can tell you that I know plenty of tricks to solve the cube, but only just enough remain to when you are restricted to three mutually adjacent faces.

## Linear formula

Let's assume that there is a linear formula that gives us P(n) using P(k) where 0 <= k <= n-1. P(n) is the number of positions at depth n.

We have then the following formula:

P(n) = sum(R(k)*P(n-k)) for 1 <= k <= n

Calculating R(k) using rokiki's results we deduce :

``` 1 12                   = 12*1
2 114                  = 12*12                  -30*1
3 1068                 = 12*114                 -30*12                  +60*1
4 10011                = 12*1068                -30*114                 +60*12                  -105*1```

## Algorithm for Counting Identities

I've been thinking about writing a program to calculate and count duplicate positions - roughly speaking, those positions that are half way through an identity.  What I have in mind will probably be a more time consuming program to write than I would prefer.  So I wonder if I could ask Herbert Kociemba and/or mdlazreg to post a little something about the programs they have already written to find identities.  It may well be that there is a much simpler approach to calculating duplicate positions than what I have in mind.

What I have in mind is an iterative deepening depth first search beginning at the Start position.  If that's all I did, the search would simply count 12n maneuvers for each distance from n, and it would not extract any useful information about how many duplicate positions there are for each n.  To solve these problems, I propose to store all the duplicate positions and not to store those positions that are not duplicate.  This would be for the quarter turn metric.  The program I have in mind would not be able to handle the face turn metric.

## God's algorithm for FTM mod 48, 2. Try

In FTM the complete knowledge of the distribution of the symmetric subgroups (first table of http://kociemba.org/symmetric2.htm ) lets us not only give the odd and even entries in the distance table but also the distances mod 48, because all unsymmetric position contribute with a multiple of 48. So we get
```
distance   positions mod 48

0              1
1             18
2              3
3             24
4             39
5             12
6             22
7             12
8             40
9              3
10              4
11             20```

## Puzzle about the Cube: Coloring the Cayley Graph

Here's an easy puzzle for Rubik's Cube: What's the chromatic number of the Cayley graph for the quarter turn metric?

Here's a slightly harder puzzle: What's the chromatic number of the Cayley graph for the half turn metric? If you can't figure it out, can you figure out an upper bound? A lower bound?

This was discussed on speedsolving.com before, but I think it's a good enough puzzle to present here as well.

## God's Algorithm out to 15q*

I've finally managed to compute God's Algorithm out to 15q*. This took longer than I expected; I had difficulties using multiple cores because occasionally the memory consumption of the concurrently-calculated cosets would exceed my physical RAM; even though this was rare, it happened frequently enough to completely stall the computation. Also, the way memory was allocated and freed led to pretty intense memory fragmentation.

In any case, it is finally done; here are the results. First we have positions at exactly that depth:

` d   mod M + inv          mod M       positions`

## Numerical formula

I wrote a program that counts cube positions by taking into account only the identities of length 4 and the identities of length 12. The results of this program are in the second column below:

``` d                  positions I4     positions I4&I12   positions  ALL
--                  ------------     ----------------   --------------

0                             1                    1                1
1                            12                   12               12
2                           114                  114              114```

## Drupal database corrupted

Sorry folks, I've been very busy lately and I just noticed the mysql database was badly corrupted on Sept. 6th, 2009. The database is updated daily, but all the backups on Sept. 6th and after are unusable. I think the only post lost was Tom Rokicki's.

I try my best to make sure everything is working but this one slipped through the cracks. Somehow the mysql database ballooned in size to over 2 gigabytes. After that happened the subsequent databases were not backed up correctly.

It would be a good idea for any posts to be buffered in some way before uploading to the forum, especially long ones.