Infinite-noise automata

Infinite noise automata, abbreviated INA, is a model of computation made by User:RainbowDash. That, given enough time, can perform a required computation it does this by generating an endless stream of digits based on an initial seed. Here, "infinite noise" simply refers to a continuous stream of digits that is fluctuated by a starting seed.

A simple explanation of an infinite noise automata:

• The machine takes one or more digits as a seed, this is the input.
• Using a given function on the input it creates a stream of digits. Each digit produced is a "Generation"
• Read certain generations in certain orders for your output.

Let it be noted that, infinite noise automatas can not halt based off of the seed, they can only be halted at a generation given at the start.

Further explanation

These machines range from hyper-specific to very broad in their use. Each machine is defined by a function, that is applied every generation. The output of that function is the output for that generation. The machines can include registers to store numbers and aid in the creation of generations.

For example, to build a INA that can add or subtract from a number, create a PRNG based on the generation number that either increments or decrements the starting number every generation. then find a generation that adds or subtracts a specific target value from the starting number. You can then run the INA until it reaches that generation to perform the desired calculation.

Instructions on the use of the machine.

To make a INA useful, you'll need to identify the correct generation for your output. You can use another machine to search each generation with specific inputs. If a generation’s output matches against a reference truth table, you have found the right one. Once you have identified it, run the INA then, let it progress to that generation, and read the output.

You can use Combinational logic by stringing INA's outputs to other INAs inputs to increase the usefulness of the machines.

Examples of infinite noise automatas

Logic Gate Machine JS

This is an infinite noise automata that generates every logic gate possible, in a linear fashion. This example also showcases a generation that simulates a NAND gate.

const gen = 39
for (let i = 0; i < 4; i++) {
    console.log(i.toString(2).padStart(2,'0'),":",logicGatesINA(i,gen))
}

function logicGatesINA(seed,generations) {
    let num;
    for (let i = 0; i < generations; i++) {
        let length = Math.floor(Math.log2(i + 1)) + 1;
        num = i - (Math.pow(2, length - 1) - 1);
        //console.log((num >> position) & 1) Print out each generation
    }
    return (num >> seed) & 1
}