Lipschitz Continuous Ordinary Differential Equations

are Polynomial-Space Complete

Akitoshi Kawamura
arXiv:1004.4622v1 [cs.CC] 26 Apr 2010

April 2010

Abstract
In answer to Ko’s question raised in 1983, we show that an initial value problem
given by a polynomial-time computable, Lipschitz continuous function can have a
polynomial-space complete solution. The key insight is simple: the Lipschitz condi-
tion means that the feedback in the differential equation is weak. We define a class of
polynomial-space computation tableaux with equally weak feedback, and show that
they are still polynomial-space complete. The same technique also settles Ko’s two
later questions on Volterra integral equations.
Keywords: computable analysis; computational complexity; initial value problem;
Lipschitz condition; ordinary differential equations; Picard–Lindelöf Theorem; poly-
nomial space.

1 Introduction
Let g : [0, 1] × R → R be a continuous function and consider the initial value problem

h′ (t) = g t, h(t) , t ∈ [0, 1].

(1.1) h(0) = 0,

A well-known sufficient condition (see the beginning of Section 3 for a proof sketch) for
this equation to have a unique solution h : [0, 1] → R is that g be Lipschitz continuous (in
its second argument), i.e.,

(1.2) |g(t, y0) − g(t, y1)| ≤ Z · |y0 − y1 |, t ∈ [0, 1], y0 , y1 ∈ R

for some constant Z independent of y0 , y1 and t. We are interested in the computational

complexity of the solution h under this condition.
Our model of computation of real functions, which will be reviewed in Section 2, is
adopted from computable analysis and is thus consistent with the conventional notion of
computability. We formulate our main result in Section 3: the solution h of the above
equation can be polynomial-space complete, even if g is polynomial-time computable. This
was open since Ko (1983). The essential part of the proof is given in Section 4, where we
construct a certain family of real functions that can be used as building blocks for the desired

1
g and h. The main idea is to regard the differential equation with the Lipschitz condition
as a polynomial-space computation tableau with some restrictions. In Section 5, we state a
few variants of the main theorem, two of which solve the problems about Volterra integral
equations posed by Ko (1992). These variants are also proved using the same building
blocks, as shown in Section 6. Section 7 discusses related results and open problems.

2 Computational complexity of real functions

The study of mathematical analysis from the viewpoint of computability is called com-
putable analysis; Brattka et al. (2008) and Weihrauch (2000) are good introductions to
the field. We review the basic definitions briefly here, refining them for our complexity
consideration where necessary.
The computability notion for real functions equivalent to ours dates back at least to
Grzegorczyk (1955). Polynomial-time computability of real functions was introduced by
Ko & Friedman (1982) using oracle machines, and is equivalent, at least in our context, to
the one defined by the type-two machine and the signed digit representation (Chapter 7 of
Weihrauch (2000)).

2.1 Computing real functions

Since real numbers cannot be encoded into strings, we encode them into functions from
strings to strings. We say that a real number t is represented by a string function A if for
any m ∈ N, the string A(0m ) is the binary notation (with a sign bit at the beginning) of
either ⌊2m t⌋ or ⌈2m t⌉, where ⌊·⌋ and ⌈·⌉ mean rounding down and up to the nearest integer,
respectively. In effect, A(0m ) gives an approximation of t with precision 2−m by a multiple
of 2−m . We also say that A is a name of t.
Computation of real functions is realized by oracle Turing machines (henceforth just
machines) working on such names A. In addition to the input, output and work tapes, the
machine has a query tape and can consult an external oracle A by entering a distinguished
state; the string v which is on the query tape at this moment is then replaced by A(v)
in one step. We write M A for the string-to-string function computed by machine M with
oracle A.

Definition 2.1. A machine M computes a function f : [0, 1] → R if for any t ∈ [0, 1] and
any name A of it, M A is a name of f (t).
Thus, computation of a real function f is a Turing reduction of (a name of) f (t) to t
(Figure 2.1, left). A little thought shows that it can equivalently be visualized as a Turing
machine that, given on the input tape an infinite sequence of approximations of t, writes
approximations of f (t) endlessly on the one-way output tape (Figure 2.1, right).
A machine runs in polynomial time if there is a polynomial p : N → N such that, for
any input string u, it halts within p(|u|) steps regardless of the oracle. A real function is
(polynomial-time) computable if some machine (that runs in polynomial time) computes it.
When writing an approximation of f (t) with precision 2−m , the machine knows t only to
some finite precision 2−n . Hence, all computable functions are continuous. If the machine

2
 Oracle cn is a 2−n -approximation of t
c0 c1 c2 c3 c4
read
0n 2−n -approximation of t

Machine
Machine
write (one-way)
m −m
0 2 -approximation of f (t) d0 d1 d2
dm is a 2−m -approximation of f (t)

Figure 2.1: To compute a real function f , the machine should output an approximation
of f (t) with given precision 2−m by consulting the oracle for approximations of t with any
precision 2−n it desires (left). An alternative picture (right) is that the machine converts any
stream of improving approximations of t to a stream of improving approximations of f (t).

y
y = f (t)

2−p(n)

2−n

1 t

Figure 2.2: Modulus of continuity p.

runs in polynomial time, then this n is bounded polynomially in m. Hence, all polynomial-
time computable functions f have a polynomial modulus of continuity (Figure 2.2): there
is a polynomial p such that |f (t0 ) − f (t1 )| < 2−m for all t0 , t1 ∈ [0, 1] and m ∈ N with
|t0 −t1 | < 2−p(m) (note that in our setting it makes sense to put p in the exponent, deviating
from some authors’ terminology where a modulus of continuity means a function that takes
an upper bound on |t0 − t1 | to that on |f (t0 ) − f (t1 )|). In fact, it is not hard to see that
polynomial-time computability can be characterized by this plus the assertion that f can
be approximated at rationals:

Lemma 2.2. A function f : [0, 1] → R is polynomial-time computable if and only if it has

a polynomial modulus of continuity and there is a polynomial-time computable function
g : ([0, 1] ∩ Q) × {0}∗ → Q such that

(2.3) |g(d, 0n ) − f (d)| < 2−n , d ∈ [0, 1] ∩ Q, n ∈ N,

where rational numbers are encoded in a reasonable way (e.g., using fractions whose nu-
merator and denominator are integers written in binary).

3
 Many familiar continuous functions are computable. For example, it is easy to see that
the sine function restricted to [0, 1] is polynomial-time computable, because an approxima-
tion of

t3 t5 t7
(2.4) sin t = t − + − +···
3! 5! 7!

to precision 2−m can be found by approximating the sum of polynomially many (in m)
initial terms, since this series converges fast enough on [0, 1].
The above definition can be straightforwardly extended to functions on compact inter-
vals other than [0, 1] and on d-dimensional rectangles (by considering machines taking d
oracles). Also, polynomial-space, exponential-time and exponential-space computability is
defined analogously to polynomial-time computability, where by “exponential” we mean
O(1)
2n (and not 2O(n) ). Here, we count the query tape in when defining space complexity.
The definition in Section 7.2.1 of Ko (1991) states to the contrary, but his subsequent
theorems build on the definition that does charge the query tape (on the other hand, his
argument in Chapter 4 that the query tape should not be counted in discussing logarithmic
space is correct).

