Probability Thread

[Savi349]

Sure!

Basically you can think of full PLL as 72 cases. However, you also get some cases that are fully rotational symmetric, and can AUF the non-fully rotationally symmetric cases. So the 4 angles of T perm can be treated as 1 unique case by AUFing.

As such, any fully rotational case including a skip case is 1/72, while any other case has a probability of 4/72, which is equal to 1/18, because of the fact it has 4 AUFs.

Edit: Z perm and E perm have a probability of 1/36 because for solved cp and diag cp, the cp swap is rotationally symmetric, and those 2 PLLs have U2 angle symmetry.

Hope this helps!

(I only recently got interested in probability, so feel free to call me out if I got anything wrong)

To add on to the answer above, the original 72 cases is calculated from doing:

(4!*4!)/(2*4)

Incase you haven't learnt about it yet, the "!" Means to make a number factorial. This means to multiple it by every smaller natural number. In other words, 4! = (4*3*2*1).

The two 4! Represent all the possibile corner and edge cases. Because each are independent, they're multiplied together, so that each corner case can be lined up with each edge case.

The total number produced by that is quite high though. But there are a couple of other things that need to be taken into account. Firstly, parity. You can never have an edge swapped with another edge, or a corner swapped with a corner. So this reduces the cases by half. Then secondly, remember that we can do any auf. Think of it like this, even though there's only one h perm alg, the aufs would turn it in to four different algs. If we were solving for 8 pieces of the cube that weren't on the same face, we couldn't do an auf like this, but since we can, it reduces the total amount of cases to an eighth of the original amount.

Therefore the total amount is (4!*4!)/(2*4)
Which simplifies to: 576/8
Which is: 72

If you're interested in learning more about this stuff, I'd recommend watching Jperm's video about the total probability for the cube. He explains the concepts much better than I did

Thank you both so much! It's been really helpful having the maths explained like this, both explanations were beyond helpful! I love Jperm's videos — I didn't realise he had a video on probability, I'll make sure to check it out!

 

[Hashbrown132]

What are the odds of getting a solved layer on a 2x2 from a random scramble

 

[Bruce MacKenzie]

What are the odds of getting a solved layer on a 2x2 from a random scramble

For any one face the odds are 1 in (21•18•15) or 1 in 5,670. Since there are six faces the odds are six times that or 1 in 945.

 

[Herbert Kociemba]

For any one face the odds are 1 in (21•18•15) or 1 in 5,670. Since there are six faces the odds are six times that or 1 in 945.

I do not think that this is correct. The problem is that there is not always exactly one solved layer but there also are nontrivial cases where two layers are solved simultaneously. This makes the computation more complicated. The probability is less than your result because you count some situations more than once.

 

[Osric]

I do not think that this is correct. The problem is that there is not always exactly one solved layer but there also are nontrivial cases where two layers are solved simultaneously. This makes the computation more complicated. The probability is less than your result because you count some situations more than once.

If what you say is correct then the way I am calculating it is also wrong. Can we spot the problem?

There are 7! positions the corner cubies could be in, and 3^7 possible orientations. So the total number of permutations of the cubies of a 2x2 is 5040*2187.

Let’s count all the cases where the top face is in a specific permutation and orientation that corresponds to START’s top face. If we allow symmetries of rotation only, there are 6*4 symmetries that are equivalent so 24 ways to rewrite the coordinate system of the cube so that we recognize any solved face. The remaining 3 corners can be in 3! positions and 3^3 orientations, for a total of 24*24*27 situations where one face is solved.

If by a ”random scramble” we mean a truly random choice among all the possible permutations (and not a “fairly scrambled”) cube, then the odds ought to be (24*24*27)/(5040*2187) = 0.14% or 1/709.

This is higher than the other result and therefore also wrong but I can’t see how?

Osric

 

[Osric]

Let’s count all the cases where the top face is in a specific permutation and orientation that corresponds to START’s top face. If we allow symmetries of rotation only, there are 6*4 symmetries that are equivalent so 24 ways to rewrite the coordinate system of the cube so that we recognize any solved face. The remaining 3 corners can be in 3! positions and 3^3 orientations, for a total of 24*24*27 situations where one face is solved.

Ahem. Perhaps 3! != 24 :-D … and then the result becomes 0.035% or 1/2835. Oops

 

[Herbert Kociemba]

