# A Generalized Quantifier Concept in Computational Complexity Theory

## 1 Introduction

In this paper we develop a unified view at some notions that appeared in computational complexity theory in the past few years. This will be in the form of operators transforming complexity classes into complexity classes. Each such operator is given in the form of a quantifier on strings. This will immediately subsume as special cases the well known universal, existential, and counting quantifiers examined in various complexity theoretic settings \[SM73, Wra77, Wag86b, Wag86a, Tor91\]. But also a lot of constructions from other subareas of complexity theory can best be understood in terms of such operators. These include circuits with arbitrary monoidal gates \[BIS90, BI94\], oracle operators \[BW96, BVW96\], leaf languages (introduced in \[BCS92, Ver93\] and examined for different computation models in \[HLS<sup>+</sup>93, JMT94, CMTV98\]). We survey some results from these areas and establish some new connections.

In finite model theory, examinations of the expressive power of various logics enhanced by Lindström quantifiers form a very well established field of active research. Descriptive complexity theory has characterized a great bulk of complexity classes by such logics. We will show that classes defined by our general operator can in a uniform way be characterized by model theoretic means using Lindström quantifiers.

In the following, we assume some familiarity of the reader with basic formal language theory (refer to \[RS97\]), basic complexity classes and resource-bounded reducibilities (refer to the standard literature, e.g. \[Pap94, BC94, BDG95\]; all complexity classes that appear in this paper without definition are defined in \[Joh90\]), as well as with the basics of finite model theory (refer to \[Vää94, EF95\]).

## 2 Definition

Given a language $`A`$ over some alphabet $`\mathrm{\Sigma }`$, we denote the characteristic function of $`A`$ by $`\chi _A`$, i.e. for all $`x\mathrm{\Sigma }^{}`$, $`\chi _A(x)=1`$ if $`xA`$, and $`\chi _A(x)=0`$ otherwise.

We will always assume some order on the alphabets we use; therefore it makes sense to talk about the lexicographic order $``$ of $`\mathrm{\Sigma }^{}`$, and for $`x,y\mathrm{\Sigma }^{}`$, $`xy`$, we define the characteristic string of $`A`$ from $`x`$ to $`y`$ as $`\chi _A[x\mathrm{}y]=_{\mathrm{def}}\chi _A(x)\chi _A(x+1)\mathrm{}\chi _A(y)`$. Here, $`x+1`$ denotes the successor of $`x`$. In fact, we will presuppose an underlying bijection between $`\mathrm{\Sigma }^{}`$ and the set $``$ of natural numbers, and we use the notation $`\chi _A[i\mathrm{}j]`$ for $`i,j`$.

Let $`,`$ denote a standard pairing function. For a set $`A\mathrm{\Sigma }^{}`$ and a string $`x\mathrm{\Sigma }^{}`$, define $`A_x=_{\mathrm{def}}\left\{y\right|x,yA\}`$.

Looking now at the well-known characterization of the polynomial hierarchy by polynomially length-bounded universal and existential quantifiers $`^p`$, $`^p`$ \[Wra77\], the following is clear:

* A language $`L`$ is in $`\mathrm{NP}`$ if and only if there is a language $`A\mathrm{P}`$ and a function $`f`$ computable in polynomial time such that for all $`x`$,

$$xL\chi _{A_x}[0\mathrm{}f(x)](0+1)^{}1(0+1)^{}\text{(i.e., contains a “}1\text{”)}.$$
* A language $`L`$ is in $`\mathrm{coNP}`$ if and only if there is a language $`A\mathrm{P}`$ and a polynomial $`p`$ such that for all $`x`$,

$$xL\chi _{A_x}[0\mathrm{}f(x)]1^{}\text{(i.e., consists out of “}1\text{”s only)}.$$

An analogous result holds for the class $`\mathrm{PP}`$, which was characterized in \[Wag86a\] in terms of the so called polynomially length-bounded counting quantifier $`\mathrm{C}^p`$:

* A language $`L`$ is in $`\mathrm{PP}`$ if and only if there is a language $`A\mathrm{P}`$ and a function $`f`$ computable in polynomial time such that for all $`x`$,

$$xL\chi _{A_x}[0\mathrm{}f(x)]\text{ contains more “}1\text{”s than “}0\text{”s}.$$

The class $`\mathrm{US}`$ (for unique solution) is defined by polynomial time nondeterministic Turing machines $`M`$ which accept an input $`x`$ if and only if there is exactly one accepting path in the computation tree of $`M`$ on $`x`$.

* A language $`L`$ is in $`\mathrm{US}`$ if and only if there is a language $`A\mathrm{P}`$ and a function $`f`$ computable in polynomial time such that for all $`x`$,

$$xL\chi _{A_x}[0\mathrm{}f(x)]0^{}10^{}.$$

Thus we see that here the semantics of quantifiers is defined by giving languages over the binary alphabet ($`E=_{\mathrm{def}}(0+1)^{}1(0+1)^{}`$ for $`^p`$, $`U=_{\mathrm{def}}1^{}`$ for $`^p`$, and $`\mathrm{maj}=_{\mathrm{def}}\left\{w\{0,1\}^{}\right|w\text{ contains more “}1\text{”s than “}0\text{”s}\}`$ for $`\mathrm{C}^p`$). The following generalization now is immediate:

Let $`B\{0,1\}^{}`$, let $`𝒦`$ be a class of sets, and $``$ be a class of functions from $`\mathrm{\Sigma }^{}`$. Define the class $`(B)^{}𝒦`$ to consists of all sets $`L`$ for which there exist some $`A𝒦`$ and some function $`f`$ such that for all $`x\mathrm{\Sigma }^{}`$, $`xL\chi _{A_x}[0\mathrm{}f(x)]B`$.

We use the following shorthands: Write $`(A)^\mathrm{p}𝒦`$ ($`(A)^{\mathrm{log}}𝒦`$, $`(A)^{\mathrm{plog}}𝒦`$, resp.), if $``$ is the class of all functions from $`\mathrm{\Sigma }^{}`$ computable in polynomial time (logarithmic time, polylogarithmic time, resp.) on deterministic Turing machines (i.e., $`=\mathrm{FP}`$, $`=\mathrm{FDLOGTIME}`$, $`=\mathrm{FPOLYLOGTIME}`$, resp.). For sub-linear time bounds we use Turing machines with index tape and random access to their input, working in the unrestricted mode (for background, refer to \[CC95, RV97\]). Observe that a function $`f\mathrm{FP}`$ is polynomially length-bounded, $`f\mathrm{FDLOGTIME}`$ is length-bounded by some function $`c\mathrm{log}n`$, and $`f\mathrm{FPOLYLOGTIME}`$ is polylogarithmically length-bounded. If $``$ is a class of languages, then $`()^{}𝒦=_{\mathrm{def}}_B(B)^{}𝒦`$.

If we take the above three languages $`E`$, $`U`$, and maj, and look at different function classes $``$, we get the existential, universal, and counting quantifier for various length-bounds.

The above definition appeared in \[Vol96b\] and (for the special case $`=\mathrm{FP}`$) in \[BS97\].

## 3 Polynomial Time Leaf Languages

The most examined special case of our general operator is probably the polynomial time case, i.e. the base class $`𝒦`$ is the class $`\mathrm{P}`$ (and $`=\mathrm{FP}`$). In this case there is a very intuitive way of visualizing the operator via so called leaf languages.

### 3.1 Definition

In the leaf language approach to the characterization of complexity classes, the acceptance of a word input to a nondeterministic machine depends only on the values printed at the leaves of the computation tree. To be more precise, let $`M`$ be a nondeterministic Turing machine, halting on every path printing a symbol from an alphabet $`\mathrm{\Sigma }`$, with some order on the nondeterministic choices. Then, $`\mathrm{leafstring}^M(x)`$ is the concatenation of the symbols printed at the leaves of the computation tree of $`M`$ on input $`x`$ (according to the order of $`M`$’s paths given by the order of $`M`$’s choices). Given now a language $`B\{0,1\}^{}`$, we define $`\mathrm{Leaf}^M(B)=\left\{x\right|\mathrm{leafstring}^M(x)B\}`$.

Call a computation tree of a machine $`M`$ balanced, if all of its computation paths have the same length, and moreover, if we identify every path with the string over $`\{0,1\}`$ describing the sequence of nondeterministic choices on this path, then there is some string $`z`$ such that all paths $`y`$ with $`|y|=|z|`$ and $`yz`$ (in lexicographic ordering) exist, but no path $`y`$ with $`yz`$ exists.

A leaf language $`B\mathrm{\Sigma }^{}`$ now defines the class $`\mathrm{BLeaf}^\mathrm{P}(B)`$ of all languages $`L`$ for which there exists a nondeterministic polynomial time machine $`M`$ whose computation tree is always balanced, such that $`L=\mathrm{Leaf}^M(B)`$. Let $`𝒞`$ be a class of languages. The class $`\mathrm{BLeaf}^\mathrm{P}(𝒞)`$ consists of the union over all $`B𝒞`$ of the classes $`\mathrm{BLeaf}^\mathrm{P}(B)`$.

This computation model was introduced by Bovet, Crescenzi, and Silvestri, and independently Vereshchagin \[BCS92, Ver93\] and later examined by Hertrampf, Lautemann, Schwentick, Vollmer, and Wagner \[HLS<sup>+</sup>93\], and Jenner, McKenzie, and Thérien \[JMT94\], among others. See also the textbook \[Pap94, pp. 504f\].

