ACC0

Sketch of an ACC-circuit: For a fixed number m, the circuit consists of NOT-, AND-, OR-, and (Mod m)-Gates. The fan-in of each gate is bounded by a polynomial and the depth of the circuit is bounded by a constant.

ACC⁰, sometimes called ACC, is a class of computational models and problems defined in circuit complexity, a field of theoretical computer science. The class is defined by augmenting the class AC⁰ of constant-depth "alternating circuits" with the ability to count; the acronym ACC stands for "AC with counters".^[1] Specifically, a problem belongs to ACC⁰ if it can be solved by polynomial-size, constant-depth circuits of unbounded fan-in gates, including gates that count modulo a fixed integer. ACC⁰ corresponds to computation in any solvable monoid. The class is very well studied in theoretical computer science because of the algebraic connections and because it is one of the largest concrete computational models for which computational impossibility results, so-called circuit lower bounds, can be proved.

Definitions

Informally, ACC⁰ models the class of computations realised by Boolean circuits of constant depth and polynomial size, where the circuit gates includes "modular counting gates" that compute the number of true inputs modulo some fixed constant.

More formally, a language belongs to AC⁰[m] if it can be computed by a family of circuits C₁, C₂, ..., where C_n takes n inputs, the depth of every circuit is constant, the size of C_n is a polynomial function of n, and the circuit uses the following gates: AND gates and OR gates of unbounded fan-in, computing the conjunction and disjunction of their inputs; NOT gates computing the negation of their single input; and unbounded fan-in MOD-m gates, which compute 1 if the number of input 1s is a multiple of m. A language belongs to ACC⁰ if it belongs to AC⁰[m] for some m.

In some texts, ACCⁱ refers to a hierarchy of circuit classes with ACC⁰ at its lowest level, where the circuits in ACCⁱ have depth O(logⁱn) and polynomial size.^[1]

The class ACC⁰ can also be defined in terms of computations of nonuniform deterministic finite automata (NUDFA) over monoids. In this framework, the input is interpreted as elements from a fixed monoid, and the input is accepted if the product of the input elements belongs to a given list of monoid elements. The class ACC⁰ is the family of languages accepted by a NUDFA over some monoid that does not contain an unsolvable group as a subsemigroup.^[2]

Computational power

The class ACC⁰ includes AC⁰. This inclusion is strict, because a single MOD-2 gate computes the parity function, which is known to be impossible to compute in AC⁰. More generally, the function MOD_m can not be computed in AC⁰[p] for prime p unless m is a power of p.^[3]

The class ACC⁰ is included in TC⁰. It is conjectured that ACC⁰ is unable to compute the majority function of its inputs (i.e. the inclusion in TC⁰ is strict), but this remains unresolved as of July 2014.

Every problem in ACC⁰ can be solved by circuits of depth 2, with AND gates of polylogarithmic fan-in at the inputs, connected to a single gate computing a symmetric function.^[4] These circuits are called SYM⁺-circuits. The proof follows ideas of the proof of Toda's theorem.

Williams (2011) proves that ACC⁰ does not contain NEXPTIME. The proof uses many results in complexity theory, including the time hierarchy theorem, IP = PSPACE, derandomization, and the representation of ACC⁰ via SYM⁺ circuits.^[5]

It is known that computing the permanent is impossible for logtime-uniform ACC⁰ circuits, which implies that the complexity class PP is not contained in logtime-uniform ACC⁰.^[6]

Notes

1. Vollmer (1999), p. 126
2. Thérien (1981), Barrington & Thérien (1988)
3. Razborov (1987), Smolensky (1987)
4. Beigel & Tarui (1994)
5. Addendum to Arora, Barak textbook
6. Allender & Gore (1994)

References

• Allender, Eric (1996), "Circuit complexity before the dawn of the new millennium", 16th Conference on Foundations of Software Technology and Theoretical Computer Science,Hyderabad, India, December 18–20, 1996 (PDF), Lecture Notes in Computer Science 1180, Springer, pp. 1–18, doi:10.1007/3-540-62034-6_33
• Allender, Eric; Gore, Vivec (1994), "A uniform circuit lower bound for the permanent" (PDF), SIAM Journal on Computing 23 (5): 1026–1049, doi:10.1137/S0097539792233907
• Barrington, D.A. (1989), "Bounded-width polynomial-size branching programs recognize exactly those languages in NC¹" (PDF), Journal of Computer and System Sciences 38 (1): 150–164, doi:10.1016/0022-0000(89)90037-8.
• Barrington, David A. Mix (1992), "Some problems involving Razborov-Smolensky polynomials", in Paterson, M.S., Boolean function complexity, Sel. Pap. Symp., Durham/UK 1990., London Mathematical Society Lecture Notes Series 169, pp. 109–128, ISBN 0-521-40826-1, Zbl 0769.68041.
• Barrington, D.A.; Thérien, D. (1988), "Finite monoids and the fine structure of NC¹", Journal of the ACM 35 (4): 941–952, doi:10.1145/48014.63138
• Beigel, Richard; Tarui, Jun (1994), "On ACC", Computational Complexity 4: 350–366, doi:10.1007/BF01263423.
• Clote, Peter; Kranakis, Evangelos (2002), Boolean functions and computation models, Texts in Theoretical Computer Science. An EATCS Series, Berlin: Springer-Verlag, ISBN 3-540-59436-1, Zbl 1016.94046
• Razborov, A. A. (1987), "Lower bounds for the size of circuits of bounded depth with basis {⊕,∨}", Math. notes of the Academy of Science of the USSR 41 (4): 333–338.
• Smolensky, R. (1987), "Algebraic methods in the theory of lower bounds for Boolean circuit complexity", Proc. 19th ACM Symposium on Theory of Computing, pp. 77–82, doi:10.1145/28395.28404.
• Thérien, D. (1981), "Classification of finite monoids: The language approach", Theoretical Computer Science 14 (2): 195–208, doi:10.1016/0304-3975(81)90057-8.
• Vollmer, Heribert (1999), Introduction to Circuit Complexity, Berlin: Springer, ISBN 3-540-64310-9.
• Williams, Ryan (2011), "Non-uniform ACC Circuit Lower Bounds" (PDF), IEEE Conf. on Computational Complexity: 115–125, doi:10.1109/CCC.2011.36.