SIAM Digital Library
 
 
 

SIAM J. on Computing

BROWSE VOLUMES

Year Range: 
Issue 8 | 2010 | pp. 3441-3904
Issue 7 | 2010 | pp. 2683-3439
Issue 6 | 2010 | pp. 2113-2682 †
Issue 5 | 2010 | pp. 1667-2112
Issue 4 | 2009 | pp. 1219-1665
Issue 3 | 2009 | pp. 783-1218 †
Issue 2 | 2009 | pp. 361-782 †
Issue 1 | 2009 | pp. vii-360 *

All Journal content published prior to 1997 is part of LOCUS.

Search Issue | RSS Feeds RSS
Previous Issue Next Issue

2010

Volume 39, Issue 7, pp. 2683-3439


Approximately Counting Integral Flows and Cell-Bounded Contingency Tables

Mary Cryan, Martin Dyer, and Dana Randall

SIAM J. Comput. 39, pp. 2683-2703 (21 pages)

Online Publication Date: May 05, 2010

Full Text: | Download PDF

Show Abstract
We consider the problem of approximately counting integral flows in a network. We show that there is a fully polynomial randomized approximation scheme (FPRAS) based on volume estimation if all capacities are sufficiently large, generalizing a result of Dyer, Kannan, and Mount [Random Structures Algorithms, 10 (1997), pp. 487–506]. We apply this to approximating the number of contingency tables with prescribed cell bounds when the number of rows is constant, but the row sums, column sums, and cell bounds may be arbitrary. We provide an FPRAS for this problem via a combination of dynamic programming and volume estimation. This generalizes an algorithm of Cryan and Dyer [J. Comput. System Sci., 67 (2003), pp. 291–310] for standard contingency tables, but the analysis here is considerably more intricate.

Approximate Halfspace Range Counting

Boris Aronov and Micha Sharir

SIAM J. Comput. 39, pp. 2704-2725 (22 pages) | Cited 1 time

Online Publication Date: May 05, 2010

Full Text: | Download PDF

Show Abstract
We present a simple scheme extending the shallow partitioning data structures of Matoušek, which supports efficient approximate halfspace range-counting queries in $\mathbb{R}^d$ with relative error $\varepsilon$. Specifically, the problem is, given a set $P$ of $n$ points in $\mathbb{R}^d$, to preprocess them into a data structure that returns, for a query halfspace $h$, a number $t$ so that $(1-\varepsilon)|h\cap P|\leq t\leq(1+\varepsilon)|h\cap P|$. One of our data structures requires linear storage and $O(n^{1+\delta})$ preprocessing time, for any $\delta>0$, and answers a query in time $O(\varepsilon^{-\gamma}n^{1-1/\lfloor d/2\rfloor}2^{b\log^\ast n})$ for any $\gamma>2/\lfloor d/2\rfloor$; the choice of $\gamma$ and $\delta$ affects $b$ and the implied constants. Several variants and extensions are also discussed. As presented, the construction of the structure is mostly deterministic, except for one critical randomized step, and so are the query, storage, and preprocessing costs. The quality of approximation, for every query, is guaranteed with high probability. The construction can also be fully derandomized, at the expense of increasing preprocessing time.

An $O(1)$ RMRs Leader Election Algorithm

Wojciech Golab, Danny Hendler, and Philipp Woelfel

SIAM J. Comput. 39, pp. 2726-2760 (35 pages)

Online Publication Date: May 05, 2010

Full Text: | Download PDF

Show Abstract
The leader election problem is a fundamental coordination problem. We present leader election algorithms for multiprocessor systems where processes communicate by reading and writing shared memory asynchronously and do not fail. In particular, we consider the cache-coherent (CC) and distributed shared memory (DSM) models of such systems. We present leader election algorithms that perform a constant number of remote memory references (RMRs) in the worst case. Our algorithms use splitter-like objects [J. Anderson and M. Moir, Sci. Comput. Programming, 25 (1995), pp. 1–39; H. Attiya and A. Fouren, Theory Comput. Syst., 31 (2001), pp. 642–664] in a novel way, by organizing active processes into teams that share work. As there is an $\Omega(\log n)$ lower bound on the RMR complexity of mutual exclusion for $n$ processes using reads and writes only [H. Attiya, D. Hendler, and W. Woelfel, in Proceedings of the ACM Symposium on Theory of Computing, ACM, New York, 2008, pp. 217–226], our result separates the mutual exclusion and leader election problems in terms of RMR complexity in both the CC and DSM models. Our result also implies that any algorithm using reads, writes, and one-time test-and-set objects can be simulated by an algorithm using reads and writes with only a constant blowup of the RMR complexity; proving this is easy in the CC model but presents subtle challenges in the DSM model, as we explain later. Anderson, Herman, and Kim raise the question of whether conditional primitives such as test-and-set and compare-and-swap can be used, along with reads and writes, to solve mutual exclusion with better worst-case RMR complexity than is possible using reads and writes only [Distributed Computing, 16 (2003), pp. 75–110]. We provide a negative answer to this question in the case of implementing one-time test-and-set.

