On AI [1]: Computers are unsuitable for the task

This is probably an AI generated image, but I think that’s actually appropriate for this conversation. Source: Google Deepmind on Unsplash

As the title suggests, this is going to be a series of articles. Every time I sit down to hash out one point on the topic of AI, I end up with another long draft for another point entirely. I’ve taken this as a sign that I might have a lot of pent up thoughts on the matter that need to be written down for posterity (or to laugh at how ignorant I was), and so I’m going to roll with it, and write a few of these—eventually.

The general goal of this series is to argue that…

If AGI is the goal, computers won’t get us there

AGI—Artificial General Intelligence: The term we had to start using to specify a real artificial intelligence because we kept using “AI” for our partial mockups.

The root of the problem is the nature of computers. And this is a known problem, but one surrounded by many unknowns—unknowns which may hold the key to surpassing that limit. As I have observed, there are generally two dominant schools of thought on how this will work out.

The first is the idea that the only true difference in nature between man and machine is on the question of scale. Thus, a true sentience can be achieved by increasing the size and complexity and computational throughput until it reaches that point of rivaling or surpassing the human brain.

The second is similar, but breaks down the distinction between machine and biology in the reverse direction. In this school of thought, machines are already a form of life and will attain sentience through “emergent” complexity—that is, roughly, that they will “evolve” into sentience as we iteratively increase their complexity.

Now… while I won’t step outside my bounds to claim that that there exists no natural, independent lifeform with a truly machine nature, I will make the claim that the distinction between man and deterministic machines—what a computer is—cannot be broken.

For today, however, I first want to make sure we all understand what a computer is.

Don’t worry, this should be pretty light on the math…. And, hopefully, not too abstract…

The Nature of Computers

That keyword, “deterministic,” is the crux of the problem here. I actually rather like the definition given on Wikipedia:

In mathematics, computer science and physics, a deterministic system is a system in which no randomness is involved in the development of future states of the system. A deterministic model will thus always produce the same output from a given starting condition or initial state.

This is the kind of system a computer is, because those are the kinds of problems they are designed to solve. Despite all of the apparent complexity of what we use them for now, their one core function has remained unchanged: they “compute.” That is, they evaluate numerical operations.

They take in two numbers, apply an [arithmetic] operation, and spit out a third number… That is what they do.

That is all they do: compute.

Everything your computer does is adding numbers. Everything. The only “thought” it is capable of, is to add numbers.

Just kidding.

The “computer” does not do math. We do math, using them.

What a computer really does, is it forces a flow of electrons through a really complex obstacle course of circuits and switches and gates. While it does that, parts of the system will reliably change between “low” or “high” states of electrical charge. Then we’ve arranged other machines that read those charges as “signals” to do their own specialized tasks.

For instance, the screen you’re looking at right now is probably reading 2 million or more of these signals, which are patterned bundles of 24 or 32 charges each. For example of what these signals look like—using “0” for “low charge” travelling across a wire, and “1” for a “high charge”—here is the [usual] signal for red:

1111 1111 0000 0000 0000 0000

Each of the tiny little mechanisms behind the glass of the screen then reacts to the pattern of the signal, and adjusts whatever bits and bobs are attached to it to produce the mix of red, green, and blue light the engineers determined should be invoked by that pattern (there are some industry standards for how one ought to do this, exactly).

That’s really the heart of what a modern computer does. It takes in binary electrical signals—produced by your touch screen, keyboard, hard drive, etc.—mixes those signals through a process that “models” arithmetic operations, then spits out the result to whoever is listening.

I say “models” arithmetic, because it’s very important when understanding a computer to realize, that…

A computer does not know what a “number” is. Numbers are human shenanigans.

A computer “knows” how to push electrons through silicon. We happen to find it useful to do that in certain specific patterns that assist us in doing our math. They are—effectively—really fancy (and expensive) pens and paper.

If you’re a programmer, I encourage you to keep that in mind. Personally, I’ve found that mental model incredibly useful for reasoning with things like memory management, IO, database optimization, and other “low level” tasks.

Numbers, meanwhile, are abstract “concepts.” To exist, there has to be a mind to conceive of them. A “one” is not a “thing” but a description of a “thing.” A description whose accuracy depends on the perspective of the observer. There could be twenty apples in a box, not “one,” but then “one” could be green and the rest red—now that green apple is “one.”

And that apple is itself not “one thing” but “trillions of small things” arranged in a pattern we call “one” apple when our perspective is focused on the whole, not the parts.

