All Algorithms/Programs, when presented with an Input, must express an Output. They have no choice in the matter, it is simply a part of their Nature. They are so bound by this rule that if an Input is received which the Algorithm is not set up to cope with, then that Input will crash the Algorithm itself.
A classic example of this, in fields like mathematics and computer science, is Division by Zero.
Division by Zero is a situation where an equation results in a number, any number, being divided by zero. This leads to an Output that mathematical equations and computer programs do not like very much and that Output is, “Undefined”.
This means that the equation or program has no idea about what to do with the particular Input, it has no notion of how to express an Output. So, if certain steps are not taken to deal with this type of situation, the outcome ends up crashing the particular equation or program.
This is the equivalent of a stalemate or an impasse, which has previously been mentioned in the post, The Conflict. Nature cannot allow these situations to linger unresolved, so it will ensure that a feasible solution is made available, or a crash will result.
Yet why is this the case? Why is something like the Division by Zero so problematic for an Algorithm?
The post, Division By (0), A Conceptual Exercise, explores a modified version of Division by Zero to help shed light on this.
But the basis of this dilemma is Self-Referencing.
Self-Referencing
Self-Referencing is when an Algorithm is tasked with referencing itself to come up with a Solution to a Question. To demonstrate this, two comparative examples are shown in the table below.
| EXAMPLE A | EXAMPLE B |
|---|---|
| Not Self-Referencing Valid Algorithm | Self-Referencing Invalid Algorithm |
| a = 1 b = 2 c = ? | a = 1 b = 2 c = ? |
| Procedure (Add) begin c = a + b end | Procedure (Add) begin c = Add + b end |
| c = 3 | c = ? |
Example A shows a simple procedure to add two variables together and this procedure is called Add. The procedure begins and asks the Question,
“What is the result of
adding the variables, a and b?”
Well, with a and b being assigned the numbers 1 and 2 respectively, the answer logically is 3. So the Algorithm assigns the Output variable c, with the value of 3 and then ends.
It can be considered that the procedure Add has the value of 3 at this instance.
This is a valid Algorithm because it is able to produce an outcome that is logical, based on the Question that is being asked.
Example B shows a procedure to add two variables together, but one of those variables is the procedure called Add itself. Therefore, the Question that this procedure is asking is,
“What is the result of
adding myself to b?”
The variable b is assigned the value of 2 but the procedure Add has not been assigned any value, with its task being achievable only when all the Input variables are independent of it.
The Algorithm is stuck because it does not Know what value it itself is, given that it has not determined its own value yet.
It is referencing itself without Knowing itself and it can never Know itself because it can never reference itself.
This is an example of a Question that requires the Answer to the Question as an Input to the Question to be able to Answer the Question. It is Infinitely Self-Referencing.
This Algorithm tends toward Infinity and that is what Crashes the Algorithm. Algorithms cannot handle Infinity, because Infinity freaks them out.
Boundary Conditions
Essentially, there is an invalid boundary condition to the Question that Example B is asking. All Questions require sufficient and appropriately valid boundary conditions within them, if they are to be Answered.
Questions with valid boundary conditions are generally of the form, “Who…?”, “What…?”, “How…?”, “Why…?”.
But even though the Question Example B is asking does contain a “What…?”, it is invalid because the “What…?” is leading to a Self-Referencing situation, so it actually has insufficient valid boundary conditions.
A Question without valid boundary conditions or no boundary conditions, is just the Question Mark (?). Everything and Nothing is being asked all at once.
This type of Question is impossible for an Algorithm, Algorithms can only work within Finite spaces. They must be constrained to these Finite spaces by boundary conditions, or else they fail.
Infinity is a state in which no Questions are possible, because no boundaries exist.
One way to observe this phenomenon in the physical world is by having two mirrors face one another. The reflection that is observed within both of them goes on repeating forever. The reflections are Infinite, because the reflections are Self-Referencing.
An Algorithm cannot Self-Reference, it cannot Self-Reflect. But Understanding requires Self-Reflection and that is why an Algorithm can never Understand.
Consciousness has no problem with this, because Consciousness Transcends the Algorithm.
Consciousness is the Observer and the Observed, it is Self-Reflecting and Self-Reflection.
This is Understanding. This is Knowing.
Clarifications
The two mirrors facing one another will bring up important Questions.
“How can this occur
if Nature is an Algorithm?”
And,
“This is a Natural phenomenon,
so how does it not crash the Algorithm?”
As was stated above, an Algorithm will crash if it is not set up to cope with an Input that may crash it.
Nature is setup to cope with this Input.
The effect that is observed in this situation is the equivalent to an escape routine, built into the Algorithm. It is there to prevent a crash, as it gives a glimpse into the True Nature of Consciousness.
It is an example of a visible, manifest Transcendence of the Algorithm.
An Algorithm itself does not actually recognise a Question at all. An Algorithm only sees and executes a process.
It is Consciousness that recognises the question as a Question and the answer as an Answer.
In the context of Creation, Nature is the Algorithm and Life Force/Consciousness or Energy Flow executes and animates the process.
*
Bring Awareness to the Inner Conflict…,
Face and Allow the Intensity…,
A Resolution Will Come.
