the last few years have been characterized by huge technological changes in the area of parallel and distributed computing . today , powerful machines are available at low price everywhere in the world .the main visible line of such changes is the large spreading of _ clusters _ which consist in a collection of tens or hundreds of standard almost identical processors connected together by a high speed interconnection network .the next natural step is the extension to local sets of clusters or to geographically distant grids .  in the last issue of the top500 ranking ( from november 2003 ) ,52 networks of workstations ( now ) of different kinds were listed and 123 entries are clusters sold either by ibm , hp or dell .looking at previous rankings we can see that this number ( within the top500 ) approximately doubled each year .this democratization of clusters calls for new practical administration tools . even if more and more applications are running on such systems , there is no consensus towards an universal way of managing efficiently the computing resources .current available scheduling algorithms were mainly created to provide schedules with performance guaranties for the makespan criterion ( maximum execution time of the last job ) , however most of them are pseudo - polynomial , therefore the time needed to run these algorithms on real instances and the difficulty of their implementation is a drawback for a more popular use .we present in this paper a new method for scheduling the jobs submitted to a cluster inspired by several existing theoretically well - founded algorithms .this method has been assessed on simulations and it is currently tested on actual conditions of use on a large cluster composed by 104 bi - processor machines from compaq ( this cluster called icluster2 was ranked 151 in the top500 in june 2003 ) .  to achieve reasonable performance within reasonable time, we decided to build a fast algorithm which has the best features of existing ones .however , to speed up the algorithm a guaranteed performance ratio can not be achieved , thus we concentrate on the average ratio on a large set of generated test instances .these instances are representative of jobs submitted on the icluster .some scheduling algorithms have been developed for classical parallel and distributed systems of the last generations .clusters introduce new characteristics that are not really taken into account into existing scheduling modules , namely , unbalance between communications and computations communications are relatively large or on - line submissions of jobs .let us present briefly some schedulers used in actual systems : the basic idea in job schedulers is to queue jobs and to schedule them one after the other using some simple rules like fcfs ( first come first served ) with priorities .maui scheduler extends the model with additional features like fairness and backfilling .apples is an application level scheduler system for grid .it is used to schedule , for example , an application composed of a large set of independent jobs with shared data input files .it selects resources efficiently and takes into account data distribution time .it is designed for grid environment .there exist other parallel environments with a more general spectrum ( heterogeneous and versatile execution platform ) like condor or with special capabilities like processus migration , requiring system - level implementation like mosix .in these environments scheduling algorithms are online algorithms with simple rules .   as no fast and flexible scheduling systems are available today for clusters , we started two years ago to develop a new system based on a sound theoretical background and a significant practical experience of managing a big cluster ( icluster1 , a 225 pc machine arrived in 2001 in our lab ) .it is based on the model of _ parallel tasks _ which are independent jobs submitted by the users .we are interested here in optimizing simultaneously two criteria , namely the minsum ( ) which is usually targeted by the users who all want to finish their jobs as soon as possible , and the makespan ( ) which is rather a system administrator objective representing the total occupation time of the platform .there exist algorithms for each criterion separately ; we propose here a bi - criteria algorithm to optimize the and criteria simultaneously .the best existing algorithm for minimizing the makespan off - line ( all jobs are available at the beginning ) has a guaranty .we can derive easily an on - line batch version by using the general framework of leading to an approximation ratio of .for the other criterion , the best result is for the unweighted case and for the weighted case . using a nice generic framework introduced by hall et al. ,a ( ; ) approximation can be obtained at the cost of a big complexity which impedes the use of such algorithms .the paper is organized as follows : in the next section , we will introduce the definitions and models used in all the paper .the algorithm itself is described in section [ sec : algo ] , along with the lower bound which is used in the experiments .the experimental setting and the results are discussed in section [ sec : experiences ] .finally we will conclude in section [ sec : conclu ] with a discussion on on - going works .the target execution support that we consider here is a cluster composed by a collection of a medium number of smp or simple pc machines ( typically several dozens or several hundreds of nodes ) .the nodes are fully connected and homogeneous .the submissions of jobs is done by some specific nodes by the way of several priority queues as depicted in figure [ lightgrid ] .no other submission is allowed .  informally ,a parallel task ( pt ) is a _ task _ that gathers elementary operations , typically a numerical routine or a nested loop , which contains itself enough parallelism to be executed by more than one processor .we studied scheduling of one specific kind of pt , denoted as _moldable jobs _ according to the classification of feitelson et al .the number of processors to execute a moldable job is not fixed but determined before the execution , as opposed to _ rigid jobs _ where the number of processors is fixed by the user at submission time . in any case , the number of processors does not change until the completion of the job .  for historical reasons , most of submitted jobs are rigid .however , intrinsically , most parallel applications are moldable .an application developer does not know in advance the exact number of processors which will be used at run time .moreover , this number may vary with the input problem size or number of available nodes .this is also true for many numerical parallel libraries .the main exception to this rule is when a minimum number of processors is required because of time , memory or storage constraints .the main restriction in a systematic use of the moldable character is the need for a practical and reliable way to estimate ( at least roughly ) the parallel execution time as function of the number of processors .most of the time , the user has this knowledge but does not provide it to the scheduler , as it is not taken into account by rigid jobs schedulers .this is an inertia factor against the more systematic use of such models , as the users habits have to be changed .our algorithm proposes , thanks to moldability , to efficiently decrease average response time ( at the users request ) while keeping computing overhead and idle time as low as possible ( at the system administrators request ) .the main objective function used historically is the _ makespan_.this function measures the ending time of the schedule , i.e. , the latest completion time over all the tasks .however , this criterion is valid only if we consider the tasks altogether and from the viewpoint of a single user .if the tasks have been submitted by several users , other criteria can be considered .let us present briefly the two criteria :  * minimization of the _ makespan _( where the completion time is equal to ) . represents the execution time of task , function is the starting time and function is the processor number ( it can be a vector in the case of specific allocations for heterogeneous processors ) . *minimization of the average completion time ( ) and its variant weighted completion time ( ) .such a weight may allow us to distinguish some tasks from each other ( priority for the smallest ones , etc . ) .  in a production cluster context ,the jobs are submitted at any time .models were the characteristics of the tasks ( duration , release date , etc ) are only known when the task is submitted are called _ on - line _ as opposed to the _ off - line _ models were all the tasks are known and available at all times .it is possible to schedule jobs on - line with a constant competitive ratio for .the idea is to schedule jobs by batches depending on their arrival time .an arriving job is scheduled in the next starting batch .this simple rule allows constant competitive ratio in the on - line case if a single batch may be scheduled with a constant competitive ratio .roughly , the last batch starts after the last task arrival date . by definition ,all the tasks scheduled in a batch are scheduled in less than , where is the optimal off - line makespan of the complete instance .the length of the previous last batch is then lower than .moreover , the length of the last batch , plus the starting time of the previous last batch ( at which none of the tasks of the last batch were released ) is less than times the length of the optimal on - line makespan .as the on - line makespan is larger than the off - line makespan , the total schedule length is less than times the on - line optimal makespan .this is how the off - line algorithm is turned into an on - line algorithm as we said in the introduction .studying some extreme instances and their optimal schedules for the minsum criterion , gave us an insight on the shape of the schedules we had to build .for example , if all the tasks are perfectly moldable ( when the work does not depend on the number of processors ) the optimal solution is to schedule all the tasks on all processors in order of increasing area .this example shows that the minsum criterion tends to give more importance to the smaller tasks .previous algorithms presented in the literature are also designed to take into account this global structure of scheduling the smaller tasks first .shmoys et al . used a batch scheduling with batches of increasing sizes .the batch length is doubled at each step , therefore only the smaller tasks are scheduled in the first batches .existing makespan algorithms for moldable tasks are also designed with a common structure of shelves ( were all tasks start at the same time ) which is a relaxed version of batches .see for example or for schedules with 2 shelves .our algorithm was built with this structure in mind : stacking tasks in shelves of increasing sizes with the additional possibility of shuffling these shelves if necessary .however , our main motivation was to design a fast algorithm for the management of some clusters of a big regional grid in grenoble .our algorithm does not have a known performance guaranty on the worst cases , however we tested its behavior on a set of generated instances which simulate real jobs submitted on our local clusters .the principle of the algorithm is shown in figure [ fig : algo - principle ] .more formally , we detail below the algorithm starting with the input describing the instances :  * tasks available at time * the processing time of task on processors * is its weight * the number of processors  first , our algorithm calls a dual approximation makespan algorithm ( defined in ) to determine an approximation of the optimal makespan of the instance . with this value and the smallest possible duration of a task , we compute the smallest useful batch size ( such that at least one task can be done ) and the number of batches .the values are the length of our batches . for every , is twice the value of .the main loop of the algorithm corresponds to the selection of the jobs to be scheduled in the current batch .we first select the tasks which are not too long to run in the batch .if there are several tasks that can be run in less than half the batch size on one processor , we can merge some of these tasks by stacking them together . in order to have as much weight as possible ,this merge is done by decreasing weight order .the next step is to run a knapsack selection , written with integer dynamic programming .we want to maximize the sum of the weight of the selected tasks while using at most processors .the allocation of the task is , the smallest allocation that fits ( in length ) into the batch .values of are initialized to for and otherwise . for from to and for going from to , we compute : the largest is the maximum weight that can be done in the batch .the complexity of this knapsack is .the first schedule is simple : we start all the selected tasks of one batch at the same time .a straightforward improvement is to start a task at an earlier time if all the processors it uses are idle .a further improvement is to use a list algorithm with the batch ordering and a local ordering within the batches , as it allows to change the set of processors alloted to the tasks .finally , an additional optimization step is used .the batch order is shuffled several times and the best resulting compact schedule is kept .this only leads to small improvements .the overall complexity of this algorithm is .   in order to assess this algorithm with experiments , for each instancewe need to know the value of an optimal solution .but since the problem is np - hard in the strong sense , computing an optimal solution in reasonable time is impossible .we are thus looking for good lower bounds .for a good lower bound may easily be obtained by dual approximation . for the lower bound is computed by a relaxation of a linear programming formulation of the problem .this formulation is not intended to yield a feasible schedule , but rather to express constraints that are necessarily respected by every feasible schedule .for this formulation , we divided the time horizon into several intervals  ] .the lower bound might be weaker , but is much faster to compute .the experimental simulations presented here were performed with an ad - hoc program .each experience is obtained by 40 runs ; for each run tasks are generated in an off - line manner , then given as an input to the scheduling algorithm and to the linear solver which computes a lower bound for this instance .comparison between the two results yields a performance ratio , and the average ratio for the whole set of runs is the result of the experiments .the runs were made assuming a cluster of 200 processors , and a number of tasks varying from 25 to 400 . in order to describe a mono - processor task , only its computing time is needed .a moldable task is described by a vector of processing times ( one per number of processor alloted to the task ) .we used two different models to generate the tasks .the first one generates the sequential processing times of the tasks , and the second one uses a parallelism model to derive all the other values .  two different sequential workload type were used : uniform and mixed cases .for all uniform cases , sequential times were generated according to an uniform distribution , varying from to .for mixed cases , we introduce two classes : small and large tasks .the random values are taken with gaussian distributions centered respectively on 1 and 10 , with respective standard deviations of 0.5 and 5 , the ratio of small tasks being 70% .  modeling the parallelism of the jobs was done in two different ways . in the first , successive processing times were computed with the formula , where is a random variable between and .depending on the distribution of , tasks generated are highly parallel ( with a quasi - linear speedup ) or weakly parallel ( with a speedup close to ) . respectivelyhighly and weakly parallel are generated using gaussian distribution centered on 0.9 , and 0.1 , and with a standard deviation of 0.2 .any random value smaller than and larger than are ignored and recomputed . according to the usual parallel program behavior ,this method generates monotonic tasks , which have decreasing execution times and increasing work with . for the mixed cases , the small tasks are weakly parallel and the large tasks are highly parallel .the second way of modeling parallelism was done according to a model from cirne and berman  , which relies on a survey about the behavior of the users in a computing center .only the sequential time model is used for theses tasks .  to evaluate our algorithm, we use the lower bound ( cf section [ sec : lowerbound ] ) as reference . some simple `` standard '' algorithmsare used to compare the behavior and efficiency of our approach .gang : : :  each task is scheduled on all processors .the tasks are sorted using  the ratio of the weight over the execution time .this algorithm is  optimal for instances with linear speedup .sequential : : :  each tasks is scheduled on a single processor . a list algorithm is  used , scheduling large processing time first ( lptf ) .list graham : : :  all the 3 algorithms are multiprocessor list scheduling .every  tasks is alloted using the number of processor selected by .this should lead to a very good average performance ratio with respect  to the criterion .only the order of the list is  changing between the three algorithms :  +  * the first one keep the order of , listing first task of the  large shelf then the tasks of small shelf then the small tasks ,  * weighted largest processing time first ( lptf ) , a classical variant ,  with a very god behavior for criterion , but the  tasks are in fact sorted using the ratio between weighted and their  execution time .  * smallest area first ( saf ), almost the opposite of lptf , the tasks  are sorted according to their area ( number of processors   execution time ) .the goal is to improve the  average performance ratio for the   criterion .  in all experiments ,task priority is a random value taken from an uniform distribution between 1 and 10 .the results of the simulation runs are given in all the following figures , plotting the minimum , maximum and average values for and .the average of the competitive ratio is computed by dividing the sum of the execution times over the sum of the lower bounds for every point .every workload type are represented separately .the same scale is represented for identical criterion between the workload type .the tasks of figure [ fig : courbe_weak ] are weakly parallel .this is the worst case for our algorithm as it spends resources to accelerate completion of small and high priority parallel tasks .these resources are thus spend without much gain .note that gang scheduling does not appear in the presented range for , as gang always has a very big ratio in this case .  as expected , the average performance ratio for our algorithm is worse than all other algorithms except gang . nevertheless , the performance ratio for is no more than .all other algorithms have an average performance ratio around .the difference is large enough to influence also the results for the minsum criterion . from this casewe may deduce that for most cases , our algorithms will not be much worse than a performance ratio of for both criterion .figure [ fig : courbe_hight ] presents the same experiments with the highly parallel tasks . on the minsum criterion ,our algorithm is clearly the best one .gang and sequential have opposite behavior on both criteria , gang being good with a small number of tasks and sequential good for a large number of tasks only .the other algorithms are stable ( with respect to the number of tasks ) but with a larger ratio on the minsum .remark that the allotment computed for list algorithms is quite good , as performance ratio of these algorithms is always smaller than .the next experiment ( cf figure [ fig : courbe_mixed ] ) presents mixed instances with some large tasks and plenty of small tasks . inthis cases our algorithm is still quite stable with a performance ratio of around for both criterion , however saf is better than our algorithm .the ratio of the two other list algorithms greatly increase with the number of tasks , which points out that the order of tasks is very important here .finally , the last experiment use a well known workload generator which emulates real applications  . inthis more realistic setting our algorithm clearly outperforms the other ones for the minsum criterion , and is also the only one to keep a stable ratio for any number of tasks .several observations can be made from these results .first , the performance ratio for the minsum criterion is never more than , and is on average around .the performance ratio for the makespan is almost always below , and is on average .this is very good , even for each criterion separately .the second observation is that our algorithm performs better when tasks are more parallel .this can be understood if we remark that , for a weakly parallel task , there is only one or two intervals in which it can be scheduled without degrading its performance .so the scheduling algorithm is more constrained when the tasks are not parallel .the saf algorithm perform quite well on simple cases .it appears on complex cases that our approach is required to keep a good performance on the minsum criterion .thus our algorithms should be preferred in actual applications as its performance ratio for minsum is insensitive to jobs behavior and its performance ratio for the makespan is not far from alternatives .finally , figure [ fig : time ] shows that the execution time of our scheduling algorithm is low ( less than 2 seconds for the largest instances ) , as expected .in this paper we presented a new algorithm for scheduling a set of independent jobs on a cluster .the main feature is to optimize two criteria simultaneously .the experiments show that in average the performance ratio is very good , and the algorithm is fast enough for practical use .the algorithm has been assessed by comparing the minsum performance to a new lower bound based on the relaxation of an ilp , and comparing the makespan performance to the best known approximation .actual results are not available at the moment , but we are currently implementing this algorithm on a full - scale platform ( icluster2 ) .several technical problems still have to be solved for an even more efficient practical solution , namely the reservation of nodes which reduces the size of the cluster and the mix of different types of jobs ( moldable jobs , rigid jobs , and divisible load jobs ).          d. g. feitelson .scheduling parallel jobs on clusters . in r.buyya , editor , _ high performance cluster computing _ ,volume 1 , architectures and systems , pages 519533 .prentice hall ptr , upper saddle river , nj , 1999 . chap .21 .r. l. henderson .job scheduling under the portable batch system . in d.g. feitelson and l. rudolph , editors , _ job scheduling strategies for parallel processing _ , volume 949 of _ lncs _ , pages 279294 , 1995 .d. jackson , q. snell , and m. j. clement .core algorithms of the maui schedule . in d.g. feitelson and l. rudolph , editors , _ job scheduling strategies for parallel processing _ , volume 2221 of _ lncs _ , pages 87102 , 2001 .m. j. litzkow , m. livny , and m. w. mutka .condor : a hunter of idle workstations . in _8th international conference on distributed computing systems ( icdcs 88 ) _ , pages 104111 , washington , d.c ., usa , june 1988 .ieee computer society press .g. mouni , c. rapine , and d. trystram .efficient approximation algorithms for scheduling malleable tasks . in _ eleventh acm symposium on parallel algorithms and architectures ( spaa99 ) _ , pages 2332 .acm , juin 1999 .e. romagnoli , y. denneulin , and d. trystram . a synthetic workload generator for cluster computing . in _3rd international workshop on performance modeling , evaluation , and optimization of parallel and distributed systems ( pmeo - pds2004 ) in conjunction with ipdps04 _ , santa fe , new mexico , 2004 .

