In short:
This is an old theory I had about 2 years ago. I'm working on another theory atm, and thought I'd release this one to get people opinions.
This theory suggests that you should only have 1 loop in your program and you shouldn't use any other loops or functions.
My reasoning behind it was that the brain only has 1 loop, and doesn't use loops or function either.
Overlapping redundancy suggests that our brain is largely backup, but backup in a way that garners more knowledge and intelligence, rather than a straight copy of data.
Feel free to criticize, or go "wow that's cool!". I'm not precious about this theory, but I do find the whole concept very cool.
Oh, and it is one of the reason why I think the current way we program, well, isn't exactly optimal.
Anyway you be the judge.
Brain Loop Theory
Differences between a brain and a computer program.
Ok, so what is the difference between a brain and a computer? Well, there is a lot of differences, but they both can take in commands and give out responses. The brain is designed for stability. It has the following properties that computers have not yet mastered:
1.Rare or no crashing
2.Runs for up to 120 years.
3.When damaged it still runs.
4.Can repair itself.
5.Can learn information in one form and act it out in another form.
6.It can apply the golden rule of learning.
How do I make a computer program have the above properties? How can I make a computer program run for 120 years without crashing. To make a computer program run in a similar fashion, we need identify what the brain doesn’t have as compared to what the computer has, that causes it to crash.
1.No internal loops, no repeating functions.
2.No single points of execution
These 2 points are huge. It goes against the 30 years of computer programming to suggest such heresy. Yet the brain manages to avoid them. So what does the 2 points entail?
So why are internal loops bad? Ok, I think it’s best to understand this is from a story from nature.
There is a forest of trees whose seeds only germinate after a fire has gone through. For as long as Europeans have lived near the forest, they have never seen a fire in this forest. This raises 2 questions:
1.How did the seeds germinate?
2.Why is the forest filled with these seemingly evolutionary defective trees?
On taking soil samples, it can be seen that a fires do actually occur at the rate of 1 fire every 400 years. The life-span of the tree is about 1200 years. So you can see that the trees gear themselves to this one cataclysmic event, because it is a near certainty to occur in there lifetimes. The same thing occurs with our brains. It is a near certainly that our brain will take damage over our life-time. It is a near certainty that our brains will malfunction in some way over the course of our life-time. I’ve never met a computer programmer who gets this philosophy. Many programmers are exuberant when they can get a computer program to last 2 days of continuous use, without it crashing, locking, up, confusing the user, and actually doing the task required of it. And indeed, to get a computer to do that is an incredible feat.
But no-one has identified why this is the case, and year after year we produce more and more unreliable systems. The reason why computer will never be stable in their current form is because of the 2 rules above, internal loops and single points of execution.
Proverbially speaking, computers don’t address the problem of the once every 400 years forest fire. Say we replace you brain with a computer, and it had to control your heart and internal organs. How long do you think you’d live, knowing that if the computer has 1 error, your dead? With the complexity of modern computers, a misplaced bit, is almost guaranteed to occur, at some point.
So what has this got to do with no internal loops, and no single points of execution? Take a loop for example:
Int I = 10;
while (I==10)
{
// live();
}
Any computer programmer, worth his weight in salt, will tell you this program will never stop running. So are they right? The answer is no, this program will die. Try running this program on your own PC, and see what happens. It may take 1sec to 1000 years, but I can guarantee you, at some point, it will die.
How did it crash, it’s meant to never stop running? It can’t even run as long as a tree can live! At some point, the variable “I” will get corrupted, due to the result of damage, age or some other catastrophic event and changed to the wrong value, and the program will cease. Our brain hardware understands this concept, and never relies on a single point of execution, because no single neuron can be wholly trusted. Can you imagine if 1 neuron in your brain died, then you die too, as in the program above? In fact, neurons will even stop firing, if they’ve been fired too much, and sometimes for no apparent reason at all.
Almost all computers right now have a single point of execution, that is repeatedly executed millions of time a second. It's an incredible miracle of engineering that they even run at all! There is absolutely nothing to fear from single point execution computers taking over the world, because they have their death built into them at the hardware level.
Now these discoveries open the door to a huge amount of research and ideas, some of which I’ll address in this document.
Brain Vs computer revised:
Knowing that the brain cannot be allowed to die, or perform an action that will lead to it’s downfall, and can only perform one global loop, what do you suppose the make-up of the brain would mainly contain? That’s right! Masses upon masses of redundancy. I’ve always found the notion that we use only 10 percent of our brains a bit misleading. We use the rest for backup! So then, only about 1 percent of our brain is probably used to do actual real work. Imagine how smart we could be if nothing in our brains was redundant. Sure, we’d die all the time, but we’d be oh, so smart. This is actually the case in most computer systems, because a computer system is a evolutionary misfit, where a brain that dies all the time hasn’t caused it’s downfall. A computer system can think with perfect clarity, never second guessing it’s function, and that’s why it can easily out perform the human brain in some areas. The huge number of checks that the human brain does is actually it downfall. It can’t add up 1,000,000 numbers in 1 second, because it would be unhealthy for it, and it’s data storage medium could be regarded as extremely unreliable (or extremely reliable, if you consider it’s lack of crashing and rejecting potentially hazardous problem that could lock it up).
No internal loops, would mean a program internally cannot ever go backwards, or repeat an action that has already been executed. It can however store the same segment of code in a later section and execute it again. Many programmers can’t see how you can write programs without loops, and indeed it’s seems silly not to use loops in a “single instruction at a time” processor. Human programmers are limited by the fact they have to type the code in. However, when a program is capable of learning outcomes to tests, and generating code that mimics those results, loops become suddenly very bad. A program can almost instantly generate code, so typing speed is no longer an issue. A loop tends to “force” a pattern on data, whereas repeating the same piece of code over and over, one can easily add exceptions. Repeated code is also faster than looping code because it has no “jmp” instruction. Repeated code can also be converted easily into parallelism.
In this paper, we are aiming for smart computers, or as smart as they can get. Directly copying the way a human brain functions may not be the best way to create the most intelligent entity. It is a combination of the two that I believe will yield the best results.
Overlapping Redundancy (Two generals problem)
It's very important to note that redundancy does not have to be an exact copy of the data that it is trying to be redundant for. In fact, back up or redundant data can be completely different, so long as the end result of a simulation has meaning.
An interesting fact is that neurons inside the brain a neuron will occasionally stop firing. It is believed that this can happen when a neuron fires too much, or is damaged. I believe also that this is protection mechanism against the possibility of loops inside the brain. If neurons form a loop, then it's possible the same neuron will will fire again and again pointlessly until it can't fire anymore. When it does fail, oddly enough, it will actually “cure” the internal loop. So, ironically, failure can actually be used as a cure for other failures (just as some poisons can cure ailments).
Neurons that “stop firing” means that the communications lines inside the brain are unreliable. However, it is assumed that all transmissions inside a computer are considered reliable. This is a very bad thing as discussed earlier because if even the smallest part of computer dies, then the system will die as well. Brains solve the untrustworthiness of it's neurons in a similar fashion to one of the solutions to “The 2 Generals Problem”.
The 2 Generals Problem.
Two armies set up camp on two different hills, separated by a valley, filled with enemy soldiers. The two armies need to attack a city at the same time to succeed. otherwise attacking by themselves is a failure. They need to communicate with each other by sending messenger(s) through the valley. Note that it is quite simple for the generals to come to an agreement on the time to attack. One successful message with a successful acknowledgement suffices for that. The trick of the Two Generals' Problem is in the impossibility of designing algorithms for the generals to use to 100% safely agree to the above statement.
There are many possible scenarios to “The 2 Generals Problem” as described by Lamport, Shostak, and Pease in 1982.
“
One solution considers scenarios in which messages may be forged, but which will be Byzantine-fault-tolerant as long as the number of traitorous generals does not equal or exceed one third. The impossibility of dealing with one-third or more traitors ultimately reduces to proving that the 1 Commander + 2 Lieutenants problem cannot be solved if the Commander is traitorous. The reason is, if we have three commanders, A, B, and C, and A is the traitor: when A tells B to attack and C to retreat, and B and C send messages to each other, forwarding A's message, neither B nor C can figure out who is the traitor, since it isn't necessarily A - the other commander could have forged the message purportedly from A. It can be shown that if n is the number of generals in total, and t is the number of traitors in that n, then there are solutions to the problem only when n is greater than or equal to 3t + 1.
A second solution requires unforgeable signatures (in modern computer systems, this may be achieved through public key cryptography), but maintains Byzantine fault tolerance in the presence of an arbitrary number of traitorous generals.
Also presented is a variation on the first two solutions allowing Byzantine-fault-tolerant behavior in some situations where not all generals can communicate directly with each other.
“
(The Byzantine Generals Problem, 1982, p.1)
However, the cause of the failures isn't really important, because failure can occur in an infinite number of ways. Whats important is that it can fail, and no matter what that failure is, we need to handle it. There is one solution that is the most likely to succeed, regardless of the failures, and it is this:
One way to deal with the uncertainty is to send multiple messages, say 100. With each message send what number they are eg 1,2,3,4 ..100 and validation messages 1,2,3,4 ..100. If any messages are missing you know then the communication channel is unreliable.
The brain solves the problem of the 2 generals by sending many messages, but it's a little more than just sending more of the same message.
Many people consider that remembering the wrong way to do something a waste, but how can you check to make sure what your doing is correct, if you don't know what is wrong. So, in this regard, even completely wrong answers are useful. Eg. If there are 2 possible answers to a problem, say 1 and 2, and we know 2 is wrong, the fact that we know all possible outcomes means we can deduce correct answer is 1 even though we haven't stored that answer anywhere.
This has 4 advantages :
1.It serves as a backup of the original program or data.
2.The redundant program/code/data can check the original answer to help determine it's correctness or incorrectness. The more things you can check about a problem, the greater the likelihood that you can confirm it's correctness.
3.The redundant program/data/code may be able to predict different things to the original program.
4.The redundant part of the program/data/code can be run simultaneously with other program/data/code. Hence there is little speed loss.
When one is learning something new, we try a number of different possibilities to make something work. These possibilities get stored away internally in our memory as overlapping redundancy. Our memories of past events gives us a reasonable “set” of possible answers. Answers that fall outside the reasonable “set” of answers, can be flagged as an unusual case, and one could conclude that something else is in play that would cause the unusual answer. Memory therefore acts as overlapping redundancy, and is useful in determining the correctness of a given answer.
Making an exact copy of something as a backup is extremely wasteful of resources, but is useful to recreate exact simulations, especially in the fields of mathematics and programming. However, in the real world creating exact simulations can be very difficult, usually impossible. One aspect of the Chaos theory is that because we haven't found the smallest element in the universe (and hence measurement can only ever be an estimate), we therefore can't precisely predict what will happen in real life. (Alligood, 1997) (Chaos theory). Therefore, it is best to record the different ways in which things works, all of which are different, and all which help conclude if an answer is valid.
So it's easy to see the the brain has the best of everything:
1.Failing neurons keep the brain safe from destructive loops.
2.Built in failure allows the brain to be fault tolerant.
3.Neuron failure is kept in check generically via massive parallelism. ( ie. The “send 100's of slightly different messages ” solution to the “The 2 Generals Problem.”)
4.The correctness of an answer is checked via the fact that neurons deliver the same answer even though it's calculated differently.
5.Problem solution do not have to be programmed, instead all relevant outcomes to an event can stored and generalized to find the generic solution to any problem. Solutions to problems can be learned.
6.The neurons don't store exactly the same information, so therefore the stored data is not a waste of space.
