How random can you be? (2019)

[Bakary]

Creepily reminiscent of this short story:

https://www.nature.com/articles/436150a

[jadbox]

All of Ted Chiang's short stories are incredible. I often reread them, and often get new insights each time I do.

[ptoo]

My solution was to generate random sentences in my head. I then iterate through the letters of each sentence, and if the letter is M or later in the alphabet, I select right. If the letter is before M in the alphabet I select left.

[tromp]

According to English letter frequencies [1] that gives a right probability of 3.0129+6.6544+7.1635+3.1671+0.1962+7.5809+5.7351+6.9509+3.6308+1.0074+1.2899+0.2902+1.7779+0.2722 = 48.7294 % even though you summed 14 of the 26 letters (a 13-13 split would lower the probability to 45.7165%).

[1] https://www3.nd.edu/~busiforc/handouts/cryptography/letterfr...

[NeoTar]

That's likely to introduce bias because the probability of the two halves aren't equal... My initial instinct would be that the latter half would be less likely (since it has Q, X, Z), but maybe not - as a rule of thumb the most common letters are ETAOIN SHURDL - so 6 from the second half, and 6 from the first.

[Tao3300]

I mentally labeled my pulse as left... right... left... right... and whenever I blinked I took that direction. The tricky part is not thinking about what should be next. It's also a slow way to play, but I was winning until I clicked randomize!

[kqr]

This was a nice way to generate random numbers fast! My go-to method is the second hand on the clock, but that's of course highly autocorrelated if you need numbers quickly.

[InCityDreams]

Try it alternating/ varying musical time signatures.

[TrinaryWorksToo]

If you want to hack it, give it a binary de Bruijn sequence with alphabet size k=2. Since it looks to follow whichever pattern already exists, and de bruijn sequences minimize existing patterns, it always beats the game.

I used http://combos.org/bruijn and pressed left for zero and right for one.

Using rule Grandmama creates close to a perfectly straight line up and to the right when you start from the first 1 in the sequence.

Try: 1001000101010011010000110010110110001110101110011110111111000000

where 1 is right and 0 is left.

[float4]

This is cool info, thanks.

> Since it looks to follow whichever pattern already exists, and de bruijn sequences minimize existing patterns, it always beats the game.

I'm pretty sure this isn't true though. A de bruin sequence doesn't guarantee that the order of the n-patterns is random, only that the number of unique n-length patterns is maximized.

Indeed, the algorithm you mention puts n-subsequences with many 0's in the front, and subsequences with many 1's in the back. Sure, every n-length subsequence appears only once, but because the order of the subsequences does follow a predictable pattern, your total sequence is still pretty predictable.

This disparity isn't noticeable when n is small (you chose n=6), so you can comfortably beat the game. But pick a large n and your sequence becomes rather predictable.

Try n=20. In that case, the generated sequence S has length |S|=32,768=2^15. In the first half, there are 9098 0's and 7286 1's. In the second half these numbers are exactly the opposite. Throw this sequence into the game, and you end up with a prediction accuracy of 50%. Not worse than random, but you didn't beat the game either.

[PinkMilkshake]

A decent strategy is to use the results of the last click to choose your next click. Win money, click right, lose money, click left.

[pil0u]

Intrigued too. It worked very well for the first 100 iterations. Starting iterations 180, I entered a very deterministic loop (6 correct - 1 wrong - repeat), making me a money loser.

[randtrain34]

Using a variation of this:

```

for(let j=0; j<5; j++){

  window.captureBtnLeftFunc({preventDefault: () => {}})
  
  for(let i=0; i<200; i++){
    
    if (window.prediction == window.lastKey) {
      
      window.captureBtnRightFunc({preventDefault: () => {}})
      
    } else {
      
      window.captureBtnLeftFunc({preventDefault: () => {}})
      
    }
    
  }
  

}

```

actually got me a pretty linear upward win line for thousands of simulated clicks

