# Quantum Computers are Analog Computers

And that's why they are so powerful.

## Abstract

Given that a Quantum Computer has the following design specifications:
1. Very Large Registers
2. Processor that runs at the Speed of Light
3. Simultaneous Transforms across the entire Register
4. Bit Values that range from 0.0 to 1.0
Then, as powerful as the first two items (Faster Processors and Larger Registers) are (and they are quite powerful), they only provide a linear increase in speed. It is the final two items (Simultaneous Transforms across the complete Register that output values in the Range of 0.0 to 1.0) that provide the true theoretical power behind Quantum Computing. But much more importantly, this power is available in classical scale computers as long as those computers are analog and not digital in nature.

## The Disclaimer

The above statement is what this rant is about. And if you understand it (or understand why I am an idiot and it is wrong), you need not read any further.

I do not understand the mathematics behind Quantum Mechanics. But I am arrogant enough to believe I understand the assumptions... and even if not, I believe the following will make for interesting reading, nonetheless.

Or in other words, I may come to regret writing this post... or come to believe that it is wrong (like way wrong). But I shall write it, anyway... because why the heck not?

Besides, I've got a hunch that I'm not wrong, that I am right. And I'd like to timestamp what I think may be a novel insight.

Of course, none of that explains why a non-mathematician, non-scientist, and non-quantum researcher believes he may have something important to say on such a complicated subject. And the rationale for that particular brand of arrogance comes from realizing that problems are often not as hard as the professional folks want to make them.

## The Entscheidungsproblem

As originally stated, I believe the Entscheidungsproblem reads (essentially) as follows:
Given a list of axioms (assumptions) and a lemma (a statement of proposed fact, call it a problem), does there exist (even if Man cannot or does not know it) an algorithm (a methodology, if you will) that will determine whether the lemma is true or not (i.e. can the problem be solved mechanically)?
For non-mathematicians in the audience, I will restate the problem as:
Can Mathematics be Automated?
And much more than a Mathematical question, this is a philosophical question:
Does Truth Exist?

How Can We Know It?

Are There Any Shortcuts?
As with any philosophical question, I will leave the above unanswered (and as the Mathematicians say), leaving it as an exercise for the reader.

