Hierarchy Of Complexity Classes Research Articles

Порождение малых сложностных классов с помощью логических формул, схем и операций ограниченной конкатенации

The FO and FOM classes are small classes of recursive functions that characterize parallel computing with constant running time and a polynomial number of processors. The article provides an overview of the results describing the basic properties of the FO and FOM classes. Various ways of defining these classes and proving the equivalence of these definitions are given. The position of FO and FOM in the hierarchy of complexity classes is characterized. The results on the affiliation of various functions to the FO and FOM classes are presented. Superposition bases in the FO and FOM classes are described and a complete proof of the result on the superposition basis in the FOM class, consisting only of simple, mainly arithmetic functions, is given.

A complexity theory for hard enumeration problems

Complexity theory provides a wealth of complexity classes for analysing the complexity of decision and counting problems. Despite the practical relevance of enumeration problems, the tools provided by complexity theory for this important class of problems are very limited. In particular, complexity classes analogous to the polynomial hierarchy and an appropriate notion of problem reduction are missing. In this work, we lay the foundations for a complexity theory of hard enumeration problems by proposing a hierarchy of complexity classes and by investigating notions of reductions for enumeration problems.

On Space Efficiency of Algorithms Working on Structural Decompositions of Graphs

Dynamic programming on path and tree decompositions of graphs is a technique that is ubiquitous in the field of parameterized and exponential-time algorithms. However, one of its drawbacks is that the space usage is exponential in the decomposition’s width. Following the work of Allender et al. [5], we investigate whether this space complexity explosion is unavoidable. Using the idea of reparameterization of Cai and Juedes [18], we prove that the question is closely related to a conjecture that the L ongest C ommon S ubsequence problem parameterized by the number of input strings does not admit an algorithm that simultaneously uses XP time and FPT space. Moreover, we extend the complexity landscape sketched for pathwidth and treewidth by Allender et al. by considering the parameter tree-depth . We prove that computations on tree-depth decompositions correspond to a model of non-deterministic machines that work in polynomial time and logarithmic space, with access to an auxiliary stack of maximum height equal to the decomposition’s depth. Together with the results of Allender et al., this describes a hierarchy of complexity classes for polynomial-time non-deterministic machines with different restrictions on the access to working space, which mirrors the classic relations between treewidth, pathwidth, and tree-depth.

Continuous-variable sampling from photon-added or photon-subtracted squeezed states

We introduce a new family of quantum circuits in Continuous Variables and we show that, relying on the widely accepted conjecture that the polynomial hierarchy of complexity classes does not collapse, their output probability distribution cannot be efficiently simulated by a classical computer. These circuits are composed of input photon-subtracted (or photon-added) squeezed states, passive linear optics evolution, and eight-port homodyne detection. We address the proof of hardness for the exact probability distribution of these quantum circuits by exploiting mappings onto different architectures of sub-universal quantum computers. We obtain both a worst-case and an average-case hardness result. Hardness of Boson Sampling with eight-port homodyne detection is obtained as the zero squeezing limit of our model. We conclude with a discussion on the relevance and interest of the present model in connection to experimental applications and classical simulations.

Exact boson sampling using Gaussian continuous-variable measurements

BosonSampling is a quantum mechanical task involving Fock basis state preparation and detection and evolution using only linear interactions. A classical algorithm for producing samples from this quantum task cannot be efficient unless the polynomial hierarchy of complexity classes collapses, a situation believe to be highly implausible. We present method for constructing a device which uses Fock state preparations, linear interactions and Gaussian continuous-variable measurements for which one can show exact sampling would be hard for a classical algorithm in the same way as Boson Sampling. The detection events used from this arrangement does not allow a similar conclusion for the classical hardness of approximate sampling to be drawn. We discuss the details of this result outlining some specific properties that approximate sampling hardness requires.

Locally checkable proofs in distributed computing

This work studies decision problems related to graph properties from the perspective of nondeterministic distributed algorithms. For a yes-instance there must exist a proof that can be verified with a distributed algorithm: all nodes must accept a valid proof, and at least one node must reject an invalid proof. We focus on locally checkable proofs that can be verified with a constant-time distributed algorithm. For example, it is easy to prove that a graph is bipartite: the locally checkable proof gives a 2-coloring of the graph, which only takes 1 bit per node. However, it is more difficult to prove that a graph is not bipartite—it turns out that any locally checkable proof requires W(log n) bits per node. In this work we classify graph properties according to their local proof complexity, i. e., how many bits per node are needed in a locally checkable proof. We establish tight or near- tight results for classical graph properties such as the chromatic number. We show that the local proof complexities form a natural hierarchy of complexity classes: for many classical