On the Implementation of Huge Random Objects

Oded Goldreich, Shafi Goldwasser, and Asaf Nussboim

SIAM J. Comput. 39, pp. 2761-2822 (62 pages) | Cited 1 time

Online Publication Date: May 05, 2010

Full Text: | Download PDF

Show Abstract
We initiate a general study of the feasibility of implementing (huge) random objects, and demonstrate its applicability to a number of areas in which random objects occur naturally. We highlight two types of measures of the quality of the implementation (with respect to the desired specification): The first type corresponds to various standard notions of indistinguishability (applied to function ensembles), whereas the second type is a novel notion that we call truthfulness. Intuitively, a truthful implementation of a random object of Type T must (always) be an object of Type T, and not merely be indistinguishable from a random object of Type T. Our formalism allows for the consideration of random objects that satisfy some fixed property (or have some fixed structure) as well as the consideration of objects supporting complex queries. For example, we consider the truthful implementation of random Hamiltonian graphs as well as supporting complex queries regarding such graphs (e.g., providing the next vertex along a fixed Hamiltonian path in such a graph).

A Better Algorithm for Random $k$-SAT

Amin Coja-Oghlan

SIAM J. Comput. 39, pp. 2823-2864 (42 pages)

Online Publication Date: May 05, 2010

Full Text: | Download PDF

Show Abstract
Let $\boldsymbol{\Phi}$ be a uniformly distributed random $k$-SAT formula with $n$ variables and $m$ clauses. We present a polynomial time algorithm that finds a satisfying assignment of $\boldsymbol{\Phi}$ with high probability for constraint densities $m/n<(1-\varepsilon_k)2^k\ln(k)/k$, where $\varepsilon_k\rightarrow0$. Previously no efficient algorithm was known to find satisfying assignments with a nonvanishing probability beyond $m/n=1.817\cdot2^k/k$ [A. Frieze and S. Suen, J. Algorithms, 20 (1996), pp. 312–355].

Faster Algorithms for All-pairs Approximate Shortest Paths in Undirected Graphs

Surender Baswana and Telikepalli Kavitha

SIAM J. Comput. 39, pp. 2865-2896 (32 pages)

Online Publication Date: May 05, 2010

Full Text: | Download PDF

Show Abstract
Let $G=(V,E)$ be a weighted undirected graph having nonnegative edge weights. An estimate $\hat{\delta}(u,v)$ of the actual distance $\delta(u,v)$ between $u,v\in V$ is said to be of stretch $t$ if and only if $\delta(u,v)\leq\hat{\delta}(u,v)\leq t\cdot\delta(u,v)$. Computing all-pairs small stretch distances efficiently (both in terms of time and space) is a well-studied problem in graph algorithms. We present a simple, novel, and generic scheme for all-pairs approximate shortest paths. Using this scheme and some new ideas and tools, we design faster algorithms for all-pairs $t$-stretch distances for a whole range of stretch $t$, and we also answer an open question posed by Thorup and Zwick in their seminal paper [J. ACM, 52 (2005), pp. 1–24].

Local Monotonicity Reconstruction

Michael Saks and C. Seshadhri

SIAM J. Comput. 39, pp. 2897-2926 (30 pages) | Cited 1 time

Online Publication Date: May 05, 2010

Full Text: | Download PDF

Show Abstract
We investigate the problem of monotonicity reconstruction, as defined by Ailon et al. (2004) in a localized setting. We have oracle access to a nonnegative real-valued function $f$ defined on the domain $[n]^d=\{1,\dots,n\}^d$ (where $d$ is viewed as a constant). We would like to closely approximate $f$ by a monotone function $g$. This should be done by a procedure (a filter) that given as input a point $x\in[n]^d$ outputs the value of $g(x)$, and runs in time that is polylogarithmic in $n$. The procedure can (indeed must) be randomized, but we require that all of the randomness be specified in advance by a single short random seed. We construct such an implementation where the time and space per query is $(\log n)^{O(1)}$ and the size of the seed is polynomial in $\log n$ and $d$. Furthermore, with high probability, the ratio of the (Hamming) distance between $g$ and $f$ to the minimum possible Hamming distance between a monotone function and $f$ is bounded above by a function of $d$ (independent of $n$). This allows for a local implementation: one can initialize many copies of the filter with the same short random seed, and they can autonomously handle queries, while producing outputs that are consistent with the same approximating function $g$.

An Efficient Algorithm for Partial Order Production

Jean Cardinal, Samuel Fiorini, Gwenaël Joret, Raphaël M. Jungers, and J. Ian Munro

SIAM J. Comput. 39, pp. 2927-2940 (14 pages)

Online Publication Date: May 05, 2010

Full Text: | Download PDF

