Background
In recent years, Single Nucleotide Polymorphisms (SNPs) have become the preferred marker for association studies of genetic diseases or traits. A set of linked SNPs on one chromosome is called a haplotype. Recent studies have shown that the patterns of Linkage Disequilibrium (LD) observed in human populations have a block-like structure 413. The chromosome recombination only takes place at some low LD regions called recombination hotspots. The high LD region between these hotspots is often referred to as a "haplotype block." Within a haplotype block, there is little or even no recombination occurred, and the SNPs in the block tend to be inherited together. Due to the low haplotype diversity within a block, the information carried by these SNPs is highly redundant. Thus, a small subset of SNPs (called "tag SNPs") is sufficient to distinguish each pair of patterns in the block 713171819. Haplotype blocks with corresponding tag SNPs are quite useful and cost-effective for association studies as it does not require genotyping all SNPs. Many studies have tried to find the minimum set of tag SNPs in a haplotype block. In a large-scale study of human Chromosome 21, Patil et al. 13 developed a greedy algorithm to partition the haplotypes into 4,135 blocks with 4,563 tag SNPs. Zhang et al. 171819 used a dynamic programming approach to reduce the numbers of blocks and tag SNPs to 2,575 and 3,562, respectively. Bafna et al. 1 showed that the problem of minimizing tag SNPs is NP-hard and gave efficient algorithms for special cases of this problem.
<p>Figure 1</p>
The influence of missing data and auxiliary tag SNPs
The influence of missing data and auxiliary tag SNPs. (A) A haplotype block defined by 12 SNPs and 4 haplotype patterns. Each column represents a haplotype pattern and each row represents a SNP locus. The black and grey boxes stand for the major and minor alleles at each SNP locus, respectively. (B) Tag SNPs genotyped without missing data. (C) Tag SNPs genotyped with missing data. (D) The auxiliary tag SNP S5 for h2. (E) The auxiliary tag SNP S8 for h3.
![]()
In reality, a SNP may not be genotyped and considered to be missing data (i.e., we fail to obtain the allele configuration of the SNP) if it does not pass the threshold of data quality 13161920. These missing data may cause ambiguity when using the minimum set of tag SNPs to distinguish an unknown haplotype sample. Figure 1 illustrates the influence of missing data when identifying haplotype samples. In this figure, a haplotype block (see Figure 1 (A)) defined by 12 SNPs and 4 haplotype patterns is presented (from the public haplotype data of human Chromosome 21 13). We follow the same assumption as previous studies that all SNPs are diallelic (i.e., taking on only two values) 113. Suppose we select SNPs S1 and S12 as tag SNPs. The haplotype sample h1 is identified as haplotype pattern P3 unambiguously (see Figure 1 (B)). Consider haplotype samples h2 and h3 with one missing tag SNP (see Figure 1 (C)). h2 can be identified as haplotype patterns P2 or P3, and h3 can be identified as P1 or P3. As a result, these missing tag SNPs result in ambiguity when distinguishing unknown haplotype samples.
Although we can not avoid the occurrence of missing data, the remaining SNPs within the haplotype block may provide abundant information to resolve the ambiguity. For example, if we re-genotype an additional SNP S5 for h2 (see Figure 1 (D)), h2 is identified as haplotype pattern P3 unambiguously. On the other hand, if SNP S8 is re-genotyped (see Figure 1 (E)), h3 is also identified unambiguously. These additional SNPs are referred to as "auxiliary tag SNPs," which can be found from the remaining SNPs in the block and are able to resolve the ambiguity caused by missing data.
Alternatively, instead of re-genotyping auxiliary tag SNPs whenever encountering missing data, we work on a set of SNPs which is not affected by the occurrence of missing data. Figure 2 illustrates a set of SNPs which can tolerate one missing SNP. Suppose we select SNPs S1, S5, S8, and S12 to be genotyped. Note that no matter which SNP is missing, each of the 16 missing patterns can be distinguished by the remaining three SNPs. Therefore, all haplotype samples with one missing SNP can still be identified unambiguously. We refer to these SNPs as "robust tag SNPs," which are able to tolerate a number of missing data. The important feature of robust tag SNPs is that although they consume more SNPs than the "tag SNPs" defined in previous studies, they guarantee that all haplotype samples with a number of missing data can be distinguished unambiguously. When the occurrence of missing data is frequent, the cost of re-genotyping processes can be reduced by robust tag SNPs.
<p>Figure 2</p>
The robust tag SNPs
The robust tag SNPs. A set of robust tag SNPs for tolerating one missing tag SNP.
![]()
This paper focuses on the problem of finding robust tag SNPs to tolerate a number of missing data. Throughout this paper, we denote m as the maximum number of missing SNPs to be tolerated, which corresponds to different missing rates in different genotyping experiments. And we wish to find a minimum set of robust tag SNPs which can distinguish each pair of haplotypes even when up to m SNPs are missing. We assume that the haplotype phases and block partition are available as the input. Numerous methods have been developed to infer haplotypes from genotype data 121415. Several algorithms have also been proposed to find the block partition 41317. The problem of finding minimum robust tag SNPs is shown to be NP-hard (See Theorem 1). To find robust tag SNPs efficiently, we propose two greedy algorithms and one linear programming (LP) relaxation algorithm. The proposed algorithms have been implemented and tested on a variety of simulated and empirical data. We also analyze the efficiency and solutions of these algorithms. An algorithm for finding auxiliary tag SNPs is described assuming robust tag SNPs have been computed in advance.
Results
We propose two greedy algorithms which select the robust tag SNPs one by one in different greedy manners. In addition, we reformulate this problem as an integer programming problem and design an LP-relaxation algorithm to solve this problem. The greedy and LP-relaxation algorithms are able to find solutions within factors of (m + 1) lnK(K−1)2
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqqGSbaBcqqGUbGBdaWcaaqaaiabdUealjabcIcaOiabdUealjabgkHiTiabigdaXiabcMcaPaqaaiabikdaYaaaaaa@363F@, ln((m+1)K(K−1)2)
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqqGSbaBcqqGUbGBcqqGOaakcqqGOaakcqWGTbqBcqGHRaWkcqaIXaqmcqGGPaqkdaWcaaqaaiabdUealjabcIcaOiabdUealjabgkHiTiabigdaXiabcMcaPaqaaiabikdaYaaacqGGPaqkaaa@3CD6@, and O(m ln K) of the optimal solution respectively, where m is the maximum number of missing SNPs allowed and K is the number of haplotype patterns in the block.
We have implemented the first and second greedy algorithms in JAVA [see Additional files 1 and 2]. The LP-relaxation algorithm has been implemented in Perl [see Additional file 3], where the LP problem is solved via a program called "lp_solve" 11. The LP-relaxation algorithm is a randomized method. Thus, this program is repeated for 10 times to explore different solutions and the best solution among them is chosen as the output.
<p>Additional File 1</p>
The program for the first greedy algorithm. The Greedyl.zip file is compressed using WinZip and contains the JAVA source code for the first greedy algorithm.
Click here for file
<p>Additional File 2</p>
The program for the second greedy algorithm. The Greedy2.zip file is compressed using WinZip and contains the JAVA source code for the second greedy algorithm.
Click here for file
<p>Additional File 3</p>
The program for the iterative LP-relaxation algorithm. The ILP.zip file is compressed using WinZip and contains the Perl script for the iterative LP-relaxation algorithm.
Click here for file
In order to evaluate the solutions and efficiency of our algorithms, we also implement a program in JAVA (referred to as "OPT") which uses a brute force method to find the optimal solution. For a given data set of N SNPs, the OPT program examines all possible solutions (i.e., all subsets of (N1)
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaadaqadaqaauaabeqaceaaaeaacqWGobGtaeaacqaIXaqmaaaacaGLOaGaayzkaaaaaa@3059@, (N2)
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaadaqadaqaauaabeqaceaaaeaacqWGobGtaeaacqaIYaGmaaaacaGLOaGaayzkaaaaaa@305B@, ..., and (NN)
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaadaqadaqaauaabeqaceaaaeaacqWGobGtaeaacqWGobGtaaaacaGLOaGaayzkaaaaaa@308E@). The minimum subset of SNPs that can tolerate m missing SNPs is chosen as the output. Due to the NP-hardness of this problem, the OPT program fails to output the optimal solution within a reasonable period of time in many data sets. As a consequence, we skip some impossible solution space to speed up this program by the following two observations: (1) the solutions with less than or equal to m SNPs are the impossible ones since m SNPs might be missing; and (2) for a data set containing K haplotype patterns, the minimum number of SNPs required to distinguish each of them is at least log K (see Lemma 2). As a result, we can examine the possible solutions only for subsets of (Nm+log K)
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaadaqadaqaauaabeqaceaaaeaacqWGobGtaeaacqWGTbqBcqGHRaWkcyGGSbaBcqGGVbWBcqGGNbWzcaaMc8UaaGPaVlabdUealbaaaiaawIcacaGLPaaaaaa@3A01@, (Nm+log K+1)
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaadaqadaqaauaabeqaceaaaeaacqWGobGtaeaacqWGTbqBcqGHRaWkcyGGSbaBcqGGVbWBcqGGNbWzcaaMc8UaaGPaVlabdUealjabgUcaRiabigdaXaaaaiaawIcacaGLPaaaaaa@3BD3@ ..., and (NN)
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaadaqadaqaauaabeqaceaaaeaacqWGobGtaeaacqWGobGtaaaacaGLOaGaayzkaaaaaa@308E@. By searching possible solutions from small subsets to large ones, the OPT program can stop and output the optimal solution immediately when a subset that can tolerate m missing SNPs is found.
Results on simulated data
Theoretically, all SNPs will reach complete linkage equilibrium after sufficient chromosome recombination takes place. We first generate 100 data sets containing short haplotypes which simulate this bottleneck model 121415. Each data set consists of 10 haplotypes with 20 SNPs. These haplotypes are created by randomly assigning the major or minor alleles at each SNP locus. Let m be the number of missing SNPs allowed and Sa be the average number of robust tag SNPs over 100 data sets. Figure 3 (a) plots Sa with respect to m (roughly corresponding to SNP missing rates from 0% to 33%). When m = 0, all programs find the same number of SNPs as the optimal solution. The iterative LP-relaxation algorithm slightly outperforms the others as m increases. When m > 6, more than 20 SNPs are required to tolerate missing data. Thus, no data sets contain enough SNPs for solutions.
<p>Figure 3</p>
Experimental results on random data
Experimental results on random data. (a) Results from data sets containing 10 haplotypes and 20 SNPs. (b) Results from data sets containing 10 haplotypes and 40 SNPs.
![]()
We then generate 100 data sets containing long haplotypes. Each data set is composed of 10 haplotypes with 40 SNPs. Figure 3 (b) illustrates the experimental results on these long data sets (corresponding to SNP missing rates from 0% to 37%). The optimal solutions for m > 2 can not be found by the OPT program within a reasonable period of time (after one week computation) and are not shown in this figure. It is because the possible solutions in long data sets are too large to enumerate. On the other hand, both greedy and iterative LP-relaxation algorithms run in polynomial time and always output a solution efficiently. In this experiment, both greedy algorithms slightly outperforms the iterative LP-relaxation algorithm. In addition, the number of missing SNPs allowed is larger than those in short data sets. For example, to tolerate 10 missing SNPs (i.e., m = 10), all programs output less than 28 SNPs. The remaining SNPs in each data set are still sufficient to tolerate more missing SNPs.
Hudson (2002) 10 provides a program which can simulate a set of haplotypes under the assumption of neutral evolution and uniformly distributed recombination rate using the coalescent model. We use Hudson's program to generate 100 short data sets with 10 haplotypes and 20 SNPs and 100 long data sets with 10 haplotypes and 40 SNPs. Figure 4 (a) shows the experimental results on Hudson's short data sets (corresponding to SNP missing rates from 0% to 23%). The number of missing SNPs allowed are less than that of random data. It is because Hudson's program generates coalescent haplotypes which are similar to each other. As a result, many SNPs can not be used to distinguish haplotypes and the amount of tag SNPs is inadequate to tolerate larger missing SNPs. In this experiment, we observe that the iterative LP-relaxation algorithm finds solutions quite close to the optimal solutions and slightly outperforms the other two algorithms.
<p>Figure 4</p>
Experimental results on Hudson's data
Experimental results on Hudson's data. (a) Results from data sets containing 10 haplotypes and 20 SNPs. (b) Results from data sets containing 10 haplotypes and 40 SNPs.
![]()
Figure 4 (b) illustrates the experimental results on long data sets generated by Hudson's program (corresponding to SNP missing rates from 0% to 29%). The optimal solutions for m > 2 again can not be found by the OPT program within a reasonable period of time. In this experiment, the performance of the first greedy and iterative LP-relaxation algorithms are similar, and they slightly outperform the second greedy algorithm as m becomes large.
Results on real data
We also test these programs on two real data sets: (1) public haplotype data of human Chromosome 21 released by Patil et al. 13; and (2) a 500 KB region on human Chromosome 5q31 which may contain a genetic variant related to the Crohn disease by Daly et al. 4. Patil's data include 20 haplotypes of 24,047 SNPs spanning over about 32.4 MB, which are partitioned into 4,135 haplotype blocks. By genotyping 103 SNPs with minor allele frequency at least 5%, Daly et al. partition the 500 KB region into 11 haplotype blocks. Each haplotype block in these real data sets contains different numbers of SNPs and haplotypes (e.g., from several SNPs to hundreds of SNPs). When m increases, some short blocks may not contain enough SNPs for tolerating missing data (e.g., m > the number of SNPs in a block). As a consequence, Sa here stands for the average number of robust tag SNPs over those blocks still containing solutions.
Figure 5 (a) shows the experimental results on Patil's 4,135 blocks. Because there are many long blocks in Patil's data (e.g., more than one hundred SNPs), the optimal solution for m > 2 can not be found within a reasonable period of time. The experimental result indicates that all algorithms find similar number of robust tag SNPs when m is small. The LP-relaxation algorithm slightly outperforms the others as m increases.
<p>Figure 5</p>
Experimental results on real data
Experimental results on real data. (a) Results from Patil's Chromosome 21 data, (b) Results from Daly's Chromosome 5q31 data.
![]()
Figure 5 (b) illustrates the experimental results on Daly's 11 blocks. Because the haplotype blocks partitioned by Daly et al. are very short (e.g., most blocks contain less than 12 SNPs), all optimal solutions still can be found. The solutions found by each algorithm is almost the same as optimal solutions. Theoretically, Sa should grow monotonically as m increases. But due to the small number of blocks in Daly's data set, Sa does not grow smoothly when m increases from 2 to 3. To explain this phenomenon, we report the detailed result of the first greedy algorithm in Table 1. For each of the 11 blocks, the number of robust tag SNPs found with respect to different values of m is listed in the table. Note that as mentioned before, some blocks may not contain enough SNPs for tolerating large missing data as m increases. When m increases from 2 to 3, Blocks 4 and 10 (which consumes 8 and 5 SNPs) do not contain enough SNPs for a solution and are discarded. As a result, Sa (for m = 3) is computed only using Blocks 1 and 2 and the value is lower than the previous one (i.e., from 4.75 to 4). This phenomenon is not shown in Figure 5 (a) because it is amortized by thousands of blocks in Patil's data set.
<p>Table 1</p>
The detailed result of first greedy algorithm on Daly's 11 blocks.
Block ID
1
2
3
4
5
6
7
8
9
10
11
S
a
m = 0
1
1
2
3
3
2
3
2
2
2
2
23/11 = 2.09
m = 1
2
2
f
5
f
3
5
4
f
3
3
27/8 = 3.375
m = 2
3
3
f
8
f
f
f
f
f
5
f
19/4 = 4.75
m = 3
4
4
f
f
f
f
f
f
f
f
f
8/2 = 4
m = 4
5
5
f
f
f
f
f
f
f
f
f
10/2 = 5
m = 5
6
f
f
f
f
f
f
f
f
f
f
6/1 = 6
m = 6
7
f
f
f
f
f
f
f
f
f
f
7/1 = 7
f: fail to contain enough SNPs for tolerating m missing SNPs
Discussion
In terms of efficiency, the first and second greedy algorithms are faster than the LP-relaxation algorithm. The greedy algorithms usually returns a solution in seconds and the LP-relaxation algorithm requires about half minute for a solution. It is because the running time of LP-relaxation algorithm is bounded by the time of solving the LP problem. Furthermore, this LP-relaxation algorithm is repeated for 10 times to explore 10 different solutions. The OPT program for searching the optimal solution is apparently slower than the others. The optimal solution usually can not be found within a reasonable period of time if the size of the block becomes large. ¿From our empirical study, the optimal solution can be found in reasonable time by the OPT program if the block contains less than 20 SNPs (e.g., the short random data sets). But for those large data sets with more than 40 SNPs, the OPT program is significantly outperformed by the approximation algorithms (e.g., fail to output a solution within one week computation).
Assuming no missing data (i.e., m = 0), we compare the solutions found by each algorithm with the optimal solution. Table 2 lists the numbers of total tag SNPs found by each algorithm in previous experiments. In the experiments on random and Daly's data, the solution found by each algorithm is as good as the optimal solution. In the experiments on Hudson's and Patil's data, these algorithms still find solutions quite close to the optimal solution. For example, the approximation ratios of these algorithms are only 472443≈1.07
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaadaWcaaqaaiabisda0iabiEda3iabikdaYaqaaiabisda0iabisda0iabiodaZaaacqGHijYUcqaIXaqmcqGGUaGlcqaIWaamcqaI3aWnaaa@37F1@ and 46574595≈1.01
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaadaWcaaqaaiabisda0iabiAda2iabiwda1iabiEda3aqaaiabisda0iabiwda1iabiMda5iabiwda1aaacqGHijYUcqaIXaqmcqGGUaGlcqaIWaamcqaIXaqmaaa@39EB@, respectively.
<p>Table 2</p>
The number of total tag SNPs found by each algorithm. The percentage of tag SNPs with respect to total SNPs is shown in parentheses.
Random data
Hudson's data
Patil's data
Daly's data
Total blocks
100
100
100
100
4135
11
Total SNPs
2000
4000
2000
4000
24047
103
1st Greedy
400 (20%)
400 (10%)
509 (25.5%)
472 (11.8%)
4610 (19.2%)
23 (22.3%)
2nd Greedy
400 (20%)
400 (10%)
509 (25.5%)
472 (11.8%)
4610 (19.2%)
23 (22.3%)
LP-relaxation
400 (20%)
400 (10%)
509 (25.5%)
471 (11.8%)
4657 (19.4%)
23 (22.3%)
OPT
400 (20%)
400 (10%)
492 (24.6%)
443 (11.1%)
4595 (19.1%)
23 (22.3%)
We then analyze the genotyping cost that can be saved by using tag SNPs. In Table 2, the percentage of tag SNPs in each data set is shown in parentheses. The experimental results indicate that the cost of genotyping tag SNPs is significantly reduced in comparison with genotyping all SNPs in a block. For example, in Patil's data, we only need to genotype about 19% of tag SNPs in each block, which saves about 81% genotyping cost.
The tradeoffs between the number of additional tag SNPs required and the number of missing SNPs allowed are discussed in the following. In practice, missing data in the genotyping experiment are usually limited to certain missing rate. We transform the maximum number of missing SNPs allowed into maximum missing rates allowed by calculating the percentage of m with respect to the number of robust tag SNPs. Table 3 lists the results of the first greedy algorithm applied on random and Hudson's long data sets. The number of additional tag SNPs grows with respect to m linearly. However, we observe that the maximum missing rate allowed grows slowly as m becomes large. This is because more additional tag SNPs are required in order to tolerate more missing SNPs. But under the same SNP missing rate, genotyping these additional tag SNPs may also increase the number of missing SNPs, which reduces the power of robust tag SNPs. On the positive side, when m is small, the corresponding maximum missing rate allowed is sufficient for most genotyping experiments since their missing rates are usually less than 10%. For example, the robust tag SNPs with m = 1 are sufficient to tolerate 10% missing SNPs, and they only requires at most 3 additional SNPs. As a result, genotyping additional tag SNPs for tolerating missing data is cost-effective under the current genotyping environment.
<p>Table 3</p>
The tradeoffs between additional tag SNPs required and maximum missing rates allowed. These results come from the first greedy algorithm applied on random and Hudson's data sets with 40 SNPs.
m
0
1
2
3
4
5
Random data (40 SNPs)
average number of robust tag SNPs
4
6
8.51
10.47
12.89
14.92
corresponding SNP missing rate
0
16.7%
23.5%
28.6%
31.0%
33.5%
average number of extra tag SNPs
0
2
4.51
6.47
8.89
10.92
Hudson's data (40 SNPs)
average number of robust tag SNPs
4.72
7.71
11.28
14.67
18.23
21.67
corresponding SNP missing rate
0
13.0%
17.7%
20.4%
21.9%
23.1%
average number of extra tag SNPs
0
2.99
6.56
9.95
13.51
16.95
In reality, not all haplotypes are of equal importance or confidence. When selecting robust tag SNPs, it might be desirable to weight them according to their population frequency. To incorporate the frequency of haplotypes into this problem, there are two possible ways:
1. It can be easily done by discarding the rare haplotypes and retain the common haplotypes as the input of our algorithms. This approach would not require modification to our algorithms. But the retained common haplotypes will be processed as equally weighted.
2. Our algorithms try to find a set of SNPs such that each pair of haplotypes are distinguished by a threshold of at least (m + 1) SNPs. A simplest way to weight the haplotypes is choosing different thresholds for each pair of haplotypes according to their population frequency. The haplotype pairs with higher frequency can then be assigned with more tag SNPs than the lower ones by our algorithms.
Methods
Assume we are given a haplotype block containing N SNPs and K haplotype patterns. This block is denoted by an N × K binary matrix Mh (see Figure 6 (A)). Define Mh[i,j] ∈ {1,2} for each i ∈ [1, N] and j ∈ [1, K], where 1 and 2 represent the major and minor alleles, respectively. In reality, the haplotype block may also contain missing data. This formulation can be easily extended to handle missing data by treating them as wild card symbols. To simplify the presentation of this paper, we will assume no missing data in the block. Let C be the set of all SNPs in Mh. The robust tag SNPs C' ⊆ C are a subset of SNPs which is able to distinguish each pair of haplotype patterns unambiguously when at most m SNPs are missing. Note that the missing data may occur at any SNP locus and thus create different missing patterns (see Figure 2). For any haplotype pattern with up to m missing SNPs, the set of robust tag SNPs C' is required to distinguish all of them unambiguously.
<p>Figure 6</p>
Reformulation of the MRTS problem
Reformulation of the MRTS problem. (A) The haplotype matrix Mh containing N SNPs and K haplotype patterns. (B) The bipartite graph corresponding to Mh.
![]()
To distinguish a haplotype pattern unambiguously, each pair of patterns must be distinguished by at least one SNP in C'. For example (see Figure 6 (A)), we say patterns P1 and P2 can be distinguished by SNP S2 since Mh[2,1] ≠ Mh[2,2]. A formal definition of this problem is given below.
Problem: Minimum Robust Tag SNPs (MRTS)
Input: An N × K matrix Mh and an integer m.
Output: The minimum subset of SNPs C' ⊆ C which satisfies:
(1) for each pair of patterns Pi and Pj, these is a SNP Sk ∈ C' such that Mh[k, i] ≠ Mh[k, j];
(2) when at most m SNPs are discarded from C' arbitrarily, (1) still holds.
We then reformulate MRTS to a variant of the set covering problem 6. Each SNP Sk ∈ C (i.e., the k-th row in Mh) is reformulated to a set Sk'
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGtbWudaqhaaWcbaGaem4AaSgabaGaei4jaCcaaaaa@303F@ = {(i, j) | M[k, i] ≠ M[k, j] and i <j}. For example, suppose the k-th row in Mh is {1,1,1,2}. The corresponding set Sk'
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGtbWudaqhaaWcbaGaem4AaSgabaGaei4jaCcaaaaa@303F@ = {(1,4), (2,4), (3,4)}. In other words, Sk'
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGtbWudaqhaaWcbaGaem4AaSgabaGaei4jaCcaaaaa@303F@ stores the pairs of patterns distinguished by SNP Sk. Define P as the set that contains all pairs of patterns (i.e., P = {(i,j) | 1 ≤ i <j ≤ K} = {(1,2), (1,3), ..., (K - l,K)}).
Consider each element in P and each reformulated set of C as nodes in an undirected bipartite graph (see Figure 6 (B). If SNP Sk can distinguish patterns Pi and Pj (i.e., (i,j) ∈ Sk'
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGtbWudaqhaaWcbaGaem4AaSgabaGaei4jaCcaaaaa@303F@), there is an edge connecting the nodes (i, j) and Sk'
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGtbWudaqhaaWcbaGaem4AaSgabaGaei4jaCcaaaaa@303F@. The following lemma implies that each pair of patterns must be distinguished by at least (m + 1) SNPs to tolerate m missing SNPs.
Lemma 1. C' ⊆ C is the set of robust tag SNPs which allows at most m missing SNPs iff each node in P has at least (m + 1) edges connecting to each node in C'.
Proof. Let C' be the set of robust tag SNPs which allows at most m missing SNPs. Suppose patterns Pi and Pj are distinguished by only m SNPs in C' (i.e., (i, j) has only m edges connecting to nodes in C'). However, if these m SNPs are all missing, no other SNPs in C' are able to distinguish patterns Pi and Pj, which is a contradiction. Thus, each pair of patterns must be distinguished by at least (m + 1) SNPs, which implies that each node in P must have at least (m + 1) edges connecting to nodes in C'. The proof of the other direction is similar.
In the following, we give a lower bound regarding the minimum number of robust tag SNPs required, which is used to skip some solution space by the OPT program.
Lemma 2. Given K haplotype patterns, the minimum number of robust tag SNPs required is at least log K.
Proof. Recall that the value of a SNP is binary. The maximum number of distinct haplotypes which can be distinguished by N SNPs is at most 2N. As a result, for a given data set containing K haplotype patterns, the minimum number of SNPs required is at least log K.
The following theorem shows the NP-hardness of the MRTS problem, which implies there is no polynomial time algorithm to find the optimal solution of MRTS.
Theorem 1. The MRTS problem is NP-hard.
Proof. When m = 0, MRTS is the same as the original problem of finding minimum tag SNPs, which is known as the minimum test set problem 617. Since the minimum test set problem is NP-hard and can be reduced to a special case of MRTS, MRTS is NP-hard.
The first greedy algorithm
To solve MRTS efficiently, we propose a greedy algorithm which returns a solution not too larger than the optimal solution. By Lemma 1, to tolerate m missing tag SNPs, we need to find a subset of SNPs C' ⊆ C such that each pair of patterns in P is distinguished by at least (m + 1) SNPs in C'. Assume that the SNPs selected by this algorithm are stored in a (m + 1) × |P| table (see Figure 7 (A)). Initially, each grid in the table is empty. Once a SNP Sk, (that can distinguish patterns Pi and Pj) is selected, one grid of the column (i, j) is filled in with Sk, and we say that this grid is covered by Sk.
<p>Figure 7</p>
An example of the first greedy algorithm
An example of the first greedy algorithm. The SNPs S1, S4, S2, and S3 are selected by the first greedy algorithm. (A) The table that stores each selected SNP.
![]()
This greedy algorithm works by covering the grids from the first row to the (m + 1)-th row, and greedily selects a SNP which covers most uncovered grids in the i-th row at each iteration. In other words, while working on the i-th row, a SNP is selected if its reformulated set S' maximizes |S' ∩ Ri |, where Ri is the set of uncovered grids at the i-th row.
Figure 7 illustrates an example for this algorithm to tolerate one missing tag SNP (i.e., m = 1). The SNPs S1, S4, S2, and S3 are selected in order. When all grids in this table are covered, each pair of patterns is distinguished by (m + 1) SNPs in the corresponding column. Thus, the SNPs in this table are the robust tag SNPs which can tolerate up to m missing SNPs. The pseudo code of this greedy algorithm is given below.
Algorithm: FlRST-GREEDY-ALGORITHM (C, P, m)
1 Ri ← P, ∀i ∈ [1, m + 1]
2 C' ← φ
3 for i = 1 to m + 1 do
4 while Ri ≠ φ do
5 select and remove a SNP S from C that maximizes |S' ∩ Ri|
6 C' ← C' ∪ S
7 j ← i
8 while S' ≠ φ and j ≤ m + 1 do
9 Stmp ← S' ∩ Rj //Stmp is a temporary variable for holding the result of S' ∩ Ri
10 Rj ← Rj - Stmp
11 S' ← S' - Stmp
12 j ← j + l
13 endwhile
14 endwhile
15 endfor
16 return C'
The time complexity of this algorithm is analyzed as follows. At Line 4, the number of iterations of the intermediate loop is bounded by |Ri| ≤ |P|. Within the loop body (Lines 5–13), Line 5 takes O(|C||P|) because we need to check all SNPs in C and examine the uncovered grids of Ri. The inner loop (Lines 8–13) takes only O(|S'|). Thus, the entire program runs in O(m|C||P|2).
We now show the solution C' returned by the first greedy algorithm is not too larger than the optimal solution C*. Suppose the algorithm selects the k-th SNP when working on the i-th row. Let |Skc
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGtbWudaqhaaWcbaGaem4AaSgabaGaem4yamgaaaaa@30B8@| be the number of grids in the i-th row covered by the k-th selected SNP (i.e., |Skc
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGtbWudaqhaaWcbaGaem4AaSgabaGaem4yamgaaaaa@30B8@| = |S' ∩ Ri|; see Line 5 in FIRST-GREEDY-ALGORITHM). For example (see Figure 7), S2c=2
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGtbWudaqhaaWcbaGaeGOmaidabaGaem4yamgaaOGaeyypa0JaeGOmaidaaa@324D@ since the second selected SNP (i.e., S4) covers two grids in the first row. We incur 1 unit of cost to each selected SNP, and spread this cost among the grids in Skc
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGtbWudaqhaaWcbaGaem4AaSgabaGaem4yamgaaaaa@30B8@3. In other words, each grid at the i-th row and j-th column is assigned a cost Cji
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGdbWqdaqhaaWcbaGaemOAaOgabaGaemyAaKgaaaaa@30A2@ (see Figure 8), where
<p>Figure 8</p>
Analysis of the first greedy algorithm
Analysis of the first greedy algorithm. This figure shows the cost Cji
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGdbWqdaqhaaWcbaGaemOAaOgabaGaemyAaKgaaaaa@30A2@ of each grid for the first greedy algorithm.
![]()
C
j
i
=
{
1
|
S
k
c
|
if the algorithm selects the
k
-th SNP when covering the
i
-th row;
0
otherwise
.
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGdbWqdaqhaaWcbaGaemOAaOgabaGaemyAaKgaaOGaeyypa0ZaaiqaaeaafaqaaeGacaaabaWaaSqaaSqaaiabigdaXaqaamaaemaabaGaem4uam1aa0baaWqaaiabdUgaRbqaaiabdogaJbaaaSGaay5bSlaawIa7aaaaaOqaaiabbMgaPjabbAgaMjabbccaGiabbsha0jabbIgaOjabbwgaLjabbccaGiabbggaHjabbYgaSjabbEgaNjabb+gaVjabbkhaYjabbMgaPjabbsha0jabbIgaOjabb2gaTjabbccaGiabbohaZjabbwgaLjabbYgaSjabbwgaLjabbogaJjabbsha0jabbohaZjabbccaGiabbsha0jabbIgaOjabbwgaLjabbccaGiabdUgaRjabb2caTiabbsha0jabbIgaOjabbccaGiabbofatjabb6eaojabbcfaqjabbccaGiabbEha3jabbIgaOjabbwgaLjabb6gaUjabbccaGiabbogaJjabb+gaVjabbAha2jabbwgaLjabbkhaYjabbMgaPjabb6gaUjabbEgaNjabbccaGiabbsha0jabbIgaOjabbwgaLjabbccaGiabdMgaPjabb2caTiabbsha0jabbIgaOjabbccaGiabbkhaYjabb+gaVjabbEha3jabbUda7aqaaiaaykW7caaMc8UaeGimaadabaGaee4Ba8MaeeiDaqNaeeiAaGMaeeyzauMaeeOCaiNaee4DaCNaeeyAaKMaee4CamNaeeyzauMaeeOla4caaaGaay5Eaaaaaa@9D18@
Since each selected SNP is assigned 1 unit of cost, the sum of Cji
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGdbWqdaqhaaWcbaGaemOAaOgabaGaemyAaKgaaaaa@30A2@ for each grid in the table is equal to |C'|,
i.e.,
|
C
'
|
=
∑
i
=
1
m
+
1
∑
j
=
1
K
(
K
−
1
)
2
C
j
i
.
(
1
)
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqGG8baFcqWGdbWqcqGGNaWjcqGG8baFcaaMc8UaaGPaVlabg2da9maaqahabaWaaabCaeaacqWGdbWqdaqhaaWcbaGaemOAaOgabaGaemyAaKgaaaqaaiabdQgaQjabg2da9iabigdaXaqaamaaleaameaacqWGlbWscqGGOaakcqWGlbWscqGHsislcqaIXaqmcqGGPaqkaeaacqaIYaGmaaaaniabggHiLdaaleaacqWGPbqAcqGH9aqpcqaIXaqmaeaacqWGTbqBcqGHRaWkcqaIXaqma0GaeyyeIuoakiabc6caUiaaxMaacaWLjaWaaeWaaeaacqaIXaqmaiaawIcacaGLPaaaaaa@537C@
Let Rki
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGsbGudaqhaaWcbaGaem4AaSgabaGaemyAaKgaaaaa@30C2@ be the number of uncovered grids in the i-th row before the k-th iteration (i.e., (k - 1) SNPs have been selected by the algorithm). For example (see Figure 8), R21=2
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGsbGudaqhaaWcbaGaeGOmaidabaGaeGymaedaaOGaeyypa0JaeGOmaidaaa@31EC@ since two grids in the first row are still uncovered before the second SNP is selected. Define Ci'
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGdbWqdaqhaaWcbaGaemyAaKgabaGaei4jaCcaaaaa@301B@ as the set of iterations used by the algorithm when working on the i-th row. For example (see Figure 8), C2'={3,4}
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGdbWqdaqhaaWcbaGaeGOmaidabaGaei4jaCcaaOGaeyypa0Jaei4EaSNaeG4mamJaeiilaWIaeGinaqJaeiyFa0haaa@368C@ since this algorithm works on the second row in the third and fourth iterations. We can rewrite (1) as
∑
i
=
1
m
+
1
∑
j
=
1
K
(
K
−
1
)
2
C
j
i
=
∑
i
=
1
m
+
1
∑
k
∈
C
i
'
(
R
k
−
1
i
−
R
k
i
)
1
|
S
k
c
|
.
(
2
)
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaadaaeWbqaamaaqahabaGaem4qam0aa0baaSqaaiabdQgaQbqaaiabdMgaPbaaaeaacqWGQbGAcqGH9aqpcqaIXaqmaeaadaWcbaadbaGaem4saSKaeiikaGIaem4saSKaeyOeI0IaeGymaeJaeiykaKcabaGaeGOmaidaaaqdcqGHris5aaWcbaGaemyAaKMaeyypa0JaeGymaedabaGaemyBa0Maey4kaSIaeGymaedaniabggHiLdGccqGH9aqpdaaeWbqaamaaqafabaWaaeWaaeaacqWGsbGudaqhaaWcbaGaem4AaSMaeyOeI0IaeGymaedabaGaemyAaKgaaOGaeyOeI0IaemOuai1aa0baaSqaaiabdUgaRbqaaiabdMgaPbaaaOGaayjkaiaawMcaaaWcbaGaem4AaSMaeyicI4Saem4qam0aa0baaWqaaiabdMgaPbqaaiabcEcaNaaaaSqab0GaeyyeIuoaaSqaaiabdMgaPjabg2da9iabigdaXaqaaiabd2gaTjabgUcaRiabigdaXaqdcqGHris5aOWaaSaaaeaacqaIXaqmaeaacqGG8baFcqWGtbWudaqhaaWcbaGaem4AaSgabaGaem4yamgaaOGaeiiFaWhaaiabc6caUiaaxMaacaWLjaWaaeWaaeaacqaIYaGmaiaawIcacaGLPaaaaaa@7177@
Lemma 3. The k-th selected SNP has |Skc|≥Rk−1i|C*|
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaadaabdaqaaiabdofatnaaDaaaleaacqWGRbWAaeaacqWGJbWyaaaakiaawEa7caGLiWoacqGHLjYSdaWcaaqaaiabdkfasnaaDaaaleaacqWGRbWAcqGHsislcqaIXaqmaeaacqWGPbqAaaaakeaacqGG8baFcqWGdbWqcqGGQaGkcqGG8baFaaaaaa@40A0@.
Proof. Suppose the algorithm is working on the i-th row at the beginning of the k-th iteration. Let Ck*
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGdbWqdaqhaaWcbaGaem4AaSgabaGaeiOkaOcaaaaa@3025@ be the set of SNPs in C* (the optimal solution) that has been selected by the algorithm before the k-th iteration, and the set of remaining SNPs in C* be Ck¯*
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGdbWqdaqhaaWcbaGafm4AaSMbaebaaeaacqGGQaGkaaaaaa@303D@. We claim that there exists a SNP in Ck¯*
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGdbWqdaqhaaWcbaGafm4AaSMbaebaaeaacqGGQaGkaaaaaa@303D@ which can cover at least Rki|Ck¯*|
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaadaWcaaqaaiabdkfasnaaDaaaleaacqWGRbWAaeaacqWGPbqAaaaakeaadaabdaqaaiabdoeadnaaDaaaleaacuWGRbWAgaqeaaqaaiabcQcaQaaaaOGaay5bSlaawIa7aaaaaaa@3797@ grids in the i-th row. Otherwise (i.e., each SNP in Ck¯*
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGdbWqdaqhaaWcbaGafm4AaSMbaebaaeaacqGGQaGkaaaaaa@303D@ covers less than Rki|Ck¯*|
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaadaWcaaqaaiabdkfasnaaDaaaleaacqWGRbWAaeaacqWGPbqAaaaakeaadaabdaqaaiabdoeadnaaDaaaleaacuWGRbWAgaqeaaqaaiabcQcaQaaaaOGaay5bSlaawIa7aaaaaaa@3797@ grids), all SNPs in Ck¯*
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGdbWqdaqhaaWcbaGafm4AaSMbaebaaeaacqGGQaGkaaaaaa@303D@ will cover less than (Rki|Ck¯*|×|Ck¯*|=Rki)
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqGGOaakdaWcaaqaaiabdkfasnaaDaaaleaacqWGRbWAaeaacqWGPbqAaaaakeaadaabdaqaaiabdoeadnaaDaaaleaacuWGRbWAgaqeaaqaaiabcQcaQaaaaOGaay5bSlaawIa7aaaacqGHxdaTdaabdaqaaiabdoeadnaaDaaaleaacuWGRbWAgaqeaaqaaiabcQcaQaaaaOGaay5bSlaawIa7aiabg2da9iabdkfasnaaDaaaleaacqWGRbWAaeaacqWGPbqAaaGccqGGPaqkaaa@473F@ grids in the i-th row. But since Ck*∪Ck¯*=C*
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGdbWqdaqhaaWcbaGaem4AaSgabaGaeiOkaOcaaOGaeSOkIuLaem4qam0aa0baaSqaaiqbdUgaRzaaraaabaGaeiOkaOcaaOGaeyypa0Jaem4qamKaeiOkaOcaaa@37EB@, this implies that C* can not cover all grids in Rki
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGsbGudaqhaaWcbaGaem4AaSgabaGaemyAaKgaaaaa@30C2@, which is a contradiction. Because all SNPs in Ck¯*
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGdbWqdaqhaaWcbaGafm4AaSMbaebaaeaacqGGQaGkaaaaaa@303D@ are candidates to the greedy algorithm, the k-th selected SNP must cover at least Rki|Ck¯*|
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaadaWcaaqaaiabdkfasnaaDaaaleaacqWGRbWAaeaacqWGPbqAaaaakeaadaabdaqaaiabdoeadnaaDaaaleaacuWGRbWAgaqeaaqaaiabcQcaQaaaaOGaay5bSlaawIa7aaaaaaa@3797@ grids in the i-th row, which implies |Skc|≥Rk−1i|C*|
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaadaabdaqaaiabdofatnaaDaaaleaacqWGRbWAaeaacqWGJbWyaaaakiaawEa7caGLiWoacqGHLjYSdaWcaaqaaiabdkfasnaaDaaaleaacqWGRbWAcqGHsislcqaIXaqmaeaacqWGPbqAaaaakeaacqGG8baFcqWGdbWqcqGGQaGkcqGG8baFaaaaaa@40A0@ since |C*| ≥ |Ck¯*
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGdbWqdaqhaaWcbaGafm4AaSMbaebaaeaacqGGQaGkaaaaaa@303D@| and |Rki|≤|Rk−1i|
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaadaabdaqaaiabdkfasnaaDaaaleaacqWGRbWAaeaacqWGPbqAaaaakiaawEa7caGLiWoacqGHKjYOdaabdaqaaiabdkfasnaaDaaaleaacqWGRbWAcqGHsislcqaIXaqmaeaacqWGPbqAaaaakiaawEa7caGLiWoaaaa@3EC0@. □
Theorem 2. The first greedy algorithm gives a solution of (m + 1) lnK(K−1)2
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqqGSbaBcqqGUbGBdaWcaaqaaiabdUealjabcIcaOiabdUealjabgkHiTiabigdaXiabcMcaPaqaaiabikdaYaaaaaa@363F@approximation.
Proof. Define the d-th harmonic number as H(d)=∑i=1d1i
MathType@MTEF@5@5@+=feaafiart1ev1aaatCvAUfKttLearuWrP9MDH5MBPbIqV92AaeXatLxBI9gBaebbnrfifHhDYfgasaacH8akY=wiFfYdH8Gipec8Eeeu0xXdbba9frFj0=OqFfea0dXdd9vqai=hGuQ8kuc9pgc9s8qqaq=dirpe0xb9q8qiLsFr0=vr0=vr0dc8meaabaqaciGacaGaaeqabaqabeGadaaakeaacqWGibascqGGOaakcqWGKbazcqGGPaqkcqGH9aqpdaaeWaqaamaalaaabaGaeGymaedabaGaemyAaKgaaaWcbaGaemyAaKMaeyypa0JaeGymaedabaGaemizaqganiabggHiLdaaaa@3ACF@ and H(0) = 0. By (2) and Lemma 3,
∑
i
=
1
m
+
1
∑
j
=
1
K
(
K
−
1
)
2
C
j
i
=
∑
i
=
1
m
+
1
∑
k
∈
C
i
'
(
R
k
−
1
i
−
R
k
i
)
1
|
S
k
c
|
≤
∑
i
=
1
m
+
1
∑
k
∈
C
i
'
(