Log In Sign Up

Model-Theoretic Characterizations of Boolean and Arithmetic Circuit Classes of Small Depth

In this paper we give a characterization of both Boolean and arithmetic circuit classes of logarithmic depth in the vein of descriptive complexity theory, i.e., the Boolean classes NC^1, SAC^1 and AC^1 as well as their arithmetic counterparts #NC^1, #SAC^1 and #AC^1. We build on Immerman's characterization of constant-depth polynomial-size circuits by formulas of first-order logic, i.e., AC^0 = FO, and augment the logical language with an operator for defining relations in an inductive way. Considering slight variations of the new operator, we obtain uniform characterizations of the three just mentioned Boolean classes. The arithmetic classes can then be characterized by functions counting winning strategies in semantic games for formulas characterizing languages in the corresponding Boolean class.


page 1

page 2

page 3

page 4


New Bounds for Energy Complexity of Boolean Functions

For a Boolean function f:{0,1}^n →{0,1} computed by a circuit C over a...

Parameterized Valiant's Classes

We define a theory of parameterized algebraic complexity classes in anal...

On the complexity of detecting hazards

Detecting and eliminating logic hazards in Boolean circuits is a fundame...

Functional lower bounds for restricted arithmetic circuits of depth four

Recently, Forbes, Kumar and Saptharishi [CCC, 2016] proved that there ex...

The canonical pairs of bounded depth Frege systems

The canonical pair of a proof system P is the pair of disjoint NP sets w...

Rectifying Mono-Label Boolean Classifiers

We elaborate on the notion of rectification of a Boolean classifier Σ. G...

Efficient Deobfuscation of Linear Mixed Boolean-Arithmetic Expressions

Mixed Boolean-Arithmetic (MBA) expressions are frequently used for obfus...

1 Introduction

The computational power of arithmetic circuits is of current focal interest in computational complexity theory, see the recent surveys [15, 12] or the continuously updated collection of results at [17]. A number of very powerful techniques to prove lower bounds for such circuits have been developed, however only for quite restricted classes.

A long line of research in computational complexity is to characterize complexity classes in a model-theoretic way. Instead of constructing a computational device such as a Turing machine or a family of circuits

deciding a language , a formula is built that defines the property of those words in

. Best-known is probably Fagin’s Theorem stating that languages in

NP are exactly those that can be defined in existential second-order logic. More important for this paper is Immerman’s theorem, in which the circuit class of all languages decidable by Boolean circuits of polynomial size and constant depth is addressed: Immerman showed that equals the class of languages definable by first-order formulae: [10]. The rationale behind this area of descriptive complexity, as it is called, is to characterize complexity classes in a model-theoretic way in order to better understand their structure, and to use logical methods in order to get new insights about the considered classes and, most prominently, to obtain lower bounds, see the monographs [11, 14]. The famous lower bound for , showing that the parity function cannot be computed by such circuit families [8], was obtained independently by Ajtai [1] in a purely logical way.

For arithmetic circuit classes, only one descriptive complexity characterization is known to date. Generalizing in a sense Immerman’s Theorem, it was shown very recently that the class of those functions from binary words to natural numbers computable by polynomial-size constant-depth arithmetic circuits with plus and times gates is equal to the class of those functions computing winning strategies in semantic games for first-order formulae: [9]. A different way to view this result is to say that is the class of functions counting Skolem functions for FO-formulae.

Central for this result is a way of looking at arithmetic computation as a counting process: Say that a proof tree of a Boolean circuit for a given input word is a minimal subtree (of the circuit unfold into a tree) witnessing that the circuit outputs on input , and let denote the number of such proof trees. It is folklore that consists of those functions counting proof trees for -circuits. To prove the mentioned result from [9], a formula has to be constructed whose number of winning strategies (or, number of Skolem functions) equals the number of proof trees of the original circuit.