Show Abstract
We consider the problem of partial order production: arrange the elements of an unknown totally ordered set $T$ into a target partially ordered set $S$ by comparing a minimum number of pairs in $T$. Special cases include sorting by comparisons, selection, multiple selection, and heap construction. We give an algorithm performing $ITLB+o(ITLB)+O(n)$ comparisons in the worst case. Here, $n$ denotes the size of the ground sets, and $ITLB$ denotes a natural information-theoretic lower bound on the number of comparisons needed to produce the target partial order. Our approach is to replace the target partial order by a weak order (that is, a partial order with a layered structure) extending it, without increasing the information-theoretic lower bound too much. We then solve the problem by applying an efficient multiple selection algorithm. The overall complexity of our algorithm is polynomial. This answers a question of Yao [SIAM J. Comput., 18 (1989), pp. 679–689]. We base our analysis on the entropy of the target partial order, a quantity that can be efficiently computed and provides a good estimate of the information-theoretic lower bound.

Quantum Hardcore Functions by Complexity-Theoretical Quantum List Decoding

Akinori Kawachi and Tomoyuki Yamakami

SIAM J. Comput. 39, pp. 2941-2969 (29 pages)

Online Publication Date: May 05, 2010

Full Text: | Download PDF

Show Abstract
Hardcore functions have been used as a technical tool to construct secure cryptographic systems; however, little is known on their quantum counterpart, called quantum hardcore functions. With a new insight into fundamental properties of quantum hardcores, we present three new quantum hardcore functions for any (strong) quantum one-way function. We also give a “quantum” solution to Damgård's question [Advances in Cryptology, Lecture Notes in Comput. Sci. 403, Springer, Berlin, 1990, pp. 163–172] on a classical hardcore property of his pseudorandom generator by proving its quantum hardcore property. Our major technical tool is the new notion of quantum list-decoding of “classical” error-correcting codes (rather than “quantum” error-correcting codes), which is defined on the platform of computational complexity theory and computational cryptography (rather than information theory). In particular, we give a simple but powerful criterion that makes a polynomial-time computable classical block code (seen as a function) a quantum hardcore for all quantum one-way functions. On their own interest, we construct efficient quantum list-decoding algorithms for classical block codes whose associated quantum states (called codeword states) form a nearly phase-orthogonal basis.

An Approximation Algorithm for Max-Min Fair Allocation of Indivisible Goods

Arash Asadpour and Amin Saberi

SIAM J. Comput. 39, pp. 2970-2989 (20 pages) | Cited 1 time

Online Publication Date: May 14, 2010

Full Text: | Download PDF

Show Abstract
In this paper, we give the first approximation algorithm for the problem of max-min fair allocation of indivisible goods. An instance of this problem consists of a set of $k$ people and $m$ indivisible goods. Each person has a known linear utility function over the set of goods which might be different from the utility functions of other people. The goal is to distribute the goods among the people and maximize the minimum utility received by them. The approximation ratio of our algorithm is $\Omega(\frac{1}{\sqrt{k}\log^{3}k})$. As a crucial part of our algorithm, we design and analyze an iterative method for rounding a fractional matching on a tree which might be of independent interest. We also provide better bounds when we are allowed to exclude a small fraction of the people from the problem.

Preprocessing Imprecise Points and Splitting Triangulations

Marc van Kreveld, Maarten Löffler, and Joseph S. B. Mitchell

SIAM J. Comput. 39, pp. 2990-3000 (11 pages)

Online Publication Date: June 03, 2010

Full Text: | Download PDF

Show Abstract
Traditional algorithms in computational geometry assume that the input points are given precisely. In practice, data is usually imprecise, but information about the imprecision is often available. In this context, we investigate what the value of this information is. We show here how to preprocess a set of disjoint regions in the plane of total complexity $n$ in $O(n\log n)$ time so that if one point per set is specified with precise coordinates, a triangulation of the points can be computed in linear time. In our solution, we solve another problem which we believe to be of independent interest. Given a triangulation with red and blue vertices, we show how to compute a triangulation of only the blue vertices in linear time.

Approximating Steiner Networks with Node-Weights

Zeev Nutov

SIAM J. Comput. 39, pp. 3001-3022 (22 pages)

Online Publication Date: June 09, 2010

Full Text: | Download PDF

