• arXiv.cs.CC Pub Date : 2020-01-17
S. Cliff Liu

We give a simpler derandomization of the best known $k$-SAT algorithm PPSZ [FOCS'97, JACM'05] for $k$-SAT with \emph{sub-exponential} number of solutions. The existing derandomization uses a complicated construction of small sample space, while we only use \emph{hashing}. Our algorithm and theorem also have a nice byproduct: It outperforms the current fastest deterministic $k$-SAT algorithm when the formula has \emph{moderately exponential} number of solutions.

更新日期：2020-01-22
• arXiv.cs.CC Pub Date : 2020-01-19
Christophe Crespelle; Pål Grønås Drange; Fedor V. Fomin; Petr A. Golovach

The survey provides an overview of the developing area of parameterized algorithms for graph modification problems. We concentrate on edge modification problems, where the task is to change a small number of adjacencies in a graph in order to satisfy some required property.

更新日期：2020-01-22
• arXiv.cs.CC Pub Date : 2020-01-20
Moshiur R. Farazi; Salman H. Khan; Nick Barnes

Visual Question Answering (VQA) has emerged as a Visual Turing Test to validate the reasoning ability of AI agents. The pivot to existing VQA models is the joint embedding that is learned by combining the visual features from an image and the semantic features from a given question. Consequently, a large body of literature has focused on developing complex joint embedding strategies coupled with visual attention mechanisms to effectively capture the interplay between these two modalities. However, modelling the visual and semantic features in a high dimensional (joint embedding) space is computationally expensive, and more complex models often result in trivial improvements in the VQA accuracy. In this work, we systematically study the trade-off between the model complexity and the performance on the VQA task. VQA models have a diverse architecture comprising of pre-processing, feature extraction, multimodal fusion, attention and final classification stages. We specifically focus on the effect of "multi-modal fusion" in VQA models that is typically the most expensive step in a VQA pipeline. Our thorough experimental evaluation leads us to two proposals, one optimized for minimal complexity and the other one optimized for state-of-the-art VQA performance.

更新日期：2020-01-22
• arXiv.cs.CC Pub Date : 2017-08-11
Mike S. PatersonUniversity of Warwick

Any monotone Boolean circuit computing the $n$-dimensional Boolean convolution requires at least $n^2$ and-gates. This precisely matches the obvious upper bound.

更新日期：2020-01-22
• arXiv.cs.CC Pub Date : 2018-02-23
Andreas Emil Feldmann; Daniel Marx

In this paper we study the hardness of the k-Center problem on inputs that model transportation networks. For the problem, an edge-weighted graph $G=(V,E)$ and an integer $k$ are given and a center set $C\subseteq V$ needs to be chosen such that $|C|\leq k$. The aim is to minimize the maximum distance of any vertex in the graph to the closest center. This problem arises in many applications of logistics, and thus it is natural to consider inputs that model transportation networks. Such inputs are often assumed to be planar graphs, low doubling metrics, or bounded highway dimension graphs. For each of these models, parameterized approximation algorithms have been shown to exist. We complement these results by proving that the k-Center problem is W[1]-hard on planar graphs of constant doubling dimension, where the parameter is the combination of the number of centers $k$, the highway dimension $h$, and even the treewidth $t$. Moreover, under the Exponential Time Hypothesis there is no $f(k,t,h)\cdot n^{o(t+\sqrt{k+h})}$ time algorithm for any computable function $f$. Thus it is unlikely that the optimum solution to k-Center can be found efficiently, even when assuming that the input graph abides to all of the above models for transportation networks at once! Additionally we give a simple parameterized $(1+\varepsilon)$-approximation algorithm for inputs of doubling dimension $d$ with runtime $(k^k/\varepsilon^{O(kd)})\cdot n^{O(1)}$. This generalizes a previous result, which considered inputs in $D$-dimensional $L_q$ metrics.

更新日期：2020-01-22
• arXiv.cs.CC Pub Date : 2018-03-27
Zhaosong Lu; Zirui Zhou

In this paper we consider a class of convex conic programming. In particular, we propose an inexact augmented Lagrangian (I-AL) method for solving this problem, in which the augmented Lagrangian subproblems are solved approximately by a variant of Nesterov's optimal first-order method. We show that the total number of first-order iterations of the proposed I-AL method for computing an $\epsilon$-KKT solution is at most $\mathcal{O}(\epsilon^{-7/4})$. We also propose a modified I-AL method and show that it has an improved iteration-complexity $\mathcal{O}(\epsilon^{-1}\log\epsilon^{-1})$, which is so far the lowest complexity bound among all first-order I-AL type of methods for computing an $\epsilon$-KKT solution. Our complexity analysis of the I-AL methods is mainly based on an analysis on inexact proximal point algorithm (PPA) and the link between the I-AL methods and inexact PPA. It is substantially different from the existing complexity analyses of the first-order I-AL methods in the literature, which typically regard the I-AL methods as an inexact dual gradient method. Compared to the mostly related I-AL methods \cite{Lan16}, our modified I-AL method is more practically efficient and also applicable to a broader class of problems.

更新日期：2020-01-22
• arXiv.cs.CC Pub Date : 2019-02-19
Olivier Bournez; Sabrina Ouazzani

We consider Continuous Ordinary Differential Equations (CODE) y'=f(y), where f is a continuous function. They are known to always have solutions for a given initial condition y(0)=y0, these solutions being possibly non unique. We restrict to our attention to a class of continuous functions, that we call greedy: they always admit unique greedy solutions, i.e. going in greedy way in some fixed direction. We prove that they can be seen as models of computation over the ordinals and conversely in a very strong sense. In particular, for such ODEs, to a greedy trajectory can be associated some ordinal corresponding to some time of computation, and conversely models of computation over the ordinals can be associated to some CODE. In particular, analyzing reachability for one or the other concept with respect to greedy trajectories has the same hardness. This also brings new perspectives on analysis in Mathematics, by providing ways to translate results for ITTMs to CODEs. This also extends some recent results about the relations between ordinary differential equations and Turing machines, and more widely with (generalized) computability theory.

更新日期：2020-01-22
• arXiv.cs.CC Pub Date : 2019-05-13
Stefan Jaax; Stefan Kiefer

We analyze affine reachability problems in dimensions 1 and 2. On the one hand, we show that the reachability problem for 1-register machines over the integers with affine updates is PSPACE-hard, hence PSPACE-complete, strengthening a result by Finkel et al. that required polynomial updates. On the other hand, motivated by tight connections with 1-dimensional affine reachability problems without control states, we study algorithmic problems in finitely generated semigroups of 2-dimensional upper-triangular integer matrices. Building on a variety of techniques from recent years, we obtain a number of complexity results, including NP-completeness of the mortality problem for matrices with determinants +1 and 0.

更新日期：2020-01-22
• arXiv.cs.CC Pub Date : 2019-07-04
Rasoul Ramezanian

We introduce an axiomatization for the notion of computation. Based on the idea of Brouwer choice sequences, we construct a model, denoted by $E$, which satisfies our axioms and $E \models \mathrm{ P \neq NP}$. In other words, regarding "effective computability" in Brouwer intuitionism viewpoint, we show $\mathrm{ P \neq NP}$.

更新日期：2020-01-22
• arXiv.cs.CC Pub Date : 2019-11-13
Paul W. Goldberg; Alexandros Hollender; Warut Suksompong

We study the fair allocation of a cake, which serves as a metaphor for a divisible resource, under the requirement that each agent should receive a contiguous piece of the cake. While it is known that no finite envy-free algorithm exists in this setting, we exhibit efficient algorithms that produce allocations with low envy among the agents. We then establish NP-hardness results for various decision problems on the existence of envy-free allocations, such as when we fix the ordering of the agents or constrain the positions of certain cuts. In addition, we consider a discretized setting where indivisible items lie on a line and show a number of hardness results extending and strengthening those from prior work. Finally, we investigate connections between approximate and exact envy-freeness, as well as between continuous and discrete cake cutting.

