Characterizing Small Circuit Classes from to via Discrete Ordinary Differential Equations
Abstract
In this paper, we provide a uniform framework for investigating small circuit classes and bounds through the lens of ordinary differential equations (ODEs). Following an approach recently introduced to capture the class of polynomial-time computable functions via ODE-based recursion schemas and later applied to the context of functions computed by unbounded fan-in circuits of constant depth (), we study multiple relevant small circuit classes. In particular, we show that natural restrictions on linearity and derivation along functions with specific growth rate correspond to kinds of functions that can be proved to be in various classes, ranging from to . This reveals an intriguing link between constraints over linear-length ODEs and circuit computation, providing new tools to tackle the complex challenge of establishing bounds for classes in the circuit hierarchies and possibly enhancing our understanding of the role of counters in this setting. Additionally, we establish several completeness results, in particular obtaining the first ODE-based characterizations for the classes of functions computable in constant depth with unbounded fan-in and Mod 2 gates () and in logarithmic depth with bounded fan-in Boolean gates ().
Keywords and phrases:
Implicit computational complexity, parallel computation, function algebras, ordinary differential equations, circuit complexityFunding:
Melissa Antonelli: Supported by the Helsinki Institute of Information Technology (HIIT) and the Magnus Ehrnrooth Foundation.Copyright and License:
2012 ACM Subject Classification:
Theory of computation Computational complexity and cryptography ; Theory of computation Circuit complexityEditors:
Paweล Gawrychowski, Filip Mazowiecki, and Michaล SkrzypczakSeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl โ Leibniz-Zentrum fรผr Informatik
1 Introduction
Implicit computational complexity is a active area of theoretical computer science that aims to provide machine-independent characterizations of relevant complexity classes. In the context of recursion theory, a foundational result is by Cobhamย [18], who, in the 1960s, provided an implicit characterization of the class of polynomial-time computable functions () through a limited recursion schema. This work not only led to the development of function algebras characterizing multiple classes different from poly-time (seeย [15]), but also inspired several alternative recursion-theoretic approachesย [6, 28, 30]. Among them, the one introduced inย [10] shows that ordinary differential equations (ODEs) provide a natural tool for algorithmic design and offers an original characterization of , using linear systems of equations and derivation along a logarithmically growing function (such as the length function ). Informally, the latter condition controls the number of recursion steps, while linearity governs the growth of objects generated during the computation. This approach has recently been generalized to the continuous settingย [7, 8] and to the study of two small circuit classesย [3]. In this paper, we extend the latter far further by presenting a comprehensive investigation of circuit classes from toย through the lens of ODE schemas.
Although small circuit classes have been characterized in different ways, investigating them through the ODE framework has never been attempted (except forย [3]). This approach is both interesting, as for a descriptive method based on ODEs to be meaningful and fruitful, it must be able to adjust with very subtle changes in restricted models of computation, and challenging, because even simple and useful mathematical functions may not be computable within the considered classes and, consequently, the tools available may seem drastically restricted and the naturalness of the approach questionable. However, the results of this paper show that this is not hopeless. Very simple and natural restrictions on linearity โ namely, constraining the values of coefficients and allowing (or not) the call for the sign of the defined function inside the linear term โ and on the function along which derivation is performed, allows us to capture the very essence of small circuit computation. Many classical functions โ such as polylog bit sum, parity, majority, iterated sum and product, and binary search โ are shown to be naturally encapsulated in very simple linear ODE families. For this reason, we believe that our approach to this line of research, which is still in its beginning, can shed some new light on circuit computation and offer a simple (and machine-independent) framework for analyzing these notoriously hard problems through very natural and uniform constraints on linear ODEs.
Concretely, the results of this paper have led to completely original ODE-based characterizations for the classes of functions computable by unbounded fan-in circuits of constant depth and polynomial size that allow Mod 2 gates () and by bounded fan-in circuits of logarithmic depth and polynomial size (). We have also improved our understanding of schemas capturing the classes of functions computable by unbounded fan-in circuits of constant depth and polynomial size (), possibly including Maj gates (), by generalizing and making them part of a more general picture. Finally, we have shown that considering schemas with derivative along is definitely worth investigating: in particular, the corresponding linear schema is in , somewhat mirroring what -ODE does for .
Structure of the paper.
In Sectionย 2, we present the basics of the method developed inย [10], the necessary notions to formulate our results, and recap definitions of the small circuit classes we will consider throughout the paper. In Sectionย 3, we present, in a high-level yet systematic and uniform manner, the main schemas (differently) corresponding to the classes that will be studied. In Sectionย 4, we introduce ODE-based schemas obtained by deriving along and by imposing different constraints on linearity, and we show that they are computable in the respective circuit classes. We also provide improved completeness results for and , along with completely original ODE-based characterizations for and . In Sectionย 5, we introduce a new class of ODE schemas, the defining feature of which consists of deriving along . Our main result here is the introduction of a very natural linear -ODE schema, the computation of which can be performed in . We conclude in Sectionย 6 pointing to possible directions for future research. For space reasons, most proofs are only sketched or omitted in the paper, but can be found inย [2]. To make the exposition shorter, most of our characterizations are proved indirectly, as these proofs tend to be more compact. However, direct proofs, both in the uniform and non-uniform settings, can be provided (but are not presented here).
2 Preliminaries
We assume the reader familiar with the basics of complexity theory. In this section, we briefly introduce the approach to complexity delineated inย [11] (see the original papersย [10, 11] for full details) and a few notions needed for our new characterizations. We also cursorily recall the definitions of the circuit classes that we will consider in the remainder of the paper.
2.1 Capturing Complexity via ODEs
One of the main approaches developed in implicit computational complexity is that based on recursion. It was initiated by Cobhamย [18], who gave the first characterization for via a limited recursion schema. This groundbreaking result has inspired not only similar characterizations for other classes, but also alternative recursion-based approaches to capture poly-time computable functions, such as safe recursionย [6] and ramificationย [28, 29]. Among them, the proposal byย [10] offers the advantages of not imposing any explicit bound on the recursion schema or assigning specific role to variables. Instead, it is based on Discrete Ordinary Differential Equations (a.k.a. Difference Equations) and combines two novel features, namelyย derivation along specific functions, to control the number of computation steps, and a special syntactic form of the equation (linearity), to control the object size.
Recall that the discrete derivative of is defined as , and that ODEs are expressions of the form
where stands for the derivative of considered as a function of , for a fixed value for . When some initial value is added, this is called Initial Value Problem (IVP). Then, in order to deal with complexity, some restrictions are needed. First, we introduce the notion of derivation along functions.
Notation 1.
For , let denote the length function, returning the length of written in binary, i.e.ย log, and such that . Additionally, let . For , let denote the greatest integer whose length is ; similarly, is the greatest integer such that . Finally, let denote integer division by 2, i.e.ย for all .
Notice that the value of changes (it increases by 1) when goes from to (for ). Similarly, the value of changes when goes from to (for ).
Definition 2 (-ODE Schema).
Let and be functions. Then,
| (1) |
is a formal synonym of . When , we call (1) a length-ODE or -ODE.
Intuitively, one of the key properties of the -ODE schema is its dependence on the number of distinct values of , i.e.,ย the value of changes only when the value of does. Computation of solutions of -ODEs have been fully described inย [11]. Here, we focus on the special case of , which is particularly relevant for our characterizations. If is a solution of (1) with and initial value , then . More generally, for all and : , where . Starting from and taking successive decreasing values of , the first difference such that is given by the biggest such that , i.e.ย . Setting , it follows by induction that:
In the present paper, both polynomial expressions (seeย [3]) and limited polynomial expressions are considered. Let be the sign function over , taking value 1 for and 0 otherwise, and be the cosign function, such that .
Definition 3.
A limited (-)polynomial expression is an expression over the signature (and the function, resp.) on the set of variables/terms and integer constants; (-)polynomial expressions are defined analogously over the signature .
To define the notion of degree for polynomial expressions, we follow the generalization to sets of variables introduced inย [3].
Definition 4.
Given a list of variables , for , the degree of a set in a -polynomial expression , , is inductively defined as follows:
-
, for , and , for
-
, for being an integer constant
-
-
and .
A -polynomial expression is said to be essentially constant in a set of variables when and essentially linear in , when .
Example 5.
Let . The expression is essentially linear in , in and in . It is not essentially linear in , as . The expression is essentially linear in , essentially constant in and not linear in . Clearly, is not linear in .
The concept of linearity allows us to control the growth of functions defined by ODEs. In what follows, we will consider functions , i.e.ย vectors of functions from to , and introduce the linear -ODE schema.
Definition 6 (Linear -ODE).
Given and , the function is linear -ODE definable from and if it is the solution of the IVP with initial value and such that:
where is essentially linear in the list of terms . For , such schema is called linear length-ODE.
If is essentially linear in , there exist matrices and , whose coefficients are essentially constant in , such that and:
Then, for all and , is
with the convention that and . Actually, the use of matrices is not necessary for the scope of this paper, but it is consistent with the general presentation of computation through essentially linear ODEs, of which full details can be found inย [10, 11].
One of the main results ofย [10] is the implicit characterization of by the algebra made of basic functions (where denotes the projection function) and closed under composition () and -ODE.
2.2 On Small Circuit Classes and Function Algebras
Boolean circuits are vertex-labeled directed acyclic graphs whose nodes/gates are either input nodes, output nodes or are labeled with a Boolean function from the set . Boolean circuit with modulo gates allows in addition gates labeled Mod 2 or, more generally, Mod , that output the sum of the inputs modulo or , respectively. Finally, Boolean circuit with majority gates are unbounded fan-in circuits including Maj gates, that output 1 when the majority of the inputs are 1โs. A family of circuits is -uniform if there is a Turing machine (with a random access tape) that decides in deterministic logarithmic time the direct connection language of the circuit, i.e.ย which, given 1 and , decides if is of type and is a predecessor of in the circuit (and analogously for input/output nodes). When dealing with circuits, the resources of interests are size, i.e. the number of gates, and depth, i.e.ย the length of the longest path from input to output (seeย [34] for further details and related results).
Definition 7 (Classes and ).
For , (resp., ) is the class of language recognized by a -uniform family of Boolean circuits of unbounded (resp. bounded) fan-in gates of polynomial size and depth log . We denote by (resp., ) the corresponding function class.
It is known that unbounded (poly) fan-in can be simulated using a bounded tree of depth log , so that . However, the inclusion has been proved to be strict only for . In contrast, when dealing with classes with counting ability, interesting bounds have been established.
Definition 8 (Classes and ).
The class (resp., ) is the class of languages recognized by a -uniform family of Boolean circuits of polynomial size and constant depth including Mod (resp., Maj) gates . We denote by (resp., ) the corresponding function class.
We can even consider other levels in the hierarchy, such that for , corresponds to classes of functions computed by families of unbounded fan-in circuits with Maj gates, of polynomial size and depth ((log ). It is known that the inclusion is proper, as the parity function cannot be computed in constant depth by standard unbounded fan-in Boolean gates, but it can be if Mod 2 gates are added. Moreover, since any Mod gate can be expressed by Maj, .
As mentioned, Cobhamโs work paved the way to several recursion-theoretic characterizations for classes other than , including small circuit ones. In 1988/90, Clote introduced the algebra to capture functions in the log-time hierarchy (equivalent to ) using so-called concatenation recursion on notation (CRN)ย [12, 13]. The greater classes and are captured adding weak bounded recursion on notationย [13], while has been characterized both in terms of the -bounded recursion on notation (-BRN) schemaย [14] and relying on the basic function ย [13]. In 1990, an alternative algebra (and logic), based on a schema called upward tree recursion, was introduced to characterize ย [19]. In 1991, a new recursion-theoretic characterization (and arithmetic ร la Buss) for was presentedย [1]. In 1992 and 1995, other small circuit classes, including , were considered (and re-considered) by Clote and Takeuti, who also introduced bounded theories for themย [16, 17]. More recently, characterizations for were developed inย [9], this time following the ramification approach. Inย [3], the first ODE-based characterizations for and were introduced. Related approaches to capture small circuit classes have also been provided in the framework of model- and proof-theory, both in the first and second orderย [26, 5, 24, 31, 19, 1, 16, 17, 27, 21, 4, 20, 22]. To the best of our knowledge, so far, no uniform implicit framework to characterize these classes has been offered in the literature.
3 Towards a Uniform Understanding of Small Circuit Classes
We informally outline here our comprehensive investigation of small circuit classes in terms of ODEs (see Figureย 1 for a complete description). By slightly modifying the restrictions on the linearity allowed in -ODE and -ODE, we can perform computation and, in several cases, characterize multiple function classes in the range from to .
Notation 9.
An equation or, by extension, an ODE schema is said to be strict when it does not include any call to in or (not even under the scope of the sign function).
We say that includes simple calls to if occurs in only in expressions of the form .
For clarityโs sake, we will use for functions with limited range, typically in , and for (possibly limited) -polynomial expressions of restricted range.
We use or (when not ambiguous) simply as an abbreviation for signed expressions in which can occur, i.e.ย , where is any polynomial expression in which and may appear.
Finally, for readability, we often use
-
as a shorthand for ,
-
, or even , as a shorthand for ,
-
(or ), with , as a shorthand for (, resp.) in which .
When different signed expressions occur in or these notational conventions are generalized accordingly. If not stated otherwise, we assume that expressions used in and schemas are limited -polynomial expressions (since multiplication is not in these classes), while those in and are -polynomial expressions.
Let us first examine the evolution in the expressive power of the linear schema (see Definitionย 6), which captures ,
when calls to are not allowed, i.e.ย when dealing with equation of the form , but still deriving along . In this case, can be expressed as a combination of iterated multiplications and products and is in . Interestingly, this schema is also the key ingredient to capture and to provide a corresponding completeness result. On the other hand, if calls to are allowed (i.e.ย we are back to the general form), but the derivative is along the โslowerโ function , then expressivity jumps to .
As a second example to focus on the smallest classes, consider schemas of the form , for , with derivative along and only simple calls to . We show that such defined functions are in . Forcing the second part to be in , i.e.ย considering equations of the forms and (that is,ย in the latter case, calls to are not allowed) makes the functions respectively in and . Remarkably, in the first two cases, the mentioned schemas are central to characterize the corresponding classes.
Finally, we examine (strict) equations of the form (where is a limited -polynomial expression), this time deriving along . Equations of this form provide the ODE equivalent to log iterated sums and, not surprisingly, define a computation in . Generalizing them to the non-strict setting by allowing equations of the form , where calls to occur, gives a really more tricky schema, that is shown computable in .
| strict schemas along | non-strict schemas along | schemas along | |
|---|---|---|---|
4 Investigating Circuit Complexity Deriving along
In this section, we present linear ODE schemas obtained by deriving along and show that they are computable and, in some cases, capable of characterizing the corresponding class.
4.1 The Class
We start by revising the characterization of fromย [3]. Recall that the function algebra capturing is based on the two very restrictive forms of -ODEโs below.
Definition 10 (Schemas -ODE1, -ODE3).
Given and , the function is obtained by -ODE1 from , and , if it is the solution of the IVP defined by and
On the other hand, is obtained by -ODE3 from if it is the solution of the IVP defined by and
Relying on them, inย [3], the ODE-based function algebra below is introduced:
where, as standard, . In the same paper, this class is shown to precisely characterize , seeย [3, Cor. 19]. Here, we dramatically simplify the (indirect) completeness proof, by showing that -ODE3 precisely captures the idea of looking for the value of a bit in an long sequence, while -ODE1 corresponds to the idea of left-shifting (the binary representation of) a given number, possibly adding 1.
ย Remark 11 (The Function ).
Given an input of length , for any , the schema -ODE3 allows us to compute its bit in a direct way. Let us consider an instance of -ODE3 such that , i.e. defined by and
Then, the bit of is .
ย Remark 12 (The CRN Schema).
Inย [13], CRN is defined by and , for , taking value in and being the binary successor functions. We can rewrite this schema as an instance of -ODE1 such that
where, by definition, for any , . Then, .
Theorem 13 ([3]).
.
Proof.
Byย [3, Prop. 12, 17]. The proof is indirect and passes through Cloteโs algebra
which, inย [13], is shown sufficient to characterize . Its basic functions 0, and composition are by design in , can be rewritten in our setting almost for free, while and CRN can be encoded as in Remarksย 11 andย 12.
In the context of a broader understanding of the hierarchy between classes, we have also considered non-strict -ODE schemas that are computable in . As anticipated, this investigation demonstrates a strong link between depth constraints over circuits and the syntactical constraints that define the corresponding linear length-ODE. Particularly interesting in this setting is the IVP defined by linear equations in which and . As long as occurs in only in expressions of the form , computation through this schema is proved to be in . Remarkably, computing the solution of such system corresponds to performing bounded search.
Lemma 14.
Let and be computable in . Then, , defined from and as the solution of the IVP made of and
where is a limited -polynomial expression and occurs in it only under the scope of the sign function in expressions of the form , is in .
Proof Sketch.
By definition of -ODE, , with the convention that . Clearly, if there is a such that , then . Therefore, we compute which is either 0, if or there is a , or , otherwise. By hypothesis, we can compute in both and, for any , . Thus, we conclude in one layer defined by an unbounded fan-in -gate. This result can actually be strengthened by showing that Lemmaย 14 holds even when generalized expressions of the form occur in .
To conclude the presentation of schemas for , let us consider simple cases of bounded search encoded by the aforementioned ODE schemas.
Example 15 (BSearch).
Let and be its characteristic function. Then, for all and , , where is defined by and which is clearly an (very limited) instance of the schema presented in Lemmaย 14. Another example of limited search consists in checking whether, at some point, reaches or not a boundary, say . This can be expressed in a natural way by an instance of the (generalized) non-strict schema (in ) defined by the equation .
4.2 The Class
By weakening the constraints on linearity of the schemas which define , we introduce an -ODE the computation of which is provably in and actually characterizes this class. We consider a non-strict schema such that and . As we will see (Sectionย 4.4), this is a special case of the schema we will introduce to capture . Together with the functions and schemas defining , it is also enough to capture , thus providing the very first ODE-based characterization for this small circuit class โwith countersโ.
Definition 16 (Schema ).
Given and , the function is defined by if it is the solution of the IVP with and
where is a limited -polynomial expression and occurs in only under the scope of the sign function.
Notably, this schema allows us to capture the computation performed by Mod 2 gates and to rewrite the parity function in a very natural way.
Example 17 (The Parity Function).
Let be a string of bits. To count the number of 1โs in we consider the following system defined by and:
which is clearly an instance of . The parity function is now computed by .
Notice that this example shows that really increases the power of -ODE1, as the parity function is known not to be in (seeย [23]). This also indicates that is actually a schema capturing the specific computational power corresponding to . Moreover, it is shown that the desired closure property holds for it.
Lemma 18.
If is defined by -b0ODE from functions in , then is in as well.
Proof Sketch.
For simplicity, let us consider the simple case of occurring only under the scope of the sign function in expressions of the form . Relying on the fact that , we can rewrite the equation defining as follows:
Intuitively, if , no change occurs. In contrast, if we restart the computation (as the preceding value of the input must not be the last one for which ) by removing the previous value of , and return 1 if either one of the following holds:
-
i
, i.e.ย โgeneratesโ a 1, and the number of changes of values (temporarily assuming that is the last value in such that ) between subsequent values, i.e.ย and , is such that 1 (possibly alternating) โpropagatesโ until the end of the computation or
-
ii
, i.e.ย โgeneratesโ a 0, and the subsequent number of changes of values is such that 0 does not propagate to the final value, i.e.ย Mod 2(.
It is easy to see that the value computed in this way corresponds to the final value of the computation, i.e.ย is given by such that for any . Clearly, this is a special case of in which no call to occurs in or , namely of the form , for . Computation through this schema can be implemented by circuits of constant depth and polynomial size including Mod 2 gates: for any , we can compute and in parallel and check both their mutual consistency, i.e. whether , and the consistency between subsequent pairs, i.e.ย whether ; then, using Mod 2 gates, we can compute whether the number of changes of values is even or odd and conclude in constant depth via (unbounded fan-in) -gate.
Since has been shown to capture computations performed by Mod 2 gates, our characterization for is obtained by simply endowing with it.
Theorem 19.
Proof.
4.3 The Class
In this section, we introduce schemas the computation of which is proved to be in . One is defined in terms of strict linear -ODE and provides a new, compact characterization for this class. The second couple of schemas considered are not strict, as they include simple calls to , and are defined uniformly with respect to corresponding (i.e.,ย non-strict) schemas for and (as well as for and , see Sectionsย 4.4 andย 4.5)
We start by dealing with the linear ODE schema defined deriving along and so that and are both -polynomial expressions, with no call to .
Definition 20 (Schema ).
Given and , the function is defined by from and , if it is the solution of the IVP with initial value and such that
where and are -polynomial expressions.
This compactly encapsulates not only iterated multiplication and addition but also -ODE1 and -ODE3 computation.
Example 21 (Counting and Iterated Addition in ).
Notably, BCount (resp. iterated addition, ItAdd) can be expressed as a special case of such that and with , i.e.ย by considering an IVP such that and:
Taking and , .
These examples are especially relevant as they reveal that is really more expressive than all strict schemas introduced so far (BCount is not computable in and , seeย [32, 33]). The closure property can be shown to hold for by relying on the following result.
Proposition 22.
If and are computable in and is defined by from and , then is computable in as well.
Proof.
By definition of -ODE, such satisfies and
with the convention that and . Computing this expression can be done combining iterated addition and multiplication, which are in . As an immediate byproduct we obtain a new, concise ODE-based characterization of .
Theorem 23.
Proof.
By Propositionย 22. Consequence of the facts that (i) -pODE is strong enough to express -ODE1 and -ODE3, together with (seeย [3, 13]), and (ii) -pODE captures BCount computation (see Exampleย 21), which is equivalent to Maj or (seeย [34]), together with the fact that (seeย [17]). established byย [17].
Additionally, in order to better and uniformly understand upper bounds in circuit computation, we consider natural constraints over the non-strict linear length-ODE schema obtained by allowing simple calls of . As shown throughout the paper, this kind of feature may increase the computational power of a schema, and, here, to ensure that computation remains in we have to restrict the forms of and .
Lemma 24.
Let and be in . Then, a function defined by the IVP with initial value and equation of one of the following forms:
where is a -polynomial expression and only occurs in expressions of the form in it, is in as well.
Proof.
For the first equation type, notice that, if , then, for any , (by definition of the schema, in which and ). Thus, in this case, with the convention that , and we can conclude by noticing that BCount is in . Otherwise, we compute in parallel and for all . Then, we search for the first such that and compute : this would be the expected result since, before , each summand is equal to 0 and, after , all signed terms remain strictly positive. Again, this corresponds to BCount, which can be done in . In terms of circuit computation, this is implemented as follows:
-
In parallel, the circuit computes the value of and, for each of both and (this can be done in for hypothesis).
-
In one layer, for any , it computes the sum by Count gates.
-
In constant depth, for any , it computes the conjunction between and and select the corresponding Count gate.
For the second equation type, first note that, if , trivially (which is clearly computable in ). Let . Then, for any , . Therefore, by definition of -ODE, with . This can be computed in : and each , for can be computed in parallel in the beginning ( and being computable in for hypothesis and being a -polynomial expression by definition) and ItMult (so, in particular, iterated multiplication by 1 and 2) is in , seeย [25].
4.4 The Class
In this section, we consider two restrictions on -ODE, which give us natural schemas the solution of which is a function computable in : namely,ย the schema defined by and and the one defined by and more liberal (obtaining the so-called schema, somewhat generalizing ).
Lemma 25 (Bounded Concatenation with Simple Calls).
Let and be computable in . Then, computation through the schema defined by the IVP with initial value and such that:
where is a -polynomial expression, and appears in it only under the scope of the sign function in expressions of the form , is in .
Proof Sketch.
By definition of -ODE, , with the convention that . Let us define the truncated sum (or concatenation) between and bounded by , as , with . In particular, we consider two sums in which the sign of the first term is assumed to be either 0 or 1: , with and . Therefore, for any and :
Clearly, and can be computed in parallel: we know the actual starting value of , which is 0, while to compute it is enough to know that, for any , . Once is computed and its sign tested, we can select between and accordingly. We conclude by taking the concatenation between and either or . This schema can be generalized so to allow calls to in expressions of the form , i.e.ย testing whether . Computation through an extended version in which occurs under the scope of is provably in but it is also strong enough to capture perfect binary tree structures, hence to provide a direct encoding of circuit computation.
ย Remark 26.
The condition that appears only in expressions of the form or even might seem limited. However, the possibilities it offers really increase the ODEโs expressive power and, on the other side, even for slightly more liberal conditions, provide the only known upper bound for the schema is .
We now move to the new characterization of . To establish it, we introduce an -ODE schema defined by imposing and , that is by generalizing the constraint defining from to taking any positive value.
Definition 27 (Schema ).
Given and , the function is defined by if it is the solution of the IVP with initial value and such that
where, for any , is a -polynomial expression, and occurs in it only in expressions of the form , being a constant.
Lemma 28.
If is defined by -bODE from functions in , then is in as well.
Proof.
To simplify the exposition, w.l.o.g. let us suppose that: (i) includes only one signed term, say , in which occurs, and (ii) is a power of two (to avoid rounding). By definition of -ODE, , with . We consider partial or truncated results between and bounded by , intuitively corresponding to subsequent compositions of in , going from to ; that is, either , i.e.ย the computation of starting from , or , i.e.ย the computation of starting from . The values of , and can be computed independently from all previous values of . Additionally, only one between and corresponds to the actual value of . Then, for any and , the value of can be computed inductively by selecting the correct partial as follows: . Both and as well as, for any , and the corresponding signs can be computed independently from each other and in parallel. The number of subsequent recursive calls needed to end up with the desired selection, i.e.ย the one corresponding to and , would require (selection) steps, ensuring we are in .
ย Remark 29.
As desired, Lemmaย 28 still holds when dealing with signed expressions occurring in . To deal with this more general case we need to add an initial consistency check, considering โs and โs, in the very beginning.
Together with , provides a new ODE-based characterization for .
Theorem 30.
Proof.
All basic functions of this algebra are already in and the closure property holds for (generalization of Propositionย 22) and (Lemmaย 28).
The proof is indirect and passes through Cloteโs algebra:
where a function is defined by 4-BRN if and for and taking values in only.
Inย [14], this class is proved to be the one characterizing .
In particular, to show that any function defined by 4-BRN can be rewritten as the solution of an instance of , we consider the IVP defined by the initial value and such that:
with .
Then, , where is defined by 4-BRN from and .
Since Cloteโs is nothing but endowed with 4-BRNย [14] and byย [3] , this encoding of 4-BRN via , together with Theoremย 23, concludes our proof.
4.5 The Class
When we consider a generalization of the non-strict schemas shown in from to more liberal (analogously to the generalization from to ), we obtain an -ODE schema, which is provably in . Formally, it is defined by an IVP with restrictions and, as mentioned, with only simple calls to .
The proof of the result below is similar to that for Lemmaย 25, except for the last step which amounts of a sum (possibly including carries) rather than a concatenation.
Lemma 31 (Bounded Sum with Simple Calls).
Let and be computable in . Then, computation through the schema defined by the IVP with initial value and such that
where is a -polynomial expression with only appearing under the scope of the sign function inside expressions of the form , is in as well.
5 Characterizing Classes Deriving along
Here, we consider alternative linear ODEs in which derivation is not along but along the โslowerโ function . Of course, in this context, same syntactic constraints on the linearity of the schema end up characterizing smaller classes (for example, the solution of the system shown in when deriving along is shown to be computable in if derivation is along ). The main result of this section is that linear ODEs with derivative along are in (rather than , as in the case of ย [10]).
First, observe that when deriving along , computation through a strict linear ODE schema is (of course in but even) in and corresponds to LogItAdd, i.e.ย iterated addition of numbers.
Lemma 32.
Let and be computable in . Then, defined from and by the IVP with initial value and such that
where is a limited -polynomial expression, is in .
When this schema is generalized to the non-strict setting by allowing to occur in under the scope of the sign function, computation is proved to be in by a much evolved argument.
Lemma 33.
Let and be definable in . Then, computation through the schema defined by the IVP with initial value and such that
where is a -polynomial expression in which only appears under the scope of the sign function, is in .
As mentioned, the IVP defined deriving along and allowing โfull linearityโ is particularly interesting.
Definition 34 (Schema -ODE).
Given and , the function is defined by -ODE if it is the solution of the IVP with initial value and such that:
This schema captures the computation of expressions in the following form:
where , i.e.ย and is the greatest integer such that .
Lemma 35.
Let be defined by -ODE from and in , then is in .
6 Conclusion
The objective of this paper was to start a new and uniform approach for studying circuit complexity through the lens of ODEs. This approach allows to consider bounds on size or depth in circuit computation in terms of constraints on the linearity of the equations defining recursion schemas in two main contexts of derivatives: derivation along and along . Additionally, we have investigated completeness both improving and placing in a coherent setting the results obtained inย [3] for and , and providing what, to the best of our knowledge, are the first ODE-based characterizations for and . In addition of being a simple and natural way to design algorithms, ODE tools have also enabled us to obtain relatively simple and self-contained membership proofs and characterizations compared to the often convoluted constructions or external theories referenced in previous literature.
Many directions for future investigation remain open. A natural one would be the study of characterizations for the entire and hierarchies. For this, one has to identify which ODE features or characteristic would help to jump from one depth level, say , to the next. Furthermore, a possible next step of our research involves defining (strict) -ODE schemas corresponding to complexity classes with counters, lying between and (i.e.ย which correspond to computations executed by unbounded fan-in circuits featuring Mod gates), ultimately allowing us to better understand their interrelationships and the concept of counting within the framework of small circuits. Another relevant and intriguing direction is the exploration of the expressive power of schemas with derivative along in particular w.r.t. the problem of capturing complexity classes. Studying the relationship between and schemas might also be informative. Classical methods such as changes of variables sometimes help to go from one ODE schema to another but, on the other side, it seems that changing the function along which the derivative is taken gives a different point of view in terms of what can be expressed. However, this study has just been initiated here, and a systematic investigation is left for future work. Other challenging directions for exploration include generalizing our approach to the continuous setting by analyzing small circuit classes over the reals, following the path outlined inย [7] for and , and developing proof-theoretical counterparts to our ODE-style algebras, in the form of natural rule systems inspired by the ODE design, to syntactically characterize the corresponding classes.
References
- [1] B.ย Allen. Arithmetizing uniform NC. Ann. Pure Appl. Logic, 53:1โ50, 1991. doi:10.1016/0168-0072(91)90057-S.
- [2] M.ย Antonelli, A.ย Durand, and J.ย Kontinen. Characterizing small circuit classes from FAC0 to FAC1 via discrete ordinary differential equations. URL: https://arxiv.org/abs/2506.23404.
- [3] M.ย Antonelli, A.ย Durand, and J.ย Kontinen. A new characterization of FAC0 via discrete ordinary differential equations. In Proc. MFCS, 2024.
- [4] T.ย Arai. A bounded arithmetic AID for Frege systems. Ann. Pure Appl. Logic, 103:155โ199, 2000. doi:10.1016/S0168-0072(99)00041-X.
- [5] D.A.M. Barrington, N.ย Immerman, and H.ย Straubing. On uniformity within NC1. J. of Comput. and Syst. Sc., 41:274โ306, 1990. doi:10.1016/0022-0000(90)90022-D.
- [6] S.ย Bellantoni and S.ย Cook. A new recursion-theoretic characterization of poly-time functions. Comput. Complex., 2:97โ110, 1992. doi:10.1007/BF01201998.
- [7] M.ย Blanc and O.ย Bournez. A characterisation of functions computable in polynomial time and space over the reals with discrete ordinary differential equations: simulation of Turing Machines with analytic discrete ODEs. In Proc. MFCS, pages 21:1โ21:15, 2023.
- [8] M.ย Blanc and O.ย Bournez. The complexity of computing in continuous time: Space complexity is precision. In Proc. ICALP, pages 129:1โ129:22, 2024.
- [9] G.ย Bonfante, R.ย Kahle, J.-Y. Marion, and I.ย Oitavem. Two function algebras defining functions in NCk boolean circuits. Inf. and Comput., 2016.
- [10] O.ย Bournez and A.ย Durand. Recursion schemes, discrete differential equations and characterization of polynomial time computation. In Proc. MFCS, 2019.
- [11] O.ย Bournez and A.ย Durand. A characterization of functions over the integers computable in polynomial time using discrete differential equations. Comput. Complex., 32(7), 2023. doi:10.1007/S00037-023-00240-1.
- [12] P.G. Clote. A sequential characterization of the parallel complexity class NC. Technical report, Boston College, 1988.
- [13] P.G. Clote. Sequential, machine-independent characterizations of the parallel complexity classes AlogTIME, ACk, NCk and NC, pages 49โ69. Progress in Computer Science and Applied Logic. Birkhรคuser, Boston, MA, 1990.
- [14] P.G. Clote. On polynomial size Frege proofs of certain combinatorial principles. In P.ย Clote and Krjรญcek J., editors, Arithmetic, Proof Theory, and Computational Complexity, pages 166โ184. Clarendon Press, 1993.
- [15] P.G. Clote and E.ย Kranakis. Boolean Functions and Computation Models. Springer, 1998.
- [16] P.G. Clote and G.ย Takeuti. Bounded arithmetic for NC, ALogTIME, L and NL. Ann. Pure and Appl. Logic, 56:73โ117, 1992. doi:10.1016/0168-0072(92)90068-B.
- [17] P.G. Clote and G.ย Takeuti. First order bounded arithmetic and small complexity classes. In Feasible Mathematics II, pages 154โ218. Birkhรคuser Boston, 1995.
- [18] A.ย Cobham. The intrinsic computational difficulty of functions. In Logic, Methodology and Phylosophy of Science: Proc. 1964 International Congress, pages 24โ30. North-Holland Pub. Co., 1965.
- [19] K.J. Compton and C.ย Laflamme. An algebra and a logic for NC1. Inf. Comput., 87(1/2):240โ262, 1990. doi:10.1016/0890-5401(90)90063-N.
- [20] S.ย Cook and T.ย Morioka. Quantified propositional calculus and a second-order theory for NC1. Arch. Math. Logic, 44:711โ749, 2005. doi:10.1007/S00153-005-0282-2.
- [21] S.ย Cook and P.ย Nguyen. Theories for TC0 and other small circuit classes. Log. Meth. Comput. Sci., 2(1โ40), 2006.
- [22] A.ย Durand, A.ย Haak, and H.ย Vollmer. Model-theoretic characterization of Boolean and arithmetic circuit classes of small depth. In Proc. LICS, pages 354โ363, 2018.
- [23] M.L. Furst, J.B. Saxe, and M.ย Sipser. Parity, circuits, and the polynomial-time hierarchy. In Proc. FOCS, pages 260โ270, 1981.
- [24] Y.ย Gurevich and H.ย Lewis. A logic for constant-depth circuit. Inf. Control, 61:65โ74, 1984. doi:10.1016/S0019-9958(84)80062-5.
- [25] W.ย Hesse, E.ย Allender, and D.A.M. Barrington. Uniform constant-depth threshold circuits for division and iterated multiplication. Journal of Computer and System Sciences, 65(4):695โ716, 2002. doi:10.1016/S0022-0000(02)00025-9.
- [26] N.ย Immerman. Languages that capture complexity classes. SIAM J. Comput., 16:760โ778, 1987. doi:10.1137/0216051.
- [27] J.ย Johannsen. A bounded arithmetic theory for constant depth threshold circuits, volumeย 6 of Springer Lecture Notes in Logic, chapter GรDEL โ96, pages 224โ234. Hรกjek, P., 1996.
- [28] D.ย Leivant. Predicative recurrence and computational complexity I: Word recurrence and poly-time. In Feasible Mathematics. Birkhรผser, 1994.
- [29] D.ย Leivant and J.-Y. Marion. Ramified recurrence and computational complexity II: Substitution and poly-space. In Proc. CSL, pages 369โ380, 1995.
- [30] D.ย Leivant and Y.-Y. Marion. Lambda calculus characterizations of poly-time. Fundam. Inform., 19(1,2):167โ184, 1993.
- [31] S.ย Lindell. A purely logical characterization of circuit uniformity. In 7th Structure in Complexity Theory Conf., pages 185โ192, 1992.
- [32] A.A. Razborov. Lower bounds on the size of bounded depth circuits over a complete basis with logical addition. Mathematical Notes of the Academy of Sciences of the USSR, 41:333โ338, 1987.
- [33] R.ย Smolensky. Algebraic methods in the theory of lower bounds for boolean circuit complexity. In Alfredย V. Aho, editor, Proceedings of the 19th Annual ACM Symposium on Theory of Computing, 1987, New York, New York, USA, pages 77โ82. ACM, 1987. doi:10.1145/28395.28404.
- [34] H.ย Vollmer. Introduction to Circuit Complexity: A Uniform Approach. Springer, 1999.
