Cover art for ‘09 – The Problem Of Specification’

09 – The Problem Of Specification

Artificial Creativity

Listen on Apple Podcasts Listen on Google Podcasts Listen on Spotify

References:

  • David Deutsch, “How Close Are We to Creating Artificial Intelligence”, https://aeon.co/essays/how-close-are-we-to-creating-artificial-intelligence
  • David Deutsch, “The Beginning of Infinity”, chapter 7, “Artificial Creativity”
  • Karl Popper, “Of Clouds and Clocks”, chapter 6 of “Objective Knowledge”
  • Brett Hall on David’s chapter “Artificial Creativity” in “The Beginning of Infinity” part 1 https://www.youtube.com/watch?v=taRSfDmBwts and part 2 https://www.youtube.com/watch?v=lIwZLL67V68 (part 2 especially goes into remaining problems with evolutionary algorithms I have outlined)
  • John Koza, “Genetic Programming”, chapter 9: “Nonrandomness of Genetic Programming” and chapter 28: “Spontaneous Emergence of Self-Replicating and Evolutionarily Self-Improving Computer Programs”

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 episodes

Transcript

This transcript was generated automatically and may contain mistakes.

Welcome back to the podcast. I’m currently traveling in Europe and so I’m recording today’s episode in Vienna. I figured it’d be a good spot since this is where Popper grew up and wrote “The Logic of Scientific Discovery”. I even went to his old address and wanted to take a picture of the building only to find it surrounded and covered by scaffolding. They seemed to be renovating the place so it was impossible to see. Anyway, today we’re talking about the problem of specification and some problems with present-day evolutionary algorithms. I’d also like to put forward some speculations as to how one might think about solving some of these problems, as well as some speculations about creativity in general.

Traditionally, programs have been written to a specification. That means that knowledge of how the program is supposed to work exists in the programmer’s mind first. For example, and I’m borrowing this from David’s Aeon article, “How Close Are We to Creating Artificial Intelligence?”, you could build a program that converts centigrade to Fahrenheit. To build this, a programmer needs to know the underlying algorithm that can perform the conversion. This means the programmer creates the knowledge of how the algorithm works, which, as we saw in episode 5, is that algorithm itself encoded in the programmer’s mental programming language.

By the way, we don’t know what this mental programming language looks like, but there must be one. Otherwise, our minds wouldn’t work, and we couldn’t explain anything. Anyway, the programmer then makes that knowledge as explicit to himself as possible, so he can then translate it into code that runs on a computer. Then he can run it and compare the implementation on the computer with the implementation in his mind. As long as there are differences, he keeps fixing the computer implementation. All this is to say that the knowledge of how to write the program originated in the programmer, not the computer.

What we’re faced with when trying to build creativity appears to be a different problem. We don’t want to think of solutions to problems first and then translate them into computer programs because then we’re the ones being creative. We want our computers to be creative instead. So it seems that we’re at an impasse. In order to write the creative algorithm we would need to specify it, which by definition defeats the purpose of what a creative algorithm is. It appears that the very act of writing a specification precludes creativity.

This has led some to believe that knowledge creation cannot be an algorithm and therefore it cannot be programmed. But that would be a violation of computational universality, so I think this problem can be solved. After all, creativity must be encoded in us somehow, for example genetically, otherwise we wouldn’t have it. So specifying a program that creates new knowledge must be possible somehow without specifying the new knowledge first, and that is because the only thing that needs to be determined in advance is general rules for how the new knowledge, or the new functions in other words, can be created at runtime, while making sure that none of the particular functions the program may output are determined in advance, meaning when writing the program.

Therefore, I think that the problem of specification is just a reformulation of the problem of knowledge creation. We need to make sure, though, that the specified mechanism to produce new functions has universal reach, that in principle, any computable function could result from it without specifying those new functions in advance. This must be possible because evolution in our minds genuinely creates new knowledge, and if it happens out there in the real world, it must be explicable, which means it can be written down as a function. So much like the knowledge of how to write a particular program may originate in a programmer, the knowledge of how to create new knowledge is specified by our genetic code, or even partially memetically, we don’t know.

Another problem that has led some to believe that creativity cannot possibly be encoded as an algorithm is that its results are inherently unpredictable. Knowledge creation is indeed deeply unpredictable, but that doesn’t mean it’s not specifiable on some level. For example, people have already written functions that can create unpredictable results, such as random number generators, and I’m referring to true random number generators here, not pseudo-random ones, that while we’re not able to predict the exact return value, we can place some constraints on all possible return values. For example, each return value is going to be a real number between 0 and 1.

