Extensional Uniformity for Boolean Circuits

Abstract

Imposing an extensional uniformity condition on a non-uniform circuit complexity class C means simply intersecting C with a uniform class L. By contrast, the usual intensional uniformity conditions require that a resource-bounded machine be able to exhibit the circuits in the circuit family defining C. We say that (C,L) has the "Uniformity Duality Property" if the extensionally uniform class C \cap L can be captured intensionally by means of adding so-called "L-numerical predicates" to the first-order descriptive complexity apparatus describing the connection language of the circuit family defining C. This paper exhibits positive instances and negative instances of the Uniformity Duality Property.

Full text

arXiv:0805.4072v2 [cs.LO] 28 May 2008
Extensional Uniformity for Boolean Circuits∗
Pierre McKenzie1, Michael Thomas2, and Heribert Vollmer2
1D´ep. d’informatique et de recherche op´erationnelle, Universit´e de Montr´eal,
C.P. 6128, succ. Centre-Ville, Montr´eal (Qu´ebec), H3C 3J7 Canada
mckenzie@iro.umontreal.ca
2Institut f¨ur Theoretische Informatik, Leibniz Universit¨at Hannover, Appelstr. 4,
30167 Hannover, Germany
{thomas,vollmer}@thi.uni-hannover.de
Abstract Imposing an extensional uniformity condition on a non-uni-
form circuit complexity class Cmeans simply intersecting Cwith a uni-
form class L. By contrast, the usual intensional uniformity conditions
require that a resource-bounded machine be able to exhibit the circuits
in the circuit family defining C. We say that (C,L) has the Uniformity
Duality Property if the extensionally uniform class C ∩ L can be captured
intensionally by means of adding so-called L-numerical predicates to the
first-order descriptive complexity apparatus describing the connection
language of the circuit family defining C.
This paper exhibits positive instances and negative instances of the Uni-
formity Duality Property.
Keywords. Boolean circuits, uniformity, descriptive complexity
1 Introduction
A family {Cn}n≥1of Boolean circuits is uniform if the way in which Cn+1 can
differ from Cnis restricted. Generally, uniformity is imposed by requiring that
some form of a resource-bounded constructor on input nbe able to fully or
partially describe Cn(see [8,21,1,5,14] or refer to [24] for an overview). Circuit-
based language classes can then be compared with classes that are based on a
finite computing mechanism such as a Turing machine.
Recall the gist of descriptive complexity. Consider the set of words w∈ {a, b}⋆
having no bat an even position. This language is described by the FO[<, Even]
formula ¬∃iEven(i)∧Pb(i). In such a first-order formula, the variables range
over positions in w, a predicate Pσfor σ∈ {a, b}holds at iiff wi=σ, and a
numerical predicate, such as the obvious 1-ary Even predicate here, holds at its
arguments iff these arguments fulfill the specific relation.
The following viewpoint has emerged [5,3,6] over two decades: when a circuit-
based language class is characterized using first-order descriptive complexity, the
circuit uniformity conditions spring up in the logic in the form of restrictions on
the set of numerical predicates allowed.
∗Supported in part by DFG VO 630/6-1, by the NSERC of Canada and by the
(Qu´ebec) FQRNT.