Abstract: we describe in this paper a new method for building an efficient algorithm for scheduling jobs in a cluster . jobs are considered as parallel tasks ( pt ) which can be scheduled on any number of processors . the main feature is to consider two criteria that are optimized together . these criteria are the _ makespan _ and the weighted minimal average completion time ( _ minsum _ ) . they are chosen for their complementarity , to be able to represent both user - oriented objectives and system administrator objectives .   we propose an algorithm based on a batch policy with increasing batch sizes , with a smart selection of jobs in each batch . this algorithm is assessed by intensive simulation results , compared to a new lower bound ( obtained by a relaxation of ilp ) of the optimal schedules for both criteria separately . it is currently implemented in an actual real - size cluster platform .   [ sequencing and scheduling ] [ scheduling , concurrency ]


several years ago , the microscopic representation approach was introduced in order to understand in a systematic manner the way in which the human concept describes a very big number of microscopic objects , in terms of a limited number of macroscopic characters defined by them . according to this approach , the microscopic picture andthe macroscopic one are considered to be two different pictures of one reality , that are complimentary to each other , as the ocean is both an aggregate of molecules and a mass of waves . in each scale should be found the macroscopic objects and the laws of their behavior , which are generated from the microscopic scale . at the same period of time a similar approach ,the universal dynamics approach was developed but from the opposite direction : from the universal to the macroscopic .it put the emphasis on the theory , therefore it is more comfortable for the presentations of the fundamentals .this approach looked for the most fundamental physical theory , under the rule that a theory is the more fundamental the less structure it assumes a priori .it starts with the basic assumption that : * the human mind thinks about relations between objects * ( this assumption is becoming more precise after introducing axiomatic characters for `` relations '' and `` objects '' ) .a collection of objects with their inter - relations is defined as `` a system '' .objects of a system can be systems themselves , i.e. with internal structure , which allows a framework for the discussion of self - organization in complex systems .the relations are directed and will therefore be called `` arrows '' , some of which are identified as fundamental in a given level of description and will be called `` links '' .arrows are composed of links and own the main importance in the description of a system .for example : in a system which is a thin brick wall - the objects are the bricks and the arrows define the relations between each brick and its six nearest neighbors , twelve next nearest neighbors etc .fig 1 describes a system which is a thin brick wall .the arrows are those who are defining the structure and turn the wall into more than a pile of bricks . in this frameworkthe dynamics of the system is described : the basic options of getting a new system from a given one are - death of an object or a link , duplication of an object or a link , merging identical objects or links , creating missing adjacent links or promoting an arrow , which can be composed of two or several links , to the status of link .the dynamical processes assembled from such elementary operations were called `` drama '' .several applications of the approach to domains outside natural sciences were developed .two examples for these applications are the works in new product development and in creative advertising ideas . in both these domainswe do not expect to find well - defined lines of thought . yet , during their study according to the universal approach it was revealed that out of the many possible routes of the dynamics , specific routes can be clearly defined and shown to be preferred - these are the `` creativity templates '' .the templates can be identified and described in an abstract and simple way so they can be easily and efficiently applied and objectively tested .an example for such a template is the development of a delivery motorbike that bakes pizza during the delivery ride according to the component connection template ( table 1 shows an example for the component connection template ) . following the simple instructions of the algorithm , leads the dynamics of the mind to the new creation .the efficiency of the templates was tested quantitatively : a group of marketing personal were trained for 4 - 5 hours in one of the templates .this group and a control group who did not receive the training were asked to generate ideas for new products in three categories .the first group used the template and the second group used conventional ideation methods ( brainstorming , questionnaires etc . ) .eight senior marketing professionals acted as judges and rated the ideas on a 1 - 7 scale according to their originality ( 1=not original at all , 7=very original ) and according to their recommendation to implement the idea ( 1=not recommended at all , 7=highly recommended ) .the judges were blind to the identity of the individuals who generated the ideas and to one another . in spite of the short length of the trainingthe advantage of the first group was salient : they received the average of 5.09 vs. 4.18 in originality and 4.40 vs. 3.36 in value .in the present paper we propose a more basic elementary building block underlying most ( may be all ) of the creative acts .we call it the `` diagonal link '' according to its structure or `` transitive template '' according to its function .the `` diagonal link '' seems to be the basic element that humans use in constructing and understanding reality in the widest sense . in orderto test this possibility we use the `` diagonal link '' as the elementary microscopic operation in the microscopic representation study of creation as described in symbolic religious stories .structurally , the `` diagonal link '' resembles a transitivity connection ( fig 2 illustrates transitivity connection ) . in the example brought in the previous sectionit can be seen clearly in fig 3 . in the same way we found that each of the creativity templates included , at least once , a diagonal link as the core of the creative process . as the basic assumption of the microscopic representation and universal dynamics related to the fundamental infrastructure of the human way of thinking, we assumed that we will be able to find similar phenomena in other fields and turned to study the tales of rabbi nachman of bratslav using this approach .we focused on the first story and studied the appearances of the diagonal link and their role .it should be emphasized that the analysis was performed in a mechanical method that referred only to the syntactic structure and not to the meaning of the text .in a very simplified and short way we can say that according to the kabala ( the jewish medieval mystical tradition ) creation starts when g - d withdrew in order to make room for the world to be created .after the creation , a line of light was sent from the infinite g - d into the created world but due to the deficiencies of the world it could not bear the light and was `` broken '' with the sparks of light scattered all around it .the human task is to collect these divine sparks and bring them back to their roots .this task is laid upon every human being , more on the nation of israel and most on the righteous person - the tzadik .this dynamics has many manifestations : the exile of the soul in the body and the need of the individual to redeem it by bettering oneself and lifting oneself spiritually , the exile of the nation of israel and their need to return to the land of israel , the exile of the divine presence and the need to help it to be re - united with g - d etc .rabbi nachman of bratslav ( 1772 - 1810 ) saw himself as a tzadik and as such he felt , like other hassidic ( the hassidic movement is a pre - modern jewish revival movement , deeply inspired by kabala ) sages , responsible for the redemption process and for the recruitment of his followers to help in the process . at a certain pointhe felt that the direct cognitive approach did not give enough fruits and that his explicit teachings did not enlighten his people as he expected .at that point he decided to convey his message in an implicit manner through story telling .the first story that he told was `` the story of the lost princess '' .it starts with a king who once got angry with his beloved daughter and cursed her that the no - good will take her .after she disappeared the king became so sorry and regretful that his second - to - the - king volunteered to go out and look for the princess .after many hardships he found the princess who instructed him how to save her by fasting , not sleeping and longing for her , but twice he failed by eating or drinking and consequently falling asleep and the princess was transferred to the golden mountain . during his wanderings looking for the golden mountain he met a giant who was responsible for all animals who tried to convince him to give up , but even after all the animals did not know anything about the golden mountain the second - to - the - king remained determined to continue his search .so the giant sent him to his brother who was responsible for all the birds . after repeating the same scenario he sent the second to the third brother who was responsible for all the winds .after the winds did not know about the golden mountain and the second - to - the - king started to cry , came another wind who apologized that it was late as it had to deliver a princess to a golden mountain .the giant then ordered the wind to take there also the second and equipped him with a tool that will help him there .the end of the story was not told ; we only have a comment of the editor saying that in the end he managed to save her but rabbi nachman did not tell how . the story is usually interpreted along the lines described in the first paragraph of this section .the king represents g - d and the pair second - princess represents either the individual and his soul or the tzadik and the divine presence . the story was not completed by rabbi nachman , because the story of creation is not finished and the harmonious unification was not yet accomplished .when performing the diagonal analysis on `` the story of the lost princess '' , 18 diagonal links were found .two examples are presented in table 2 .our assumption was that diagonal links indicate key - events in the story and in order to check if the events associated with these 18 diagonal links were to be considered important events we went through 21 authors who commentated `` the story of the lost princess '' .we looked at the 29 events they referred to and ranked them according to the number of writers referring to them . when comparing the events pointed by the diagonal links we found that they matched quite fully the top part of the list : the first event that was not pointed by a diagonal link was number 14 in the ranked list and only one of these events matched a low - ranked event ( number 22 ) .the detailed analysis of this study will be published elsewhere . for the purpose of this paperit is enough that appearance of a diagonal link indicates a crucially significant point in the story .the grimm brothers story `` the raven '' starts with a queen who lost her patience with her daughter and cursed her to become a raven , which she did and flew to a black forest .a man going through the forest heard the raven and went to it .he met the princess who instructed him how to save her by fasting , not sleeping and waiting for her at a specific time .thrice he failed by drinking and falling asleep and the princess was transferred to the golden palace . during his wanderings looking for the golden palace he met a giant who first was hostile but then tried to help him .he looked for the palace in his map but in vain .he tried a bigger map and again - in vain .then he convinced the man to wait for his brother who , when came back , looked at his map that was still bigger but the palace was not on it .at last they found the palace in an old map and the giant took the man most of the way toward it .the man took from three thieves the equipment that helped him enter the palace and release the princess .the story ends with the princess thanking the man for saving her and declaring their wedding to be celebrated the next day .this story is clearly a parallel to rabbi nachman s `` the story of the lost princess '' although they are not identical . s. pitrushka claims that neither of the two stories is the source of the other but they both share a common source in the polish story `` a diverting story about the virtuous princess banialuce from an eastern land '' by hieronim morsztyn ( died in 1655 ) .although rabbi nachman did not know the polish language , pitrushka quotes the polish historian a. brinker who proved that `` princess banialuce '' was translated to the ukrainian language . finding a parallel story was indeed intriguing in light of the fact that rabbi nachman did refer to the relations between his stories and other folk tales .rabbi nachman s tales were edited by his main disciple rabbi nathan sternhartz of nemirow . in his first introduction rabbinathan tells : `` before [ the rebbe ( hassidic sage ) ] began telling the first story in this book , he declared , ' ' many hidden meanings and lofty concepts are contained in the stories the world tell .these stories , however , are deficient : they contain many omissions .they are also confused , and people do not tell them in the correct order ... `` .the rebbe spoke about this .then he began to tell the story on the following page .he said , ' ' i told this story while on a journey ... `` in contemporary words , rabbi nachman claims that folk tales need to be upgraded and is moving to give an example how he does it .therefore it was especially interesting to perform a diagonal analysis on ' ' the raven " .in the analysis we found 12 diagonal links in `` the raven '' . further examination showed that out of the 18 diagonal links of `` the lost princess '' only 9 were present in `` the raven '' . in 8 out of the 9 missing appearances ,the event itself was present in `` the raven '' but its description lacked the diagonal link . on the other hand , in all three diagonal links that appeared in `` the raven '' and did not appear in `` the lost princess '' the event itself was not part of the story .two of these are placed in the last part of the story , the part that rabbi nachman did not tell . when calculating the density of diagonal links appearances according to the number of words we found that in `` the raven '' there were 12 diagonal links in 1652 words , which is a density of 0.7 percent .in `` the lost princess '' there were 18 diagonal links in 1312 words , which is a density of 1.4 percent .in an earlier section we showed that an appearance of a diagonal link indicates a part of the story which is of special quality . from this obviously derives that the overall importance of the text increases with the density of diagonal links appearances .the double density that was found in `` the lost princess '' in comparison to `` the raven '' indicates a significant difference in quality . according to our findingsrabbi nachman managed to execute what he was trying to do - to upgrade the story .our intention now is to analyze the story of `` princess banialuce '' and one of the theoretical teachings of rabbi nachman . according to the above we expect to find a significant difference in the diagonal density between `` the lost princess '' and `` princess banialuce '' and a non - significant difference between the stories and the teachings of rabbi nachman .  10 , _the microscopic representation of complex macroscopic phenomena _ , annual reviews of computational physics ii pp 243 - 294 ( world scientific , 1995 ) ., _ pushing einstein s principles to the extreme _ , in _ quantum fields and quantum space time _ , edited by g. t hooft et al ( plenum press , 1997 ) ., _ universal dynamics of complex adaptive systems : gauge theory of things alive _ , desy * 94 - 075 * , ( april 1994 ) . , _ gauge theory of things alive : universal dynamics as a tool in parallel computing _ , prog . theor .physics suppl .* 122 * , 201 ( 1996 ) ., _ restricted ability to recover 3d global motion from 1d motion signals : theoretical observations _ , vision research * 35 * , 569 ( 1995 ) ; n. rubin , s. hochstein and s. solomon , _ restricted ability to recover 3d global motion from 1d motion signals : psychophysical observations _ , vision research * 35 * , 463 ( 1995 ) ; s. solomon , _ the microscopic bases of vision _ , in perspectives on cognitive science , vol .2 , edited by b. kokinov ( nbu , 1995 ) . , _ the dynamics of childrens s drawings _ , in perspectives on cognitive science , vol .2 , edited by b. kokinov ( nbu , 1995 ) ; e. adi - japha , i. levin and s. solomon , _ emergence of representation in drawing : the relation between kinematic and referential aspect _ , cognitive development * 13 * , 25 ( 1998 ). , _ collective degrees of freedom and multiscale dynamics in spin glasse _ , phys .e. * 54 * , 4399 ( 1996 ) ; i. stenhill , s. solomon and k. wolowelsky , _ dynamical algebraic multi - grid simulations of free fields on rts _ , computer physics communications * 83 * , 152 ( 1994 ) ; e. adi and s. solomon , _ the solution to wheeler - de witt is eight _ , phys .b * 336 * , 152 ( 1994 ) ., _ new product development with prescribed algorithms _ , international journal of modern physics c , vol .8 no . 2 , 365 ( 1996 ) ., _ toward identifying the inventive templates of new products : a channeled ideation approach _ , journal of marketing research * 36 * , 200 ( may 1999 ) . ,cluster concepts dynamics leading to creative ideas without critical slowing down _ , international journal of modern physics c , vol . 75 , 655 ( 1996 ) . , _ creativity templates : towards identifying the fundamental schemes of quality advertisements _ , marketing science , vol .18 , no . 3 , 333 ( 1999 ) ., _ creativity templates in product innovation _ ( cambridge university press , ( in press ) ) . , _nachman of bratslav - the tales _( paulist press , new york 1978 ) ., _ rabbi nachman s stories _( breslov research institute , new york 1983 ) ., _ polish source for rabbi nachman of brastlav s tales _ , ktuvim , year b , issue 41 - 42 , 12.7.1928 ( in hebrew ) .

