> Evolutionary arguments are notoriously tricky. > Respected scientists get them wrong all the time. Which is why clarity about that topic is especially important. As it is used herein, "evolution", as a term, refers to an algorithm. The structure and nature of that algorithm is (fortunately) not ambiguous. In other words, there is no debate about the basic algorithm form itself. And there has not been any confusion about it for quite a long time. Making these sorts of claims is a bit like saying, that a 'sorting algorithm' is going to do 'sorting'. It either works or it doesn't, by definition. In its simplest form, we can characterize the fundamental algorithm of evolution independent of whether we're using it for carbon-based life forms as a way of describing biological evolution or any other kind of thing that might be described in the use of genetic processing techniques for, for example, computing some sort of solution to a problem. As a computer scientist, I might use genetic algorithms as a heuristic as a means for solving certain kinds of problems. The algorithm itself is pretty well characterized -- it is rather well known. Roughly speaking, Evolution refers to an overall long term change in the average constitution of a constellation of sets of code values that represent a set of capabilities to create changes in a world. So, as a basic instance, we can consider a single set of code values that represent some sort of functionality in some sort of world. The set of code values themselves represent "the genotype". The functions in the world is what is called "the phenotype". The coding values themselves can change in one of two ways:. - you can either add or remove 'code points' (where code values are stored); and, where for each code point;. - you can change the code values that are stored in each code point. For example, in a binary system, 'code points' represent places (memory locations) where single bits (or bytes, etc) can be stored, and 'code values' represent the actual stored bits -- either a zero or a one -- in each memory location (each code point). Similarly, the genetic code for carbon based life consists of a sequence of base four numbers, which represent things like amino acids and proteins. Regardless of the way code values are represented in code points, there are two basic single changes; either adding or removing a code point from a total set (for a single instance of a single type of creature, for example) or changing the specific value stored at a code point. Nevertheless, both of these change types still represent a basic notion of 'change'. Moreover, it can be noticed that there are only and exactly (basically) three kinds of change:. - 1; you can change one code point (one thing). - 2; you can change all the code points in the set (change all of the things). - 3; you can change some of the things (some code points, but not all). Obviously, as far as change goes, between the minimal possible something and the maximal possible something and also considering everything in between, that this will cover the full set of possible changes. When we talk about 'single point changes', we will call it "mutation" (changing a single code point value only). When we talk about 'all of the things being changed' (ie, all code points are deleted, regardless of their specific values) we call it "survival of the fittest" or "survival selection". When we change some of the things, (either adding or removing sub-sets of code points, and/or changing at least some of the values of some set of subsets of code points), we call it 'recombination' or 'sexual selection'. Those are the terms that have been applied to the three kinds of changes in evolution. And the three together is a complete set. Notice that there is no ambiguity that there would be any others to add, or that there is any possibility of anything missing. The basic "genetic algorithm" runs as follows:. - 1; where assuming there is some collection of genotype instances;. - 2; and where there is some kind of embodied real world expression or translation of those code points into practice, into real effects in the real world. That this is called 'phenotype expression'. - 3; that the phenotype expression results in, maybe indirectly, further changes in the genotype instances (in the code sets), in any one (or more) of the three above change types, (ie; via mutation, survival selection, or sexual selection). That there is some process that results in making some sort of changes to the code (the instance genotypes). - 4; goto step 2. There is some bijection occurring where code affects world, and where world affects code, and that the resulting code changes can be in any one (or more) of the three types, and that this process just repeats over and over again in some sort of overall distributed and long term way. And that is, roughly speaking, "the genetic algorithm". It will have this basic underlying algorithmic form regardless of whether it's applied to one thing or another, (ie; to organic life, future AGI, or software problems). Thus, it is possible to be clear and unambiguous about the fundamental shape of the evolutionary algorithm. There is no real debate about any of this. ~ ~ ~