Structural Aggregation: A Unified Methodology

• Structural Aggregation is a family of methods that define fusion procedures using explicit relationships such as graph topology, modular decomposition, and geometric adjacency.
• It has broad applications across heterogeneous GNNs, robust optimization, modular expert systems, and numerical multilevel methods, demonstrating its versatility in combining structure-dependent information.
• Adopting structural aggregation enhances algorithm expressivity and robustness by incorporating domain-specific structural priors, mitigating the limitations of unstructured averaging.

Structural aggregation is used across optimization, machine learning, graph analysis, database systems, and statistical physics to denote aggregation procedures whose grouping rule, weighting rule, or fusion rule is determined by explicit structure rather than by unstructured averaging alone. In the cited literature, that structure may be graph topology and type semantics, modular system decomposition, directed acyclic computation graphs over experts, array neighborhoods, polymer contact topology, or transforming production networks (Zhu et al., 2023, Levin, 2011, Feng et al., 31 May 2026, Abdelmoniem et al., 1 Feb 2025, Berx et al., 2023, Nakano et al., 2024). Taken together, these uses indicate not a single algorithm but a recurring design principle: define a structured relation over basic units, derive admissible aggregation sets or paths from that relation, and aggregate subject to structural constraints, structural priors, or structure-dependent weights.

1. Recurring formal pattern

Across the literature, structural aggregation appears in several formally distinct but conceptually related forms. In heterogeneous graph learning, it is neighbor aggregation under structure-dependent neighborhoods, such as meta-path neighborhoods, fused meta-path graphs, or direct cross-type neighborhoods (Zhu et al., 2023). In modular system synthesis, it is aggregation over solution structures through substructure, superstructure, median/consensus, and extended median/consensus (Levin, 2011). In nonconvex optimization, it is the linear combination of multiple constraints into a single surrogate constraint whose convex hull is tractable (Dey et al., 2024). In multilevel numerical methods, it is the construction of a coarse model from aggregates and the use of that model to accelerate fine-level iteration (Bulgakov, 2016). In array processing, it is the grouping of cells by circular, grid, hierarchical, or sliding neighborhoods rather than by equality of attribute values (Abdelmoniem et al., 1 Feb 2025).

A common mathematical pattern is therefore present even when the objects differ. One first specifies a structural relation: a graph edge set, a meta-path set, a tree decomposition, a covering by groups, a grid partition, a braid, or a network of production linkages. One then defines admissible local or global aggregation units from that relation: neighborhoods, blocks, rings, bundles, supports, or aggregated constraints. Finally, one applies a combination rule such as weighted summation, median/consensus, knapsack-style extension, softmax attention, or convex hull intersection. This suggests that “structural aggregation” is best understood as a family of structure-aware aggregation operators rather than as a domain-specific primitive.

2. Graph and graph-neural formulations

In graph learning, structural aggregation is primarily a message-passing problem in which the key question is how the aggregation neighborhood is selected and how structural semantics modify the weights assigned to messages. HAGNN separates this into two phases: meta-path-based intra-type aggregation and meta-path-free inter-type aggregation (Zhu et al., 2023). For a node type $t$, it constructs a fused meta-path graph $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$, computes structural semantic weights

$$\delta_{uv}^{t} = \sum_{p_t \in P_t} \mathcal{A}(H,p_t)[u,v],$$

normalizes them, and blends them with learned GAT-style attention through

$$\eta_{uv}^{t} = (1-\beta)\alpha_{uv}^{t} + \beta \tilde{\delta}_{uv}^{t}.$$

It then combines intra-type and inter-type channels by concatenation,

$z_v = h_v^{intra} \,\|\, W_m h_v^{inter}.$

The explicit motivation is that meta-path-only methods capture higher-order same-type structural semantics, whereas meta-path-free methods capture first-order cross-type attribute semantics; HAGNN is designed to use both simultaneously. The paper also begins from the observation that a simple homogeneous graph model without meta-path can achieve comparable results, which calls into question the necessity of meta-path and makes hybridization the central design response.

Other graph-neural work uses structural aggregation to modify what is aggregated, not only how it is weighted. GraLSP injects local structural patterns via Random Anonymous Walks and then uses an adaptive receptive radius, structure-aware attention, and amplification to modulate neighborhood aggregation (Jin et al., 2019). SSRead shifts structural aggregation from node-level message passing to graph-level readout: nodes are aligned to learnable structural prototypes by cosine-distance-based structural semantic alignment, then aggregated position-wise so that classification can use position-specific weights rather than a single global readout (Lee et al., 2021). RSEA-MVGNN performs inter-view structural aggregation on multi-view graphs by weighting each view with

