Hacker News Reader

Comment by eternauta3k | Hacker News Reader

Makes you think what kinds of things we may find in the space of 256-byte programs. Is there a convincing chatbot there somewhere (sans language training)? Perhaps something conscious?

View on HN

z_n+1 = z_n^2 + c <- fewer than 256 bytes, yet it can be used to produce a beautiful endlessly complex image.

To me it almost feels as if God or whoever has intentionally hidden it, in the way everything works I mean, so that we could one day find it. Once we have invented complex numbers for example..

What other secrets are out there? Or rather in here?

There is probably a 256-byte program that simulates a universe in which a superhuman intelligence evolves. Of course the memory and runtime requirements of that program would be prohibitive, and the superhuman intelligence would not know any human language, because there are more than 2048 bits of entropy in the basic vocabulary of any language (even Toki Pona, I would guess).

Hmmm.

This makes me wonder if, in the same way we've been technically-erroneously been hyperfocusing on CPU speed and quantity of memory in system-measuring contests and benchmarks, we've developed a fixation for how little RAM or CPU we can use while doing something interesting. I don't see the same sorts of fights developing around how much disk space we use or what the specs of all the systems we used for preprocessing are.

Demos are supposed to be about conquering limitations, right? Inspiring creativity and all that? Well, why can't we add those sorts of constraints in, then? Aren't we smart enough? :P

We might even build consciousness one day if we're honest about how much total resources we're using. That way we would actually have to reason about all the bits (no more "GPUs are really *that complicated* that what you're describing is impossible") and there would be no more black boxes.

Demos would be interesting.

> There is probably a 256-byte program that simulates a universe in which a superhuman intelligence evolves

I can even write it :)

    x = 0
    while (true):
      eval(int_to_code(x))
      x += 1

of course the runtime will be probably quite long

EDIT: I forgot about the stop problem. But that's easy - stop the eval when memory repeats.

    x = 0
    prevStates = None
    while (true):
      state = x
      prevStates = set()
      while(not state in prevStates):
        prevStates += state
        state = eval_1_step(int_to_code(state))
      x += 1

int_to_code and eval_1_step should be part of the language

What really blows my mind is that this basically makes the multiverse (everything that could happen - happens in some other universe).

Anthropomorphizing evolution a little, I'd bet the department that works on crafting serious intelligence into bees and jumping spider into milliwatt (or perhaps order 10² μW) brains would look respectfully at this kind of demo-scene wizardry.

It is plausible that there could be an initially 256-byte program that is self-expanding, as in, it generates more code as it runs, gradually increasing the complexity of whatever it's doing.

... you mean like our DNA?

> increasing the complexity of whatever it's doing.

I wonder if this is possible at all without external input. I'm an ignorant in Complexity Theory though.

You could have something generating a sequence, say PI to infinite digits, and then 'executing' instructions based on those digits. You'd have to design the 'language' very carefully so that any errors or nonsensical series of instructions were ignored or recovered from. Some way of avoiding infinite loops. Hmmmm. It's probably not possible to guarantee that it wouldn't get stuck in a loop eventually (which would mean complexity would no longer increase).

My bet is on this being impossible to continue indefinitely due to the halting problem implying that it would fall into a loop eventually.

Although not quite 256 bytes, here's a chess playing program in 288 bytes:

https://leanchess.github.io/

Reply on news.ycombinator.com