B-Tree-based Intermediate Representation

• B-tree-based intermediate representation is a design pattern that leverages high-fanout, balanced trees to mediate ordered computations beyond conventional dictionary operations.
• It exploits wide nodes and logarithmic search bounds to enable efficient parallel set operations, cache-optimized layouts, and dynamic data manipulation.
• Advanced implementations include pointerless arrays, multi-version partitioning, and authenticated or succinct variants to enhance performance, security, and space efficiency.

Searching arXiv for recent and foundational papers on B-tree-based intermediate representations and related B-tree-like internal layouts. B-tree-based intermediate representation denotes the use of B-trees, $B^+$-trees, or closely related arity-bounded search trees as an internal form for ordered data, sets, intervals, prefixes, versions, or authenticated records, chosen not merely for dictionary operations but as a substrate on which higher-level algorithms are expressed. In this role, the tree is an intermediate representation because it mediates between a logical problem formulation—such as set algebra, Longest Prefix Match, multi-version storage, or authenticated lookup—and an execution strategy with specific guarantees in latency, work, I/O complexity, locality, or proof size. Across the literature, this role is occupied by $(a,b)$-trees for parallel set operations, flat-array linearized $B^+$-trees for software IPv6 lookup, cache-oblivious B-tree-like layouts for dynamic subtree manipulation, partitioned $B^+$-trees for storage engines, and authenticated or succinct B-tree variants for integrity or space efficiency (Akhremtsev et al., 2015).

1. Definition and scope

A B-tree-based intermediate representation is characterized by three recurrent properties. First, it preserves total order and balanced height, allowing search and update bounds logarithmic in the number of stored items. Second, it exploits high fanout or wide nodes, which improves cache behavior or reduces I/O depth relative to binary search trees. Third, it is used compositionally: split, join, partition, predecessor search, subtree insertion, or proof construction become the primitives from which domain-specific operations are assembled (Akhremtsev et al., 2015).

The literature uses several closely related structures in this role. The paper on fast parallel set operations employs $(a,b)$-trees, explicitly describing them as “a generalization of B-trees,” and emphasizes balanced height, wide nodes, and batch update amenability (Akhremtsev et al., 2015). PlanB introduces a “linearized $B^+$-tree,” in which all keys reside in a single flat array, internal nodes are laid out in breadth-first order before the leaves, and parent-child relations are computed arithmetically rather than via pointers (Zhang et al., 16 Apr 2026). CORoBTS stores arity-bounded search trees in van Emde Boas layout inside a Packed Memory Array, giving a cache-oblivious representation for B-tree-like structures (Ondráček et al., 2022). MV-PBT extends the Partitioned BTree concept into a multi-version, append-based, single-tree organization for key-sorted storage engines (Riegger et al., 2022).

This diversity suggests that “B-tree-based intermediate representation” is not a single data structure but a design pattern. A plausible implication is that the representation is selected less for its textbook search-tree interface than for the algebra it enables over ordered blocks, partitions, intervals, or committed node contents.

2. Parallel set representations and join-based computation

One of the clearest formulations of B-tree-like structures as intermediate set representations appears in the use of $(a,b)$-trees for parallel split, join, bulk update, union, intersection, difference, and symmetric difference (Akhremtsev et al., 2015). The representation is motivated by balanced height, $\mathcal{O}(\log n)$ search and update, wide nodes, improved cache efficiency over binary trees, and suitability for batch operations. Set-theoretic computation is reduced to a small set of tree primitives.

For parallel split, a tree $T$ is divided into $k$ subtrees according to $(a,b)$0 sorted splitters by having each of $(a,b)$1 processors descend to the relevant leaf, copy the necessary paths, and assemble subtrees in parallel. The stated complexity is total work $(a,b)$2 and span $(a,b)$3 (Akhremtsev et al., 2015). For parallel join, $(a,b)$4 disjoint $(a,b)$5-trees $(a,b)$6, ordered by key range, are merged by pairwise joins in rounds, with array-of-pointers used for fast access to spine ranks and special handling of sequences of degree-$(a,b)$7 nodes. The work is $(a,b)$8, the parallel time is $(a,b)$9, and the processor count is $B^+$0; a lightweight randomized variant achieves the same expected bounds (Akhremtsev et al., 2015).