$p_{i,j} = VAR(b^{i,j}) / u^{i,j},$

where $b^{i,j}$ and $u^{i,j}$ are subjective-logic belief and uncertainty, and by coupling that weighting with reliable structural enhancement via feature de-correlation (Chen et al., 2024). Feddy extends the idea to dynamic graphs: at time $t$, structural aggregation pulls messages from neighbors in the previous graph $G^{(t-1)}$, combines them with a temporal self-link, and updates node states using fixed coefficients $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$0 and $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$1 (Jiang et al., 2020).

A separate line of work focuses on robustness. For GCNs, the standard weighted-mean aggregator has a finite-sample breakdown point of $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$2 and, at node level, a single-edge injection can arbitrarily corrupt the pre-activation message, yielding a breakdown point of $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$3 (Chen et al., 2021). Replacing weighted mean by median or trimmed mean changes the structural aggregation rule itself; the paper reports that median aggregation has breakdown point $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$4, trimmed mean has breakdown point approximately $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$5, and direct-attack robustness on Cora rises from $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$6 for GCN to $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$7 for Median and $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$8 for TMean. In graph representation learning more broadly, this establishes an important distinction: structural aggregation is not only about richer semantics, but also about robustness to perturbations in the structure that defines the aggregation set.

3. Expert composition and LLMs

In mixture-of-experts systems, structural aggregation refers to replacing permutation-invariant expert mixing with an explicit computation structure over selected experts. DAG-MoE starts from the standard sparse MoE layer

$\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$9

then replaces this weighted sum by a directed acyclic graph over the top-$$\delta_{uv}^{t} = \sum_{p_t \in P_t} \mathcal{A}(H,p_t)[u,v],$$0 selected experts (Feng et al., 31 May 2026). Initialization uses

$$\delta_{uv}^{t} = \sum_{p_t \in P_t} \mathcal{A}(H,p_t)[u,v],$$1

subsequent layers perform learned gated pairwise aggregation, and final readout is

$$\delta_{uv}^{t} = \sum_{p_t \in P_t} \mathcal{A}(H,p_t)[u,v],$$2

The paper proves that DAG-style MoE is strictly more expressive than weighted-sum MoE under injective aggregation, and also gives a dynamic-programming theorem showing that one DAG-style MoE block can realize multiple compositional steps aligned to a DP computation DAG. Empirically, it reports measured throughput overheads of $$\delta_{uv}^{t} = \sum_{p_t \in P_t} \mathcal{A}(H,p_t)[u,v],$$3 for $$\delta_{uv}^{t} = \sum_{p_t \in P_t} \mathcal{A}(H,p_t)[u,v],$$4 and $$\delta_{uv}^{t} = \sum_{p_t \in P_t} \mathcal{A}(H,p_t)[u,v],$$5 for $$\delta_{uv}^{t} = \sum_{p_t \in P_t} \mathcal{A}(H,p_t)[u,v],$$6, while large-scale pretraining at approximately $$\delta_{uv}^{t} = \sum_{p_t \in P_t} \mathcal{A}(H,p_t)[u,v],$$7B tokens and $$\delta_{uv}^{t} = \sum_{p_t \in P_t} \mathcal{A}(H,p_t)[u,v],$$8M parameters improves perplexity from $$\delta_{uv}^{t} = \sum_{p_t \in P_t} \mathcal{A}(H,p_t)[u,v],$$9 to $$\eta_{uv}^{t} = (1-\beta)\alpha_{uv}^{t} + \beta \tilde{\delta}_{uv}^{t}.$$0 on Pile and from $$\eta_{uv}^{t} = (1-\beta)\alpha_{uv}^{t} + \beta \tilde{\delta}_{uv}^{t}.$$1 to $$\eta_{uv}^{t} = (1-\beta)\alpha_{uv}^{t} + \beta \tilde{\delta}_{uv}^{t}.$$2 on C4. The technical point is that aggregation itself becomes the scaling axis: the router and experts are unchanged, but the aggregation space expands from a simple mixture to a learned DAG.

