Darwinism Design inference Evolutionary biology ID Foundations Informatics Information Intelligent Design Irreducible Complexity

Why I Love AVIDA – Detecting Design in Digital Organisms

Spread the love

There are many ID’ers who complain about the AVIDA simulation, and I for the life of me can’t figure out why this is so.

Personally, I view AVIDA to be one of the best demonstrations of Intelligent Design on the planet. It, in fact, works incredibly well. Sure, there are some sideshows that people use to make it look like AVIDA is supporting Darwinian evolution. However, AVIDA is a great platform that can be used to demonstrate and apply design detection techniques.

In an old paper of mine, I described how to reformulate Irreducible Complexity into computability theory. You can read the paper for the details, or you can read a short, non-technical summary of my ideas. The basic gist of it follows.

First, in computer programming, there is the concept of a Universal computer (also called a Turing-complete computer). A Universal computer is one that can perform any computable function. All Universal computers are computationally equivalent. Now, in reality, no computer is Universal, but just like the Ideal Gas Law gives us workable conceptions for dealing with non-ideal gases, the concepts behind Universal computers give us workable conceptions for computability theory on real computers.

So, what makes a computer Universal? As I have explained in my paper, one key feature of Universal computation is the ability to perform open-ended loops. That is, the ability to have a repetition of a statement such that there is no implicit control over the number of times that the loop executes. Let me give you a few examples. If you have programmed in any programming language, you should be able to follow.

First, let’s look at a close-ended loop. A close-ended loop looks like this:


my_animals = ["dragon", "parakeet", "chicken"];
foreach(animal in my_animals) {
print "I own a ";
print animal;
}

This is a close-ended loop, because the looping structure itself (the foreach statement) limited the number of iterations. A foreach statement is a very powerful structure, but you cannot achieve universal computation with it. It is powerful, but tame.

On the other hand, an open-ended loop looks like this:


my_animals = ["dragon", "parakeet", "chicken"];
index = 0;
while(index < my_animals.length) {
animal = my_animals[index]
print "I own a ";
print animal;
index = index + 1;
}

There is much more that can go wrong with an open-ended loop. I could forget to increment my counter. I could compare against the wrong entity. I could go backwards. I might forget a comparison altogether. However, it is also much more powerful. There are many procedures that, given a base set of functions, can only be done with open-ended loops. Therefore, open-ended loops are much more prone to failure, but they are also incredibly more powerful. There are many operations which require open-ended loops.

Therefore, since any computable function can be programmed on any Universal machine, it follows that there are functions on a given Universal machine that require open-ended loops to run. That’s where things get interesting.

Open-ended loops are not just difficult – they are chaotic. Small changes do not lead to small effects. Small changes lead to dramatic effects, such that one can’t climb the hill. It takes multiple, coordinated, simultaneous changes to make a useful change, and these changes are not incrementally useful at all – usually they are disastrous. Therefore, the possibility of a mutation that generates such a change goes up exponentially with both the number of changes required, and also (though probably not exponentially) with the size of the code base.

Therefore, my paper suggests that the way to tell a biologically-designed unit is to pick it apart to find open-ended loops. An open-ended loop that contributes towards a function essentially requires a designer. The paper has some caveats about doing this in real organisms (i.e., the actual design may be located elsewhere in a generator mechanism), but this is easy enough to analyze in AVIDA, where we know where everything comes from.

AVIDA is a great system, because it is one of the few evolutionary systems that is truly Universal. Most evolutionary systems only allow close-ended loops, precisely because it leads to fewer chaotic situations. However, this also means that the parameters of the system are what are guiding the evolution, not selection. In other words, in such cases, most of the solution is already designed-in in the evolutionary simulation. However, AVIDA at least allows for the possibility for a more open-ended evolution because its language is Universal.

Because of this, given ANY AVIDA organism, it is possible to detect the designed parts. (NOTE – it is possible that there are more designed parts than given by this method – ID goes to great lengths to remove false positives, but that means that a negative can’t necessarily be counted out). If you find an open-ended loop that contributes to function, you have found a designed part of the organism.

Also of interest – each AVIDA organism does contain a designed part – the replication loop. It is, in every case I am aware of, the only functional open-ended loop in an AVIDA system. Thus, every replicating AVIDA organism shows distinct, detectable evidence of design within the organism.

There are a very few functions that AVIDA organisms evolve, but none of these functions use or require open-ended loops to accomplish. Thus, design detection is coherently demonstrated and validated in each AVIDA organism, as well as the way in which evolution works with design to accomplish biological goals. The foundational units of operation (i.e. the open-ended loops) are designed-in, and then shifted around in a parameterized evolution to apply these units to functional tasks. The theory, simulation, and experimentation of Intelligent Design all match up in AVIDA.

I’m just not sure why so few people bother to mention it.

