Sharable Bitgraph Structure

• Sharable bitgraph structure is a compact graph encoding that stores connectivity in bit-level form, allowing direct query and traversal without full decompression.
• Distinct implementations such as B2SR, Log(Graph), and SP-A2NN tailor designs for GPU processing, concurrent analytics, and threshold-protected collaborative search.
• Each design balances reusability, performance, and privacy, addressing trade-offs between efficient representation and inherent structural limitations.

Searching arXiv for the cited papers to ground the article. A sharable bitgraph structure is a graph representation in which graph connectivity is encoded in compact bit-level form and designed for reuse across multiple queries, kernels, algorithms, threads, or collaborating parties. Across the literature, the term does not denote a single canonical data structure. Instead, it spans several related designs with different objectives: a reusable bit-level sparse adjacency-matrix format for homogeneous graphs in matrix-centric GPU processing, a modular compressed adjacency-array framework with succinct offsets for read-mostly graph analytics, and a branch-and-metadata graph surrogate for threshold-protected collaborative HNSW search (Chen et al., 2022, Besta et al., 2020, Guo, 23 Jul 2025). The common theme is that graph structure is stored in a compact binary or succinct form that remains directly queryable or traversable without full decompression, but the notion of “sharable” varies from amortized reuse across GraphBLAS kernels to concurrent read access in shared-memory systems to multi-party searchable sharing under threshold protection.

1. Concept and scope

In the most general systems sense supported by the literature, a sharable bitgraph structure is a graph-wide representation that can be constructed once and then reused by multiple graph operations or by multiple participants. In "Bit-GraphBLAS: Bit-Level Optimizations of Matrix-Centric Graph Processing on GPU" (Chen et al., 2022), this role is played by Bit-Block Compressed Sparse Row (B2SR), a reusable bit-level sparse adjacency-matrix format for homogeneous graphs. In "Log(Graph): A Near-Optimal High-Performance Graph Representation" (Besta et al., 2020), the closest analogue is a family of compact adjacency-array encodings with bit-packed adjacency data and succinct bitvector offsets. In "Threshold-Protected Searchable Sharing: Privacy Preserving Aggregated-ANN Search for Collaborative RAG" (Guo, 23 Jul 2025), the term is explicit: a sharable bitgraph structure is constructed as the central indexing mechanism for threshold-protected collaborative HNSW-compatible search.

These proposals differ in graph model, access semantics, and threat model. B2SR assumes a binary adjacency matrix and targets GPU GraphBLAS kernels; Log(Graph) assumes an adjacency-array substrate for static or slowly changing undirected graphs; the SP-A$^2$NN bitgraph is derived from undirected HNSW layer graphs but stores traversal metadata rather than literal undirected adjacency (Chen et al., 2022, Besta et al., 2020, Guo, 23 Jul 2025). This suggests that “sharable bitgraph structure” is best treated as a family resemblance concept rather than a single formal category.

A recurring misconception is to equate any binary or succinct graph encoding with a universally sharable graph structure. The literature does not support that conclusion. B2SR is explicitly limited to homogeneous graphs whose adjacency matrix is binary; Log(Graph) does not define a single immutable mmap-oriented graph object with explicit process-sharing semantics; and the SP-A$^2$NN bitgraph deliberately leaves substantial topology information visible in order to keep threshold-shared search practical (Chen et al., 2022, Besta et al., 2020, Guo, 23 Jul 2025).

2. Matrix-centric bitgraph structure: B2SR

B2SR is a two-level graph representation designed for binary sparse adjacency matrices. The upper level uses a sparse structure over non-empty blocks, represented similarly to CSR or CSC, while the lower level stores each non-empty block as a dense bit matrix. The paper states that the upper level is similar to BSR's upper level, using a sparse format to represent the locations of non-zero blocks, whereas the lower level differs from BSR in that each non-zero block is represented as a dense bit matrix in which each element becomes one bit in the representation (Chen et al., 2022).