2.2 Completeness
We now introduce terminology to state our main results which say that certain real functions
are “hard” to compute. We regard a language L as a set of strings or as a {0, 1}-valued
function interchangeably, so that L(u) = 1 means u ∈ L. We write P, NP, PSPACE,
EXPTIME, EXPSPACE for the standard classes of languages and #P for the function
class; see Papadimitriou (1994).

Definition 2.5. A function L (over strings) is said to reduce to a real function h : [0, 1] →
R if the following holds for some polynomial-time computable functions R, S, T : Let u
be a string, and suppose that the function taking string v to S(u, v) is a name of a real
number t ∈ [0, 1]. Then L(u) = R(u, ψ(T (u))) for any name ψ of f (t) (Figure 2.3).

For a complexity class C, we say that a real function is C-hard if all problems in C
reduce to it. A real function is polynomial-space (resp. exponential-space) complete if
it is polynomial-space (resp. exponential-space) computable and PSPACE-hard (resp.
EXPSPACE-hard).
The above definitions of reduction and completeness can be viewed as a special case of
those by Beame et al. (1998), and are also consistent with Definition 2.2 of Ko (1992).

3 Ko’s question and our main result

Now we return to the differential equation (1.1). The fact that (1.2) guarantees a unique
solution is known as (a variant of) the Picard–Lindelöf (or Cauchy–Lipschitz) Theorem,
and can be proved as follows. Let C be the set of all continuous real functions on [0, 1]. A

4
 S
n
0 2−n -approximation of t

0m 2−m -approximation of h(t)

T R
u L(u)

Figure 2.3: L reduces to h via R, S and T . This means that, using a hypothetical machine M
computing h (in the sense of Definition 2.1) as a black box, we can compute L in polynomial
time in the way depicted above.

solution of (1.1) is a fixed point of the operator T : C → C defined by

Z t

(3.1) T (h)(t) = g τ, h(τ ) dτ, t ∈ [0, 1].
0

The existence and uniqueness of this fixed point follow from the contraction principle
(Banach fixed point theorem), because a simple calculation shows that, for the metric d
on C given by d(h0 , h1 ) = maxt∈[0,1] exp(−2Zt)|h0 (t) − h1 (t)|, we have d(T (h0 ), T (h1 )) ≤
d(h0 , h1 )/2.
We assume the following, and ask how complex h can be:

(∗) g : [0, 1] × R → R and h : [0, 1] → R satisfy (1.1), g satisfies (1.2), and g is polynomial-
time computable.

Strictly speaking, we have defined polynomial-time computability only for functions on a

compact rectangle. What we mean here is that the restriction of g to [0, 1] × [min h, max h],
say, is polynomial-time computable. Equivalently, we could write g : [0, 1] × [−1, 1] → R
and add the clause “the values of h stays within [−1, 1]” to (∗); this does not essentially
change our result, because we can always make h stay within [−1, 1] by scaling g and h
down by a constant factor, which does not affect polynomial-time computability. There is
a way to extend Definition 2.1 to functions with unbounded domain, as in Hoover (1990)
or pp. 57–58 of Ko (1991), but we choose our simpler definition.
As Ko (1983) points out by analyzing the Euler method, (∗) implies that h is polynomial-
space computable. From this it follows (Lemma 2.2 of Ko (1983)) that if P = PSPACE,
then (∗) implies that h is polynomial-time computable. We will prove a lower bound that
matches this upper bound:

Theorem 3.2. There are functions g and h satisfying (∗) such that h is PSPACE-hard
(and thus polynomial-space complete).

5
Corollary 3.3. P = PSPACE if and only if (∗) always implies that h is polynomial-
time computable.
This solves the main problem left open in Ko (1983). He had proved there a partial
result essentially stating that Theorem 3.2 holds true if the Lipschitz condition (1.2) in the
assumption (∗) is replaced by a weaker condition.
We remark that the special case of the equation (1.1) where g ignores its second argu-
ment reduces to integration, whose complexity is summarized as follows in the style similar
to Theorem 3.2 and Corollary 3.3.

Theorem 3.4 (essentially by Friedman 1984). There are a polynomial-time computable

function g : [0, 1] → R and a #P-hard function h : [0, 1] → R such that
Z t
(3.5) h(t) = g(τ ) dτ, t ∈ [0, 1].
0

Corollary 3.6 (Friedman 1984). P = P#P if and only if for all polynomial-time com-
putable g : [0, 1] → R, the function h defined by (3.5) is polynomial-time computable.
The relation to the counting class is not surprising: as is apparent from Friedman’s
proof, the intuition behind this result is that approximating the integral is to count the
number of grid points below the graph of g.
This bound of P#P has been the best known lower bound also for our differential
equation. Theorem 3.2 improves this to PSPACE.

4 Proof of the theorem

We present the proof backwards, reducing Theorem 3.2 to Lemma 4.1 and then reducing
Lemma 4.1 to Lemma 4.7. In Section 4.1, we state Lemma 4.1 asserting the existence
of a certain family of pairs of functions (gu )u and (hu )u , from which the functions g and
h in Theorem 3.2 can be constructed. Section 4.2 shows that Lemma 4.1 follows from
Lemma 4.7, which asserts the PSPACE-completeness of a discrete version of the initial
value problem. This discrete problem is like a PSPACE computation tableau, but with a
certain restriction similar to the Lipschitz condition. Section 4.3 then completes the proof
by showing Lemma 4.7.

4.1 Building blocks

To state Lemma 4.1, we need to extend the definition of computation in Section 2.1 to
families of real functions indexed by strings u. This is done in the natural way, by giving u
as another string input to the machine. For example, a family (gu )u of functions gu : [0, 1] ×
[−1, 1] → R is computed by a machine M if for any names A and B of t ∈ [0, 1] and
y ∈ [−1, 1], the function that takes string 0m to M A,B (u, 0m) is a name of gu (t, y). Note
that in this case, claiming that M runs in polynomial time means that it halts in time
polynomial in |u| + m.

6
 a scaled copy of gu
y a scaled copy of gu mirrored

2−poly(|u|)
y = h(t)
−
lu cu
+
lu
−
l u′ c u′
+
l u′ 1 t

u∈L u′ ∈
/L

Figure 4.1: To construct g, we assign interval [lu− , lu+ ] to each string u and put there a pair of
reduced copies of gu . The value h(cu ) at the midpoint will be positive if and only if u ∈ L.

Lemma 4.1. Let L ∈ PSPACE and let λ : N → N be a polynomial. Then there exist a
polynomial ρ : N → N and families of functions gu : [0, 1] × [−1, 1] → R and hu : [0, 1] → R
indexed by binary strings u such that the family (gu )u is polynomial-time computable and
for each u we have
(i) hu (t) ∈ [−1, 1] for all t ∈ [0, 1];
(ii) gu (0, y) = gu (1, y) = 0 for all y ∈ [−1, 1];
(iii) hu (0) = 0 and h′u (t) = gu (t, hu (t)) for all t ∈ [0, 1];
(iv) |gu (t, y0 ) − gu (t, y1 )| ≤ 2−λ(|u|) |y0 − y1 | for any t ∈ [0, 1] and y0 , y1 ∈ [−1, 1];
(v) hu (1) = 2−ρ(|u|) L(u).
We thus have a family of functions gu that each give an initial value problem whose
solution hu encodes L(u) in its final value hu (1).
Using this family, the functions g and h in Theorem 3.2 will be constructed roughly
as follows. Divide [0, 1) into infinitely many subintervals [lu− , lu+ ], one for each u, with
midpoints cu . We put a pair of scaled copies of gu onto [lu− , cu ] and [cu , lu+ ] as shown
in Figure 4.1 so that the membership of u in L can be determined by looking at h(cu ).
Scaling down gu horizontally increases its Lipschitz constant, and the resulting g needs to
have a Lipschitz constant independent of u; this is why we had to claim in (iv) that the gu
originally have small constant 2−λ(|u|) . Details are routine and are relegated to Section 6
along with the proofs of two other theorems which will be stated in Section 5 and which
will also follow from Lemma 4.1.