Show Abstract
The (undirected) Steiner Network problem is as follows: given a graph $G=(V,E)$ with edge/node-weights and edge-connectivity requirements $\{r(u,v):u,v\in U\subseteq V\}$, find a minimum-weight subgraph $H$ of $G$ containing $U$ so that the $uv$-edge-connectivity in $H$ is at least $r(u,v)$ for all $u,v\in U$. The seminal paper of Jain [Combinatorica, 21 (2001), pp. 39–60], and numerous papers preceding it, considered the Edge-Weighted Steiner Network problem, with weights on the edges only, and developed novel tools for approximating minimum-weight edge-covers of several types of set functions and families. However, for the Node-Weighted Steiner Network (NWSN) problem, nontrivial approximation algorithms were known only for $0,1$ requirements. We make an attempt to change this situation by giving the first nontrivial approximation algorithm for NWSN with arbitrary requirements. Our approximation ratio for NWSN is $r_{\max}\cdot O(\ln|U|)$, where $r_{\max}=\max_{u,v\in U}r(u,v)$. This generalizes the result of Klein and Ravi [J. Algorithms, 19 (1995), pp. 104–115] for the case $r_{\max}=1$. We also give an $O(\ln|U|)$-approximation algorithm for the node-connectivity variant of NWSN (when the paths are required to be internally disjoint) for the case $r_{\max}=2$. Our results are based on a much more general approximation algorithm for the problem of finding a minimum node-weighted edge-cover of an uncrossable set-family. Finally, we give evidence that a polylogarithmic approximation ratio for NWSN with large $r_{\max}$ might not exist even for $|U|=2$ and unit weights.

Tractability and Learnability Arising from Algebras with Few Subpowers

PaweŁ Idziak, Petar Marković, Ralph McKenzie, Matthew Valeriote, and Ross Willard

SIAM J. Comput. 39, pp. 3023-3037 (15 pages)

Online Publication Date: June 09, 2010

Full Text: | Download PDF

Show Abstract
A constraint language $\Gamma$ on a finite set $A$ has been called polynomially expressive if the number of $n$-ary relations expressible by $\exists\wedge$-atomic formulas over $\Gamma$ is bounded by $\exp(O(n^k))$ for some constant $k$. It has recently been discovered that this property is characterized by the existence of a $(k+1)$-ary polymorphism satisfying certain identities; such polymorphisms are called $k$-edge operations and include Mal'cev and near-unanimity operations as special cases. We prove that if $\Gamma$ is any constraint language which, for some $k>1$, has a $k$-edge operation as a polymorphism, then the constraint satisfaction problem for $\langle\Gamma\rangle$ (the closure of $\Gamma$ under $\exists\wedge$-atomic expressibility) is globally tractable. We also show that the set of relations definable over $\Gamma$ using quantified generalized formulas is polynomially exactly learnable using improper equivalence queries.

Adaptive Local Ratio

Julián Mestre

SIAM J. Comput. 39, pp. 3038-3057 (20 pages)

Online Publication Date: June 18, 2010

Full Text: | Download PDF

Show Abstract
Local ratio is a well-known paradigm for designing approximation algorithms for combinatorial optimization problems. At a very high level, a local-ratio algorithm first decomposes the input weight function $w$ into a positive linear combination of simpler weight functions or models. Guided by this process, a solution $S$ is constructed such that $S$ is $\alpha$-approximate with respect to each model used in the decomposition. As a result, $S$ is $\alpha$-approximate under $w$ as well. These models usually have a very simple structure that remains “unchanged” throughout the execution of the algorithm. In this work we show that adaptively choosing a model from a richer spectrum of functions can lead to a better local ratio. Indeed, by turning the search for a good model into an optimization problem of its own, we get improved approximations for a data migration problem.

Chosen-Ciphertext Security via Correlated Products

Alon Rosen and Gil Segev

SIAM J. Comput. 39, pp. 3058-3088 (31 pages)

Online Publication Date: June 18, 2010

Full Text: | Download PDF

Show Abstract
We initiate the study of one-wayness under correlated products. We are interested in identifying necessary and sufficient conditions for a function $f$ and a distribution on inputs $(x_1,\dots,x_k)$ so that the function $(f(x_1),\dots,f(x_k))$ is one-way. The main motivation of this study is the construction of public-key encryption schemes that are secure against chosen-ciphertext attacks (CCAs). We show that any collection of injective trapdoor functions that is secure under a very natural correlated product can be used to construct a CCA-secure public-key encryption scheme. The construction is simple, black-box, and admits a direct proof of security. It can be viewed as a simplification of the seminal work of Dolev, Dwork, and Naor [SIAM J. Comput., 30 (2000), pp. 391–437], while relying on a seemingly incomparable assumption. We provide evidence that security under correlated products is achievable by demonstrating that lossy trapdoor functions [Peikert and Waters, Proceedings of the 40th Annual ACM Symposium on Theory of Computing, 2008, pp. 187–196] yield injective trapdoor functions that are secure under the above-mentioned correlated product. Although we currently base security under correlated products on existing constructions of lossy trapdoor functions, we argue that the former notion is potentially weaker as a general assumption. Specifically, there is no fully black-box construction of lossy trapdoor functions from trapdoor functions that are secure under correlated products.

Quantum Computation and the Evaluation of Tensor Networks

Itai Arad and Zeph Landau

SIAM J. Comput. 39, pp. 3089-3121 (33 pages)

Online Publication Date: June 24, 2010

Full Text: | Download PDF

Show Abstract
We present a quantum algorithm that additively approximates the value of a tensor network to a certain scale. When combined with existing results, this provides a complete problem for quantum computation. The result is a simple new way of looking at quantum computation in which unitary gates are replaced by tensors and time is replaced by the order in which the tensor network is “swallowed.” We use this result to derive new quantum algorithms that approximate the partition function of a variety of classical statistical mechanical models, including the Potts model.

