So I want to talk today about an idea. It's a big idea.
Actually I think it'll eventually be seen as probably the single biggest idea that's emerged in the past century.
It's the idea of computation.
Now of course that idea has brought us all the computer technology we have today, and so on.
But there's a lot more to computation than that.
It's really a very deep, very powerful, very fundamental idea.
Whose effects we've only just started to see.
Well, I myself spent the past 30 years working on three large projects that try to really take the idea of computation seriously.
So, I started off at a young age as a physicist, using computers as tools.
Then I started drilling down. Thinking about the computations I might want to do.
And trying to figure out what primitives they could be built from. And how they could be automated as much as possible.
Eventually I created a whole structure—based on symbolic programming—that let me build Mathematica.
And for the past 23 years, at an increasing rate, we've been pouring more and more ideas and capabilities and so on into Mathematica.
And I'm happy to say that's led to many good things in R&D, and education, and lots of other areas.
Well, I have to admit that I also had a selfish reason for building Mathematica.
I wanted to use it myself, a bit like Galileo used his telescope 400 years ago.
But I wanted to look not at the astronomical universe, but at the computational universe.
We normally think of programs as being complicated things that we build for very specific purposes.
But what about the space of all possible programs?
Here's a representation of a really simple program.
So, if we run this program, this is what we get.
So, let's try changing the rule for this program a little bit.
Now we get another result.
Still very simple.
Try changing it again.
We get something a little bit more complicated.
But if we keep running this for a while, we find out that although the pattern we get is very intricate, it has very regular structure.
So the question is: can anything else happen?
Well, we can do a little experiment; let's just do a little Mathematica experiment to try and find out.
Let's just run all possible programs of the particular type that we're looking at—they're called cellular automata.
And you can see a lot of diversity in their behavior here.
Most of them do very simple things.
But if you look along all these different pictures, at rule number 30, you start to see something interesting going on.
So, let's take a closer look at rule number 30, here.
So here it is.
We're just following this very simple rule at the bottom, here.
But we're getting all this amazing stuff.
It's not at all what we're used to.
And I must say that when I first saw this it came as a huge shock to my intuition.
And in fact to understand it I eventually had to create a whole new kind of science.
This science is different—more general—than the mathematics-based science we've had for the past 300 or so years.
You know, it's always seemed like a big mystery how nature—seemingly so effortlessly—manages to produce so much that seems to us so complex.
Well, I think we've found its secret.
It's just sampling what's out there in the computational universe.
And quite often getting things like rule 30. Or like this.
Knowing that starts to explain a lot of longstanding mysteries in science.
It also brings up new issues, though. Like computational irreducibility.
We're used to having science let us predict things.
But something like this is fundamentally irreducible. The only way to find its outcome is effectively just to watch it evolve.
It's connected to what I call the Principle of Computational Equivalence.
Which tells us that even incredibly simple systems can do computations as sophisticated as anything.
It doesn't take lots of technology, or biological evolution, to be able to do arbitrary computation.
It's just something that happens naturally, all over the place.
Things with rules as simple as these can do it.
Well this has deep implications.
About the limits of science. About predictability and controllability of things like biological processes, or economies.
About intelligence in the universe. About questions like free will. And about creating technology.
You know, in working on this science for many years, I kept on wondering: what will be its first killer app?
Ever since I was a kid I'd been thinking about systematizing knowledge, and somehow making it computable.
People like Leibniz had wondered about that too—300 years earlier.
But I'd always assumed that to make progress I'd essentially have to replicate a whole brain.
Well, then I got to thinking: this scientific paradigm of mine suggests something different.
And by the way, I've now got huge computation capabilities in Mathematica.
And I'm a CEO with some worldly resources to do large, seemingly crazy projects.
So I decided to just try to see just how much of the systematic knowledge out there in the world we can make computable.
It's been a very big, very complex project that I wasn't sure was going to work at all.
But I'm happy say it's actually going really well.
And last year we were able to release the first website version of Wolfram|Alpha.
Its purpose is to be a serious knowledge engine—that computes answers to questions.
So, let's give it a try. Let's start off with something really easy and hope for the best.
Very good. OK. So far, so good...
Let's try something a little bit harder. Let's do some mathy thing and with luck it'll work out the answer and try and tell us some interesting things about related math.
We could ask it something about the real world. Let's say, what's the GDP of Spain?
And it should be able to tell us that.
Now we can compute something related to this. Let's say the GDP of Spain divided by the revenue of Microsoft.
The idea is that we can type this kind of question in however we think of it.
Let's try asking a health-related question:
Let's say we have a lab finding that we have an LDL of 140 for a male aged 50. So let's type that in.
Or let's try asking about the International Space Station.
And what's happening here is that Wolfram|Alpha is not just looking up something. It's computing in real time where the International Space Station is right now, at this moment, how fast it's going and so on.
So, Wolfram|Alpha knows about lots and lots of kinds of things. It's got by now, a pretty good coverage of everything you might find in a standard reference library and so on.
But the goal is to go much further and very broadly to democratize all of this kind of knowledge.
And to try and be an authoritative source in all areas.
To be able to compute answers to specific questions people have. Not by searching what people have written about them before.
But by using built-in knowledge to compute fresh new answers to specific questions.
Now, of course Wolfram|Alpha is a monumentally huge, long-term project, with lots of challenges.
For a start, one has to curate a zillion different sources of facts and data.
And we've built quite a pipeline of Mathematica automation and human domain experts for doing this.
But that's just the beginning. Given raw facts or data, to actually answer questions one has to compute.
One has to implement all those methods and models and algorithms and so on that science and other areas have built up over the centuries.
Well, even starting from Mathematica, this is still a huge amount of work.
So far there are about 8 million lines of Mathematica code in Wolfram|Alpha, built by experts from many, many different fields.
Well, a crucial idea of Wolfram|Alpha is that you can just ask it questions using ordinary human language.
Which means that we've got to be able to take all those strange utterances that people type into the input field, and understand them.
And I must say that I thought that that step might just be plain impossible.
But two big things happened.
First, a bunch of new ideas about linguistics that came from studying the computational universe.
And second, the realization that having actual computable knowledge completely changes how one can set about understanding language.
And of course, now, with Wolfram|Alpha actually out in the wild, we can learn from its actual usage.
And in fact there's been an interesting co-evolution going on between Wolfram|Alpha and its human users.
And it's really encouraging: right now, if we look at web queries, more than 80% of them get handled successfully the first time.
And if you look at things like the iPhone app, the fraction is considerably larger.
So, I'm pretty pleased with it all.
But in many ways, we're still at the very beginning with Wolfram|Alpha.
I mean, everything is scaling up very nicely, and we're getting more confident.
You can expect to see Wolfram|Alpha technology showing up in more and more places.
Working both with this kind of public data, like on the website—and with private knowledge, for people, and companies, and so on.
You know, I've realized that Wolfram|Alpha actually gives one a whole new kind of computing—that one can call knowledge-based computing.
In which one's starting not just from raw computation, but from a vast amount of built-in knowledge.
And when one does that, one really changes the economics of delivering computational things, whether it's on the web or elsewhere.
You know, we have a fairly interesting situation right now.
On the one hand, we have Mathematica, with its precise formal language.
And a huge network of carefully designed capabilities.
Able to get a lot done in just a few lines. Let me show you a couple of examples here.
So, here's sort of a trivial piece of Mathematica programming.
Here's something where we're integrating a bunch of different capabilities.
Here we'll just create in this line a little user interface that allows us to do something fun there.
If we go on, that's a slightly more complicated program that's now doing all sorts of algorithmic things and creating a user interface and so on.
It's all very precise stuff. It's a precise specification with a precise formal language that causes Mathematica to know what to do here.
But then, on the other hand we have Wolfram|Alpha, with the messiness of the world and human language and so on built into it.
So what happens when you put these together? I think it's actually rather wonderful.
With Wolfram|Alpha inside Mathematica, you can for example make precise programs that call on real-world data.
Here's a really simple example.
You can also just give vague input, then have Wolfram|Alpha try and figure out what you're talking about.
And I think the most exciting thing about this is that it really gives one the chance to democratize programming.
I mean, anyone will just be able to say what they want in plain language.
Then Wolfram|Alpha will figure out what precise pieces of code can do what they're asking for.
And then show them examples that'll let them pick what they need to build up bigger and bigger precise programs.
Sometimes, Wolfram|Alpha will be able to do the whole thing immediately.
And just give back a whole big program, that you can then compute with.
So here's a big website where we've been collecting lots of educational and other demonstrations about lots of kinds of things.
Here's an example. This is just an example of one of these computable documents.
This is probably a fairly small piece of Mathematica code that's able to be run here.
But OK. Let's zoom out again. Given our new kind of science, is there a general way to use it to make technology?
With physical materials, we're used to going around the world and discovering that particular materials are useful for particular technological purposes and so on.
Well, it turns out that we can do very much the same kind of thing in the computational universe.
There's an inexhaustible supply of programs there. The challenge is to see how to harness them for human purposes.
Something like rule 30, for example, turns out to be a really good randomness generator.
Other simple programs are good models for processes in the natural or social world.
Wolfram|Alpha and Mathematica are actually now full of algorithms that we discovered by searching the computational universe.
And for example this has become surprisingly popular among composers.
Finding musical forms by searching the computational universe.
In a sense, we can use the computational universe to get mass customized creativity.
I'm hoping we can for example use it to get even Wolfram|Alpha to routinely do invention and discovery on the fly.
And to find all sorts of wonderful stuff that no engineer, and no process of incremental evolution, would ever come up with.
Well, so that leads to an ultimate question.
Could it be that someplace out there in the computational universe we might find our physical universe?
Perhaps there's even some quite simple rule—some simple program—for our universe.
Well, the history of physics would have us believe that the rule for the universe must be pretty complicated.
But in the computational universe we've seen how rules that are incredibly simple can produce incredibly rich and complex behavior.
So could that be what's going on with our whole universe?
If the rules for the universe are simple, it's inevitable that they're very abstract and low level.
Operating, for example, far below space and time.
Which makes it hard to represent things.
But in at least a large class of cases, one can think of the universe as being like a network.
Which, when it gets big enough, behaves like continuous space, in much the same way that lots of molecules can behave like a continuous fluid.
Well, then the universe has to evolve by applying little rules that progressively update this network.
And each possible rule in a sense corresponds to a candidate universe.
Actually, I haven't shown these before. But here are a few of the candidate universes I've looked at.
Some of them are hopeless as universes. Completely sterile.
With other pathologies—like no notion of space, or time, or matter.
But the exciting thing that I've found in the last few years is you don't have to go far in the computational universe before you start finding candidate universes that aren't obviously not our universe.
Here's the problem.
Any serious candidate for our universe is full of computational irreducibility.
Which means it's irreducibly difficult to find out how it will really behave—and whether it matches our physical universe.
A few years ago, I was pretty excited to discover that there are candidate universes with incredibly simple rules that successfully reproduce special relativity, and even general relativity and gravitation, and at least give hints of quantum mechanics.
So, will we find the whole of physics?
I don't know for sure. But I think at this point it's sort of almost embarrassing not to at least try.
It's not an easy project. One's got to build a lot of technology, and a structure that's probably at least as deep as existing physics.
And I'm not sure what the best way to organize it is. Build a team. Open it up. Offer prizes and so on.
But I'll tell you here today that I am committed to seeing this project done.
To see if within this decade we can finally hold in our hands the rule for our universe.
And know where our universe lies in the space of all possible universes.
And be able to type into Wolfram|Alpha "theory of the universe" and have it tell us.
So, I've been working on the idea of computation now for more than 30 years.
Building tools and methods, and turning intellectual ideas into millions of lines of code and grist for server farms and so on.
With every passing year, I realize how much more powerful the idea of computation really is.
It's taken us a long way already.
But there's so much more to come.
From the foundations of science, to the limits of technology, to the very definition of the human condition, I think computation is destined to be the defining idea of our future.