Abstract
Background
Searching for structural motifs across known protein structures can be useful for identifying unrelated proteins with similar function and characterising secondary structures such as βsheets. This is infeasible using conventional sequence alignment because linear protein sequences do not contain spatial information. βresidue motifs are βsheet substructures that can be represented as graphs and queried using existing graph indexing methods, however, these approaches are designed for general graphs that do not incorporate the inherent structural constraints of βsheets and require computationallyexpensive filtering and verification procedures. 3D substructure search methods, on the other hand, allow βresidue motifs to be queried in a threedimensional context but at significant computational costs.
Findings
We developed a new method for querying βresidue motifs, called BetaSearch, which leverages the natural planar constraints of βsheets by indexing them as 2D matrices, thus avoiding much of the computational complexities involved with structural and graph querying. BetaSearch exhibits faster filtering, verification, and overall query time than existing graph indexing approaches whilst producing comparable index sizes. Compared to 3D substructure search methods, BetaSearch achieves 33 and 240 times speedups over indexbased and pairwise alignmentbased approaches, respectively. Furthermore, we have presented casestudies to demonstrate its capability of motif matching in sequentially dissimilar proteins and described a method for using BetaSearch to predict βstrand pairing.
Conclusions
We have demonstrated that BetaSearch is a fast method for querying substructure motifs. The improvements in speed over existing approaches make it useful for efficiently performing highvolume exploratory querying of possible protein substructural motifs or conformations. BetaSearch was used to identify a nearly identical βresidue motif between an entirely synthetic (Top7) and a naturallyoccurring protein (CharcotLeyden crystal protein), as well as identifying structural similarities between biotinbinding domains of avidin, streptavidin and the lipocalin gamma subunit of human C8.
Background
The βsheet is a common secondary structure element that plays important functional and structural roles in proteins, for example, the ligandbinding pockets of biotinbinding proteins and the structure of the commonlyoccurring TIMbarrel fold [1]. These processes are often mediated by interactions between adjacent pairs of residues across βstrands. These include the disulphide, ionic, and hydrogen bonds; and hydrophobic packing interactions frequently involved in maintaining the structural stability of a protein or in enzymatic active sites [1]. The influence of pairwise interactions within βsheets and their tertiary structures have been studied experimentally [2] and statistically [3,4], the results of which have been used to predict βsheet topology [57] and tertiary structure [8]. These studies have provided insights into the folding mechanisms of βsheets although it remains an open problem [4]. Examining interresidue interactions at the single pairwise level however, provides only a limited view of a larger interaction network within a βsheet. We refer to these clusters of interacting residues as βresidue motifs, which are contiguous subsets of βsheet residues connected by peptide and/or hydrogen bonds (as shown in Figure 1D). Unlike sequence motifs, βresidue motifs encode information about both the peptide and bridgepartners of each residue. For the purposes of this study, we consider βresidue motifs to be provisional, since they may also exist via a general conservation between homologs rather than as independent functional units, as is the case for motifs in the traditional sense [9].
Figure 1. An example βsheet with its corresponding βgraph, βmatrix, and βresidue motif. Here we show an example conversion of a βsheet (a) to its graph representation (or “βgraph”) (b) and the βmatrix projection (c). A βresidue motif (d) is a submatrix of its source βmatrix, or a connected subgraph of its source βgraph. The source code to perform these conversions are available for download (see Availability).
Many characteristic βresidue motifs are observed in the Protein Data Bank (PDB) [10]. For example, the βsheets in leucinerich repeat (LRR) domains contain consecutive adjacent interstrand pairs of buried leucines stericallypacked alongside their bridgepartners, contributing to structural stability [11]. Other βresidue motifs appear as a combination of inter and intrastrand residue neighbours, as is the case for the TCT motif of certain antifreeze proteins [12] and glutamic acid/lysine motifs [13]. The conserved biotinbinding site in streptavidin [PDB:1STP] contains a βresidue motif of five inwarddirecting residues of a βbarrel: S88, T90, W92, W108, and L110. Identification of these βresidue motifs can be used to search for other proteins with similar structural elements or function with low sequence identities.
Searching for structural motifs, βresidue or otherwise, in the PDB using linear approaches such as sequence alignment is a difficult, if not impossible task because interresidue interactions can occur across secondary structures that are sporadically located throughout a protein sequence. Furthermore, pairwise residue interactions are not accounted for in conventional multiplesequence alignment tools such as BLAST [14] and CLUSTALW [15], given the onedimensional nature of sequences.
The conventional approach to motif querying, involves the use of protein substructure search methods that structurally align the 3D atomic coordinates of a query with known protein structures. These methods provide a structural context to each query hit and generally produce approximate matches in the form of a ranked list of hits but may take hours to perform few queries due to their reliance on structural alignment algorithms [16].
Alternatively, protein structures can be represented as graphs and queried for motifs using graph indexing approaches [17]. Unlike 3D substructure searches, these methods perform exact matching by querying only the discrete edge, node, and label features of graphs rather than by 3D similarity between continuous coordinates. The query matching algorithms used by existing graph indexing methods are based on solutions to the subgraph isomorphism problem, described briefly as follows:
A graphG=(V,E) is defined by a set of vertices v∈Vand a set of edges e∈Ewhere each edge represents a connection between a pair of vertices . A graph is undirected if its edges are unordered pairs and directed otherwise. The degree of a node is the number of edges it has to other nodes.
If G_{1}and G_{2}are graphs defined as and , then G_{1}is a subgraph of G_{2}if . An isomorphism between G_{1}and G_{2}is a bijection f:V_{1}→V_{2}such that .
A graph G_{1}is subgraph isomorphic to G_{2}if G_{3}is a subgraph of G_{2}and there exists an isomorphism between G_{3}and G_{1}.
Graph representations of proteins [18] and βsheets [17] have been previously described in which nodes represent residues and edges represent interresidue interactions such as peptide or hydrogen bonds. For simplicity, we define a βgraph to be a graph representation of a βsheet in which each node is labelled with a residue name, solid edges represent peptide bonds, and dotted edges represent a bridgepartner relationship between adjacent interstrand residue pairs (Figure 1B). βresidue motifs are considered to be connected subgraphs of βgraphs whose nodes are labelled with amino acids.
The planarity of βgraphs allows for a compact twodimensional representation. We define a βmatrix to be a projection (or “flattening”) of a βgraph onto a 2D matrix of amino acid characters. The residues in the same βstrand are located in the same row and residues connected by bridge edges lie in the same column (Figure 1C). βresidue motifs are then considered to be submatrices of βmatrices (Figure 1D).
Algorithms for detecting subgraph isomorphisms have been described for general graphs [19,20] that run in time factorial to the number of vertices in a query [21] and cannot be solved in polynomial time, as it is proven to be NPcomplete for general graphs [22]. Naively performing a subgraph test on every graph in a database is therefore computationallyexpensive [23]. Consequently, graph indexing methods were developed to simplify this problem. A potentially large number of nonmatching graphs can be pruned from the search by using indexing techniques analogous to those in conventional search engines [24]. Graphs can be indexed by various features using disk or memorybased indices. These approaches usually consist of three stages:
1. Index construction: The features of each graph in a database are obtained, each representing a graph characteristic. A data structure, usually an inverted index, is then constructed in which each feature is associated with the set of their originating graphs.
2. Filtering: The features of the query graph are obtained. An initial set of coarsegrained candidates containing these features are retrieved from the index (or indices). It is possible these candidates do not contain any query matches.
3. Verification: Each candidate is checked for a subgraph that exactly matches the query. This is performed using a subgraph test in most methods.
Graph indexing methods are loosely classified into three categories: pathbased, subgraphbased, and treebased.
Pathbased methods (GraphGrep [25], GraphFind [26], GraphGrepSX [23], and SING [27]) index graphs using paths as features. These methods construct an inverted index I that maps each path p to a set of their originating graphs
where p is a sequence of connected vertices in a graph G
where l_{p} is the maximum path length. The filtering process returns the set of candidate graphs C containing all the paths of a query graph Q
and verification of each candidate is performed using the VF2 algorithm [20].
Enumerating all paths up to and including length l_{p}produces large feature sets and consequently, large indices. GraphFind avoids these problems by pruning redundant features using data mining techniques similar to those of gIndex [28]. GraphGrepSX exploits feature redundancy by implementing its index as a suffix tree where each string is a path sequence. The suffix tree was shown to be more spaceefficient than the hash tables used by other pathbased methods [23]. Our empirical results corroborate these findings (Table 1). SING uses a second filtering stage that prunes candidates by using path locality information. For example, a path p in a candidate must be surrounded by the same paths as in the query. This improvement in filtering comes at the cost of maintaining an auxiliary hash table of locality information.
Table 1. Indexing times and disk sizes
Subgraphbased methods (gIndex [28], FGIndex [29], and GDIndex [30]) use subgraphs as features and retain more topological information about graphs than paths due to their more complex structures. Index construction then requires time exponential to the number of nodes in each graph which also produces larger indices than those of pathbased methods. These problems can be alleviated to a degree by indexing only the most frequent subgraphs [28].
Treebased methods (TreePi [31], TreePi+δ[32], and CTree [33]) use subtrees as features and are purported to provide an ideal compromise between the small indices of pathbased methods and the specificity of subgraphbased methods. Algorithmic operations on trees are generally more asymptotically efficient than those on graphs, in particular, subtree isomorphism can be tested in polynomial time [34]. However, previous results showed that certain pathbased methods are still an order of magnitude faster in query time than existing treebased methods [27].
GCoding [35] generates numeric representations of graphs using encodings of their adjacency matrices and cannot be classified into any of the above groups. These representations allow efficient filtering without computationally expensive graph traversals or feature enumeration. A specialised subgraph isomorphism test is used for verification [35]. While these encodings provide a compact index, expensive eigenvalue calculations are required to compute them [27].
Each of these methods can be applied to a wide variety of problems because they were designed for general graphs (i.e. graphs with an unrestricted degree and/or node count) that do not make use of the inherent structural constraints of βsheets. For example, each βresidue has at most four neighbours: the preceding and following peptidebonded residues and one bridgepartner located on each of the two adjacent hydrogenbonded βstrands.
The problem of protein 3D substructure searching involves searching a database of protein structures for structures that contain substructures similar to a query structure and remains a significant problem in structure biology. These substructures may be relevant to biological processes such as binding sites, enzymatic function, or may be representative of a particular fold family [16,36]. Current methods for substructure searching are based on the comparison of threedimensional coordinates between structures and use computationally complex structural alignment algorithms. Methods such as Dali [37], DaliLite [38], and SHEBA [39] align protein structures at the residue level, that is, they find onetoone residue alignments between pairs of proteins; methods such as QPTableauSearch [40] and SATableauSearch [16] align proteins at the level of secondary structure elements (SSEs) and therefore lack residuelevel specificity but are generally faster [16]. A common drawback of these methods is that exhaustive pairwise comparisons are required between the query and the each protein structure in a database. This naive approach often leads to redundant comparisons between highly similar structures or structures with no obvious match, ultimately resulting in queries requiring hours or even days to complete [16].
Recently, LabelHash [36,41] was developed primarily for the 3D substructure matching of small motifs, commonly between 4 and 15 residues. This method is unique among structural search methods in general since it uses a precomputed index to vastly accelerate querying in a manner similar to those of graph indexing approaches. Indeed, the results in this paper show that LabelHash yields a considerable performance boost in compute time over a conventional pairwise structural alignment approach (see Results and discussion).
In this paper we describe BetaSearch, a method that allows fast querying of βresidue motifs in large datasets of protein structures. Our method leverages the natural planar constraints of βsheets by indexing them as 2D matrices, known as βmatrices. This approach avoids the geometric, topological, and computational complexities usually involved in 3D substructure or graph querying. Furthermore, by using βsheet representations independent of a 3D coordinate system, BetaSearch identifies matching βresidue motifs in structurally and sequentially dissimilar proteins.
Results and discussion
We have compared the performance of BetaSearch against stateoftheart graph indexing and 3D substructure search methods separately. The results of three case studies are also presented, which provide biologicallyrelevant contexts in which BetaSearch could be used.
Comparisons with graph indexing methods
We compared BetaSearch against SING and GraphGrepSX. SING was shown to outperform existing methods in terms of query time on standard datasets of chemical compounds, protein transcription networks, proteininteraction networks, and synthetic graphs [27].
The elapsed indexing, total query, filtering, and verification times were averaged over five repetitions. SING and GraphGrepSX were run using l_{p}=4 and l_{p}=10, where l_{p} denotes the path length. These values were chosen by the authors of each method in their own comparisons [23,27]. We were unable to use larger l_{p} values or datasets of more than 16,000 βsheets due to the memory consumption of the SING and GraphGrepSX implementations. We therefore only reported results for datasets up to and including N = 16,000. Accuracies of each method were not measured since each query matches at least one βsheet and any nonmatching βsheet is excluded at the filtering and verification stages of each method.
Indexing
The elapsed times and disk space required for index construction are shown in Table 1.
BetaSearch recorded the fastest indexing times with a 1.9 times speedup over the next fastest method (GraphGrepSX,l_{p}=4) for the N = 16,000 dataset. The size of the BetaSearch indices were similar to those of SING,l_{p}=4 since trimers have an effective path length of l_{p}=3 and both use hash tables.
The l_{p}=10 variants of SING and GraphGrepSX were slower than their l_{p}=4 variants due to the increase in the number of features generated in the former case. This observation was consistent with those of general graphs [23].
GraphGrepSX,l_{p}=4 generated the smallest indices by a considerable margin through the use of a suffix trees to store its indices. However, the results obtained in the following sections show that the reduction in index disk space came at a significant cost to the querying time.
Furthermore, the BetaSearch index is limited only by the size of the hard disk on which it is stored, whereas the implementations of SING and GraphGrepSX used in this study were memorylimited, requiring the entire index to be loaded into memory in order for queries to be performed.
Overall query times
The query time for a single query was calculated as the sum of its filtering and verification times. The time required to perform all the queries on a dataset was measured as the sum of its individual query times, shown in Table 2. These results show that BetaSearch consistently recorded the fastest querying times for all datasets by at least an order of magnitude over the next fastest method (SING,l_{p}=10) and a 109 times speedup over the baseline (GraphGrepSX,l_{p}=4) for the N = 16,000 dataset.
Table 2. Overall query times (graph indexing comparisons)
The tradeoff between the index disk size and querying times within the SING and GraphGrepSX variants can be seen in these results where the l_{p}=10 variants required four to five times as much disk space but were at least twice as fast as the l_{p}=4 variants.
The overall query time speedups for all query sizes were measured using the GraphGrepSX,l_{p}=4 as the baseline, shown in Figure 2. Only the speedups for the N = 2,000 and 16,000 datasets were shown for the purposes of brevity. The speedups of each method generally tapers down after queries of approximately six to seven edges. This is an expected observation because larger βsheet subgraph queries are more specific than smaller ones, resulting in fewer possible candidates and therefore a reduced filtering and verification load.
Figure 2. Speedups in mean verification and overall query times. The speedups in mean verification times and overall query times for the n= 2,000 and 16,000 datasets. The GraphGrepSX, l_{p}=4 times were used as baselines for each plot. Mean verification times were measured as the total verification time divided by the total number of filtered candidates for each dataset.
Filtering
The filtering time was calculated as the time required to perform filtering for all the queries of a given dataset. The precision was calculated as the total number of actual query matches divided by the total number of filtered candidates for all the queries of a given dataset. The filtering results are shown in Table 3.
Table 3. Filtering times and precisions (graph indexing comparisons)
In contrast to their indexing performances, the l_{p}=10 variants of SING and GraphGrepSX generally outperformed their l_{p} = 4 variants. A larger l_{p}value has more specificity and therefore results in fewer numbers of filtered candidates than a small l_{p} value, reducing the verification load. The BetaSearch and l_{p} = 10 precision values were consistently near 1.0 for all datasets and query sizes. The precision of the l_{p} = 4 variants were considerably lower than the l_{p} = 10 variants due to the aforementioned specificity limitations of smaller path lengths.
Verification
We measured the mean verification time as the total verification time for a dataset divided by the total number of filtered candidates for a dataset. The mean verification times were less than a second due to the relatively small query graphs involved in this study. The speedups of each method were measured using the GraphGrepSX,l_{p}=4 times as the baseline and are shown in Figure 2.
BetaSearch consistently recorded the fastest verifications across all query sizes and datasets, this is because the BetaSearch verification algorithm runs in quadratic time whereas the VF2 algorithm employed by SING and GraphGrepSX was designed for general graphs and has a potential nonpolynomial time complexity [21]. The largest speedup by BetaSearch was achieved for queries with two edges, since these queries equated to individual trimers, there was no need for candidates to be verified.
Comparisons with 3D substructure search methods
We have compared BetaSearch with LabelHash and SHEBA since they each perform residuelevel matching. SHEBA was shown to be amongst the most accurate substructure search methods in recent work [16], however, LabelHash has yet to be evaluated against other methods. LabelHash and SHEBA were run using default search parameters. Comparisons with DaliLite were unable to be performed due to the majority of our queries and βsheets not meeting the minimum number of residues required by DaliLite. DaliLite was shown to have accuracies comparable to SHEBA but with considerably longer compute times [16].
Figure 3A shows the F_{1}scores computed across all query sizes for each method. Exact matches for each method were considered to be those with p^{′}=1 for LabelHash and m=1 for SHEBA. We also computed F_{1}at p^{′}≥0.999, however, the F_{1} at m≥0.999 was identical to that of m=1 so we instead computed F_{1}at m≥0.95. BetaSearch, by virtue of inherent exact matching, produces unranked hits and consequently produces an F_{1} score of 1.0 for the entire query set.
Figure 3. Comparisons with 3D substructure search methods. (a) The F_{1}score versus query size, p^{′}and m denote the hit scores at which an exact match is considered and all hits below this threshold are excluded. BetaSearch is an exactmatching method and does not produced ranked hits, it therefore yields an F_{1}score of 1.0 for all queries. (b) The CPU time speedups of BetaSearch and LabelHash over SHEBA. Elapsed wallclock times were nearly identical to the CPU times and were therefore omitted.
LabelHash at p^{′}≥0.999 clearly outperforms SHEBA on all query sizes, however, neither method performed particularly well on queries of 10 residues or less with the worst F_{1}scores observed for queries of 4–5 residues, which have the largest number of hits amongst all query sizes (see Additional file 1: Figure S1A). Although, once the queries reach sizes of 25 residues, LabelHash maintained F_{1} scores of at least 0.9 since the number of possible hits closely approaches the number queries (see Additional file 1: Figure S1B).
Additional file 1. Supplementary materials (supplement.pdf). This PDF file contains additional information about our experiments as well as the pseudocode for each algorithm referenced in this paper.
Format: PDF Size: 260KB Download file
This file can be viewed with: Adobe Acrobat Reader
We measured the CPU times of each method and computed the speedups over SHEBA. The wallclock times were also measured but were omitted since they were analogous to the CPU times. The CPU times of each method for the ASTRAL95 query set were measured as follows:
• SHEBA – 239 h 25 m
• LabelHash – 33 h 17 m
• BetaSearch – 0 h 59 m
Figure 3B shows the speedups at each query size. BetaSearch achieved total speedups of 240 times over SHEBA and 33 times over LabelHash. The largest speedups of BetaSearch were obtained for queries of 4–15 residues, which are the sizes of commonly studied motifs [41]. The improved performance of BetaSearch and LabelHash over SHEBA can be attributed to their use of indices which removes the need to perform exhaustive pairwise comparisons for each query against the dataset. This naive approach to substructural searching can lead to query sets taking days to complete [16,40].
Case Studies
βresidue motifs can contribute both to the structural and functional features of a protein. For researchers who study protein structure, BetaSearch can be a useful tool for surveying particular βsheet configurations across known protein structures. The frequency of a particular motif may give an indication of its relative stability as a βsheet structural element. Researchers who study functional aspects of βsheets can use BetaSearch to identify similar motifs in unrelated proteins, as we demonstrate with the biotinbinding pockets of avidin and streptavidin. BetaSearch is fast with a simple, intuitive search query context that allows the researcher to efficiently make comparisons against known βsheets.
A typical BetaSearch workflow involves the researcher (i) inspecting a protein structure for a βsheet of interest, (ii) identifying a specific βresidue motif, and (iii) manually entering the amino acids in the corresponding βmatrix into BetaSearch. Alternatively, this workflow can be automated, allowing BetaSearch to be used in a data mining or knowledgediscovery capacity which potentially allows interesting relationships between specific amino acid configurations and protein structures or functions, which would not be intuitively revealed by manual trialanderror querying.
To demonstrate the capabilities and potential usecases of BetaSearch we present the results of three case studies. These were drawn from realworld examples and illustrate the role βresidue motifs play in the structure and function of proteins. We also provide the matches from comparative queries using BLAST to demonstrate the difference in matches between a conventional sequencebased homology search and BetaSearch (see Additional files 2, 3, and 4).
Additional file 2. Results from a BLAST query of Top7 chain A (1QYSABLASTresults.txt). This plain text file contains the accession numbers of the protein sequences obtained from a BLAST query of Top7 [PDB:1QYS] chain A. The query parameters are defined in this file.
Format: TXT Size: 4KB Download file
Additional file 3. Results from a BLAST query of streptavidin chain A (1STPABLASTresults.txt). This plain text file contains the accession numbers of the protein sequences obtained from a BLAST query of streptavidin [PDB:1STP] chain A. The query parameters are defined in this file.
Format: TXT Size: 19KB Download file
Additional file 4. Matchingβsheets from Case Study 2 (casestudy2matches.txt). This plain text file contains all the matching βsheets in our dataset from the biotinbinding βresidue motif query defined in Figure 5C.
Format: TXT Size: 89KB Download file
Case Study 1  Synthetic motifs in the Top7 protein
Top7 [PDB:1QYS] is the only engineered protein (nonhypothetical) not to be derived from the sequence or structure of any other protein [42,43]. Most notably, it adopts a unique fold that has yet to be observed in nature. Its structure consists of an amphipathic βsheet and two αhelices. Inspection of the βsheet revealed a repeating βresidue motif (Figure 4A). Using this as a query, we wanted to discover known protein structures that possessed this putative synthetic motif. BetaSearch was used to query the PDB2011 dataset, which revealed matches only in structures of the CharcotLeyden crystal (CLC) protein [PDB:1G86,1HDK,1LCL,1QKQ].
Figure 4. Matching the Top7 and CLC βsheets (Case Study 1). The amphipathic query (a) is a characterisation of the repeating amphipathic region in the Top7 protein (bold). This query was matched only in the CLC protein [PDB: 1LCL]. A structural alignment (b) around the querymatching regions of both proteins where the strand and sidechain directions are conserved. The structural alignment was generated using the PyMOL “align” command: “fetch 1QYS; fetch 1LCL; align 1QYS & (resi 8+19+50+81+90), 1LCL & (resi 20+93+102+110)”.
A structural alignment of Top7 and CLC around the matching regions of the query motif (Figure 4B) shows remarkably, that the βstrand topology and sidechain directions are nearly identical. This does not suggest a homology between the two proteins because Top7 is entirely synthetic. However, our findings demonstrate that the RosettaDesign [44] approach used to engineer Top7 had inadvertently reproduced a known stable βresidue motif ab initio. The CLC protein was not found in a BLAST query of Top7 chain A (see Additional file 2).
Case Study 2  Biotinbinding domains
Streptavidin [PDB:1STP] and avidin [PDB:1VYO] are structurally and functionally similar homologous proteins that bind strongly to biotin despite having a sequence identity of less than 35%. Both proteins consist of eight antiparallel βstrands that fold into a βbarrel, inside of which forms a highly conserved biotinbinding site. The βresidue motifs that line this highly specific site are shown in Figures 5A and 5B. When the residues on the nonbinding face of the βsheet are ignored, the two motifs are differentiated by only a single residue: . The results from the corresponding BLAST query are shown in Additional file 3.
Figure 5. Querying biotinbinding βresidue motifs (Case Study 2). The (a) streptavidin and (b) avidin biotinbinding motifs are well conserved with the residues on the binding face coloured red. (c) The minimal biotinbinding βresidue motif used to query potential biotinbinding proteins. (d) The query was matched in the gamma chain of the human complement C8 protein [PDB:1IW2]. The βmatrices shown in (a), (b), and (d) have been abbreviated for clarity and are submatrices of larger βmatrices.
We have characterised these biotinbinding sites as a minimal, βresidue motif (Figure 5C). This putative motif is evolutionary conserved between the avidins and has not yet been shown to be recurrent in evolutionarily distant proteins. Using this query, BetaSearch not only identifies the structures of avidin and streptavidin, but also xenavidin—a biotinbinding protein from Xenopus tropicalis (frog). A number of seemingly unrelated proteins were also matched including uncharacterised proteins from Roseovarius nubinhibens [PDB:3BVC] and Oceanicola granulosus [PDB:2RG4]; and the human complement protein C8 gamma [PDB:1IW2]. The complete set of matching βsheets is listed in Additional file 4.
Inspection of the uncharacterised proteins reveal a similar arrangement of residues to the knownbiotin binding proteins but with less room for the ligand to bind. More tantalising is the match with the gamma subunit of human C8 which is a crucial component of the cytolytic membrane attack complex (MAC) [45]. This subunit has a characteristic lipocalin fold with a distinctive binding pocket similar to the avidins, however, the ligand target of C8 gamma remains unknown [45]. Based on the spatial similarities of this binding pocket with the biotinbinding sites of avidin, one may suggest that these proteins could have an affinity for biotin or a biotinlike compounds.
These results demonstrate that a relatively small βresidue motif query can be matched in unrelated proteins. This capability can be particularly useful in characterising proteins of unknown function by similarities in βresidue motifs to those of known function.
Case Study 3  βstrand pairing prediction
One of the unsolved problems of tertiary structure prediction is the ability to predict the pairs of βstrands which are hydrogen bonded, and therefore adjacent, in a βsheet [46]. Information about adjacent βstrands can be used to determine the overall topology of a βsheet. A number of βsheet topology prediction algorithms exist that are based on wellknown machine learning methods [4649].
We used BetaSearch to predict the βstrand pairings of the fivestranded βsheet found in chain A of csrc tyrosine kinase [PDB: 1A09]. This βsheet contains five strands, is nonbarreled, nonbifurcated, and therefore has four native strand pairings. A score for each possible strand pair was computed as a function of the number of hits, in a BetaSearch index, obtained for each interstrand 4mer query. The top four pairs ranked by pairing scores were considered as predictions. Strand pairing scores were computed for parallel and antiparallel orientations, as shown in Table 4. These results demonstrated that each of the native strand pairs were correctly predicted. The procedures used to perform these predictions are described in the Methods section. Our mechanisms for strand pair scoring are by no means a definitive solution to βsheet topology prediction. They can, however, be used in existing algorithms such as BetaPro [47] which require preliminary βstrand or βresidue pairing scores in order for predictions to be made. A large scale evaluation of our BetaSearchbased prediction method is the topic of future work.
Table 4. The predicted strand pairing scores for the 1A09 chain A βsheet (Case Study 3)
Conclusion
We have described a method for indexing and querying βresidue motifs, called BetaSearch, that is at least an order of magnitude faster than stateoftheart graph indexing methods. These speedups are achieved by indexing βsheets as 2D matrices of amino acids known as βmatrices. This representation leverages the inherent planar structural constraints of βsheets, thereby avoiding much of the computational complexity involved in querying and indexing 3D or graph representations of protein structures. BetaSearch is therefore able to achieve quadratictime querying. Filtering precisions were close to 1.0 for all datasets and query sizes, resulting in near minimal verification time.
When compared with existing 3D substructure search methods, BetaSearch achieves a 240 times speedup over the baseline (SHEBA) and a 33 times speedup over the next fastest method (LabelHash). The demonstrated efficiency of BetaSearch lends itself well to the rapid exploration of probable motif or βsheet conformations in a matter of minutes, rather than days or weeks with 3Dbased methods. Furthermore, the ability of BetaSearch to perform exact matching ensures that correct hits are not missed.
Our three case studies demonstrated the utility of BetaSearch in biological contexts. We discovered that the synthetic Top7 protein shares an identical βresidue motif with a known naturallyoccurring protein—the CharcotLeyden crystal. A small query derived from the biotinbinding motif of avidins easily identified unrelated biotinbinding proteins and is suggestive of biotinbinding in others including the gamma subunit of the human C8 complement protein. BetaSearch, with its ability to identify functional similarity from unrelated proteins can potentially help characterise the proteins in the PDB with unknown function. We also demonstrated how BetaSearch could be used to predict strand pairing in βsheets, which could help reduce the search space of more complex supersecondary or tertiary structure prediction tasks. Although our work has focused on substructural motifs in βsheets, our algorithm can be modified to perform querying of any substructural motif involving pairwise interactions, such as the wellcharacterised hydrogenbond pairings in helices and turns. Indeed, this is an avenue of development we are currently exploring.
It is our intention for BetaSearch to be used by protein researchers to supplement conventional sequence and structural search methods. For example, the efficiency of the BetaSearch filtering and verification algorithms introduces the possibility for their use as a rapid “firstpass” filter to improve the querying performance of other methods. Such an application would be nontrivial to develop but could potentially reduce conventional structural query times from hours to minutes.
Findings
The pseudocode for each of the algorithms described in this section is provided in the Supplementary Materials.
Trimers
A trimer is a path of three amino acids in a βmatrix configured in the shape of an ‘L’ (an Ltrimer), vertically in the same column (a Vtrimer), or horizontally in the same row (an Htrimer). Trimers are the features by which βmatrices are indexed in BetaSearch. An example of the trimer extraction process is shown in Additional file 1: Figure S2.
A trimer t has a number of attributes that encode its configuration and location within a βmatrix:
• t.SEQ: a three letter string of residues spanned by the trimer where
• t.CLASS: an integer representing the class of the trimer, defined as
• t.ID: a (t.CLASS,t.SEQ) tuple.
• t.ORIENT: an integer value such that t.ORIENT. These values describe the possible orientations of a trimer and were chosen to allow the calculation of x and yaxis trimer reflections using the bitwiseXOR (‘⊕’) operator. Orientation reflections are calculated as
where t’ is the reflection of t. Additional file 1: Figure S2 shows how trimer orientations are determined for each trimer class.
t.EQORIENTS: an integer that encodes the equivalent orientations of t.ORIENT, defined as
such that
where ‘<’ and ‘>’ are the lexicographic lessthan and greaterthan operators; and ‘&’ is the bitwiseAND operator. The equivalent orientations of a trimer are encoded using bitmasks such that orientation i is equivalent to t.ORIENT if the i^{th}bit of t.CLASS is set to 1. The t.CLASS value for each type of trimer is an encoding of the minimum t.CLASS value for the class.
• t.ROW: the row coordinate of t.SEQ[1] within its βmatrix.
• t.COL: the column coordinate of t.SEQ[1] within its βmatrix.
•t.COORD: a (t.ROW,t.COL) tuple.
•t.SPAN1, t.SPAN2: the row (t.ROWSPAN) or column spans (t.COLSPAN) of a trimer, depending on the trimer class. Each span is an ordered tuple (i,j) where i is the coordinate of t.SEQ[1] and j is the coordinate of either t.SEQ[0] or t.seq[2], depending on the trimer type. Ltrimers have one row span and one column span, Vtrimers have two row spans, and Htrimers have two column spans. Examples of the spans for each trimer are shown in Additional file 1: Figure S3.
Index construction
BetaSearch uses three indices: , , and .
• is an inverted index that maps each trimer id to the set of βmatrices in which they are contained, defined as
where B is the set of βmatrices in the dataset.
• maps a compound key to a trimer t, defined by
such that class∉{3,15}.
• maps a compound key to a trimer t, defined by
such that t.CLASS∉{5,31}.
Ltrimers are indexed in and ; whereas Htrimers are indexed only in because they do not contain any row spans, conversely, Vtrimers are indexed only in because they do not contain any column spans. The BUILDINDICES procedure in Additional file 1: Algorithm S1 describes the index construction algorithm.
Time complexity
Each entry in a βmatrix is the intersection of at most six trimers: four Ltrimers (one in each of the four orientations), one Vtrimer, and one Htrimer. BUILDINDICES runs in O(6mn) time where m is the maximum number of residues in a βmatrix and n is the number of βmatrices.
Filtering
A query is a wellformed βmatrix Q. Preprocessing Q requires the following steps:
1. Enumerate the query trimers and storing them in Q.TRIMERS.
2. Store the corresponding trimer IDs in Q.TRIMERIDS.
Partially matching candidates are obtained by pruning the βmatrices in using two filters. The FIRSTFILTER procedure, described in Additional file 1: Algorithm S2, prunes the βmatrices in that do not contain the entire set of trimer IDs in Q.TRIMERIDS.
βmatrices are indexed in a single arbitrary orientation, therefore a procedure for comparing a query against all orientations of a candidate is required. The naive approach enumerates and stores the x and yaxes reflections of each βmatrix, effectively tripling the index size. Alternatively, the x and yaxes reflections of the query are enumerated and compared with a candidate, effectively tripling the filtering time.
We have developed an algorithm that prunes invalid candidates without enumerating reflections of the candidate or the query. The algorithm is implemented as the SECONDFILTER procedure described in Additional file 1: Algorithm S3, where only the candidates congruent to Q are retained from C_{1}. A query Q is congruent to a candidate c if
The CONGRUENT procedure defined in Additional file 1: Algorithm S3 implements Equation 5 using bitwise operations that enable constanttime set unions and intersections.
Time complexity
The FIRSTFILTER algorithm runs in Q.trimerids) time where is the cardinality of the smallest postings set and Q.trimerids is the number of unique trimer ids in the query. A postings set is a set in the index of βmatrices containing a particular query trimer. The SECONDFILTER algorithm runs in time where C_{1} is the number of candidates returned by FIRSTFILTER.
Verification
Most graph indexing methods use the VF2 [20] or Ullmann [19] algorithms for candidate verification. Other methods use algorithms optimised for the data structures of their features and indices.
Constraining βgraphs to the simpler structures of βmatrices has enabled us to develop a quadratic time candidate verification algorithm that does not rely on subgraph isomorphism tests.
A graph G of the query is constructed, in which each vertex is a trimer q∈Q.trimers and each edge e= indicates a span overlap (i.e. t.COLSPAN or t.ROWSPAN) between adjacent query trimers q_{src} and q_{des}. The algorithm to construct a query graph is implemented in the MAKEQUERYGRAPH procedure described in Additional file 1: Algorithm S4.
The remainder of the verification algorithm attempts to find a subgraph of a candidate c that matches G by matching each pair to a pair , where a match between pairs is defined by
and a match between a query Q and a candidate c occurs if
The keys by which trimers are indexed in and contain their locations and geometric configurations within a candidate, allowing MATCHPAIRS to be tested in constanttime. MATCHPAIRS is implemented using the procedures defined in Additional file 1: Algorithm S8. The VERIFYCANDIDATE procedure in Additional file 1: Algorithm S6 describes our algorithm for verifying a single candidate.
Time complexity
The MAKEQUERYGRAPH procedure runs in time where Q.trimers is the number of trimers in the query. The VERIFYCANDIDATE procedure runs in time, which is called by the VERIFY procedure in Additional file 1: Algorithm S7 to verify each filtered candidate in C_{2}. Therefore, the overall time complexity of our candidate verification algorithm is .
βstrand pairing prediction
For Case Study 3, we constructed a BetaSearch index from the ASTRAL95 dataset, as per the 3D substructure search comparisons. The secondary structures for the βsheet were using DSSP. Each βstrand sequence was delineated as contiguous substrings of “E” secondary structure assignments. Scores for each possible βstrand pairing (i,j) were computed as follows:
1. Let be the index generated from the ASTRAL95 dataset.
2. Let S^{P}and S^{A}be the strand pairing score matrices for the parallel and antiparallel strand pairs, respectively.
3. Let M be a matrix where M_{ij}contains the number of 4mers between strands i and j. We define a 4mer as a single occurrence of twoconsecutive bridge pairings. For example, the βmatrix has the 4mers – and .
4. For each strand pair (i,j):
(a) For each alignment a of j on i:
(i) For each 4mer m of a:
(A) Let h_{P}and h_{A}be the number of hits returned from querying for the parallel and antiparallel orientations of m, respectively.Set Set Set
(b) Let be the number of residues separating strands i and j.Set Set
The total score for a strand pair was defined as
Evaluation
The graph indexing methods were evaluated according to their filtering, verification, and overall query times. The sizes of the indices generated by each method were measured using the POSIX “stat” command. The filtering precision was calculated as the total number of hits divided by the total number of filtered candidates for all queries of a given dataset size.
A “hit” for a query against a βsheet occurs when it contains (or is) an exact match of the query structure. Unlike BetaSearch, LabelHash and SHEBA perform approximate matching and return a list of hits ranked by a structural similarity score. For LabelHash, this is a statisticallydetermined pvalue where a low value indicates a close match. SHEBA ranks hits according to the mvalue which is the number of aligned residues between a query and a result, divided by the number of residues in the larger of the two structures. For simplicity, we denote the LabelHash score for a hit as p^{′}=1−p. These scores need to be thresholded in order to obtain exact matches so that all hits with scores below a given threshold are ignored and those above the threshold are assigned the same rank. Once a suitable hit score threshold is chosen, the querying accuracy of each method can be computed by counting a hit as a true positive (TP) if the query is exactly matched within a βsheet, a false positive (FP) if it is not, or a false negative (FN) if a correct βsheet hit is absent from the list of results. We can then calculate the recall, as
which denotes the proportion of exactlymatching βsheets out of all correct βsheet hits. and the precision, as
which denotes the proportion of correct βsheet hits in a list of hits. These two measures are commonly used to evaluate conventional document retrieval systems [24], as well as protein structural search methods [16]. The Fscore, defined as
is the harmonic mean of the precision and recall values. It provides a convenient way of evaluating the query precision and recall as a single value. The βparameter allows emphasis to be placed on precision or recall depending on the query performance goals. We used the F_{1} score in our 3D substructure search comparisons as a measure of query accuracy.
Datasets
For the graph indexing comparisons, the January 3, 2011 (PDB2011) snapshot of the PDB was used to generate a dataset of 209,127 βsheets. A number of PDB files were excluded due to discrepancies in their content [50]. βsheets exhibiting poor planarity, such as those with significantly pronounced twisting or curvature, were also excluded.
The DSSP [51] algorithm was used to assign secondary structures to each PDB file. Residues with a secondary structural assignment of “E” or “b” were considered to form part of a βstrand. DSSP also assigns bridge partner relationships between residues on adjacent βstrands, which were used to determine the bridge edges in βgraphs.
We used ProOrigami [52] to generate βgraphs and a topological sort was used to generate the βmatrix from the peptide and bridge edges of each βgraph.
Subsets containing 1,000; 2,000; 4,000; 8,000; and 16,000 βsheets were randomly selected from the dataset. These sizes were used in previous benchmarks [23,27]. GraphGrepSX and SING were unable to be run on datasets of 32,000 or more due to the memory consumption of their respective implementations, we therefore restricted the sizes of our datasets accordingly.
Each βgraph was preprocessed by inserting “dummy” nodes in place of a labelled edge. Each dummy node was labelled with either a “b” to denote a bridge edge or a “z” to denote a peptide edge in order to avoid conflict with the labels of residue nodes. Preprocessing was required because edgelabelled graphs were not supported by SING or GraphGrepSX.
Queries were generated in the same manner as in previous benchmarks [23]. A query was created from each βgraph by randomly selecting a root node and performing a random breadthfirst traversal until the query obtained the degrees d such that 2≤d≤10. Queries were not generated from βgraphs with insufficient edges. Each query contained a single wildcard node that matched any amino acid. To enable wildcard matching on all methods, each query was repeated by replacing the wildcard node with each of the 20 amino acids. The βmatrices for each query were generated for use by BetaSearch. The total numbers of queries generated for each query size are shown in Additional file 1: Table S1.
For the case studies, we generated the required indices from all the βmatrices in the PDB2011 dataset. Each βmatrix was assigned a sheet identifier of the format “Â¡PDB ID¿Â¡chain ID¿_SHEET_Â¡number¿”. For example, the sheet ID of the first βmatrix in chain A of ubiquitin [PDB:1UBQ] is “1UBQA_SHEET_000”.
For the 3D substructure search comparisons, the ASTRAL SCOP 1.75A 95% sequence identity nonredundant dataset [53] of protein structures (ASTRAL95) were used. βsheets were extracted and filtered as per the graph indexing datasets and a total of 29,341 βsheets were obtained. A subset of 26,669 βsheets containing between 4 and 50 residues, inclusive, were used as queries. The βmatrices corresponding to each βsheet were generated and used with BetaSearch.
Implementation
The graph indexing comparisons were performed on a 2.66 Ghz Intel Nehalem 8core processor with 48 GB of main memory running CentOS. The source code to SING and GraphGrephSX were provided by the authors of their respective publications. All methods were implemented in C++, compiled using g++ version 4.3, and depend on the Boost C++ version 1.42.0 libraries [54]. BetaSearch additionally requires Redis [55] version 2.0.4 and the official Redis C headers [56].
The indices in SING and GraphGrepSX were implemented as modified C++ STL “std::map” containers in the memory spaces of their respective processes. In contrast, BetaSearch stores its indices using Redis hash tables that are stored in (diskbased) virtual memory and operates external to BetaSearch as a concurrent process. It is therefore subject to interprocess communication overhead during filtering and indexing, which are included in our experimental timings.
The 3D substructure search comparisons were performed on the same platform with 8 GB of main memory. BetaSearch was reimplemented in Python 2.7 using the Whoosh Python Search Library [57]. LabelHash 1.0.2 [58] and SHEBA 3.1.1 [59] were downloaded and used. The LabelHash index was built from the PDB coordinates of all the ASTRAL95 βsheets, which were extracted from their original structures using ProDy [60]. The BetaSearch index was built from the βmatrix representations of each βsheet.
Structural renderings and alignments
We used PyMOL [61] to generate 3D renderings and structural alignments of proteins.
Availability and requirements
• Project name: BetaSearch
•Project homepage:http://www.csse.unimelb.edu.au/∼hohkhkh1/betasearch webcite
•Operating system(s): Ubuntu Linux 11.10+ ( http://www.ubuntu.com webcite)
•Programming language(s): Python
•Other requirements: A complete listing of Python module dependencies is provided on the project homepage.
•License: None
•Any restrictions to use by nonacademics: BetaSearch can be used freeofcharge by nonacademics, provided appropriate citation and credit is given to the authors of this publication.
Competing interests
The authors declare that they have no competing interests.
Authors’ contributions
HH, GG, and KR contributed to the design of the algorithms. HH implemented the algorithms and evaluation software, performed the experimental analyses, and prepared the manuscript and figures. MJK contributed to the evaluation of the case studies. All authors read and approved the final manuscript.
Funding
This work was supported by a Victorian Life Sciences Computation Initiative (VLSCI) [grant number VR0127] on its Peak Computing Facility at the University of Melbourne, an initiative by the Victorian Government. HH is supported by a NICTA PhD scholarship. NICTA (National ICT Australia) is funded by the Australian Government’s Department of Communications; Information Technology and the Arts; Australian Research Council through Backing Australia’s Ability; ICT Centre of Excellence programs.
Acknowledgements
We would like to thank:
The reviewers for their feedback in improving the quality of this article.
R. Di Natale, R. Giugno, V. Bonnici, and D. Shasha for their assistance and providing the GraphGrepSX and SING source code.
M. Moll for his assistance with the LabelHash software.
A. Stivala for his assistance with the ProOrigami source code.
The VLSCI systems support staff for their assistance with our HPC technical requests.
References

Kessel A, BenTal N: Introduction to proteins: structure, function, and motion. CRC Press, London; 2010.

Zaremba SM, Gregoret LM: Contextdependence of amino acid residue pairing in antiparallel βsheets.
J Mol Biol 1999, 291:463479. PubMed Abstract  Publisher Full Text

Parisien M, Major F: Ranking the factors that contribute to protein βsheet folding.
Proteins 2007, 68:824829. PubMed Abstract  Publisher Full Text

Wathen B, Jia Z: Folding by numbers: primary sequence statistics and their use in studying protein folding.
Int J Mol Sci 2009, 10:15671589. PubMed Abstract  Publisher Full Text  PubMed Central Full Text

Hubbard TJP: Use of βstrand interaction pseudopotentials in protein structure prediction and modelling.
Proceedings of the 27th Hawaii International Conference on System Sciences 1994, 336344.

Zhu H, Braun W: Sequence specificity, statistical potentials, and threedimensional structure prediction with selfcorrecting distance geometry calculations of βsheet formation in proteins.

Steward RE, Thornton JM: Prediction of strand pairing in antiparallel and parallel βSheets using information theory.
Proteins 2002, 48:178191. PubMed Abstract  Publisher Full Text

Rajgaria R, Wei Y, Floudas CA: Contact prediction for beta and alphabeta proteins using integer linear optimization and its impact on the first principles 3D structure prediction method ASTROFOLD.
Proteins 2010, 78:18251846. PubMed Abstract  Publisher Full Text  PubMed Central Full Text

Bork P, Koonin E: Protein sequence motifs.
Curr Opin Struct Biol 1996, 6:366376. PubMed Abstract  Publisher Full Text

Berman HM, Westbrook J, Fend Z, Gilliland G, Bhat TN, Weissig H, Shindyalov IN, Bourne PE: The protein data bank.
Nucleic Acids Res 2000, 28:235242. PubMed Abstract  Publisher Full Text  PubMed Central Full Text

Bella J, Hindle KL, McEwan PA, Lovell SC: The leucinerich repeat structure.
Cell Mol Life Sci 2008, 65:23072333. PubMed Abstract  Publisher Full Text

Liou YC, Tocilij A, Davies PL, Jia Z: Mimicry of ice structure by surface hydroxyls and water of a βhelix antifreeze protein.
Nature 2000, 406:322324. PubMed Abstract  Publisher Full Text

Makabe K, McElheny D, Tereshko V, Hilyard A, Gawlak G, Yan S, Koide A, Koide S: Atomic structures of peptide selfassembly mimics.
Proc Natl Acad Sci USA 2006, 103:1775317758. PubMed Abstract  Publisher Full Text  PubMed Central Full Text

Altschul SF, Madden TL, Schäffer AA, Zhang J, Zhang Z, Miller W, Lipman DJ: Gapped BLAST and PSIBLAST: a new generation of protein database search programs.
Nucleic Acids Res 1997, 25:33893402. PubMed Abstract  Publisher Full Text  PubMed Central Full Text

Larkin MA, Blackshields G, Brown NP, Chenna R, McGettigan PA, McWilliam H, Valentin F, Wallace IM, Wilm A, Lopez R, Thompson JD, Gibson TJ, Higgins DG: ClustalW and ClustalX version 2.
Bioinformatics 2007, 23:29472948. PubMed Abstract  Publisher Full Text

Stivala A, Wirth A, Stuckey PJ: Fast and accurate protein substructure searching with simulated annealing and GPUs.

Parisien M: Les feullets beta dans les protéines. Annotation, comparaison et construction. Master’s thesis. Université de Montréal; 2005.

Amitai G, Shemesh A, Sitbon E, Shklar M, Netanely D, Venger I, Pietrokovski S: Network analysis of protein structures identifies functional residues.
J Mol Biol 2004, 344:11351146. PubMed Abstract  Publisher Full Text

Ullmann JR: An algorithm for subgraph isomorphism.
J ACM 1976, 23:3142. Publisher Full Text

Cordella LP, Foggia P, Sansone C, Vento M: A (sub)graph isomorphism algorithm for matching large graphs.

Zampelli S: A constraint programming approach to subgraph isomorphism.
PhD thesis. 2008.
Université catholique de Louvain

Cook SA: The complexity of theoremproving procedures.
Proceedings of the 3rd ACM Symposium on Theory of Computing 1971, 151158.

Bonnici V, Ferro A, Giugno R, Pulvirenti A, Shasha D: Enhancing graph database indexing by suffix tree structure. In Pattern Recognition in Bioinformatics, Volume 6282 of Lecture Notes in Computer Science.. Springer; 2010:195203.

Manning CD, Raghavan P, Schütze H: Introduction to Information Retrieval. Cambridge University Press, Cambridge; 2008.

Giugno R, Shasha D: GraphGrep: a fast and universal method for querying graphs.
Proceedings of the 16th International Conference on Pattern Recognition, 2002, Volume 2 2002, 112115.

Ferro A, Giugno R, Mongiovi M, Pulvirenti A, Skripin D, Shasha D: GraphFind: enhancing graph searching by low support data mining.

Di Natale R, Ferro A, Giugno R, Mongiovi M, Pulvirenti A, Shasha D: SING: subgraph search in nonhomogeneous graphs.

Yan X, Yu PS, Han J: Graph indexing based on discrimintative frequent structure analysis.
ACM T Database Syst 2005, 30(4):960993. Publisher Full Text

Cheng J, Ke Y, Ng W, Lu A: FGIndex: towards verificationfree query processing on graph databases.
Proceedings of the 2007 ACM SIGMOD International Conference on the Management of Data 2007, 857872.

Williams DW, Huan J, Wang W: Graph database indexing using structured graph decomposition.
IEEE 23rd International Conference on Data Engineering, 2007 2007, 976985.

Zhang S, Hu M, Yang J: TreePi: a novel graph indexing method.
IEEE 23rd International Conference on Data Engineering, 2007 2007, 966975.

Zhao P, Yu JX, Yu PS: Graph indexing: tree + delta <= graph.

He H, Singh AK: Closuretree: an index structure for graph queries.
Proceedings of the 22nd International Conference on Data Engineering (ICDE’06) 2006, 3838.

Shamir R, Tsur D: Faster subtree isomorphism.
Proceedings of the 5th Israel Symposium on the Theory of Computing Systems 1997, 267280.

Zou L, Chen L, Yu JX, Lu Y: A novel spectral coding in a large graph database.
Proceedings of the 11th International Conference on Extending Database Technology (EDBT’08) 2008, 181192.

Moll M, Bryant DH, Kavraki LE: The LabelHash server and tools for substructurebased functional annotation.

Holm L, Sander C: Mapping the protein universe.
Science 1996, 273:595602. PubMed Abstract  Publisher Full Text

Holm L, Park J: DaliLite workbench for protein structure comparison.
Bioinformatics 2000, 16:566567. PubMed Abstract  Publisher Full Text

Jung J, Lee B: Protein structure alignment using environmental profiles.

Stivala A, Wirth A, Stuckey PJ: Tableaubased protein substructure search using quadratic programming.

Moll M, Bryant DH, Kavraki LE: The LabelHash algorithm for substructure matching.

Kuhlman B, Dantas G, Ireton GC, Varani G, Stoddard BL, Baker D: Design of a novel globular protein fold with atomiclevel accuracy.
Science 2003, 302:13641368. PubMed Abstract  Publisher Full Text

Havranek JJ: Specificity in computational protein design.
J Biol Chem 2010, 285:3109531099. PubMed Abstract  Publisher Full Text  PubMed Central Full Text

Liu Y, Kuhlman B: RosettaDesign server for protein design.
Nucleic Acids Res 2006, 34:W235W238. PubMed Abstract  Publisher Full Text  PubMed Central Full Text

Rosado CJ, Kondos S, Bull TE, Kuiper MJ, Law RHP, Buckle AM, Voskoboinik I, Bird PI, Trapani JA, Whisstock JC, Dunstone MA: The MACPF/CDC family of poreforming toxins.
Cell Microbiol 2008, 10:17651774. PubMed Abstract  Publisher Full Text  PubMed Central Full Text

Brown WM, Martin S, Chabarek JP, Strauss C, Faulon JL: Prediction of βstrand packing interactions using the signature product.
J Mol Model 2006, 12:355361. PubMed Abstract  Publisher Full Text

Cheng J, Baldi P: Threestage prediction of protein βsheets by neural networks, alignments and graph algorithms.
Bioinformatics 2005, 21:7584. Publisher Full Text

Jeong JK, Berman P, Przytycka TM: Bringing folding pathways into strand pairing prediction. In Lecture Notes in Computer Science, Volume 4645.. Springer; 2007:3848.

Aydin Z, Altunbasak Y, Erdogan H: Bayesian models and algorithms for protein βsheet prediction. In IEEE/ACM Transactions on Computational Biology and Bioinformatics, Volume 8.. Springer; 2011:395409.

Schierz AC, Soldatova LN, King RD: Overhauling the PDB.
Nat Biotechnol 2007, 25:437442. PubMed Abstract  Publisher Full Text

Kabsch W, Sander C: Dictionary of protein secondary structure: pattern recognition of hydrogenbonded and geometrical features.
Biopolymers 1983, 22:25772637. PubMed Abstract  Publisher Full Text

Stivala AD, Wybrow M, Wirth A, Whisstock JC, Stuckey PJ: Automatic generation of protein structure cartoons with Proorigami.
Bioinformatics 2011, 27:33153316. PubMed Abstract  Publisher Full Text

Brenner M, Koehl P, Levitt M: The ASTRAL compendium for sequence and structure analysis.
2000, 28:254256.

Boost v1.42.0 [ http://www.boost.org/users/history/version_1_42_0 webcite]

hiredis [ https://github.com/antirez/hiredis webcite]

Whoosh Python search library [ https://bitbucket.org/mchaput/whoosh/wiki/Home webcite]

LabelHash 1.0.2 [ http://labelhash.kavrakilab.org/downloads/python27/LabelHash1.0.2Linux64.tar.gz webcite]

SHEBA 3.1.1 [ https://ccrod.cancer.gov/confluence/download/attachments/63341259/sheba3.1.1.tar.gz webcite]

Bakan A, Meireles LM, Bahar I: ProDy: protein dynamics inferred from theory and experiments.
Bioinformatics 2011, 27:15751577. PubMed Abstract  Publisher Full Text  PubMed Central Full Text

Schrödinger LLC: The PyMOL Molecular Graphics System, Version 1.3r1.
2010.