Logical Characterization of Algebraic Circuit Classes over Integral Domains

TL;DR

This paper extends algebraic circuit classes over the reals to arbitrary infinite integral domains, providing logical characterizations and hierarchy results that unify and generalize classical complexity classes over various domains.

Contribution

It introduces a generalized framework for algebraic circuits over integral domains and establishes logical characterizations and hierarchy theorems for these classes.

Findings

Sets decided by constant-depth, polynomial-size circuits match definable first-order logic.

Characterizations of $ ext{AC}_R$ and $ ext{NC}_R$ hierarchies are provided.

Framework applies to Boolean $ ext{AC}$ and $ ext{NC}$ hierarchies as well.

Abstract

We present an adapted construction of algebraic circuits over the reals introduced by Cucker and Meer to arbitrary infinite integral domains and generalize the $\mathrm{AC}_{\mathbb{R}}$ and $\mathrm{NC}_{\mathbb{R}}$-classes for this setting. We give a theorem in the style of Immerman's theorem which shows that for these adapted formalisms, sets decided by circuits of constant depth and polynomial size are the same as sets definable by a suitable adaptation of first-order logic. Additionally, we discuss a generalization of the guarded predicative logic by Durand, Haak and Vollmer and we show characterizations for the $\mathrm{AC}_{R}$ and $\mathrm{NC}_{R}$ hierarchy. Those generalizations apply to the Boolean $\mathrm{AC}$ and $\mathrm{NC}$ hierarchies as well. Furthermore, we introduce a formalism to be able to compare some of the aforementioned complexity classes with different underlying integral domains.

Equations

$$a\times (b+c)$$

$$(a+b)\times c$$

$$r\times 0$$

$$0\times r$$

$$f(x)=\sum _{i\ge 0}{a}_i{x}^i=a_0+a_{1}x+a_2{x}^2+\cdots ,$$

$$\sum _{i\ge 0}{a}_i{x}^i=\sum _{i\ge 0}{b}_i{x}^i⟺(\forall i\ge 0):a_i=b_i.$$

$$f(x)+g(x):=\sum _{i\ge 0}(a_i+b_i)x^i$$

$$f(x)\times g(x):=\sum _{k\ge 0}\sum _{\begin{array}{c}0\le i\le k,\\ 0\le j\le k,\\ i+j=k\end{array}}{a}_i{b}_j{x}^{i+j}$$

$$S:=R[x_1,\dots ,x_n]:=(R[x_1,\dots ,x_{n-1}])[x_n],$$

$$R[f]:=\{a+f\cdot b\mid a,b\in R\}.$$

$$(a+f\cdot b)+(c+f\cdot d):=(a+c)+f\cdot (b+d)$$

$$(a+f\cdot b)\cdot (c+f\cdot d):=ac+f(ad+bc)+f^2(bd),$$

$$a\times (b+c)=a\times b+a\times c,\text{ for all }a,b,c\in F$$

