Random Walk: About

This is just the description bit. For reasons beyond comprehension, but something to do with child/parent HTML element sizes, the walk has to be viewed in a full browser window. So please walk freely. Strangely, you will might see two versions of the walk, depending on your luck.

Just be aware that this is computationally intensive, and it may take a good few seconds to fully render. It probably won’t work if you’re browsing on a retro Apollo flight computer rebuild. Our walk consists of 250,000 individual steps, in one of eight compass directions over a 2D plane. We use Pythagoras to ensure that each step is of identical length whilst performing (speedy) integer calculations. And we use the following right shift (>>) trick to reduce our byte wise entropy consumption by 50%:-

for (int pointer = OFFSET;
        pointer < (OFFSET + NO_VALUES);
        pointer++) {
    int s = entropy[pointer] & 0b111;    // 3 lsbits
    switch (s) {
        case 0:
            x += 5;
            break;
        case 1:
            x -= 5;
            break;
        case 2:
            y += 5;
            break;
        case 3:
            y -= 5;
            break;
        case 4:
            x += 4;
            y += 3;
            break;
        case 5:
            x += 4;
            y -= 3;
            break;
        case 6:
            x -= 4;
            y -= 3;
            break;
        case 7:
            x -= 4;
            y += 3;
            break;
    }

    point = new JsonArray();
    point.add(x);
    point.add(y);
    route.add(point);

    s = (entropy[pointer] >> 5) & 0b111;    // Other 3 msbits
    switch (s) {
        case 0:
            x += 5;
            break;
        case 1:
            x -= 5;
            break;
        case 2:
            y += 5;
            break;
        case 3:
            y -= 5;
            break;
        case 4:
            x += 4;
            y += 3;
            break;
        case 5:
            x += 4;
            y -= 3;
            break;
        case 6:
            x -= 4;
            y -= 3;
            break;
        case 7:
            x -= 4;
            y += 3;
            break;
    }

    point = new JsonArray();
    point.add(x);
    point.add(y);
    route.add(point);
}

Also be aware that the Null Gamma Device is a raw entropy source. It is not a fully fledged TRNG, so it’s output entropy is biased. There is no randomness extractor. The bias is small and hard to notice from the random walks, but it’s there. So it’s kinda an entropy walk in reality. Scientifically, it’s a biased random walk. But they’re still pretty.

And dwell on this. These walks are built from 750,000 bits of truly random information, which is their Kolmogorov complexity. [A little less in reality as the entropy is biased, and thus ever so slightly compressible.] Therefore if you kept looking at these images till the end of time, you’ll never see a repeat. Ever. Each one is absolutely unique. Something that budding Entropists and Crypto-magés will appreciate.