Jenner, McKenzie, and Thérien also considered the case where the computation trees are not required to be balanced. For that case, let $`B`$ be any language. Then, the class $`\mathrm{Leaf}^\mathrm{P}(B)`$ consists of those languages $`L`$ for which there exists a nondeterministic polynomial time machine $`M`$ without further restriction, such that $`L=\mathrm{Leaf}^M(B)`$. Let $`𝒞`$ be a class of languages. The class $`\mathrm{Leaf}^\mathrm{P}(𝒞)`$ consists of the union over all $`B𝒞`$ of the classes $`\mathrm{Leaf}^\mathrm{P}(B)`$. (Strictly speaking, the definition of balanced given in \[JMT94\] is different from ours and, at first sight, slightly more general. However, it is easy to see that both definitions are equivalent.)

The reader now might wonder about the seemingly unnatural condition that the nondeterministic choices of $`M`$ are ordered. In fact, most complexity classes of current focus can be defined without this assumption—in this case the leaf language $`B`$ has the special property that we can permute the letters in a given word without affecting membership in $`B`$. (Cf. our results on cardinal languages in Sect. 3.3.2 below.) However, strange classes where the order of the paths is important for their definition are conceivable, and the results presented below, especially the oracle separation criterion (Theorem 3.8), also hold for these pathologic cases.

The following connection to our generalized quantifier now is not too hard to see.

###### Theorem 3.1

Let $`B\{0,1\}^{}`$. Then $`(B)^\mathrm{p}\mathrm{P}=\mathrm{BLeaf}^\mathrm{P}(B)`$.

* ($``$) Let $`L(B)^\mathrm{p}\mathrm{P}`$, $`xL\chi _{A_x}[0\mathrm{}f(x)]B`$. The nondeterministic machine, given $`x`$, branches on all possible second inputs $`y`$ in the range $`0,\mathrm{},f(x)`$, and outputs $`\chi _A(x,y)`$.

($``$) Let $`L\mathrm{BLeaf}^\mathrm{P}(B)`$ via the nondeterministic machine $`M`$. Computation paths of a nondeterministic machines can be followed in polynomial time if the nondeterministic choices are known. Defining $`A`$ to consist of all pairs $`(x,p)`$ such that $`p`$ is a sequence of nondeterministic choices leading to a path of $`M`$ that outputs “$`1`$” and $`f(x)`$ to be the number of paths of $`M`$ on input $`x`$, we have $`xL\chi _{A_x}[0\mathrm{}f(x)]B`$.

The definition of leaf languages allows for languages $`B`$ not necessarily over the binary alphabet. If we want to come up with a connection to our generalized quantifier also for such $`B`$, we face a problem. In the definition in Sect. 2 the binary alphabet seems essential. Fortunately, for every $`B`$ there is usually a $`B^{}\{0,1\}^{}`$ such that $`\mathrm{BLeaf}^\mathrm{P}(B)=\mathrm{BLeaf}^\mathrm{P}(B^{})`$, where $`B`$ and $`B^{}`$ are of the same complexity. In most cases, $`B^{}`$ can simply be obtained from $`B`$ by block encoding (then $`B`$ and $`B^{}`$ are $`\mathrm{FO}`$-equivalent). We come back to this point in the next subsection.

### 3.2 The Complexity of a Leaf Language

In \[HLS<sup>+</sup>93\] the question how complex a leaf language must be in order to characterize some given complexity class $`𝒦`$ was addressed. Let us start by considering some examples.

At great number of classes can be defined by regular leaf languages. This is obvious for $`\mathrm{NP}`$, $`\mathrm{coNP}`$ and $`\mathrm{US}`$ as we saw in the previous section, for $`\mathrm{Mod}_k\mathrm{P}`$ (all words with a number of “$`1`$”s divisible by $`k`$), but also true for higher levels of the polynomial hierarchy (see below) and the boolean hierarchy over $`\mathrm{NP}`$ (e.g. the class $`\mathrm{NP}\mathrm{coNP}`$ can be defined via the set of all words such that the string “$`010`$” appears at least once, but the string “$`0110`$” does not appear).

For other complexity classes, context-free languages come immediately to mind. $`\mathrm{PP}`$ can obviously be defined by the language maj from the previous section. Recalling the characterization of $`\mathrm{PSPACE}`$ via polynomial time alternating Turing machines, it is clear that the set of all (suitably encoded) boolean expressions involving the constants “true” and “false” and the connectives AND and OR that evaluate to “true”, is an appropriate leaf language.

The question however arises if we can do better here. It was shown in \[HLS<sup>+</sup>93\], that in the case of $`\mathrm{PSPACE}`$ there is a regular leaf language.

Let $`S_5`$ denote the word problem for the group of permutations on five elements (suitably encoded over the binary alphabet), i.e. $`S_5`$ consists of sequences of permutations which multiply out to the empty permutation.

###### Theorem 3.2

$`(S_5)^\mathrm{p}\mathrm{P}=\mathrm{PSPACE}`$.

* For the inclusion from left to right, just observe that a $`\mathrm{PSPACE}`$ machine can traverse the whole computation tree of a given nondeterministic machine to evaluate the product over $`S_5`$. This simulation then stops accepting if and only if the result is the identity permutation.

For the other direction, we are given a language $`L\mathrm{PSPACE}`$. Then there is a polynomial time alternating Turing machine accepting $`L`$. Thus, for every input $`w`$, machine $`M`$ defines a polynomial depth computation tree $`T(w)`$ where the leafs carry values $`0`$ or $`1`$ and in the inner nodes the functions AND and OR are evaluated. $`wL`$ iff the root of this tree evaluates to $`1`$. As a first step we transform this tree into a tree $`T^{}(w)`$ where in all the inner nodes the function NOR is evaluated. This can easily be achieved since the NOR function constitutes a complete basis for the boolean functions.

As a second step we now “simulate” NOR in $`S_5`$. This simulation is essentially due to David Barrington \[Bar89\]. Let $`b,c,d,e,f`$ be the following permutations from the group $`S_5`$:

$$b=(23)(45),c=(12435),d=(243),e=(345),f=(152)$$

Further let $`a_0`$ be the empty permutation, denoted by $`a_0=()`$, and let $`a_1=(12345)`$. Now consider the following product in $`S_5`$ including the variables $`x`$ and $`y`$:

$$w(x,y)=a_0bx^4cy^4dxeyf$$

Simple calculations show that $`w(a_0,a_0)=a_1`$ and $`w(a_0,a_1)=w(a_1,a_0)=w(a_1,a_1)=a_0`$. Thus coding the value true by $`a_1`$, and false by $`a_0`$, we can view $`w`$ as the NOR-operation applied to $`x`$ and $`y`$.

Now replace every appearance of a “NOR”-node in $`T^{}(x)`$ with sons $`x`$ and $`y`$ by a binary subtree of height 4 whose 16 leaves are

$$a_0bxxxxcyyyydxeyf$$

Thus we accept the input $`w`$ if and only if the leaf string evaluates to $`a_1`$. Taking $`B`$ to be the regular language

$$B=_{\mathrm{def}}\left\{x\right|x\text{ is a string of elements from }S_5\text{ which evaluates to }a_1\},$$

we then get $`\mathrm{Leaf}^\mathrm{P}(B)=\mathrm{PSPACE}`$. It is easy to go from $`B`$ to the word problem $`S_5`$ (by just adding one more factor $`a_1^1`$), and since we have an identity element which we can insert arbitrarily in the leaf string to fill gaps in the computation tree in order to make it balanced, we get $`\mathrm{PSPACE}=\mathrm{Leaf}^\mathrm{P}(B)=\mathrm{BLeaf}^\mathrm{P}(S_5)=(S_5)^\mathrm{p}\mathrm{P}`$.

The question now of course is what is so special about the language $`S_5`$. What can be said more generally? Using deep algebraic properties of regular languages exhibited in \[Thé81, BT88\] (see also the textbook \[Str94\]) one can show the following.

Let $`\mathrm{PH}`$ denote the union of all classes of the polynomial hierarchy \[SM73\], i.e. $`\mathrm{PH}=\mathrm{NP}\mathrm{NP}^{\mathrm{NP}}\mathrm{NP}^{\mathrm{NP}^{\mathrm{NP}}}\mathrm{}`$. Let MOD-PH denote the oracle hierarchy constructed similarly, but now allowing as building blocks not only $`\mathrm{NP}`$ but also all classes $`\mathrm{Mod}_k\mathrm{P}`$ for arbitrary $`k`$.

###### Theorem 3.3 (\[HLS<sup>+</sup>93\])

1. Let $`A`$ be a regular language whose syntactic monoid is non-solvable. Then $`(A)^\mathrm{p}\mathrm{P}=\mathrm{PSPACE}`$.
2. Let SOLVABLE denote the class of all regular languages whose syntactic monoid is solvable. Then $`(\mathrm{SOLVABLE})^\mathrm{p}\mathrm{P}=\text{MOD-PH}`$.
3. Let APERIODIC denote the class of all regular languages whose syntactic monoid is aperiodic. Then $`(\mathrm{APERIODIC})^\mathrm{p}\mathrm{P}=\mathrm{PH}`$.

