Credit: WolframAlpha

What happens if you take four of today's most popular buzzwords and string them together? Does the result mean anything? Given that today is April 1 (as well as being Easter Sunday), I thought it'd be fun to explore this. Think of it as an Easter egg... from which something interesting just might hatch. And to make it clear: while I'm fooling around in stringing the buzzwords together, the details of what I'll say here are perfectly real.

Credit: WolframAlpha

But before we can really launch into talking about the whole string of buzzwords, let's discuss some of the background to each of the buzzwords on their own.


Saying something is "quantum" sounds very modern. But actually, quantum mechanics is a century old. And over the course of the past century, it's been central to understanding and calculating lots of things in the physical sciences. But even after a century, "truly quantum" technology hasn't arrived. Yes, there are things like lasers and MRIs and atomic force microscopes that rely on quantum phenomena, and needed quantum mechanics in order to be invented. But when it comes to the practice of engineering, what's done is still basically all firmly classical, with nothing quantum about it.

Today, though, there's a lot of talk about quantum computing, and how it might change everything. I actually worked on quantum computing back in the early 1980s (so, yes, it's not that recent an idea). And I have to say, I was always a bit skeptical about whether it could ever really work—or whether any "quantum gains" one might get would be counterbalanced by inefficiencies in measuring what was going on.

But in any case, in the past 20 years or so there's been all sorts of nice theoretical work on formulating the idea of quantum circuits and quantum computing. Lots of things have been done with the Wolfram Language, including an ongoing project of ours to produce a definitive symbolic way of representing quantum computations. But so far, all we can ever do is calculate about quantum computations, because the Wolfram Language itself just runs on ordinary, classical computers.

There are companies that have built what they say are (small) true quantum computers. And actually, we've been hoping to hook the Wolfram Language up to them, so we can implement a QuantumEvaluate function. But so far, this hasn't happened. So I can't really vouch for what QuantumEvaluate will (or will not) do.

But the big idea is basically this. In ordinary classical physics, one can pretty much say that definite things happen in the world. A billiard ball goes in this direction, or that. But in any particular case, it's a definite direction. In quantum mechanics, though, the idea is that an electron, say, doesn't intrinsically go in a particular, definite direction. Instead, it essentially goes in all possible directions, each with a particular amplitude. And it's only when you insist on measuring where it went that you'll get a definite answer. And if you do many measurements, you'll just see probabilities for it to go in each direction.

Well, what quantum computing is trying to do is somehow to make use of the "all possible directions" idea in order to in effect get lots of computations done in parallel. It's a tricky business, and there are only a few types of problems where the theory's been worked out—the most famous being integer factoring. And, yes, according to the theory, a big quantum computer should be able to factor a big integer fast enough to make today's cryptography infrastructure implode. But the only thing anyone so far even claims to have built along these lines is a tiny quantum computer—that definitely can't yet do anything terribly interesting.

But, OK, so one critical aspect of quantum mechanics is that there can be interference between different paths that, say, an electron can take. This is mathematically similar to the interference that happens in light, or even in water waves, just in classical physics. In quantum mechanics, though, there's supposed to be something much more intrinsic about the interference, leading to the phenomenon of entanglement, in which one basically can't ever "see the wave that's interfering"—only the effect.

In computing, though, we're not making use of any kind of interference yet. Because (at least in modern times) we're always trying to deal with discrete bits—while the typical phenomenon of interference (say in light) basically involves continuous numbers. And my personal guess is that optical computing—which will surely come—will succeed in delivering some spectacular speedups. It won't be truly "quantum", though (though it might be marketed like that). (For the technically minded, it's a complicated question how computation-theoretic results apply to continuous processes like interference-based computing.)


A decade ago computers didn't have any systematic way to tell whether a picture was of an elephant or a teacup. But in the past five years, thanks to neural networks, this has basically become easy. (Interestingly, the image identifier we made three years ago remains basically state of the art.)

So what's the big idea? Well, back in the 1940s people started thinking seriously about the brain being like an electrical machine. And this led to mathematical models of "neural networks"—which were proved to be equivalent in computational power to mathematical models of digital computers. Over the years that followed, billions of actual digital electronic computers were built. And along the way, people (including me) experimented with neural networks, but nobody could get them to do anything terribly interesting. (Though for years they were quietly used for things like optical character recognition.)

