Stephen Wolfram: Computational Universe | MIT 6.S099: Artificial General Intelligence (AGI)

Welcome back to 6S099, artificial general intelligence. Today we have Stephen Wolfram. Wow, that's a first. I didn't even get started. You're already clapping. In his book A New Kind of Science, he has explored and revealed the power, beauty and complexity of cellular automata and as simple computational systems from which incredible complexity can emerge. It's actually one of the books that really inspired me to get into artificial intelligence. He's created the Wolfram Alpha computational knowledge engine, created Mathematica that has now expanded to become Wolfram language. Both he and his son were involved in helping analyze create the alien language from the movie Arrival, of which they used the Wolfram language. Please again, give Stephen a warm welcome.

Thanks. All right, so I gather the brief here is to talk about how artificial general intelligence is going to be achieved. Is that the basic picture? So maybe I'm reminded of kind of a story which I don't think I've ever told in public, but something that happened just a few buildings over from here. So this was 2009 and WolframAlpha was about to arrive on the scene. I assume most of you have used WolframAlpha or seen WolframAlpha. Yes. How many of you have used WolframAlpha? Okay, that's good. So I had long been a friend of Marvin Minsky's and Marvin was a sort of pioneer of the AI world. And I kind of seen for years question answering systems that tried to do sort of general intelligence question answering. And so had Marvin. And so I was going to show Marvin, you know, Wolfram Alpha. He looks at it and he's like, oh, okay, that's fine, whatever. Said, no, Marvin, this time it actually works. You can try real questions. This is actually something useful. This is not just a toy. And it was kind of interesting to see. It took about five minutes for Marvin to realize that this was finally a question answering system that could actually answer questions that were useful to people. And so one question is how did we achieve that? So, so, you know, you go to WolframAlpha and you can ask it. I mean, it's. I don't know what we can ask it. I don't know what's the. Some random question. What is the population of Cambridge? Actually, here's a question divided by. Let's try that. What's the population of Cambridge? It's probably going to figure out, we mean Cambridge, Massachusetts. It's going to give us some number, it's going to give us some plot. Actually what I want to know is number of students At MIT divided by population of Cambridge. See if it can figure that out. Okay. It's kind of interesting. Oh no, that's divided by. Ah, that's interesting. It guessed that we were talking about Cambridge University as the denominator there. So it says the number of students at MIT divided by the number of students at Cambridge University. That's interesting. I'm actually surprised. Let's see what happens if I say Cambridge Ma there now it'll probably fail horribly. No, that's good. Okay, so no, that's interesting. That's a plot as a function of time of the fraction of the of. Okay, so anyway, so I'm glad it works. So one question is, how did we manage to get so that many things have to work in order to get stuff like this to work? You have to be able to understand the natural language. You have to have data sources, you have to be able to compute things from the data and so on. One of the things that was a surprise to me was in terms of natural language understanding was the critical thing turned out to be just knowing a lot of stuff. The actual parsing of the natural language is kind of, I think it's kind of clever and we use a bunch of ideas that came from my new kind of science project and so on. But I think the most important thing is just knowing a lot of stuff about the world is really important to actually being able to understand natural language in a useful situation. I think the other thing is actually having access to lots of data. Let me show you a typical example here of what is needed. I ask about the ISS and hopefully it'll wake up and tell us something here, come on, what's going on here? There we go. It figured out that we probably are talking about a spacecraft, not a file format. Now it's going to give us a plot that shows us where the ISS is right now. Now, so to make this work, we obviously have to have some feed of radar tracking data about satellites and so on, which we have for every satellite that's out there. But then that's not good enough to just have that feed. Then you also have to be able to do celestial mechanics to work out, well, where is the ISS actually right now? Based on the orbital elements that have been deduced from radar. And then if we want to know things like, okay, when is it going to. It's not currently visible from Boston, Massachusetts. It will next rise at 7:36pm on Monday on today. So this requires a mixture of data about what's going on in the world together with models about how the world is supposed to work, being able to predict things and so on. And I think another thing that kind of realized about AI and so on from the WolframAlpha effort has been that one of the earlier ideas for how one would achieve AI was let's make it work, kind of like brains do, and let's make it figure stuff out. And so if it has to do physics, let's have it do physics by pure reasoning. Like people at least used to do physics, but in the last 300 years we've had a different way to do physics that wasn't sort of based on natural philosophy. It was instead based on things like mathematics. And so one of the things that we were doing in WolframAlpha was to kind of cheat relative to what had been done in previous AI systems, which was instead of using kind of reasoning type methods, we're just saying, okay, we want to compute where the ISS is going to be. Well, we've got a bunch of equations of motion that correspond to differential equations. We're just going to solve the equations of motion and get an answer. That's kind of leveraging the last 300 years or so of exact science that have been done with rather than trying to make use of kind of human reasoning ideas. And I might say that in terms of the history of the WolframAlpha project, when I was a kid, a disgustingly long time ago, I was interested in AI kinds of things. And in fact, I was kind of upset recently to find a bunch of stuff I did when I was 12 years old, kind of trying to assemble a pre version of Wolfram Alpha way back before it was technologically possible. But it's also a reminder that one just does the same thing one's whole life, so to speak. Level. But what happened was when I started off working mainly in physics, and then I got involved in building computer systems to do things like mathematical computation and so on, and I then sort of got interested in, okay, so can we generalize this stuff? And can we really make systems that can answer sort of arbitrary questions about the world? And for example, sort of the promise would be if there's something that is systematically known in our civilization, make it automatic to answer questions on the basis of that systematic knowledge. And back in around late 1970s, early 1980s, my conclusion was if you wanted to do something like that, the only realistic path to being able to do it was to build something much like a brain. And so I got interested in neural nets and I tried to do things with neural nets back in 1980 and nothing very interesting happened, or I couldn't get them to do anything very interesting and that. So I kind of had the idea that the only way to get the kind of thing that now exists in Wolfram Alpha, for example, was to build a brain like thing. And then many years later, for reasons I can explain, I kind of came back to this and realized actually it wasn't true that you had to build a brain like thing. Sort of mere computation was sufficient. And that was kind of what got me started actually trying to build WolframAlpha. When we started building WolframAlpha, one of the things I did was go to a sort of a field trip to a big reference library and you see all these shelves of books and so on. And the question is, can we take all of this knowledge that exists in all of these books and actually automate being able to answer questions on the basis of it? And I think we've pretty much done that for that. At least the books you find in a typical reference library. So that was. It looked kind of daunting at the beginning because there's a lot of knowledge and information out there. But actually it turns out there are a few thousand domains and we've steadily gone through and worked on these different domains. Another feature of the WolframAlpha project was that we didn't really, you know, I'd been involved a lot in doing basic science and in trying to have sort of grand theories of the world. One of my principles in building WolframAlpha was not to start from a grand theory of the world. That is not to kind of start from some global ontology of the world and then try and build down into all these different domains, but instead to work up from having hundreds, then thousands of domains that actually work, whether they're information about cars or information about sports or information about movies or whatever else, have each of these domains sort of building up from the bottom in each of these domains and then finding that there were common themes in these domains that we could then build into frameworks and then sort of construct the whole system on the basis of that. And that's kind of how it's worked. And I can talk about some of the actual frameworks that we end up using and so on, but maybe I should explain a little bit more. So one question is, how does WolframAlpha actually sort of work inside? And the answer is it's a big program. It's. The core system is about 15 million lines of Wolfram language code. And it's some number of terabytes of raw data. And so the way the thing that sort of made building WolframAlpha possible was this language, Wolfram language, which started with Mathematica, which came out in 1988 and has been sort of progressively growing since then. So maybe I should show you some things about Wolfram language. And you know, it's easy. You can go use this. MIT has a site license for it. You can use it all over the place, you can find it on the web, et cetera, et cetera, et cetera. But okay, the basics work. Let's start off with something like let's make a random graph. And let's say we have a random graph with 200 nodes, 400 vertices. Okay, so there's a random graph. The first important thing about Wolfram language is that it's a symbolic language. So I can just pick up this graph and I could say, I don't want to do some analysis of this graph. That graph is just a symbolic thing that I can just do computations on. Or I could say let's get. Another good thing to always do is get a current image. See, there we go. And now I could go and say something like, let's do some basic thing. Let's say, let's edge detect that image again. This image is just a thing, thing that we can manipulate. We could take the image, we could make it. I don't know, we could take the image and partition it, little pieces, do computations on that. I don't know, simple. Let's just say sort each row of the image, assemble the image again. Oops, Assemble that image again. We'll get some mixed up picture there. If I wanted to, I could, for example, let's say, let's make that the current image and let's say make that dynamic. Now I can be just running that code hopefully and it'll loop and there we can make that work. So one general point here is this is just an image for us. It's just a piece of data like anything else. We just have a variable, a thing called X. It just says, okay, that's X. I don't need to know particular value. It's just a symbolic thing that corresponds to. That's a thing called X. Now what gets interesting when you have symbolic language and so on is we're interested in having it represent stuff about the world as well as just abstract kinds of things. I mean, I can abstractly say find some funky integral, I don't know what that's then representing using symbolic variables. To represent algebraic kinds of things. But I could also just say, I don't know, something like Boston. And Boston is another kind of symbolic thing that has, if I say, what is it really inside, it's the entity, a city. Boston, Massachusetts, United States. Actually, you notice when I typed that in, I was using natural language to type it in. And it gave me a bunch of disambiguation here. It said, assuming Boston is a city, assuming Boston, Massachusetts, use Boston, New York. Or okay, let's use Boston and the Philippines, which I've never heard of, but let's try using that instead. And now if I look at that, it'll say it's Boston in some province of the Philippines, et cetera, et cetera, et cetera. Now I might ask it of that. I could say something like, what's the population of that? And okay, it's a fairly small place. Or I could say, for example, let me do this, let me say a geolist plot from that. Boston. Let's take from that Boston to. And now let's type in Boston again. And now let's have it use the default meaning of the word of Boston. And then let's join those up. And now this should plot. This should show me a plot. There we go. Okay, so there's the path from the Boston that we picked in the Philippines to the Boston here. Or we could ask it, I don't know, I could just say I could ask it the distance from one to another or something like that. So one of the things here, one of the things we found really, really useful actually in Wolfram language. So first of all, there's a way of representing stuff about the world, like cities, for example. Well, let's say, I want to say, let's do this. Let's say, let's do something with cities. Let's say capital cities in South America. Okay, so notice this is a piece of natural language. This will get interpreted into something which is precise symbolic Wolfram language code that we can then compute with. And that will give us the cities in south capital cities in South America. I could, for example, let's say, I say find shortest tour. So now I'm going to use some. Oops, no, I don't want to do that. What I want to do first is to say, show me the geopositions of all those Cities on line 21 there. So now it will find the geopositions and now it will say, compute the shortest tour. So that's saying there's a 10,000 mile traveling salesman tour around those cities. So I could take those Cities on line 21 and I could say, order the cities according to this and then I could make another geolist plot of that. Join it up. And this should now show us a traveling salesman tour of the capital cities in South America. So, you know, it's sort of interesting to see what's involved in making stuff like this work. One of, you know, my goal has been to sort of automate as much as possible about things that have to be computed. And that means knowing as many algorithms as possible and also knowing as much data about the world as possible. And I kind of view this as sort of a knowledge based programming approach. Where you have a typical kind of idea in programming languages is you have some small programming languages, has a few primitives that are pretty much tied into what a machine can intrinsically do, and then maybe you'll have libraries that add on to that and so on. My kind of crazy idea of many, many years ago has been to build an integrated system where all of this stuff about different domains of knowledge and so on are all just built into the system and designed in a coherent way. I mean, this has been kind of the story of my life for the last 30 years, is trying to keep the design of the system coherent even as one adds all sorts of different areas of capability. So as, I mean, we can go and dive into all sorts of different kinds of things here. But maybe as an example. Well, let's do. What could we do here? We could take, let's try. How about this? Is that a bone? I think so. That's a bone. So let's try that as a mesh region, see if that works. So this will now use a completely different domain of human endeavor. Okay. Oops, there's two of those bones. Let's try. Let's just try. Let's try left humerus. Let's try the mesh region for that. And now we should have a bone here. Okay, there's a representation of a bone. Let's take that bone. And we could for example, say, let's take the surface area of that as in some units. Or I could, let's do some much more outrageous thing. Let's say we take region distance. So we're going to take the distance from some, from that bone to a point. Let's say 0, 0Z. And let's make a plot of that distance with Z going from. Let's say I have no idea where this bone is, but let's try something like this. So that was really boring. Let's try. So what this is doing. Again, a whole bunch of stuff has to work in order for this to to operate. This has to be. This is a. This is some region in 3D space that's represented by some mesh. You have to compute, you know, do the computational geometry to figure out where it is. If I wanted to. Let's try anatomy, anatomy plot 3D and let's say something like left hand, for example. And now it's going to show us probably the complete data that it has about the geometry of, of a left hand. There we go. Okay, so there's the result. And we could take that apart and start computing things from it and so on. So what? So this, this is. So there's a. There's a lot of kind of computational knowledge that's built in here. 1. Let's talk a little bit about kind of the modern machine learning story. So for instance, if I say. Let's get a picture here. Let's say, let's just say picture of somebody got a favorite kind of animal. What? Panda. Okay, so let's try. Okay. Giant panda. Okay. Okay, there's a panda. Let's see what now let's try saying. Let's try for this panda. Let's try saying image identify. And now here we'll be embarrassed probably, but let's just see. Let's see what happens if I say image identify that. And now it'll hopefully wake up, wake up, wake up. This only takes a few hundred milliseconds. Okay, very good. Giant panda. Let's see what the runners up were to the giant panda. Let's say we want to say the 10 runners up in all categories for that thing. Okay, so a giant panda, a procurenid, which I've never heard of. Are pandas carnivorous. They eat bamboo shoots. Okay, so that was so lucky it didn't get that one. It's really sure it's a mammal and it's absolutely certain it's a vertebrate. Okay. So you might ask, how did it figure this out? And so then you can kind of look under the hood and say. So we have a whole framework for representing neural nets symbolically. And so this is the actual model that it's using to do this. So this is a. So there's a neural net and it's got. We can drill down and we can see there's a piece of the neural net. We can drill down even further to one of these and we can probably see what. That's our batch normalization layer. Somewhere deep inside the entrails of the not panda, but of this thing. So now let's take that object, which is just a symbolic object, and let's feed it the picture of the panda. And we can see and there. Oops, I was not giving it the right thing. What did I just do wrong here? Here, let's, let's take. Oh, I see what I did. Ok, let's take this thing and feed it the picture of the panda. And it says a giant panda. Okay, how about we do something more outrageous? Let's take that neural net and let's only use the first, let's say 10 layers of the neural net. So let's just take out 10 layers of the neural net and feed it the panda. And now what we'll get is something from the insides of the neural net. And I could say, for example, let's just make those into images. Okay, so that's what the neural net had figured out about the panda. After 10 layers of going through the neural net and maybe actually be interesting to see. Let's do a feature space plot. So now we're going to. Of those intermediate things in the sort of, in the brain of the neural net, so to speak. This is now taking. So what this is just doing is to do dimension reduction on this space of images. And so not very exciting. It's probably mostly distinguishing these by total gray level, but that's kind of showing us the space of different sort of features of the insides of this neural net. So it's also what's interesting to see here is things like the symbolic representation of the neural nets. And if you're wondering how does that actually work inside, it's Underneath it's using MXnet, which we happen to have contributed to a lot. There's a bunch of symbolic layers on top of that that feed into that. Maybe I can show you here, let me show you how you would train one of these neural nets. That's also kind of fun. So we have a data repository that has all sorts of useful data. One piece of data it has is a bunch of neural net training sets. So this is the standard MNIST training set of handwritten digits. Okay, so there's mnist, and you notice that these things here, that's just an image which I could copy out and I could do, let's say I could do color negate on that image because it's just an image and there's the result and so on. And now I could say let's take a neural net like. Let's take a simple neural net like Lynette for example, okay, so let's take Lynette and then let's take the untrained initial evaluation network. So this is now a version of Lynette simple standard neural net that didn't get trained. So for example, if I take that symbolic representation of Lynette and I could say net initialize, then it will take that and it'll just put random weights into Lynette. Okay? So if I take those random weights and I feed it a zero here, I feed it that image of a zero, it will presumably produce something completely random in this particular case, two. So now what I would like to do is to take this. So that was just randomly initializing the weights. So now what I'd like to do is to take the MNIST training set and I'd like to actually train Lynette using MNIST training set. So let's take this and let's take a random sample of, let's say, I don't know, a thousand pieces of Lynette. Come on. Why is it having to load it again? There we go. Okay, so there's a random sample. There is on line 21. And now let me go down here and say, where was it? Well, we can just take this thing here. So this is the uninitialized version of Lynette and we can say take that and then let's say net train of that with the thing on line 21, which was that thousand instances. So now what it's doing is it's running training on and that you see the loss going down and so on. It's running training for those thousand instances of Lynette. And we can stop it if we want to. Actually, this is a new display. This is very nice. This is a new version of Wolfram language, which is coming out next week, which I'm showing you. But it's quite similar to what exists today because that's one of the features of running a software company is that you always run the very latest version of things, for better or worse. And this is also a good way to debug it because it's supposed to come out next week. If I find some horrifying bug, maybe it will get delayed. But let's try this. Ok, now it says it's zero. This is now a trained version of Lynette, trained with that training data, one of the things. So we can talk about all kinds of details of neural nets and so on. But maybe I should zoom out to talk a little bit about bigger picture as. As I see it. So one question Is sort of a question of what is in principle possible to do with computation. So we have, as we're building all kinds of things, we're making image identifiers, we're figuring out all kinds of things about where the International Space Station is and so on question is, what is in principle possible to compute? And so one of the places one can ask that question is when one looks at, for example, models of the natural world. One can say, how do we make models of the natural world? A traditional approach has been let's use mathematical equations to make models of the natural world. A question is, if we want to generalize that and say, well, what are all possible ways to make models of things? What can we say about that question? So I spent many years of my life trying to address that question. And basically what I thought about a lot is that if you want to make a model of a thing, you have to have definite rules by which the thing operates. What's the most general way to represent possible rules? Well, in today's world, we think of that as a program. So the next question is, well, what does the space of all possible programs look like? And most of the time, we're writing programs like wolfram, language is 50 million lines of code. And it's a big, complicated program that was built for a fairly specific purpose. But the question is, if we just look at sort of the space of possible programs more or less at random, what's out there in the space of possible programs? So I got interested many years ago in cellular automata, which are a really good example of a very simple kind of program. So let me show you an example of one of these. So these are the rules for a typical cellular automaton. And this just says, you have a row of black and white squares. And this just says, you look at a black, look at a square. Say, what color is that square? What color are its left and right neighbors? Decide what color the square will be on the next step based on that rule. Okay, so really simple rule. So now let's take a look at what actually happens if we use that rule a bunch of times. So we can take that rule. The 254 is just the binary digits that correspond to those positions in this rule. So now I can say this. I could say, let's do 50 steps. Let me do this. And now if I run according to the rule I just defined, it turns out to be pretty trivial. It's just saying if any square is. We start off with a black square. If any square is. If any Neighboring square is black. Make a black square. So we've used a very simple program. We got a very simple result out. Okay, let's try a different program. We can try changing this. We'll get. That's a program with one bit different. Now we get that kind of pattern. So the question is, well, what happens? You might say, okay, if you've got such a trivial program, it's not surprising you're just going to get trivial results out. But you can do an experiment to test that hypothesis. You can just say, let's take all possible programs. There are 256 possible programs that are based on these eight bits here. Let's just take. Well, let's just. Whoops. Let's just take say the first 64 of those programs and let's just make a. Let's just make a table of the results that we get by running those first 64 programs here. So here we get the result and what you see is, well, most of them are pretty trivial. They start off with one black cell in the middle and it just tools off to one side. Occasionally we get something more exciting happening. Like here's a nice nested pattern that we get. If we were to continue it longer, it would make more detailed nesting. But then my all time favorite science discovery, if you go on and just look at these, after a while you find this one here, which is Rule 30 in this numbering scheme. And that's doing something a bit more complicated. You say, well, what's going on here? We just started off with this very simple rule. Let's see what happens. Maybe after a while, if we run Rule 30 long enough, it will resolve into something simpler. So let's try running it, let's say 500 steps and that's the result we get. Let's say, let's just make it full screen. Okay, it's aliasing a bit on the projector there, but you get the basic idea. So this just started off from one black cell at the top and this is what it made. And that's pretty weird because all this is. This is sort of not the way things are supposed to work because what we have here is just that little program down there and it makes this big complicated pattern here. And you know, we can see there's a certain amount of regularity on one side. But for example, the center column of this pattern is for all practical purposes completely random. In fact, it was. We used this as the random number generator in mathematical and Wolfram language for many years. It was recently retired after excellent service because we found a somewhat more efficient one. So what do we learn from this? What we learn from this is out in the computational universe of possible programs, it's possible to get even with very simple programs, very rich, complicated behavior. Well, that's important if you're interested in modeling the natural world, because you might think that there are programs that represent systems in nature that might work this way, and so on. It's also important for technology because it says, okay, let's say you're trying to find a. Let's say you're trying to find a program that's a good random number generator. How are you going to do that? Well, you could start thinking very hard and you could try and make up, you know, you could try and write down all kinds of flowcharts about how this random number generator is going to work. Or you can say, forget that. I'm just going to search the computational universe up possible programs and just look for one that serves as a good random number generator. In this particular case, after you've searched 30 programs, you'll find one that makes a good random number generator. Why does it work? That's a complicated story. It's not a story that I think necessarily we can really tell very well. But what's important is that this idea that out in the computational universe, there's a lot of rich, sophisticated stuff that can be essentially mined for our technological purposes. That's the important thing. Whether we understand how this works is a different matter. I mean, it's like when we look at the natural world, the physical world, we're used to kind of mining things. We started using magnets to do magnetic stuff long before we understood the theory of ferromagnetism and so on. And so similarly here we can sort of go out into the computational universe and find stuff that's useful for our purposes now. In fact, the world of sort of deep learning and neural nets and so on is a little bit like this. It uses the trick that there's a certain degree of differentiability there, so you can kind of home in on, let's try and find something that's incrementally better. And for certain kinds of problems, that works pretty well. I think the thing that we've done a lot, I've done a lot, is just sort of exhaustive search in the computational universe of possible programs. Just search a trillion programs and try and find one that does something interesting and useful for you. There's a lot of things to say about what? Well, actually, in the search a trillion programs and find One that's useful. Let me show you another example of that. Let's see. So I was interested a while ago in the. I have to look something up here. Sorry, in, let me see here. In Boolean algebra and in. I was interested in the space of all possible mathematics. And let me just see here. I'm not finding what I wanted to find. Sorry. Was a good example. I should have memorized this, but I haven't. So here we go. There it is. So I was interested in. If you just look at. So we talked about sort of looking at the space of all possible. The space of all possible programs. Another thing you can do is say, if you're going to invent mathematics from nothing, what possible axiom systems could be used in mathematics? So I was curious where that again, might seem like a completely crazy thing to do, to just say, let's just start enumerating axiom systems at random and see if we find one that's interesting and useful. But it turns out once you have this idea that out in the computational universe of possible programs, there's actually a lot of low hanging fruit to be found, it turns out you can apply that idea in lots of places. I mean, the thing to understand is, why do we not see a lot of engineering structures that look like. The reason is because our traditional model of engineering has been we engineer things in a way where we can foresee what the outcome of our engineering steps are going to be. And when it comes to something like this, we can find it out in the computational universe, but we can't readily foresee what's going to happen. We can't do sort of a step by step design of this particular thing. And so in engineering, in human engineering as it's been practiced so far, most of it has consisted of building things where we can foresee, step by step, what the outcome of our engineering is going to be. And we see that in programs, we see that in other kinds of engineering structures. And so there's sort of a different kind of engineering, which is about mining the computational universe of possible programs. And it's worth realizing there's a lot more that can be done a lot more efficiently by mining the computational universe of possible programs than by just constructing things step by step as a human. So, for example, if you look for optimal algorithms for things like, I don't know, even something like sorting networks, the optimal sorting networks look very complicated. They're not things that you would construct by sort of step by step thinking about things in a kind of typical human way. And so this idea, if you're really going to have computation work efficiently, you are going to end up with these programs that are sort of just mined from the computational universe. And one of the issues with mining things so that this makes use of computation much more efficiently than a typical thing that we might construct. Now, one feature of this is it's hard to understand what's going on. And there's actually a fundamental reason for that, which is in our efforts to sort of understand what's going on, we get to use our brains, our computers, our mathematics, or whatever, and our goal is this particular little program did a certain amount of computation to work out this pattern. The question is, can we kind of outrun that computation and say, oh, I can tell that actually this particular bit down here is going to be a black, black bit. You don't have to go and do all that computation. But it turns out that. And again, this will maybe is a digression, which there's this phenomenon I call computational irreducibility, which I think is really common, and it's a consequence of this thing I call principle of computational equivalence. And that principle of computational equivalence basically says as soon as you have a system whose behavior isn't fairly easy to analyze, the chances are that the computation it's doing is essentially as sophisticated as it could be. And that has consequences. Like, it implies that the typical thing like this will correspond to a universal computer that you can use to program anything. It also has the consequence of this computational irreducibility phenomenon that says you can't expect our brains to be able to outrun the computations that are going on inside the system. If there was computational reducibility, then we can expect that this thing went to a lot of trouble and did a million steps of evolution. But actually, just by using our brains, we can jump ahead and see what the answer will be. Computational irreducibility suggests that isn't the case. If we're going to make the most efficient use of computational resources, we will inevitably run into computational irreducibility all over the place. It has the consequence that we get the situation where we can't readily sort of foresee and understand what's going to happen. So back to mathematics for a second. So this is just an axiom system that. So I looked for all possible. Look through sort of all possible axiom systems, starting off with really tiny ones, and I asked the question, what's the first axiom system that corresponds to Boolean algebra? So it turns out this thing here, this tiny little thing here generates all theorems of Boolean algebra. It is the simplest axiom for Boolean algebra. Now, something I have to show you this because it's a new feature. You see, if I say, find equational proof, let's say I want to prove commutativity of the NAND operation. I'm going to show you something here. This is going to try to generate. Let's see if this works. This is going to try to generate an automated proof based on that axiom system of that result. So it had 102 steps in the proof. And let's try and say, let's look at, for example, the proof network here. Actually, let's look at the proof data set. No, that's not what I wanted. I should learn how to use this, shouldn't I? See, what I want is the proof data set. There we go. Very good. Okay, so this is actually, let's say, first of all, let's say the proof graph. Okay, so this is going to show me how that proof was done. So there are a bunch of lemmas that got proved, and from those lemmas, those lemmas were combined and eventually it proved the result. So let's take a look at what some of those lemmas were. Okay, so here's the result. So after, so it goes through, and these are various lemmas it's using, and eventually after many pages of nonsense, it will get to the result. Okay, each one of these, some of these lemmas are kind of complicated. There, that's that lemma. It's a pretty complicated lemma, et cetera, et cetera, et cetera. So you might ask, what on earth is going on here? And the answer is. So I first generated a version of this proof 20 years ago, and I tried to understand what was going on, and I completely failed. And it's sort of embarrassing because this is supposed to be a proof, it's supposed to be demonstrating some results. And what we realize is that what does it mean to have a proof of something? What does it mean to explain how a thing is done? What is the purpose of a proof? Purpose of a proof is basically to let humans understand why something is true. And so, for example, if you go to, let's say we go to WolframAlpha and we do some random thing where we say, let's do an integral of something or another, it will be able to very quickly. In fact, it will take it only milliseconds internally to work out the answer to that integral. But then somebody who wants to hand in a piece of homework or something like that needs to explain why is this true? Okay, well, we have this handy step by step solution thing here, which explains why it's true. Now, the thing I should admit about the step by step solution is it's completely fake. That is, the steps that are described in the step by step solution have absolutely nothing to do with the way that internally that integral was computed. These are steps created purely for the purpose of telling a story to humans about why this integral came out the way it did. And now what we're seeing. And so that's a. So there's one thing is knowing the answer, the other thing is being able to tell a story about why the answer worked that way. Well, what we see here is this is a proof, but it was an automatically generated proof and it's a really lousy story for us humans. I mean, if it turned out that one of these theorems here was one that had been proved by Gauss or something and appeared in all the textbooks, we would be much happier because then we would start to have a kind of human representable story about what was going on. Instead we just get a bunch of machine generated lemmas that we can't understand, that we can't kind of wrap our brains around. And it's sort of the same thing that's going on in. When we look at one of these neural nets we're seeing when we were looking wherever it was, at the innards of that neural net. And we say, well, how is it figuring out that that's a picture of a panda? Well, the answer is it decided that, you know, if we humans were saying, how would you figure out if it's a picture of a panda? We might say, well, look and see if it has eyes. That's a clue for whether it's an animal. Look and see if it looks like it's kind of round and furry and things. That's a version of whether it's a panda and et cetera, et cetera, et cetera. But what it's doing is it learnt a bunch of criteria for, you know, is it a panda? Or is it one of 10,000 other possible things that it could have recognized? And it learnt those criteria in a way that was somehow optimal based on the training that it got and so on. But it learnt things which were distinctions which are different from the distinctions that we humans make in the language that we as humans use. And so in some sense, when we start talking about, well, describe a picture, we have a certain human language for Describing that picture we have in our human. In typical human languages, we have maybe 30,000 to 50,000 words that we use to describe things. Those words are words that have sort of evolved as being useful for describing the world that we live in. When it comes to this neural net it could be using, it could say, well, the words that it has effectively learnt which allow it to make distinctions about what's going on in the analysis that it's doing. It has effectively invented words that describe distinctions, but those words have nothing to do with our historically invented words that exist in our languages. So it's kind of an interesting situation that it is its way of thinking, so to speak. If you say, well, what's it thinking about? How do we describe what it's thinking? That's a tough thing to answer because just like with the automated theorem, we're sort of stuck having to say, well, we can't really tell a human story because the things that it invented are things for which we don't even have words in our languages, and so on. Okay, so one thing to realize is in this kind of space of sort of all possible computations, there's a lot of stuff out there that can be done. There's this kind of ocean of sophisticated computation. And then the question that we have to ask for us humans is, okay, how do we make use of all of that stuff? So what we've got kind of on the one hand is we've got the things we know how to think about, human languages, our way of describing things, our way of talking about stuff. That's the one set of things. The other set of things we have is this very powerful kind of seething ocean of computation on the other side, where lots of things can happen. So the question is, how do we make use of this sort of ocean of computation in the best possible way for our human purposes and building technology and so on. And so the way I see my kind of part of what I've spent a very long time doing is kind of building a language that allows us to take human thinking on the one hand and describe and provide a sort of computational communication language that allows us to get the benefit of what's possible over in the sort of ocean of computation in a way that's rooted in what we humans actually want to do. And so I kind of view Wolfram language as being sort of an attempt to make a bridge between. So on the one hand there's all possible computations. On the other hand, there's things we think we want to do and I view Wolfram language as being my best attempt right now to make a way to take our sort of human computational thinking and be able to actually implement it. So in a sense, it's a language which works on two sides. It's both a language where you, as the machine can understand, okay, it's looking at this, and that's what it's going to compute. But on the other hand, it's also a language for us humans to think about things in computational terms. So if I go and I. I don't know, one of these things that I'm doing here, whatever it is, this wasn't that exciting. But find shortest tour of the geoposition of the capital cities in South America. That is a language. That's a representation in a precise language of something. And the idea is that that's a language which we humans can find useful in thinking about things in computational terms. It also happens to be a language that the machine can immediately understand and execute. And so I think this is sort of a general. When I think about AI in general, what's the overall problem? Well, part of the overall problem is, so how do we tell the AIs what to do, so to speak. There's this very powerful, this sort of ocean of computation is what we get to mine for purposes of building AI kinds of things. But then the question is, how do we tell the AIs what to do? And what I see, what I've tried to do with Wolfram language is to provide a way of accessing that computation and making use of the knowledge that our civilization has accumulated. And because that's the, you know, there's the general computation on this side, and there's the specific things that we humans have thought about. And the question is to make use of the things that we've thought about to do things that we care about doing, actually, if you're interested in these kinds of things. I happened to just write a blog post couple of days ago. It's kind of a funny blog post. It's about. Well, you can see the title there. It came because a friend of mine has this crazy project to put little. Little sort of disks or something that should represent kind of the best achievements of human civilization, so to speak, to send out its hitchhiking on various spacecraft that are going out into the solar system in the next little while. And the question is what to put on this little disk that kind of represents the achievements of civilization. It's kind of depressing when you go back and you look at what, what people have tried to do on this before and realizing how hard it is to tell even whether something is an artifact or not. But this was sort of a. Yeah, that's a good one. That's from 11,000 years ago. The question is, can you figure out what on earth it is and what it means? But, so what's relevant about this is this whole question of there are things that are out there in the computational universe. And when we think about extraterrestrial intelligence, I find it kind of interesting that artificial intelligence is our first example of an alien intelligence. We don't happen to have found what we view as extraterrestrial intelligence right now, but we are in the process of building pretty decent version of an alien intelligence here. And the question is, if you ask questions like, well, what is it thinking? Does it have a purpose in what it's doing? And so on, and you're confronted with things like this, it's very. You can kind of do a test run of, you know, what's its purpose? What is it trying to do? In a way that is very similar to the kinds of questions you would ask about extraterrestrial intelligence. But any case, the main point is that I see this sort of ocean of computation. There's the. Let's describe what we actually want to do with that ocean of computation. And that's one of the primary problems we have now. People talk about AI and what is AI going to allow us to automate? And my basic answer to that would be, we'll be able to automate everything that we can describe. The problem is, it's not clear what we can describe. Or put another way, you imagine various jobs and people are doing things. They're repeated judgment jobs, things like this, where we can readily automate those things. But the thing that we really automate is saying, well, what are we trying to do? That is, what are our goals? Because in a sense, when we see one of these systems, let's say it's a cellular automaton here, the question is, what is the cellular automaton trying to do? Maybe. Maybe I'll give you another cellular automaton that is a little bit more exciting here. Let's do this one. So the question is, what is this cellular automaton trying to do? It's got this whole big structure here, and things are happening with it. We can go, we can run it for a coup. We can ask. It's a nice example of kind of undecidability in action. What's going to happen here? This is kind of the halting problem. Is this going to halt? What's it going to do? There's computational irreducibility, so we actually can't tell. This is a case where we know this is a universal computer. In fact, eventually, well, I won't even spoil it for you. If I went on long enough, it would go into some kind of cycle. But we can ask, what is this thing trying to do? What is it, you know, what's it thinking about? What's its goal? What's its purpose? And we get very quickly in a big mess thinking about those kinds of things. One of the things that comes out of this principle of computational equivalence is thinking about what kinds of things are capable of sophisticated computation. So I mentioned a while back here, sort of my personal history with Wolf Malpha of having thought about doing something like Wolf Malpha when I was a kid and then believing that you sort of had to build a brain to make that possible and so on. And one of the things that I then thought was that there was some kind of bright line between what is intelligent and what is merely computational, so to speak. In other words, that there was something which is like, oh, we've got this great thing that we humans have that is intelligence and all these things in nature and so on, and all the stuff that's going on there, it's just computation or it's just things operating according to rules that's different. There's some bright line distinction between these things. Well, I think the thing that came about after I'd looked at all these cellular automata and all kinds of other things like that is I sort of came up with this principle of computational equivalence idea, which we've now got quite a lot of evidence for which I talk about, people are interested in, but that basically there isn't a. That once you reach a certain level of computational sophistication, everything is equivalent. And that means that that implies that there really isn't a bright line distinction between, for example, the computations going on in our brains and the computations going on in these simple cellular automata and so on. And that essentially philosophical point is what actually got me to start trying to build both of them Alpha. Because I realized that, gosh, I've been looking for this sort of the magic bullet of intelligence. And I just decided probably there isn't one. And actually it's all just computation. And so that means we can actually in practice build something that does this kind of intelligent, like thing. And so that's what I think is the case, is that there really Isn't sort of a bright line distinction, and that has more extreme consequences. Like, people will say things like, you know, the weather has a mind of its own. Okay, sounds kind of silly, sounds kind of animistic, primitive and so on. But in fact, the fluid dynamics of the weather is as computationally sophisticated as the stuff that goes on in our brains. But we can start asking, but then you say, but the weather doesn't have a purpose. What's the purpose of the weather? Well, maybe the weather is trying to equalize the temperature between the North Pole and the tropics or something. And then we have to say, well, but that's not a purpose in the way that we think about purposes. That's just. And we get very confused. And in the end, what we realize is when we're talking about things like purposes, we have to have this kind of chain of provenance that goes back to humans and human history and all that kind of thing. And I think it's the same type of thing when we talk about computation and AI and so on. The thing that we. This question of sort of purpose, goals, things like this, that's the thing which is intrinsically human and not something that we can ever sort of automatically generate. It makes no sense to talk about automatically generating it, because these computational systems, they do all kinds of stuff. We can say they've got a purpose, we can attribute purposes to them, et cetera, et cetera, et cetera. But ultimately, it's sort of the human thread of purpose that we have to deal with. So that means, for example, when we talk about AIs and we're interested in things like, so how do we tell? We'd like to be able to tell. We talk about AI ethics, for example. Example, we'd like to be able to make a statement to the AIs, like, please be nice to us humans. And that's something. So one of the issues there is. So talking about that kind of thing, one of the issues is how are we going to make a statement like, be nice to us humans. How are we going to explain that to an AI? And this is where, again, my efforts to build a language, a computational communication language that bridges the world of what we humans think about and the world of what is possible in computation is important. And so one of the things I've been interested in is actually building what I call a symbolic discourse language that can be a general representation for the kinds of things that we might want to put in, that we might want to say in things like, be nice to humans. So sort of a little bit of background to that. So, you know, in the modern world, people are keen on smart contracts. They often think of them as being deeply tied into blockchain, which I don't think is really quite right. The important thing about smart contracts is it's a way of having sort of an agreement between parties which can be executed automatically. And that agreement, maybe you may choose to sort of anchor that agreement in a blockchain, you may not. But the whole point is you have to. When people write legal contracts, they write them in an approximation to English. They write them in legalese, typically, because they're trying to write them in something a little bit more precise than regular English. But the limiting case of that is to make a symbolic discourse language in which you can write the contract and code, basically. And I've been very interested in using Wolfram language to do that, because in Wolfram language, we have a language which can describe things about the world, and we can talk about the kinds of things that people actually talk about in contracts and so on. And we're most of the way there to being able to do that. And then when you start thinking about that, you start thinking about, okay, so we've got this language to describe things that we care about in the world. And so when it comes to things like tell the AIs to be nice to the humans, we can imagine using Wolfram language to sort of build an AI constitution that says, this is how the AI is supposed to work. But when we talk about sort of just. The untethered AI doesn't have any particular. It's just going to do what it does. And if we want it to. If we want to somehow align it with human purposes, is we have to have some way to sort of talk to the AI. And that's, you know, I view my efforts to build Wolfram language as a way to do that. I mean, as I was showing at the beginning, you can take natural language, and with natural language, you can build up a certain amount of. You can say a certain number of things in natural language. You can then say, well, how do we make this more precise? In a precise symbolic language, if you want to build up more complicated things, it gets hard to do that in natural language. And so you have to kind of build up more serious programs in symbolic language. And I've probably been yakking a while here, and I'm happy to. I can talk about all kinds of different things here, but maybe I've not seen as many reactions as I might have expected. To think so I'm not sure which things people are interested in and which they're not, but. So maybe I should, maybe I should, should stop here and we can have discussion, questions, comments. Yes.