Regular leaf languages for individual levels of the polynomial hierarchy can also be given. For example $`\mathrm{\Sigma }_2^\mathrm{p}`$ can be defined over $`\mathrm{\Sigma }=\{a,b,c\}`$ by $`\mathrm{\Sigma }^{}ca^+c\mathrm{\Sigma }^{}`$, intuitively: “there is a block consisting out of ‘$`a`$’s only”. This is an $``$ predicate directly reflecting the nature of $`\mathrm{\Sigma }_2^\mathrm{p}`$-computations. If we now chose a simple block encoding this might lead us out of the aperiodic languages. However, we may proceed as follows: Define $`A_2=(0+1)^{}11(010)^+11(0+1)^{}`$. It is clear that this leaf language defines a subclass of $`\mathrm{\Sigma }_2^\mathrm{p}`$—just check that there are two substring $`11`$ such that in between we have a sequence of occurrences of the 3-letter string $`010`$; this is an $``$ condition. On the other hand, suppose we are given a $`\mathrm{\Sigma }_2^\mathrm{p}`$ machine $`M`$, i.e. an alternating machine with computation trees consisting of one level of $``$ nodes followed by a second level of $``$ nodes; i.e. the initial configuration is the root of an existential tree where in the leaves we append universal subtrees. We transform this into a tree where we use the substring “$`11`$” in the leafstring as separator between different $``$ subtrees, and within each such subtree we simulate an accepting path by the 3 leaf symbols “$`010`$” and a rejecting path by the symbol “$`0`$”. Then $`M`$ produces a tree with at least one universal subtree consisting out of only accepting paths iff the leaf word of this simulation is in $`A_2`$. $`\mathrm{\Sigma }_3^\mathrm{p}`$ can similarly be defined via $`A_3=(0+1)^{}111\overline{A_2}111(0+1)^{}`$. This generalizes to higher levels of the polynomial hierarchy. With some care one can show that $`A_2`$ and $`A_3`$ are in levels $`_2`$ and $`_3`$, resp., of the Brzozowski-hierarchy of regular languages. This hierarchy of star-free regular languages measures the nesting depth of the dot (i.e. concatenation) operation. For a formal definition see \[Eil76\]. More generally the following holds:

###### Theorem 3.4 (\[HLS<sup>+</sup>93\])

$`(_k)^\mathrm{p}\mathrm{P}`$ is the boolean closure of the class $`\mathrm{\Sigma }_k^\mathrm{p}`$.

Let us now come back to the question if $`\mathrm{PP}`$ (for which we gave a context-free leaf language above) can also be done by a regular language.

###### Corollary 3.5

$`\mathrm{PP}`$ is not definable via a regular leaf language unless either $`\mathrm{PP}=\mathrm{PSPACE}`$ or $`\mathrm{PP}\text{MOD-PH}`$.

* If there is a regular leaf language $`L`$ for $`\mathrm{PSPACE}`$, then there are two cases to consider: either $`L`$ is non-solvable (in this case $`\mathrm{PP}=\mathrm{PSPACE}`$) or $`L`$ is solvable (then $`\mathrm{PP}\text{MOD-PH}`$).

In \[HLS<sup>+</sup>93\] leaf languages defined by restricting resource bounds as time and space were examined. It was shown that the complexity class obtained in this way is defined via the same resource, but the bound is one exponential level higher, for example $`(\mathrm{P})^\mathrm{p}\mathrm{P}=\mathrm{EXPTIME}`$, $`(\mathrm{NP})^\mathrm{p}\mathrm{P}=\mathrm{NEXPTIME}`$, $`(\mathrm{LOGSPACE})^\mathrm{p}\mathrm{P}=\mathrm{PSPACE}`$, $`(\mathrm{PSPACE})^\mathrm{p}\mathrm{P}=\mathrm{EXPSPACE}`$, and so on. Denoting the levels of the alternating log-time hierarchy \[Sip83\] by $`\mathrm{\Sigma }_k^{\mathrm{log}}`$ ($`k`$), we get the following special case:

###### Theorem 3.6

$`(\mathrm{\Sigma }_k^{\mathrm{log}})^\mathrm{p}\mathrm{P}=\mathrm{\Sigma }_k^\mathrm{p}`$.

### 3.3 Some Complexity Theoretic Applications

#### 3.3.1 Normal Forms

The characterization of $`\mathrm{PSPACE}`$ (Theorem 3.2) was somewhat surprising, since it points out a very restricted normal form for $`\mathrm{PSPACE}`$ computations. Cai and Furst defined a class $`𝒦`$ to be $`𝒦^{}`$-serializable, if every $`𝒦`$ computation can be organized into a number of local computations $`c_1,\mathrm{},c_r`$ (which in turn are restricted to be $`𝒦^{}`$ computations), each passing only a constant number $`k`$ of bits as the result of its computation to the next local computation. The sequence $`c_1,\mathrm{},c_r`$ is uniform in the sense that there is one $`𝒦^{}`$ program that gets as input only the original input, a number $`i`$, and a string of $`k`$ bits, and computes the $`k`$-bit-result of $`c_i`$’s computation. Please refer to \[CF91\] for a formal definition. Machines as just described are also called bottleneck machines. The bottleneck refers to the restricted way of passing information onwards.

###### Corollary 3.7 (\[HLS<sup>+</sup>93\])

$`\mathrm{PSPACE}`$ is $`\mathrm{AC}^0`$-serializable.

* Let $`L\mathrm{BLeaf}^\mathrm{P}(S_5)`$ via machine $`M`$. The information passed from one computation to the next will be an encoding of an element of the group $`S_5`$. Each local computation uses its number to recover from it a path of the nondeterministic Turing machine. (If the number does not encode a correct computation path, then we simply pass the information we get from our left neighbor onwards to the right.) The leaf symbol on this path is then multiplied to the permutation we got from the left, and the result is passed on to the right. This can be done in $`\mathrm{AC}^0`$ since computation paths of polynomial time Turing machines can be checked in $`\mathrm{AC}^0`$. (A computation path consists not only out of $`M`$’s nondeterministic choices, but is a complete sequence of configurations of $`M`$.)

The power of bottleneck machines was examined in detail in \[Her97\]. He gave a connection between these machines and leaf languages defined via transformation monoids. The power of bottleneck machines as a function of the number of bits passed from one local computation to the next was determined.

#### 3.3.2 Oracle Separations

The original motivation for the introduction of leaf languages in \[BCS92, Ver93\] was the wish to have a uniform oracle separation theorem. Usually when relativized complexity classes are separated, this is achieved by constructing a suitable oracle by diagonalization, usually a stage construction. Bovet, Crescenzi, Silvestri, and Vereshchagin wanted to identify the common part of all these constructions in a unifying theorem, such that for future separations, one could concentrate more on the combinatorial questions which are often difficult enough. They showed that to separate two classes defined by leaf languages, it is sufficient to establish a certain non-reducibility between the defining languages. Let $`A,B\{0,1\}^{}`$. Say that $`A`$ is polylogarithmic time bit-reducible to $`B`$, in symbols: $`A_m^{\mathrm{𝑝𝑙𝑡}}B`$, if there are two functions $`f,g`$ computable in polylogarithmic time such that for all $`x`$, $`xAf(x,0)f(x,1)\mathrm{}f(x,g(x))B`$.

###### Theorem 3.8 (\[BCS92, Ver93\])

Let $`A,B\{0,1\}^{}`$. Then $`A_m^{\mathrm{𝑝𝑙𝑡}}B`$ if and only if for all oracles $`Y`$, the inclusion $`(A)^\mathrm{p}\mathrm{P}^Y(B)^\mathrm{p}\mathrm{P}^Y`$ holds.

Observe that $`A_m^{\mathrm{𝑝𝑙𝑡}}B`$ is just another formulation for the containment of $`A`$ in $`(B)^{\mathrm{plog}}\mathrm{POLYLOGTIME}`$, which in turn is equivalent to the inclusion of the class $`(A)^{\mathrm{plog}}\mathrm{POLYLOGTIME}`$ in $`(B)^{\mathrm{plog}}\mathrm{POLYLOGTIME}`$.

###### Corollary 3.9

Let $`A,B\{0,1\}^{}`$. Then we have:

$$(A)^{\mathrm{plog}}\mathrm{POLYLOGTIME}(B)^{\mathrm{plog}}\mathrm{POLYLOGTIME}$$

if and only if for all oracles $`Y`$, the inclusion

$$(A)^\mathrm{p}\mathrm{P}^Y(B)^\mathrm{p}\mathrm{P}^Y$$

holds.

In \[BS97\], Theorem 3.8 was strengthened as follows: It was shown that $`(A)^\mathrm{p}𝒦(B)^\mathrm{p}𝒦`$ for all nontrivial classes $`𝒦`$ if and only if $`A`$ is reducible to $`B`$ by monotone polylogarithmic-time uniform projection reducibility. Refer to their paper for details.

Observe that a polylogarithmic time bit-reduction cannot (simply because of its time bound) read all of its input. This often allows one to prove $`A_m^{\mathrm{𝑝𝑙𝑡}}B`$ by an adversary arguments. We give a very simple example.

* Let $`E=(0+1)^{}1(0+1)^{}`$, $`U=1^{}`$ as in Sect. 2. Then $`(E)^\mathrm{p}\mathrm{P}=\mathrm{NP}`$ and $`(U)^\mathrm{p}\mathrm{P}=\mathrm{coNP}`$. Suppose $`U_m^{\mathrm{𝑝𝑙𝑡}}E`$. The input $`x=1^n`$ must be mapped by this reduction to a word with at least one “$`1`$”. The computation leading to this “$`1`$” however cannot read all of $`x`$. If we now define $`x^{}`$ by complementing in $`x`$ a bit which is not queried, then again $`x^{}`$ will be mapped to a string in $`E`$, which is a contradiction. Thus $`U_m^{\mathrm{𝑝𝑙𝑡}}E`$, and hence there is an oracle separating $`\mathrm{coNP}`$ from $`\mathrm{NP}`$.

