Constant Number Of Variables Research Articles

Computing a visibility polygon using few variables

We present several algorithms for computing the visibility polygon of a simple polygon P of n vertices (out of which r are reflex) from a viewpoint inside P, when P resides in read-only memory and only few working variables can be used. The first algorithm uses a constant number of variables, and outputs the vertices of the visibility polygon in O(nr¯) time, where r¯ denotes the number of reflex vertices of P that are part of the output. Whenever we are allowed to use O(s) variables, the running time decreases to O(nr2s+nlog2r) (or O(nr2s+nlogr) randomized expected time), where s∈O(logr). This is the first algorithm in which an exponential space-time trade-off for a geometric problem is obtained.

PCP Characterizations of NP: Toward a Polynomially-Small Error-Probability

This paper strengthens the low-error PCP characterization of NP, coming closer to the upper limit of the BGLR conjecture. Consider the task of verifying a written proof for the membership of a given input in an NP language. In this paper, this is achieved by making a constant number of accesses to the proof, obtaining error probability that is exponentially small in the total number of bits that are read. We show that the number of bits that are read in each access to the proof can be made as high as log β n , for any constant β < 1, where n is the length of the proof. The BGLR conjecture asserts the same for any constant β, for β smaller or equal to 1. Our results are in fact stronger, implying that the Gap-Quadratic-Solvability problem with a constant number of variables in each equation is NP-hard. That is, given a system of n quadratic equations over a field $${\mathcal{F}}$$ of size up to $$2^{\log^\beta n}$$ , where each equation depends on a constant number of variables, it is NP-hard to distinguish between the case where there is a common solution to all of the equations and the case where any assignment satisfies at most a $${2 / |\mathcal{F}|}$$ fraction of them. At the same time, our proof presents a direct construction of a low-degree test whose error-probability is exponentially small in the number of bits accessed. Such a result was previously known only relying on recursive applications of the entire PCP theorem.

Optimization of a convex program with a polynomial perturbation

We consider the problem of minimizing a convex function plus a polynomial p over a convex body K . We give an algorithm that outputs a solution x whose value is within ϵ range K ( p ) of the optimum value, where range K ( p ) = sup x ∈ K p ( x ) − inf x ∈ K p ( x ) . When p depends only on a constant number of variables, the algorithm runs in time polynomial in 1 / ϵ , the degree of p , the time to round K and the time to solve the convex program that results by setting p = 0 .

The Nonapproximability of Non-Boolean Predicates

Constraint satisfaction programs where each constraint depends on a constant number of variables have the following property: The randomized algorithm that guesses an assignment uniformly at random satisfies an expected constant fraction of the constraints. Combining constructions from interactive proof systems with harmonic analysis over finite Abelian groups, Håstad [J. ACM, 48 (2001), pp. 798--859] showed that for several constraint satisfaction programs this naive algorithm is essentially the best possible unless $P = NP$. While most of the predicates analyzed by Håstad depend on a small number of variables, Samorodnitsky and Trevisan [{\it Proceedings of the 32nd Annual ACM Symposium on Theory of Computing, Portland, OR, 2000, pp. 191--199] recently extended Håstad's result to predicates depending on an arbitrarily large, but still constant, number of Boolean variables. We combine ideas from these two constructions and prove that there exists a large class of predicates on finite non-Boolean domains such that for predicates in the class, the naive randomized algorithm that guesses a solution uniformly is essentially the best possible unless P = NP$. As a corollary, we show that it is NP-hard to approximate the Maximum k-CSP problem over domains with size d within $d^{k-2k^{1/2}} - \epsilon$, for every constant $\epsilon > 0$, unless P = NP. This lower bound extends the previously known bound for the case d = 2 and matches well with the best known upper bound, dk-1, of Serna, Trevisan, and Xhafa [Proceedings of the 15th Annual Symposium on Theoretical Aspects of Computer Science, Lecture Notes in Comput. Sci. 1373, M. Morvan, C. Meinel, and D. Krob, eds., Springer-Verlag, Berlin, 1998, pp. 488--498].

Queries and Algorithms Computable by Polynomial Time Existential Reflective Machines

We consider two kinds of reflective relational machines: the usual ones, which use first order queries, and existential reflective machines, which use only first order existential queries. We compare these two computation models. We build on already existing results for standard relational machines, obtained by Abiteboul, Pa-padimitriou and Vianu [2], so we prove only results for existential machines. First we show that for both standard and existential reflective machines the set of polynomial time computable Boolean queries consists precisely of all PSPACE computable queries. Then we go further and compare which classes of algorithms both kinds of machines represent. Unless PSPACE = P NP, there are PSPACE queries which cannot be computed by polynomial time existential reflective machines which use only polynomial amount of relational memory, while it is possible for standard reflective machines. We conclude that existential reflective machines, being equivalent in computational power to unrestricted machines, implement substantially worse algorithms than the latter. Concerning deciding P classes of structures, every fixpoint query can be evaluated by a polynomial time unrestricted reflective machine using constant number of variables, while existential reflective machines need [n/2] variables to implement the graph connectivity query. So again the algorithms represented by existential reflective machines are worse. Finally, for each k we get a characterization of the Δ k+1 p level in the polynomial time hierarchy in terms of reflective relational machines which use either P k 0 or S k p queries.