Invariant Aggregation (IA)

• Invariant Aggregation is a framework of aggregation schemes that enforce invariance under specified transformation rules, ensuring robustness and consistency.
• It systematically isolates nuisance variations through dedicated components like boundary regions, invariant branches, or masks to enhance model reliability.
• IA is applied across fields such as image segmentation, federated learning, and graph pooling, where precise invariance criteria lead to provable performance gains.

Invariant Aggregation (IA) denotes a family of aggregation principles in which an aggregate is required to remain unchanged, or to change only in a prescribed way, under a specified class of transformations. In the literature, the protected transformations vary by domain: seeded region initialization order in image segmentation, adjacent-category merging in ordinal marginals, client-specific attribute skew in federated learning, node relabeling in graph comparison, Euclidean motions in molecular representation learning, and malicious or minority-aligned update directions in robust federated optimization. The common theme is that aggregation is constrained by an invariance criterion that separates admissible structural information from nuisance variation or arbitrary procedural choices (0806.3887, Chambers et al., 18 Sep 2025).

1. Conceptual scope

The term is not attached to a single formalism. Instead, it appears as a domain-dependent design principle: define a transformation that should not affect the semantic content of the aggregate, then construct the aggregation rule so that this condition is enforced. This suggests that IA is best treated as a class of invariance-constrained aggregation schemes rather than a single algorithmic template.

Setting	Invariant requirement	Representative formulation
Seeded region growing	Independence from seeded region initialization order	Ambiguous pixels are assigned to a boundary region (0806.3887)
Joint-distribution modeling	Merging adjacent categories must not alter unaffected joint probabilities	IA holds iff the model is a copula model (Chambers et al., 18 Sep 2025)
Federated learning under attribute skew	Only cross-invariant attributes participate in global aggregation	Aggregate invariant branch, keep specific branch local (Luo et al., 2022)
Symmetry-aware pooling	Pooling must respect group orbits	Orbit-aware global pooling (Bujel et al., 2023)
Robust federated defense	Keep only update dimensions with broad directional agreement	AND-mask plus trimmed-mean (Wang et al., 2022)

Two broad patterns recur. In one pattern, invariance means exact independence from a procedural choice, such as seed order. In the other, invariance specifies how an aggregate must transform under a controlled modification, such as merging two adjacent ordinal bins. A further recurrent motif is the use of a reserved component—boundary region, invariant branch, orbit summary, or mask—to isolate ambiguity or nuisance structure from the aggregated signal.

2. Order-invariant region growing and ambiguous pixels

A canonical formalization of IA appears in seeded region growing by pixels aggregation (SRGPA), where the central difficulty is dependence on the seeded region initialization order (SRIO). In the simple-partition setting, the image domain $\Omega$ is partitioned into disjoint regions $X_i$, and region growth is governed by zones of influence

$$Z_i^t = (X_i^t \oplus V)\setminus \left( \bigcup_{j\in\mathbb{N}} X_j \right).$$

When multiple regions grow toward the same ambiguous pixel, the resulting assignment depends on which pixel enters the queue first. This makes the final partition SRIO-dependent (0806.3887).

The paper introduces a precise geometric account of ambiguity through geodesic distance. Given seeds $S=(s_i)_{1\le i\le n}$, the geodesic influence zone of seed $s_i$ is

$$z_A(s_i)=\left\{x\in\Omega:\forall j\neq i,\ d_\Omega(s_i,x)<d_\Omega(s_j,x)\right\},$$

and the ambiguous set is

$$A=\left\{x\in\Omega:\exists i\neq j,\ d_\Omega(s_i,x)=d_\Omega(s_j,x)<d_\Omega(s_k,x)\ \forall k\notin\{i,j\}\right\}.$$

The domain then decomposes as

$$\Omega=\left(\biguplus_{i=1}^{n} z_A(s_i)\right)\uplus A.$$

The IA construction assigns all ambiguous pixels to a dedicated boundary region. Operationally, the algorithm maintains zones of influence and uses a system queue. When a pixel $x$ belongs to the zones of influence of at least two regions and the currently processed region has the minimal label among them, the pixel is assigned to the boundary region; otherwise it is assigned to the unique region. The resulting partition is $\{z_A(s_i)\}_{1\le i\le n}\cup A$, and is independent of SRIO (0806.3887).