Vereshchagin in \[Ver93\] used Theorem 3.8 to establish all relativizable inclusions between a number of prominent classes within $`\mathrm{PSPACE}`$. His list contains besides the classes of the polynomial time hierarchy also UP, FewP, RP, BPP, AM, MA, PP, IP, and others.

A very satisfactory application of Theorem 3.8 was possible in the following special case. Say that $`L\mathrm{\Sigma }^{}`$ is a cardinal language, if membership in $`L`$ only depends on the frequency with which the elements of $`\mathrm{\Sigma }`$ appear in words. This means that if $`\mathrm{\Sigma }=\{a_1,\mathrm{},a_k\}`$ we can associate $`L`$ with a set $`N(L)^k`$, in such a way that $`wL`$ iff there is a $`(v_1,\mathrm{},v_k)N(L)`$ where $`a_i`$ occurs in $`w`$ exactly $`v_i`$ times ($`1ik`$). ($`N(L)`$ is the image of $`L`$ under the Parikh mapping: $`N(L)=\mathrm{\Psi }_\mathrm{\Sigma }(L)`$.) Say that $`L`$ is of bounded significance if there is a number $`m`$ such that for all $`(v_1,\mathrm{},v_k)`$ we have

$$(v_1,\mathrm{},v_k)N(L)(\mathrm{min}(v_1,m),\mathrm{},\mathrm{min}(v_k,m))N(L).$$

Using Ramsey theory, Hertrampf in \[Her95a\] proved the following:

###### Theorem 3.11 (\[Her95a\])

There is an algorithm that, given two cardinal languages $`A,B`$ of bounded significance, decides if $`(A)^\mathrm{p}\mathrm{P}^Y(B)^\mathrm{p}\mathrm{P}^Y`$ for all oracles $`Y`$.

Pushing his ideas just a bit further, the following was proved: We say that $`p:^k`$ is a positive linear combination of multinomial coefficients if $`p(\stackrel{}{v})=_{uz}\alpha _u\left(\genfrac{}{}{0pt}{}{v}{u}\right)`$ for some $`z^k`$, $`\alpha _u`$ (for $`uz`$, the order taken component-wise).

###### Theorem 3.12 (\[CHVW97\])

Let $`A,B`$ be cardinal languages of bounded significance over a $`k`$ element alphabet. Then $`A_m^{\mathrm{𝑝𝑙𝑡}}B`$ if and only if there are functions $`p_1,\mathrm{},p_k:^k`$ which are positive linear combinations of multinomial coefficients, such that for all $`\stackrel{}{v}=(v_1,\mathrm{},v_k)`$, $`\stackrel{}{v}N(A)`$ if and only if $`(p_1(\stackrel{}{v}),\mathrm{},p_k(\stackrel{}{v}))N(B)`$.

In other words, if such $`k`$ functions do not exist, then there is an oracle separating $`(A)^\mathrm{p}\mathrm{P}`$ from $`(B)^\mathrm{p}\mathrm{P}`$. Thus we see that the oracle separation criterion Theorem 3.8 leads to a very strong statement in the context of cardinal languages. This result was used in \[CHVW97\] to establish a complete list of all relativizable inclusions between classes of the boolean hierarchy over $`\mathrm{NP}`$ and other classes defined by cardinal languages of bounded significance.

Valiant’s counting class $`\mathrm{\#}\mathrm{P}`$ is of course strongly related to the notion of cardinal languages. In the case of $`\mathrm{\#}\mathrm{P}`$ we just deal with the binary alphabet, and we count the number of “$`1`$”s in a leaf string. Closure properties of $`\mathrm{\#}\mathrm{P}`$, that is operations that don’t lead us out of the class, play an important role to establish inclusions between complexity classes; e.g. Toda’s result $`\mathrm{PH}\mathrm{P}^{\mathrm{PP}}`$ \[Tod91\] and Beigel, Reingold, and Spielman’s proof that $`\mathrm{PP}`$ is closed under intersection \[BRS91\] both heavily build on the fact that $`\mathrm{\#}\mathrm{P}`$ is closed under certain sums, products, and choose operations.

Similar to Theorem 3.12 one can obtain the following:

###### Theorem 3.13 (\[HVW95\])

A function $`f:^k`$ is a relativizable closure property of $`\mathrm{\#}\mathrm{P}`$ (i.e., relative to all oracles, if $`h_1,\mathrm{},h_k\mathrm{\#}\mathrm{P}`$ then also $`f(h_1,\mathrm{},h_k)\mathrm{\#}\mathrm{P}`$), if and only if $`f`$ is a positive linear combinations of multinomial coefficients.

#### 3.3.3 Circuit Lower Bounds

Circuit classes as leaf languages have been considered in \[CMTV98, Vol96a\]. For background on circuit complexity, we refer the reader to \[Str94\]. It is immediate from Theorem 3.2 that $`(\mathrm{NC}^1)^\mathrm{p}\mathrm{P}=\mathrm{PSPACE}`$. Additionally one can prove e.g. that $`(\mathrm{AC}^0)^\mathrm{p}\mathrm{P}=\mathrm{PH}`$, and that $`(\mathrm{TC}^0)^\mathrm{p}\mathrm{P}`$ is the counting hierarchy $`\mathrm{CH}`$, defined in \[Wag86b, Wag86a\] as $`\mathrm{PP}\mathrm{PP}^{\mathrm{PP}}\mathrm{PP}^{\mathrm{PP}^{\mathrm{PP}}}\mathrm{}`$. Finer results are given in \[Vol98\].

Building on leaf language characterizations, the circuit class $`\mathrm{TC}^0`$ (where we require logtime uniformity) was separated from the counting hierarchy in \[CMTV98\]. This was improved by Allender \[All96\] to the following separation.

###### Theorem 3.14

$`\mathrm{TC}^0\mathrm{PP}`$.

* We sketch the proof of the weaker result from \[CMTV98\]. Suppose that $`\mathrm{TC}^0=\mathrm{CH}`$. Then we have $`\mathrm{TC}^0=\mathrm{CH}=\mathrm{BLeaf}^\mathrm{P}(\mathrm{TC}^0)=\mathrm{BLeaf}^\mathrm{P}(\mathrm{CH})\mathrm{EXPTIME}`$, thus $`\mathrm{P}\mathrm{EXPTIME}`$, which is a contradiction. Allender now observed that this can be extended to show that any language complete for $`\mathrm{PP}`$ under $`\mathrm{TC}^0`$ reductions cannot be in $`\mathrm{TC}^0`$.

In the non-uniform case no similar lower bound for $`\mathrm{TC}^0`$ is known. If we relax the uniformity condition just a little bit, we know that

$$(\text{logspace-uniform }\mathrm{AC}^0)^\mathrm{p}\mathrm{P}=\mathrm{PSPACE}$$

(thus also $`\mathrm{BLeaf}^\mathrm{P}(\text{logspace-uniform }\mathrm{TC}^0)=\mathrm{PSPACE}`$). This shows that logtime-uniformity is critical in the above proof.

In Corollary 3.9 it became clear that the oracle separability of two polynomial time classes is equivalent to the absolute separability of two lower classes with the same acceptance paradigm. A similar relation is known between polynomial time and constant depth circuit classes. E.g. building on previous work by Furst, Saxe, and Sipser \[FSS84\], Yao in his famous paper used a lower bound for the parity function to construct an oracle separating $`\mathrm{PSPACE}`$ from the polynomial hierarchy \[Yao85\]. This connection has been exploited a number of times since then.

The formal connection between Theorem 3.8 and the Furst, Saxe, Sipser approach to oracle construction has been given in \[Vol98\]. The main observation that has to be made is that $`_m^{\mathrm{𝑝𝑙𝑡}}`$-reductions can be performed by (uniform) $`\mathrm{qAC}^0`$ circuits. $`\mathrm{qAC}^0`$ stands for quasipolynomial $`\mathrm{AC}^0`$ \[Bar92\], i.e. unbounded fan-in circuits of constant depth and size $`2^{\mathrm{log}^{O(1)}n}`$. (Similarly we will also use $`\mathrm{qTC}^0`$ for quasipolynomial size $`\mathrm{TC}^0`$ circuits, and $`\mathrm{qNC}^1`$ for quasipolynomial size $`\mathrm{NC}^1`$ circuits.)

###### Theorem 3.15

Let $`A,B\{0,1\}^{}`$. Then we have: $`A(B)^{\mathrm{plog}}\mathrm{qAC}^0`$ if and only if $`(A)^{\mathrm{plog}}\mathrm{qAC}^0(B)^{\mathrm{plog}}\mathrm{qAC}^0`$ if and only if there is an oracle $`Y`$ such that $`(A)^\mathrm{p}\mathrm{PH}^Y(B)^\mathrm{p}\mathrm{PH}`$.

This theorem can be used to attack the “nagging question” \[For97\] how to separate superclasses of $`\mathrm{P}^{\mathrm{PP}}`$ from $`\mathrm{PSPACE}`$. Some special cases are the following.

###### Corollary 3.16

$`S_5\mathrm{qTC}^0`$ if and only if $`\mathrm{qTC}^0\mathrm{qNC}^1`$ if and only if there is an oracle separating the counting hierarchy from $`\mathrm{PSPACE}`$.

* Under the assumption $`S_5\mathrm{qTC}^0`$, the following inclusion chain holds relativizably:

$$\mathrm{PSPACE}=\mathrm{BLeaf}^\mathrm{P}(S_5)\mathrm{BLeaf}^\mathrm{P}(\mathrm{qTC}^0)=\mathrm{CH}.$$