We can imagine a theoretical random number generator that could return any real number between 0 and 1 with arbitrary precision. So it’s possible it might return a particular real number no person has ever held in his mind before. Likewise, we can constrain our predictions of the outputs of the creative algorithm in some ways based on an explanation of how it works. For example, we can predict that it will output hard-to-vary computable functions. The particular function it outputs at any given time may be unpredictable, but that doesn’t mean the way it does so is not specifiable.

We can absolutely specify criteria for what the output, or rather the range of outputs, would look like. I don’t have the solution to these problems now, but my guess is that for the reasons I just mentioned, specification on the highest level does not preclude knowledge creation. After all, we can consider evolution and our genetic code to have endowed us with, or specified, the creative program. But we still have all the freedom to come up with genuinely new knowledge.

I also guess that most of what needs to be determined in advance is that we’re interested in solving problems. And so what the creative program does will be determined in part by the problems it encounters, and by the underlying regularity it tries to replicate or explain. So not exclusively by the programmer. Also, since it creates new knowledge at runtime, the longer it runs, more and more of the knowledge it contains will have been created by itself, and the knowledge of the programmer embedded in it will only inhabit a smaller and smaller fraction of all the knowledge in the program. Its functionality is also partly influenced by the knowledge it has created in the past, much like humans often try to explain new problems with, well, with something they already know. So in short, there must be a way of specifying knowledge creation without specifying any of the particular knowledge later created at runtime.

There are other issues with present-day genetic programs that distinguish it from real evolution. Usually they are programmed in such a way that there is a central control unit that handles reproduction and selection based on explicit fitness functions. But in evolution in nature, no explicit fitness is ever assigned. It is implicit, and individuals reproduce themselves. They are active. Selection and elimination also occur on an individual basis, and all of this happens asynchronously in nature, whereas in genetic programming these things usually happen in lockstep. John Koza was aware of these discrepancies, and he covered them in chapters 9 and 28 of the first book of his series called “Genetic Programming”.

Since creativity is an evolutionary process of trial and error elimination, another guess is that while some elements of the creative algorithm are random, at least the part that conjectures new functions since these are blind guesses, this randomness is limited in some way, so that randomness gives it some freedom beyond specification, but this freedom is nonetheless limited in a specifiable way. This is reminiscent of an essay Popper wrote called “Of Clouds and Clocks”. Much like one may think an algorithm that works like clockwork could not allow for creativity, and a completely random algorithm could not allow for creativity either, Popper argued that both pure physical determinism, so the idea that the entire universe works like a giant, very precise clockwork, as well as physical indeterminism, the idea that the entire universe and every event in it is the result of chance, both destroy the possibility of creativity.

Instead, Popper claims that the freedom to create something new is, quote, “the result of a subtle interplay between something almost random or haphazard and something like a restrictive or selective control”, end quote. I think part of the creative algorithm, when faced with a problem, creates a sea, or perhaps a big cloud, of random functions that are candidate solutions to that problem. One of our selective controls is that of being hard to vary. When a randomly generated function solves a particular problem, it sort of clicks into place and is not discarded but remembered.

Here’s another speculative idea to address the problem of specification. If this cloud of functions is created by harnessing some naturally occurring physical process, for example in the brain, there is no need to specify the creative part. The only thing that needs to be specified in terms of software is the selective control, and the physical process needs to be reproduced somehow. Using such a physical process, neither the creation of the cloud of functions nor the weeding out of unfit ones need happen in lockstep, and replication and selection can happen on an individual basis. The cloud is made up of functions which continuously try to copy themselves and compete for processing power and real estate, or memory. The selective control that we program then finds problems, meaning conflicts between those functions, according to a specified formula that is not creative.

This way, if we understand what that naturally occurring process is, that functions leverage to copy themselves, the creative part may not even need to be programmed, only the problem-finding part. In all of these cases, the functions actively replicate themselves with high but imperfect fidelity, leading to random mutations. The point is that if these mutations are part of this naturally occurring process, they are potentially truly random, which is another thing that distinguishes present-day genetic algorithms from real evolution. Genetic algorithms, as far as I’m aware, introduce only pseudo-random changes, but variations need to be blind, not planned to any degree. Unfortunately, I do not know what naturally occurring process we should be looking for, so I can’t help but point out again how speculative this is.