The aim of this paper is to generalize the theorem to larger circuit classes, in particular the classes , and , defined by families of arithmetic circuits of polynomial size and logarithmic depth with bounded fan-in addition and multiplication gates (for ), unbounded fan-in addition and bounded fan-in multiplication gates (), and unbounded fan-in addition and multiplication gates (), see [18]. The mentioned equality between the value computed by an arithmetic circuit and the number of proof trees of the corresponding Boolean circuit does not only hold in the case of the class but is a general observation. Thus, a reasonable roadmap to obtain our generalization seems to study logical characterizations of the corresponding decision classes , and . Such characterizations can be found in the literature: can be characterized by an extension of first-order logic by so called monoidal quantifiers [3], and similarly by extending FO by groupoidal quantifiers [13]. However, for such logics with generalized quantifier the notion of winning strategy is not clear. Following a completely different approach, Immerman extended first-order logic by allowing repeated quantifier blocks and thus characterized [10]. Here it can be said that in Immerman’s notation, , but this result cannot be transfered to the other log-depth classes and . Hence we have to start by developing new logical characterizations for the Boolean classes , and .

Inspiration comes from a result by Compton and Laflamme, characterizing by FO logic augmented with the RPR-operator allowing to define relations by a certain kind of linear recursion [5] (RPR stands for relational primitive recursion). This approach does not generalize to the classes and , though. Also, the number of winning strategies does not seem to be related to the number of proof trees; so again, their approach is not suitable for our aim. Instead, we consider a new operator, called GPR (“guarded predicative recursion”), allowing to define relations by a certain kind of parallel recursion. We show that , first-order logic augmented by GPR, characterizes , and that slight modifications of the GPR-operator lead to characterizations of and . In a second step, we show that these characterizations are in a sense “close enough” to the circuit world to mirror the process of counting proof trees by counting winning strategies in semantic games.

Our paper is structured as follows. In the next section, we will give the necessary preliminaries from first order logic and circuit complexity including the respective counting mechanism. In Sect. 3 we briefly recall the result by Compton and Laflamme and then introduce our inductive operator GPR. To demonstrate suitability of our logical approach, we give an example of a formula defining an -complete problem. We then prove our main results: In Sect. 4 we characterize the Boolean classes , and in a model-theoretic way by first-order logic with different forms of the GPR-operator. This is the technically most demanding part of our paper. We would like to stress that our proofs are completely different from the one for the mentioned result from Compton and Laflamme [5]. In Sect. 5 we characterize the arithmetic classes , and by counting winning-strategies in semantic games for the above logics. Finally, we conclude with a summary and some open problems.

2 Preliminaries

In this paper we will use first-order logic FO with usual syntax and semantics, see, e.g., [7]. We consider finite σ-structures where σ is a finite vocabulary consisting of relation and constant symbols. For a structure , denotes its universe. We will always use structures with universe for some . Furthermore, we will always assume that our structures contain the built-in relation , which is implicitly interpreted in the expected way: is true, iff the ’th bit of the binary representation of is 1. When talking about structures with built-in relations, includes the interpretation of the built-in relations in the intended way.

We assume the standard encoding of structures as binary strings (see, e.g., [11]): Relations are encoded row by row by listing their truth values as 0’s and 1’s. Constants are encoded by the binary representation of their value and thus a string of length . A whole structure is encoded by the concatenation of the encodings of its relations and constants except for numerical predicates and constants: These are not encoded, because they are determined by the input length.

Since we want to talk about languages accepted by Boolean circuits, we will need the vocabulary

of binary strings. A binary string is represented as a structure over this vocabulary as follows: Let with . Then the structure representing this string is the structure with universe , interpreted as the -relation on ℕ restricted to the universe and , iff the ’th bit of is 1. The structure corresponding to string is denoted by . Also, by the above, is the encoding of structure .

We denote by FO not only the set of first-order formulae, but also the complexity class of all languages definable in first-order logic with built-in BIT: A language is in FO if there is an FO-formula φ over vocabulary such that for all :

We will also use relativized quantifiers. A relativization of a quantifier is a formula restricting the domain of elements considered for that quantifier. More precisely, we write

as a shorthand for and, respectively,

as a shorthand for .

Furthermore, we consider bounded variants of relativized quantifiers, that is, quantifiers where we only consider the maximal two elements meeting the condition expressed by the relativization. Notation: , . Formally, the semantics can be given in FO as follows:

For the definition of uniform circuit families we will need FO-interpretations, which are mappings between structures over different vocabularies.

Let σ, τ be vocabularies, . A first-order interpretation (or FO-interpretation)

is given by a tuple of FO-formulae over vocabulary σ. For some , has free variables and has free variables for all . For each structure , these formulae define the structure

where the universe is defined by and the relations by in the following way:

For better readability, we will write instead of and instead of for all .

We will next recall the definition of Boolean circuits and complexity classes defined using them. A circuit is a directed acyclic graph (dag), whose nodes (also called gates) are marked with either a Boolean function (in our case or ), a constant (0 or 1), or a (possibly negated) bit of the input. Also, one gate is marked as the output gate. On any input, a circuit computes a Boolean function by evaluating all gates according to what they are marked with. The value of the output gate then is the function value for that input. If is a circuit, we denote the function it computes by .
When we want circuits to work on different input lengths, we have to consider families of circuits: A family contains a circuit for any input length . Families of circuits allow us to talk about languages being accepted by circuits: A circuit family is said to accept (or decide) the language

, if it computes its characteristic function


The complexity classes in circuit complexity are classes of languages that can be decided by circuit families with certain restrictions to their resources. The resources relevant here are depth, size and fan-in (number of children) of gates. The depth here is the length of a longest path from any input gate to the output gate of a circuit and the size is the number of non-input gates in a circuit. Depth and size of a circuit family are defined as functions accordingly.
Above, we have not restricted the computability of the circuit from in any way. This is called non-uniformity, which allows such circuit families to even compute non-recursive functions. Since we want to capture a kind of efficient computability, we need some notion of uniformity. For this, we first define the vocabulary for Boolean circuits as FO-structures:

where the relations are interpreted as follows:

  • : gate is a child of gate

  • : gate is an and-gate

  • : gate is an or-gate

  • : gate is an input gate associated with the ’th input bit

  • : gate is a negated input gate associated with the ’th input bit

  • : gate is the output gate

We will now define FO-uniformity of Boolean circuits and the complexity classes relevant in this paper.

A circuit family is said to be first-order uniform (FO-uniform) if there is an FO-interpretation

mapping any structure over with built-in BIT to the circuit given as a structure over the vocabulary .

Note that by [2] this uniformity coincides with the maybe better known DLOGTIME-uniformity for many familiar circuit classes (and in particular for all classes studied in this paper). All circuit classes we consider in this paper are FO-uniform.

A language is in if there is an FO-uniform circuit family with depth and polynomial size accepting . is defined analogously with bounded fan-in gates. is defined analogously with bounded fan-in ∧-gates and unbounded fan-in ∨-gates. We will also call circuit families with the above restrictions on their resources , and circuit families, respectively.

For this paper, the classes , , and are of particular interest. It is known that the class coincides with the class FO [3, 11]: .

We will next define counting variants of the above classes. The idea for counting classes in general is to use a model of computation and identify a kind of witness for acceptance in that model. For a nondeterministic Turing machine, we usually consider the accepting paths on a given input as witnesses. Considering polynomial time computations, this concept gives rise to the class #P. A witness that a Boolean circuit accepts its input is a so-called proof tree: a minimal subtree of the circuit showing that it evaluates to true for a given input. For this, we first unfold the given circuit into tree shape, and we further require that it is in negation normal form (meaning that negations only occur directly in front of literals)—note that this is always the case for -structures, though. A proof tree then is a subtree that contains the output gate, for every included -gate exactly one child and for every included -gate all children, such that every input gate which we reach in this way is a true literal. This allows us to define the following counting complexity classes:

A function is in (, ) if there is an (, ) circuit family such that for all ,

Note that, already at the first level, the classes , , , though based on relatively close circuit classes, have a rather different computational power. It can be seen, through the connections between circuits and multiplicatively disjoint circuits (see [16]) that and are subclasses of . On the contrary, the class can output numbers bigger than for input of size , hence numbers of super-polynomial sizes in . This comes from the fact that the unfolding of a polynomial size, logarithmic depth circuit with unbounded fan-in may be of size . This means that .