Bulk update is then expressed as split–update–join. A batch $B^+$1 of size $B^+$2 is inserted into a tree $B^+$3 of size $B^+$4 by splitting $B^+$5 by the keys of $B^+$6, merging each processor’s assigned segment, and joining the results. The time bound on $B^+$7 processors is

$B^+$8

with total work $B^+$9 (Akhremtsev et al., 2015). Union, intersection, difference, and symmetric difference are obtained by reducing them to bulk insertion, search, and deletion. For two trees $B^+$0 and $B^+$1 with $B^+$2, $B^+$3, and $B^+$4, the time is

$B^+$5

while union work is $B^+$6 (Akhremtsev et al., 2015).

A later line of work studies the same general problem under an explicit I/O-cost model. In the Fork-Join I/O Model, parallel B-tree set operations are analyzed in terms of I/O work and I/O span, and the paper reports that union, intersection, and difference of two B-trees of sizes $B^+$7 and $B^+$8 can be computed with $B^+$9 I/O work and $(a,b)$0 I/O span (Goodrich et al., 22 Oct 2025). There the join-based framework is generalized from binary trees to multiway B-trees via B-Way Join, Multi-Split, and Multi-Join. This suggests a consistent view of B-trees as an intermediate algebraic object for ordered-set computation, with the objective function changing from RAM work/span to block-transfer work/span.

3. Layout transformations and search-space re-encoding

A second major use of B-tree-based intermediate representation is as a transformed search space whose memory layout is itself part of the algorithm. PlanB exemplifies this approach for IPv6 Longest Prefix Match. It begins from the observation that LPM is a two-dimensional search problem over prefix value and prefix length. Each prefix $(a,b)$1 is mapped to an address interval $(a,b)$2, where $(a,b)$3 and $(a,b)$4. After sorting all start and end points, the address space is partitioned into elementary intervals, each annotated with the next-hop of the most-specific covering prefix. LPM is then reduced to predecessor search over sorted interval boundaries (Zhang et al., 16 Apr 2026).

The intermediate representation for this transformed problem is a linearized $(a,b)$5-tree. All keys are stored in a single flat array; internal nodes contain discriminating keys, leaves contain actual interval boundary keys, and internal nodes are laid out in breadth-first order before the leaves. Because there are no pointers, child locations are computed arithmetically using level offsets. With $(a,b)$6 keys per node, $(a,b)$7, and depth $(a,b)$8, the layout uses

$(a,b)$9

and

$B^+$0

The implementation reported in the paper uses 64-bit keys and $B^+$1, so $B^+$2, fitting one node into a 64-byte cache line; the design is also described as flexible enough to use 16-key nodes on Apple Silicon with 128-byte cache lines (Zhang et al., 16 Apr 2026).

The search algorithm is likewise specialized to the representation. At each level, lookup performs lower-bound search within a node; the AVX-512 variant compares the target against all node keys at once, converts the comparison mask into a child number via popcount, and descends with no branches. The paper states that “the entire traversal consists of a fixed number of vector loads + popcnts, no branches” (Zhang et al., 16 Apr 2026). Extensive evaluation reports single-core performance of 390 Million Lookups Per Sec and full-12-core performance of 3.4 Billion Lookups Per Sec, stated as $B^+$3 higher than PopTrie, CP-Trie, Neurotrie and HBS (Zhang et al., 16 Apr 2026).

CORoBTS adopts a different transformation strategy but the same general principle: represent a B-tree-like search tree in a layout tuned to the memory hierarchy. It combines van Emde Boas layout with a Packed Memory Array, assumes all leaves are at the same depth, and requires arity between constants $B^+$4 and $B^+$5. Search has optimal I/O complexity $B^+$6, linear space, and subtree insertion or removal of size $B^+$7 has amortized I/O complexity

$B^+$8

and amortized time complexity $B^+$9 (Ondráček et al., 2022). Here the intermediate representation is not merely a conventional B-tree on disk; it is a cache-oblivious encoding of a B-tree-like shape that supports dynamic subtree operations.

These examples show a recurring pattern: the logical problem is first rewritten into ordered intervals, balanced subtrees, or vEB-localized vertex sequences, after which a B-tree-derived representation becomes the computational substrate.