Two microphones. If you have questions, please come up.

So I have a quick question. It goes to the earlier part of your talk where you say you don't build a top down ontology, you actually build from the bottom up with disparate domains. What do you feel are the core technologies of the knowledge representation which you use within Wolfram Alpha that allows you different domains to reason about each other, to come up with solutions? And is there any feeling of differentiability, for example? So if you were to come up with a plan to do something new within WolframAlpha language, how would you go about doing that?

Okay, so we've done maybe a couple of thousand domains. Okay, what is actually involved in doing one of these domains? Domains? It's a gnarly business. Every domain has some crazy different thing about it. I tried to make up actually a while ago. Let me show you something. A kind of a hierarchy of what it means to make. See if I can find this here. Kind of a hierarchy of what it means to make a domain computable. Where is it? There we go. Okay, here we go. So this is sort of a hierarchy of levels of what it means to make a domain computable from just, you know, you've got some, you know, you've got some array of data that's quite structured. Forget, you know, the separate issue about extracting things from unstructured data. But let's imagine that you were given, you know, a bunch of data about landing sites of meteorites or something. Okay, so you go through various levels. So you know, things like, okay, the landing sites, the meteorites, are the positions just strings or are they some kind of canonical representation of geoposition? Is the type of meteorite. You know, some of them are iron meteorites, some of them are stone meteorites. Have you made a canonical representation? Have you made some kind of way to identify what.

