 Research
 Open Access
 Published:
Incorporating Ab Initio energy into threading approaches for protein structure prediction
BMC Bioinformatics volume 12, Article number: S54 (2011)
Abstract
Background
Native structures of proteins are formed essentially due to the combining effects of local and distant (in the sense of sequence) interactions among residues. These interaction information are, explicitly or implicitly, encoded into the scoring function in protein structure prediction approaches—threading approaches usually measure an alignment in the sense that how well a sequence adopts an existing structure; while the energy functions in Ab Initio methods are designed to measure how likely a conformation is nearnative. Encouraging progress has been observed in structure refinement where knowledgebased or physicsbased potentials are designed to capture distant interactions. Thus, it is interesting to investigate whether distant interaction information captured by the Ab Initio energy function can be used to improve threading, especially for the weakly/distant homologous templates.
Results
In this paper, we investigate the possibility to improve alignmentgenerating through incorporating distant interaction information into the alignment scoring function in a nontrivial approach. Specifically, the distant interaction information is introduced through employing an Ab Initio energy function to evaluate the “partial” decoy built from an alignment. Subsequently, a local search algorithm is utilized to optimize the scoring function.
Experimental results demonstrate that with distant interaction items, the quality of generated alignments are improved on 68 out of 127 querytemplate pairs in Prosup benchmark. In addition, compared with statetoart threading methods, our method performs better on alignment accuracy comparison.
Conclusions
Incorporating Ab Initio energy functions into threading can greatly improve alignment accuracy.
Introduction
Protein structure determination is critical for understanding protein functions, and also highly relevant with therapeutics and drugs design. Computational prediction methods for protein structure play important roles due to the speed of experimental determination methods cannot catch up with that of generation of protein primary sequences by genome projects. Computational protein structure prediction methods can be categorized into free modeling (FM) and templatebased modeling (TBM). Specifically, for the protein without structural analogs in the template database, the structural conformation has to be built from the scratch; while for the proteins having structural analogs, the key step is to identify an accurate alignment between the query sequence and a template with known structure.
Both Ab Initio and threading approaches employ scoring functions to capture interactions among residues in an explicit or implicit manner. In essence, protein folding is the combining effects of local interactions and distant interactions among residues. Specifically, local interactions lead to local structural motifs, while nonlocal interactions arrange local structural motif to form nativelike structures.
The Ab Initio approaches for free modeling attempt to find a structural conformation with the lowest energy. Typically, local interactions are described via short structural fragments while nonlocal interactions are captured via an energy function. Various energy functions [1–5] have been proposed, and can be categorized into two classes, i.e., knowledgebased and physicsbased. Compared with physicsbased energy functions, knowledgebased energy functions are more attractive since they are easy to use and understand. In addition, distancedependent potentials perform better than distanceindependent ones [6].
A typical templatebased modeling procedure consists of a threading step to align the target protein onto a template, and a refinement step to refine the template structure to be more nativelike. Numerous threading methods have been proposed to calculate the optimal alignments under different scoring functions. These threading methods can be categorized into the following classes based on the divergence of scoring functions:

1.
The scoring function does not contain any nonlocal interaction information explicitly. For example, FASTA [7], BLAST [8], and PSIBLAST [9] assume independence among residues at different positions while HMMer [10] and HHpred [11] apply Hidden Markov Model to introduce the transition information between adjacent residues into scoring function. Since only local information is taken into consideration in their scoring functions, dynamic programming is a natural technique to obtain a global optimal solution.

