No full-text available
To read the full-text of this research,
you can request a copy directly from the authors.
Finite monoids and the fine structure of NC
Abstract
Recently a new connection was discovered between the parallel complexity class NC ¹ and the theory of finite automata in the work of Barrington on bounded width branching programs. There (nonuniform) NC ¹ was characterized as those languages recognized by a certain nonuniform version of a DFA. Here we extend this characterization to show that the internal structures of NC ¹ and the class of automata are closely related.
In particular, using Thérien's classification of finite monoids, we give new characterizations of the classes AC ⁰ , depth- k AC ⁰ , and ACC , the last being the AC ⁰ closure of the mod q functions for all constant q . We settle some of the open questions in [3], give a new proof that the dot-depth hierarchy of algebraic automata theory is infinite [8], and offer a new framework for understanding the internal structure of NC ¹ .
... The "optimism period" produced many significant results. The classes AC 0 ⊂ ACC 0 ⊆ NC 1 were characterized by polynomial length programs over the aperiodic, the solvable, and all monoids respectively [Bar89,BT88]. More generally for any variety V of monoids (a variety being the undisputed best fit with the informal notion of a natural class of monoids) one can define the class P(V) of languages recognized by polynomial length programs over a monoid drawn from V. In particular, if A is the variety of aperiodic monoids, then P(A) characterizes the complexity class AC 0 [BT88]. ...
... The classes AC 0 ⊂ ACC 0 ⊆ NC 1 were characterized by polynomial length programs over the aperiodic, the solvable, and all monoids respectively [Bar89,BT88]. More generally for any variety V of monoids (a variety being the undisputed best fit with the informal notion of a natural class of monoids) one can define the class P(V) of languages recognized by polynomial length programs over a monoid drawn from V. In particular, if A is the variety of aperiodic monoids, then P(A) characterizes the complexity class AC 0 [BT88]. It was further observed that in a formal sense, only the regular languages matter for the purpose of understanding much of the structure of NC 1 (see for example [Str94]). ...
... Programs over varieties of monoids. Programs over monoids form a non-uniform model of computation, first defined by Barrington and Thérien [BT88], extending Barrington's permutation branching program model [Bar89]. Let M be a finite monoid and Σ a finite alphabet. ...
The program-over-monoid model of computation originates with Barrington's proof that it captures the complexity class NC. Here we make progress in understanding the subtleties of the model. First, we identify a new tameness condition on a class of monoids that entails a natural characterization of the regular languages recognizable by programs over monoids from the class. Second, we prove that the class known as DA satisfies tameness and hence that the regular languages recognized by programs over monoids in DA are precisely those recognizable in the classical sense by morphisms from QDA. Third, we show by contrast that the well studied class of monoids called J is not tame. Finally, we exhibit a program-length-based hierarchy within the class of languages recognized by programs over monoids from DA.
... • If m = 1, then AC 0 [6] ⊆ (BPAC 0 ) R . ...
... The problem is to simulate (i.e., output a string of measurement outcomes with nonzero probability) the sequence on a fixed initial state, and the complexity depends on the number of qubits. In particular, we show that simulating a sequence of Clifford gates on two qubits is NC 1 -complete, by first characterizing the group of two-qubit Clifford gates and applying a result of Barrington and Thérien [6]. We also show that simulating a particularly nice sequence of CNOT gates on n-qubits is ⊕L-hard, by a simple reduction from known ⊕L-hard problems [16]. ...
... However, the simulation problems outlined above are unsuitable because the natural quantum implementation (i.e., literally executing a sequence of classically-controlled Clifford gates, then measuring) is not constant depth. 6 We use an observation of Raussendorf, Browne, and Briegel [33] that their procedure for measurement-based quantum computation (MBQC) works without adaptivity for Clifford circuits. Ordinarily, MBQC introduces errors in the form of Pauli operators (they call them byproduct operators), which must be fixed adaptively, with a layer of adaptivity (or more) for each layer of the original circuit. ...
Recent work of Bravyi et al. and follow-up work by Bene Watts et al. demonstrates a quantum advantage for shallow circuits: constant-depth quantum circuits can perform a task which constant-depth classical (i.e., AC) circuits cannot. Their results have the advantage that the quantum circuit is fairly practical, and their proofs are free of hardness assumptions (e.g., factoring is classically hard, etc.). Unfortunately, constant-depth classical circuits are too weak to yield a convincing real-world demonstration of quantum advantage. We attempt to hold on to the advantages of the above results, while increasing the power of the classical model. Our main result is a two-round interactive task which is solved by a constant-depth quantum circuit (using only Clifford gates, between neighboring qubits of a 2D grid, with Pauli measurements), but such that any classical solution would necessarily solve L-hard problems. This implies a more powerful class of constant-depth classical circuits (e.g., AC for any prime p) unconditionally cannot perform the task. Furthermore, under standard complexity-theoretic conjectures, log-depth circuits and log-space Turing machines cannot perform the task either. Using the same techniques, we prove hardness results for weaker complexity classes under more restrictive circuit topologies. Specifically, we give QNC interactive tasks on and grids which require classical simulations of power NC and AC, respectively. Moreover, these hardness results are robust to a small constant fraction of error in the classical simulation. We use ideas and techniques from the theory of branching programs, quantum contextuality, measurement-based quantum computation, and Kilian randomization.
... In 2014, Hansen et al. used the characterization of Barrington and Thérien [2] and showed that bipartite perfect matching in graphs with bounded planar cutwidth is in ACC 0 [8]. They also gave a lower bound of AC 0 for the same problem. ...
... In Section 2 we will cover the preliminaries and notations that we will be using throughout the paper. We also discuss the work of Thérien and Barrington [2] and results from Hansen et al. [8]. In Section 3 we show the reduction of Parity to perfect matching in bipartite bounded planar cutwidth graphs. ...
... In the following year Barrington Part 2 of Theorem 2 is not directly stated in [2] but can be derived from their proof as also claimed in [8]. We will use these results to show that BGGM is not in AC 0 [p α ] where p is prime and α ∈ N. ...
Recently, perfect matching in bounded planar cutwidth bipartite graphs (\BGGM) was shown to be in ACC by Hansen et al.. They also conjectured that the problem is in AC. In this paper, we disprove their conjecture by showing that the problem is not in AC for every prime p. Our results show that the previous upper bound is almost tight. Our techniques involve giving a reduction from Parity to BGGM. A further improvement in lower bounds is difficult since we do not have an algebraic characterization for AC where m is not a prime power. Moreover, this will also imply a separation of AC from P. Our results also imply a better lower bound for perfect matching in general bounded planar cutwidth graphs.
... Our proof is based on leveraging the NC 1 -completeness of a classic problem: Unsolvable Automaton Membership Testing. According to Barrington's theorem [3,4], given a fixed unsolvable automaton, judging whether the automaton accepts an input is complete in NC 1 . Below, we will prove that solving the system of linear equations is NC 1 -hard by demonstrating that the Unsolvable Automaton Membership Testing problem is NC 0 reducible to the problem of solving a system of linear equations. ...
... If it is the variable x ki (k i ∈ [m]), then l i = k i , m 2 sin( 2kiπ m ), m 2 cos( 2kiπ m ) . 3. i and i 2 are the position embeddings and represent the position of the token in the sequence. 4. The constant embedding 1 is used as a bias term. ...
Recent studies have discovered that Chain-of-Thought prompting (CoT) can dramatically improve the performance of Large Language Models (LLMs), particularly when dealing with complex tasks involving mathematics or reasoning. Despite the enormous empirical success, the underlying mechanisms behind CoT and how it unlocks the potential of LLMs remain elusive. In this paper, we take a first step towards theoretically answering these questions. Specifically, we examine the capacity of LLMs with CoT in solving fundamental mathematical and decision-making problems. We start by giving an impossibility result showing that any bounded-depth Transformer cannot directly output correct answers for basic arithmetic/equation tasks unless the model size grows super-polynomially with respect to the input length. In contrast, we then prove by construction that autoregressive Transformers of a constant size suffice to solve both tasks by generating CoT derivations using a commonly-used math language format. Moreover, we show LLMs with CoT are capable of solving a general class of decision-making problems known as Dynamic Programming, thus justifying its power in tackling complex real-world tasks. Finally, extensive experiments on four tasks show that, while Transformers always fail to predict the answers directly, they can consistently learn to generate correct solutions step-by-step given sufficient CoT demonstrations.
... In the late eighties, Barrington and Thérien [3], building on Barrington's celebrated theorem [2], gave an interesting viewpoint on those conjectures, relying on algebraic automata theory. They defined the notion of a program over a monoid M : a sequence of instructions (i, f ), associating through function f some element of M to the letter at position i in the input of fixed length. ...
... Programs over monoids. Programs over monoids form a non-uniform model of computation, first defined by Barrington and Thérien [3], extending Barrington's permutation branching program model [2]. Let M be a finite monoid and Σ an alphabet. ...
The model of programs over (finite) monoids, introduced by Barrington and Th{\'e}rien, gives an interesting way to characterise the circuit complexity class and its subclasses and showcases deep connections with algebraic automata theory. In this article, we investigate the computational power of programs over monoids in , a small variety of finite aperiodic monoids. First, we give a fine hierarchy within the class of languages recognised by programs over monoids from , based on the length of programs but also some parametrisation of . Second, and most importantly, we make progress in understanding what regular languages can be recognised by programs over monoids in . We show that those programs actually can recognise all languages from a class of restricted dot-depth one languages, using a non-trivial trick, and conjecture that this class suffices to characterise the regular languages recognised by programs over monoids in .
... In that case, however, the tree or formula is fixed in advance and not allowed to change with the input. Nevertheless, our quantum algorithm for star-free languages implies that even the dynamic version of the AND-OR language (as well as the dynamic generalization of constant-depth Boolean formulas [8]) can be decided withΘ( √ n) queries and, moreover, there is an efficient quantum algorithm. Next consider the language of balanced parentheses, where the parentheses are only allowed to nest k levels deep. ...
... We also define a subset of the star-free languages, which we call the trivial languages. Intuitively, the trivial languages are those languages for which membership can be decided by the first and last characters of the input string, 8 which we formalize as those languages accepted by trivial regular expressions. A trivial regular expression is any Boolean combination of the languages a|aΣ * a, aΣ * b, and ε for a = b ∈ Σ. ...
We present a trichotomy theorem for the quantum query complexity of regular languages. Every regular language has quantum query complexity Theta(1), ~Theta(sqrt n), or Theta(n). The extreme uniformity of regular languages prevents them from taking any other asymptotic complexity. This is in contrast to even the context-free languages, which we show can have query complexity Theta(n^c) for all computable c in [1/2,1]. Our result implies an equivalent trichotomy for the approximate degree of regular languages, and a dichotomy--either Theta(1) or Theta(n)--for sensitivity, block sensitivity, certificate complexity, deterministic query complexity, and randomized query complexity. The heart of the classification theorem is an explicit quantum algorithm which decides membership in any star-free language in ~O(sqrt n) time. This well-studied family of the regular languages admits many interesting characterizations, for instance, as those languages expressible as sentences in first-order logic over the natural numbers with the less-than relation. Therefore, not only do the star-free languages capture functions such as OR, they can also express functions such as "there exist a pair of 2's such that everything between them is a 0." Thus, we view the algorithm for star-free languages as a nontrivial generalization of Grover's algorithm which extends the quantum quadratic speedup to a much wider range of string-processing algorithms than was previously known. We show applications to problems such as evaluating dynamic constant-depth Boolean formulas and recognizing balanced parentheses nested constantly many levels deep.
... Our second motivation is complexity-theoretic. Regular languages are well known to hold the key to much of the internal structure of the complexity class NC 1 of languages computed by families of logarithmic depth boolean circuits (see [29] for a pedagogical account of this fascinating connection). In particular, the complexity classes AC 0 , ACC 0 and NC 1 are captured by automata having aperiodic, solvable and nonsolvable so-called syntactic monoids [3,4] respectively. Another prominent subclass of NC 1 , the class TC 0 , that initially had no algebraic characterization because of the non-regularity of the MAJ language (of binary words having more ones that zeroes), was captured subsequently in the same algebraic framework by the introduction of typed monoids [25]. ...
... the CA results originating from [10]. 4 A language L is bounded if L ⊆ w * 1 w * 2 · · · w * k for some words w 1 , w 2 , . . . , w k . ...
The Parikh automaton model equips a finite automaton with integer registers and imposes a semilinear constraint on the set of their final settings. Here the theories of typed monoids and of rational series are used to characterize the language classes that arise algebraically. Complexity bounds are derived, such as containment of the unambiguous Parikh automata languages in NC1. Affine Parikh automata, where each transition applies an affine transformation on the registers, are also considered. Relying on these characterizations, the landscape of relationships and closure properties of the classes at hand is completed, in particular over unary languages.
... The class ACC 0 is one of the most important subclasses of NC 1 . Barrington's characterization of NC 1 in terms of constant-width branching programs [Bar89] highlighted the importance of algebraic considerations in studying small circuit complexity classes, and initiated a productive line of research reinforcing the connections between circuit complexity and formal language theory [BT88,BCST92,MPT91]. In this framework, computation over non-solvable monoids gives complete problems for NC 1 , while computation over solvable monoids yields problems in ACC 0 . ...
... The results in this paper seem to rule out characterizations in terms of crossing number, genus, or thickness. Algebraic approaches to circuit complexity tend to mimic the structure of regular sets, and it is known that any regular set that is not complete for NC 1 lies inside ACC 0 [Bar89], [BT88]; thus this avenue does not seem promising when searching for a characterization of TC 0 . One might attempt to follow the approach of [AAD00] Chapter 4 ...
In this thesis, we deal largely with complexity theoretic aspects in planar restrictions and obliviousness. Our main motivation was to identify problems for which the planar restriction is much easier, computationally, than the unrestricted version. First, we study constant width polynomial-sized circuits of low (polylogarithmic) genus; we show how such circuits characterize exactly the well-known circuit complexity class ACC0 (given that the unrestricted version captures the whole of NC1). We also give a new circuit characterization of the class NC1. Shifting our focus from circuits to graphs, we look at different notions of connectivity. We investigate the directed planar graph reachability problem, as a possibly more tractable special case of the arbitrary graph reachability problem (which is NL-complete). We prove that this problem logspace-reduces to its complement, and also that reachability questions on genus 1 graphs reduce to that in planar graphs. We also prove that reachability in a particularly simple class of planar graphs (namely, grid graphs) is no easier than the general directed planar reachability question. We then proceed to isolate to several large classes of planar graphs for which the reachability questions are solvable in deterministic logspace. Counting the number of spanning trees in a graph is a useful extension of the task of determining
... It thus suffices to show how n elements in a finite monoid can be multiplied with Θ(log n) depth. We show how a log-depth universal transformer can implement the standard binary tree construction (Barrington & Thérien, 1988;Liu et al., 2023; where each level multiplies two items, meaning the overall depth is Θ(log|w|). We will represent a tree over the input tokens within the transformer. ...
Recent theoretical results show transformers cannot express sequential reasoning problems over long input lengths, intuitively because their computational depth is bounded. However, prior work treats the depth as a constant, leaving it unclear to what degree bounded depth may suffice for solving problems over short inputs, or how increasing the transformer's depth affects its expressive power. We address these questions by analyzing the expressive power of transformers whose depth can grow minimally with context length n. We show even highly uniform transformers with depth can express two important problems: recognizing regular languages, which captures state tracking abilities, and graph connectivity, which underlies multi-step reasoning. Notably, both of these problems cannot be expressed by fixed-depth transformers under standard complexity conjectures, demonstrating the expressivity benefit of growing depth. Moreover, our theory quantitatively predicts how depth must grow with input length to express these problems, showing that depth scaling is more efficient than scaling width or chain-of-thought steps. Empirically, we find our theoretical depth requirements for regular language recognition match the practical depth requirements of transformers remarkably well. Thus, our results clarify precisely how depth affects transformers' reasoning capabilities, providing potential practical insights for designing models that are better at sequential reasoning.
... Then the data instances A over which the answer to q is yes form a language, L(q), over the alphabet 2 Ξ . In fact, using the automata-theoretic view of LTL (Vardi & Wolper, 1986), one can show (see Proposition 5 below) that the language L(q) is regular, and so can be decided in NC 1 (Barrington & Thérien, 1988; Barrington, 1989). ...
Our concern is the problem of determining the data complexity of answering an ontology-mediated query (OMQ) formulated in linear temporal logic LTL over (Z,<) and deciding whether it is rewritable to an FO(<)-query, possibly with some extra predicates. First, we observe that, in line with the circuit complexity and FO-definability of regular languages, OMQ answering in AC0, ACC0 and NC1 coincides with FO(<,≡)-rewritability using unary predicates x ≡ 0 (mod n), FO(<,MOD)-rewritability, and FO(RPR)-rewritability using relational primitive recursion, respectively. We prove that, similarly to known PSᴘᴀᴄᴇ-completeness of recognising FO(<)-definability of regular languages, deciding FO(<,≡)- and FO(<,MOD)-definability is also PSᴘᴀᴄᴇ-complete (unless ACC0 = NC1). We then use this result to show that deciding FO(<)-, FO(<,≡)- and FO(<,MOD)-rewritability of LTL OMQs is ExᴘSᴘᴀᴄᴇ-complete, and that these problems become PSᴘᴀᴄᴇ-complete for OMQs with a linear Horn ontology and an atomic query, and also a positive query in the cases of FO(<)- and FO(<,≡)-rewritability. Further, we consider FO(<)-rewritability of OMQs with a binary-clause ontology and identify OMQ classes, for which deciding it is PSᴘᴀᴄᴇ-, Π2p- and coNP-complete.
... Meanwhile, noncommuting 1QCs (i.e., without the classical side-processor), or rather classically conditioned single-qubit quantum circuits that compute a particular Boolean function, have a long history of study. Abaylev [17] and later Cosentino [18] showed that one can use either the A 5 subgroup of SU (2) or the subgroup generated by {H, T } in combination with Barrington's theorem [49,50] to compute any symmetric Boolean function with resource costs L C = n and T Q = poly(n). However, these methods work by dissecting a classical circuit of NOT and 2-bit AND gates and effectively achieve the same resource scaling as a related classical model, so-called width-5 classical branching programs. ...
The limited computational power of constant-depth quantum circuits can be boosted by adapting future gates according to the outcomes of mid-circuit measurements. We formulate computation of a variety of Boolean functions in the framework of adaptive measurement-based quantum computation using a cluster state resource and a classical side-processor that can add bits modulo 2, so-called l2-MBQC. Our adaptive approach overcomes a known challenge that computing these functions in the nonadaptive setting requires a resource state that is exponentially large in the size of the computational input. In particular, we construct adaptive l2-MBQC algorithms based on the quantum signal processing technique that compute the mod-p functions with the best known scaling in the space-time resources (i.e., qubit count, quantum circuit depth, classical memory size, and number of calls to the side-processor). As the subject is diverse and has a long history, the paper includes reviews of several previously constructed algorithms and recasts them as adaptive l2-MBQCs using cluster state resources. Our results constitute an alternative proof of an old theorem regarding an oracular separation between the power of constant-depth quantum circuits and constant-depth classical circuits with unbounded fan-in NAND and mod-p gates for any prime p.
... Programs over varieties of monoids. Programs over monoids form a non-uniform model of computation, first defined by Barrington and Thérien [BT88], extending Barrington's permutation branching program model [Bar89]. Let M be a finite monoid and Σ an alphabet. ...
The program-over-monoid model of computation originates with Barrington's
proof that the model captures the complexity class . Here we
make progress in understanding the subtleties of the model. First, we identify
a new tameness condition on a class of monoids that entails a natural
characterization of the regular languages recognizable by programs over monoids
from the class. Second, we prove that the class known as
satisfies tameness and hence that the regular languages recognized by programs
over monoids in are precisely those recognizable in the classical
sense by morphisms from . Third, we show by contrast that the
well studied class of monoids called is not tame. Finally, we
exhibit a program-length-based hierarchy within the class of languages
recognized by programs over monoids from .
... Circuits and regular languages. Since the works of Barrington and Thérien [2,5] in the early 1990s, regular languages have emerged as the backbone of small-depth circuit complexity. Despite being the most elementary class of languages, regular languages seem to embody the intrinsic power of circuit classes. ...
The regular languages with a neutral letter expressible in first-order logic with one alternation are characterized. Specifically, it is shown that if an arbitrary formula defines a regular language with a neutral letter, then there is an equivalent formula that only uses the order predicate. This shows that the so-called Central Conjecture of Straubing holds for over languages with a neutral letter, the first progress on the Conjecture in more than 20 years. To show the characterization, lower bounds against polynomial-size depth-3 Boolean circuits with constant top fan-in are developed. The heart of the combinatorial argument resides in studying how positions within a language are determined from one another, a technique of independent interest.
... pure-ACC circuits [Yao90]) have been a longstanding and fundamental roadblock in the way of improved circuit complexity lower bounds. Since their identification over 30 years ago [Bar86,BT87], scant progress has been made on lower bounds against CC 0 circuits, and their close cousin ACC 0 which includes AND and OR in the gate basis. Some exceptions include work focusing on special cases of the problem (e.g., [BBR94,GT00,CGPT06,CW09]), uniform lower bounds [AG94], and work proving strong lower bounds but only for functions whose complexity is in QuasiNP or higher (e.g., [Wil11,CP19,MW20,CLW20]). ...
What is the power of constant-depth circuits with gates, that can count modulo m? Can they efficiently compute MAJORITY and other symmetric functions? When m is a constant prime power, the answer is well understood: Razborov and Smolensky proved in the 1980s that MAJORITY and require super-polynomial-size circuits, where q is any prime power not dividing m. However, relatively little is known about the power of circuits for non-prime-power m. For example, it is still open whether every problem in EXP can be computed by depth-3 circuits of polynomial size and only gates. We shed some light on the difficulty of proving lower bounds for circuits, by giving new upper bounds. We construct circuits computing symmetric functions with non-prime power m, with size-depth tradeoffs that beat the longstanding lower bounds for circuits for prime power m. Our size-depth tradeoff circuits have essentially optimal dependence on m and d in the exponent, under a natural circuit complexity hypothesis. For example, we show for every that every symmetric function can be computed with depth-3 circuits of size, for a constant m depending only on . That is, depth-3 circuits can compute any symmetric function in \emph{subexponential} size. This demonstrates a significant difference in the power of depth-3 circuits, compared to other models: for certain symmetric functions, depth-3 circuits require size [H{\aa}stad 1986], and depth-3 circuits (for fixed prime power ) require size [Smolensky 1987]. Even for depth-two circuits, lower bounds were known [Barrington Straubing Th\'erien 1990].
... We also investigate the non-uniform variant of this problem (in the sense that the regular language L is fixed). In the late 1980s and early 1990s, several connections between classes of regular languages and circuit complexity classes were established [6,8,9]. For example, it was shown that all regular languages belong to NC 1 , all star-free languages belong to AC 0 , all regular languages whose syntactic monoid is solvable belong to ACC 0 , and there are regular languages that are NC 1 -complete. ...
For a formal language L, the problem of language enumeration asks to compute the length-lexicographically smallest word in L larger than a given input w ∈ Σ∗ (henceforth called the L-successor of w). We investigate this problem for regular languages from a computational complexity and state complexity perspective. We first show that if L is recognized by a DFA with n states, then 2Θ(nlog n) states are (in general) necessary and sufficient for an unambiguous finite-state transducer to compute L-successors. As a byproduct, we obtain that if L is recognized by a DFA with n states, then 2Θ(nlog n) states are sufficient for a DFA to recognize the subset S(L) of L composed of its lexicographically smallest words. We give a matching lower bound that holds even if S(L) is represented as an NFA. It has been known that L-successors can be computed in polynomial time, even if the regular language is given as part of the input (assuming a suitable representation of the language, such as a DFA). In this paper, we refine this result in multiple directions. We show that if the regular language is given as part of the input and encoded as a DFA, the problem is in NL. If the regular language L is fixed, we prove that the enumeration problem of the language is reducible to deciding membership to the Myhill-Nerode equivalence classes of L under DLOGTIME-uniform AC0 reductions. In particular, this implies that fixed star-free languages can be enumerated in AC0, arbitrary fixed regular languages can be enumerated in NC1 and that there exist regular languages for which the problem is NC1-complete.
... Let us quickly recap how [GS20] connects this problem to NC 1 -hard computation. First, a result of Barrington and Thérien shows that computing products in non-solvable groups is NC 1 -hard [BT88], even to distinguish between the product being the identity or some other predetermined group element. The 2-qubit Cliffords modulo 2-qubit Pauli operations, which we denote {C 2 P 2 }, turn out to be a non-solvable group (specifically, isomorphic to S 6 ). ...
Recent work by Bravyi et al. constructs a relation problem that a noisy constant-depth quantum circuit (QNC) can solve with near certainty (probability ), but that any bounded fan-in constant-depth classical circuit (NC) fails with some constant probability. We show that this robustness to noise can be achieved in the other low-depth quantum/classical circuit separations in this area. In particular, we show a general strategy for adding noise tolerance to the interactive protocols of Grier and Schaeffer. As a consequence, we obtain an unconditional separation between noisy QNC circuits and AC circuits for all primes , and a conditional separation between noisy QNC circuits and log-space classical machines under a plausible complexity-theoretic conjecture. A key component of this reduction is showing average-case hardness for the classical simulation tasks -- that is, showing that a classical simulation of the quantum interactive task is still powerful even if it is allowed to err with constant probability over a uniformly random input. We show that is true even for quantum tasks which are L-hard to simulate. To do this, we borrow techniques from randomized encodings used in cryptography.
... Thus, one can say that NC 1 is completely characterized via group theory. Moreover, this idea has been extended to characterize ACC 0 by solvable monoids [5]. On the other hand, the word problem of a finite p-group is in ACC 0 [p], so Smolensky's lower bound [50] implies that it is strictly easier than the word problem of a finite non-solvable group. ...
We give lower bounds on the complexity of the word problem of certain non-solvable groups: for a large class of non-solvable infinite groups, including in particular free groups, Grigorchuk's group and Thompson's groups, we prove that their word problem is -hard. For some of these groups (including Grigorchuk's group and Thompson's groups) we prove that the compressed word problem (which is equivalent to the circuit evaluation problem) is -complete.
... In the past, several intriguing links between so-called varieties of finite semigroups and the computational complexity of algebraic problems for such varieties were made. For example, the fixed membership problem for a regular language was shown to be in AC 0 if its syntactic monoid is aperiodic, in ACC 0 if the syntactic monoid is solvable and NC 1 -complete otherwise [7,9]. It is remarkable that in most results of this type, both the involved complexity classes and the algebraic varieties are natural. ...
We investigate the complexity of deciding, given a multiplication table representing a semigroup S, a subset X of S and an element t of S, whether t can be expressed as a product of elements of X. It is well-known that this problem is NL-complete and that the more general Cayley groupoid membership problem, where the multiplication table is not required to be associative, is P-complete. For groups, the problem can be solved in deterministic log-space which raised the question of determining the exact complexity of this variant. Barrington, Kadau, Lange and McKenzie showed that for Abelian groups and for certain solvable groups, the problem is contained in the complexity class FOLL and they concluded that these variants are not hard for any complexity class containing PARITY. The more general case of arbitrary groups remained open. In this work, we show that for both groups and for commutative semigroups, the problem is solvable in qAC^0 (quasi-polynomial size circuits of constant depth with unbounded fan-in) and conclude that these variants are also not hard for any class containing PARITY. Moreover, we prove that NL-completeness already holds for the classes of 0-simple semigroups and nilpotent semigroups. Together with our results on groups and commutative semigroups, this allows us to show that there is no natural complexity class which includes qAC^0, is strictly contained in NL and corresponds to a restriction of the Cayley semigroup membership problem to a variety of semigroups. We also discuss applications of our technique to FOLL.
... In 1988 Barrington [Bar85] showed that 5 − P-BP = NC 1 . Moreover, for deterministic branching programs, width 5 is necessary, unless NC 1 = ACC 0 [BT88]. Unrestricted branching programs are generally unexplored due to the lack of powerful proof methods. ...
... Here we are especially interested in the constant depth circuit complexity classes AC 0 , CC 0 , and ACC 0 that have tight connections to algebra via programs. For instance the class AC 0 is equal to the class of languages recognized by polynomial-length programs over finite aperiodic monoids [6]. Using these connections allowed the usage of algebraic methods in circuit complexity [5,4,3,14,21]. ...
We investigate in a method for proving separation results for abstract
classes of languages. A well established method to characterize varieties of
regular languages are identities. We use a recently established generalization
of these identities to non-regular languages by Gehrke, Grigorieff, and Pin: so
called equations, which are capable of describing arbitrary Boolean algebras of
languages.
While the main concern of their result is the existence of these equations,
we investigate in a general method that could allow to find equations for
language classes in an inductive manner.
Thereto we extend an important tool -- the block product or substitution
principle -- known from logic and algebra, to non-regular language classes.
Furthermore, we abstract this concept by defining it directly as an operation
on (non-regular) language classes. We show that this principle can be used to
obtain equations for certain circuit classes, given equations for the gate
types.
Concretely, we demonstrate the applicability of this method by obtaining a
description via equations for all languages recognized by circuit families that
contain a constant number of (inner) gates, given a description of the gate
types via equations.
... For the non-solvable case it was remarked in HLSVW93] that the famous proof of Barrington Ba89,BaTh88] about the NC 1 -completeness of width ve branching programs can be translated to the case of polynomial time machines, whose acceptance mechanism is given by a non-solvable group. However, the proof there was only formulated for the special case of the group A 5 of even permutations on ve elements. ...
We investigate the power of polynomial time machines whose acceptance mechanism is defined by a word problem over some finite semigroup, monoid, or group. For the case of non-solvable groups or monoids (semigroups, resp.) containing non-solvable groups it follows from [HLSVW93] that the according complexity class is PSPACE. For solvable monoids it was shown there that the according class is always a subclass of MOD-PH. We obtain the following results for finite groups: Commutative groups with k elements exactly characterize co-MOD k P, solvable groups with k elements characterize a class that contains co-MOD k P and is contained in (co-MOD k ) r P, the class obtained by r-fold iterated application of the co-MOD k -operator to P. Our results for finite monoids are the following: The classes characterized by commutative finite monoids are the eventually periodic counting classes (see Section 2 for definitions). If we restrict our attention to aperiodic commutative finite monoids, we ob...
... The latter is a finite solvable group, see Theorem 1. Hence, its word problem belongs to DLOGTIME-uniform TC 0 (actually ACC 0 ) by [8]. ...
The circuit evaluation problem (also known as the compressed word problem)
for finitely generated linear groups is studied. The best upper bound for this
problem is , which is shown by a reduction to polynomial
identity testing. Conversely, the compressed word problem for the linear group
is equivalent to polynomial identity testing. In
the paper, it is shown that the compressed word problem for every finitely
generated nilpotent group is in . Within
the larger class of polycyclic groups we find examples where the compressed
word problem is at least as hard as polynomial identity testing for skew
arithmetic circuits.
... In particular, we can show that MOD p / ∈ MOD(s, q)[Reg] if p is a prime that does not divide q, and that AND / ∈ MOD(0, q)[Reg]. The use of finite semigroups in circuit complexity originates in the work of Barrington [3] and Barrington and Thérien [6], who introduced a model of computation called a program over a finite monoid. For purposes of the present paper we will give a somewhat different definition of these programs, due to Péladeau, Straubing and Thérien [18] and indicate their connection with the Barrington-Thérien model. ...
We prove that a regular language defined by a Boolean combination of generalized Σ 1 -sentences built using modular counting quantifiers can be defined by a Boolean combination of Σ 1 -sentences in which only regular numerical predicates appear. The same statement, with “Σ 1 ” replaced by “first-order,” is equivalent to the conjecture that the nonuniform circuit complexity class ACC is strictly contained in NC 1 . The argument introduces some new techniques, based on a combination of semigroup theory and Ramsey theory, which may shed some light on the general case.
... The class of functions computed by such programs is a natural subclass of functions computable by programs over solvable groups. Starting with the famous and surprising work of Barrington [3] that showed the class of functions computed by polynomial length programs over finite non-solvable groups is exactly the complexity class NC 1 , programs over groups have been used (see for example [7,6]) to characterise natural subclasses of NC 1 . ...
Boolean functions that have constant-degree polynomial representation over a fixed finite ring form a natural and strict subclass of the complexity class ACC 0 . They are also precisely the functions computable efficiently by programs over fixed and finite nilpotent groups. This class is not known to be learnable in any reason-able learning model. In this paper, we provide a deterministic polynomial time algorithm for learning boolean functions represented by polynomials of constant degree over arbitrary finite rings from Membership queries, with the additional constraint that each variable in the target polynomial appears in a constant number of variables. Our algorithm extends to superconstant but low degree polynomials and still runs in quasipolynomial time.
... People also found various characterizations for languages in ACC 0 . Barrington and Thérien [BT88] showed that ACC 0 is captured exactly by bounded-width programs of polynomial size over solvable monoids, which confirmed that ACC 0 is the most natural subclass of NC 1 . (See Section 1.2 or [Bar89].) ...
We give lower bounds on the complexity of the word problem for a large class of non-solvable infinite groups that we call strongly efficiently non-solvable (SENS) groups. This class includes free groups, Grigorchuk’s group and Thompson’s groups. We prove that these groups have an -hard word problem and that for some of them (including Grigorchuk’s group and Thompson’s groups) the compressed word problem (which is equivalent to the circuit evaluation problem) is -complete.
Our concern is the problem of determining the data complexity of answering an ontology-mediated query (OMQ) formulated in linear temporal logic LTL over (Z,<) and deciding whether it is rewritable to an FO(<)-query, possibly with some extra predicates. First, we observe that, in line with the circuit complexity and FO-definability of regular languages, OMQ answering in AC^0, ACC^0 and NC^1 coincides with FO(<,\equiv)-rewritability using unary predicates x \equiv 0 (mod n), FO(<,MOD)-rewritability, and FO(RPR)-rewritability using relational primitive recursion, respectively. We prove that, similarly to known PSPACE-completeness of recognising FO(<)-definability of regular languages, deciding FO(<,\equiv)- and FO(<,MOD)-definability is also \PSPACE-complete (unless ACC^0 = NC^1). We then use this result to show that deciding FO(<)-, FO(<,\equiv)- and FO(<,MOD)-rewritability of LTL OMQs is EXPSPACE-complete, and that these problems become PSPACE-complete for OMQs with a linear Horn ontology and an atomic query, and also a positive query in the cases of FO(<)- and FO(<,\equiv)-rewritability. Further, we consider FO(<)-rewritability of OMQs with a binary-clause ontology and identify OMQ classes, for which deciding it is PSPACE-, Pi_2^p- and coNP-complete.
The PLP conjecture for monoids states that for every monoid M, either M is universal (that is, for every language there is a program over M which accepts the language L) or it has the polynomial length property (that is, every program over the monoid M has an equivalent program of length ). The conjecture has been confirmed (Tesson-Therien (2001)) for the case of groups and several subclasses of aperiodic monoids such as the variety DA and the monoids divided by the monoid U. However, the case of the set of monoids divided by the monoid is still open, which if resolved, confirms the conjecture for all aperiodic monoids.
The model of programs over (finite) monoids, introduced by Barrington and Thérien, gives an interesting way to characterise the circuit complexity class and its subclasses and showcases deep connections with algebraic automata theory. In this article, we investigate the computational power of programs over monoids in , a small variety of finite aperiodic monoids. First, we give a fine hierarchy within the class of languages recognised by programs over monoids from , based on the length of programs but also some parametrisation of . Second, and most importantly, we make progress in understanding what regular languages can be recognised by programs over monoids in . We show that those programs actually can recognise all languages from a class of restricted dot-depth one languages, using a non-trivial trick, and conjecture that this class suffices to characterise the regular languages recognised by programs over monoids in .
Fix an algebraic structure (A,⁎). Given a graph G=(V,E) and the labelling function ϕ (ϕ:E→A) for the edges, two nodes s, t∈V, and a subset F⊆A, the A-Reach problem asks if there is a path p (need not be simple) from s to t whose yield (result of the operation in the ordered set of the labels of the edges constituting the path) is in F. On the complexity frontier of this problem, we show the following results.
•When A is a group whose size is polynomially bounded in the size of the graph (hence equivalently presented as a multiplication table at the input), and the graph is undirected, the A-Reach problem is in L. Building on this, using a decomposition in [4], we show that, when A is a fixed quasi-group, and the graph is undirected, the A-Reach problem is in L. In a contrast, we show NL-hardness of the problem over bidirected graphs, when A is a matrix group over Q, or an aperiodic monoid.
•As our main theorem, we prove a dichotomy for graphs labelled with fixed aperiodic monoids by showing that for every fixed aperiodic monoid A, A-Reach problem is either in L or is NL-complete.
•We show that there exists a monoid M, such that the reachability problem in general DAGs can be reduced to A-Reach problem for planar non-bipartite DAGs labelled with M. In contrast, we show that if the planar DAGs that we obtain above are bipartite, the problem can be further reduced to reachability testing in planar DAGs and hence is in UL.
The computational complexity of the circuit and expression evaluation problem for finite semirings is considered, where semirings are not assumed to have an additive or a multiplicative identity. The following dichotomy is shown: If a finite semiring is such that (i) the multiplicative semigroup is solvable and (ii) it does not contain a subsemiring with an additive identity 0 and a multiplicative identity 1 ≠ 0, then the circuit evaluation problem is in DET ⊆ NC², and the expression evaluation problem for the semiring is in TC⁰. For all other finite semirings, the circuit evaluation problem is P-complete and the expression evaluation problem is NC¹-complete. As an application, we determine the complexity of intersection non-emptiness problems for given context-free grammars (regular expressions) with a fixed regular language.
We study the circuit evaluation problem (also known as the compressed word problem) for finitely generated linear groups. The best upper bound for this problem is coRP (the complements of problems in randomized polynomial time), which is shown by a reduction to polynomial identity testing for arithmetic circuits. Conversely, the compressed word problem for the linear group is equivalent to polynomial identity testing. In the paper, we show that the compressed word problem for every finitely generated nilpotent group is in . Within the larger class of polycyclic groups we find examples where the compressed word problem is at least as hard as polynomial identity testing for skew arithmetic circuits. It is a major open problem, whether polynomial identity testing for skew arithmetic circuits can be solved in polynomial time.
In this work, we study the power of bounded width branching programs by comparing them with bounded width skew circuits.
It is well known that branching programs of bounded width have the same power as skew circuit of bounded width. The naive approach converts a BP of width w to a skew circuit of width . We improve this bound and show that BP of width can be converted to a skew circuit of width 7. This also implies that skew circuits of bounded width are equal in power to skew circuits of width 7. For the other way, we prove that for any , a skew circuit of width w can be converted into an equivalent branching program of width w. We prove that width-2 skew circuits are not universal while width-3 skew circuits are universal and that any polynomial sized CNF or DNF is computable by width 3 skew circuits of polynomial size.
We prove that a width-3 skew circuit computing Parity requires exponential size. This gives an exponential separation between the power of width-3 skew circuits and width-4 skew circuits.
We investigate in a method for proving lower bounds for abstract circuit classes. A well established method to characterize varieties of regular languages are identities. We use a recently established generalization of these identities to non-regular languages by Gehrke, Grigorieff, and Pin: so called equations, which are capable of describing arbitrary Boolean algebras of languages. While the main concern of their result is the existence of these equations, we investigate in a general method that could allow to find equations for circuit classes in an inductive manner. Thereto we extend an important tool – the block product or substitution principle – known from logic and algebra, to non-regular language classes. Furthermore, we abstract this concept by defining it directly as an operation on (non-regular) language classes. We show that this principle can be used to obtain equations for certain circuit classes, given equations for the gate types. Concretely, we demonstrate the applicability of this method by obtaining a description via equations for all languages recognized by circuit families that contain a constant number of (inner) gates, given a description of the gate types via equations.
Fix an algebraic structure . Given a graph and the labelling function () for the edges, two nodes s, , and a subset , the -Reach problem asks if there is a path p (need not be simple) from s to t whose yield (result of the operation in the ordered set of the labels of the edges constituting the path) is in F. On the complexity frontier of this problem, we show the following results.
The problem of determining whether several finite automata accept a word in common is closely related to the well-studied membership problem in transformation monoids. We raise the issue of limiting the number of final states in the automata intersection problem. For automata with two final states, we show the problem to be ⊕ L-complete or NP-complete according to whether a nontrivial monoid other than a direct product of cyclic groups of order 2 is allowed in the automata. We further consider idempotent commutative automata and (Abelian, mainly) group automata with one, two, or three final states over a singleton or larger alphabet, elucidating (under the usual hypotheses on complexity classes) the complexity of the intersection nonemptiness and related problems in each case.
A proof system for a language L is a function f such that Range(f) is exactly L. In this article, we look at proof systems from a circuit complexity point of view and study proof systems that are computationally very restricted. The restriction we study is proof systems that can be computed by bounded fanin circuits of constant depth (NC⁰) or of O(log log n) depth but with O(1) alternations (poly log AC⁰). Each output bit depends on very few input bits; thus such proof systems correspond to a kind of local error correction on a theorem-proof pair.
We identify exactly how much power we need for proof systems to capture all regular languages. We show that all regular languages have poly log AC⁰ proof systems, and from a previous result (Beyersdorff et al. [2011a], where NC⁰ proof systems were first introduced), this is tight. Our technique also shows that Maj has poly log AC⁰ proof system.
We explore the question of whether Taut has NC⁰ proof systems. Addressing this question about 2TAUT, and since 2TAUT is closely related to reachability in graphs, we ask the same question about Reachability. We show that if Directed reachability has NC⁰ proof systems, then so does 2TAUT. We then show that both Undirected Reachability and Directed UnReachability have NC⁰ proof systems, but Directed Reachability is still open.
In the context of how much power is needed for proof systems for languages in NP, we observe that proof systems for a good fraction of languages in NP do not need the full power of AC⁰; they have SAC⁰ or coSAC⁰ proof systems.
We extend the familiar program of understanding circuit complexity in terms of regular languages to visibly counter languages. Like the regular languages, the visibly counter languages are - complete. We investigate what the visibly counter languages in certain constant depth circuit complexity classes are. We have initiated this in a previous work for . We present characterizations and decidability results for various logics and circuit classes. In particular, our approach yields a way to understand , where the regular approach fails.
We study the complexity of several of the classical graph decision problems in the setting of bounded cutwidth and how imposing planarity affects the complexity. We show that for 2-coloring, for bipartite perfect matching, and for several variants of disjoint paths, the straightforward NC
1 upper bound may be improved to AC
0[2], ACC
0, and AC
0 respectively for bounded planar cutwidth graphs. We obtain our upper bounds using the characterization of these circuit classes in tems of finite monoids due to Barrington and Thérien. On the other hand we show that 3-coloring and Hamilton cycle remain hard for NC
1 under projection reductions, analogous to the NP-completeness for general planar graphs. We also show that 2-coloring and (non-bipartite) perfect matching are hard under projection reductions for certain subclasses of AC
0[2]. In particular this shows that our bounds for 2-coloring are quite close.
We examine visibly counter languages, which are languages recognized by visibly counter automata (a.k.a. input driven counter automata). We are able to effectively characterize the visibly counter languages in AC0 and show that they are contained in FO[+].
We study a model of computation where executing a program on an input corresponds to calculating a product in a finite monoid. We show that in this model, the subsets of 0 ¡ 1 ¢ n that can be recognized by nilpotent groups have exponential cardinality. Translator’s Note: This is a translation of the article “Sur les langages reconnus par des groupes nilpotents, ” C. R. Acad.
We focus on basics of computational complexity and discuss some aspects of automata and formal language theory relevant to the subject under consideration. In particular we concentrate on auxiliary storage automata, which are resource-bounded Turing machines having free access to a separate storage device, typically a pushdown or a stack. Over the last 40 years, a vast literature documenting the ability of auxiliary storage automata to capture complexity classes has developed. In the present chapter, we tour a fragment of this literature. We thus come across characterizations of a wealth of complexity classes, including LOG(DCF), LOG(CF), the AC k -hierarchy, P, its nondeterministic counterpart NP, the polynomial hierarchy, and PSPACE. We do not prove these characterizations but we merely draw attention to the main ideas involved. Our tour of the subject therefore lacks completeness, and reflects our personal view of what constitute interesting links to complexity theory.
The problem of determining whether several finite automata accept a word in common is closely related to the well-studied membership problem in transformation monoids. We raise the issue of limiting the number of final states in the automata intersection problem. For automata with two final states, we show the problem to be L-complete or NP-complete according to whether a nontrivial monoid other than a direct product of cyclic groups of order 2 is allowed in the automata. We further consider idempotent commutative automata and (Abelian, mainly) group automata with one, two, or three final states over a singleton or larger alphabet, elucidating (under the usual hypotheses on complexity classes) the complexity of the intersection nonemptiness and related problems in each case.
The notion of a program over a finite semigroup has recently emerged from the work of D.A. Barrington on bounded-width branching programs [2], [3], and the joint work of D.A. Barrington and D. Thérien [4], [5]. These authors introduced programs over semigroups under the name of “non-uniform deterministic finite automata (NUDFA)”, and they studied the potential programs have in terms of recognizability of certain languages that are commonly treated in complexity theory by using families of Boolean circuits.
Eventual consistency aims to ensure that replicas of some mutable shared object converge without foreground synchronisation. Previous approaches to eventual consistency are ad-hoc and error-prone. We study a principled approach: to base the design of shared data types on some simple formal conditions that are sufficient to guarantee eventual consistency. We call these types Convergent or Commutative Replicated Data Types (CRDTs). This paper formalises asynchronous object replication, either state based or operation based, and provides a sufficient condition appropriate for each case. It describes several useful CRDTs, including container data types supporting both add and remove operations with clean semantics, and more complex types such as graphs and monotonic DAGs. It discusses some properties needed to implement non-trivial CRDTs.
We show that any language recognized by an NC ’ circuit (fan-in 2, depth O(log n)) can be recognized by a width-5 polynomial-size branching program. As any bounded-width polynomial-size branching program can be simulated by an NC ’ circuit, we have that the class of languages recognized by such programs is exactly nonuniform NC’. Further, following
The purpose of this paper is to study reducibilities that can be computed by combinational logic networks of polynomial size and constant depth containing AND’s, OR’s and NOT’s, with no bound placed on the fan-in of AND-gates and OR-gates. Two such reducibilities are defined, and reductions and equivalences among several common problems such as parity, sorting, integer multiplication, graph connectivity, bipartite matching and network flow are given. Certain problems are shown to be complete, with respect to these reducibilities, in the complexity classes deterministic logarithmic space, nondeterministic logarithmic space, and deterministic polynomial time. New upper bounds on the size-depth (unbounded fan-in) circuit complexity of symmetric Boolean functions are established.
We present optimal depth Boolean circuits (depth O(log O(log n)) for integer division, powering, and multiple products. We also show that these three problems are of equivalent uniform depth and space complexity. In addition, we describe an algorithm for testing divisibility that is optimal for both depth and space.
Ideas from combinatorial group theory are used to obtain a description of the languages recognized by nilpotent groups of class m.
We study two classes of unbounded fan-in parallel computation, the standard one, based on unbounded fan-in ANDs and ORs, and a new class based on unbounded fan-in threshold functions. The latter is motivated by a connectionist model of the brain used in Artificial Intelligence. We are interested in the resources of time and address complexity. Intuitively, the address complexity of a parallel machine is the number of bits needed to describe an individual piece of hardware. We demonstrate that (for WRAMs and uniform unbounded fan-in circuits) parallel time and address complexity is simultaneously equivalent to alternations and time on an alternating Turing machine (the former to within a constant multiple, and the latter a polynomial). In particular, for constant parallel time, the latter equivalence holds to within a constant multiple. Thus, for example, polynomial-processor, constant-time WRAMs recognize exactly the languages in the logarithmic time hierarchy, and polynomial-word-size, constant-time WRAMs recognize exactly the languages in the polynomial time hierarchy. As a corollary, we provide improved simulations of deterministic Turing machines by constant-time shared-memory machines. Furthermore, in the threshold model, the same results hold if we replace the alternating Turing machine with the analogous threshold Turing machine, and replace the resource of alternations with the corresponding resource of thresholds. Threshold parallel computers are much more powerful than the standard models (for example, with only polynomially many processors, they can compute the parity function and sort in constant time, and multiply two integers in O(log*n) time), and appear less amenable to known lower-bound proof techniques.
A super-polynomial lower bound is given for the size of circuits of fixed depth computing the parity function. Introducing the notion of polynomial-size, constant-depth reduction, similar results are shown for the majority, multiplication, and transitive closure functions. Connections are given to the theory of programmable logic arrays and to the relativization of the polynomial-time hierarchy.
The class NC consists of problems solvable very fast (in time polynomial in log n) in parallel with a feasible (polynomial) number of processors. Many natural problems in NC are known; in this paper an attempt is made to identify important subclasses of NC and give interesting examples in each subclass. The notion of NC1-reducibility is introduced and used throughout (problem R is NC1-reducible to problem S if R can be solved with uniform log-depth circuits using oracles for S). Problems complete with respect to this reducibility are given for many of the subclasses of NC. A general technique, the “parallel greedy algorithm,” is identified and used to show that finding a minimum spanning forest of a graph is reducible to the graph accessibility problem and hence is in NC2 (solvable by uniform Boolean circuits of depth O(log2n) and polynomial size). The class LOGCFL is given a new characterization in terms of circuit families. The class DET of problems reducible to integer determinants is defined and many examples given. A new problem complete for deterministic polynomial time is given, namely, finding the lexicographically first maximal clique in a graph. This paper is a revised version of S. A. Cook, (1983, in “Proceedings 1983 Intl. Found. Comut. Sci. Conf.,” Lecture Notes in Computer Science Vol. 158, pp. 78–93, Springer-Verlag, Berlin/New York).
A regular event is star-free if it can be denoted by a regular expression involvingonly Boolean operations and concatenation (dot). The family of star-free events can be constructed by alternately applying Boolean operations and concatenation. This approach leads to a hierarchy of star-free events, and to the definition of “dot-depth” of a star-free event which appears to be useful as a measure of the complexity of the event.Properties of dot-depth are examined; for example, it is shown that the dot-depthof a star-free event cannot be increased by the quotient operation with respect to any language, nor can it be increased by multiplying the event by a finite language. The use of two-sided quotients adds insight to the theory of star-free events and permits the derivation of some new properties of these events; in particular, every star-free event has at least one quotient which is either empty or full.The family of star-free events has been shown to be equivalent to the family ofregular noncounting events, and also corresponds to the family of finite automata whose semigroups have no nontrivial subgroups (group-fee automata). In the final section an algorithm is developed for constructing a star-free expression for the event accepted by a group-free finite automaton. An upper bound for the dot-depth of the event is found.We conjecture that for each n≥0, there exist star-free events of dot depth n. We have been able to show this only for n≤2; the general problem remains open.
An alternative definition is given for a family of subsets of a free monoid that has been considered by Trahtenbrot and by McNaughton.
Let A be a finite alphabet and A∗ the free monoid generated by A. A language is any subset of A∗. Assume that all the languages of the form {a}, where a is either the empty word or a letter in A, are given. Close this basic family of languages under Boolean operations; let (0) be the resulting Boolean algebra of languages. Next, close (0) under concatenation and then close the resulting family under Boolean operations. Call this new Boolean algebra (1), etc. The sequence (0), (1),…, k,… of Boolean algebras is called the dot-depth hierarchy. The union of all these Boolean algebras is the family of star-free or aperiodic languages which is the same as the family of noncounting regular languages. Over an alphabet of one letter the hierarchy is finite; in fact, (2) = (1). We show in this paper that the hierarchy is infinite for any alphabet with two or more letters.
The computation of finite semigroups using unbounded fan-in circuits are considered. There are constant-depth, polynomial size circuits for semigroup product iff the semigroup does not contain a nontrivial group as a subset. In the case that the semigroup in fact does not contain a group, then for any primitive recursive function f circuits of size O(nf−1(n)) and constant depth exist for the semigroup product of n elements. The depth depends upon the choice of the primitive recursive function f. The circuits not only compute the semigroup product, but every prefix of the semigroup product. A consequence is that the same bounds apply for circuits computing the sum of two n-bit numbers.
We use algebraic methods to get lower bounds for complexity of different functions based on constant depth unbounded fan-in circuits with the given set of basic operations. In particular, we prove that depth k circuits with gates NOT, OR and MODp where p is a prime require Exp(&Ogr;(n1/2k)) gates to calculate MODr functions for any r ≠ pm. This statement contains as special cases Yao's PARITY result [ Ya 85 ] and Razborov's new MAJORITY result [Ra 86] (MODm gate is an oracle which outputs zero, if the number of ones is divisible by m).
This paper is a contribution to the problem of effectively determining the dot-depth of a star-free language, a problem in the theory of automata and formal languages with close connections to algebra and formal logic. We conjecture an effective criterion for determining whether a given language has dot-depth 2. The condition is shown to be necessary in general, and sufficient for languages over a two-letter alphabet. The condition involves a novel use of categories in the study of semigroup-theoretic problems.
It ~S shown how to determine membership in any parenthesis context-free language in log space As an apphcatton, the evaluation of Boolean sentences ~s shown to be log space computable Log space translatton of parenthesis languages ~s slmdarly shown to be possible, thus log space translators among various representations of Boolean formulas may be constructed
This is the seventeenth edition of a (usually) quarterly column that covers new developments in the theory of NP-completeness. The presentation is modeled on that used by M. R. Garey and myself in our book "Computers and Intractability: A Guide to the Theory of NP-Completeness," W. H. Freeman & Co., New York 1979 (hereinafter referred to as "[G&J]"; previous columns will be referred to by their dates). A background equivalent to that provided by [G&J] is assumed, and, when appropriate, cross-references will be given to that book and the list of problems (NP-complete and harder) presented there. Readers who have results they would like mentioned (NP-hardness, PSPACE-hardness, polynomial-time-solvability, etc.) or open problems they would like publicized, should send them to David S. Johnson, Room 2C-355, AT&T Bell Laboratories, Murray Hill, NJ 07974 (or to dsjbtl.csnet). Please include details, or at least sketches, of any new proofs; full papers are preferred. If the results are unpublished, please state explicitly that you are willing for them to be mentioned. Comments and corrections are also welcome. For more details on the nature of the column and the form of desired submissions, see the December 1981 issue of this Journal.
This is the sixth edition of a quarterly column the purpose of which is to provide continuing coverage of new developments in the theory of NP-completeness. The presentation is modeled on that used by M. R. Garey and myself in our book “Computers and Intractability: A Guide to the Theory of NP-Completeness,” W. H. Freeman & Co., San Francisco, 1979 (hereinafter referred to as “[G&J]”; previous columns will be referred to by their dates). A background equivalent to that provided by [G&J] is assumed, and, when appropriate, cross-references will be given to that book and the list of problems (NP-complete and harder) presented there. Readers who have results they would like mentioned (NP-hardness, PSPACE-hardness, polynomial-time-solvability, etc.), or open problems they would like publicized, should send them to David S. Johnson, Room 2C-355, Bell Laboratories, Murray Hill, NJ 07974, including details, or at least sketches, of any new proofs (full papers are preferred). In the case of unpublished results, please state explicitly that you would like the results to be mentioned in the column. Comments and corrections are also welcome. For more details on the nature of the column and the form of desired submissions, see the December 1981 issue of this Journal.
Let 9= variables, for each n 3 1.Let p4(n) be the minimum number of variables off, that each have to be set to constant values so that the resulting function is a constant function. We show that the growth rate of p s ( n ) completely determines whether or not the family 9 is'good', that is, can be realized by a family of constant-depth, polynomial-size circuits (with unbounded fan-in). Furthermore, if p s ( n ) S (log n ) k for some k, then the family 9 is good. However, if p s ( n ) 2 n'for some E > 0, then the family is not good.
The concept of a ∗-variety of congruences is introduced and related to ∗-variety of languages and variety of monoids. A systematic construction of increasingly complex ∗-varieties of congruences is presented. This construction is powerful enough to generate all monoids containing solvable groups. Some hierarchies occurring through this process are shown to correspond to well-known hierarchies of monoids, thus indicating that our construction is natural from an algebraic point of view. Some problems that remain open are also discussed.
: We give improved lower bounds for the size of small depth circuits computing several functions. In particular we prove almost optimal lower bounds for the size of parity circuits. Further we show that there are functions computable in polynomial size and depth k but requires exponential size when the depth is restricted to k Gamma 1. Our Main Lemma which is of independent interest states that by using a random restriction we can convert an AND of small ORs to an OR of small ANDs and conversely. Warning: Essentially this paper has been published in Advances for Computing and is hence subject to copyright restrictions. It is for personal use only. 1. Introduction Proving lower bounds for the resources needed to compute certain functions is one of the most interesting branches of theoretical computer science. One of the ultimate goals of this branch is of course to show that P 6= NP . However, it seems that we are yet quite far from achieving this goal and that new techniques have to...
It S shown how to determine membership in any parenthesis context-free language in log space As an apphcaton, the evaluation of Boolean sentences is shown to be log space computable Log space translanon of parenthess languages s slmdarly shown to be possible, thus log space translators among various representations of Boolean formulas may be constructed KEY WORDS AND PHRASES log space, parenthess grammars, parenthess languages CR CATEGORIES' 5 23, 5 25, 5 26 1.
Finite monoids and Boolean circuit complexity
- H Straubing
STRAUBING, H. Finite monoids and Boolean circuit complexity. Manuscript, Boston College (1986).
STRAUBING H. Finite monoids and Boolean circuit complexity
- H Straubing