Similarly, one can identify witnesses for acceptance in first-order logic. One possibility for this is to do this in terms of the model-checking game defined as follows. The model checking game for FO is the two-player game with the players “verifier” and “falsifier” played recursively on any FO formula φ and input structure . The verifier tries to reach an atom that is satisfied while the falsifier tries to reach an atom that is not satisfied. For this, the game starts on the whole formula. From there, depending on the outermost operator or quantifier, one of the players makes a choice and the game continues on a certain sub-formula. The rules for this are as follows:

  • : verifier chooses a value for , continue on ψ

  • : falsifier chooses a value for , continue on ψ

  • : verifier chooses whether to continue with or

  • : falsifier chooses whether to continue with or

  • : verifier and falsifier swap roles, continue on

  • For any atom : verifier wins if it is true, falsifier wins otherwise

In this game the verifier has a winning strategy—that is, a strategy that lets him win the game independent of the choices of the opponent—if and only if . This means that winning strategies in this game can be seen as witnesses for acceptance in first-order logic, which allows us to define a counting class based on FO.

A function is in #Win-FO, if there is an FO-formula φ over vocabulary such that for all :

where is the number of winning strategies of the verifier in the model checking game for .

As was shown in [9], the counting versions of and FO coincide, i.e.: .

For the quantifiers and we define the following rules in the model checking game for FO: Here, the choosing player is restricted to the maximal two elements satisfying the relativization.

3 Gpr

We aim to characterize counting classes from circuit complexity beyond by counting winning strategies in different logics. It has been proved in [5] that can be characterized using FO with a certain kind of linear recursion, called relational primitive recursion (RPR). It allows the recursive definition of predicates in the following way:

where intuitively, has the same truth value as for and being equivalent to . Then, denotes the class of languages definable by formula of the form:

where is first-order and make use of the inductively defined . Over structures with built-in BIT, it holds that [5]. This characterization does not immediately generalize to classes and as well as counting classes. However, inspired by this, we define a different kind of inductive definition called guarded predicative recursion, GPR for short, that allows us to capture all these classes in a unified way.

[GPR ] A formula if it is of the form:

where and with free variables such that each atomic sub-formula involving symbol

  1. is of the form where is in the scope of a guarded quantification with and

  2. never occur in the scope of any quantification not guarded in this way.

We also call the part in a GPR-operator. We define similary by allowing only bounded variants for guarded quantification and for which universal guarded and bounded existential guarded quantifications are allowed.

This approach is flexible enough to easily express problems computable by small circuit classes.

The shortcake problem, proved -complete in [4] is defined as follows. Two players, (or ) and (or ) are alternately moving a token on an Boolean matrix . A configuration of the game is a contiguous submatrix of given that the indices of its first and last lines and columns . It is given, at each round, with an indication of which corner of this submatrix the token is on and whose turn it is. In the beginning of the game, the configuration is thus , the token is at the corner and starts to play. In his turn, tries to move the token horizontally in the submatrix to some entry 111Supposing different from both allows to forget the precise corner where the token is and simplify in a non essential way the formula , satisfying . After, ’s move either all columns to the left of or all columns to the right of are removed from the current submatrix, whichever number of columns is greater, leaving the token once again on a corner of the current submatrix. I.e. the new configuration is if and if not. In his turn, plays similarly but vertically, on the rows. The first player with no move left loses.

We encode the matrix by a structure representing a binary word of length . Remark, that the size of the matrix is divided by at least two after each round. The existence of a winning strategy for is encoded by the following formula (

is an upper bound for the size of the matrix at each round with some padding,

is for the players),

with and is

The formula associated to is defined similarly (but with universally guarded quantification for and (row) ). In [4] a variant of this game, called semicake is shown to be -complete: it is easily definable along the same lines in .

