On the time and space complexity of computation using write-once memory or is pen really much worse than pencil?

We introduce a model of computation based on the use of write-once memory. Write-once memory has the property that bits may be set but not reset. Our model consists of a RAM with a small amount of regular memory (such as logarithmic ornα for α<1, wheren is the size of the problem) and a polynomial amount of write-once memory. Bounds are given on the time required to simulate on write-once memory algorithms which originally run on a RAM with a polynomial amount of regular memory. We attempt to characterize algorithms that can be simulated on our write-once memory model with very little slow-down. A persistent computation is one in which, at all times, the memory state of the computation at any previous point in time can be reconstructed. We show that any data structure or computation implemented on this write-once memory model can be made persistent without sacrificing much in the way of running time or space. The space requirements of algorithms running on the write-once model are studied. We show that general simulations of algorithms originally running on a RAM with regular memory by algorithms running on our write-once memory model require space proportional to the number of steps simulated. In order to study the space complexity further, we define an analogue of the pebbling game, called the pebble-sticker game. A sticker is different from a pebble in that it cannot be removed once placed on a node of the computation graph. As placing pebbles correspond to writes to regular memory, placing stickers correspond to writes to the write-once memory. Bounds are shown on pebble-sticker tradeoffs required to evaluate trees and planar graphs. Finally, we define the complexity class WO-PSPACE as the class of problems which can be solved with a polynomial amount of write-once memory, and show that it is equal toP.

[1]  Jeffrey Scott Vitter,et al.  Computational Complexity of an Optical Disk Interface (Extended Abstract) , 1984, ICALP.

[2]  Keshav Pingali,et al.  I-structures: data structures for parallel computing , 1986, Graph Reduction.

[3]  Allan Borodin,et al.  A time-space tradeoff for sorting on a general sequential model of computation , 1980, STOC '80.

[4]  Adi Shamir,et al.  How to Reuse a "Write-Once" Memory , 1982, Inf. Control..

[5]  Robert E. Tarjan,et al.  Planar point location using persistent search trees , 1986, CACM.

[6]  Peter van Emde Boas,et al.  Design and implementation of an efficient priority queue , 1976, Mathematical systems theory.

[7]  Alok Aggarwal,et al.  Hierarchical memory with block transfer , 1987, 28th Annual Symposium on Foundations of Computer Science (sfcs 1987).

[8]  K. Mehlhorn Pebbling Moutain Ranges and its Application of DCFL-Recognition , 1980, ICALP.

[9]  Carl Hewitt,et al.  Comparative Schematology , 1970 .

[10]  Jeffrey Scott Vitter,et al.  An efficient I/O interface for optical disks , 1985, TODS.

[11]  Carl Ponder,et al.  Are applicative languages inefficient? , 1988, SIGP.

[12]  Richard P. Brent,et al.  The Parallel Evaluation of General Arithmetic Expressions , 1974, JACM.

[13]  Robert E. Tarjan,et al.  Data structures and network algorithms , 1983, CBMS-NSF regional conference series in applied mathematics.

[14]  Robert E. Tarjan,et al.  Making data structures persistent , 1986, STOC '86.

[15]  Leslie G. Valiant,et al.  Graph-Theoretic Arguments in Low-Level Complexity , 1977, MFCS.

[16]  David Maier,et al.  Correcting faults in write-once memory , 1984, STOC '84.

[17]  Robert E. Tarjan,et al.  Applications of a planar separator theorem , 1977, 18th Annual Symposium on Foundations of Computer Science (sfcs 1977).