Results 21  30
of
34
Efficient Implementation of Tree Skeletons on DistributedMemory Parallel Computers
, 2006
"... The METR technical reports are published as a means to ensure timely dissemination of scholarly and technical work on a noncommercial basis. Copyright and all rights therein are maintained by the authors or by other copyright holders, notwithstanding that they have offered their works here electron ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
The METR technical reports are published as a means to ensure timely dissemination of scholarly and technical work on a noncommercial basis. Copyright and all rights therein are maintained by the authors or by other copyright holders, notwithstanding that they have offered their works here electronically. It is understood that all persons copying this information will adhere to the terms and constraints invoked by each author’s copyright. These works may not be reposted without the explicit permission of the copyright holder.
Hardness Results for Tournament Isomorphism and
, 2007
"... A tournament is a graph in which each pair of distinct vertices is connected by exactly one directed edge. Tournaments are an important graph class, for which isomorphism testing seems to be easier to compute than for the isomorphism problem of general graphs. We show that tournament isomorphism and ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
A tournament is a graph in which each pair of distinct vertices is connected by exactly one directed edge. Tournaments are an important graph class, for which isomorphism testing seems to be easier to compute than for the isomorphism problem of general graphs. We show that tournament isomorphism and tournament automorphism is hard under DLOGTIME uniform AC 0 manyone reductions for the complexity classes NL, C=L, PL (probabilistic logarithmic space), for logarithmic space modular counting classes ModkL with odd k ≥ 3 and for DET, the class of problems, NC 1 reducible to the determinant. These lower bounds have been proven for graph isomorphism, see [21]. 1
Sequential Random Permutation, List Contraction and Tree Contraction are Highly Parallel
"... We show that simple sequential randomized iterative algorithms for random permutation, list contraction, and tree contraction are highly parallel. In particular, if iterations of the algorithms are run as soon as all of their dependencies have been resolved, the resulting computations have logarit ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
We show that simple sequential randomized iterative algorithms for random permutation, list contraction, and tree contraction are highly parallel. In particular, if iterations of the algorithms are run as soon as all of their dependencies have been resolved, the resulting computations have logarithmic depth (parallel time) with high probability. Our proofs make an interesting connection between the dependence structure of two of the problems and random binary trees. Building upon this analysis, we describe linearwork, polylogarithmicdepth algorithms for the three problems. Although asymptotically no better than the many prior parallel algorithms for the given problems, their advantages include very simple and fast implementations, and returning the same result as the sequential algorithm. Experiments on a 40core machine show reasonably good performance relative to the sequential algorithms. 1
Practical authenticated pattern matching with optimal proof size
 Proceedings of the VLDB Endowment
"... We address the problem of authenticating pattern matching queries over textual data that is outsourced to an untrusted cloud server. By employing cryptographic accumulators in a novel optimal integritychecking tool built directly over a suffix tree, we design the first authenticated data structure ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
We address the problem of authenticating pattern matching queries over textual data that is outsourced to an untrusted cloud server. By employing cryptographic accumulators in a novel optimal integritychecking tool built directly over a suffix tree, we design the first authenticated data structure for verifiable answers to pattern matching queries featuring fast generation of constantsize proofs. We present two main applications of our new construction to authenticate: (i) pattern matching queries over text documents, and (ii) exact path queries over XML documents. Answers to queries are verified by proofs of size at most 500 bytes for text pattern matching, and at most 243 bytes for exact path XML search, independently of the document or answer size. By design, our authentication schemes can also be parallelized to offer extra efficiency during data outsourcing. We provide a detailed experimental evaluation of our schemes showing that for both applications the times required to compute and verify a proof are very small—e.g., it takes less than 10µs to generate a proof for a pattern (mis)match of 102 characters in a text of 106 characters, once the query has been evaluated. 1.
Hardness results for isomorphism and automorphism of bounded valence graphs
 In Theory and Practice of Computer Science (SOFSEM), volume 2  Stutend Research Forum
, 2008
"... Abstract. In a bounded valence graph every vertex has O(1) neighbours. Testing isomorphism of bounded valence graphs is known to be in P [15], something that is not clear to hold for graph isomorphism in general. We show that testing isomorphism for undirected, directed and colored graphs of valenc ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
Abstract. In a bounded valence graph every vertex has O(1) neighbours. Testing isomorphism of bounded valence graphs is known to be in P [15], something that is not clear to hold for graph isomorphism in general. We show that testing isomorphism for undirected, directed and colored graphs of valence 2 is logspace complete. We also prove the following: If a special version of bounded valence GI is hard for ModkL then it is also hard for #L. All results are proved with respect to DLOGTIME uniform AC0 manyone reductions. 1
Dynamic Parallel Tree Contraction* (Extended Abstract)
"... Parallel tree contraction has been found to be a useful and quite powerful tool for the design of a wide class of efficient graph algorithms. We propose a corresponding technique for the parallel solution of incremental problems. As our computational model, we assume a variant of the CRCW PRAM where ..."
Abstract
 Add to MetaCart