A related but distinct use appears in transformer modification through neuron encapsulation. Here the model partitions neurons into $$\eta_{uv}^{t} = (1-\beta)\alpha_{uv}^{t} + \beta \tilde{\delta}_{uv}^{t}.$$3 modules, computes

$$\eta_{uv}^{t} = (1-\beta)\alpha_{uv}^{t} + \beta \tilde{\delta}_{uv}^{t}.$$4

and then aggregates them as

$$\eta_{uv}^{t} = (1-\beta)\alpha_{uv}^{t} + \beta \tilde{\delta}_{uv}^{t}.$$5

with curvature-adaptive gating

$$\eta_{uv}^{t} = (1-\beta)\alpha_{uv}^{t} + \beta \tilde{\delta}_{uv}^{t}.$$6

The framework is embedded into each GPT-2 block and adds a Laplacian-style regularizer and explicit renormalization of $$\eta_{uv}^{t} = (1-\beta)\alpha_{uv}^{t} + \beta \tilde{\delta}_{uv}^{t}.$$7 (Bakushev et al., 10 Feb 2025). The reported model increases parameter count from $$\eta_{uv}^{t} = (1-\beta)\alpha_{uv}^{t} + \beta \tilde{\delta}_{uv}^{t}.$$8M to $$\eta_{uv}^{t} = (1-\beta)\alpha_{uv}^{t} + \beta \tilde{\delta}_{uv}^{t}.$$9M, reduces perplexity from $z_v = h_v^{intra} \,\|\, W_m h_v^{inter}.$0 to $z_v = h_v^{intra} \,\|\, W_m h_v^{inter}.$1 on News Articles and from $z_v = h_v^{intra} \,\|\, W_m h_v^{inter}.$2 to $z_v = h_v^{intra} \,\|\, W_m h_v^{inter}.$3 on Technical Manuals, and raises inference latency from $z_v = h_v^{intra} \,\|\, W_m h_v^{inter}.$4 ms to $z_v = h_v^{intra} \,\|\, W_m h_v^{inter}.$5 ms. In both DAG-MoE and neuron encapsulation, structural aggregation replaces implicit or permutation-invariant fusion by structured composition with module-level state and explicit control over interaction topology.

4. Combinatorial, statistical, and multilevel optimization

In combinatorial optimization, structural aggregation is often a consensus or synthesis procedure over structured objects. Levin’s framework for aggregation of composite solutions treats sets, set morphologies, and trees, and organizes aggregation around four strategies: extension, compression, combined strategy, and new design strategy (Levin, 2011). For sets, the exact kernel is

$z_v = h_v^{intra} \,\|\, W_m h_v^{inter}.$6

the superstructure is

$z_v = h_v^{intra} \,\|\, W_m h_v^{inter}.$7

and the weighted median is

$z_v = h_v^{intra} \,\|\, W_m h_v^{inter}.$8

Extended median/consensus then adds a knapsack layer under resource and compatibility constraints. For morphologies, aggregation becomes a multiple-choice knapsack or morphological clique problem. This use of structural aggregation is not statistical averaging; it is the construction of a structurally feasible consensus object under compatibility, budget, and hierarchy constraints.

In statistical learning, structured sparse aggregation aggregates least-squares estimators indexed by sparsity patterns while embedding structure into the prior over supports (Percival, 2011). For pattern $z_v = h_v^{intra} \,\|\, W_m h_v^{inter}.$9, the structural penalty is

$p_{i,j} = VAR(b^{i,j}) / u^{i,j},$0

and the structured sparse aggregation estimator is

$p_{i,j} = VAR(b^{i,j}) / u^{i,j},$1

The theory gives structured sparse oracle inequalities in terms of $p_{i,j} = VAR(b^{i,j}) / u^{i,j},$2 or, in grouped form, $p_{i,j} = VAR(b^{i,j}) / u^{i,j},$3 and $p_{i,j} = VAR(b^{i,j}) / u^{i,j},$4. The central claim is that finite-sample risk adapts to structured sparsity of the target, so aggregation is simultaneously a model-averaging device and a structure-aware regularizer.

In continuous nonconvex optimization, structural aggregation can mean aggregating constraints rather than estimators. For bilinear bipartite equalities, the paper studies

$p_{i,j} = VAR(b^{i,j}) / u^{i,j},$5