As a well studied example [12,5], FO[<, +,×] = DLOGTIME-uniform AC0(
non-uniform AC0= FO[arb], where the latter class is the class of languages
definable by first-order formulae entitled to arbitrary numerical predicates (we
use a logic and the set of languages it captures interchangeably when this brings
no confusion).
In a related vein but with a different emphasis, Straubing [23] presents a
beautiful account of the relationship between automata theory, formal logic and
(non-uniform) circuit complexity. Straubing concludes by expressing the proven
fact that AC0(ACC0and the celebrated conjectures that AC0[q](ACC0and
that ACC0(NC1as instances of the following conjecture concerning the class
REG of regular languages:
Q[arb]∩REG = Q[reg].(1)
In Straubing’s instances, Qis an appropriate set of quantifiers chosen from
{∃} ∪ {∃(q,r): 0 ≤r < q}and reg is the set of regular numerical predicates,
that is, the set of those numerical predicates of arbitrary arity definable in a
formal sense by finite automata. We stress the point of view that intersecting
{∃}[arb] = FO[arb] with REG to form FO[arb]∩REG in conjecture (1) amounts
to imposing uniformity on the non-uniform class FO[arb]. And once again, im-
posing uniformity has the effect of restricting the numerical predicates: it is a
proven fact that FO[arb]∩REG = FO[reg], and conjecture (1) expresses the
hope that this phenomenon extends from {∃} to other Q, which would determine
much of the internal structure of NC1. We ask:
1. Does the duality between uniformity in a circuit-based class and numerical
predicates in its logical characterization extend beyond NC1?
2. What would play the role of the regular numerical predicates in such a
duality?
3. Could such a duality help understanding classes such as the context-free
languages in AC0?
To tackle the first question, we note that intersecting with REG is just one
out of many possible ways in which one can “impose uniformity”. Indeed, if Lis
any uniform language class, one can replace Q[arb]∩REG by Q[arb]∩ L to get
another uniform subclass of Q[arb]. For example, consider any “formal language
class” (in the loose terminology used by Lange when discussing language theory
versus complexity theory [14]), such as the class CFL of context-free languages.
Undoubtedly, CFL is a uniform class of languages. Therefore, the class Q[arb]∩
CFL is another uniform class well worth comparing with Q[<, +] or Q[<, +,×].
Of course, FO[arb]∩CFL is none other than the poorly understood class AC0∩
CFL, and when Qis a quantifier given by some word problem of a nonsolvable
group, (FO+{Q})[arb]∩CFL is the poorly understood class NC1∩CFL alluded
to 20 years ago [11].
The present paper thus considers classes Q[arb]∩ L for various Qand L. To
explain its title, we note that the constructor-based approach defines uniform
classes by specifying their properties: such definitions are intensional definitions.
By contrast, viewing Q[arb]∩REG as a uniform class amounts to an extensional
2

definition, namely one that selects the members of Q[arb] that will collectively
form the uniform class. In this paper we set up the extensional uniformity frame-
work and we study classes Q[arb]∩ L for Q ⊇ {∃}.
Certainly, the uniform class Lwill determine the class of numerical predicates
we have to use when trying to capture Q[arb]∩L, as Straubing does for L= REG,
as an intensionally uniform class. A contribution of this paper is to provide a
meaningful definition for the set LNof L-numerical predicates. Informally, LN
is the set of relations over the natural numbers that are definable in the sense
of Straubing [23, Section III.2] by a language over a singleton alphabet drawn
from L. When Lis REG, the L-numerical predicates are precisely Straubing’s
regular numerical predicates.
Fix a set Qof monoidal or groupoidal quantifiers in the sense of [5,24,16].
(As prototypical examples, the reader unfamiliar with such quantifiers may think
of the usual existential and universal quantifiers, of Straubing’s “there exist r
modulo q” quantifiers, or of threshold quantifiers such as “there exist a majority”
or “there exist at least t”). We propose the Uniformity Duality Property for
(Q,L) as a natural generalization of conjecture (1):
Uniformity Duality Property for (Q,L):
Q[arb]∩ L =Q[<, LN]∩ L.
Barrington, Immerman and Straubing [5] have shown that Q[arb] equals
AC0[Q], that is, non-uniform AC0with Qgates. Behle and Lange [6] have shown
that Q[<, LN] equals FO[<, LN]-uniform AC0[Q], that is, uniform AC0[Q] where
the direct connection language of the circuit families can be described by means
of the logic FO[<, LN]. Hence the Uniformity Duality Property can be restated
in circuit complexity-theoretic terms as follows:
Uniformity Duality Property for (Q,L), 2nd form:
AC0[Q]∩ L = FO[<, LN]-uniform AC0[Q]∩ L.
By definition, Q[arb]∩L ⊇ Q[<, LN]∩L. The critical question is whether the
reverse inclusion holds. Intuitively, the Uniformity Duality Property states that
the “extensional uniformity induced by intersecting Q[arb] with L” is a strong
enough restriction imposed on Q[arb] to permit expressing the uniform class
using the L-numerical predicates, or in other words: the extensional uniformity
given by intersecting the non-uniform class with Lcoincides with the intensional
uniformity condition given by first-order logic with L-numerical predicates. Fur-
ther motivation for this definition of Q[<, LN]∩ L is as follows:
–when constructors serve to define uniform classes, they have access to input
lengths but not to the inputs themselves; a convenient logical analog to this
is to use the unary alphabet languages from Las a basis for defining the
extra numerical predicates
–if the closure properties of Ldiffer from the closure properties of Q[arb], then
Q[arb]∩ L =Q[<, LN] may fail trivially (this occurs for example when L=
CFL and Q={∃} since the non-context-free language {anbncn:n≥0}is
3

easily seen to belong to Q[<, LN] by closure under intersection of the latter);
hence intersecting Q[<, LN] with Lbefore comparing it with Q[arb]∩ L is
necessary to obtain a reasonable generalization of Straubing’s conjecture for
classes Lthat are not Boolean-closed.
We now state our results, classified, loosely, as foundational observations (F)
or technical statements (T). We let Lbe any class of languages.
(F) By design, the Uniformity Duality Property for (Q,REG) is precisely Strau-
bing’s conjecture (1), hence its conjectured validity holds the key to the
internal structure of NC1.
(F) The Uniformity Duality Property for ({∃},NEUTRAL) is precisely the Crane
Beach Conjecture [4]; here, NEUTRAL is the class of languages Lthat have
a neutral letter, i.e., a letter ethat may be arbitrarily inserted into or deleted
from words without changing membership in L. The Crane Beach conjecture,
stating that any neutral letter language in AC0= FO[arb] can be expressed
in FO[<], was motivated by attempts to develop a purely automata-theoretic
proof that Parity, a neutral letter language, is not in AC0. The Crane Beach
Conjecture was ultimately refuted [4], but several of its variants have been
studied. Thus [4]:
–the Uniformity Duality Property for ({∃},NEUTRAL) fails
–the Uniformity Duality Property for ({∃},NEUTRAL ∩REG) holds
–the Uniformity Duality Property for ({∃},NEUTRAL ∩ {two-letter lan-
guages}) holds.
(T) Our definition for the set LNof L-numerical predicates parallels Straubing’s
definition of regular numerical predicates. For kernel-closed language classes
Lthat are closed under homomorphisms, inverse homomorphisms and in-
tersection with a regular language, we furthermore characterize LNas the
set of predicates expressible as one generalized unary L-quantifier applied to
an FO[<]-formula. (Intuitively, L-numerical predicates are those predicates
definable in first-order logic with one “oracle call” to a language from L.)
(T) We characterize the numerical predicates that surround the context-free lan-
guages: first-order combinations of CFLNsuffice to capture all semilinear
predicates over N; in particular, FO[<, +] = FO[DCFLN] = FO[BC(CFL)N],
where DCFL denotes the deterministic context-free languages and BC(CFL)
is the Boolean closure of CFL.
(T) We deduce that, despite the fact that FO[BC(CFL)N] contains all the semi-
linear relations, the Uniformity Duality Property fails for ({∃},L) in each of
the following cases:
–L= CFL
–L= VPL, the “visibly pushdown languages” recently introduced by [2]
–L= Boolean closure of the deterministic context-free languages
–L= Boolean closure of the linear context-free languages
–L= Boolean closure of the context-free languages.
The crux of the justifications of these negative results is a proof that the com-
plement of the “Immerman language”, used in disproving the Crane Beach
Conjecture, is context-free.
4

(T) At the opposite end of the spectrum, while it is clear that the Uniformity
Duality Property holds for the set of all languages and any Q, we show that
the Uniformity Duality Property already holds for (Q,L) whenever Qis a
set of groupoidal quantifiers and L= NTIME(n)L; thus it holds for, e. g., the
rudimentary languages, DSPACE(n), CSL and PSPACE.
The rest of this paper is organized as follows. Section 2 contains preliminaries.
Section 3 defines the L-numerical predicates and introduces the Uniformity Du-
ality Property formally. The context-free numerical predicates are investigated
in Section 4, and the duality property for classes of context-free languages is
considered in Section 5. Section 6 shows that the duality property holds when
Lis “large enough”. Section 7 concludes with a summary and a discussion.
2 Preliminaries
2.1 Complexity Theory
We assume familiarity with standard notions in formal languages, automata and
complexity theory.
When dealing with circuit complexity classes, all references will be made
to the non-uniform versions unless otherwise stated. Thus AC0refers of the
Boolean functions computed by constant-depth polynomial-size unbounded-fan-
in {∨,∧,¬}-circuits. And DLOGTIME-uniform AC0refers to the set of those
functions in AC0computable by a circuit family having a direct connection lan-
guage decidable in time O(log n) on a deterministic Turing machine (cf. [5,24]).
2.2 First-Order Logic
Let Nbe the natural numbers {1,2,3,...}and let N0=N∪ {0}. A signature
σis a finite set of relation symbols with fixed arity and constant symbols. A
σ-structure A=hUA, σAiconsists of a set UA, called universe, and a set σA
that contains an interpretation RA⊆(UA)kfor each k-ary relation symbol
R∈σ. We fix the interpretations of the “standard” numerical predicates <, +,
×, etc. to their natural interpretations. By Bit we will denote the binary relation
{(x, i)∈N2: bit iin the binary representation of xis 1}. For logics over strings
with alphabet Σ, we will use signatures extending σΣ={Pa:a∈Σ}and
identify w=w1···wn∈Σ⋆with Aw=h{1,...,n}, σAw}i, where PAw
a={i∈
N:wi=a}for all a∈Σ. We will not distinguish between a relation symbol
and its interpretation, when the meaning is clear from the context.
Let Qbe a set of (first-order) quantifiers. We denote by Q[σ] the set of first-
order formulae over σusing quantifiers from Qonly. The set of all Q[σ]-formulae
will be referred to as the logic Q[σ]. In case Q={∃} (Q={∃} ∪ Q′}), we will
also write FO[σ] (FO+Q′[σ], respectively). When discussing logics over strings,
we will omit the relation symbols from σΣ.
Say that a language L⊆Σ⋆is definable in a logic Q[σ] if there exists a
Q[σ]-formula ϕsuch that Aw|=ϕ⇐⇒ w∈Lfor all w∈Σ⋆, and say that a
5

relation R⊆Nnis definable by a Q[σ]-formula if there exists a formula ϕwith
free variables x1,...,xnthat defines Rfor all sufficiently large initial segment of
N, i. e., if h{1, . . . , m}, σi |=ϕ(c1,...,cn)⇐⇒ (c1,...,cn)∈Rfor all m≥cmax,
where cmax = max{c1,...,cn}[22, Section 3.1]. By abuse of notation, we will
write L∈ Q[σ] (or R∈ Q[σ]) to express that a language L(a relation R, resp.) is
definable by a Q[σ]-formula and use a logic and the set of languages and relations
it defines interchangeably.
3 The Uniformity Duality Property
In order to generalize conjecture (1), we propose Definition 3.2 as a simple gen-
eralization of the regular numerical predicates defined using V-structures by
Straubing [23, Section III.2].
Definition 3.1. Let Vn={x1,...,xn}be a nonempty set of variables and let
Σbe a finite alphabet. A Vn-structure is a sequence
w= (a1, V1)···(am, Vm)∈(Σ×P(Vn))⋆
such that a1,...,am∈Σand the nonempty sets among V1,...,Vmform a par-
tition of Vn(the underscore distinguishes Vn-structures from ordinary strings).
Define Γn={0} × P(Vn). We say that a Vn-structure wis unary if w∈Γ⋆
n,
i. e., if a1···anis defined over the singleton alphabet {0}; in that case, we de-
fine the kernel of w,kern(w), as the maximal prefix of wthat does not end
with (0,∅); to signify that xi∈Vcifor all 1≤i≤n, we also write kern(w)as
[x1=c1,...,xn=cn]and we let wNstand for (c1,...,cn).
We define Strucnas the language of all such words in Γ⋆
nthat are unary
Vn-structures and let Struc = Sn>0Strucn.
Any set Lof unary Vn-structures naturally prescribes a relation over the
natural numbers. Hence, a set of such Lprescribes a set of relations, or numerical
predicates, over N.
Definition 3.2. Let L⊆Γ⋆
nbe a unary Vn-language, that is, a set of unary
Vn-structures. Let LN={wN:w∈L}denote the relation over Nndefined by L.
Then the L-numerical predicates are defined as
LN={LN:L∈ L and L⊆Struc}.
We say that a language Lis kernel-closed if, for every w∈L,kern(w)∈L. We
further say that a language class Lis kernel-closed if, for every L∈ L there
exists an L′∈ L such that LN=L′Nand L′is kernel-closed.
Remark 3.3. A unary Vn-language Ldefines a unique numerical relation LN.
Conversely, if two unary Vn-structures vand wdefine the same tuple vN=wN,
then one of the two is obtained from the other by padding on the right with
the letter (0,∅), i.e., v∈w(0,∅)⋆or w∈v(0,∅)⋆. Hence a numerical relation R
uniquely determines kern(L) = {kern(w) : w∈L}for any language Lsuch that
R=LN.
6

We point out the following facts, where we write ≡qrfor the unary predicate
{x:x≡rmod q}.
Proposition 3.4. Let APER and NEUTRAL denote the set of aperiodic lan-
guages and the set of languages having a neutral letter respectively. Then
1. APERN= FO[<],
2. REGN= (AC0∩REG)N= FO[<, {≡qr: 0 ≤r < q}] = reg, and
3. NEUTRALN⊆FO[<].
Proof. For part 1, let L∈APER with L⊆Strucn. Define L′= kern(L)·(0,∅)⋆.
We claim that L′is aperiodic. To see this, note that for any language K, any
monoid recognizing Lalso recognizes LK −1={v∈Γ⋆
n:vu ∈Lfor some u∈
K}[20, Proposition 2.5]. Hence L[(0,∅)⋆]−1is aperiodic. But kern(L)⊆L[(0,∅)⋆]−1.
So L′equals L[(0,∅)⋆]−1·(0,∅)⋆and is indeed aperiodic.
Hence there exists a formula ϕ∈FO[<] such that L(ϕ) = L′[19]. Let
ψ(x1,...,xn) be obtained from ϕby replacing each P(0,V )(x), V⊆ Vn, with
Vxi∈Vx=xi∧Vxi/∈Vx6=xi. Then for all w= [x1=c1,...,xn=cn](0,∅)jand
all m≥max{ci: 1 ≤i≤n},
Aw|=ϕ⇐⇒ h{1,...,m}, <Ai |=ψ(c1,...,cn).
Let ~x and ~c abbreviate x1,...,xnand c1,...,cn, respectively, and let cmax =
max{ci: 1 ≤i≤n}. Then
~c ∈LN=⇒ ∃i: [x1=c1,...,xn=cn](0,∅)i∈L
=⇒[x1=c1,...,xn=cn]∈kern(L)
=⇒ ∀i: [x1=c1,...,xn=cn](0,∅)i∈L′
=⇒ ∀i:A[x1=c1,...,xn=cn](0,∅)i|=ϕ
=⇒ ∀m≥cmax :h{1,...,m}, <, =,~ci |=ψ(~x)
and
~c /∈LN=⇒ ∀i: [x1=c1,...,xn=cn](0,∅)i/∈L
=⇒[x1=c1,...,xn=cn]/∈kern(L)
=⇒ ∀i: [x1=c1,...,xn=cn](0,∅)i/∈L′
=⇒ ∀i:A[x1=c1,...,xn=cn](0,∅)i6|=ϕ
=⇒ ∀m≥cmax :h{1,...,m}, <, =,~ci 6|=ψ(~x)
Hence LN={~c ∈Nn: (∀m≥cmax)[h{1,...,m}, <, =,~ci |=ψ(~x)]}. But
ψ(~x)∈FO[<] and therefore LN∈FO[<]. ˆ
A
For the other inclusion, let R∈Nn∩FO[<] via formula ψ(~x). Define ϕ≡
∃x1· · · ∃xnψ(~x)∧χ(~x), where
χ(~x)≡^
1≤i≤n_
V∈P(Vn),
xi∈VP(0,V )(xi)∧ ∀z_
V′∈P(Vn),
xi∈V′P(0,V ′)(z)↔z=xi.
7

The purpose of χ(~x) is to bind the variables in ~x to their respective values in a
corresponding Vn-structure: for a string w= (0, V1)···(0, Vm)∈Γ⋆
nand a tuple
~c,Aw|=χ(~c) holds iff m≥max{ci: 1 ≤i≤n},wis a unary Vn-structure, and
for all 1 ≤i≤n,xi∈Vci. Alike the above equivalence, we obtain
~c ∈R⇐⇒ ∀m≥cmax :h{1,...,m}, <, =,~ci |=ψ(~x)
⇐⇒ ∀i:A[x1=c1,...,xn=cn](0,∅)i|=ϕ.
Let Lbe the unary Vn-language {w∈Strucn:Aw|=ϕ}. Then R=LN=
L(ϕ)Nwith ϕ∈FO[<]. Thus MLis finite and aperiodic and LN∈APERN.
Part 2 follows analogously from [23, Theorems III.1.1 and III.2.1].
For Part 3, let R∈NEUTRALN. Then R=LNfor some neutral letter
language L⊆Strucn. Assume that the neutral letter of Lis (0,∅), otherwise
L⊆Strucnimplies that Lis empty. Since we can insert or delete (0,∅) in any
word at will, Lis fully determined by the (0,∅)-free words it contains, that is,
L=[
(V1,V2,...,Vk) partitions Vn
and (0,V1)(0,V2)···(0,Vk)∈L
(0,∅)⋆(0, V1)(0,∅)⋆(0, V2)···(0,∅)⋆(0, Vk)(0,∅)⋆.
This is a finite union of regular aperiodic languages. Hence Lis regular aperiodic,
and LNis in FO[<] by Part 1.
Having discussed the L-numerical predicates, we can state the property ex-
pressing the dual facets of uniformity, namely, intersecting with an a priori uni-
form class on the one hand, and adding the corresponding numerical predicates
to first-order logics on the other.
Property 3.5 (Uniformity Duality for (Q,L)). Let Qbe a set of quantifiers
and let Lbe a language class, then
Q[arb]∩ L =Q[<, LN]∩ L.
As Q[arb] = AC0[Q] [5] and Q[<, LN] = FO[<, LN]-uniform AC0[Q] [6], the
above property equivalently states that
AC0[Q]∩ L = FO[<, LN]-uniform AC0[Q]∩ L.
As a consequence of Proposition 3.4 (1–2), the Uniformity Duality Property
is equivalent to the instances of the Straubing conjectures obtained by setting
Qand Las we expect, for example Q ⊆ {∃} ∪ {∃(q,r): 0 ≤r < q}and L= REG
yield exactly (1). Similarly, as a consequence of Proposition 3.4 (3), the Unifor-
mity Duality Property is equivalent to the Crane Beach Conjecture if FO[<]⊆ L.
Property 3.5 is thus false when Q={∃} and Lis the set NEUTRAL of all neu-
tral letter languages. For some other classes, the Crane Beach Conjecture and
thus Property 3.5 hold: consider for example the case L= REG ∩NEUTRAL
[4], or the case Q={∃} and L ⊆ NEUTRAL ∩FO[+]. Accordingly the Unifor-
mity Duality Property both generalizes the conjectures of Straubing et al. and
captures the intuition underlying the Crane Beach Conjecture. Encouraged by
this unification, we will take a closer look at the Uniformity Duality in the case
of first-order logic and context-free languages in the next section.
8

In the rest of this section, we present an alternative characterization of LN
using FO[<]-transformations and unary Lindstr¨om quantifiers. This is further
justification for our definition of L-numerical predicates. The reader unfamiliar
with this topic may skip to the end of Section 3.
Digression: Numerical Predicates and Generalized Quantifiers
Generalized or Lindstr¨om quantifiers provide a very general yet coherent ap-
proach to extending the descriptive complexity of first-order logics [17]. Since
we only deal with unary Lindstr¨om quantifiers over strings, we will restrict our
definition to this case.
Definition 3.6. Let ∆={a1,...,at}be an alphabet, ϕ1,...,ϕt−1be FO[<]-
formulae, each with k+ 1 free variables x1, x2,...,xk, y, and let ~x abbreviate
x1, x2,...,xk. Further, let Struct(σ)denote the set of finite structures A=
hUA, σAiover σ. Then ϕ1,...,ϕt−1define an FO[<]-transformation
[ϕ1(~x),...,ϕt−1(~x)]: struct({<, x1,...,xk})→∆⋆
as follows: Let A∈struct({<, x1,...,xk}),xA
i=ci∈ UA,1≤i≤k, and
s=|UA|, then [ϕ1(~x),...,ϕt−1(~x)](A) = v1···vs∈∆⋆, where
vi=




a1,if A|=ϕ1(c1,...,ck, i),
aj,if A|=ϕj(c1,...,ck, i)∧Vj−1
l=1 ¬ϕl(c1,...,ck, i),1< j < t,
at,if A|=Vt−1
l=1 ¬ϕl(c1,...,ck, i).
A language L⊆∆⋆and an FO[<]-transformation [ϕ1(~x),...,ϕt−1(~x)] now nat-
urally define a (unary) Lindstr¨om quantifier Qun
Lvia
A|=Qun
Ly[ϕ1(~x, y),...,ϕt−1(~x, y)] ⇐⇒ [ϕ1(~x),...,ϕt−1(~x)](A)∈L.
Finally, the set of relations definable by formulae Qun
Ly[ϕ1(~x, y),...,ϕt−1(~x, y)],
where L∈ L and ϕ1,...,ϕt−1∈FO[<], will be denoted by Qun
LFO[<].
The notation [ϕ1(~x),...,ϕt−1(~x)] is chosen to distinguish the variables in
~x from y; the variables in ~x are interpreted by Awhereas yis utilized in the
transformation.
Theorem 3.7. Let Lbe a kernel-closed language class which is closed under ho-
momorphisms, inverse homomorphisms and intersection with regular languages,
then LN=Qun
LFO[<]; that is, the L-numerical predicates correspond to the
predicates definable using a unary Lindstr¨om quantifier over Land an FO[<]-
transformation.
Proof. For the inclusion from left to right, consider a relation LN⊆Nnin LNand
let Vn={x1, . . . , xn}. Define the FO[<]-transformation [ϕ1(~x),...,ϕ2n−1(~x)]
from Nnto unary V-structures as follows. For 1 ≤i < 2n, let
ϕi≡^
j∈Vi
(y=xj)∧^
j /∈Vi
(y6=xj),
9

where Videnotes the ith subset of Vin the natural subset ordering, and as-
sociate the letter (0, Vi) with ϕi. Let ~c = (c1,...cn)∈Nnand denote by A
the structure ({1,...,l}, σ) with l= maxi{ci}and {<, x1,...,xn} ⊆ σ. Then
[ϕ1(~x),...,ϕ2n−1(~x)] maps Ato the unary Vn-structure v1···vl. Then
~c ∈LN=⇒ ∃j∃w= [x1=c1,...,xn=cn] : w(0,∅)j∈L
=⇒[x1=c1,...,xn=cn]∈L(since Lis kernel-closed)
=⇒[ϕ1(~x),...,ϕ2n−1(~x)](A)∈L
=⇒A|=Qun
Ly[ϕ1(~x, y),...,ϕ2n−1(~x, y)],
and the reverse implications hold for any unary Vn-language L.
For the opposite inclusion, let R⊆Nn∩ Qun
LFO[<] via the transformation
[ϕ1(~x),...,ϕk−1(~x)] and the language L⊆∆⋆∩ L,|∆|=k. We must exhibit a
unary Vn-language A∈ L such that R=AN, i. e., R=h(kern(A)), where
h:{kern(w) : wis a unary Vn-structure} → Nn
[x1=c1,...,xn=cn]7→ (c1,...,cn).
Our proof is similar to the proof of Nivat’s Theorem, see [16, Theorem 2.4].
Define B⊆Γn×∆⋆to consist of all words u1
v1···ul
vlsuch that u=
u1···ulis the kernel of a unary Vn-structure and [ϕ1(~x),...,ϕk−1(~x)] maps uN
to v=v1···vl. Define the length-preserving homomorphisms f:u
v7→ uand
g:u
v7→ v. Then R= (h◦kern ◦f)B∩g−1(L).
We claim that Bis regular. Theorem 3.7 then follows from the closure prop-
erties of Lby setting A=fB∩g−1(L)
For 1 ≤i≤k−1, let ϕ′
i(y) be defined as ϕ′
i(y)≡ ∃x1···∃xn(ϕi(~x, y)∧ψ(~x)∧
π(~x)), where ψ(~x) and π(~x) bind the variables in ~x to their respective values in a
corresponding unary Vn-structure and asserts that each variable occurs exactly
once; that is,
ψ(~x)≡^
1≤i≤n_
d∈∆_
V∈P(Vn),
xi∈V
P((0,V )
d)(xi),
π(~x)≡^
1≤i≤n
∀z_
d∈∆_
V∈P(Vn),
xi∈V
P((0,V )
d)(z)↔z=xi.
Now let χj(z)≡WV∈P(Vn)P((0,V )
dj)(z),1≤j≤k, where djis the jth letter in ∆.
Then a string u1
v1···ul
vl∈Γn×∆⋆is in Bif and only if u=u1···ulis the
kernel of a unary Vn-structure and
∀zk−1
^
i=1 ϕ′
i(z)∧
i−1
^
l=1
¬ϕ′
l(z)↔χi(z)∧k−1
^
l=1
¬ϕ′
l(z)↔χk(z)
holds on ~z =uN, where the empty conjunction is defined to be true. Concluding,
B∈FO[<]⊂REG.
We stress that the above result provides a logical characterization of the L-
numerical predicates for all kernel-closed classes Lforming a cone, viz. a class
10

of languages Lclosed under homomorphisms, inverse homomorphisms and in-
tersection with regular languages [10]. As the closure under these operations is
equivalent to the closure under rational transductions (i. e., transductions per-
formed by finite automata [7]), we obtain:
Corollary 3.8. Let Lbe kernel-closed and closed under rational transductions,
then LN=Qun
LFO[<].
4 Characterizing the Context-Free Numerical Predicates
In order to examine whether the Uniformity Duality Property for first-order
logics holds in the case of context-free languages, we first need to consider the
counterpart of the regular numerical predicates, that is, CFLN. Our results in
this section will relate CFLNto addition w. r. t. to first-order combinations, and
are based upon a result by Ginsburg [9]. Ginsburg showed that the number
of repetitions per fragment in bounded context-free languages corresponds to
a subset of the semilinear sets. For a start, note that addition is definable in
DCFLN.
Lemma 4.1. Addition is definable in DCFLN.
Proof. Let V3={x1, x2, x3}and L+be a unary Vn-language defining addition,
that is, LN
+={(x1, x2, x3) : x1+x2=x3}. Then L+is recognized by the following
deterministic PDA P= (Q, Γn, ∆, δ, q0,⊥,{qacc}), where Q={q0, qacc},∆=
{⊥,0}and δis defined as follows:
δ(z0,(0,∅), γ) = (z0,0γ)δ(zy,(0,∅), γ) = (zy, γ)
δ(z0,(0,{x}), γ) = (zx,0γ)δ(zy,(0,{x}), γ) = (zxy , γ)
δ(z0,(0,{y}), γ) = (zy,0γ)δ(zxy,(0,∅),0) = (zxy , ε)
δ(zx,(0,∅), γ) = (zx,0γ)δ(zxy,(0,{z}),0) = (zz, ε)
δ(zx,(0,{y}), γ) = (zxy, γ)δ(zz, ε , ⊥) = (zacc,⊥)
where γ∈∆.
Next, we restate the result of Ginsburg in order to prepare ground for the
examination of the context-free numerical predicates. In the following, let w⋆
abbreviate {w}⋆and say that a language L⊆Σ⋆is bounded if there exists an
n∈Nand w1, . . . , wn∈Σ+such that L⊆w⋆
1···w⋆
n.
Definition 4.2. A set R⊆Nn
0is stratified if
1. each element in Rhas at most two non-zero coordinates,
2. there are no integers i, j, k, l and x= (x1,...,xn), x′= (x′
1,...,x′
n)in R
such that 1≤i < j < k < l ≤nand xix′
jxkx′
l6= 0.
Moreover, a set S⊆Nnis said to be stratified semilinear if it is expressible
as a finite union of linear sets, each with a stratified set of periods; that is,
S=Sm
i=1{~αi0+Pni
j=1 k·~αij :k∈N0}, where ~αi0∈Nn,~αij ∈Nn
0,1≤j≤ni,
1≤i≤m, and each Pi={~αij : 1 ≤j≤ni}is stratified.
11

Theorem 4.3 ([9, Theorem 5.4.2]). Let Σbe an alphabet and L⊆w⋆
1···w⋆
n
be bounded by w1,...,wn∈Σ+. Then Lis context-free if and only if the set
E(L) = (e1,...,en)∈Nn
0:we1
1. . . wen
n∈L
is a stratified semilinear set.
Theorem 4.3 relates the bounded context-free languages to a strict subset of
the semilinear sets. The semilinear sets are exactly those sets definable by FO[+]-
formulae. There are however sets in FO[+] that are undefinable in CFLN: e. g., if
R={(x, 2x, 3x) : x∈N}was definable in CFLNthen {anbncn:n∈N} ∈ CFL.
Hence, FO[+] can not be captured by CFLNalone. Yet, addition is definable in
CFLN, therefore we will in the following investigate the relationship between first-
order logic with addition, FO[+], and the Boolean closure of CFL, BC(CFL).
Lemma 4.4. Let R⊆Nnand let R=LNfor language L. Then Lis bounded.
Proof. Let R⊆Nnand Lsuch that R=LN. Let L⊆Γ⋆
n, where Vn=
{x1,...,xn}is a set of variables. Every unary Vn-structure w∈Lof a given
order type t∈Tbelongs to the language
Lt= (0,∅)⋆(0, V1) (0,∅)⋆(0, V2)···(0, Vk) (0,∅)⋆,
where (V1, V2, . . . , Vk) is an ordered partition of Vn. The number pof such ordered
partitions depends on n; in particular, pis finite. Hence L(L⋆
1L⋆
2···L⋆
tp, where
t1, t2,...,tpexhaust the possible types. Since each letter (0, Vi) belongs to the
language QV⊆Vn(0, V )⋆, it follows that L⊆Q1≤i≤pQV⊆Vn(0, V )⋆2n+1.
Lemma 4.5. All bounded context-free languages are definable in FO[+].
Proof. Since Lis bounded, there exist w1,...,wn∈Σ+such that L⊆w⋆
1. . . w⋆
n.
By Theorem 4.3, it holds that the set
E(L) = {(e1,...,en) : we1
1...wen
n∈L}
is stratified semilinear. It follows by semilinearity alone that, for ~e = (e1,...,en),
E(L) = Sm
i=1{~e :~e =~αi0+Pni
j=1 k·~αij , k ∈N0}, where ~αi0∈Nn,~αij ∈Nn
0for
all 1 ≤j≤ni, 1 ≤i≤m. As a consequence, Lis defined via the formula ϕ=
∃e1···∃enϕw1,...,wn(e1,...,en)∧ϕlin(e1,...,en), where ϕw1,...,wn(e1,...,en)
checks whether the input is of the form we1
1···wen
nand
ϕlin(e1, . . . , en)≡
m
_
i=1 ∃ai,1···∃ai,ni
n
^
k=1 ek=αi0k+
ni
X
j=1
aij αijk .
In particular, ϕwe1
1...wen
n∈FO[+]. Concluding, L∈FO[+].
Lemma 4.6. Let Vn={x1,...,xn}and let Lbe a unary Vn-language. Then
L∈FO[+] implies LN∈FO[+].
12

Proof. Since L∈FO[+], there exists a formula ϕ∈FO[+] such that for all
w= (0, V1)··· (0, Vm)∈Γ⋆
n,
h{1,...,m}, <, +,Pi |=ϕ⇐⇒ w∈L,
where P={P(0,V ):V∈P(Vn)}and P(0,V )(z) is true if and only if z∈V,
for 1 ≤z≤m. Let ~y = (y1,...,yn). We construct the formula ϕ′(~y) from ϕby
replacing, for each variable zand each V∈P(Vn), the predicate P(0,V )(z) with
Vyi∈Vz=yi∧Vyi/∈Vz6=yi. Then
h{1, . . . , m}, <, +i |=ϕ′(~y)⇐⇒ h{1,...,m}, <, +,Pi |=ϕ.
Hence the formula ϕ′witnesses LN∈FO[+].
Theorem 4.7. BC(CFLN)⊆BC(CFL)N⊆FO[+].
Proof. The inclusion BC(CFLN)⊆BC(CFL)Nfollows from (1.) the fact that for
every unary Vn-language L∈CFL, there exists an equivalent kernel-closed unary
Vn-language L′∈CFL; (2.) LN
1∩LN
2= (L1∩L2)Nand LN
1∪LN
2= (L1∪L2)Nfor
kernel-closed languages L1, L2; and (3.) the observation that for a kernel-closed
L∈CFL with R=LN, the language L′=L(0,∅)⋆∈CFL also verifies R=L′N,
so that R= (L′∩Strucn)N∈BC(CFL)N.
It remains to show that BC(CFL)N⊆FO[+]. Denote by coCFL set of lan-
guages whose complement is in CFL, i. e., coCFL = {L:L∈CFL}. Let
R⊆BC(CFL)N∩Nnand Vn={x1,...,xn}. Further, let Lbe some unary
Vn-language such that R=LN; w. l. o. g. L=Sm
i=1 Tki
j=1 Lij where Lij ∈
CFL ∪coCFL. It holds that Lis a unary Vn-language if and only if Tki
j=1 Lij is a
unary Vn-language for all 1 ≤i≤m. Hence, we need to show that LN
iis FO[+]-
definable, for any unary Vn-language Li=Tki
j=1 Lij with Lij ∈CFL ∪coCFL.
Note that Strucnis bounded and definable in FO[<]⊂REG. Then Li=
(Li1∩Strucn)∩ · · · ∩ (Lik ∩Strucn) and each (Lij ∩Strucn), 1 ≤j≤k, is
bounded (Lemma 4.4). We have to distinguish the following two cases:
Case 1: Lij ∈CFL. Then Lij ∩Strucn∈CFL. Thus Lemma 4.5 implies Lj∩
Strucn∈FO[+].
Case 2: Lij ∈coCFL. As Lij ∩Strucnis bounded, it can be written as Lij ∩
Strucn={we1
1···wen
n: (e1,...,en)∈X}for words w1, . . . , wnand some
relation X⊆Nn
0. Hence,
Lij ∩Strucn=Lij ∪Strucn= (Lij ∩Strucn)∪Strucn
where Lij ∩Strucnis the intersection of a context-free language with a reg-
ular language and therefore context-free. Further note that Lij ∩Strucn=
{we1
1···wen
n∈Strucn: (e1,...,en)/∈X}is bounded. From Lemma 4.5
it now follows that Lij ∩Strucn∈FO[+]. Thus, finally, Lij ∩Strucn=
(Lij ∩Strucn)∪Strucn∈FO[+].
Summarizing, Li= (Li1∩Strucn)∩ · · · ∩ (Lik ∩Strucn) is definable in FO[+]
using the conjunction of the defining formulae. Since Liis a unary Vn-language
by assumption, Lemma 4.6 implies the claim.
13

That is, the relations definable in the Boolean closure of the context-free
unary Vn-languages are captured by FO[+]. Hence, FO[BC(CFL)N]⊆FO[+].
Now Lemma 4.1 yields the following corollary.
Corollary 4.8. FO[DCFLN] = FO[CFLN] = FO[BC(CFL)N] = FO[+].
We note that in particular, for any k∈N, the inclusion (TkCFL)N(FO[+]
holds, where TkCFL denotes the languages definable as the intersection of ≤k
context-free languages: this is deduced from embedding numerical predicates
derived from the infinite hierarchy of context-free languages by Liu and Weiner
into CFLN[18]. Hence,
CFLN(···((TkCFL)N((Tk+1 CFL)N(···((TCFL)N⊆FO[+].
Unfortunately, we could neither prove nor refute FO[+] ⊆BC(CFL)N. The
difficulty in comparing FO[+] and BC(CFL)Ncomes to some extent from the
restriction on the syntactic representation of tuples in CFL; viz., context-free
languages may only compare distances between variables, whereas the tuples
defined by unary Vn-languages count positions from the beginning of a word.
This difference matters only for language classes that are subject to similar
restrictions as the context-free languages (e. g., the regular languages are not
capable of counting, the context-sensitive languages have the ability to convert
between these two representations). To account for this special behavior, we will
render precisely CFLNin Theorem 4.9.
But there is more to be taken into account. Consider, e. g., the relation R=
{(x, x, x) : x∈N}.Ris clearly definable in CFLN, yet the set E(L) of the
defining language L,LN=R, is not stratified semilinear. Specifically, duplicate
variables and permutations of the variables do not increase the complexity of a
unary Vn-language Lbut affect LN.
Let tbe an order type of ~x = (x1,...,xn) and say that a relation R⊆Nn
has order type tif, for all ~x ∈R,~x has order type t. For ~x of order type t,
let ~x′= (x′
1,...,x′
m), m≤n, denote the variables in ~x with mutually distinct
values and let πtdenote a permutation such that x′
πt(i)< x′
πt(i+1), 1 ≤i < m.
We define functions sort :P(Nn)→P(Nm) and diff :P(Nn)→P(Nn
0) as
sort(R) = πt(~x′) : ~x ∈Rhas order type t,
diff (R) = n(xi)1≤i≤n:i
X
j=1
xj1≤i≤n∈Ro.
The function sort rearranges the components of Rin an ascending order and
eliminates duplicates, whereas diff transforms a tuple (x1,...,xn) with x1<
x2<···< xninto (x1, x2−x1, x3−x2−x1,...,xn−Pn−1
i=1 xi), a representation
more “suitable” to CFL (cf. E(L) in Theorem 4.3).
Theorem 4.9. Let R⊆Nn.R∈CFLNif and only if there exists a partition
R=R1∪ · · · ∪ Rksuch that each diff sort(Ri),1≤i≤k, is a stratified
semilinear set.
14

Proof. For the direction from left to right, let LN∈CFLN,LN⊆Nnand let
t1,...,tpexhaust the possible order types of ~x = (x1,...,xn). As CFL is closed
under intersection with regular languages, Lcan be partitioned into context-free
languages L=Lt1∪ · · · ∪ Ltpsuch that LN
tihas order type ti, 1 ≤i≤p.
Fix any Lti. By design of sort , it holds that x1< x2<··· < xmfor all
(x1,...,xm)∈sort (LN
ti), hence diff sort(LN
ti)∈Nm
0is defined. Since ~x has
order type tifor all ~x ∈Lti,sort(LN
ti) = (ϕ(Lti))Nfor a homomorphism ϕ
substituting the characters (0, V ), V6=∅, with appropriate (0, V ′). We thus
obtain that sort(LN
ti)∈CFLN. Say AN=sort(LN
ti) for the context-free unary Vn-
language A, then Theorem 4.3 implies that the set E(A) is a stratified semilinear
set. Consider the finite state transducer Tin Figure 1. Tdefines the rational
(0,{x1})/a1(0,{x2})/a2(0,{xm−1})/am−1(0,{xm})/am
(0,∅)/a1(0,∅)/a2(0,∅)/am(0,∅)/e
Figure 1. Transducer T
transduction ψ:Γ⋆
n→ {a1,...,am,e}⋆,ψ(w) = v1···vs, where w=w1···ws,
|w|=s, is the given unary Vn-structure and, for 1 ≤i≤s, 1 ≤j≤m,
vi=(aj,if wi···ws= (0,∅)l(0,{xj})ufor some l∈N0, u ∈Γ⋆
n,
e,if w1···wi(0,∅)l=wfor some l∈N0.
We claim that diff sort(LN
ti)=Eψ(A). The claim concludes the direction
from left to right, since ψ(A)∈CFL due to the closure of CFL under rational
transductions.
Claim. Let A∈CFL such that AN=sort(LN
ti), then diff sort(LN
ti)=Eψ(A).
To prove the claim, let Vn={x1,...,xm}and let A∈CFL be a unary
Vn-language such that AN=sort (LN
ti). Fix an arbitrary ~c = (c1,...,cm)∈AN
and choose w∈Asuch that wN=~c. Then c1< c2<···< cmand
w= (0,∅)c1−1(0,{x1})(0,∅)c2−c1−1(0,{x2})···
(0,∅)cm−Pm−1
i=1 ci−1(0,{xm})(0,∅)d,
where d=|w| − cm. Hence ψ(w) = ac1
1ac2−c1
2···acm−Pm−1
i=1 ci
medand
Eψ({w})=nc1, c2−c1,...,cm−
m−1
X
i=1
cio.
On the other hand, diff ({~c}) = {(c1, c2−c1,...,cm−Pm−1
i=1 ci)}. Thus, for
every ~c ∈sort(LN
ti), Eψ({~c})=diff ({~c}) and diff sort(LN
ti)=Eψ(A).
This implies the claim and concludes the direction from left to right.
15

For the direction from right to left, it suffices to show that Ri∈CFLNfor
each 1 ≤i≤k. By assumption, diff sort (Ri)⊆Nm
0is a stratified semilin-
ear set. Thence there exists a bounded language A∈CFL such that E(A) =
diff sort(Ri). Let Aw. l. o. g. be bounded by a1,...,am∈Σ, i. e., A⊆a⋆
1···a⋆
m.
Define the rational transduction χ:{a1,...,am}⋆→Γ⋆
nas χ(w) = v1···vs,
where w=w1···ws,|w|=s, and, for 1 ≤i≤s, 1 ≤j≤m,
vi=((0,{xj}),if i=sand wi= ajor i < s and wi= aj6=wi+1 ,
(0,∅) if i < s and wi=wi+1 .
Note that (ψ◦χ)(w) = wfor all w∈A. An argument analogous to the above
claim thus yields E(A) = Eψ(χ(A))=diff (χ(A))Nand sort(Ri) = (χ(A))N.
In particular, (χ(A))N∈CFLN.
Moreover, c1< c2<··· < cmfor all ~c = (c1,...,cm)∈(χ(A))N, thus there
exists a function π:{1,...,n} → {1,...,m},n≥m, such that
(xπ(1),...,xπ(n)) : (x1,...,xm)∈(χ(A))N=Ri.
Let the homomorphism φ:Γ⋆
n→Γ⋆
nmimic the above transformation by replac-
ing (0,{xi}) with (0, Vi), where Vi={xj: 1 ≤j≤n, π(j) = i}, 1 ≤i≤m.
Then Ri=(φ◦χ)(A)N∈CFLN.
5 The Uniformity Duality and Context-Free Languages
Due to the previous section, we may express the Uniformity Duality Property for
context-free languages using Corollary 4.8 in the following more intuitive way: let
Q={∃} and Lbe such that FO[LN] = FO[<, +] (e. g., DCFL ⊆ L ⊆ BC(CFL)),
then the Uniformity Duality Property for ({∃},L) is equivalent to
FO[arb]∩ L = FO[<, +] ∩ L.(2)
We will hence examine whether (2) holds, and see that this is not the case.
For a binary word u=un−1un−2···u0∈ {0,1}⋆, we write bufor the integer
un−12n−1+···+ 2u1+u0. Recall the Immerman language LI⊆ {0,1,a}⋆, that
is, the language consisting of all words of the form
x1ax2a··· ax2n,
where xi∈ {0,1}n,bxi+ 1 = bxi+1 , 1 ≤i < 2n, and x1= 0n,x2n= 1n. For exam-
ple, 00a01a10a11 ∈LIand 000a001a010a011a100a101a110a111 ∈LI. We prove
that despite its definition involving arithmetic, LIis simply the complement of
a context-free language.
Lemma 5.1. The complement LIof the Immerman language is context-free.
Proof. Let Σ={0,1,a}. Throughout this proof, uand vstand for binary words.
Claim. Let u=un−1un−2···u0, v =vn−1vn−2···v0and u06=v0. Then
bu+ 1 = bv(mod 2n) (3)
iff none of the words u1u0v1v0, u2u1v2v1,..., un−1un−2vn−1vn−2belongs to
{0010,0011,0100,0111,1001,1000,1110,1101}.(4)
16

The claim implies that the following language is context-free:
A={xuavy :x∈Σ⋆, y ∈Σ⋆,|u|=|v|,bu+ 1 6=bv(mod 2|u|)}.
Note that {xuavy :x∈(Σ⋆a)⋆, y ∈(aΣ⋆)⋆,|u|=|v|,bu+ 1 6=bv(mod 2|u|)} ⊂
A⊂LI. Hence Adoes not catch all the words in LI, but it catches all the
words of the correct “form” which violate the successor condition (modulo 2|u|).
For example, Acatches 00a01a11a11a, but it does not catch a nor 0a1a0a1
nor 01a10a11a00 nor 00a01a10a11a00a01 nor 00a01001a10a11. We complete the
proof by expressing LIas follows:
LI=A∪a⋆∪Σ⋆a0⋆aΣ⋆∪Σ⋆a1⋆aΣ⋆∪
{0,1}⋆1Σ⋆∪Σ⋆0{0,1}⋆∪S|u|6=|v|(Σ⋆a)⋆uav(aΣ⋆)⋆.(5)
Now we prove the claim. The direction from left to right is easy: if any word
uiui−1vivi−1belongs to the forbidden set (4) then (3) trivially fails. For the
converse, we must prove that if no forbidden word occurs then (3) holds. We
prove this by induction on the common length nof the words uand v. When
n= 1, u0and v06=u0are successors modulo 2. So suppose that n≥1 and that
none of the forbidden words occurs in the pair (unu, vnv), where un, vn∈ {0,1},
u=un−1···u1u0and v=vn−1···v1v0and u06=v0. Then by induction, bu+1 =
bv(mod 2n). There are four cases to be treated:
Case 1: un−1=vn−1= 0. Then no overflow into unoccurs when 1 is added to
buto obtain bv. Since the forbidden words leave only un=vnas possibilities,
dunu+ 1 = dvnv.
Case 2: un−1=vn−1= 1. Analogous.
Case 3: 0 = un−16=vn−1= 1. Analogous.
Case 4: 1 = un−16=vn−1= 0. This is an interesting case. The fact that bu+1 = bv
(mod 2n) implies that u= 1nand v= 0n. Now the forbidden words imply
un6=vn. This means that either unu= 01nand vnv= 10n, or unu= 1n+1
and vnv= 0n+1. In the former case, dunu+ 1 = dvnv, and in the latter case,
dunu+ 1 = dvnv(mod 2n+1).
For a language L⊆Σ⋆, let Neutral(L) denote Lsupplemented with a neutral
letter e /∈Σ, i.e., Neutral(L) consists of all words in Lwith possibly arbitrary
repeated insertions of the neutral letter.
Theorem 5.2. FO[arb]∩BC(CFL) )FO[<, +] ∩BC(CFL).
Proof. From the Crane Beach Conjecture by Barrington et al. [4, Lemma 5.4],
we know that Neutral(LI)∈FO[arb]\FO[<, +] . So we are done if we can
show Neutral(LI)∈BC(CFL). We proved in Lemma 5.1 that LI={0,1,a}⋆\
LIis context-free. Therefore Neutral(LI) is context-free. Now, for any we∈
{0,1,a,e}⋆, let w∈ {0,1,a}⋆be the word obtained by deleting all occurrences
of the neutral letter e from we. Then for any we,
we∈Neutral(LI)⇐⇒ w∈LI⇐⇒ w /∈LI⇐⇒ we/∈Neutral(LI).
In other words, Neutral(LI) = {0,1,a,e}⋆\Neutral(LI) = Neutral(LI) and thus
Neutral(LI)∈BC(CFL).
17

Theorem 5.2 implies that the Uniformity Duality Property fails for Q={∃}
and L= BC(CFL), since FO[<, BC(CFL)N] = FO[<, +]. Yet, it even provides
a witness for the failure of the duality property in the case of L= CFL, as the
context-free language Neutral(LI) lies in FO[arb]\FO[<, +]. We will state this
result as a corollary further below. For now, consider the modified Immerman
language RIdefined as LIexcept that the successive binary words are reversed
in alternance, i. e.,
RI={. . . , 000a(001)Ra010a(011)Ra100a(101)Ra110a(111)R,...}.
RIis the intersection of two deterministic context-free languages. Even more, the
argument in Lemma 5.1 can actually be extended to prove that the complement
of RIis a linear CFL. Hence,
Theorem 5.3. 1. FO[arb]∩BC(DCFL) )FO[<, +] ∩BC(DCFL).
2. FO[arb]∩BC(LinCFL) )FO[<, +] ∩BC(LinCFL).
Proof. For the first claim, observe that Neutral(RI)/∈FO[<, +], because FO[<, +]
has the Crane Beach Property and RI/∈REG. On the other hand, Neutral(RI)∈
FO[arb]; and since RI∈BC(DCFL), Neutral(RI)∈BC(DCFL).
For the second claim, RIcan be expressed analogously to LIby substituting
Awith an appropriate set A′in (5). Further, for uav∈Σ⋆with binary words
uand v, the conditions c
uR+ 1 6=bv(mod 2|u|) and bu+ 1 6=c
vR(mod 2|u|) can
be checked by a linear CFL. Since the linear context-free languages are closed
under finite union, the claim follows.
The role of neutral letters in the above theorems suggests taking a closer look
at Neutral(CFL). As the Uniformity Duality Property for ({∃},Neutral(CFL))
would have it, all neutral-letter context-free languages in AC0would be regular
and aperiodic. This is, however, not the case as witnessed by Neutral(LI). Hence,
Corollary 5.4. In the case of Q={∃}, the Uniformity Duality Property fails
in all of the following cases.
1. L= CFL,
2. L= BC(CFL),
3. L= BC(DCFL),
4. L= BC(LinCFL),
5. L= Neutral(CFL).
Remark 5.5. The class VPL of visibly pushdown languages [2] has gained promi-
nence recently because it shares with REG many useful properties. But despite
having access to a stack, the VPL-numerical predicates coincide with REGN, for
each word may only contain constantly many characters different from (0,∅).
It follows that the Uniformity Duality Property fails for VPL and first-order
quantifiers: consider, e. g., L={anbn:n > 0} ∈ FO[arb]∩(VPL \REG) then
L∈FO[arb]∩VPL but L /∈FO[<, VPLN]∩VPL.
18

6 The Duality in Higher Classes
We have seen that the context-free languages do not exhibit our conjectured
Uniformity Duality. In this section we will show that the Uniformity Duality
Property holds if the extensional uniformity condition imposed by intersecting
with Lis quite loose, in other words, if the language class Lis powerful.
Recall the notion of non-uniformity introduced by Karp and Lipton [13].
Definition 6.1. For a complexity class L, denote by L/poly the class Lwith
polynomial advice. That is, L/poly is the class of all languages Lsuch that, for
each L, there is a function f:N→ {0,1}⋆with
1. |f(x)| ≤ p(|x|), for all x, and
2. Lf={hx, f (|x|)i:x∈L} ∈ L,
where pis a polynomial depending on L. Without loss of generality, we will
assume |f(x)|=|x|kfor some k∈N.
Note that, using the above notation, DLOGTIME-uniform AC0/poly = AC0.
As we further need to make the advice strings accessible in a logic, we define the
following predicates.
Following [5], we say that a Lindstr¨om quantifier QLis groupoidal, if L∈
CFL.
Definition 6.2. Let Qbe any set of groupoidal quantifiers. Further, let L∈
DLOGTIME-uniform AC0[Q]/poly and let fbe the function for which Lf∈
DLOGTIME-uniform AC0[Q]. Let r= 2kl + 1, where kand lare chosen such
that the circuit family recognizing Lin DLOGTIME-uniform AC0has size nl
and |f(x)|=|x|k. We define Advicef
L,Q∈FO+Q[arb]to be the ternary relation
Advicef
L,Q={(i, n, nr) : bit iof f(n)equals 1},
and denote the set of all relations Advicef
L,Q, for L∈ L, by AdviceL,Q.
The intention of Advicef
L,Qis to encode the advice string as a numerical
relation. A point in this definition that will become clear later is the third argu-
ment of the Advicef
L,Q-predicate; it will pad words in the corresponding unary
Vn-language to the length of the advice string. This padding will be required for
Theorem 6.4.
Theorem 6.3. Let Lbe a language class and Qbe a set of groupoidal quantifiers.
Then the Uniformity Duality Property for ({∃} ∪ Q,L)holds if Bit ∈ LNand
AdviceL,Q∈ LN.
Proof. Let Lbe a language class that satisfies the requirements of the claim. We
have to show that FO+Q[arb]∩ L = FO+Q[<, LN]∩ L.
The inclusion from right to left is trivial. For the other direction, let L∈
FO+Q[arb]∩ L. Without loss of generality, we assume L⊆ {0,1}⋆. In [5],
19

Barrington et al. state that FO+Q[arb] = FO+Q[Bit]/poly = DLOGTIME-
uniform AC0[Q]/poly for arbitrary sets Qof monoidal quantifiers, but what is
needed in fact is only the existence of a neutral element, which is given in our
case. There hence exists a polynomial p(n) = nk,k∈N, a function fwith
|f(x)|=p(|x|), and a DLOGTIME-uniform circuit family {Cm}m>0that recog-
nizes Lf. From {Cm}m>0, we construct a formula ϕ∈FO+Q[<, LN], essentially
replacing the advice input gates with the relation Advicef
L,Q.
Let x1,...,xn, y1,...,ynkdenote the input gates of circuit Cm,m > 0, where
x1···xn=xand y1···ynk=f(|x|). First canonically transform {Cm}m>0into
a formula ϕ′over an extended vocabulary σthat satisfies L(ϕ′) = L(cf. [5, The-
orem 9.1], [23, Theorem IX.2.1] or [24, Theorem 4.73] for the construction of ϕ′).
Let l∈Nbe such that nlis a size bound on {Cm}m>0. Then the transformation
encodes gates as l-tuples of variables over {1,...,n}and ensures the correct
structure using additional predicate symbols Pred,Input0,Input1,Output,
And,Or,Not and predicates QuantQfor the subset of oracle gates from Q
used in Cm. For example, the relation Pred holds on a tuple (z1,...,z2l) iff
the gate encoded by (z1,...,zl) is a predecessor of (zl+1,...,z2l); and each of
remaining predicates holds on a tuple (z1,...,zl) iff (z1,...,zl) encodes a gate
of the corresponding type. Note that each relation in σis definable in FO[<, LN],
as DLOGTIME ⊆FO[Bit]⊆FO[<, LN].
Next, replace the relations Input0 and Input1 corresponding to the input
gates yi, 1 ≤i≤nk, with the respective advice predicates from Definition 6.2,
¬Advicef
L,Q(i, n, nr) and Advicef
L,Q(i, n, nr);
both of which are definable in LNby assumption. In the resulting formula, replace
the remaining predicates besides <and Bit by their defining FO+Q[<, LN]-
formulae and eventually obtain a formula defining L∈FO+Q[<, LN].
We can now give a lower bound beyond which the Uniformity Duality Prop-
erty holds. Let NTIME(n)Ldenote the class of languages decidable in linear
time by nondeterministic Turing machines with oracles from L.
Theorem 6.4. Let Qbe any set of groupoidal quantifiers and suppose L=
NTIME(n)L. Then the Uniformity Duality Property for ({∃} ∪ Q,L) holds.
Proof. Choose any L∈AC0[Q]∩L and let fbe an advice function for which Lf∈
DLOGTIME-uniform AC0[Q]. We have to show that the relation Advicef
L,Qis
definable in LN. Let k∈Nsuch that |f(x)|=|x|kand denote by {Cm}m>0the
DLOGTIME-uniform circuit family of size ≤nlthat recognizes Lfusing oracle
gates from Q. Let Nbe a nondeterministic linear-time Turing machine deciding
Lusing some oracle L′∈ L.
We will define a nondeterministic Turing machine Mthat decides x∈LAdv,
where LAdv is such that LN
Adv =ADVICEf
L,Q. Given input x,Mproceeds as
follows:
1if xis not of the form x= [x1=i, x2=n, x3=nr] for some
n > 0 and 1 ≤i≤n
20

2then reject;
3for all strings aof length nkin lexicographic ordering do
4t←true;
5for all inputs yof length ndo
6if the output of Cn+nkon ywith advice acontradicts the result of
Non y
7then t←false;
8if t=true and bit iof ais 1 then accept;
9else reject;
That is, Mguesses the advice string ausing a na¨ıve trial-and-error approach;
once the correct advice string ahas been found, it accepts xiff the ith bit in the
advice string ais on. Thus Mdecides LAdv.
As for the time required by M, note that in line 6 the circuit Cn+nkcan
be evaluated in time O((n+nk)2l) = O(nr) = O(|x|). Furthermore, L=
NTIME(n)Limplies that Lis closed under complement. Thus the above al-
gorithm solves the problem in NTIME(|x|)coNTIME(|x|)L= NTIME(|x|)L=L
and ADVICEf
L,Q∈ LN. The claim now follows from Theorem 6.3, because
L= NTIME(n)Lmoreover implies Bit ∈ LN.
Corollary 6.5. Let Qbe any set of groupoidal quantifiers. The Uniformity Dual-
ity Property holds for ({∃} ∪ Q,L)if Lequals the deterministic context-sensitive
languages DSPACE(n), the context-sensitive languages CSL, the rudimentary
languages (i. e., the linear time hierarchy [26]), PH,PSPACE, or the recursively
enumerable languages.
Proof. All of the above classes satisfy L= NTIME(n)L.
7 Conclusion
For a set Qof quantifiers and a class Lof languages, we have suggested that
Q[arb]∩ L defines an (extensionally) uniform complexity class. After defining
the notion of L-numerical predicates, we have proposed comparing Q[arb]∩ L
with its subclass Q[<, LN]∩ L, a class equivalently defined as the (intensionally)
uniform circuit class FO[<, LN]-uniform AC0[Q]∩ L.
We have noted that the duality property, defined to hold when both classes
above are equal, encompasses Straubing’s conjecture (1) as well as some positive
and some negative instances of the Crane Beach Conjecture.
We have then investigated the duality property in specific cases with Q=
{∃}. We have seen that the property fails for several classes Linvolving the
context-free languages. Exhibiting these failures has required new insights, such
as characterizations of the context-free numerical predicates and a proof that the
complement of the Immerman language is context-free, but these failures have
prevented successfully tackling complexity classes such as AC0∩CFL. Restricting
the class of allowed relations on the left hand side of the uniformity duality
property from arb to a subclass might lead to further insight and provide positive
21

examples of this modified duality property (and address, e.g., the class of context-
free languages in different uniform versions of AC0). Methods from embedded
finite model theory should find applications here.
More generally, the duality property widens our perspective on the relation-
ship between uniform circuits and descriptive complexity beyond the level of NC1.
We have noted for example that the property holds for any set of groupoidal quan-
tifiers Q ⊇ {∃} and complexity classes Lthat are closed under nondeterministic
linear-time Turing reductions.
A point often made is that a satisfactory uniformity definition should ap-
ply comparable resource bounds to a circuit family and to its constructor. For
instance, although P-uniform NC1has merit [1], the classes AC0-uniform NC1
and NC1-uniform NC1[5] seem more fundamental, provided that one can make
sense of the apparent circularity. As a by-product of our work, we might suggest
FO[<, LN]∩ L as the minimal “uniform subclass of L” and thus as a meaning-
ful (albeit restrictive) definition of L-uniform L. Our choice of FO[<] as the
“bottom class of interest” is implicit in this definition and results in the contain-
ment of L-uniform Lin (non-uniform) AC0for any L. Progressively less uniform
subclasses of Lwould be the classes Q[<, LN]∩ L for Q ⊇ {∃}.
Restating hard questions such as conjecture (1) in terms of a unifying prop-
erty does not make these questions go away. But the duality property raises
further questions. As an example, can the duality property for various (Q,L) be
shown to hold or to fail when Qincludes the ma jority quantifier? This could
help develop incisive results concerning the class TC0. To be more precise, let us
consider Q={∃,MAJ}. The majority quantifier is a particular groupoidal (or,
context-free) quantifier [16], hence it seems natural to consider the Uniformity
Duality Property for ({∃,MAJ},CFL):
FO+MAJ[arb]∩CFL = FO+MAJ[<, +] ∩CFL.(6)
It is not hard to see that the Immerman language in fact is in FO+MAJ[<, +],
hence our Theorem 5.2 that refutes (2), the Uniformity Duality Property for
(FO,BC(CFL)), does not speak to whether (6) holds. (Another prominent ex-
ample that refutes (2) is the “Wotschke language” W = {(anb)n:n≥0}, again
a co-context-free language [25]. Similar to the case of the Immerman language
we observe that W ∈FO+MAJ[<, +], hence W does not refute (6) either.)
Observe that FO+MAJ[arb] = TC0[5] and that, on the other hand,
FO+MAJ[<, +] = MAJ[<] = FO[+]-uniform linear fan-in TC0[15,6]. Let us
call this latter class sTC0(for small TC0or strict TC0). It is known that
sTC0(TC0[16]. Hence we conclude that if (6) holds, then in fact TC0∩CFL =
sTC0∩CFL. Thus, if we can show that some language in the Boolean closure
of the context-free languages is not in sTC0, we have a new TC0lower bound.
Thus, to separate TC0from a superclass it suffices to separate sTC0from a
superclass, a possibly less demanding goal. This may be another reason to look
for appropriate uniform classes Lsuch that
FO+MAJ[arb]∩ L = FO+MAJ[<, +] ∩ L.
22

Acknowledgements
We would like to thank Klaus-J¨orn Lange (personal communication) for sug-
gesting Lemma 5.1. We also acknowledge helpful discussions on various topics of
this paper with Christoph Behle, Andreas Krebs, Klaus-J¨orn Lange and Thomas
Schwentick. We also acknowledge helpful comments from the anonymous refer-
ees.
References
1. E. Allender. P-uniform circuit complexity. Journal of the Association for Comput-
ing Machinery, 36:912–928, 1989.
2. R. Alur and P. Madhusudan. Visibly pushdown languages. In Proc. of the 16th
Annual ACM Symposium on Theory of Computing, pages 202–211, 2004.
3. D. A. Mix Barrington and N. Immerman. Time, hardware, and uniformity. In
Proceedings 9th Structure in Complexity Theory, pages 176–185. IEEE Computer
Society Press, 1994.
4. D. A. Mix Barrington, N. Immerman, C. Lautemann, N. Schweikardt, and D. Th´e-
rien. First-order expressibility of languages with neutral letters or: The Crane
Beach Conjecture. Journal of Computer and System Sciences, 70:101–127, 2005.
5. D. A. Mix Barrington, N. Immerman, and H. Straubing. On uniformity within
NC1.Journal of Computer and System Sciences, 41(3):274–306, 1990.
6. C. Behle and K.-J. Lange. FO[<]-Uniformity. In Proceedings of the 21st Annual
IEEE Conference on Computational Complexity (CCC’06), pages 183 – 189, 2006.
7. J. Berstel. Transductions and Context-Free Languages, volume 38 of Leitf¨aden der
angewandten Mathematik und Mechanik LAMM. Teubner, 1979.
8. A. Borodin. On relating time and space to size and depth. SIAM Journal on
Computing, 6:733–744, 1977.
9. S. Ginsburg. The Mathematical Theory of Context-Free Languages. McGraw-Hill,
New York, 1966.
10. S. Ginsburg, S. Greibach, and J. Hopcroft. Abstract families of languages. Memoirs
of the Amer. Math. Soc., 87, 1969.
11. O. Ibarra, T. Jiang, and B. Ravikumar. Some subclasses of context-free languages
in NC1.Information Processing Letters, 29:111–117, 1988.
12. N. Immerman. Expressibility and parallel complexity. SIAM Journal on Comput-
ing, 18:625–638, 1989.
13. R. Karp and R. Lipton. Turing machines that take advice. L’enseignement
math´ematique, 28:191–209, 1982.
14. K.-J. Lange. Complexity theory and formal languages. In 5th International Meeting
of Young Computer Scientists, volume 381 of Lecture Notes in Computer Science,
pages 19–36. Springer, 1989.
15. K.-J. Lange. Some results on majority quantifiers over words. 19th IEEE Confer-
ence on Computational Complexity, pages 123–129, 2004.
16. C. Lautemann, P. McKenzie, T. Schwentick, and H. Vollmer. The descriptive
complexity approach to LOGCFL. Journal of Computer and Systems Sciences,
62(4):629–652, 2001.
17. P. Lindstr¨om. First order predicate logic with generalized quantifiers. Theoria,
32:186–195, 1966.
23

18. L. Liu and P. Weiner. An infinite hierarchy of intersections of context-free lan-
guages. Mathematical Systems Theory, 7:185–192, 1973.
19. R. McNaughton and S. Papert. Counter-Free Automata. MIT Press, 1971.
20. J.-´
E. Pin. Vari´et´es de langages formels. Masson, 1984.
21. W. L. Ruzzo. On uniform circuit complexity. Journal of Computer and Systems
Sciences, 21:365–383, 1981.
22. N. Schweikardt. Arithmetic, first-order logic, and counting quantifiers. ACM Trans-
actions on Computational Logic, 6(3):634–671, July 2005.
23. H. Straubing. Finite Automata, Formal Logic, and Circuit Complexity. Birkh¨auser,
Boston, 1994.
24. H. Vollmer. Introduction to Circuit Complexity – A Uniform Approach. Texts in
Theoretical Computer Science. Springer Verlag, 1999.
25. D. Wotschke. The Boolean closure of the deterministic and nondeterministic
context-free languages. In 3. GI Jahrestagung, volume 1 of Lecture Notes in Com-
puter Science, pages 113–121. Springer, 1973.
26. C. Wrathall. Rudimentary predicates and relative computation. SIAM Journal on
Computing, 7(2):194–209, 1978.
24