Onion Representations in Networks & Geometry

• Onion representations are decompositions that stratify vertices or points into layers based on well-defined combinatorial or geometric rules.
• They enable robust analysis of network resilience and geometric structure through efficient algorithms like convex-layer decomposition and biased stub matching.
• Applications include anomaly detection, graph sampling, and modeling dynamical processes, offering clear insights into hierarchical network properties.

Onion representations encompass a family of decompositions and structures in graph theory and computational geometry that organize data (vertices, points) into stratified layers, or "onions," based on well-defined combinatorial or geometric rules. These representations serve as robust summaries of both underlying connectivity and multi-scale organization, revealing deep insights into network resilience, geometric structure, and hierarchical centrality. Methods and statistics built on onion representations now play central roles in network science, data structures, algorithm engineering, and multi-scale anomaly detection.

1. Onion Structure in Networks

The onion structure in complex networks is defined by a radial layering of vertices, with high-degree ("core") vertices occupying the center and lower-degree ("peripheral") vertices organized into concentric shells. Edges are biased toward intra-layer (same-shell) connections. The construction begins by sampling a degree sequence $\{k_i\}_{i=1}^{N}$, typically from a power-law distribution $P(k)\propto k^{-\gamma}$. Nodes are sorted in non-decreasing order of degree, and all nodes of the same degree are assigned the same layer index $s_i$ (e.g., $s_i=0$ for the smallest degree, $s_i=1$ for the next, etc.) (Wu et al., 2011).

Edge formation uses a probability $P_{ij}=1/(1 + a|s_i-s_j|)$, favoring stubs within the same layer, with $a>0$ as a tunable bias parameter. As $|s_i-s_j|$ grows, cross-layer edges become increasingly rare.

Empirical studies reveal that onion-layered networks, while retaining scale-free heterogeneity, exhibit a much higher robustness index $R$ to both targeted and random vertex removals than standard configuration-model graphs. Crucially, these onion networks also display strong expander properties, quantifiable by a large spectral gap $\Delta\lambda = \lambda_1 - \lambda_2$ or, equivalently, a large spectral ratio $P(k)\propto k^{-\gamma}$0. This structural alignment enables maximally resilient and well-mixed network topologies (Wu et al., 2011).

2. Onion Decomposition in Geometric and Graph Settings

The onion decomposition is an inductive procedure partitioning a finite set (vertices or points in $P(k)\propto k^{-\gamma}$1) into layers reflecting their distance to a boundary or core. In computational geometry, the onion decomposition (also known as convex-layer decomposition) of a point set $P(k)\propto k^{-\gamma}$2 of size $P(k)\propto k^{-\gamma}$3 is the sequence of convex hulls:

$P(k)\propto k^{-\gamma}$4

where ch($P(k)\propto k^{-\gamma}$5) denotes the convex hull of $P(k)\propto k^{-\gamma}$6 and the process halts when the set is exhausted. The number of layers $P(k)\propto k^{-\gamma}$7 is determined by the point configuration. Each layer is typically represented as a circular list of vertices in counterclockwise order, enabling fast tangent, split, and join operations for geometric manipulation (Löffler et al., 2013).

In networks, the onion decomposition refines the $P(k)\propto k^{-\gamma}$8-core peeling process. For each vertex $P(k)\propto k^{-\gamma}$9, the decomposition records a pair $s_i$0, where $s_i$1 is the maximum $s_i$2 such that $s_i$3 survives in the $s_i$4-core, and $s_i$5 is the layer in which $s_i$6 is removed during the successive stripping of degree-$s_i$7 nodes (Hébert-Dufresne et al., 2015).

3. Generative and Algorithmic Frameworks

Onion-Network Generation

The generative algorithm for onion-structured scale-free networks proceeds as follows (Wu et al., 2011):

1. Degree Sequence Sampling: Sample $s_i$8 from $s_i$9, ensuring $s_i=0$0 is even.
2. Layer Assignment: Sort nodes by degree, assign layers $s_i=0$1 accordingly.
3. Stub Matching with Onion Bias: Place $s_i=0$2 stubs on each node. While stubs remain, randomly pair two stubs $s_i=0$3 and connect them with probability $s_i=0$4, forbidding self-loops and multiple edges.
4. Final Reshuffling: If stubs remain unpaired, use random edge rewiring to incorporate them, maintaining simplicity.

This algorithm is $s_i=0$5 in practice ($s_i=0$6 the edge number), directly produces robust, onion-layered graphs, and circumvents the need for explicit optimization.

Onion Decomposition Algorithms

For geometric onions, efficient algorithms exist for decomposing point sets and merging onions. Using a space decomposition tree (($s_i=0$7)-SDT), one can preprocess a set of $s_i=0$8 disjoint unit disks in $s_i=0$9 expected time and answer onion decomposition queries for any one-point-per-disk sample $s_i=1$0 in $s_i=1$1 time, optimally matching decision-tree lower bounds (Löffler et al., 2013).

In graphs, the onion decomposition of $s_i=1$2 is computed by iteratively removing all vertices with degree $s_i=1$3 in rounds, recording both the core index $s_i=1$4 and removal layer $s_i=1$5 per node. With suitable bucket data structures, the decomposition completes in $s_i=1$6 time and $s_i=1$7 space (Hébert-Dufresne et al., 2015).