2.
The scoring function captures nonlocal interaction information via contact preference. That is, if a pair of residues in the query sequence are aligned to the two ends of an interaction, then this pair will be given a score according to a contact preference matrix. PROSPECT [12] and RAPTOR [13] implemented this kind of energy function and demonstrated the improvements of prediction accuracy. However, the following features of nonlocal interactions were not taken into consideration explicitly: (i) it is more accurate to describe pairwise interactions in distancedependent manner than distanceindependent ways; and (ii) besides distance, the orientation angles involved in dipole–dipole interactions have also been proved to be useful to discriminate native structures.
The purposes of the study is to investigate whether threading results can be improved through incorporating Ab Initio energy function. Distant interactions are usually described in a more accurate manner in Ab Initio energy function. For example, dDFIRE [6] employs distancedependent pairwise interaction rather than distanceindependent one. Encouraging progress has been observed in structure refinement where Ab Initio energy function is employed to refine template structure to be more nativelike. It is interesting whether Ab Initio energy function improves alignment generating.
In addition, when the global structural information is incorporated, effective algorithms such as dynamic programming do not work any more: if all pairwise interactions are added into scoring function, the optimization problem becomes NPhard [14]. A variety of techniques, such as integer linear programming [13] and divide and conquer [15] have been proposed to solve this problem. In this study, we propose an efficient, local search based method to identify optimal alignments. Comparing with existing methods [13, 15], which are designed specifically for scoring functions consisting of distantindependent pairwise interaction alone as their global item, our method is more general and can be used to optimize any kind of scoring functions.
Scoring model
The scoring function to assess an alignment A consists of local item L(A) and distant item G(A), i.e., score(A) = ω_{ L }L(A) + G(A), where ω_{ L } denotes weight of local item.
Local item is the weighted sum of mutation score S_{ m }, secondary structure compatibility score S_{ ss }, solvent accessibility score S_{ sa }, gap penalty score S_{ g }, and structural segment compatibility score S_{ CLE }[16], i.e., L(A) = ω_{ m }S_{ m }(A) + ω_{ ss }S_{ ss }(A) + ω_{ CLE }S_{ CLE }(A) + ω_{ sa }S_{ sa }(A) + ω_{ g }S_{ g }(A), S_{ g }(A) = ω_{ go }GO + ω_{ ge }GE, where GO and GE are the number of gap open and gap extending, respectively. The weight of these items are to be determined via training on SALIGN benchmark.
The global item G(A), which contains the nonlocal interaction information implicitly, is captured by the dDFIRE energy over a “partial” decoy corresponding to the alignment A. An ideal way to measure nonlocal interaction is to calculate dDFIRE energy over a fulllength decoy. However, it is usually timeconsuming to obtain fulllength decoy through running structuregenerating tools such as MODELLER [17]. Thus, this strategy is unacceptable since we usually need to sample thousands of alignments. Here, we employ an alternative method to build a partial “decoy” from the alignment. Specifically, only the aligned residues are kept with their coordinates simply copied from the corresponding residues in the template.
This section are organized as follows: We first verify that dDFIRE energy function is constantly goodperforming when used to evaluate “partial” decoys. Second, both local item and global item should be normalized using match state size. Third, we prove that global item of the our scoring function is effective to capture distance interaction comparing with contactpreference based scoring functions. Fourth, we show that optimal local score can be used to determine “easy” pairs for which local score item is sufficient while adding global item may lead noise contrarily. Last, we train ω_{ L } on SALIGN [18] benchmark dataset.
Performance of dDFIRE on partial structure
Since we calculate dDFIRE energy on the “partial” decoy instead of a fulllength structure, thus it is necessary to verify whether the “partial dDFIRE energy” still have the power to distinguish nativelike decoys. To verify this, we performed experiments on three commonlyused benchmark datasets: LKF [1], Gapless Threading [2] and Rosetta [5]. The datasets contain 178, 200 and 232 proteins, respectively; and for each protein, 100 decoys were generated as control to the native structure. The objective of this experiment is to verify whether the “partial” native structure can be distinguished from the “partial” decoys by dDFIRE.
For both native structures and decoys, the “partial” conformations were simulated through randomly excising a set of residues. At various excising percentage, the ratio of proteins for which the partial native structure has the lowest dDFIRE energy relative to all partial decoys are calculated, and denoted as accuracy in Fig.1. As demonstrated by Fig.1, on LKF and Rosetta benchmarks, dDFIRE performs constantly well even if over 40% residues are excised; and on Gapless Threading benchmark, the performance decreases slightly.
Score normalization
We also investigate the relationship between the scores with the match state size. Analysis suggests the linearity between local(global) scores and match state size. Specifically, the linear correlation coefficient between local(global) scores and the match state size is –0.762 (–0.968) (See Fig.2 and 3 for details). Thus, it is reasonable to normalize both local and global score through dividing by the match state size.
Effect of global items
We further investigate the effect of global item. As control, we performed comparison with the traditional way to describe nonlocal interactions via contact preference matrix [13, 15], i.e, S_{ p } = ∑_{ i }∑_{ j }δ(i, j)Pair(A(i), A(j)), and where A(i) is the matched residue in the sequence, δ(i, j) indicates whether i th and j th residue in the template have contact, P_{ m } is the profile vector at the m th position and C is the contact preference matrix.
We first give some notations before presenting the experiments to examine the effects of global items. For each querytemplate pair, two typical alignments are generated: the structural alignment A_{ R } generated via running TMalign [19], and the optimal alignment (denoted as A_{ L }) when only local item L(A) is taken into consideration, i.e. A_{ L } = argmin_{ A }L(A). For each alignment A, its real quality is measured by TMscore [20], denoted as TM(A). We also use L(A) and G(A) to denote the local score and global score of A, and use C(A) to denote the contactpreferencebased score of A.
The 200 querytemplate pairs in SALIGN [18] dataset are categorized into two classes according to the quality of A_{ L }: (i) TM(A_{R}) – TM(A_{ L }) < 0.1, 144 pairs in total; and (ii) TM(A_{ R }) – TM(A_{ L }) ≥ 0.1, 56 pairs in total. Intuitively, class 1 contains the pairs for which a scoring function with local score item alone is sufficient; and class 2 contains the pairs for which local score alone failed. For pairs in class 2, we expect global items can help to distinguish the reference alignment. We verify this by comparing the global score of A_{ L } and A_{ R } : only for pairs satisfying A_{ L } – A_{ R } > 0, it is likely to distinguish the reference alignment. Fig.4 and 5 suggest that for the pairs that local item alone cannot separate A_{ L } from A_{ R } (L(A_{ L }) ≤ L(A_{ R }) because of A_{ L } = argmin_{ A }L(A)), global item of our scoring function can effectively measure the quality of alignments. Specifically, we observed that G(A_{ R }) <G(A_{ L }) on 52 of 56 pairs. In contrast, the contactpreferencebased score does not help improve this situation, only on 20 of 56 pairs, C(A_{ R }) <C(A_{ L }).
Determining pairs for which local score item alone is sufficient
On 144 of 200 pairs of SALGIN benchmark, local score alone is sufficient to find out a “good” alignment(TM(A_{ R }) – TM(A_{ L }) < 0.1). In fact, in these cases, adding global item may lead to falsenegative [21]. We observed that the normalization of local scores help recognizing these “easy” pairs. This is reasonable since local score contains most of the homologous information between the sequence and the template.
Fig.6 implies that TMscore value is strongly correlated with local score (linear correlation coefficient is 0.78). Besides, as the local score increases, A_{ L } becomes worse, i.e., the cumulative average value of TM(A_{ R }) – TM(A_{ L }) increases as the local score increasing (the blue curve in Fig.6). Accordingly, we choose a threshold of local score, denoted as θ, to determine whether local score item is sufficient: if L(A_{ L }) ≤ θ, then A_{ L } is treated as a good alignment. In our method, θ = –87.
Weight training process
Parameter ω_{ L } is trained by classification. For each querytemplate pair in SALIGN benchmark, one positive alignment A_{ p } and 10 negative alignments A_{ n } are selected (We also have tried other number of negative alignments, similar result is obtained).
Here, we use the reference alignment as positive alignment, i.e. A_{ p } = A_{ R }. Negative alignments are chosen from the top 100 alignments returned by dynamic programming. We first cluster these alignments to remove redundancy, and then randomly select alignments satisfying TM(A_{ p }) – TM(A_{ n }) > 0.2.
ω_{ L } should divide A_{ n } and A_{ p } as much as possible. Formally
ω_{ L } = arg max H
where
H = {(A_{ p }, A_{ n }) ∈ Pω_{ L }L(A_{ p }) + G(A_{ p }) <ω_{ L }L(A_{ n }) + G(A_{ n })}
= {(A_{ p }, A_{ n }) ∈ Pω_{ L }L(A_{ p }) – L(A_{ n })) <G(A_{ n }) – G(A_{ p })}.
P = {(A_{ p }, A_{ n }) A_{ p } and A_{ n } are from the same pair}, since alignments of different querytemplate pair are not comparable. The classification result is showed in Fig.7, ω_{ L } = 0.0047.
After obtaining the parameter ω_{ L } and θ, our threading algorithm can be described informally as follows: given a querytemplate pair, dynamic programming algorithm is employed to calculate A_{ L } . If L(A_{ L }) <θ, then A_{ L } is considered as a good alignment and returned. Otherwise, local search algorithm is then used to find a better alignment under scoring function score(A) = ω_{ L }L(A) + G(A). The initial alignments used in this step are chosen from the dynamic programming table in the previous step.
Preliminary results on alignment generating
We test our threading method on Prosup benchmark (containing 127 querytemplate pairs). Each querytemplate pair shares low sequence identity but high structure similarity. Denote the alignment generated by our method as A_{ O }.
First, we compare TM(A_{ O }) with TM(A_{ L }) in order to evaluate the effect of the new scoring function. The result is showed in Fig.8. It suggests that on 68 out of 127 pairs the new scoring function gains a better TMscore compared with scoring function with local item only. On 12 out of 127 pairs, TMscore improvement is greater than 0.1 while no pair’s TMscore decrease greater than 0.1.
Second, we compare the alignment accuracy with other threading methods. For an alignment, its accurate accuracy is defined as the ratio of number of correct matchstate over the number of matchstate of the reference alignment; the ratio is denoted as ±4residuesaccuracy if a ±4 error allowed. Experimental results (Table 1) indicate that our method performs better than FASTA, Sequence and PSIBLAST. If only the local score item is considered, the alignment accuracy is comparable to RAPTOR. When the distant scoring item is added, the alignment accuracy improves significantly: 8% better than RAPTOR on accurate comparison and 6.4% on ±4residues comparison.
Methods
Threading Algorithm
The framework of our threading algorithm are described as follows:
Algorithm 1(Threading Algorithm)
Input: query sequence, template, θ, ω_{ L }, α, k
Output: an alignment between query and template
step 1 set score(A) = L(A), calculate the optimal alignment A_{ L } under this scoring function by dynamic programming algorithm, save the best 100 alignments from the dynamic programming table
step 2 calculate L(A_{ L }) , if L(A_{ L }) <θ, then return A_{ L }
step 3 set score(A) = ω_{ L }L(A) + G(A), for each alignment A_{ i } in the 100 candidates in step 1, run local search algorithm(Algorithm 2 described in the following subsection) with parameter α, k and initial alignment A_{ i }, it returned A_{ Oi }
step 4 return
Local Search Algorithm
In this subsection we describe the threading problem in a concise way, propose a local search algorithm based on a new neighborhood for general scoring function. Under a certain assumption, we prove its approximation guarantee for two specific scoring functions.
Problem Formulation
We first give some formal definitions.
Definition 1. Given a template T = {t_{1}, t_{2}, ⋯, t_{ m }}, t_{ i } <t_{i+1}and a sequence S = {s_{0}, s_{1}, s_{2}, ⋯, s_{ n }}, s_{ i } <s_{ i }_{+1}, a valid alignment is a nondecreasing mapping A from T to S.
Denote all valid alignments as F . Nondecreasing mapping is equivalent with traditional alignment definition with gap. For all t satisfying A(t) = s, s >s_{0}, we can define the smallest t actually matches with s while others are gap on template. In order to allow gap on the left end of the template, we add a extra amino acid s_{0} in the left end of the sequence. All t ∈ T aligned to s_{0} are gap on the left end of the template. Mapping allows gap on sequence naturally.
Now we define the neighborhood of an alignment. Denote the k neighbor of A as N(A, k), we have the following definition.
Definition 2. Suppose A′ ∈ F, then A′ ∈ N(A, k) if and only if there exists a subset U of S, satisfying U ≤ k and ∀t ∈ T A′(t) ∈ {A(t)} ∪ U.
Intuitively, a member of kneighbors of A differs with A only on at most k positions at sequences.
Claim 1. N(A, k) ⊂ N(A, k + 1).
Claim 2. N(A, n + 1) = F .
Claim 3. N(A, k) = O(m^{2}^{k}n^{k}), ∀A ∈ F .
Claim 1 and claim 2 are obvious. The proof claim 3 is put in the Appendix.
Claim 1 and claim 2 show that with the increasing of k, the number of neighbors of an alignment is growing and eventually reaches the whole space. Claim 3 estimates the size of N(A, k). It shows that for a fixed k the number of neighbors of a valid alignment is polynomial about m and n.
Definition 3. For any A ∈ F, there is a real positive number denoted as score(A) to evaluate A, the threading problem is min_{ A }_{∈}_{ F }score(A).
score(A) is the general representation of scoring function. In this study, score(A) = ω_{ L }L(A) + G(A).
Algorithm
Based on the definition of neighborhood above, we give the local search algorithm as follows:
Algorithm 2(Local Search)
Input α ≥ 0, k, initial alignment A_{0}
Output an approximate local optimal solution of the scoring function score(A)
step 1 i = 0, initialize A_{0} according to input
step 2 calculate A_{ i }_{+1} = argmin_{ A }_{∈}_{ N }_{(}_{ A }_{ i }_{,}_{ k }_{)}score(A)
step 3 if (1 + α)score(A_{ i }_{+1}) <score(A_{ i }), i = i + 1, goto step 2
step 4 output A_{ i }
When α = 0, we can obtain an accurate local optimal solution. When α = 0 and k = n + 1, we can obtain an accurate global optimal solution.
Claim 4. Suppose α >0, The time complexity of algorithm 2 is O(m^{2}^{k}n_{ k }log_{1+}_{ α }M), where
Proof. Based on the algorithm, we have
(1 + α)^{i}score(A_{ i }) <score(A_{0}),
which implies that
According to claim 3, each iteration wastes at most O(m^{2}^{k}n^{k}) time, so the claim is proved.
If a closing assumption is satisfied, we can prove two approximation guarantee results when the scoring function only consists of local item and pairwise contact item. Details are listed in the Appendix section.
Discussion
In order to employ general energy function, the key step is transforming alignment to decoy efficiently In this paper, “partial“ decoy strategy is quick enough but not accurate because only matched residues’ backbone and C_{ β } atoms are kept. Methods that effectively recover other unmatched residues and even side chain atoms according to alignments are imperative.
Though the energy function of Ab Initio can be used by threading, the two methods have fundamental difference on the divergence of search space. Actually, the search space of threading is much smaller than that of Ab Initio methods because many useful prior knowledge can greatly narrow its search space. For instance, we can restrict that a core on template either totally aligned or totally gaped. This prior has been verified and applied by many threading methods. Consequently, the search space can be reduced to O(N^{m}) where N is the number of cores and m the length of query sequence. On average, N ≤ 10, it is much smaller than 200^{m}, which is the search space of ROSETTA.
In this paper we have proposed a local search algorithm to find out the optimal solution of general scoring function. This algorithm is based on a neighborhood definition, and this neighborhood can also be used by other search strategies such as simulated annealing and genetic algorithm.
References
Loose C, Klepeis J, Floudas C: A new pairwise folding potential based on improved decoy generation and sidechain packing. Proteins: Structure, Function, and Bioinformatics 2004, 54(2):303–314.
Zhang J, Chen R, Liang J: Empirical potential function for simplified protein models: Combining contact and local sequence–structure descriptors. Proteins: Structure, Function, and Bioinformatics 2006, 63(4):949–960.
Ranjit B, Pinak C: Discriminating the native structure from decoys using scoring functions based on the residue packing in globular proteins. BMC Structural Biology 9:
Shen M, Sali A: Statistical potential for assessment and prediction of protein structures. Protein Science 2006, 15(11):2507–2524.
Simons K, Kooperberg C, Huang E, Baker D: Assembly of protein tertiary structures from fragments with similar local sequences using simulated annealing and bayesian scoring functions1. Journal of Molecular Biology 1997, 268: 209–225.
Zhou H, Zhou Y: Distancescaled, finite idealgas reference state improves structurederived potentials of mean force for structure selection and stability prediction. Protein Science 2002, 11(11):2714–2726.
Pearson W, Lipman D: Improved tools for biological sequence comparison. Proceedings of the National Academy of Sciences of the United States of America 1988, 85(8):2444.
Altschul S, Gish W, Miller W, Myers E, Lipman D: Basic local alignment search tool. Journal of molecular biology 1990, 215(3):403–410.
Altschul S, Madden T, Schaffer A, Zhang J, Zhang Z, Miller W, Lipman D: Gapped BLAST and PSIBLAST: a new generation of protein database search programs. Nucleic acids research 1997, 25(17):3389.
Durbin R: Biological sequence analysis: probabilistic models of proteins and nucleic acids. Cambridge Univ Pr 1998.
Soding J: Protein homology detection by HMM–HMM comparison. Bioinformatics 2005, 21(7):951.
Xu Y, Xu D, Uberbacher E: An Efficient Computational Method for Globally Optimal Threading1. Journal of Computational Biology 1998, 5(3):597–614.
Xu J, Li M, Kim D, Xu Y: RAPTOR: optimal protein threading by linear programming. INTERNATIONAL JOURNAL OF BIOINFORMATICS AND COMPUTATIONAL BIOLOGY 2003, 1: 95–118.
Lathrop R: The protein threading problem with sequence amino acid interaction preferences is NPcomplete. Protein Engineering Design and Selection 1994, 7(9):1059.
Xu Y, Xu D: Protein threading using PROSPECT: design and evaluation. Proteins: Structure, Function, and Bioinformatics 2000, 40(3):343–354.
Wang S, Zheng W: CLePAPS: fast pair alignment of protein structures based on conformational letters. Journal of bioinformatics and computational biology 2008, 6(2):347–366.
Eswar N, Webb B, MartiRenom M, Madhusudhan M, Eramian D, Shen M, Pieper U, Sali A: Comparative protein structure modeling using MODELLER. Curr Protoc Protein Sci 2007.
MartiRenom M, Madhusudhan M, Sali A: Alignment of protein sequences by their profiles. Protein Science 2004, 13(4):1071–1087.
Zhang Y, Skolnick J: TMalign: a protein structure alignment algorithm based on the TMscore. Nucleic acids research 2005, 33(7):2302.
Zhang Y, Skolnick J: Scoring function for automated assessment of protein structure template quality. Proteins: Structure, Function, and Bioinformatics 2004, 57(4):702–710.
Peng J, Xu J: Boosting protein threading accuracy. In Research in Computational Molecular Biology. Springer; 2009:31–45.
Domingues F, Lackner P, Andreeva A, Sippl M: Structurebased evaluation of sequence comparison and fold recognition alignment accuracy1. Journal of molecular biology 2000, 297(4):1003–1013.
Zhou H, Zhou Y: Fold recognition by combining sequence profiles derived from evolution and from depthdependent structural alignment of fragments. Proteins: Structure, Function, and Bioinformatics 2005, 58(2):321–328.
Acknowledgements
This article has been published as part of BMC Bioinformatics Volume 12 Supplement 1, 2011: Selected articles from the Ninth Asia Pacific Bioinformatics Conference (APBC 2011). The full contents of the supplement are available online at http://www.biomedcentral.com/14712105/12?issue=S1.
Author information
Authors and Affiliations
Corresponding authors
Additional information
Competing Interests
The authors declare that they have no competing interests.
Appendix
Proof of Claim 3
Proof There is cases to choose a subset U of S while U = k. Denote the neighbors of an alignment under a certain U as N_{ U }(A). So, we only need to prove N_{ U }(A) = O(m^{2}^{k}).
We can assume that all positions in U are not aligned, that is, there exists no t ∈ T such that A(t) = u_{ i }. If not, say, u_{ i } is aligned, we can extend S to and change Obviously, N_{ U }(A) ≤ N_{ U }_{′}(A).
Consider the subproblem when T_{ i } = {t_{1}, t_{2}, ⋯, t_{ i }}, U_{ j } = {u_{1}, u_{2}, ⋯, u_{ j }}, 1 ≤ i ≤ m and 1 ≤ j ≤ k. For this subproblem, we define A(i, j) = {g ∈ N_{ U }_{ j } (A)g(t_{ i }) = u_{ j }}, and B(i, j) = {A′ ∈ N_{ U }_{ j } (A)A′(t_{ i }) = A(t_{ i })}. Then N_{ U }(A) = A(m, k) + B(m, j).
Now we give out the iterative formula. Let a_{ i } = inf{jA(t_{ j }) ≥ u_{ i }}. then a_{ i } ≤ a_{ i }_{+1}. Without losing generality, in the following prove, we assume that a_{ i } ≤ a_{ i }_{+1}. Define δ(x) = 1 when x ≥ 0 and δ(x) = 0 when x < 0, we have
we employ mathematics induction to prove:
A(i, j) ≤ i^{j} if 1 ≤ i ≤ a_{1}
A(i, j) ≤ i^{i}^{+j} if a_{1} <i <α_{ i }_{+1}, 1 ≤ l <j
A(i, j) ≤ i^{2}^{j}^{–1} if i >a_{ j }
B(i, j) ≤ 1 if 1 ≤ i <a_{1}
B(i, j) ≤ i^{2}^{l}^{–1} if i = a_{ l }, 1 ≤ l ≤ j
B(i, j) ≤ i^{2}^{l} if a_{ l } <i <α_{ i }_{+i}, 1 ≤ l <j
B(i, j) ≤ i^{2j} if i >a_{ j }.
Firstly, B(1, j) = A(1, j) = 1. When 1 <i <a_{1},
When i = a_{1},
When a_{ l } <i <a_{ l }_{+1} ≤ a_{ j },
Similar deduction can be used in the case of i >a_{ j }. So the claim is proved.
Approximation Guarantee of Local Search Algorithm
In this subsection, we prove two approximation results under a certain assumption. The neighbor we used here is 1neighbor. From claim 1 we know that for kneighbor, k > 1, we can obtain a better result.
The algorithm’s approximation guarantee is closely linked to the specific form of score(A). First we only consider score(A) consists of local items: score(A) = ∑_{ t }_{∈}_{ T }m(t, A(t)). For convenience’s sake, we define the following marks.
Due to the technical reasons, we have to do a assumption. In the process of prove, we only need that local optimal solution and distant optimal solution satisfy the assumption, unfortunately, this does not always hold too.
Assumption 1. Given 2 alignments A and g, define
if A_{ i }∈ F, i = 0, 1, 2, ⋯, n, we say A and g satisfies closing assumption.
If the above assumption is satisfied, we have the following theorem.
Theorem 1. If score(A) = ∑_{ t }_{∈}_{ T } m(t, A(t)), ∀A ∈ F, A ** is the distant optimal solution, A * is the approximate local optimal solution obtained from algorithm 2 with factor α and k = 1, A * and A ** satisfies closing assumption, n is the length of given sequence, αn < 1. then
Proof Define
A * and A_{ i } differs only in T_{ i } (in this proof, we abbreviate Ti(A **) as T_{ i }), so
score(A *) – score(A_{ i }) = m(T_{ i }, A *) – m(T_{ i }, A **)
From the assumption, we know that A_{ i } ∈ F, even more, A_{ i } ∈ N_{ i }(A *) ⊂ N(A *) which means score(A *) ≤ (1 + α)score(A_{ i }). Notice that and T_{ i } ∩ T_{ j } = Ø, i = j. We have,
which implicates the conclusion.
Corollary 1. If score(A) = ∑_{ t }_{∈}_{ T }m(t, A(t)), ∀A ∈ F, A * is the accurate local optimal solution, then score(A *) = score(A **).
Proof This is the special case of theorem 1 when α = 0.
If pair contact is taken into scoring function: score(A) = ∑_{ t }_{∈}_{ T }m(t, A(t)) + ∑_{ u }_{∈}_{ T }∑_{ v }_{∈}_{ T }p(u, A(u), v, A(v)) we have following theorem.
Theorem 2. If score(A) = ∑_{ t }_{∈}_{ T }m(t, A(t)) + ∑_{ u }_{∈}_{ T }∑_{ v }_{∈}_{ T }p(u, A(u), v, A(v)), then
where
Proof. Define
then
score(A *) – score(A_{ i })
= m(T_{ i }, A *) + p(T_{ i }, A *, T_{ i }, A *) + p(T_{ i }, A *, T – T_{ i }, A *) + p(T – T_{ i }, A *, T_{ i }, A *) – m(T_{ i }, A **) – p(T_{ i }, A **, T_{ i }, A **) – p(T_{ i }, A **, T – T_{i}, A *) – p(T – T_{ i }, A *, T_{ i }, A **)
= m(T_{ i }, A *) + p(T_{ i }, A *, T_{ i }, A *) + 2p(T_{ i }, A *, T – T_{ i }, A *) – m(T_{ i }, A **) – p(T_{ i }, A **, T_{ i }, A **) – 2p(T_{ i }, A **, T – T_{ i }, A *).
score(A *) – score(A_{ i }) – α score(A_{ i })
= m(T_{ i }, A *) + p(T_{ i }, A *, T_{ i }, A *) + 2p(T_{ i }, A *, T – T_{ i }, A *) – (1 + α)[m(T_{ i }, A **) + p(T_{ i }, A **, T_{ i }, A **) + 2p(T_{ i }, A **, T – T_{ i }, A *)] – α[m(T – T_{ i }, A *) + p(T – T_{ i }, A *, T – T_{ i }, A *)] ≤ 0
Move positive items to the left side and negative items to the right side, and sum up with i = 0, 1, 2, ⋯, n, we have, the left side
the right side
By adjusting the inequality of L ≤ R, we can obtain the conclusion.
Rights and permissions
Open Access This article is published under license to BioMed Central Ltd. This is an Open Access article is distributed under the terms of the Creative Commons Attribution License ( https://creativecommons.org/licenses/by/2.0 ), which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly cited.
About this article
Cite this article
Shao, M., Wang, S., Wang, C. et al. Incorporating Ab Initio energy into threading approaches for protein structure prediction. BMC Bioinformatics 12 (Suppl 1), S54 (2011). https://doi.org/10.1186/1471210512S1S54
Published:
DOI: https://doi.org/10.1186/1471210512S1S54
Keywords
 Local Search Algorithm
 Protein Structure Prediction
 Alignment Accuracy
 Reference Alignment
 Local Item