更新日期：2020-01-22
• arXiv.cs.CC Pub Date : 2019-11-18
Bas Lodewijks

We discuss several mappings from well-known NP-hard problems to Quadratic Unconstrained Binary Optimisation problems which are treated incorrectly by Lucas. We provide counterexamples and correct the mappings. We also extend the body of QUBO formulations of NP-complete and NP-hard optimisation problems by discussing additional problems.

更新日期：2020-01-22
• arXiv.cs.CC Pub Date : 2020-01-15
João F. Doriguello; Ashley Montanaro

In this work we revisit the Boolean Hidden Matching communication problem, which was the first communication problem in the one-way model to demonstrate an exponential classical-quantum communication separation. In this problem, Alice's bits are matched into pairs according to a partition that Bob holds. These pairs are compressed using a Parity function and it is promised that the final bit-string is equal either to another bit-string Bob holds, or its complement. The problem is to decide which case is the correct one. Here we generalize the Boolean Hidden Matching problem by replacing the parity function with an arbitrary function $f$. Efficient communication protocols are presented depending on the sign-degree of $f$. If its sign-degree is less than or equal to 1, we show an efficient classical protocol. If its sign-degree is less than or equal to $2$, we show an efficient quantum protocol. We then completely characterize the classical hardness of all symmetric functions $f$ of sign-degree greater than or equal to $2$, except for one family of specific cases. We also prove, via Fourier analysis, a classical lower bound for any function $f$ whose pure high degree is greater than or equal to $2$. Similarly, we prove, also via Fourier analysis, a quantum lower bound for any function $f$ whose pure high degree is greater than or equal to $3$. These results give a large family of new exponential classical-quantum communication separations.

更新日期：2020-01-17
• arXiv.cs.CC Pub Date : 2020-01-15
Lars Jaffke; Mateus de Oliveira Oliveira; Hans Raj Tiwary

It can be shown that each permutation group $G \sqsubseteq S_n$ can be embedded, in a well defined sense, in a connected graph with $O(n+|G|)$ vertices. Some groups, however, require much fewer vertices. For instance, $S_n$ itself can be embedded in the $n$-clique $K_n$, a connected graph with n vertices. In this work, we show that the minimum size of a context-free grammar generating a finite permutation group $G \sqsubseteq S_n$ can be upper bounded by three structural parameters of connected graphs embedding $G$: the number of vertices, the treewidth, and the maximum degree. More precisely, we show that any permutation group $G \sqsubseteq S_n$ that can be embedded into a connected graph with $m$ vertices, treewidth k, and maximum degree $\Delta$, can also be generated by a context-free grammar of size $2^{O(k\Delta\log\Delta)}\cdot m^{O(k)}$. By combining our upper bound with a connection between the extension complexity of a permutation group and the grammar complexity of a formal language, we also get that these permutation groups can be represented by polytopes of extension complexity $2^{O(k \Delta\log \Delta)}\cdot m^{O(k)}$. The above upper bounds can be used to provide trade-offs between the index of permutation groups, and the number of vertices, treewidth and maximum degree of connected graphs embedding these groups. In particular, by combining our main result with a celebrated $2^{\Omega(n)}$ lower bound on the grammar complexity of the symmetric group $S_n$ we have that connected graphs of treewidth $o(n/\log n)$ and maximum degree $o(n/\log n)$ embedding subgroups of $S_n$ of index $2^{cn}$ for some small constant $c$ must have $n^{\omega(1)}$ vertices. This lower bound can be improved to exponential on graphs of treewidth $n^{\varepsilon}$ for $\varepsilon<1$ and maximum degree $o(n/\log n)$.

更新日期：2020-01-17
• arXiv.cs.CC Pub Date : 2020-01-16
Marc Hellmuth; Carsten R. Seemann; Peter F. Stadler

Binary relations derived from labeled rooted trees play an import role in mathematical biology as formal models of evolutionary relationships. The (symmetrized) Fitch relation formalizes xenology as the pairs of genes separated by at least one horizontal transfer event. As a natural generalization, we consider symmetrized Fitch maps, that is, symmetric maps $\varepsilon$ that assign a subset of colors to each pair of vertices in $X$ and that can be explained by a tree $T$ with edges that are labeled with subsets of colors in the sense that the color $m$ appears in $\varepsilon(x,y)$ if and only if $m$ appears in a label along the unique path between $x$ and $y$ in $T$. We first give an alternative characterization of the monochromatic case and then give a characterization of symmetrized Fitch maps in terms of compatibility of a certain set of quartets. We show that recognition of symmetrized Fitch maps is NP-complete but FPT in general. In the restricted case where $|\varepsilon(x,y)|\leq 1$ the problem becomes polynomial, since such maps coincide with class of monochromatic Fitch maps whose graph-representations form precisely the class of complete multi-partite graphs.

更新日期：2020-01-17
• arXiv.cs.CC Pub Date : 2018-12-19
Matthew Stephenson; Jochen Renz; Xiaoyu Ge

The physics-based simulation game Angry Birds has been heavily researched by the AI community over the past five years, and has been the subject of a popular AI competition that is currently held annually as part of a leading AI conference. Developing intelligent agents that can play this game effectively has been an incredibly complex and challenging problem for traditional AI techniques to solve, even though the game is simple enough that any human player could learn and master it within a short time. In this paper we analyse how hard the problem really is, presenting several proofs for the computational complexity of Angry Birds. By using a combination of several gadgets within this game's environment, we are able to demonstrate that the decision problem of solving general levels for different versions of Angry Birds is either NP-hard, PSPACE-hard, PSPACE-complete or EXPTIME-hard. Proof of NP-hardness is by reduction from 3-SAT, whilst proof of PSPACE-hardness is by reduction from True Quantified Boolean Formula (TQBF). Proof of EXPTIME-hardness is by reduction from G2, a known EXPTIME-complete problem similar to that used for many previous games such as Chess, Go and Checkers. To the best of our knowledge, this is the first time that a single-player game has been proven EXPTIME-hard. This is achieved by using stochastic game engine dynamics to effectively model the real world, or in our case the physics simulator, as the opponent against which we are playing. These proofs can also be extended to other physics-based games with similar mechanics.

更新日期：2020-01-17
• arXiv.cs.CC Pub Date : 2019-04-29
Thomas Bläsius; Philipp Fischbeck; Tobias Friedrich; Maximilian Katzmann

The VertexCover problem is proven to be computationally hard in different ways: It is NP-complete to find an optimal solution and even NP-hard to find an approximation with reasonable factors. In contrast, recent experiments suggest that on many real-world networks the run time to solve VertexCover is way smaller than even the best known FPT-approaches can explain. Similarly, greedy algorithms deliver very good approximations to the optimal solution in practice. We link these observations to two properties that are observed in many real-world networks, namely a heterogeneous degree distribution and high clustering. To formalize these properties and explain the observed behavior, we analyze how a branch-and-reduce algorithm performs on hyperbolic random graphs, which have become increasingly popular for modeling real-world networks. In fact, we are able to show that the VertexCover problem on hyperbolic random graphs can be solved in polynomial time, with high probability. The proof relies on interesting structural properties of hyperbolic random graphs. Since these predictions of the model are interesting in their own right, we conducted experiments on real-world networks showing that these properties are also observed in practice. When utilizing the same structural properties in an adaptive greedy algorithm, further experiments suggest that, on real instances, this leads to better approximations than the standard greedy approach within reasonable time.

更新日期：2020-01-17
• arXiv.cs.CC Pub Date : 2020-01-15
Marie Louisa Tølbøll Berthelsen; Kristoffer Arnsfelt Hansen

