Verifiable Symmetry Budgets for Federated Learning with Open Membership

When many devices train a shared model without revealing their data, secure aggregation hides each device's update from the server. That privacy also blinds the server to poisoned updates. The only checks it can run on a hidden update today are coarse size limits. Those limits are hardest to get right when membership is open, meaning new, unvetted devices can join mid-training: a newcomer has no track record, so defenses that compare a client against its own history have nothing to work with. We propose a different check. Many tasks have a known symmetry, such as tissue patches looking the same when rotated. For those tasks, an honest client that trains with symmetry-based data augmentation (feeding the model rotated and reflected copies of each example) produces an update with a predictable linear structure. Its component that breaks the symmetry is small. A client can prove this in zero knowledge, meaning without revealing the update, using the same machinery already used to prove size limits.

The point is that augmentation, usually treated purely as a training trick, also makes updates checkable. The check is a fixed public statement that does not depend on who is in the federation, so it applies equally to a client that joined five minutes ago. It confines an attacker to symmetric perturbations. That removes, for example, backdoors keyed to a small patch in one corner of the image, and it costs one extra linear map inside an existing proof.

Core Claim

Take a convolutional network built only from square-kernel convolutions, symmetric padding and pooling, and a global average pool before the classifier head. Let $G$ be the dihedral group $D_4$: the eight rotations by multiples of 90° and reflections. Rotating or reflecting the input is equivalent to applying the same spatial transform to every kernel. That transform is a public permutation $\rho(g)$ of the weight vector, and it satisfies $L(\theta; g\cdot x) = L(\rho(g)^{-1}\theta; x)$, where $L$ is the per-example loss and $\theta$ the weights.

Define the orbit-averaged loss $\bar L(\theta) = \frac{1}{|G|}\sum_{g\in G} L(\theta; g\cdot x)$. It is invariant under every $\rho(h)$. Because permutations are orthogonal, its gradient therefore transforms equivariantly. If the global model $\theta$ is itself symmetric, then the gradient is fixed by every $\rho(h)$, and so is any multi-step local update $\Delta$. Writing $P_\perp = I - \frac{1}{|G|}\sum_{g}\rho(g)$ for the public projection onto the symmetry-breaking subspace, honest full-orbit training gives

$$\|P_\perp \Delta_i\|_2 \le \tau, \qquad \|\Delta_i\|_2 \le B,$$

where $\Delta_i$ is client $i$'s update and $B$ is the usual norm bound. The budget $\tau$ is zero in exact arithmetic for perfectly symmetric data and models. It is set positive to absorb two things: real symmetry breaking in the data, such as anatomical laterality, and the noise from sampling one random orbit element per example instead of averaging over all eight. The same derivation applies to the 48-element octahedral group on 3D volumes, the symmetry group used for cosmological fields in Estimating Cosmological Parameters from the Dark Matter Distribution.

What is new is treating this inequality as an input-validation predicate under secure aggregation and studying its value when membership churns. ACORN: Input Validation for Secure Aggregation proves $L_0$, $L_2$ and $L_\infty$ bounds on masked updates with Bulletproofs, a type of short zero-knowledge proof. It constrains only update magnitude, not direction, and it assumes a fixed client set per session. ESP: Exploiting Symmetry Prior for Multi-Agent Reinforcement Learning shows that symmetry augmentation plus a consistency loss matches hard-coded equivariant networks while staying flexible. It operates in an unencrypted, fixed-cohort setting and never uses symmetry as something a third party can check. We reuse ACORN's proof system and ESP's insight that symmetry works best as a soft constraint. We contribute the predicate, the budget calibration, and the open-membership evaluation.

Research Program

The first component is the predicate and its calibration. We will derive $\rho(g)$ for standard small CNNs, for example the ResNet-18 that MedMNIST v2 finds competitive on 28×28 images, after replacing any asymmetric stride or padding. We will verify the invariance identity numerically. We then study how the honest distribution of $\|P_\perp\Delta_i\|$ depends on three factors: full-orbit versus sampled-orbit augmentation, the number of local steps, and how much asymmetry the global model has already absorbed. The server publishes $\tau$ per round. It also caps the symmetry-breaking part of the global model by partially projecting it, which keeps the regime "approximately symmetric" rather than letting asymmetry drift without limit.

The second component is the proof. Since $P_\perp$ is an average of permutations, $P_\perp\Delta_i$ is a public linear function of the committed update. Proving its norm bound adds a linear transformation in front of ACORN's existing $L_2$ argument. We will implement this and measure the real client cost, not assume it.

The third component is open membership. New clients are admitted through a Merkle-tree membership proof, the accumulator approach from the dynamic signature literature (Lattice-Based Group Signatures: Achieving Full Dynamicity with Ease.). They are given masking neighbors drawn from the current roster, in the spirit of Flamingo's per-round neighborhood graphs (Flamingo: Multi-Round Single-Server Secure Aggregation with Applications to Private Federated Learning). We do not claim a new security proof for dynamic joins, which Flamingo leaves open. The prototype exists so that churn, and attackers arriving as fresh joiners, can be simulated realistically. The ML question is whether a check that ignores history holds up under churn better than defenses that rely on history.

Baselines

