On Parsimonious Explanations For 2-D Tree- and Linearly-Ordered Data

This paper studies the ``explanation problem\u27\u27 for tree- and linearly-ordered array data, a problem motivated by database applications and recently solved for the one-dimensional tree-ordered case. In this paper, one is given a matrix A=(a_{ij}) whose rows and columns have semantics: special subsets of the rows and special subsets of the columns are meaningful, others are not. A submatrix in A is said to be meaningful if and only if it is the cross product of a meaningful row subset and a meaningful column subset, in which case we call it an ``allowed rectangle.\u27\u27 The goal is to ``explain\u27\u27 A as a sparse sum of weighted allowed rectangles. Specifically, we wish to find as few weighted allowed rectangles as possible such that, for all i,j, a_ij equals the sum of the weights of all rectangles which include cell (i,j). In this paper we consider the natural cases in which the matrix dimensions are tree-ordered or linearly-ordered. In the tree-ordered case, we are given a rooted tree $T_1$ whose leaves are the rows of $A$ and another, $T_2$, whose leaves are the columns. Nodes of the trees correspond in an obvious way to the sets of their leaf descendants. In the linearly-ordered case, a set of rows or columns is meaningful if and only if it is contiguous. For tree-ordered data, we prove the explanation problem NP-Hard and give a randomized $2$-approximation algorithm for it. For linearly-ordered data, we prove the explanation problem NP-Har and give a $2.56$-approximation algorithm. To our knowledge, these are the first results for the problem of sparsely and exactly representing matrices by weighted rectangles

Lower Bounds for Linear Locally Decodable Codes and Private Information Retrieval

We prove that if a linear error-correcting code C: {0, 1}^n → {0, 1}^m is such that a bit of the message can be probabilistically reconstructed by looking at two entries of a corrupted codeword, then m = 2^(Ω(n)). We also present several extensions of this result. We show a reduction from the complexity, of one-round, information-theoretic private information retrieval systems (with two servers) to locally decodable codes, and conclude that if all the servers' answers are linear combinations of the database content, then t = Ω(n/2^a), where t is the length of the user's query and a is the length of the servers' answers. Actually, 2^a can be replaced by O(a^k), where k is the number of bit locations in the answer that are actually inspected in the reconstruction

Improved Approximation Algorithms for PRIZE-COLLECTING STEINER TREE and TSP

Abstract — We study the prize-collecting versions of the Steiner tree, traveling salesman, and stroll (a.k.a. PATH-TSP) problems (PCST, PCTSP, and PCS, respectively): given a graph (V, E) with costs on each edge and a penalty (a.k.a. prize) on each node, the goal is to find a tree (for PCST), cycle (for PCTSP), or stroll (for PCS) that minimizes the sum of the edge costs in the tree/cycle/stroll and the penalties of the nodes not spanned by it. In addition to being a useful theoretical tool for helping to solve other optimization problems, PCST has been applied fruitfully by AT&T to the optimization of real-world telecommunications networks. The most recent improvements for the first two problems, giving a 2-approximation algorithm for each, appeared first in 1992. (A 2-approximation for PCS appeared in 2003.) The natural linear programming (LP) relaxation of PCST has an integrality gap of 2, which has been a barrier to further improvements for this problem. We present (2 − ɛ)-approximation algorithms for all three problems, connected by a unified technique for improving prizecollecting algorithms that allows us to circumvent the integrality gap barrier. 1

Competitive Algorithms for Layered Graph Traversal

A layered graph is a connected graph whose vertices are partitioned into sets L0=s, L1, L2,..., and whose edges, which have nonnegative integral weights, run between consecutive layers. Its width is {|Li|}. In the on-line layered graph traversal problem, a searcher starts at s in a layered graph of unknown width and tries to reach a target vertex t; however, the vertices in layer i and the edges between layers i-1 and i are only revealed when the searcher reaches layer i-1. We give upper and lower bounds on the competitive ratio of layered graph traversal algorithms. We give a deterministic on-line algorithm which is O(9w)-competitive on width-w graphs and prove that for no w can a deterministic on-line algorithm have a competitive ratio better than 2w-2 on width-w graphs. We prove that for all w, w/2 is a lower bound on the competitive ratio of any randomized on-line layered graph traversal algorithm. For traversing layered graphs consisting of w disjoint paths tied together at a common source, we give a randomized on-line algorithm with a competitive ratio of O(log w) and prove that this is optimal up to a constant factor