[Bakary]

This was a really intriguing idea but I failed to get much luck with it...`

[marcAKAmarc]

I did this and by 100, i was +30, but by 200 i was bqck to 0.

[coldtea]

I once wore a smoked herring as a tie to a black suit event.

That's how random I can be!

[Tao3300]

Penguin of doom territory, to be sure.

[femto]

There is a style of tie known as a kipper (ie. smoked herring) tie [1]. There is no escape from the numbers! :-)

[1] https://en.wikipedia.org/wiki/Kipper_tie

[carlmr]

So I did 128 presses and it was 48% right at guessing me. I guess I'm quite random, since ~50% is what you'd expect for an actual coin toss.

[ACow_Adonis]

150 presses and 51% here, just trying with my fingers on my smartphone :)

And now to 200 with 49%. Feeling not so subtley smug.

And now to 400 with 50%. Admit I'm getting bored now.

Now the question I have to answer, is that because of my professional experience and history, something inherent in my mind, or was it...just random?

edit: just consciously trying to be random, not using any deliberate or external tricks.

Second question: what percentage of the population behaves like me and is it qualitatively different from the population that doesn't?

I don't believe I actually am random, but whatever it is i'm doing the results are somewhat statistically unlikely. Is knowledge/experience with randomness itself sufficient to defeat this method?

[archi42]

The prediction is deterministic, so you can adapt to it and "beat" it every time. Though intuitively and without looking at the implementation, I obviously am not a good adversary: Lowest I reached was 43% after ~50 inputs, stopped at 47% after 103.

With just tapping "randomly", it was looking good until I got 52% at 250 inputs. From there on it went steep downward: 59% at 500 but 57% again at 1000 (I changed how I tapped at the 500 mark; else it would have declined even more).

[ouid]

6 bit maximum period lfsr is probably a nearly perfect adversary for it.

[machina_ex_deus]

At the heart of Bells inequality in physics is the assumption of free will, that the experimentalist is "free" to choose a detector setting.

Yet when faced with the task of actually generating random numbers, humans fail miserably. Some how the failure to generate random numbers isn't seen as a lack of free will by anyone.

But in the context of quantum physics, the experimenters "freedom" to do something most humans can't actually do is a given, and denying it is "super determinism" and anti science.

It's funny that physicist take the freedom of their random choices as a given when a simple experiment shows they don't have such freedom.

[rowanG077]

It's incredibly easy to cheat this since you actually, in real-time, can see the feedback of how random it thinks you are.

[Yajirobe]

And how exactly do you use this information?

[synergy7]

There is an example in Mathematica [1] that illustrates a similar point using Rock-Paper-Scissors game. It uses a very simple strategy to predict human opponent [2], but it appears to work well. (Although, at the moment the demonstration does not seem to be working at all (I tried it in Firefox and Chrome)).

[1]. https://demonstrations.wolfram.com/RockPaperScissorsWithAIPl... [2]. https://blog.wolfram.com/2014/01/20/how-to-win-at-rock-paper...

[jwie]

This doesn’t really test randomness.

It appears that the guessing output is deterministic using your inputs as it’s inputs and you could figure out as many consecutive inputs you felt like to produce a specific outcome. For instance 6R1L3R inputs forces the game to “guess” wrong each time. It’s not guessing. This isn’t a random input, but it’s perfectly within a reasonable random distribution. Equally random is 10L, which the guesser will guess right each time.

Losing to the guesser doesn’t indicate a lack of random input, nor does guessing the opposite of the guesser indicate randomness.

We can’t really generate randomness. Only outcomes consistent with some distribution. It’s more of a philosophical point. If you made it it’s not random.

[water-your-self]

If you can predict bits with greater than 50% accuracy then you have not got a truly random set.

[FartyMcFarter]

What's the easiest pseudo-random sequence one can calculate mentally in order to beat this?

[camel-cdr]

This one doesn't really "beat" this, but here is a simple PRNG that you can trivially compute using mental arithmetics proposed by George Marsaglia [1]:

1. Select an initial random number (seed) between 1 and 58. (This is accomplished by mentally collecting entropy from the environment, e.g. counting a group of objects you don't knew the count of before)

2. Multiply the least significant digit by 6, add the most significant digit to the result, and use the new result as the next seed/state.

3. The second digit of the state is your generated pseudorandom number.

4. Goto 2.

                         Sequence generated by 42:

    42 -> 2*6+4=16 -> 6*6+1=37 -> ...

    42|16|37|45|34|27|44|28|50|05|03|18|49|58|53|23|20|02|12|13|19|55|35|33|21
     2| 6| 7| 5| 4| 7| 4| 8| 0| 5| 3| 8| 9| 8| 3| 3| 0| 2| 2| 3| 9| 5| 5| 3| 1

[1] "Multiply with carry", George Marsaglia (1994): https://groups.google.com/g/sci.math/c/6BIYd0cafQo/m/Ucipn_5...

Edit: Thanks to lifthrasiir you can try it out your self:

    (async () => {
        let x = 42;
        for (let i = 0; i < 10; ++i) {
            for (let j = 0; j < 10; ++j) {
                x = (x / 10) + (x % 10) * 6;
                (x & 1 ? captureBtnLeftFunc : captureBtnRightFunc)({ preventDefault() {} });
            }
            await new Promise(r => requestAnimationFrame(r));
        }
    })()

Edit2: fixed *'s

[082349872349872]

No need for pseudo-random; a 6-bit binary counter ought to do it.

(assuming this has the same Achilles' Heel as Shannon's 3-bit machine: https://this1that1whatever.com/miscellany/mind-reader/Shanno... )

[variaga]

There's a deterministic sequence that will beat it every time, which you can calculate as follows.

  - it assumes your first selection was preceeded by 5 consecutive 'left's
  - each press, look at the last 5 bits you selected (for your 1st 5 selections, 
 include those 'virtual' 5 lefts at the beginning). If you have not entered that sequence of 5 before, select 'right'.   If you have entered that sequence before,  pick the opposite of whatever you selected last time as your next press.

RRRRRRLRRRLRLRLLRRRRLLRRLRRLRLLLRRRLLLRLRRLLRLRLRRRRRRLRRRLRLRLLRLL...

[generalizations]

I pressed right 6 times in a row. Apparently that's a very random thing to do.

[water-your-self]

Its equivalently random to any other sequence!

[plank]

Tried it. Not being random, I earned some virtual money fast (iteration 39: I guessed left (wrong). You pressed right. My guesses are correct 28% of the time (overall).) https://www.dropbox.com/s/n46fda7nmm0wi0e/20220911_112422.jp...

[kthejoker2]

This is also kind of similar to the Newcomb Problem (read the Solution page for an excellent shott story)

http://www.greylabyrinth.com/puzzle/puzzle014

[kristopolous]

Adversarially it can be defeated. However, when trying to be faithfully random it does pretty good

[omnicognate]

Yeah, it was only 44% right on my 100 presses but I was trying to beat it, not be random. You can sometimes get surprisingly long runs of wrong guesses out of it by repeating your guess once you get a wrong.

[kthejoker2]

The Pudding had a different take on eliciting and measuring randomness

https://pudding.cool/2022/04/random/

[mrsmee89]

This is cool! I had some success winning by tapping to a beat (I changed my choice every time the cadence in the song changed).

[ouid]

100000100001100010100111101000111001001011011101100110101011111 and repeat

[amelius]

This might come in handy during boxing and other combat sports.

[belter]

Nine,nine,nine,nine,nine,nine...

[marginalia_nu]

I was apparently extremely random by counting in binary

left

right

right left

right right

right left left

right left right

right right left

right right right

right left left left

etc.

[seanhandley]

potato