The Crane Beach Conjecture

Abstract

A language L over an alphabet A is said to have a neutral letter
if there is a letter e∈A such that inserting or deleting e's from
any word in A* does not change its membership (or non-membership) in L.
The presence of a neutral letter affects the definability of a language
in first-order logic. It was conjectured that it renders all numerical
predicates apart from the order predicate useless, i.e., that if a
language L with a neutral letter is not definable in first-order logic
with linear order then it is not definable in first-order. Logic with
any set 𝒩 of numerical predicates. We investigate this conjecture
in detail, showing that it fails already for 𝒩={+, *}, or possibly
stronger for any set 𝒩 that allows counting up to the m times
iterated logarithm, 1g(m), for any constant m. On the
positive side, we prove the conjecture for the case of all monadic
numerical predicates, for 𝒩={+}, for the fragment BC(Σ) of
first-order logic, and for binary alphabets

Full text

The Crane Beach Conjecture
DAVID A. MIX BARRINGTON ∗
Computer Science Department
University of Massachusetts
barring@cs.umass.edu
NEIL IMMERMAN †
Computer Science Department
University of Massachusetts
immerman@cs.umass.edu
CLEMENS LAUTEMANN
Institut f¨
ur Informatik
Johannes Gutenberg-Universit¨
at Mainz
cl@informatik.uni-mainz.de
NICOLE SCHWEIKARDT
Institut f¨
ur Informatik
Johannes Gutenberg-Universit¨
at Mainz
nisch@informatik.uni-mainz.de
DENIS TH´
ERIEN ‡
School of Computer Science
McGill University
denis@cs.mcgill.ca
Abstract
A language Lover an alphabet Ais said to have a neutral
letter if there is a letter e∈Asuch that inserting or deleting
e’s from any word in A∗does not change its membership (or
non–membership) in L.
The presence of a neutral letter affects the definability of a
language in first–order logic. It was conjectured that it ren-
ders all numerical predicates apart from the order predicate
useless, i.e., that if a language Lwith a neutral letter is not
definable in first–order logic with linear order, then it is not
definable in first–order logic with any set Nof numerical
predicates.
We investigate this conjecture in detail, showing that it fails
already for N={+,∗}, or, possibly stronger, for any set N
that allows counting up to the mtimes iterated logarithm,
lg(m), for any constant m.
On the positive side, we prove the conjecture for the case
of all monadic numerical predicates, for N={+}, for
the fragment BC(Σ1)of first–order logic, and for binary
alphabets.
∗Supported by NSF grant CCR-9988260.
†Supported by NSF grant CCR-9877078.
‡Supported by NSERC and FCAR.
1 Introduction
Logicians have long been interested in the relative expres-
sive power of different logical formalisms. In the last
twenty years, these investigations have also been motivated
by a close connection to computational complexity theory
— most computational complexity classes have been given
characterisations as finite model classes of appropriate log-
ics, cf. [Imm98]. In these investigations it became apparent
that in order to describe computation over a finite structure,
a formula has to be able to refer to some linear order of the
elements of this structure. Given such an order, the universe
of the structure, i.e., the set of its elements, can be identified
with an initial segment of the natural numbers. In a logic
with the capability to express induction we can then define
predicates for arithmetical operations such as addition or
multiplication on the universe, and use them in order to de-
scribe operations on time or memory locations. In weak
logics, however, e.g., first–order logic, defining an order re-
lation does not automatically make arithmetic available. In
fact, even over strings, the expressive power of first–order
logic varies considerably, depending on the set of numerical
predicates that can be used.
As an example, if the order is the only numerical rela-
tion then the only regular languages that can be defined
in first–order logic are the star–free languages. If, how-
ever, for every p∈Nwe have available the predicate modp
(which holds for a number miff m≡0 (mod p)) then
we can express regular languages that are not star–free,