This proves the direction from right to left. For the other direction, if relative to all oracles $`\mathrm{PSPACE}\mathrm{CH}`$ then $`S_5`$ polylogarithmic time bit-reduces to $`\mathrm{qTC}^0`$, but this class is even closed under $`\mathrm{qAC}^0`$ reductions.

Define $`\mathrm{par}=_{\mathrm{def}}\left\{w\{0,1\}^{}\right|\text{the number of “}1\text{”s in }w\text{ is odd}\}`$, and let maj be as in Sect. 2.

###### Corollary 3.17

$`S_5(\mathrm{maj})^{\mathrm{plog}}(\mathrm{par})^{\mathrm{plog}}\mathrm{qAC}^0`$ if and only if there is an oracle separating $`\mathrm{PP}^\mathrm{}\mathrm{P}`$ from $`\mathrm{PSPACE}`$.

* If $`\mathrm{PSPACE}\mathrm{PP}^\mathrm{}\mathrm{P}`$ then $`S_5`$ polylogarithmic time bit-reduces to a language in the class $`(\mathrm{maj})^{\mathrm{plog}}(\mathrm{par})^{\mathrm{plog}}\mathrm{qAC}^0`$, and therefore $`S_5`$ is even in this class (it is closed under $`_m^{\mathrm{𝑝𝑙𝑡}}`$).

On the other hand, if $`S_5(\mathrm{maj})^{\mathrm{plog}}(\mathrm{par})^{\mathrm{plog}}\mathrm{qAC}^0`$, then $`\mathrm{PSPACE}=\mathrm{BLeaf}^\mathrm{P}(S_5)\mathrm{BLeaf}^\mathrm{P}((\mathrm{maj})^{\mathrm{plog}}(\mathrm{par})^{\mathrm{plog}}\mathrm{qAC}^0)=\mathrm{PP}^{\mathrm{}\mathrm{P}^{\mathrm{PH}}}=\mathrm{PP}^\mathrm{}\mathrm{P}`$.

A refinement of Theorem 3.15 and further investigations along these lines can be found in \[Vol98\].

### 3.4 Definability vs. Tree Shapes

Our quantifier from Sect. 2 coincides as we saw in the polynomial time context with leaf languages for balanced computation trees. The unbalanced case has also attracted some attention in the literature. It was observed in \[HVW96\] that the relativization result from \[BCS92, Ver93\] does not hold in the case of unbalanced trees. Thus, part of the motivation to consider this construct is gone. Nevertheless definability questions are also interesting in this case. The just mentioned observation even makes a systematic comparison of both models a worthwhile study.

#### 3.4.1 Balanced vs. Unbalanced Trees

In \[HVW96\] the question of definability of the polynomial hierarchy was addressed. As mentioned earlier in Theorem 3.6, the classes of the log-time hierarchy exactly define the classes of the polynomial hierarchy. However, in the case of unbalanced trees, one can somehow use the tree structure to hide an oracle that is able to count paths. More formally,

###### Theorem 3.18 (\[HVW96\])

$`\mathrm{Leaf}^\mathrm{P}(\mathrm{\Sigma }_k^{\mathrm{log}})=\left(\mathrm{\Sigma }_k^\mathrm{p}\right)^{\mathrm{PP}}`$.

#### 3.4.2 The Acceptance Power of Different Tree Shapes

Hertrampf \[Her95b\] considered besides the above two models also the definition of classes via leaf languages for computation trees which are full binary trees. The obtained classes are noted by $`\mathrm{FBTLeaf}^\mathrm{P}()`$. Though trivially for every $`B\{0,1\}^{}`$ we have $`\mathrm{FBTLeaf}^\mathrm{P}(B)\mathrm{BLeaf}^\mathrm{P}(B)\mathrm{Leaf}^\mathrm{P}(B)`$, Hertrampf proved the somewhat counterintuitive result, that the definability power by arbitrary single regular languages does not decrease but possibly increases as the tree shapes get more and more regular; that is for every regular language $`B`$ there is a regular language $`B^{}`$ such that $`\mathrm{Leaf}^\mathrm{P}(B)=\mathrm{Leaf}^\mathrm{P}(B^{})=\mathrm{BLeaf}^\mathrm{P}(B^{})`$, and for every regular language $`B`$ there is a regular language $`B^{}`$ such that $`\mathrm{BLeaf}^\mathrm{P}(B)=\mathrm{BLeaf}^\mathrm{P}(B^{})=\mathrm{FBTLeaf}^\mathrm{P}(B^{})`$.

#### 3.4.3 Definability Gaps

In the case of arbitrary tree shapes, Borchert et al. were able to prove the existence of definability gaps. In particular, the following was shown.

###### Theorem 3.19

Suppose the polynomial hierarchy does not collapse, and let $`B`$ be an arbitrary regular language.

1. If $`\mathrm{P}\mathrm{Leaf}^\mathrm{P}(B)𝒦`$, then $`\mathrm{Leaf}^\mathrm{P}(B)=\mathrm{P}`$ or $`\mathrm{Leaf}^\mathrm{P}(B)=𝒦`$, where $`𝒦`$ is one of the classes $`\mathrm{NP}`$, $`\mathrm{coNP}`$, or $`\mathrm{Mod}_p\mathrm{P}`$ (for some prime number $`p`$) \[Bor94\].
2. If $`\mathrm{NP}\mathrm{Leaf}^\mathrm{P}(B)\mathrm{coUS}`$, then $`\mathrm{Leaf}^\mathrm{P}(B)=\mathrm{NP}`$ or $`\mathrm{Leaf}^\mathrm{P}(B)=\mathrm{coUS}`$ \[BKS96\] (analogously for $`\mathrm{coNP}`$ and $`\mathrm{US}`$).

We come back to questions of this kind in Sect. 6.

## 4 Other Resource Bounds

### 4.1 Circuit Classes

Corollary 3.7 easily yields the following:

###### Corollary 4.1

$`(S_5)^\mathrm{p}\mathrm{AC}^0=\mathrm{PSPACE}`$.

This coincidence between $`()^\mathrm{p}\mathrm{P}`$ and $`()^\mathrm{p}\mathrm{AC}^0`$ holds under more general circumstances. Let $`𝒩`$ denote the set of all languages $`L\mathrm{\Sigma }^{}`$ that contain a neutral letter $`e`$, i.e. for all $`u,v\mathrm{\Sigma }^{}`$, we have $`uvLuevL`$.

###### Theorem 4.2

If $`B𝒩`$ then $`(B)^\mathrm{p}\mathrm{P}=(B)^\mathrm{p}\mathrm{AC}^0`$.

* Correctness of computation paths of nondeterministic Turing machines can be checked in $`\mathrm{AC}^0`$ as already pointed out in the proof of Corollary 3.7. The required $`\mathrm{AC}^0`$ computation in input $`(x,y)`$ now checks that its second input argument is a correct path of the corresponding machine on input $`x`$; if so it outputs $`1`$ iff this path is accepting and $`0`$ otherwise. If $`y`$ does not encode a correct path then the neutral letter is output.

A careful inspection of the just given proof reveals that the result not only holds for language $`B𝒩`$, $`B\{0,1\}^{}`$, but also for languages $`B`$ that are obtained from some $`B^{}𝒩`$, $`B\mathrm{\Sigma }^{}`$ (possibly $`|\mathrm{\Sigma }|>2`$) by block encoding. The same generalization holds for all results that we state below for “$`B𝒩`$” (i.e., Theorem 4.8 and all results in Sect. 5).

In the context of $`\mathrm{NC}^1`$ and subclasses, some interesting results can be obtained for classes of the form $`()^{\mathrm{log}}\mathrm{AC}^0`$.

First, Barrington’s theorem \[Bar89\] yields:

###### Theorem 4.3

$`(S_5)^{\mathrm{log}}\mathrm{AC}^0=\mathrm{NC}^1`$.

###### Theorem 4.4

1. $`(B)^{\mathrm{log}}\mathrm{AC}^0=\mathrm{NC}^1`$ for every regular language $`B`$ whose syntactic monoid is non-solvable.
2. $`(\mathrm{SOLVABLE})^{\mathrm{log}}\mathrm{AC}^0=\mathrm{ACC}^0`$.

Generally the class $`(B)^{\mathrm{log}}\mathrm{AC}^0`$ roughly corresponds to $`\mathrm{AC}^0`$ circuits with a $`B`$ gate on top, e.g. $`(\mathrm{maj})^{\mathrm{log}}\mathrm{AC}^0`$ is the class of all languages accepted by perceptrons.

$`\mathrm{AC}^0`$ circuits with arbitrary $`B`$ gates are examined in \[BIS90, BI94\] (see also Sect. 6).

### 4.2 Logspace and Logtime Leaf Languages

In the same spirit as above for nondeterministic polynomial time machines, Jenner, McKenzie, and Thérien examined in \[JMT94\] leaf languages for nondeterministic logarithmic time and logarithmic space machines.

First turning to the logspace case, we observe that the trivial way to formulate $`\mathrm{Leaf}^\mathrm{L}(B)`$, the class defined by logspace machines with leaf language $`B`$, as a class $`()^\mathrm{p}\mathrm{L}`$ does not work ($`\mathrm{L}`$ denotes the class of logspace decidable sets). This is because (for $`B𝒩`$) already $`(B)^\mathrm{p}\mathrm{P}=(B)^\mathrm{p}\mathrm{AC}^0`$ (see Sect. 4.1), and therefore also $`(B)^\mathrm{p}\mathrm{P}=(B)^\mathrm{p}\mathrm{L}`$.

