Loading ...
Sorry, an error occurred while loading the content.
 

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

Expand Messages
  • 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
    Message 1 of 16 , Sep 29, 2004
      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

      --- In speedsolvingrubikscube@yahoogroups.com, cmhardw
      <no_reply@y...> wrote:
      > 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
    • Gustav Fredell
      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
      Message 2 of 16 , Sep 29, 2004
        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
        <no_reply@y...> wrote:
        > 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
      • Stefan Pochmann
        ... 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 3 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();
          }
          }
          }
        • pathfinder_netstorm
          ... solved
          Message 4 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
            > <no_reply@y...> wrote:
            > > 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
          • pathfinder_netstorm
            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 5 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();
              > }
              > }
              > }
            • jasmine_ellen
              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 6 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
                about
                > 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...
                >
                > http://forums.somethingawful.com/showthread.php?threadid=1254440
                > http://forums.somethingawful.com/showthread.php?threadid=1222915
                >
                > Cheers!
                > Stefan
              • cmhardw
                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 7 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
                  <no_reply@y...> wrote:
                  > I think you should think that most people can solve at least 1
                  side.
                  > the rest could be random.
                • Stefan Pochmann
                  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 8 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


                    --- In speedsolvingrubikscube@yahoogroups.com, cmhardw <no_reply@y...>
                    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.
                  • Minh
                    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 9 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
                      <no_reply@y...> wrote:
                      > 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
                    • Stefan Pochmann
                      The 18/432... is only correct if you try *all* 18 moves. But you only try one. Stefan
                      Message 10 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
                        > <no_reply@y...> wrote:
                        > > 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.