such as (000 + 001)∗. In fact, with these predicates we
can express all the first–order definable regular languages,
cf. [Str94]. Thus, even very powerful relations (arithmeti cal
relations, or even undecidable ones) are of no further help
in defining regular languages. On the other hand, with ad-
dition, we can express languages that are not regular, such
as {0n1n/ n∈N}.
First-order logic with varying numerical predicates can al so
be thought of as specifying circuit complexity classes with
varying uniformity conditions [BIS90]. The language de-
fined by a first-order formula is naturally computed by a
family of boolean circuits with constant depth, polynomial
size, and unbounded fan-in (called “AC0circuits”). The
power of such a family depends in part on the sophistication
of the connections among the nodes. A formula with only
simple numerical predicates leads to a circuit family where
these connections are easily computable. These are called
“uniform circuits”, and how uniform they are is quantified
by the computational complexity of a language describing
the connections. A formula with arbitrary numerical predi-
cates leads to a circuit family with arbitrary connections —
the set of languages so describable is called “non-uniform
AC0”.
There are languages, such as the PARITY language, for
which we can prove no AC0circuit exists [Ajt83, FSS84].
A major open problem in complexity theory is to develop
methods for showing languages to be outside of uniform cir-
cuit complexity classes even if they are in the corresponding
non-uniform class. This is an additional motivation for the
study of the expressive power of first-order logic with vari-
ous numerical predicates, as this provides a parametrization
of various versions of “uniform AC 0”.
In an attempt to obtain a better understanding of this expres-
sive power, Th´erien considered the concept of a neutral let-
ter for a language L, i.e., a letter ethat can be inserted into
or deleted from a string without affecting its membership in
L. Since, in the presence of such a letter, membership in L
cannot depend on specific (combinations of) letters being in
specific (combinations of) positions, it seemed conceivable
that neutral letters would render all numerical predicates,
except for the order, useless. With this in mind, Th´erien
proposed what was later dubbed the Crane Beach Conjec-
ture:
If a language with a neutral letter can be defined
in first–order logic using some set Nof numerical
predicates then it can be so defined using only the
order relation.
One particular example ofa language with a neutral letter is
PARITY, consisting precisely of those 0–1–strings in which
1occurs an even number of times. PARITY is not definable
in first–order logic – no matter what numerical predicates
are used (cf. [Ajt83, FSS84]). The Crane Beach conjecture
would imply this result, since PARITY is a regular language
known not to be star–free.
In this paper, we investigate the Crane Beach conjecture in
detail. We first show that in general it is not true — in fact,
it already fails for N={+,∗}. However, we also show
that the conjecture is true in a number of interesting special
cases, including the case of addition, i.e., when N={+}.
This work is closely related to a line of research in data
base theory which is concerned with so–called collapse re-
sults (cf. [BL00]). Here one considers a finite data base
embedded in some infinite, ordered domain, and then looks
at locally generic queries, i.e., queries which are invariant
under monotone injections of the data base universe into the
larger domain. In this setting, a language with a neutral let-
ter is the special case of a locally generic (Boolean) query
over monadic databases with background structure hN,N i,
and the conjecture then can be translated into a collapse for
first–order logic.
We will come back to this in connection with Theorem 3.12.
Acknowledgements
We are indebted to Thomas Schwentick for bringing the
data base theory connection to our attention. He also took
an active part in many discussions on the subject of this pa-
per. In particular, the first proof of Theorem 3.9 was partly
due to him. The first author in particular would like to thank
Eric Allender, Pierre McKenzie, and Howard Straubing for
valuable discussions on this topic, many of which occurred
at a Dagstuhl workshop in March 1997. Much important
work on this topic also occurred at various McGill Invi-
tational Workshops on Complexity Theory, particularly on
excursions to Crane Beach, St. Philip, Barbados.
2 Preliminaries
2.1 First–Order Logic
Asignature is a set σcontaining finitely many relation, or
predicate, symbols, each with a fixed arity. A σ–structure
A=hUA, σAiconsists of a set UA, called the universe of
Aand a set σAthat contains an interpretation RA⊆(UA)k
for each k–ary relation symbol R∈σ.
In this paper, we are concerned almost exclusively with
first–order logic over finite strings. In this context, for an
alphabet Awe use the signature σA:= {Qa/ a ∈A}
and identify a string w=w1···wn∈A∗with the struc-
ture w=h{1,... ,n}, σw
Ai, where σw
A={Qw
a/ a∈A}and
Qw
a={i≤n / wi=a}, i.e, i∈Qw
a⇐⇒ wi=a, for all
a∈A.
In addition to the predicates Qawe also have numerical
predicates. A k–ary numerical predicate Phas, for every
2