There are 7! positions the corner cubies could be in, and 3^7 possible orientations. So the total number of permutations of the cubies of a 2x2 is 5040*2187.

There are two ways to count. If you fix a corner, ther are 7! permutations and 3^6 orientations, so you get 3674160 positions. Or you do not fix one corner - I use this approach for my computation since you have more symmetries - you have 8! permuations and 3^7 orientations and you get 88179840, which is 24 times larger and corresponds to the 24 possible orientations o a cube in space.

I tried a correct computation myself but I also see some possibility that I did something wrong. Here is my approach:

Let use the abbreviation L_U if exactly the layer U is correct and L_UF if exactly the layers U and F are correct for example. Then there are the following distinct cases:
L_URFDLB: all layers are solved, 1 case
L_UD, L_RL, L_FB: exactly two opposite layers solved, 3 cases
L_UR, L_UF, L_UL, L_UB, L_RF, L_RD, L_RB, L_FD, L_FL, L_DL, L_DB, L_LB: exactly two adjacent layers solved, 12 cases
L_U, L_R, L_F, L_D, L_L, L_B: exactly one layer solved, 6 cases

L_URFDLB: The positions are determined by the URF corner which are 24 different positions.

L_UD: The 24 positions of the URF corner define the solved U-layer. For some specific solved U layer there are 3 different possibilites for a solved D layer (not 4, one case results in L_URFDLB ). So L_UD has 24*3 positions.

L_UR: The 24 positions of the URF corner define the solved U-layer and the solved R layer. For some specific solved U and R layer there are 5 possible positions for the yet undetermined DLF and DLB corners (not 6, one case results in L_URFDLB). So L_UR has 24*5 positions.

L_U: The 24 positions of the URF corner define the solved U-layer. The 4 yet undetermined corners of the D layer have 4!*3^3 = 648 possibilities for each specific U layer. But since the 24*648 possibilites include also the cases L_UD and L_UR, L_UF, L_UL, L_UB and L_URFDLB we have to subtract 24*3 and 4 times 24*5 and 24*1 and we get 24*(648-3-4*5-1) = 24*624 different positions.

Now the total number of positions with at least one solved layer should be
N(L_URFDLB)+ 3*N(L_UD)+12*N(L_UR)+ 6*N(L_U)= 24+3*24*3+12*24*5+6*(24*624) = 91536

So the probability is 91536/88179840 = 1907/1837080 which is slightly less than 1/945

The probability for exactly one solved layer is btw.

6*N(L_U)/88179840=26/25515

 

[Bruce MacKenzie]

I do not think that this is correct. The problem is that there is not always exactly one solved layer but there also are nontrivial cases where two layers are solved simultaneously. This makes the computation more complicated. The probability is less than your result because you count some situations more than once.

You're right. The sets do overlap. The identity cube would be in all six sets for example. I don't know if the probability would be reduced significantly by this. This is a fairly small group. One could generate all the states and count how many have at least one solved face. I'll see what i can do.

I knocked out some code and found 2056 2x2 states with a least one face solved. That gives odds of 2056 in 3,674,160 or 1 in 1787.042847.
You are quite right. This is a very significant difference.

Since my last edit I have filled in some metrics:

There are 2056 states with at least one solved face. There are 2010 states with exactly one solved face. There are 45 states with exactly two solved faces and the identity cube with all six faces solved. There are 9 states with two opposing faces solved but not aligned with one another. I include these in the exactly one face solved count.

A clap on the back and a hearty "Well Done!" to anyone who can derive these numbers from first principles.

 

[Jorian Meeuse]

There are two ways to count. If you fix a corner, ther are 7! permutations and 3^6 orientations, so you get 3674160 positions. Or you do not fix one corner - I use this approach for my computation since you have more symmetries - you have 8! permuations and 3^7 orientations and you get 88179840, which is 24 times larger and corresponds to the 24 possible orientations o a cube in space.

I tried a correct computation myself but I also see some possibility that I did something wrong. Here is my approach:

Let use the abbreviation L_U if exactly the layer U is correct and L_UF if exactly the layers U and F are correct for example. Then there are the following distinct cases:
L_URFDLB: all layers are solved, 1 case
L_UD, L_RL, L_FB: exactly two opposite layers solved, 3 cases
L_UR, L_UF, L_UL, L_UB, L_RF, L_RD, L_RB, L_FD, L_FL, L_DL, L_DB, L_LB: exactly two adjacent layers solved, 12 cases
L_U, L_R, L_F, L_D, L_L, L_B: exactly one layer solved, 6 cases