But then, starting in 2012, a lot of people suddenly got very excited, because it seemed like neural nets were finally able to do some very interesting things, at first especially in connection with images.

So what happened? Well, a neural net basically corresponds to a big mathematical function, formed by connecting together lots of smaller functions, each involving a certain number of parameters ("weights"). At the outset, the big function basically just gives random outputs. But the way the function is set up, it's possible to "train the neural net" by tuning the parameters inside it so that the function will give the outputs one wants.

It's not like ordinary programming where one explicitly defines the steps a computer should follow. Instead, the idea is just to give examples of what one wants the neural net to do, and then to expect it to interpolate between them to work out what to do for any particular input. In practice one might show a bunch of images of elephants, and a bunch of images of teacups, and then do millions of little updates to the parameters to get the network to output "elephant" when it's fed an elephant, and "teacup" when it's fed a teacup.

But here's the crucial idea: the neural net is somehow supposed to generalize from the specific examples it's shown—and it's supposed to say that anything that's "like" an elephant example is an elephant, even if its particular pixels are quite different. Or, said another way, there are lots of images that might be fed to the network that are in the "basin of attraction" for "elephant" as opposed to "teacup". In a mechanical analogy, one might say that there are lots of places water might fall on a landscape, while still ending up flowing to one lake rather than another.

At some level, any sufficiently complicated neural net can in principle be trained to do anything. But what's become clear is that for lots of practical tasks (that turn out to overlap rather well with some of what our brains seem to do easily) it's realistic with feasible amounts of GPU time to actually train neural networks with a few million elements to do useful things. And, yes, in the Wolfram Language we've now got a rather sophisticated symbolic framework for training and using neural networks—with a lot of automation (that itself uses neural nets) for everything.


The word "blockchain" was first used in connection with the invention of Bitcoin in 2008. But of course the idea of a blockchain had precursors. In its simplest form, a blockchain is like a ledger, in which successive entries are coded in a way that depends on all previous entries.

Crucial to making this work is the concept of hashing. Hashing has always been one of my favorite practical computation ideas (and I even independently came up with it when I was about 13 years old, in 1973). What hashing does is to take some piece of data, like a text string, and make a number (say between 1 and a million) out of it. It does this by "grinding up the data" using some complicated function that always gives the same result for the same input, but will almost always give different results for different inputs. There's a function called Hash in the Wolfram Language, and for example applying it to the previous paragraph of text gives 8643827914633641131.

OK, but so how does this relate to blockchain? Well, back in the 1980s people invented "cryptographic hashes" (and actually they're very related to things I've done on computational irreducibility). A cryptographic hash has the feature that while it's easy to work out the hash for a particular piece of data, it's very hard to find a piece of data that will generate a given hash.

So let's say you want to prove that you created a particular document at a particular time. Well, you could compute a hash of that document, and publish it in a newspaper (and I believe Bell Labs actually used to do this every week back in the 1980s). And then if anyone ever says "no, you didn't have that document yet" on a certain date, you can just say "but look, its hash was already in every copy of the newspaper!".

The idea of a blockchain is that one has a series of blocks, with each containing certain content, together with a hash. And then the point is that the data from which that hash is computed is a combination of the content of the block, and the hash of the preceding block. So this means that each block in effect confirms everything that came before it on the blockchain.

In cryptocurrencies like Bitcoin the big idea is to be able to validate transactions, and, for example, be able to guarantee just by looking at the blockchain that nobody has spent the same bitcoin twice.

How does one know that the blocks are added correctly, with all their hashes computed, etc.? Well, the point is that there's a whole decentralized network of thousands of computers around the world that store the blockchain, and there are lots of people (well, actually not so many in practice these days) competing to be the one to add each new block (and include transactions people have submitted that they want in it).

The rules are (more or less) that the first person to add a block gets to keep the fees offered on the transactions in it. But each block gets "confirmed" by lots of people including this block in their copy of the blockchain, and then continuing to add to the blockchain with this block in it.

