BACKGROUND
trees have a long history as models for the evolutionary history of organisms  <cit> .
lineage sorting and reticulate evolution have long been recognized as processes that make it difficult to infer species evolution from gene trees  <cit> .
however, the extent of gene transfer between divergent species, particularly in case of microorganisms, has initiated a reassessment of the applicability of a tree-based concept for organismal evolution  <cit> .
individual genes coexisting in a present day genome can have very different evolutionary histories  <cit> .
in particular, horizontal gene transfer is recognized as an alternative to within lineage processes like duplication and de-novo evolution of genes for an organism to acquire new properties  <cit> .
here we present a software tool, which computes dekapentagonal maps to depict the phylogenetic relationships of five genomes in a visually appealing diagram as an alternative to bifurcating trees.
dekapentagonal maps allow for the recognition of a plurality or majority signal and they can serve as a visual tool to pre-screen for putative instances of horizontally transferred genes .
given five genomes we can characterize all possible phylogenetic relationships between the genomes with fifteen different unrooted tree topologies.
one way to depict all fifteen relationships is to use a generalization of barycentric coordinates, so called dekapentagonal maps .
the support value vector for a gene family contains the posterior probabilities for each of the fifteen tree topologies given the aligned sequences, or the frequencies with which the fifteen different tree topologies are recovered from bootstrapped samples generated from the aligned sequences.
the dekapentagonal map of five genomes depicts the support value vectors for all gene families that have a representative in each of the five genomes.
the successful construction of dekapentagonal maps critically depends on an optimal layout of the fifteen different tree topologies along the fifteen vertices of the dekapentagon.
figure  <dig> is an example of a particular layout of the tree topologies along the dekapentagon's vertices .
the points within the diagram denote actual data support for particular tree topologies, with each point representing one family of orthologous genes  <cit> .
the individual regions within the map demark areas of support for individual topologies.
the region in the center of dekapentagonal map represents an area of no support for any particular topology.
the resulting display facilitates recognition of frequently supported tree topologies  and their shared features  grouping with rhodobacter capsulatus ).
the placement of a support value vector to the inside of the dekapentagon depends on how the fifteen topologies are laid out along the vertices.
a gene family that has equal support for only two of the tree topologies will map to the periphery, if these two topologies occupy neighboring vertices, but it will map into the center, if the two topologies occupy opposing vertices.
we define as optimal a layout of tree topologies along the vertices, if it minimizes the distance of the support value vectors from the periphery.
this way an analysis of genomes related only through strict vertical inheritance will result in a cluster of points neighboring a single vertex; the horizontal transfer of several genes will result in points close to other not necessarily neighboring vertices , and tree topologies between which the data frequently cannot decide will be neighboring each other.
computing the optimal layout of the tree topologies along the vertices of the dekapentagon presents a difficult optimization problem given the large number of possible layouts: !/ <dig> = 14!/2≈4* <dig> .
this setting seems ideally suited for optimization based on genetic algorithms  <cit> .
at the core of the software tool presented here is the design and implementation of a hybrid genetic algorithm which computes optimal tree topology layouts along the dekapentagon vertices using demes in order to avoid premature convergence and which employs a local search strategy to complement the global search behavior of the crossover and mutation operators.
implementation
design overview
pentaplot is written as a program, which is comprised of multiple processing steps implemented both in perl and c++.
the processing steps are hidden from the user by means of a master perl script that ties all the processing steps together.
in normal usage the user prepares a probability matrix , which provides information about the support of particular tree topologies by the families of orthologous genes.
this matrix is processed by the program into the visual dekapentagonal map as shown in figure  <dig>  the individual processing steps are as follows:
• compute tree topology layout from probability matrix.
• map the polar coordinates for orthologous gene family into a cartesian coordinates.
• summarize the number of genes, which fall into the individual zones that support particular tree topologies.
• construct the dekapentagonal map.
the generated dekapentagonal map is available as an image, which either can be viewed in an interactive previewer or saved in the post-script and pdf formats.
the implementation heavily relies on wall's genetic algorithm c++ component library  <cit>  and tex  <cit> .
pentaplot also provides access to a number of tuning parameters for the construction of the maps, which are accessible via command line arguments:
• iterations : optimizing tree topology layouts with a genetic algorithm is a stochastic approach, therefore, in order to obtain some confidence in the computed solutions the solutions should be recomputed a number of times.
this parameter controls how often the computation is to be repeated.
• populations : a fundamental concept in genetic algorithms is the notion of a population.
here we apply a genetic algorithm that utilizes multiple populations at the same time in order to prevent premature convergence.
this parameter specifies how many populations the algorithm should use.
• population sizes : population sizes are critical in genetic algorithms.
if the population size is too small there will not be enough genetic diversity in the population to effectively explore the search space.
if the population size is too large then a large amount of computation time might be wasted.
this parameter controls the sizes of the populations.
• maximum number of generations : the genetic algorithm as implemented in pentaplot has an automatic stopping criteria built in based on 99% convergence within  <dig> generations, that is, if the performance of the best layout of the current generation t and the performance of the best layout of the generation t- <dig> are within 1% from each other then the genetic algorithm terminates.
however, in particularly difficult optimization landscapes this convergence might never occur and the genetic algorithm might run forever .
to avoid this situation the maximum generation parameter allows the user to limit the number of generations the genetic algorithm is allowed to compute.
data preparation: the probability matrix
the first step in the phylogenetic analysis of genomes is the detection of sets of orthologous genes from the genomes making up the set of five genomes under consideration, i.e., genes that share common ancestry and are related through speciation and not gene duplication events.
we use reciprocal top scoring hits as a criterion to select orthologous genes, i.e., each of the genes picks the other members of the quintet as the top scoring hit in a blast search  <cit> .
while this selection scheme aims at detecting orthologous genes, the resulting sets can only be considerate to be putatively orthologous.
while this selection scheme aims at detecting orthologous genes, the resulting sets only can be considered to be putatively orthologous.
these gene sets include horizontally transferred genes , especially those instances, where the transferred gene replaced its ortholog, synologs that were brought into a single genome through lineage fusion  <cit>  and duplicated genes where one or the other paralog was lost in each the analyzed genomes  <cit> .
when we refer to sets of orthologous genes in the rest of the manuscript we mean that those orthologs are putative.
once these putatively orthologous genes are detected, they are aligned and all possible unrooted tree topologies are evaluated  and either their posterior probabilities or bootstrap support values are calculated .
therefore, each family of putatively orthologous genes is associated with a 15-dimensional support value vector.
this construction results in probability matrices where each row represents a family of orthologous genes and each column represents a particular unrooted tree topology.
a value in a matrix represents the probability of support for a particular tree topology by a particular gene family.
it is important to note that all the probabilities in one record have to sum up to one.
any other method that calculates support value vectors can be used to produce valid probability matrices.
please note that the construction of the probability matrix is a preprocessing step and is not included in the pentaplot program.
mapping of probabilities into barycentric coordinate systems
barycentric coordinate systems  are most easily explained using triangles instead of generalized polygons.
a simple probability matrix is shown in table  <dig>
with the tree topologies at the vertices of a triangle we can interpret the probabilities as weights at each corner of the triangle with the restriction that p <dig> + p <dig> + p <dig> =  <dig>  we can then visualize this as shown in figure  <dig>  it is interesting to note that, given the particular assignment of the tree topologies to the vertices, the point p in the area of the triangle is completely defined by the support at each vertex, that is, the point p represents the center of gravity of this construction.
we can now interpret the point p as a visual characterization of the support for each of the tree topologies by the set of orthologous genes in the example dataset above.
if our dataset had more than one record  we would see multiple points in the triangle, one for each set of orthologous genes.
figure  <dig> shows a visualization of a dataset with numerous orthologous genes and their support of three different tree topologies involving four genomes a, b, c, and d, respectively.
the areas at the vertices demark the regions of support for the individual tree topologies.
we can generalize this to the case of the dekapentagon as shown in figure  <dig>  similarly to the case of the triangle in figure  <dig>  we only show the construction of the center of gravity of a single set of orthologous genes.
again, the weights at the vertices represent the support of a particular tree topology by the set of orthologous genes.
the points mij denote the centers of gravity due to the weights indicated by the subscripts.
when we include all the weights in this construction we will obtain a unique m that represents the center of gravity of all the weights for a particular arrangement of the weights along the vertices of the dekapentagon.
similar to the previous case we can interpret the center of gravity as a visual representation of the support for the tree topologies by this set of orthologous genes.
should there be multiple sets of orthologous genes in the dataset we will obtain multiple centers of gravity, one for each set of orthologous genes.
computing the center of gravity in a dekapentagon
computing the center of gravity in a triangle is straightforward; however, the same computation in a dekapentagon deserves some remarks.
to construct the center of gravity we place the dekapentagon into a cartesian coordinate system with its origin coinciding with the center of the dekapentagon.
then the cartesian coordinates  of a vertex i can be computed with the equations:
where r is the distance from origin to the vertex , and  <dig> ≤ i ≤  <dig>  for each pair of vertices i and j the coordinates  of the center of gravity mij are calculated according to the law of the lever:
where pi and pj represent the support  at the vertices i and j, respectively.
the process is repeated for all pairs of vertices, and then iteratively for all "intermediate" centers of gravities until only one pair of coordinates remains, which represents the center of gravity of the dekapentagon using all the "weights".
the resulting coordinates of the dekapentagon's center of gravity do not depend on the order in which the masses are combined but they do depend on the particular arrangement of the support p along the vertices, i.e.
on the way the  <dig> different tree topologies are assigned to the vertices.
for example, one could envision a family of orthologous genes that supports only two of the fifteen possible tree topologies.
if these two topologies were assigned to two opposing vertices, the support value vector would map to the center of the dekapentagonal map, indicating no particular support for any tree topology, whereas if the two topologies are assigned to neighboring vertices, the support value vector will map onto the periphery between these two vertices, revealing support for these two topologies over the other  <dig> alternatives.
therefore, it is crucial to compute a layout that moves the centers of gravity as close to the periphery as possible.
as mentioned above, in our case we not only compute a single center of gravity or barycentric point, but instead, given a data set with n orthologous genes we will compute n different barycentric points, one for each record in the data set.
the layout algorithm
there are about 4* <dig> possible arrangements of topologies on a dekapentagon's vertices.
an arrangement is considered optimal when the topologies are arranged at the polygon vertices in a way that maximizes the sum of the distances of all barycentric points from the center of the polygon.
there are too many arrangements of topologies around the dekapentagon to search for the optimal arrangement exhaustively.
therefore, we used a heuristic search based on genetic algorithms  <cit> .
in the genetic algorithm setup, each generation consists of a population of arrangements where each individual in a population encodes a particular mapping of the possible tree topologies identified by numerical identifiers  to vertices of the dekapentagon.
the fittest individuals in a population maximize the sum of all distances of the barycentric points from the center of the polygon.
as is typical in evolutionary computation, the genetic algorithm applies mutation and crossover operations to each successive generation of arrangements until an optimal solution is obtained  <cit> .
genetic algorithms today provide many different implementation strategies beyond the basic bit string genetic algorithm first developed by holland  <cit> .
we chose an array-based, hybrid genetic algorithm that uses demes to avoid premature convergence  <cit> .
genetic algorithms are good at finding approximate solutions in large search spaces but they are notoriously inefficient when it comes to fine tuning these solutions.
by equipping a genetic algorithm with a local search strategy we avoid these problems.
this is referred to as hybrid genetic algorithms  <cit>  .
our hybrid genetic algorithm is summarized by the following pseudo code:
function evolve
create initial population
do
// perform crossover and mutation
population : = compute-new-population
best : = fittest-individual
optimized : = local-optimization
// if optimized is fitter than best replace best
// with optimized in the population
if  > fitness )
replace
until
return fittest-individual
this algorithm is replicated over the demes giving rise to our hybrid deme genetic algorithm.
it is noteworthy that we deviate from the standard notion of hybrid genetic algorithm slightly by only applying the local optimization function to the fittest individual of the population at each generation in each deme due to the computational cost of our local optimization: given the tree topology layout of the fittest individual, our local optimization strategy attempts to find an even better layout by systematically swapping tree topologies in the layout.
the pseudo code of the local search heuristic follows:
function local-optimization
bestscore : = bestsource : = besttarget : = -1
for s : =  <dig> to  <dig> do
for t : = s+ <dig> to  <dig> do
swap-topologies
score : = scorearrangement
if
bestscore : = score
bestsource : = s
besttarget : = t
endif
undo-swap
endfor
endfor
swap-topologies
return layout
this procedure steps through all topologies in a layout and evaluates the score obtained by swapping each topology with all other positions.
here 'scorearrangement' is a procedure that computes the barycentric coordinates for each record in the data set and the score is derived from the sum of all the distances of the barycentric points from the center of the polygon.
most likely we can improve the computational requirements of this local search procedure by sampling possible swaps in the layouts instead of trying them all  <cit> .
another key notion beyond the local search strategy is that we have to constrain the structure of the individuals in the populations in such a way that each individual can only encode legal sequences of topologies, that is, each individual can only encode layouts of topologies around the perimeter of the polygon that do not have repetitions.
this is analogous to the term closure condition that arises in genetic programming where any term constructor combined with any other legal term constructor must give rise to a legal term  <cit> .
here we opted for an array representation where each position in the array denotes a vertex on the polygon.
the contents at each array position denote a tree topology assigned to that vertex.
each individual is initialized in such a way that the tree topologies  <dig> through  <dig> are assigned to the vertices in such a way that there are no repetitions.
in order to make this work the crossover and mutation operators have to preserve the uniqueness property of the topology layouts.
goldberg's pmx  operator  <cit>  and wall's swap mutation implemented in galib  <cit>  fulfill our uniqueness requirement and have been implemented in pentaplot.
RESULTS
we tested the design of our algorithm with four experiments of increasing difficulty  <cit> .
each experiment involved the comparison of five genomes.
we applied both posterior probability mapping and bootstrap support value mapping  <cit>  to two different genome quintets:
<dig>  an inter-domain genome quintet consisting of representatives of all three domains of life: saccharomyces cerevisiae , rhodobacter capsulatus , bacillus subtilis , archaeoglobus fulgidus , sulfolobus solfataricus .
<dig>  bacterial genomes representing the five phyla that contain organisms with chlorophyll-based photosynthesis: chlorobium tepidum , chloroflexus aurantiacus , heliobacillus mobilis , rhodobacter capsulatus , sulfolobus solfataricus .
the two datasets resulting from the first genome quintet each had  <dig> records, that is,  <dig> families of orthologous genes with one representative in each of the five genomes.
the datasets resulting from the second genome quintet each had  <dig> records.
our investigation reported in  <cit>  corroborated the layouts produced by our algorithm.
the increase in difficulty in these experiments arises from the fact that  maximum likelihood mappings tend to produce barycentric points which lay close to the circumference of the polygon making it more difficult to discern an optimal layout and  the bacterial genomes contained a large number of orthologous genes, that is, there were a large number of barycentric points that needed to be considered during optimization.
we also compared the performance of our hybrid deme genetic algorithm to other genetic algorithm implementations such as the binary string genetic algorithm, the array based genetic algorithm, and a deme based genetic algorithm in each of these four experiments.
the population size of the genetic algorithms in all the experiments for all genetic algorithms was  <dig> individuals.
in the case of the deme configurations this population was distributed over  <dig> subpopulations.
we used a convergence stopping criterion of 99% with a window of  <dig> generations.
typical runs lasted between  <dig> and  <dig> generations.
the convergence percentages were computed by averaging the number of times a genetic algorithm computed exactly the same layout over the fifty runs.
we postulate that a high degree of reproducibility indicates either a global optimal solution or a very strong local minimum, which can be considered a quasi-optimal solution.
given that the reproducible solutions found by the genetic algorithms were corroborated in bipartition analyses  <cit>  we are confident that the genetic algorithms did converge on a global optimum.
the results are summarized in table  <dig>
in the case of the binary string and array genetic algorithms it was interesting to see that we did not achieve reproducible solutions.
introducing demes into the genetic algorithms produced the most dramatic performance jump as can be seen from table  <dig>  in the case of the first experiment the performance jumped from 0% to 100% and dropped off with increasing difficulty of the experiments.
the deme genetic algorithm performed well over the range of the experiments.
however, in the fourth experiment it only converged on an optimal solution on every other run.
the fourth column shows the performance of our hybrid deme genetic algorithm.
we can see that it shares the performance characteristics of the deme genetic algorithm on the easier experiments but the performance of the hybrid deme genetic algorithm did not degenerate as fast with increasing difficulty of the experiments.
tables  <dig> and  <dig> summarize the performance of the hybrid deme genetic algorithm using parameters other than the default parameters.
in these experiments we applied our hybrid deme genetic algorithm to the maximum likelihood mapping of the bacterial genomes .
table  <dig> shows the convergence behavior of the genetic algorithm given different number of populations and different sizes of the populations.
here, convergence is defined as above.
what is most intriguing here is that bigger populations are not necessarily better.
one possible explanation for this premature convergence might be the fact that the single best individual we are selecting in the local search for improvement does not have as much an impact on the large populations as it does in smaller populations.
thus, larger populations are more prone to early stagnation in their search.
table  <dig> highlights the fact that the deme idea is indeed very important to this algorithm in order to prevent premature convergence.
as can be seen from both tables, our default values present a reasonable tradeoff between convergence behavior and computational complexity implied in larger number of populations or large populations.
CONCLUSIONS
dekapentagonal maps provide an alternative to a single evolutionary tree to visualize phylogenetic relationships between organisms.
here we presented a tool, which computes such dekapentagonal maps given an appropriate probability matrix.
the visualization critically depends on the optimal layout of unrooted tree topologies along the vertices of the dekapentagon.
given the large number of possible layouts, this represents a difficult optimization problem well suited for genetic algorithms.
at its core our tool utilizes a genetic algorithm with demes and a local search strategy.
the chosen optimality criterion moves the individual barycentric points representing orthologous genes as far to the periphery as possible.
the resulting arrangement places tree topologies between which individual data sets frequently do not decide next to each other.
the developed hybrid genetic algorithm performs satisfactorily even in those cases where the chosen genomes are so divergent that little phylogenetic information has survived in the individual gene families.
availability and requirements
• project name: pentaplot
• project home page:
• operating system: linux, kernel version  <dig> .
<dig> and above
• programming language: perl, c++, latex
• other requirements: perl  <dig>  bioperl  <dig> , latex 2e, galib  <dig> .5
• license: gnu gpl
• any restrictions to use by non-academics: contact authors
authors' contributions
lh wrote the code for the pentaplot program.
oz and jpg developed overall methodology for dekapentagonal mapping.
oz prepared probability matrices for analyzed genome quintets.
all authors contributed equally to the manuscript preparation.

 trees have a long history as models for the evolutionary history of organisms. lineage sorting and reticulate evolution have long been recognized as processes that make it difficult to infer species evolution from gene trees. however, the extent of gene transfer between divergent species, particularly in case of microorganisms, has initiated a reassessment of the applicability of a tree-based concept for organismal evolution. individual genes coexisting in a present day genome can have very different evolutionary histories. in particular, horizontal gene transfer is recognized as an alternative to within lineage processes like duplication and de-novo evolution of genes for an organism to acquire new properties. here we present a software tool, which computes dekapentagonal maps to depict the phylogenetic relationships of five genomes in a visually appealing diagram as an alternative to bifurcating trees. dekapentagonal maps allow for the recognition of a plurality or majority signal and they can serve as a visual tool to pre-screen for putative instances of horizontally transferred genes. given five genomes we can characterize all possible phylogenetic relationships between the genomes with fifteen different unrooted tree topologies. one way to depict all fifteen relationships is to use a generalization of barycentric coordinates, so called dekapentagonal maps. the support value vector for a gene family contains the posterior probabilities for each of the fifteen tree topologies given the aligned sequences, or the frequencies with which the fifteen different tree topologies are recovered from bootstrapped samples generated from the aligned sequences. the dekapentagonal map of five genomes depicts the support value vectors for all gene families that have a representative in each of the five genomes. the successful construction of dekapentagonal maps critically depends on an optimal layout of the fifteen different tree topologies along the fifteen vertices of the dekapentagon. figure is an example of a particular layout of the tree topologies along the dekapentagon's vertices. the points within the diagram denote actual data support for particular tree topologies, with each point representing one family of orthologous genes. the individual regions within the map demark areas of support for individual topologies. the region in the center of dekapentagonal map represents an area of no support for any particular topology. the resulting display facilitates recognition of frequently supported tree topologies and their shared features grouping with rhodobacter capsulatus ). the placement of a support value vector to the inside of the dekapentagon depends on how the fifteen topologies are laid out along the vertices. a gene family that has equal support for only two of the tree topologies will map to the periphery, if these two topologies occupy neighboring vertices, but it will map into the center, if the two topologies occupy opposing vertices. we define as optimal a layout of tree topologies along the vertices, if it minimizes the distance of the support value vectors from the periphery. this way an analysis of genomes related only through strict vertical inheritance will result in a cluster of points neighboring a single vertex; the horizontal transfer of several genes will result in points close to other not necessarily neighboring vertices, and tree topologies between which the data frequently cannot decide will be neighboring each other. computing the optimal layout of the tree topologies along the vertices of the dekapentagon presents a difficult optimization problem given the large number of possible layouts:!/ = 14!/2≈4*. this setting seems ideally suited for optimization based on genetic algorithms. at the core of the software tool presented here is the design and implementation of a hybrid genetic algorithm which computes optimal tree topology layouts along the dekapentagon vertices using demes in order to avoid premature convergence and which employs a local search strategy to complement the global search behavior of the crossover and mutation operators. implementation design overview pentaplot is written as a program, which is comprised of multiple processing steps implemented both in perl and c++. the processing steps are hidden from the user by means of a master perl script that ties all the processing steps together. in normal usage the user prepares a probability matrix, which provides information about the support of particular tree topologies by the families of orthologous genes. this matrix is processed by the program into the visual dekapentagonal map as shown in figure the individual processing steps are as follows: • compute tree topology layout from probability matrix. • map the polar coordinates for orthologous gene family into a cartesian coordinates. • summarize the number of genes, which fall into the individual zones that support particular tree topologies. • construct the dekapentagonal map. the generated dekapentagonal map is available as an image, which either can be viewed in an interactive previewer or saved in the post-script and pdf formats. the implementation heavily relies on wall's genetic algorithm c++ component library and tex. pentaplot also provides access to a number of tuning parameters for the construction of the maps, which are accessible via command line arguments: • iterations: optimizing tree topology layouts with a genetic algorithm is a stochastic approach, therefore, in order to obtain some confidence in the computed solutions the solutions should be recomputed a number of times. this parameter controls how often the computation is to be repeated. • populations: a fundamental concept in genetic algorithms is the notion of a population. here we apply a genetic algorithm that utilizes multiple populations at the same time in order to prevent premature convergence. this parameter specifies how many populations the algorithm should use. • population sizes: population sizes are critical in genetic algorithms. if the population size is too small there will not be enough genetic diversity in the population to effectively explore the search space. if the population size is too large then a large amount of computation time might be wasted. this parameter controls the sizes of the populations. • maximum number of generations: the genetic algorithm as implemented in pentaplot has an automatic stopping criteria built in based on 99% convergence within generations, that is, if the performance of the best layout of the current generation t and the performance of the best layout of the generation t- are within 1% from each other then the genetic algorithm terminates. however, in particularly difficult optimization landscapes this convergence might never occur and the genetic algorithm might run forever. to avoid this situation the maximum generation parameter allows the user to limit the number of generations the genetic algorithm is allowed to compute. data preparation: the probability matrix the first step in the phylogenetic analysis of genomes is the detection of sets of orthologous genes from the genomes making up the set of five genomes under consideration, i.e., genes that share common ancestry and are related through speciation and not gene duplication events. we use reciprocal top scoring hits as a criterion to select orthologous genes, i.e., each of the genes picks the other members of the quintet as the top scoring hit in a blast search. while this selection scheme aims at detecting orthologous genes, the resulting sets can only be considerate to be putatively orthologous. while this selection scheme aims at detecting orthologous genes, the resulting sets only can be considered to be putatively orthologous. these gene sets include horizontally transferred genes, especially those instances, where the transferred gene replaced its ortholog, synologs that were brought into a single genome through lineage fusion and duplicated genes where one or the other paralog was lost in each the analyzed genomes. when we refer to sets of orthologous genes in the rest of the manuscript we mean that those orthologs are putative. once these putatively orthologous genes are detected, they are aligned and all possible unrooted tree topologies are evaluated and either their posterior probabilities or bootstrap support values are calculated. therefore, each family of putatively orthologous genes is associated with a 15-dimensional support value vector. this construction results in probability matrices where each row represents a family of orthologous genes and each column represents a particular unrooted tree topology. a value in a matrix represents the probability of support for a particular tree topology by a particular gene family. it is important to note that all the probabilities in one record have to sum up to one. any other method that calculates support value vectors can be used to produce valid probability matrices. please note that the construction of the probability matrix is a preprocessing step and is not included in the pentaplot program. mapping of probabilities into barycentric coordinate systems barycentric coordinate systems are most easily explained using triangles instead of generalized polygons. a simple probability matrix is shown in table with the tree topologies at the vertices of a triangle we can interpret the probabilities as weights at each corner of the triangle with the restriction that p + p + p = we can then visualize this as shown in figure it is interesting to note that, given the particular assignment of the tree topologies to the vertices, the point p in the area of the triangle is completely defined by the support at each vertex, that is, the point p represents the center of gravity of this construction. we can now interpret the point p as a visual characterization of the support for each of the tree topologies by the set of orthologous genes in the example dataset above. if our dataset had more than one record we would see multiple points in the triangle, one for each set of orthologous genes. figure shows a visualization of a dataset with numerous orthologous genes and their support of three different tree topologies involving four genomes a, b, c, and d, respectively. the areas at the vertices demark the regions of support for the individual tree topologies. we can generalize this to the case of the dekapentagon as shown in figure similarly to the case of the triangle in figure we only show the construction of the center of gravity of a single set of orthologous genes. again, the weights at the vertices represent the support of a particular tree topology by the set of orthologous genes. the points mij denote the centers of gravity due to the weights indicated by the subscripts. when we include all the weights in this construction we will obtain a unique m that represents the center of gravity of all the weights for a particular arrangement of the weights along the vertices of the dekapentagon. similar to the previous case we can interpret the center of gravity as a visual representation of the support for the tree topologies by this set of orthologous genes. should there be multiple sets of orthologous genes in the dataset we will obtain multiple centers of gravity, one for each set of orthologous genes. computing the center of gravity in a dekapentagon computing the center of gravity in a triangle is straightforward; however, the same computation in a dekapentagon deserves some remarks. to construct the center of gravity we place the dekapentagon into a cartesian coordinate system with its origin coinciding with the center of the dekapentagon. then the cartesian coordinates of a vertex i can be computed with the equations: where r is the distance from origin to the vertex, and ≤ i ≤ for each pair of vertices i and j the coordinates of the center of gravity mij are calculated according to the law of the lever: where pi and pj represent the support at the vertices i and j, respectively. the process is repeated for all pairs of vertices, and then iteratively for all "intermediate" centers of gravities until only one pair of coordinates remains, which represents the center of gravity of the dekapentagon using all the "weights". the resulting coordinates of the dekapentagon's center of gravity do not depend on the order in which the masses are combined but they do depend on the particular arrangement of the support p along the vertices, i.e. on the way the different tree topologies are assigned to the vertices. for example, one could envision a family of orthologous genes that supports only two of the fifteen possible tree topologies. if these two topologies were assigned to two opposing vertices, the support value vector would map to the center of the dekapentagonal map, indicating no particular support for any tree topology, whereas if the two topologies are assigned to neighboring vertices, the support value vector will map onto the periphery between these two vertices, revealing support for these two topologies over the other alternatives. therefore, it is crucial to compute a layout that moves the centers of gravity as close to the periphery as possible. as mentioned above, in our case we not only compute a single center of gravity or barycentric point, but instead, given a data set with n orthologous genes we will compute n different barycentric points, one for each record in the data set. the layout algorithm there are about 4* possible arrangements of topologies on a dekapentagon's vertices. an arrangement is considered optimal when the topologies are arranged at the polygon vertices in a way that maximizes the sum of the distances of all barycentric points from the center of the polygon. there are too many arrangements of topologies around the dekapentagon to search for the optimal arrangement exhaustively. therefore, we used a heuristic search based on genetic algorithms. in the genetic algorithm setup, each generation consists of a population of arrangements where each individual in a population encodes a particular mapping of the possible tree topologies identified by numerical identifiers to vertices of the dekapentagon. the fittest individuals in a population maximize the sum of all distances of the barycentric points from the center of the polygon. as is typical in evolutionary computation, the genetic algorithm applies mutation and crossover operations to each successive generation of arrangements until an optimal solution is obtained. genetic algorithms today provide many different implementation strategies beyond the basic bit string genetic algorithm first developed by holland. we chose an array-based, hybrid genetic algorithm that uses demes to avoid premature convergence. genetic algorithms are good at finding approximate solutions in large search spaces but they are notoriously inefficient when it comes to fine tuning these solutions. by equipping a genetic algorithm with a local search strategy we avoid these problems. this is referred to as hybrid genetic algorithms. our hybrid genetic algorithm is summarized by the following pseudo code: function evolve create initial population do     // perform crossover and mutation     population: = compute-new-population     best: = fittest-individual     optimized: = local-optimization     // if optimized is fitter than best replace best     // with optimized in the population     if > fitness )         replace until return fittest-individual this algorithm is replicated over the demes giving rise to our hybrid deme genetic algorithm. it is noteworthy that we deviate from the standard notion of hybrid genetic algorithm slightly by only applying the local optimization function to the fittest individual of the population at each generation in each deme due to the computational cost of our local optimization: given the tree topology layout of the fittest individual, our local optimization strategy attempts to find an even better layout by systematically swapping tree topologies in the layout. the pseudo code of the local search heuristic follows: function local-optimization bestscore: = bestsource: = besttarget: = -1 for s: = to do     for t: = s+ to do         swap-topologies         score: = scorearrangement         if             bestscore: = score             bestsource: = s             besttarget: = t         endif         undo-swap     endfor endfor swap-topologies return layout this procedure steps through all topologies in a layout and evaluates the score obtained by swapping each topology with all other positions. here'scorearrangement' is a procedure that computes the barycentric coordinates for each record in the data set and the score is derived from the sum of all the distances of the barycentric points from the center of the polygon. most likely we can improve the computational requirements of this local search procedure by sampling possible swaps in the layouts instead of trying them all. another key notion beyond the local search strategy is that we have to constrain the structure of the individuals in the populations in such a way that each individual can only encode legal sequences of topologies, that is, each individual can only encode layouts of topologies around the perimeter of the polygon that do not have repetitions. this is analogous to the term closure condition that arises in genetic programming where any term constructor combined with any other legal term constructor must give rise to a legal term. here we opted for an array representation where each position in the array denotes a vertex on the polygon. the contents at each array position denote a tree topology assigned to that vertex. each individual is initialized in such a way that the tree topologies through are assigned to the vertices in such a way that there are no repetitions. in order to make this work the crossover and mutation operators have to preserve the uniqueness property of the topology layouts. goldberg's pmx operator and wall's swap mutation implemented in galib fulfill our uniqueness requirement and have been implemented in pentaplot.  we tested the design of our algorithm with four experiments of increasing difficulty. each experiment involved the comparison of five genomes. we applied both posterior probability mapping and bootstrap support value mapping to two different genome quintets: an inter-domain genome quintet consisting of representatives of all three domains of life: saccharomyces cerevisiae, rhodobacter capsulatus, bacillus subtilis, archaeoglobus fulgidus, sulfolobus solfataricus. bacterial genomes representing the five phyla that contain organisms with chlorophyll-based photosynthesis: chlorobium tepidum, chloroflexus aurantiacus, heliobacillus mobilis, rhodobacter capsulatus, sulfolobus solfataricus. the two datasets resulting from the first genome quintet each had records, that is, families of orthologous genes with one representative in each of the five genomes. the datasets resulting from the second genome quintet each had records. our investigation reported in corroborated the layouts produced by our algorithm. the increase in difficulty in these experiments arises from the fact that maximum likelihood mappings tend to produce barycentric points which lay close to the circumference of the polygon making it more difficult to discern an optimal layout and the bacterial genomes contained a large number of orthologous genes, that is, there were a large number of barycentric points that needed to be considered during optimization. we also compared the performance of our hybrid deme genetic algorithm to other genetic algorithm implementations such as the binary string genetic algorithm, the array based genetic algorithm, and a deme based genetic algorithm in each of these four experiments. the population size of the genetic algorithms in all the experiments for all genetic algorithms was individuals. in the case of the deme configurations this population was distributed over subpopulations. we used a convergence stopping criterion of 99% with a window of generations. typical runs lasted between and generations. the convergence percentages were computed by averaging the number of times a genetic algorithm computed exactly the same layout over the fifty runs. we postulate that a high degree of reproducibility indicates either a global optimal solution or a very strong local minimum, which can be considered a quasi-optimal solution. given that the reproducible solutions found by the genetic algorithms were corroborated in bipartition analyses we are confident that the genetic algorithms did converge on a global optimum. the results are summarized in table in the case of the binary string and array genetic algorithms it was interesting to see that we did not achieve reproducible solutions. introducing demes into the genetic algorithms produced the most dramatic performance jump as can be seen from table in the case of the first experiment the performance jumped from 0% to 100% and dropped off with increasing difficulty of the experiments. the deme genetic algorithm performed well over the range of the experiments. however, in the fourth experiment it only converged on an optimal solution on every other run. the fourth column shows the performance of our hybrid deme genetic algorithm. we can see that it shares the performance characteristics of the deme genetic algorithm on the easier experiments but the performance of the hybrid deme genetic algorithm did not degenerate as fast with increasing difficulty of the experiments. tables and summarize the performance of the hybrid deme genetic algorithm using parameters other than the default parameters. in these experiments we applied our hybrid deme genetic algorithm to the maximum likelihood mapping of the bacterial genomes. table shows the convergence behavior of the genetic algorithm given different number of populations and different sizes of the populations. here, convergence is defined as above. what is most intriguing here is that bigger populations are not necessarily better. one possible explanation for this premature convergence might be the fact that the single best individual we are selecting in the local search for improvement does not have as much an impact on the large populations as it does in smaller populations. thus, larger populations are more prone to early stagnation in their search. table highlights the fact that the deme idea is indeed very important to this algorithm in order to prevent premature convergence. as can be seen from both tables, our default values present a reasonable tradeoff between convergence behavior and computational complexity implied in larger number of populations or large populations.  dekapentagonal maps provide an alternative to a single evolutionary tree to visualize phylogenetic relationships between organisms. here we presented a tool, which computes such dekapentagonal maps given an appropriate probability matrix. the visualization critically depends on the optimal layout of unrooted tree topologies along the vertices of the dekapentagon. given the large number of possible layouts, this represents a difficult optimization problem well suited for genetic algorithms. at its core our tool utilizes a genetic algorithm with demes and a local search strategy. the chosen optimality criterion moves the individual barycentric points representing orthologous genes as far to the periphery as possible. the resulting arrangement places tree topologies between which individual data sets frequently do not decide next to each other. the developed hybrid genetic algorithm performs satisfactorily even in those cases where the chosen genomes are so divergent that little phylogenetic information has survived in the individual gene families. availability and requirements • project name: pentaplot • project home page: • operating system: linux, kernel version. and above • programming language: perl, c++, latex • other requirements: perl bioperl, latex 2e, galib.5 • license: gnu gpl • any restrictions to use by non-academics: contact authors authors' contributions lh wrote the code for the pentaplot program. oz and jpg developed overall methodology for dekapentagonal mapping. oz prepared probability matrices for analyzed genome quintets. all authors contributed equally to the manuscript preparation. 
