The Oracle tells us that the Architect's job is to balance "the equation", the primary governing equation for the Matrix. I would never even think of trying to hypothesize some elaborate equation with quadrillions of variables on each side. But it is interesting to think about what an overview sketch of the equation might look like.

First, it is important to remember that the Matrix is more than a power plant. It is a giant computer. The computing power is provided primarily by the network of human brains working together. Humans in their power plant pods would therefore be the main "RAM", "hard drive" and "CPU" of the Matrix. The software of the Matrix would consist of the RSIs of both humans and programs running in the Matrix (see Comics: Goliath for more on this). If a human in his pod does something that isn't compatible with the rules that govern the Matrix, it causes a hardware and software error, the same way a calculator might give you the wrong answer if you spill water on it before pushing the "equals" sign.

In trying to think of what goes on each side of the equation, the simplest approach I've found is to recognize that the need for balance in the Matrix comes from what humans do inside of it. If a human does something that throws the equation off balance, the Architect counters it by manipulating programs within the Matrix. (We see an example of this at the beginning of M2, when Neo encounters the upgraded agents. This was the Architect's response to the error Neo caused within the Matrix when he destroyed Smith.)

So, the base equation I will work with is the following:

(Humans) = (Programs)

This is to be read, "Humans are in balance with programs."

Everything in the Matrix (aside from humans) is a program, from basketball hoops to the law of gravity. When humans cause errors on the left side of the equation, the Architect manipulates the right side of the equation through the creation, updating or deletion of programs. The question that really defines the essence of balance within the Matrix "equation" would be, "How does the Architect handle human errors?"

The Architect's first two Matrix models failed because they did not allow for human choice. They forced humans to accept the Matrix when some of them didn't want to. This caused bad things to happen to humans' brains - or, in computer terms, "hardware errors". The Human/Program equation would look like this:

(Humans) + (Hardware Errors) = (Programs in Severe Error)

The Architect's equation did not take into account human choice. Therefore, the source of errors that resulted from supression of choice were not even recognized, let alone balanced in an equation. The Architect didn't even understand why the Matrix crashed those two times - he thought it was something wrong with the theme of the Matrix (paradise vs. suffering). The Matrix crashed when the equation demonstrated severe unbalance. Even though a minority of people wanted to reject the Matrix (1%), the system did not allow their brains to do the rejecting, so their brains reacted accordingly by behaving like calculators with water spilled on them.

When the Oracle introduced choice as the reason for failure of the first two Matrix models, this allowed the Architect to finally be able to "subtract" the errors from both sides of the equation (this is just my way of showing that the Architect finally recognizes the source of the errors and can actually manipulate them):

(Humans) + (Rejection Errors) = (Programs in Error) - (Rejection Errors) = - (Rejection Errors) ------------------------------------------------------ (Humans) = (Programs in Error) - (Rejection Errors)

What happens to these rejection errors? They get encapsulated into the One via the Prime Program (see Matrix System: Prime Program). So, another way to write the resulting equation above would be:

(Humans) = (Programs in error) - (Encapsulated Rejection Errors)

And, if we replace "Encapsulated Rejection Errors" with "The One" (both are equivalent) and add "The One" to both sides of the equation, we get:

(Humans) + (The One) = (Programs in Error)

It's important for these errors to go from one side of the equation to another to show that they are being handled by the Prime Program before finally resting on the left side of the equation (the One is still irrevocably human). Let us call this equation the "primary equation" since I will be referring back to it later. This primary equation is what is seen in the Matrix during the entire 100 years of its running, until the One finally fulfills his purpose (discussed below).

Notice that "Programs in Error" is still there. The errors aren't nearly as bad as they were in the first two failed Matrix versions, because each initial rejection is recognized and immediately encapsulated as soon as it first happens. These people who reject the Matrix continue doing so, but each additional rejection by the same person does not cause problems in the system since the cause of the rejection has already been identified. Once identified, the Prime Program "flags" that individual and changes the way that programs and other people interact with that person. In other words, the system knows that the person rejects gravity, matter, heat, or whatever it is they reject, and knows how to handle that person in the future.

The Architect is still left with humans' *initial* rejection, a rejection that was not predicted by the system. That means the One carries
around the first rejections of everyone who rejected the Matrix for any reason. (And, if a person rejects five different parts of the Matrix for five
different reasons, that would be five instances of "initial rejection" that the One would carry on their behalf.)

In the first two failed Matrix versions, the errors would compound exponentially since each error would be allowed to occur over and over again. This model is much better, but still imperfect since the initial rejection error still causes at least one program error. The "butterfly effect" of millions of individual program errors is what causes the Matrix to crash every 100 years unless something else is done to achieve balance. What would be an example of "program errors"? See Animatrix: Beyond.

So, the Prime Program also creates a "link" between the One and each person who rejected the Matrix. Every piece of rejection code that makes up the One is connected to the person it came from. It wouldn't matter if the original person is dead or not - the Prime Program (Oracle) sees the Matrix without time, and that includes going backwards by 100 years.

To the Architect, a person who rejects the Matrix for any reason is a person without purpose inside of the Matrix, and a person who therefore needs to be deleted in order to bring balance to the equation. No person would ever choose deletion for themselves, and that is why the One is created and the survival of the human race is placed over his head when it comes time for him to choose his own deletion.