In the latest version of the Wolfram Language, BlockchainBlockData[-1, BlockchainBase->"Bitcoin"] gives a symbolic representation of the latest block that we've seen be added to the Bitcoin blockchain. And by the time maybe 5 more blocks have been added, we can be pretty sure everyone's satisfied that the block is correct. (Yes, there's an analogy with measurement in quantum mechanics here, which I'll be talking about soon.)

Traditionally, when people keep ledgers, say of transactions, they'll have one central place where a master ledger is maintained. But with a blockchain the whole thing can be distributed, so you don't have to trust any single entity to keep the ledger correct.

And that's led to the idea that cryptocurrencies like Bitcoin can flourish without central control, governments or banks involved. And in the last couple of years there's been lots of excitement generated by people making large amounts of money speculating on cryptocurrencies.

But currencies aren't the only thing one can use blockchains for, and Ethereum pioneered the idea that in addition to transactions, one can run arbitrary computations at each node. Right now with Ethereum the results of each computation are confirmed by being run on every single computer in the network, which is incredibly inefficient. But the bigger point is just that computations can be running autonomously on the network. And the computations can interact with each other, defining "smart contracts" that run autonomously, and say what should happen in different circumstances.

Pretty much any nontrivial smart contract will eventually need to know about something in the world ("did it rain today?", "did the package arrive?", etc.), and that has to come from off the blockchain—from an "oracle". And it so happens (yes, as a result of a few decades of work) that our Wolfram Knowledgebase, which powers Wolfram|Alpha, etc., provides the only realistic foundation today for making such oracles.


Back in the 1950s, people thought that pretty much anything human intelligence could do, it'd soon be possible to make artificial (machine) intelligence do better. Of course, this turned out to be much harder than people expected. And in fact the whole concept of "creating artificial intelligence" pretty much fell into disrepute, with almost nobody wanting to market their systems as "doing AI".

But about five years ago—particularly with the unexpected successes in neural networks—all that changed, and AI was back, and cooler than ever.

What is AI supposed to be, though? Well, in the big picture I see it as being the continuation of a long trend of automating things that humans previously had to do for themselves—and in particular doing that through computation. But what makes a computation an example of AI, and not just, well, a computation?

I've built a whole scientific and philosophical structure around something I call the Principle of Computational Equivalence, that basically says that the universe of possible computations—even done by simple systems—is full of computations that are as sophisticated as one can ever get, and certainly as our brains can do.

In doing engineering, and in building programs, though, there's been a tremendous tendency to try to prevent anything too sophisticated from happening—and to set things up so that the systems we build just follow exactly steps we can foresee. But there's much more to computation than that, and in fact I've spent much of my life building systems that make use of this.

Wolfram|Alpha is a great example. Its goal is to take as much knowledge about the world as possible, and make it computable, then to be able to answer questions as expertly as possible about it. Experientially, it "feels like AI", because you get to ask it questions in natural language like a human, then it computes answers often with unexpected sophistication.

Most of what's inside Wolfram|Alpha doesn't work anything like brains probably do, not least because it's leveraging the last few hundred years of formalism that our civilization has developed, that allow us to be much more systematic than brains naturally are.

Some of the things modern neural nets do (and, for example, our machine learning system in the Wolfram Language does) perhaps work a little more like brains. But in practice what really seems to make things "seem like AI" is just that they're operating on the basis of sophisticated computations whose behavior we can't readily understand.

These days the way I see it is that out in the computational universe there's amazing computational power. And the issue is just to be able to harness that for useful human purposes. Yes, "an AI" can go off and do all sorts of computations that are just as sophisticated as our brains. But the issue is: can we align what it does with things we care about doing?

And, yes, I've spent a large part of my life building the Wolfram Language, whose purpose is to provide a computational communication language in which humans can express what they want in a form suitable for computation. There's lots of "AI power" out there in the computational universe; our challenge is to harness it in a way that's useful to us.

Oh, and we want to have some kind of computational smart contracts that define how we want the AIs to behave (e.g. "be nice to humans"). And, yes, I think the Wolfram Language is going to be the right way to express those things, and build up the "AI constitutions" we want.

Common Themes

