Lower Bounds for Oblivious Data Structures

Abstract

An oblivious data structure is a data structure where the memory access patterns reveals no information about the operations performed on it. Such data structures were introduced by Wang et al. [ACM SIGSAC'14] and are intended for situations where one wishes to store the data structure at an untrusted server. One way to obtain an oblivious data structure is simply to run a classic data structure on an oblivious RAM (ORAM). Until very recently, this resulted in an overhead of ω(lg n) for the most natural setting of parameters. Moreover, a recent lower bound for ORAMs by Larsen and Nielsen [CRYPTO'18] show that they always incur an overhead of at least Ω(lg n) if used in a black box manner. To circumvent the ω(lg n) overhead, researchers have instead studied classic data structure problems more directly and have obtained efficient solutions for many such problems such as stacks, queues, deques, priority queues and search trees. However, none of these data structures process operations faster than Θ(lg n), leaving open the question of whether even faster solutions exist. In this paper, we rule out this possibility by proving Ω(lg n) lower bounds for oblivious stacks, queues, deques, priority queues and search trees. * rikj@itu.dk. IT University Copenhagen. † larsen@cs.au.dk. Aarhus University.

Path Oblivious Heap: Optimal and Practical Oblivious Priority Queue

“…Optimality. Path Oblivious Heap outperforms existing works both in asymptotic and concrete performance, and moreover achieves optimality in light of the recent lower bound by Jacob et al [24]. We recommend the Path-variant for a cloud outsourcing scenario, and the Circuit-variant for RAM-model multi-party computation [23], [30] -recall that these are the two primary application scenarios for oblivious algorithms.…”

“…The very recent work of Jafargholi et al [25] was first to answer this question affirmatively: they showed how to construct an oblivious priority queue where each request completes in amortized O(log N ) bandwidth, but requiring O(log 1 δ ) words of CPU cache. In another very recent work, Jacob et al [24] prove that any oblivious priority queue must incur Ω(log N ) bandwidth per request even when the CPU can store O(N ) words in its private cache where 0 < < 1 is an arbitrary constant.…”

Lower Bounds for Oblivious Near-Neighbor Search

“…The seminal work of Larsen and Nielsen [LN18] presented the first cell-probe lower bound for oblivious data structures, in which they proved a (tight) Ω(lg n) lower bound for ORAMs. Jacob et al [JLN19] show Ω(lg n) cell-probe lower bounds for oblivious stacks, queues, deques, priority queues and search trees. Both [LN18, JLN19] adapt the information transfer technique of Pǎtraşcu and Demaine [PD06].…”

“…For the problem of RAMs, it has been shown that the Θ(lg n) overhead is both necessary and sufficient [LN18,PY19]. Jacob et al [JLN19] also show that the Θ(lg n) overhead is necessary and sufficient for many fundamental data structures such as stacks and queues, but quite surprisingly, Jafargholi et al [JLS19] very recently showed that (comparison-based) priority queues can be made oblivious with no overhead at all. We consider this question for the ANN problem.…”

“…This is also the first oblivious cell-probe lower bound exceeding ω(lg n) (for a problem where no super-logarithmic cell-probe lower bound is known). Previous works on oblivious cell-probe lower bounds have focused on data structures with O( √ lg n) or smaller complexity for their nonoblivious counterparts (such as RAMs [LN18,PY19] as well as stacks, queues, deques, priority queues and search trees [JLN19]) and peaked at Ω(lg n).…”