Sorry, go ahead.

No, no, I mean to do that.

So, so my question is like, you know, if you did have positions as a string as well as a canonical representation, do you have redundant pieces of the same? Redundant representations of the same information in the different.

No, I mean our domains, everything canonical that you have? Yeah.

You have a minimal representation of everything.

Yeah, our goal is to make everything canonical. Now that's, you know, there is a lot of complexity in doing that. I mean, if you, you know, in each. Okay, so another feature of these domains. Okay, so here's another thing to say. You know, it would be lovely if one could just automate everything and cut the humans out of the loop. Turns out this doesn't work. And in fact, whenever we do these domains, it's fairly critical to have expert humans who really understand the domain or you simply get it wrong. And it's also, having said that once you've done enough domains, you can do a lot of cross checking between domains. And we are the number one reporters of errors in pretty much all standardized data sources, because we can do that kind of cross checking. But I think if you ask the question, what's involved in bringing online a new domain? The sort of hierarchy of things, some of those take a few hours. You can get to the point of having we've got good enough tools for ingesting data, figuring out, oh, those are names of cities in that column. Let's canonicalize those. Some may be questions, but many of them will be able to nail down and to get to the full level of you've got some complicated domain and it's fully computable is probably a year of work. And you might say, well, gosh, why are you wasting your time? You've got to be able to automate that. So you can probably tell we're fairly sophisticated about machine learning kinds of things and so on. And we have tried to automate as much as we can and we have got a pretty efficient pipeline. But if you actually want to get it right and you see, here's an example of what happens. There's a level even going between Wolfram Alpha and Wolfram language. There's a level of. So for example, let's say you're looking at lakes in Wisconsin. So people are querying about lakes in Wisconsin and WolframAlpha. They'll name a particular lake and they want to know how big is the lake. Okay, fine. In Wolfram language, they'll be doing a systematic computation about lakes in Wisconsin. So if there's a lake missing, you're going to get the wrong answer. And so that's a kind of higher level of difficulty. Okay, but I think you're asking some more technical questions about ontologies and I can try and answer those.

