Here's a thought experiment, based on a simple computer a la Turing. Start with three parts:
- Read-Only Memory (populated with code)
- Processor (interprets code, a la Turing)
- RAM Memory (empty)
Consider the ROM as the input, the RAM as the output, and the processor as the functional engine. Add to this, a clock to sequence the processor's interpretation of the ROM, and a known start point to run the code. There are no external inputs, so everything that happens in the RAM is purely the result of the code in the ROM - thus dependent on the nature of the processor, and contents of ROM.
Consider the system as a pair of 3D cubes, with the following axes:
- X axis, data in memory cells
- Y axis, address of memory cells
- Z axis, states at successive clock pulses
As such, the ROM (input) would be the same 2D X x Y array repeated for all clock pulses along the Z axis, whereas the RAM would start off as undefined (or zero, if we assume empty cells to hold that value) until completely or partially painted in by code activity.
The simple case is where code interpretation is limited to the ROM; the larger case is where code within writable RAM can also be interpreted. The overall code will either:
- Continue running indefinitely (open system, e.g. the irrational number Pi)
- Fall into a repeating loop (closed, e.g. 1/3 expressed in decimal)
- Stop (closed. e.g. 1/100 expressed in decimal)
We'll avoid the Halting Problem by assuming case (3) for starters, which may also require us to consider only the simple case, where only the code in the ROM is interpreted. Now, the questions...
- If we gather only the full 3D X-Y-Z array of the RAM, can we deduce the ROM?
- If we know both 3D RAM and 2D ROM arrays, can we deduce the processor?
- Do these answers change, if pre-used ("empty") RAM values are known?
- Do these answers change, if pre-used RAM values remain flagged?
The elephant in the room
The processor can be considered a complicated operator that takes an input value, and produces an output value - but if each output value may arise from different inputs, then the processor is not a function - it is "blurry", in the same sense that quantum particles are blurred as waves.
We manufacture our processors, i.e. they arise from a template of arbitrary pattern, as opposed to "crafted" (one-off creation with no template retained for re-use). In contrast, "naturally-arising" processors may grow from a recursive self-similarity basis, which we may expect to be easier to derive from the output.
One example would be the ZX Spectrum running a program that ignores external inputs. This 1982 home computer had a 16k ROM, either 16k or 48k or RAM, and a Zilog Z80 processor clocked at 3.5MHz, 16-bit addressing, 8-bit data bus. So, the "size" of the system would be 0-65535 on the Y axis, 0-255 on the X axis, and 3.5 million x seconds to end of runtime on the Z axis.
That's a far larger computational mass than the initial program "seed", so needs a larger computer to fully model it; so far, so in keeping with our info-theory, and probably doable on today's hardware.
Another example is how the genotype is converted to the phenotype, where the nature of the processor is largely unknown. Ironically, the way "ROM" DNA is read to run-time mRNA, for ribosomes to "knit" mRNA into protein threads, is closer to Turing's endless-tape model than our Z80 processor!
Reverse computing is hard
It always seems harder to reverse computing, as seen through a series of problems successively conquered as our computational power grows. OCR is harder than printing fonts, speech recognition is harder than text-to-speech, etc. In each of these models of the external "real world", the generated output is easier to read than the "real thing", as it's quantized into a narrower set of possibilities.
This applies to attempts to understand the universe, via models that need the "It's as if..." disclaimer, rather than the unwarranted arrogance of "It is...". We can only model the universe in our heads (including peer-to-peer and computational extensions thereof); the universe itself can only be passed by value (the part we experience, as local copy), not by reference (complete, writable).