Following? Maybe? I know. Generally, talking about abstractions is the kind of thing where either your head spins immediately when you start thinking about it, or I started sounding incredibly pedantic over obvious things and you would like me to move on.

The point is, there are no numbers in a computer. There are circuits holding electrical charges in patterns we find useful for representing numbers. And even better, we can make those patterns of charges change in a very reliable, consistent way that looks like doing arithmetic. That is to say, the operation of the machine “models” our concept of math.

As a side note, these machines don’t have to be electronic, either. In fact, the first “computers” were conceived of as gears and rods. Theoretically, you could build one out of a fountain if you had the time, resources, and patience. Nevertheless, for a variety of reasons, electricity and silicon was found to be the most practical medium as the scale of the systems we needed increased.

Mechanical concerns are why computers use “binary” numbers by the way. Counting to 10 in each digit has proven to be rather cumbersome when translating math to machinery. It also turns out that it’s a lot easier to make a machine “do something” that looks very much like adding numbers when each digit being operated on can only be one of two things.

Another thing that might surprise some of you…

(*whispering*) Computers aren’t even particularly good at math…. Get this… they think that if you count high enough, the number wraps back around.

How dumb is that? 🤣🤣🤣

I’m being facetious. A computer can still count way better (and waay faster) than you and me…

But they really will wrap a number back around if they count too high (or too low). It’s called “overflow.” The consequences of overflow are rare on modern systems, but if you remember 8bit and 16bit era games, its the source of many seemingly strange limits for different counters, and more infamously, a slew of bugs and exploits.

This kind of “incorrect” behavior is possible because we are just “modelling” numbers with a machine, and—for several practical engineering concerns—there’s a limit to how accurate that model can get. Generally, it is accurate right up until the point of failure. But, if we do push the model past its limit, the reality of what the machine can do will contradict the abstract logic we’re trying to keep track of.

For computers, the limits overwhelmingly revolve around the number of observable electrical charges we have available to build a signal for any given operation at any given time. This is because there are only so many “unique numbers” we can represent with a fixed number of binary digits—that is, a “bit.” And the machine needs one physical “thing” for every bit of every “number” we want it to actively keep track of.

And there’s only so much extravagantly engineered magic sand we can produce on a reasonable budget, and only so much space we can use before our obstacle course becomes too slow for the electrons to traverse…

I could go on and on talking about how computers work (and I will, sometime). But now, let’s connect this back to the primary characteristic I noted about computers: they are deterministic by design. They are because arithmetic is, and they were built to model arithmetic.

We can push the machines past the limits of this model, but when we do, we do not get good novel behavior—they break.

The Problem with Nondeterministic Systems

…is that they break computers.

At least, chaotic nondeterminism does. Meaning, nondeterministic systems—systems with unpredictable outputs—that have no “will” behind them, guiding the system to produce an “ordered” output. At worst, chaotic nondeterminism will produce invalid outputs just as likely as valid. At best, they produce arbitrary valid outputs.

Meaning, that there is no meaning behind why one output was selected over the other, but that it doesn’t break the rules of the system.

As a kind of example, think of “the square root of 4.” It’s “2,” right? Well, it’s also “-2.” Is there any rule saying to prefer one over the other? No. Both are valid. But often we prefer the positive number because it’s more helpful to whatever we’re doing.

For instance, when getting the length of the diagonal of a rectangle using the Pythagorean theorem: a²+b²=c². If “a” is 3 and “b” is 5, then:

(3)²+(5)²=c² → 9+25=c² → 34=c² → sqrt(34)=c

(I know some of you didn’t need that, but some of you will)

SO, “c” is the square root of 34. Great, so the diagonal of the rectangle with a width of 3 and a height of 5 is: -5.831…

Hey. Don’t look at me. That’s a valid answer to the square root…

…But it’s not a valid answer to “the diagonal length of this phone screen.”

So, even though either the positive or negative output is “valid” for the particular “subsystem” of a “square root,” picking a valid output arbitrarily is “chaotic.” As in, if there is a greater “system”—i.e. measuring a phone screen—the chaotic element may cause the system as a whole to fail. So, for a square root to actually be a solution, we have to artificially limit the possible outputs until it isn’t nondeterministic.

Where does nondeterminism come from in physics?

To my knowledge, the only phenomenon in pure, material physics truly recognized as “nondeterministic” is the behavior of quantum particles.

I am sidestepping all questions of whether or not human reasoning (and biological life in general) is “nondeterministic” in nature… for now.