47 Replies to “Why I Love AVIDA – Detecting Design in Digital Organisms

  1. 1
    johnnyb says:

    Technical Notes:

    With Avida-ED’s default ancestor, that loop is “zvxg”. That is a fairly small loop, mainly because Avida’s instructions are designed to make replication easy. The “x” instruction is a bit of a cop-out (it performs several checks to make sure everything is right before performing), making the loop not quite as “open-ended” as would normally be considered. For it to be really open-ended, “x” should really do its job even if the daughter organism is not ready.

    Here is Avida’s irreducibly complex feature – the one that was built in by the designer of the original organism. What is really interesting is that Avida’s instruction set is extremely geared towards replication (such that replication can be accomplished with essentially 4 opcodes), yet it still never evolves on its own, because of the chaotic way that looping structures have to come into being.

    Being that it is only 4 opcodes, I won’t say that it is absolutely impossible (it is only ~19 bits of information – Dembski suggested a minimum of 500 bits to prevent all false positives). Nevertheless, in all of the functioning, replicating organisms I’ve tested, it is the same, inherited loop. It is design that is detectable.

  2. 2
    johnnyb says:

    So, in Avida-ED, you take the ancestor organism, drop it in, and watch it go. Then, take any other organism and drag it to your “freezer”. Then you can open it up in the “Organism” tab. Run the organism to make sure it actually replicates. If it does, you will find, towards the end of the genome, the codes “zvxg”, often with additional instructions in-between. “z” sets the marker for where the loop bounds are, “v” performs a single-element copy, “x” attempts a division and terminates the loop (but this does nothing if the replication is not finished), and “g” goes back to the point set by “z”. This is the designed replication loop from the original ancestor. Your organism will look nothing like the original organism, except that it will have this replication loop, and it will have no other function-enabling loops.

    As I said, the “x” is kind of a cheater instruction (it combines a conditional check, a function, and a loop termination in a single instruction), which makes the loop not quite as irreducibly complex as we might like, but even so it illustrates the point well.

  3. 3
    bornagain77 says:

    Or related interest:

    Avida, when using realistic biological parameters as its default settings, instead of using highly unrealistic default settings as it currently does, actually supports Genetic Entropy instead of Darwinian evolution:

    Biological Information – Mendel’s Accountant and Avida 1-31-2015 by Paul Giem
    https://www.youtube.com/watch?v=cGd0pznOh0A&list=PLHDSWJBW3DNUUhiC9VwPnhl-ymuObyTWJ&index=14

    also of note:

    Panda’s Thumb Richard Hoppe forgot about Humpty Zombie – April 15, 2014
    Excerpt: I discovered if you crank up Avida’s cosmic radiation parameter to maximum and have the Avida genomes utterly scrambled, the Avidian organisms still kept reproducing. If I recall correctly, they died if the radiation was moderate, but just crank it to the max and the creatures come back to life!
    This would be like putting dogs in a microwave oven for 3 days, running it at full blast, and then demanding they reproduce. And guess what, the little Avida critters reproduced. This little discovery in Avida 1.6 was unfortunately not reported in Nature. Why? It was a far more stupendous discovery! Do you think it’s too late for Richard Hoppe and I to co-author a submission?
    Hoppe eventually capitulated that there was indeed this feature of Avida. To his credit he sent a letter to Dr. Adami to inform him of the discovery. Dr. Adami sent Evan Dorn to the Access Research Network forum, and Evan confirmed the feature by posting a reply there.
    http://www.creationevolutionun.....idcs/?p=90

    LIFE’S CONSERVATION LAW – William Dembski – Robert Marks – Pg. 13
    Excerpt: (Computer) Simulations such as Dawkins’s WEASEL, Adami’s AVIDA, Ray’s Tierra, and Schneider’s ev appear to support Darwinian evolution, but only for lack of clear accounting practices that track the information smuggled into them.,,, Information does not magically materialize. It can be created by intelligence or it can be shunted around by natural forces. But natural forces, and Darwinian processes in particular, do not create information. Active information enables us to see why this is the case.
    http://evoinfo.org/publication.....ation-law/

    Podcast: Winston Ewert on computer simulation of evolution (AVIDA) that sneaks in information
    http://www.uncommondescent.com.....formation/

    On Algorithmic Specified Complexity by Robert J. Marks II – video
    paraphrase (All Evolutionary Algorithms have failed to generate truly novel information including ‘unexpected, and interesting, emergent behaviors’) – Robert Marks
    https://www.youtube.com/watch?v=No3LZmPcwyg

    Biological Information – Tierra 11-8-2014 by Paul Giem – video
    https://www.youtube.com/watch?v=aPf_lc3gnFA

  4. 4
    Mark Frank says:

    Johnnyb

    As I understand it the objective of Avida is to simulate how RM+NS can generate new functions. You seem to be saying that it does generate new functions but there is an element of design hidden in the program. What kind of computer simulation would satisfy you that RM+NS is capable of generating new function? To put it another way, how would Avida have to change to be convincing simulation of neo-Darwinian evolution?

  5. 5
    bornagain77 says:

    OT: Mark Frank, you might be interested in this recent video by Dr. Giem since it features your debate with him:

    Bayes’ Theorem and Atheism 3-14-2015 by Paul Giem
    https://www.youtube.com/watch?v=QW3IGBJi05A

    Of note: I personally thought Dr. Giem was very ‘gentle’ in exposing your over the top atheistic bias and appealing to your reason so that you too might see this unreasonable bias against God that is, prior to investigation, inherent in you.

  6. 6
    johnnyb says:

    Mak Frank –

    Good question. My point is that Avida does *not* have to change per se – I like it how it is! What it would have to be able to do to demonstrate the building of complex functions would be to evolve, through a selectable path, a function that incorporated an open-ended loop, such that the open-ended loop contributed towards the task.

    I like Avida because, unlike many other evolutionary software, it *allows* for evolving open-ended loops. I think a good demonstration of RM+NS would be to show that it can evolve an open-ended loop that contributes to function. However, if you look at any Avida organism, the only loop in any organism that contributes to function is the replication loop, and that was designed!

  7. 7
    johnnyb says:

    Mark Frank – If you know the creators, one feature I would like to see in Avida is the ability to extend the set of rewarded functions beyond logic functions. I would love to try to evolve, for instance, the factorial function – it is one of the smallest functions that *require* an open-ended loop for processing. Unless it has greatly changed in the last few years while I wasn’t paying attention, this is not possible.

  8. 8
    Mark Frank says:

    Johnnyb #7, #6

    Sorry I don’t know the Avida creators.

    I am bit surprised by your #6 and indeed the OP. You seem to have offered a new criterion for detecting design. Instead of IR, CSI, FSCI, DFSCI etc – you offer open-ended loops. How do they relate to the other criteria? Are they necessary or sufficient to detect design?

  9. 9
    johnnyb says:

    Mark Frank –

    The paper where I describe it more fully is here. It is basically a reformulation of Irreducible Complexity into computability theory to make some of the pieces more explicit. It is very much along the same lines as the others, but I think it shines in certain areas.

    For instance, CSI is hard to use in a practical sense. This is very easy to use in a practical sense. I could probably come up with a more formal relationship between the theories, but having a day job prevents more thorough analysis. I basically wind up with enough time to do one or two major ID or Creation-oriented projects each year, so doing that isn’t on the top of my list, though I think it would be a worthwhile study.

    Interestingly, along those same lines, Winston Ewert proved the equivalence of Algorithmic Specified Complexity and FSCI in Engineering and the Ultimate, and I also have a chapter in there relating the concepts on this blog article (or at least very closely related concepts) to non-materialistic cognitive modeling and software complexity management.

  10. 10
    Mark Frank says:

    JB

    Sorry – but I am up to my eyes in papers I have to read for a living. I just don’t have time to read one for fun. Suppose Avida comes up with an organism that generates IR or CSI but has not generated any open-ended loops. How would you react? Or is it somehow impossible?

  11. 11
    harry says:

    The problem with software that supposedly demonstrates mindless, accidental evolution in action is that it makes clear, as johnnyb is saying, the exact opposite. There is an intelligently designed utility company providing necessary electricity to the computer the software runs on. The computer was intelligently designed. The computer’s operating system was intelligently designed. The program running on it that is supposed to demonstrate mindless, accidental evolution in action was intelligently designed. It is absurd, no matter what results the execution of that program produces, to then exclaim, “Look at what can happen mindlessly and accidentally!”

    It is the same with life. I assume readers here are familiar with British mathematician/physicist Roger Penrose’s calculation of the odds of the Big Bang producing by chance a universe low enough in entropy that the emergence of life would even be a possibility to be 1 in 10^10^123. To write out that number without using exponential notation would require writing so many zeros after the “1” than even if you wrote a zero for every proton, neutron, electron, and every other elementary particle in the observable Universe, you would still fall far short of writing out the figure needed. In other words, it is simply irrational to just assume it was a mindless accident that the Universe was fine-tuned such that life could emerge and be sustained. That happening mindlessly and accidentally was a virtual impossibility. (At this point, some reader with a darkened, atheistic mind is saying to himself, “Well, we should expect, since we are here, to find that the Universe is fine-tuned for life.” Duh! That painfully obvious fact doesn’t change the odds one bit, or the implications of the fact that the Universe, in spite of those odds, is fine-tuned for life.)

    Continuing with the analogy provided by software that supposedly demonstrates mindless evolution in action, let’s consider the utility company, the computer and the computer’s operating system as “the Universe,” and self-replicating software executing on the computer, “life.” Just the fact that it would be irrational to just assume this “universe” that allows for the execution of software of any kind was a mindless accident should incline us to assume that the self-replicating software running on it wasn’t an accident, either. Yet atheistic materialism’s abiogenesis project assumes just that. And does so even though life on Earth is now known to consist of digital-information-based nanotechnology the functional complexity of which is light years beyond anything modern science knows how to build from scratch. It does so even though there are no instances of significant functional complexity known to have come about mindlessly and accidentally. It does so even though the only known source of functional, digital information is an intellect. It continues to search for a mindless, accidental origin of life even though intelligence is a known reality and intelligent agency is always a causal factor in the emergence of phenomena exhibiting significant functional complexity.

    It is simply irrational to just assume the Universe and the life within it are mindless accidents. Science, to remain true science, must remain rational.

  12. 12
    Zachriel says:

    harry: There is an intelligently designed utility company providing necessary electricity to the computer the software runs on. The computer was intelligently designed. The computer’s operating system was intelligently designed.

    That’s been the problem with computer weather modeling: There’s neither snow nor rain nor heat nor gloom of night in the computer. We’re currently running a simulation of ocean currents, but the computer doesn’t seem to like the salt water.

  13. 13
    johnnyb says:

    Mark –

    I would have to do some thinking on that. However, on first glance, I think that my standard is actually *much* lower than that required by CSI. CSI requires 500 bits. The example I used here is around 19 bits, though that is low because of the semi-cheating “x” instruction. It would more properly be around 32-40 bits. Again, that’s 1/10th the size of the requirement of CSI. However, if you had all non-looping components, perhaps CSI would be more selectable. However, if the CSI was more selectable, that might be equivalent to it having fewer *actual* bits.

    So, I’m not going to take a hard-and-fast stance on it at the moment, but those are the things that I think are good to think about. My guess is that at the end of the day, they will all wind up being relatively equivalent things, with each having their own place where they are better used. Some of them will just differ by where the markings are (i.e. Celsius vs Fahrenheit vs Kelvin), and some may have some subtle but important differences (i.e., mass vs. weight). Some of them might wind up being correlations of others rather than theoretically significant in their own right (think of the ways that ancient climate is measured). Others of them might wind up being exactly equivalent. It is my understanding, for instance, that when Newton’s and Liebniz’s calculus were first discovered, people didn’t recognize that they were equivalent, and it was only later that it was discovered that they were the same thing.

    Anyway, that’s the fun of a new field!

  14. 14
    johnnyb says:

    harry –

    While I agree with several of your later points, I think you make a few mistakes in your opening statement:

    The program running on it that is supposed to demonstrate mindless, accidental evolution in action was intelligently designed. It is absurd, no matter what results the execution of that program produces, to then exclaim, “Look at what can happen mindlessly and accidentally!”

    I disagree here with your assertion that a designed program cannot in principle be used to demonstrate what mindless evolution would do (whether anything or nothing). I agree that the program (like life itself) requires a suitable place for it to occur, and that is just as much evidence of design as life itself is. However, I think it is wrong to make the direct connection that just because the program was built by a human that it cannot simulate undesigned conditions.

    The goal of the simulation is to see what RM+NS evolution can do, and, as long as the work of the programmer is to *ensure* that it is RM+NS that is doing the evolution, I think it qualifies for consideration at least. In this case, I am perfectly happy to attribute the results of “mindless evolution” to the extent that it happens. I just think that we need to be realistic about what that is. What was it that Avida was able to accomplish? What was it not able to accomplish? To what extent was its instruction set tailored for the tasks at hand? What happens when it tries to perform computations where the instruction set was not tailored for it?

    I think these are the kinds of great questions that can be asked and answered. I don’t think the fact that Avida was designed means that we can’t, in principle, use it to answer these questions (unless, of course, it was badly designed to do so).

    Let’s take another example. Let’s say that I wanted to test the ability of a tower to withstand random weather conditions. I could, at least in principle, build a testing bed to simulate random weather conditions on the tower. I might succeed or fail in building a suitable test, but it is at least in principle possible. No one would criticize my test bed by saying, “how can it simulate random weather conditions because it was designed?” and then throw out all of the results of my studies. The results might be thrown out because I didn’t design it well enough, but not because of an in-principle problem with simulating random weather conditions in a designed space.

  15. 15
    RodW says:

    JohnnyB

    Thanks for the post.
    A serious deficit in my education is that I know very little about programming ( though I may try to teach myself Python in the near future) so I only have a vague idea of the differences you describe between open and close-ended loops and how they lead to those profound outcomes.
    My questions are: what makes you think that genetic networks could be categorized as either closed or open-ended loops?
    and..to the extent they could be categorized this way could you describe the architecture of the 2 types of loops? ie. what would be the nature of the proteins and the interactions between them that would lead to closed vs. open
    and…are there any properties of genetic networks, or for that matter living things in general that could tell you right now whether they are composed of open or close-ended loops?

  16. 16
    johnnyb says:

    Yes, if you read my original paper, I point out that in biology, similar open-ended loops occur if there is a cascade of proteins produced, such that the production of A promotes the production of B and so forth, such that a later member of the cascade is required to turn A back off. The original paper points to a regulatory system in the flagellum that operates on this principle.

    I should also make a clarification, as my original post comes off as too simplistically dogmatic (i.e., “An open-ended loop that contributes towards a function essentially requires a designer.”). More technically and exactly, the probabilistic requirements go up significantly (I believe exponentially) with the number of bits required to build a functioning loop. It may be possible, if a GP system can make an open-ended loop with few enough bits to implement, that a few open-ended loops could be found. On Avida, this requires a number of instructions, so it is rarely if ever seen. Nonetheless, for a given GP system, you could find a loop control size past which it is nearly impossible to generate loops.

  17. 17
    Zachriel says:

    johnnyb: I point out that in biology, similar open-ended loops occur if there is a cascade of proteins produced, such that the production of A promotes the production of B and so forth, such that a later member of the cascade is required to turn A back off.

    Why couldn’t a circuit evolve? We have an enzyme A. B is added as a promoter. C is then added as a regulator for B. And so on.

  18. 18
    johnnyb says:

    I didn’t say that circuits can’t evolve, just as I didn’t say that functions can’t evolve. I was very specific in the type of cascade I was talking about. There are probably other types as well, but I dealt specifically with one that matched the question.

    In your example, it is the *promoter* that is regulated by outside forces. That is not open-ended because it is inherently self-limiting. That is, nothing catastrophic happens if the promoter doesn’t even exist. However, if instead it requires a repressor to turn it off, then the result is much more chaotic, as it requires the simultaneous evolution of the repressor to keep it from spinning out of control.

  19. 19
    Zachriel says:

    johnnyb: That is, nothing catastrophic happens if the promoter doesn’t even exist.

    Why would you say that? If a particular gene is not transcribed, it could be very detrimental.

    johnnyb: However, if instead it requires a repressor to turn it off, then the result is much more chaotic, as it requires the simultaneous evolution of the repressor to keep it from spinning out of control.

    Not necessarily. We have a useful but not critical function A. However, it causes problems when the organism is in a salty environment, so it evolves a repressor B. Organisms with B are now able to invade salty environments. Over time, similar adaptations can evolve for other environments creating a panoply of possible strategies concerning the complex. Also, helpers to A may evolve, which can then, through functional migration, become essential. So we have loops upon loops.

  20. 20
    johnnyb says:

    Zachriel –

    Like most evolutionary storytelling, you think that the fact that you can phrase it in a sentence makes it easy to do biologically.

  21. 21
    Zachriel says:

    johnnyb: Like most evolutionary storytelling, you think that the fact that you can phrase it in a sentence makes it easy to do biologically.

    You based your claim on lack of an evolutionary pathway. We proposed an evolutionary pathway. We may have misunderstood your position, but handwaving is not much of an argument.

  22. 22
    RodW says:

    JohnnyB

    Zachriel beat me to my next question so I’ll pick things up where you guys left off.

    You describe a negative feedback loop as an example of an open-ended loop. ( as an aside these have the opposite properties you describe for open-ended loops ie. being chaotic etc.) Negative feedback loops are common in genetic systems, especially in bacteria and would not be hard to evolve. Consider a biosynthetic pathway that is not regulated this way. It would be wasteful and so mutations that allowed to first enzyme be shut off by binding the terminal product would be advantageous. It wouldn’t be that difficult since the first enzyme would already be binding a similar molecule.
    In trying to refute Zach’s point about evolving promoters etc. you start from an impossible position and ask can function be derived from this by NS. Of course the answer is no but this is the same as asking if a dead organism can come to life via mutations. The correct way to think about this is that at time=0 we have a fully functioning surviving organism. The correct question is ‘can mutation and selection incrementally add function and complexity to this already functioning system’? The answer is a resounding ‘yes’!

  23. 23
    RodW says:

    JohnnyB

    In your back and forth with Zachriel you suggest that because we can recognize a high level of functionality in open-ended loops they can’t result from natural processes but at the same time you acknowledge that mutation and selection can create the connections that will give rise to o-e loops. I don’t understand the disconnect. If natural processes can do it – end-of-story. Just because we understand it on some abstract level has no bearing on how it comes into existence. Its as if you said the experience of Beauty is profound and moving. Its very difficult for artists/designers to create beauty. Therefore, beauty can’t arise from natural processes. Therefore the Rocky Mountains didn’t arise from geological processes, they were literally sculpted by a designer.

  24. 24
    harry says:

    johnnyb @ 14

    Hello johnnyb,

    Thank you for your very thoughtful reply to my remarks.

    Software can be written to effectively simulate reality. There is no doubt about that. Yet if simulators purportedly demonstrate that what is completely unrealistic is actually realizable, one has to suspect that the simulation, no matter how sincere and well-intentioned its authors may be, is defective, e.g., a simulation of a tornado constructing houses.

    Any software that genuinely simulates the inexorable tendency of matter to disintegrate into a more likely state is not going to demonstrate the mindless, accidental increasing integration of matter resulting in increasing functional complexity. That is simulating a tornado building a house.

    The crux of the issue is the likelihood of an instantiation of significant functional complexity emerging mindlessly and accidentally; that happening is well beyond the probabilistic resources the Universe provides.

    Being a programmer, you are aware of the fact that mindless modifications to software (at least our modifications seem mindless when we find the bug ;o) don’t ever prove to be advantageous, but instead decrease functionality, if not result in the complete cessation of all functionality. This is why we don’t fix bugs in software or add features to software by randomly altering bytes in the executable on disk and then relaunching the program to see if we fixed anything, or if any new features were added. Such mindless modifications are the only kind mindless processes can make. Even if only the exceedingly rare, accidentally advantageous modifications are selected, they would be so rare that RM+NS would always be taking one step forward while RM alone is taking two trillion steps back. You just can’t develop functionality that way, much less increase it. Simulations purporting to demonstrate a mindless increase in functional complexity are not simulating reality.

    It is absurd to think a computer and operating system might come about mindlessly and accidentally. Penrose’s calculation makes it simply irrational to just assume that the environment life would require was a mindless accident. Like a computer and its operating system make software a possibility, but doesn’t make the mindless production of functional software possible, so the intelligent configuration of the Universe made life a possibility, but didn’t make its mindless, accidental instantiation possible.

  25. 25
    johnnyb says:

    RodW –

    I apologize, but I literally have no idea what your second post means. Please try to rephrase. I think I answered your first post in my reply below to Zachriel.

    Zachriel –

    My problem is with the statement “so it evolves a repressor B”. Here’s the deal – repressors don’t just pop into existence. The lack of a repressor would cause it to be a drain on fitness in a different environment. In other words, the whole system would be de-selected before the new system came online. It would be a lot easier to ditch the useless gene than to evolve just the right repressor for it, if it survived long enough to do either.

    In order to make a plausible evolutionary story, you have to know how many neutral and harmful mutations you need before you have a functional system again. These are known as potentiating mutations. The problem is that the probabilistic resources required for *each additional* potentiating mutation is essentially exponential. And, it gets worse, because the organism has to survive, and not select away, the potentiating mutations before they are useful.

    That is the computational problem, and simply saying, “well, what if it happened” doesn’t solve the problem, especially since it had to happen over and over and over and over again in the history of life.

  26. 26
    Zachriel says:

    Zachriel: We have a useful but not critical function A. However, it causes problems when the organism is in a salty environment, so it evolves a repressor B.

    johnnyb: The lack of a repressor would cause it to be a drain on fitness in a different environment. In other words, the whole system would be de-selected before the new system came online.

    No. In the example, it lives well in the salt-less environment, but doesn’t prosper in the salty environment.

    johnnyb: It would be a lot easier to ditch the useless gene than to evolve just the right repressor for it, if it survived long enough to do either.

    Then it would be at a disadvantage in the salt-less environment. With the regulator, it is best adapted to a changeable environment.

    johnnyb: In order to make a plausible evolutionary story, you have to know how many neutral and harmful mutations you need before you have a functional system again.

    Given the evolvability of links, loops are evolvable. That contradicts your argument. That leaves the question of whether links are evolvable, but has nothing to do with loops.

  27. 27
    johnnyb says:

    “Then it would be at a disadvantage in the salt-less environment. With the regulator, it is best adapted to a changeable environment.”

    Right, but it has to *get* there. This is the problem. Evolutionists forget that there has to be reasonable biological intermediaries. That’s exactly the problem with open-ended loops – the chaotic nature of the loop makes the intermediaries unstable, and *less* selectable. They are more likely to go back than go forward. In fact, if you run Avida with a mutation rate that matches observed rates, it evolves practically nothing at all, because it always favors the stable configuration over the potentiating ones.

    “Given the evolvability of links, loops are evolvable.”

    Incorrect. That is a mere bald assertion that is contradicted by available evidence. Go run Avida-ED yourself. It takes minutes to get setup, and you can leave the simulation running as little or as long as you wish. Call me when it evolves a new functional loop.

  28. 28
    Mung says:

    johnnyb, let’s not confuse the implementation with the abstraction!

    >> [1,2,3,4].each {|item| puts item}
    1
    2
    3
    4
    => [1, 2, 3, 4]
    >> for item in [1,2,3,4]
    >> puts item
    >> end
    1
    2
    3
    4
    => [1, 2, 3, 4]

    Neither of these depend on the actual size of the enumeration.

    Speaking of a closed loop, what would you call a loop that does this?

    >> int = 10
    => 10
    >> [1,2,3,4].each {|item| puts item + int}
    11
    12
    13
    14
    => [1, 2, 3, 4]

  29. 29
    Mung says:

    Zachriel: Why couldn’t a circuit evolve?

    Indeed. And why can’t dragons fly?

    http://en.wikipedia.org/wiki/Circuit

  30. 30
    Mung says:

    Zachriel: We proposed an evolutionary pathway.

    Really? You are so pathetically confused. A pathway implies an end. Ends are verboten!

  31. 31
    johnnyb says:

    Mung –

    “johnnyb, let’s not confuse the implementation with the abstraction!”

    Actually, it is the implementation that is important. Once it is abstracted (which is done by intelligence), then the evolution is do-able.

    All of your examples are closed loops – the abstractions are self-limiting. Also importantly, you cannot create a Turing-complete system with only those looping constructs.

    However, with open-ended constructs, you don’t need very many instructions to have a Turing-complete system. In fact, you only need one – “subtract and branch if negative”.

    Once they are abstracted, then they are able to be put to use in more mechanical ways. I dealt with this a little bit here.

  32. 32
    Mung says:

    Don’t go all weird on me.

    You defined a close-ended loop as follows:

    This is a close-ended loop, because the looping structure itself (the foreach statement) limited the number of iterations.

    How do either of the two loops I presented limit the number of iterations?

  33. 33
    Zachriel says:

    johnnyb: Right, but it has to *get* there. This is the problem. Evolutionists forget that there has to be reasonable biological intermediaries. That’s exactly the problem with open-ended loops – the chaotic nature of the loop makes the intermediaries unstable, and *less* selectable.

    We provided what we thought was a plausible pathway. You then seemingly changed your argument to the difficulty of evolving individual links. Perhaps we misunderstand your position.

  34. 34
    johnnyb says:

    Mung –

    “How do either of the two loops I presented limit the number of iterations?”

    How do they not? A foreach loop only works on fixed-length arrays, and only iterate for the length of the array. They are inherently limited. You will *not* run into the halting problem (and, relatedly, not be in a Turing-complete system), using those constructs.

    Zachriel –

    “We provided what we thought was a plausible pathway.”

    It’s easy enough to make stories and call them plausible. Here I give specific reasons why specific types of those pathways are not very plausible mathematically. Therefore, if you disagree, you need to show *why* these are plausible. You also mistake the question of whether a certain configuration is *selectable* with whether it is *produceable*. It’s all well-and-good for X to be selectable if it actually arrives. But the process question is whether it will arise, given that every intermediate stage has to be selectable as well, and it has to find the solution.

    The problem with open-ended loops is that the intermediate forms are less fit than either the previous form or the final form. This is due to the chaotic nature of open-ended loops (and also the reason for the difficulty of the halting problem, as well as the power of Universal machines).

    “You then seemingly changed your argument to the difficulty of evolving individual links.”

    The problem – which has been the same for over a hundred years (i.e., Mivart), is that the individual links are where the problem actually lies. Whether in incipient structures, potentiating mutations, or the more computational formulation of them as open-ended loops, the problem is that (a) the chance of hitting one in a single shot decreases exponentially with the size of the base loop, and (b) the chance of hitting one in through a selective path is essentially zero, because the steps are less selectable than either the original or the final product. It requires multiple components to be in-place before being selectable. Before that it is actually a dramatic decrease in fitness. This is due to the chaotic nature of open-ended loops.

  35. 35
    Zachriel says:

    johnnyb: The problem with open-ended loops is that the intermediate forms are less fit than either the previous form or the final form.

    Our scenario doesn’t have that problem.

    johnnyb: The problem – which has been the same for over a hundred years (i.e., Mivart), is that the individual links are where the problem actually lies.

    Then it has nothing to do with loops, and your argument is wasted.

  36. 36
    johnnyb says:

    Zachriel –

    “Our scenario doesn’t have that problem.”

    Yes it did, and I described how it had that problem in comment #25 & #27.

    “Then it has nothing to do with loops, and your argument is wasted.”

    Yes it does. The individual links are required to build the loop, but the direction of selection goes backwards while the links are building.

  37. 37
    Zachriel says:

    johnnyb: My problem is with the statement “so it evolves a repressor B”. Here’s the deal – repressors don’t just pop into existence. The lack of a repressor would cause it to be a drain on fitness in a different environment. In other words, the whole system would be de-selected before the new system came online. It would be a lot easier to ditch the useless gene than to evolve just the right repressor for it, if it survived long enough to do either.

    Per the scenario, the lack of a repressor would cause it to be a drain in the salty environment. The system would not be de-selected because it could still live in the not-salty environment. Salty is a continuum as well, so there would be a trade-off between the advantage of A, and the advantage of not-A, depending on the level of salt. Being able to control the function of A would give the organism the ability to survive in either environment, or in a changing environment.

    Notably, your objection is independent of the existence of a loop.

  38. 38
    Mung says:

    How on earth did I not say “don’t go all loopy on me!” lol

    Let’s try another perspective.

    Say that an “open ended” loop is one without end.

    You’d soon get off into memory areas that had nothing to do with what you were hoping to iterate over. The program would crash because memory itself is finite.

    That said, your allegedly open ended loop isn’t. It suffers from the same defect that you ascribe to close ended loops.

    while(index < my_animals.length)

    What is animals.length if not a fixed length array?

    And I am coming from the Ruby language, where the size of an array is dynamic.

    input = []
    loop do
    input.push(gets.chomp)
    end

    Now that’s an open ended loop!

  39. 39
    Mung says:

    Zachriel: We provided what we thought was a plausible pathway.

    A plausible pathway to what? A pathway has an end. Ends are forbidden. Plausibility has nothing to do with it. In fact, injecting the idea of “plausibility” only contributes to the point.

    People understand the “plausibility” according to the relevance to the “end.”

    Are you trying to bring teleology back to biology Zachriel?

    Perhaps we misunderstand your position.

  40. 40
    johnnyb says:

    Mung –

    Again, you misunderstand. What makes the loop open-ended is that the control structure itself does not manage the length. In a while loop, there are several independent parts that all have to be working for the loop to function.


    index = 0;
    while(index < myanimals.length) {
    index = index + 1;
    }

    There are three separate parts – the “while”, the “condition” (which itself has parts), and the “increment”. All of these have to evolve in coordination. If any of those are not perfect, the loop will spin out-of-control. In the “each” example, there is literally no way for the loop to spin out of control. I can describe an infinite number of while loops that can spin out of control. I can describe zero each loops that spin out of control.

    Here are some examples:


    while(true) {
    // spins out of control
    }


    index = 0;
    while(index < myanimals.length) {
    // oops, forgot the increment, spins out of control.
    }


    index = 0;
    while(index < myanimals.length) {
    index = index - 1; //oops, decrementing instead of incrementing, spins out of control
    }

    There are zero scenarios with an each loop where it spins out of control. Thus, while loops are open-ended, and each loops are not. Something like a while loop is required for a language to be Turing complete, while each loops do not make a language Turing-Complete.

    Zachriel –

    “Notably, your objection is independent of the existence of a loop.”

    You misunderstand. My objection is to the formation of loops. I agree with their existence. The question is how can they be formed by selection? Life is full of them. Their existence and abundance is very clear evidence of design.

    “The system would not be de-selected because it could still live in the not-salty environment. ”

    You know this how? Oh yes, it’s one of those imaginary evolutionary scenarios which don’t have to have anything to do with reality that we can just pop into existence when we need them. Again – Avida-ED is there. Pop it in. Run it. Find a loop that contributes to function. It will be the originally designed replication loop. This is empirical data, not imaginary story-telling where the world works exactly as you wish it for your dreams to come true.

    “Being able to control the function of A would give the organism the ability to survive in either environment, or in a changing environment.”

    I agree! But it has to be able to *get* to the control, first. You can’t select what you don’t have, and for materialists, you wouldn’t get it because you can’t evolve it. Again, go to Avida. Run the simulation. Tell the world your results.

  41. 41
    Mung says:

    johnnyb: There are zero scenarios with an each loop where it spins out of control.

    That would be determined by the implementation not the abstraction. You’re making the same mistake you made earlier, which is to confuse implementation with abstraction. You didn’t listen to me then, so you repeat the error.

    I can easily write an implementation of each that spirals out of control. Do you believe me? Try it yourself, it’s easy.

    A while loop, as you have described it, is only open ended in a perverse way.

    Here is a truly open while loop:

    while(true)
    end

    It’s an infinite loop. There is no case where the condition can be false.

    In contrast your example:
    while(index < myanimals.length)

    It is implicit here that the condition (index < myanimals.length) may evaluate to false. If it is never false this is known as a logic error and no different from writing:

    while(index)
    end

  42. 42
    johnnyb says:

    “I can easily write an implementation of each that spirals out of control.”

    I agree. That’s not the point. You miss what the evolutionary algorithm is evolving. The evolutionary algorithm isn’t evolving an implementation of each, it is using an implementation of each. Thus, we assume its validity. The question is, what does the evolutionary algorithm do with it?

    With the while statement, even if while is perfectly implemented, the evolutionary algorithm can screw up with it. However, there is a relationship between having constructs that you can royally screw up and being able to program arbitrary functions. If your system doesn’t have features that you can screw up and get yourself in an infinite loop, then it also doesn’t have enough features to write arbitrary computations. Being able to write infinite loops is a necessary condition of being able to write any computable function.

    Therefore, if your system only has a well-behaved each loop, then you CANNOT program any computable function even in principle – they cannot be coded . You are heavily constrained in the computations you can perform. It is only when you have constructs such as while which allow for the possibility of infinite loops that allows all computable functions to be written. However, with constructs such as while, the difficulty in evolving an application that makes proper use of them goes up exponentially, because, as my examples pointed out, all features have to be correct for the while loop to actually do something reasonable.

    I get the feeling that you had an initial reaction to my thoughts, and rather than actually reading what I wrote with charity, you simply impose your gut-reaction to what I was saying in place of what I am actually saying.

    Think carefully about what it would look like for an evolutionary algorithm to work with a “while” statement. What happens at each step? How does that affect fitness? When the “while” loop first appears, what is the likelihood that it has parameters that are stable vs unstable? What about the each loop? If the “while” loop doesn’t break the program when it enters, what are the chances that changes to it will be catastrophic? Compare that to changes within the “each”. When evolving using a “while” construct, can I modify a working while such that it spins out of control into an infinite loop? Yes. When evolving using a “each” construct, can I modify a working each such that it spins out of control into an infinite loop? No.

  43. 43
    Zachriel says:

    Mung: A plausible pathway to what? A pathway has an end.

    Pathways can form circuits, or even more complex mappings.

    johnnyb: My objection is to the formation of loops.

    That’s what we gathered.

    johnnyb: You know this how? Oh yes, it’s one of those imaginary evolutionary scenarios which don’t have to have anything to do with reality that we can just pop into existence when we need them.

    You’re making a logical argument. As such, exploring plausible scenarios is appropriate.

    johnnyb: Again – Avida-ED is there.

    Avida is an instance. Your claim was applied to evolution broadly.

    johnnyb: But it has to be able to *get* to the control, first.

    So your argument has nothing to do with loops, but with adding any links whatsoever.

    johnnyb: With the while statement, even if while is perfectly implemented, the evolutionary algorithm can screw up with it.

    Sure it can, but those would be deselected. Only those links that are beneficial can be added to the circuit.

    johnnyb: However, with constructs such as while, the difficulty in evolving an application that makes proper use of them goes up exponentially, because, as my examples pointed out, all features have to be correct for the while loop to actually do something reasonable.

    Let A be an enzyme that removes salt in order to strike a balance between too much salt and too little salt. However, salt may be low in many environments, and the organism does well without A. However, with A, the organism can invade more salty environments, the disadvantage being that too much activity from A results in too little salt.

    In relatively stable environments, A is duplicated, traded, or removed over several generations resulting in multiple strains, closely related, adapted to differing levels of salt, sharing the A gene among them. However, if A should become regulated, and if the environment were subject to rapid change, then the regulated A strain would have an advantage over strains that have to slowly evolve or trade for the appropriate rate of A activity.

    Now we have a two-part system; A and the regulator of A. This is a simple while circuit. While salty, then A. More complicated circuits can be built the same way. There is nothing about the while circuit that is unevolvable, given the evolvability of function.

    Are you arguing that regulators can’t evolve at all?

  44. 44
    Joe says:

    Evolution isn’t being debated, Zachriel. Perhaps you should educate yourself as to what is actually being debated. That way you won’t come off as an equivocating lackey.

    Unguided evolution cannot account for regulation…

  45. 45
    johnnyb says:

    Zachriel –

    “if A should become regulated”

    But the whole question is whether it could become regulated at all. I agree with you 10000% that “if A should become regulated” that it would be selected for. The question is, what sorts of regulatory modes are evolvabled, and why or why not?

    “Avida is an instance. Your claim was applied to evolution broadly.”

    The whole point of Avida is to investigate claims of biology that are generally handwaved away. This would be a good example of that. Avida happens to be the one experimental place where this can be examined. If you wish to propose another experimental methodology where the idea of magic-popping-into-being regulatory circuits that you propose can be tested, I would love to give it a hearing. Without it, that leaves Avida to be the main source of empirical data, which is why I am emphasizing it.

    What makes it good science is that anyone can re-create the experiment. I showed you how. If you think that Avida is a bad platform for such an experiment, you should say why. This is one of the advantages of having reproducible experiments – the experimental setup is open to critique and discussion. Imaginary magical scenarios are much more difficult to critique and discuss. So, if you think that Avida is a poor choice for examining this claim, please let me know what limitation Avida has and why it is important for this question, and negatively impacts Avida’s ability to generate such loops.

  46. 46
    Zachriel says:

    From what we understand, Avida presupposes a ‘chemistry’ composed of logical operators, not algorithms.

  47. 47
    Mung says:

    Zachriel: From what we understand, Avida presupposes a ‘chemistry’ composed of logical operators, not algorithms.

    lol. nuff said.

Leave a Reply