We now introduce a certain normal-form for circuits showing membership in , and , which will be needed for our later proofs. Note that due to built-in BIT, we have an order and arithmetic on the gates of circuits from uniform circuit families. Circuit families in our normal-form have the following properties: All tuples of the appropriate size are gates (so from the FO

-interpretation showing uniformity is always true). The ∧-gates are exactly the gates that are odd and neither input nor negated input gates. The ∨-gates are exactly the gates that are even and neither input nor negated input gates. Children of gates are smaller than half of each of their parents.

Let and . Then there is an FO-interpretation with tuple size that uniformly describes a circuit family showing such that for all :

  1. for all :

  2. for all :


Properties 1 and 2 are straightforward. For property 3, a certain unary encoding of the depth can be added to the encoding of gates in order to halve the numerical value of gates in each step from parent to child.

A formal proof can be found in the appendix.

4 Logical Characterizations of Small Depth Decision Classes

We now show that the newly defined logics characterize the classes , and , respectively.


: Let via the FO-uniform circuit family with the properties from Lemma 3 and has depth at least 1 for all . The latter can easily be achieved by adding a new ∧-gate as output-gate with the old output-gate being its only child. Let

be an FO-interpretation showing that is uniform. Furthermore, let

Then the following -formula defines :


Even and Odd check the parity of the least significant bit within the least significant variable within tuple using BIT. Note that within the relativization for can be moved outside the relativization, so Φ is equivalent to a -formula.

Since , we can write θ as

where is either ∃ or ∀ depending on the parity of .

Let and . We now prove that the predicate in the above formula is the valuation for the gates in circuit . By definition, on input structure , the formulae from used above give access to . We prove inductively that for any , gives the value of gate in on input if all children of have depth .

: Note that gives the value of in on input if is an input gate. Then for gates all children of which are input gates we have:


By assumption, if then , and thus

This yields

This means that actually gives the value of .

: Again, by assumption,

We also know that for all children of only two cases can occur:

If is an input gate, then is false and gives the value of .

If is not an input gate, then is false, is true and gives the value of by induction hypothesis.

By (4) this means that actually gives the value of .

Since gives the value of arbitrary non-input gates in on input for any and and we assumed that the output gate is not an input gate, it is easy to see that the above formula defines : The formula behind the recursive definition of simply states that the output gate of the circuit evaluates to true.

: At first assume that only one occurrence of GPR-operators is allowed. The proof easily extends to the general case. Furthermore, we begin by proving the result without negations in θ. We will explain how to handle arbitrary -formulae afterwards.

Let via the formula

By definition of , occurs in θ only in the form , where is in the scope of a guarded quantification with and not in the scope of any unguarded quantification.

Ignoring occurrences of , φ is an FO-formula. Hence, we can build an circuit family evaluating φ except for these occurrences.

In order to compute the predicate we proceed as follows:

θ is also an FO-formula except for occurrences of , so we can build for all a circuit that computes with certain input gates marked with . The circuit can easily be built in a way that is part of the encoding of gates that are marked with . Thus, we can remove the marks and instead connect each gate that was marked with to the output gate of the subcircuit computing . Since occurrences of only occur within guarded quantifications , there can be at most logarithmically many steps from any before reaching , terminating the recursion. By the above, each such step—computing , when given values of for certain —can be done in constant depth leading to logarithmic depth in total.

The gates computing values of can now be connected to the circuit family evaluating φ as needed. This leads to an circuit family evaluating the whole formula.

Next, we talk about the case of θ containing negations. For this, we use the same construction as above, but add a negated version of each gate. We do this by adding a negation-bit to the encoding of all gates (possibly with padding). This is toggled exactly when negations occur in the quantifier-free part. For example, consider a subformula and assume there was no negation around α. Then we have a gate , which will compute the truth-value of α, for which the negation-bit is 0. We connect this to the gate for the truth-value of β with negation-bit 0 and—since there is a negation around γ—the gate for the truth-value of γ with negation-bit 1.

Apart from constructing the connections in this way, the negation-bit also changes the gate-type of gates: If a non-negated gate is a ∨-gate, the negated version is a ∧-gate and vice versa. Also, negated gates computing the value of literals also use the negated version of the respective literal compared to the non-negated version.