However, if we turn to logarithmic space-bounded one-way protocol machines or 2-1-machines \[Lan86\], we can come up with a connection. A 2-1-Turing machine is a Turing machine with two input tapes: first a (regular) input tape that can be read as often as necessary, and second, an additional (protocol) tape that can be read only once (from left to right). Define 2-1-$`\mathrm{L}`$ to be the class of all two argument languages $`L`$ that can be computed by logspace-bounded 2-1-TMs such that in the initial configuration, the first argument of the input is on the regular input tape, and the second argument is on the one-way input tape. Then the following can be shown using ideas from \[Lan86\]:

###### Theorem 4.5

Let $`B\{0,1\}^{}`$. Then $`(B)^\mathrm{p}\text{2-1-}\mathrm{L}=\mathrm{Leaf}^\mathrm{L}(B)`$.

Jenner, McKenzie, and Thérien showed that in a lot of cases, the balanced and unbalanced model coincide for logarithmic space machines, and moreover it sometimes coincides with the polynomial time case, e.g. Theorem 3.6 above also holds with leaf languages for logspace machines. Interesting to mention is that in the logarithmic space model, regular leaf languages define the class $`\mathrm{P}`$, while $`\mathrm{NC}^1`$ defines the class $`\mathrm{PSPACE}`$.

In the logarithmic time case, coincidence with the logarithmic time reducibility closure could be shown for all well-behaved leaf languages. Formulated in terms of our quantifier, some of their results read as follows:

###### Theorem 4.6 (\[JMT94\])

1. $`(\mathrm{REG})^{\mathrm{log}}\mathrm{DLOGTIME}=\mathrm{NC}^1`$.
2. $`(\mathrm{CFL})^{\mathrm{log}}\mathrm{DLOGTIME}=\mathrm{LOGCFL}`$.
3. $`(\mathrm{CSL})^{\mathrm{log}}\mathrm{DLOGTIME}=\mathrm{PSPACE}`$.

###### Theorem 4.7 (\[JMT94\])

1. $`(B)^{\mathrm{log}}\mathrm{DLOGTIME}=\mathrm{NC}^1`$ for any regular language $`B`$ whose syntactic monoid is non-solvable.
2. $`(\mathrm{SOLVABLE})^{\mathrm{log}}\mathrm{DLOGTIME}=\mathrm{ACC}^0`$.
3. $`(\mathrm{APERIODIC})^{\mathrm{log}}\mathrm{DLOGTIME}=\mathrm{AC}^0`$.

### 4.3 Other models

#### 4.3.1 Type 2 Operators

Operators ranging not over words but over oracles, so called type 2 operators, have been examined in \[BW96, BVW96, VW97\] and elsewhere. Most of the considered classes coincide with classes of the form $`(B)^{}𝒦`$ where $`𝒦=\mathrm{coNP}`$ or $`𝒦=\mathrm{PSPACE}`$ and $``$ is the class of all exponential time computable functions (let us write $`(B)^{\mathrm{exp}}𝒦`$ as a shorthand for this choice of $``$). A word of care about the computational model however is in order now. We say that a language $`L`$ belongs to the class $`(B)^{\mathrm{exp}}\mathrm{coNP}`$ if there is a function $`f`$ computable in exponential time, and a set $`A`$ such that $`xL\chi _{A_x}[0\mathrm{}f(x)]B`$, where $`A`$ is accepted by some co-nondeterministic Turing machine $`M`$ that on input $`x,y`$ runs in time polynomial in the length of $`x`$. The length of $`y`$ is possibly exponential in the length of $`x`$; thus to enable $`M`$ to access all positions of $`y`$ within its time bound we supply $`M`$ with a regular input tape on which $`x`$ is found, and a second input tape for $`y`$, which is accessed by an index tape . This special input tape is similar to an oracle tape, and therefore quantifiers over strings on this tape translate to quantifiers over oracles. (In the case of $`(B)^{\mathrm{exp}}\mathrm{PSPACE}`$ we require our machines to use space no more than polynomial in the length of their regular input $`x`$.)

###### Theorem 4.8

Let $`B𝒩`$. Then we have:

$$(B)^{\mathrm{exp}}\mathrm{EXPTIME}=(B)^{\mathrm{exp}}\mathrm{PSPACE}=(B)^{\mathrm{exp}}\mathrm{coNP}.$$

* If we look at the proof of Theorem 4.2 we see that to check correct computation paths we actually don’t need the full power of $`\mathrm{AC}^0`$. $`\mathrm{\Pi }_1^{\mathrm{log}}`$ is sufficient, but we have to modify the computation model slightly as follows: The log-time machine has a regular input tape (which is accessed as usual by using an index tape) and a second input tape on which the path to be checked is given (again access is by an index tape). We thus get:

$$(B)^\mathrm{p}\mathrm{P}=(B)^\mathrm{p}\mathrm{AC}^0=(B)^\mathrm{p}\mathrm{\Pi }_1^{\mathrm{log}}.$$

Using standard translation arguments we now get the claim of the theorem by lifting up this equation one exponential level.

#### 4.3.2 $`\mathrm{NC}^1`$ Leaf Languages

In \[CMTV98\] leaf languages for nondeterministic finite automata were considered. The original input is however first given into a uniform projection, and the result of this projection is then fed into the NFA. Barrington’s Theorem 4.3 implies that with regular leaf languages we thus get exactly the class $`\mathrm{NC}^1`$. Some other characterizations were given in \[CMTV98\], and the model was also used to examine counting classes within $`\mathrm{NC}^1`$.

#### 4.3.3 Function Classes

In \[KSV97\] the definability of function classes has been examined. An oracle separation criterion generalizing Theorem 3.8 was given and applied successfully in some open cases.

## 5 Leaf Languages vs. Lindström Quantifiers

Lindström quantifiers \[Lin66\] are a well established generalized quantifier notion in finite model theory. The reader probably has noticed some resemblance of our definition in Sect. 2 with that of Lindström quantifiers. It will be our aim in the upcoming sections to make this precise.

As we will see there is a strong connection between leaf languages for polynomial time machines and second-order Lindström quantifiers. Since this notion might not be so well-known, we give—after very briefly recalling some terminology from finite model theory—a precise definition in Sect. 5.1.

In later subsections we will have the need to talk about the second-order version of a given first-order Lindström quantifier. We chose to make this precise by talking about the semantics of quantifiers given by languages instead of the usual way of defining semantics by classes of structures. In the next subsection, we will define how a language $`B`$ gives rise to a first-order quantifier $`Q_B^0`$ and a second order quantifier $`Q_B^1`$.

### 5.1 Second-Order Lindström Quantifiers

A signature is a finite sequence $`\tau =R_1,\mathrm{},R_k,c_1,\mathrm{},c_{\mathrm{}}`$ of relation symbols and constant symbols. A finite structure of signature $`\tau `$ is a tuple $`𝒜=(A,R_1^𝒜,\mathrm{},R_k^𝒜,c_1^𝒜,\mathrm{},c_{\mathrm{}}^𝒜)`$ consisting of a finite set $`A`$ (the universe of $`𝒜`$) and interpretations of the symbols in $`\tau `$ by relations over $`𝒜`$ (of appropriate arity) and elements of $`𝒜`$. $`\mathrm{Struct}(\tau )`$ is the set of all finite ordered structures over $`\tau `$. The characteristic string $`\chi _R`$ of a relation $`R\{0,\mathrm{},n1\}^a`$ is the string $`\chi _R=_{\mathrm{def}}b_1\mathrm{}b_{n^a}`$ where $`b_i=1`$ iff the $`i`$-th vector in $`\{0,\mathrm{},n1\}^a`$ (in the order $`(0,\mathrm{},0,0)<(0,\mathrm{},0,1)<(n1,\mathrm{},n1,n1)`$) is in $`R`$. For $`1in^a`$, let $`\chi _R[i]`$ denote the $`i`$-th bit in $`\chi _R`$.

If $``$ is a logic (as e.g. $`\mathrm{FO}`$ or $`\mathrm{SO}`$) and $`𝒦`$ is a complexity class, then we say that $``$ captures $`𝒦`$ if every property over (standard encodings of) structures decidable within $`𝒦`$ is expressible by $``$ sentences, and on the other hand for every fixed $``$ sentence $`\varphi `$, determining whether $`𝒜\varphi `$ can be done in $`𝒦`$. As an abbreviation we will most of the time simply write $`𝒦=`$.

A first-order formula $`\varphi `$ with $`k`$ free variables defines for every structure $`𝒜`$ the relation $`\varphi ^𝒜=_{\mathrm{def}}\left\{\stackrel{}{a}A^k\right|𝒜\varphi (\stackrel{}{a})\}`$, see \[EF95\].

Every class of structures $`K\mathrm{Struct}(\sigma )`$ over a signature $`\sigma =P_1,\mathrm{},\mathrm{P}_s`$ defines the first-order Lindström quantifier $`Q_K`$ as follows: Let $`\varphi _1,\mathrm{},\varphi _s`$ be first-order formulae over signature $`\tau `$ such that for $`1is`$ the number of free variables in $`\varphi _i`$ is equal to the arity of $`P_i`$. Then

$$Q_K\stackrel{}{x}_1,\mathrm{},\stackrel{}{x}_s[\varphi _1(\stackrel{}{x}_1),\mathrm{},\varphi _s(\stackrel{}{x}_s)]$$

is a $`Q_K\mathrm{FO}`$ formula. If $`𝒜\mathrm{Struct}(\tau )`$, then

$$𝒜Q_K\stackrel{}{x}_1,\mathrm{},\stackrel{}{x}_s[\varphi _1(\stackrel{}{x}_1),\mathrm{},\varphi _s(\stackrel{}{x}_s)]$$