This formulation is significant because it converts order dependence into an explicit ambiguity set. The boundary region is composed entirely and exclusively of ambiguous points, while regular points are assigned according to unique geodesic proximity. The paper also notes an important limitation: the resulting partition is a simple partition with some holes, but not always a $X_i$0-boundary-partition. That distinction prevents a common misconception that “adding a boundary region” alone is sufficient; the invariant result requires the boundary to coincide with the ambiguous set rather than with whichever pixels happen to be claimed first.

3. Marginal coarsening invariance and copula models

A second formalization of IA concerns the construction of a joint distribution from categorical marginals with ordinal structure. Here, a model is a map

$X_i$1

and the invariance requirement concerns merging adjacent categories in one marginal. If two adjacent categories are merged, the recommended joint distribution over unaffected values should remain unchanged. This is called Invariant Aggregation in the paper (Chambers et al., 18 Sep 2025).

For a marginal distribution $X_i$2 and index $X_i$3, the merged distribution $X_i$4 is defined by

$X_i$5

If the merge is performed in coordinate $X_i$6, the IA condition requires the model output to transform by preserving unaffected entries and summing only the merged adjacent probabilities in the affected coordinate. The paper’s main theorem states:

A model satisfies IA if and only if it is a copula model (Chambers et al., 18 Sep 2025).

The copula representation is given by

$X_i$7

where $X_i$8 is a copula and $X_i$9 are the marginal cdfs. The independence copula and the Fréchet–Hoeffding upper bound are explicit examples discussed in this connection, while maximal coupling is presented as a contrast that fails IA (Chambers et al., 18 Sep 2025).

The practical consequences are stated clearly in the paper. IA provides robustness against data manipulation and survey design, because arbitrary adjacent-bin coarsening does not distort unaffected recommendations. It also allows seamless incorporation of new variables. The paper further notes that in the unordered categorical case, adjacency is meaningless; imposing a neutrality or label-invariance condition then restricts admissible models to the independence copula for those variables. This establishes one of the sharpest known characterizations associated with IA: in this setting, invariance is not merely desirable regularization, but an exact criterion that identifies an entire model class.

4. Federated learning: invariant branches, adversarial masking, and partial aggregation

In federated learning under attribute skew, IA appears as a rule for excluding domain-specific structure from global aggregation. Disentangled Federated Learning (DFL) separates each client model into an invariant branch $$Z_i^t = (X_i^t \oplus V)\setminus \left( \bigcup_{j\in\mathbb{N}} X_j \right).$$0 and a specific branch $$Z_i^t = (X_i^t \oplus V)\setminus \left( \bigcup_{j\in\mathbb{N}} X_j \right).$$1, with prediction module $$Z_i^t = (X_i^t \oplus V)\setminus \left( \bigcup_{j\in\mathbb{N}} X_j \right).$$2 operating on the concatenated outputs. The global objective is written as

$$Z_i^t = (X_i^t \oplus V)\setminus \left( \bigcup_{j\in\mathbb{N}} X_j \right).$$3

where only the invariant parameters $$Z_i^t = (X_i^t \oplus V)\setminus \left( \bigcup_{j\in\mathbb{N}} X_j \right).$$4 are aggregated, while the domain-specific parameters $$Z_i^t = (X_i^t \oplus V)\setminus \left( \bigcup_{j\in\mathbb{N}} X_j \right).$$5 remain local (Luo et al., 2022).

The server-side aggregation rule is

$$Z_i^t = (X_i^t \oplus V)\setminus \left( \bigcup_{j\in\mathbb{N}} X_j \right).$$6

equivalently

$$Z_i^t = (X_i^t \oplus V)\setminus \left( \bigcup_{j\in\mathbb{N}} X_j \right).$$7

Disentanglement is promoted by the mutual-information objective

$$Z_i^t = (X_i^t \oplus V)\setminus \left( \bigcup_{j\in\mathbb{N}} X_j \right).$$8