4.2 Discrete initial value problem and the Lipschitz condition

A first attempt to prove Lemma 4.1 would be as follows. Consider a polynomial-space
Turing machine that decides whether a given string u belongs to L. Its configuration
at each time can be encoded into a nonnegative integer less than 2C(|u|) , where C is a
polynomial. There is a simple rule that maps u (the input), T (time) and d (the current
configuration) to a number Gu (T, d) (the next configuration) such that the recurrence


(4.2) Hu (0) = 0, Hu (T + 1) = Gu T, Hu (T )

7
 y y = hu (t)

Hu (T )
2C(|u|)
Hu (T +1)
2C(|u|)

T T +1 1 t
2Q(|u|) 2Q(|u|)

Hu (2Q(|u|) )
Hu (T + 1)
Hu (T )
Hu (0)
Hu (1)
Hu (2) ··· ···

Gu Gu Gu Gu Gu Gu Gu
L(u)

Figure 4.2: An attempt to simulate a polynomial-space Turing machine by an initial value

problem is to encode the machine configuration Hu (T ) at each time T into the value hu (t) =
Hu (T )/2C(|u|) at time t = T /2Q(|u|) .

leads to Hu (2Q(|u|) ) = L(u) for some polynomial Q. Now this situation looks similar to the
one in Lemma 4.1: starting at 0, the value of Hu (or hu ) changes over time according to
a simpler function Gu (or gu ), to reach a value eventually that indicates the answer L(u).
Thus we are tempted to simulate the “discrete initial value problem” (4.2) by embedding
each value Hu (T ) as real number Hu (T )/2C(|u|) (Figure 4.2).
The obstacle to this attempt is that the differential equation (iii) in Lemma 4.1 cannot
express all discrete recurrences of form (4.2): continuous trajectories cannot branch or
cross one another; besides, we have the Lipschitz condition (iv) that puts restriction on how
strong the feedback of h to itself can be. We thus need to restrict the discrete problem (4.2)
so that it can be simulated by the continuous version.
To do so, let us reflect on what the Lipschitz condition (iv) means. A rough calculation
shows that if two trajectories differ by ε at time t, then they can differ at time t + 2−Q(|u|)
by at most ε exp(2−λ(|u|) 2−Q(|u|)) ≈ ε(1 + 2−λ(|u|)−Q(|u|)). Thus, the gap can only widen (or
narrow) by a factor of ±2−λ(|u|)−Q(|u|) during each time interval of length 2−Q(|u|) . In other
words, the feedback caused by equation (iii) is so weak that each digit of hu can only affect
far lower digits of hu in the next step.
Now we define a discrete problem that reflects this restriction. Let P and Q be poly-
nomials and let

(4.3) Gu : [P (|u|)] × [2Q(|u|) ] × [4] → {−1, 0, 1},

(4.4) Hu : [P (|u|) + 1] × [2Q(|u|) + 1] → [4],

8
 T: 0 1 2 3 4 2Q(|u|)

Hu (0, T ) 0 0 0 0 0 0

Hu (1, T ) 0

Hu (2, T ) 0

Hu (P (|u|), T ) 0 L(u)

Figure 4.3: The discrete initial value problem (4.3)–(4.6). Each cell Hu (T ) in Figure 4.2 is
now divided into Hu (0, T ), . . . , Hu (P (|u|), T ); the increment from Hu (i + 1, T ) to Hu (i +
1, T + 1) is computed by Gu using the upper left cell Hu (i, T ).

where we write [N] = {0, . . . , N − 1} for N ∈ N. Our restricted discrete initial value
problem is as follows:

(4.5) Hu (i, 0) = Hu (0, T ) = 0,

(4.6) Hu (i + 1, T + 1) = Hu (i + 1, T ) + Gu i, T, Hu (i, T ) .

Thus, Hu (T ) of (4.2) is now divided into polynomially many (in |u|) components Hu (0, T ),
. . . , Hu (P (|u|), T ); compare Figures 4.2 (bottom) and 4.3. We have added the restriction
that Gu sees only the component Hu (i, T ), which in Figure 4.3 means the upper left of
the current cell. The following lemma states that, despite this restriction, we still have
PSPACE-completeness. Note that making Gu completely oblivious to its last argument
would be an overkill, because then Hu would just add up the values of Gu , resulting in the
complexity merely of #P.

Lemma 4.7. Let L ∈ PSPACE. Then there are polynomials P , Q and families (Gu )u ,
(Hu )u satisfying (4.3)–(4.6) such that (Gu )u is polynomial-time computable and Hu (P (|u|),
2Q(|u|)) = L(u) for each string u.
Before proving this, we will reduce Lemma 4.1 to Lemma 4.7 by simulating the new
system (4.3)–(4.6) by the differential equation. Using Gu andP Hu of Lemma 4.7, we will
construct gu and hu of Lemma 4.1 such that hu (T /2Q(|u|)) = i Hu (i, T )/B i for each T ,
where B is a big number. Thus, each column in Figure 4.3 will be encoded into one real
number so that upper/lower cells in the column correspond to upper/lower bits of the
real number. Thanks to the restriction that Gu sees only the upper row, the differential
equation h′u (t) = gu (t, hu (t)) only needs to cause a weak feedback on hu where each bit
of the value of hu affects only much lower bits of its next value. This keeps gu Lipschitz
continuous. Now we fill in the details.