We study the computational complexity of decision problems about Nash equilibria in $m$-player games. Several such problems have recently been shown to be computationally equivalent to the decision problem for the existential theory of the reals, or stated in terms of complexity classes, $\exists\mathbb{R}$-complete, when $m\geq 3$. We show that, unless they turn into trivial problems, they are $\exists\mathbb{R}$-hard even for 3-player zero-sum games. We also obtain new results about several other decision problems. We show that when $m\geq 3$ the problems of deciding if a game has a Pareto optimal Nash equilibrium or deciding if a game has a strong Nash equilibrium are $\exists\mathbb{R}$-complete. The latter result rectifies a previous claim of NP-completeness in the literature. We show that deciding if a game has an irrational valued Nash equilibrium is $\exists\mathbb{R}$-hard, answering a question of Bil\o and Mavronicolas, and address also the computational complexity of deciding if a game has a rational valued Nash equilibrium. These results also hold for 3-player zero-sum games. Our proof methodology applies to corresponding decision problems about symmetric Nash equilibria in symmetric games as well, and in particular our new results carry over to the symmetric setting. Finally we show that deciding whether a symmetric $m$-player games has a non-symmetric Nash equilibrium is $\exists\mathbb{R}$-complete when $m\geq 3$, answering a question of Garg, Mehta, Vazirani, and Yazdanbod.

更新日期：2020-01-16
• arXiv.cs.CC Pub Date : 2020-01-15
Tomoyuki Yamakami

Quantum computation has emerged as a powerful computational medium of our time, having demonstrated the efficiency in solving the integer factoring and searching a database faster than any currently known classical computer algorithm. Adiabatic evolution of quantum systems have been studied as a potential means that physically realizes quantum computation. Up to now, all the research on adiabatic quantum systems has dealt with polynomial time-bounded computation and little attention has been paid to, for example, adiabatic quantum systems consuming only constant memory space. Such quantum systems can be modeled in a form similar to quantum finite automata. This exposition dares to ask a bold question of how to make adiabatic quantum computation fit into the rapidly progressing framework of quantum automata theory. As our answer to this eminent but profound question, we first lay out a fundamental platform for adiabatic evolutionary quantum systems (AEQSs) with limited computational resources and then establish how to construct AEQSs using quantum finite automata. We also explore fundamental structural properties of decision problems (or equivalently, languages) solved quickly by such AEQSs.

更新日期：2020-01-16
• arXiv.cs.CC Pub Date : 2014-08-22
Latif Salum

This paper shows that $\mathbf{P} = \mathbf{NP}$ by means of one-in-three SAT, also known as exactly-1 3SAT, or X3SAT. $\phi = \bigwedge C_k$ denotes an X3SAT formula, $C_k = (r_i \odot r_j \odot r_u)$ is a clause, and $\phi(r_j) := r_j \wedge \phi$ denotes the truth assignment $r_j = \mathbf{T}$, $r_j \in \{x_j, \overline{x}_j\}$. The assignment initiates reductions via $\odot$ of $C_k = (r_j \odot \overline{x}_i \odot x_u)$ into $\psi_k = r_j \wedge x_i \wedge \overline{x}_u$ for all $C_k \ni r_j$, and $C_k = (\overline{r}_j \odot r_u \odot r_v)$ into $C_{k'} = (r_u \odot r_v)$ for all $C_k \ni \overline{r}_j$. These reductions transform $r_j \wedge \phi$ into $\psi(r_j) \wedge \phi'(r_j)$, unless $\psi(r_j)$ involves a contradiction $x_i \wedge \overline{x}_i$. Then, $\phi'(r_j) = \bigwedge (C_k \wedge C_{k'})$, and $\psi(r_j) = \bigwedge (\psi_k \wedge C_{k'})$ such that $C_{k'} = r_i$, thus $\psi(r_j)$ and $\phi'(r_j)$ are disjoint. Also, $\psi(r_j)$ involves $x_i \wedge \overline{x}_i$ iff $\not\models \psi(r_j)$, which is trivial to verify. Furthermore, it is redundant to check if $\not\models \phi'(r_j)$, sketched out as follows. Any $\psi(r_i)$ is true, $\psi(r_i) \models \psi(r_i | r_j)$, hence $\psi(r_i | r_j)$ is true for all $r_i$ in $\phi'(r_j)$, which becomes satisfiable when any $r_j$ such that $\not\models \psi(r_j)$ is removed from $\phi$, hence any $\overline{r}_j$ is in $\psi$. Thus, $\phi$ transforms into $\psi \wedge \phi'$, where $\psi = \bigwedge r_i$. If $\psi \supseteq \{x_j, \overline{x}_j\}$, then $\not\models \phi$, or else $\phi(r_i) = \psi(r_i) \wedge \phi'(r_i)$ reduces to $\psi(r_i)$ and $\psi \wedge \psi(r_{i_0}) \wedge \psi(r_{i_1} | r_{i_0}) \wedge \cdots \wedge \psi(r_{i_n} | r_{i_m})$ satisfies $\phi$, and any $\psi(r_j | r_i)$ and $\psi(r_k | r_j)$ are disjoint. The time complexity is $O(mn^3)$, therefore $\mathbf{P} = \mathbf{NP}$.

更新日期：2020-01-16
• arXiv.cs.CC Pub Date : 2020-01-14
Cédric Pilatte

We prove the NP-completeness of the following problem. Given a set $S$ of $n$ slopes and an integer $k\geq 1$, is it possible to draw a complete graph on $k$ vertices in the plane using only slopes from $S$? Equivalently, does there exist a set $K$ of $k$ points in general position such that the slope of every segment between two points of $K$ is in $S$? We also present a polynomial algorithm for this question when $n\leq 2k-c$, conditionally on a conjecture of R.E. Jamison. For $n=k$, an algorithm in $\mathcal{O}(n^4)$ was proposed by Wade and Chu. In this case, our algorithm is linear and does not rely on Jamison's conjecture.

更新日期：2020-01-15
• arXiv.cs.CC Pub Date : 2016-01-10
Ronald de Haan; Jakub Szymanik

Ramsey quantifiers are a natural object of study not only for logic and computer science, but also for the formal semantics of natural language. Restricting attention to finite models leads to the natural question whether all Ramsey quantifiers are either polynomial-time computable or NP-hard, and whether we can give a natural characterization of the polynomial-time computable quantifiers. In this paper, we first show that there exist intermediate Ramsey quantifiers and then we prove a dichotomy result for a large and natural class of Ramsey quantifiers, based on a reasonable and widely-believed complexity assumption. We show that the polynomial-time computable quantifiers in this class are exactly the constant-log-bounded Ramsey quantifiers.

更新日期：2020-01-15
• arXiv.cs.CC Pub Date : 2018-12-10
Erik D. Demaine; Dylan H. Hendrickson; Jayson Lynch

We build a general theory for characterizing the computational complexity of motion planning of robot(s) through a graph of "gadgets", where each gadget has its own state defining a set of allowed traversals which in turn modify the gadget's state. We study two families of such gadgets, one which naturally leads to motion planning problems with polynomially bounded solutions, and another which leads to polynomially unbounded (potentially exponential) solutions. We also study a range of competitive game-theoretic scenarios, from one player controlling one robot to teams of players each controlling their own robot and racing to achieve their team's goal. Under small restrictions on these gadgets, we fully characterize the complexity of bounded 1-player motion planning (NL vs. NP-complete), unbounded 1-player motion planning (NL vs. PSPACE-complete), and bounded 2-player motion planning (P vs. PSPACE-complete), and we partially characterize the complexity of unbounded 2-player motion planning (P vs. EXPTIME-complete), bounded 2-team motion planning (P vs. NEXPTIME-complete), and unbounded 2-team motion planning (P vs. undecidable). These results can be seen as an alternative to Constraint Logic (which has already proved useful as a basis for hardness reductions), providing a wide variety of agent-based gadgets, any one of which suffices to prove a problem hard.

更新日期：2020-01-15
• arXiv.cs.CC Pub Date : 2019-08-16
Erich Novak

Error bounds and complexity bounds in numerical analysis and information-based complexity are often proved for functions that are defined on very simple domains, such as a cube, a torus, or a sphere. We study optimal error bounds for the approximation or integration of functions defined on $D_d \subset R^d$ and only assume that $D_d$ is a bounded Lipschitz domain. Some results are even more general. We study three different concepts to measure the complexity: order of convergence, asymptotic constant, and explicit uniform bounds, i.e., bounds that hold for all $n$ (number of pieces of information) and all (normalized) domains. It is known for many problems that the order of convergence of optimal algorithms does not depend on the domain $D_d \subset R^d$. We present examples for which the following statements are true: 1) Also the asymptotic constant does not depend on the shape of $D_d$ or the imposed boundary values, it only depends on the volume of the domain. 2) There are explicit and uniform lower (or upper, respectively) bounds for the error that are only slightly smaller (or larger, respectively) than the asymptotic error bound.