Stochastic Enumeration Method for Counting Trees

The problem of estimating the size of a backtrack tree is an important but hard problem in the computational sciences. An efficient solution of this problem can have a major impact on the hierarchy of complexity classes. The first randomized procedure, which repeatedly generates random paths through the tree, was introduced by Knuth. Unfortunately, as was noted by Knuth and a few other researchers, the estimator can introduce a large variance and become ineffective in the sense that it underestimates the cost of the tree. Recently, a new sequential algorithm called Stochastic Enumeration (SE) method was proposed by Rubinstein et al. The authors showed numerically that this simple algorithm can be very efficient for handling different counting problems, such as counting the number of satisfiability assignments and enumerating the number of perfect matchings in bipartite graphs. In this paper we introduce a rigorous analysis of SE and show that it results in significant variance reduction as compared to Knuth’s estimator. Moreover, we establish that for almost all random trees the SE algorithm is a fully polynomial time randomized approximation scheme (FPRAS) for the estimation of the overall tree size.

A Complexity Theory of Constructible Functions and Sheaves

In this paper we introduce constructible analogs of the discrete complexity classes $\mathbf{VP}$ and $\mathbf{VNP}$ of sequences of functions. The functions in the new definitions are constructible functions on $\mathbb{R}^n$ or $\mathbb{C}^n$. We define a class of sequences of constructible functions that play a role analogous to that of $\mathbf{VP}$ in the more classical theory. The class analogous to $\mathbf{VNP}$ is defined using Euler integration. We discuss several examples, develop a theory of completeness, and pose a conjecture analogous to the $\mathbf{VP}$ vs. $\mathbf{VNP}$ conjecture in the classical case. In the second part of the paper we extend the notions of complexity classes to sequences of constructible sheaves over $\mathbb{R}^n$ (or its one point compactification). We introduce a class of sequences of simple constructible sheaves, that could be seen as the sheaf-theoretic analog of the Blum-Shub-Smale class $\mathbf{P}_{\mathbb{R}}$. We also define a hierarchy of complexity classes of sheaves mirroring the polynomial hierarchy, $\mathbf{PH}_{\mathbb{R}}$, in the B-S-S theory. We prove a singly exponential upper bound on the topological complexity of the sheaves in this hierarchy mirroring a similar result in the B-S-S setting. We obtain as a result an algorithm with singly exponential complexity for a sheaf-theoretic variant of the real quantifier elimination problem. We pose the natural sheaf-theoretic analogs of the classical $\mathbf{P}$ vs. $\mathbf{NP}$ question, and also discuss a connection with Toda's theorem from discrete complexity theory in the context of constructible sheaves. We also discuss possible generalizations of the questions in complexity theory related to separation of complexity classes to more general categories via sequences of adjoint pairs of functors.

Measuring nondeterminism in pushdown automata

The amount of nondeterminism that a pushdown automaton requires to recognize an input string can be measured by the minimum number of guesses that it must make to accept the string, where guesses are measured in bits of information. When this quantity is unbounded, the rate at which it grows as the length of the string increases serves as a measure of the pushdown automaton's “rate of consumption” of nondeterminism. We show that this measure is similar to other complexity measures in that it gives rise to an infinite hierarchy of complexity classes of context-free languages differing in the amount of the resource (in this case, nondeterminism) that they require. In addition, we show that there are context-free languages that can only be recognized by a pushdown automaton whose nondeterminism grows linearly, resolving an open problem in the literature. In particular, the set of palindromes is such a language.

Parallel turing machines with one-head control units and cellular automata

Parallel Turing machines ( Ptm) can be viewed as a generalization of cellular automata ( Ca) where an additional measure called processor complexity can be defined which indicates the “amount of parallelism” used. In this paper Ptm are investigated with respect to their power as recognizers of formal languages. A combinatorial approach as well as diagonalization are used to obtain hierarchies of complexity classes for Ptm and Ca. In some cases it is possible to keep the space complexity of Ptm fixed. Thus for the first time it is possible to find hierarchies of complexity classes (though not Ca classes) which are completely contained in the class of languages recognizable by Ca with space complexity n and in polynomial time. A possible collapse of the time hierarchy for these Ca would therefore also imply some unexpected properties of Ptm.

Minimax games, spin glasses, and the polynomial-time hierarchy of complexity classes

We use the negative replica method, which was originally developed for the study of overfrustation in disordered systems, to investigate the statistical behavior of the cost function of minimax games. These games are treated as hierarchical statistical mechanical systems, in which one of the components is at negative temperature.

