Saturday, February 14, 2015

Is change evidence for evolution?

As we saw in the previous post, A Practical Test for Evolution, it is impossible for some sequences which are not existent in any organism to evolve or mutate, which shows only a design mechanism where large sequences are replaced which shows a Designer in action. In this blog, we will explore how the same explanation for evolution can be used to show how a designed C-code can evolve itself, except it can't.

The simplest code to test if a number is prime in C is as follows.


int check_prime(int);

main() {
   int n, result;
   printf("Enter an integer to check whether it is prime or not.\n");
   result = check_prime(n);
   if ( result == 1 )
      printf("%d is prime.\n", n);
      printf("%d is not prime.\n", n);
   return 0;

int check_prime(int a) {
   int c;
   for ( c = 2 ; c <= a minus 1 a / 2; c++ ) { 
      if ( a%c == 0 )
return 0;
   if ( c == a )
      return 1;

After some time, I realized that I just need to check the code till half of it. Hence, a - 1 (which is in red) is changed to a / 2 (in dark green underlined). While the code can still be optimized till sqrt(a), I believe this small explanation is more than enough for the scope of this post.

Now, the less optimized version 1 code and the more optimized code is compared and it has the following features.

Comparing files the two compiled binary files, we have only 58 bytes changed out of 66,912 bytes. Now, that's 99.91% Identical !!

00000088: 04 08 00000788: 3B FC 00000797: 10 00 00001626: DC 66
000000D8: CB 03 00000789: 45 7D 00000798: 5D EB 00001627: BC CB
000000D9: 5A 7C 0000078A: 10 D7 00000799: C3 00 00001628: 97 FE
00000775: 1E 24 0000078B: 75 8B 0000079A: 90 48 00001629: 40 E6
0000077D: 83 89 0000078C: 07 45 0000079B: 90 83 0000162A: B0 5F
0000077E: E8 C2 0000078D: B8 FC 0000079C: 90 C4 0000162B: 99 26
0000077F: 01 C1 0000078E: 01 3B 0000079D: 90 10 0000162C: 30 73
00000780: 3B EA 0000078F: 00 45 0000079E: 90 5D 0000162D: DF 0D
00000781: 45 1F 00000790: 00 10 0000079F: 90 C3 0000162E: 4B 0C
00000782: FC 01 00000791: 00 75 00001620: 5D 8D 0000162F: 3C A8
00000783: 7D D0 00000792: EB 07 00001621: 1B 66 00001840: 9A A0
00000784: DD D1 00000793: 00 B8 00001622: 5C CA 0000CFA3: 31 32
00000785: 8B F8 00000794: 48 01 00001623: CD 1E 0000CFF0: BA C0
00000786: 45 3B 00000795: 83 00 00001624: 3F 45
00000787: FC 45 00000796: C4 00 00001625: D5 7A

Just because the code it 99.91 % identical, does it mean these files have a common ancestor? Just because they have the exact same functions does it mean it must have come from a common ancestor? Why then the genome code is viewed differently? Why then proper attribution is not given to the Designer?

A Practical Test for Evolution

As we previously saw, in Designer 101 for every evolutionist! any expert designer or developer will never reinvent the wheel or redesign an existing design. Hence, common design pattern are not evidence of common ancestry but common framework used by an expert Designer. In this blog, we will do a practical test to see if an organism is designed or evolved, using a gene.

To do this little experiment, we need to test the genes that are designed to function differently to see if there is a possibility for being evolved or is it a cut / insert scenario. One such unique gene is HVRA (or Human accelerated region 1). HAR1A was identified in August 2006 when human accelerated regions (HARs) were first investigated. These 49 regions represent parts of the human genome that differ significantly from chimpanzee in terms of evolution. Hence, this gene is a good candidate to see if there is any small possibility of us being evolved from a common ancestor between chimps and humans.

HAR1-A Gene is located in humans at chr20:63102205-63104386 and have some matches with chimps at chr20:60485431-60486874. However, this is not a straight forward match.

The multiple sequence formats (MSF) file is located here.

With significant number of mutations, the first 389 positions from chimp aligns to human genome with negligible gaps. The 55bp from offset 1173 to 1227 position from chimp is not only present in human genome but also duplicated at positions 1099-1172 in human genome. Till then it's fine and no issues with mutations which are in acceptable range.

Now, the real difference is below.

Chimp has the following sequence:

While humans have the below sequence:

If you try to compare the sequence, you will notice that the chimp sequence is not found in human genome (not even a low identical match) and the human sequence is not found in chimps either. In other words, both chimps and humans are designed differently from a common framework using same genes, where the code is inserted separately by a Designer and did not evolve.

Tuesday, February 10, 2015

Human-Chimp Evolution vs Revision Experiment

Human mtDNA and Chimp mtDNA are 91% identical. After posting A Third of Mitochondria in Chromosome 1, I did got some replies that they are NUMTs. I later realized there had been significant research done on this in the past and I wish to do my own. However, this experiment is to test the evolution vs revision of species, for the formation of new species.

I used BLAST to find all matching NUMT sequences in human genome from RSRS and filtered matching sequences that are 60 bases above 95% and above. I then used CLUSTALW, the multisequence alignment tool to get consensus sequence.  I did the same for chimp using chimp reference mtDNA on chimp genome to get consensus mtDNA sequence. RSRS is 91% identical to Chimp reference mtDNA.  However, these consensus sequences are both 92% identical to each other. I did the same procedure for 90-95% identical NUMT sequences with 120 bases, 87-90% with 180 bases, 95-100% with 40-120 bases in length. All these made the consensus sequence between human and chimp to be 93% identical to each other.

As you can see, I aligned human mtDNA with NUMT from human chromosomes which becomes 2% closer to aligned chimp mtDNA using NUMT from chimp chromosomes. I never used another chimp NUMT to align human genome or vice versa. I always used human mtDNA with human genome and chimp mtDNA with chimp genome.

However, if I try to align less then 85% identical NUMT longer sequences on both chimp and human, comparing the consensus sequence for both reduces to 92% identical, which could indicate mutations on NUMT itself.

I also created a consensus sequence using both human and chimp 93% identical sequences, by manually aligning them to match. The result was a consensus sequence that is 94% identical to human rCRS and chimp reference mtDNA.

All data used for alignments/fasta/output are available here.

Hence, undeniably, this experiment seems to prove Human-Chimp divergence from a common ancestor using NUMTs.

Or is it?

In computer science and software engineering, re-usability is the use of existing assets in some form within the software product development process. Don’t repeat yourself (DRY) is a principle of software development in software engineering, aimed at reducing repetition of information of all kinds, especially useful in multi-tier architectures. No software developer would build something from scratch when most of the required functions, libraries, code is already available to reuse.

MtDNA functionality hasn't changed from chimp to humans. I haven't seen a single developer till date who changes a function and rewrites it from scratch when the existing function works as expected. So, why would the Designer change the already designed mtDNA, when it's functionality is exactly what is required? Wouldn't that be reinventing the wheel? Hence, mtDNA does not need to be changed significantly in humans.

Are there any evidence for revisions of organisms between species? Yes there is.

Mammalian NUMT insertion is non-random. They seems to be occurring not only in a non-random way, the authors had discovered that the inferred insertion points of NUMTs have a strong tendency to have high-predicted DNA curvature, occur immediately adjacent to A + T oligomers and preferentially insert into introns.

Hazkani-Covo et al. (7) reconstructed the approximate pre-insertion sequence of 37 human-specific NUMTs by multiply aligning them with their flanks to human mtDNA and the chimpanzee nuclear genome. They observed that deletion of nuclear DNA did not occur in 54% of those events, in contrast to a nearly 100% rate observed in two experimental systems using V(D)J (91,92) and I-SceI-induced DSBs (93–96). In light of this, they hypothesized that NUMTs serve as filler DNA which mitigates the tendency of short stretches of nuclear DNA to be lost during DSB repair
We do not present evidence to contradict their hypothesis, but note the logical possibility that repair without deletion may not be caused by the use of filler DNA, but rather that the kind of DSBs which commonly occur in primate germ line cells may have an inherent tendency to allow repair without deletion of nuclear material. In other words, the perceived connection to NUMTs may simply be due to the fact that the DSBs which create NUMTs afford reconstructing the details of their repair. Thus, the characteristics of NUMT insertion sites observed here may reflect mammalian germ-line DSBs in general. (PMCID: PMC346703)
So, what's going on? Fillers? If they are fillers, then the instructions are already present or coded and these fillers are filled in. Hence, the mtDNA fragments are used to fill the non-instruction positions.

The chromosome 2 and the Y chromosome of humans and chimps are the best examples and evidence themselves. There is not a single NUMT at Chromosome 2 fusion site and Chromosome Y Heterochromatic region, which Chimpanzees don't have. This can only happen if the new instructions present in those two regions are part of a major release developed by a Master Programmer. Hence, NUMT isn't an ongoing activity, but rather, it marks a major revision and a release of a new 'product' (or species).


  • NUMTs does show the same mtDNA template being used for both humans and chimps.
  • The non-random NUMTs are actually the mtDNA fragments over which genetic code for chromosomes are written.
  • There is not a single NUMT in Chromosome 2 fusion site and Chromosome Y Heterochromatic region which are non-existent in chimpanzees.
  • NUMTs actually proves the blueprint of existing species are revised for release of a new major version as a new species.
Clarification: This does not mean theistic evolution. Theistic evolution requires guided mutations - which is awkward for any Designer like God. An Designer, plans in advance, gathers all information like what libraries will be required and how to build, does the design properly, builds them exactly to specifications or what He planned, go live to production and finally supports it. So, we can get raise an incident to the Developer (pray to God) to get direct support for anything that went wrong in our body.

Monday, February 2, 2015

A Third of Mitochondria in Chromosome 1

When I was doing some research on human genome, I noticed that a third of Mitochondria is also located within Chromosome 1.

The MtDNA RSRS sequence from 3914 to 9730 position is identical to the chromosome segment from position 629084 to 634899 (GRCh38) or position 564464 to 570279 (ucsc/hg19). It is a 5816 base-pair sequence (which amounts to 35% of mtDNA).

Comparing these two sequences, there are only 68 differences (~70 including indels). I had pasted the fasta for both sequences.


The above sequence can also be downloaded from here.

>Chr1:629084-634899, GRCh38 

The above sequence can also be downloaded from here.

The 68 differences can be downloaded from here.


Nearly a third of Mitochondria sequence located within Chromosome 1 is a significant find and gives us clues to how Mitochondria was designed. Such a sequence wasn't found in pan troglodytes, indicating that the relationship between the Mitochondria sequence located within Chromosome 1 has nothing to do with Pan troglodytes, nor did it evolve from it, but rather Mitochondria was created the same time when Chromosome was created. The 68 differences from 5816 bp indicate a timeline of mutations when Chromosome 1 and Mitochondria had these sequences identical. It could also help correct RSRS sequence to have the true mt-Eve sequence from Chromosome 1.

Saturday, January 31, 2015

Designer 101 for every evolutionist!

I have my own thoughts and response esp., on evolution and the arguments put forward in favor of it using genetics. In this post, I will address every argument put in favor of evolution using standard procedures and methodologies used in most software companies for designing, developing, testing and roll-out of software.

Genetic similarity of humans with primates

One of the most common answers I always find is the genetic similarity of humans with primates. This statement must be analyzed what it means, to understand what is assumed. The assumption here is the consideration of only the genes and the rest of the Junk DNA is useless. Hence, the genes (which are the only biologically significant) are identical up to 90%.

A gene is the basic physical and functional unit of heredity. Genes, which are made up of DNA, act as instructions to make molecules called proteins. Every developer has a set of libraries. Most of the developers, don't develop these libraries with common functions from scratch. They put all common functions in one dll or library and link it either statically or dynamically with every other program they require. Hence, a gene is comparable to a function or set of functions, more like a library, a dll file, used in all the organisms that require it. Even though Microsoft Word and Excel loads the exact same set of common libraries and calls same functions, and has similar look and feel, they function differently and both are designed. Human and chimp using same genes for their function which is used as an evidence for evolution, is like saying Microsoft Word and Excel had a common ancestor and evolved because they share the same set of functions and load the same common libraries. Just because a dll is used in a program does not necessarily means the program will use all functions in that dll. A program will use only the functions it requires and the rest will never used. This is exactly why some genes are switched off or inactivated while others function.

As we know operating systems came a long way, but does that have a common ancestor and evolved itself? Identical operating systems actually share code, libraries etc but they are always developed. Take Linux for example: They share code from Unix - Does that mean Linux evolved itself from Unix?

Hence, identical genes between species is actually an evidence for Designer at work rather than evolution.

C-value enigma or the Onion Test

Some organisms (like some amoebae, onions, some arthropods, and amphibians) have much more DNA per cell than humans, but cannot possibly be more developmentally or cognitively complex, implying that eukaryotic genomes can and do carry varying amounts of unnecessary baggage.

If you look into the code of any developer, you might find unused functions, unused imports, unused libraries, debug and trace information. I personally have the habit of embedding the data within the code to make the code more portable. These things increase the size of the code but not it's functionality.

For example, some software doing simple stuff like a dictionary are 100 MB in size, while Stuxnet which brought down Iranian nuclear reactors is just half a megabyte. The size of the code is not directly proportional to it's complexity, which every developer knows this. Any project manager would know that complexity does not depend on the number of code and does not estimate the costs based on lines of code required.
“Measuring programming progress by lines of code is like measuring aircraft building progress by weight.” --Bill Gates
Murphy's law on software engineering states, The chances of a program doing what it's supposed to do is inversely proportional to the number of lines of code used to write it. If this is the case for computer code designed and developed by humans, isn't it a perfect evidence for a grand Designer at work, creating complex organisms with less genomes perfectly satisfying Murphy's law?

There is an another logic which is even used in DOS and Windows. If there is a fixed size and you are to write in them, the remaining left over space is huge when the actual information is very less, which makes the overall size huge. The DOS and Windows file systems use fixed-size clusters. Even if the actual data being stored requires less storage than the cluster size, an entire cluster is reserved for the file. This is why when very less information like 1 byte on a million files will not be 1 MB in size but rather, 4 GB for a 4K cluster. Does genome has such features? We do know introns within a gene are removed by RNA splicing indicating some kind of cluster like structures.


Hence, C-value enigma or Onion test is actually an evidence for Designer at work, satisfying Murphy's laws, cluster style design rather than evolution.

Reverse Engineering Genome

Most of the work biologists do today are just reverse engineering the genome, trying to understand it's design and documenting it. Most decompilers provide data region, code region, functions used, the data string used and the entry point.  However, none of these luxury exists in genome reverse engineering. All we have is a sequence of code when executed has a specific functions and codons to identify them. Most of the remaining genome, we have no clue. If you look into the structure of any executable file, without having any clue of the structure, you can quickly come to conclusion that most of the info in there is junk. But if you know the actual structure, it isn't junk but actual data in them.

As you can see, the only readable info in the file is MZ. Apart from this, nothing is decode-able without actually having documentation on it.

The same logic is with genome. Just because a sequence of binary code is not a part of a function (or a gene), does not mean it is not used. If I want to be more accurate, a genome is not just a code, but much more to it. A genome is like a code that has instructions to build the computer itself and then install all the required operating systems and the application code and then finally make the computer boot execute the required code in the right order.


I would like to add more, but these are more than enough as it covers most of the arguments used in genetics. It's only a designer can understand and detect the architecture of an another Designer. People who can't detect design or understand the complex architecture do require some designing skills to actually understand them. If they can't, it is better to atleast see the computer word and understand in order to relate and detect design concepts. Evolutionary biologists are not designers or developers which is understandable, but that does not mean they should reject on design concepts and ways to detect design. In 16 trillion bits in my computer, there is not a single 0 or 1 was by chance.