However, if we change the question slightly, we come up with the Halting Problem. Stated inanely, the Halting Problem asks whether a computer (keeping in mind, computers didn't exist when the Halting Problem was being formulated, so this really is an inane definition) will halt or not (hence, the name) on a given input.

In simpler terms, if we make a universal computational device (call it a computer) and we give it a computational problem, will we always get an answer.
Will the program terminate?

Will it halt?
So, that's the question. And the answer is no... or at least, it is believed to be no.

Mr. Turing designed a computer and showed that one could not determine whether a program would halt or not prior to running (or stepping through) any given arbitrary program.

In other words:
The only way to solve a problem is to work the problem; if one wants the answer, there is no way to avoid working the problem.
Do you want to know an even simpler way of stating the preceding?
There is no such thing as an Oracle!
So, like, if I have a deck of cards and I shuffle it, no matter how proficient at magic I might be, the only way to conclusively know the value of the top card is to flip it over.

That's part of magic.

That's part of the game.

And one can sidestep the issue and say that there are other ways to know the value of a card other than flipping it over; but within the context of the metaphor, proving and knowing are synonymous with flipping over a card, because how else do you know that I know or I know that you know or that neither one of us is lying?

The answer is simple: by flipping over the card.

And in the game of mathematics (in order to 'flip over the card'), one sometimes has to put together the design specs for the modern computer (ala Alan Turing) or a functional programming language (ala Alonzo Church) to prove something as simple as:
There is no shortcut to knowledge.
I mean, let's look at what Mr Turing did:
``` Entscheidungsproblem -> Halting Problem -> Invented Computers -> Computers Can't Solve the Problem -> ∴ The Problem Can't Be Solved ```
Believe it or not, I read Alan Turing's On Computable Numbers with an Application to the Entscheidungsproblem. And to be honest, most of it was way (way-way-way) over my head, as I am really not that good with numbers.

Likewise, I've read a few (and just a few) brief articles on Quantum Computers. I don't understand the mathematics involved in the least. So, I'm not going to comment on the mathematical proofs (not in the least, like [0|1⟩ ⟨1|0] • ⟨1|0] [0|1⟩ is something the average reader of this page is going to understand). Rather, I'm going to assume all the mathematics work out perfectly.

But I think I understand the assumptions.

And I think I understand the conclusions.

And sometimes the steps in-between are not all that important.

So, if you're wondering why I took a side-trip down Entscheidungsproblem Lane it's to help answer the question of:
How can I be so arrogant as to believe I have something meaningful to add to the unfolding discussion about Quantum Computers?
• The equations on which Quantum Mechanics are built don't befuddle me.
• Mainly, because I don't understand them.
• Thus, I am more than happy to accept their mathematical validity.
• Rather, it's the Real World Application that I question.
• And I have plenty of experience with the real world.
• More importantly, I have plenty of experience with mathematicians overstepping their bounds...
• And getting tripped up in the complexity of their own thoughts.
Or to put it more succinctly, if there was a positive solution to the Entscheidungsproblem, Oracles would exist and you would not have to read the rest of this post to know what I have to say.

Time would have no meaning.

And the Universe would be solved.

So if Mathematicians are going to play God (and spend a lot of good effort proving the patently obvious), I don't see why I can't.

But enough of that non-sense.

Let's get on with Quantum Computers and the topic of the day, shall we?

## Quantum Mechanics

I actually don't believe in Quantum Mechanics. It's not that I doubt there are equations or doubt the equations model reality. It's that I doubt the underlying assumptions are correct: mainly, that observation (human or otherwise) solidifies state.

You have a name. If I know the worldwide frequencies of names, I can assign a probability that a person chosen at random from the population at large will have your name. But you still have a name. And the probability that your name is your name is 1.0. It's 100%. It is a certainty. And it makes no difference what the global probability is.

Quantum Mechanics holds that a particle doesn't really know what it is about, doesn't really know it's own name.

And I do not think that is the case.

Ironically, this makes absolutely no difference to the rest of the discussion. But I felt the need to get that out of the way, right at the start.

## Quantum Computers Will Have Very Large Registers

Quantum Computers (as the name implies) compute at the Quantum Level. Because they compute at the Quantum Level it is believed (by some, but not by me) that this will enable the Registers to be unbelievably large.

Of course, that's not really clear. So, take it as a given (because it's flat out true) that most laptops (circa 2018) have 64-Bit registers. This is pretty good. Forty years ago, when I was a kid, 8-Bit computers were all the rage.

But in the grand scheme of things, sixty-four bits isn't that many (26 to be exact). Quantum Computers, on the other hand (or so goes the claim) will have registers in the millions and billions and millions-of-billions and millions-of-billions-of-millions-of-billions of Bits. These are Very Large Registers.

Or at least, they might be. I don't (personally) believe Quantum Computers will ever get that big. And in fact, I believe (if we ever get them to work) Quantum Computers will be lucky if they have 8-Bits (so they might only have 4-Bits, 2-Bits, or 1-Lone-Bit: after all, yes/no is really all we need) due to the limitations of what I will call Bringing Focus to Bear.

Telescopes are big... and they are getting bigger. Electron microscopes are not exactly small. And particle colliders are simply huge. So, I question how many inter-related spin states (or whatever) we can focus upon and control at once.

Of course, this is a minor aside for two reason. First, we may only ever be able to direct our gaze at a single spin state (a 1-Bit register), but we may have enough control over that single Quantum State, it can be asked very complicated questions. And in all this, I'm merely calling back to that yes/no, single bit register... to which we can pose very complicated questions, like Which planet, besides ours, in All the Universe is most likely to contain life? And second, even if we can make the registers millions-of-billions-of-millions-of-billions of spin states large, that's only a... um, let me do the math here:
``` million = 106 billion = 109 m-of-b-of-m-of-b = 1030 ```
It's only a 1030 increase in computing power.

Fine! That would be awesome!

But it would still only be 1030.

And if we are going to talk about such nonsensical numbers, let's at least admit that we are now talking about a Quantum Supercomputer the size of a marble... and that's bloody well unlikely.

But 1030?

Ha!

Are you joking?

Is that all you've got?

See, here I will scoff at your pathetic 1030 increase in computational speed, because it's still just a linear increase in time. That is to say, even if 1030 more resources are thrown at a computer program, said program still may not halt before the end of time, meaning certain mathematical problems will remain (practically) unsolvable.

## Big-O Notation

Some mathematical problems are hard, some are harder, and some are harder still.