and then intersects convex hulls of such aggregated sets (Dey et al., 2024). The theoretical results are sharp: when $p_{i,j} = VAR(b^{i,j}) / u^{i,j},$6, there exists $p_{i,j} = VAR(b^{i,j}) / u^{i,j},$7 with $p_{i,j} = VAR(b^{i,j}) / u^{i,j},$8 such that $p_{i,j} = VAR(b^{i,j}) / u^{i,j},$9; in higher dimensions, there are examples where infinitely many aggregations are necessary, and other examples where aggregation cannot recover $b^{i,j}$0 exactly. The same paper applies this to structural model updating and reports average root-node relative gap improvements against one-row relaxation of $b^{i,j}$1 on the 12-story set and $b^{i,j}$2 on the 16-story set using grid search for aggregation weights.

Multilevel aggregation in numerical linear algebra is yet another form. In iterative PCA, documents are clustered into aggregates, a coarse data matrix $b^{i,j}$3 is formed, and the coarse covariance is

$b^{i,j}$4

The leading eigenvectors of $b^{i,j}$5 define projectors that augment fine-level power iteration (Bulgakov, 2016). On the Cardiovascular Diseases Abstracts data set with $b^{i,j}$6 and on the talk.politics data set with $b^{i,j}$7, the method uses $b^{i,j}$8 aggregates and targets the first $b^{i,j}$9 principal components. Here “aggregation” is literally coarse-model construction, closely paralleling structural multilevel methods in finite-element analysis.

5. Physical aggregation and geometric assembly

In physical and geometric contexts, structural aggregation refers to the emergence or design of aggregate structure itself. For printable aggregate elements, the problem is to synthesize a connected, globally rigid 3D object from large, identifiable elements such as pebbles, fruits, sticks, swords, or noodles (Dumas et al., 2018). The design variables are positions, orientations, and optionally articulated deformations of elements. The continuous surrogate is a density field

$u^{i,j}$0

and structural soundness is enforced by minimizing compliance

$u^{i,j}$1

subject to domain and deformation constraints. The optimization combines continuation, connectivity improvement, and finite-element analysis; reported examples include a chair made from $u^{i,j}$2 fruits on a $u^{i,j}$3 grid in about $u^{i,j}$4 min, a chair made from $u^{i,j}$5 swords in about $u^{i,j}$6 min, and tables made from $u^{i,j}$7 pebbles in about $u^{i,j}$8 min. In this setting, structural aggregation means arranging discrete elements so that shape and stiffness emerge jointly.

In polymer physics, structural aggregation denotes phase transitions between distinct aggregate morphologies rather than the assembly algorithm. For semiflexible $u^{i,j}$9 polymers, the order parameter

$t$0

distinguishes amorphous aggregates from bundles (Zierenberg et al., 2014). The study identifies $t$1 phases with $t$2 and $t$3 phases with $t$4, with low-temperature amorphous-to-bundle crossovers near $t$5 for $t$6 and $t$7 for $t$8. Aggregation is first-order-like for both system sizes. A later extension based on braided circuit topology argues that contact counts and $t$9 alone are insufficient for multichain aggregates, and introduces motif fractions

$G^{(t-1)}$0

together with braid length, writhe, and braid complexity to detect re-ordering in entangled bundles (Berx et al., 2023). In that formulation, structural aggregation is explicitly topological: it concerns not only whether chains aggregate, but how their contacts and entanglements are organized.

6. Structural aggregation in data systems, screening, and networked domains

In computational biology, AANet uses structural aggregation to reason over multiple candidate binding sites under pocket uncertainty (Zhu et al., 6 Jun 2025). After tri-modal alignment of ligand, holo pocket, and cavity embeddings, the method applies a single-head cross-attention adapter over candidate cavities,

$G^{(t-1)}$1

The final compatibility score is computed from $G^{(t-1)}$2 and an adapted ligand representation. On DUD-E in the blind apo setting, the method improves EF1% from $G^{(t-1)}$3 to $G^{(t-1)}$4, and on blind apo-pred it improves EF1% from $G^{(t-1)}$5 to $G^{(t-1)}$6. Here structural aggregation is a soft, ligand-conditioned combination of uncertain structural candidates.

