This thesis proposes a combinatorial generalization of a nilpotent operator on a vector space. The resulting object is highly natural, with basic connections to a variety of fields in pure mathematics, engineering, and the sciences. For the purpose of exposition we focus the discussion of applications on homological algebra and computation, with additional remarks in lattice theory, linear algebra, and abelian categories. For motivation, we recall that the methods of algebraic topology have driven remarkable progress in the qualitative study of large, noisy bodies of data over the past 15 years. A primary tool in Topological Data Analysis [TDA] is the homological persistence module, which leverages categorical structure to compare algebraic shape descriptors across multiple scales of measurement. Our principle application to computation is a novel algorithm to calculate persistent homology which, in certain cases, improves the state of the art by several orders of magnitude. Included are novel results in discrete, spectral, and algebraic Morse theory, and on the strong maps of matroid theory. The defining theme throughout is interplay between the combinatorial theory matroids and the algebraic theory of categories. The nature of these interactions is remarkably simple, but their consequences in homological algebra, quiver theory, and combinatorial optimization represent new and widely open fields for interaction between the disciplines.
A number of closely related algorithms share the cubic worst-case bound while demonstrating dramatic improvements in performance empirically. These include the algorithm of Chen and Kerber @cite_6 , and the algorithm of de Silva, Morzov, and Vejdemo-Johansson @cite_73 @cite_84 . Some parallel algorithms for shared memory systems include the algorithm @cite_19 , and the algorithm @cite_65 . Algorithms for distributed computation include the @cite_10 and the spectral sequence algorithm of Lipsky, Skraba, and Vejdemo-Johansson @cite_49 .
@cite_65 @cite_84 @cite_6 @cite_19 @cite_49 @cite_73 @cite_10
2130306834 2020196988 2052785830 2339415939
With recent technological advances, shared memory parallel machines have become more scalable, and offer large main memories and high bus bandwidths. They are emerging as good platforms for data warehousing and data mining. In This work, we focus on shared memory parallelization of data mining algorithms. We have developed a series of techniques for parallelization of data mining algorithms, including full replication, full locking, fixed locking, optimized full locking, and cache-sensitive locking. Unlike previous work on shared memory parallelization of specific data mining algorithms, all of our techniques apply to a large number of popular data mining algorithms. In addition, we propose a reduction-object-based interface for specifying a data mining algorithm. We show how our runtime system can apply any of the techniques we have developed starting from a common specification of the algorithm. We have carried out a detailed evaluation of the parallelization techniques and the programming interface. We have experimented with apriori and fp-tree-based association mining, k-means clustering, k-nearest neighbor classifier, and decision tree construction. The main results from our experiments are as follows: 1) Among full replication, optimized full locking, and cache-sensitive locking, there is no clear winner. Each of these three techniques can outperform others depending upon machine and dataset parameters. These three techniques perform significantly better than the other two techniques. 2) Good parallel efficiency is achieved for each of the four algorithms we experimented with, using our techniques and runtime system. 3) The overhead of the interface is within 10 percent in almost all cases. 4) In the case of decision tree construction, combining different techniques turned out to be crucial for achieving high performance. This paper considers the problem of nonpreemptively scheduling n independent jobs on m identical, parallel processors with the object of minimizing the “makespan”, or completion time for the entire set of jobs. Coffman, Garey, and Johnson [SIAM J. Comput., 7 (1978), pp. 1–17] described an algorithm MULTIFIT which has a considerably better worst case performance than the largest processing time first algorithm. In this paper we tighten the bounds obtained in that paper on the worst case behavior of this algorithm by giving an example showing that it may be as bad as 13 11 and proving that it can be no worse than 6 5. In this paper a parallel algorithm to solve the stable marriage problem is given. The worst case performance of this algorithm is stated. A theoretical analysis shows that the probability of the occurrence of this worst case is extremely small. For instance, if there are sixteen men and sixteen women involved, then the probability that the worst case occurs is only 10−45. Possible future research is also discussed in this paper. In this paper, we study the communication complexity for the problem of computing a conjunctive query on a large database in a parallel setting with @math servers. In contrast to previous work, where upper and lower bounds on the communication were specified for particular structures of data (either data without skew, or data with specific types of skew), in this work we focus on worst-case analysis of the communication cost. The goal is to find worst-case optimal parallel algorithms, similar to the work of [18] for sequential algorithms. We first show that for a single round we can obtain an optimal worst-case algorithm. The optimal load for a conjunctive query @math when all relations have size equal to @math is @math , where @math is a new query-related quantity called the edge quasi-packing number, which is different from both the edge packing number and edge cover number of the query hypergraph. For multiple rounds, we present algorithms that are optimal for several classes of queries. Finally, we show a surprising connection to the external memory model, which allows us to translate parallel algorithms to external memory algorithms. This technique allows us to recover (within a polylogarithmic factor) several recent results on the I O complexity for computing join queries, and also obtain optimal algorithms for other classes of queries.