Hardness Amplification Proofs Require Majority

Ronen Shaltiel and Emanuele Viola

SIAM J. Comput. 39, pp. 3122-3154 (33 pages)

Online Publication Date: July 08, 2010

Full Text: | Download PDF

Show Abstract
Hardness amplification is the fundamental task of converting a $\delta$-hard function $f:\{0,1\}^n\to\{0,1\}$ into a $(1/2-\epsilon)$-hard function $\mathit{Amp}(f)$, where $f$ is $\gamma$-hard if small circuits fail to compute $f$ on at least a $\gamma$ fraction of the inputs. In this paper we study the complexity of black-box proofs of hardness amplification. A class of circuits $\mathcal{D}$ proves a hardness amplification result if for any function $h$ that agrees with $\mathit{Amp}(f)$ on a $1/2+\epsilon$ fraction of the inputs there exists an oracle circuit $D\in\mathcal{D}$ such that $D^h$ agrees with $f$ on a $1-\delta$ fraction of the inputs. We focus on the case where every $D\in\mathcal{D}$ makes nonadaptive queries to $h$. This setting captures most hardness amplification techniques. We prove two main results: (1) The circuits in $\mathcal{D}$ “can be used” to compute the majority function on $1/\epsilon$ bits. In particular, when $\epsilon\leq1/\log^{\omega(1)}n$, $\mathcal{D}$ cannot consist of oracle circuits that have unbounded fan-in, size $\mathrm{poly}(n)$, and depth $O(1)$. (2) The circuits in $\mathcal{D}$ must make $\Omega\left(\log(1/\delta)/\epsilon^2\right)$ oracle queries. Both our bounds on the depth and on the number of queries are tight up to constant factors. Our results explain why hardness amplification techniques have failed to transform known lower bounds against constant-depth circuit classes into strong average-case lower bounds. Our results reveal a contrast between Yao's XOR lemma ($\mathit{Amp}(f):=f(x_1)\oplus\cdots\oplus f(x_t)\in\{0,1\}$) and the direct-product lemma ($\mathit{Amp}(f):=f(x_1)\circ\cdots\circ f(x_t)\in\{0,1\}^t$; here $\mathit{Amp}(f)$ is non-Boolean). Our results (1) and (2) apply to Yao's XOR lemma, whereas known proofs of the direct-product lemma violate both (1) and (2). One of our contributions is a new technique for handling “nonuniform” reductions, i.e., the case when $\mathcal{D}$ contains many circuits.

Approximate Hypergraph Partitioning and Applications

Eldar Fischer, Arie Matsliah, and Asaf Shapira

SIAM J. Comput. 39, pp. 3155-3185 (31 pages)

Online Publication Date: July 08, 2010

Full Text: | Download PDF

Show Abstract
Szemerédi's regularity lemma is a cornerstone result in extremal combinatorics. It (roughly) asserts that any dense graph is composed of a finite number of pseudorandom graphs. The regularity lemma has found many applications in theoretical computer science, and thus a lot of attention was given to designing algorithmic versions of this lemma. Our main results in this paper are the following: (i) We introduce a new approach to the problem of constructing regular partitions of graphs, which results in a surprisingly simple $O(n)$ time algorithmic version of the regularity lemma, thus improving over the previous $O(n^2)$ time algorithms. Furthermore, unlike all the previous approaches for this problem (see [N. Alon and A. Naor, SIAM J. Comput., 35 (2006), pp. 787–803], [R. A. Duke, H. Lefmann, and V. Rödl, SIAM J. Comput., 24 (1995), pp. 598–620], [A. Frieze and R. Kannan, Electron. J. Combin., 6 (1999), article 17], [A. Frieze and R. Kannan, “The regularity lemma and approximation schemes for dense problems,” in Proceedings of the 37th Annual Symposium on Foundations of Computer Science (Burlington, VT, 1996), IEEE Computer Society Press, Los Alamitos, CA, 1996, pp. 12–20], and [Y. Kohayakawa, V. Rödl, and L. Thoma, SIAM J. Comput., 32 (2003), pp. 1210–1235]), which only guaranteed to find tower-size partitions, our algorithm will find a small regular partition, if one exists in the graph. (ii) For any constant $r\geq3$ we give an $O(n)$ time randomized algorithm for constructing regular partitions of $r$-uniform hypergraphs, thus improving the previous $O(n^{2r-1})$ time (deterministic) algorithms [A. Czygrinow and V. Rödl, SIAM J. Comput., 30 (2000), pp. 1041–1066], [A. Frieze and R. Kannan, “The regularity lemma and approximation schemes for dense problems,” in Proceedings of the 37th Annual Symposium on Foundations of Computer Science (Burlington, VT, 1996), IEEE Computer Society Press, Los Alamitos, CA, 1996, pp. 12–20]. These two results are obtained as an application of an efficient algorithm for approximating partition problems of hypergraphs which we obtain here: Given a (directed) hypergraph with bounded edge arities, a set of constraints on the set sizes and densities of a possible partition of its vertex set, and an approximation parameter, we provide in $O(n)$ time a partition approximating the constraints if a partition satisfying them exists. We can also test in $O(1)$ time for the existence of such a partition given the approximation parameter. This algorithm extends the result of Goldreich, Goldwasser, and Ron for graph partition problems [O. Goldreich, S. Goldwasser, and D. Ron, J. ACM, 45 (1998), pp. 653–750] and encompasses more recent hypergraph-related results such as the maximal constraint satisfaction approximation of [G. Andersson and L. Engebretsen, Random Structures Algorithms, 21 (2002), pp. 14–32].