When the One returns to the Source and chooses the right door, he is choosing a "dissemination" of his code. In order for his code to be disseminated,
he has to be temporarily deleted. The One cannot be alive when his code is being taken apart, piece by piece. That is why, essentially, the One is
choosing *deletion for himself* when he chooses the right door. The links that connect the One to all of the individuals who rejected the Matrix
are used to "delete" each rejection carried by the One.

So, very simply, the One is subtracted from both sides of the equation:

(Humans) + (The One) = (Programs in Error) - (The One) = - (The One) ------------------------------------------------------ (Humans) = (Programs)

Subtracting "The One" from the right side of the equation results in just "Programs" because of the "links" mentioned above that join the One to all of the people contributing to his code. Programs in error are only the result of the first rejections of all humans in the Matrix, which is exactly what defines the One. Deletion of all human rejection choices (the One) gets rid of all program errors.

The Oracle says that her purpose is to unbalance the equation. This results directly from the fact that the Oracle is still studying the human psyche to get closer to understanding human irrationality. The only way she can do so is to encourage and develop human rejection. Remember the "primary equation" from above:

(Humans) + (The One) = (Programs in Error)All that would happen to this equation because of the Oracle's unbalancing is that humans in the Matrix would cause errors at a faster rate (therefore causing the One to become stronger at a faster rate) because the Oracle encourages humans (mostly potentials, or children) to reject the Matrix.

What happens to the equation when a person actually swallows a red pill? I would speculate that nothing happens. The setup of the Oracle's choice model actually carries the necessity for people to exit the Matrix so that Zion can grow and eventually train the One. The Oracle knows what all redpill hackers are doing within the Matrix and knows which people are going to swallow red pills before they actually do. These people have already rejected some part of the Matrix and are already "flagged" by the system so that future rejections are expected when they're inside the Matrix.

As for people who are born in Zion, they can't hack into the Matrix since they do not have headplugs. Everyone who hacks into the Matrix is a person already recognized by the system. By the time a person returns to the Matrix as a hacker a few weeks or months after they swallow a red pill, the Matrix system would recognize that person as a hacker capable of bending and breaking many more rules within the Matrix, so nothing they do while they are hacking the Matrix is unexpected. This includes the ultimate redpill hacker, Neo, who is identified by the system as the One, or "the anomaly".

The Oracle tells Neo that the Architect balances the equation and that the Oracle unbalances it. In that same conversation, the Oracle says that Smith is
the result of the equation trying to __balance__ itself out. This tells us without any doubt that Smith (the virus, not necessarily the Agent) is the
result of the Architect's efforts. The Architect probably gave Smith the ability to copy over other programs so that he can eventually gain the same
powers within the Matrix as Neo. (For more on Smith being Neo's opposite, see Neo: Neo's Opposite.)

How would this be represented in the equation? Again, let's start with the primary equation from above:

(Humans) + (The One) = (Programs in Error)

Calling Smith the "Anti-One", the introduction of the One necessitates something to counter the One:

(Humans) + (The One) = (Programs in Error) + (The Anti-One)

Since we cannot just arbitrarily add something to only one side of an equation without adding the same thing to the other side, why can we do it here? It is because "The Anti-One" comes from breaking it apart from "Programs in Error". To call Smith a "program in error" would be an understatement, because Smith is an exile who is determined to destroy the Matrix itself.

Remember above, when the Anti-One does not exist, "Programs in Error" are removed from the equation when "The One" is subtracted from both sides. However,
in this case, by the time Smith becomes extremely powerful, he has copied over every program and human in the entire Matrix. In other words, Smith
__is__ the Matrix. That means that "Programs in Error" and "Humans" eventually get copied over by "The Anti-One" until there are no longer any more
"Programs in Error" or "Humans" to speak of:

(The One) = (The Anti-One)

At this point, the Matrix cannot just be restarted since the One hasn't cancelled out the initial rejections of all humans for the past 100 years. Not only that, but Smith wouldn't choose deletion for himself by choosing to return to the Source. Just as the function of the One is to choose deletion for himself, the only way Smith can be destroyed is to also choose deletion for himself. When Neo gives himself up to die at the end of M3, Smith takes him over and inherits that same decision. After Smith copies over Neo, we have:

(The Anti-One) = (The Anti-One)

...which reduces to...

0 = 0

It is not because of this null equation that Smith is deleted, however. What this null equation means is that Smith is officially __everything__ at
this point. There is nothing anywhere to balance himself out. Fortunately, Neo had already chosen deletion before Smith took him over, so Smith is
completely wiped out. Wiping Smith out adds the original equality to both sides of the "zero equals zero" equation:

(Humans) = (Programs)

Humans and programs aren't functioning or thinking at this point, but that is easily fixed by restarting the new Matrix version 7.0.

I've seen it argued that the Smith virus is inevitable in every Matrix version since Smith is the result of the equation balancing itself out against the One, and since Neo would supposedly always choose to destroy Agent Smith the same way he did at the end of M1. The argument continues by saying Smith is always stopped when the One chooses the right door, and machines simply didn't know how dangerous Smith becomes when given enough time to fully develop. This theory cannot be true - see Debunked: Previous Smith Viruses.

Back to Architect |