$${\mathrm{sign}}_{(R,<)}(x)=\{\begin{array}{ll}1& \text{if x>0}\\ 0& \text{otherwise.}\end{array}$$

$$R^{\ast }=\bigcup _{k\in {\mathbb{N}}_0}{R}^k$$

$$x<y⟺\mathrm{sign}(\mathrm{sign}(y-x)\cdot (2+\mathrm{sign}(x-y)))=1.$$

$$f_C(x_1,\dots ,x_n)=(y_1,...,y_m),$$

$$f_{\mathcal{C}}(x)=f_{C_{|x|}}(x)$$

$${\text{sum}}_{\overline{x}}(t(\overline{x},\overline{w}))$$

$$\phi :=\exists x\forall y(x\ne y\to {\text{sum}}_a(f_E(x,a))>2\times {\text{sum}}_b(f_E(y,b)))$$

$$x\le \frac{y}{2}⟺x+x\le y.$$

$$\text{BIT}:=\{(i,j)\mid \text{ the ith bit of the binary representation of j is 1, }i,j\in \mathbb{N}\}.$$

$$\begin{gathered} \text{BIT}:=\{(i,j)\mid \text{ when i and j are taken as their numerical interpretations, the } \\ \text{ith bit of the binary representation of j is 1, }i,j\in D^{\ast }\} \end{gathered}$$

$$\overline{x}\le \overline{y}/2⟺\exists \overline{z}\overline{x}+\overline{x}=\overline{z}\wedge \overline{z}\le \overline{y}$$

$${\text{max}}_{\overline{x}}.(\phi (\overline{x}))t(\overline{x})$$

$${\text{max}}_{\overline{x}}(\chi [\phi (\overline{x})]\times t(\overline{x})).$$

$${\text{sum}}_{\overline{x}}.(\phi (\overline{x}))t(\overline{x})$$

$${\text{sum}}_{\overline{x}}(\chi [\phi (\overline{x})]\times t(\overline{x}))$$

$${\text{prod}}_{\overline{x}}.(\phi (\overline{x}))t(\overline{x})$$

$${\text{prod}}_{\overline{x}}(\chi [\phi (\overline{x})]\times t(\overline{x})+\chi [\neg \phi (\overline{x})]\times 1).$$

$$\phi :=[f(\overline{x},\overline{y_1},\dots ,\overline{y_i},\overline{y_{i+1}})\equiv t(\overline{x},\overline{y_1},\dots ,\overline{y_i},\overline{y_{i+1}},f)]\psi (f),$$

Full text

1. Introduction

Boolean circuits as a computational model are a fundamental concept in the study of theoretical computer science. Mainly in computational complexity, Boolean circuits play a central part in the analysis of parallel algorithms and the corresponding complexity classes, enabling a finer view and providing new proof methods, especially for subpolynomial complexity classes. An obvious generalization of Boolean circuits is that instead of dealing with truth values as inputs – or the field $\mathbb{Z}_{2}$ for the algebraically minded – we consider elements from some other algebraic structure. This approach has its roots in the works of Blum, Shub, and Smale, whose model of the BSS-machine is able to describe computations over real numbers. Following this, Blum, Shub, Smale, and Cucker [Blu+98] also give a generalization to algebraic circuits over the reals.

1.1. Our Contribution

In this article, we provide logical characterizations of circuit complexity classes over integral domains. In particular, we define natural extensions of the classical circuit complexity hierarchies $\mathrm{AC}^{i}$ and $\mathrm{NC}^{i}$ over arbitrary integral domains. The resulting classes are denoted as $\mathrm{AC}^{i}_{R}$ and $\mathrm{NC}^{i}_{R}$, respectively. We adapt the framework of metafinite model theory to define various extensions of first order logic, which capture these new complexity classes.

We establish a Immerman-style theorem stating that $\mathrm{FO}_{R}=\mathrm{AC}^{0}_{R}$ and provide a framework to establish complexity-theoretic comparisons of classes with different underlying integral domains and give examples over which integral domain the $\mathrm{AC}^{0}$-classes are equal.

We adapt the $\mathrm{GPR}$-operator, which Durand, Haak and Vollmer use to provide logical characterizations of $\mathrm{AC}^{1}$ and $\mathrm{NC}^{1}$ [DHV18] to logics over metafinite structures and extend it to be able to characterize the whole $\mathrm{AC}_{R}$ and $\mathrm{NC}_{R}$-hierarchies.

Finally, we define a formalism suitable for comparing complexity classes with different underlying integral domains and we show that a hierarchy of sets of complexity classes emerges, such that each set is able to “simulate” the complexity classes from the sets lower in the hierarchy.

1.2. Related Work

Another model of computation that is commonly known under the name “algebraic circuit” are Valiant circuits [Val79], which are the foundational model in the emerging subfields of algebraic and geometric complexity theory. They differ from the model we analyze in this work in the way that we use $<$-gates, which are not available in the Valiant setting. This difference is of complexity-theoretical significance since for our model, we have that $\mathrm{NC}^{i}_{\mathbb{R}}\subsetneq\mathrm{NC}^{i+1}_{\mathbb{R}}$ [Cuc92] but we have that $\mathrm{VNC^{2}}=\mathrm{VNC^{3}}=\ldots=\mathrm{VP}$ [Bür13] in the Valiant setting for every field, in particular over the reals.

1.3. Outline of the Paper

We start with an overview of some central concepts from algebra and circuit complexity, which are needed for the definition of our model. We then establish our model of algebraic circuits for arbitrary integral domains and the analogous complexity classes induced by them in analogy to the Boolean case. Afterwards, we give a logical characterization of the presented circuit classes inspired by classical descriptive complexity. However, since our models now have an infinite component, we build on the foundations of metafinite model theory.

We then go on to define first-order logic over $R$ and show that, like in the classical case, we have that $\mathrm{AC}^{0}_{R}=\mathrm{FO}_{R}[\mathrm{Arb}_{R}]+\mathrm{SUM}_{R}+\mathrm{PROD}_{R}$.

In Section 4, we give logical characterizations of $\mathrm{AC}^{i}$ and $\mathrm{NC}^{i}$. The tool of our choice is an adaptation of the guarded predicative logic of [DHV18].

In Section 5, we discuss connections between $\mathrm{AC}^{0}_{R}$-classes over different integral domains.

Acknowledgements**.**

We thank Sebastian Berndt and Anselm Haak for fruitful discussions.

2. Preliminaries

First, we discuss the theoretical background of this paper. We give the basic definitions and remarks on the notation used in this paper.

Notation 2.1**.**

In this paper, we will generally use overlined letters (e. g. $\overline{x}$) to denote tuples.

As the name suggests, algebraic circuit classes make use of concepts originating from abstract algebra. We will first give an overview of some fundamental concepts used in this paper. For further information on the topic, the reader may refer to the books by Aluffi [Alu09] or Lang [Lan02].

Definition 2.2** (Ring).**

A ring with unit $(R,+,\times)$ is a tuple consisting of a set $R$ and two binary operations $+$ and $\times$ such that

• •

$1\in R$

• •

$(R,+)$ is an abelian group, i. e.

• –

For every $a,b,c\in R$, we have $(a+b)+c=a+(b+c)$

• –

For every $a,b\in R$, we have $a+b=b+a$

• –

There is a $0\in R$, we have $a+0=a$

• –

For every $a\in R$, there exists an inverse $-a\in R:a+(-a)=0$

• •

$(R,\times)$ is a monoid, i. e.

• –

$(a\times b)\times c=a\times(b\times c)$

• –

There is a $1\in R$ such that $a\times 1=1\times a=a$

• •

multiplication is distributive with respect to addition:

[TABLE]

A ring is called commutative, if $a\times b=b\times a$, for all $a,b\in R$.

In the following a ring is always assumed to have a unit.

Definition 2.3** (Integral domain).**

A ring $R$ with unit is called integral domain, if it is a commutative ring and if there is no element $a\in R$ which is a zero-divisor, i. e. there is no $a\in R\setminus\{0\}$ for which there is a $b\in R\setminus\{0\}$ with $a\times b=0$.

Throughout the paper, whenever not otherwise specified, we use $R$ to denote an infinite integral domain.

Remark 2.4**.**

In particular we require that for every $r\in R$ the equations

[TABLE]

hold.

Definition 2.5** (Polynomial).**

Let $R$ be a ring. A polynomial $f(x)$ in the indeterminate $x$ and with coefficients in $R$ is a finite linear combination of nonnegative exponents of $x$ with coefficients in $R$:

[TABLE]

where all $a_{i}$ are elements of $R$ (the coefficients) and we require $a_{i}=0$ for infinitely many $i$. Two polynomials are taken to be equal if all the coefficients are equal:

[TABLE]

The set of polynomials in $x$ over $R$ is denoted by $R[x]$.

Definition 2.6** (Polynomial ring).**

Let $f(x)=\sum_{i\geq 0}a_{i}x^{i}$ and $g(x)=\sum_{i\geq 0}b_{i}x^{i}$ be two polynomials. A polynomial ring is the set $R[x]$ together with the following two operations:

[TABLE]

and

[TABLE]

The unit of this ring is $1_{R[x]}=1_{R}+0x+0x^{2}+\cdots$.

Remark 2.7**.**

A polynomial ring like in Definition 2.6 is also a ring with unit. Analogous to Definition 2.6, we can a define polyomial ring $S$ with finitely many variables $x_{1},\ldots,x_{n}$ by applying Definition 2.6 inductively:

[TABLE]

where $R$ is a ring. Note that polynomial rings over fields are integral domains.

Definition 2.8** (Adjoint elements to a ring).**

When adjoining a number $f\not\in R$ to a ring $R$ we obtain the set

[TABLE]

The set $R[f]$ together with the following two operations

[TABLE]

and

[TABLE]

where $+$ and $\cdot$ are the binary operations on the ring, is again a ring, where $1_{R[x]}=1_{R}+0f$ is the unit of this ring.

Example 2.9**.**

Popular examples of rings include $\mathbb{Z},\mathbb{Q},\mathbb{R}$ and $\mathbb{C}$, as well as sets with adjoined elements like $\mathbb{Z}[i],\mathbb{Z}[\sqrt[p]{-1}],\mathbb{Z}[\sqrt{p},\sqrt{q},\ldots]$, $\mathbb{R}[i_{k}],\mathbb{Z}[i_{k}],\ldots$, where $k\in\mathbb{N}$, $p\neq q$ are primes and $i_{k}$ denotes the $k$th root of $-1$, i. e. $i_{k}^{k}=-1$. Alternatively, we can adjoin $\ell$ algebraic independent prime root elements with $2^{\ell}=k$ and get an analogous construction.

Remark 2.10**.**

The denotation of $\mathbb{R}[i_{k}]$ resp. $\mathbb{Z}[i_{k}]$ are not unique but the constructions of the circuit over the underlying rings are analogous except for the placeholders for the adjoined numbers. For example $\mathbb{Z}^{4}$ can denote $\mathbb{Z}[i_{4}]=\mathbb{Z}[i_{4},i_{4}^{2},i_{4}^{3}]$ or $\mathbb{Z}[\sqrt{2},\sqrt{5}]=\mathbb{Z}[\sqrt{2},\sqrt{5},\sqrt{10}]$ or many other rings. Since we only focus on the structure of the tuples, i. e., the coefficients of adjoint elements, or later the underlying circuits, our short notation for $\mathbb{Z}^{k}$ for arbitrary $k>1$ is not unique and may differ, e. g. $\mathbb{Z}^{2}$ may denote $\mathbb{Z}[i]$ or may denote $\mathbb{Q}$. In the context of the placeholder notation, the arithmetic of the specific ring must be clear, if it is important.

Definition 2.11** (Field).**

A field $(F,+,\times)$ is a tuple consisting of a set $F$ and two binary operations $+$ and $\times$ such that

• •

$1\in F$

• •

$0\in F$

• •

$(F,+)$ is an abelian group (see 2.2)

• •

$(F,\times)$ is an abelian group (see 2.2)

• •

multiplication is distributive with respect to addition:

[TABLE]

We do not need two equations for distributivity since multiplication and addition are both commutative.

Remark 2.12**.**

An alternative characterisation for a field is as a commutative ring where $0\neq 1$ holds and every element $a\neq 0\in F$ is invertible.

We need some ordering $<$ on our integral domain $R$. In some cases, like $\mathbb{R}$ and $\mathbb{Z}$, we have some natural ordering that we want to use. In other cases, like $\mathbb{C}$, we have to construct some ordering. This ordering does not have to be closed under multiplication, we only have to distinguish different numbers from each other. So an ordering on tuples ($z_{1}=a_{1}+b_{1}i,z_{2}=a_{2}+b_{2}i\in\mathbb{C}:(a_{1},b_{1})<_{\mathbb{C}}(a_{2},b_{2})\iff a_{1}<_{\mathbb{R}}a_{2}\text{ or }a_{1}=a_{2}\text{ and }b_{1}<_{\mathbb{R}}b_{2}$) is possible.

Definition 2.13**.**

A strict total order on a set $S$ is a binary relation $<$ on $S$ which is irreflexive, transitive and total.

Example 2.14**.**

For some field $\mathbb{F}_{p^{k}}$ for some prime $p$ and a natural number $k$, we write the finitely many elements in a list and then use the lexicographical on this list. For example, let $R=\mathbb{Z}_{3}$. Then we define $<_{\mathbb{Z}_{3}}$ as $0<1<2$.

There are multiple possibilities for such a $<$ over the field of complex numbers. Let $z=a+bi\in\mathbb{C}$ and let $<_{1}$ be the lexicographic order on pairs $(\sqrt{a^{2}+b^{2}},a)$. Furthermore, let $<_{2}$ be the lexicographic order on pairs of the form $(a,b)$. Then both variants are possible since both distinguish different complex numbers.

Definition 2.15**.**

A strict total order $<$ over a ring $R$ induces a $\operatorname{sign}$-function as follows:

[TABLE]

In the following, unless explicitly otherwise specified, the symbol $R$ denotes an infinite integral domain with a strict total order $<$ on $R$. Most of the rings we consider have a natural ordering. In this case, we omit the ordering symbol.

2.1. Algebraic Circuits over $R$

As this work is a generalization of the well established Boolean circuits, some background in circuit complexity is assumed. Standard literature which introduces this topic is the book by Vollmer [Vol99]. The generalization to algebraic circuits over real numbers were first introduced by Cucker [Cuc92]. In analogy to them, Barlag and Vollmer defined an unbounded fan-in version of algebraic circuits [BV21].

Definition 2.16**.**

We define an algebraic circuit $C$ over an integral domain $R$ with a strict total order $<$, or $R$-circuit for short, as a directed acyclic graph. It has gates of the following types:

Input nodes

have indegree [math] and contain the respective input values of the circuit.

Constant nodes

have indegree [math] and are labelled with elements of $R$

Arithmetic nodes

have an arbitrary indegree $\geq 1$, bounded by the number of nodes in the circuit and are labelled with either $+$ or $\times$.

Comparison ($<$) nodes

have indegree $2$.

Output nodes

have indegree $1$ and contain the output value after the computation of the circuit.

Nodes cannot be predecessors of the same node more than once, thus the outdegree of nodes in these algebraic circuits is bounded by the number of gates in the circuit.

During the computation of an algebraic circuit, the arithmetic gates compute their respective functions with the values of their predecessor gates being taken as the function arguments and the comparison gates compute the characteristic function of $<$ in the same way. The values of the output gates at the end of the computation are the result of the computation.

In contrast to the classical setting, where we consider words over an alphabet $\Sigma$ as inputs, and where languages are thus defined to be subsets of the Kleene closure of the alphabet (in symbols, $L\subseteq\Sigma^{*}$), we consider vectors of integral domain elements as input. In analogy to $\Sigma^{*}$, we denote for an integral domain $R$:

[TABLE]

With $\lvert x\rvert$, we denote the length of $x$, i. e., if $x\in R^{k}$ then $\lvert x\rvert=k$.

Remark 2.17**.**

We will use the term algebraic circuit to describe circuits in the sense of Blum, Cucker, Shub and Smale [Blu+98] rather than arithmetic circuits as e. g. in [BV21] to distinguish them from arithmetic circuits in the sense of Valiant, see e. g. [BCS97]. Valiant circuits are essentially algebraic circuits without $\operatorname{sign}$-gates [Blu+98, page 350].

Remark 2.18**.**

In the special case $R=\mathbb{Z}_{2}$, the definition above yields exactly the Boolean circuits.

Definition 2.19**.**

We call the number of gates in a circuit the size of the circuit and the longest path from an input gate to an output gate the depth of the circuit.

Remark 2.20**.**

Unlike the way algebraic circuits with unbounded fan-in gates were introduced previously [BV21], algebraic circuits in this context have comparison gates instead of $\operatorname{sign}$-gates. This stems from the fact that when dealing with real or complex numbers, we can construct a $\operatorname{sign}$-function from $<$ via Definition 2.15 and the order relation from the $\operatorname{sign}$-function via

[TABLE]

If we now consider finite integral domains, however, suddenly it becomes less clear how to construct the $<$ relation from the $\operatorname{sign}$ function, while the other way around still works by Definition 2.15.

Given that we define circuits and logic fragments relative to an ordering, it is natural for both to have access to this ordering. Therefore we choose to use $<$ gates rather than $\operatorname{sign}$ gates. So in the following, all usages of $\operatorname{sign}$ are implicit uses of the order relation as by Definition 2.15.

In the cases which are considered in other literature ($\mathbb{R}$ or $\mathbb{F}_{2}$), this has no complexity-theoretic impact, since in the emulation of one formalism using the other, we get a linear overhead in the size and constant overhead in the depth of the circuit.

In order to define complexity classes with respect to algebraic circuits, we have to define the function calculated by such a circuit and define the term of circuit families.

Definition 2.21**.**

The ($n$-ary) function $f_{C}\colon R^{n}\to R^{m}$ computed by an $R$-circuit $C$ (with $n$ input gates and $m$ output gates) is defined by

[TABLE]

where $y_{1},\dots,y_{m}$ are the values of the output gates of $C$, when given $x_{1},...,x_{n}$ as its inputs.

Definition 2.22**.**

A family of $R$-circuits $\mathcal{C}=(C_{n})_{n\in\mathbb{N}}$ is a sequence of circuits which contains one circuit for every input length $n\in\mathbb{N}$. The function $f_{\mathcal{C}}\colon R^{*}\to R^{*}$ computed by a circuit family $\mathcal{C}$ is defined by

[TABLE]

The size (resp. depth) of a circuit family $(C_{n})_{n\in\mathbb{N}}$ is defined as a function mapping $n\in\mathbb{N}$ to the size (resp. depth) of $C_{n}$.

Analogously to the classical case, we say that a set $S\subseteq R^{*}$ can be decided by a circuit family $\mathcal{C}$, if $\mathcal{C}$ can compute the characteristic function of $S$.

Definition 2.23**.**

The class $\mathrm{AC}^{i}_{R}$ is the class of sets decidable by $R$-circuit families of size $\mathcal{O}(n^{\mathcal{O}(1)})$ and depth $\mathcal{O}((\log_{2}n)^{i})$.

Definition 2.24**.**

The class $\mathrm{NC}^{i}_{R}$ is the class of sets decidable by $R$-circuit families of size $\mathcal{O}(n^{\mathcal{O}(1)})$ and depth $\mathcal{O}((\log_{2}n)^{i})$, where each arithmetic gate has an indegree bounded by $2$ (we call this bounded fan-in).

Remark 2.25**.**

The circuit families we have just introduced do not have any restrictions on the difficulty of constructing any individual circuit given the input length. If it is important to know how hard obtaining a particular circuit is, one can consider so-called uniform circuit families. These families require their circuits to meet restrictions on the difficulties of obtaining them. For more information on uniformity, cf. [Vol99].

Uniformity criteria can be defined for algebraic circuit classes in a similar way. See e. g. [Blu+98, Section 18.5].

2.2. Structures and first-order logic over integral domains

As we want to characterize circuit complexity classes with logical fragments, this work falls broadly under the umbrella of finite model theory, and, in particular, descriptive complexity. Foundational knowledge of these topics is assumed and can be found in the books by Grädel et al., Libkin and Immerman [Grä+07, Lib04, Imm99]. Traditionally, descriptive complexity is viewed as a subdiscipline of finite model theory, since allowing infinite structures often makes problems undecidable. In our setting, however, we want to (carefully) reintroduce infinite structures to our reasoning. For this, we use metafinite model theory, an extension of the finite model formalism first introduced by Grädel and Gurevich [GG98]. A short introduction to metafinite model theory is also featured in the book by Grädel et al. [Grä+07, page 210]. The approach was taken by Grädel and Meer [GM95] to describe some essential complexity classes over real numbers. These descriptions were later extended by Cucker and Meer [CM99], where, among other things, the $\mathrm{NC}$-hierarchy over real numbers was defined. For the characterization, these papers introduce a so-called first-order logic with arithmetics, which we will adapt to be used in our setting.

To make proofs easier, we use the well known trick that a signature consisting only of functions can emulate any predicates we might want to define via a characteristic function corresponding to the relation the predicate is interpreted as. We can furthermore emulate constants by [math]-ary functions.

Definition 2.26**.**

Let $L_{s}$, $L_{f}$ be finite vocabularies which only contain function symbols. An $R$-structure of signature $\sigma=(L_{s},L_{f})$ is a pair $\mathcal{D}=(\mathcal{A},F)$ where

1. (1)

$\mathcal{A}$ is a finite structure of vocabulary $L_{s}$ which we call the skeleton of $\mathcal{D}$ whose universe $A$ we will refer to as the universe of $\mathcal{D}$ and whose cardinality we will refer to by $\lvert A\rvert$ 2. (2)

and $F$ is a finite set which contains functions of the form $X\colon A^{k}\rightarrow R$ for $k\in\mathbb{N}$ which interpret the function symbols in $L_{f}$.

We will use $\textsc{struc}_{R}(\sigma)$ to refer to the set of all $R$-structures of signature $\sigma$ and we will assume that for any signature $\sigma=(L_{s},L_{f})$, the symbols in $L_{s}$ and $L_{f}$ are ordered.

Remark 2.27**.**

In this paper, we only consider ranked structures, i. e., structures, in which the skeleton is ordered.

Definition 2.28** (First-order logic over $R$).**

The language of first-order logic over an integral domain $R$ contains for each signature $\sigma=(L_{s},L_{f})$ a set of formulae and terms. The terms are divided into index terms which take values in universe of the skeleton and number terms which take values in $R$. These terms are inductively defined as follows:

1. (1)

The set of index terms is defined as the closure of the set of variables $V$ under applications of the function symbols of $L_{s}$. 2. (2)

Any element of $R$ is a number term. 3. (3)

For index terms $h_{1},...,h_{k}$ and a $k$-ary function symbol $X\in L_{f}$, $X(h_{1},...,h_{k})$ is a number term. 4. (4)

If $t_{1}$, $t_{2}$ are number terms, then so are $t_{1}+t_{2}$, $t_{1}\times t_{2}$ and $\operatorname{sign}(t_{1})$.

Atomic formulae are equalities of index terms $h_{1}=h_{2}$ and number terms $t_{1}=t_{2}$, inequalities of number terms $t_{1}<t_{2}$ and expressions of the form $P(h_{1},...,h_{k})$, where $P\in L_{s}$ is a k-ary predicate symbol and $h_{1},..,h_{k}$ are index terms.

The set $\mathrm{FO}_{R}$ is the smallest set which contains the closure of atomic formulae under the logical connectives $\{\land,\lor,\neg,\to,\leftrightarrow\}$ and quantification $\exists v\psi$ and $\forall v\psi$ where $v$ ranges over $\mathcal{A}$.

For better readabilty, we will use inequalities of the form $x\leq y$ and the extensions of equalities $\overline{x}=\overline{y}$ and the inequalities $\overline{x}<\overline{y}$ and $\overline{x}\leq\overline{y}$ to tuples throughout this paper. Note that these extensions are easily definable from $=$ and $<$ in first-order logic.

Remark 2.29**.**

We call any element of $R$ a number term even though some integral domains can contain elements like $\zeta$, $\aleph$ or $\circledast$ which are not numbers. Since we want to do some calculations with these elements, we call them numbers, too.

Equivalence of $\mathrm{FO}_{R}$-formulae and sets defined by $\mathrm{FO}_{R}$-formulae are done in the usual way, i. e., a formula $\varphi$ defines a set $S$ if and only if the elements of $S$ are exactly the encodings of $R$-structures under which $\varphi$ holds and two such formulae are said to be equivalent if and only if they define the same set.

With the goal in mind to create a logic which can define sets decided by circuits with unbounded fan-in, we introduce new rules for building number terms: the sum and the product rule. We will also define a further rule, which we call the maximization rule. This one is, however, already definable in $\mathrm{FO}_{R}$ and we thus do not gain any expressive power by using it. We will use it to show that we can represent characteristic functions in $\mathrm{FO}_{R}$.

Definition 2.30** (Sum, product and maximization rule).**

Let $t$ be a number term in which the variables $\overline{x}$ and the variables $\overline{w}$ occur freely and let $A$ denote the universe of the given input structure. Then

[TABLE]

is also a number term which is interpreted as $\sum_{\overline{x}\in A^{\lvert\overline{x}\rvert}}t(\overline{x},\overline{w})$. The number terms ${\textbf{prod}_{\overline{x}}}(t(\overline{x},\overline{w}))$ and ${\textbf{max}_{\overline{x}}}(t(\overline{x},\overline{w}))$ are defined analogously.

We call these operators aggregators and for any formula $\varphi$ containing aggregators of the above form, the variables in $\overline{x}$ are considered bound in $\varphi$.

Example 2.31**.**

Let $\sigma=(\{\},f_{E}^{2})$ be the signature of weighted graphs, i. e. $f_{E}(x,y)$ gives the weight of the edge from $x$ to $y$ or [math] if there is none. Let $\mathcal{G}$ be a (graph) structure over $\sigma$. Then the following $\mathrm{FO}_{R}+\textnormal{SUM}_{R}$ sentence $\varphi$ states that there is a node in the skeleton of $\mathcal{G}$, for which the sum of its outgoing edges is more than double the sum of the outgoing edges of any other node.

[TABLE]

Observation 2.32**.**

$\mathrm{FO}_{R}=\mathrm{FO}_{R}+\textnormal{MAX}_{R}$.

Proof.

An occurrence of ${\textbf{max}_{i}}(F(i))$ essentially assures that there exists an element $x$, such that for all elements $y$, $F(x)\geq F(y)$ and takes the value of $F(x)$. Clearly, this can be defined in fist order logic by a formula of the form $\forall x\exists yF(x)\geq F(y)$. ∎

Furthermore, any characteristic function of a logical formula can be described in $\mathrm{FO}_{R}$. The proof for this runs analogously to that of Cucker and Meer [CM99, Proposition 2], since this proof does not make any use of special properties of the reals.

3. $\mathrm{AC}^{0}_{R}=\mathrm{FO}_{R}$

In this section, we present a proof that $\mathrm{FO}_{R}$ captures the class $\mathrm{AC}^{0}_{R}$. The proof idea is similar to the proof of the established result by Immerman which characterizes $\mathrm{AC}^{0}$ via $\mathrm{FO}$.

When using logics to check, whether a given $R$-tuple would be accepted by a $R$-circuit, one needs to think about how this $R$-tuple would be interpreted as an $R$-structure $\mathcal{A}$. This can be done by interpreting it as the set of the circuit’s input gates along with a single unary function $f_{\mathrm{element}}\colon A\to R$ mapping the $i$th input gate to the $i$th input of the circuit. We call this kind of structure a circuit structure.

In the following, we would like to extend $\mathrm{FO}_{R}$ by additional functions and relations that are not given in the input structure. To that end, we make a small addition to Definition 2.26 where we defined $R$-structures. Whenever we talk about $R$-structures over a signature $(L_{s},L_{f})$, we now also consider structures over signatures of the form $(L_{s},L_{f},L_{a})$. The additional (also ordered) vocabulary $L_{a}$ does not have any effect on the $R$-structure, but it contains function symbols, which can be used in a logical formula with this signature. This means that any $R$-structure of signature $(L_{s},L_{f})$ is also an $R$-structure of signature $(L_{s},L_{f},L_{a})$ for any vocabulary $L_{a}$. The symbols in $L_{a}$ stand for functions that we will use to extend the expressive power of $\mathrm{FO}_{R}$ to capture various complexity classes.

Definition 3.1**.**

Let $F$ be a set of finite functions. We will write $\mathrm{FO}_{R}[F]$ to denote the class of sets that can be defined by $\mathrm{FO}_{R}$-sentences which can make use of the functions in $F$ in addition to what they are given in their structure.

Formally, this means that $\mathrm{FO}_{R}[F]$ describes exactly those sets $S\subseteq R^{*}$ for which there exists a $\mathrm{FO}_{R}$-sentence $\varphi$ over a signature ${\sigma=(L_{s},L_{f},L_{a})}$ such that for each length $n$, there is an interpretation $I_{n}$ interpreting the symbols in $L_{a}$ as elements of $F$ such that for all $R^{*}$-tuples $s$ of length $n$ it holds that $s\in S$ if and only if $s$ encodes an $R$-structure over $(L_{s},L_{f},L_{a})$ which models $\varphi$ when using $I_{n}$.

Definition 3.2**.**

We write $\mathrm{Arb}_{R}$ to denote the set of all functions $f\colon R^{k}\to R$, where $k\in\mathbb{N}$.

Theorem 3.3**.**

Let R be an infinite integral domain. Then $\mathrm{AC}^{0}_{R}=\mathrm{FO}_{R}[\mathrm{Arb}_{R}]+\textnormal{SUM}_{R}+\textnormal{PROD}_{R}$.

Proof.

The proof for this theorem works similarly to the construction for $\mathrm{FO}_{\mathbb{R}}[\mathrm{Arb}_{\mathbb{R}}]+\textnormal{SUM}_{\mathbb{R}}+\textnormal{PROD}_{\mathbb{R}}=\mathrm{AC}^{0}_{\mathbb{R}}$ [BV21], since this construction does not make use of any special properties of the real numbers.

The basic idea for this proof is that we first show that for any $\mathrm{FO}_{R}[\mathrm{Arb}_{R}]+\textnormal{SUM}_{R}+\textnormal{PROD}_{R}$-sentence $\varphi$, we can construct a circuit familiy which accepts its input if and only if the input encodes an $R$-structure that satisfies $\varphi$. This is basically done by mimicing the behaviour of the logical operators of $\varphi$ using the available gate types and evaluating the formula level by level. A universal quantifier as in $\forall x\varphi(x)$, for instance, is implemented by using a $\operatorname{sign}$-gate (obtained from $<$ as per Definition 2.15) on top of a multiplication gate, which has the circuits for $\varphi(a)$ for each $a$ in the skeleton of the encoded structure as its predecessors.

To translate the semantics of $\mathrm{FO}_{R}$ into a circuit, we can mostly use the same translations as in the proof for the real case, as for the most part only properties of integral domains are used. We need ring properties for most of these translations and in particular for universal quantifiers, we also need commutativity of multiplication and no zero dividers, hence we require integral domains.

We do need to change the translation for existential quantifiers and $\lor$, however. In the real case, the circuit for $\exists x\varphi(x)$ is constructed similarly to the universal case with a $\operatorname{sign}$-gate followed by an addition gate with the circuits for $\varphi(a)$ for each $a$ in the skeleton as its predecessors. Since there are infinite integral domains with characteristic greater than [math], i. e., where adding a positive amount of $1$ elements can yield [math], this would not always produce the desired result. However, we can overcome this easily by translating $\exists x\varphi(x)$ to $\neg\forall x\neg\varphi(x)$ and $x\lor y$ to $\neg(\neg x\land\neg y)$, as negation, universal quantifiers and $\land$ are constructible with integral domain properties.

For the converse inclusion, a number term $\operatorname{val}_{d}(g)$ is created when given a circuit family $(C_{n})_{n\in\mathbb{N}}$, such that for each $n$, $\operatorname{val}_{d}(g)$ evaluates to the value of gate $g$ if $g$ is on the $d$th level of the respective circuit $C_{n}$. For this construction, with integral domain properties no changes need to be made to the formula in the real setting. ∎

4. Algebraic Circuits and Guarded Functional Recursion

In this section, we generalize the logical characterizations of $\mathrm{NC}^{1}$ and $\mathrm{AC}^{1}$ by Durand, Haak and Vollmer [DHV18] to the respective complexity classes over integral domains $\mathrm{NC}^{1}_{R}$ and $\mathrm{AC}^{1}_{R}$. We furthermore extend this method to capture the entire $\mathrm{NC}_{R}$ and $\mathrm{AC}_{R}$ hierarchies.

In their paper, Durand, Haak and Vollmer use what they call guarded predicative recursion to extend first-order logic in order to capture the logarithmic depth circuit complexity classes $\mathrm{NC}^{1}$ and $\mathrm{AC}^{1}$. This essentially amounts to a recursion operator, which halves a tuple of variables (in their numerical interpretation) which is handed down in each recursion step. This ensures that the total recursion depth is at most logarithmic. The halving of the variable tuple is performed by using the fact that addition is expressible in $\mathrm{FO}$ if BIT and $<$ are expressible [Imm99] in the following way

[TABLE]

Note that we do not define the formula of the halving to be equality, since this is not possible for odd numbers. However, this is not an issue since we only want to bound the worst case recursion depth. In order to capture classes of polylogarithmic depth, we would like to find a suitable factor to replace $\frac{1}{2}$ with, so that the recursion process has polylogarithmic depth as well. As it turns out, for any $i\in\mathbb{N}$, we can assure a recursion depth of $\mathcal{O}((\log_{2}n)^{i})$ by using the factor $2^{-\frac{\log_{2}n}{(\log_{2}n)^{i}}}$.

Observation 4.1**.**

Any number $n\in\mathbb{N}$ can be multiplied by the factor $2^{-\frac{\log_{2}n}{(\log_{2}n)^{i}}}$ exactly $(\log_{2}n)^{i}$ times, before reaching $1$.

Proof.

$n\cdot\left(2^{-\frac{\log_{2}n}{(\log_{2}n)^{i}}}\right)^{(\log_{2}n)^{i}}=n\cdot 2^{-\frac{\log_{2}n}{(\log_{2}n)^{i}}\cdot(\log_{2}n)^{i}}=n\cdot 2^{-\log_{2}n}=n\cdot\frac{1}{n}=1$ ∎

A more general version of this observation can be found in Lemma A.2 in the appendix. Unfortunately, while it is simple to divide by $2$ when the BIT predicate is available, it is not at all clear if multiplying by a factor such as $2^{-\frac{\log_{2}n}{(\log_{2}n)^{i}}}$ can be done in first-order logic.

We can, however, make use of the ability to divide by $2$ in order to achieve polylogarithmic recursion depth, by instead of dividing a number, essentially dividing the digits of a base $n$ number individually and carrying over once [math] is reached.

Let us take for example the base $5$ number $444$. The previously mentioned process is illustrated in the table in Figure 1. The table is supposed to be read from top to bottom and then from left to right.

We divide the digits of $444$ from the least to most the significant digit until [math] is reached. So, the first step is dividing the rightmost digit of $444$ by $2$, getting from $444$ to $442$. After two more divisions of that kind, we reach [math] and in the subsequent step we reset the rightmost digit and divide the second digit once. This works in a similar way to counting down, where instead of taking away $1$ in each step, we divide by $2$ and carry over in an analogous way. Notably, reaching $000$ from $444$ takes $63=(\lfloor\log_{2}5\rfloor+2)^{3}-1$ steps. This is no coincidence: It can easily be shown that for any base $n$ number of $i$ digits, this sort of process reaches the smallest possible element after less than $(\lfloor\log_{2}n-1\rfloor+2)^{i}-1$ steps.

In order to perform divisions by $2$, as stated before, we need to be able to express the BIT predicate in our logic. In the classical case with natural numbers, BIT is defined as follows, where we assume the most significant bit of $j$’s binary representation to be the bit at index $1$:

Definition 4.2**.**

Let the relation $\text{BIT}^{2}\subseteq\mathbb{N}\times\mathbb{N}$ be defined as follows:

[TABLE]

Since we wish to logically characterize languages decided by circuit families, it is useful to briefly talk about representation of numbers in descriptive complexity. In descriptive complexity, tuples of elements from a finite, ordered domain $A$ are often associated with numbers. This is frequently done by interpreting the tuple as a base $\lvert A\rvert$ number with each element of the tuple representing its position in the ordering of $A$.

Example 4.3**.**

For example, let $D=\{a,b,c,d\}$ be ordered such that $a<b<c<d$. Then the tuple $(b,d,c,a)=(1,3,2,0)$ would be interpreted as the base $4$ number $1320$, which would correspond to $60$ in decimal.

Whenever we talk about the numerical interpretation of a tuple, we refer to this sort of interpretation. Given that we are in this setting, we adjust the definition of BIT to suit our purposes as follows, where again, the most significant bit of $j$’s binary representation is the bit at index $1$:

Definition 4.4**.**

For any ranked structure with universe $D$, let the relation $\text{BIT}^{2}\subseteq D^{*}\times D^{*}$ be defined as follows:

[TABLE]

With the BIT predicate and an order relation, we are now able to express division by $2$ in first-order logic. We use the fact that whenever BIT and an order are available, we can express multiplication and addition of numerical interpretations of tuples [Imm99]. This result was shown for plain first-order logic, and since our two-sorted first-order logic $\mathrm{FO}_{R}$ is equivalent to first-order logic if the secondary component is ignored, we can apply it here as well.

We express division by $2$ as follows:

[TABLE]

Note again, that since the numerical interpretations of tuples are natural numbers, expressing $\overline{x}\leq\overline{y}/2$ is really as good as we can do, since $\overline{x}=\overline{y}/2$ would not work for odd numbers.

Next, we will turn to defining the recursion operator which we have alluded to in the beginning of this section. First, we need a little bit of additional notation, i. e., relativized aggregators. A relativization of an aggregator is a formula restricting which elements are considered for the aggregator.

Notation 4.5**.**

For a number term $t$ and a $\mathrm{FO}_{R}$ formula $\varphi$ we write

[TABLE]

as a shorthand for

[TABLE]

Analogously we write

[TABLE]

for

[TABLE]

and

[TABLE]

as a shorthand for

[TABLE]

We now define the $\mathrm{GFR}_{R}^{i}$ operator and logics extended by $\mathrm{GFR}_{R}^{i}$ of the form $\mathcal{L}+\mathrm{GFR}_{R}$. The idea is to mimic the behavior demonstrated in Figure 1.

Definition 4.6** ($\mathrm{GFR}_{R}^{i}$).**

Let $F$ be a set of functions such that BIT is definable in $\mathrm{FO}_{R}[F]$ and let $\mathcal{L}$ be $\mathrm{FO}_{R}[F]$ or a logic obtained by extending $\mathrm{FO}_{R}[F]$ with some construction rules (such as the sum or the product rule as per Definition 2.30).

For $i\geq 0$, the set of $\mathcal{L}+\mathrm{GFR}_{R}^{i}$-formulae over $\sigma$ is the set of formulae by the grammar for $\mathcal{L}$ over $\sigma$ extended by the rule

[TABLE]

where $\psi$ is a $\mathcal{L}$ formula, $f$ is a function symbol and $t$ is a $\mathcal{L}$ number term with free variables $\overline{x},\overline{y_{1}},\dots,\overline{y_{i}},\overline{y_{i+1}}$ such that all $\overline{y_{j}}$ for $1\leq j\leq i$ contain the same (positive) number of variables and each (sub-)number term involving the symbol $f$ in $t$

1. (1)

is of the form $f(\overline{x},\overline{z_{1}},\dots,\overline{z_{i}},\overline{z_{i+1}})$, where $\overline{z_{1}},\dots,\overline{z_{i}},\overline{z_{i+1}}$ are in the scope of a guarded aggregation

[TABLE]

with $A\in\{\textbf{max},\textbf{sum},\textbf{prod}\}$, $\xi\in\mathcal{L}$ with $\xi$ not containing any relation symbols for relations given in the input structure and 2. (2)

never occurs in the scope of any aggregation (or quantification) not guarded this way.

The function symbol $f$ is considered bound in

[TABLE]

The semantics for the $\mathrm{GFR}_{R}^{i}$ operator are defined as follows: Let $\varphi$ be a $\mathcal{L}+\mathrm{GFR}_{R}^{i}$ formula over $\sigma$ with the single $\mathrm{GFR}_{R}^{i}$ occurrence

[TABLE]

and let $\mathcal{D}\in\textsc{struc}_{R}(\sigma)$. Then, the operator which is applied to the formula $\psi$, namely $[f(\overline{x},\overline{y_{1}},\dots,\overline{y_{i}},\overline{y_{i+1}})\equiv t(\overline{x},\overline{y_{1}},\dots,\overline{y_{i}},\overline{y_{i+1}},f)]$, defines the interpretation of $f$ in $\psi$ in the following way: For all tuples $\overline{a},\overline{b_{1}},\dots,\overline{b_{i}},\overline{b_{i+1}}$ of elements of the universe $D$ of $\mathcal{D}$ with the same arities as $\overline{x},\overline{y_{1}},\dots,\overline{y_{i}},\overline{y_{i+1}}$, respectively,

[TABLE]

This means that the formula $[f(\overline{x},\overline{y_{1}},\dots,\overline{y_{i}},\overline{y_{i+1}})\equiv t(\overline{x},\overline{y_{1}},\dots,\overline{y_{i}},\overline{y_{i+1}},f)]\psi(\overline{c},f)$ holds for a tuple $\overline{c}\in D^{\lvert\overline{c}\rvert}$ with the same arity as $\overline{z}$ if and only if $\mathcal{D}\models\psi(\overline{c},f_{I})$ where $f_{I}$ is the interpretation of $f$ as defined by the $\mathrm{GFR}_{R}^{i}$ operator. Semantics of formulae with several $\mathrm{GFR}_{R}^{i}$ operators are defined analogously.

Note that the $(i+1)$th tuple does not get restricted by the guarded aggregation.

Having defined the $\mathrm{GFR}_{R}^{i}$ operator, it remains to be shown that it indeed ensures polylogarithmic recursion depth in the way that we want it to.

Lemma 4.7**.**

Let $\mathcal{D}\in\textsc{struc}_{R}(\sigma)$ and let $\varphi$ be a formula containing a $\mathrm{GFR}_{R}^{i}$ operator. Then the recursion depth of the $\mathrm{GFR}_{R}^{i}$ operator is bounded by $\mathcal{O}((\log_{2}n)^{i})$, where $n$ is the size of the universe of $\mathcal{D}$.

Proof.

Let $n$ be the size of the universe of the structure under which the $\mathrm{GFR}_{R}^{i}$ operator is interpreted. The bound for the recursion depth of the $\mathrm{GFR}_{R}^{i}$ operator stems from the relativization which guards the aggregated variables. Let $f(\overline{x},\overline{z_{1}},\dots,\overline{z_{i}},\overline{z_{i+1}})$ be an occurrence of a $\mathrm{GPR}^{i}$ operator. Then the variables in $\overline{z_{1}},\dots,\overline{z_{i}},\overline{z_{i+1}}$ are in the scope of a guarded aggregation of the form

[TABLE]

as per Definition 4.6.

Let $z_{j}$ be the numerical interpretation of $\overline{z_{j}}$ for all $1\leq j\leq i$. We interpret the tuple $\overline{z_{1}},\dots,\overline{z_{i}}$ as a natural number $z$ of base $n$ where the $j$th digit of $z$ is $z_{j}$.

First, observe that in this interpretation, the relativization of the variables used in the recursive call ensures that $z$ strictly decreases in each step. The big conjunction $\bigvee\limits_{j=1}^{i}\overline{z_{j}}\leq\overline{y_{j}}/2\land\bigwedge\limits_{k=1}^{j-1}\overline{z_{k}}\leq\overline{y_{k}}$ makes sure that there is an index $j$, such that $\overline{z_{j}}\leq\overline{y_{j}}/2$, which means that the numerical interpretation of $\overline{z_{j}}$ is at most half of the numerical interpretation of $\overline{y_{j}}$. It also ensures that all tuples with smaller indices $\overline{z_{k}}$ (i. e. the more significant tuples in the interpretation of $\overline{z_{1}},\dots,\overline{z_{i}}$ as a base $n$ number) do not increase.

Since each of the tuples $\overline{z_{j}}$ (in their numerical interpretation) can only get halved at most $\lfloor\log_{2}n\rfloor+1$ times before reaching [math], it takes at most $\lfloor\log_{2}n\rfloor+2$ recursion steps until a tuple other than the $i$th has been halved. In the worst case that is the $(i-1)$th tuple. This process can then be repeated at most $\lfloor\log_{2}n\rfloor+1$ times, before the tuple at the next lower index gets halved. In total, in the worst case, it takes $(\lfloor\log_{2}n\rfloor+2)^{j}$ recursion steps until the $i-j$th tuple gets halved in this process.

This means, that after $(\lfloor\log_{2}n\rfloor+2)^{i}-1$ recursion steps, the first tuple has reached [math]. Therefore, the total maximum recursion depth is $(\lfloor\log_{2}n\rfloor+2)^{i}-1\in\mathcal{O}((\log_{2}n)^{i})$.

This process can be thought of as counting down a base $\log_{2}n$ number. The idea for it has already been visualized in Figure 1. It is also explicitly illustrated in Figure 2 and Figure 3, for a sequence which we will define shortly in Definition 4.12 to make use of exactly this kind of process. ∎

Since our final goal is to characterize both $\mathrm{AC}^{i}_{R}$ and $\mathrm{NC}^{i}_{R}$, we need to also define aggregators which model the properties of $\mathrm{NC}_{R}$ circuits. For this purpose, we introduce bounded aggregators, i. e., relativized aggregators where we only consider the two elements of maximal size meeting the condition in the relativization.

Definition 4.8**.**

We define the bounded aggregators ${\textbf{sum}_{\overline{x},\mathrm{bound}}}$ and ${\textbf{prod}_{\overline{x},\mathrm{bound}}}$. They are used in the same way as the aggregators defined earlier in Definition 2.30. The semantics are defined as follows:

[TABLE]

The bounded aggregators ${\textbf{prod}_{\overline{x},\mathrm{bound}}}$ and ${\textbf{max}_{\overline{x},\mathrm{bound}}}$ are defined analogously.

With this bounded aggregation, we can now define a slightly weaker version of the guarded functional recursion from Definition 4.6, which we call bounded guarded functional recursion $\mathrm{GFR}_{R,\mathrm{bound}}^{i}$. This allows us then to define logics of the form $\mathrm{FO}_{R}[F]+\mathrm{GFR}_{R}^{i}$ or $\mathrm{FO}_{R}[F]+\mathrm{GFR}_{R,\mathrm{bound}}^{i}$.

Definition 4.9** ($\mathrm{GFR}_{R,\mathrm{bound}}^{i}$).**

A formula is in $\mathrm{FO}_{R}[F]+\mathrm{GFR}_{R,\mathrm{bound}}^{i}$ if the same conditions as in Definition 4.6 are met, but instead of a guarded aggregation in (1), we require a bounded guarded aggregation.

Our goal in the following is to characterize the $\mathrm{AC}_{R}$ and $\mathrm{NC}_{R}$ hierarchies using first-order logic and guarded functional recursion. For that purpose, we now define a sequence which we will later use as part of the numbers of our gates in order to encode the gates’ depth into their numbers. The idea behind the construction of of this sequence will be that for a circuit family $(C_{n})_{n\in\mathbb{N}}$ with depth bounded by $c\cdot(\log_{2}n)^{i}$, each of the sequence’s elements is essentially a $i$-digit base $c\cdot\lfloor\log_{2}n\rfloor-1$ number with each digit being encoded in unary and padded by zeroes. For readability purposes, we will refer to this encoding simply as a unary encoding. The sequence can then be seen as counting down to [math] in that interpretation. This will then result in a length of $c^{i}\cdot\lfloor\log_{2}n\rfloor^{i}\in\mathcal{O}((\log_{2}n)^{i})$ for fixed $i$. We begin by introducing our conventions regarding unary encodings of numbers.

Definition 4.10**.**

Let $n,\ell\in\mathbb{N}$ such that $\ell\geq n$. Then we will refer to the function $\mathrm{unary}_{\ell}\colon\mathbb{N}\to\{0,1\}^{\ell}$ defined as

[TABLE]

as the (length $\ell$) unary encoding of $n$.

Definition 4.11**.**

For any binary string $\overline{a}$ of the form

[TABLE]

for some $k,m$, we define the function $\mathrm{uval}\colon\{0,1\}^{\star}\to\mathbb{N}$ defined as

[TABLE]

and call $\mathrm{uval}(\overline{a})$ the value of the unary encoding $\overline{a}$.

We now proceed to define the aforementioned sequence $d$ which we will later use to essentially encode our circuit’s gates’ depth into their gate numbers.

Definition 4.12**.**

For each $n,c,i\in\mathbb{N}$, we define the sequence $d(n,c,i)$ as follows. For readability purposes we leave out the arguments $(n,c,i)$ in the definition of the sequence and only write $d$ instead of $d(n,c,i)$.

1. (1)

Each element $d_{\ell}$ of $d$ consists of $i$ tuples $d_{\ell,j}$ ($1\leq j\leq i$), each of which is the length $\lfloor c\cdot\log_{2}n\rfloor-1$ unary encoding of a number in $[0,\lfloor c\cdot\log_{2}n\rfloor-1]$. 2. (2)

$d_{1}=1\dots 1$ (I. e., $d_{1,j}=\mathrm{unary}_{\lfloor c\cdot\log_{2}n\rfloor-1}(c\cdot\lfloor\log_{2}n\rfloor-1)=1\dots 1$ for all $j$ with $1\leq j\leq i$.) 3. (3)

$d_{\ell+1,i}=\begin{cases}\mathrm{unary}_{\lfloor c\cdot\log_{2}n\rfloor-1}(\lfloor c\cdot\log_{2}n\rfloor-1)&\textnormal{if }\mathrm{uval}(d_{\ell,i})=0,\\ \mathrm{unary}_{\lfloor c\cdot\log_{2}n\rfloor-1}(\mathrm{uval}(d_{\ell,i})-1)&\textnormal{otherwise,}\end{cases}$

for all $\ell$ where $d_{\ell}\neq 0\dots 0$. 4. (4)

$d_{\ell+1,j}=\begin{cases}\mathrm{unary}_{\lfloor c\cdot\log_{2}n\rfloor-1}(\mathrm{uval}(d_{\ell,j}-1))&\textnormal{if }\mathrm{uval}(d_{\ell,j+1})=0,\\ d_{\ell,j}&\textnormal{otherwise,}\end{cases}$

for $j<i$.

Examples for the sequence $d$ can be seen in Figures 2 and 3.

Remark 4.13**.**

Note that substracting the value $1$ in this unary encoding can be seen as an integer division by $2$ in binary. This will become useful later when putting this into the context of guarded functional recursion with BIT.

Note that the length (i. e. the number of elements) of $d(8,1,2)$ is

[TABLE]

and the length of $d(8,2,2)$ is

[TABLE]

This is no coincidence. Next, we show that this observation holds in general.

Lemma 4.14**.**

Let $n,c,i\in\mathbb{N}$. Then, $d(n,c,i)$ has length $c^{i}\cdot\lfloor\log_{2}n\rfloor^{i}$.

Proof.

Since for each element $e$ in $d(n,c,i)$ the successor rule can be interpreted as subtracting $1$ from $e$ when $e$ is seen as a base $c\cdot\lfloor\log_{2}n\rfloor$ number with $i$ digits, we are starting at the largest possible element in that sense (i. e. $1\dots 1$, which would correspond to $(c\cdot\lfloor\log_{2}n\rfloor)^{i}-1$) and we are counting down to the lowest possible element (i. e. $0\dots 0$, corresponding to [math]), there are exactly $(c\cdot\lfloor\log_{2}n\rfloor)^{i}=c^{i}\cdot\lfloor\log_{2}n\rfloor^{i}$ elements in $d(n,c,i)$. ∎

The remaining problem that stands in the way of using the sequence $d$ for the numbering of gates in descriptions for circuits is that the length of the elements in $d$ depends on $n$ (which will be the number of input gates of our circuit). However, we can remedy this, since we essentially have access to base $n$ numbers in the description for a circuit with $n$ input gates (by virtue of interpreting circuit inputs as circuit structures). Combining those with the BIT predicate and now interpreting the unary encoded tuples in elements of $d$ as binary numbers allows us to encode elements of $d$ using a constant number of digits.

Observation 4.15**.**

Let $n,c\in\mathbb{N}$ and $1\leq\ell\leq c\cdot\lfloor\log_{2}n\rfloor$. The number $2^{\ell}-1$ can be encoded by a base $n$ number of length $c$.

Proof.

The largest possible number of that form is $2^{c\cdot\lfloor\log_{2}n\rfloor}-1\leq n^{c}-1$, which corresponds to ‘\underbrace{{n-1}\dots n-1}_{\text{c times}}’ in base $n$. Therefore, $2^{c\cdot\lfloor\log_{2}n\rfloor}-1$ can be encoded with $c$ base $n$ digits and thus also all smaller natural numbers can be encoded in this way. ∎

We can thus encode the binary valuations of tuples in elements of $d$ as base $n$ numbers of length $c$. Therefore, each element of $d$ can be encoded using $i$ base $n$ numbers of length $c$ (or $i\cdot c$ base $n$ digits).

Before we proceed to using the sequence $d$ for circuit descriptions, we need one more lemma which provides a useful property of $\mathrm{AC}^{i}_{R}$ resp. $\mathrm{NC}^{i}_{R}$ circuits. We would like to be able to talk about the depth of gates, i. e., the distance of a gate to the input gates of the circuit. For this reason, we will establish the fact that for the circuit families we investigate, circuits exist where for each gate $g$, each input-$g$ path has the same length.

Lemma 4.16**.**

Let $L$ be in $\mathrm{AC}^{i}_{R}$ or $\mathrm{NC}^{i}_{R}$ via the circuit family $\mathcal{C}=(C_{n})_{n\in\mathbb{N}}$. Then there exists a circuit family $\mathcal{C}^{\prime}=(C^{\prime}_{n})_{n\in\mathbb{N}}$ deciding $L$, such that for all $n\in\mathbb{N}$ and each gate $g$ in $C^{\prime}_{n}$, each path from an input gate to $g$ in $C^{\prime}_{n}$ has the same length. We call $C^{\prime}_{n}$ a balanced DAG.

Proof.

Let $L$ be in $\mathrm{AC}^{i}_{R}$ or $\mathrm{NC}^{i}_{R}$ via $\mathcal{C}=(C_{n})_{n\in\mathbb{N}}$. For each circuit $C_{n}\in\mathcal{C}$, we construct a circuit $C^{\prime}_{n}$, such that $f_{C_{n}}=f_{C^{\prime}_{n}}$ and for each gate $g$ in $C^{\prime}_{n}$, all input-$g$-paths in $C^{\prime}_{n}$ have the same length. We transform $C_{n}$ into $C^{\prime}_{n}$ by creating paths of dummy gates to replace edges that go over more than one level of depth.

Let the depth of $C_{n}$ be bounded by $c_{1}\cdot(\log_{2}n)^{i}$ and let its size be bounded by $c_{2}\cdot n^{c_{3}}$. We proceed by structural induction over the depth $d$ of gates $g$ in $C_{n}$, i. e., the maximum length of paths from an input gate to $g$.

$d=1$:

Each gate $g$ at depth $d$ is a direct successor of an input gate. Therefore, no changes need to be made, since all gates at depth $d$ only have input-$g$ paths of length $1$ and therefore have the desired property.

$d\to d+1$:

For each gate at depth $d+1$, all predecessors are gates of depth $<d+1$ for which it holds that all paths from input gates to them are of the same length. Keep all those predecessors at depth $d$ as they are and replace the edge from predecessors of smaller depths $d^{\prime}<d$ to $g$ by a path of dummy (unary addition) gates of length $d-d^{\prime}$. Now all paths from input gates to $g$ have exactly length $d+1$ and we only added at most $c_{1}\cdot(\log_{2}n)^{i}$ gates per predecessor of $g$. In total, the number of dummy gates added for $g$ is bounded by $c_{2}\cdot n^{c_{3}}\cdot c_{1}\cdot(\log_{2}n)^{i}$.

The resulting circuit is $C^{\prime}_{n}$. Since addition gates with only a singular predecessor are essentially identity gates, the value of each gate in any computation of $C^{\prime}_{n}$ remains the same. Thus, $f_{C_{n}}=f_{C^{\prime}_{n}}$.

Additionally, for each gate in $C_{n}$, we add at most $c_{1}\cdot(\log_{2}n)^{i}\cdot c_{2}\cdot n^{c_{3}}$ gates to arrive at $C^{\prime}_{n}$. Therefore, the size of $C^{\prime}_{n}$ is bounded by $c_{1}\cdot(\log_{2}n)^{i}\cdot c_{2}\cdot n^{c_{3}}\cdot c_{2}\cdot n^{c_{3}}=c_{1}\cdot(\log_{2}n)^{i}\cdot(c_{2}\cdot n^{c_{3}})^{2}\in\mathcal{O}(n^{\mathcal{O}(1)})$. The depth of $C^{\prime}_{n}$ does not change, since we only ever add gates, when longer paths within $C_{n}$ exist so that they end up at the same length.

In total, $C^{\prime}_{n}$ computes the same function as $C_{n}$ – and thus decides $L$ – and has the property that for each of its gates $g$, all input-$g$-paths have the same length. ∎

As previously mentioned, whenever we are dealing with balanced DAGs, we will refer to the unambiguous length from input gates to a gate $g$ as the depth of $g$.

Now we will turn to a lemma which will then finally enable us to use the previously defined sequence $d$ to encode our gates’ depth into their circuit numbers. This, combined with Lemma 4.14, provides us with a way to logically ensure the polylogarithmic depth of a circuit given as a circuit structure.

Lemma 4.17**.**

Let $L$ be in $\mathrm{AC}^{i}_{R}$ or $\mathrm{NC}^{i}_{R}$ via the circuit family $\mathcal{C}=(C_{n})_{n\in\mathbb{N}}$. Then there exists an $\mathrm{AC}^{i}_{R}$ (resp. $\mathrm{NC}^{i}_{R}$) circuit family $\mathcal{C}^{\prime}=(C^{\prime}_{n})_{n\in\mathbb{N}}$ deciding $L$ with depth bounded by $c\cdot(\log_{2}n)^{i}$, such that the gates of each circuit of $\mathcal{C}^{\prime}$ are numbered as base $n$ numbers, where for each path from an input gate to the output gate, the first $c\cdot i$ digits encode elements of $d$ in the order that they appear in the sequence.

The numbering after the first $c\cdot i$ digits can be chosen arbitrarily.

Proof.

Let $L\in\mathrm{AC}^{i}_{R}$ or $L\in\mathrm{NC}^{i}_{R}$ via the circuit family $\mathcal{C}=(C_{n})_{n\in\mathbb{N}}$ the depth of which is bounded by $c_{1}\cdot(\log_{2}n)^{i}$. Without loss of generality, let the circuits of $\mathcal{C}$ be balanced DAGs as per Lemma 4.16. That means that for each circuit $C_{n}$ in $\mathcal{C}$, for each gate $g$ in $C_{n}$, the length of all paths from input gates to $g$ is the same. Let $c\in\mathbb{N}$ be such that $c^{i}\cdot\lfloor\log_{2}n\rfloor^{i}$ is larger than the depth of $C_{n}$ (which is bounded by $c_{1}\cdot(\log_{2}n)^{i}$). We pad each path in $C_{n}$ to length $c^{i}\cdot\lfloor\log_{2}n\rfloor^{i}$ by replacing each edge from an input gate to a gate in $C_{n}$ by a path of dummy gates of length $c^{i}\cdot\lfloor\log_{2}n\rfloor^{i}-\textit{depth}(C_{n})$ so that the resulting circuit has exactly depth $c^{i}\cdot\lfloor\log_{2}n\rfloor^{i}$.

We now use any base $n$ numbering for the gates of $C_{n}$ and for each gate $g$ prepend the $\text{depth}(g)$th element of $d(n,c,i)$ to the number of $g$. Since we made sure that each input-output-path in $C_{n}$ has length exactly $c^{i}\cdot\lfloor\log_{2}n\rfloor^{i}$, we can encode exactly the sequence $d(n,c,i)$ in the numbers of each input-output-path. So now for each input-output-path, the first $c\cdot i$ digits of gate numbers encode the elements of $d(n,c,i)$ in the order that they appear in the sequence. ∎

With the normal form from Lemma 4.17 and the previous definitions, we can now turn to a theorem characterizing $\mathrm{AC}^{i}_{R}$ and $\mathrm{NC}^{i}_{R}$ logically by tying it all together.

Theorem 4.18**.**

a**

1. (1)

$\mathrm{AC}^{i}_{R}=\mathrm{FO}_{R}[\mathrm{Arb}_{R}]+\textnormal{SUM}_{R}+\textnormal{PROD}_{R}+\mathrm{GFR}_{R}^{i}$** 2. (2)

$\mathrm{NC}^{i}_{R}=\mathrm{FO}_{R}[\mathrm{Arb}_{R}]+\textnormal{SUM}_{R}+\textnormal{PROD}_{R}+{\mathrm{GFR}_{R,\mathrm{bound}}^{i}}$**

Proof.

We start by showing the inclusions of the circuit classes in the respective logics and will then proceed with the converse directions.

Step 1: $\mathrm{AC}^{i}_{R}\subseteq\mathrm{FO}_{R}[\mathrm{Arb}_{R}]+\textnormal{SUM}_{R}+\textnormal{PROD}_{R}+\mathrm{GFR}_{R}^{i}$:

Let $L\in\mathrm{AC}^{i}_{R}$ via the nonuniform circuit family $\mathcal{C}=(C_{n})_{n\in\mathbb{N}}$ and let the depth of $\mathcal{C}$ be bounded by $c\cdot(\log_{2}n)^{i}$. We construct a $\mathrm{FO}_{R}[\mathrm{Arb}_{R}]+\textnormal{SUM}_{R}+\textnormal{PROD}_{R}+\mathrm{GFR}_{R}^{i}$ sentence $\varphi$ defining $L$. As the circuit input is interpreted as a circuit structure, the signature $\sigma$ of $\varphi$ contains only the single unary function symbol $f_{\mathrm{element}}$.

We define the following additional relations and functions which will essentially encode our given circuits. We will have access to them because of the $\mathrm{Arb}_{R}$ extension of our logic and we use relations here instead of functions for ease of reading, since we essentially have access to relations in functional structures if we consider the respective characteristic functions of the relations instead.

• •

$G_{+}(\overline{x})\iff\overline{x}$ is an addition gate.

• •

$G_{\times}(\overline{x})\iff\overline{x}$ is a multiplication gate.

• •

$G_{<}(\overline{x})\iff\overline{x}$ is a $<$-gate, the left predecessor of which is lexicographically lower than the right predecessor.

• •

$G_{\mathrm{input}}(\overline{x})\iff$ $\overline{x}$ is an input gate.

• •

$G_{E}(\overline{x},\overline{y})\iff\overline{y}$ is a successor gate of $\overline{x}$.

• •

$G_{\mathrm{output}}(\overline{x})\iff\overline{x}$ is the output gate.

• •

$G_{\mathrm{const}}(\overline{x})\iff\overline{x}$ is a constant gate.

• •

$f_{\mathrm{const\_val}}(\overline{x})=y\in R$ $\iff$ $y$ is the value of $\overline{x}$ if $\overline{x}$ is a constant gate and $y=0$ otherwise.

Without loss of generality let all circuits of $\mathcal{C}$ be in the normal form of Lemma 4.17 and let the numbering of $C_{n}$ be such that the last digit of the number of the $j$th input gate is $j$ for $1\leq j\leq n$. Recall that this means that for each gate number of a gate $g$ represented as a tuple $\overline{g}$, the first $c\cdot i$ elements of $\overline{g}$ encode the $\textit{depth}(g)$th element of $d(n,c,i)$. The following sentence $\varphi$ defines $L$:

[TABLE]

where $t$ is defined as follows (with $\overline{z_{j}}$ denoting the $j$th $c$-long subtuple in the $c\cdot i$ long prefix of $\overline{z}$, which, as per the normal form of Lemma 4.17 encodes the $j$th tuple of an element of $d(n,c,i)$):

[TABLE]

Here, the relations $G_{g}(\overline{y})$ for $g\in\{+,\times,<,\textnormal{input},\textnormal{const},\textnormal{output}\}$ give information about the gate type of the gate encoded by $\overline{y}$ and are provided by the $\mathrm{Arb}_{R}$-extension of $\mathrm{FO}_{R}$. They are interpreted as mentioned above. The BIT predicate is provided in the same way.

We will now prove that $\varphi$ does indeed define $L$. Let $\overline{a}\in R^{n}$ be the input to $C_{n}$. We will show that for all $\overline{g}\in R^{l}$, where $l$ is the encoding length of a gate in $\mathcal{C}$, the value of the gate encoded by $\overline{g}$ in the computation of $C_{n}$ when $C_{n}$ is given $\overline{a}$ as the input is $f(\overline{g})$. Let $g$ be the gate encoded by $\overline{g}$. We will argue by induction on the depth of the gate $g$, i. e., by the distance between $g$ and an input gate.

$d=0$: If $d=0$, then $g$ is an input gate. Therefore, the only summand in $t(\overline{g},f)$ that is not trivially [math] is the fourth one, which is equal to $f_{\mathrm{element}}(g_{\lvert\overline{g}\rvert})$ (which is the value of the $g_{\lvert\overline{g}\rvert}$th input gate).

$d\to d+1$: Since $d+1>0$, $g$ is not an input gate. This means that there are the following 5 possibilities for $g$:

1. (1)

$g$ is an addition gate: In that case, the only summand in $t(\overline{g},f)$ which is not trivially [math] is the first one. All predecessors of $g$ have a number, the first $c\cdot i$ digits of which are the successor of the first $c\cdot i$ digits of $g$ in the sequence $d(n,c,i)$ because of the normal form of Lemma 4.17. Additionally, the relativization ensures that the gate encoded by $\overline{z}$ in the respective summand has exactly the successor in the sequence $d(n,c,i)$ of $g$’s first $c\cdot i$ digits in its first $c\cdot i$ digits. This means that by the induction hypothesis

[TABLE]

yields exactly the sum of all the values of predecessor gates of $g$. 2. (2)

$g$ is a multiplication gate: Analogously to the above case,

[TABLE]

yields exactly the product of all predecessor gates of $g$. 3. (3)

$g$ is a $<$ gate: In that case, the relativization

[TABLE]

makes sure that $\overline{z}$ is the maximum gate number of a predecessor of $g$ and

[TABLE]

makes sure that $\overline{b}$ is the gate number of the other predecessor of $g$ and that therefore $\chi[f(\overline{b})<f(\overline{z})]$ is the value of $t(\overline{g},f)$, which is exactly the value of $g$ in the computation of $C_{n}$. 4. (4)

$g$ is a constant gate: Since $\varphi_{\mathrm{const\_val}}(\overline{g})$ returns exactly the value of $g$, and that value is taken by $t(\overline{g},f)$. 5. (5)

$g$ is the output gate: In that case, $g$ only has one predecessor and thus

[TABLE]

ensures that $g$ takes the value of that predecessor, since there is only one element matching the relativization.

Finally, by

[TABLE]

we make sure that there exists an output gate which has the value $1$ at the end of the computation.

Step 2: $\mathrm{NC}^{i}_{R}\subseteq\mathrm{FO}_{R}[\mathrm{Arb}_{R}]+\textnormal{SUM}_{R}+\textnormal{PROD}_{R}+\mathrm{GFR}_{R,\mathrm{bound}}^{i}$:

The proof for this inclusion follows in the the same as the proof for the $\mathrm{AC}^{i}_{R}$-case, by just replacing all guarded aggregations in the formulae by bounded guarded aggregations.

Step 3: $\mathrm{FO}_{R}[\mathrm{Arb}_{R}]+\textnormal{SUM}_{R}+\textnormal{PROD}_{R}+\mathrm{GFR}_{R}^{i}\subseteq\mathrm{AC}^{i}_{R}$:

Let $L\in\mathrm{FO}_{R}[\mathrm{Arb}_{R}]+\textnormal{SUM}_{R}+\textnormal{PROD}_{R}+\mathrm{GFR}_{R}^{i}$ via a formula $\varphi$ over some signature $\sigma=(L_{s},L_{f},L_{a})$ and let there be only one occurrence of a $\mathrm{GFR}_{R}^{i}$ operator in $\varphi$. This proof easily extends to the general case. This means that $\varphi$ is of the form

[TABLE]

We now construct an $\mathrm{AC}^{i}_{R}$ circuit family $\mathcal{C}=(C_{n})_{n\in\mathbb{N}}$ deciding $L$.

We first construct an $\mathrm{AC}^{i}_{R}$ family evaluating $\varphi$ without the occurrences of $f$ as in Theorem 3.3. This is possible, since $\varphi$ is an $\mathrm{FO}_{R}[\mathrm{Arb}_{R}]+\textnormal{SUM}_{R}+\textnormal{PROD}_{R}$ formula over $(L_{s},L_{f},L_{a}\cup\{f\})$ and by Theorem 3.3, there is such a circuit family for $\varphi$.

Next, we explain how we build an $\mathrm{AC}^{i}_{R}$ circuit family for the whole formula $\varphi$ from this point. For this, we need to construct an $\mathrm{AC}^{i}_{R}$ circuit family computing the value of $f(\overline{x},\overline{y})$ for each pair $\overline{a},\overline{b}$ with $\overline{a}\in A^{k}$ for some $k\in\mathbb{N}$ and $\overline{b}\in A^{i}$, where the length of the tuple $\overline{b}$ is exactly the exponent of the polylogarithm bounding the circuit depth. Notice, that $t$ is an $\mathrm{FO}_{R}[\mathrm{Arb}_{R}]+\textnormal{SUM}_{R}+\textnormal{PROD}_{R}+\mathrm{GFR}_{R}^{i}$ number term and can therefore be evaluated by an $\mathrm{AC}^{0}_{R}$ circuit family, except for the occurrences of $f$. We now obtain $C_{n}$ by taking the $n$th circuit of all those (polynomially many) $\mathrm{AC}^{0}_{R}$ circuit families and for all $\overline{a},\overline{b}$ replacing the gate labeled $f(\overline{a},\overline{b})$ by the output gate of the circuit computing $t(\overline{a},\overline{b},f)$.

Since all occurrences of $f(\overline{x},\overline{y})$ are in the scope of a guarded aggregation

[TABLE]

the number of steps from any $f(\overline{a},\overline{b})$ before reaching $f(\overline{a},\overline{0})$, terminating the recursion, is bounded by $\mathcal{O}((\log_{2}n)^{i})$ as per Lemma 4.7.

Since each such step – computing $f(\overline{a},\overline{b})$, when given values of the next recursive call $f(\overline{c},\overline{d})$ – is done by an $\mathrm{AC}^{0}_{R}$ circuit and therefore has constant depth, in total, any path from the first recursive call to the termination has length in $\mathcal{O}((\log_{2}n)^{i})$. Since the starting circuit deciding $\varphi$ had constant depth, the circuit we constructed now has polylogarithmic depth in total. And given that we only added polynomially many subcircuits with polynomially many gates each, the whole circuit is an $\mathrm{AC}^{i}_{R}$ circuit deciding $\varphi$.

For the general case of several $\mathrm{GFR}_{R}^{i}$ operators, we construct a circuit for each operator in the same way and connect them to the circuit evaluating $\varphi$.

Step 4: $\mathrm{FO}_{R}[\mathrm{Arb}_{R}]+\textnormal{SUM}_{R}+\textnormal{PROD}_{R}+\mathrm{GFR}_{R,\mathrm{bound}}^{i}\subseteq\mathrm{NC}^{i}_{R}$:

This case can be proven analogously to the case for $\mathrm{AC}^{i}_{R}$. Instead of $\mathrm{AC}^{0}_{R}$ families for evaluating $\varphi$ and $t$, we now need to use $\mathrm{NC}^{1}_{R}$ families. With this, we have logarithmic depth for evaluating $t$, which would generally be a problem, since repeating this $(\log_{2}n)^{i}$ times would yield a $\mathrm{NC}^{i+1}_{R}$ family. However, by definition, there are no occurrences of $f$ in the scope of unbounded aggregators or quantifiers. For the bounded aggregators, we still construct circuits for all possible values of the aggregated variables, but we only connect the output gates of the maximum two circuits satisfying the relativization. We can do this, since, as $\xi$ does not contain function or relation symbols given in the structure, we can predetermine which circuits will match the relativization and therefore hardwire the connections. In general, $\mathrm{FO}_{R}[\mathrm{Arb}_{R}]+\textnormal{SUM}_{R}+\textnormal{PROD}_{R}$ formulae without unbounded quantifiers or aggregators can be evaluated in $\mathrm{NC}^{0}_{R}$. Therefore, the gates marked $f(\overline{a},\overline{b})$ only occur at constant depth in the subcircuits for $t(\overline{a},\overline{b},f)$. This means, that in total, the construction leads to a depth in $\mathcal{O}((\log_{2}n)^{i})$. ∎

As mentioned previously, the basis of the idea for guarded functional recursion was the guarded predicative recursion used for plain first-order logic [DHV18]. The same extension to polylogarithmic recursion depth that was showcased in this paper for $\mathrm{GFR}_{R}$ can be applied to $\mathrm{GPR}$, yielding the following results. (A formal definition of $\mathrm{GPR}^{i}$ is presented in the appendix as Definition B.2).

Corollary 4.19**.**

a**

1. (1)

$\mathrm{FO}[\mathrm{Arb}]+\mathrm{GPR}^{i}=\mathrm{AC}^{i}$** 2. (2)

$\mathrm{FO}[\mathrm{Arb}]+\mathrm{GPR}_{\mathrm{bound}}^{i}=\mathrm{NC}^{i}$**

5. Relationship between versions of $\mathrm{AC}^{0}_{R}$ over different integral domains

Intuitively, a circuit deciding a problem in $\mathrm{AC}^{0}_{\mathbb{R}}$ should also be able to simulate circuits deciding problems in, for example, $\mathrm{AC}^{0}_{\mathbb{Z}}$ and $\mathrm{AC}^{0}_{\mathbb{Z}_{2}}$. Furthermore, we should be able to simulate an $\mathrm{AC}^{0}_{\mathbb{Z}_{3}}$-circuit by an $\mathrm{AC}^{0}_{\mathbb{Z}_{2}}$-circuit by simulating the operations defined in the integral domain $\mathbb{Z}_{3}$ by operations of tuples of $\mathbb{Z}_{2}$. To formalise this intuition, we propose the notion of $\mathfrak{C}$-simulation maps.

Definition 5.1**.**

Let $f_{1},f_{2}\colon\mathbb{N}\to\mathbb{N}$ be two functions and let $\mathfrak{C}$ be a complexity class with $\mathfrak{C}\in\{\textsc{TimeSpace}(f_{1},f_{2}),\textsc{SizeDepth}(f_{1},f_{2}),\textsc{UnbSizeDepth}(f_{1},f_{2})\}$.

A $\mathfrak{C}$-simulation map from an integral domain $R_{1}$ to an integral domain $R_{2}$ is an injective function $f\colon R_{1}^{*}\to R_{2}^{*}$ such that the following holds:

For all $k\in\mathbb{N}_{>0}$ and $A\in\mathfrak{C}_{R_{1}^{k}}$ there exists an $\ell\in\mathbb{N}_{>0}$ and a language $B\in\mathfrak{C}_{R_{2}^{\ell}}$ such that for all $\overline{x}=(x_{1},x_{2},\dots,x_{\lvert x\rvert}$) with $x_{i}\in R_{1}^{k}$ for all $i$:

[TABLE]

If there exists a $\mathfrak{C}$-simulation map from an integral domain $R_{1}$ to an integral domain $R_{2}$, we also write $\mathfrak{C}_{R_{1}}\subseteq_{\mathrm{sim}}\mathfrak{C}_{R_{2}}$. The relations $=_{\mathrm{sim}}$ and $\subsetneq_{\mathrm{sim}}$ are defined analogously.

Similar to the formalism of reductions in classical complexity theory, the relation induced by $\subseteq_{\mathrm{sim}}^{\mathfrak{C}}$ is reflexive and transitive. Since in this work, the main focus is on the $\mathrm{AC}_{R}$ and $\mathrm{NC}_{R}$ hierarchies, we will proceed to restrict ourselves to these classes. But note that the simulation methods we show trivially extend to larger complexity classes.

The formalism essentially divides our integral domains in a three-tier hierarchy. The first tier in this hierarchy consists of the complexity classes over finite integral domains, the second tier consists of the classes over integral domains which are simulatable by $\mathbb{Z}$ and the third tier consists of classes over integral domains which are simulatable by $\mathbb{R}$. In this setting, a complexity class over a certain integral domain is able to simulate the complexity classes over integral domains in the same tier or below. To make this explicit, we show the following three equalities:

Theorem 5.2**.**

The following three equations hold:

1. (1)

$\mathrm{NC}^{i}_{\mathbb{F}_{p}}=_{\mathrm{sim}}\mathrm{NC}^{i}_{\mathbb{F}_{q}}$* for all prime powers $p,q$ and $i\in\mathbb{N}$.* 2. (2)

$\mathrm{NC}^{i}_{\mathbb{Z}}=_{\mathrm{sim}}\mathrm{NC}^{i}_{\mathbb{Z}[j_{k}]}$* for all $i\in\mathbb{N}$.* 3. (3)

$\mathrm{NC}^{i}_{\mathbb{R}}=_{\mathrm{sim}}\mathrm{NC}^{i}_{\mathbb{R}[j_{k}]}$* for all $i\in\mathbb{N}$.*

Proof.

We split the proof in two main parts: the finite case, in which simulations of integral domains are trivial, and the infinite case, where we have to be more careful about the new operations our simulating circuits execute to uphold that the structure the circuits simulate are still integral domains.

The finite case. The simulation of finite integral domains is quite trivial. For $\mathrm{NC}^{i}_{\mathbb{F}_{p}}\subseteq_{\mathrm{sim}}\mathrm{NC}^{i}_{\mathbb{F}_{q}}$ where $p>q$, choose the length of tuples that the $\mathrm{NC}^{i}_{\mathbb{F}_{q}}$-circuit uses to be the smallest $k\in\mathbb{N}$ such that $p\leq q^{k}$ holds. Map the $p$ elements to the first $p$ elements in $\mathbb{F}_{q}^{k}$ and define addition an multiplication tables of constant size which simulate the addition and multiplication in $\mathbb{F}_{p}$.

The infinite case. We will prove that $\mathrm{NC}^{i}_{\mathbb{Z}}=_{\mathrm{sim}}\mathrm{NC}^{i}_{\mathbb{Z}[j_{k}]}$ for any fixed $k\in\mathbb{N}$. Note that the following proof does not depend on the countability of the set, so the proof for the uncountable case runs analogously. The direction $\mathrm{NC}^{i}_{\mathbb{Z}}\subseteq_{\mathrm{sim}}\mathrm{NC}^{i}_{\mathbb{Z}[j_{k}]}$ is trivial. For the other direction, note that when simulating infinite integral domains, we can no longer hard-code the addition and multiplication tables in a trivial way. Furthermore, integral domains are not closed under cartesian products, since for two integral domains $R_{1},R_{2}$, we have for $R_{1}\times R_{2}$ that $(1,0)\times(0,1)=(0,0)$ using componentwise multiplication. We fix this by still using $k$-tuples to emulate the adjoint elements and using componentwise addition, but adapting multiplication so that it simulates multiplication of two elements with adjoint elements, where the $m$-th index of the tuple stands for the $m$-th power of the adjoint element, which we call $j$ here. Explicitly, we use the integral domain $(\mathbb{Z}^{k},+_{\mathbb{Z}^{k}},\times_{\mathbb{Z}^{k}})$, where $+_{\mathbb{Z}^{k}}$ is componentwise addition, and $\times_{\mathbb{Z}^{k}}$ is defined as follows:

If we want to multiply two tuples of length $k$

[TABLE]

we simulate the multiplication in the original, adjoint integral domain

[TABLE]

by constructing the following matrix of constant size which corresponds to expanding the multiplication:

[TABLE]

Observe that, due to the fact that $j^{k}=-1$, every entry $a_{uv}$ of the matrix contributes to the term at index $(u+v-2)\mod k$ in the tuple. The entry of the resulting tuple at index $\ell$ is thus

[TABLE]

Theorem 5.3**.**

The following three equations hold:

1. (1)

$\mathrm{AC}^{i}_{\mathbb{F}_{p}}=_{\mathrm{sim}}\mathrm{AC}^{i}_{\mathbb{F}_{q}}$* for all prime powers $p,q$ and $i\in\mathbb{N}$.* 2. (2)

$\mathrm{AC}^{i}_{\mathbb{Z}}=_{\mathrm{sim}}\mathrm{AC}^{i}_{\mathbb{Z}[j_{k}]}$* for all $i\in\mathbb{N}$.* 3. (3)

$\mathrm{AC}^{i}_{\mathbb{R}}=_{\mathrm{sim}}\mathrm{AC}^{i}_{\mathbb{R}[j_{k}]}$* for all $i\in\mathbb{N}$.*

Proof.

We use the strategy from the proof of Theorem 5.2, and show that unbounded addition and multiplication can be realized without a significant increase in the complexity.

For $n$ given tuples of length $k$

[TABLE]

the simulation of unbounded addition by unbounded componentwise addition of tuples is straightforward. Observe that for unbounded multiplication, simply iterating the binary multiplication would result in linear depth. But similar to the method for binary multiplication, we can compute in advance which values contribute to a given index of the resulting tuple. And since the value of a tuple entry in the result can only depend on the values $x_{i,j}$, to simulate an unbounded multiplication gate, we need only an unbounded multiplication gate with a linear number of predecessors (but possibly exponential increase in the wire complexity). ∎

Corollary 5.4**.**

For all $i\in\mathbb{N}$, we have $\mathrm{NC}^{i}_{\mathbb{R}}=_{\mathrm{sim}}\mathrm{NC}^{i}_{\mathbb{C}}$ and $\mathrm{AC}^{i}_{\mathbb{R}}=_{\mathrm{sim}}\mathrm{AC}^{i}_{\mathbb{C}}$.

Proof.

Observe that $\mathbb{C}=\mathbb{R}[j_{(2)}]$. ∎

Lemma 5.5**.**

For all $i\in\mathbb{N}$, we have $\mathrm{NC}^{i}_{\mathbb{Z}}=_{\mathrm{sim}}\mathrm{NC}^{i}_{\mathbb{Q}}$ and $\mathrm{AC}^{i}_{\mathbb{R}}=_{\mathrm{sim}}\mathrm{AC}^{i}_{\mathbb{C}}$.

Proof.

For $\mathrm{NC}^{i}_{\mathbb{Z}}\subseteq_{\mathrm{sim}}\mathrm{NC}^{i}_{\mathbb{Q}}$ (resp. $\mathrm{AC}^{i}_{\mathbb{Z}}\subseteq_{\mathrm{sim}}\mathrm{AC}^{i}_{\mathbb{Q}}$), take $f(x)\coloneqq x$ and for $\mathrm{NC}^{i}_{\mathbb{Q}}\subseteq_{\mathrm{sim}}\mathrm{NC}^{0}_{\mathbb{Z}}$ (resp. $\mathrm{AC}^{i}_{\mathbb{Z}}\subseteq_{\mathrm{sim}}\mathrm{AC}^{i}_{\mathbb{Q}}$), take $f(x)\coloneqq(a,b)$, where $x=\frac{a}{b}$. ∎

Lemma 5.6**.**

$\mathrm{NC}^{i}_{\mathbb{Q}}\subsetneq\mathrm{NC}^{i}_{\mathbb{R}}$.

Proof.

We use the fact that $\mathbb{R}$ is a trancendental field extension of $\mathbb{Q}$, i. e., there is no finite set of numbers $M$ which we can adjoin to $\mathbb{Q}$ in order to get $\mathbb{Q}[M]=\mathbb{R}$. In our setting this mean that we can not simulate all numbers $r\in\mathbb{R}$ by a set of finite tuples $(a_{0},\cdots,a_{n})$ of numbers where $a_{0},\cdots,a_{n}\in\mathbb{Q}$. ∎

6. Conclusion

In this paper, we introduced algebraic complexity classes with respect to algebraic circuits over integral domains. We showed a logical characterization for $\mathrm{AC}^{0}_{R}$ and further characterizations for the $\mathrm{AC}_{R}$ and $\mathrm{NC}_{R}$ hierarchies, using a generalization of the $\mathrm{GPR}$ operator of Durand, Haak and Vollmer [DHV18]. We constructed a formalism to be able to compare the expressiveness of complexity classes with different underlying integral domains. We then showed that using this formalism, we obtain a hierarchy of sets of complexity classes, each set being able to “simulate” the complexity classes from the sets below.

For future work it would be interesting to investigate the logical characterizations made in this paper in the uniform setting. We know that for the real numbers, the characterization $\mathrm{AC}^{0}_{\mathbb{R}}=\mathrm{FO}_{\mathbb{R}}[\mathrm{Arb}_{\mathbb{R}}]+\textnormal{SUM}_{\mathbb{R}}+\textnormal{PROD}_{\mathbb{R}}$ holds both non uniformly and for uniformity criteria given by polynomial time computable circuits ($\mathrm{P}_{\mathbb{R}}$-uniform), logarithmic time computable circuits ($\mathrm{LT}_{\mathbb{R}}$-uniform) and first-order definable circuits ($\mathrm{FO}_{\mathbb{R}}$-uniform) [BV21]. We believe that the results we presented hold here in analogous uniform settings as well, though this would need to be further examined.

Another open direction is to find interesting problems (potentially even complete) for these new complexity classes. This could even provide new insights for the classical case.

A promising approach to the separation of algebraic circuit complexity classes could be an adaption of the approach taken by Cucker, who showed that the problem $\mathrm{FER}$, which essentially asks whether a point lies on a fermat curve, seperates the (logarithmic time uniform) $\mathrm{NC}^{i}_{\mathbb{R}}$-classes [Cuc92]. The same proof could also hold for the $\mathrm{NC}^{i}_{\mathbb{C}}$-classes.

Another model deserving of the name “algebraic circuit” are arithmetic circuits in the sense of Valiant [Val79]. This model is similar to the model presented here, with the exception that generally, only addition and multiplication gates are permitted. Maybe the ideas presented in this paper can lead to further insights with regards to this model of computation as well.

In the Boolean case, in addition to the $\mathrm{AC}$ and $\mathrm{NC}$ hierarchies, one commonly investigated hierarchy is the so called $\mathrm{SAC}$ hierarchy. This hierarchy is defined by bounding the fan-in of only one gate type, i. e., either the conjunction or the disjunction gates. It is known that it does not make a difference in that setting which gate type is bounded. A possible next step is to define a sensible analogue of the SAC hierarchy in the algebraic setting. We believe that in the algebraic case, it does make a difference which gate type we bound. This model could then possibly be useful to investigate algebraic structures where the respective operations do not adhere to the same axioms.

Appendix A Bounding circuit depth

Definition A.1**.**

Let $C$ be a circuit and let $L_{k}$ be the set of all gates $g\in C$ with $\textit{depth}(g)=k$. Then we call $L_{k}$ the $k$th layer of $C$.

Lemma A.2**.**

Let $\mathcal{C}=(C_{n})_{n\in\mathbb{N}}$ be a circuit family, $f$ a sublinear function and $g_{C}(k)$ the number of gates at layer $k$ for a circuit $C\in\mathcal{C}$. Furthermore, let $\alpha\coloneqq{}2^{-\frac{\log_{2}n}{f(n)}}$.

A circuit $C$ has depth $\mathcal{O}(f(n))$ if we request that for every layer $k$, the inequality $g_{C}(k)\leq\lfloor\alpha\cdot g_{C}(k-1)\rfloor$ holds.

Proof.

We want to bound the depth of the circuit (that is, the number of layers $k$) by the sublinear function $f$. For any input size $n$, we therefore set $k=f(n)<n$. Furthermore, if we require that the inequality $g_{C}(k)\leq\lfloor\alpha\cdot g_{C}(k-1)\rfloor$ holds, the circuit reaches its maximum depth when $n\alpha^{k}\leq 1$ holds, since the factor of $\alpha$ is applied $k$ times, once for each layer. Substitution yields

[TABLE]

Corollary A.3**.**

A circuit $C$ has depth $\mathcal{O}((\log_{2}n)^{i})$ if we request that for every layer $k$, the inequality $g_{C}(k)\leq\left\lfloor 2^{-\frac{\log_{2}n}{(\log_{2}n)^{i}}}\cdot g_{C}(k-1)\right\rfloor$ holds.

Appendix B Guarded Predicative Recursion

Notation B.1**.**

Similarly to the relativized aggregators in Notation 4.5, for relativized quantifiers, we write

[TABLE]

as a shorthand for $\exists x_{1}\dots\exists x_{k}(\varphi\land\psi)$ and

[TABLE]

as a shorthand for $\forall x_{1},\dots,x_{k}(\varphi\to\psi)$.

For a $\mathrm{FO}$-formula $\varphi$ and a relation variable $P$, we write $\varphi(P^{+})$ if $P$ does not occur in the scope of a negation in $\varphi$.

Definition B.2** ($\mathrm{GPR}^{i}$).**

Let $\mathcal{R}$ be a set of relations such that BIT is definable in $\mathrm{FO}[\mathcal{R}]$. The set of $\mathrm{FO}[\mathcal{R}]+\mathrm{GPR}^{i}$-formulae over $\sigma$ is the set of formulae by the grammar for $\mathrm{FO}[\mathcal{R}]$-formulae over $\sigma$ extended by the rule

[TABLE]

where $\psi$ and $\theta$ are $\mathrm{FO}[\mathcal{R}]$-formulae over $\sigma$, $\overline{x},\overline{y_{1}},\dots,\overline{y_{i}},\overline{y_{i+1}}$ are tuples of variables, $P$ is a relation variable and each atomic sub-formula involving $P$ in $\theta$

1. (1)

is of the form $P(\overline{x},\overline{y_{1}},\dots,\overline{y_{i}},\overline{y_{i+1}})$, the $\overline{y_{1}},\dots,\overline{y_{i}},\overline{y_{i+1}}$ are in the scope of a guarded quantification

[TABLE]

with $Q\in\{\forall,\exists\}$, $\xi\in\mathrm{FO}[\mathcal{R}]$ with $\xi$ not containing any relation symbols for relations given in the input structure and 2. (2)

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

The semantics for $\mathrm{GPR}^{i}$ are defined analogously to the semantics for $\mathrm{GFR}_{R}^{i}$ in Definition 4.6.