And the way that progression of difficulty is expressed in Computer Science (and likely in mathematics, as well) is with a thing known as Big-O Notation.

Truthfully, I don't know Big-O Notation all that well, because it doesn't have much utility in my world. But the basic concept is simple.

Some things are pretty darn easy to do and take a set amount (also, known as a constant amount) of time. Things like checking to see if a single bit is set to 0 or 1 takes a constant amount of time.
`Constant Time = N0 = 1 = C`
Whereas, if we wanted to check the status of a thousand bits, it would take Linear Time.
`Linear Time = N * N0 = 1000 * 1 = 1000 = N`
Another example of Linear Time would be the amount of time it would take to count the number of people on the planet that have first names, which start with the letter B (you know, given an appropriate data set, not to actually conduct the survey). Solving this type of problem involves going through a list of everyone's name and checking for a match. So, it's Linear Time to go through a list and Constant Time to check each item on the list, but lower orders of time complexity are thrown away (ignored and discarded) in Big-0, as higher orders of complexity rule the day.

Thus:
`Check Items in a List = Linear Time = N1 = N`
Another way to look at it is:
``` Cycle Through List = Linear Time = N1 = N Check Each Item on List = Linear Time = N1 = N Do Both = N + N = 2N ~> N ```
Meaning, there is no Time Complexity difference between 2N & N (or even, N plus some incredibly large constant like 1030).
``` Linear Time = N + 1030 ~> N + C ~> N ```
Suffice to say, Linear Time has a greater Time Complexity that Constant Time.

From there, there are a good dozen (or half dozen) different ways of measuring complexity that for the most I could care less about.
```log(N) = Logarithmic Time < Linear Time NN = Exponential Time > Linear Time```
So, there's a sort of progression:
``` C -> ln(N) -> N -> NN Constant Time -> Logarithmic Time -> Linear Time -> Exponential Time ```
With N (in the above) being the size of the problem set. Do you want to look up N things? Do you want to sort N things? Do you want to apply a function to N things? Or pass N things as arguments to a single function?

So, if I have a (Quantum Computer with a) register (sitting pretty) at 1030-Bits and I need to do something that will take Constant or Linear Time on a Classical Computer, I get a 1030 speed up on a Quantum Computer, which means... the problem is solved.

It's done.

But even if I have incredibly large registers (sitting pretty at 1030-Bits), if the problem is of the nature NN (or NNN) then if a linear speed up in time is all a Quantum Computer has to offer, then NN (or NNN) for sufficiently large values of N are just as impossible for Quantum Computers to solve as they are for their Classical Computer counterparts.
``` If N = Number of Planets in the Universe: Then, NNN just ain't going to happen. ```

## Quantum Computers Will Flop at the Speed of Light

This to me has always been where Quantum Computers will shine. I mean, I can see a very small bit computer (call it 4-Bit) flopping so fast (computing so fast) that it's like a thousand, ten thousand... hey, call it a 1030 speed up over its classical counterpart.

But for the reasons given above, that won't solve any of those NNN problems (or even those much-much simpler NN problems) when N becomes high enough.

So, here you'll have to read this outloud in the voice of a television huckster.
But wait! Can't we do better?
Why, as a matter of fact, we can.

But to do so, we need to really dive into Quantum Mechanics.

But not to worry, I'm really not that smart, so I'll be using plenty small words when I try to explain things.

## Super-Position

Quantum Mechanics would hardly be interesting (or much different from Classical Mechanics) if things were already decided. Which is to say, on the Quantum Level a thing can be, not be, or maybe it's a bit more philosophical (and/or like one of those people who are always putting things off, call them a procrastinator) and hasn't decided one way or the other, which way things should be, just yet. I mean, this isn't very quantum sounding yet, so let's talk about spin... like I know what spin is. I don't. But let's assume that I do. And let's, also, assume that there are exactly two spin states. But ironically (and quite counter intuitively), if there are exactly two spin states, that means there are really at least three spin states.
``` Spin = UP Spin = DOWN Spin = UNKNOWN ```
And when `Spin = UNKNOWN`, well, things get exciting, because we might as well call `UNKNOWN` by the name `UNDECIDED`.

