|
Darwinism
vs. Teleology in Genomic Change, Part 1 Creationism and Change Creationists are falsely considered to be supportive of species
stasis. This isn't totally unjustified. Many people who are
new to the debate understand intuitively that unbounded change
is not possible without intervention, and when Darwinists label
the other side as being for fixity of the species, they accept
the label uncritically, simply assuming that this is the other
side of Darwinism, and is required of creationism.
Those are the lower and upper Biblical limits of the amount of change within an organism. There are other non-Biblical limitting factors of organismal change:
Genomic Change Historically, the extent to which Creationists would allow the possibility of organismal change was limitted to what Wood classifies as heterozygous fractionation. This is basically the filtering of genes from generation to generation to become more and more homozygous within a population, and another population to become homozygous in another allele. This accounts for some amount of measured change within and between species. However, as noted by several creationists, the amount of organismal change that can occur through this process is not enough to account for the present variety of species, given the number and diversity of them that are known to be in the same biblical kind (many of these are known absolutely through breeding, both experimentally and in the wild).There have been two issues that have hindered Creationists from understanding genomic change more fully:
As Mendellian genetics came to light, it became apparent that the gradualistic approach of Darwinism had to be at least somewhat modified to interact with the discrete inheritance view of Mendel. Mendel's approach was actually used by Mendel himself to argue against gradual and unbounded variation. He pointed out that if you have discrete units of inheritance, they can only be recombined in discrete ways. The combination of Mendellian genetics and Darwinism is known as the Modern Synthesis or the Neo-Darwinian Synthesis or just Neo-Darwinism. The way that they were integrated is this:
Of course, while we are talking about genes and genetics, this was all before we discovered DNA, and thus were able to find out how such characters were actually stored in the cell. When you add DNA to the mix, you find out that what was really happening underneath was that the genes were coding for specific proteins, and one of the biproducts of certain genes were the characters being observed. However, what is even more interesting is that the expressed external characters that we were keeping track of were not the interesting part. The interesting part is that the DNA code was a giant manual for manufacturing proteins. The proteins work together in very complex ways, and the expressed characters were among the least important or interesting of the things that were occurring. So, while the morphology of the organisms were interesting, the web of interacting proteins making the cells function was where the real interesting things were happening. It wasn't just the morphology of an organism, but in order to support the morphology required a complex web of biochemical pathways, all coded for by DNA. So now, while mutation can be applied to morphological characters, it is way more complicated than that. Not only must the morphology have changed between organisms, but also the biochemical pathways supporting that morphology. And the required changes must be happenstance, not directed by the organims. And it has to be able to make these changes a small step at a time, without destroying essential machinery. If it morphs too fast, it would cause error catastrophe and kill the cell completely. If it morphs too slowly, nothing will happen. In fact, if a particular adaptation requires multiple changes, it may not be able to adapt at all if the adaptations are slow. Christian Problems with Darwinism It is important to keep in mind what, specifically, the problems Christians have with Darwinism are. Primarily it is this: that life did not need God to bring it into existence, or to order its path. Even removing origin-of-life questions, Darwinism says that purpose is unimportant for life. As Christians, we see the voice of the Lord speaking life into matter -- the life was totally dependent on the voice of the Lord to come into being. The aim and purpose of Darwinism is to remove teleology, the study of purpose, from biology. Christians view purpose as being completely intertwined with all of life.Notice, it isn't change per se that is the problem with Darwinism. It is the purposeless self-creating that is problematic. Note that I have not used the word evolution yet in this essay. The reason is that the word evolution has a wide array of meanings. I prefer to be very specific about my criticisms of biological theory. Clearly there is much in biology, and with the study of organismal change, which is very good. Unfortunately, depending on who you talk to, evolution can mean anything from any sort of change to the idea that life arose unplanned entirely through material causation. Thus, when you criticize evolution, it is unclear what, specifically, the criticism is aimed at. Therefore, I try not to use the word evolution in my criticisms, because it does more to confuse than clarify. I suggest others do the same. Now, the other problem is with the idea of Universal Common Ancestry. Universal Common Ancestry seems to violate the idea of things reproducing after their kind, as well with the specific idea of man being made from mud from the ground. Scripture seems to indicate that man was made as a direct act of creation from unliving material, not from an existing life form, as Universal Common Ancestry would indicate. Biological and Algorithmic Problems with Darwinism Huxley and Typewriting Monkeys -- The Probability Theorem Does Not Show Life is InevitableThe big scientific problem with Darwinism is the idea that information can make itself. The idea that it could was popularized in the Huxley/Wilberforce debate. Huxley pointed out that if you had an infinite number of monkeys on an infinite number of typewriters for an infinite length of time, you would eventually have all of the great works of literature written. The probability theorem states that as the number of trials increases, the probability for a given set of independent events approaches one. He pointed out that with this mechanism, you would eventually find even the entire Bible written. He said basically that anything that God could accomplish, could be just as easily accomplished simply with enough time. This line of argumentation lead to the acceptance of the idea that information could create itself.However, as you may have guessed, there are several problems with Huxley's argument. First of all, to dispense with the obvious, the use of a typewriter itself imparts a huge amount of design onto what the monkeys were doing. It forced all of the monkeys typing to be within the range of intelligible characters. Imagine, for instance, if instead of giving them typewriters you gave them pencils instead! You would not have anything of meaning at the end of the timeframe. Allowing a typewriter increased the information potential of the monkeys by several orders of magnitude. Second of all, to dispense with another easy an obvious idea, an infinitude of time is much longer than the 21 billion years hypothesized for the age of the universe, or the 4 billion years hypothesized for the age of the earth. 4 billion years may seem like a long time to you and me, but, for example, even if one of our monkeys were typing at several hundred letters per second, the chances he would type "thelordismyshepherdishallnotwant" in that time frame is next to zero. However, there are three other issues which are much more interesting. First of all, lets say that we have a pile of paper with all of the things that the monkeys have typed. Where, specifically, is the information we are looking for? Where is the Bible within this mess? Well, in order to have a usable Bible, we would have to find the Bible within the pile of information. It's not enough to know that somewhere in here is all of the great works of literature, especially since in that same pile are all of the bad works of literature, as well as more jibberish than even imaginable. Finding the great work within that mess would be even harder than writing it from scratch. Who would decide where the great literature was? Even with all of the possible works of literature within the paper, it still would require an intelligent agent to pull meaning and greatness out of it. In fact, it still requires an intelligent agent to produce a work that is distinct from the noise. Think, for instance, of a tree sculptor. You know -- those people who cut trees into beautiful shapes. Or an ice sculptor. Within the tree stump or the ice block are all possible combinations of art forms. Before Mount Rushmore was carved, face could have been engraved into the rock. The rock had within it all of the possible shapes, but yet it was not enough for all of the shapes to be in there somewhere. It took an artist to cut through the rock that was not beautiful to find the work of art within. Such is the process for the ice sculptor and the tree sculptor. Just having an infinitude of forms within the tree or the ice is not good enough, one must pull and highlight the good to be an artist. Thus, with the data that the monkeys generated, there was no process which separated out the good work from the bad. So, at the end you are still in the position of the ice sculptor before he sculpts. Having an infinitude of possibilities does no good whatsoever. You still need a designer to pull out the design from the randomness. The next problem is even more severe. Remember that the probability thoerem -- which was the basis of the original proof -- says that as the number of trials gets larger, the probability approaches one. That's all good and well, but you need to look at what the probability theorem applies to. It only applies to independent events. That is, only if event #X is completely independent of event #X-1 does the probability apply at all. Physical reactions are not independent events. They are dependent on each other. The next problem carries on top of the previous one. In biology, almost all of the reactions that take place are reactions. This means that the reactions are reversible. So, what would happen, is that as the improbable events leading up to the first life form were occurring, it would be more and more probable that the previous events would come "unglued" and fall apart. Going back to the typing monkeys example, let's say that the monkeys could type forwards, or erase what has been there. Let's also say that as the line the monkey was typing got longer, it became more and more likely that he would erase what was there. That is an equilibrium reaction. At the end of all eternity, at the end you would have nothing at all (well, at most you would have a few lines of gibberish). So, as you can see, the argument from typing monkeys was always a fallacious one for numerous reasons, though it has persisted in public thought as a reason of why information can create itself. The Nature of Computational Systems and ProgramsLet's stop talking now about typing monkeys, and look at the biological problems of information self-creation. Cell biology is much like a machine, or more specifically, a machine being run by a computer. You have, essentially, a code, a way to replicate the code, a way to run the code, and a system that mediates the action of the code. In fact, in cell biology, you have the only naturally occurring Shannon information system. That's an interesting topic, but I don't have time to get into it here.The most interesting thing about biology is that it is coded information and algorithms. In order to understand why this is so important, we need to discuss codes, algorithms, and complexity. I once saw a Dilbert cartoon where a salesman was trying to sell a computer that was so easy to use, an idiot could use it. It didn't have a keyboard or a mouse, it just had one button. Of course, the reason that is funny is because there is absolutely nothing useful that a stupid person could do with a one button machine (a complex system like Morse Code could be established, but then it is no longer simple -- you have simply switched one form of complexity for another). With a one button machine, the only states you have are "pushed" and "not pushed". If the machine is truly idiot-proof, then that means that all possible button states are accounted for. You essentially have a computer that can do two things -- it can do one thing when the button is down, and something else when the button is up. In fact, you can have a computer with a multitude of states and combination of states that is still idiot-proof. You just have to code for all of the possible combinations, and make sure that each possible state makes sense. Such an arrangement is good if you only have a limitted number of tasks you wish to accomplish, and perhaps may need a few independent arrangements of these tasks. You just have to flip the right switches and everything works out fine. In fact, even if you switch the wrong switches everything will turn out fine. It may or may not do what you wanted it to do, but you won't break the system or lose data by throwing the wrong systems. At worst, you might process a file that didn't need processing. Now, such a system is very robust -- there is not much you can do to really screw it up. In fact, pretty much nothing you could do would be catastrophic to the system. Likewise, if you forgot which button does what, you would be quite safe pushing all of them until the right thing happened. But such a system, being absolutely foolproof, is not very expressive. You can't get it to do much outside of its original setup. In fact, it has two interesting properties:
Now, let's expand our computer a little bit. let's add a keyboard. Let's also say that you can give the computer sequential, low-level commands. For example, you can tell it to add two numbers and write them to a file. This computer is a little more interesting. It allows you to put together your own processing steps. However, it is also more dangerous. Because you are putting together your own processing steps, you can easily mess yourself up. For example, if you added two numbers, but wrote them to the wrong file, you could accidentally overwrite an important file. However, you are fairly safe from harm. As long as you do a few basic checks, you should be worried about too much. This new system has some features that are different from our last system. On this new system:
Now, let's build a third computer, but on this one lets add flow control statements. A flow control statement is something that says "Do this if this other condition is true". Or "repeat this until a certain condition happens". It allows you to conditionally execute a part of a program, or to repeat certain program paths, or any combination of conditions and repetition. You could repeat a section of program that had multiple conditionals, where each time the conditions change. Here you have much more complex system behavior. In fact, at this point (depending on the programming model), you can do any mathematical computation that can in principle be automated. Note that there are other flow controls than conditionals and repitition, but they do not expand the computational complexity of the programs which you can create. Now, with this sort of complex behavior, you have all sorts of potential errors that can creep in. You can have a conditional statement whose condition is not exacting enough. You can have a loop that never reaches its terminating condition. You can have a multitude of conditional statements within your loop which have a few possible cases which are incorrect. You can have a condition improperly controlling a loop. The possibilities for error are endless. In fact, it often takes hours to find small mistakes, and the smallest mistake can have disastrous results on your program. Simply turning a conditional on or off, or having a slightly improper terminating condition for a loop can completely destroy a programs ability to function. However, only at this stage do you have the full computational power at your fingertips. So, in this system:
Here is a summary of the systems we have looked at so far:
Hopefully you can see that in order to be easily modifiable, most of the complexity must be coded into the system at the cost of flexibility to the user. As the system becomes more capable and flexible for the programmer, it becomes more and more susceptible to problems arising from coding problems. If the program holds the complexity, then arbitrary changes to the program can be disastrous. However, if the system holds the complexity, then arbitrary changes to the program are not disastrous. Note that there are more fine gradations than what has been shown here, but it is the trend that is important. The flexibility of a programming system stems from the fact that there is a certain amount of chaos inherent in it, which the programmer can harness to serve very interesting purposes, but which can lead to catastrophe if not managed in a very exacting way. This idea is given support by Stephen Wolfram and Matthew Cooke in their experiments with cellular autonoma. Matthew Cooke was able to show that even in very simple systems, if they demonstrate enough chaos in their workings, they can be harnessed into a fully expressible programming system. In fact, if I were to give a short definition for what a programmer or designer does, it would be to tame chaos into order. It should be becoming clear why creationists often make the proposition that information cannot create itself, and evolutionists claim it can. Depending on what type of system you are looking at, you have different potentials for purely random data to do something. In the first two, purely random data can produce a working system, because the primary informational component is the system itself, and not the data. In the third example, it is much more difficult, because the primary informational component is the program itself, not the system. Now, most programs actually contain a variety of different subsystems, each operating on data at different levels. Also, different kinds of programs have different amounts of possibilities for different kinds of programs by purely random codings. For example, it would be possible to create a code which 90% of the time behaved as a discrete switch system, but had a few instructions which allowed it to branch out. In evaluating such systems, and claims of systems able to program themselves, it is important to look at whether or not the self-generated programs operate by the systems complexity or of their own complexity. If working programs constitute an inordinate amount of the possible search space, then it is apparent that most of the design is in the system itself, and not in the program built by the system. Dembski has claimed to have calculated the limit of the number of bits of informational systems which can be usefully determined by stochastic means in a single step (500 bits), but his claims have not yet been examined by this author, though I do not think it is a controversial figure. Data Operating on Programs, Programs Operating on Data, Are Programs Making Themselves?At this point I would like to point out many of the ways and reasons where computer programs modify their permanent storage. This is not meant to be an exhaustive list, but to show some examples and how they work within an informational perspective. I am going to restrict these to non-interactive programs, since we are not interested in information inserted by an intelligence (a programmer or a user), but in how a program modifies itself, and can use information it discovers in the environment for its own purposes.First of all, programs can be transmitted as either object code (directly runnable by the computer) or as source code (must be translated first before running) or some combination. If it is transmitted as source code, it either needs a compiler on the host computer to transform it to object code, or an interpretter on the host computer to run it a step at a time, or it needs to include either or both of these as a part of the package. With a compiler, the nature and coding of a program is being changed, but the semantics (the core constraints) of a program are not being changed. If the semantics are changed, then it is a bug in either the compiler or the programmer. The purpose of such a transformation is to preserve semantics. Compilers and interpretters never try to modify the semantics of a program being operated on. Compilers come in many different forms. Some of them work instantaneously up-front, and some perform their work as the program runs. Just-in-time compilers can even generate multiple versions of the same code for a variety of different circumstances. Along a similar vein, a programmer can create a section of code to generate a lookup table at startup time. For example, if a programmer needed to generate a set of squares of all the numbers 1 through 1000. I could encode all of the answers directly in the program, I could generate them as needed, or I could write a short program to generate them when the program started up. I'm going to categorize all of these examples as being semantically equivalent changes, meaning that while they may change the structure of how the program is represented, they ultimately do not change how the program operates. And, if any of the changes goes awry, it would lead to the detrimental operation of the program. Programs operate based on complex networks of assumed constraints, and if a semantic change occurs, it will likely alter one of those constraints, making much of the program non-functional. The next type of change is data-gathering. Computers use a unified store for data and programs. Therefore, as programs gather data from the environment, they are making changes to their informational store. If a program is written to watch data and look for intruders, it might log the different kinds of data packets being transmitted. It might record any number of things such as time stamps, packet type, sender, recipient, route, and other information. The information to record is selected by the programming. None of this data makes any fundamental changes to the operation of the program. No matter how much data is collected, the semantics of the program will not change (unless, of course, it is specifically programmed to do so, or if an error condition occurs -- the former is not really a change per se, and the latter is usually catastrophic). The collection and processing of such data is a routine part of the function of the program. Having or not having data does not change the program except as specifically specified by the programmer. I'm going to categorize this example as data-oriented changes. It does not affect the behavior of the program, except as specified by the programmer beforehand. While the exact resullts would not be known by the programmer ahead of time, all possible computational alternatives would have been enumerated by the programmer. Now, data can provide feedback for future processing. For example, let's return to our example of an intruder-detection program. We do not know all of the possible routes that someone may use to break in. Therefore, after a break-in is discovered, we want to be able to adaptively modify our program's behavior to look at the traits of the transactions of the intruder, and raise alarm bells when future programs exhibit similar access patterns. There are many models to do this, Bayesian inference being probable the most widely known. So, the behavior of past inputs will inform how the program responds to future inputs. However, the adaptive responses must follow several guidelines in order to maintain order:
The main points of all of this are as follows:
Let's look at two examples of this. Firs of all, let's look at computer viruses. Most viruses operate by knowing the beginning sequence of computer programs, and inserting themself there, and rewriting the beginning to execute the virus code first. So, the virus alters the semantics of the program, but only by knowing what those semantics are to begin with. Now, viruses aren't necessarily destructive. In fact, they were originally envisioned as a way of introducing new potential to running programs after-the-fact. You could introduce a virus that collected run-time statistics. Or, if you had even deeper knowledge of the program's semantics, you could employ a virus that modified a critical function of the program. Another example is pluggable subsystems. Many programs have semantic hooks which allow third-party functionality to be added in. In most word processors, for example, you can insert other documents (like a spreadsheet, for instance) as part of your word processing document. The word processor doesn't even need to know ahead of time what types of documents it will be able to handle. As long as the word processor and the plugin are written according to the same set of semantics, and the word processor or the plugin (or a third-party brokering system) know how to hook up together, the change can occur. As you can see, the only way to change the core semantics of a program is to write a program which explicitly causes this to happen. Programs cannot write themselves by random or stochastic means because the interworkings of semantic assumptions which allow the program to operate at all must be changed either together and in concert, in specific isolated contexts made for change, or not at all. The way that change is managed within a program is by the stable semantics that surround the change. If both the changeable portions and the semantics both changed, it would lead to chaos within the program, and cause the program to cease to function. Dembski's View of Information Much of William Dembski's work is in this area of why core semantic change requires intelligence, though he approaches it from a different standpoint. For him, the basic distinction is between a blind search and an assisted search. He points out that:
Next Up, Applying this to the Genome Next, as you've probably guessed, I'm going to apply these ideas to genomic change. However, when doing this, you should keep in mind that not all cellular programming is done through genetics. In fact, there is a lot of reasons to think that this is not the case (see the Sternberg reference at the end for more information). However, in order for a cell to operate in the stable, reproducible, and purposive way that it does, the information on how to do this must be stored somewhere, be it a genetic or epigenetic system. For instance, some of the information may be encoded structurally within the cell. There may be other information sources that we have not yet learned of. The point is, while this discussion will apply these concepts to the genome, it may turn out that the genome is more changeable simply because the core semantics are housed elsewhere. However, biology would not exist if organisms did not have a core semantic which they followed (if that were the case, the concept of "organism" or "species" would be meaningless, as there would be no way to transmit structural information if the information itself was non-existent).I apologize for the delay that will inevitably occur between this installment and the next, but time constraints are slowing me down. However, in the meantime, I encourage you to use pubmed to examine the biological literature to see how to apply these concepts to genetics. Bibliography For those of you interested in these subjects, here are some additional articles, papers, and books which may be of interest to you:
Copyright (c) 2005
Jonathan Bartlett All rights reserved.
|
||||||||||||||||||||
Site maintained by: Matt Christensen