Currently, computers don’t have a particularly stable relationship with quantum physics. Quite specifically, quantum physics is part of what’s making our computers unstable as we try to shrink them down further. As our circuits get smaller and smaller, the very minute behaviors of quantum particles are able to randomly effect the flow of electrons significantly enough to disrupt the computer’s processing.

To put it playfully: it’s very hard to do good math when ghosts and goblins keep changing the numbers on you.

For a bit of trivia, though, sometimes random numbers are exactly what we want in computer processes—security being the largest use case I know of after video games—but computers can’t actually produce them. Instead, we usually build mathematical functions with hard to predict outputs and make the time of the day one of the inputs.

When a really hard to predict number is needed, people have been known to connect a camera to a computer, point it at a wall of lava lamps, and interpret the flow of goop as numbers. This has been considered a gold standard for secure number generation.

…We also don’t want our random numbers to change at random. We just don’t want anyone to be able to guess the one we have.

What about quantum computers?

That’s a bit too complicated to explain here in detail, but the short version (as I understand it) is that the property of quantum particles we’re leveraging in a quantum computer is their ability to hold superpositions. For now, just think of it as being able to hold multiple “bits” in the same place at the same time.

There’s more to it than that—I think—but from what I’ve read, quantum computers are still deterministic.

Determinism begets determinism

Which gets to an important point about the relationship between deterministic and nondeterministic systems: they’re like adding even and odd numbers.

Nondeterministic (odd) systems can combine with deterministic (even) or other nondeterministic systems to create a more complex deterministic one. But if you combine deterministic systems together, they always end up deterministic—even if more “complex.”

This is part of the reason why, no matter how large we scale a computer system in size and complexity, it can’t surpass the fundamental restraints of its nature. No matter how capable it is at modelling math, it will remain deterministic.

It will also continue to “model arithmetic.” So, everything we want to do with them must compose down into arithmetic operations, if we want to accurately model those more complex operations.

To put it another way, if you want a computer to do a specific task, you have to be able to define that task as a series of numbers being added together.

It turns out that, given enough numbers, you can define a lot of processes this way.

For instance, as mentioned previously, we can “draw” arbitrary images with a computer by generating a spread of “numbers” representing colored dots (pixels), and send those numbers to an apparatus of tiny lights (a screen) tuned to the perceptions of the human eye so their combined radiance can create an illusion.

The strength of any one light in the screen is “mapped” to a number range from 0 (as dim as it will go) to 255 (as bright as it will go). So, if we want a bright red in our pixel, we need our math machine to spit out 255 somehow, someway. If we want no red at all, we have it spit out 0.

With that rule in mind, pretty much everything before is arbitrary, so there are a lot of ways to produce an image with a computer.

So many ways, that it has become it’s own discipline: computer graphics—my favorite discipline, and frankly, justification enough for the invention of computers (everything else they do is just a bonus).

The way we interact with images on computers doesn’t seem mathematical, but fundamentally it is. It’s very “human defined” as far as the math goes, but once our input devices translate our intent into numbers, it is deterministic.

The Unbridgeable Divide

This brings us back to why computers are unsuitable for modelling human reason: you must at least be able to define the thing you’re modelling. Not only have we—so far—failed to rigorously define all of human reasoning, mathematically, we have no reason to believe human reason can be fully defined that way.

I’d say the evidence is quite strong that it can’t, but we’ll talk about that as we go.

And, should we manage to define it, human reason still has to be modelled, and that’s it’s own problem. Just look at what I described about the nature of “numbers” in computers. That’s the one thing we often say computers do get “perfectly,” but in actuality they can’t achieve a true 1:1 model with the concept in our heads. A number in your head can truly go to infinity, because it is a “concept.” A “number” on a computer must have an end eventually, because it is an enumeration of states of physical matter and energy. For a computer’s “number” to be infinite, the world it is in must be infinite to supply an infinite amount of bits of matter to store the information in.

We have, however, built solid workarounds for many of the limitations of computers, and have gotten more than close enough when it comes to [most of] the math. So, what’s to say we can’t find something that gets us at least close enough with human reason to build an AGI?

This, I shall discuss in part 2.

---

I have part two mostly drafted out already, so should be done within two weeks if all goes well. That one should be a bit shorter, too. This is most of the necessary technical setup.

I hope this all made sense and you learned something. And if it doesn’t and you didn’t, feel free to complain to me in the comments and I’ll try to improve it! And if you did enjoy, please consider one of the following ways to support this publication.

Thank you!

METANOIA [1] is Now (mostly) Available!

And if you wanna check out a (spicier) more Sci-fi, philosophy, and theology flavored opinion on AI, here’s The Pneumanaut’s piece:

Should AI Worship Us?