Parallel tree contraction has been found to be a useful and quite powerful tool for the design of a wide class of efficient graph algorithms. We propose a corresponding technique for the parallel solution of incremental problems. As our computational model, we assume a variant of the CRCW PRAM where we can dynamically activate processors by a forking operation. We consider a dynamic binary tree T of < n nodes and unbounded depth. We describe a procedure, which we call the dynam~c parallel tree contraction algomthm, which incrementally processes various parallel modification requests and queries: (1) parallel requests to add or delete leaves of T, or modify labels of internal nodes or leaves of T, and also (2) parallel tree contraction queries which require recomputing values at specified nodes. Each modification or query is with respect to a set of nodes U in T. Our dynamic parallel tree contraction algorithm is a randomized algorithm that takes O (log ( IUI log n)) expected par
CEAL: A CBased Language for SelfAdjusting Computation
"... Selfadjusting computation offers a languagecentric approach to writing programs that can automatically respond to modifications to their data (e.g., inputs). Except for several domainspecific implementations, however, all previous implementations of selfadjusting computation assume mostly functio ..."
Abstract
 Add to MetaCart
(Show Context)
Selfadjusting computation offers a languagecentric approach to writing programs that can automatically respond to modifications to their data (e.g., inputs). Except for several domainspecific implementations, however, all previous implementations of selfadjusting computation assume mostly functional, higherorder languages such as Standard ML. Prior to this work, it was not known if selfadjusting computation can be made to work with lowlevel, imperative languages such as C without placing undue burden on the programmer. We describe the design and implementation of CEAL: a Cbased language for selfadjusting computation. The language is fully general and extends C with a small number of primitives to enable writing selfadjusting programs in a style similar to conventional C programs. We present efficient compilation techniques for translating CEAL programs into C that can be compiled with existing C compilers using primitives supplied by a runtime library for selfadjusting computation. We implement the proposed compiler and evaluate its effectiveness. Our experiments show that CEAL is effective in practice: compiled selfadjusting programs respond to small modifications to their data by orders of magnitude faster than recomputing from scratch while slowing down a fromscratch run by a moderate constant factor. Compared to previous work, we measure significant space and time improvements.
Around and Beyond the Isomorphism Problem for Interval Graphs
"... Ever since Reingold’s deterministic logspace algorithm [66] for undirected graph reachability, logspace algorithms for various combinatorial problems have been discovered and it is now a flourishing area of research. Notable examples include special cases of directed graph reachability and planar gr ..."
Abstract
 Add to MetaCart
(Show Context)
Ever since Reingold’s deterministic logspace algorithm [66] for undirected graph reachability, logspace algorithms for various combinatorial problems have been discovered and it is now a flourishing area of research. Notable examples include special cases of directed graph reachability and planar graph isomorphism [23]. In this interesting article, Johannes Köbler, Sebastian Kuhnert and Oleg Verbitsky discuss the structural properties of interval graphs and other technical ingredients that go into their recent logspace isomorphism algorithm for interval graphs, along with some generalizations and new directions.
Parallel Processing Letters, ❢c World Scientific Publishing Company SYSTEMATIC DERIVATION OF TREE CONTRACTION ALGORITHMS ∗
, 2004
"... While tree contraction algorithms play an important role in efficient tree computation in parallel, it is difficult to develop such algorithms due to the strict conditions imposed on contracting operators. In this paper, we propose a systematic method of deriving efficient tree contraction algorithm ..."
Abstract
 Add to MetaCart
(Show Context)
While tree contraction algorithms play an important role in efficient tree computation in parallel, it is difficult to develop such algorithms due to the strict conditions imposed on contracting operators. In this paper, we propose a systematic method of deriving efficient tree contraction algorithms from recursive functions on trees. We identify a general recursive form that can be parallelized into efficient tree contraction algorithms, and present a derivation strategy for transforming general recursive functions to the parallelizable form. We illustrate our approach by deriving a novel parallel algorithm for the maximum connectedset sum problem on arbitrary trees, the treeversion of the wellknown maximum segment sum problem.
Abstract Dynamic Parallel Tree Contraction ∗ (Extended Abstract)
"... Parallel tree contraction has been found to be a useful and quite powerful tool for the design of a wide class of efficient graph algorithms. We propose a corresponding technique for the parallel solution of incremental problems. As our computational model, we assume a variant of the CRCW PRAM where ..."
Abstract
 Add to MetaCart
Parallel tree contraction has been found to be a useful and quite powerful tool for the design of a wide class of efficient graph algorithms. We propose a corresponding technique for the parallel solution of incremental problems. As our computational model, we assume a variant of the CRCW PRAM where we can dynamically activate processors by a forking operation. We consider a dynamic binary tree T of ≤ n nodes and unbounded depth. We describe a procedure, which we call the dynamic parallel tree contraction algorithm, which incrementally processes various parallel modification requests and queries: (1) parallel requests to add or delete leaves of T,ormodify labels of internal nodes or leaves of T, and also (2) parallel tree contraction queries which require recomputing values at specified nodes. Each modification or query is with respect to a set of nodes U in T. Our dynamic parallel tree contraction algorithm is a randomized algorithm that takes O(log(U  log n)) expected parU  log n allel time using O() processors. We give a large log(U  log n) number of applications (with the same bounds), including: (a) maintaining the usual tree properties (such as number of ancestors, preorder, etc.), (b) Eulerian tour, (c) expression evaluation, (d) least common ancestor, and (e) canonical forms of trees. Previously, there where no known parallel algorithms for incrementally maintaining and solving such problems in parallel time less than Θ(log n). In deriving our incremental algorithms, we solve a key subproblem, namely a processor activation problem, within the same asymptotic bounds, which may be useful in the