4. Multi-Scale Statistical Characterization: Onion Spectrum and Local Representation

The onion spectrum $s_i=1$8 is a two-dimensional histogram counting the number of graph nodes with coreness $s_i=1$9 and onion layer $P_{ij}=1/(1 + a|s_i-s_j|)$0. A more refined measure, the joint degree–onion distribution $P_{ij}=1/(1 + a|s_i-s_j|)$1, counts nodes with degree $P_{ij}=1/(1 + a|s_i-s_j|)$2, core index $P_{ij}=1/(1 + a|s_i-s_j|)$3, and layer $P_{ij}=1/(1 + a|s_i-s_j|)$4, with normalization $P_{ij}=1/(1 + a|s_i-s_j|)$5. Marginals recover classical features such as the degree distribution and $P_{ij}=1/(1 + a|s_i-s_j|)$6-core sizes (Hébert-Dufresne et al., 2015).

Onion spectra carry signatures at multiple structural scales:

• Microscale: Reveals degree heterogeneity and degree–degree correlations (e.g., deep layers for high assortativity).
• Mesoscale: Layer-decay rates within each core quantify local subgraph structure; exponential decay is indicative of tree-like local topology, while sub-exponential decay suggests loops or lattices.
• Macroscale: The maximal $P_{ij}=1/(1 + a|s_i-s_j|)$7 and maximal layer index among all nodes reflect core density and centrality, respectively.

Each vertex also admits a concise local "onion representation" $P_{ij}=1/(1 + a|s_i-s_j|)$8 recording its degree, coreness, onion layer, and counts of neighbors in deeper, same, or shallower positions. This representation summarizes both global and immediate-neighborhood structure in a canonical tuple (Hébert-Dufresne et al., 2015).

5. Onion Representations in Data Structures and Fast Algorithms

Efficient onion decomposition and manipulation depend on dynamic representations of convex layers or onion spectra. For convex-layers in $P_{ij}=1/(1 + a|s_i-s_j|)$9, each layer is stored as a circular binary search tree supporting $a>0$0 tangent-finding, split, and join operations. These primitives allow fast union and partial recomputation of onions, which is key for computational geometry queries, imprecise point set decompositions, and spatial database applications (Löffler et al., 2013).

The union of two onions (disjoint convex-layer decompositions) can be constructed in $a>0$1 time, where $a>0$2 is the number of resulting layers. This efficiency is achieved by recursive layer merging and convex hull operations, as formalized in the union-onions pseudocode (Löffler et al., 2013).

6. Applications: Robustness, Anomaly Detection, and Network Ensemble Generation

Onion structures and decompositions provide practical and theoretically justified tools across several domains:

• Network Robustness: Onion-structured scale-free networks maximize robustness index $a>0$3 to targeted and random failures, greatly outperforming unstructured scale-free models. This robustness coincides with increased assortativity $a>0$4 and large spectral-gap proxies $a>0$5 (Wu et al., 2011).
• Topological Anomaly Detection: Deviations in layer-counts within shells ($a>0$6 vs. $a>0$7), such as plateaus or slow decay, reveal anomalous subgraphs (e.g., dense cliques or long chains), as demonstrated in co-authorship and web graphs (Hébert-Dufresne et al., 2015).
• Graph Sampling: The onion network ensemble (ONE) consists of random graphs with prescribed $a>0$8. Pairing stubs with constraints matching onion statistics accurately reproduces not only degree and core properties but also multi-scale onion structure (Hébert-Dufresne et al., 2015).
• Dynamical Process Modeling: The steady-state prevalence of SIS epidemic dynamics is more faithfully captured in ONE-based randomizations, compared to models that only preserve degree or degree–degree correlations, such as the correlated configuration model (CCM).
• Shortest Path Distributions: The onion structure preserves the all-pairs shortest-path-length distribution with higher fidelity than rewired null models lacking onion constraints (Hébert-Dufresne et al., 2015).

7. Comparative Insights and Interpretability

The onion decomposition strictly refines the standard $a>0$9-core or $|s_i-s_j|$0-shell method by introducing within-core layering (the $|s_i-s_j|$1 coordinate), providing a granular distance-to-periphery stratification. Whereas classical $|s_i-s_j|$2-core methods assign only a coreness index, the onion decomposition encodes how long each node survives once its shell’s threshold is reached, reflecting both global and local structural roles.

Interpretability is enhanced, since $|s_i-s_j|$3 quantifies rounds survived inside shell $|s_i-s_j|$4, correlating with centrality and other network metrics. The same principles generalize to geometric onions, where convex-layer indices stratify distance from the hull in planar point sets, supporting fast union, update, and partial-recombination operations.

In summary, onion representations synthesize a variety of local and global features—degree heterogeneity, core–periphery stratification, assortativity, and loop density—into computational models and data structures that are tractable, expressive, and broadly applicable for resilience analysis, geometry, and network fingerprinting (Wu et al., 2011, Löffler et al., 2013, Hébert-Dufresne et al., 2015).