Cladistics


Consider, again, these taxa, characters and states:

internalatrial two temporalpedicillate
Taxonamnionlegsscalesbloodnostrilsseptumfenestrationshemipenesgizzardteethfeatherswingsvertebrae
perchnonoyescoldnonononononononoyes
coelocanthnonoyescoldyesyesnonononononoyes
salamandernoyesnocoldyesyesnononoyesnonoyes
frognoyesnocoldyesyesnononoyesnonoyes
turtleyesyesyescoldyesyesnonononononoyes
manyesyesnowarmyesyesnonononononoyes
geckoyesyesyescoldyesyesyesyesnonononoyes
snakeyesyesyescoldyesyesyesyesnonononoyes
alligatoryesyesyescoldyesyesyesnoyesnononoyes
budgyyesyesnowarmyesyesyesnoyesnoyesyesyes

The preceding matrix, again, can be represented numerically (for convenience) as:
12345678910111213
perch0000000000000
coelocanth0000110000000
salamander0110110001000
frog0110110001000
turtle1100110000000
man1111110000000
gecko1100111100000
snake1100111100000
alligator1100111010000
budgy1111111010110

Hennigian argumentation proceeds as follows: Each apomorphic (derived) character state defines a relationship. That is, the presence of an amnion defines the group (turtle, man, gecko, snake, alligator, budgy). However, the absence of an amnion does NOT define the group (perch, coelocanth, salamander, frog) as having descended from a common ancestor exclusive of turtle, man, gecko, snake, alligator, and budgy. That is,
character 1 defines the group:
but not the group:

We can then enumerate for all apomorphic states, for all characters, the group(s) hypothesized by each:

Having determined each group defined by each character, you can then begin, stepwise, to resolve the tree by adding the charatacters one at a time...


This is only really possible for relatively uncomplicated datasets of relatively small sizes. I there are lots of taxa and there is lots of homoplasy, it is not likely [sic] that you'll actually get the shortest possible tree or all of the shortest trees even if you happen to get one of them.

The Wagner algorithm provides a better way to arrive at an efficient tree. It is not guaranteed to be the shortest tree for complicated data, but it is guaranteed to get the shortest tree if there is no homoplasy, and is likely [sic] to do a lot better than you can by-eye.

We begin by constructing a Manhattan matrix of absolute character differences as follows...

The difference for any two taxa is simply the number of characters that are different for the two taxa:
perchcoelocanthsalamanderfrogturtlemangeckosnakealligatorbudgy
perch255466663
coelocanth33244448
salamander0336657
frog336657
turtle22226
man4444
gecko026
snake26
alligator4
budgy

Now we can pick any two taxa to join, but normally this will be the two closest taxa, so, in this case we can choose either salamander-frog or snake-gecko.

Next we need to calculate the patristic distance between each of the yet-to-be-joined taxa to the existing interval INT(salamander:frog). This is simply, the sum of the patristic distances of the taxon-to-be-joined, less the patristic distance of the interval itself, all divided by two. For example,

D[perch: INT(frog:salamander)] = |(perch:salamander + perch:frog - frog:salamander)|/2
or...
= |(5 + 5 -0)|/2
= 5

Thus, our new matrix looks like this:
perchcoelocanthturtlemangeckosnakealligatorbudgy Int[SalFrog]
perch24666635
coelocanth2444483
turtle222263
man44443
gecko0266
snake266
alligator45
budgy7

Thus, there are three possible choices for the next taxon to add to point X on the interval of salamnader:frog. Ideally, you'd want to persue all possible paths (e.g., mhennig in Hennig86), but here we'll just go with the first one that appears in the matrix (e.g., hennig in Hennig86) and keep going.

Now we need to find the shortest patristic distance among all of the possible additions of taxa to each of the three intervals

salamader:X
X:frog
X:coelocanth
but to do this we need to get the state-set for X. This is merely the median state for the three closest nodes, in this case,
coelocanth0000110000000
salamander0110110001000
frog0110110001000
.
X0110110001000

For perch,

D(Int salamander:X) = 5+5-0/2 = 5
D(Int frog:X) = 5+5-0/2 = 5
D(Int coelocanth:X) = 2+5-3/2 = 4
For turtle,
D(Int salamander:X) = 3+3-0/2 = 3
D(Int frog:X) =3+3-0/2 = 3
D(Int coelocanth:X) = 2+3-3/2 = 1
For man,
D(Int salamander:X) = 3+3-0/2 = 3
D(Int frog:X) =3+3-0/2 = 3
D(Int coelocanth:X) = 4+3-3/2 = 2
and so on... , in this case, D [turtle: Int(coelocanth:X)] = 1 is among a few possible shortest next-additions (1 step), so we can add turtle a follows:

Continue this process stepwise and you have calculated a wagner tree by stepwise addition, which might look something like this: