Characterizations Of Complexity Classes Research Articles

Complexity Column

Descriptive complexity theory initiated by celebrated Fagin's theorem aims to characterize complexity classes by the kind of logic necessary to express problems in the class. For many complexity classes such a characterization has been found; this includes the class NP that, according to Fagin's theorem, can be characterized by the monadic second order logic. Some classes, however, eludes such a characterization, and this famously includes the class P. Due to the importance of the class P, finding a logic for P is one of the central open problems in descriptive complexity.

Combining linear logic and size types for implicit complexity

Several type systems have been proposed to statically control the time complexity of lambda-calculus programs and characterize complexity classes such as FPTIME or FEXPTIME. A first line of research stems from linear logic and restricted versions of its !-modality controlling duplication. An instance of this is light linear logic for polynomial time computation [5]. A second approach relies on the idea of tracking the size increase between input and output, and together with a restricted recursion scheme, to deduce time complexity bounds. This second approach is illustrated for instance by non-size-increasing types [8]. However, both approaches suffer from limitations. The first one, that of linear logic, has a limited intensional expressivity, that is to say some natural polynomial time programs are not typable. As to the second approach it is essentially linear, more precisely it does not allow for a non-linear use of functional arguments. In the present work we incorporate both approaches into a common type system, in order to overcome their respective constraints. The source language we consider is a lambda-calculus with data-types and iteration, that is to say a variant of Gödel's system T. Our goal is to design a system for this language allowing both to handle non-linear functional arguments and to keep a good intensional expressivity. We illustrate our methodology by choosing the system of elementary linear logic (ELL) and combining it with a system of linear size types. We discuss the expressivity of this new type system, called sEAL, and prove that it gives a characterization of the complexity classes FPTIME and 2k-FEXPTIME, for k≥0.

Paths-based criteria and application to linear logic subsystems characterizing polynomial time

Several variants of linear logic have been proposed to characterize complexity classes in the proofs-as-programs correspondence. Light linear logic (LLL) ensures a polynomial bound on reduction time, and characterizes in this way polynomial time (Ptime). In this paper we study the complexity of linear logic proof-nets and propose three semantic criteria based on context semantics: stratification, dependence control and nesting. Stratification alone entails an elementary time bound, the three criteria entail together a polynomial time bound.These criteria can be used to prove the complexity soundness of several existing variants of linear logic. We define a decidable syntactic subsystem of linear logic: SDNLL. We prove that the proof-nets of SDNLL satisfy the three criteria, which implies that SDNLL is sound for Ptime. Several previous subsystems of linear logic characterizing polynomial time (LLL, mL4, maximal system of MS) are embedded in SDNLL, proving its Ptime completeness.

Reverse Complexity

Reverse Complexity is a long term research program aiming at discovering the abstract, logical principles underlying Complexity Theory, by means of a formal, reverse analysis of its proofs. The final goal is to get a cleaner, machine independent presentation of the foundation of Complexity Theory and a better, synergic integration with logic; in particular, we aim to provide abstract, axiomatic characterizations of Complexity Classes with the purpose to better grasp their essence, identify their distinctive properties, suggest new, possibly non-standard computational models and finally provide new tools for separating them. In this article, we introduce the program and illustrate its methodology through an investigation of the well known Hierarchy Theorems. The analysis is conducted with the assistance of an interactive theorem prover (in our case, Matita), not only used to check the formal correctness of proofs, but as an important driver of the actual research.

Characterizingco-NLby a group action

In a recent paper, Girard (2012) proposed to use his recent construction of a geometry of interaction in the hyperfinite factor (Girard 2011) in an innovative way to characterize complexity classes. We begin by giving a detailed explanation of both the choices and the motivations of Girard's definitions. We then provide a complete proof that the complexity classco-NLcan be characterized using this new approach. We introduce the non-deterministic pointer machine as a technical tool, a concrete model to compute algorithms.

The Complexity of Computing the Size of an Interval

Given a p-order $A$ over a universe of strings (i.e., a transitive, reflexive, antisymmetric relation such that if $(x, y) \in A$, then $|x|$ is polynomially bounded by $|y|$), an interval size function of $A$ returns, for each string $x$ in the universe, the number of strings in the interval between strings $b(x)$ and $t(x)$ (with respect to $A$), where $b(x)$ and $t(x)$ are functions that are polynomial-time computable in the length of $x$. By choosing sets of interval size functions based on feasibility requirements for their underlying p-orders, we obtain new characterizations of complexity classes. We prove that the set of all interval size functions whose underlying p-orders are polynomial-time decidable is exactly mP. We show that the interval size functions for orders with polynomial-time adjacency checks are closely related to the class FPSPACE(poly). Indeed, FPSPACE(poly) is exactly the class of all nonnegative functions that are an interval size function minus a polynomial-time computable function. We study two important functions in relation to interval size functions. The function mDIV maps each natural number $n$ to the number of nontrivial divisors of $n$. We show that mDIV is an interval size function of a polynomial-time decidable partial p-order with polynomial-time adjacency checks. The function mMONSAT maps each monotone boolean formula $F$ to the number of satisfying assignments of $F$. We show that mMONSAT is an interval size function of a polynomial-time decidable total p-order with polynomial-time adjacency checks. Finally, we explore the related notion of cluster computation.

What can be efficiently reduced to the Kolmogorov-random strings?

We investigate the question of whether one can characterize complexity classes (such as PSPACE or NEXP) in terms of efficient reducibility to the set of Kolmogorov-random strings R C . This question arises because PSPACE ⊆ P R C and NEXP ⊆ NP R C , and no larger complexity classes are known to be reducible to R C in this way. We show that this question cannot be posed without explicitly dealing with issues raised by the choice of universal machine in the definition of Kolmogorov complexity. What follows is a list of some of our main results. • Although Kummer showed that, for every universal machine U there is a time bound t such that the halting problem is disjunctive truth-table reducible to R C U in time t , there is no such time bound t that suffices for every universal machine U . We also show that, for some machines U , the disjunctive reduction can be computed in as little as doubly-exponential time. • Although for every universal machine U , there are very complex sets that are ≤ dtt P -reducible to R C U , it is nonetheless true that P = REC ∩ ⋂ U { A : A ≤ dtt P R C U } . (A similar statement holds for parity-truth-table reductions.) • Any decidable set that is polynomial-time monotone-truth-table reducible to R C is in P / poly . • Any decidable set that is polynomial-time truth-table reducible to R C via a reduction that asks at most f ( n ) queries on inputs of size n lies in P / ( f ( n ) 2 f ( n ) 3 log f ( n ) ) .

Neat function algebraic characterizations of logspace and linspace

We characterize complexity classes by function algebras that neither contain bounds nor any kind of variable segregation. The class of languages decidable in logarithmic space is characterized by the closure of a neat class of initial functions (projections and constants) under composition and simultaneous recursion on notation. We give a similar characterization of the class of number-theoretic 0--1 valued functions computable in linear space using simultaneous recursion on natural numbers in place of simultaneous recursion on notation.

Complexity Classes and Sparse Oracles

Complexity classes are usually defined by referring to computation models and by putting suitable restrictions on them. Following this approach, many proofs of results are tightly bound to the characteristics of the computation model and of its restrictions and therefore they sometimes hide the essential properties which ensure the obtained results. In order to obtain more general results, a uniform family of computation models which encompass most of the complexity classes of interest has been introduced in an earlier paper. As an initial set of results derivable from the proposed approach, a necessary and sufficient condition to prove the separation of relativized complexity classes, a characterization of complexity classes which admit a complete language, and a sufficient condition to prove the strong separation of relativized complexity classes have been presented in that paper. In this paper, we apply this approach to obtain positive relativization results, that is, results similar to those obtained in the literature. In particular, our goal is to prove statements of the kind: "Given two complexity classes C and D, C = D if and only if for every sparse set S, CS = DS." We derive a sufficient condition to prove such results and, as an application, we prove a general theorem from which all of the results obtained previously and new ones can be immediately derived.

Finite-model theory - a personal perspective

Finite-model theory is a study of the logical properties of finite mathematical structures. This paper is a very personalized view of finite-model theory, where the author focuses on his own personal history, and results and problems of interest to him, especially those springing from work in his Ph.D. thesis. Among the topics discussed are: 1. Differences between the model theory of finite structures and infinite structures. Most of the classical theorems of logic fail for finite structures, which gives us a challenge to develop new concepts and tools, appropriate for finite structures. 2. The relationship between finite-model theory and complexity theory. Surprisingly enough, it turns out that, in some cases, we can characterize complexity classes (such as NP) in terms of logic, where there is no notion of machine, computation, or time. 3. 0–1 laws. There is a remarkable phenomenon which says that certain properties (such as those expressible in first-order logic) are either almost surely true or almost surely false. 4. Descriptive complexity theory. Here we consider how complex a formula must be to express a given property. In recent years, there has been a re-awakening of interest in finite-model theory. One goal of this paper is to help “fan the flames” of interest, by introducing more researchers to this fascinating area.

Logical and schematic characterization of complexity classes

We consider classes of well-known program schemes from a complexity theoretic viewpoint. We define logics which express all those problems solvable using our program schemes and show that the class of problems so solved or expressed coincides exactly with the complexity classPSPACE (our problems are viewed as sets of finite structures over some vocabulary). We derive normal form theorems for our logics and use these normal form theorems to show that certain problems concerning acceptance and termination of our program schemes and satisfiability of our logical formulae arePSPACE-complete. Moreover, we show that a game problem, seemingly disjoint from logic and program schemes, isPSPACE-complete using the results described above. We also highlight similarities between the results of this paper and the literature, so providing the reader with an introduction to this area of research.

Characterizing complexity classes by general recursive definitions in higher types

General recursive definitions in higher (finite) types, a different notation of finitely typed λ-terms with if-then-else and fixpoints, can be classified into an infinite syntactic hierarchy: A definition is in the n th stage of this hierarchy, a so called rank n definition, iff n is an upper bound on the levels of the types occurring in it. We restrict attention to definitions of first-order functions, i.e., functions of type ind × … × ind → ind, ind for individuals; higher types only occur as detours in between. Interpreting these definitions over finite structures we show that rank ( n + 1) definitions characterize the complexity class of global functions ⋃ p(x) a poly DTIME ( exp n (p(x))) , where exp 0 ( x ) = x , exp n + 1 ( x ) = 2 exp n ( x ) . This generalizes the result of Y. Gurevich ( in “Proceedings, 24th Symposium on Foundations of Computer Science,” pp. 210–214, IEEE Comput. Soc. Press, New York, 1989) and V. Sazonov ( Elektron. Informationsverarb. Kybernet. 16 , 319–323, 1980) that rank 1 recursive definitions over finite structures characterize PTIME.

A uniform approach to define complexity classes

Complexity classes are usually defined by referring to computation models and by putting suitable restrictions on them. Following this approach, many proofs of results are tightly bound to the characteristics of the computation model and of its restrictions and, therefore, they sometimes hide the essential properties which insure the obtained results. In order to obtain more general results, a uniform family of computation models which encompasses most of the complexity classes of interest is introduced. As a first initial set of results derivable from the proposed approach, we will give a sufficient and necessary condition for proving separations of relativized complexity classes, a characterization of complexity classes with complete languages and a sufficient condition for proving strong separations of relativized complexity classes. Examples of applications of these results to some specific complexity classes are then given. Additional results related to separations by sparse oracles can be found in Bovet (1991).

Characterizing complexity classes by higher type primitive recursive definitions

Higher type primitive recursive definitions (also known as Gödel's system T) defining first-order functions (i.e. functions of type ind x…x ind→ind, ind for individuals, note that the higher types are used as detour to define first-order functions) can be classificed into an infinite syntactic hierarchy: A definition belongs to the nth stage of this hirarchy (is of rank n) iff n is an upper bound on the levels of the types occurring in it. We interpret these definitions over finite structures and show: Rank-1-definitions characterize LOGSPACE (in the sense of Gurevich (1983); in fact, this result is from his paper), rank-2 definitions characterize PTIME, rank-3 PSPACE and rank-4 EXPTIME (=DTIME(2 poly)).

REFINING KNOWN RESULTS ON THE GENERALIZED WORD PROBLEM FOR FREE GROUPS

We refine the known result that the generalized word problem for finitely-generated subgroups of free groups is complete for P via logspace reductions and show that by restricting the lengths of the words in any instance and by stipulating that all words must be conjugates then we obtain complete problems for the complexity classes NSYMLOG, NL, and P. The proofs of our results range greatly: some are complexity-theoretic in nature (for example, proving completeness by reducing from another known complete problem), some are combinatorial, and one involves the characterization of complexity classes as problems describable in some logic.

Logical Decision Problems and Complexity of Logic Programs

We survey and give new results on logical characterizations of complexity classes in terms of the computational complexity of decision problems of various classes of logical formulas. There are two main approaches to obtain such results: The first approach yields logical descriptions of complexity classes by semantic restrictions (to e.g. finite structures) together with syntactic enrichment of logic by new expressive means (like e.g. fixed point operators). The second approach characterizes complexity classes by (the decision problem of) classes of formulas determined by purely syntactic restrictions on the formation of formulas.

Equality Sets and Complexity Classes

If $h_1 $, $h_2 $ are two homomorphisms, then the equality set$\operatorname{Eq}(h_1 ,h_2 )$ of $h_1 $, $h_2 $ is $\operatorname{Eq} (h_1 ,h_2 ) = \{ w | h_1 (w) = h_2 (w)\} $. In this paper it is shown how to characterize complexity classes of formal languages in terms of equality sets of pairs of homomorphisms with bounded balance. In addition the complete twin shuffle language is investigated, and it is shown that for alphabets with at least two letters, this language cannot be represented as the equality set of a pair of homomorphisms unless both homomorphisms are erasing and have linear bounded balance.