In data management, structural aggregation is formalized directly over array neighborhoods. The AQL-to-MapReduce translator supports circular, grid, hierarchical, and sliding aggregations, and maps each to a structural group identifier such as a block index, output index, or ring id (Abdelmoniem et al., 1 Feb 2025). Grid aggregation uses keys like $G^{(t-1)}$7; sliding and circular templates enumerate all output groups affected by a cell; hierarchical aggregation becomes a pipeline of MapReduce stages. The translator uses custom splitters for dimension-based predicates, fuses value-based predicates into the mapper, and performs in-mapper aggregation through a minimal UDAF API with updateInMap, updateInReduce, and getAggResult. On the reported Hadoop cluster, generated code outperforms short handwritten code by up to $G^{(t-1)}$8x, with subsetting speedups for sliding aggregation reaching $G^{(t-1)}$9x at $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$00 subset and $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$01x at $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$02 subset.

Structural aggregation also appears in symbolic or networked inference. In ontology matching, the Heterogeneous Structural Combination Weight is

$\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$03

where $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$04 is the mean of six normalized structural differences: superclasses, subclasses, depth, instances, properties, and siblings (Keikha et al., 2013). This weight is then used to combine GMO, VDoc, and ISub scores heterogeneously for each class pair. On OAEI 2012, the reported F1 for group 201–210 rises to $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$05 under HSCW, compared with $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$06 for the Experimental strategy and $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$07 for Sigmoid. In production networks, nonlinear Domar aggregation is structural because the monetary input–output matrix transforms with prices when $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$08 (Nakano et al., 2024). Aggregate output is

$\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$09

and singularity occurs when

$\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$10

The same paper proves that same-direction shocks are superadditive when $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$11 and subadditive when $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$12. In both ontology matching and macro-network aggregation, structure enters by changing the weights through which local objects contribute to a global score.

7. General properties, limits, and recurring misconceptions

One recurrent misconception is that structural aggregation is synonymous with “more complex aggregation.” The literature does not support that simplification. Some uses are explicitly consensus-based, as in substructure or median/consensus for modular solutions (Levin, 2011). Others are explicitly geometric, as in array windows or polymer braids (Abdelmoniem et al., 1 Feb 2025, Berx et al., 2023). Others are operator-theoretic, as in aggregation of bilinear equalities or coarse PCA models (Dey et al., 2024, Bulgakov, 2016). What these approaches share is not complexity per se, but the use of explicit structural information to define the admissible aggregation domain.

A second recurring theme is the trade-off between discrimination or expressivity and feasibility. In structural graph classification, full $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$13-injectivity of multiset aggregation is provably expensive: for bounded $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$14, every $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$15-injective aggregation $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$16 satisfies

$\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$17

The same work therefore proposes the restricted notion of $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$18-injectivity and shows that the standard sum aggregator and a projective histogram can discriminate any fixed number of adversarial inputs when their output dimensions are scaled appropriately (Seo et al., 2019). An analogous pattern appears elsewhere: DAG-MoE gains expressivity but adds an $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$19 term and sequential overhead (Feng et al., 31 May 2026); bilinear aggregation can tighten relaxations substantially, yet exact recovery of $\mathcal{G}_t = \bigcup_{p_t \in P_t} G_{p_t}$20 may require infinitely many aggregations or may be impossible (Dey et al., 2024).

A third theme is that structural aggregation often emerges when simple averaging or simple pooling is no longer trusted. In heterogeneous GNNs, the necessity of meta-path was questioned, and HAGNN responded by hybridizing meta-path-based and meta-path-free aggregation (Zhu et al., 2023). In GCN robustness, weighted mean was shown to have low breakdown point, motivating median and trimmed mean (Chen et al., 2021). In SSRead, global readout was criticized for losing structural information of each node, motivating position-specific readout (Lee et al., 2021). In AANet, max-over-cavities is replaced or complemented by cross-attentive aggregation to address structural uncertainty (Zhu et al., 6 Jun 2025). This suggests that structural aggregation typically appears when the failure mode of a simpler aggregator can be tied to neglected structure.

Across these domains, structural aggregation therefore functions as a research program rather than a single technique. It asks how aggregation changes when the objects being combined possess graph structure, modular organization, geometric adjacency, compositional order, or topological entanglement, and it answers that question with domain-specific mechanisms: prototype alignment, structural priors, DAG composition, neighborhood masks, convexified surrogate constraints, or coarse-to-fine operators. The term is consequently best treated as a cross-disciplinary methodological category whose precise semantics are defined by the structure that governs the aggregation.