Retroactive data structures

  title={Retroactive data structures},
  author={Erik D. Demaine and John Iacono and Stefan Langerman},
  booktitle={SODA '04},
We introduce a new data structuring paradigm in which operations can be performed on a data structure not only in the present but also in the past. In this new paradigm, called retroactive data structures, the historical sequence of operations performed on the data structure is not fixed. The data structure allows arbitrary insertion and deletion of operations at arbitrary times, subject only to consistency requirements. We initiate the study of retroactive data structures by formally defining… 

Figures and Tables from this paper

Retroactive Data Structure
A data structure is fully retroactive if it supports queries and updates to current and past version.
Implementation, Analysis and Application of Retroactive Data Structures
This paper focuses on the data structures for which retroactivity hasn’t been implemented yet and the enhancements in existing Retroactive data structures.
Non-oblivious Retroactive Data Structures
A new model of retroactivi ty is proposed, called non-oblivious retroactivity, where both updates and queries are maintained as part of the operation sequence, and a revision to theoperation sequence returns the earliest operation that becomes inconsistent, i.e., an operation whose return value differs from before.
2 Temporal Data Structures
There are two primary models of temporal data structures; the first, called persistence, is based on the branching-universe model of time travel; the second, called retroactivity, works on the idea of round-trip time travel.
Upper and Lower Bounds for Fully Retroactive Graph Problems
It is shown that under the OMv conjecture (proposed by Henzinger et al. (STOC 2015)), there does not exist fully retroactive data structures maintaining connectivity or MSF, or incremental fully Retroactive data structure maintaining the maximum degree with $O(n^{1-\epsilon})$ time per operation, for any constant $\epsilons > 0$.
Fully Retroactive Priority Queues using Persistent Binary Search Trees
This work presents how to implement a data structure to a fully retroactive version of a priority queue through persistent self-balanced binary search trees in polylogarithmic time and shows that the average performance of the proposed algorithm is better in terms of processing times than the other algorithms, despite the high constants in its complexity.
Nearly Optimal Separation Between Partially And Fully Retroactive Data Structures
The lower bound construction illustrates an interesting power of fully retroactive queries: they can be used to quickly solve batched pair evaluation and can prove useful for other data structure lower bounds, especially dynamic ones.
Implementing Partial Persistence in Object-Oriented Languages
This paper presents the first working implementation of partial persistence in the object-oriented language Java and uses aspect-oriented programming, a modularization technique which allows the existing code with the needed hooks for the persistence implementation to be instrumented.
Towards Time Travel in Distributed Event-sourced Systems
Retroactive computing introduces new opportunities for a developer to access and even modify an application timeline, and establishes powerful new ways to debug systems and introduces new approaches to solve problems.
PEDaLS: Persisting Versioned Data Structures
This paper investigates how to automatically persist versioned data structures in distributed settings (e.g. cloud + edge) using append-only storage and shows that it is possible to achieve algorithmic complexities similar to those of in-memory versioning but in a distributed setting.


Making data structures persistent
This paper develops simple, systematic, and efficient techniques for making linked data structures persistent, and uses them to devise persistent forms of binary search trees with logarithmic access, insertion, and deletion times and O (1) space bounds for insertion and deletion.
Making data structures confluently persistent
Decomposable Searching Problems I: Static-to-Dynamic Transformation
The cell probe complexity of dynamic data structures
New lower and upper bounds on the time per operation are proved to implement solutions to some familiar dynamic data structure problems including list representation, subset ranking, partial sums, and the set union problem.
Succinct Dynamic Data Structures
P succinct data structures are developed to represent a sequence of values to support partial sum and select queries and update and a dynamic array which supports insertion, deletion and access of an element at any given index.
Amortized Analysis of Algorithms for Set Union with Backtracking
It is proven that any separable pointer-based algorithm for the deunion problem required omega(log n/log log n) time per operation, thus showing that the upper bound an amortized time is tight.
Database Management Systems
A Simple Balanced Search Tree with O(1) Worst-Case Update Time
In this paper we show how a slight modification of (a, b)-trees allows us to perform member and neighbor queries in O(log n) time and updates in O(1) worst-case time (once the position of the
The Set Union Problem with Backtracking
This work studies a variant of the classical set union problem, where backtracking over the union operations is possible with the deunion operation, and develops an implementation to on-line perform an intermixed sequence of m finds, k unions and at most k deunions in O((m+k) log log n) steps.
Should tables be sorted?
  • A. Yao
  • Computer Science
    19th Annual Symposium on Foundations of Computer Science (sfcs 1978)
  • 1978
It is shown that, in a rather general model including al1 the commonly-used schemes, $\lceil $ lg(n+l) $\rceil$ probes to the table are needed in the worst case, provided the key space is sufficiently large.