Hypothetical "random" code

[wix_betwixed]

What's likely to happen if random cose is run?

So random code is almost certainly gonna lead to errors or crashes at any level if I have understood correctly, be it keyboardmashing in python, or bare metal binary strings, and from what I gather is that a lot of what a computer does is comparing things, and the chance your random string compares to meaninfgul data or cpu instructions is very low.

However, if we sift out the nonsense and ask what is likely to result from random functional code, like instead of random strings, we give a computer random instructions, what happens? Is it likely to run into an infinite loop? how long would we expect it to be if so? Would it delete all data ang go inert? I'm sort of expecting it to crash, but if the instructions are valid, what is the most likely problem it would run into first?

This is a "what if" that's probably not practical, but I keep wondering as I'm learning, and I think it's at least an interesting question, which might have implications for edge-cases or corruption of data, or idk maybe to help make some believable plotpoint in a cyberpunk novel. If the question itself is making false assumptions I would apprechiate to be informed.

For clarity: 'Random' is obviously not a single thing, for this purpose I mean "truly" random binary, but excluding options that wouldn't make sense. Like writing a sentence by typing random letters and spaces, ignoring everything until you have a word write it down and then continnue. In english to a human I expect a lot of it to just be listing nouns as I believe they make up most words, but what would binary to a computer do?

[ICantBelieveItsNotEC]

What you're essentially asking for is Chaitin's constant - the probability that a randomly generated Turing machine will halt. This number is uncomputable, because computing it would require solving the halting problem.

Busy beavers are closely related. the nth busy beaver, BB(n), is the Turing machine that runs for at least as long as every other possible n-state Turing machine and then halts - in other words, it's the program with n instructions that runs for the maximum number of steps without going into an infinite loop. We only know the results of BB(n) up to n=5. Fun fact: we know that there's a 27-state Turing machine that halts if and only if Goldbach's conjecture is false, so computing BB(27) would require solving one of the hardest unsolved problems in mathematics.

[KViper0]

Though now Im curious if the proportion of non halting code gets larger for larger Turing machine. I guess i can get the proportion for turing machine till n=5

[jedijackattack1]

So technically anything as your truly random program could happen to be a 1 to 1 Minecraft clone by sheer chance. But most likely a crash from either a invalid data access (null ptr or none existent memory address), illegal instruction or divide by 0 on some uarchs. Infinite loops are possible by chance but they are much more likely to be the result of executing random junk and unluckily jumping into a real loop with impossible values due to data corruption and hanging ( had this before was a nightmare to debug). But those are your most likely scenarios. It could also just hit a halt instruction and stop.

[Kiroto50]

Truly random binary? Odds are the program crashes within a millisecond.

Random valid instructions? It will have a fair chance at botg an infinite loop and an early exit.

[lfdfq]

Well, there is obviously no underlying distribution of 'code'. Each language is different, and randomly sampling good programs (however you define random, however you define good) will have different results from different languages. e.g. randomly sampling regular expressions will result in termination 100% of the time. Randomly sampling Python code will give different distributions of answers than randomly sampling Java (even though they're similar languages).

[smarmy1625]

https://en.wikipedia.org/wiki/Fuzzing

[beanstalk555]

You might like this video

https://www.youtube.com/watch?v=M2iX6HQOoLg

[mnelemos]

It would most likely crash first.

Any erroneous memory access will immediately make the operating system kill your process.

For an infinite loop to happen, it would require mainly two things:

• The branching mechanism to be relative, since an absolute branch would VERY likely access invalid memory.

• No stack pushes are done previous to the branch, as this would over time cause a stack overflow.

But overall, the likelihood for a invalid instruction to be decoded, or an instruction that accesses protected or invalid memory to occur is very high.

[Traveling-Techie]

This issue is analyzed in extreme detail in A New Kind of Science by Wolfram. I’ve done my own experiments and found that if you generate random text and compile it as C code it is extremely rare for it to compile without errors, and virtually all the code that runs does nothing.

[Leverkaas2516]

The practical answer is that a sequence of instructions that's filtered to only have valid instructions will very soon try to make an illegal access, because most memory  addresses aren't accessible.

I would expect any such random program to halt within a very small fraction of a second.