which minimizes dependence between specific and invariant features while maximizing alignment between local and global invariant branches. Training alternates between a local step, where the invariant branch is frozen and the specific branch is optimized, and a global step, where the specific branch is frozen, the invariant branch is optimized, and invariant parameters are aggregated. The paper states that this is the first convergence guarantee for federated learning with partial aggregation and reports higher top-1 accuracy, better interpretability, and faster convergence rate than compared methods on both synthetic and realistic attribute-skew datasets (Luo et al., 2022).

A distinct use of invariant aggregation in federated learning concerns defense against backdoor attacks. The “Invariant Aggregator” paper defines invariant directions as update dimensions for which many clients agree on the sign. For client pseudo-gradients $$Z_i^t = (X_i^t \oplus V)\setminus \left( \bigcup_{j\in\mathbb{N}} X_j \right).$$9, sign consistency in dimension $S=(s_i)_{1\le i\le n}$0 is

$S=(s_i)_{1\le i\le n}$1

A mask is then formed as

$S=(s_i)_{1\le i\le n}$2

Only dimensions passing this consistency check are retained, and aggregation within retained dimensions is performed using trimmed-mean. The final update is

$S=(s_i)_{1\le i\le n}$3

The paper argues that this combination is effective over flat loss landscapes because the masking criterion uses sign rather than magnitude, and reports that the backdoor attack success rate was reduced by 61.6% on average compared to standard FedAvg, with an average 1.2% loss in benign accuracy relative to no defense (Wang et al., 2022).

Taken together, these two strands show that IA in federated learning can mean either selective participation of invariant model components in the global average, or selective participation of invariant update directions in a robust aggregator. In both cases, the aggregation rule is explicitly designed to reject client-local or minority-aligned variation from the global update.

5. Isomorphism, group actions, and geometric invariant pooling

In graph isomorphism, IA appears as neighborhood aggregation that is invariant to node relabeling. The $S=(s_i)_{1\le i\le n}$4-labeling of a node $S=(s_i)_{1\le i\le n}$5 is defined by the matrix whose $S=(s_i)_{1\le i\le n}$6-entry counts the number of walks of length $S=(s_i)_{1\le i\le n}$7 from $S=(s_i)_{1\le i\le n}$8 to $S=(s_i)_{1\le i\le n}$9:

$s_i$0

This yields an isomorphism invariant because corresponding nodes in isomorphic graphs have permutation-equal labels. The refinement $s_i$1-labeling replaces sum-aggregation by multiset-aggregation over neighbor labels. The paper states that $s_i$2 identifies all trees, $s_i$3 identifies all 3-connected planar graphs, and $s_i$4 distinguishes all graphs up to 12 nodes and all known strongly regular graphs up to 64 nodes in the reported experiments (Jüttner et al., 2023).

For general group symmetries, Group Invariant Global Pooling (GIGP) defines invariant aggregation at the level of group orbits. Writing the set of orbits as $s_i$5, the pooling layer takes the form

$s_i$6

The paper states that GIGP is provably sufficiently expressive to represent a large class of invariant functions and validates it on rotated MNIST and QM9, where it attains identical results on the former and improved performance on the latter relative to standard global pooling (Bujel et al., 2023).

In molecular learning, invariance is formulated with respect to $s_i$7 actions and permutation of conformers. The conformer aggregation mechanism is based on the Fused Gromov-Wasserstein barycenter

$s_i$8

with final multimodal aggregation

$s_i$9

and prediction

$$z_A(s_i)=\left\{x\in\Omega:\forall j\neq i,\ d_\Omega(s_i,x)<d_\Omega(s_j,x)\right\},$$0

The paper proves that the aggregation pipeline is $$z_A(s_i)=\left\{x\in\Omega:\forall j\neq i,\ d_\Omega(s_i,x)<d_\Omega(s_j,x)\right\},$$1-invariant and permutation-invariant with respect to conformer order, and reports that the method significantly outperforms state-of-the-art molecule property prediction methods on established datasets (Nguyen et al., 2024).