The representation is built for homogeneous graphs, meaning that an edge is sufficiently represented by presence or absence alone. The paper is explicit that “As Bit-GraphBLAS relies on the bit-operation and bit-data, it only directly applies to homogeneous graphs (i.e., the adjacency matrix is a binary matrix)” (Chen et al., 2022). Nodes are not encoded separately; their identity is implicit from matrix row and column positions, as in conventional adjacency-matrix and CSR formulations. Each adjacency entry $A_{ij}$ is one bit, with $1$ for edge existence and $0$ for edge absence.

The matrix is partitioned into square tiles of dimension tileDim × tileDim, where tileDim may be 4, 8, 16, or 32. The number of tile rows is defined as

$nTileRow = \frac{nRows + tileDim - 1}{tileDim}.$

B2SR uses three main arrays: TileRowPtr, analogous to CSR row_ptr; TileColInd, analogous to CSR col_ind; and BitTiles, a bit-packing payload array with size equal to tileDim × numofTiles (Chen et al., 2022). The four variants are B2SR-4, B2SR-8, B2SR-16, and B2SR-32, with packing using unsigned char for $4 \times 4$ and $8 \times 8$ tiles, unsigned short for $16 \times 16$, and unsigned int for $32 \times 32$ (Chen et al., 2022).

The structure is sharable in the qualified sense that once the adjacency matrix is converted, the same B2SR representation is reused across GraphBLAS kernels and algorithms. The paper explicitly argues that a graph can be reused repeatedly and that the one-time conversion cost can be greatly amortized (Chen et al., 2022). At the same time, its sharability is limited: it is not a universal graph representation, does not directly encode arbitrary edge weights or edge types, and can lose efficiency when tile occupancy is poor or graph nonzeros are too random (Chen et al., 2022).

3. Succinct adjacency-array bitgraphs: Log(Graph)

Log(Graph) begins from the adjacency array representation, consisting of a contiguous adjacency-data array $^2$0 and an offset structure $^2$1 pointing to each vertex’s subarray $^2$2. The graph model is undirected by default, vertices have contiguous IDs in $^2$3, and each neighborhood $^2$4 is sorted by vertex IDs (Besta et al., 2020). Rather than replacing this model with an adjacency matrix or pointer-based object graph, Log(Graph) “logarithmizes” multiple parts of the adjacency-array structure.

The first granularity is fine elements: vertex IDs, edge weights, and individual offsets can be bit-packed. The second is the offset structure $^2$5 as a whole, which can be converted from a pointer array to a bitvector or succinct bitvector. The third is the adjacency structure $^2$6 as a whole, via relabeling, gap encoding, and recursive partitioning schemes (Besta et al., 2020). The strongest “bitgraph-like” component is the succinct offset structure, where $^2$7 is divided into blocks of size $^2$8 bits and the $^2$9-th bit in $A_{ij}$0 indicates a neighborhood start at block $A_{ij}$1, so retrieving $A_{ij}$2 becomes a select query on the bitvector (Besta et al., 2020).

Several succinct and compressed structures are evaluated. The paper lists bvPL, bvIL, bvEN, bvSD, bvBT, and bvGC, with bvSD representing positions of ones as a non-decreasing integer sequence encoded using Elias–Fano (Besta et al., 2020). It defines

$A_{ij}$3

as the number of ones up to position $A_{ij}$4, and

$A_{ij}$5

as the position of the $A_{ij}$6-th one (Besta et al., 2020). For neighborhood-specific packing, the local-width formula is

$A_{ij}$7

where the extra term stores local width metadata (Besta et al., 2020).

The structure is sharable primarily as a read-mostly, array-based, concurrently readable representation. The paper explicitly targets shared-memory and distributed-memory systems and emphasizes low-overhead decompression, parallel access to succinct structures, reduced data transfer, and reduced communication volume (Besta et al., 2020). However, it does not define a single canonical sharable graph object with explicit serialization, mmap, or zero-copy API semantics. This suggests that its sharability is architectural rather than standardized: compact binary layouts, succinct offsets, and on-the-fly extraction make the structure naturally suitable for concurrent reuse, but not productized as an explicit immutable interchange format (Besta et al., 2020).

4. Threshold-protected sharable bitgraph for HNSW-compatible search