iff $`(A,\varphi _1^𝒜,\mathrm{},\varphi _s^𝒜)K`$.

The just given definition is the original definition given by Lindström \[Lin66\], which the reader will also find in textbooks, see e.g. \[Ebb85, EF95\]. For our examinations, the following equivalent formulation will be useful (observe that this only makes sense for ordered structures):

Given a first-order formula $`\varphi `$ with $`k`$ free variables and a corresponding finite ordered structure $`𝒜`$, this defines the binary string $`\chi _{\varphi ^𝒜}`$ of length $`n^k`$ ($`n=|A|`$). Now given a sequence $`\varphi _1,\mathrm{},\varphi _s`$ of formulae with $`k`$ free variables each and a structure $`𝒜`$, we similarly get the tuple $`(\chi _{\varphi _1^𝒜},\mathrm{},\chi _{\varphi _s^𝒜})`$, where $`|\chi _{\varphi _1^𝒜}|=\mathrm{}=|\chi _{\varphi _s^𝒜}|=n^k`$. Certainly, there is a one-one correspondence between such tuples and strings of length $`n^k`$ over a larger alphabet (in our case with $`2^s`$ elements) as follows. Let $`A_s`$ be such an alphabet. Fix an arbitrary enumeration of $`A_s`$, i.e. $`A_s=\{a_0,a_1,\mathrm{},a_{2^s1}\}`$. Then $`(\chi _{\varphi _1^𝒜},\mathrm{},\chi _{\varphi _s^𝒜})`$ corresponds to the string $`b_1b_2\mathrm{}b_{n^k}`$, where for $`1in^k`$, $`b_iA_s`$, $`b_i=a_k`$ for that $`k`$ whose length $`s`$ binary representation (possibly with leading zeroes) is given by $`\chi _{\varphi _1^𝒜}[i]\mathrm{}\chi _{\varphi _s^𝒜}[i]`$. In symbols: $`w_s(\chi _{\varphi _1^𝒜},\mathrm{},\chi _{\varphi _s^𝒜})=b_1b_2\mathrm{}b_{n^k}`$.

This leads us to the following definition: A sequence $`[\varphi _1,\mathrm{},\varphi _s]`$ is in first-order word normal form, iff the $`\varphi _i`$ have the same number $`k`$ of free variables. Let $`\mathrm{\Gamma }`$ be an alphabet such that $`|\mathrm{\Gamma }|2^s`$, and let $`B\mathrm{\Gamma }^{}`$. Then $`𝒜Q_B\stackrel{}{x}[\varphi _1(\stackrel{}{x}),\mathrm{},\varphi _s(\stackrel{}{x})]`$ iff $`w_s(\chi _{\varphi _1^𝒜},\mathrm{},\chi _{\varphi _s^𝒜})B`$.

It can be shown \[BV98, Bur96\] that every Lindström quantifier $`Q_K`$ can without loss of generality be assumed to be of the form $`Q_B`$ as just defined. This is the case since for every sequence $`[\varphi _1,\mathrm{},\varphi _s]`$ of first-order formulae we find an equivalent sequence in word normal form such that the corresponding formulae with Lindström quantifier express the same property.

Second-order Lindström quantifiers are defined as follows \[BV98, Bur96\]: Given a formula $`\varphi `$ with free second-order variables $`P_1,\mathrm{},P_m`$ and a structure $`𝒜`$, define $`\varphi ^{2^𝒜}=_{\mathrm{def}}\left\{(R_1^𝒜,\mathrm{},R_m^𝒜)\right|𝒜\varphi (R_1^𝒜,\mathrm{},R_m^𝒜)\}`$, and let $`\chi _{\varphi ^{2^𝒜}}`$ be the corresponding characteristic string, the order of vectors of relations being the natural one induced by the underlying order of the universe. If the arities of $`P_1,\mathrm{},P_m`$ are $`r_1,\mathrm{},r_m`$, resp., then the length of $`\chi _{\varphi ^{2^𝒜}}`$ is $`2^{n^{r_1}+\mathrm{}+n^{r_m}}`$

Let $`\sigma =\sigma _1,\mathrm{},\sigma _s`$ be a signature, where $`\sigma _i=P_{i,1},\mathrm{},P_{i,m_i}`$ for $`1is`$. Thus $`\sigma `$ is a signature consisting of a sequence of $`s`$ signatures with only predicate symbols each. Let $`\mathrm{}_{i,j}`$ be the arity of $`P_{i,j}`$. A second-order structure of signature $`\sigma `$ is a tuple $`𝒜=(A,_1,\mathrm{},_s)`$, where for every $`1is`$, $`_i\left\{(R_{i,1},\mathrm{},R_{i,m_i})\right|R_{i,j}A^{\mathrm{}_{i,j}}\}`$. Given now a signature $`\tau `$ and second-order formulae $`\varphi _1(\stackrel{}{X}_1),\mathrm{},\varphi _s(\stackrel{}{X}_s)`$ over $`\tau `$ where for every $`1is`$ the number and arity of free predicates in $`\varphi _i`$ corresponds to $`\sigma _i`$. Let $`𝒦`$ be a class of second-order structures over $`\sigma `$. Then $`Q_𝒦\stackrel{}{X}_1,\mathrm{},\stackrel{}{X}_s[\varphi _1(\stackrel{}{X}_1),\mathrm{},\varphi _s(\stackrel{}{X}_s)]`$ is a $`Q_𝒦\mathrm{SO}`$ formula. If $`𝒜\mathrm{Struct}(\tau )`$, then $`𝒜Q_𝒦\stackrel{}{X}_1,\mathrm{},\stackrel{}{X}_s[\varphi _1(\stackrel{}{X}_1),\mathrm{},\varphi _s(\stackrel{}{X}_s)]`$ iff $`(A,\varphi _1^{2^𝒜},\mathrm{},\varphi _s^{2^𝒜})𝒦`$.

Again, we want to talk about second-order Lindström quantifiers defined by languages. Thus we define analogously to the above: A sequence $`[\varphi _1(\stackrel{}{X}_1),\mathrm{},\varphi _s(\stackrel{}{X}_s)]`$ of second-order formulae is in second-order word normal form, if the $`\varphi _1,\mathrm{},\varphi _s`$ have the same predicate symbols, i.e. in the above terminology $`\sigma _1=\mathrm{}=\sigma _s=P_1,\mathrm{},P_m`$. Let for $`1im`$ the arity of $`P_i`$ be $`r_i`$. Observe that in this case, $`|\chi _{\varphi _1^{2^𝒜}}|=\mathrm{}=|\chi _{\varphi _s^{2^𝒜}}|=2^{n^{r_1}+\mathrm{}+n^{r_m}}`$ (for $`n=|A|`$), thus $`(\chi _{\varphi _1^{2^𝒜}},\mathrm{},\chi _{\varphi _s^{2^𝒜}})`$ corresponds to a word of the same length over an alphabet of cardinality $`2^s`$. Given now a language $`B\mathrm{\Gamma }^{}`$ with $`|\mathrm{\Gamma }|2^s`$, the second-order Lindström quantifier given by $`B`$ is defined by $`𝒜Q_B^1\stackrel{}{X}[\varphi _1(\stackrel{}{X}),\mathrm{},\varphi _s(\stackrel{}{X})]`$ iff $`w_s(\chi _{\varphi _1^{2^𝒜}},\mathrm{},\chi _{\varphi _s^{2^𝒜}})B`$.

Again it was shown in \[BV98, Bur96\] that for every second-order Lindström quantifier $`Q_𝒦`$ there is an equivalent $`Q_B^1`$.

When talking about the first-order Lindström quantifier given by $`B`$, we sometimes explicitly write $`Q_B^0`$ instead of $`Q_B`$. In addition to the above logics $`Q_B^0\mathrm{FO}`$ and $`Q_B^1\mathrm{SO}`$ where we allow Lindström quantifiers followed by an arbitrary first-order (second-order, resp.) formula, we also need $`Q_B^1\mathrm{FO}`$ (where we have a second-order Lindström quantifier followed by a formula with no other second-order quantifiers), and $`\mathrm{FO}(Q_B^0)`$ and $`\mathrm{SO}(Q_B^1)`$ (where we have first-order (second-order, resp.) formulae with arbitrary nesting of universal, existential, and Lindström quantifiers). For a class of languages $`𝒞`$ we use the notation $`Q_𝒞`$ with the obvious meaning, e.g. $`\mathrm{FO}(Q_𝒞^0)`$ denotes all first-order sentences with arbitrary quantifiers $`Q_B^0`$ for $`B𝒞`$.

### 5.2 A Logical Characterization of the Leaf Concept

The main technical connection between polynomial time leaf languages and second-order Lindström quantifiers is given in the following theorem:

###### Theorem 5.1

Let $`M`$ be a polynomial time nondeterministic machine whose computation tree is always a full binary tree, and let $`B\{0,1\}^{}`$. Then there is a $`\mathrm{\Sigma }_1^1`$ formula $`\varphi `$ such that

$$\mathrm{Leaf}^M(B)=Q_B^1\stackrel{}{X}\left[\varphi (\stackrel{}{X})\right].$$

* We use a modification of Fagin’s proof \[Fag74\]. The $`Q_B^1`$ quantifier will bind the nondeterministic guesses of the machine. The second-order quantifiers in $`\varphi `$ will bind variables $`Y`$ that encode computation paths of $`M`$. The formula $`\varphi (X)`$ says “there is a $`Y`$ encoding a correct computation path of $`M`$ corresponding to nondeterministic guesses $`X`$, which is accepting.”

