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 modeltheoretic 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. Bestknown is probably Fagin’s Theorem stating that languages in
NP are exactly those that can be defined in existential secondorder 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 firstorder formulae: [10]. The rationale behind this area of descriptive complexity, as it is called, is to characterize complexity classes in a modeltheoretic 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 polynomialsize constantdepth arithmetic circuits with plus and times gates is equal to the class of those functions computing winning strategies in semantic games for firstorder formulae: [9]. A different way to view this result is to say that is the class of functions counting Skolem functions for FOformulae.
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 fanin addition and multiplication gates (for ), unbounded fanin addition and bounded fanin multiplication gates (), and unbounded fanin 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 firstorder 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 firstorder 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 logdepth 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 RPRoperator 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 , firstorder logic augmented by GPR, characterizes , and that slight modifications of the GPRoperator 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 modeltheoretic way by firstorder logic with different forms of the GPRoperator. 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 winningstrategies 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 firstorder 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 builtin 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 builtin relations, includes the interpretation of the builtin 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 firstorder formulae, but also the complexity class of all languages definable in firstorder logic with builtin BIT: A language is in FO if there is an FOformula φ 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 FOinterpretations, which are mappings between structures over different vocabularies.
Let σ, τ be vocabularies, . A firstorder interpretation (or FOinterpretation)
is given by a tuple of FOformulae 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 fanin (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 noninput 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 nonuniformity, which allows such circuit families to even compute nonrecursive 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 FOstructures:
where the relations are interpreted as follows:

: gate is a child of gate

: gate is an andgate

: gate is an orgate

: 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 FOuniformity of Boolean circuits and the complexity classes relevant in this paper.
A circuit family is said to be firstorder uniform (FOuniform) if there is an FOinterpretation
mapping any structure over with builtin BIT to the circuit given as a structure over the vocabulary .
Note that by [2] this uniformity coincides with the maybe better known DLOGTIMEuniformity for many familiar circuit classes (and in particular for all classes studied in this paper). All circuit classes we consider in this paper are FOuniform.
A language is in if there is an FOuniform circuit family with depth and polynomial size accepting . is defined analogously with bounded fanin gates. is defined analogously with bounded fanin ∧gates and unbounded fanin ∨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 socalled 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 superpolynomial sizes in . This comes from the fact that the unfolding of a polynomial size, logarithmic depth circuit with unbounded fanin may be of size . This means that .
Similarly, one can identify witnesses for acceptance in firstorder logic. One possibility for this is to do this in terms of the modelchecking game defined as follows. The model checking game for FO is the twoplayer 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 subformula. 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 firstorder logic, which allows us to define a counting class based on FO.
A function is in #WinFO, if there is an FOformula φ 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 firstorder and make use of the inductively defined . Over structures with builtin 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 subformula involving symbol

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

never occur in the scope of any quantification not guarded in this way.
We also call the part in a GPRoperator. 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 ^{1}^{1}1Supposing 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 normalform for circuits showing membership in , and , which will be needed for our later proofs. Note that due to builtin BIT, we have an order and arithmetic on the gates of circuits from uniform circuit families. Circuit families in our normalform 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 FOinterpretation with tuple size that uniformly describes a circuit family showing such that for all :


for all :

for all :
Proof.
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.
Proof.
: Let via the FOuniform 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 outputgate with the old outputgate being its only child. Let
be an FOinterpretation showing that is uniform. Furthermore, let
Then the following formula defines :
with
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 noninput 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 GPRoperators 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 FOformula. 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 FOformula 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 negationbit to the encoding of all gates (possibly with padding). This is toggled exactly when negations occur in the quantifierfree part. For example, consider a subformula and assume there was no negation around α. Then we have a gate , which will compute the truthvalue of α, for which the negationbit is 0. We connect this to the gate for the truthvalue of β with negationbit 0 and—since there is a negation around γ—the gate for the truthvalue of γ with negationbit 1.
Apart from constructing the connections in this way, the negationbit also changes the gatetype of gates: If a nonnegated 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 nonnegated 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 GPRoperators, 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 fanin 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 semiunboundedness of the quantifiers around occurrences of directly corresponds to the semiunboundedness in circuit families.
∎
The proof of the inclusion also immediately gives us the following normalform for our logical classes. Let . Then
where denotes the class of languages decidable in firstorder logic with one GPRoperator 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 modelchecking 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:
Proof.
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 normalform for our new logical classes. Let . Then
where denotes the class of functions that can be described as the number of winning strategies for firstorder formulae with one GPRoperator 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 sofar 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 logicallydefined 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 ?
References
 [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 twoperson 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 JeanMarc 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–LeibnizZentrum fuer Informatik.
 [7] HeinzDieter Ebbinghaus, Jörg Flum, and Wolfgang Thomas. Mathematical logic. Undergraduate texts in mathematics. SpringerVerlag, 1994.
 [8] Merrick L. Furst, James B. Saxe, and Michael Sipser. Parity, circuits, and the polynomialtime hierarchy. Mathematical Systems Theory, 17(1):13–27, 1984.
 [9] Anselm Haak and Heribert Vollmer. A modeltheoretic characterization of constantdepth 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 1619th, 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. https://github.com/dasarpmar/lowerboundssurvey.
 [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 FOinterpretation that uniformly describes a circuit family showing . Let be the length of tuples encoding gates in this circuit family. We now stepwise construct an FOinterpretation 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 leftmost variable in a tuple and significance reduces towards the left.
1.: We first construct an FOinterpretation 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