更新日期：2020-01-15
• arXiv.cs.CC Pub Date : 2019-09-04
A. R. Balasubramanian

We provide upper and lower bounds for the length of controlled bad sequences over the majoring and the minoring orderings of finite sets of $\mathbb{N}^d$. The results are obtained by bounding the length of such sequences by functions from the Cichon hierarchy. This allows us to translate these results to bounds over the fast-growing complexity classes. The obtained bounds are proven to be tight for the majoring ordering, which solves a problem left open by Abriola, Figueira and Senno (Theor. Comp. Sci, Vol. 603). Finally, we use the results on controlled bad sequences to prove upper bounds for the emptiness problem of some classes of automata.

更新日期：2020-01-15
• arXiv.cs.CC Pub Date : 2020-01-11
Pierre Aboulker; Édouard Bonnet; Eun Jung Kim; Florian Sikora

The first-fit coloring is a heuristic that assigns to each vertex, arriving in a specified order $\sigma$, the smallest available color. The problem Grundy Coloring asks how many colors are needed for the most adversarial vertex ordering $\sigma$, i.e., the maximum number of colors that the first-fit coloring requires over all possible vertex orderings. Since its inception by Grundy in 1939, Grundy Coloring has been examined for its structural and algorithmic aspects. A brute-force $f(k)n^{2^{k-1}}$-time algorithm for Grundy Coloring on general graphs is not difficult to obtain, where $k$ is the number of colors required by the most adversarial vertex ordering. It was asked several times whether the dependency on $k$ in the exponent of $n$ can be avoided or reduced, and its answer seemed elusive until now. We prove that Grundy Coloring is W[1]-hard and the brute-force algorithm is essentially optimal under the Exponential Time Hypothesis, thus settling this question by the negative. The key ingredient in our W[1]-hardness proof is to use so-called half-graphs as a building block to transmit a color from one vertex to another. Leveraging the half-graphs, we also prove that b-Chromatic Core is W[1]-hard, whose parameterized complexity was posed as an open question by Panolan et al. [JCSS '17]. A natural follow-up question is, how the parameterized complexity changes in the absence of (large) half-graphs. We establish fixed-parameter tractability on $K_{t,t}$-free graphs for b-Chromatic Core and Partial Grundy Coloring, making a step toward answering this question. The key combinatorial lemma underlying the tractability result might be of independent interest.

更新日期：2020-01-14
• arXiv.cs.CC Pub Date : 2020-01-12
Ivan Petrenko

The GKS game was formulated by Justin Gilmer, Michal Koucky, and Michael Saks in their research of the sensitivity conjecture. Mario Szegedy invented a protocol for the game with the cost of $O(n^{0.4732})$. Then a protocol with the cost of $O(n^{0.4696})$ was obtained by DeVon Ingram who used a bipartite matching. We propose a slight improvement of Ingram's method and design a protocol with cost of $O(n^{0.4693})$.

更新日期：2020-01-14
• arXiv.cs.CC Pub Date : 2020-01-12

We study algorithmic complexity of solving subtraction games in a~fixed dimension with a finite difference set. We prove that there exists a game in this class such that any algorithm solving the game runs in exponential time. Also we prove an existence of a game in this class such that solving the game is PSPACE-hard. The results are based on the construction introduced by Larsson and W\"astlund. It relates subtraction games and cellular automata.

更新日期：2020-01-14
• arXiv.cs.CC Pub Date : 2020-01-13

Some classical graph problems such as finding minimal spanning tree, shortest path or maximal flow can be done efficiently. We describe slight variations of such problems which are shown to be NP-complete. Our proofs use straightforward reduction from $3$-SAT.

更新日期：2020-01-14
• arXiv.cs.CC Pub Date : 2020-01-13
Markus Hecher; Michael Morak; Stefan Woltran

Epistemic logic programs (ELPs) are a popular generalization of standard Answer Set Programming (ASP) providing means for reasoning over answer sets within the language. This richer formalism comes at the price of higher computational complexity reaching up to the fourth level of the polynomial hierarchy. However, in contrast to standard ASP, dedicated investigations towards tractability have not been undertaken yet. In this paper, we give first results in this direction and show that central ELP problems can be solved in linear time for ELPs exhibiting structural properties in terms of bounded treewidth. We also provide a full dynamic programming algorithm that adheres to these bounds. Finally, we show that applying treewidth to a novel dependency structure---given in terms of epistemic literals---allows to bound the number of ASP solver calls in typical ELP solving procedures.

更新日期：2020-01-14
• arXiv.cs.CC Pub Date : 2020-01-13
Zhengfeng Ji; Anand Natarajan; Thomas Vidick; John Wright; Henry Yuen

We show that the class MIP* of languages that can be decided by a classical verifier interacting with multiple all-powerful quantum provers sharing entanglement is equal to the class RE of recursively enumerable languages. Our proof builds upon the quantum low-degree test of (Natarajan and Vidick, FOCS 2018) by integrating recent developments from (Natarajan and Wright, FOCS 2019) and combining them with the recursive compression framework of (Fitzsimons et al., STOC 2019). An immediate byproduct of our result is that there is an efficient reduction from the Halting Problem to the problem of deciding whether a two-player nonlocal game has entangled value $1$ or at most $\frac{1}{2}$. Using a known connection, undecidability of the entangled value implies a negative answer to Tsirelson's problem: we show, by providing an explicit example, that the closure $C_{qa}$ of the set of quantum tensor product correlations is strictly included in the set $C_{qc}$ of quantum commuting correlations. Following work of (Fritz, Rev. Math. Phys. 2012) and (Junge et al., J. Math. Phys. 2011) our results provide a refutation of Connes' embedding conjecture from the theory of von Neumann algebras.

更新日期：2020-01-14
• arXiv.cs.CC Pub Date : 2010-05-17
Changlin Wan; Zhongzhi Shi

The $\textbf{P}$ vs. $\textbf{NP}$ problem is an important problem in contemporary mathematics and theoretical computer science. Many proofs have been proposed to this problem. This paper proposes a theoretic proof for $\textbf{P}$ vs. $\textbf{NP}$ problem. The central idea of this proof is a recursive definition for Turing machine (shortly TM) that accepts the encoding strings of valid TMs. By the definition, an infinite sequence of TM is constructed, and it is proven that the sequence includes all valid TMs. Based on these TMs, the class $\textbf{D}$ that includes all decidable languages and the union and reduction operators are defined. By constructing a language $\textbf{Up}$ of the union of $\textbf{D}$, it is proved that $\textbf{P}=\textbf{Up}$ and $\textbf{Up}=\textbf{NP}$, and the result $\textbf{P}=\textbf{NP}$ is proven.

更新日期：2020-01-14
• arXiv.cs.CC Pub Date : 2019-07-18
Andrei A. Bulatov; Stanislav Zivny

In this paper we study the complexity of counting Constraint Satisfaction Problems (CSPs) of the form #CSP($\mathcal{C}$,-), in which the goal is, given a relational structure $\mathbf{A}$ from a class $\mathcal{C}$ of structures and an arbitrary structure $\mathbf{B}$, to find the number of homomorphisms from $\mathbf{A}$ to $\mathbf{B}$. Flum and Grohe showed that #CSP($\mathcal{C}$,-) is solvable in polynomial time if $\mathcal{C}$ has bounded treewidth [FOCS'02]. Building on the work of Grohe [JACM'07] on decision CSPs, Dalmau and Jonsson then showed that, if $\mathcal{C}$ is a recursively enumerable class of relational structures of bounded arity, then assuming FPT $\neq$ #W[1], there are no other cases of #CSP($\mathcal{C}$,-) solvable exactly in polynomial time (or even fixed-parameter time) [TCS'04]. We show that, assuming FPT $\neq$ W[1] (under randomised parametrised reductions) and for $\mathcal{C}$ satisfying certain general conditions, #CSP($\mathcal{C}$,-) is not solvable even approximately for $\mathcal{C}$ of unbounded treewidth; that is, there is no fixed parameter tractable (and thus also not fully polynomial) randomised approximation scheme for #CSP($\mathcal{C}$,-). In particular, our condition generalises the case when $\mathcal{C}$ is closed under taking minors.

更新日期：2020-01-14
• arXiv.cs.CC Pub Date : 2019-10-04
Petra Wolf

Imagine an assembly line where a box with a lid and liquid in it enters in some unknown orientation. The box should leave the line with the open lid facing upwards with the liquid still in it. To save costs there are no complex sensors or image recognition software available on the assembly line, so a reset sequence needs to be computed. But how can the dependencies of the deforming impact of a transformation of the box, such as 'do not tilt the box over when the lid is open' or 'open the lid again each time it gets closed' be modeled? We present three attempts to model constraints of these kinds on the order in which the states of an automaton are transitioned by a synchronizing word. The first two concepts relate the last visits of states and form constraints on which states still need to be reached, whereas the third concept concerns the first visits of states and forms constraints on which states might still be reached. We examine the computational complexity of different variants of the problem, whether an automaton can be synchronized with a word that respects the constraints defined in the respective concept, and obtain nearly a full classification. While most of the problems are PSPACE-complete we also observe NP-complete variants and variants solvable in polynomial time. We will also observe a drop of the complexity if we track the orders of states on several paths simultaneously instead of tracking the set of active states. Further, we give upper bounds on the length of a synchronizing word depending on the size of the input relation and show that the Cerny conjecture holds for partial weakly acyclic automata.

更新日期：2020-01-14
• arXiv.cs.CC Pub Date : 2019-10-04
Antoine Amarilli; İsmail İlkan Ceylan

We study the problem of probabilistic query evaluation (PQE) over probabilistic graphs, namely, tuple-independent probabilistic databases (TIDs) on signatures of arity two. Our focus is the class of queries that is closed under homomorphisms, or equivalently, the infinite unions of conjunctive queries, denoted UCQ^\infty. Our main result states that all unbounded queries in UCQ^\infty are #P-hard for PQE. As bounded queries in UCQ^\infty are already classified by the dichotomy of Dalvi and Suciu [17], our results and theirs imply a complete dichotomy on PQE for UCQ^\infty queries over probabilistic graphs. This dichotomy covers in particular all fragments in UCQ^\infty such as negation-free (disjunctive) Datalog, regular path queries, and a large class of ontology-mediated queries on arity-two signatures. Our result is shown by reducing from counting the valuations of positive partitioned 2-DNF formulae (#PP2DNF) for some queries, or from the source-to-target reliability problem in an undirected graph (#U-ST-CON) for other queries, depending on properties of minimal models.

更新日期：2020-01-14
• arXiv.cs.CC Pub Date : 2019-10-10
Michael Blondin; Javier Esparza; Blaise Genest; Martin Helfrich; Stefan Jaax

Angluin et al. proved that population protocols compute exactly the predicates definable in Presburger arithmetic (PA), the first-order theory of addition. As part of this result, they presented a procedure that translates any formula $\varphi$ of quantifier-free PA with remainder predicates (which has the same expressive power as full PA) into a population protocol with $2^{O(\text{poly}(|\varphi|))}$ states that computes $\varphi$. More precisely, the number of states of the protocol is exponential in both the bit length of the largest coefficient in the formula, and the number of nodes of its syntax tree. In this paper, we prove that every formula $\varphi$ of quantifier-free PA with remainder predicates is computable by a leaderless population protocol with $O(\text{poly}(|\varphi|))$ states. Our proof is based on several new constructions, which may be of independent interest. Given a formula $\varphi$ of quantifier-free PA with remainder predicates, a first construction produces a succinct protocol (with $O(|\varphi|^3)$ leaders) that computes $\varphi$; this completes the work initiated in [STACS'18], where we constructed such protocols for a fragment of PA. For large enough inputs, we can get rid of these leaders. If the input is not large enough, then it is small, and we design another construction producing a succinct protocol with one leader that computes $\varphi$. Our last construction gets rid of this leader for small inputs.

更新日期：2020-01-14
• arXiv.cs.CC Pub Date : 2019-12-04
Pascal Koiran; Mateusz Skomra

We study the decomposition of multivariate polynomials as sums of powers of linear forms. As one of our main results we give an algorithm for the following problem: given a homogeneous polynomial of degree 3, decide whether it can be written as a sum of cubes of linearly independent linear forms with complex coefficients. Compared to previous algorithms for the same problem, the two main novel features of this algorithm are: (i) It is an algebraic algorithm, i.e., it performs only arithmetic operations and equality tests on the coefficients of the input polynomial. In particular, it does not make any appeal to polynomial factorization. (ii) For an input polynomial with rational coefficients, the algorithm runs in polynomial time when implemented in the bit model of computation. The algorithm relies on methods from linear and multilinear algebra (symmetric tensor decomposition by simultaneous diagonalization). We also give a version of our algorithm for decomposition over the field of real numbers. In this case, the algorithm performs arithmetic operations and comparisons on the input coefficients. Finally we give several related derandomization results on black box polynomial identity testing, the minimization of the number of variables in a polynomial, the computation of Lie algebras and factorization into products of linear forms.

更新日期：2020-01-14
• arXiv.cs.CC Pub Date : 2017-08-24
Andrea Coladangelo; Alex Grilo; Stacey Jeffery; Thomas Vidick

The problem of reliably certifying the outcome of a computation performed by a quantum device is rapidly gaining relevance. We present two protocols for a classical verifier to verifiably delegate a quantum computation to two non-communicating but entangled quantum provers. Our protocols have near-optimal complexity in terms of the total resources employed by the verifier and the honest provers, with the total number of operations of each party, including the number of entangled pairs of qubits required of the honest provers, scaling as $O(g\log g)$ for delegating a circuit of size $g$. This is in contrast to previous protocols, which all require a prohibitively large polynomial overhead. Our first protocol requires a number of rounds that is linear in the depth of the circuit being delegated, and is blind, meaning neither prover can learn the circuit being delegated. The second protocol is not blind, but requires only a constant number of rounds of interaction. Our main technical innovation is an efficient rigidity theorem which allows a verifier to test that two entangled provers perform measurements specified by an arbitrary $m$-qubit tensor product of single-qubit Clifford observables on their respective halves of $m$ shared EPR pairs, with a robustness that is independent of $m$. Our two-prover classical-verifier delegation protocols are obtained by combining this rigidity theorem with a single-prover quantum-verifier protocol for the verifiable delegation of a quantum computation, introduced by Broadbent (Theory of Computing, 2018).

更新日期：2020-01-13
• arXiv.cs.CC Pub Date : 2020-01-09
Nate Veldt; Austin R. Benson; Jon Kleinberg

The minimum $s$-$t$ cut problem in graphs is one of the most fundamental problems in combinatorial optimization, and graph cuts underlie algorithms throughout discrete mathematics, theoretical computer science, operations research, and data science. While graphs are a standard model for pairwise relationships, hypergraphs provide the flexibility to model multi-way relationships, and are now a standard model for complex data and systems. However, when generalizing from graphs to hypergraphs, the notion of a "cut hyperedge" is less clear, as a hyperedge's nodes can be split in several ways. Here, we develop a framework for hypergraph cuts by considering the problem of separating two terminal nodes in a hypergraph in a way that minimizes a sum of penalties at split hyperedges. In our setup, different ways of splitting the same hyperedge have different penalties, and the penalty is encoded by what we call a splitting function. Our framework opens a rich space on the foundations of hypergraph cuts. We first identify a natural class of cardinality-based hyperedge splitting functions that depend only on the number of nodes on each side of the split. In this case, we show that the general hypergraph $s$-$t$ cut problem can be reduced to a tractable graph $s$-$t$ cut problem if and only if the splitting functions are submodular. We also identify a wide regime of non-submodular splitting functions for which the problem is NP-hard. We also analyze extensions to multiway cuts with at least three terminal nodes and identify a natural class of splitting functions for which the problem can be reduced in an approximation-preserving way to the node-weighted multiway cut problem in graphs, again subject to a submodularity property. Finally, we outline several open questions on general hypergraph cut problems.

更新日期：2020-01-10
• arXiv.cs.CC Pub Date : 2020-01-09
Debbie Leung; Ashwin Nayak; Ala Shayeghi; Dave Touchette; Penghui Yao; Nengkun Yu

We consider the problem of implementing two-party interactive quantum communication over noisy channels, a necessary endeavor if we wish to fully reap quantum advantages for communication. For an arbitrary protocol with $n$ messages, designed for a noiseless qudit channel over a $\mathrm{poly}(n)$ size alphabet, our main result is a simulation method that fails with probability less than $2^{-\Theta(n\epsilon)}$ and uses a qudit channel over the same alphabet $n\left(1+\Theta \left(\sqrt{\epsilon}\right)\right)$ times, of which an $\epsilon$ fraction can be corrupted adversarially. The simulation is thus capacity achieving to leading order, and we conjecture that it is optimal up to a constant factor in the $\sqrt{\epsilon}$ term. Furthermore, the simulation is in a model that does not require pre-shared resources such as randomness or entanglement between the communicating parties. Our work improves over the best previously known quantum result where the overhead is a non-explicit large constant [Brassard et al., FOCS'14] for low $\epsilon$.

更新日期：2020-01-10
• arXiv.cs.CC Pub Date : 2020-01-07
Emmanuel Abbe; Colin Sandon

The goal of this paper is to characterize function distributions that deep learning can or cannot learn in poly-time. A universality result is proved for SGD-based deep learning and a non-universality result is proved for GD-based deep learning; this also gives a separation between SGD-based deep learning and statistical query algorithms: (1) {\it Deep learning with SGD is efficiently universal.} Any function distribution that can be learned from samples in poly-time can also be learned by a poly-size neural net trained with SGD on a poly-time initialization with poly-steps, poly-rate and possibly poly-noise. Therefore deep learning provides a universal learning paradigm: it was known that the approximation and estimation errors could be controlled with poly-size neural nets, using ERM that is NP-hard; this new result shows that the optimization error can also be controlled with SGD in poly-time. The picture changes for GD with large enough batches: (2) {\it Result (1) does not hold for GD:} Neural nets of poly-size trained with GD (full gradients or large enough batches) on any initialization with poly-steps, poly-range and at least poly-noise cannot learn any function distribution that has super-polynomial {\it cross-predictability,} where the cross-predictability gives a measure of `average'' function correlation -- relations and distinctions to the statistical dimension are discussed. In particular, GD with these constraints can learn efficiently monomials of degree $k$ if and only if $k$ is constant. Thus (1) and (2) point to an interesting contrast: SGD is universal even with some poly-noise while full GD or SQ algorithms are not (e.g., parities).

更新日期：2020-01-10
• arXiv.cs.CC Pub Date : 2019-04-11
Titus Dose

Pudl\'ak [Pud17] lists several major conjectures from the field of proof complexity and asks for oracles that separate corresponding relativized conjectures. Among these conjectures are: - $\mathsf{DisjNP}$: The class of all disjoint NP-pairs does not have many-one complete elements. - $\mathsf{SAT}$: NP does not contain many-one complete sets that have P-optimal proof systems. - $\mathsf{UP}$: UP does not have many-one complete problems. - $\mathsf{NP}\cap\mathsf{coNP}$: $\text{NP}\cap\text{coNP}$ does not have many-one complete problems. As one answer to this question, we construct an oracle relative to which $\mathsf{DisjNP}$, $\neg \mathsf{SAT}$, $\mathsf{UP}$, and $\mathsf{NP}\cap\mathsf{coNP}$ hold, i.e., there is no relativizable proof for the implication $\mathsf{DisjNP}\wedge \mathsf{UP}\wedge \mathsf{NP}\cap\mathsf{coNP}\Rightarrow\mathsf{SAT}$. In particular, regarding the conjectures by Pudl\'ak this extends a result by Khaniki [Kha19].

更新日期：2020-01-10
• arXiv.cs.CC Pub Date : 2019-09-05
Titus Dose

As one step in a working program initiated by Pudl\'ak [Pud17] we construct an oracle relative to which $\mathrm{P}\ne\mathrm{NP}$ and all non-empty sets in $\mathrm{NP}\cup\mathrm{coNP}$ have $\mathrm{P}$-optimal proof systems.

更新日期：2020-01-10
• arXiv.cs.CC Pub Date : 2019-10-18
Titus Dose

We build on a working program initiated by Pudl\'ak [Pud17] and construct an oracle relative to which each $\mathrm{coNP}$-complete set has $\mathrm{P}$-optimal proof systems and $\mathrm{NP}\cap\mathrm{coNP}$ does not have complete problems.

更新日期：2020-01-10
• arXiv.cs.CC Pub Date : 2020-01-08
Susanna F. de Rezende; Or Meir; Jakob Nordström; Robert Robere

We establish an exactly tight relation between reversible pebblings of graphs and Nullstellensatz refutations of pebbling formulas, showing that a graph $G$ can be reversibly pebbled in time $t$ and space $s$ if and only if there is a Nullstellensatz refutation of the pebbling formula over $G$ in size $t+1$ and degree $s$ (independently of the field in which the Nullstellensatz refutation is made). We use this correspondence to prove a number of strong size-degree trade-offs for Nullstellensatz, which to the best of our knowledge are the first such results for this proof system.

更新日期：2020-01-09
• arXiv.cs.CC Pub Date : 2020-01-07
Zhong Huang; Xueliang Li

The concept of rainbow connection number of a graph was introduced by Chartrand et al. in 2008. Inspired by this concept, other concepts on colored version of connectivity in graphs were introduced, such as the monochromatic connection number by Caro and Yuster in 2011, the proper connection number by Borozan et al. in 2012, and the conflict-free connection number by Czap et al. in 2018, as well as some other variants of connection numbers later on. Chakraborty et al. proved that to compute the rainbow connection number of a graph is NP-hard. For a long time, it has been tried to fix the computational complexity for the monochromatic connection number, the proper connection number and the conflict-free connection number of a graph. However, it has not been solved yet. Only the complexity results for the strong version, i.e., the strong proper connection number and the strong conflict-free connection number, of these connection numbers were determined to be NP-hard. In this paper, we prove that to compute each of the monochromatic connection number, the proper connection number and the conflict free connection number for a graph is NP-hard. This solves a long standing problem in this field, asked in many talks of workshops and papers.

更新日期：2020-01-08
• arXiv.cs.CC Pub Date : 2020-01-07
Riccardo Dondi; Giancarlo Mauri; Italo Zoppis

The problem of matching a query string to a directed graph, whose vertices are labeled by strings, has application in different fields, from data mining to computational biology. Several variants of the problem have been considered, depending on the fact that the match is exact or approximate and, in this latter case, which edit operations are considered and where are allowed. In this paper we present results on the complexity of the approximate matching problem, where edit operations are symbol substitutions and are allowed only on the graph labels or both on the graph labels and the query string. We introduce a variant of the problem that asks whether there exists a path in a graph that represents a query string with any number of edit operations and we show that is is NP-complete, even when labels have length one and in the case the alphabet is binary. Moreover, when it is parameterized by the length of the input string and graph labels have length one, we show that the problem is fixed-parameter tractable and it is unlikely to admit a polynomial kernel. The NP-completeness of this problem leads to the inapproximability (within any factor) of the approximate matching when edit operations are allowed only on the graph labels. Moreover, we show that the variants of approximate string matching to graph we consider are not fixed-parameter tractable, when the parameter is the number of edit operations, even for graphs that have distance one from a DAG. The reduction for this latter result allows us to prove the inapproximability of the variant where edit operations can be applied both on the query string and on graph labels.

更新日期：2020-01-08
• arXiv.cs.CC Pub Date : 2020-01-07
Susanna F. de Rezende; Or Meir; Jakob Nordström; Toniann Pitassi; Robert Robere; Marc Vinyals

We significantly strengthen and generalize the theorem lifting Nullstellensatz degree to monotone span program size by Pitassi and Robere (2018) so that it works for any gadget with high enough rank, in particular, for useful gadgets such as equality and greater-than. We apply our generalized theorem to solve two open problems: * We present the first result that demonstrates a separation in proof power for cutting planes with unbounded versus polynomially bounded coefficients. Specifically, we exhibit CNF formulas that can be refuted in quadratic length and constant line space in cutting planes with unbounded coefficients, but for which there are no refutations in subexponential length and subpolynomial line space if coefficients are restricted to be of polynomial magnitude. * We give the first explicit separation between monotone Boolean formulas and monotone real formulas. Specifically, we give an explicit family of functions that can be computed with monotone real formulas of nearly linear size but require monotone Boolean formulas of exponential size. Previously only a non-explicit separation was known. An important technical ingredient, which may be of independent interest, is that we show that the Nullstellensatz degree of refuting the pebbling formula over a DAG G over any field coincides exactly with the reversible pebbling price of G. In particular, this implies that the standard decision tree complexity and the parity decision tree complexity of the corresponding falsified clause search problem are equal.

更新日期：2020-01-08
• arXiv.cs.CC Pub Date : 2018-12-27
Alexandre Bayen; Jesse Goodman; Eugene Vinitsky

We introduce the combinatorial optimization problem Time Disjoint Walks (TDW), which has applications in collision-free routing of discrete objects (e.g., autonomous vehicles) over a network. This problem takes as input a digraph $G$ with positive integer arc lengths, and $k$ pairs of vertices that each represent a trip demand from a source to a destination. The goal is to find a walk and delay for each demand so that no two trips occupy the same vertex at the same time, and so that a min-max or min-sum objective over the trip durations is realized. We focus here on the min-sum variant of Time Disjoint Walks, although most of our results carry over to the min-max case. We restrict our study to various subclasses of DAGs, and observe that there is a sharp complexity boundary between Time Disjoint Walks on oriented stars and on oriented stars with the central vertex replaced by a path. In particular, we present a poly-time algorithm for min-sum and min-max TDW on the former, but show that min-sum TDW on the latter is NP-hard. Our main hardness result is that for DAGs with max degree $\Delta\leq3$, min-sum Time Disjoint Walks is APX-hard. We present a natural approximation algorithm for the same class, and provide a tight analysis. In particular, we prove that it achieves an approximation ratio of $\Theta(k/\log k)$ on bounded-degree DAGs, and $\Theta(k)$ on DAGs and bounded-degree digraphs.

更新日期：2020-01-08
• arXiv.cs.CC Pub Date : 2019-12-11
Rohan Karthikeyan; Siddharth Sinha; Vallabh Patil

The Sensitivity Conjecture is a long-standing problem in theoretical computer science that seeks to fit the sensitivity of a Boolean function into a unified framework formed by the other complexity measures of Boolean functions, such as block sensitivity and certificate complexity. After more than thirty years of attacks on this Conjecture, Hao Huang (2019) gave a very succinct proof of the Conjecture. In this survey, we explore the ideas that inspired the proof of this Conjecture by an exposition of four papers that had the most impact on the Conjecture. We also discuss progress on further research directions that the Conjecture leads us to.

更新日期：2020-01-08
• arXiv.cs.CC Pub Date : 2020-01-03
Lucas Assunção; Andréa Cynthia Santos; Thiago F. Noronha; Rafael Andrade

This paper addresses a class of problems under interval data uncertainty composed of min-max regret versions of classical 0-1 optimization problems with interval costs. We refer to them as interval 0-1 min-max regret problems. The state-of-the-art exact algorithms for this class of problems work by solving a corresponding mixed integer linear programming formulation in a Benders' decomposition fashion. Each of the possibly exponentially many Benders' cuts is separated on the fly through the resolution of an instance of the classical 0-1 optimization problem counterpart. Since these separation subproblems may be NP-hard, not all of them can be modeled by means of linear programming, unless P = NP. In these cases, the convergence of the aforementioned algorithms are not guaranteed in a straightforward manner. In fact, to the best of our knowledge, their finite convergence has not been explicitly proved for any interval 0-1 min-max regret problem. In this work, we formally describe these algorithms through the definition of a logic-based Benders' decomposition framework and prove their convergence to an optimal solution in a finite number of iterations. As this framework is applicable to any interval 0-1 min-max regret problem, its finite optimal convergence also holds in the cases where the separation subproblems are NP-hard.

更新日期：2020-01-07
• arXiv.cs.CC Pub Date : 2020-01-05
Moses Charikar; Weiyun Ma; Li-Yang Tan

Roughgarden, Vassilvitskii, and Wang (JACM 18) recently introduced a novel framework for proving lower bounds for Massively Parallel Computation using techniques from boolean function complexity. We extend their framework in two different ways, to capture two common features of Massively Parallel Computation: $\circ$ Adaptivity, where machines can write to and adaptively read from shared memory throughout the execution of the computation. Recent work of Behnezhad et al. (SPAA 19) showed that adaptivity enables significantly improved round complexities for a number of central graph problems. $\circ$ Promise problems, where the algorithm only has to succeed on certain inputs. These inputs may have special structure that is of particular interest, or they may be representative of hard instances of the overall problem. Using this extended framework, we give the first unconditional lower bounds on the complexity of distinguishing whether an input graph is a cycle of length $n$ or two cycles of length $n/2$. This promise problem, 1v2-Cycle, has emerged as a central problem in the study of Massively Parallel Computation. We prove that any adaptive algorithm for the 1v2-Cycle problem with I/O capacity $O(n^{\varepsilon})$ per machine requires $\Omega(1/\varepsilon)$ rounds, matching a recent upper bound of Behnezhad et al. In addition to strengthening the connections between Massively Parallel Computation and boolean function complexity, we also develop new machinery to reason about the latter. At the heart of our proofs are optimal lower bounds on the query complexity and approximate certificate complexity of the 1v2-Cycle problem.

更新日期：2020-01-07
• arXiv.cs.CC Pub Date : 2020-01-06
Istvan Miklos; Miklos Kresz

Here we prove that counting maximum matchings in planar, bipartite graphs is #P-complete. This is somewhat surprising in the light that the number of perfect matchings in planar graphs can be computed in polynomial time. We also prove that counting non-necessarily perfect matchings in planar graphs is already #P-complete if the problem is restricted to bipartite graphs. So far hardness was proved only for general, non-necessarily bipartite graphs.

更新日期：2020-01-07
• arXiv.cs.CC Pub Date : 2015-01-28
Marco Voigt; Christoph Weidenbach

First-order predicate logic extended with linear arithmetic is undecidable, in general. We show that the Bernays-Sch\"onfinkel-Ramsey (BSR) fragment extended with linear arithmetic restricted to simple bounds (SB) is decidable through finite ground instantiation. The identified ground instances can be employed to restrict the search space of existing automated reasoning procedures for BSR(SB). Satisfiability of BSR(SB) compared to BSR remains NEXPTIME-complete. The decidability result is almost tight because BSR is undecidable if extended with linear difference inequations, simple additive inequations, quotient inequations and multiplicative inequations.

更新日期：2020-01-07
• arXiv.cs.CC Pub Date : 2018-11-02
Miriam Backens; Leslie Ann Goldberg

We construct a theory of holant clones to capture the notion of expressibility in the holant framework. Their role is analogous to the role played by functional clones in the study of weighted counting Constraint Satisfaction Problems. We explore the landscape of conservative holant clones and determine the situations in which a set $\mathcal{F}$ of functions is "universal in the conservative case", which means that all functions are contained in the holant clone generated by $\mathcal{F}$ together with all unary functions. When $\mathcal{F}$ is not universal in the conservative case, we give concise generating sets for the clone. We demonstrate the usefulness of the holant clone theory by using it to give a complete complexity-theory classification for the problem of approximating the solution to conservative holant problems. We show that approximation is intractable exactly when $\mathcal{F}$ is universal in the conservative case.

更新日期：2020-01-07
• arXiv.cs.CC Pub Date : 2019-01-15
Alexandr Kazda; Dmitriy Zhuk

We study the problem of whether a given finite algebra with finitely many basic operations contains a cube term; we give both structural and algorithmic results. We show that if such an algebra has a cube term then it has a cube term of dimension at most $N$, where the number $N$ depends on the arities of basic operations of the algebra and the size of the basic set. For idempotent algebras we give a tight bound on $N$ that matches an earlier result of K. Kearnes and A. Szendrei. On the algorithmic side, we show that deciding the existence of cube terms is in P for idempotent algebras and in EXPTIME in general. Since an algebra contains a $k$-ary near unanimity operation if and only if it contains a $k$-dimensional cube term and generates a congruence distributive variety, our algorithm also lets us decide whether a given finite algebra has a near unanimity operation.

更新日期：2020-01-07
• arXiv.cs.CC Pub Date : 2019-05-06

We revisit the task of visible compression of an ensemble of quantum states with entanglement assistance in the one-shot setting. The protocols achieving the best compression use many more qubits of shared entanglement than the number of qubits in the states in the ensemble. Other compression protocols, with potentially larger communication cost, have entanglement cost bounded by the number of qubits in the given states. This motivates the question as to whether entanglement is truly necessary for compression, and if so, how much of it is needed. Motivated by questions in communication complexity, we lift certain restrictions that are placed on compression protocols in tasks such as state-splitting and channel simulation. We show that an ensemble of the form designed by Jain, Radhakrishnan, and Sen (ICALP'03) saturates the known bounds on the sum of communication and entanglement costs, even with the relaxed compression protocols we study. The ensemble and the associated one-way communication protocol have several remarkable properties. The ensemble is incompressible by more than a constant number of qubits without shared entanglement, even when constant error is allowed. Moreover, in the presence of shared entanglement, the communication cost of compression can be arbitrarily smaller than the entanglement cost. The quantum information cost of the protocol can thus be arbitrarily smaller than the cost of compression without shared entanglement. The ensemble can also be used to show the impossibility of reducing, via compression, the shared entanglement used in two-party protocols for computing Boolean functions.

更新日期：2020-01-07
• arXiv.cs.CC Pub Date : 2019-10-24
V. Arvind; Frank Fuhlbrück; Johannes Köbler; Oleg Verbitsky

The $k$-dimensional Weisfeiler-Leman procedure ($k$-WL), which colors $k$-tuples of vertices in rounds based on the neighborhood structure in the graph, has proven to be immensely fruitful in the algorithmic study of Graph Isomorphism. More generally, it is of fundamental importance in understanding and exploiting symmetries in graphs in various settings. Two graphs are $k$-WL-equivalent if the $k$-dimensional Weisfeiler-Leman procedure produces the same final coloring on both graphs. 1-WL-equivalence is known as fractional isomorphism of graphs, and the $k$-WL-equivalence relation becomes finer as $k$ increases. We investigate to what extent standard graph parameters are preserved by $k$-WL-equivalence, focusing on fractional graph packing numbers. The integral packing numbers are typically NP-hard to compute, and we discuss applicability of $k$-WL-invariance for estimating the integrality gap of the LP relaxation provided by their fractional counterparts.

更新日期：2020-01-07
• arXiv.cs.CC Pub Date : 2020-01-03
Marcel Rémon; Johan Barthélemy

The relationship between the complexity classes $P$ and $NP$ is an unsolved question in the field of theoretical computer science. In the first part of this paper, a lattice framework is proposed to handle the 3-CNF-SAT problems, known to be in $NP$. In the second section, we define a multi-linear descriptor function ${\cal H}_\varphi$ for any 3-CNF-SAT problem $\varphi$ of size $n$, in the sense that ${\cal H}_\varphi : \{0,1\}^n \rightarrow \{0,1\}^n$ is such that $Im \; {\cal H}_\varphi$ is the set of all the solutions of $\varphi$. A new merge operation ${\cal H}_\varphi \bigwedge {\cal H}_{\psi}$ is defined, where $\psi$ is a single 3-CNF clause. Given ${\cal H}_\varphi$ [but this can be of exponential complexity], the complexity needed for the computation of $Im \; {\cal H}_\varphi$, the set of all solutions, is shown to be polynomial for hard 3-CNF-SAT problems, i.e. the one with few ($\leq 2^k$) or no solutions. The third part uses the relation between ${\cal H}_\varphi$ and the indicator function $\mathbb{1}_{{\cal S}_\varphi}$ for the set of solutions, to develop a greedy polynomial algorithm to solve hard 3-CNF-SAT problems.

更新日期：2020-01-06
• arXiv.cs.CC Pub Date : 2018-02-20

We give elementary proofs of several Stirling's precise bounds. We first improve all the precise bounds from the literature and give new precise bounds. In particular, we show that for all $n\ge 8$ $$\sqrt{2\pi n}\left(\frac{n}{e}\right)^n e^{\frac{1}{12n}-\frac{1}{360n^3+103n}} \ge n!\ge \sqrt{2\pi n}\left(\frac{n}{e}\right)^n e^{\frac{1}{12n}-\frac{1}{360n^3+102n}}$$ and for all $n\ge 3$ $$\sqrt{2\pi n}\left(\frac{n}{e}\right)^n e^{\frac{1}{12n+\frac{2}{5n}-\frac{1.1}{10n^3}}} \ge n!\ge \sqrt{2\pi n}\left(\frac{n}{e}\right)^n e^{\frac{1}{12n+\frac{2}{5n}-\frac{0.9}{10n^3}}}.$$

更新日期：2020-01-06
• arXiv.cs.CC Pub Date : 2019-12-31
John Napp; Rolando L. La Placa; Alexander M. Dalzell; Fernando G. S. L. Brandao; Aram W. Harrow

Random quantum circuits are commonly viewed as hard to simulate classically. In some regimes this has been formally conjectured, and there had been no evidence against the more general possibility that for circuits with uniformly random gates, approximate simulation of typical instances is almost as hard as exact simulation. We prove that this is not the case by exhibiting a shallow circuit family with uniformly random gates that cannot be efficiently classically simulated near-exactly under standard hardness assumptions, but can be simulated approximately for all but a superpolynomially small fraction of circuit instances in time linear in the number of qubits and gates. We furthermore conjecture that sufficiently shallow random circuits are efficiently simulable more generally. To this end, we propose and analyze two simulation algorithms. Implementing one of our algorithms numerically, we give strong evidence that it is efficient both asymptotically and, in some cases, in practice. To argue analytically for efficiency, we reduce the simulation of 2D shallow random circuits to the simulation of a form of 1D dynamics consisting of alternating rounds of random local unitaries and weak measurements -- a type of process that has generally been observed to undergo a phase transition from an efficient-to-simulate regime to an inefficient-to-simulate regime as measurement strength is varied. Using a mapping from quantum circuits to statistical mechanical models, we give evidence that a similar computational phase transition occurs for our algorithms as parameters of the circuit architecture like the local Hilbert space dimension and circuit depth are varied.

更新日期：2020-01-04
Contents have been reproduced by permission of the publishers.

down
wechat
bug