L_URFDLB: The positions are determined by the URF corner which are 24 different positions.

L_UD: The 24 positions of the URF corner define the solved U-layer. For some specific solved U layer there are 3 different possibilites for a solved D layer (not 4, one case results in L_URFDLB ). So L_UD has 24*3 positions.

L_UR: The 24 positions of the URF corner define the solved U-layer and the solved R layer. For some specific solved U and R layer there are 5 possible positions for the yet undetermined DLF and DLB corners (not 6, one case results in L_URFDLB). So L_UR has 24*5 positions.

L_U: The 24 positions of the URF corner define the solved U-layer. The 4 yet undetermined corners of the D layer have 4!*3^3 = 648 possibilities for each specific U layer. But since the 24*648 possibilites include also the cases L_UD and L_UR, L_UF, L_UL, L_UB and L_URFDLB we have to subtract 24*3 and 4 times 24*5 and 24*1 and we get 24*(648-3-4*5-1) = 24*624 different positions.

Now the total number of positions with at least one solved layer should be
N(L_URFDLB)+ 3*N(L_UD)+12*N(L_UR)+ 6*N(L_U)= 24+3*24*3+12*24*5+6*(24*624) = 91536

So the probability is 91536/88179840 = 1907/1837080 which is slightly less than 1/945

The probability for exactly one solved layer is btw.

6*N(L_U)/88179840=26/25515

Is this for an actual first layer skip (as in half the cube being solved) or just a face skip where the permutation of that face isn't yet decided?

Edit: from the computation it actually seems quite obvious now that this is referring to a solved layer, not face.

 

[Foreright]

Here’s one for Roux - I have 68 CMLL skips (ie. Top corners solved / oriented after block stage) out of my last 1250 or so solves so approx. 2% which is a fair bit better than expected (skip is 1/162 iirc).

I noted earlier when I was looking at smart cube stats that I have one LSE stage skip in my total 3500 or so solves recorded (ie. After CMLL the cube was completely solved). This was also with no AUF. What are the chances of that?

 

[Herbert Kociemba]

You're right. The sets do overlap. The identity cube would be in all six sets for example. I don't know if the probability would be reduced significantly by this. This is a fairly small group. One could generate all the states and count how many have at least one solved face. I'll see what i can do.

I knocked out some code and found 2056 2x2 states with a least one face solved. That gives odds of 2056 in 3,674,160 or 1 in 1787.042847.
You are quite right. This is a very significant difference.

Since my last edit I have filled in some metrics:

There are 2056 states with at least one solved face. There are 2010 states with exactly one solved face. There are 45 states with exactly two solved faces and the identity cube with all six faces solved. There are 9 states with two opposing faces solved but not aligned with one another. I include these in the exactly one face solved count.

A clap on the back and a hearty "Well Done!" to anyone who can derive these numbers from first principles.

 

[Herbert Kociemba]

Are you sure these new values are correct? I mean now you get 2056/3673160 = 0.00056 fo at least one solved face which seems to be too far away from your original 1/945 = 0.0011 which is not correct but at least quite a good approximation because you just ignore the small overlaps. And my hopefully correct value is 1907/1837080 = 0.0010 for at least one solved layer. Why your new probability is only about half of this?

Edit: 1907/1837080 = 3814/3674160, so for your way of counting there should be 3814 and not 2056 states with at least one solved layer.
If you fix for example the DLB corner (what you essentially do if you take 3,674,160 positions in total ) the U, R and F layer counts should be different from your D, B and L layer counts.

 

[Bruce MacKenzie]

Are you sure these new values are correct? I mean now you get 2056/3673160 = 0.00056 fo at least one solved face which seems to be too far away from your original 1/945 = 0.0011 which is not correct but at least quite a good approximation because you just ignore the small overlaps. And my hopefully correct value is 1907/1837080 = 0.0010 for at least one solved layer. Why your new probability is only about half of this?

Edit: 1907/1837080 = 3814/3674160, so for your way of counting there should be 3814 and not 2056 states with at least one solved layer.
If you fix for example the DLB corner (what you essentially do if you take 3,674,160 positions in total ) the U, R and F layer counts should be different from your D, B and L layer counts.