And really, if you want to get down to brass tacks as to the exact point where I disagree with Quantum Mechanics it's at this point. I think spin is `UNKNOWN` by man. And the current theory (you know, the popular one, the one getting the grant money) states that it's `UNDECIDED` by the universe. And there is a huge philosophical gap between the two. However, on a mathematical level, they mean pretty much the same thing... because mathematically:
There is no Oracle greater than Man.
And really:
There is no Oracle other than Man.
So, if Man does not know something, mathematically, it is not know... and this is, of course, exactly where Quantum Mechanics goes wrong, as it interprets this lack of knowing by Man as a lack of knowing by the Universe... or God.

But enough of that.

We were talking of Spin.

At `Spin = UNKNOWN` (or `Spin = UNDECIDED`, I will use them interchangeably from here on out) we still know a thing or two about spin.
``` Spin = UNKNOWN = {UP:DOWN} ```
To my eye that looks a lot like a Maybe Monad... from functional programming and/or abstract algebra. And since that's not the type of stuff they (likely) taught you in high school (or you are one smart cookie) let me just point out that that a Maybe Monad holding a spin state has EXACTLY two states... and not the three or more that Quantum Mechanics proposes.

To wit:
``` Spin = MAYBE{UP} Spin = MAYBE{DOWN} ```
The central factoid of a `MAYBE{UP}` monoid (and I certainly hope I am using that word correctly) is that we maybe know the spin is up or maybe we don't (that is to say, the spin could be Up or we might not know what the spin is) but it's never going to be down.

So in my universe, the following (not only provides clarity) but states that the Universe is deterministic... even if Man does not know it (or understand it), just yet.
``` Spin = MAYBE{MAYBE{UP}:MAYBE{DOWN}} ```
Still, let us return to the popular paradigm and realize that in ``` Spin = UNKNOWN = {UP:DOWN}```, the UP and DOWN values are replaced by probability functions.
``` UPp + DOWNp = 1.0 Where:   0.0 -> UPp -> 1.0   0.0 -> DOWNp -> 1.0 ```
Which, if you don't read my personal mathematical notation (and why should you), means that the Probability of Up and the Probability of Down equal a certainty (in the end, it's one or the other) and that these probabilities are as we (or at least I) would expect them (i.e. somewhere between zero and one as all probabilities are).

If we replaced Up with Heads and Down with Tails and wanted to model a fair coin flip, we might say:
``` TAILS(.5) + HEADS(.5) = 1.0 ```
It's either going to be heads or tails with equal probability.

And if we wanted to model a function (call it `f_name_char_first`) that told us the probability that a person's first name would begin with any particular letter, then we might model that as:
``` f_name_char_first(?) = A(.03) + B(.06)... + Z(.01) ```
My first name is Brett, so:
``` f_name_char_first(ME) = B(1.0) ```
But that doesn't change the fact that for an unknown person (or even me if we don't know that we are talking about me yet, which you should, because that's what I'm always talking about) instead of a certainty, we get a spread.
``` f_name_char_first(?) = A(.03) + B(.06)... + Z(.01) ```
And that spread is Superposition in a nutshell. The Quantum State is in a Super Position. As in, it's not in a specific position. It's in a Probabilistic State.

And like I've said, some folks think this is the Nature of the Universe. I think it more accurately reflects the Ignorance of Man... perhaps because that's the corner of the universe I rub up against more than anything else.

Anyhow, the point is: probability distributions.

The Quantum World (as currently modelled) works on probability distributions.

And rather than:
``` Spin = UP(.5) + DOWN(.5) ```
We are looking at complex numbers at the very least.
``` Spin = UP(√2, √2i) + DOWN(√2, √2i) ```
Personally, I strongly suspect the imaginary variables extend long into the `i, j, k` range. But it's a trivial point.

Between 0.0 and 1.0 there are an infinite number of values. Sure, we don't (as of yet) know how to extract an infinite amount of information from those values and most folks eyes glaze over much beyond 0.001. But from a mathematical perspective the `range 0.0 -> 1.0` is infinite. And this is the spread Quantum Computers think in.

I mean, maybe I've been a bit wordy, maybe I've stumbled over my own thoughts, maybe I went off on a `MAYBE` tangent (or two), just maybe. So, let's take a moment and regroup.

Quantum Computers think in probabilities. These probabilities range from 0.0 to 1.0. So, Quantum Computers think with floating point bits of (theoretically) infinite precision.

Classical Computers hold zeroes and ones {0:1} or exactly two pieces of information per bit (yes or no).