At the outset, it might seem as if "quantum," "neural," "blockchain" and "AI" are all quite separate concepts, without a lot of commonality. But actually it turns out that there are some amazing common themes.

One of the strongest has to do with complexity generation. And in fact, in their different ways, all the things we're talking about rely on complexity generation.

What do I mean by complexity generation? One day I won't have to explain this. But for now I probably still do. And somehow I find myself always showing the same picture—of my all-time favorite science discovery, the rule 30 automaton. Here it is:

Credit: WolframAlpha

And the point here is that even though the rule (or program) is very simple, the behavior of the system just spontaneously generates complexity, and apparent randomness. And what happens is complicated enough that it shows what I call "computational irreducibility", so that you can't reduce the computational work needed to see how it will behave: you essentially just have to follow each step to find out what will happen.

There are all sorts of important phenomena that revolve around complexity generation and computational irreducibility. The most obvious is just the fact that sophisticated computation is easy to get—which is in a sense what makes something like AI possible.

But OK, how does this relate to blockchain? Well, complexity generation is what makes cryptographic hashing possible. It's what allows a simple algorithm to make enough apparent randomness to successfully be used as a cryptographic hash.

In the case of something like Bitcoin, there's another connection too: the protocol needs people to have to make some investment to be able to add blocks to the blockchain, and the way this is achieved is (bizarrely enough) by forcing them to do irreducible computations that effectively cost computer time.

What about neural nets? Well, the very simplest neural nets don't involve much complexity at all. If one drew out their "basins of attraction" for different inputs, they'd just be simple polygons. But in useful neural nets the basins of attractions are much more complicated.

It's most obvious when one gets to recurrent neural nets, but it happens in the training process for any neural net: there's a computational process that effectively generates complexity as a way to approximate things like the distinctions ("elephant" vs. "teacup") that get made in the world.

Alright, so what about quantum mechanics? Well, quantum mechanics is at some level full of randomness. It's essentially an axiom of the traditional mathematical formalism of quantum mechanics that one can only compute probabilities, and that there's no way to "see under the randomness".

I personally happen to think it's pretty likely that that's just an approximation, and that if one could get "underneath" things like space and time, we'd see how the randomness actually gets generated.

But even in the standard formalism of quantum mechanics, there's a kind of complementary place where randomness and complexity generation is important, and it's in the somewhat mysterious process of measurement.

Let's start off by talking about another phenomenon in physics: the Second Law of Thermodynamics, or Law of Entropy Increase. This law says that if you start, for example, a bunch of gas molecules in a very orderly configuration (say all in one corner of a box), then with overwhelming probability they'll soon randomize (and e.g. spread out randomly all over the box). And, yes, this kind of trend towards randomness is something we see all the time.

But here's the strange part: if we look at the laws for, say, the motion of individual gas molecules, they're completely reversible—so just as they say that the molecules can randomize themselves, so also they say that they should be able to unrandomize themselves.

But why do we never see that happen? It's always been a bit mysterious, but I think there's a clear answer, and it's related to complexity generation and computational irreducibility. The point is that when the gas molecules randomize themselves, they're effectively encrypting the initial conditions they were given.

It's not impossible to place the gas molecules so they'll unrandomize rather than randomize; it's just that to work out how to do this effectively requires breaking the encryption—or in essence doing something very much like what's involved in Bitcoin mining.

OK, so how does this relate to quantum mechanics? Well, quantum mechanics itself is fundamentally based on probability amplitudes, and interference between different things that can happen. But our experience of the world is that definite things happen. And the bridge from quantum mechanics to this involves the rather "bolted-on" idea of quantum measurement.

The notion is that some little quantum effect ("the electron ends up with spin up, rather than down") needs to get amplified to the point where one can really be sure what happened. In other words, one's measuring device has to make sure that the little quantum effect associated with one electron cascades so that it's spread across lots and lots of electrons and other things.

And here's the tricky part: if one wants to avoid interference being possible (so we can really perceive something "definite" as having happened), then one needs to have enough randomness that things can't somehow equally well go backwards—just like in thermodynamics.