If we deal with $`B\mathrm{\Gamma }^{}`$ not necessarily over the binary alphabet, then instead of $`\varphi `$ above, we get formulae $`\varphi _s,\mathrm{},\varphi _s`$ such that

$$\mathrm{Leaf}^M(B)=Q_B^1\stackrel{}{X}[\varphi _1(\stackrel{}{X}),\mathrm{},\varphi _s(\stackrel{}{X})].$$

$`\varphi _i(X)`$ says “there is a $`Y`$ encoding a correct computation path of $`M`$ corresponding to nondeterministic guesses $`X`$, and the leaf symbol produced on this path has a $`1`$ in bit position $`i`$ (in binary). Thus what we have here is some block-encoding of $`\mathrm{\Gamma }`$ in binary strings of length $`s`$.

The just given theorem shows that $`\mathrm{FBTLeaf}^\mathrm{P}(B)Q_B^1\mathrm{\Sigma }_1^1`$. The question now of course is if there is a logic capturing $`\mathrm{FBTLeaf}^\mathrm{P}(B)`$. For the special case $`B𝒩`$, the answer is yes.

###### Theorem 5.2 (\[BV98\])

Let $`B𝒩`$. Then $`Q_B^1\mathrm{FO}=\mathrm{BLeaf}^\mathrm{P}(B)`$.

* This time $`Q_B^1`$ binds the nondeterministic guesses $`X`$ as well as the encoding $`Y`$ of a possible computation path. The first order formulae “output” the neutral letter, if $`Y`$ does not encode a correct path. This proves the direction from right to left. For the other inclusion, we observe that we can design a Turing machine which branches on all possible assignments for the relational variables and then simply evaluates the first-order part.

In the preceding theorem $`\mathrm{BLeaf}^\mathrm{P}(B)`$ is captured by the logic $`Q_B^1\mathrm{FO}`$ uniformly in the sense of \[MP93, MP94\]; this means that the particular formula describing the Turing machine is independent of the leaf language.

Let us next address the question if the quantifier in the preceding theorem is genuinely second-order. First, we have to give some definitions. A succinct representation \[Wag86a, BLT92, Vei96\] of a binary word $`x`$ is a boolean circuit giving on input $`i`$ the $`i`$th bit of $`x`$. The succinct version $`sA`$ of a language $`A`$ is the following: Given a boolean circuit describing a word $`x`$, is $`x=x_10x_20\mathrm{}x_{n1}0x_n1w`$ for arbitrary $`w\{0,1\}^{}`$, such that $`x_1x_2\mathrm{}x_nA`$? The boolean circuits we allow are standard unbounded fan-in circuits over AND, OR, NOT. The encoding consists of a sequence of tuples $`(g,t,h)`$, where $`g`$ and $`h`$ are gates, $`t`$ is the type of $`g`$, and $`h`$ is an input gate to $`g`$ (if $`g`$ is not already an input variable).

Now we see that there is an equivalent first-order logic for $`Q_B^1\mathrm{FO}`$.

###### Theorem 5.3

Let $`B𝒩`$. Then $`\mathrm{BLeaf}^\mathrm{P}(B)=Q_B^1\mathrm{FO}=Q_{sB}^0\mathrm{FO}`$.

* Veith \[Vei96\] showed that $`sB`$ is complete for $`\mathrm{BLeaf}^\mathrm{P}(B)`$ under projection reductions. (A somewhat weaker result appeared in \[BL96\]). This together with Theorem 5.2 implies the theorem.

### 5.3 Applications

Burtschick and Vollmer in \[BV98\] also examined logically defined leaf languages. It turned out that if the leaf language is given by a first-order formula, then the obtained complexity class is captured by the corresponding second-order logic. More specifically, they proved for instance:

###### Theorem 5.4 (\[BV98\])

Let $`B𝒩`$. Then $`(Q_B^0\mathrm{\Sigma }_k^0)^\mathrm{p}\mathrm{P}=Q_B^1\mathrm{\Sigma }_k^1`$.

As a special case of Theorem 5.4 we get a characterization of the classes of the polynomial hierarchy which is tighter than the one in Theorem 3.6.

###### Corollary 5.5

$`(\mathrm{\Sigma }_k^0)^\mathrm{p}\mathrm{P}=\mathrm{\Sigma }_k^\mathrm{p}`$.

From the $`\mathrm{PSPACE}`$ characterization Theorem 3.2 and the above results, we get the following model-theoretic characterization of $`\mathrm{PSPACE}`$:

###### Corollary 5.6

$`Q_{S_5}^1\mathrm{FO}=Q_{sS_5}^0\mathrm{FO}=\mathrm{PSPACE}`$.

### 5.4 First-order quantifiers

It is known from the work of Immerman et al. \[Imm89, BIS90\] that (uniform) $`\mathrm{AC}^0`$ is captured by $`\mathrm{FO}`$. However, for this result, we have to include the bit predicate in our logic. We make this assumption throughout this subsection (all the previously given results are valid without the bit predicate).

###### Theorem 5.7

Let $`B\{0,1\}^{}`$. Then $`(B)^{\mathrm{log}}\mathrm{AC}^0=Q_B^0\mathrm{FO}`$.

Theorem 5.7, together with results from Sect. 4.2 on logtime leaf languages, gives some more model-theoretic characterizations.

###### Corollary 5.8

1. $`\mathrm{PSPACE}=Q_{\mathrm{CSL}}^0\mathrm{FO}=\mathrm{FO}(Q_{\mathrm{CSL}})`$.
2. $`\mathrm{LOGCFL}=Q_{\mathrm{CFL}}^0\mathrm{FO}=\mathrm{FO}(Q_{\mathrm{CFL}})`$.

* One can show that generally $`\mathrm{Leaf}^{\mathrm{LT}}(B)Q_B^0\mathrm{FO}`$. The corollary then follows from Theorem 4.6.

## 6 Conclusion

We examined a generalized quantifier notion in computational complexity. We proved that not only all quantifiers examined so far (whether in the logarithmic, polynomial, or exponential time context) can be seen as special cases of this quantifier, but also circuits with generalized gates and Turing machines with leaf language acceptance.

Most of the emerging complexity classes can be characterized by means from finite model theory. We gave a precise connection to finite model theory by showing how complexity classes defined by the generalized quantifier relate to classes of finite models defined by logics enhanced with Lindström quantifiers.

A number of questions remain open. The results we gave in Sect. 5 related complexity classes to logics of the form “Lindström quantifier followed by a usual first- or second-order formula.” It is not clear if logics defined by arbitrary nesting of Lindström quantifiers have a nice equivalent in terms of the generalized complexity theoretic quantifier. Barrington, Immerman, and Straubing proved:

###### Theorem 6.1 (\[BIS90\])

Let $`B𝒩`$. Then $`\mathrm{FO}(Q_B^0)=\mathrm{AC}^0[B]`$ ($`\mathrm{AC}^0`$ circuits with $`B`$ gates).

Moreover one can show:

###### Theorem 6.2 (\[Vol96b\])

Let $`B𝒩`$. Then $`\mathrm{FO}(Q_B^1)`$ is the oracle hierarchy given by $`(B)^\mathrm{p}\mathrm{AC}^0`$ as building block.

But the general relationship remains unclear. The work of Makowsky and Pnueli (see \[MP93, MP94\]), Stewart (see e.g. \[Ste91, Ste92\]), and Gottlob (see\[Got95\]) shows that there is a strong relation between Lindström logics and relativized computation. The just mentioned results also hint in that direction. Gottlob \[Got95\] related the expressive power of logics of the form “Lindström quantifier Q followed by first-order formula” to the expressive power of $`\mathrm{FO}(Q)`$. However his results only apply for superclasses of $`\mathrm{L}`$ (logarithmic space). Interesting cases within $`\mathrm{NC}^1`$ remain open. Generally the connection between prenex Lindström logics vs. logics allowing arbitrary quantifier nestings on the model theoretic side, and leaf languages vs. oracle computations on the complexity theoretic side should be made clearer.

It is open for which of the results in Sect. 5.4 the bit predicate is really needed. One can show that without bit, $`Q_{\mathrm{CFL}}\mathrm{FO}=\mathrm{CFL}`$ contrasting the corresponding result with bit given in Corollary 5.8. The power of the bit predicate in this context deserves further attention.

From a complexity theoretic point of view, we think the main open question is the following. A lot of classes defined by leaf languages have been identified. However, most of the results are not about singular leaf languages but about classes of leaf languages. For example (see Theorem 3.3), if we take an arbitrary aperiodic leaf languages, then the complexity class we obtain is included in $`\mathrm{PH}`$, and conversely we get all of $`\mathrm{PH}`$ when we allow aperiodic leaf languages: $`\mathrm{BLeaf}^\mathrm{P}(\mathrm{APERIODIC})=\mathrm{PH}`$. The question now is the following: What exactly are the classes of the form $`\mathrm{BLeaf}^\mathrm{P}(B)`$ for aperiodic $`B`$? Is it possible to come up with a complete list of classes that can be defined in this way? Some of the results in Sect. 3.4.3 point in this direction. For example we know that there is no class between $`\mathrm{P}`$ and $`\mathrm{NP}`$ that can be defined by a regular leaf language (unfortunately the result given in Sect. 3.4.3 holds only for the unbalanced case). Can we come up with similar result for the balanced case? Generally, very little is known about the power of single leaf languages as opposed to classes of leaf languages.

Acknowledgment. For helpful discussions I am grateful to J. Makowsky (Haifa) and H. Schmitz (Würzburg).