Complexity classes and fragments of C

l

ra-

Information Processing Letters 88 (2003) 213–218

www.elsevier.com/locate/ip

Complexity classes and fragments of C

Lars Kristiansena,∗, Paul J. Vodab

a Oslo University College, Faculty of Engineering, Cort Adelers Gate 30, N-0254 Oslo, Norwayb Institute of Informatics, Comenius University Bratislava, Mlynská dolina, 842 15 Bratislava, Slovakia

Received 4 November 2002; received in revised form 12 August 2003

Communicated by H. Ganzinger

Keywords: Complexity theory; Programming languages

1. Introduction ation that might increase something, the situation d

kenalingill

fps,tea-ea-all

m-lan-anyC

al-per-

matically changes.ve

ach

rray

e

in

erved

Tiny fragments of programming languages, liPascal or C, might yield an enormous computatiopower. Just a few arithmetical operations, like addand subtracting 1, a test for 0, and while-loops, wgive full Turing computability. A similar handful osimple operations and for-loops, but no while-loowill give enough computational power to compuany primitive recursive function, that is, computtional power far beyond everything considered as fsible. Thus it seems hard to characterize the smand important complexity classes studied in coputer science, by fragments of such programmingguages, and it seems unlikely that there should beneat and natural fragments of, let us say, standardthat capture complexity classes likeP, LOGSPACEorLINSPACE. Surprisingly enough, as soon as we dislow the successor operation, and in general any o

* Corresponding author.E-mail addresses: [email protected] (L. Kristiansen),

[email protected] (P.J. Voda).URLs: http://www.iu.hio.no/~larskri,

http://www.fmph.uniba.sk/~voda.

0020-0190/$ – see front matter 2003 Elsevier B.V. All rights resdoi:10.1016/j.ipl.2003.08.010

The programs which we study in this paper haforms given by the grammar

k ∈ Constant ::= decimal number

a ∈ Array ::= array identifier, each has an arity1

r ∈ Register ::= register identifier,

disjoint from Array

e ∈ Entry ::= a[r1, . . . ,rn]s ∈ Statement::= r1 := r2 | r := k | r- |

set(e) | reset(e)| if e {p} | for r {p} | while

r {p} | reject | acceptp ∈ Program ::= s | s;pThe semantics is as expected from the syntax. Eregister holds a natural number, i.e., a value inN. Thearrays are of arbitrary size, and each entry in an aholds a bit, i.e., a value in{0,1} ({false, true}). If theregisterr holds the natural numbern, thena[r] refersto thenth entry in the arraya. This generalizes in th

1 An array’s arity is its number of dimensions, assumed fixedany one program.

.

214 L. Kristiansen, P.J. Voda / Information Processing Letters 88 (2003) 213–218

obvious way to arrays with arity> 1. The statementr- decreases the number stored inr by 1 (if positive),

t

ent

t.ts

o

pute

r)nral

tillngen

terg input

r-lye;hend

Table 1The relationship between complexity classes and fragments

h ofe 1nts

ityh to]).the

metheal

l re-derursndthen-le-res-.

pro-ar-thendisby

rcexityinggu-ity

and r1 := r2 and r := k are ordinary assignmenoperations. Theset statement set(e) sets the bit in thearray entrye to 1 (true). Likewise, thereset statementreset(e) sets the bit in the array entrye to 0 (false).(Set and reset operations can be viewed as assignmof the formsa[r1, . . . ,rn] := 1 anda[r1, . . . ,rn] :=0.) The test if e {p} executesp if (and only if )the bit in the array entrye is 1 (true). Thewhile-loopwhile r {p} executes its bodyp while the valuein r is different from 0, and thefor-loop for r {p}executes its bodyn times in a row, wheren is the valuestored inr when the loop starts. A programacceptsits input iff the statementaccept is executed, and irejects its input iff the statementreject is executedA program will terminate immediately after it accepor rejects the input.