Um...
``` ∞ > 2 ```
And in fact:
``` ∞ - 2 = ∞ ```
So, mathematically speaking a single floating point Quantum Bit can hold infinitely more information than a single classical binary bit (or all the classical bits in all the computers in the world, it's that powerful of a mathematical construct).

And I strongly suspect (though I haven't heard anyone explicitly state it as such) this is one of the major reasons why Quantum Computers are (expected to be way) more powerful than Classical Computers.

Quantum Computers will be analog; and so, their bits will be way more efficient.

Going from binary to anolog (from 2 to ∞) is probably (maybe, not very likely at all, but then, I'm no mathematician) enough to (give a computer a theoretically one-dimensional infinite boost and) take a problem from the world of NNN all the way down to NN or maybe just NNln(N), which is still pretty good. And like I said a long time ago in the Big-O section, a reduction in complexity is far more important than a mere increase in computational speed.

Oddly, when talking about the great increases in efficiency awaiting us whenever we get Quantum Computers online, this last (floating point bits with infinite accuracy) is not mentioned so much, as there's another way in which Quantum Computers kick (the theoretical) snot out of Classical Computers.

## Super-Position (in brief)

Eh, maybe I did not explain Super-Position that well, so let me do that real quickly, using small words, and not going off on any tangents.
```If Spin = UP

Then:
UPp = 1.0
DOWNp = 0.0
```
And all is well In the World. Please note: the specific turn of phrase.
```But if Spin = UNKNOWN
Then:
UPp = 0.0 -> 1.0
DOWNp = 0.0 -> 1.0
```
And the particle (or whatever) doesn't really have a Spin and trying to describe such an unknown (really, a non-entity if you believe that Quantum Crap) takes a few extra numbers in order to hold onto all the possibilities... by which I mean, your complex number system (e.g. `0.23 + 0.37i`).

But that's, still, too complicated.

Wait a second, I forgot to cue the television huckster's voice.
But that's, still, too complicated!

We can do better!
To wit, a particle in Super-Position does not exist in the Real World. Once it exists in the Real World it will have a simple Position (Up or Down in the case of Spin) and not a Super-Position.

And (in my ever so humble opinion) the mathematics behind Quantum Mechanics is so very complicated; mainly, because they are trying to make sense of something that does not exist in the Real World.

Certainly, once that Spin hits Up, everything else zeroes out.

And until that Spin hits Up (or Down) it doesn't exist in any sense of the term you or I understand.

Super-Position is a modelling of things that Do Not Exist... AND NEVER WILL!

Spin is either Up or Down. It has never been observed in an in-between state.

Of course, I really don't know the states for spin. So, let me restate that last more... um, explicitly.

Quantum Values (like spin, charm, whatever) exist in a limited number of discrete states that can be enumerated. This is the quantum part of Quantum Mechanics. And what Super-Position does is model the probability between two or more of these states. But Reality is not a probability. Reality is what IS. So, we never observe probabilities (not directly, we only infer them), as we only observe discrete states.

Thus, Super-Position is another way of saying we don't know what state a particle is in... not just yet, anyhow.

It's a statement of ignorance... or if you think that's too aggressive, it's statement of fuzz and the unknown, The Chaos of the Universe... or The Humbleness of Man.

## Entanglement

So, we know what Super-Position is, now... or at least, what's relevant to this discussion. Meaning, Super-Position can be reduced to the notion of mind-boggling complex mathematical equations that link a potentiality to the Real World.

Can we have two potentialities that connect with each other (not through the Real World) but directly?

Yes!

That's Entanglement.

When the equations for two Quantum Particles interact and are dependent upon one another that state is referred to as Entanglement.

So, we have a bunch of functions that predict the letters of a person's first name:
``` f_name_char_one f_name_char_two f_name_char_three ```
And if `f_name_char_one(x)` equals B, then it is far more likely that `f_name_char_two(x)` equals R than, say, another B.

Thus, the resulting value of `f_name_char_one` effects all the other `f_name_char_xxx` functions. They are interrelated. They are dependent. They ultimately are referring to some larger shared construct. And for Quantum Equations this larger shared construct is (intended to be, anyway) a little thing I like to call Reality.

The point is: Quantum States can become Entangled.

And an assumption of (the current model of) Quantum Computing is that entire registers can become Entangled. They can all be pointed (linked, and/or entangled) together in unison, as they are put to work seeking (their part of) a solution to a common problem. And more importantly than that, since they are entangled, a change to the one, changes them all.

Now, I have serious doubts as to whether this is possible or not. I mean, it sounds like a highly unstable situation to me. But then, one could restate Reality as a Quantum Equation that the entire Universe is solving in lock step... so, um... it's a matter of perspective.

Anyhow, I don't think the registers will ever get to the 1030 range. But in the world of Theoretical Mathematics this is easy to assume.

Here, I'll do it for you:
``` Given an Entangled Register of size 1030: Then:   Stuff ```
See, mathematically it's easy to assume the execution of procedures that are not presently possible (and may never be possible) in the real world. But then, if we make that assumption, coolness results.

## Simultaneous Transforms

Remember all the way back at the beginning, I listed out the benefits of Quantum Computing. Well, we've covered all of them at this point outside of Simultaneous Transforms.

And we have sort of covered that one, as well. If two Quantum Particles are Entangled, then changing the one can be used to change the other. And if 1030 Quantum Particles are Entangled, then changing the one can be used to change the other 1030.

In pure mathematics, this would simply be a mapping: we have a known starting state (the input) and it maps to a known end point (the output). The input maps to the output. This is what functions do. And it is what mathematical operators do.
``` A + B = C ```
Is just common-speak for:
``` add(A, B) = C ```
Which can be further obscured into the realms of abstraction as:
``` add_a(B) = C ```
They are all the same thing. And we could do the same thing with multiplication or any other mathematical (or logical) function you could name.

Since we don't care about the exact function involved, we can abstract that away, too. Common symbols for this abstraction include ⊕ and ⊗.

So, if R is a Register, then we can write such things as:
``` R ⊕ R R1 ⊗ R2 ⊕(⊗(R)) ```
You're not supposed to understand what that means in any exacting detail, just that something happened.

I mean, something like `√R` might mean that I took the square root of the register element by element (leaving me with a register of size R, as opposed to a single scalar). But `⊕(⊗(R))` is (for the most) me having fun with symbols, while I try to convey the idea that something mysterious has happened to R.

If you're familiar with Matrices, then I view it as a convolve (a filter, if you will) operating over the entire Matrix. But this might not shed any light... for like, anyone.

Suffice to say, all of Classical Computing is made up of ones and zeroes and a few simple primitive functions that we use to change them about. Oddly, I don't know how many primitive functions are required. I wonder if anyone knows. Modern Assembly has upwards of 128 commands, 64 are core, 32 are non-redundant, and of the remaining, maybe only 4, 6, 8, or 16 are actually required. I think they claim circuit boards only require a NAND Gate. And Lambda Calculus likes to believe the world of mathematics can be summed up by something (sorry, but I can't remember the exact equation) along the lines of `λxy.x`.

That one equation makes a lot of assumptions about it's use... as do NAND Gates, and even those sixteen odd Assembly Language primitives. Of course, this web-page makes a lot of assumptions about not only your ability to read English but my kind of English. But I think one thing we can all agree on is that there are twenty-six letters in the English alphabet and along with those, ten numbers, and a handful of symbols, we can convey (or at least, try to convey) almost anything we want to each other.

Quantum Guys (as I'm not sure if they should be Quantum Scientists, Quantum Mathematicians, Quantum Theorists, or whatever) think they have the few primitives they need to reduce a register of size 1030 to something along the lines of:
``` 0101 1001 0001 0011 1100 1000 0001 ```
Which in truth is just random ones and zeroes but is intended to represent the answer to some extra-ordinarily complex question that we happen to be looking for (say, that one other planet out there that supports life, as that seems to be my example question of choice in this particular rant).

So, um... let me restate that, once again.

If we can work on a 1030 register as an organic whole, applying register wide transforms (mappings, functions, those ⊕ and ⊗ things), then even if it takes a million (or a million-billion) such mappings we are so far ahead of the game, it flips mathematical problem solving into a whole other universe... call it a Quantum Universe.

Or even more briefly, an image of size 10,000 by 5,000 takes a few seconds (in real time) to load on my computer and would completely crash this web-page (browsers are not made to handle images that large). But in the world of Quantum Computers that's a very small register (R). Then, if we want to apply a convolve-filter (blur, sharpen, etc.) to that image (change the pixels) in the Classical World we have to apply a given function (10,000 x 5,000 =) 50,000,000 times. It could take a while. But in the world of Quantum Computing (assuming the filter is one of the primitives) that's a single flop.

Now, it may, actually, take 10,000 primitive operations to compose the desired operation. But 10,000 is a way less than 50,000,000.

And there in a nutshell is the fourth and final speed up (theoretically) available to Quantum Computers: Register Wide Transforms (as opposed to element by element transforms done one element at a time).

In short:
```|a b c|     |r s t|
|d e f|  ⊕  |u v w|
|g h i|     |x y z|
```
Reduces to:
``` R1 ⊕ R2 ```
For arbitrarily sized registers.

So regardless of whether the register contains 9-Bits (per above) or 1030-Bits, the operation only takes a single clock cycle... call it a flop.

## Quantum Computers Kicking It

So, let's revisit that summary I posted way back in the abstract section of this (way longer than I expected) rant.
1. Very Large Registers
• I'll grant you a 1030 speed up.
• But it's only a Linear speed up.
• And I don't personally think registers will ever (like, ever) get that large.
2. Processor that runs at the Speed of Light
• I'll grant you a 1010 speed up.
• Or whatever the difference is between quantum vibrations and electrons on a wire.
• I will not be doing the math.
• It's still just Linear.
3. Bit Values that range from 0.0 to 1.0
• This is huge: a zillion-fold increase, perhaps changing the complexity dynamics of mathematics.
• Some fraction of this speed up is available to Analog Computers.
• Thus, Analog Computers offer the promise of reduced Computational Complexity for certain problem sets.
• Booyah!
4. Simultaneous Transforms across the entire Register
• The Holy Grail!
• The proper selection of primitives theoretically reduces the Computation Complexity of many problem sets.
• Similar primitives may be available to Analog Computers.
But as I've said, I have serious doubts whether Quantum Computers will ever live up to the hype. I question the physical possibility of very large registers. A failure rate as low as 1 in 1020, which is basically non-existent in the Classical World (things are not nearly so perfect), makes failure a certainty when registers expand to the size 1030-Bits.

On the other hand, I do believe an 8-Bit, 16-Bit, or 64-Bit Analog computer is imminently possible.

## The New Maths

A ways back I claimed:
``` ∞ > 2 ```
And that's OK.

But then, I followed that up with:
``` ∞ - 2 = ∞ ```
Which is not true.

I know, you noticed my mistake at the time, but you could see that I was on a roll, so didn't want to say anything. Well, now, let's talk about that little logistical error... briefly.

``` ∞ is that number which is greater than every other number, even itself. ```
I am tempted to then compare ∞ to itself (ala `∞ > ∞`, `∞ < ∞`, and `∞ <> ∞`), but such a comparison would be technically incorrect. Of course, the preceding was not a definition that was ever meant to be used in any algebraic formula. It's a philosophical statement more than a practical one.

Continuing on:
0
``` 0 is that number which is not equal to anything, not even itself. ∴ 0 ≠ 0 ≠ ∅ ≠ {} ```
Zero does not exist, so equating a nothingness to anything is clearly a bogus proposition... and likely explains why algebra makes so little sense to so many.

And with that little foray out of my system, I think it is time to move on.

## Analog Computers

If we allow Quantum Computers (that is to say, assume they are possible, because as far as I know, no one has ever made a working Quantum Computer) it seems fair to allow Analog Computers (the current state of which, I haven't a clue).

In short, at this point in time, both Quantum & Analog Computing requires a sort of leap (of faith, if you will) into the world of Science Fiction to talk about to any meaningful degree.

But, hey.

I'm just the guy to do it.

So, if you're looking for a really high performance Analog Computer, let me show you how it's done.

First, we'll need superconductivity. Eh, maybe you would not need it. But I would. So, if we are going to be doing this thing together (and you are kind enough to elect me team leader), we will need some sort of superconductive material... because that's the kind of ship I sail.

Now, if I were unto a god and I had a lump of superconductive material in my hand, I would probably roll it around into a ball... because, let me tell you, I am not the God of Pottery or Graven Images or what have you. A simple ball is about all I can manage.

So, I'm thinking a black ball (because that'll look cooler and black is easier for the CGI to render in the upcoming movie adaption of this webpage) about the size of a marble, which being made of superconductive material (clearly a viscous crystalline polymer, call it a ceramic glass) will be able to hold an arbitrary charge indefinitely.

And if I have not imprinted upon you the mathematical (and therefore) theoretical importance of infinity, let me just point out I just gave my single black marble infinity in spades. As a Perfect Superconductor (which my marble is), it's essentially a perpetual motion machine for electro-magnetic energy.

I get:
• Arbitrary Charge
• Arbitrary Internal Current
Please keep in mind, I'm just writing a Science Fiction Story, at this point. But between those two seemingly insignificant phrases, we get infinity as many times as we want it... along with the corresponding decrease in mathematical complexity (that decrease from NNN to NN for yea of the short attention span theater) that such a call to infinity implies... if you know, a call to infinity implies any such thing... even if we all know, that's where the real power of Quantum Computing was going to come from.

And yet, even as I say all that, I can already hear the static from the off-screen announcer's microphone turning on.
But wait! That's not all!
Yeah, this is SF, we want a good shot of the computer, something sexy, so rather than the one ball with Internal Wave Mechanics doing the heavy computational lifting (um, is there such a thing as Internal Wave Mechanics), we'll throw a couple hundred (or thousand) of these suckers (i.e. marbles) up in the air, stick them in a stasis field (or just do this entire exercise in Zero-G; Low Earth Orbit Computing, it's a'coming) and let them do their thing in a controlled environment where the inputs and outputs are done via Electromagnetic Waves (for point effects) and Fields (for, um, field effects) arbitrarily (a wonderful word when used in a theoretical context) changing the charge, field, and electron flow of any one (or all) of the marbles simultaneously... along with their trajectories and positions in space... because why the heck not? Also, I promised the boys back in CGI that I'd give them something to work with: namely, a chance to model those highly-polished reflective black marbles as they float this way and that, which will likely coalesce into the image of some poor sap's face in the penultimate scene of the upcoming cinematic adaptation of this very webpage (a point I may have mentioned before).

Penultimate: a three minute montage sequence wherein the boys in AI figure out who the bad guys are.
That's our target!
Ultimate: a twenty minute chase scene in which the bad guys are brought to justice, while I grow bored and wonder when they are going to get back to the good stuff.
Oh, a double shot to the head. Well, I got to admit, that was pretty good.
Thus, to reiterate and bring this around full circle my Analog Black Ball Computer has:
• Very Large Registers
• Well, upwards of a million (106) marbles seems possible.
• But more importantly, each marble has an infinite number of possible states.
• Of course, whether that's a countable level of infinity or non-countable infinity, I know not.
• Also, the position of the marble array as a whole has an infinite number of states.
• So, OK. Large Registers? Check!
• Speed of Light
• We're using electro-magnetic radiation for the internal state of those super high-tech marbles.
• So, check on that.
• Changes in marble positioning would flow much more slowly.
• But that's just the icing on the cake.
• Simultaneous Transforms
• Magnetic Fields will do the trick.
• So, check.
• And, hey! We're almost there!
• 0.0 to 1.0 Bit Values
• Yes! And, Yes!
• In fact, not only can the charge in each marble range between 0.0 volts and 1.0 volts
• But swirling electro-magnetic currents in each marble give us a function rather than a scalar for the bit value.
• Functional Bits!
• Hey, I coined a term!
• I will leave it as an exercise for the reader to determine exactly what it means...
As described, my Black Marble Box has infinitely more power than a standard computer (or at least, a lot-lot more); and once one considers that each marble could operate on the Quantum Level (because why the heck not) it trumps even the best of Quantum Computers (subsuming the lot in it's design specification, as it just did).

Yeah, most of this last is fanciful nonsense... but no more fanciful than a Quantum Computer that has yet to be made.

Besides, the point of this rant was not to design a working Analog Computer, but to show that it is a trivial matter (once one starts assuming infinities of precision) to construct an Analog Computer that will work similarly to a Quantum Computer.

In short, there is no mathematical reason why the speed-ups expected from Quantum Computers cannot be had by their Analog Computer counterparts. The limitations are imposed by the current hardware paradigm, not because the rules of reality fail to hold at the Quantum Level. I mean, if they work anywhere, them-there rules work there, as well.

next Brett Rants entry

Home Brett Rants Index

Floating Black Balls...

Analog Computing...

A Report in the Minority...

that
Phillip K. Dick