n∈N, a fixed interpretation Pn⊆ {1, . . . , n}k. Our prime
example of a numerical predicate is the linear order rela-
tion ≤. Where we see no danger of confusion (i.e., almost
everywhere) we will not distinguish notationally between a
predicate and its interpretation.
An atomic σ–formula is either of the form x1=x2,
or P(x1,... ,xk), where x1, x2,... ,xkare variables and
P∈σis a k–ary predicate symbol. First–order σ–formulas
are built from atomic σ–formulas in the usual way, using
Boolean connectives ∧,∨,¬, etc. and universal (∀x) and
existential (∃x) quantifiers.
For every alphabet A, and every set Nof numerical predi-
cates, we will denote the set of first–order σA∪ N –formulas
by F O[N]. We define semantics of first–order formulas in
the usual way. In particular, for a string w∈A∗and a for-
mula ϕ∈F O[N]without free variables (i.e., variables not
bound by a quantifier), we will write w|=ϕif ϕholds on
the string w. If x1,... ,xkare the free variables of ϕ, and
if p1,... ,pk≤ |w|,w|=ϕ(p1,... ,pk)indicates that ϕ
holds on the string wwith xiinterpreted as pi, for every
i≤k.
Every formula ϕ∈
FO
[N]without free variables defines
the set Lϕof those A–strings which satisfy ϕ. We say
that a language L⊆A∗is definable in F O[N], and write
L∈F O[N], if L=Lϕ, for some ϕ∈F O [N]. We will
use analogous notation for subsets of
FO
[N], in particular,
we will consider the set Σ1[N]of formulas which are of the
form ∃x1···∃xrψ, for some quantifier–free ψ∈
FO
[N],
and its Boolean closure, BC(Σ1[N]). (One can define a
complete hierarchy of classes Σi[N]and Πi[N]along with
their Boolean closures, using the hierarchy of first-order for-
mulas given by the number of quantifier alternations. But in
this paper we will have need only for BC(Σ1[N]).
2.2 Ehrenfeucht–Fra¨
ıss´
e Games
One of our main technical tools will be (various versions
of) the Ehrenfeucht–Fra¨
ıss´
e game. In our context, the
Ehrenfeucht–Fra¨ıss´e game for a set of numerical predicates,
N, is played by two players, Spoiler and Duplicator, on two
strings u, v ∈A∗. There is a fixed number kof rounds, and
in each round i
•first, Spoiler chooses one position, aiin u, or a position
biin v;
•then Duplicator chooses a position in the other string,
i.e., a biin v, if Spoiler’s move was in u, and an aiin
u, otherwise.
After krounds, the game finishes with positions a1,... ,ak
chosen in uand b1,... ,bkchosen in v. Duplicator has won
if the mapping ai7→ bi,i= 1,... ,k, is a partial σA∪ N –
isomorphism, i.e., if
•for every i, j ≤k,ai=aj⇐⇒ bi=bj,
•for every i≤k,aiand bicarry the same letter, i.e.,
uai=vbi, and
•for every m–ary predicate P∈ N , and every
i1,... ,im≤k, it holds that P(ai1,... ,aim)⇐⇒
P(bi1,... ,bim).
If Duplicator has a winning strategy in the k–round game
for Non two strings uand v, we write u≡N
kv. The funda-
mental use of the game comes from the fact that it charac-
terises first–order logic (c.f., e.g., [EFT94]). In our context,
this can be formulated as follows:
2.1 Theorem (Ehrenfeucht, Fra¨ıss´e)
A language L⊆A∗is definable in F O[N]iff there is a
finite subset N′of Nand a number ksuch that, for every
u∈L,v6∈ L, Spoiler has a winning strategy in the k–round
game for N′on uand v.
We will also use the following variant of the game:
In the single–round k–game for Non two strings u,v
•first, Spoiler chooses kpositions a1,... ,akin u, or
b1,... ,bkin v;
•then Duplicator chooses kpositions in the other string,
i.e., positions b1, . . . , bkin v, if Spoiler’s move was in
u,a1,... ,akin u, otherwise.
Again, Duplicator wins iff the mapping ai7→ bi,i=
1,... ,k, is a partial isomorphism. Clearly, if Duplicator
has a winning strategy for the single–round k–game on u
and v, then she also has one for the single–round h–game,
for all h≤k.
This game characterises the expressive power of
BC(Σ1[N]):
2.2 Theorem
A language L⊆A∗is definable in BC(Σ1[N]) iff there
is a finite subset N′of Nand a number ksuch that, for
every u∈L,v6∈ L, Spoiler has a winning strategy in the
single–round k–game for N′on uand v.
3 The Crane Beach Conjecture
Intuitively, since numerical predicates can only talk about
positions in strings, it seems that they can only help ex-
press properties that depend on certain (combinations of)
letters appearing in certain (combinations of) positions. The
Crane Beach Conjecture (named after the location of its
first, flawed, proof) is an attempt to make that intuition pre-
cise.
3

3.1 Definition (Neutral letter)
Let L⊆A∗. A letter e∈Ais called neutral for Lif for
any u, v ∈A∗it holds that uv ∈L⇐⇒ uev ∈L.
Thus membership in a language with a neutral letter cannot
depend on the individual positions on which letters are: any
letter can be moved away from any position by insertion or
deletion of neutral letters. It seems therefore conceivable
that for every such language, if it can be defined at all in
first–order logic then it can be defined using the linear order
as the only numerical relation.
3.2 Definition (Crane Beach Conjecture)
Let Nbe a set of numerical predicates. We say that the
Crane Beach conjecture is true for N, iff every language
L∈F O[≤,N]that has a neutral letter is also definable in
F O[≤].
It turns out that the conjecture is true for some sets of nu-
merical predicates, but not for all. In fact, it fails for the set
N={+,∗}. This set of predicates is particularly important
because F O[+,∗]corresponds to the most natural uniform
version of the circuit complexity class AC0[BIS90].
Our counterexample to the Crane Beach conjecture makes
use of the well-known but somewhat counterintuitive ability
of F O[+,∗]formulas to count letters up to numbers poly-
logarithmic in the input size:
3.3 Definition (Definibility of Counting)
Let f(n)≤nbe a nondecreasing function from Nto N. We
say that a logical system can count up to f(n)if there is a
formula ϕsuch that for every nand for every w∈ {0,1}n,
w|=ϕ(c)⇐⇒ c≤f(n)∧c= #1(w),
where #1(w)is the number of ones in w.
We will need to consider two functions with similar nota-
tion. We write the base-two logarithm of nas lg n, the
k’th power of this logarithm as (lg n)k, and the k’th iter-
ated logarithm as lg(k)n. For example, lg(2) nis the same
as lg(lg n).
3.4 Proposition ([AB84, FKPS85, DGS86, WWY92])
The system F O[+,∗]can count up to (lg n)kfor any k. If
f(n) = (lg n)ω(1), and Nis any set of numerical predi-
cates, then F O[≤,N]cannot count up to f(n).
3.5 Theorem
There is a language Lwith a neutral letter that is definable
in F O[+,∗]but not in F O [≤].
Proof:
We define a language Aon alphabet {0,1, a}as follows.
For each positive integer k,Awill contain a string con-
sisting of the 2kbinary strings of length k, in order, sep-
arated by a’s. The total length of the k’th string in Ais thus
2k(k+ 1) −1. The first three strings in Aare thus 0a1,
00a01a10a11, and
000a001a010a011a100a101a110a111.
Our desired language Bhas alphabet {0,1, a, e}and is sim-
ply the set of strings wover this alphabet such that the string
obtained by deleting all the e’s in wis in A. Clearly Bhas
a neutral letter e, as inserting or deleting e’s cannot affect
membership in B. Clearly Bis not regular, so it cannot be
in F O[≤]. It remains for us to prove:
3.6 Lemma
Bis definable in F O[+,∗].
Proof:
We need to formulate a sentence of F O[+,∗]that will hold
for a string exactly if it is in B, that is, exactly if its non-
neutral letters form a string in A. Recall that a string wis in
Aexactly if for some number k,wconsists of the 2wbinary
strings of length k, in order, separated by a’s.
Our sentence will assert the existence of a number ksuch
that the input string, with e’s removed, is the k’th string
in the language A. Since the length of the k’th string in
Ais exponential in k, and a valid input string must be at
least as long, any valid kmust be at most lg n. Therefore by
Proposition 3.4, the system F O[+,∗]is able to count letters
in any interval in the input string up to a limit of k.
We first assert that there are exactly k0’s and no 1’s before
the first a, exactly k0’s and 1’s between each pair of a’s,
exactly k1’s (and no 0’s) after the last a. It then remains to
assert that each string of 0’s and 1’s between two a’s is the
successor of the previous one. To do this, we assert that for
every position ycontaining a 0or 1:
•If there is a position wleft of ysuch that there is a 0or
1at yand exactly k−1 0’s and 1’s between wand y,
•Then whas the same letter as yunless
•xhas the unique abetween xand y,zhas the next a
to the right of xor is the rightmost position if there is
no such a,
•whas 1, there are no 0’s between wand x,yhas 0, and
there are no 1’s between yand z,or
•whas 0, there are no 0’s between wand x,yhas 1, and
there are no 0’s between yand z.
This proves Lemma 3.6 and thus Theorem 3.5. 
4

Theorem 3.5 now follows immediately. 
The construction above crucially uses the fact that we can
count up to lg nin F O [+,∗]. We can strengthen the con-
struction so that it provides a counterexample using only
counting up to lg(m)n, the mtimes iterated logarithm of n.
However, we do not yet know whether this strengthening is
non-trivial — it may be that any set of numerical predicates
that allows counting up to lg(m)nalso allows counting up
to lg n.
3.7 Proposition
If the system F O[≤,N]can count up to lg(m)nfor some
m, then there is a language Lwith a neutral letter that is
definable in F O[≤,N]but not in F O[≤].
Proof:
We must show that counting up to lg(m)nsuffices to pro-
vide a counterexample to the Crane Beach conjecture. We
give the construction in some detail for m= 2, indicating
how to generalize it to arbitrary values for m. Take the al-
phabet {a, b, 0,1, e}and for every kconsider strings of the
form (b(0 + 1)k(a(0 + 1)k)∗)∗b. Finally, add eas a neutral
letter. aand bare used as markers, and we interpret the 0–
1–substring between any two successive markers as the bi-
nary representation of some number between 0and 2k−1.
If xis any position, we define block(x)to be the interval
between the two markers nearest x, and num(x)to be the
number represented by the 0–1subsequence in block(x).
Using a formula that can count up to kand the construction
from the proof of Theorem 3.5 we can write formulas ex-
pressing num(x) = num(y)and num(x) + 1 = num(y),
respectively. We can now express easily that between ev-
ery successive occurences of two b’s each number from 0to
2k−1is represented precisely once. In other words, this
formula stipulates that the {a, 0,1}–substring between two
b’s represent a permutation of the numbers 0,... ,2k−1.
Finally, we write a formula that expresses that all permuta-
tions are represented. Altogether, our formula defines the
set of those strings which consist of a sequence of permuta-
tions of the numbers 0,... ,2k−1, for some k, containing
every permutation at least once. In particular, every such
string has length Ω(2k!), whereas counting is only required
up to k=O(lg lg(2k!)).
To be more precise, the formula forces all permutations to
be present as follows. It says that for every represented
permutation π(starting, say, with a bat position p), and
every pair of positions i, j within that permutation (i.e.,
p < i < j < p′, where p′is the smallest position > p
that carries a b), there is a permutation ρ(between b’s at q
and q′, say) which is equal to π, except that num(i)and
num(j)are swapped. In what follows we will use abbre-
viations f irst(x)and last(x)for formulas which express
that xlies in the first, respectively last, block of some per-
mutation; next(x)will denote the first position in the block
directly to the right of block(x). Our formula for iand j
now expresses the following for all r, s such that p < r < p′
and q < s < q′:
•num(r) = num(s)→num(next(r)) =
num(next(s))
unless last(r)or {num(r), num(next(r))} ∩
{num(i), num(j)} 6=∅
•(num(r)=num(s)∧num(next(r))=num(i)) →
num(next(s))=num(j)
•(num(r)=num(s)∧num(next(r))=num(j)) →
num(next(s))=num(i)
•(num(s)=num(j)∧ ¬last(s)) →
num(next(s))=num(next(i))
•(num(s) = num(i)∧¬last(s)) →num(next(s)) =
num(next(j))
•(first(r)∧f irst(s)∧num(r)6=num(i)) →
num(r) = num(s)
•(first(r)∧f irst(s)∧num(r) = num(i)) →
num(s) = num(j).
Thus we can construct the desired formula for m= 2.
We can then iterate this process, using an additional marker
symbol c. The resulting formula stipulates that our string
represent all permutations of all the permutations of the
numbers 0,... ,2k−1. This will guarantee that string to
be of length Ω(((2k)!)!), etc. 
It is not difficult to code the languages above using only
two non–neutral letters: just apply the homomorphism
{a, b, 0,1, e}∗→ {0,1, e}∗which maps eto e,ato 010,
bto 0110,0to 01110, and 1to 011110, for example. How-
ever, with only one non–neutral letter there is no way of
defeating the conjecture.
3.8 Theorem
If |A|= 2 then for every set Nof numerical predicates and
every language L⊆A∗with a neutral letter it holds that
L∈F O[≤,N] =⇒L∈F O[≤].
Proof:
Let Lbe a language on {1, e}with eas a neutral letter.
Consider the set of numbers nsuch that 1nis in Land 1n+1
is not. If this set is finite, it is easy to see that Lis regular
and definable in F O [≤]. Otherwise, we will show that no
family of unbounded fan-in circuits with constant depth and
polynomial size can recognize L— it follows from [BIS90]
that Lis not definable in F O[≤,N]for any N.
5

For these particular values of n, any circuit deciding
Lon strings of length 2nwould compute a symmet-
ric function of the inputs saying yes on inputs with n
1’s and no on inputs with n+ 1 ones. Following the
construction of [FKPS85], a constant-depth poly-size
combination of these circuits can be used to compute
the parity function on inputs of this size. If the circuit
deciding Lhad constant depth and polynomial size, then
this new circuit would compute the parity function in AC 0
for infinitely many input sizes, violating [Ajt83, FSS84]. 
Since PARITY is a non–star–free regular language over
{0,1}∗and has a neutral letter, Theorem 3.8 implies the
nonexpressibility of PARITY in first–order logic with arbi-
trary numerical predicates (i.e., AC0). Note, however, that
it directly uses the existing proofs of the nonexpressibility
of PARITY to get this result.
On the other hand, the following special case of the Crane
Beach conjecture can be proved directly:
3.9 Theorem
The Crane Beach conjecture holds for the set of all monadic
relations.
Proof:
Let Lbe a language with a neutral letter that is not definable
in F O[≤]. This means that for any number of moves k
there must be two strings y∈Land z6∈ Lsuch that the
Duplicator wins the k-move game (using only ≤) on yand
z. By adding neutral letters we can make yand zhave the
same length m.
Now let Nbe any monadic predicate. We will show that
Lis not definable in F O[≤,N]as follows. We will use N
to construct two strings u∈Land v6∈ Lfrom yand zby
suitable padding with neutral letters. (The length of uand v
will be a suitably large number nto be defined below.) Then
we will show how the Duplicator can win the k-move game
on uand v, with both ≤and Nas numerical predicates.
The predicate Nmay be regarded as a coloring of the in-
put positions from 1to n, with finitely many colors. If r
and sare input positions, consider the colored string given
by the interval from rto s, with each input position hold-
ing a neutral letter. For any two such strings, consider the
k-move game with only ≤as numerical predicate and the
colors considered as the input. Let two strings be consid-
ered equivalent iff the Duplicator wins this game on them.
Since the language defined by this game is regular, there are
only a finite number of equivalence classes. We now define
a colored undirected graph whose vertices are these ninput
positions and where the color of the edge from position r
to position srepresents the equivalence class of the colored
string for that interval.
By the Erdos-Szekeres Theorem [ES35], as long as nis
greater than mdwhere dis the number of edge colors, there
must be a monochromatic path in the graph of length at least
m. We create ufrom y, and vfrom z, by placing the letters
of the shorter strings in the locations given by the vertices
of these path (the “special locations”), and making all other
letters neutral. We must now explain how the Duplicator
can win the game with ≤and Non the strings uand v(the
“Big Game”).
The Duplicator will model the Big Game by a series of
“small games”, where she already has a winning strategy
for each. One small game is played on the strings yand
zusing only ≤, and there is another small game (using ≤
and color only) for each interval between special locations.
Whenever the Spoiler moves in the Big Game, the Dupli-
cator translates this move into the y-zsmall game by mov-
ing to the position matching the next special position to the
right. She also translates it into the small game for that inter-
val. The Duplicator’s reply in the Big Game is determined
by her correct move in the y-zgame, and her correct move
in the special small game for that particular interval.
After kmoves Delilah must win the original Small Game
and all the interval Small Games, as she has made at most
kmoves in each. It is easy but tedious to look at the input
predicates, order, equality, and position color in the Big
Game and verify that Delilah has won that as well. 
We can use Theorem 3.9 to derive the following interest-
ing generalization of the nonexpressibility of PARITY. But
again, we do not get an independent proof of this fact be-
cause the existing proofs are used crucially to obtain the
results in [BCST92].
3.10 Corollary
The Crane Beach conjecture holds for all regular languages.
That is, for every set Nof numerical predicates and every
regular set Lwith a neutral letter it is true that that L∈
F O[≤,N] =⇒L∈F O[≤].
Proof:
This follows from Theorem 3.9 and the fact, proven
in [BCST92], that every regular language definable in
F O[≤,N](using any set Nof numerical predicates) is
definable in F O[≤,{modp/ p ∈N}], where modp(i)is
true iff i≡0 mod p.
Although according to Theorem 3.9 the Crane Beach con-
jecture holds for the set of all unary relations, it is not true
for all binary relations, since F O [≤,+,∗] = F O[≤,
Bit
],
c.f., [Imm98]. In fact, it already fails for the set of all unary
functions, or for the set of all linear orderings. This follows
from the existence of a unary function f:N→N(see
the proof of Theorem 3 in [Sch97]) and a set Oof linear or-
derings (in fact, four order relations suffice, cf.[ScSc]) such
that
FO
[≤,+,∗] =
FO
[≤,
Bit
] =
FO
[≤, f ] =
FO
[≤,O].
6

We can also consider special cases of the Crane Beach con-
jecture based on restrictions on the type of logical formulas
allowed. For example, with arbitrary sets of numerical rela-
tions the conjecture does hold for Boolean combinations of
Σ1–formulas:
3.11 Theorem
Let Nbe a set of numerical predicates, and let Lbe a
language with a neutral letter that is definable in the class
BC(Σ1[≤,N]). Then L∈BC(Σ1[≤]).
Proof:
We must show that for any set Nof numerical predicates
and any language Lwith a neutral letter, Lis definable in
BC(Σ1[≤,N]) iff it is definable in BC(Σ1[≤]).
Using Theorem 2.2, we first show the proposition for the
special case N={suc, min,max}, where suc is the suc-
cessor relation suc(n, m)iff m=n+1,hw, ni |= min(n)
iff x=1, and hw, ni |= max(n)iff n=|w|.
Let ebe the neutral letter, and assume that L6∈ BC(Σ1[≤]).
Then, for every k, there are strings u∈L,v6∈ Lsuch that
Duplicator wins the single–round k–game for ≤on u, v.
We can assume uand vto be of the same length m(if
not, append |v|+k e′s to uand |u|+k e′s to v). We con-
struct strings Ufrom uand Vfrom vsuch that U∈L,
V6∈ L, and Duplicator wins the single–round k–game
for {≤, suc, min,max}on U, V . Then L6∈ BC(Σ1[≤
, suc, min,max]), which proves the assertion, by contrapo-
sition.
In order to construct U, insert 2k−1e′s between each pair
of adjacent positions in u, as well as at the beginning and
the end of u. More precisely, U=U1···Um2k+2k−1, with
Uj2k=uj, and Uj2k+i=e, for any j≤m,i < 2k.
Similarly, we construct Vfrom v. Since eis neutral, we
have U∈L,V6∈ L.
Assume that Spoiler chooses positions a1,... ,akin U(the
other case is symmetric). Some (possibly all, or none) of
the Uajwill be neutral letters, others will be from A\ {e}.
For the sake of notational simplicity we will assume, with-
out loss of generality, that Ua1,... ,Uaq∈A\ {e}, and
Uaq+1 =··· =Uak=e. Then each ajwith j≤qis of
the form sj2k, for some sj∈ {1, . . . , m}. Now Duplica-
tor simulates a move of Spoiler in the game for ≤on u, v
in which Spoiler pebbles s1,... ,sqon u, and finds her re-
ply, s′
1,... ,s′
qon v, according to her winning strategy. She
then sets, for each jfrom 1through q,bjto be s′
j2k. Then
for each j, j ′≤qit holds that
•bj6=bj′+1 and aj6=aj′+1,
•bj≤bj′⇐⇒ aj≤aj′, and
•Vbj=vs′
j=usj=Uaj.
To complete this move, Duplicator has to define
bq+1,... ,bksuch that Vbq+1 =··· =Vbk=e, and that
for all j, j ′≤k
•bj≤bj′⇐⇒ aj≤aj′,
•bj=bj′+1 ⇐⇒ aj=aj′+1, and
•bj= 1 ⇐⇒ aj= 1,bj=|V| ⇐⇒ aj=|U|.
Such bq+1,... ,bkcan easily be found, since between any
two different bi, bjwith i, j ≤q, there are at least 2k−1
positions pwhere Vp=e.
Now let Nbe an arbitrary finite set of numerical predicates
and assume that L6∈ BC(Σ1[≤]). From what we have
just shown it follows that, for every k, we can find strings
u∈L,v6∈ Lof the same length msuch that Duplica-
tor has a winning strategy in the single–round 2k+2–game
for ≤, suc, min,max on u, v. We want to construct strings
Uand Vby inserting neutral letters into uand v, respec-
tively, in such a way that the original letters of uand v
are moved onto positions i1,... ,imwhich are, in a cer-
tain sense, highly indistinguishable. To this end, we define,
for every number n, a coloring of subsets of size h≤2kof
{1,... ,n}. This coloring was inspired by the one used by
Straubing in [Str01], in his proof of Theorem 8. There he
used the following extension of Ramsey’s theorem, which
will also help us here:
Theorem Let m, k, c1, . . . , ck>0, with k≤m. Let n
be sufficiently large as a function of mand the c’s. If all
h–element subsets of {1, . . . , n}, with 1≤h≤k, are col-
ored from a set of chcolors, then there exists an m–element
subset Tof {1,... ,n}such that for each hwith 1≤h≤k
there exists a color κhsuch that all h–element subsets of T
are colored κh.
Let T={τ1,... ,τq}be the set of all atomic formulas over
N,≤on variables x1, . . . , xk, y1,... ,yh. The N,≤–type
of a tuple r= (r1, . . . , rk)∈ {1,... ,n}kwith respect
to a h–element set S={p1<··· < ph},α(r, S), is the
set of all those formulas of Tthat are satisfied when xiis
interpreted as ri, and yjas pj, for i≤kand j≤h.
We now color, for each number nand every h≤2k, every
h–element set S={p1<··· < ph} ⊆ {1,... ,n}with
the set of all those α⊆ T for which there is a k–tuple r
over {1,... ,n}such that rhas N–type αwith respect to
S. Clearly, for every h≤2kthere is a fixed number of
possible colors, independent of n. The extension of Ram-
sey’s theorem stated above tells us that for large enough n
we can find numbers i1<··· < im≤nsuch that, for
every h≤2k, all h–element subsets of {i1,... ,im}have
the same color. We now insert neutral letters into uin such
a way that in the resulting string Uwe have Uis=us, for
s= 1,... ,m, and Ui=efor all i6∈ {i1,... ,im}. In the
7

same way we construct Vfrom v. Let us call i1,... ,imthe
special positions.
We now show that Duplicator has a winning strategy in the
k–game for ≤,Non U, V . Assume that Spoiler chooses
a=a1,... ,akin U(again, the other case is symmet-
ric). Then Duplicator finds, for every ajthe next small-
est special position isj, i.e, isj≤aj< isj+1. Let
S={isj, isj+1 / j = 1,... ,k}. Duplicator now simulates
a move of Spoiler in the 2k+2–game for ≤, suc, min,max
on u, v, in which Spoiler plays all the points sjand sj+1,
for j= 1,... ,k on u, as well as min and max. Using
her winning strategy in this game, Duplicator finds a reply
with which she wins the game for ≤, suc. Therefore, we
can safely call these points tj, tj+1, for j= 1,... ,k, and
we know that usj=vtj, for j= 1, . . . , k. Let Tbe the
set {itj, itj+1 / j = 1,... ,k}.|T|=|S|=h≤2k, so
Sand Thave the same colour, and this implies that there is
a tuple b= (b1,... ,bk)with the same N–type as a, and
with ω(b, T ) = ω(a, S ). Duplicator now puts her pebbles
on b1,... ,bkin V. We have to check the winning condi-
tions. By construction, α(a, S =α(b, T ). In particular, this
implies that
•(a1,... ,ak)and (b1,... ,bk)have the same N–type,
•aj≤aj′⇐⇒ bj≤bj′, for all j, j ′,
•if aj=isjthen bj=itjhence Uaj=usj=vtj=
Vbj. If ajis not of this form then isj< aj< isj+1,
consequently, itj< bj< itj+1 and Uaj=Vbj=e.

As we have seen, with addition and multiplication first–
order logic has enough expressive power to defeat the neu-
tral letter. Addition alone is, in many ways much weaker
than addition and multiplication together. For example,
this is witnessed by the fact that the first–order theory of
the natural numbers with +and ∗is undecidable, whereas
Presburger arithmetic, the first–order theory of the natural
numbers with addition only, can be decided using quantifier
elimination. Also note that at least our technique for pro-
ducing a counterexample cannot work with addition only,
since it is well known (see, e.g., page 12 of [Lyn82]) that
F O[≤,+] cannot count up to any non-constant function.
It is therefore more than conceivable that addition alone is
too weak to make the conjecture fail, and we now show that
this is indeed the case.
3.12 Theorem
Every language L∈
FO
[≤,+] that has a neutral letter is
definable in
FO
[≤].
As indicated in the introduction, this theorem follows from
collapse results for first–order queries over finite databases
(e.g., Theorem 5.5 in [BST99]). However the terminology
in which these results are formulated is rather alien to our
setting here, so we will instead use a recent collapse result
on infinite databases in [LS01]. First, however, let us give
an intuitive explanation of the main idea behind the proof.
For simplicity, we concentrate on 0–1–strings u, v of the
same (large) size and discuss what Duplicator has to do in
order to win the k–round +–game on uand v. Let Abe the
set of indices afor which ua= 1, similarly, B={b / vb=
1}. As in previous proofs, we will work with a set Qof
indistinguishable positions, and choose uand vsuch that
A, B ⊆Q.
Assume that, after i−1rounds a(1),..,a(i−1) have been
played in u, and b(1) ,..,b(i−1) in v. Let Spoiler choose
some element a(i)in u. When choosing b(i)in v, Du-
plicator has to make sure that any Spoiler moves for the
remaining k−irounds in one structure can be matched in
the other. In particular, this means that any sum over the
a(j)behaves in relation to Aexactly as the corresponding
sum over the b(j)behaves in relation to B. For instance, for
any sets J, J′⊆ {1,..,i}, it should hold that there is some
a∈Athat lies between Pj∈Ja(j)and Pj′∈J′a(j′)if and
only if there is some b∈Bthat lies between Pj∈Jb(j)
and Pj′∈J′b(j′). But it is not enough to consider simple
sums over previously played elements. Since with O(r)
additions it is possible to generate s·a(i)from a(i), for any
s≤2r, we also have to consider linear combinations with
coefficients as large as this. Furthermore, since Spoiler is
allowed to choose either structure to move in each time,
it is necessary to deal with even more complex linear
combinations. One can only handle all these complications
because, as the game progresses, the number of rounds left
for Spoiler to do all these things decreases. This means, for
instance, that the coefficients and the length of the linear
combinations we have to consider decrease: after the last
round, the only relevant linear combinations are simple
additions of chosen elements.
All the technical details necessary to make this strategy
work are worked out in [Lyn82] in order to prove that
for each first–order formula with addition ϕthere is a set
Q⊆Nsuch that ϕcannot distinguish between subsets of
Qif they are of equal cardinality, or both large enough.
Drawing on Lynch’s theorem, in [LS01] the authors
prove a theorem, which, specialised to our setting can be
formulated as follows.
Theorem ([LS01], Theorem 3.2)
For every k∈Nthere exists a number r(k)∈N
and an order–preserving mapping q:N→Nsuch
that, for every signature σthe following holds: If
σUand σVare interpretations of σover N, and if
n, m ∈Nwith hN, σU, ni ≡≤
r(k)hN, σV, mi, then
hN, q(σU, n)i ≡+
khN, q(σV, m)i.
8

Here, q(σU, n)is short for σq ,U , q(n), where σq,U =
{Rq,U / R ∈σ}, and Rq,U ={q(i)/ i ∈RU}.
Proof of 3.12, using the above theorem:
Assume that L6∈
FO
[≤], and let u=u1···un∈L,
v=v1...vm6∈ L, such that u≡≤
r(k)v. We construct
strings U∈L,V6∈ Lfrom uand v, respectively, by in-
serting neutral letters in such a way that Uq(i)=uiand
Vq(j)=vj, for i= 1,... ,n,j= 1, . . . , m, where qis as in
the theorem. uand vdefine σA–interpretations σU
Aand σV
A,
respectively, and the winning strategy of Duplicator on u
and vcan easily be extended to hN, σU, niand hN, σV, mi:
If Spoiler plays a position ai≤non hN, σ U, ni, this cor-
responds to a move on u, and Duplicator can choose her
answer according to her winning strategy on v. If Spoiler
plays a position ai> n on hN, σU, ni, then Duplicator
replies with bi:= m+(ai−n). (The case where Spoiler
plays on hN, σV, niis completely symmetric.) Clearly, this
defines a winning strategy for Duplicator. Application of
the theorem above gives us a winning strategy for Duplica-
tor in the kround game for {≤,+}on hN, q(σU, n)iand
hN, q(σV, m)i. From this, we obtain a winning strategy for
Duplicator in the kround game for {≤,+}on Uand V:
Every move of Spoiler in Uis translated into a move on
hN, q(σU, n)i, and Duplicator’s reply on hN, q (σV, m)iis
translated back into a move on V. The winning condition
of Duplicator on hN, q(σU, n)iand hN, q(σV, m)idirectly
translates into the winning condition for Duplicator on U
and V, thus proving that U≡+
kV.
4 Discussion
Much of the above can be generalised from strings to arbi-
trary relational structures over the natural (or real) numb ers.
This programme is pursued in [LS01]. With regard to the
questions here, the following problems remain open.
•It would be very good to have a proof of Theorem 3.8
that does not rely on [Ajt83, FSS84]. However, since
Theorem 3.8 implies the nonexpressibility of PARITY,
we expect this to be very difficult.
•What is the status of the conjecture for F O [≤,∗]?
There is a construction of Julia Robinson [Rob49]
defining addition from multiplication and the succes-
sor operation, but in our context this only suffices to
define addition on some numbers (those less than n1/4)
from multiplication and order on all numbers. We con-
jecture that some variant of this construction will suf-
fice to disprove the Crane Beach conjecture for F O[≤
,∗], perhaps by showing it equivalent to F O[≤,+,∗].
•Can we find a set of numerical predicates that allows
us to count up to lg(m)n, but not to lg n? What about
counting up to even smaller functions? We conjecture
that the Crane Beach conjecture is true of a system iff
it cannot count beyond a constant.
•Within F O[≤,+,∗], we can consider the subclasses
of formulas based on the number of quantifier alter-
nations. The lg–counting operation requires Σ3, and
the construction of the counter example adds a few
more levels. This leaves a gap between the upper
bound of something like Σ5in Theorem 3.5, and a
lower bound of BC(Σ1)in Theorem 3.11. Since in
BC(Σ2), counting is only possible up to a constant
(cf., [FKPS85]), it is conceivable that the lower bound
can be improved.
•Theorem 3.12 places limits on the power of a partic-
ular uniform circuit complexity class, an “addition-
uniform” version of AC0. Can we use these tech-
niques to place limits on the power of more power-
ful uniform versions of AC0(without using the non-
uniform lower bounds) or on addition-uniform ver-
sions of more powerful classes? This has been done
for one such class, an addition-uniform version of
LOGCFL, by Lautemann, McKenzie, Schwentick, and
Vollmer [LMSV99].
•It would also be of interest to study the conjecture for
certain extensions of FO, such as FO with unary count-
ing quantifiers or FO with modulo counting quanti-
fiers. These each have various versions depending on
the numerical predicates available.
References
[AB84] M. Ajtai and M. Ben-Or. A theorem on proba-
bilistic constant depth computations. Proc. 16th
ACM STOC (1983), 471-474.
[Ajt83] M. Ajtai. Σ1
1–formulae on finite structures. An-
nals of Pure and Applied Logic, 24:1–48, 1983.
[BCST92] D.A.M. Barrington, K. Compton, H. Straub-
ing, and D. Th´erien. Regular languages in
NC1.Journal of Computer and Systems Sci-
ences, 44:478–499, 1992.
[BIS90] D.A.M. Barrington, N. Immerman, and H.
Straubing. On uniformity within N C 1.J.
Comp. Syst. Sci. 41:3 (1990), 274-306.
[BL00] M. Benedikt and L. Libkin. Expressive power:
The finite case. In G. Kuper, L. Libkin, and
J. Paredaens, editors, Constraint Databases,
pages 55–87. Springer, 2000.
9

[BST99] O.V. Belegradek, A.P. Stolboushkin, and M.A.
Taitslin. Extended order-generic queries. An-
nals of Pure and Applied Logic, 97:85–125,
1999.
[DGS86] L. Denenberg, Y. Gurevich, and S. Shelah.
Definability by constant-depth polynomial-size
circuits. Inf. and Control 70 (1986) 216-240.
[EFT94] H.-D. Ebbinghaus, J. Flum, and W. Thomas.
Mathematical Logic. Springer-Verlag, New
York, 2nd edition, 1994.
[ES35] P. Erd¨os and G. Szekeres. A combinatorial
problem in geometry. Compositio Math. 2
(1935), 464-470.
[FKPS85] R. Fagin, M. Klawe, N. Pippenger, and L.J.
Stockmeyer. Bounded-depth polynomial size
circuits for symmetric functions. Theoretical
Computer Science, 36:239–250, 1985.
[FSS84] M.L. Furst, J.B. Saxe, and M. Sipser. Parity, cir-
cuits, and the polynomial–time hierarchy. Math-
ematical Systems Theory, 17:13–27, 1984.
[Imm98] N. Immerman. Descriptive and Computational
Complexity. Springer–Verlag, New York, 1998.
[LMSV99] C. Lautemann, P. McKenzie, T. Schwentick,
and H. Vollmer. The descriptive complexity
approach to LOGCFL. In STACS 1999: 16th
Annual Symposium on Theoretical Aspects of
Computer Science, Lecture Notes in Computer
Science 1563, Springer Verlag (1999), 444-454.
[LS01] C. Lautemann and N. Schweikardt. An
Ehrenfeucht–Fra¨ıss´e approach to collapse re-
sults for first–order queries over embedded
databases. In STACS 2001: 18th Annual Sym-
posium on Theoretical Aspects of Computer Sci-
ence, Lecture Notes in Computer Science 2010,
Springer Verlag (2001), 455-466.
[Lyn82] J. F. Lynch. On sets of relations definable by
addition. Journal of Symbolic Logic, 47:659–
668, 1982.
[Rob49] J. Robinson. Definability and decision prob-
lems in arithmetic. Journal of Symbolic Logic
14 (1949), 98-114.
[Sch97] Th. Schwentick. Padding and the expressive
power of existential second-order logics. In
Mogens Nielson and Wolfgang Thomas, edi-
tors, Proceedings of the Annual Conference of
the European Association for Computer Sci-
ence Logic, Lecture Notes in Computer Science,
pages 461–477, 1997.
[ScSc] N. Schweikardt and Th. Schwentick. In prepa-
ration.
[Str94] H. Straubing. Finite Automata, Formal Logic,
and Circuit Complexity. Birkh¨auser, 1994.
[Str01] H. Straubing. Languages defined with modular
counting quantifiers. Information and Compu-
tation, 2001. To appear.
[WWY92] I. Wegener, N. Wurm, and S.-Z. Yi. Symmetric
functions in AC0can be computed in constant
depth and very small size. in Boolean Function
Complexity, ed. M. Paterson, London Mathe-
matical Society Lecture Notes 169 (1992), 129-
139.
10