Invariant aggregation also appears in graph out-of-distribution generalization. PISA extends earlier invariant-subgraph methods by freezing multiple invariant branches and learning a dynamic MLP-based aggregation over the stacked branch predictions,

$$z_A(s_i)=\left\{x\in\Omega:\forall j\neq i,\ d_\Omega(s_i,x)<d_\Omega(s_j,x)\right\},$$2

The paper states that this adaptive aggregation prioritizes informative invariant subgraphs more effectively than uniform or greedy aggregation and reports up to 5% higher classification accuracy than prior methods on 15 datasets (Ghasemi et al., 27 Nov 2025).

These examples show that in symmetry-sensitive learning, IA typically operates by making the pooling operator orbit-aware, multiset-aware, or geometry-aware. The invariant condition is attached to the action that should be quotiented out—permutations, isomorphisms, Euclidean motions, or environment-specific subgraphs—while retaining enough structure for discrimination.

6. Aggregation invariants, correctness criteria, and terminological boundaries

Not every aggregation invariant in the literature is labeled “Invariant Aggregation,” but several adjacent traditions are conceptually close. In distributed averaging, the core invariant is mass conservation:

$$z_A(s_i)=\left\{x\in\Omega:\forall j\neq i,\ d_\Omega(s_i,x)<d_\Omega(s_j,x)\right\},$$3

The analysis of Push-Sum Protocol, Push-Pull Gossip, and Distributed Random Grouping shows that asynchrony, message loss, and node crashes can break this invariant in realistic settings, compromising correctness. Two modified versions of Push-Pull Gossip—Push-Pull Back Cancellation and Push-Pull Ordered Wait—are proposed to restore atomic mass exchange and thereby preserve mass conservation (Jesus et al., 2010). This is not called IA in the paper, but it exemplifies the broader principle that an aggregation procedure is only dependable if its defining invariant survives the operational environment.

A related notion appears in interactive analytics, where correctness of aggregate queries is controlled by aggregable properties, summarizability, generalized summarizability, and propagation rules through filter, project, join, aggregate, union, difference, and pivot. The paper’s objective is to preserve summarizability and generalized summarizability under analytic operations so that semantically incorrect aggregate queries can be detected automatically, including for non-distributive functions like average and count (Simon et al., 2021). Here again, the invariant is not a symmetry of the input but a correctness condition that must be preserved across transformations of a query session.

Belief aggregation provides a more explicitly normative variant. The paper on (Non-)Commutative Aggregation studies commutativity, moderate commutativity, and weak commutativity as criteria relating update-then-aggregate and aggregate-then-update procedures. It shows that strong commutativity together with Pareto and Monotonicity yields dictatorship, while weak commutativity characterizes dual-self aggregation and moderate commutativity characterizes linear pooling under suitable assumptions (Yang, 2024). This places IA-like ideas within a broader family of invariance criteria for aggregation under uncertainty.

The term “IA” is also used for unrelated concepts. “Interaction-and-Aggregation” in person re-identification refers to spatial and channel feature aggregation modules that model interdependencies and adapt receptive fields, but it is not a formal theory of invariant aggregation in the sense used above (Hou et al., 2019). “Incremental Aggregation” in multi-hop federated learning denotes in-network aggregation at intermediate hops; the paper studies correlated sparsification methods such as RE-SIA, CL-SIA, TC-SIA, and CL-TC-SIA, and reports a 15x improvement in communication efficiency over conventional routing and a 11x improvement over state-of-the-art sparse IA, but the acronym there stands for incremental rather than invariant aggregation (Mukherjee et al., 2024). Likewise, robust vote aggregation for invariant local features concerns multi-detection from local correspondences and vote spaces, rather than a general IA principle (Kurzejamski et al., 2016).

A persistent misconception is therefore terminological: “IA” does not denote one universally shared method across computer vision, graph learning, federated optimization, statistics, and decision theory. The more stable commonality is structural. Each line of work defines a transformation—seed order, label permutation, group action, adjacent-bin coarsening, adversarial update direction, or analytic query rewriting—that should not alter the meaningful content of the aggregate. The aggregation rule is then engineered so that this requirement becomes a theorem, a convergence guarantee, or a correctness certificate.