4. Storage engines, partitioning, and multi-version organization

In storage systems, B-tree-based intermediate representation is often used to reconcile the search efficiency of $(a,b)$0-trees with write patterns more commonly associated with LSM-style designs. Multi-Version Partitioned BTrees (MV-PBT) extend the Partitioned BTree concept by prepending a partition number to each key, thereby imposing logical horizontal partitioning within a single $(a,b)$1-tree (Riegger et al., 2022).

The central mechanism is partition switching. All inserts, updates, and deletes are written to the most recent hot partition maintained in memory as the “MV-PBT buffer.” When the buffer exceeds a dirty page threshold, a new partition number is assigned, the former hot partition becomes immutable, and out-of-place clean-up produces a dense-packed representation that is written sequentially, bottom-up and partition-wise, to persistent storage (Riegger et al., 2022). The representation remains a single-tree index, but its logical key space encodes partitioning and versioning. The paper states that the structure provides MVCC and supports Snapshot Isolation, with record types including Regular Record, Replacement Record, Anti-Record, and Tombstone Record (Riegger et al., 2022).

The intended effect is to combine sequential writes with sustained read performance. The paper attributes low write amplification to the buffered in-memory hot partition, sequential writes during flush, and the fact that valid data are not rewritten unless space is reclaimed. It further introduces Cached Partitions as compact indexes over older immutable partitions, created via background merge-sort, to identify the latest valid version without searching each partition individually (Riegger et al., 2022). Garbage collection collects valid or latest versions into a new partition and then removes old ones with bulk range truncation.

The reported empirical comparison is explicit. MV-PBT was integrated into the WiredTiger KV storage engine and is said to offer “an up to 2x increased steady throughput in comparison to LSM-Trees and several orders of magnitude in comparison to B+ Trees in a YCSB workload” (Riegger et al., 2022). The detailed summary additionally reports that write amplification in MV-PBT is “30% less than LSM-Tree” and “up to 300× lower than B+ Trees,” and that in YCSB Workload A it achieves $(a,b)$2 the throughput of LSM-Tree (Riegger et al., 2022).

Within this line of work, the B-tree-based intermediate representation is not merely an index over application records. It is the mechanism by which hot and cold regions, version chains, and sequentially written immutable segments are unified inside one search-tree address space. A plausible implication is that the representation is intended to collapse the usual separation between mutable in-memory components and immutable on-disk components into a single logically ordered structure.

5. Authenticated, succinct, and history-sensitive variants

The intermediate role of B-trees also appears in settings where the principal objective is not throughput but verifiability, compression, or privacy properties. The Dynamic Merkle B-tree is a hybrid of a self-balancing $(a,b)$3-tree and q-mercurial polynomial commitments, with node commitments and hashes authenticating the node contents (Smith et al., 2020). In each node, sorted key-value pairs are committed by interpolating a polynomial $(a,b)$4 over modified keys $(a,b)$5, committing to the resulting set, and hashing the commitment together with the node type. Because the tree height depends on the number of elements rather than key bitlength, and because intra-node proofs are constant-size, the paper argues for smaller and more efficient proofs than in trie-based Merkle structures (Smith et al., 2020).

The proof complexity is stated in terms of $(a,b)$6 group elements for membership and non-membership proofs, with verification also $(a,b)$7 (Smith et al., 2020). The paper explicitly mentions applications to outsourced databases, blockchain, key-value stores, relational databases, and Merkle forests. In this case the B-tree-based intermediate representation mediates between a mutable ordered dictionary and a proof-carrying authenticated data structure.

Space efficiency motivates a different family of representations. “Load-Balancing Succinct B Trees” proposes B-tree representations storing $(a,b)$8 keys of $(a,b)$9 bits in either $\mathcal{O}(\log n)$0 bits with $\mathcal{O}(\log n)$1 time per operation, or $\mathcal{O}(\log n)$2 bits with $\mathcal{O}(\log n)$3 time (I et al., 2021). The construction uses generalized $\mathcal{O}(\log n)$4 leaf redistribution, large leaf blocks, circular buffers, and a decoupling of internal and leaf structures. It also supports augmentation with aggregate values such as subtree minima within the same space and time bounds (I et al., 2021). Here the intermediate representation is B-tree-like in operation but compressed to near the information-theoretic minimum.

