Mind Matters Natural and Artificial Intelligence News and Analysis
Program development concept. Young man working with computer
Program development concept. Young man working with computer

Why Software Cannot Just Evolve — a Demonstration

The claims for Avida — a software program that is supposed to “evolve” solutions via neo-Darwinian evolution — fail the most basic test

A Michigan State University publication headlined a media release declaring: “Evolution of learning is key to better artificial intelligence” (September 19, 2019). Reportedly, researchers used the computer simulation software, Avida, to show the “evolution of learning.” On that view, artificial intelligence arises via neo-Darwinian evolution. Really?

The “Sound Bites” Were Exciting…

The university’s team “composed of biologists and computer scientists used a digital evolution program that allowed them to observe tens of thousands of generations of evolution in just a few hours, a feat unachievable with living systems.” According to the release:

• “The results are the first demonstration that shows the evolution of associative learning in an artificial organism without a brain.”

• “While the environment was simulated, the evolution was real. The programs that controlled the digital organism were subject to genetic variation from mutation, inheritance and competitive selection.”

• The digital organisms started as “‘blank slates,’ incapable of sensing, moving or learning.” In the computer simulation, each digital organism reproduced, and “its descendants could suffer mutations that changed their behavior.”

• “Most mutations were lethal. Some did nothing.” But the rare [favorable] traits allowed an organism [to flourish] resulting in its “collecting more resources, reproducing more often and, thus, gaining share in the population.”

• “Over the generations, [the digital] organisms evolved more and more complex behaviors.”

Admiring the Avida computer simulation’s results, a program director at the National Science Foundation boasted that the researchers “have evolved associated learning in a computer from the raw ingredients of mutation, inheritance and competitive selection” (September 19, 2019). Note: The paper is open access.

Left unexamined was the question of whether computer software actually can “evolve” in the way the researchers posit for living organisms, i.e., by undirected mutations and natural selection. To believe that computer programs can “evolve” the ability to learn or any other function requires the assumption that programs can “evolve” at all. Other researchers have shown the defective reasoning and unsupported claims for Avida, which was first touted in 2004 to demonstrate successful neo-Darwinian evolution. The fundamental assumption must be tested: Can software programs undergo undirected mutation to evolve a meaningful new function?

Stephen C. Meyer, author of Signature in the Cell (2009) and The Return of the God Hypothesis (2021), posed the same question concretely in a podcast in 2017: “If you start with a functional computer program or operating system, and then you start randomly changing the zeroes and ones, are you more likely to degrade the information you have — or to get something fundamentally new, like a new program or operating system?”

How We Can Test Software Mutation

I developed a simulation system, InforMutation, to test the effects of undirected mutations using a simple computer program. First, I wrote a program in the venerable old-school BASIC programming language. True, it takes intelligent design to write this program, just as the Avida simulation was designed and written but set that fact aside for now. We’re going to test whether computer programs can be successfully mutated so we’ll assume we start with a working program that does something interesting.

I wrote the BASIC program to calculate the prime numbers from 2 to 101. That’s the same series of numbers used in the 1997 movie Contact as evidence of extraterrestrial intelligence. Here’s the program:

100 FOR T = 2 TO 101
110 M = INT(T^(.5) +1)
120 D = 2
130 IF T = D THEN GOTO 190
140 IF (T/D) = INT(T/D) THEN GOTO 200
150 D = D + 1
160 IF D<=M THEN GO TO 140
200 NEXT T
490 END
500 QUIT

Here’s the output:

 2           IS PRIME 53          IS PRIME
 3           IS PRIME 59          IS PRIME
 5           IS PRIME 61          IS PRIME
 7           IS PRIME 67          IS PRIME
 11          IS PRIME 71          IS PRIME
 13          IS PRIME 73          IS PRIME
 17          IS PRIME 79          IS PRIME
 19          IS PRIME 83          IS PRIME
 23          IS PRIME 89          IS PRIME
 29          IS PRIME 97          IS PRIME
 31          IS PRIME 101         IS PRIME
 37          IS PRIME 
 41          IS PRIME 
 43          IS PRIME 
 47          IS PRIME 

Mutations Usually Produce Permanently Fatal Errors

Next, using InforMutation’s simulation environment, I subjected the BASIC program to a single random mutation of just one character. (For the record, I ran the InforMutation simulation on February 17, 2021, for the tests here.) InforMutation randomly mutated the second line of the BASIC program — the character “5” is modified to “W.” The program shown above is the same, except that line 110 has become:

110 M = INT(T^(.W) +1)

This single character mutation amounts to a change of 3 bits of information (W = 01010111; 5 = 00110101).

What happens to the program at that point? The simulation system tries to run the mutated program but returns this message:

ERROR in line 110: Syntax error

What happened? The simulation demonstrated a reality for any kind of computer programming: The program code must follow the syntax and semantic rules of the programming language. If the program code is modified randomly, there is no reason to think the resulting program will still follow those rules.