Well I'm fairly confident in my counts. Generating all members of the group is straightforward using radix encoding to compress the position permutation and the orientations to a number between 0 and 3,674,160. And testing for a solved face is trivial. I can not see how I could have under counted to that degree.
-(void)test2: (NSString *)input { NSData *state,*item; OSG_SYMTAG sym; const OSG_SYMTAG *p; NSUInteger index, atLeast1, exactly1, exactly2; NSMutableSet *all, *set1, *set2; BOOL flag1, flag2; all = [NSMutableSet set]; set1 = [NSMutableSet set]; set2 = [NSMutableSet set]; for(index = 0 ; index < 3674160 ; index++) { @autoreleasepool { state = [self t2_stateForIndex: index]; [all addObject: state]; flag1 = flag2 = YES; for(sym = 0 ; sym < 24 ; sym++) // Test all orientations for UP face solved { item = [self conjugateOfState: state bySymtag: sym ]; p = [item bytes]; if( flag1 == YES && p[UFR] == 0 && p[URB] == 0 && p[UBL] == 0 && p[ULF] == 0 ) { [set1 addObject: state]; flag1 = NO; //only count once } if( flag2 == YES && p[UFR] == 0 && p[URB] == 0 && p[UBL] == 0 && p[ULF] == 0 && p[DRF] == 0 && p[DBR] == 0) { [set2 addObject: state]; flag2 = NO; //only count once } } } } atLeast1 = [set1 count]; [set1 minusSet: set2]; exactly1 = [set1 count]; exactly2 = [set2 count] - 1; [self reportDone]; } // Return a cube state with the edges and the UFR cubie solved as encoded by index -(NSData *)t2_stateForIndex: (NSInteger)index { int i,n,p, orient[7]; NSUInteger position, orientation, perm[7]; OSG_SYMTAG state[20]; static NSUInteger last; orientation = index % 729; //3^6 orientations position = index / 729; [self radixDecode: position length: 7 toBuffer: perm]; orient[0] = 0; for(n = 1 ; n < 7 ; n++) { orient[n] = orientation % 3; orient[0] += orient[n]; orientation /= 3; } orient[0] = (21 - orient[0]) % 3; for( n = 0 ; n < 13 ; n++) state[n] = 0 ; for( p = 0 , i = 0 ; i < 6 ; i++ ) for( n = i + 1 ; n < 7 ; n ++ ) if( perm[I] > perm[n] ) p ^= 1; if( p == 1 ) state[UF] = state[UB] = [OhGroup symtagForKey: @"-x, y,-z"]; //balance parity to give a valid 3x3 state by swapping the UF and UB cubies RBK_Cubie cubie, cubicle; for( i = 0 , n = 13 ; n < 20 ; i++ , n++ ) { cubicle = (RBK_Cubie)perm[I] + 13; cubie = n; state[n] = [self symtagToPutCubie: cubie inCubicle: cubicle withOrientation: orient[I] ]; } return [NSData dataWithBytes: state length: sizeof(OSG_SYMTAG [20])]; }[/I][/I][/I]

 

[OreKehStrah]

Here’s one for Roux - I have 68 CMLL skips (ie. Top corners solved / oriented after block stage) out of my last 1250 or so solves so approx. 2% which is a fair bit better than expected (skip is 1/162 iirc).

I noted earlier when I was looking at smart cube stats that I have one LSE stage skip in my total 3500 or so solves recorded (ie. After CMLL the cube was completely solved). This was also with no AUF. What are the chances of that?

there is a video of a person having an LSE skip in competition. Pretty neat!

 

[Herbert Kociemba]

Well I'm fairly confident in my counts. Generating all members of the group is straightforward using radix encoding to compress the position permutation and the orientations to a number between 0 and 3,674,160. And testing for a solved face is trivial. I can not see how I could have under counted to that degree.

I do not understand this code. But at least we should reach an agreement what a "solved face" is. If you fix for example the DLB corner I still would count the U-face or better U-layer solved if we apply an U-move to the solved cube. Do you also count like this?

 

[NigelTheCuber]

I dont have proof so if you dont believe me its fine, i probably also wouldnt belive it if someone said this but my first sub 6 (5.33) was with a premade x-cross, i think on yellow. As said in the easy/lucky/a lot of other things scrambles thread, i lost the scramble, but if i somehow retrieve it, ill make sure to post it here.

you should participate in the lottery ig

 

[NigelTheCuber]

what is the probability of at least 2 free pairs and pll skip on the same solve

 

[Bruce MacKenzie]

I do not understand this code. But at least we should reach an agreement what a "solved face" is. If you fix for example the DLB corner I still would count the U-face or better U-layer solved if we apply an U-move to the solved cube. Do you also count like this?

I did some testing since my last post and found there are indeed a lot of cases I was missing. The problem was with states with solved faces not color aligned with the UFR reference cubie. I thought that by looking at all the rotation conjugates I would catch these cases but that is not true. I changed the way I test for solved faces and now my numbers are:

At least 1 solved face: 3814
Exactly 1 solved face: 3753
Exactly 2 solved faces: 60
6 solved faces: 1 (the identity cube)

The number for at least 1 solved face agrees with your number I believe.


-(void)test2: (NSString *)input
{
NSData *state, *item;
NSArray *s6;
NSString *conj;
const OSG_SYMTAG *p;
NSUInteger index,
atLeast1,
exactly1,
exactly2;
NSMutableSet *set1,
*set2;
BOOL flag1,
flag2;

s6 = [OhGroup subgroupNamed: @"S6xyz"];

set1 = [NSMutableSet set];
set2 = [NSMutableSet set];

for(index = 0 ; index < 3674160 ; index++)
{
@autoreleasepool
{
state = [self t2_stateForIndex: index];

flag1 = flag2 = YES;
for(conj in s6) //map each of the 6 faces onto the UP face
{
item = [self conjugateOfState: state
bySymtag: [conj intValue]];
p = [item bytes];

if( flag1 == YES &&
p[UFR] == p[URB] &&
p[UFR] == p[UBL] &&
p[UFR] == p[ULF])
{
[set1 addObject: state];
flag1 = NO; //only count once

if( flag2 == YES &&
p[UFR] == p[DRF] &&
p[UFR] == p[DBR])
{
[set2 addObject: state];
flag2 = NO;
}

if( flag2 == YES &&
p[UFR] == p[DBR] &&
p[UFR] == p[DLB])
{
[set2 addObject: state];
flag2 = NO;
}

if( flag2 == YES &&
p[UFR] == p[DLB] &&
p[UFR] == p[DFL])
{
[set2 addObject: state];
flag2 = NO;
}

if( flag2 == YES &&
p[UFR] == p[DRF] &&
p[UFR] == p[DFL])
{
[set2 addObject: state];
flag2 = NO;
}

}
}
}
}

atLeast1 = [set1 count];
[set1 minusSet: set2];
exactly1 = [set1 count];
exactly2 = [set2 count] - 1;

[self report: @"\n\nExactly One"];
for( state in set1 )
[self report: [NSString stringWithFormat: @"\n%@",[self configurationForState: state]]];

[self report: @"\n\nTwo or more(i.e. Identity"];
for( state in set2 )
[self report: [NSString stringWithFormat: @"\n%@",[self configurationForState: state]]];


[self reportDone];
}

 

[Herbert Kociemba]

Yes, my theoretical reasoning above also gave the 3814, so 1907/1837080 for the probability should be correct.

Sadly, the values for exactly one and two solved faces still differ. My 26/25515 for the probability corresponds to 3744 cases and not to 3753 for exactly 1 solved layer. And my 9 less cases here correspond to 9 additional cases with 2 solved layers. I have 69 here: 60 with two adjacent solved layers and 9 with two parallel solved layers. Is it possible that you did not recognize the second kind as two solved layers?

 

[Bruce MacKenzie]

Yes, my theoretical reasoning above also gave the 3814, so 1907/1837080 for the probability should be correct.

Sadly, the values for exactly one and two solved faces still differ. My 26/25515 for the probability corresponds to 3744 cases and not to 3753 for exactly 1 solved layer. And my 9 less cases here correspond to 9 additional cases with 2 solved layers. I have 69 here: 60 with two adjacent solved layers and 9 with two parallel solved layers. Is it possible that you did not recognize the second kind as two solved layers?

The nine cases with two opposing solved layers not color aligned with one another are counted as 1 solved layer in my count. If the layers aren't color aligned I deem one of the layers unsolved. If they are aligned then one has the identity cube. I was aware of those cases (I mentioned them in my first erroneous accounting).