Retroactive Monotonic Priority Queues via Range Searching

2025-08-13

AI Summary

This paper establishes a lower bound for the time complexity of fully retroactive monotone priority queues. While the current best upper bound stands at $O(log^2 m log log m)$, standard and partially retroactive variants achieve $O(log m)$. The key methodological advance is the first reduction of the minimum-query operation to two-dimensional range searching. Leveraging this insight, we design a novel data structure that tightly couples query and update mechanisms of dynamic range-searching structures to support insertions, deletions, and arbitrary-time retroactive operations. Theoretical analysis shows that each operation runs in $O(log m + T(m))$ time, where $T(m)$ denotes the cost of a single operation on the underlying range-searching structure. Employing an optimal dynamic 2D range-searching structure yields an overall bound of $O(log m log log m)$—the first improvement over the $O(log^2 m)$ barrier and the best known result to date.

Technology Category

• Search and Optimization: Distributed Search
• Data Mining & Knowledge Management: Intelligent Query Processing
• Planning, Routing, and Scheduling: Optimization of Spatio-temporal Systems

Application Category

• Graph Algorithms and Modeling for the Web: Querying, indexing, and retrieval in Web-related graphs
• Search and Retrieval-Augmented AI: Web learning to rank, online learning, and counterfactual learning for ranking
• Security and Privacy: Data transparency and provenance

Abstract

The best known fully retroactive priority queue costs $O(log^2 m log log m)$ time per operation, where $m$ is the number of operations performed on the data structure. In contrast, standard (non-retroactive) and partially retroactive priority queues cost $O(log m)$ time per operation. So far, it is unknown whether this $O(log m)$ bound can be achieved for fully retroactive priority queues. In this work, we study a restricted variant of priority queues known as monotonic priority queues. We show that finding the minimum in a retroactive monotonic priority queue is a special case of the range-searching problem. We design a fully retroactive monotonic priority queue with a cost of $O(log m + T(m))$ time per operation, where $T(m)$ is the maximum between the query and the update time of a specific range-searching data structure with $m$ elements. Finally, we design a fully retroactive monotonic priority queue that costs $O(log m log log m)$ time per operation.

Problem

• Achieving O(log m) time for fully retroactive priority queues
• Designing efficient retroactive monotonic priority queues
• Linking priority queues to range-searching problem solutions

Innovation

• Uses range searching for retroactive queues
• Achieves O(log m + T(m)) time per operation
• Implements O(log m log log m) time solution