Weighted Matchings via Unweighted Augmentations

We design a generic method for reducing the task of finding weighted matchings to that of finding short augmenting paths in unweighted graphs. This method enables us to provide efficient implementations for approximating weighted matchings in the streaming model and in the massively parallel computation (MPC) model. In the context of streaming with random edge arrivals, our techniques yield a $(1/2+c)$-approximation algorithm thus breaking the natural barrier of $1/2$. For multi-pass streaming and the MPC model, we show that any algorithm computing a $(1-\delta)$-approximate unweighted matching in bipartite graphs can be translated into an algorithm that computes a $(1-\varepsilon(\delta))$-approximate maximum weighted matching. Furthermore, this translation incurs only a constant factor (that depends on $\varepsilon> 0$) overhead in the complexity. Instantiating this with the current best multi-pass streaming and MPC algorithms for unweighted matchings yields the following results for maximum weighted matchings: * A $(1-\varepsilon)$-approximation streaming algorithm that uses $O_\varepsilon(1)$ passes and $O_\varepsilon(n\, \text{poly} (\log n))$ memory. This is the first $(1-\varepsilon)$-approximation streaming algorithm for weighted matchings that uses a constant number of passes (only depending on $\varepsilon$). * A $(1 - \varepsilon)$-approximation algorithm in the MPC model that uses $O_\varepsilon(\log \log n)$ rounds, $O(m/n)$ machines per round, and $O_\varepsilon(n\, \text{poly}(\log n))$ memory per machine. This improves upon the previous best approximation guarantee of $(1/2-\varepsilon)$ for weighted graphs

ObliDC: An SGX-based oblivious distributed computing framework with formal proof

AXA Research Fund Singapor

Linear programming

To this reviewer’s knowledge, this is the first book accessible to the upper division undergraduate or beginning graduate student that surveys linear programming from the Simplex Method…via the Ellipsoid algorithm to Karmarkar’s algorithm. Moreover, its point of view is algorithmic and thus it provides both a history and a case history of work in complexity theory. The presentation is admirable; Karloff's style is informal (even humorous at times) without sacrificing anything necessary for understanding. Diagrams (including horizontal brackets that group terms) aid in providing clarity. The end-of-chapter notes are helpful...Recommended highly for acquisition, since it is not only a textbook, but can also be used for independent reading and study. —Choice Reviews The reader will be well served by reading the monograph from cover to cover. The author succeeds in providing a concise, readable, understandable introduction to modern linear programming. —Mathematics of Computing This is a textbook intended for advanced undergraduate or graduate students. It contains both theory and computational practice. After preliminary discussion of linear algebra and geometry, it describes the simplex algorithm, duality, the ellipsoid algorithm (Khachiyan’s algorithm) and Karmarkar’s algorithm. —Zentralblatt Math The exposition is clear and elementary; it also contains many exercises and illustrations. —Mathematical Reviews A self-contained, concise mathematical introduction to the theory of linear programming. —Journal of Economic Literature

On Construction of k-wise Independent Random Variables

A 0-1 probability space is a probability space(\Omega ; 2\Omega ; P ), where the sample space\Omega ` f0; 1g n for some n. A probability space is k-wise independent if, when Y i is defined to be the ith coordinate of the random n-vector, then any subset of k of the Y i 's is (mutually) independent, and it is said to be a probability space for p1 ; p2 ; :::; pn if P [Y i = 1] = p i . We study constructions of k-wise independent 0-1 probability spaces in which the p i 's are arbitrary. It was known that for any p1 ; p2 ; :::; pn , a k-wise independent probability space of size m(n;k) = \Gamma n k \Delta + \Gamma n k\Gamma1 \Delta + \Gamma n k\Gamma2 \Delta + \Delta \Delta \Delta + \Gamma n 0 \Delta always exists. We prove that for some p1 ; p2 ; :::; pn 2 [0; 1], m(n;k) is a lower bound on the size of any k-wise independent 0-1 probability space. For each fixed k, we prove that every k-wise independent 0-1 probability space for all p i = k=n has size\Omega\Gamma n ..