So even though pure quantum circuits as one imagines them for practical quantum computers typically have a sufficiently simple mathematical structure that they (presumably) don't intrinsically generate complexity, the process of measuring what they do inevitably must generate complexity. (And, yes, it's a reasonable question whether that's in some sense where the randomness one sees "really" comes from... but that's a different story.)

Reversibility, Irreversibility and More

Reversibility and irreversibility are a strangely common theme, at least between "quantum", "neural" and "blockchain". If one ignores measurement, a fundamental feature of quantum mechanics is that it's reversible. What this means is that if one takes a quantum system, and lets it evolve in time, then whatever comes out one will always, at least in principle, be able to take and run backwards, to precisely reproduce where one started from.

Typical computation isn't reversible like that. Consider an OR gate, that might be a basic component in a computer. In p OR q, the result will be true if either p or q is true.  But just knowing that the result is "true", you can't figure out which of p and q (or both) is true. In other words, the OR operation is irreversible: it doesn't preserve enough information for you to invert it.

In quantum circuits, one uses gates that, say, take two inputs (say p and q), and give two outputs (say p' and q'). And from those two outputs one can always uniquely reproduce the two inputs.

OK, but now let's talk about neural nets. Neural nets as they're usually conceived are fundamentally irreversible. Here's why. Imagine (again) that you make a neural network to distinguish elephants and teacups. To make that work, a very large number of different possible input images all have to map, say, to "elephant". It's like the OR gate, but more so. Just knowing the result is "elephant" there's no unique way to invert the computation. And that's the whole point: one wants anything that's enough like the elephant pictures one showed to still come out as "elephant"; in other words, irreversibility is central to the whole operation of at least this kind of neural net.

So, OK, then how could one possibly make a quantum neural net? Maybe it's just not possible. But if so, then what's going on with brains? Because brains seem to work very much like neural nets. And yet brains are physical systems that presumably follow quantum mechanics. So then how are brains possible?

At some level the answer has to do with the fact that brains dissipate heat. Well, what is heat? Microscopically, heat is the random motion of things like molecules. And one way to state the Second Law of Thermodynamics (or the Law of Entropy Increase) is that under normal circumstances those random motions never spontaneously organize themselves into any kind of systematic motion. In principle all those molecules could start moving in just such a way as to turn a flywheel. But in practice nothing like that ever happens. The heat just stays as heat, and doesn't spontaneously turn into macroscopic mechanical motion.

OK, but so let's imagine that microscopic processes involving, say, collisions of molecules, are precisely reversible—as in fact they are according to quantum mechanics. Then the point is that when lots of molecules are involved, their motions can get so "encrypted" that they just seem random. If one could look at all the details, there'd still be enough information to reverse everything. But in practice one can't do that, and so it seems like whatever was going on in the system has just "turned into heat".

So then what about producing "neural net behavior"? Well, the point is that while one part of a system is, say, systematically "deciding to say elephant", the detailed information that would be needed to go back to the initial state is getting randomized, and turning into heat.

To be fair, though, this is glossing over quite a bit. And in fact I don't think anyone knows how one can actually set up a quantum system (say a quantum circuit) that behaves in this kind of way. It'd be pretty interesting to do so, because it'd potentially tell us a lot about the quantum measurement process.

To explain how one goes from quantum mechanics in which everything is just an amplitude, to our experience of the world in which definite things seem to happen, people sometimes end up trying to appeal to mystical features of consciousness. But the point about a quantum neural net is that it's quantum mechanical, yet it "comes to definite conclusions" (e.g. elephant vs. teacup).

Is there a good toy model for such a thing? I suspect one could create one from a quantum version of a cellular automaton that shows phase transition behavior—actually not unlike the detailed mechanics of a real quantum magnetic material. And what will be necessary is that the system has enough components (say spins) that the "heat" needed to compensate for its apparent irreversible behavior will stay away from the part where the irreversible behavior is observed.

Let me make a perhaps slightly confusing side remark. When people talk about "quantum computers", they are usually talking about quantum circuits that operate on qubits (quantum analog of binary bits). But sometimes they actually mean something different: they mean quantum annealing devices.