Extensional Uniformity for Boolean Circuits

Pierre McKenzie, Michael Thomas, and Heribert Vollmer

SIAM J. Comput. 39, pp. 3186-3206 (21 pages)

Online Publication Date: July 08, 2010

Full Text: | Download PDF

Show Abstract
Imposing an extensional uniformity condition on a nonuniform circuit complexity class $\mathcal{C}$ means simply intersecting $\mathcal{C}$ with a uniform class $\mathcal{L}$. By contrast, the usual intensional uniformity conditions require that a resource-bounded machine be able to exhibit the circuits in the circuit family defining $\mathcal{C}$. We say that $(\mathcal{C},\mathcal{L})$ has the uniformity duality property if the extensionally uniform class $\mathcal{C}\cap\mathcal{L}$ can be captured intensionally by means of adding so-called $\mathcal{L}$-numerical predicates to the first-order descriptive complexity apparatus describing the connection language of the circuit family defining $\mathcal{C}$. This paper exhibits positive instances and negative instances of the uniformity duality property.

Unique Games with Entangled Provers Are Easy

Julia Kempe, Oded Regev, and Ben Toner

SIAM J. Comput. 39, pp. 3207-3229 (23 pages)

Online Publication Date: July 15, 2010

Full Text: | Download PDF

Show Abstract
We consider one-round games between a classical verifier and two provers who share entanglement. We show that when the constraints enforced by the verifier are “unique” constraints (i.e., permutations), the value of the game can be well approximated by a semidefinite program (SDP). Essentially the only algorithm known previously was for the special case of binary answers, as follows from the work of Tsirelson in 1980. Among other things, our result implies that the variant of the unique games conjecture where we allow the provers to share entanglement is false. Our proof is based on a novel “quantum rounding technique,” showing how to take a solution to an SDP and transform it into a strategy for entangled provers. Using our approximation by an SDP, we also show a parallel repetition theorem for unique entangled games.

Locally Testable Codes Require Redundant Testers

Eli Ben-Sasson, Venkatesan Guruswami, Tali Kaufman, Madhu Sudan, and Michael Viderman

SIAM J. Comput. 39, pp. 3230-3247 (18 pages)

Online Publication Date: July 27, 2010

Full Text: | Download PDF

Show Abstract
Locally testable codes (LTCs) are error-correcting codes for which membership, in the code, of a given word can be tested by examining it in very few locations. Most known constructions of LTCs are linear codes and give error-correcting codes whose duals have (superlinearly) many small weight codewords. Examining this feature appears to be one of the promising approaches to proving limitation results for (i.e., upper bounds on the rate of) LTCs. Unfortunately, until now it has not even been known whether LTCs need to be nontrivially redundant, i.e., need to have one linear dependency among the low-weight codewords in their dual. In this paper we give the first lower bound of this form, by showing that every positive rate constant query strong LTC must have linearly many redundant low-weight codewords in its dual. We actually prove the stronger claim that the actual test itself must use a linear number of redundant dual codewords (beyond the minimum number of basis elements required to characterize the code); in other words, nonredundant (in fact, low redundancy) local testing is impossible. Our main theorem is a special case of a more general theorem that applies to any tester for an arbitrary linear LTC $\mathcal{C}$. The general theorem can be used, for instance, to provide an arguably simpler proof of the main result of Ben-Sasson, Harsha, and Raskhodnikova [SIAM J. Comput., 35 (2005), pp. 1–21], which says that testing random low density parity check (LDPC) codes requires linear query complexity. Informally, our more general theorem says the following. Take any basis $B$ for the dual code of $\mathcal{C}$ that is composed of words of small support; i.e., every element of $B$ has very few nonzero entries. Then the dual code of $\mathcal{C}$ must contain many words that (i) are not in $B$, (ii) have small support, and, most importantly, (iii) are a linear combination of a constant fraction of $B$.

Small-Size $\eps$-Nets for Axis-Parallel Rectangles and Boxes

Boris Aronov, Esther Ezra, and Micha Sharir

SIAM J. Comput. 39, pp. 3248-3282 (35 pages)

Online Publication Date: July 29, 2010

Full Text: | Download PDF