The naive reference point is secure aggregation with no input validation, with clients applying augmentation or not as they choose. It sets the attack ceiling and the clean-accuracy ceiling. As a sanity anchor for the clean federated setting, Flamingo reports convergence on EMNIST in "40 minutes" against "3.5 hours" for BBGLR, with accuracy identical to non-private training. We do not need to beat that number; it only confirms our masking prototype is not the bottleneck.

The strongest existing method is ACORN-style norm validation. Every client proves $\|\Delta_i\|_2\le B$, with $B$ tuned on clean held-out rounds to the same false-rejection rate we allow for our predicate. ACORN reports dense-vector proofs of length 250,000 "under 80 seconds on a standard laptop" and end-to-end bandwidth "as low as 5% more than non-validated aggregation". We take those as the cost reference. For backdoor or poisoning success under ACORN, no reported result was found on Lacuna, so we rerun it ourselves on identical data, attack budgets and rounds. Beating it means a lower backdoor attack success rate at matched clean accuracy (within 0.5 AUC or accuracy points) and matched honest rejection rate, with proof time and bandwidth within a small constant factor of ACORN's reported figures.

The third baseline is a history-based robust filter that we implement. It down-weights clients whose update disagrees with their own past updates. Unlike secure aggregation, it requires seeing individual updates, which makes it an optimistic, privacy-violating upper reference for history-based defenses. It isolates the open-membership question, because it should degrade as the fraction of fresh joiners rises.

The key ablation sets $\tau=0$ with an exactly weight-tied invariant CNN and server-side projection of the aggregate. That configuration needs no zero-knowledge proof at all, as discussed next.

Why not just…?

Why not just use a weight-tied equivariant network and project the aggregate onto the symmetric subspace? This is the real threat. It gives the $\tau=0$ version of our defense for free, because the server can delete every symmetry-breaking component without seeing individual updates. If data symmetry is exact, our proof machinery is unnecessary, and we will report it that way. The case for a positive budget rests on datasets where symmetry is only approximate. ESP's argument that hard constraints prevent learning "subtle, real-world symmetry-breaking nuances" predicts that the tied model loses accuracy there. With $\tau>0$, aggregate projection cannot tell honest asymmetry from malicious asymmetry, so a per-client budget needs a per-client proof. The experiment comparing ChestMNIST/OrganAMNIST with PathMNIST settles this. If the tied model matches the budgeted model on the broken-symmetry datasets, we drop the zero-knowledge component.

Why not just rely on norm bounding? A norm ball is isotropic: an attacker spends their whole budget in whatever direction implants the backdoor. Our predicate removes the symmetry-breaking directions, which make up the bulk of the parameter space for an eight-element group. We cannot cite a measured backdoor rate under ACORN, so the head-to-head comparison against the norm-only baseline will show directly whether the extra constraint changes attack success.

Why not just ask clients to augment and trust them? Augmentation that is never checked constrains only honest clients. ESP also shows that augmentation alone, without a consistency term, adds variance. The no-validation baseline with augmentation measures exactly this. The relevant attacker ignores the instruction, so trust buys no robustness.

Why not just re-key and re-vet the federation whenever someone joins? Flamingo's measurements show per-round setup is the dominant latency cost in wide-area networks: 3.5 hours versus 40 minutes. Even with cheap re-keying, a fresh joiner still has no history. Re-keying addresses who may participate, not whether their update is plausible, so it complements our check rather than replacing it.

Proposed Experiments

The main testbed is MedMNIST v2. We pair approximately rotation- and reflection-invariant 2D tasks (PathMNIST, BloodMNIST, DermaMNIST) with tasks where the symmetry is broken (ChestMNIST, OrganAMNIST). We add the 3D subsets with the octahedral group to test scaling to $|G|=48$. For reference, the paper reports average AUC of 0.927 for Google AutoML Vision on the 2D tasks and 0.863 for 3D ResNet-50. We add CIFAR-10 with horizontal flip only, as a group of order two. EMNIST serves as a negative control: rotations change letter and digit identity, so the predicate should either force $\tau$ so large it becomes useless or hurt accuracy, and we expect to report that.

Clients are partitioned non-identically. Each round, a joining process replaces 0–50% of the active roster. Attackers enter only as joiners and make up 5–20% of participants. They run three attacks: a corner-patch backdoor, a targeted label flip, and, as an honest stress test of the predicate's limit, a backdoor with a $D_4$-symmetric trigger. The symmetric-trigger attack should not be stopped by our check by construction.

The metrics are clean AUC or accuracy, attack success rate, the false-rejection rate of honest clients as a function of $\tau$, client proof time and bandwidth relative to ACORN's norm-only proof, and how each metric changes as churn increases.

Three outcomes would decide the proposal. First, on the approximately symmetric datasets, the budgeted predicate must cut corner-patch backdoor success well below norm-only validation at matched clean accuracy. If it does not, the idea fails. Second, on the broken-symmetry datasets, the budgeted model must beat the $\tau=0$ tied model on clean accuracy while keeping most of the robustness gain. If it does not, the simpler aggregate projection wins and the zero-knowledge proof is unjustified. Third, as the joiner fraction rises, the history-based filter's robustness should decline while ours stays flat, because our predicate depends on nothing but the current update and the public group. The symmetric-trigger attack will be reported in all cases, to show exactly what the defense does not cover.