## [Speed cubing group] Re: Funny outsiders...

Expand Messages
• ... I had some fun learning how to use Java s BigDecimal class, here s the result (number of turns vs. probability to accidentally solve). I used 1000 digits
Message 1 of 16 , Sep 29, 2004
--- In speedsolvingrubikscube@yahoogroups.com, Richard Patterson
<richy_jr_2000@y...> wrote:
> With over 43 quintillion different combinations, does
> anyone know the actual odds of solving it by accident?
> Say, 1000 random turns...can that be figured out?

I had some fun learning how to use Java's BigDecimal class, here's the
result (number of turns vs. probability to accidentally solve). I used
1000 digits precision.

10^0 : 0.0000000000000000000231203163
10^1 : 0.0000000000000000002312031638
10^2 : 0.0000000000000000023120316385
10^3 : 0.0000000000000000231203163852
10^4 : 0.0000000000000002312031638520
10^5 : 0.0000000000000023120316385202
10^6 : 0.0000000000000231203163852017
10^7 : 0.0000000000002312031638519936
10^8 : 0.0000000000023120316385175310
10^9 : 0.0000000000231203163849347630
10^10 : 0.0000000002312031638252929242
10^11 : 0.0000000023120316358474586107
10^12 : 0.0000000231203161179275247580
10^13 : 0.0000002312031371245709479730
10^14 : 0.0000023120289657771148207966
10^15 : 0.0000231200491127469735292260
10^16 : 0.0002311764384602375115896654
10^17 : 0.0023093609520051823138659937
10^18 : 0.0228550898430060057068061681
10^19 : 0.2064217767522700322187135016
10^20 : 0.9009402067081038970925219248
10^21 : 0.9999999999090140835069998078
10^22 : 0.9999999999999999999999999999

Isn't it funny how the numbers look very similar for a long time? And
here are the reciprocal values:

10^0 : 43252003274489856000.000000000
10^1 : 4325200327448985600.4500000000
10^2 : 432520032744898560.49500000000
10^3 : 43252003274489856.499500000000
10^4 : 4325200327448986.0999500000000
10^5 : 432520032744899.05999500000000
10^6 : 43252003274490.355999500000001
10^7 : 4325200327449.4855999500000192
10^8 : 432520032745.39855999500019266
10^9 : 43252003274.989855999501926693
10^10 : 4325200327.9489855999692669303
10^11 : 432520033.24489856018766930321
10^12 : 43252003.774489857926193032100
10^13 : 4325200.8274490048668803210016
10^14 : 432520.53274509122929820999981
10^15 : 43252.503276416549031583004599
10^16 : 4325.7003467159159037864998179
10^17 : 433.02022541418460481598214744
10^18 : 43.753929950356976451685197428
10^19 : 4.8444501143894109135381508565
10^20 : 1.1099515734277697062526475446
10^21 : 1.0000000000909859165012786291
10^22 : 1.0000000000000000000000000000

So assuming that guy twisted for a full day at one twist per second,
i.e. he came across 24*60*60=86400 states, the chance that he truely
solved it is less than 1 out of 432520032744899.

Cheers!
Stefan

P.S. Here's my code:

import java.math.*;