The most explicit use of the phrase appears in the SP-A$A_{ij}$8NN framework, which addresses collaborative approximate nearest neighbor search over private vector databases while remaining compatible with HNSW-style multilayer retrieval (Guo, 23 Jul 2025). Here the sharable bitgraph structure is introduced because directly sharing an undirected HNSW graph under threshold secret sharing makes representation and search expensive: the paper argues that because an undirected edge must effectively be represented in both directions when shared and searched collaboratively, the resulting overhead becomes quadratic in the number of vertices (Guo, 23 Jul 2025).

The bitgraph is a transformed representation of an undirected graph, particularly an HNSW layer graph, intended to preserve search walks and insertion walks while storing structure in a more share-friendly way. At the multilayer level, HNSW organization is preserved: $A_{ij}$9 Each layer $1$0 is thus implemented as an encrypted bitgraph $1$1, rather than as an encrypted undirected adjacency structure (Guo, 23 Jul 2025).

The formal construction begins with a partition of a graph $1$2 into subgraphs: $1$3 A bitgraph $1$4 is then defined through a bijection from subgraphs to branches: $1$5 with per-subgraph maps

$1$6

and

$1$7

Each branch is an ordered tuple

$1$8

At the vertex level, the standardized entry is a quadruple

$1$9

which becomes a quintuple in the optimized shared search by adding a visit bit: $0$0 Thus adjacency is not stored as an edge list but reconstructed from predecessor in sequence, a contiguous successor range determined by post-positive degree, and parallel-branch pointers (Guo, 23 Jul 2025).

The paper claims a walk-preservation property via

$0$1

with the statement that the set of vertices in a walk of $0$2 forms a subset of the vertices in the corresponding walk of $0$3 (Guo, 23 Jul 2025). This is not edge-level graph isomorphism, but a procedural search-walk preservation claim. A plausible implication is that this bitgraph is “HNSW-compatible” at the algorithmic level rather than at the literal adjacency-list level.

5. Sharing semantics, complexity, and access patterns

The meaning of “sharable” differs substantially across the three principal designs.

In B2SR, sharability means that one converted binary graph can serve as the persistent matrix representation behind multiple GraphBLAS kernels and algorithms. The same representation is used for SpMV or BMV, SpGEMM or BMM, BFS, SSSP, PageRank, Connected Components, and Triangle Counting, with preprocessing treated as a one-time cost of about 3 to 34 ms (Chen et al., 2022). The paper reports up to $0$4 and $0$5 for essential GraphBLAS kernels SpMV and SpGEMM, respectively, with algorithm-level acceleration up to $0$6 for BFS, up to $0$7 for SSSP, PR, and CC, and up to $0$8 for TC (Chen et al., 2022). These are reuse-driven sharing properties rather than multi-party or inter-process semantics.

In Log(Graph), sharability is centered on direct access to compressed state. Neighbor access is performed by loading $0$9, computing an exact bit offset, reading a surrounding 64-bit word, and extracting the required field via shift, AND, and Intel BEXTR (Besta et al., 2020). Degree is obtained without decompressing the neighborhood: $nTileRow = \frac{nRows + tileDim - 1}{tileDim}.$0 Parallel read access is explicitly benchmarked, and the paper notes that bvPL and bvSD are fastest among bitvectors and that succinct structures can match pointer-array performance at higher thread counts (Besta et al., 2020). It also reports that in distributed BFS on 1024 compute nodes, communicated data is reduced by about 37% when logarithmizing fine elements (Besta et al., 2020). Here the structure is sharable because it is concurrently readable, partition-friendly, and communication-efficient.

In SP-A$nTileRow = \frac{nRows + tileDim - 1}{tileDim}.$1NN, sharability is cryptographic and collaborative. The bitgraph reduces the cost of threshold-sharing and searching by replacing explicit edge sharing with branch metadata. For an undirected graph, the paper defines a Minimum Sharable Set $nTileRow = \frac{nRows + tileDim - 1}{tileDim}.$2 with

$nTileRow = \frac{nRows + tileDim - 1}{tileDim}.$3

leading to

$nTileRow = \frac{nRows + tileDim - 1}{tileDim}.$4

under the stated bounds (Guo, 23 Jul 2025). For the bitgraph,

$nTileRow = \frac{nRows + tileDim - 1}{tileDim}.$5