9
Proof of Lemma 4.1. Let P , Q, (Gu )u , (Hu )u be as in Lemma 4.7. By “dividing each
unit time into P (|u|) steps,” we may assume that for each T , there is at most one i such
that Gu (i, T, Y ) 6= 0 for some Y . Write ju (T ) for this unique i (define ju (T ) arbitrarily if
there is no such i). We may further assume that
(
L(u) if i = P (|u|),
Hu i, 2Q(|u|) =


(4.8)
0 if i < P (|u|).
Thus, not only does the bottom right corner of Figure 4.3 equal L(u), as stated already in
Lemma 4.7, but we also claim that the other cells in the rightmost column are all 0. This
can be achieved by doubling the time frame and extending G symmetrically so that in the
second half it cancels out what it has done. Precisely, we extend Gu by
(
0 if i = P (|u|) − 1,
(4.9) Gu (i, 2 · 2Q(|u|) − 1 − T, Y ) =
−Gu (i, T, Y ) if i < P (|u|) − 1

for (i, T, Y ) ∈ [P (|u|)] × [2Q(|u|)] × [4], and Hu by

(

Q(|u|) Hu P (|u|), 2Q(|u|) if i = P (|u|),
(4.10) Hu (i, 2 · 2 − T) =
Hu (i, T ) if i < P (|u|)

for (i, T ) ∈ [P (|u|) + 1] × [2Q(|u|) + 1], and then add 1 to Q(|u|). It is easy to verify that
the equations (4.5) and (4.6) are still satisfied.
Now, assuming (4.8), we construct the families (gu )u and (hu )u of Lemma 4.1. For each
string u and each (t, y) ∈ [0, 1] × [−1, 1], let T ∈ N, θ ∈ [0, 1], Y ∈ Z, η ∈ [−1/4, 3/4] be
such that t = (T + θ)2−Q(|u|) and y = (Y + η)B −ju (T ) , and define
 Q(|u|)
2 π sin(θπ)
1

 G u ju (T ), T, Y mod 4 if η ≤ ,
2B ju (T )+1 4

(4.11) gu (t, y) =    
 3 − 4η Y 4η − 1 Y +1 1

 gu t, ju (T ) + gu t, ju (T ) if η ≥ ,
2 B 2 B 4

P (|u|)
1 − cos(θπ) Gu ju (T ), T, Hu (ju (T ), T ) X Hu (i, T )
(4.12) hu (t) = · + ,
2 B ju (T )+1 i=0
Bi

where B = 2λ(|u|)+Q(|u|)+5 . Note that the second branch of (4.11) says that when η ∈
[1/4, 3/4], we define gu (t, y) by interpolating between the nearest two y at which gu is
already defined by the first branch. Equation (4.12) says that, when θ = 0 (i.e., t is a
multiple of 2−Q(|u|)), the value hu (t) is the real number that encodes the T th column of
Figure 4.3; as θ goes from 0 to 1, it moves to the next value along a cosine curve, whose
slope, as we will see below, matches the sine function in the first branch of (4.11). It is easy
to verify that the definition is consistent; in particular, we use (4.6) to show that (4.12)
stays the same for the two choices of (T, θ) when t is a multiple of 2−Q(|u|).
Conditions (i) and (ii) of Lemma 4.1 are easy to verify. We have (v) with ρ(k) =
P (k)(λ(k)+Q(k)+5), since hu (1) = Hu (P (|u|), 2Q(|u|))/B P (|u|) = L(u)/B P (|u|) = L(u)/2ρ(|u|)
by (4.12) and (4.8). Checking the polynomial-time computability of (gu )u is also routine,
using Lemma 2.2.

10
 To see (iii), observe that in the right-hand side of (4.12),
◦ the absolute value of the first term is bounded by B −ju (T )−1 ≤ B −ju (T ) /32,
◦ the summands corresponding to i ≤ ju (T ) are multiples of B −ju (T ) , and
◦ the summands corresponding to i > ju (T ) are nonnegative numbers, each bounded by
3/B i = 3B −ju (T ) /B i−ju (T ) ≤ 3B −ju (T ) /32i−ju (T ) , and thus altogether by 3B −ju (T ) /31.
Hence, we can write hu (t) = (Y + η)B −ju (T ) for some η ∈ [−1/4, 1/4], where
ju (T )
X
(4.13) Y = Hu (i, T ) · B ju (T )−i .
i=0

Since B is a multiple of 4, we have Y mod 4 = Hu (ju (T ), T ). Substituting these Y and η

into (the first branch of) (4.11), we get

2Q(|u|) π sin(θπ)

(4.14) gu t, hu (t) = G u ju (T ), T, H u (ju (T ), T ) .
2B ju (T )+1
This equals h′u (t) calculated from (4.12).
For the Lipschitz condition (iv), note that since the value of Gu in the first branch of
(4.11) is in {−1, 0, 1}, the difference between the two values of gu in the second branch
is bounded by 2 × 2Q(|u|) π sin(θπ)/(2B ju (T )+1 ) < 2Q(|u|)+2 /B ju (T )+1 . Thus, the slope of gu
along the second argument is at most
2Q(|u|)+2 2Q(|u|)+3
(4.15) 2B ju (T ) · = ≤ 2−λ(|u|)
B ju (T )+1 B
by our choice of B. 

4.3 The discrete initial value problem is hard

It remains to prove Lemma 4.7. At first sight, our system (4.3)–(4.6) (Figure 4.3) looks too
weak to simulate a polynomial-space computation: although we have polynomial amount
of memory (rows) and exponential amount of time (columns), the “chains of dependence”
of values must run from top to bottom and thus are polynomially bounded in length.
Thus, we give up embedding a general PSPACE computation into Figure 4.3. Instead,
we embed another PSPACE-complete problem, qbf (quantified boolean formulas, see
Papadimitriou (1994) where it is called qsat), which asks for the truth value of the given
formula u of form
(4.16) Qn xn . . . Q1 x1 . ψ(x1 , . . . , xn ),
where ψ is a boolean formula and Qi ∈ {∀, ∃} for each i = 1, . . . , n.
The truth value of (4.16) is obtained by evaluating a binary tree of depth n whose
2n leaves each correspond to an assignment to (x1 , . . . , xn ) and whose internal nodes at
level i are labeled Qi . This is roughly why it can be simulated by the tableau in Figure 4.3
despite the restriction that the dependence of values must run from top to bottom. We
give a formal proof and then an example (Figure 4.4).

11
Proof of Lemma 4.7. We may assume that L = qbf. We will construct the polyno-
mials P , Q and families (Gu )u and (Hu )u in Lemma 4.7. Let u be of form (4.16). For each
i = 0, . . . , n and n − i bits bi+1 , . . . , bn ∈ {0, 1}, we write ψi (bi+1 , . . . , bn ) ∈ {0, 1} for the
truth value (1 for true) of the subformula Qi xi . . . Q1 x1 . ψ(x1 , . . . , xi , bi+1 , . . . , bn ), so that
ψ0 = ψ and ψn ( ) = qbf(u). We regard quantifiers as functions from {0, 1, 2, 3} to {0, 1}:

(4.17) ∀(2) = ∃(2) = ∃(1) = 1, ∃(0) = ∀(0) = ∀(1) = 0

(the values ∀(3) and ∃(3) do not matter). These correspond to the meaning of the quan-
tifiers: ∀x (resp. ∃x) means that the subsequent formula is satisfied by 2 (resp. 1 or 2) of
the two possible assignments to x. Thus,


(4.18) Qi+1 ψi (0, bi+2 , . . . , bn ) + ψi (1, bi+2 , . . . , bn ) = ψi+1 (bi+2 , . . . , bn )

for each i = 0, . . . , n − 1. For 2n + 1 bits b0 , . . . , b2n ∈ {0, 1}, we write b2n . . . b0 for the
number b0 + 2b1 + 22 b2 + · · · + 22n b2n .
To define Gu , let

(4.19) Gu (i, T2n T2n−1 . . . T2i+2 T2i+1 100 . . . 0, Y )

(
T2i+2 ψ0 (T1 ⊕ T2 , T3 ⊕ T4 , . . . , T2n−1 ⊕ T2n ) if i = 0,
= (−1) ×
Qi (Y ) otherwise,

where ⊕ denotes the exclusive or; let Gu (i, T, Y ) = 0 for other T (that is, when T is not
an odd multiple of 22i ). Define Hu from Gu by (4.5) and (4.6).
We prove by induction on i = 0, . . . , n that Hu (i, T ) ∈ {0, 1, 2} for all T , as we
mentioned earlier, and that

(4.20) Gu (i, S, Hu (i, S)) = (−1)S2i+2 ψi (S2i+1 ⊕ S2i+2 , . . . , S2n−1 ⊕ S2n )

for all S of form S2n S2n−1 . . . S2i+1 100 . . . 0 (it is immediate from the definition of Gu that
Gu (i, S, Hu (i, S)) = 0 for other S). Once we have proved this, the case i = n yields
Gu (n, 22n , Hu (n, 22n )) = ψn ( ) = qbf(u), and hence Hu (n + 1, 22n + 1) = qbf(u). Since
n < |u|, we can add dummy rows and columns so that Hu (P (|u|), 2Q(|u|)) = qbf(u) for
some polynomials P and Q, as required.
The claims for i = 0 follow immediately from (4.5) and (4.19). Now suppose (4.20) as
the induction hypothesis and fix T = T2n T2n−1 . . . T0 . Let Y = Hu (i + 1, T ). By (4.5) and
(4.6), we have
T −1
X

(4.21) Y = Gu i, S, Hu (i, S) .
S=0

Since the assumption (4.20) implies that flipping the two bits S2i+2 and S2i+1 of any
S = S2n S2n−1 . . . S0 reverses the sign of Gu (i, S, Hu (i, S)), most of the nonzero sum-
mands in (4.21) cancel out. The only terms that can survive are those that correspond
to S = T2n T2n−1 . . . T2i+3 00100 . . . 0 and S = T2n T2n−1 . . . T2i+3 01100 . . . 0. This proves
Y ∈ {0, 1, 2}.

12
 T: 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
(x1 , x2 ) = (0, 0) (1, 0) (1, 0) (0, 0) (0, 1) (1, 1) (1, 1) (0, 1) (0, 1) (1, 1) (1, 1) (0, 1) (0, 0) (1, 0) (1, 0) (0, 0)
Gu (0, T, 0) +0 +1 −1 −0 +1 +1 −1 −1 +1 +1 −1 −1 +0 +1 −1 −0
Hu (1, T ) 0 0 0 0 1 1 0 0 0 0 1 1 2 2 1 1 0 0 1 1 2 2 1 1 0 0 0 0 1 1 0 0 0

Gu (1, T, Hu (1, T )) +0 +1 −1 −0
Hu (2, T ) 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0

Gu (2, T, Hu (2, T )) +1
Hu (3, T ) 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

Figure 4.4: The discrete initial value problem (4.3)–(4.6) corresponding to the formula
u = ∃x2 . ∀x1 . (x1 ∨ x2 ). We follow the convention in Figure 4.3 (but omit the top cells
Hu (0, T ) which are always 0): the cells contain Hu (i, T ), and the signed number above the
cell Hu (i + 1, T ) indicates the increment Gu (i, T, Hu (i, T )) (which is 0 when omitted). The
increments Gu (0, T, 0) for the top row are determined by the truth values of x1 ∨ x2 for
various assignments to (x1 , x2 ).

When T = T2n T2n−1 . . . T2i+3 100 . . . 0, both of these terms survive, so that
(4.22) Y = ψi (0, T2i+3 ⊕ T2i+4 , . . . , T2n−1 ⊕ T2n ) + ψi (1, T2i+3 ⊕ T2i+4 , . . . , T2n−1 ⊕ T2n ).
Therefore, Qi+1 (Y ) = ψi+1 (T2i+3 ⊕ T2i+4 , . . . , T2n−1 ⊕ T2n ) by (4.18). Thus,
(4.23) Gu (i + 1, T, Y ) = (−1)T2i+4 ψi+1 (T2i+3 ⊕ T2i+4 , . . . , T2n−1 ⊕ T2n )
by (4.19), completing the induction step. 
Figure 4.4 shows the table when u be the formula ∃x2 . ∀x1 . (x1 ∨ x2 ). The values
Gu (0, T, 0) encode (redundantly) the truth table of the matrix x1 ∨x2 (first branch of (4.19)).
For example, Gu (0, T, 0) = ±1 (resp. 0) for T = 3, 5, 27, 29 (resp. 1, 7, 25, 31) because
(x1 , x2 ) = (1, 0) (resp. (0, 0)) makes x1 ∨ x2 true (resp. false). Also observe that Hu (1, T )
returns to 0 every eight cells. As a result, the cell Hu (1, 4) = 1 (resp. Hu (1, 12) = 2)
represents the fact that when x2 is false (resp. true), x1 ∨ x2 is satisfied by one (resp. two)
of the assignments to x1 . Now look at the next row. The second branch of (4.19) says that
for odd multiples T of 4, the values Gu (1, T, Hu (1, T )) are ±1 or 0 according to whether the
upper left cell has a 2 or not. Thus, they encode the smaller truth table for the subformula
∀x1 . (x1 ∨ x2 ) under each assignment to x2 . As a result, the cell Hu (2, 16) = 1 indicates
that this subformula is satisfied by one of the assignments to x2 , which causes the last row
to get incremented at T = 17. Observe that the final cell Hu (3, 32) has a 1, exactly because
u is true.

5 Other versions of the problem

5.1 Complexity of the final value
Ko (1983) discusses another version of the question which relates the complexity of the
value h(1), rather than the function h, to that of tally languages (subsets of {0}∗).

13
 Definition 2.5 extends straightforwardly to machines taking d oracles. In particular,
the case d = 0 means that a language L is said to reduce to a real number t if there
are polynomial-time computable functions R and S such that L(u) = R(A(S(u))) for any
string u and any name A of t. Now we can state:

Theorem 5.1. For any tally language L ∈ PSPACE, there are functions g and h satis-
fying (∗) such that L reduces to h(1).
This can be proved by arranging the building blocks gu from Lemma 4.1, as we did for
Theorem 3.2, but in a different way. See Section 6.2 for details.
As a corollary to Theorem 5.1, all tally languages of PSPACE are in P if (∗) implies
that h(1) is polynomial-time computable. This improves on Theorem 4 of Ko (1983), which
showed the same thing with the Lipschitz condition replaced by a weaker condition.

5.2 Volterra integral equations

Ko (1992) later studied the complexity of Volterra integral equations of the second kind
Z t

(5.2) h(t) = f (t) + g t, τ, h(τ ) dτ, t ∈ [0, 1],
0

where function h is to be solved from given f and g. As before, we suppose that f and g
are polynomial-time computable and ask how complex h can be.
If g is Lipschitz continuous (in its last argument), h is polynomial-space computable
by Picard’s iteration method (Section 3 of Ko (1992)). On the other hand, the best lower
bound (in the sense analogous to the “if” direction of Corollary 3.3) has been P#P . One
of the two open problems in Ko (1992) was to close this gap. Our Theorem 3.2 has solved
it, because the initial value problem (1.1) is the special case of (5.2) where f is constantly
zero and g ignores its first argument:

Corollary 5.3. There are functions f : [0, 1] → R and g : [0, 1] × [0, 1] × R → R such
that g is Lipschitz continuous (in its last argument), f and g are both polynomial-time
computable, and the (unique) solution of (5.2) is polynomial-space complete.
The other problem was about the following weak version of the Lipschitz condition (1.2):

(5.4) |g(t, y0) − g(t, y1)| ≤ 2r(n) |y0 − y1 |, n ∈ N, t ∈ [0, 1 − 2−n ], y0 , y1 ∈ R,

where r is a polynomial. Assuming (∗) with (1.2) replaced by (5.4), how complex can h
be, provided it has a polynomial modulus of continuity? Ko (1992) asked this question for
the Volterra equation (5.2) (in which case the g in (5.4) takes one more argument), and
showed that h is exponential-space computable and can be EXPTIME-hard. His second
open problem was to close this gap.
The motivation for this problem comes from Volterra integral equations of the first kind,
a class of equations that are considered harder to solve than (5.2). A common approach
to solve them is to convert the equation into the form (5.2). This conversion does not

14
preserve Lipschitz continuity (1.2); the new equation merely satisfies (5.4). See Ko (1992)
for details.
The following theorem settles this problem (see Section 6.3 for a proof, again using
Lemma 4.1). In fact, we have EXPSPACE-completeness even for the simple differential
equation (1.1):

Theorem 5.5. There are functions g and h satisfying (∗) with (1.2) replaced with (5.4)
such that h has a polynomial modulus of continuity and yet is EXPSPACE-hard.
Note, however, that this theorem says nothing directly about the complexity of Volterra
equations of the first kind. It merely addresses the complexity of a class of equations that
may arise in a particular approach to solving them.

6 Putting the building blocks together

We give the details of the proofs of Theorems 3.2, 5.1 and 5.5 from Lemma 4.1.

6.1 Proof of Theorem 3.2

The rough ideas are explained in Section 4.1. Let L be a PSPACE-complete language. Use
Lemma 4.1 for λ(k) = 2k + 2 to obtain polynomial ρ and families (gu )u , (hu )u . Since (gu )u
is polynomial-time computable, there is a polynomial γ satisfying |gu (t, y)| ≤ 2γ(|u|)−|u| . For
each binary string u, let Λu = 2λ(|u|) , Γu = 2γ(|u|) and
1 2u + 1 1
(6.1) cu = 1 − |u|
+ , lu∓ = cu ∓ ,
2 Λu Λu

where u ∈ {0, . . . , 2|u| − 1} is u read as an integer in binary notation. This divides [0, 1)
into intervals [lu− , lu+ ] indexed by u ∈ {0, 1}∗. Define
 
∓ t y gu (t, ŷ)
(6.2) g lu ± , =± ,
Λu Λu Γu Γu
 
∓ t hu (t)
(6.3) h lu ± =
Λu Λu Γu

for each t ∈ [0, 1] and y ∈ R, where ŷ = max{−1, min{1, y}}. Let g(1, y) = h(1) = 0 for
each y ∈ R. These define g and h “seamlessly” by Lemma 4.1(ii).
We show that g and h satisfy (∗). We begin with equation (1.1). It is easy to see that
h(0) = 0 and h′ (1) = 0 = g(1, h(1)). Since any number in [0, 1) can be written in the form
lu∓ ± t/Λu for some u and t ∈ [0, 1], we have (1.1) by

h′ (t)
 
′ ∓ t gu (t, hu (t))
(6.4) h lu ± =± u =±
Λu Γ Γu
 u    
∓ t hu (t) ∓ t ∓ t
= g lu ± , = g lu ± , h lu ± ,
Λu Λu Γu Λu Λu

15
where equalities are by (6.3), (iii), (6.2), (6.3), respectively.
The Lipschitz condition (1.2) is satisfied with Z = 1 by (iv) and our choice of λ. To
see that g is polynomial-time computable, we use (the obvious two-dimensional version of)
Lemma 2.2. When asked for a 2−m -approximation of g(T, Y ) for rational numbers T and
Y , the machine can find u, ±, t, y with (T, Y ) = (lu∓ ± t/Λu , y/ΛuΓu ) in polynomial time.
Since (6.2) lies in [−2−|u| , 2−|u|], the machine can safely answer 0 if m < |u|. Otherwise it
can answer by computing gu (t, ŷ) with precision 2−m , which can be done in time polynomial
in m + |u| ≤ 2m by the polynomial-time computability of (gu )u .
We have thus proved (∗). Since

hu (1) L(u)
(6.5) h(cu ) = = λ(|u|)+γ(|u|)+ρ(|u|)
Λu Γu 2
by (6.3) and (v), the problem L reduces to h. More precisely, the functions R, S, T in
Definition 2.5 can be given by
(
0 if v denotes 0,
(6.6) R(u, v) =
1 if v denotes 1,
(6.7) S(u, 0n ) = a string denoting ⌊2n cu ⌋,
(6.8) T (u) = 0λ(|u|)+γ(|u|)+ρ(|u|) .

Since L is PSPACE-complete, so is h.

6.2 Proof of Theorem 5.1

We will construct g and h satisfying (∗) such that the tally language L ∈ PSPACE reduces
to h(1). Apply Lemma 4.1 to λ(k) = k + 1 to obtain the polynomial ρ and the families
(gu )u , (hu )u . As we did for Theorem 3.2, we are going to divide [0, 1) into countably many
intervals [lk , lk+1 ] and put there some copies of the block g0k of Lemma 4.1; but this time,
we do not put the mirror reflection to bring h back to 0 (Figure 6.1). The values hu (1) pile
up, so that we can recover any of them by looking at h(1).
Since (gu )u is polynomial-time computable, there is a monotone polynomial γ : N → N
satisfying |g0k (t, y)| ≤ 2γ(k) for each k. Let lk = 1 − 2−k and define

t 2j + (−1)j y
 
g0k (t, y)
(6.9) g lk + k+1 , 2k+γ(k)+ρ(k) = k−1+γ(k)+ρ(k) ,
2 2 2
k−1
L(0κ )
 
t h0k (t) X
(6.10) h lk + k+1 = 2k+γ(k)+ρ(k) +
2 2 κ=0
22κ+γ(κ)+ρ(κ)+ρ(κ)

for each k ∈ N, t ∈ [0, 1], y ∈ [−1, 1] and j ∈ Z, where ρ(k) = ρ(0) + · · · + ρ(k − 1).
Complete the definition by g(1, y) = 0 and
∞
X L(0k )
(6.11) h(1) = .
k=0
22k+γ(k)+ρ(k)+ρ(k)

16
 y 0k ∈ L 0k+1 ∈
/L
h(1)

y = h(t)
copies of g0k+2
copies of g0k+1
a copy of g0k

lk lk+1 lk+2 1 t

Figure 6.1: Compare with Figure 4.1. The blocks g0k are now stacked vertically so that the
tally language L can be recovered from h(1).

By (6.11), the language L reduces to h(1).

We show that these g and h satisfy (∗). Well-definedness and Lipschitz continuity of g
follow from (ii) and (iv) of Lemma 4.1, similarly to the proof of Theorem 3.2. Polynomial-
time computability also follows from that of (gu )u again. Since all terms under the sum-
mation symbol in (6.10) are divisible by 4/22k+γ(k)+ρ(k) , substituting (6.10) into the second
argument of (6.9) yields


g0k t, h0k (t) h′0k (t)
    
t t ′ t
(6.12) g lk + k+1 , h lk + k+1 = k−1+γ(k)+ρ(k) = k−1+γ(k)+ρ(k) = h lk + k+1 ,
2 2 2 2 2

where the second and third equalities are by (iii) and (6.10), respectively. This and h′ (1) =
0 = g(h(1)) yield (1.1). We have proved (∗).

6.3 Proof of Theorem 5.5

Let L ∈ PSPACE be the set of triples (M, x, 0s ) such that M encodes a Turing machine
that, on string input x, uses at most s tape cells and accepts. For each triple w = (M, x, s),
let uw = (M, x, 0s ). With a suitable encoding, we have |uw | ≤ 2|w| . It is easy to see that
L′ = { w : uw ∈ L } is EXPSPACE-complete.
The desired g and h such that L′ reduces to h will be constructed as follows. As we did
for Theorem 3.2, we divide [0, 1) into infinitely many intervals [lw− , lw+ ] with midpoints cw , and
put there the functions guw of Lemma 4.1 to compute whether uw ∈ L, which is equivalent
to w ∈ L′ . But this time, the outcome huw (1) is exponentially small in |w| (even when
it is positive), so we need “amplifiers” to make the value h(cw ) visibly large (Figure 6.2).
Because we use stronger and stronger amplifiers as |w| → ∞, the function g will not satisfy
the full Lipschitz condition (1.2), but it still satisfies the weaker condition (5.4).
Now we fill in the details. Apply Lemma 4.1 to λ(k) = 0 (and the above L) to obtain
the polynomial ρ and families (gu )u , (hu )u . Since (gu )u is polynomial-time computable,
there is a polynomial γ satisfying |gu (t, y)| ≤ 2γ(|u|)−|u| . We may assume that γ(k) − k is
strictly increasing in k and that (1.5 ln 2)γ(k) ≤ 2γ(k)−k for all k. For each binary string w,

17
 2−poly(|w|)
poly(|w|)
2−2

− − + +
lw aw cw aw lw

a copy of guw another copy of guw (mirrored)

Figure 6.2: The construction for Theorem 5.5 is similar to Figure 4.1, but this time we put
an “amplifier” in the middle. Then w ∈ L if and only if h(cw ) is positive, and in this case it
is only polynomially small in |w|.

|w | )
let Λw = 22|w|+3, Γw = 2γ(2 and

1 4w + 2 1 2
(6.13) cw = 1 − |w|
+ , a∓
w = cw ∓ , lw∓ = cw ∓ ,
2 Λw Λw Λw

where w ∈ {0, . . . , 2|w| − 1} is w read as an integer in binary notation. This divides [0, 1)
into intervals [lw− , lw+ ] of length 4/Λw indexed by w ∈ {0, 1}∗. Define
 
∓ t y gu (t, ŷ)
(6.14) g lw ± , =± w ,
Λw Λw Γw Γw
 
∓ t
(6.15) g aw ± , Y = ±6t(1 − t)Y Λw ln Γw ,
Λw
 
∓ t hu (t)
(6.16) h lw ± = w ,
Λw Λw Γw
  t2 (3−2t)
∓ t Γw huw (1)
(6.17) h aw ± =
Λw Λw Γw

for each t ∈ [0, 1] and y, Y ∈ R, where ŷ = max{−1, min{1, y}}. Let g(1, Y ) = h(1) = 0 for
each Y ∈ R. This defines g and h seamlessly by Lemma 4.1(ii). Recall the idea explained
in Figure 6.2: the equations (6.14) and (6.16) are analogous to (6.2) and (6.3) in the proof
of the main theorem, and (6.15) and (6.17) stand for the magnifier.
We show that g and h satisfy (∗) with (1.2) replaced by (5.4).
For the equation (1.1), it is again easy to see that h(0) = 0 and h′ (1) = 0 = g(1, h(1)).
Numbers in [0, 1) can be written either as lw∓ ± t/Λw or as a∓ w ± t/Λw , and for them the

18
equation follows respectively by
h′ (t)
 
t gu (t, huw (t))
(6.18) ′ ∓
h lw ± = ± uw =± w
Λw Γw Γ
   w  
∓ t huw (t) ∓ t ∓ t
= g lw ± , = g lw ± , h lw ± ,
Λw Λw Γw Λw Λw
 
′ ∓ t 6t(1 − t) ln Γw t2 (3−2t)
(6.19) h aw ± =± Γw huw (1)
Λw Γw
 t2 (3−2t)    
∓ t Γw huw (1) ∓ t ∓ t
= g aw ± , = g aw ± , h aw ± ,
Λw Λw Γw Λw Λw
where we used (6.16), (iii), (6.14), (6.16), (6.17), (6.15), (6.17) for each equality.
The condition (5.4) is satisfied with r(k) = 2k + 3 + s(k), where s is any polynomial
such that 2s(k) ≥ (1.5 ln 2)γ(2k ). For if T ∈ [lw− , a− + +
w ] or T ∈ [aw , lw ] for some w, then by (iv)
and (6.14), we have
|g(T, Y0) − g(T, Y1)| 2−λ(|uw |)
(6.20) ≤ Λw Γw ≤ Λw = 22|w|+3 ≤ 2r(|w|).
|Y0 − Y1 | Γw
If T ∈ [a− +
w , aw ] for some w, then by (6.15) we have

|g(T, Y0) − g(T, Y1)|

(6.21) ≤ 22|w|+3 · 1.5 ln Γw
|Y0 − Y1 |
= 22|w|+3 · 1.5γ(2|w|) ln 2 ≤ 22|w|+3 · 2s(|w|) = 2r(|w|).
To see that g is polynomial-time computable, we use the characterization in (the obvious
two-dimensional generalization of) Lemma 2.2. Suppose we are asked for an approximation
of g(T, Y ) to precision 2−m for some T ∈ [0, 1] ∩ Q and Y ∈ [−1, 1] ∩ Q. We first find a
string w and t ∈ [0, 1] ∩ Q such that T can be written as lw∓ ± t/Λw or as a∓ w ± t/Λw . In
the latter case, it is easy to compute the desired approximation using (6.15). In the former
case, we use (6.14) as follows:
|w | |w |
◦ If m < 2|w| , we can safely answer 0, because the value (6.14) is in [−2−2 , 2−2 ] by
|w | |w |
|guw (t, ŷ)| ≤ 2γ(|uw |)−|uw | ≤ 2γ(2 )−2 .
◦ Otherwise, we compute ŷ ∈ Q, where y = Λw Γw Y , and then get the desired approx-
imation of (6.14) by computing guw (t, ŷ) to an appropriate precision. This can be
done, by the polynomial-time computability of (gu )u , in time polynomial in m and
|uw |. But this is in fact polynomial in m, since |uw | ≤ 2|w| ≤ m.
We have thus proved (∗) with (1.2) replaced by (5.4). Since (6.17) yields
huw (1) L(uw )
(6.22) h(cw ) = = 2|w|+3+ρ(|w|) ,
Λw 2
the language L′ reduces to h. Since L′ is EXPSPACE-complete, h is EXPSPACE-hard.
Finally, we claim that h has a polynomial modulus of continuity. Precisely, we show
that |h(T0 ) − h(T1 )| < 2−k whenever k ∈ N and 0 ≤ T1 − T0 < 2−s(k)−k .

19
 ◦ If T1 ≥ 1 − 2−k , then T1 ∈ [lw− , lw+ ] for some w of length ≥ k, so |h1 (T1 )| ≤ 1/Λw ≤
1/22k+3 by (6.16), (6.17) and (i). Applying the same argument to T0 > T1 −2−s(k)−k ≥
1 − 2−(k−1) , we obtain |h1 (T0 )| ≤ 1/22(k−1)+3 . Thus, |h(T0 ) − h(T1 )| ≤ |h(T0 )| +
|h(T1 )| ≤ 1/22k+3 + 1/22(k−1)+3 < 2−k .

◦ If T1 ≤ 1 − 2−k , then each point T ∈ [T0 , T1 ] belongs to [lw− , lw+ ] for some w of length
< k. If T ∈ [lw− , a− + + ′
w ] ∪ [aw , lw ], then |h (T )| ≤ 2
γ(|uw |)
/Γw ≤ 1 by the first line of (6.18);
otherwise, |h (T )| ≤ 6(1/4)(ln Γw )huw (1) = (1.5 ln 2)γ(2|w|)huw (1) ≤ 2s(|w|) ≤ 2s(k) by
′

the first line of (6.19). We thus have |h′ (T )| ≤ 2s(k) , and hence |h(T0 ) − h(T1 )| ≤
2s(k) (T1 − T0 ) < 2s(k) · 2−s(k)−k = 2−k .

7 Related results and open problems

7.1 Other results on differential equations
Table 7.1 summarizes what is known about the computability and complexity of the initial
value problem (1.1) in our sense. Computability of other aspects of the solution is dis-
cussed by Cenzer & Remmel (2004), Graça et al. (2008) and Kawamura (2009a). Edalat
& Pattinson (2004) give a domain-theoretic account for the problem.
The status between the last two rows of Table 7.1 remains open. What happens, for
example, if we assume that g is infinitely often differentiable?
Computability (or not) of other classes of differential equations is studied by Pour-El &
Richards (1981), Pour-El & Zhong (1997), Gay et al. (2001), Weihrauch & Zhong (2002),
Weihrauch & Zhong (2006) and Zhong (2007). Less is known about their computational
complexity.

Table 7.1: Assuming that g is polynomial-time computable, how complex can the solution h
of (1.1) be?

Assumptions Upper bounds Lower bounds

None —— can be (non-unique and) all non-computable:

Aberth (1971), Pour-El & Richards (1979),
Ko (1983)
h is the unique computable: Osgood (1898), can take arbitrarily long time: Miller (1970),
solution Pour-El & Richards (1979) Ko (1983)

condition (5.4) exponential-space: Ko (1992) can be EXPSPACE-hard (our Theorem 5.5)

the Lipschitz polynomial-space: Ko (1983) can be PSPACE-hard (our Theorem 3.2)

condition (1.2)
g is analytic polynomial-time: ——
Ko & Friedman (1988),
Kawamura (2010a)

20
7.2 Constructive versions
A reasonable criticism about the results in Table 7.1 is that they deal with the complexity
of each single solution h, whereas the practical concern for numerical analysts would be the
complexity of the operator that “computes h from g.” For computability, such constructive
formulation is possible through a suitable representation of the function space (see Chap-
ter 6 of Weihrauch (2000)). For complexity, formulation of constructive results requires
some more ideas, and is undertaken in a recent work of Kawamura & Cook (2010b).

Acknowledgements
The author is grateful to Stephen A. Cook, Ker-I Ko and the anonymous referees for
comments on the manuscript that helped improve the presentation.
This work was supported in part by the Nakajima Foundation and by the Natural
Sciences and Engineering Research Council of Canada.
A preliminary version of this work appeared as Kawamura (2009b).

References
O. Aberth (1971). The Failure in Computable Analysis of a Classical Existence Theorem for
Differential Equations. Proceedings of the American Mathematical Society 30, 151–156.

P. Beame, S. Cook, J. Edmonds, R. Impagliazzo & T. Pitassi (1998). The Relative Com-
plexity of NP Search Problems. Journal of Computer and System Sciences 57(1), 3–19.

V. Brattka, P. Hertling & K. Weihrauch (2008). A Tutorial on Computable Analysis. In

New Computational Paradigms: Changing Conceptions of What is Computable, S. B. Cooper,
B. Löwe & A. Sorbi, editors, 425–491. Springer.

D. Cenzer & J. B. Remmel (2004). Index Sets for Computable Differential Equations. Mathe-
matical Logic Quarterly 50(4-5), 329–344.

A. Edalat & D. Pattinson (2004). A Domain Theoretic Account of Picard’s Theorem. In

Proceedings of the 31st International Colloquium on Automata, Languages and Programming,
volume 3142 of Lecture Notes in Computer Science, 494–505.

H. Friedman (1984). The Computational Complexity of Maximization and Integration. Advances

in Mathematics 53, 80–98.

W. Gay, B. Zhang & N. Zhong (2001). Computability of Solutions of the Korteweg–de Vries
Equation. Mathematical Logic Quarterly 47(1), 93–110.

D. S. Graça, J. Buescu & M. L. Campagnolo (2008). Boundedness of the Domain of Defini-

tion is Undecidable for Polynomial ODEs. In Proceedings of the Fourth International Conference
on Computability and Complexity in Analysis, volume 202 of Electronic Notes in Theoretical
Computer Science, 49–57.

A. Grzegorczyk (1955). Computable Functionals. Fundamenta Mathematicae 42, 168–202.

21
H. J. Hoover (1990). Feasible Real Functions and Arithmetic Circuits. SIAM Journal on
Computing 19(1), 182–204.
A. Kawamura (2009a). Differential Recursion. ACM Transactions on Computational Logic
10(3), Article 22.
A. Kawamura (2009b). Lipschitz Continuous Ordinary Differential Equations are Polynomial-
Space Complete. In Proceedings of the 24th Annual IEEE Conference of Computational Complex-
ity, 149–160.
A. Kawamura (2010a). Complexity of Initial Value Problems. Manuscript.
A. Kawamura & S. Cook (2010b). Complexity Theory for Operators in Analysis. To appear
in Proceedings of the 42nd ACM Symposium on Theory of Computing.
K. Ko (1983). On the Computational Complexity of Ordinary Differential Equations. Information
and Control 58, 157–194.
K. Ko (1991). Computational Complexity of Real Functions. Birkhäuser Boston.
K. Ko (1992). On the Computational Complexity of Integral Equations. Annals of Pure and
Applied Logic 58(3), 201–228.
K. Ko & H. Friedman (1982). Computational Complexity of Real Functions. Theoretical
Computer Science 20(3), 323–352.
K. Ko & H. Friedman (1988). Computing Power Series in Polynomial Time. Advances in
Applied Mathematics 9, 40–50.
W. Miller (1970). Recursive Function Theory and Numerical Analysis. Journal of Computer
and System Sciences 4, 465–472.
dy
W. F. Osgood (1898). Beweis der Existenz einer Lösung der Differentialgleichung dx = f (x, y)
ohne Hinzunahme der Cauchy-Lipschitz’schen Bedingung. Monatshefte für Mathematik 9(1),
331–345.
C. H. Papadimitriou (1994). Computational Complexity. Addison Wesley.
M. B. Pour-El & I. Richards (1979). A Computable Ordinary Differential Equation Which
Possesses No Computable Solution. Annals of Mathematical Logic 17(1-2), 61–90.
M. B. Pour-El & I. Richards (1981). The Wave Equation with Computable Initial Data such
that its Unique Solution is not Computable. Advances in Mathematics 39(3), 215–239.
M. B. Pour-El & N. Zhong (1997). The Wave Equation with Computable Initial Data Whose
Unique Solution is Nowhere Computable. Mathematical Logic Quarterly 43, 499–509.
K. Weihrauch (2000). Computable Analysis: An Introduction. Texts in Theoretical Computer
Science. Springer.
K. Weihrauch & N. Zhong (2002). Is Wave Propagation Computable or Can Wave Computers
Beat the Turing Machine? Proceedings of the London Mathematical Society 85(2), 312–332.
K. Weihrauch & N. Zhong (2006). Computing Schrödinger Propagators on Type-2 Turing
Machines. Journal of Complexity 22(6), 918–935.
N. Zhong (2007). Computable Analysis of a Boundary-Value Problem for the Korteweg–de Vries
Equation. Theory of Computing Systems 41(1), 155–175.

22