Abstract: we extend the microscopic representation approach to the quantitative study of religious and folk stories : a story encrypting symbolically the creation is deconstructed into its simplest conceptual elements and their relationships . we single out a particular kind of relationship which we call `` diagonal ( or transitive ) link '' : given 2 relations between the couples of elements ab and respectively bc , the `` diagonal link '' is the ( composite ) relation ac . we find that the diagonal links are strongly and systematically correlated with the events in the story that are considered crucial by the experts . we further compare the number of diagonal links in the symbolic creation story with a folk tale , which ostensibly narrates the same overt succession of events ( but without pretensions of encrypting additional meanings ) . we find that the density of diagonal links per word in the folk story is lower by a factor of 2 . we speculate that , as in other fields the simple transitive operations acting on elementary objects are at the core of the emergence and recognition of macroscopic meaning and novelty in complex systems . +  * keywords : * + complexity , emergence , microscopic representation , diagonal link , novelty , creation , stories


consider a finite set of particles or points in , moving in time along continuous trajectories .interpreting these points as the centers of moving objects , we are interested in the topological changes the configuration undergoes .our interest in this problem originates in a sorting process that segregates cells during zebrafish development , as studied by heisenberg and krens .the sorting process operates on intermixed configurations of cells in which different types have different physical properties .one example is a mix of two cell types , in which the cells of the first type have a strong preference for neighboring cells of the same type and a strong dislike of exposed boundary , while the cells of the second type have milder preferences and dislikes .the typical outcome is that the cells of the first type form a ball - like shape that is engulfed by a spherical shell consisting of cells of the second type .  in an effort to formalize the sorting process and to make it amenable to detailed and objective measurements , heisenberg , krens , and the authors of this paper introduced the _ restricted voronoi medusa _ as a mathematical representation .it is a geometric body in -dimensional space - time obtained by stacking up restricted voronoi regions in  . at any moment in time ,the voronoi region of a particle is intersected with a ball , and the resulting bodies are glued together to form a -dimensional structure .applying persistent homology to the time function on this structure yields fine - grained information about the sorting process that is difficult to observe directly .this paper complements this foundational work with a description of the computational aspects of the medusa construction .[ [ results . ] ] results .+ + + + + + + +   proves that the restricted voronoi medusa has the same homotopy type as the medusa obtained by stacking up simplices in the corresponding alpha complex .the latter _ alpha medusa _ is combinatorial in nature , which has computational advantages .continuing in this direction , this paper makes three contributions :  1 .we describe an algorithm that maintains a fixed - radius alpha complex for points moving on piecewise algebraic trajectories in .the algorithm supports insertions and deletions of points and allows for piecewise algebraic trajectories . 2 .maintaining an alpha complex , we construct the alpha medusa whose geometric and topological properties reflect the events during the sorting process .we convert the kinetic algorithm and the medusa construction into robust and efficient software . basing the implementation on the cgal package for kinetic data structures by daniel russel , it achieves correctness through the exact geometric computation paradigm .part of contribution 1 is an extension of previous work from kinetic delaunay triangulations to kinetic alpha complexes , which is of independent interest .the requirement of correctly comparing algebraic numbers , without tolerance for inaccuracy or approximation in contribution 3 seriously slows down the software , even for piecewise - linear trajectories . to counteract , we introduce techniques that speed - up the computations without sacrificing their correctness .we evaluate the effectivity of these techniques experimentally .[ [ outline . ] ] outline .+ + + + + + + +  section [ sec2 ] explains background from computational geometry and topology .section [ sec3 ] describes the kinetic algorithm for fixed - radius alpha complexes .section [ sec4 ] explains the algorithm that constructs the medusa of a set of moving cells .section [ sec5 ] describes techniques to speed up the computations .section [ sec6 ] concludes the paper .we review the fundamental geometric data structures that are required in this work .voronoi tessellations and delaunay triangulations are treated in most computational geometry textbooks , including , and alpha complexes are described in . for the most part , the discussion focuses on the -dimensional case .most definitions and properties extend to higher dimensions as well as to the plane .we will exploit the latter fact when we draw illustrations .[ [ cell - complexes . ] ] cell complexes .+ + + + + + + + + + + + + + +  we recall that a _ -simplex _ is the convex hull of an affinely independent set of points in some euclidean space .face _ is a simplex defined by a subset of the points .it is _ proper _ if the subset is different from the set . reversing the direction , we call the -simplex a _ coface _ of its face . we define a _ simplicial complex _ as a finite collection of simplices that is closed under the face relation , with the additional property that any two simplices in the collection are either disjoint or their intersection is a face of both .the _ boundary _ of a -simplex is the collection of its -faces .the simplices of dimension , , , and are referred to as _ vertices _ , _ edges _ , _ triangles _ , and _tetrahedra_. the _ star _ of a -simplex is the set of simplices that contain the -simplex as a face . noting that the star is in general not closed under the face relation , we define the _ closed star _ as the set of all simplices in the star and of all faces of these simplices .it is the smallest simplicial complex that contains the star . finally , if is a -simplex and is a point that does not lie in the -plane of the simplex , then the _ join _ , denoted as , is the -simplex that is the convex hull of and the vertices of .it is convenient to also introduce an abstract counterpart to the above geometric concept of a simplicial complex .specifically , an _ abstract simplicial complex _ consists of a finite set of ( abstract ) elements and a collection of subsets that is closed under the subset relation .we may map each element to a point in some euclidean space , and each subset to the convex hull of the points that correspond to its elements .if the dimension of the space is sufficiently high and the points are well chosen , this is a simplicial complex , which we refer to as a _ geometric realization _ of the abstract simplicial complex .here is an example of this construction .consider a finite set , , of possibly overlapping bodies , and define the _ nerve _ as the collection of subsets of with non - empty common intersection .we note that the nerve is an abstract simplicial complex . indeed , the bodies are the elements , and if is a set in the nerve , then every subset of is also in the nerve .a useful result is the nerve theorem , which states that if the bodies in are convex then every geometric realization of the nerve has the same homotopy type as the union of the bodies .intuitively , this means that one can be transformed into the other by continuous transformations like bending , shrinking , and expanding , but without gluing and cutting .most complexes in this paper will be constructed using the nerve operation .we will have occasion to also use complexes that are more general than simplicial complexes . instead of -simplices ,they contain _-cells _ , which are homeomorphic to the -dimensional unit ball .the _ boundary _ of a -cell is the homeomorphic image of the -sphere that bounds the -ball .we define a _ cell complex _ as a finite collection of cells with pairwise disjoint interiors such that the boundary of each -cell is a union of -cells in the complex .[ [ voronoi - tessellations - and - delaunay - complexes . ] ] voronoi tessellations and delaunay complexes .+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +  consider now a finite set of points , , in .the _ voronoi region _ of a point in is the set of points that have as the closest point in : note that is convex .we usually drop from the notation .the _ voronoi tessellation _ of is the set of voronoi regions of its points .while it is not a cell complex formally , we get a cell complex if we add the common intersections of voronoi regions as lower - dimensional cells to the set .if the points in are in general position , by which we mean that no four lie in a common plane and no five lie on a common sphere , then the voronoi regions intersect in a rather predictable pattern .specifically , the intersection of any two is either empty or a ( -dimensional ) polygon , the intersection of any three is either empty or a ( -dimensional ) edge , and the intersection any four is either empty or a ( -dimensional ) point .furthermore , the intersection of five or more voronoi regions is necessarily empty .  we get the dual _ delaunay complex _ if we replace each non - empty intersection of voronoi regions by the convex hull of the points that generate the voronoi regions containing the intersection .equivalently , we may define the delaunay complex as the set of convex hulls of subsets of points that have the _ empty sphere property_. specifically , this means that there exists a sphere that passes through the points of the subset and all other points in lie strictly outside this sphere .we note that the center of this sphere belongs to the intersection of the corresponding voronoi regions . assuming general position, the delaunay complex is a simplicial complex , which is generally referred to as the _ delaunay triangulation_. it is a geometric realization of the nerve of the voronoi tessellation .[ [ restricted - voronoi - tessellations - and - alpha - complexes . ] ] restricted voronoi tessellations and alpha complexes .+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +  fixing a positive radius , , we define the _ restriction _ of a voronoi region to be its intersection with the closed ball of radius centered at the generating point : again , we usually drop from the notation .the _ restricted voronoi tessellation _ of is the set of restricted voronoi regions of its points .in contrast to the unrestricted case , each restricted voronoi region is bounded , and the tessellation covers only the union of balls and not the entire space .  as before , we assume general position so we can dualize by geometrically realizing the nerve . the resulting simplicial complexis called the _ alpha complex_. since , for each point in , the alpha complex is a subcomplex of the delaunay triangulation .next , we derive an equivalent condition for a delaunay simplex to lie in the alpha complex which is more suitable for computations .each -simplex in the delaunay triangulation has a unique circumscribed -sphere in its supporting -plane .we call its center the _ circumcenter _ , its radius the _ circumradius _ , the ball in with this center and this radius the _ circumball _ , and the sphere that bounds the circumball the _ circumsphere _ of the -simplex . note that the circumsphere is the smallest sphere that passes through the vertices of the -simplex .we call the -simplex _ short _ if its circumradius is smaller than or equal to .finally , we call the -simplex _ gabriel _ if its circumball has no point of in its interior .a simplex in the delaunay triangulation of belongs to the alpha complex , for radius , iff it is short and gabriel , or it is the face of another delaunay simplex that is short and gabriel .the face of a short simplex is necessarily short , but the face of a gabriel simplex is not necessarily gabriel .it follows that all simplices in the alpha complex are short , but not all simplices need to be gabriel .also note that a tetrahedron is in the delaunay triangulation iff it is gabriel ; therefore , it is in the alpha complex iff it is short . in our application , we use the restricted voronoi tessellation to model a set of biological cells for which the positions of their nuclei are known .indeed , a cell tends to minimize its surface area and usually does not grow larger than a certain size .therefore , a restricted voronoi region appears to be a good approximation of the actual cell shape and is still simple enough for our computational purposes .in this section , we describe the algorithm that maintains the alpha complex for a fixed radius .we pay particular attention to the certificates that govern the sequence of operations needed to preserve the correctness of the structure at all times .[ [ the - kinetic - framework . ] ] the kinetic framework .+ + + + + + + + + + + + + + + + + + + + + +  the input to our algorithm is a finite set of trajectories , each a continuous map \to { { \ifmmode{{\mathbb r}}\else{\mbox{\({\mathbb r}\)}}\fi}}^3 ] be a particular trajectory , we get the region of within the tessellation of for each time . piling up these regions in and taking the closure, we call the result the _ stack _ of the trajectory : \right).\end{aligned}\ ] ] taking the closure is not redundant because the region of a trajectory can change discontinuously when inserting another trajectories , causing a locally open pile .the set of stacks of trajectories in is the _ restricted voronoi medusa _ , which we denote as .while it is the preferred representation of a spatial sorting process , we introduce a dual structure that is easier to compute and gives the same measurements . as a first approximation of this construction, we exploit the duality between restricted voronoi diagrams and alpha complexes and pile up the simplices of the latter to form cells in ; see figure [ fig : alpha_medusa_illu ] .this construction has two shortcomings .first , the cells do not define a cell complex , but this can be corrected by adding ( geometrically degenerate ) cells that represent flip , insertion , and deletion events .second , the walls are redundant and are better contracted .the contraction produces simplices , but they are connected to each other in more general ways than allowed in a simplicial complex .the main difficulty in defining the alpha medusa formally is a lack of regularity of the stacks in . while every restricted voronoi region is convex , the stack of such regions is generally not convex , and the intersection of two stacks is generally not connected .taking the nerve of the set of stacks would thus produce an abstract complex that does not respect the nerve theorem . to finesse these difficulties , we take the _ multi - nerve _ as follows. if stacks intersect in different connected components , then the multi - nerve has copies of the abstract -simplex , each representing one component of the intersection .moreover , each abstract simplex is associated with the _ lifetime interval _ ,  ] is _ active _ for all and _ finished _ for all .we construct the alpha medusa by running the kinetic alpha complex algorithm and updating the medusa at each event .we maintain two lists of simplices , called the _ output list _ and the _ active list _ , preserving the following property at all times :  after the algorithm has handled an event at time , the output list consists of all simplices finished at , and the active list consists of all simplices active at .at the beginning , all simplices in the alpha complex are put into the active list . whenever a simplex is added to the alpha complex at a time , we put it into the active list , and when it is removed from the alpha complex at a later time , we remove it from the active list and put it into the output list with lifetime interval  ] .we thus add the -simplex , connecting it its five boundary tetrahedra , which are the ones involved in the flip .indeed , the -simplex fills the void between the five tetrahedra , which could not be filled by gluing the tetrahedra to each other as they are not face - to - face .[ [ insertions - and - deletions . ] ] insertions and deletions .+ + + + + + + + + + + + + + + + + + + + + + + + +  finally , we consider the case in which a trajectory , , is inserted at time .the case of a deletion is symmetric and omitted .let be the vertex inserted into the alpha complex .as described in section [ sec3 ] , the insertion of into the delaunay triangulation is synonymous with the substitution of the star for the simplices in the conflict region of .any subset of these simplices may belong to the alpha complex .in addition to finding this subset , we need to construct simplices that fill the gap between the deleted and the inserted alpha complex simplices in the medusa .this is similar to a flip , in which the void formed by the five tetrahedra is filled by a -simplex . to describe a general solution to this problem ,let be a finite set of points , a point not in , and write for the set including the new point .we call each an _ old region _ , each a _ new region _ , and the _ region _ of .let be a non - empty common intersection of old regions .then , intersects the region of iff the common intersection of the corresponding new regions is either empty or it also intersects the region of .proof .  forthe forward direction , assume that intersects the region of , and let be an arbitrary point in that intersection .note that , where is the distance to the closest points in . in the first case, we have , for all , which implies that the corresponding new regions do not intersect . in the second case, we have , for some , then there exists a point such that , which implies that belongs to the intersection of the new regions with the region of .  for the backward direction , if the new regions intersect the region of , so do the old regions . in the remaining case ,the new regions do not intersect .let be a point in the intersection of the old regions .since is not in the intersection of the new regions , it must be in the region of .we use the insertion lemma to derive an algorithm that updates the alpha medusa upon the insertion of a point at time . similar to the case of the delaunay triangulation, we identify the conflict region and remove all simplices in its interior .in addition , if a removed -simplex is in the alpha complex just before , we add the join , , to the alpha medusa with lifetime interval $ ] .we do this because the old regions represented by have a non - empty common intersection , but the corresponding new regions do not . in the second step ,we insert the star of into the delaunay triangulation , check for every inserted simplex whether it belongs to the alpha complex , and if it does then we add it to the active list . clearly , every inserted simplex is of the form , with on the boundary of the conflict region .in this section , we turn to implementation issues . in particular , we discuss how to implement the algorithm in a robust manner , we study the effect of practical choices , and we present experimental results obtained with our software .  [ [ robust - computation . ] ] robust computation .+ + + + + + + + + + + + + + + + + + +  recall the basic structure of a kinetic data structure as explained in section [ sec3 ] : it consists of certificate functions , which are polynomials in , and each step advances the state to the smallest root larger than the current time . to maintain the certificates and to advance to the next event , the algorithm computes and compares real roots of univariate polynomials .these roots are algebraic numbers irrational in general which makes the computations non - trivial .the naive solution of approximating these roots by inexact floating - point numbers can have unpredictable effects .it is not true that the outcome is just slightly wrong , e.g. by switching the order of events that happen almost simultaneously , but the incorrect order can lead to inconsistent configurations , causing program crashes , non - termination , and non - sensical results . this problem is well - known in geometric contexts and several approaches have been proposed .we follow the _ exact geometric computation ( egc ) paradigm _ , popularized by chee yap .it suggests that the basic primitives be mathematically correct , so that an algorithm using these primitives is in the position to compute provably correct results .translated to our situation , we require that the events of our process are handled in the mathematically correct order .the price we pay for this interpretation of robustness is the burden to compute with algebraic numbers .we implement our algorithm using the cgal library , which is designed in the spirit of the egc paradigm .another aspect of cgal is its generic programming approach : algorithms access underlying data structures and primitives through a well - defined interface , so that these layers can be easily replaced with alternative implementations .more specifically , we make use of the kinetic data structures package , which provides an egc implementation of kinetic delaunay triangulations in two and three dimensions .internally , the package contains an algebraic kernel , providing the low - level functionality needed to handle roots of polynomials , and a combinatorial layer , maintaining the data structure and the certificates over time .as mentioned earlier , we have extended the combinatorial layer to maintaining an alpha complex .[ [ experimental - set - up . ] ] experimental set - up .+ + + + + + + + + + + + + + + + + + + +  we use datasets obtained with the compucell3d software , which allows for the simulation of a -dimensional cell segregation process using a monte - carlo algorithm for energy minimization ; see the companion paper for more details .we focus on simulated as opposed to observed data because they offer a better control of the input size and the direct accessibility of the cell trajectories . in our particular example, the cells are colored blue or red , each color with probability one half , and the parameters of the simulation are chosen so that the blue cells eventually engulf the red ones ; see figure [ fig : vor - tessel ] for an illustration .we created datasets for several input sizes .in all cases , each trajectory represents the path of a cell nucleus which exists throughout the entire process .hence , no new cells are ever inserted after the start of the process , and no old cells are deleted before the end of the process .the trajectories follow a global rhythm in which each trajectory starts a new segment at each value in a common sequence of bending events . in between two bending events , each trajectory is linear .all experiments are performed on a intel core 2 dual cpu clocked with 2.4 ghz each , with 3 mb of cache size , and 4 gb of total memory .the code runs under debian squeeze , compiled with gcc-4.4.5 and cgal version 3.9 .  in a first test, we compare the running times for maintaining the delaunay triangulation and the alpha complex , and for constructing the alpha medusa , all for the same datasets ; see table [ tbl : del_alpha_compare ] .we observe that the overhead of computing the medusa is negligible .for this reason , we concentrate on the maintenance of the alpha complex . comparing the third and fourth columns of the table ,we see that the radius events slow down the algorithm by more than a magnitude , in spite of the fact that their number is not much larger than the number of flip events . in the remainder of this section ,we explain improvements of our algorithm aimed at reducing the performance gap between delaunay and alpha complexes .  [ [ number - of - certificates . ] ] number of certificates .+ + + + + + + + + + + + + + + + + + + + + + +  the bottleneck is the construction of radius certificates and the computation of their real roots . recall that in our original formulation , we maintain a radius certificate for each edge , triangle , and tetrahedron .our first optimization is based on the observation that many of these certificates are not necessary : if a simplex is short , then all its faces are short , and if a simplex is non - short , then all its cofaces are non - short .  whenever a triangle or tetrahedron becomes short ,we remove the radius certificates of its proper faces , and when an edge or triangle becomes non - short , we remove the radius certificates of its proper cofaces .  of course , this implies that we sometimes have to construct certificates that would otherwise still exist .for example , we construct the certificate of a triangle at the time its third edge becomes short . on the other hand, we avoid unnecessary certificates , for instance the certificates of the boundary edges of a triangle that stays short for the whole simulation .as we see in table [ tbl : reduced_cert ] , the strategy saves time in practice .we observe that the constructions of radius certificates and the running time both decrease roughly by a factor of two .[ [ degree . ] ] degree .+ + + + + + +  we turn to the computation of certificates .assuming piecewise - linear trajectories , the radius certificate of an edge is a polynomial of degree ; compare with section [ sec3 ] .there is a standard construction of a radius certificate of a tetrahedron , which is a polynomial of degree ; see .our interest lies in the remaining triangle case .the current cgal implementation computes the squared circumradius of a triangle in with an expression of the form where is the determinant of the matrix in , and , , are expressions formed by minors of this matrix . the corresponding certificate, is a polynomial whose degree is , which is higher than the degree for the tetrahedron .we replace by a simpler expression . writing , , for the three vertices of the triangle, the circumradius can also be written as a formula that is straightforward to derive using elementary matrix calculus ; see also wikipedia .monitor the radius of a triangle using the following certificate function :   the degree of this certificate is .we see the effect of this improvement in table [ tbl : reduced_degree ] .the running time improves by more than a factor of two .[ [ algebraic - kernel . ] ] algebraic kernel. + + + + + + + + + + + + + + + + +  as already mentioned , the cgal package for kinetic data structures contains an internal algebraic kernel , which , among other things , is used to isolate the roots of polynomials and sort them in the event queue . by the generic design of the package, the combinatorial layer communicates with the kernel via a small and well - defined interface , which makes it possible to replace the algebraic kernel with a different implementation .  in recent years, a mature and generic algebraic kernel for geometric computations has been developed .it has been integrated into cgal and is available since version 3.7 under the name ` algebraic_kernel_d ` .we refer to it as the ak_d kernel .both the internal kds and the ak_d kernels use subdivision methods for root isolation , but they differ in the strategy for detecting empty intervals and isolating intervals .the kds kernel uses sturm theory , while the ak_d kernel is based on descartes rule of sign , which leads to a better performance in practice ; see for a comparison of various root solvers .the difference between the third and fourth columns in table [ tbl : new_kernel ] shows that exchanging the kernel yields another improvement of roughly a factor of two .[ [ filter - and - cache . ] ] filter and cache .+ + + + + + + + + + + + + + + + +  we get further optimizations by exploiting the special structure of our experimental setup . for any certificate ,we are only interested in the roots between the current time and the next bending event , when the certificate becomes invalid .many certificates do not have roots in this interval , but may have roots outside .the current implementation first computes all real roots and thereafter discards the ones that lie outside the mentioned interval .we use descartes rule of sign to certify the non - existence of roots in the interval until the next bending event , and if successful , we skip the root isolation algorithm .  the fifth column of table [ tbl : new_kernel ] shows the improvement. more than ninety percent of the certificates that do not have a root before the next bending event are filtered out . as a final improvement, we avoid isolating the roots of the same polynomial multiple times .we store polynomials together with their real roots in the interval until the next bending event in cache , which is cleared at the next bending event .we see in the sixth column of table [ tbl : new_kernel ] that the cache yields another substantial speed - up , which suggests that certificates are frequently devalidated and revalidated during the runtime of the algorithm .we remark that also the kds kernel would benefit from caching . comparing the running times for maintaining the alpha complex before and after the four steps of optimization, we see that the performance improves by roughly a factor of .moreover , compared to maintaining the delaunay triangulation , the optimized algorithm is slower by a factor up to .it is no surprise that the extension to alpha complexes is expensive .after all , it requires additional radius certificates , which have higher degrees than the flip certificates needed to maintain the delaunay triangulation .we have demonstrated that with some algorithmic engineering , the overhead needed for alpha complexes can be kept within a moderate bound .the main contributions of this paper are a kinetic algorithm for alpha complexes , its use to construct a space - time representation of a spatial sorting process called a medusa and the implementation of a moderately fast but correct software . in a companion paper , we have demonstrated that the theory of persistent homology applied to the time function on the medusa quantifies the sorting process by measuring its topological features . while the work in this and the companion papers is limited to simulated data , an application of our methods to observed biological data is under way .there is no theoretical obstacle to generalizing our algorithm and its implementation to the weighted case , in which different voronoi regions are restricted to within different size balls .a more challenging problem is the restriction to within bodies different than balls , e.g. arbitrarily oriented ellipsoids .the first author of this paper made a considerable effort to accelerate the implementation of the kinetic alpha complex algorithm , since this was necessary to compute examples of reasonable size in acceptable time ; the instances computed in each took about 4 hours with our best configuration .nevertheless , there are opportunities to further speed up the software , in particular on the level of the algebraic kernel . for example, it would be desirable to restrict the root isolation method to within a given interval , without wasting any time on roots outside this interval .similarly , we expect an improvement from implementing the filter for ruling out empty intervals in certified approximate arithmetic .we believe that kinetic data structures are an important tool in the topological analysis of time - varying shapes .we hope that our work on cell segregation initiates further work on such data . to facilitate this research, it would be useful if our extension of cgal s package on kinetic data structures is transformed from an experimental branch to a redesign of the package .it is desirable that such a redesign solves the problem of degeneracies in the implementation of kinetic delaunay triangulations and alpha complexes .except for some special cases , the current versions of both algorithms are not guaranteed to work correctly when two or more events happen at exactly the same time .

Abstract: motivated by an application in cell biology , we consider spatial sorting processes defined by particles moving from an initial to a final configuration . we describe an algorithm for constructing a cell complex in space - time , called the _ medusa _ , that measures topological properties of the sorting process . the algorithm requires an extension of the kinetic data structures framework from delaunay triangulations to fixed - radius alpha complexes . we report on several techniques to accelerate the computation .