Show Abstract
We show the existence of $\varepsilon$-nets of size $O\left(\frac{1}{\varepsilon}\log\log\frac{1}{\varepsilon}\right)$ for planar point sets and axis-parallel rectangular ranges. The same bound holds for points in the plane and “fat” triangular ranges and for point sets in $\boldsymbol{R}^3$ and axis-parallel boxes; these are the first known nontrivial bounds for these range spaces. Our technique also yields improved bounds on the size of $\varepsilon$-nets in the more general context considered by Clarkson and Varadarajan. For example, we show the existence of $\varepsilon$-nets of size $O\left(\frac{1}{\varepsilon}\log\log\log\frac{1}{\varepsilon}\right)$ for the dual range space of “fat” regions and planar point sets (where the regions are the ground objects and the ranges are subsets stabbed by points). Plugging our bounds into the technique of Brönnimann and Goodrich or of Even, Rawitz, and Shahar, we obtain improved approximation factors (computable in expected polynomial time by a randomized algorithm) for the hitting set or the set cover problems associated with the corresponding range spaces.

Line Transversals of Convex Polyhedra in $\mathbb{R}^3$

Haim Kaplan, Natan Rubin, and Micha Sharir

SIAM J. Comput. 39, pp. 3283-3310 (28 pages) | Cited 1 time

Online Publication Date: July 29, 2010

Full Text: | Download PDF

Show Abstract
We establish a bound of $O(n^2k^{1+\varepsilon})$, for any $\varepsilon>0$, on the combinatorial complexity of the set $\mathcal{T}$ of line transversals of a collection $\mathcal{P}$ of $k$ convex polyhedra in $\mathbb{R}^3$ with a total of $n$ facets, and we present a randomized algorithm which computes the boundary of $\mathcal{T}$ in comparable expected time. Thus, when $k\ll n$, the new bounds on the complexity (and construction cost) of $\mathcal{T}$ improve upon the previously best known bounds, which are nearly cubic in $n$. To obtain the above result, we study the set $\mathcal{T}_{\ell_0}$ of line transversals which emanate from a fixed line $\ell_0$, establish an almost tight bound of $O(nk^{1+\varepsilon})$ on the complexity of $\mathcal{T}_{\ell_0}$, and provide a randomized algorithm which computes $\mathcal{T}_{\ell_0}$ in comparable expected time. Slightly improved combinatorial bounds for the complexity of $\mathcal{T}_{\ell_0}$ and comparable improvements in the cost of constructing this set are established for two special cases, both assuming that the polyhedra of $\mathcal{P}$ are pairwise disjoint: the case where $\ell_0$ is disjoint from the polyhedra of $\mathcal{P}$, and the case where the polyhedra of $\mathcal{P}$ are unbounded in a direction parallel to $\ell_0$. Our result is related to the problem of bounding the number of geometric permutations of a collection $\mathcal{C}$ of $k$ pairwise-disjoint convex sets in $\mathbb{R}^3$, namely, the number of distinct orders in which the line transversals of $\mathcal{C}$ visit its members. We obtain a new partial result on this problem.

Server Scheduling to Balance Priorities, Fairness, and Average Quality of Service

Nikhil Bansal and Kirk R. Pruhs

SIAM J. Comput. 39, pp. 3311-3335 (25 pages)

Online Publication Date: July 29, 2010

Full Text: | Download PDF

Show Abstract
Often server systems do not implement the best known algorithms for optimizing average Quality of Service (QoS) out of concern that these algorithms may be insufficiently fair to individual jobs. The standard method for balancing average QoS and fairness is to optimize the $\ell_p$ norm, $1<p<\infty$. Thus we consider server scheduling strategies to optimize the $\ell_p$ norms of the standard QoS measures, flow and stretch. We first show that there is no $n^{o(1)}$-competitive online algorithm for the $\ell_p$ norms of either flow or stretch. We then show that the standard clairvoyant algorithms for optimizing average QoS, Shortest Job First (SJF), and Shortest Remaining Processing Time (SRPT), are scalable for the $\ell_p$ norms of flow and stretch. We then show that the standard nonclairvoyant algorithm for optimizing average QoS, Shortest Elapsed Time First (SETF), is also scalable for the $\ell_p$ norms of flow. We then show that the online algorithm, Highest Density First (HDF), and the nonclairvoyant algorithm, Weighted Shortest Elapsed Time First (WSETF), are scalable for the weighted $\ell_p$ norms of flow. These results suggest that the concern that these standard algorithms may unnecessarily starve jobs is unfounded. In contrast, we show that the Round Robin, or Processor Sharing, algorithm, which is sometimes adopted because of its seeming fairness properties, is not $O(1+\epsilon)$-speed, $n^{o(1)}$-competitive for sufficiently small $\epsilon$.

A Complexity Dichotomy for Partition Functions with Mixed Signs

Leslie Ann Goldberg, Martin Grohe, Mark Jerrum, and Marc Thurley

