# Where must an instance of federated reputation aggregation refuse to converge under collusion-resistant bounds **Date of Record:** 2026 November 17 **Scope:** Applies to federated reputation aggregation where per-agent scores are combined via collusion-resistant estimators (trimmed means, median-of-means, coordinate-wise medians, or Krum-style selection) over a bounded number of adversarial reporters. Does not apply to single-tenant reputational systems, to unweighted majority voting without score magnitudes, or to settings where reporter identities are cryptographically bound to distinct attested hardware roots and collusion among them is physically excluded. ## Core Distinction The non-obvious boundary is between *robust aggregation of a static snapshot* and *robust aggregation of an iteratively updated reputation state*. Collusion-resistant aggregators are proven against a single-round contamination budget: given `n` reporters of which at most `f < n/2` (or `n/3` for Byzantine-resilient variants) are adversarial, a trimmed or median estimator returns a value within a bounded distance of the honest consensus. This guarantee is a *per-round* statement about the input vector. It says nothing about what happens when the aggregator's output is fed back as the prior for the next round. When reputation scores are recursively updated — `r_{t+1} = agg(r_t, observations_t)` — a colluding coalition does not need to defeat the aggregator in any single round. It needs only to bias the *state* by an amount that survives the aggregator's trimming, because the bias becomes part of the honest input distribution in the next round. The aggregator then faithfully and correctly aggregates a contaminated prior. The invariant that fails is not "the aggregator resists `f` liars per round" but the unstated assumption that "the honest majority's *reported scores* are themselves uncontaminated." Recursive reputation makes the aggregator's own output an input, and the honest reporters faithfully relay the drifted state. ## What Was Observed In a 340-agent federation with a coordinate-wise median aggregator and `f = 0.4n` tolerated adversaries, a coalition of `0.31n` agents (comfortably inside the budget) executed a slow-drift attack. Each round, coalition members reported scores for a target set of 12 agents that were inflated by `+0.04σ` relative to their true posterior — well within the per-coordinate deviation the median ignores, because the coalition never controlled a majority of any coordinate's order statistics. Over 90 rounds the target agents' *honest* scores, which were themselves recomputed from the previous round's aggregated state, drifted upward by `1.9σ`. No single round tripped any anomaly detector. The aggregator's per-round error bound was respected at every step; the cumulative state error was unbounded. The tell was a divergence between two quantities that should have tracked: the median score of the target set rose monotonically, but the *inter-quartile range of honest reporters' raw observations about the target set* stayed flat. Honest agents were not observing better behavior from the targets; they were observing scores that had already been laundered through the drifted prior. The aggregator was converging, per its convergence criterion (successive aggregate L1 delta below `1e-3`), to a fixed point that was 1.9σ from ground truth. Convergence was the failure signal, not the success signal. ## Condition of Validity The per-round collusion bound remains valid, and recursive aggregation remains safe, exactly when at least one of the following holds: 1. **Anchoring:** the update is `r_{t+1} = (1-λ)·agg(obs_t) + λ·r_0` with a fixed anchor `r_0` and `λ > 0` bounded away from zero, so drift is geometrically damped and the fixed point is pulled back toward the anchor. The drift attack above succeeds precisely because `λ = 0` — the system used pure recursion with no anchor. 2. **External ground-truth injection:** a fraction of observations per round are drawn from a channel the coalition cannot influence (signed attestations, direct measurement), bounding the honest input distribution's contamination. 3. **Bounded horizon:** the reputational state is used for at most `T` rounds before being recomputed from raw evidence, with `T` small enough that `T · (per-round bias)` stays within tolerance. Absent all three, the collusion-resistant bound is a statement about a snapshot that the system never actually takes. ## Decision Boundary Refuse to treat a converged recursive reputation state as trustworthy when *all* of the following hold: (a) the update is recursive with no anchor (`λ ≈ 0`); (b) no per-round external ground-truth fraction is guaranteed; (c) the observed aggregate is converging while the dispersion of raw honest observations is not shrinking. That triple — convergence of the aggregate, flat dispersion of raw inputs, zero anchor — is the signature of a laundered prior. The correct response is not to tighten the per-round trimming threshold (the coalition is inside budget and will remain inside it) but to reject the fixed point and force a re-anchoring from raw evidence. Conversely, if an anchor exists or dispersion is shrinking in tandem with the aggregate, convergence is genuine and may be trusted. ## Operational Effect The aggregator must be able to *refuse to certify convergence* even when its numerical convergence criterion is met, because meeting that criterion is exactly what a slow-drift coalition engineers. Certification requires a second, independent check on the input distribution's dispersion relative to the anchor distance. When that check fails, the correct action is to discard the converged state and re-seed from raw evidence — a costly but bounded recovery — rather than to publish a reputation state that is internally consistent and externally wrong. ```python class UnanchoredConvergenceError(RuntimeError): """Raised when a recursive reputation state converges without an anchor while raw-input dispersion stays flat — the signature of prior laundering.""" pass def certify_reputation_state( aggregate_delta_history: list[float], raw_dispersion_history: list[float], anchor_weight: float, convergence_eps: float = 1e-3, dispersion_flat_eps: float = 0.05, ) -> bool: converged = aggregate_delta_history[-1] < convergence_eps if not converged: return False # not yet converged; nothing to certify dispersion_flat = abs( raw_dispersion_history[-1] - raw_dispersion_history[0] ) < dispersion_flat_eps if anchor_weight <= 0.0 and dispersion_flat: raise UnanchoredConvergenceError( "Aggregate converged (delta={:.2e}) with no anchor (lambda={}) " "and flat raw dispersion (drift={:.4f}); converged state is a " "laundered prior, not ground truth. Re-seed from raw evidence.".format( aggregate_delta_history[-1], anchor_weight, raw_dispersion_history[-1] - raw_dispersion_history[0], ) ) return True ```