What’s interesting is that the problem-finding part, though not creative itself, may not need to be specified either. Problems may be an emergent phenomenon of two or more functions clashing, and then no control unit is necessary to find problems, though it remains to be discovered how it is determined which function wins. One thing I don’t like about this hypothesis is that it introduces the notion that if such a naturally occurring physical process exists in the brain that powers the random creation and mutation of a cloud of functions, it makes the brain special in terms of hardware and thereby infringes on computational universality. We can still simulate that process on a computer, but I’m worried that by attempting that we introduce the problem of specification again for the creative part as well, and then we’re right back where we started, since the whole point of this hypothesis was that the creative part may not need specifying.

At the very least, I think we will need to think of functions as individual actors and a problem as a kind of competition between two or more functions, and we will need to think of reproduction, selection, and variation as things happening not through a control unit but on an individual basis. If we want to avoid looking for such a naturally occurring process, we will need to give functions the ability to copy themselves and compete for resources. Again, this is all highly speculative, and I may be completely wrong, but it’s a problem worth keeping in mind. We will need to find a way of specifying something without limiting its ability to create new knowledge.

And this is closely related to another problem as well. We need to make sure that not too much human knowledge leaks into the program at the time of writing it, because if too much leaks, we may not be able to tell so easily how much knowledge originates in the program at runtime, or if it’s all or mostly human knowledge we inadvertently embedded in it when we wrote it. As David points out in chapter 7 of “The Beginning of Infinity”, the much more obvious explanation for anything in evolutionary algorithm outputs is the creativity of the programmer, at least in present-day evolutionary algorithms. Therefore, I suggest to not even use something like Clojure in the final program, because Clojure contains a lot of human-invented functions that already have reach and that are already adapted to particular purposes, and that reach may be mistaken for the product of evolution.

When the program comes up with a solution to a problem, it may just be reusing a built-in function that already has the reach to solve that problem. So to go as bare-bones as possible, I suggest we use something like lambda calculus or a subset of Clojure that only represents lambda calculus. This is a functional language which, even though it contains only single-parameter functions and nothing else, is Turing complete. So we know it has the requisite repertoire to run the creative algorithm. At the same time, though, it’s extremely bare bones, and it contains only that functionality which makes it Turing complete and nothing else. So my hope is that this way, the language and its subroutines evolve along with the creative algorithm. When this isn’t the case, it’s usually an indication that no real evolution occurred, and that all the relevant knowledge was created by the programmer.

Another problem with present-day genetic programs is that variation and selection on their own may not quite constitute evolution. As David explains in that same chapter, chapter 7, the emphasis here needs to be on knowledge creation by variation and selection. Otherwise, you’re just varying and selecting existing knowledge. Consider that favorite example of ours of multiplication. Is a recombination of the concepts of looping and addition a genuinely new piece of knowledge? I go back and forth on it. I don’t know the answer. According to my explanation of knowledge in episode 5, I should consider a program to have created new knowledge if, when it encounters a problem, it outputs a function that was not hidden in its implementation. In any case, Brett Hall also goes over the remaining problems with evolutionary algorithms in his video on chapter 7. I’ll link to it in the description.

Evolution is blind. It doesn’t have a goal in mind. Present-day evolutionary algorithms do, though, and they are filled with knowledge the programmers put in. In any case, it’s okay to encode some knowledge in the program, namely in the knowledge of how to create new knowledge, since that’s just what our genes gave us, but presumably we want to encode that knowledge and nothing more. Where did that knowledge come from? And if knowledge is required to create new knowledge, where did that first type of knowledge come from? It sounds like an infinite regress. My guess is this question is similar to the question, or maybe it is the question, what is the origin of life? Because maybe the question “Where does new knowledge come from?” has the same answer as the question “Where does knowledge come from, period?” But that’s a problem for another time.

Thank you so much for listening. If all goes as planned, in the next episode I intend to revisit the current state of AGI research and the software development industry in general. There have also been some interesting developments lately, so I’d like to catch up on those, so be sure to tune in for that. And until then, leave any questions or comments on Twitter. Link is in the description. Bye.


What people are saying

What are your thoughts?

You are responding to comment #. Clear
Markdown supported. cmd + enter to submit. You have free speech here. You’re responsible for what you write. Terms, privacy policy
Your real name is preferred.
This small puzzle helps protect the blog against automated spam.

Sign your comment with GPG to create or add to a public profile with all your comments.

Paste a detached signature of your comment.

              
Paste your public-key block if you haven’t before. You consent to your key’s contents, including your name, being displayed to the public.

              

Preview

Playing ~