fine.
With ‘function’ in that context you regard the function of the IC-system.
Yepp. But the more interesting question is how it happened.
I agree that you’re sure to belong to that group.
But sorry, I don’t like to invest too much time with impolite people.
Clearly you haven’t understood Dembski’s explanatory filter for if you had, you would have immediately understood that design, being the last decision node of the filter, cannot be the default position.
I don’t remember claiming that they were. So we can add this to the long list of non sequitors.
This does however appear to be yet another rabbit-hole to distract from ID’s lack of testable hypotheses or predictions.
The greatly simplified model of the “weasel” won’t. But that’s because it’s greatly simplified. Dawkins explicitly talks about how it’s not a good model of evolution, so I don;t see why you kept trying to pretend that Dawkins meant more by it than he said.
It really isn’t. You’ve yet to provide any reason to think that Darwinian mechanisms can’t follow indirect routes.
You really aren’t. The misrepresentation of Dawkins alone shows that.
I’m not a programmer, but I am curious what you did to implement irreducible complexity in the weasel program? I assume you defined some sort of co-dependence between words or mutations? The entire sentence?
Please explain why. I think you have an essential misunderstanding of how the evolution of an IC system can work; once again, your misunderstanding seems to rely on the idea that evolution would have to work by the sequential addition (and/or subtraction) of invariant parts.
How did you show that? This is the fourth time I’ve asked you to explain. What does your revised Weasel program actually do?
I’m not sure that’s true, but what would it matter?
What do you mean by “creationism”? Is religion necessarily creationism?
So no one who disagrees with Dembski really understands Dembski, therefore Dembski is correct?
This is circular reasoning, beginning with the unstated presupposition “Dembski is Correct”. It never allows the possibility that others DO understand Dembski, and that Dembski is wrong.
It is also The Explanatory Filter. “I believe in a Creator”, and after going through the steps of TEF I conclude there is a Creator. It never considers any other possibilities.
Note: this It is a criticism of Circular Arguments. It says nothing about the existence of a Creator either way. I think there are better arguments for having faith, even if I don’t put much stock in it myself. I think we can all do without bad arguments.
an IC-system is defined only having a selectable function (we always talk about the function of the IC-System, not any function) having all parts in place.
I used one word in that sentence als IC-system. That means that selection can only ‘see’ it if all correct letters are in the correct position.
If you run the program the rest of the sentece ist quickly found as usual, but not the ‘IC-word’.
That means cumulative selection works fine for certain systems, but not for IC-systems.
That there are other possibilites to generate an IC-systems isn’t relevant for that program.
it shows that cumulative selection, if you use the implicit definition in this program, doesn’t effectively generate IC-systems. The part ‘LIKE’ of the string in my modification got positve selection value only if all letters are in the correct postion, modeling the system-property ‘is irreducibly complex’.
The OutPut may look like the following:
*** Mit Irreduzibler Komplexität ***
YNDKNPQAOHSQEYPLAJSYJWKAHXUA
(* random string *)
1 YNDKNPQAOHSQEYPLAJSYJWKAHXEA
2 YNDKNPQAOHSQEYPLAJSYJWKAAXEA
3 YNDKNPQAOHSQESPLAJSYJWKAAXEA
[ … ]
270 METHINKS IT IS MXKI A WEASEL
271 METHINKS IT IS MXKI A WEASEL
272 METHINKS IT IS MHKI A WEASEL
[ … ]
5142 METHINKS IT IS LINE A WEASEL
5143 METHINKS IT IS LIKE A WEASEL
Fertig —> Enter drücken
BTW, an interesting side-issue is ‘latching’ (a correct letter in a certain position remains). Dembski made some fuzz about that because he doesn’t understand population genetics. Latching is trivial if you look in the source code. Dawkins program can be used to show how that can happen in natural populations.
It matters quite a lot if you regard evolutionary biology from the standpoint of the history of science or philosophical viewpoints.
There was e.g. quite a fuzz about the Biston betularia industrial melanism. It was a wunderful confirmation of evolution, if you define ‘evolution’ as 'change of allele frequencies in populations over generations". But was it ‘evolution’ ™? The black variant existed before soothing of trees, and declined after.
In a similar way you can ask “what is ‘darwinian’”. Before the evolutionary synthesis in the 1940s there were a lot of competing evolutionary theories and even after there were discussions, if certain mechanisms (neutral theorey, punk eek, now mechanisms of the Extended Synthesis) can be integrated into the Modern Synthesis.
You’re right, ‘creationism’ is not the best term (in Germany ‘creationism’ without qualification usually means YEC, that’s not taught in schools, but you could teach something about it, if you like, but it’s not mentioned in the official curricula).
Difficult question. I’d prefer ‘interventionism’ meaning any viewpoint regarding an entity which directly or at least indirectly intervenes in evolution. YEC and ID then are ‘interventionistic’, most versions of theistic evolutions are not (even if Kenneth Miller even proposes a mechanism, how Got could intervene …)
I assume that most or at least most religions assume such interventions. Don’t forget the first words in the Bible.
Let’s clarify the sleight-of-hand that Behe uses here.
Behe has multiple definitions of IC. His followers seem to think that if any structure fits one of them, it must have been designed. Case closed.
The reality is that Behe merely hypothesizes that it was designed. He can’t be bothered to test his own hypothesis, which isn’t scientific because posits no mechanism.
Are biological systems generally limited to single functions?
In the absence of direct evidence for a designer, the last node of the filter should be ‘we don’t know.’ That should be the default position - not some unevidenced and possibly entirely made up entity. It also has benefits: landing on ‘we don’t know’ may spur us to continue our research, whereas landing on ‘design’ may give some people a warm and fuzzy feeling, but does nothing to further our actual knowledge about how the world works.
Of course it can be. If you cannot find overwhelming evidence that it is (i) “law” or (ii) “chance” – and Slick Willy doesn’t look very hard, and stacks the deck by treating them as separate ‘explanations’ – then you are left with “design” as the default.
This is of course the only way that “design” could be the answer – as there is no positive evidence for it.
This can be shown be reversing the order and putting “design” first.
There is no positive evidence for “design” – so under this ordering the answer must be some combination of chance and law.
Slick Willy even implicitly admitted to this when he said:
Roughly speaking the filter asks three questions and in the following order: (1) Does a law explain it? (2) Does chance explain it? (3) Does design explain it?[1]
[My emphasis]
The order is important, because only by making “design” come last in the order does it make it the default – an answer derived not from design’s own merits – but by casting doubt on “chance” and “law”.
Like everything else in ID’s arsenal, the Explanatory Filter is simply empty rhetoric and a dishonest argument – “PR” of zero probative value.
Poppycock. Dembski himself has said that design is the default position if law and chance are ruled out. The supposed third stage is just ruling out chance based on specification matching, and leaving design as the default.
The third stage of the Explanatory Filter therefore presents us with a binary choice: attribute the thing we are trying to explain to design if it is specified; otherwise, attribute it to chance. In the first case, the thing we are trying to explain not only has small probability, but is also specified. In the other, it has small probability, but is unspecified. It is this category of specified things having small probability that reliably signals design. Unspecified things having small probability, on the other hand, are properly attributed to chance.
There is and never has been any actual test for design, and the filter doesn’t allow an result of ‘unknown’. Design is the default position reached after eliminating law once and chance twice.
You* are the one who clearly hasn’t understood Dembski’s explanatory filter.
Again, no, that’s not what I mean, and you know that, please don’t treat us like children. ID, as promoted by DI, is literally just creationism with a different name. They are one in the same. The new name was to circumvent a Supreme Court decision.
Don’t dishonestly conflate that classical Greek philosophy. You very well know what we’re talking about.
Why?
Well, we know that: Thru evolutionary mechanisms like mutation, drift and selection. All that is left is to figure out the historical events by which a particular system evolved. That’s no trivial task, but it is not necessary to know in order to know that something evolved. Similarly, we know that the Grand Canyon arose thru geological processes like sedimentation and erosion. This knowledge does not entail or require that we know the exact history of how every single one
of its feature was formed. But our knowledge of the processes by which such canyons and other such geological structures arise in general, allows to answer the question of how the Grand Canyon, in particular, came to be.
By the same token, the question “How did the bacterial flagellum come to be?” can be more specifically worded as “What series mutations occurred, what were their results, and how did they become fixed in the genome to eventually form the bacterial flagellum?” Whereas, those who insist on believing that if was formed by “design” have no analogous processes to draw upon to form a hypothesis. They’re just left with invoking magical actions of a magical being. That’s not really good science, is it?
That’s a convenient excuse to ignore questions that cause you discomfort. I have a feeling that, if you could answer them, you’d get over your aversion to impoliteness.
It wasn’t. It was evolution.
Dawkins’s ‘weasel’ program isn’t really appropriate for testing evolution of irreducibly complex systems, because there is only one possible target, and the components of it are independent of each other. Nor does ‘weasel’ include the concept of non-functionality status, since the only possible metric is difference from the target string.
You haven’t said how you modified ‘weasel’ to include irreducible complexity, but you’ve hinted that all you’ve done is change the weighting mechanism so that some substring(s) don’t count towards matching the target unless all of the letters in them are correct. If that’s the case, you haven’t demonstrated anything about irreducible complexity, you’ve only made some parts of the string less likely to be found by random mutation (1 in 27n instead of 1 in 27) and shown that this makes ‘weasel’ take longer to finish.[1] That’s neither unsurprising nor new. Nor is it relevant to how evolution is expected to produce irreducibly complex systems, which is by producing a fully functional system that isn’t irreducibly complex, then optimising or streamlining it without losing that functionality.
If you really want to model the evolution of irreducibly complex systems, you’d be better of modifying a program such as Dave Thomas’s Steiner tree algorithm which not only includes a criterion for functional vs non-functional (all nodes connected) but also doesn’t have a fixed target, or even a known one.
By changing the initial population generation parameters you can ensure that the starting population contains no functional systems at all, yet it can not only evolve functional systems, but also irreducible complex functional systems.
I’ve appended the Python code of one of my implementations of the algorithm (which runs multiple three-dimensional Steiner simulations back-to-back, all starting with completely non-functional systems), as well as the results of one run which includes some outcomes that are irreducibly complex, and some that are not.[2]
So this is a demonstration of how evolutionary algorithms can produce systems that are irreducibly complex, by indirect routes that involved finding a reducible functional system and then optimising it, just as is expected to happen in nature.
That so-called ‘direct’ Darwinian paths might not be able to generate irreducibly complex systems is completely irrelevant in a world where the vast majority of evolutionary paths (like that of penguin forelimbs) are indirect, and the vast majority of biological systems are both multifunctional and not irreducibly complex.
Python code:
"""
Simple evolutionary algorithm to generate a Steiner tree connecting a set
of defined nodes using some number of additional intermediate nodes.
Based on Dave Thomas's original Fortran code.
The data structure for a tree is
- 3n fixed values, copied from the initial list and never changed [x,y,z]
- 3(n-1) values for variable nodes [x,y,z]
- (2n-1)*(2n-1) booleans representing connectivity, of which only the values where the first index is lower than the second one are used
- 1 boolean representing its connectivity
- one number representing its Steiner length
Update: in order to stimulate finding steiner trees instead of spanning graphs,
fixed nodes are never connected, and all paths between them must be via variable nodes.
"""
import math
import random
# point parameters - change these to look for a different Steiner trees
fixed_points_x = [100,200,100,300,200,400,300,400]
fixed_points_y = [200,100,300,100,400,200,400,300]
fixed_points_z = [200,300,200,300,200,300,200,300]
max_dim_x = max(fixed_points_x)+50
min_dim_x = min(fixed_points_x)-50
max_dim_y = max(fixed_points_y)+50
min_dim_y = min(fixed_points_y)-50
max_dim_z = max(fixed_points_z)+50
min_dim_z = min(fixed_points_z)-50
num_of_fixed_points = len(fixed_points_x)
num_of_nodes = num_of_fixed_points - 1
total_points = num_of_fixed_points + num_of_nodes
# population and mutation parameters - change these to alter the performance of the simulation
population_size = 1000
number_of_generations = 1000
unconnected_length = 10000000
node_mutate = 150
link_mutate = 100
# indices into structure
nodes_index = num_of_fixed_points * 3
connections_index = total_points*3
connected_index = total_points*3 + total_points*total_points
steiner_length_index = total_points*3 + total_points*total_points + 1
"""
determine connectivity of steiner tree
"""
def connected(tree) :
# initialise list of connected points
connected_points = [True] # first node is always connected
for a in range(total_points - 1) :
connected_points.append(False)
points_connected = 1 # first node is always connected
new_points_added = True
# loop through connections until either (i) number of connected points = total number, or (ii) no new points have been added
while new_points_added:
last_connected_count = points_connected
for a in range(total_points-1):
for b in range(a,total_points):
if tree[connections_index + (total_points*a) + b] :
if (connected_points[a] != connected_points[b]) :
connected_points[a] = True
connected_points[b] = True
points_connected += 1
if last_connected_count == points_connected :
new_points_added = False
# only need to check fixed points
fixed_points_connected = True
for a in range(num_of_fixed_points) :
if connected_points[a] == False :
fixed_points_connected = False
return fixed_points_connected
"""
determine total length of steiner tree
"""
def steiner_length(tree) :
total_length = 0
for a in range(total_points-1):
for b in range(a,total_points):
if tree[connections_index + (total_points*a) + b] :
x_diff = tree[3*a] - tree[3*b]
y_diff = tree[3*a+1] - tree[3*b+1]
z_diff = tree[3*a+2] - tree[3*b+2]
total_length += math.sqrt(x_diff*x_diff + y_diff*y_diff + z_diff*z_diff)
return total_length
"""
create a mutated copy of an existing tree
"""
def mutate(tree) :
new_tree = list(tree)
for x in range (num_of_nodes) :
if random.randint(0,node_mutate) == 0 : # chance to change the x position of a variable node
new_tree[nodes_index + 3*x] = random.randint(min_dim_x,max_dim_x)
if random.randint(0,node_mutate) == 0 : # chance to change the y position of a variable node
new_tree[nodes_index + 3*x +1] = random.randint(min_dim_y,max_dim_y)
if random.randint(0,node_mutate) == 0 : # chance to change the z position of a variable node
new_tree[nodes_index + 3*x +2] = random.randint(min_dim_z,max_dim_z)
for x in range (total_points) :
for y in range (total_points) :
if not( (x < num_of_fixed_points) and (y < num_of_fixed_points) ) : # don't change state of connectivity between fixed nodes
if random.randint(0,link_mutate) == 0 : # chance to flip a connection
if new_tree[connections_index + (x * total_points) + y]:
new_tree[connections_index + (x * total_points) + y] = False
else :
new_tree[connections_index + (x * total_points) + y] = True
new_tree[connected_index] = connected(new_tree)
if new_tree[connected_index] :
new_tree[steiner_length_index] = steiner_length(new_tree)
else :
new_tree[steiner_length_index] = unconnected_length
return new_tree
def single_run() :
population = []
# generate initial population
for x in range(population_size) :
tree = []
for y in range(num_of_fixed_points):
tree.append(fixed_points_x[y])
tree.append(fixed_points_y[y])
tree.append(fixed_points_z[y])
for y in range(num_of_nodes):
tree.append(random.randint(min_dim_x,max_dim_x)) # x co-ordinate of variable node
tree.append(random.randint(min_dim_y,max_dim_y)) # y co-ordinate of variable node
tree.append(random.randint(min_dim_z,max_dim_z)) # z co-ordinate of variable node
for y in range(total_points):
for z in range(total_points):
tree.append(False) # start with no connections
tree.append(False) # they're always unconnected
tree.append(unconnected_length)
population.append(tree)
for gen in range (number_of_generations) :
# generate next generation
for x in range (population_size) :
# compare each member of the population to a random other one,
# and replace it with a mutated copy of the one that is shorter
competitor = random.randint(0,population_size-1) # it might be competing against itself (it'll win!)
if population[x][steiner_length_index] > population[competitor][steiner_length_index] :
population[x] = mutate(population[competitor])
else :
population[x] = mutate(population[x])
# find shortest tree
shortest_nodes = ""
current_steiner_record = unconnected_length+1 # one more than default unconnected value, to ensure there is always a winner
for x in range (population_size) :
if population[x][steiner_length_index] < current_steiner_record :
shortest_nodes = ""
current_steiner_record = population[x][steiner_length_index]
for a in range(total_points-1):
for b in range(a,total_points):
if population[x][connections_index + (total_points*a) + b] :
if ((population[x][3*a] != population[x][3*b]) or (population[x][3*a+1] != population[x][3*b+1]) or (population[x][3*a+2] != population[x][3*b+2])) :
shortest_nodes = shortest_nodes + "(" + str(population[x][3*a]) + "," + str(population[x][3*a+1])+ "," + str(population[x][3*a+2]) + ")-("+ str(population[x][3*b]) + "," + str(population[x][3*b+1])+ "," + str(population[x][3*b+2]) + "); "
retval = []
retval.append(current_steiner_record)
retval.append(shortest_nodes)
return retval
# batch run
number_of_runs = 10
results = []
for runs in range (number_of_runs) :
print ("Run " + str(runs+1))
results.append(single_run())
results.sort()
for runs in range (number_of_runs) :
print (str(runs+1) + " L: " + str(results[runs][0]) + " " + results[runs][1])
Results (top 3 only):
1 L: 1182.403350618639 (100,200,200)-(158,248,240); (200,100,300)-(235,89,301); (100,300,200)-(198,322,190); (300,100,300)-(353,187,301); (300,100,300)-(428,112,331); (300,100,300)-(235,89,301); (200,400,200)-(223,382,208); (400,200,300)-(353,187,301); (300,400,200)-(223,382,208); (400,300,300)-(353,187,301); (198,322,190)-(223,382,208); (198,322,190)-(158,248,240); (353,187,301)-(158,248,240);
2 L: 1195.145521457145 (100,200,200)-(138,296,224); (200,100,300)-(226,136,286); (200,100,300)-(138,296,224); (100,300,200)-(194,330,237); (100,300,200)-(138,296,224); (300,100,300)-(277,109,258); (200,400,200)-(194,330,237); (400,200,300)-(277,109,258); (400,200,300)-(365,323,241); (300,400,200)-(365,323,241); (400,300,300)-(365,323,241); (277,109,258)-(226,136,286);
3 L: 1196.697508957284 (100,200,200)-(98,214,217); (200,100,300)-(272,198,315); (100,300,200)-(289,213,294); (100,300,200)-(98,214,217); (300,100,300)-(289,213,294); (200,400,200)-(307,399,152); (400,200,300)-(289,213,294); (300,400,200)-(307,399,152); (300,400,200)-(342,258,283); (400,300,300)-(342,258,283); (289,213,294)-(272,198,315); (289,213,294)-(342,258,283);
You can confirm for yourself which ones are irreducibly complex, i.e. will cease to be functional if any of the connecting segments are removed.
I’m assuming you’ve implemented your modifications correctly, though it’s possible you have accidentally done something else; see here for an instance of some-one trying to demonstrate a point using a ‘weasel’ implementation and instead only demonstrating their own lack of understanding. ↩︎
I set a low number of generations for the runs, so the results are nowhere near optimal, but much better results can be achieved with more generations. ↩︎
I am not saying that who disagrees with Dembski doesn’t understand him, therefore Dembski is correct, not at all. I am amazed you think that I’ve said such thing. What I am saying is simply that no one who claims that design is the default position within Dembski explanatory filter doesn’t understand how it works. That’s all.
Sorry, but what you are saying here shows that you don’t understand how the EF works.
The curriculum contains some obligatory issues about that and there are informations in the textbooks, usually in form of flow-charts or diagrams. Testing of hypotheses, derived from theories, is quite central. I used examples from the history of (evolutionary) biology, e.g. the chemical nature of the gene or soft inheritance or Phlogiston in chemistry.
Sorry, English isn’t my native language. My wording may not be understandable.
Perhaps I should argue in more detail. Here in Germany there are authors who criticize evolution from an interventionist perspective (ID or YEC). Some of them are quite competent scientists. I meant that this criticism should be taken seriously and used to develop better naturalistic theories.
Of course, refuting naturalistic (non-interventionist) theories does not mean that interventionism is right. But see below.
I don’t understand your question, sorry.
E.g. how Ussery is mentioned in Creationism’s Trojan Horse concerning ‘Mike Gene’?
But more generally, my position isn’t that ID would be the new theory, but that critique from ‘outside’ can help to find new and better scientific theories.
ID is a very old ‘theory’ (you know that ‘theory’ is a very difficult concept, e.g. in Mahner/Bunge Foundations of Biophilosophy you find in the index 'Theory 38-105 and half a page special entries for ‘theories’, e.g. 'general:, ‘semantic view’, ‘syntax/structure’ and so on). Philosophy of science is quite complex, with some little exceptions (population genetics) most theories of evolutionary biology don’t pass the criteria of physics for a ‘theory’. Not only Ernst Mayr complained that theory of science is a domain of theoretical physicists. BTW, one author of the book mentioned (Mahner) ist biologist.
The modern science started by a kind of IC (contrary to the then standard aristotelism, because these christians taught that God had free will, so we had to do research). I prefer naturalism.
You can start ID as a hypothesis: Certain biological systems cannot be generated by naturalistic mechanisms. John Lennox called confirmation of that ‘good gaps’ (my translation, didn’t read that in English, in German its 'Gute Lücken), meaning that they are not closed by the results of new research but tend to get even wider. As an example he and others use abiogenesis.
I don’t want to discuss that, but that would be another ‘science’ than usual, but you know that it’s extremely complex, to define what’s science or not (‘demarcation problem’). You see that in the discussions about the rulings of McLean (e.g. Larry Laudan vs. Michael Ruse) or Kitzmiller (e.g. Bradley Monton vs. Robert Pennock).