Imagine you've got a bunch of dominoes and you're trying to arrange them on the plane so that some matching condition associated with the markings on them is always satisfied. It turns out this can be a very hard problem. It's related to computational irreducibility (and perhaps to problems like integer factoring). But in the end, to find out, say, the configuration that does best in satisfying the matching condition everywhere, one may effectively have to essentially just try out all possible configurations, and see which one works best.

Well, OK, but let's imagine that the dominoes were actually molecules, and the matching condition corresponds to arranging molecules to minimize energy. Then the problem of finding the best overall configuration is like the problem of finding the minimum energy configuration for the molecules, which physically should correspond to the most stable solid structure that can be formed from the molecules.

And, OK, it might be hard to compute that. But what about an actual physical system? What will the molecules in it actually do when one cools it down? If it's easy for the molecules to get to the lowest energy configuration, they'll just do it, and one will have a nice crystalline solid.

People sometimes assume that "the physics will always figure it out", and that even if the problem is computationally hard, the molecules will always find the optimal solution. But I don't think this is actually true—and I think what instead will happen is that the material will turn mushy, not quite liquid and not quite solid, at least for a long time.

Still, there's the idea that if one sets up this energy minimization problem quantum mechanically, then the physical system will be successful at finding the lowest energy state. And, yes, in quantum mechanics it might be harder to get stuck in local minima, because there is tunneling, etc.

But here's the confusing part: when one trains a neural net, one ends up having to effectively solve minimization problems like the one I've described ("which values of weights make the network minimize the error in its output relative to what one wants?"). So people end up sometimes talking about "quantum neural nets", meaning domino-like arrays which are set up to have energy minimization problems that are mathematically equivalent to the ones for neural nets.

(Yet another connection is that convolutional neural nets—of the kind used for example in image recognition—are structured very much like cellular automata, or like dynamic spin systems. But in training neural nets to handle multiscale features in images, one seems to end up with scale invariance similar to what one sees at critical points in spin systems, or their quantum analogs, as analyzed by renormalization group methods.)

OK, but let's return to our whole buzzword string. What about blockchain? Well, one of the big points about a blockchain is in a sense to be as irreversible as possible. Once something has been added to a blockchain, one wants it to be inconceivable that it should ever be reversed out.

How is that achieved? Well, it's curiously similar to how it works in thermodynamics or in quantum measurement. Imagine someone adds a block to their copy of a blockchain. Well, then the idea is that lots of other people all over the world will make their own copies of that block on their own blockchain nodes, and then go on independently adding more blocks from there.

Bad things would happen if lots of the people maintaining blockchain nodes decided to collude to not add a block, or to modify it, etc. But it's a bit like with gas molecules (or degrees of freedom in quantum measurement). By the time everything is spread out among enough different components, it's extremely unlikely that it'll all concentrate together again to have some systematic effect.

Of course, people might not be quite like gas molecules (though, frankly, their observed aggregate behavior, e.g. jostling around in a crowd, is often strikingly similar). But all sorts of things in the world seem to depend on an assumption of randomness. And indeed, that's probably necessary to maintain stability and robustness in markets where trading is happening.

OK, so when a blockchain tries to ensure that there's a "definite history", it's doing something very similar to what a quantum measurement has to do. But just to close the loop a little more, let's ask what a quantum blockchain might be like.

Yes, one could imagine using quantum computing to somehow break the cryptography in a standard blockchain. But the more interesting (and in my view, realistic) possibility is to make the actual operation of the blockchain itself be quantum mechanical.

In a typical blockchain, there's a certain element of arbitrariness in how blocks get added, and who gets to do it. In a "proof of work" scheme (as used in Bitcoin and currently also Ethereum), to find out how to add a new block one searches for a "nonce"—a number to throw in to make a hash come out in a certain way. There are always many possible nonces (though each one is hard to find), and the typical strategy is to search randomly for them, successively testing each candidate.

But one could imagine a quantum version in which one is in effect searching in parallel for all possible nonces, and as a result producing many possible blockchains, each with a certain quantum amplitude. And to fill out the concept, imagine that—for example in the case of Ethereum—all computations done on the blockchain were reversible quantum ones (achieved, say, with a quantum version of the Ethereum Virtual Machine).