Towards the computational complexity of [formula omitted

We investigate a simply typed term system ℘R ω aimed at defining partial primitive recursive functionals over arbitrary Scott domains (Scott, 1982). A hierarchy of complexity classes R n ω for functionals definable in ℘R ω is given based on a hierarchy of term classes ℘R n ωpn denoting the nth class of so-called prenormal terms. They come into play by the key observation that every term t can be transformed by what we call higher type modularization as a kind of inversion of normalization into an αβη equal term t′ having almost no structural complexity. However, it turns out that normalization of a prenormal term may increase its structural complexity with respect to the classes ℘R n ωpn , and conversely, ground type modularization being still possible may reduce it. Thus the structural complexity of a prenormal term t defined as the least n with t ϵ ℘R n ωpn depends strongly on the representation of t. We present a measure denoted μ(t) = n rel v, ϱ for prenormal terms t to be read as t is of complexity n with valued free variables v and valued type π. It is shown that μ is stable on αβη equal terms and furthermore, μ(t) ⩽ min{n |∃t′ ϵ ℘R n ω pn.t′ = αβη t} . Moreover, if t is in a certain μ- normal form 2, the estimate above is even true with equality, that is μ( t) yields the structural complexity of the maximal modularization of t, clearly the best a purely structural measure can do. μ-normal forms 2 do not always exist. The counterexample we give, however, clearly shows that μ does not only take into account the structural complexity of a prenormal term but also the nature and computationl complexity of the algorithm it represents.

A leaf-size hierarchy of two-dimensional alternating turing machines

This paper introduces a simple, natural complexity measure for space bounded two-dimensional alternating Turing machines, called “leaf-size”, and provides a hierarchy of complexity classes based on leaf-size bounded computations. Specifically, we show that for any positive integer k⩾1 and for any two functions L: N→ N and L′: N→ N such that (1) L is a two-dimensionally space-constructible function such that L( m) k+1 ⩽ m ( m⩾1), (2) lim m→∞L(m)L′(m) k log m=0 and (3) lim m→∞L′(m) L(m)=0 , L( m) space bounded and L( m>) k leaf-size bounded two-dimensional alternating Turing machines are more powerful than L( m) space bounded and L′( m) k leaf-size bounded two-dimensional alternating Turing machines.

On a complexity hierarchy between L and NL

This paper attempts to explain the complexity of the unary 0–1 knapsack problem which lies between L and NL. We introduce a new complexity class of languages log-space reducible to languages accepted by the family of one-way one-turn Nondeterministic auxiliary counter machines whose auxiliary worktapes are O( log n ) bounded. This complexity class is denoted by LOG(1-1-NAuxCM( log n )). We show that the modified unary knapsnack problem with bandwidth 2 O( log n ) is log-space complete for LOG(1-1-NAuxCM( log n )). By varying the space bound on the auxiliary worktape, we obtain a hierarchy of complexity classes between L and NL.

Arthur-Merlin games: A randomized proof system, and a hierarchy of complexity classes

Arthur-Merlin games: A randomized proof system, and a hierarchy of complexity classes

Automata-based computational complexity

Automata theory is the study of abstract computing devices, their organization, and their structure and computational power. Thus, automata theory is necessarily linked to other parts of mathematics which are concerned with “constructability,” but it goes further into the study of constructability by investigating a variety of abstract computing devices which perform these constructions, relating these devices to the algorithms they execute, and characterizing the simplicity of their operation. An important goal of automata theory is to understand the computational processes in relation to various classes of problems. The theory must go beyond the notion of computability and include some measure of the difficulty of the computation and how the difficulty is related to the organization of the machine that performs the computation. Two natural measures of the computational difficulty are the computation time and the amount of memory required to perform the computation on a given computing device. Both of these measures yield a rich computational complexity structure for the computable functions and a variety of results have been established about these complexity classes, their ordering, and their dependence on the organization of the computing device. Interesting applications of the memory-limited computations have been achieved in the study of context-free and context-sensitive languages, where several infinite hierarchies of complexity classes of these languages have been obtained.

Some Results on Tape-Bounded Turing Machines

Classes of tape-bounded Turing machines similar to the on-line and off-line Turing machines, but without the restrictions that each machine halt and be deterministic, are studied. It is shown that the lower bounds on tape complexity of [1] depend on neither the halting assumption nor determinism. The existence of a dense hierarchy of complexity classes likewise does not depend on the halting assumption, and it is shown that below log n tape complexity there exists a dense hierarchy of complexity classes for two-way nondeterministic devices. It is also shown that the complexity classes of one-way, nondeterministic machines below linear large complexity are not closed under complementation and are larger that the corresponding deterministic complexity class.