Actually. One quick question.

Can you now? There's a lot of other questions.

Yeah, that's fine.

Okay.

All right, thank you very much.

That was a great recycle.

To the left here.

I've got a simple question. Who or what are your key influences? Oh, gosh, in Terms of language design for Wolfram language. So in the context of machine intelligence, if you like, if you want to make it tailored to this audience. I don't know. I've been absorbing stuff forever. I think my main, in terms of language design, probably LISP and APL were my sort of early influences. But in terms of thinking about AI, you know, in, I mean, I'm kind of quite knowledgeable. I like history of science. I'm pretty knowledgeable about the early history of kind of mathematical logic, symbolic kinds of things. I would say, okay, maybe I can answer that in the negative. Okay, I have, for example, in building WolframAlpha, I thought, Gosh, let me do my homework. Let me learn all about computational linguistics. Let me hire some Computational Linguistics PhDs. That will be a good way to get this started. Turns out we used almost nothing from the previous sort of history of computational linguistics, partly because what we were trying to do, namely, short question, natural language understanding is different from a lot of the natural language processing which has been done in the past. I also have made, to my disappointment, very little use of people like Marvin Minsky, for example. I really don't think, I mean, I knew Marvin for years and in fact some of his early work on simple Turing machines and things, those are probably more influential to me than his work on AI. And probably my mistake of not understanding that better, but really I would say that I've been rather uninfluenced by the traditional AI kinds of things. I mean, it probably hasn't helped that I've kind of lived through a time when AI went from when I was a kid, AI was going to solve everything in the world and then it kind of decayed for a while and then sort of come back. So I would say I can describe my negative. My non influence is better than my influence. The impression you give is that you made it up out of your own head. And it sounds as though that's pretty much right. Yeah, I mean, yes, I, I mean, insofar as there's things to, I mean, look, things like the, you know, okay, so for example, studying simple programs as a. And trying to understand the universe of simple programs. Actually the personal history of that sort of interesting. I mean, I, you know, I used to do particle physics when I was a kid, basically, and then I actually got interested. Okay, so I'll tell you the history of that, just as an example of how sort of interesting is a sort of history of ideas type thing. So I was interested in how order arises in the universe. So, you know, you Start off from the hot big bang and then pretty soon you end up with a bunch of humans and galaxies and things like this. How does this happen? So I got interested in that question. I was also interested in things like neural networks for sort of AI purposes. And I thought, let me make a minimal model that encompasses sort of how complex things arise from other stuff. And I ended up sort of making simpler and simpler and simpler models and eventually wound up with cellular automata, which I didn't know were called cellular automata when I started looking at them and then found they did interesting things. And the two areas where cellular automata have been singularly unuseful in analyzing things are large scale structure in the universe and neural networks. So it turns out. But that, by the way, the fact that I kind of even imagined that one could just start, yeah, I should say I've been doing physics and in physics the kind of intellectual concept is you take the world as it is and you try and drill down and find out what makes the world out of primitives and so on. It's kind of a reduce to find things. Then I built my first computer language, I think called smp, which went the other way around where I was just like, I'm just going to make up this computer language and just make up what I want the primitives to be and then I'm going to build stuff up from it. I think that the fact that I kind of had the idea of doing things like making up up cellular automata as possible models for the world was a consequence of the fact that I worked on this computer language which was a thing which worked the opposite way around from the way that one is used to doing natural science, which is sort of this reductionist approach. And that's, I mean, so that's just an example of, you know, I found, I happen to have spent a bunch of time studying, as I say, history of science. And one of my, one of my hobbies is sort of history of ideas. I even wrote this, this little book called Idea Makers, which is about biographies of a bunch of people who for one reason or another, I've written about. And so I.