class RubikLuckySolve {

static BigDecimal big ( int n ) {
return scale( new BigDecimal( n + "" ));
}

static BigDecimal one = big( 1 );

static BigDecimal div ( BigDecimal a, BigDecimal b ) {
return scale( a.divide( b, a.ROUND_HALF_EVEN ));
}

static BigDecimal mul ( BigDecimal a, BigDecimal b ) {
return scale( a.multiply( b ));
}

static BigDecimal sub ( BigDecimal a, BigDecimal b ) {
return scale( a.subtract( b ));
}

static BigDecimal scale ( BigDecimal a ) {
return scale( a, 1000 );
}

static BigDecimal scale ( BigDecimal a, int scale ) {
return a.setScale( scale, a.ROUND_HALF_EVEN );
}

static BigDecimal power( BigDecimal base, int exp ) {
BigDecimal result = one;
while( exp-- > 0 )
result = mul( result, base );
return result;
}

static String nice ( BigDecimal a ) {
return (a+"").substring( 0, 30 );
}

public static void main ( String[] args ) {
BigDecimal n = one;
for( int e=1; e<=12; e++ )
n = mul( n, big( 2*e ));
for( int c=1; c<=8; c++ )
n = mul( n, big( 3*c ));
n = div( n, big( 12 ));

for( int k=0; k<2; k++ ){
BigDecimal foo = sub( one, div( one, n ));
for( int i=0; i<23; i++ ){
System.out.print( "10^" + i + " :\t" );
BigDecimal bar = sub( one, foo );
System.out.println( nice( (k==0) ? bar : div( one, bar )));
foo = power( foo, 10 );
}
System.out.println();
}
}
}
• ... solved
Message 2 of 16 , Sep 29, 2004
--- In speedsolvingrubikscube@yahoogroups.com, "Gustav Fredell"
<gufr5747@s...> wrote:
> Well thats no different from other repeated probabilities if n is
> sufficiently high (coin flipping is no good ;). There will still be
> an expected value of exactly one solve though.
>
> /Gustav
>
> --- In speedsolvingrubikscube@yahoogroups.com, cmhardw
> > Sorry for the multiple posts but I found this interesting too,
> >
> > If you did 43252003274489856000 random turns on a cube, assuming
> you
> > start from a scrambled state, then the chance of seeing the
solved
> > state by luck is
> >
> > 1-(43252003274489855999/43252003274489856000)^43252003274489856000
> >
> > which is a close approximation of lim n->infinity 1-[(n-1)/n]^n
> >
> > If you work out this limit you get 1-(1/e) which is approximately
> a
> > 63% chance.
> >
> > I know this is probably getting a little too deep into
> probabilities
> > and stuff, but I just think it's cool that even if you did the
> exact
> > same number of moves as there are combinations to the cube,
> there's
> > still only a 63% that your cube will solve by luck.
> >
> > Chris
• I think you should think that most people can solve at least 1 side. the rest could be random. ... the ... used ... And ... second, ... truely ... bar )));
Message 3 of 16 , Sep 29, 2004
I think you should think that most people can solve at least 1 side.
the rest could be random.

