My blog about philosophy, coding, and anything else that interests me.
05 – Knowledge in Computer Programs
Artificial Creativity
This episode relies heavily on video components, so you’ll want to watch it on YouTube: https://www.youtube.com/watch?v=DHR6roiZjQ8
Apologies for the audio quality in this episode; it varies and cuts out sometimes.
References
- David Deutsch, “The Beginning of Infinity” chapter 10, “A Dream of Socrates”
- Stephen Hawking, “A Brief History of Time”
- David Deutsch, “The Beginning of Infinity” chapter 7, “Artificial Creativity”
- David Deutsch, “The Fabric of Reality” chapter 6, “Universality and the Limits of Computation”
Further reading
- QuickCheck: http://hackage.haskell.org/package/QuickCheck
- “Turtles all the way down” concept: https://en.wikipedia.org/wiki/Turtles_all_the_way_down
- “Why is the Quantum so Strange?” - interview with David explaining computation (among other things): https://www.youtube.com/watch?v=MckuBQC6gKU
- The Clojure programming language: https://clojure.org/
If you have any questions or comments, please leave them here or tweet at me: https://twitter.com/dchackethal
Subscribe to this podcast via RSS Back to all episodesTranscript
This transcript was generated automatically and may contain mistakes.
Welcome back to the podcast on Artificial Creativity. This is the fifth episode. It’s about how to store or represent knowledge in computer programs. There is something interesting about the fact that epistemological rules apply not only to explanations, but computer programs as well. Some of those rules are that good explanations are hard to vary, that some explanations have reach, that good explanations are discrete, and so on. How they and other rules apply to computer programs and what that means, we will see in this episode.
Now we will get into some code in this episode, but I would like to remind you here that if you don’t have a background in computer programming, that’s totally okay. I will try to make this as accessible as possible. We’re not even going to program that much. Remember that no one is born with this knowledge, so we all had to learn it at some point, and in our infinite ignorance, we’re all the same anyway. And if you have any questions, please do tweet them at me. I will do my very best to answer them. On whatever platform you’re listening to this, a link to my Twitter profile should be in the description.
Speaking of listening, this is an episode that has video components, since I want to show you some code, so I highly recommend that you pull this up on YouTube. A link to the YouTube video should also be in the description, because otherwise you will have a hard time following much of this episode. So if you’re not on YouTube already, go ahead and pause this and pull it up there instead. On that note, I also want to mention that I will most likely make the transcripts of these episodes available online because as we are getting more and more into the weeds here, I think being able to read along will help also. I don’t know yet where I will put them, but once I do, I will let you know.
Let’s recap the previous episode real quick. We roughly answered the question of how we know, how is knowledge created, and what knowledge is. Knowledge consists of explanations. Different bits of knowledge, as it were, are adapted to solving different problems. Knowledge creation is an evolutionary process in an individual’s mind that works by conjecture and refutation, and this process is creativity. Good explanations are hard to vary, meaning changing any part of a good explanation diminishes its ability to meet its purpose. And in order to make progress in any field, we need to create good explanations.
A universal explainer is a general purpose problem solver whose capacity to solve problems is only dictated by the knowledge he has, and of course, as everything else, by the laws of physics. We learned that creativity can be used to copy existing knowledge as well as to create new knowledge. Both are powered by the same mechanism. We therefore concluded that knowledge creation is a replication effort, that to understand anything means to replicate it mentally. People are general purpose explainers, which means they are general purpose knowledge creators, which means they can replicate any explanation. So knowledge and replication take a center stage here. So what we need to do in order to build artificial creativity is, among other things, figure out how to represent explanations in computer programs, and then how to write a computer program that can replicate them.
You’re probably wondering at this point why we need to talk about software engineering at all, because epistemology on the face of it has nothing to do with software engineering. I don’t think that’s true, but never mind that for now. Our goal is to eventually build artificial creativity. And we already figured out that due to the universality of computation, building it is a software project, not a hardware project. So if we want to build this thing, at some point we need to write some code.
There is a deeper reason, too, that I hinted at in the last couple of episodes, and that is that programmers have already contributed to epistemology by finding rules governing the improvement of the structure of programs. Good programs, just like good explanations, are hard to vary. Now, just about anything is only good if it is hard to vary. I don’t think a piece of art can be good if you can easily imagine changes to it that would make it better. The same is true of a movie or a book or a building.
The deeper connection here is that explanations can find their counterparts in computer programs. If we want to build something that can create explanations, we need to know how to encode explanations in computer programs. And that’s what we’ll get into in this episode. We will explore epistemological rules as they apply to computer programs, and we will look at how we can encode explanations as functions.
To start off, I want to tell you a story. When I was a boy in elementary school, I remember sitting in math class and listening to our teacher introducing the topic of multiplication. I don’t remember what grade this was, maybe second or third, but I do remember being pretty fond of math at the time. And the teacher introduced the topic of multiplication as follows. Before explaining any of it, he posed an open question to the room. He asked, how do you think multiplication works? I raised my hand and said something along the lines of, well, I know that when people do multiplication, they say things like three times five. So my guess is that to calculate this, you need to add five three times. So in this case, it would be five plus five plus five.
In other words, I remembered some clues I had gotten previously from the environment, from which I could guess an explanation of how multiplication worked. This is knowledge creation in action. My teacher had an explanation of multiplication in his mind that we as students needed to replicate in order to understand it. We couldn’t download this explanation directly. We had to guess. The example of multiplication will come up again and again in this episode, so I suggest you keep it fresh in memory.
There is a lot of implicit knowledge in the statement you need to add 5 three times. Add to what? And it’s not 5 and 3 for every calculation, so the use of variables was implied here too. Another concept that was implied was the concept of looping, including some condition to terminate the loop. And I remember using fingers on one hand to count the number of iterations I had done so far. So I would show one finger and go 5, and then I’d show a second finger and go 10, and then I’d show a third finger and I’d go 15, and then I’d stop. This, by the way, is what computation is. I was using physical objects, my fingers, to represent abstract ones, in this case numbers.
Implementing multiplication as a computer program is a fun and easy way to make this example more explicit, so let’s try it together. We will use a language called Clojure, which is a modern programming language. It doesn’t matter all that much which programming language we use, most of them are general purpose and so you could do what we’re about to do with any of them anyway. But Clojure is a remarkably simple language, and so my hope is that it will allow us to focus only on the things that matter. As a bonus, much of the research in genetic programming has been done using this kind of language. The family of languages Clojure belongs to is called Lisps, so it may help us later.
If you don’t understand everything line by line, that’s totally fine. All that matters is that you get the general idea, and if at the end you think you’re seeing just a bunch of parentheses, which you will see Clojure uses a lot, everyone’s been there too. But in time, I promise you won’t even notice them anymore.
So let’s start here. What we’re doing is implementing a function that can multiply two given numbers. Now, in Clojure, the way you declare a new function is using this defn thing. And we’re going to give the function a name. And it’s going to take two parameters, two numbers, a and b. And then the function has a body, and this is basically the meat of the function, and what’s going to happen here is we’re going to have to loop, and basically we’re going to have a counter that we’re going to set to zero to start out with, and we want to keep track of the result we have, and we’re going to start out with zero for that one too.
And then what we’re going to say is we need to check, well, if in the current iteration, are we still not done? So if the counter is less than a, then we want to keep going. And so we’re going to call recur. And recur basically tells the loop to iterate again. And this time, we’re going to pass in a counter that is one greater than before. So we’re just going to add one to the counter. And we’re going to add something to the result. We’re going to add b to the result. However, next time, if we iterate and we are done iterating, then we just return the result.
So when you write Clojure, you’re basically in the business of writing functions. This whole thing is a function now, and defn is, like I said, how we declare it. Times is a name. So now we could reference this function elsewhere using that name. And by function, I don’t just mean mathematical functions. I mean, this would work not just for numbers, but you could write a different function that would work for words or, you know, lists of things and collections and whatnot. So a programming language is a lot more flexible than this. But here we’re arbitrarily constraining ourselves to just using numbers in this particular example.
Something, if you’ve seen other programming languages, that you may not be used to is, for example, this thing here. Usually you would write something like counter less than a, so you have to read this kind of in a different order. This is called Polish notation. So you open the parentheses, then the first thing within the parentheses is a function you want to invoke, and then all the parameters to the function are passed in as a list behind that. So this reads as, is the counter less than a?
Something else you should know is when we call recur, this part right here, because it’s the first argument that’s provided to recur, is going to replace this first part of the loop instruction right here. And this is the second part to recur, so it’s going to replace the second part. So what is this going to do if we were to run this? Well, basically it would say, let’s say we invoke this with 2 times 3, okay? So basically what it would do is it would say, well, we’re going to go in the first time, we’re going to set the counter to 0, and we’re going to set the result to 0. And then we’re going to check, is the counter less than a? So is 0 less than 2? Indeed it is. So we’re going to run this first branch of the if statement. And this says, okay, run this loop again. This time, increment the counter to 1 and add b to the result. So this is going to be 0 plus 3.
So now the second time it goes in and it says, okay, the counter is now 1 and the result is now, put this here, and the result is now, so the first one was one, and the result is now three, okay? And then we’re going to say, well, is one less than two? Indeed it is still less than two, so we’re going to loop again, and this time we’re going to say, well, increment the counter to two and add three to the result, because b is still three and the result is currently three, so this ends up being six. And then we’re going to go in and say, well, is the counter still less than two? And no, at this point in time the counter is now two, so this is going to evaluate to false, which instructs the if statement to go to the second branch, which simply returns the result, which at this point is now six.
So if you don’t understand every single bit of this, don’t worry about it, and I want to encourage you not to give up, and like I said, don’t worry about all the parentheses. But the point here is that this is a hard-to-vary computer program. Most changes would break it. You could change the counter to one if, instead, if you also want to change less than to less than or equal to, that’s a change you could make. Another change you could make without breaking it is change the order of the parameters. You could call the first one b and the second one a. That would still work because multiplication is commutative. But that’s about it. So this is a hard-to-vary function implementation.
Also, now that it has been created, the function is largely autonomous, just like explanations are. So whether we like it or not, functions have some reach. They contain certain errors, and they carry out a purpose. This function has some reach. I mean, it works for all integers, so perhaps we could call it a universal integer multiplier. But it doesn’t work for floats, so you couldn’t use it for any number. But it is commutative, as we would expect from a multiplication function.
The function also depends on several underlying functions or underlying concepts. It depends on the concept of looping, it depends on the concept of conditionals, indicated by this if statement, it depends on the concept of comparison, and it depends on the concept of addition, both here in the plus function and the inc function. That means it would be very difficult to build this function without any of these underlying concepts. This also means that as a child, if my explanation of multiplication was anything like this computer program, then I would have needed to know these concepts in advance or come up with them at that time, which would make the problem harder.
For autonomy, we should make sure that this function really works for any integer. I don’t think it works when the first parameter is negative because the loop depends on the number being positive here, because otherwise the counter is never less than the negative number a. So in terms of autonomy, we may think this function does one thing when it really does another. So as a bonus, I encourage you to run this in a Clojure REPL and see if it works for, say, negative 2 times 3.
Another law of epistemology is that good explanations are discrete. So to get to another hard-to-vary implementation of multiplication requires more creativity. We can try it out right now. So if we try to build another implementation of this, well, let’s see what else we could do. We could, for example, say repeat a b times. Don’t worry about this arrow here. This is called a thread last operator. It basically just allows us to write the following parts in a more intuitive order. So we’re going to repeat a b times. So if, for example, a is three and b is five, what we’re going to end up with here is a list that looks like this. It just contains the number three five times. And now that we have that list, what we can do is basically just apply the plus function to it.
So what this will end up looking like is plus these five threes. And this will, of course, give us the correct result, 15. So this one is pretty hard to vary also, except for being commutative. So you could again swap a and b in the parameter declaration. You could get rid of the threading operator and move things around a little bit, but I think this reads better, so actually this is kind of hard to vary in itself.
What’s interesting is you could replace apply here with a function called reduce, which instead of doing this all at once would basically say, okay, what’s three plus three? That’s six. And then what’s six plus three? That’s nine, and so forth. So it kind of does several additions pairwise instead of one big multi-element addition here. So since we can make that replacement, my guess is that if you can change part of a well-adapted function without making it worse, then that’s an indication of the reach of the replacement.
But I like apply a little better here, but overall, I think the second implementation is better than the first one because we use the built-in repeat function, which extracts the concept of looping into its own separate function, and as a result different parts of this function are more isolated from each other, which makes them easier to read and test. This is a special case of being adapted to a particular purpose. Our previous function here, this implementation was adapted to the purpose of multiplication and looping, but we were really only after an adaptation to multiplication. So this means that extracting those sub-concepts into their own separate well-adapted functions is a good idea because it makes the parent function better adapted to its purpose as well.
Now this second function depends on the concepts repeat, apply, and addition, so it would be difficult to build it without having those functions first. It also means that a creative recombination of the concepts of repeat, apply, and addition can lead to the entirely new idea of multiplication. A function’s underlying functions, like repeat, apply, and plus in this case, we can consider implicit, and to make them explicit we have to look up their implementation. Likewise, just as some knowledge is explicit, we know that other knowledge is implicit because we cannot quite put it into words.
Now here would be an example of an implementation of this same function that would be easier to vary. So we could do the same thing, but we could at the end add plus. So, if I can spell this. So, this line, this last line is completely useless. It just adds zero to the result. We can get rid of this entire line without reducing the whole function’s ability to fulfill its purpose.
But let’s explore the concept of being hard to vary a little further. As we said, being hard to vary means being hard to change without diminishing a function’s ability to fulfill its purpose. If we can easily make changes without diminishing or perhaps we even end up improving the function’s ability to fulfill its purpose, that means the current implementation is easy to vary. I think this works two ways. Either a function is easy to vary with respect to its particular purpose, this indicates a sort of internal variability, or it is easy to vary with respect to fulfilling many different purposes without really being adapted to any of them. This I consider a sort of external variability. This last example here is an example of a function that is easy to vary internally because the whole function performs a particular purpose, but we can make changes to its internal structure without ruining that purpose by getting rid of this last line.
An example of a function that is easy to vary externally, we can call this function perform. It’s so easy to vary that it’s actually hard to come up with a name for it. And basically, it’s just going to take any function at all and some arguments that we want to apply to that function. And then all it’s going to do is it’s going to call that function with those arguments. I mean, this line performs any function at all, right? This is not very useful. All this function does is call any given function with the provided arguments. It’s easy to vary because it works for any function that’s passed in, and so it’s not adapted to a particular purpose. And as a result, the structure doesn’t explain anything. It just passes the job of explaining onto the apply function. So we could have just used apply to begin with.
It’s a kind of regress, I think. It is a bit like watching a conjuring trick and explaining it by saying the conjurer did something, which is also an example I’m borrowing from David Deutsch, if I’m remembering this correctly. The explanation is not false, but it is bad. The perform function has tremendous reach because it applies to any function at all, but that reach came at the cost of its adaptation to a purpose. It doesn’t have a purpose, and that resulted in a bad implementation.
Now you can combine these two kinds of variability to get an example of a function that is easy to vary both internally and externally. So actually, let’s put this up here. If up here we said add zero to nothing, and then also just invoke any function whatsoever, while it’s still doing that, it’s still having that really, really broad purpose. But in addition, we now have this useless line that doesn’t do anything. So this, I would say, is easy to vary in both ways. Also, because it was easy to vary this, it was easy to add this, to make this change here, that useless change. That means that easy to vary functions are not discrete. We can easily introduce almost random changes with little creative effort to get another easily variable function.
Now, I’d say in epistemology an example, a real life example of an explanation that is easy to vary internally is, for example, you perform multiplication by repeated addition while wearing a hat. An example of an explanation that is easy to vary externally is, in order to do x, you have to understand it first. Its internal structure is sound and correct, but it applies to anything at all. An example of an explanation that is both easily variable internally as well as externally is, the gods did it. It is easily variable internally because you could replace gods with angels or wizards, and it would still explain as much. And it is easily variable externally because it explains anything at all. My guess is that most explanations that are easy to vary externally are also at least to a degree easily variable internally, but that would require some more investigation. We did see that happening here though.
Here’s another parallel between explanations and functions. They can’t be proven true. An explanation is something that is tentatively held as being true. There also wouldn’t be much value in repeatedly finding confirming instances for the theory unless they were part of a test that had some chance of falsifying the theory. Otherwise, those confirming instances would just tell us something we already know. For more on that, I recommend you read “The Beginning of Infinity” chapter 10, “A Dream of Socrates”, in which David says that if an oracle tells you something you already know, surely that won’t count as a revelation.
So for example, general relativity cannot be proven true because it is stated in such a way that it is true at all times everywhere. This is by design, so that a single problematic observation could in principle refute it. That means in order to prove it true, you would need to fail to prove it false at every spacetime coordinate in the universe. This is impossible. The same holds for function implementations. No matter how many tests succeed, we have always only run a finite number of tests compared to the infinity of tests the function would need to pass, so we can’t assign probabilities either.
Programmers may see this as an occasion for despair. Some of them may say, well, if I can’t become more confident that my programs are running correctly, why bother testing them at all? Well, that’s easy, because the more errors you correct, the better your programs get. Here’s an example. Let’s say we get some part of the implementation of our multiplier function wrong. This guy right here. And when asked to calculate 4 times 4, instead of returning 16, we get, say, 22. That means that part of this implementation is wrong, and with some effort, we can correct it. And then once corrected, the function is objectively better adapted to its purpose, assuming that that change didn’t introduce more issues.
But can we be sure that next time it calculates, say, 400 times 271, that it does so correctly? Well, not until we try. Can we try every pair of numbers? And can we even be sure that the same pair of numbers will yield the same result the second time and the third and so on? Well, no. We can have good explanations of that, but we can’t be certain. But our function has a hard-to-vary implementation, and that’s all we’re after. And so we tentatively adopt our function implementation with regard to the problem it is designed to solve. There are tools available to programmers that randomly generate test cases to catch flaws in programs, such as a tool called QuickCheck. Programmers should use tools like this because they help them catch bugs and make their programs better. But if they use these tools to become more confident in their code being bug-free, they are mistaken.
Now just as a bad explanation can still explain something and may even be true, a bad function implementation does not necessarily mean you cannot run it. But when we do find an issue with an explanation or a function implementation, we want to avoid so-called ad hoc fixes. An ad hoc fix is a fix that doesn’t require much creativity and does not explain why the function failed in the first place. For example, remember how we said we had a multiplier function that works great except for some reason it returns 22 instead of 16 as an answer to 4 times 4? Well, consider this implementation here. Say we have our multiplier function. And we know that there is some that there’s something wrong with implementation. So we have some faulty implementation here. And we know that it fails for four times four, but it seems to work for everything else we’ve tried.
Okay, so what we could do is we could say, well, if a is 4 and b is also 4, then we just return 16. And in all other cases, we run our algorithm that we know is faulty, right? Because it’s not going to get those numbers that it can’t perform. I mean, if we were to do this, we were basically bending over backwards to make this thing work because we’re hard coding the solution for that case rather than solving the underlying multiplication problem. This way we sort of immunize our function against criticism this way.
This has similarities to real life as well. So in 1919, experiments were conducted during a solar eclipse that were designed to test Einstein’s then newly proposed general theory of relativity. Now, they ended up corroborating his theory, but imagine those experiments had gone differently and had ended up refuting the theory. If he had then said, oh, but the eclipse fell on a Thursday and general relativity works only on all other weekdays, not only would he have immunized his theory ad hoc, he would also have lost all credibility as a scientist. And by the way, the experiments on that day never proved Einstein true, as so many sources claim. They simply failed to refute the theory.
The similarity between epistemology and the rules of how to write good computer programs doesn’t stop there. We can even translate some philosophical misconceptions into function implementations that work poorly. Consider the doctrine of instrumentalism, which states that science cannot describe reality and therefore shouldn’t even bother explaining anything but only predict. Well, first of all, there is no such thing as an explanationless prediction. For the same reason, there cannot be a return value without a function.
But let me try and give an example of a really poor explanation of multiplication that resembles instrumentalism. This function in here, this is another implementation of multiplication, but basically what’s happening here is that all the possible answers are hard-coded. So we know if a is one and b is one, the answer is one. If a is one and b is two, the answer is two, and this keeps going. This is basically a multiplication table. All the answers are hard-coded, and this goes up to some, let me, you know, maybe this goes up to 10 times 10, who knows. But this is such a bad explanation of how multiplication works that no one would ever write such a program, and yet this is precisely what instrumentalism claims science is about. This also shows why explaining multiplication well is better than just giving someone a multiplication table.
Now, some bad explanations involve something called an infinite regress. For example, the claim that design requires a designer then begs the question, well, who designed the designer? And so forth, ad infinitum. Stephen Hawking tells the following story in his book “A Brief History of Time”. There are variations of the story, but his account is as follows. Quote, a well-known scientist, some say it was Bertrand Russell, once gave a public lecture on astronomy. He described how the earth orbits around the sun and how the sun in turn orbits around the center of a vast collection of stars called our galaxy. At the end of the lecture, a little old lady at the back of the room got up and said, what you’ve told us is rubbish. The world is really a flat plate supported on the back of a giant tortoise. The scientist gave a superior smile before replying, what is the tortoise standing on? You’re a very clever young man, very clever, said the old lady, but it’s turtles all the way down.
Of course, explaining the world in this way is a bad explanation because it doesn’t explain anything. This problem can be found in computer programs as well in the following form. We can directly translate that example into a computer program, we can say defn tortoise. And let’s actually wait to implement that. And we say earth just calls the tortoise function. And we said, well, the tortoise is just standing on top of another tortoise. So basically, that’s analogous to the tortoise function just calling the tortoise function again. I mean, you kind of have to read this bottom up. So if you try to invoke this earth function, it will in turn invoke the tortoise function, which is here, which from then on will just keep invoking itself.
It will actually keep trying until the computer runs out of memory to keep track of the progress it has made in calling the next function. This is known as a stack overflow. But the deeper reason here is that this is problematic not just because of limited memory, but that the tortoise function does not explain anything. It just keeps delegating. As a quick aside here, to those of you who are programmers, you may recognize that this is part of a mechanism called recursion, which is of course a valid and useful tool in any programmer’s tool belt, but recursion works because at each iteration something is being explained, and because eventually there is a condition to terminate.
Now, all of these examples of rules of epistemology applying to computer programs serve a particular purpose, namely the purpose of suggesting an answer to the question of how we could encode explanations in computer programs. Let’s go back to our good implementation of multiplication earlier. This one right here. Oh, sorry. This one right here. I contend that as I was sitting in that classroom when I was seven or eight years old, the explanation of how to multiply that I had in my mind looked something like that. Since then, I’ve rarely run this function because I’ve memorized the results for small integers. Likewise, the results of certain function invocations in computer programs can be cached or remembered in a way. And for larger numbers as well as for decimal numbers and fractions and so forth, I use different algorithms.
But all this is to say that I don’t think the similarities between the rules about what makes a good explanation and what makes a good function are an accident. I guess that that is so, because function implementations are explanations. A function’s body is the explanation, the function’s parameters are the experimental setup or the initial conditions, the return values are the function’s predictions, running a function is to make a prediction, and running two or more functions with the same parameters expecting the same return values is to test them in order to find a problem.
In “The Beginning of Infinity” chapter 7, “Artificial Creativity”, David says that if you can’t program it, you haven’t understood it. By this, I think he means that if you really understand something, and you know how to write computer programs, you are able to replicate what you’ve understood in the form of a computer program. I think this is an excellent yardstick to gauge someone’s understanding of something, and given what we just discussed, I would like to reformulate it in a stronger version. To understand something is to program it, if only mentally. This doesn’t mean people who are not software engineers can’t understand anything. It means that our minds all have a programming language, and to understand anything means to implement a function that replicates that thing in our personal programming language.
My teacher knew how to multiply. There was a function in his mind that he had originally created in response to the problem of how to perform multiplication. He wanted to pass this knowledge on to us, and so we had to recreate it. And by recreating it, we understood it. In “The Fabric of Reality”, chapter 6, “Universality and the Limits of Computation”, David writes that it is computability that makes reality comprehensible. Computability is also what makes the evolution of living organisms possible. The underlying link here is knowledge creation, as we discussed in the previous episode.
So let’s wrap this up. The fact that functions are explanations and vice versa, that explanations can be represented on computers by functions, we could state as a sort of equivalence principle. The reason we don’t think in terms of computer programs from day to day is that explaining things comes so naturally to us. But I conjecture that every explanation you as an individual have is a program that runs in your mind, which you can invoke to make predictions or to test it.
And the origin of that program is creativity, meaning the output of the creative algorithm takes the shape of functions. This works not just for math, but for any function. Understanding and giving directions, understanding a recipe from a cookbook, how to drive a car, how to play the piano, anything at all that can be learned can be modeled as a function implementation. To understand anything means to write a program of how it works in one’s mind. This is the universality of computation applied to epistemology. When there is a regularity in nature, we seek to explain it. By doing so, our explanation not only incorporates that regularity, it is a functional representation of that regularity in our minds. It replicates the regularity. Therefore, replicating a function is the computational counterpart to creating an explanation.
I know we covered a lot in this episode, but if you want to take away just one thing, it is this conjecture. Functions are explanations, and explanations are functions. In the next episode, we will combine what we know so far to propose a particular problem phrased in terms of software that I hope will present an actionable item towards building AGI. As always, thank you for listening, or watching in this case. Please leave a comment if you have any questions, and I hope to see you next time.
What people are saying