In total, this construction only doubles the size of the circuit and does not change its depth, but handles arbitrary negations.

For the case of multiple GPR-operators, we build a circuit for each of them in the above way. In case of nesting, we start from the innermost operator. Adequate connections between the different circuits are easily doable and size and depth of the combination of all those circuits still stays within the desired bounds.

and : Can be shown with the same formula and the same proof as , replacing GPR by or , respectively.

: This can be proven completely analogously to . Instead of circuit families for evaluation of φ and θ, we now use circuit families. This leads to logarithmic depth for evaluation of θ. In general, repeating this for logarithmically many steps would be a problem. By definition there are no occurrences of inside any unbounded quantifier, though. For the bounded quantifiers, we still create subcircuits for all possible values for the quantified variable, but we only connect the maximal two satisfying the relativization to the parent. This ensures that gates marked with for some still only occur in constant depth in the circuit evaluating , this time with only bounded fan-in gates. Consequently, the construction still only leads to logarithmic depth in total.

: Here, the same trick as for can be used. θ can be evaluated using an circuit family which is also an circuit family. Also, the semi-unboundedness of the quantifiers around occurrences of directly corresponds to the semi-unboundedness in circuit families.

The proof of the inclusion also immediately gives us the following normal-form for our logical classes. Let . Then

where denotes the class of languages decidable in first-order logic with one GPR-operator in the beginning.

5 Logical Characterizations of Small Depth Counting Classes

Next, we want to define a game semantics for our new logics. The game we define will correspond to model-checking and is defined analogous to the model checking game for FO for the most part. When playing the game on an -formula

it begins on formula φ. The only difference to the model checking for FO is an additional case for atoms of the form . In this case, the game continues on the formula . For all other atoms, the winner is immediately determined as before.

Now for any and it holds that

Analogously, we can extend the semantic game for and .

Similar to the approach in [9], we can also count the number of winning strategies of the verifier.

A function is in , if there is an -formula φ over vocabulary such that for all :

where is the number of winning strategies of the verifier in the model checking game for . and are defined analogously.

This then gives us characterizations of the counting version of the corresponding classes from circuit complexity:


The proof consists of carefully counting winning strategies in semantic games for those formulae developed in the decision version (Theorem 4) and is given in the appendix. ∎

Analogously to the decision version, the proof again allows us to establish a normal-form for our new logical classes. Let . Then

where denotes the class of functions that can be described as the number of winning strategies for first-order formulae with one GPR-operator in the beginning.

To further show the robustness of our classes, we want to mention certain variations of our logics that do not change the resulting complexity classes. For all decision classes, we can drop condition 2 from Definition 3 without changing the class. For the same holds.

For and , condition 2 cannot be dropped but can be replaced by the following weaker version: “never occur in the scope of any universal quantification not guarded in this way”.

6 Conclusion

We extended the only so-far known logical characterization of an arithmetic circuit class, namely [9], to arithmetic classes defined by circuits of logarithmic depth. In order to achieve this, we first had to develop logical characterizations of the corresponding Boolean classes.