--- In speedsolvingrubikscube@yahoogroups.com, "Stefan Pochmann"
<pochmann@g...> wrote:
> --- In speedsolvingrubikscube@yahoogroups.com, Richard Patterson
> <richy_jr_2000@y...> wrote:
> > With over 43 quintillion different combinations, does
> > anyone know the actual odds of solving it by accident?
> > Say, 1000 random turns...can that be figured out?
>
> I had some fun learning how to use Java's BigDecimal class, here's
the
> result (number of turns vs. probability to accidentally solve). I
used
> 1000 digits precision.
>
> 10^0 : 0.0000000000000000000231203163
> 10^1 : 0.0000000000000000002312031638
> 10^2 : 0.0000000000000000023120316385
> 10^3 : 0.0000000000000000231203163852
> 10^4 : 0.0000000000000002312031638520
> 10^5 : 0.0000000000000023120316385202
> 10^6 : 0.0000000000000231203163852017
> 10^7 : 0.0000000000002312031638519936
> 10^8 : 0.0000000000023120316385175310
> 10^9 : 0.0000000000231203163849347630
> 10^10 : 0.0000000002312031638252929242
> 10^11 : 0.0000000023120316358474586107
> 10^12 : 0.0000000231203161179275247580
> 10^13 : 0.0000002312031371245709479730
> 10^14 : 0.0000023120289657771148207966
> 10^15 : 0.0000231200491127469735292260
> 10^16 : 0.0002311764384602375115896654
> 10^17 : 0.0023093609520051823138659937
> 10^18 : 0.0228550898430060057068061681
> 10^19 : 0.2064217767522700322187135016
> 10^20 : 0.9009402067081038970925219248
> 10^21 : 0.9999999999090140835069998078
> 10^22 : 0.9999999999999999999999999999
>
> Isn't it funny how the numbers look very similar for a long time?
And
> here are the reciprocal values:
>
> 10^0 : 43252003274489856000.000000000
> 10^1 : 4325200327448985600.4500000000
> 10^2 : 432520032744898560.49500000000
> 10^3 : 43252003274489856.499500000000
> 10^4 : 4325200327448986.0999500000000
> 10^5 : 432520032744899.05999500000000
> 10^6 : 43252003274490.355999500000001
> 10^7 : 4325200327449.4855999500000192
> 10^8 : 432520032745.39855999500019266
> 10^9 : 43252003274.989855999501926693
> 10^10 : 4325200327.9489855999692669303
> 10^11 : 432520033.24489856018766930321
> 10^12 : 43252003.774489857926193032100
> 10^13 : 4325200.8274490048668803210016
> 10^14 : 432520.53274509122929820999981
> 10^15 : 43252.503276416549031583004599
> 10^16 : 4325.7003467159159037864998179
> 10^17 : 433.02022541418460481598214744
> 10^18 : 43.753929950356976451685197428
> 10^19 : 4.8444501143894109135381508565
> 10^20 : 1.1099515734277697062526475446
> 10^21 : 1.0000000000909859165012786291
> 10^22 : 1.0000000000000000000000000000
>
> So assuming that guy twisted for a full day at one twist per
second,
> i.e. he came across 24*60*60=86400 states, the chance that he
truely
> solved it is less than 1 out of 432520032744899.
>
> Cheers!
> Stefan
>
> P.S. Here's my code:
>
> import java.math.*;
>
> class RubikLuckySolve {
>
> static BigDecimal big ( int n ) {
> return scale( new BigDecimal( n + "" ));
> }
>
> static BigDecimal one = big( 1 );
>
> static BigDecimal div ( BigDecimal a, BigDecimal b ) {
> return scale( a.divide( b, a.ROUND_HALF_EVEN ));
> }
>
> static BigDecimal mul ( BigDecimal a, BigDecimal b ) {
> return scale( a.multiply( b ));
> }
>
> static BigDecimal sub ( BigDecimal a, BigDecimal b ) {
> return scale( a.subtract( b ));
> }
>
> static BigDecimal scale ( BigDecimal a ) {
> return scale( a, 1000 );
> }
>
> static BigDecimal scale ( BigDecimal a, int scale ) {
> return a.setScale( scale, a.ROUND_HALF_EVEN );
> }
>
> static BigDecimal power( BigDecimal base, int exp ) {
> BigDecimal result = one;
> while( exp-- > 0 )
> result = mul( result, base );
> return result;
> }
>
> static String nice ( BigDecimal a ) {
> return (a+"").substring( 0, 30 );
> }
>
> public static void main ( String[] args ) {
> BigDecimal n = one;
> for( int e=1; e<=12; e++ )
> n = mul( n, big( 2*e ));
> for( int c=1; c<=8; c++ )
> n = mul( n, big( 3*c ));
> n = div( n, big( 12 ));
>
> for( int k=0; k<2; k++ ){
> BigDecimal foo = sub( one, div( one, n ));
> for( int i=0; i<23; i++ ){
> System.out.print( "10^" + i + " :\t" );
> BigDecimal bar = sub( one, foo );
> System.out.println( nice( (k==0) ? bar : div( one,
bar )));
> foo = power( foo, 10 );
> }
> System.out.println();
> }
> }
> }
• I was just poking around the cube facts page on the rubiks.com site. I came across the following: The least number of moves required in unscrambling the
Message 4 of 16 , Sep 29, 2004
I was just poking around the 'cube facts' page on the rubiks.com
site. I came across the following:

"The least number of moves required in unscrambling the Cube from
the worst disorder, the shortest route, is often called God's
Algorithm. Morwen Thistlethwaite, using computers at South Bank
University in London, calculated that the magical minimum was 52
moves. A number subsequently reduced to 50. It is thought that the
number of moves may turn out to be somewhere in the low twenties."

I'm guessing this is where that person got the number 52. I think we
all know that God's Algorithm is *much* lower than 52!!

Jasmine
http://www.geocities.com/jasmine_ellen

--- In speedsolvingrubikscube@yahoogroups.com, "Stefan Pochmann"
<pochmann@g...> wrote:
> Analyzing the logfiles of my homepage, I found these two threads
> cubing. It's kinda amusing when they claim 7 moves are always
enough
> to solve the 3x3 or when they say that's wrong and they have
> mathematically proven it's 52 moves. And other stuff...
>
>
> Cheers!
> Stefan
• Here s one more thing I was thinking about based on this last post. Assuming someone can work their way to finishing the F2L and then perform random
Message 5 of 16 , Sep 29, 2004
Here's one more thing I was thinking about based on this last post.

Assuming someone can work their way to finishing the F2L and then
perform random transformations on the LL via trial and error then
the odds would be a lot better of a random lucky solve.

Assuming they just place all the LL pieces together in the right way
in relation to eachother and all oriented correctly then the LL face
can be off by one move, but I think we can assume that that position
would be technically solved since someone could recognize that it
was only off by 1 turn.

So there 4 out of 62208 solved states, or 1 out of 15552.