But what would one do with such a blockchain? Yes, it would be an interesting quantum system with all kinds of dynamics. But to actually connect it to the world, one has get data on and off the blockchain—or, in other words, one has to do a measurement. And the act of that measurement would in effect force the blockchain to pick a definite history.

OK, so what about a "neural blockchain"? At least today, by far the most common strategy with neural nets is first to train them, then to put them to work. (One can train them "passively" by just feeding them a fixed set of examples, or one can train them "actively" by having them in effect "ask" for the examples they want.) But by analogy with people, neural nets can also have "lifelong learning", in which they're continually getting updated based on the "experiences" they're having.

So how do the neural nets record these experiences? Well, by changing various internal weights. And in some ways what happens is like what happens with blockchains.

Science fiction sometimes talks about direct brain-to-brain transfer of memories. And in a neural net context this might mean just taking a big block of weights from one neural net and putting it into another. And, yes, it can work well to transfer definite layers in one network to another (say to transfer information on what features of images are worth picking out). But if you try to insert a "memory" deep inside a network, it's a different story. Because the way a memory is represented in a network will depend on the whole history of the network.

It's like in a blockchain: you can't just replace one block and expect everything else to work. The whole thing has been knitted into the sequence of things that happen through time. And it's the same thing with memories in neural nets: once a memory has formed in a certain way, subsequent memories will be built on top of this one.

Bringing It Together

At the outset, one might have thought that "quantum", "neural" and "blockchain" (not to mention "AI") didn't have much in common (other than that they're current buzzwords)—and that in fact they might in some sense be incompatible. But what we've seen is that actually there are all sorts of connections between them, and all sorts of fundamental phenomena that are shared between systems based on them.

So what might a "quantum neural blockchain AI" ("QNBAI") be like?

Let's look at the pieces again. A single blockchain node is a bit like a single brain, with a definite memory. But in a sense the whole blockchain network becomes robust through all the interactions between different blockchain nodes. It's a little like how human society and human knowledge develop.

Let's say we've got a "raw AI" that can do all sorts of computation. Well, the big issue is whether we can find a way to align what it can do with things that we humans think we want to do. And to make that alignment, we essentially have to communicate with the AI at a level of abstraction that transcends the details of how it works: in effect, we have to have some symbolic language that we both understand, and that for example AI can translate into the details of how it operates.

Inside the AI it may end up using all kinds of "concepts" (say to distinguish one class of images from another). But the question is whether those concepts are ones that we humans in a sense "culturally understand". In other words, are those concepts (and, for example, the words for them) ones that there's a whole widely understood story about?

In a sense, concepts that we humans find useful for communication are ones that have been used in all sorts of interactions between different humans. The concepts become robust by being "knitted into" the thought patterns of many interacting brains, a bit like the data put on a blockchain becomes a robust part of "collective blockchain memory" through the interactions between blockchain nodes.

OK, so there's something strange here. At first it seemed like QNBAIs would have to be something completely exotic and unfamiliar (and perhaps impossible). But somehow as we go over their features they start to seem awfully familiar—and actually awfully like us.

Yup, according to physics, we know we are "quantum". Neural nets capture many core features of how our brains seem to work. Blockchain—at least as a general concept—is somehow related to individual and societal memory. And AI, well, AI in effect tries to capture what's aligned with human goals and intelligence in the computational universe—which is also what we're doing.

OK, so what's the closest thing we know to a QNBAI? Well, it's probably all of us!

Maybe that sounds crazy. I mean, why should a string of buzzwords from 2018 connect like that? Well, at some level perhaps there's an obvious answer: we tend to create and study things that are relevant to us, and somehow revolve around us. And, more than that, the buzzwords of today are things that are somehow just within the scope that we can now think about with the concepts we've currently developed--and that are somehow connected through them.

I must say that when I chose these buzzwords I had no idea they'd connect at all. But as I've tried to work through things in writing this, it's been remarkable how much connection I've found. And, yes, in a fittingly bizarre end to a somewhat bizarre journey, it does seem to be the case that a string plucked from today's buzzword universe has landed very close to home. And maybe in the end—at least in some sense—we are our buzzwords!