Difference between revisions of "Relationship between Ploidy, Alleles and Genotypes"
(10 intermediate revisions by the same user not shown)  
Line 7:  Line 7:  
Plants species exhibit a diverse number of ploidy, for example, the strawberry is an octoploid and the pear is a triploid.  Plants species exhibit a diverse number of ploidy, for example, the strawberry is an octoploid and the pear is a triploid.  
+  
+  Copy number variations in somatic variant calling also leads to variable ploidy to consider when genotyping a locus.  
While there are explicit functions that could be googled for handling haploid and diploid cases. It seems difficult to find the closed forms for the general case.  While there are explicit functions that could be googled for handling haploid and diploid cases. It seems difficult to find the closed forms for the general case.  
Line 52:  Line 54:  
So when <math>a_k=0</math>, the binomial coefficient reads as <math>\binom{k1}{k}</math> which equals 0 since there are 0 ways to choose k items from k1 items.  So when <math>a_k=0</math>, the binomial coefficient reads as <math>\binom{k1}{k}</math> which equals 0 since there are 0 ways to choose k items from k1 items.  
+  
+  = Getting the genotypes from a genotype index and a given ploidy =  
+  
+  The genotype index is computed by a summation of a series which is  
+  monotonically decreasing. This allows you to compute the inverse function  
+  from index to the ordered genotypes by using a "water rapids algorithm" with  
+  decreasing height of each mini water fall.  
+  
+  std::vector<int32_t> bcf_ip2g(int32_t genotype_index, uint32_t no_ploidy)  
+  {  
+  std::vector<int32_t> genotype(no_ploidy, 0);  
+  int32_t pth = no_ploidy;  
+  int32_t max_allele_index = genotype_index;  
+  int32_t leftover_genotype_index = genotype_index;  
+  while (pth>0)  
+  {  
+  for (int32_t allele_index=0; allele_index <= max_allele_index; ++allele_index)  
+  {  
+  int32_t i = choose(pth+allele_index1, pth);  
+  if (i>=leftover_genotype_index  allele_index==max_allele_index)  
+  {  
+  if (i>leftover_genotype_index) allele_index;  
+  leftover_genotype_index = choose(pth+allele_index1, pth);  
+  pth;  
+  max_allele_index = allele_index;  
+  genotype[pth] = allele_index;  
+  break;  
+  }  
+  }  
+  }  
+  return genotype;  
+  }  
+  
+  todo:: describe in a human understandable fashion.  
= Simple cases =  = Simple cases =  
Line 298:  Line 334:  
13 <br>  13 <br>  
14 <br>  14 <br>  
−  15 <br>  +  <span style="color:#FF0000">15</span><br> 
 AAA <br>   AAA <br>  
AAB <br>  AAB <br>  
Line 355:  Line 391:  
3  3  
2  2  
−    +  index=10+3+2=<span style="color:#FF0000">15</span> (QED!) 
    
}  } 
Latest revision as of 21:07, 18 October 2017
Introduction
The VCF format encodes genotypes by the index of the enumeration of genotypes given ploidy number and alleles. This allows for direct access to a value associated with a genotype within an array when one works with genotype likelihoods.
Motivation
Plants species exhibit a diverse number of ploidy, for example, the strawberry is an octoploid and the pear is a triploid.
Copy number variations in somatic variant calling also leads to variable ploidy to consider when genotyping a locus.
While there are explicit functions that could be googled for handling haploid and diploid cases. It seems difficult to find the closed forms for the general case. This wiki fills in that need.
The number of genotypes given a ploidy and alleles
where P is the ploidy number and A is the number of alleles.
Getting the index of a genotype in an enumerated list given a ploidy and alleles
where P is the number of ploidy, , .. are the alleles in numeric encoding (0 to A1) and are ordered (e.g. AB and ABCCCC are ordered but ACB is not ordered).
This is well defined because:
Because may be 0, we will see cases of when . This is alright because of the definition of which defines this case as 0. But to make it more sensible, we can define the function equivalently as:
So when , the binomial coefficient reads as which equals 0 since there are 0 ways to choose k items from k1 items.
Getting the genotypes from a genotype index and a given ploidy
The genotype index is computed by a summation of a series which is monotonically decreasing. This allows you to compute the inverse function from index to the ordered genotypes by using a "water rapids algorithm" with decreasing height of each mini water fall. std::vector<int32_t> bcf_ip2g(int32_t genotype_index, uint32_t no_ploidy) { std::vector<int32_t> genotype(no_ploidy, 0); int32_t pth = no_ploidy; int32_t max_allele_index = genotype_index; int32_t leftover_genotype_index = genotype_index; while (pth>0) { for (int32_t allele_index=0; allele_index <= max_allele_index; ++allele_index) { int32_t i = choose(pth+allele_index1, pth); if (i>=leftover_genotype_index  allele_index==max_allele_index) { if (i>leftover_genotype_index) allele_index; leftover_genotype_index = choose(pth+allele_index1, pth); pth; max_allele_index = allele_index; genotype[pth] = allele_index; break; } } } return genotype; }
todo:: describe in a human understandable fashion.
Simple cases
Ploidy  Alleles  No. of Genotypes  Index 

1  A  
2  A 
Derivation for counting the number of genotypes
There must always be P observed alleles and there can only be at most A alleles. This can be modeled by P+A1 points where you choose A1 points to be dividers that separate the alleles. Thus the number of ways you can observe this is which is equivalent to .
Derivation for getting the index of a genotype in an enumerated list
Observation of nested patterns
An important observation here is that for the enumeration of A alleles for a given P ploidy, the enumeration of A1 alleles for P ploidy is a subsequence.
Index  A=4,P=3  A=3,P=3  A=2,P=3  A=1,P=3 

0 1 
AAA AAB 
AAA AAB 
AAA AAB 
AAA

Another important observation here is that for a genotype , The th genotype to all end with , this does not help distinguish the order, so we need to only examine the genotype . The sub genotype is also ordered else is not ordered.
The nested genotype sequence is in red. The blue sequence shows the sequence of genotypes enumerated without involving .
Index  A=4,P=3  A=4,P=2  A=4,P=1 

0 1 
AAA AAB 
AAA AAB 
AAA AAB 
The above 2 observations are the key to breaking down the enumeration recursively.
Derivation
is ordered and indexed 0 to A1.
This algorithm is demonstrated in the following table to obtain the index of the genotype C/C/D.
Index  Iteration 0  Iteration 1  Iteration 2  

0 1 
AAA AAB 
AAA AAB 
AA 
AA 
A  
Function call  G(CCD)  F(3,3)  G(CC)  F(2,2)  G(C) = F(1, 2)  
value returned  10  3  2  index=10+3+2=15 (QED!) 
Algorithm for enumerating the genotypes given ploidy and alleles
The below code is for enumerating genotypes and can be used to test the above equations.
uint32_t no = 0 // some global variable void print_genotypes(uint32_t A, uint32_t P, std::string genotype) { if (genotype.size()==P) { std::cerr << no << ") " << genotype << "\n"; ++no; } else { for (uint32_t a=0; a<A; ++a) { std::string s(1,(char)(a+65)); s.append(genotype); print_genotypes(a+1, P, s); } } }
Acknowledgement
To Petr Danecek for double checking this.
Maintained by
This page is maintained by Adrian.