The result from [9] was used in [6] to place in a strict hierarchy of counting classes within #P. In this way, lower bounds for several logically-defined arithmetic classes were obtained. Our hope is that the here presented characterizations of larger arithmetic classes will also lead to new insights about these and hopefully spur development of new upper and lower bounds, e.g., is ? Is ? Is ?


  • [1] Miklós Ajtai. -formulae on finite structures. Ann. Pure Appl. Logic, 24(1):1–48, 1983.
  • [2] David A. Mix Barrington and Neil Immerman. Time, hardware, and uniformity. In Proceedings 9th Structure in Complexity Theory, pages 176–185. IEEE Computer Society Press, 1994.
  • [3] David A. Mix Barrington, Neil Immerman, and H. Straubing. On uniformity within NC. Journal of Computer and System Sciences, 41:274–306, 1990.
  • [4] Ashok K. Chandra and Martin Tompa. The complexity of short two-person games. Discrete Applied Mathematics, pages 21–33, January 1990.
  • [5] Kevin J. Compton and Claude Laflamme. An algebra and a logic for NC. Inf. Comput., 87(1/2):240–262, 1990.
  • [6] Arnaud Durand, Anselm Haak, Juha Kontinen, and Heribert Vollmer. Descriptive complexity of #AC functions. In Jean-Marc Talbot and Laurent Regnier, editors, 25th EACSL Annual Conference on Computer Science Logic (CSL 2016), volume 62 of Leibniz International Proceedings in Informatics (LIPIcs), pages 20:1–20:16, Dagstuhl, Germany, 2016. Schloss Dagstuhl–Leibniz-Zentrum fuer Informatik.
  • [7] Heinz-Dieter Ebbinghaus, Jörg Flum, and Wolfgang Thomas. Mathematical logic. Undergraduate texts in mathematics. Springer-Verlag, 1994.
  • [8] Merrick L. Furst, James B. Saxe, and Michael Sipser. Parity, circuits, and the polynomial-time hierarchy. Mathematical Systems Theory, 17(1):13–27, 1984.
  • [9] Anselm Haak and Heribert Vollmer. A model-theoretic characterization of constant-depth arithmetic circuits. In Jouko A. Väänänen, Åsa Hirvonen, and Ruy J. G. B. de Queiroz, editors, Logic, Language, Information, and Computation - 23rd International Workshop, WoLLIC 2016, Puebla, Mexico, August 16-19th, 2016. Proceedings, volume 9803 of Lecture Notes in Computer Science, pages 234–248. Springer, 2016. See also: CoRR, abs/1603.09531.
  • [10] Neil Immerman. Expressibility and parallel complexity. SIAM J. Comput., 18(3):625–638, 1989.
  • [11] Neil Immerman. Descriptive complexity. Graduate texts in computer science. Springer, 1999.
  • [12] Neeraj Kayal and Ramprasad Saptharishi. A selection of lower bounds for arithmetic circuits. In Manindra Agrawal and Vikraman Arvind, editors, Perspectives in Computational Complexity: The Somenath Biswas Anniversary Volume, pages 77–116. Birkhäuser, 2014.
  • [13] Clemens Lautemann, Pierre McKenzie, Thomas Schwentick, and Heribert Vollmer. The descriptive complexity approach to LOGCFL. J. Comput. Syst. Sci., 62(4):629–652, 2001.
  • [14] Leonid Libkin. Elements of Finite Model Theory. Texts in Theoretical Computer Science. An EATCS Series. Springer, 2004.
  • [15] Meena Mahajan. Algebraic complexity classes. In Manindra Agrawal and Vikraman Arvind, editors, Perspectives in Computational Complexity: The Somenath Biswas Anniversary Volume, pages 51–75. Birkhäuser, 2014.
  • [16] Guillaume Malod and Natacha Portier. Characterizing Valiant’s algebraic complexity classes. Journal of Complexity, 24(1), February 2008.
  • [17] Ramprasad Saptharishi. A survey of known lower bounds in arithmetic circuits. A continu- ously updated git survey.
  • [18] Heribert Vollmer. Introduction to Circuit Complexity - A Uniform Approach. Texts in Theoretical Computer Science. An EATCS Series. Springer, 1999.

Appendix A Appendix

Proof of Lemma 3.

Since , there is an FO-interpretation that uniformly describes a circuit family showing . Let be the length of tuples encoding gates in this circuit family. We now stepwise construct an FO-interpretation still showing but with properties 1, 2 and 3.

Since we will have to adapt encodings of gates as tuples in order to manipulate certain properties related to the numerical predicates, it is relevant for this proof in what way we represent numbers as tuples. We will always use an most significant bit first encoding, meaning that the variable containing the most significant bit of number is the left-most variable in a tuple and significance reduces towards the left.

1.: We first construct an FO-interpretation that has property 1. This is done by allowing all tuples as gates, but allowing connections between gates only if both gates were already gates in the original circuit. Analogously, we also have to change the formula determining the output gate—otherwise, multiple tuples could become output gates. The only formulae we have to change for this are those for the universe and the predicates and output. Let be the respective formulae from . For we instead use