SIAM J. Comput. 39, pp. 3336-3402 (67 pages)

Online Publication Date: August 05, 2010

Full Text: | Download PDF

Show Abstract
Partition functions, also known as homomorphism functions, form a rich family of graph invariants that contain combinatorial invariants such as the number of $k$-colorings or the number of independent sets of a graph and also the partition functions of certain “spin glass” models of statistical physics such as the Ising model. Building on earlier work by Dyer and Greenhill [Random Structures Algorithms, 17 (2000), pp. 260–289] and Bulatov and Grohe [Theoret. Comput. Sci., 348 (2005), pp. 148–186], we completely classify the computational complexity of partition functions. Our main result is a dichotomy theorem stating that every partition function is either computable in polynomial time or #P-complete. Partition functions are described by symmetric matrices with real entries, and we prove that it is decidable in polynomial time in terms of the matrix whether a given partition function is in polynomial time or #P-complete. While in general it is very complicated to give an explicit algebraic or combinatorial description of the tractable cases, for partition functions described by Hadamard matrices (these turn out to be central in our proofs) we obtain a simple algebraic tractability criterion, which says that the tractable cases are those “representable” by a quadratic polynomial over the field $\mathbb{F}_2$.

Fault Tolerant Spanners for General Graphs

S. Chechik, M. Langberg, D. Peleg, and L. Roditty

SIAM J. Comput. 39, pp. 3403-3423 (21 pages)

Online Publication Date: August 10, 2010

Full Text: | Download PDF

Show Abstract
This paper concerns graph spanners that are resistant to vertex or edge failures. In the failure-free setting, it is known how to efficiently construct a $(2k-1)$-spanner of size $O(n^{1+1/k})$, and this size-stretch trade-off is conjectured to be tight. The notion of fault tolerant spanners was introduced a decade ago in the geometric setting [C. Levcopoulos, G. Narasimhan, and M. Smid, in Proceedings of the 30th Annual ACM Symposium on Theory of Computing, 1998, pp. 186–195]. A subgraph $H$ is an $f$-vertex fault tolerant $k$-spanner of the graph $G$ if for any set $F\subseteq V$ of size at most $f$ and any pair of vertices $u,v\in V\setminus F$, the distances in $H$ satisfy $\delta_{H\setminus F}(u,v)\leq k\cdot\delta_{G\setminus F}(u,v)$. A fault tolerant geometric spanner with optimal maximum degree and total weight was presented in [A. Czumaj and H. Zhao, Discrete Comput. Geom., 32 (2004), pp. 207–230]. This paper also raised as an open problem the question of whether it is possible to obtain a fault tolerant spanner for an arbitrary undirected weighted graph. The current paper answers this question in the affirmative, presenting an $f$-vertex fault tolerant $(2k-1)$-spanner of size $O(f^{2}k^{f+1}\cdot n^{1+1/k}\log^{1-1/k}n)$. Interestingly, the stretch of the spanner remains unchanged, while the size of the spanner increases only by a factor that depends on the stretch $k$, on the number of potential faults $f$, and on logarithmic terms in $n$. In addition, we consider the simpler setting of $f$-edge fault tolerant spanners (defined analogously). We present an $f$-edge fault tolerant $(2k-1)$-spanner with edge set of size $O(f\cdot n^{1+1/k})$ (only $f$ times larger than standard spanners). For both edge and vertex faults, our results are shown to hold when the given graph $G$ is weighted.

Left-to-Right Multiplication for Monotone Boolean Dualization

Endre Boros, Khaled Elbassioni, and Kazuhisa Makino

SIAM J. Comput. 39, pp. 3424-3439 (16 pages)

Online Publication Date: August 12, 2010

Full Text: | Download PDF

Show Abstract
Given the prime conjunctive normal form (CNF) representation $\phi$ of a monotone Boolean function $f:\{0,1\}^n\to\{0,1\}$, the dualization problem calls for finding the corresponding prime disjunctive normal form representation $\psi$ of $f$. A very simple method works by multiplying out the clauses of $\phi$ from left to right in some order, simplifying whenever possible by using the absorption law. We show that for any monotone CNF $\phi$, left-to-right multiplication can be done in subexponential time, and for many interesting subclasses of monotone CNFs such as those with bounded size, bounded degree, bounded intersection, bounded conformality, and read-once formula, it can be done in polynomial or quasi-polynomial time.
Close

Your Recent History Recent History Help

Recently Viewed

  1. Programmable Control of Nucleation for Algorithmic Self-Assembly
  2. Faster Integer Multiplication
  3. Statistically Hiding Commitments and Statistical Zero-Knowledge Arguments from Any One-Way Function
  4. Stateless Distributed Gradient Descent for Positive Linear Programs
  5. A 2EXPTIME Complete Varietal Membership Problem
© SIAM By using SIAM Publications Online you agree to abide by the Terms and Conditions of Use. Banner art adapted from a figure by Hinke M. Osinga and Bernd Krauskopf (University of Bristol, UK).
close