A program receives its input in one of the twmodes: (i)the bit mode or (ii) the numerical mode. Ifa program receives the input in the bit mode, the inwill be a string of bitss. When the program starts thith bit in s will be stored in the array entryinput[i],and the length ofs will be stored (as a natural numbein the registerN. If a program receives the input ithe numerical mode, the input will simply be a natunumber stored in the registerN when the programstarts. When a program starts all registers, excepN,are initialized to 0. Arrays are dynamical. They wbe allocated when the program starts, and the raof an arraya is given by the Pascal-like declaratioa : array[0 : n, . . . ,0 : n] of {0,1} wheren is set tothe maximum of the number stored in the input regisN and the numbers given by the constants occurrinthe program. Each entry in each array (except the inarray) will be initialized to 0 (false).

A program with no while-loops is afor-program,and a program with no for-loops is awhile-program.Any program is aset-reset program. A program withno reset statements is aset-only program, and aprogram with no set or reset statement is aread-onlyprogram. Now we can define 2× 3 × 2 fragmentsof our programming language: (1) read-only foprograms taking input in the bit mode; (2) read-onfor-programs taking input in the numerical mod. . . ; (12) set-reset while-programs taking input in tnumerical mode. (Nothing else is a fragment, ahenceforth the wordfragment will be exclusively used

s

Control Data Input

read-only set-only set-reset

for LOGSPACE P P bitLINSPACE ETIME ETIME numerical

while LOGSPACE P PSPACE bitLINSPACE ETIME ESPACE numerical

to refer to one of these twelve sublanguages.) Eacthe fragments will capture a complexity class. Tablgives a summary of complexity classes the fragmecapture.

We think our results are interesting forthree rea-sons.

(1) Complexity theory and programming languagetheory: We subscribe to the thesis that complexand programming language theories have mucoffer each other, in both directions (Jones [4,5Our results somewhat bridge the gap betweentwo areas. Moreover, they do also provide soevidence for the thesis. Jones [6] investigatesexpressive power of constructions in functionlanguages, e.g., tail recursion versus generacursion, first order programs versus higher orprograms, and he finds correspondences like obetween fragments of functional languages acomplexity classes. Hence, when we combineresults in [6] and Table 1, we end up with an iteresting analysis of the expressive power of ements of imperative languages versus the expsive power of elements of functional languages

(2) The naturalness of the complexity classes: Duringthe last three or four decades researchers havevided so-called resource-free and intrinsic chacterizations of the complexity classes, e.g.,seminal papers of Cobham [2], Fagin [3] aBellantoni–Cook [1]. One of the motivationsto show that the complexity classes, defineda particular machine model and explicit resoubounds, are natural entities, and that completheory is a robust and mathematically interestfield. The table above provides yet another arment in favor of the naturalness of the complexclasses.

L. Kristiansen, P.J. Voda / Information Processing Letters 88 (2003) 213–218 215

(3) Pedagogical value: Pascal and C like program-ming languages are in daily use by thousands of

willdi-ac-ry.

ndngeesardiound

1,de-b-

e

msec-ramdon)

ut.)a-

ne

-ells

on

of

rk-

ing in polynomial (respectively exponential) time. TheclassLOGSPACE(respectivelyLINSPACE, ESPACE) is

inen-

es-gis-

-

init

engineers and scientists. We hope this paperbe informative and enlightening to a wide auence, and will perhaps help nonspecialists toquire a better understanding of complexity theo

We have tried to make our proofs intuitive adirect such that they will be accessible to a wide raof readers. Readers not familiar with Turing machinand basic complexity theory should consult a standtextbook on the subject, e.g., Lewis–Papadimitr[8]. The paper builds on ideas from Kristiansen [7] aVoda [9].

2. Proofs

Before we prove the results indicated in Tablewe recallsome standard definitions and settle sometails. A problem is a set of natural numbers, i.e., a suset ofN. A programP (respectively Turing machinM) decides a problemA iff P (respectivelyM) ac-ceptsx if x ∈ A and rejectsx if x /∈ A. The input to aprogram is always a natural number, and for progrataking input in the bit mode, there should be no unnessary leading zeros in the input. For any one prog(Turing machine) we will usex to denote the input an|x| to denote the length (of the binary representatiof the input, i.e.,|x| = �log2 x + 1 whenx �= 0 and|0| = 1. (So,x is a variable; we will usek, n, k′, n′, etc.to denote fixed numbers not depending on the inpTo keep things simple, we assume that a Turing mchineM always has one read-only input tape and oread–write work tape. We say thatM works inpolyno-mial time (respectively space) iff there exists a polynomialφ such that the number of steps (respectively cvisited on the work tape) in the run ofM on inputx,is bounded byφ(|x|); M works in exponential time(respectively space) iff there exist fixedk,n ∈ N suchthat the number of steps (respectively cells visitedthe work tape) in the run ofM on inputx, is boundedby k2n|x|; M works in logarithmic (respectively lin-ear) space iff there exists fixedn ∈ N such that thenumber of cells visited on the work tape in the runM on inputx, is bounded byn(log2 |x| + 1) (respec-tively n|x|). The classP (respectivelyETIME) is theset of problems decidable by a Turing machine wo

the set of problems decidable by a Turing machworking in logarithmic (respectively linear, exponetial) space. The classesETIME andESPACEare some-times called EXP and EXPSPACE in the literature.

Lemma 1. Let P be any program (in any of thefragments), and let k ∈ N denote the value of thegreatest constant occurring in P. If an execution of Pstarts with the number v stored in the input register N,then no register in P will exceed max(v, k) during theexecution.

Proof. The only operations on registers, are predecsor and assignment operations. Moreover, every reter, exceptN, contains 0 when the execution starts.✷Lemma 2.

(i) While-programs can simulate for-loops,(ii) If the number m is stored in a register, then any

fragment can simulate the successor operation ona register holding a number <m.

(iii) Any fragment can simulate the construction ifX=0 then P else Q.

(iv) The function max(x, y) can be computed in anyfragment.

Proof. (i) The loopfor X {...} can be simulatedby the constructionY:= X; while Y{...; Y-}whereY is a new variable.

(ii) Assume thatx <m and thatx andm are respectively stored in the registersX andM. The for-programY:= M; for X {Y-}; Y-; X:= M; for Y{X-} increases the number inX by 1.

(iii) The following code shows that (iii) holds.

V:= 1; W:= 1; for X {V-};for V {W-}; for V {P}; for W {Q}

(iv) Storex in the registerX, y is in the registerY,and execute the programW:= Y; for X {W-};if W=0 then Z:= X else Z:= Y. Note thatmax(x, y) is stored in the registerZ when the programterminates. ✷

We will carefully prove the equalities indicatedTable 1 for all fragments receiving input in the b


mode. Thereafter we will explain how these proofscan be transformed into proofs of the equalities for the

Wegsely

)

he

ill

ialy

setng

ngere

her

ss

rst

edt

if m = 0). For each such transitionTi let Pi be theprogram given by

n-ere

f

-t

t-thes-le-

bit

a-utin-

altion

e

s a

fragments receiving input in the numerical mode.start in the right column of Table 1. In the followinLsrFb (respectivelyLsrW

b ) denotes the set of problemdecidable by a set-reset for-program (respectivwhile-program) taking input in the bit mode.

Theorem 1. (1) P = LsrFb and (2) PSPACE= LsrW

b .

Proof. We will argue first that the inclusions (1LsrFb ⊆ P and (2)LsrW

b ⊆ PSPACEhold. LetP be aset-reset for-program taking input in the bit mode. TregisterN stores the length of the input|x| when theprogram starts. By Lemma 1 there exists a fixedksuch that no register will exceed max(|x|, k) duringthe execution. Since there are no while-loops inP,the number of primitive steps in the execution wbe bounded byφ(|x|) for some fixed polynomialφ.It follows that the execution ofP on inputx can besimulated by a Turing machine running in polynomtime in |x|. Thus, inclusion (1) holds. It follows easilfrom Lemma 1 that also the inclusion (2) holds.

We will now argue that the inclusions (1)P ⊆ LsrFb

and (2) PSPACE⊆ LsrWb hold. First we show that a

Turing machineM running in polynomial time in thelength of the input, can be simulated by a set-refor-program taking input in the bit mode. The runnitime ofM on inputx will be bounded by max(|x|, k)nfor some fixedk,n ∈ N. The program simulatingMdoes not need to handle numbers beyond the ra0, . . . ,max(|x|, k)n. The numbers in the range arepresented in the base max(x, k)+1. Thus,n registervariables can hold one number in the range. Tprogram will representM ’s tape by a fixed numbeof n-dimensional arrays. Three arraysa0, a1 andaBwill be sufficient since we can assume without loof generality thatM ’s alphabet is{0,1}. (B denotesthe blank symbol.) Forκ ∈ {0,1,B}, the array entryaκ [Z1, . . . ,Zn] will be set equal to 1 iffκ is the symbolin tape cell numberz represented by the registeZ1, . . . ,Zn. We use the register variableS to representhe current state ofM. Theith transitionTi : qκq ′νmin M ’s transition table, says that ifM is in stateqscanning the symbolκ , thenM should go to stateq ′,write the symbolν, and move the head as indicatby m (left if m = −1; right if m = 1; no movemen

if S = q and aκ[Z1, . . . ,Zn] = true then{S:= q ′; reset(aκ[Z1, . . . ,Zn]);set(aν[Z1, . . . ,Zn]); movem}

wheremovem simulates the movements of the scaning head. Thus,move1 increases by 1 the numbrepresented byZ1, . . . ,Zn,move−1 decreases by 1 thnumber, andmove0 does nothing. Letstep denotethe programP1;P2; . . . ;Pr wherer is the number oftransitions inM ’s transition table. One execution ostep corresponds to one step in the execution ofM,and hence, we can simulateM by executing the program step sufficiently many times. We know thaM on inputx ∈ N will terminate within max(|x|, k)nsteps, and hence, we can simulateM on inputx by theprogram

W:= max(|x|, k); W1:= W; W2:= W...;Wn:= W; init;

for W1 [for W2...for Wn[ step ]...].

(∗)

The subprograminit initializes the arrays represening the tape. In particular, the subprogram “writesinputx on the tape in binary notation”. It follows eaily form Lemma 2 that the program can be impmented as set-reset for-program taking input in themode. (The length of the input|x| is given in the regis-terNwhen the program starts.) Thus, every Turing mchine running in polynomial time in the length of inpcan be simulated by a set-reset for-program takingput in the bit mode. Hence, the inclusion (1)P ⊆ LsrF

b

holds.LetM be a Turing machine working in polynomi

space. The number of tape cells visited in an execuof M on inputx ∈ N is bounded by max(|x|, k)n forsome fixedk,n ∈ N. Hence, we can simulateM byexecutingstep sufficiently many times, and thus, thprogram

init; X:= 1;while X {step;if <M is in a halt state>then X:= 0 else X:= 1}

obviously simulatesM. It follows fairly easy fromLemma 2 that the program can be implemented a

L. Kristiansen, P.J. Voda / Information Processing Letters 88 (2003) 213–218 217

set-reset while-program taking input in the bit mode.Hence, the inclusion (2)PSPACE⊆ LsrW holds. ✷

dgs

ely

-

rre-ur-

mis--

by

el-

-owginee-et

p-thatber

, in

kin

rtssr

how one naturalt number can represent one possiblework tape configuration in the execution ofM on in-

xe-er

for-

she

amit

set

rray

aldoted

in

med

f

t

b

Next we prove two of the equalities indicatein the left column of Table 1. In the followinLroFb (respectivelyLroW

b denotes the set of problemdecidable by a read-only for-program (respectivwhile-program) taking input in the bit mode.

Theorem 2. (1) LOGSPACE= LroFb and (2) LOGSPACE

= LroWb .

Proof. The inclusions (1)LroFb ⊆ LOGSPACE and

(2) LroWb ⊆ LOGSPACE are straightforward conse

quences of Lemma 1. A read-only programP does notaccess arrays apart from the input array which cosponds to a Turing machine’s input tape. Thus, a Ting machineM can simulate a for- or a while-prograP by tracing the contents of a fixed number of regter variables. At the startM sets aside a fixed number of cells on its work tape for each variable.M willrepresent numbers in binary notation, and henceLemma 1, it suffices to set aside log2 max(|x|, k) tapecells for each variable whenP receives the input in thbit mode (k is a sufficiently large fixed number). It folows that the inclusions (1) and (2) hold.

We turn to the proof of the inclusions (1)LOGSPACE

⊆ LroFb and (2) LOGSPACE⊆ LroW

b . First we notethat (2) follows from (1) since for-loops can be implemented by while-loops. Thus, it remains to shthat (1) holds. LetM be a Turing machine workinin logarithmic space. Recall that any such machalso runs in polynomial time. Thus, the proof of Thorem 1 shows howM can be simulated by a set-resfor-programP. To turnP into a read-only for-programsimulatingM, it suffices to eliminate the arrays reresenting the work tape. Thus, we need to showthe work tape can be represented by (a fixed numof) register variables. SinceM works in logarithmicspace, the number of cells visited on the work tapean execution ofM on inputx, is strictly bounded byk′(log2 |x| + 1) for some fixedk′ ∈ N. Assume thereare r symbols inM ’s alphabet (including the blansymbolB). We view these symbols as digits, andparticular we view the blank symbolB as a digit differ-ent from zero. A string of these symbols, which stawith B, and has lengthk′ log2 |x|, can be viewed aa natural numbert in baser. It now becomes clea

put x: The(i + 1)th digit in the baser representationof t is κ iff the symbol in theith tape cell isκ . More-over, for each sucht we havet < rk

′ log2 |x|. A simplearithmetical argument yields fixedk,n ∈ N such thatrk

′ log2 |x| � max(|x|, k)n. Hence it will be sufficient touse natural numbers in the range 0, . . . ,max(|x|, k)n−1 to represent the work tape configurations in the ecution ofM on inputx. We have seen that any numbin this range can be represented byn register variableseach holding a number� max(|x|, k). Thus, a fixednumber of register variables can contain enough inmation to represent the work tape.✷

We turn to the proof of two of the equalitieindicated in the center column of Table 1. In tfollowing let LsoF

b (respectivelyLsoWb ) denote the

set of problems decidable by a set-only for-progr(respectively while-program) taking input in the bmode.

Theorem 3. (1) P = LsoFb and (2) P = LsoW

b .

Proof. Since any set-only program also is a set-reprogram, the inclusion (1)LsoF

b ⊆ P follows from(1) of Theorem 1. Further, letP be a set-only while-program taking input in the bit mode, and letk be thevalue of the largest constant occurring inP. During theexecution ofP on the inputx, no register will storea number outside the range 0, . . . ,max(|x|, k), andhence, the number of set operations changing an aentry from 0 to 1, will be bounded byφ(|x|) for somepolynomialφ. Thus, there will also exist a polynomiψ such that, if the execution terminates at all, it willso before the number of primitive operations execureachesψ(|x|). This entails that ifP terminates, thenP can be simulated by a Turing machine runningpolynomial time. Hence, the inclusion (2)LsoW

b ⊆ P

holds.We will now explain how a set-reset for-progra

Psr taking input in the bit mode can be transforminto an equivalent set-only for-programPso takinginput in the bit mode. (The programPso will decide thesame problem asPsr.) First we note that the number oreset operations in an execution ofPsr will be boundedby max(|x|, k)n where |x| is the length of the inpuand k,n are some fixed numbers. The programPso


will represent eachr-ary arraya of Psr by n registervariablesZa, . . . ,Zan and an(n+ r)-ary arraya’. The

e

toonen

e

edon

-

ip.es-

ing fragment taking input in the numerical mode cap-tures LINSPACE (respectivelyETIME, ESPACE). The

ns-theac-

ehe

eri-2)

s,gr.,

imeu-

m-

am-.life

ofngs

u-

m-

1registersZa1, . . . ,Z

an will represent a number in th

range 0, . . . ,max(|x|, k)n. In the following we assumethat r = 1, but the construction generalizes easilyarbitrary r. Here is the idea behind the constructiof Pso from Psr: If j reset operations have beexecuted at a given stage in the run ofPsr, then atthe corresponding stage in the run ofPso, Za1, . . . ,Zan representj anda’[Za1, . . . ,Z

an, i] = a[i] (for

all relevanti). Thus, we constructPso from Psr byreplacing

(i) each occurrence ofif a[X] by if a’[Za1,. . . ,Zan, X],

(ii) each occurrence ofset(a[X]) byset(a’[Za1,. . . ,Zan, X]), and

(iii) each occurrence ofreset(a[X]) by a suitableimplementation of the program

Y1:= Za1; ...Yn:= Zan;

(* Y1,...,Yn are new variables *)< increase the number represented

by Za1,...,Zan >

W:= < upper bound of a >;(* W is a new variable *)

for i:= 0 to W do{ if i �= X and a’[Y1,..., Yn,X] = 1then set (a’[Za1,...,Z

an,X]) }

We leave to the reader to verify thatPso indeed decidethe same problem asPsr. Recall that each entry in tharraya’ will be 0 (reset) when the execution ofPso

starts.Since any set-reset for-program can be transform

into an equivalent set-only for-program, the inclusi(1) P ⊆ LsoF

b follows from (1) of Theorem 1. Theinclusions (2)P ⊆ LsoW

b does also follow since forloops can be replaced by while-loops.✷

The classesLOGSPACE, P andPSPACEare in gen-eral closely related in that order toLINSPACE, ETIME

and ESPACE. Table 1 reflects this close relationshIf a fragment taking input in the bit mode capturLOGSPACE(respectivelyP, PSPACE), the correspond

proofs of the theorems above can easily be traformed into proofs of corresponding theorems forfragments taking input in the numerical mode. Tocomplish these transformations, note that

– any program receiving the inputx in numericalmode, starts the execution with the numberx inthe registerN (in contrast, a program receiving thinput in bit mode, starts the execution with tnumber|x| in N).

– for any polynomialφ(x) there exist fixedk,n ∈N such thatφ(x) � k2n|x|, and for any fixedk,n ∈ N there exists a polynomialφ such thatk2n|x| � φ(x). Thus, an exponential bound in|x|corresponds to a polynomial bound inx.

– for any fixed k ∈ N there exists fixedk′ ∈ N

such that k log2(x + 1) � k′|x|, and for anyfixed k ∈ N there exists fixedk′ ∈ N such thatk|x| � k′ log2(x + 1). Thus, a linear bound in|x|corresponds to a logarithmic bound inx.

References

[1] S.J. Bellantoni, S. Cook, A new recursion-theoretic charactzation of the polytime functions, Comput. Complexity 2 (19997–110.

[2] A. Cobham, The intrinsic computational difficulty of functionin: Logic Methodology Philos. Sci., Proc. 1964 Internat. Con1965, pp. 24–30.

[3] R. Fagin, Generalized first-order spectra and polynomial-trecognizable sets, in: R.M. Karp (Ed.), Complexity of Comptation, SIAM–AMS Proceedings, Vol. 7, 1974, pp. 43–73.

[4] N.D. Jones, Computability and Complexity from a Programing Perspective, MIT Press, Cambridge, MA, 1997.

[5] N.D. Jones, LOGSPACE and PTIME characterized by progrming languages, Theoret. Comput. Sci. 228 (1999) 151–174

[6] N.D. Jones, The expressive power of higher-order types or,without CONS, J. Funct. Programm. 11 (2001) 55–94.

[7] L. Kristiansen, New recursion-theoretic characterizationswell known complexity classes, in: J. Royer (Ed.), ProceediICC’02, 2002, Journal version submitted.

[8] L.R. Lewis, C.H. Dimitriou, Elements of the Theory of Comptation, 2nd edn., Prentice-Hall, Englewood Cliffs, NJ, 1998.

[9] P.J. Voda, Two simple intrinsic characterizations of main coplexity classes, in: J. Royer (Ed.), Proc. ICC’02, 2002.

Documents

Complexity classes and fragments of C