I think we can assume that a transformation on the LL could be done
in 20 moves roughly if the person is using trial and error to break
apart the LL and try to put it back together again using relatively
few inefficient algorithms.

So after each 20 move transformation the chance that the new LL
configuration is a recognizable solved state is 1/15552.

So the chance of solving the cube at least once in 50
transformations on the LL (1000 moves) is

1-(15551/15552)^50 ~ 0.32% chance

I think this would definitely be possible, even though less people
figure out how to get the F2L than people how can figure out the
first layer only.

In case anyone is interested,
Chris

--- In speedsolvingrubikscube@yahoogroups.com, pathfinder_netstorm
> I think you should think that most people can solve at least 1
side.
> the rest could be random.
• Yeah I know, that s what I meant in my original posting that started this thread. But people claim they just randomly twisted the cube. And that s just -
Message 6 of 16 , Sep 30, 2004
Yeah I know, that's what I meant in my original posting that started
this thread. But people claim they just randomly twisted the cube. And
that's just - excuse me - bullshit. I'm still wondering *why* they say
so. Next time somebody tells me that in person, I'm gonna ask. I'd
also ask in that guy in that forum thread, but I'm not gonna pay the
\$10 for it.

Cheers!
Stefan

wrote:
> Here's one more thing I was thinking about based on this last post.
>
> Assuming someone can work their way to finishing the F2L and then
> perform random transformations on the LL via trial and error then
> the odds would be a lot better of a random lucky solve.
• Sorry in advance if I just made a complete fool of myself, - but since, from the solved cube you can create 18 different permutations (R, R , R2 -- same with
Message 7 of 16 , Oct 9, 2004
Sorry in advance if I just made a complete fool of myself, - but
since, from the solved cube you can create 18 different permutations
(R, R', R2 --> same with FBUDL), doesn't that mean that there is a
18/43252003274489856000 chance of the next turn producing a solved
state? Maybe my logic is stuffed, since probability isn't one of my
best topics... but that's how I think of it as..
so P(1000 turns) = 1 - ((43252003274489856000-
18)/43252003274489856000) ^ 1000

= approx 4.16^-14 % chance???...

Minh

--- In speedsolvingrubikscube@yahoogroups.com, cmhardw
> The chance that the next turn produces the solved state is
> 1/43252003274489856000 so the chance that in 1000 turns you see
the
> solved state at least once should be
>
> 1-(43252003274489855999/43252003274489856000)^1000
>
> or roughly 2.31*10^-15 % chance
>
> Chris
>
>
> --- In speedsolvingrubikscube@yahoogroups.com, Richard Patterson
> <richy_jr_2000@y...> wrote:
> > With over 43 quintillion different combinations, does
> > anyone know the actual odds of solving it by accident?
> > Say, 1000 random turns...can that be figured out?
> > -Richard
• The 18/432... is only correct if you try *all* 18 moves. But you only try one. Stefan
Message 8 of 16 , Oct 12, 2004
The 18/432... is only correct if you try *all* 18 moves. But you only
try one.

Stefan

--- In speedsolvingrubikscube@yahoogroups.com, "Minh" <minh144@y...>
wrote:
>
> Sorry in advance if I just made a complete fool of myself, - but
> since, from the solved cube you can create 18 different permutations
> (R, R', R2 --> same with FBUDL), doesn't that mean that there is a
> 18/43252003274489856000 chance of the next turn producing a solved
> state? Maybe my logic is stuffed, since probability isn't one of my
> best topics... but that's how I think of it as..
> so P(1000 turns) = 1 - ((43252003274489856000-
> 18)/43252003274489856000) ^ 1000
>
> = approx 4.16^-14 % chance???...
>
> Minh
>
> --- In speedsolvingrubikscube@yahoogroups.com, cmhardw
> > The chance that the next turn produces the solved state is
> > 1/43252003274489856000 so the chance that in 1000 turns you see
> the
> > solved state at least once should be
> >
> > 1-(43252003274489855999/43252003274489856000)^1000
> >
> > or roughly 2.31*10^-15 % chance
> >
> > Chris
> >
> >
> > --- In speedsolvingrubikscube@yahoogroups.com, Richard Patterson
> > <richy_jr_2000@y...> wrote:
> > > With over 43 quintillion different combinations, does
> > > anyone know the actual odds of solving it by accident?
> > > Say, 1000 random turns...can that be figured out?
> > > -Richard
Your message has been successfully submitted and would be delivered to recipients shortly.