When a program fails because of a syntax error, as in this example, the program does not run again — ever. A program that fails because of a semantic error usually produces spurious results and dies just as dead.

Neo-Darwinian evolution theory holds that an animal undergoes an undirected mutation and survives to reproduce, with its descendants undergoing other undirected mutations over thousands of reproduction cycles. Given enough such successive mutations, a new feature or function “evolves.” The Avida simulation applies this approach to programming.

As InforMutation shows, however, one small mutation in a software program is very often fatal to the software. It is not simply that the program runs just slightly wrong — the program flails or dies. Often, the program does not run at all and cannot run again even if it were designed internally to run multiple times. Other times the mutation damages the program so that it partially runs and then dies forever. With some mutations, the program goes into an infinite loop doing something that cannot be considered useful or meaningful.

Can We Manually Restart the Program?

With InforMutation, you can start the program fresh and impose more undirected mutations to see if the result ever moves in the direction of providing some other interesting output — perhaps the Fibonacci series or a printout of the English alphabet. You can run the program as often as you want, imposing bigger mutations, such as whole line substitutions, character and token exchanges, random additions, and more.

Indeed, the researchers who use the Avida system proceed in that way: The small software programs get mutated over and over, with the “successful” mutants surviving to reproduce more programs that are themselves mutated.

So, let’s start over and allow InforMutation to impose a different single character mutation. This time, line 160 gets mutated, changing the “N” character to “\”, giving:

160 IF D<=M THE\ GO TO 140

That mutation involves changing only two bits of information (N = 01001110; \ = 01011100).

When the mutated BASIC program is executed, the result is:

2           IS PRIME

ERROR in line 160: Syntax error

This test delivered a result where the mutation damages the BASIC program just enough that it runs but fails shortly after it starts. Nothing within the BASIC program can correct its syntax error; nothing within the program will cause it to ever run again so as to attempt any other mutations. The error is permanently fatal.

Multiple Bad Mutations Cannot Produce A Good Mutation

InforMutation allows you to test more than one undirected mutation at a time. Syntax and run-time errors nearly always give errors and crash the BASIC program. Changing just a few random bits in formerly running software usually kills the software permanently. Even if one random mutation doesn’t kill the software or throw it into an infinite loop, the next mutation probably will.

There is no plausible way for undirected mutations of software to (a) have a decent chance of satisfying the syntax requirements of the programming language, and (b) achieve an interesting new function, before the mutated software fails and never starts again.

Claims that Avida has shown how neo-Darwinian-like evolution can produce “learning” are intrinsically false. The digital organisms in Avida could be mutated, still run, and achieve new functions only if outside intelligent designers set up a system for mutations that either (1) never imposes syntax or run-time errors or (2) can impose errors but the organism continues to run and mutate enough to fix the errors. Either of these scenarios could exist only under one of two circumstances: The mutations are carefully directed (not undirected) or the digital organisms and the simulation system are pre-designed to tolerate a wide range of software failures and still run so that “favorable” mutations can accumulate.

Avida’s Faux Evolution is Intelligently Designed

Working with InforMutation exposes the reasons why Avida could not demonstrate neo-Darwinian evolution of “learning” software. Rather, as a product of careful design, the Avida simulation showed the the fundamental elements of intelligent design: Purpose, Plan, Engineering, and Foresight. Only with these elements could randomly-mutated programs survive and run repeatedly so as to accumulate mutations.

A National Science Foundation director is quoted as touting the Avida simulation as “open[ing] the door to creating artificial intelligence systems without the limitations imposed by human design.” That claim is demonstrably false. The Avida simulation is nothing other than a software system tuned specifically by human design — because software exposed to raw, truly undirected, mutations always dies early. If “learning” was observed in the Avida simulation, it resulted from carefully chosen features, functions, and algorithms, not from undirected software evolution.

You may also wish to read: Random evolution doesn’t produce algorithmic functions in animals (Richard W. Stevens)

Richard Stevens

Fellow, Walter Bradley Center on Natural and Artificial Intelligence
Richard W. Stevens is a lawyer, author, and a Fellow of Discovery Institute's Walter Bradley Center on Natural and Artificial Intelligence. He has written extensively on how code and software systems evidence intelligent design in biological systems. He holds a J.D. with high honors from the University of San Diego Law School and a computer science degree from UC San Diego. Richard has practiced civil and administrative law litigation in California and Washington D.C., taught legal research and writing at George Washington University and George Mason University law schools, and now specializes in writing dispositive motion and appellate briefs. He has authored or co-authored four books, and has written numerous articles and spoken on subjects including legal writing, economics, the Bill of Rights and Christian apologetics. His fifth book, Investigation Defense, is forthcoming.

Why Software Cannot Just Evolve — a Demonstration