History independence motivates yet another alternative. The B-skip-list is presented as a “simpler uniquely represented alternative to B-trees,” with depth $\mathcal{O}(\log n)$5, linear space with high probability, and efficient one-dimensional range queries (Golovin, 2010). It is blocked for external memory, uses deterministic hash-assigned levels, partitions each level into contiguous partition sets, and replaces real pointers with abstract pointers derived from labels. The paper emphasizes strong history independence: the physical representation on disk is determined uniquely by the logical set of elements rather than the history of updates (Golovin, 2010). Although it is not itself a B-tree, it is framed explicitly as an alternative to B-tree-based indexing when unique representation is required.

These strands show that B-tree-based intermediate representation can be optimized for cryptographic succinctness, bit-level succinctness, or resistance to historical information leakage, without abandoning the core strategy of order-preserving, high-fanout balanced organization.

6. Adaptive and cache-oblivious generalizations, limits, and alternatives

Not all B-tree-based intermediate representations are static in their operational profile. “Lazy B-Trees” generalize lazy search trees to the external-memory setting by partitioning the current set into gaps $\mathcal{O}(\log n)$6, refining those gaps only when queries arrive, and further partitioning each gap into intervals that are maintained via B-trees (Rysgaard et al., 30 Jun 2025). The structure is explicitly described as interpolating between a priority queue and a B-tree depending on use. It supports an interface including Construct(S), Insert(e), Delete(ptr), ChangeKey(ptr,e'), QueryElement(e), and QueryRank(r) (Rysgaard et al., 30 Jun 2025).

The performance guarantees are stated in terms of the manipulated gap size $\mathcal{O}(\log n)$7. In particular, insertion has $\mathcal{O}(\log n)$8 worst-case I/Os, while QueryElement and QueryRank have amortized

$\mathcal{O}(\log n)$9

I/Os (Rysgaard et al., 30 Jun 2025). In priority-queue mode, the paper states $T$0 insert and decrease-key, and amortized $T$1 delete-minimum, all in $T$2 space (Rysgaard et al., 30 Jun 2025). This is an adaptive intermediate representation: the internal partitioning of the ordered set changes with query history, and the cost profile changes with it.

Cache-oblivious work such as CORoBTS highlights a different limit. Search is optimal, but updates inherit a $T$3 factor due to PMA rearrangements and pointer recalculation (Ondráček et al., 2022). The paper explicitly notes that write complexity is higher than the lower bound for B-trees and identifies PMA as the bottleneck. Similarly, the parallel $T$4-tree work stresses that optimal theoretical algorithms, such as the stack-of-arrays technique for joins, are intricate and may not be trivial to implement robustly; it also notes dependence on batch sizes, data distribution, and synchronization tuning (Akhremtsev et al., 2015). PlanB, for its part, relies on a full, pointerless array layout with sentinels for padding and handles updates by rebuilding in a secondary tree and atomically swapping, ensuring that active queries see only immutable trees (Zhang et al., 16 Apr 2026).

These limitations clarify a common misconception. A B-tree-based intermediate representation is not automatically the same as a conventional mutable page-oriented B-tree. In several cases, the representation is deliberately specialized—pointerless and rebuilt in batches, cache-obliviously laid out, multi-versioned and append-based, or gap-partitioned and workload-adaptive. The benefits therefore derive not from the generic label “B-tree,” but from how the representation is matched to the target computational model: multicore work/span, SIMD-friendly CPU search, cache-oblivious I/O, authenticated proofs, or versioned storage semantics.

Taken together, the literature presents B-tree-based intermediate representation as a general methodology for expressing ordered computation through balanced, high-fanout structure. Whether the objective is information-theoretically optimal parallel set operations (Akhremtsev et al., 2015), software IPv6 lookup on transformed elementary intervals (Zhang et al., 16 Apr 2026), cache-oblivious subtree manipulation (Ondráček et al., 2022), multi-version storage management (Riegger et al., 2022), succinct authentication (Smith et al., 2020), near-optimal bit complexity (I et al., 2021), or adaptive external-memory behavior (Rysgaard et al., 30 Jun 2025), the recurring idea is to encode the problem into a B-tree-like form whose structure exposes the right primitive operations and the right memory behavior for the domain.