and search is similarly reduced from a quadratic-style dependence to a linear-style dependence in the paper’s model (Guo, 23 Jul 2025). This is a different kind of sharability: the graph structure is made economical to distribute and use under threshold secret sharing.

6. Structural limitations and leakage tradeoffs

Each design achieves compactness and reusability by imposing structural constraints.

B2SR is restricted to binary adjacency matrices. It directly supports only homogeneous graphs and does not directly encode multiple edge types, arbitrary edge weights, or rich edge attributes (Chen et al., 2022). Its efficiency depends on tile occupancy and graph pattern; the paper is explicit that B2SR is not universally superior, and that performance tends to be best for diagonal, block, and stripe patterns and worst for random “dot” patterns and poor tile occupancy (Chen et al., 2022). The structure is therefore specialized rather than general-purpose.

Log(Graph) is broader in graph model but narrower in mutability. The main target is static or slowly changing graphs, although some offset succinct structures such as bvBT and bvGC are dynamic (Besta et al., 2020). The paper does not develop a general directed-graph representation, does not introduce a property-graph attribute schema, and does not present a fully dynamic graph store (Besta et al., 2020). Moreover, the strongest succinctness claims apply mainly to the offset structure $nTileRow = \frac{nRows + tileDim - 1}{tileDim}.$6, not uniformly to the whole graph representation. This suggests that “succinct sharable bitgraph” is most accurate for substructures rather than for every Log(Graph) variant.

The SP-A$nTileRow = \frac{nRows + tileDim - 1}{tileDim}.$7NN bitgraph makes an even sharper tradeoff: the vector contents are threshold-shared, but the graph connectivity metadata are not hidden in the strong sense of standard encrypted indexing. The paper explicitly states that parties can recognize whether two vertices are adjacent by observing storage locations and sequences, although they cannot determine what the vertex content actually represents (Guo, 23 Jul 2025). The leakage term added by the bitgraph is

$nTileRow = \frac{nRows + tileDim - 1}{tileDim}.$8

and the privacy analysis includes explicit leakage formulas such as

$nTileRow = \frac{nRows + tileDim - 1}{tileDim}.$9

(Guo, 23 Jul 2025). A common misconception would be to treat this bitgraph as a topology-hiding encrypted graph index. The paper does not claim that.

7. Related but non-graph uses of sharable binary structure

The broader literature also uses closely related language for sharable binary structures that are not graphs in the formal adjacency sense. "Highly-Economized Multi-View Binary Compression for Scalable Image Clustering" (Zhang et al., 2018) is an instructive contrast. It learns a shared common binary code matrix

$4 \times 4$0

and a binary cluster structure through

$4 \times 4$1

with shared and private projection decomposition

$4 \times 4$2

(Zhang et al., 2018). The paper explicitly does not define an adjacency graph, affinity matrix, neighborhood graph, similarity matrix, or binary adjacency matrix. Its structure is prototype-based and embedding-based rather than edge-based (Zhang et al., 2018). This clarifies an important boundary condition: a sharable binary structure need not be a bitgraph unless relationships are represented as navigable graph structure.

A different use of “sharable” appears in "A study of Quantum Correlation for Three Qubit States under the effect of Quantum Noisy Channels" (Sarangi et al., 2014), where monogamous states are described as not freely sharable and polygamous states as freely sharable in the context of quantum correlation (Sarangi et al., 2014). This is conceptually unrelated to data-structure design, but it underscores that “sharable structure” is domain-dependent. In graph systems, the relevant notion is reusability and accessibility of a compact graph representation, not sharability of correlation resources.

Taken together, the literature supports a precise but qualified understanding. A sharable bitgraph structure is not a universal graph storage abstraction. It is a specialized compact graph representation that uses bit-level or succinct structure to make reuse economical under a particular workload model: GPU matrix kernels over binary adjacency matrices, concurrent graph analytics over compressed adjacency arrays, or threshold-protected collaborative HNSW traversal (Chen et al., 2022, Besta et al., 2020, Guo, 23 Jul 2025). Its technical value lies in that specialization, and its limitations follow directly from the assumptions that make the specialization possible.