Complexity Theory for Operators in Analysis
Akitoshi Kawamura
University of Toronto
kawamura@cs.toronto.edu
Stephen Cook
University of Toronto
sacook@cs.toronto.edu
ABSTRACT
We propose a new framework for discussing computational com-
plexity of problems involving uncountably many objects, such as
real numbers, sets and functions, that can be represented only by
approximation. The key idea is to use a certain class of string func-
tions, which we call regular functions, as names representing these
objects. These are more expressive than infinite sequences, which
served as names in prior work that formulated complexity in more
restricted settings. An important advantage of using regular func-
tions is that we can define their size in the way inspired by higher-
type complexity theory. This enables us to talk about computation
on regular functions whose time or space is bounded polynomi-
ally in the input size, giving rise to more general analogues of the
classes P, NP, and PSPACE. We also define NP- and PSPACE-
completeness under suitable many-one reductions.
Because our framework separates machine computation and se-
mantics, it can be applied to problems on sets of interest in analysis
once we specify a suitable representation (encoding). As prototype
applications, we consider the complexity of functions (operators)
on real numbers, real sets, and real functions. The latter two can-
not be represented succinctly using existing approaches based on
infinite sequences, so ours is the first treatment of them. As an in-
teresting example, the task of numerical algorithms for solving the
initial value problem of differential equations is naturally viewed as
an operator taking real functions to real functions. As there was no
complexity theory for operators, previous results could only state
how complex the solution can be. We now reformulate them to
show that the operator itself is polynomial-space complete.
Categories and Subject Descriptors
F.1.3 [Computation by Abstract Devices]: Complexity Measures
and Classes
General Terms
Theory
This is a preprint. The official version will appear in the Proceedings of the
42nd ACM Symposium on Theory of Computing (STOC 2010), June 5–8,
2010, Cambridge, Massachusetts, USA.
Keywords
computable analysis, computational complexity, higher-type com-
plexity, second-order polynomials
1. INTRODUCTION
Computable analysis [19] studies problems involving real num-
bers, sets and functions from the viewpoint of computability. Un-
countably many objects (such as real numbers) are represented by
infinite sequences of approximations and processed by Turing ma-
chines. This framework is applicable not only to the real num-
bers but also with great generality to other spaces arising naturally
in mathematical analysis. There is a unified way to discuss com-
putability of real functions, sets of real numbers, operators taking
real functions as inputs, and so on.
In contrast, the application of this approach to computational
complexity has been limited in generality. For example, although
there is a widely accepted notion of polynomial-time computable
real functions f W Œ0; 1 ! R on the compact interval that has been
studied extensively [14], the same approach does not give a nice
class of real functions on R. Most of the complexity results in
computable analysis to date (with a few exceptions [6, 18, 20])
are essentially limited to the complexity of either real functions
with compact domain or of bounded subsets of R. They do not
address the complexity of, say, an operator F that takes real func-
tions f W Œ0; 1 ! R to another real function F.f /. There are many
results [12] about such operators, but typically the positive and neg-
ative results are stated in the form
if f is in the (small) complexity class X , then F.f / is
in complexity class Y , and
there is f in complexity class X such that F.f / is
hard for Z.
More direct (and preferable) statements would be the “construc-
tive” or “effectivized” form
the operator F is in class Y , and
the operator F is Z-hard,
where Y and Z are the “higher-order versions” of Y and Z. At the
level of computability, it is common to ask, as soon as we see an
ineffective result, whether it can be effectivized. For complexity,
we cannot even ask this question because we do not know how to
formulate Y and Z. This limitation has been widely recognized;
see, for example, [12, pp. 57–58], [20], and [3, p. 484].
The present paper addresses this problem. We start with the ob-
servation (Section 2) that the aforementioned limitation has to do
with the fact that traditional formulations of computable analysis
do not take into account the “size” of the infinite sequences given
to the machine as input. We then propose (Section 3) an extension
on the machine model by replacing infinite sequences by what we
call regular functions from strings to strings. An important advan-
tage of regular functions is that we can define their size in the way
suggested by type-two complexity theory [16, 7]. This enables us
to measure the growth of running time (or space) in terms of the
input size—exactly what we do in the usual (type-one) Complex-
ity Theory. We thus obtain the complexity classes analogous to P,
NP, PSPACE (and function classes FP and FPSPACE) by bound-
ing the time or space by second-order polynomials in the input
size. Analogues of many-one reductions and NP- and PSPACE-
hardness will also be introduced.
We apply this framework to a few specific problems in analy-
sis by using suitable representations of real numbers, real sets, and
real functions (Section 4). For real numbers, the induced complex-
ity notions turn out to be equivalent to what has been studied by
Ko–Friedman [10] and Hoover [6]. For sets and functions, our ap-
proach seems to be the first to provide complexity notions in a uni-
fied manner. This is of particular interest, because many numerical
problems in the real world are naturally formulated as operators
taking sets or functions. For example, consider the operator F that
finds the solution F.f / of the differential equation (of a certain
class) given by a function f . As mentioned above, the existing in-
effective results [11, 8] only tell us how complex the solution F.f /
can be when f is easy; precisely, they say that if f is polynomial-
time computable, F.f / is polynomial-space computable and can
be polynomial-space hard. But the practical concern for numeri-
cal analysis would be how hard it is to compute F (i.e., to compute
F.f / given f ). We formulate and prove the first result of this kind:
F itself is a polynomial-space complete operator. Our contribution
is in introducing the framework making such formulations possible,
solving an important open problem as explained above. The techni-
cally hard parts of the proofs of the specific results are already done
in the proofs of the ineffective versions, and all we need to do is to
check that they effectivize in our sense. The original ineffective
versions are now corollaries of the effectivized statements.
2. TYPE-TWO THEORY OF
EFFECTIVITY
Computable Analysis dates back at least to Grzegorczyk [5],
and there have been several equivalent formulations. Weihrauch’s
Type-Two Theory of Effectivity (TTE) is a powerful framework. In
this section, we briefly introduce computable analysis through TTE
and clarify its limitations in dealing with complexity.
2.0 Multi-functions
Before discussing TTE, we begin with a few words about multi-
valued functions, or multi-functions. A multi-function F from a
set X to a set Y is formally a subset of X Y . For x 2 X , we
write FŒx for the set of y 2 Y such that .x; y/ belongs to this
subset. These y are the “allowable outputs” on input x. We denote
by dom F the set of x 2 X for which F Œx is nonempty. When FŒx
is a singleton, its unique element is denoted by F.x/, as usual. If
FŒx is a singleton for all x 2 dom F, we say that F is a partial
function. When in addition dom F D X , we say that F is a total
function, or simply a function.
Like some authors, we regard the so-called “function problems”
(also called search problems) as multi-functions. The classes FP
and FPSPACE are the sets of multi-functions from strings to strings
that are computed by a machine whose time/space is polynomially
bounded. Here, the word “compute” is interpreted according to
the “allowable outputs” semantics of multi-functions: A machine
is said to compute F if, on any input x 2 dom F, it outputs some
element of FŒx. The classes FP
2
and FPSPACE
2
that we will
define later will also consist of multi-functions.
Note that we do not care what happens on inputs outside dom F ,
unlike some authors who require that such inputs be rejected explic-
itly. Thus, a multi-function can be easy to compute while having a
nasty domain. We also note, however, that allowing dom F to be
smaller than X is not so important in the context of time- or space-
bounded computation, because a machine that runs past the time
bound for some inputs can be modified so that it keeps track of the
time and outputs an error message when it has run out of time.
2.1 Computability
In the usual Computability Theory, we introduce computability
for functions from ˙
to ˙
under some machine model, where
˙
is the set of strings. To discuss computation on other sets X ,
we specify an encoding of X —that is, a rule for interpreting an
element of ˙
as an element of X .
TTE roughly follows the same path. But since the countable
set ˙
cannot encode uncountable sets, such as the set R of real
numbers, TTE uses the set ˙
N
of infinite sequences.
Computability of functions from ˙
N
to ˙
N
is defined using Tur-
ing machines. The machine has an input tape, an output tape and
a work tape, each of which is infinite to the right. We also assume
that the output tape is one-way, that is, the only instruction for the
output tape is “write a 2 ˙ in the current cell and move the head
to the right”. The difference from the usual setting is in the conven-
tion by which the machine reads the input and delivers the output.
The input is now an infinite string a
0
a
1
: : : 2 ˙
N
, and is written
on the input tape before the computation starts (with the tape heads
at the leftmost cell). We say the machine outputs an infinite string
b
0
b
1
: : : 2 ˙
N
if it never halts and writes the string indefinitely
(that is, for each n 2 N, it eventually writes b
0
: : : b
n1
into the first
n cells) on the output tape. This defines a class of (possibly partial)
computable functions (without any time or space bound) from ˙
N
to ˙
N
. The definition can be extended to multi-functions A: We
say that a machine M computes A if M , on any input ' 2 dom A,
always outputs some element of AŒ'.
A representation of a set X is formally a partial function from
˙
N
to X which is surjective—that is, for each x 2 X , there is at
least one ' 2 ˙
N
with .'/ D x. We say that ' is a -name
of x. Using representations, computability of multi-functions on
represented sets is defined as follows.
Definition 2.1. Let and ı be representations of sets X and Y , re-
spectively. We say that a machine .; ı/-computes a multi-function
A from X to Y if it computes the multi-function ı
1
ı A ı given
by
.ı
1
ı A ı /Œ'
D
(
f 2 dom ı W ı. / 2 AŒ .'/ g if ' 2 dom ;
; otherwise:
(1)
In other words, whenever the machine is given a -name of an
element x 2 dom A, it must output some ı-name of some element
of AŒx (Figure 1).
As an example, we define a representation
R
of R, the set of
real numbers. First, for each n 2 N, let D
n
denote the set of strings
of form
sx=1 00 : : : 0
„ƒ‚…
n
; (2)
where s 2 fC; g and x 2 f0; 1g
. Let D D
S
n2N
D
n
. A string
in D encodes a rational number in the obvious sense (read (2) as a
˙
N
//
²²
˙
N
ı
²²
X
A
//
Y
Figure 1: .; ı/-computing a multi-function A.
fraction whose numerator and denominator are integers written in
binary with leading zeros allowed). We write JuK for the rational
number encoded by u 2 D. We define a representation
R
of R
by saying that an infinite string ' 2 ˙
N
is a
R
-name of x 2 R
if ' is of the form u
0
#u
1
#u
2
# : : : (where # is a delimiter symbol
not appearing in the u
i
) such that u
i
2 D and jJu
i
K xj < 2
i
for
each i 2 N. Thus, this representation specifies a real number as a
list of rational numbers converging to it.
It turns out that
R
is a natural representation with which to dis-
cuss computability of real functions. In particular,
R
is admis-
sible, that is, it matches well with the usual topology of R [19,
Lemma 4.1.6].
To deal with functions of two arguments, we define, for represen-
tations and ı of sets X and Y , a new representation Œ; ı of X Y
by Œ; ı.a
0
b
0
a
1
b
1
a
2
b
2
: : :/ D . .a
0
a
1
a
2
: : :/; ı.b
0
b
1
b
2
: : ://.
Example 2.2. Binary addition C W R R ! R is .Œ
R
;
R
;
R
/-
computable. For suppose that we are given names ' D u
0
#u
1
# : : :
and D v
0
#v
1
# : : : of real numbers s and t. An approximation
of s C t with precision 2
m
, for each m, is given by Ju
mC1
K C
Jv
mC1
K.
Example 2.3. Multiplication W R R ! R is .Œ
R
;
R
;
R
/-
computable. For suppose that we are given names ' D u
0
#u
1
# : : :
and D v
0
#v
1
# : : : of real numbers s and t . First, let k D
maxfju
0
j; jv
0
jg. Since Ju
0
K and Jv
0
K are near s and t, and it takes
more than k digits to encode a number with absolute value 2
k
,
we have jsj, jtj < 2
k
. Hence, s t is approximated with precision
2
m
by Ju
mCkC1
K Jv
mCkC1
K.
The strength of TTE is that, by using suitable representations, we
can discuss computation over sets other than R. Moreover, there
are often standard ways to introduce representations of higher-type
objects, such as sets or of functions. For example, since we have
agreed on the representations
R
of R, we can introduce a canon-
ical representation of the set CŒR of continuous real functions,
and there are reasons to believe that this is the “right” represen-
tation [19, Chapter 3].
2.2 Complexity
Now we ask whether the computation runs in polynomial time.
We ask whether the time it takes to output the nth prefix of the
output is bounded by a polynomial in n (independently of '):
Definition 2.4. A machine M runs in polynomial time if there is a
polynomial p such that for all ' 2 ˙
N
and n 2 N, the machine M
on input ' finishes writing the first n symbols of the output within
p.n/ steps. Define polynomial space analogously by counting the
number of visited cells on all (input, work and output) tapes.
Can we use this notion to define polynomial-time computability
of, say, a real function?
2.2.1 Representations must be chosen carefully
A little thought shows that the simple combination of Defini-
tion 2.4 and the representation
R
is useless [19, Examples 7.2.1,
7.2.3]. On the one hand, the machine M could “cheat” by writ-
ing redundant
R
-names: By writing C10000=100000 instead of
C1=10, it gets more time to compute the next approximation. On
the other hand, the machine may suffer by receiving redundant
names as input, such as the one in which the first approximation
is too long to even read in time.
Thus, to develop a meaningful complexity theory, we need to
disallow redundancy carefully. This leads to the use of signed
digit representation
sd
of R [19, Definition 7.2.4], defined as fol-
lows: dom
sd
consists of sequences ' 2 ˙
N
of form a
k
: : : a
1
a
0
a
1
a
2
: : : for some k, where each a
i
is either 0, 1 or 1, such that
either k D 0 or .a
k
; a
k1
/ 2 f.1; 0/; .1; 1/; .1; 0/; .1; 1/g; if
this is the case, set
sd
.'/ D
k
X
iD1
a
i
2
i
(3)
Thus, we read the digit sequence as a binary expansion of a real
number (with decimal point ) with digits 0, 1 and 1; we forbid
certain patterns in the first two digits of the integer part in order to
exclude redundancy. (See [19, Example 2.1.4.7] for the reason why
the usual binary expansion without the “1” digit does not work.)
Let
sd
j
Œ0;1
denote the restriction of
sd
to (infinite sequences
representing) real numbers in Œ0; 1. By Definition 2.4, we know
what it means for a real function f W Œ0; 1 ! R to be polynomial-
time .
sd
j
Œ0;1
;
sd
/-computable. This notion turns out to be robust
and natural, and equivalent to the widely accepted polynomial-time
computability of Ko and Friedman [10], so we will drop the pre-
fix “.
sd
j
Œ0;1
;
sd
/” from now on. The same goes for polynomial-
space computability, and for functions on compact intervals or rect-
angles instead of Œ0; 1 (use the pairing function as in Examples 2.2
and 2.3). It is routine to verify that, for example, addition and multi-
plication C, W Œ0; 1Œ0; 1 !R are polynomial-time computable.
For more interesting results, see Ko’s book [12], survey [14] or
Weihrauch’s book [19, Section 7.3].
2.2.2 Difficulties in generalizing to other spaces
Unfortunately, this approach does not extend much further. For
example, a naive extension to real functions on R (instead of Œ0; 1)
does not work: polynomial-time .
sd
;
sd
/-computability tends to
fail for trivial reasons, as in the following example.
Example 2.5. Addition on R (Example 2.2) is not polynomial-time
.Œ
sd
;
sd
;
sd
/-computable. For suppose that a machine .Œ
sd
;
sd
;
sd
/-computed it within polynomial time bound p. In particular,
the machine has to write the first symbol of the output in t WD p.1/
steps or fewer. Note that this first symbol must be 1 if the sum is
greater than 1, and 1 if the sum is less than 1. In particular, it
must be 1 if the two summands are 2
tC100
and 2
tC50
, and 1
if they are 2
tC50
and 2
tC100
. However, the machine cannot tell
between these two cases, because it can read at most t symbols of
the input in time.
The trouble seems to be that the time bound is independent of the
input. Compare this with the addition of integers (written in binary)
by the usual Turing machine. It is in polynomial time, because a
large summand would make the “input size” big and thereby give
the machine more time. For the same thing to happen for addition
of the real numbers, we would need to talk about the “size” of the
input and a time bound “polynomial in” it, but we do not have the
notion of size for infinite sequences.
This problem is not just about real numbers. There are many
other objects that we want to give representations to. The objects
1
0
?
S
Figure 2: Computing a set S .
for which TTE gives reasonable notions of complexity are limited
1
,
compared to what we can do at the level of computability. This has
long been recognized as a challenge; see, for example, [12, pp. 57–
58], [20, Section 1], or [3, p. 484]. As a result of this limitation, the
complexity of operators working on objects other than real numbers
has been mostly formulated in non-constructive (ineffective) forms.
We quote examples of such theorems below. We will reformulate
them in effectivized forms later (Theorems 4.6 and 4.9).
2.2.3 Ineffective results
The first pair of results are the positive and negative statements
about the operator of taking the convex hull CH.S / of a closed set
S Œ0; 1
2
.
Polynomial-time computability (deterministic or nondeterminis-
tic) of a set S Œ0; 1
2
is defined using usual Turing machines as
follows (see e.g. Braverman [4] for a discussion on this definition).
We say that S is (nondeterministic) polynomial-time computable if
there is a (nondeterministic) polynomial-time Turing machine that
computes a function ' W ˙
! f0; 1g such that, for any n 2 N and
u, v 2 D,
'.u; v; 0
n
/ D 1 if dist..JuK; JvK/; S/ < 2
n
, and
'.u; v; 0
n
/ D 0 if dist..JuK; JvK/; S/ > 2 2
n
,
where dist.p; S/ WD inf
q2S
kp qk denotes the Euclidean distance
of point p 2 R
2
from S (Figure 2).
Theorem 2.6 (Essentially
2
in [15, Corollary 4.3]). If a set S
Œ0; 1
2
is polynomial-time computable, then CH.S/ is nondetermin-
istic polynomial-time computable.
Theorem 2.7 (Essentially
2
in [15, Corollary 4.6]). Unless P D
NP, there exists a set S Œ0; 1
2
which is polynomial-time com-
putable, but whose convex hull CH.S/ is not.
For A R
d
, let CŒA be the set of continuous functions from A
to R. The second pair of results concerns the differential equation
h
.
0
/
D
0
;
h
0
.t/ D g
t; h.t/
(4)
called the initial value problem (IVP), where g 2 CŒŒ0; 1 R is
given and h 2 CŒ0; 1 is the unknown. The Picard–Lindelöf (or
1
We note, however, that Weihrauch [20] and Schröder [17] study
how far we can get with the infinite string model.
2
Ko and Yu state these results for strong recognizability instead of
computability, but their proof almost works for computability as
well. See Braverman [4] for a comparison of the two notions ([4]
says weak computability for Ko’s strong recognizability). In the
present paper, Theorems 2.6 and 2.7 will be derived as corollaries
of the effective version, Theorem 4.6.
Cauchy–Lipschitz) Theorem states that the solution h exists and is
unique if g is Lipschitz continuous (in the second argument), i.e.,
jg.t; y
0
/ g.t; y
1
/j L jy
0
y
1
j (5)
for some nonnegative constant L independent of t, y
0
, y
1
. The
following results state how complex h can be, assuming that g is
polynomial-time computable. Since polynomial-time computabil-
ity is defined only for functions with compact domain, we restrict
g to the rectangle Œ0; 1 Œ1; 1. If there is a solution h 2 CŒ0; 1
whose values stay in Œ1; 1 (in which case h is unique, as men-
tioned above), we write LipIVP.g/ for this h. Thus, LipIVP is a
partial function from CLŒŒ0; 1 Œ1; 1 to CŒ0; 1, where the for-
mer set is the subset of CŒŒ0; 1 Œ1; 1 consisting of functions
Lipschitz continuous in the second argument.
Theorem 2.8 ([11, Section 4]
3
). If g 2 dom LipIVP is polynomial-
time computable, then LipIVP.g/ is polynomial-space computable.
Theorem 2.9 ([8, Theorem 3.2]). There is a polynomial-time com-
putable function g 2 dom LipIVP such that LipIVP.g/ is poly-
nomial-space complete (in the sense defined in [13] or [8]).
We can derive from Theorem 2.9 a statement of a similar form
to Theorem 2.7: unless P D PSPACE, there is a real function g 2
dom LipIVP which is polynomial-time computable but LipIVP.g/
is not.
3. FUNCTIONS AS NAMES
We present the main definitions for our framework here.
As we have noted, the limitations of the TTE approach have to
do with the fact that the information carried by infinite sequences in
˙
N
is not rich enough, and in particular we do not have the notion
of their size. We replace ˙
N
with Reg, a class of string functions
which we will use as names of real numbers, sets and functions
4
.
This section develops a complexity theory for computation over
Reg, introducing the analogues of classes P, NP, PSPACE and the
notions of completeness under many-one reductions.
3.1 Computation over regular functions
We say that a (total) function ' W ˙
! ˙
is regular if it pre-
serves relative lengths of strings in the sense that j'.u/j j'.v/j
whenever juj j vj. We write Reg for the set of all regular func-
tions (the motivation for considering these functions will become
clear in Section 3.2 where we define their lengths).
Now we begin replacing the role of ˙
N
in TTE (see Section 2.1)
by Reg. This is a generalization, since an infinite string a
0
a
1
: : : 2
˙
N
can be identified with a regular function ' 2 Reg which
(a) takes values of length 1, and
(b) depends only on the length of the argument,
by setting '.0
n
/ D a
n
. In the following, observe that Definitions
3.1 and 3.2 extend their counterparts in TTE in this sense.
Since we will deal with an analogue of NP, and nondetermin-
ism is better understood for predicates (f0; 1g-valued functions),
it sometimes makes sense to stop the generalization halfway, re-
moving (b) only and keeping (a). Let Pred Reg be the set of
f0; 1g-valued regular functions.
Instead of the machine in TTE that converted infinite strings to
infinite strings, we use an oracle Turing machine (henceforth just
“machine”) to convert regular functions to regular functions:
3
The original theorem is stated with a condition slightly weaker
than Lipschitz continuity.
4
Ko’s formulation [12] already uses string functions instead of in-
finite strings of TTE, but it does not make full use of this extension.
Definition 3.1. 1. A deterministic machine computes a func-
tion F W Reg ! Reg if, given ' as oracle and u as string
input, it outputs F.'/.u/ and halts.
2. A nondeterministic machine computes a function F W Reg !
Pred if, given ' as oracle and u as input, it has at least one
accepting branch exactly when F.'/.u/ D 1.
For the precise conventions for issuing and answering queries,
follow any of [16, 7, 12].
As before, we can extend these definitions to multi-functions F
by saying that a machine computes F if on any input ' 2 dom F it
outputs some element of FŒ'.
3.2 Polynomial time and space
Recall that regular functions are those that respect lengths in the
sense explained at the beginning of Section 3.1. In particular, they
map strings of equal lengths to strings of equal lengths. Therefore,
it makes sense to define the size j'j W N ! N of a regular function '
by j'j.juj/ D j'.u/j. It is a non-decreasing function from N to N.
Now we want to define what it means for a machine to run in
polynomial time. Since j'j is a function, we begin by defining poly-
nomials “in” a function, following the idea of Kapron and Cook [7].
Second-order polynomials (in type-1 variable L and type-0 vari-
able n) are defined inductively as follows: a positive integer is
a second-order polynomial; the variable n is also a second-order
polynomial; if P and Q are second-order polynomials, then so are
P C Q, P Q and L.P/. An example is
L
L.n n/
C L
L.n/ L.n/
C L.n/ C 4: (6)
A second-order polynomial P specifies a function, which we also
denote by P , that takes a function p W N ! N to another function
P .p/ W N ! N in the obvious way. For example, if P is the above
second-order polynomial (6) and p.x/ D x
2
, then P .p/ is given
by
P .p/.x/ D
.x x/
2
2
C .x
2
x
2
/
2
C x
2
C 4
D x
8
C x
4
C x
2
C 4: (7)
As in this example, P .p/ is a (usual first-order) polynomial if p is.
Definition 3.2. A (deterministic or nondeterministic) machine M
runs in (second-order) polynomial time if there is a second-order
polynomial P such that, given any ' 2 Reg as oracle and any u 2
˙
as input, M halts within P.j'j/.juj/ steps (regardless of the
nondeterministic choices). Define polynomial space analogously
by counting the number of visited cells on all (input, work, output
and query) tapes.
When ' satisfies (a), the size j'j is a constant function, so the
bound P .j'j/.juj/ reduces to a (usual first-order) polynomial in
juj. Therefore, Definition 3.2 can be viewed as an extension of
Definition 2.4.
Definition 3.3. 1. We write FP
2
(resp. FPSPACE
2
) to denote
the class of multi-functions from Reg to Reg computed by a
deterministic machine that runs in second-order polynomial
time (resp. space).
2. We write P
2
(resp. NP
2
) for the class of multi-functions from
Reg to Pred computed by a deterministic (resp. nondeter-
ministic) machine M that runs in polynomial time.
Note that unlike FP and FPSPACE, it is easy to separate, e.g.,
FP
2
and FPSPACE
2
, because an FPSPACE
2
machine can make
exponentially many queries to the given oracle.
It is easy to see that the classes defined here respect the corre-
sponding usual complexity classes:
Lemma 3.4. 1. Functions in FP
2
(resp. FPSPACE
2
) map reg-
ular functions in FP to FP (resp. FPSPACE to FPSPACE).
2. Functions in P
2
(resp. NP
2
) map regular functions in FP to
P (resp. NP).
Why we restrict ourselves to regular functions
The idea of using second-order polynomial as a bound on time
and space comes from Kapron and Cook’s characterization [7] of
Mehlhorn’s class [16] of polynomial-time computable operators
5
.
This is a class of (total) functionals F W .˙
! ˙
/ ˙
! ˙
,
but they can be regarded as F W .˙
! ˙
/ ! .˙
! ˙
/ by
writing F.'/.x/ instead of F.'; x/. Kapron and Cook define the
size of ' W ˙
! ˙
by
j'j.n/ D max
jujn
j'.u/j; n 2 N: (8)
Note that our definition of size for regular ' is a special case of this.
Then they defined the class of polynomial-time functionals in the
same way as Definition 3.3.1. (We added FPSPACE
2
by analogy.)
We have restricted attention to regular functions. This is be-
cause, in order to obtain reasonable complexity notions, it seems
necessary to be able to simulate a given machine with known time
bounds. Note that for usual (type-one) computation, it was easy to
find jxj given x, and thus to clock the machine with the time bound
p.jxj/ for a fixed polynomial p. In contrast, finding the value (8)
for a given ' in general requires exponentially many queries to '
and thus exponential time. For regular ', we can easily find j'j.n/
for each n, and thus the second-order polynomial P .j'j/.juj/ is a
bound “time-constructible” from ' and u.
Regular functions ' suffice for our purpose, because our inten-
tion is to use ' as names of real numbers, sets and functions, and
there seems to be little incentive to use irregular names. All repre-
sentations in this paper (Section 4) will use regular functions only.
3.3 Reduction and completeness
Recall that the definition of the usual many-one reduction be-
tween multi-functions A, B from ˙
to ˙
is as follows: we say
that A many-one reduces to B (written A
1
mF
B) if there are (to-
tal) functions r, t 2 FP such that for any u 2 dom A, we have
r.v/ 2 AŒu whenever v 2 BŒt .u/—that is, we have a function t
that converts an input for A to an input for B, and another func-
tion r that converts an output of B to an output of A (we omit r
in the many-one reduction
1
m
between predicates). Since multi-
functions over Reg also get a function as input, the analogous defi-
nition of reduction involves one more converter s:
Definition 3.5. 1. Let A and B be multi-functions from Reg to
Reg. We say that A many-one reduces to B (written A
2
mF
B) if there are (total) functions r , s, t 2 FP
2
such that for any
' 2 dom A, we have s.'/ 2 dom B and r .'/ı ıt.'/ 2 AŒ'
whenever 2 BŒs.'/ (Figure 3).
2. Let A and B be multi-functions from Reg to Pred. We write
A
2
m
B if there are functions s, t 2 FP
2
such that for any
' 2 dom A, we have s.'/ 2 dom B and ı t .'/ 2 AŒ'
whenever 2 BŒs.'/.
5
Kapron and Cook [7] call them Basic Feasible Functionals or Ba-
sic Polynomial-Time Functionals.