in particular, the generated maps focus attention on those gene families that significantly deviate from the consensus or plurality phylogeny. the hybrid genetic algorithm performs satisfactorily even in those cases where the chosen genomes are so divergent that little phylogenetic information has survived in the individual gene families. dekapentagonal maps depict the phylogenetic relationships of five genomes in a visually appealing diagram and can be viewed as an alternative to a single evolutionary consensus tree. the visualization with dekapentagonal maps critically depends on the optimal layout of unrooted tree topologies representing different evolutionary relationships among five organisms along the vertices of the dekapentagon. at its core our tool utilizes a genetic algorithm with demes and a local search strategy to search for the optimal layout. this is a difficult optimization problem given the large number of possible layouts. pentaplot is a software tool that computes such dekapentagonal maps given an appropriate probability support matrix.
 dekapentagonal maps depict the phylogenetic relationships of five genomes in a visually appealing diagram and can be viewed as an alternative to a single evolutionary consensus tree. in particular, the generated maps focus attention on those gene families that significantly deviate from the consensus or plurality phylogeny. pentaplot is a software tool that computes such dekapentagonal maps given an appropriate probability support matrix.  the visualization with dekapentagonal maps critically depends on the optimal layout of unrooted tree topologies representing different evolutionary relationships among five organisms along the vertices of the dekapentagon. this is a difficult optimization problem given the large number of possible layouts. at its core our tool utilizes a genetic algorithm with demes and a local search strategy to search for the optimal layout. the hybrid genetic algorithm performs satisfactorily even in those cases where the chosen genomes are so divergent that little phylogenetic information has survived in the individual gene families.  pentaplot is being made publicly available as an open source project at. 