# Retroactive data structures

@inproceedings{Demaine2004RetroactiveDS,
title={Retroactive data structures},
author={Erik D. Demaine and John Iacono and Stefan Langerman},
booktitle={SODA '04},
year={2004}
}
• Published in SODA '04 11 January 2004
• Computer Science
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
• Computer Science
• 2014
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
• Computer Science
• 2012
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
• Computer Science
• 2007
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
• Computer Science
• 2007
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
• Computer Science
• 2021
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
• Computer Science
• 2020
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
• Computer Science, Mathematics
SWAT
• 2018
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
• Computer Science
ALENEX
• 2008
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
• Computer Science
2021 IEEE International Conference on Cloud Engineering (IC2E)
• 2021
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.

## References

SHOWING 1-10 OF 37 REFERENCES
Making data structures persistent
• Computer Science
STOC '86
• 1986
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.
The cell probe complexity of dynamic data structures
• Computer Science
STOC '89
• 1989
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
• Computer Science
• 2001
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
• Computer Science
SIAM J. Comput.
• 1989
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.
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
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.