Two trackers, one truth — how to combine estimates across a network without counting the same evidence twice.
Two radar sites both track the same aircraft. Each hands you a track: a state estimate and a covariance ellipse. Surely fusing them — averaging weighted by confidence — gives you a better track. It gives you a smaller ellipse. It does not necessarily give you a smaller error.
Make it concrete. Radar A reports the aircraft with a 1 km ellipse; radar B reports it with a 1.2 km ellipse. You have done the textbook move a dozen times on this site (combining two measurements, the information filter): convert to information, add, invert. Out comes an ellipse of roughly three-quarters the size — σ ≈ 0.77 km. Tighter than either input. Progress, apparently.
Now ask the fatal question: what did that rule assume? That the two errors are independent. But both trackers were initialized from the same flight-plan prior. Both use the same constant-velocity physics chasing the same actual wind gusts. And if the two sites ever exchanged tracks before, each estimate already contains pieces of the other. Their errors are not independent opinions — they are two retellings of substantially the same story.
Here is the pathology in its purest form: fuse the same two tracks twice. The information doubles again; the ellipse shrinks by another factor of √2. Nothing new was measured. Keep iterating and the claimed variance is halved every round while the true error variance never moves — with the numbers we will derive in Chapter 3, the consistency ratio (NEES) grows like 1.2 × 2k−1 after k mutual exchanges. The filter becomes arbitrarily confident and not one bit more correct.
The crime has a name: double counting of common information — information that both estimates already contain. A shared prior. Shared process noise from chasing the same physical target. A previously exchanged message coming back around like a rumor you started yourself.
This is not a radar curiosity. Multi-robot SLAM merging maps between robots, V2X cars sharing perceived pedestrians, satellite constellations sharing orbit estimates, sensor-network temperature fields — every one of these dies the same death if fusion is naive. Wherever estimates travel over a network, the overlap problem travels with them.
This lesson builds the complete arsenal, one discipline per chapter: (1) bookkeep the overlap exactly — channel filters, exact on tree networks; (2) refuse to claim what you cannot prove — covariance intersection and the geometric mean, consistent anywhere; (3) restructure so the overlap is pre-paid — federated splitting; (4) agree by iteration — consensus. One problem, four answers.
The cross is the true aircraft. Warm and teal ellipses are the two radar tracks (95%). Fuse once draws the naive information-sum ellipse (red dashed). Keep exchanging repeats the mutual re-fusion: watch the ellipse shrink by √2 per round around a point that never moves toward the truth, while the NEES readout climbs. The slider controls how correlated the two track errors are drawn on Reset.
Before any algebra, a plumbing question. Your four radar sites must somehow act like one tracker. What travels down the wire — raw detections, finished tracks, or something in between? That one choice determines everything that can go wrong later.
Three architectures cover the field (the full taxonomy lives in fusion architectures; here is the compressed version). Centralized: every sensor streams raw measurements to one filter. Hierarchical (track-level): each site runs its own local filter and sends finished tracks up to a fusion center. Fully decentralized: peers exchange with neighbors; no center exists, and no node even knows the global topology.
Make "what crosses the wire" quantitative. A raw measurement is m numbers per detection. A track report is n + n(n+1)/2 numbers per update — the state vector plus the symmetric covariance. For a 6-state track that is 27 numbers, versus 3 for a position detection. Track fusion is not automatically the low-bandwidth option; what it buys is a lower rate (send at 1 Hz what was sensed at 50 Hz) and local autonomy — each site keeps a usable track even if the network dies.
Centralized is the gold standard for accuracy: one filter, conditionally independent raw measurements, no double counting possible by construction. It loses anyway, for reasons that have nothing to do with estimation theory: a single point of failure, raw-data bandwidth at full sensor rate, one processor sized for the whole problem — and politics. Coalition partners and competing vendors will not stream you raw data.
Hierarchical fusion commits the first correlation sin: the center receives tracks whose errors are correlated through common process noise (Chapter 6 derives exactly how much), and if the center feeds fused tracks back down to the sites, it manufactures loops (Chapter 3's nightmare).
Decentralized is the PhD-hard case and this lesson's home. Every node is a peer running its own filter and exchanging with neighbors. Survivability is the prize: kill any node and the network degrades gracefully. The price: common information is now everywhere, and nobody has the global view needed to subtract it exactly.
Here is the lesson mapped onto this taxonomy. The information filter (Chapter 2) makes decentralized exchange algebraically clean. Channel filters (Chapter 4) make it exact on trees. CI and the geometric mean (Chapter 5) make it safe on any graph. Federated filtering (Chapter 7) is hierarchical fusion done with exact bookkeeping. Consensus (Chapter 8) is decentralized agreement by iteration.
Switch between the three architectures and watch what flows: small dots are raw measurements (m = 2 numbers, at sensor rate), fat rectangles are track reports (n + n(n+1)/2 = 14 numbers for n = 4, at 1 Hz), diamonds are information deltas between peers. The corner readout totals the link load. Then kill a node and see which architecture survives.
You met the information filter in the information filter lesson. Here is the sixty-second recap of the only fact this lesson needs: when evidence is genuinely independent, beliefs add.
The dual coordinates in three sentences. The information matrix Y = P−1 measures sharpness rather than spread. The information vector y = P−1x̂ is the estimate expressed in those coordinates. Same Gaussian, inverse bookkeeping — the derivation, and the price the predict step pays in this form, both live in sf-09.
Now the load-bearing wall of this entire lesson — the addition theorem. If the joint likelihood factorizes, p(zA, zB | x) = p(zA | x) p(zB | x), then the posterior information is a plain sum:
Each source contributes an information increment (ik, Ik) = (HkTRk−1zk, HkTRk−1Hk), and fusion is a sum — order-free, associative, perfect for a network. Feel how mechanical this is with three sensors:
Three independent sensors measure the same scalar x, no prior. Sensor variances R = (4, 2, 4); readings z = (10.4, 9.9, 10.1). Fuse them in information form.
Now flip the theorem around, because this pivot is the whole lesson. Addition is exact only under conditional independence given the state. The "given x" matters: two sensors are conditionally independent when, once you know the true state, their errors share nothing. Two tracks never satisfy this — they share priors and process noise, so even perfect knowledge of x leaves their errors entangled.
Everything from Chapter 3 onward is about what to do when the addition theorem's hypothesis fails. Channel filters restore the hypothesis by subtracting the overlap. CI abandons addition for a convex combination. Federated filtering splits the shared terms up front so that addition becomes legal again.
Here is the smallest crime scene in distributed estimation: two nodes, one shared prior, one measurement each. Add their posteriors and you have committed the canonical sin. Let us catch it in four lines of algebra.
The setup, with full numbers. Shared prior N(0, 4). Node A measures zA = 1.2; node B measures zB = 0.8; both with measurement variance R = 1. Each runs a perfectly legal Bayes update — nobody has made an error yet. Node A ends up holding N(0.96, 0.8); node B holds N(0.64, 0.8).
Now commit the crime: fuse by addition. Y = 1.25 + 1.25 = 2.5 and y = 1.2 + 0.8 = 2.0, so the naive fused belief is N(0.8, 0.4). Compare the truth: the centralized filter sees the prior once plus both measurements, Y = 0.25 + 1 + 1 = 2.25, giving N(0.8889, 0.4444). The naive answer is sharper and biased toward the prior mean — because the prior voted twice.
Extract the identity and frame it, because it is the entire field's problem statement in one line:
The excess is exactly the common information — here, the shared prior's Y0 = 0.25. Every algorithm in this lesson is an accounting strategy for that excess term.
The damage is not just bookkeeping — it is a measurable estimator property. The naive fused mean (zA + zB)/2.5 has an actual error variance of 0.48 (worked below), while claiming 0.4. Its expected NEES is 1.2 instead of 1: measurably, testably overconfident, detectable with the machinery from debugging consistency.
Now let the crime compound. In a cyclic network, node A's measurement travels A→B→C→A. When it returns home wearing C's posterior, node A cannot recognize its own information inside it — and adds it again. Each lap around the loop re-counts the same evidence. This is rumor propagation: confidence spirals upward while no new physics happens.
Understand why this is hard, not merely careless. In a decentralized network with latency, dropouts, and no global registry, no node knows what any other node already knows. Common information is not a bug you patch; it is a quantity you must either track exactly (Chapter 4), bound conservatively (Chapter 5), pre-allocate (Chapter 7), or dilute by averaging (Chapter 8).
Node A makes ONE measurement (the glowing packet, worth Y = 1 unit of information). Step hops it around the cycle inside each posterior; every receiving node re-adds it. The bars show each node's claimed information against the dashed line at the TRUE total in the whole network. Break the loop and the packet propagates once to everyone — then the bars freeze at the honest level.
Shared prior N(0, 4). Node A measures zA = 1.2, node B measures zB = 0.8, both with measurement variance R = 1. Compare naive information addition of the two posteriors against the centralized answer, then compute what the naive fuser's REAL error variance is.
If the crime is counting shared evidence twice, the honest fix is an accountant: on every communication link, keep a running ledger of everything the two endpoints both know — and subtract it at fusion time.
Start from the identity we just proved: Ynaive = Ycentral + Ycommon. So compute the fusion as
The channel filter (the heart of Grime & Durrant-Whyte's decentralized data fusion architecture) is a small filter living on the link itself, whose entire job is to maintain (Ycommon, ycommon).
What does the ledger hold, and how does it evolve? After an exchange, both endpoints hold the same fused posterior — so that is now their common information, and the channel stores it. Between exchanges, both nodes predict with the same F and Q, so the channel applies the same predict to its stored ledger. New local measurements are the only thing the ledger does not contain — exactly the increments that deserve to be added.
One round on a two-node link, mechanically: (1) both nodes and the channel run the identical information-form predict; (2) each node adds its own local measurement increment; (3) they exchange posteriors; (4) each computes YA + YB − Ych; (5) both nodes — and the ledger — now hold the fused result. The exactness proof is one line:
— which is precisely the centralized update. Not approximately: bit for bit.
Scale from a link to a network. On a tree (no cycles), each node runs one channel filter per neighbor, and information percolates hop by hop with every overlap correctly subtracted. The decentralized network is exactly equivalent to the centralized filter, with delay equal to the graph diameter. The structural reason is the same one that makes message passing exact on trees: each link separates the tree into two halves, so pairwise ledgers capture ALL shared information.
Now break it honestly, because quals will. Loops. With a cycle A–B–C–A, information from A reaches C by two paths. The A–C channel ledger only knows what crossed the A–C link; the copy that arrived via B looks brand new. Pairwise bookkeeping cannot represent multi-hop overlap — double counting returns, slower than naive fusion but just as inexorable.
And the operational fragilities: links must be reliable (a dropped message desynchronizes the ledger), communication should be full-rate or carefully burst-reconciled, and dynamic topologies — nodes joining, links re-routing around failures, the exact survivability we wanted! — silently create temporary cycles. Practical systems either enforce a spanning tree by protocol or give up exactness for CI (next chapter).
Three nodes track a slowly drifting scalar; a ledger box sits on each edge showing its stored information. Step round: predict, local measurements, then ledger-subtracting exchanges — the readout shows the live arithmetic YA + YB − Ych. The bars compare node A's information with a centralized ghost fed all measurements: exactly equal, step after step. Then add the loop edge and watch the equality break.
Same scenario as Chapter 3: shared prior N(0, 4), zA = 1.2 and zB = 0.8 with R = 1. Now fuse with a channel filter whose ledger holds the common information — the shared prior.
The exactness theorem as executable code — a dynamic 1D constant-velocity target, two sensors, full-rate comms on one link. The ledger predicts alongside the nodes, the fusion subtracts it, and the assert at the bottom demands bit-for-bit equality with the centralized information filter, every step, for 25 steps.
python — channel filter == centralized, on a tree import numpy as np # 1D constant-velocity target, two sensors, full-rate comms on one link. dt = 1.0 F = np.array([[1, dt], [0, 1]]) Q = 0.05 * np.array([[dt**3/3, dt**2/2], [dt**2/2, dt]]) H = np.array([[1.0, 0.0]]) R_A, R_B = np.array([[1.0]]), np.array([[2.25]]) def to_info(x, P): Y = np.linalg.inv(P) return Y, Y @ x def from_info(Y, y): P = np.linalg.inv(Y) return P @ y, P def predict_info(Y, y): x, P = from_info(Y, y) # info-form predict = round-trip return to_info(F @ x, F @ P @ F.T + Q) rng = np.random.default_rng(7) x_true = np.array([0.0, 1.0]) x0, P0 = np.array([0.0, 0.8]), np.diag([4.0, 1.0]) Yc, yc = to_info(x0, P0) # centralized reference YA, yA = to_info(x0, P0) # node A YB, yB = to_info(x0, P0) # node B Ych, ych = to_info(x0, P0) # channel ledger: what A and B both know for k in range(25): x_true = F @ x_true + rng.multivariate_normal(np.zeros(2), Q) zA = H @ x_true + rng.normal(0, np.sqrt(R_A[0, 0]), 1) zB = H @ x_true + rng.normal(0, np.sqrt(R_B[0, 0]), 1) iA, IA = H.T @ np.linalg.inv(R_A) @ zA, H.T @ np.linalg.inv(R_A) @ H iB, IB = H.T @ np.linalg.inv(R_B) @ zB, H.T @ np.linalg.inv(R_B) @ H Yc, yc = predict_info(Yc, yc); Yc, yc = Yc + IA + IB, yc + iA + iB YA, yA = predict_info(YA, yA); YA, yA = YA + IA, yA + iA YB, yB = predict_info(YB, yB); YB, yB = YB + IB, yB + iB Ych, ych = predict_info(Ych, ych) # the ledger predicts too! Yf, yf = YA + YB - Ych, yA + yB - ych # fuse, minus common info YA, yA = Yf.copy(), yf.copy() # both nodes adopt the fusion YB, yB = Yf.copy(), yf.copy() Ych, ych = Yf.copy(), yf.copy() # ...which is now the shared info xf, Pf = from_info(Yf, yf) xc, Pc = from_info(Yc, yc) print('decentralized:', np.round(xf, 6), ' P[0,0] =', round(Pf[0, 0], 8)) print('centralized: ', np.round(xc, 6), ' P[0,0] =', round(Pc[0, 0], 8)) assert np.allclose(xf, xc) and np.allclose(Pf, Pc) print('channel filter == centralized on a tree: PASS')
Channel filters demand that you know what the other node knows. On a real network — loops, dropouts, nodes joining mid-mission — you cannot. Covariance intersection is the algebra of fusing under confessed ignorance.
The recap in two sentences (the derivation and ω-optimization theory live in covariance intersection). Instead of ADDING informations, take a convex combination: Y = ωYA + (1 − ω)YB and y = ωyA + (1 − ω)yB, with ω chosen to minimize the trace or determinant of the fused covariance. The result is consistent — claimed covariance never smaller than the truth — for ANY unknown cross-correlation.
The density-level view generalizes it, and this is the PhD framing. CI is the Gaussian case of the geometric mean density — also called generalized CI (GCI), Chernoff fusion, or the log-linear pool:
It averages log-beliefs instead of multiplying beliefs. And that one design choice carries a one-line immunity proof — the intellectual heart of this chapter. Suppose both densities contain a common factor (the rumor): pA = pc qA and pB = pc qB. Then
The exponents on the common factor SUM TO ONE. Shared information enters exactly once, for every ω. Double counting is structurally impossible — with no knowledge of what the shared factor even is.
Contrast with multiplication to sharpen it: naive Bayes fusion multiplies densities, so the common factor appears as pc² — that IS double counting, seen at the density level. The geometric mean is exactly the multiplication rule with the redundancy divided back out when you cannot measure it.
Now pay the bill honestly. If the two estimates actually WERE independent, GCI still only counts their independent parts with weights ω and 1−ω — it under-uses genuinely new evidence. On the Chapter 3 numbers (worked below): GCI at ω = 0.5 reports variance 0.8 where the exact answer is 0.4444 — consistent (the actual error variance 0.48 sits safely below 0.8) but nearly twice as pessimistic as necessary. Conservatism is the price of correlation-agnosticism.
Position the three regimes as an engineering dial: know the overlap exactly → subtract it (channel filter, exact). Know the cross-covariance → account for it (Bar-Shalom–Campo, next chapter). Know nothing → geometric mean (consistent, conservative). Real systems mix them: channel filters inside a well-managed subtree, CI at the boundary where subtrees meet.
Warm and teal are estimates A and B. Red dashed is naive addition — always the smallest ellipse. Purple is the CI/GCI ellipse at your ω. The thin gray family shows the EXACT fused ellipse for each possible cross-correlation ρ — the truths you cannot rule out. The visual theorem: the CI ellipse bounds every gray candidate; the naive ellipse fails most of them. The inset plots det(Pfused) versus ω with the minimizer ω* marked.
Same two node posteriors as Chapter 3 — N(0.96, 0.8) and N(0.64, 0.8), built from a shared prior N(0, 4) and measurements zA = 1.2, zB = 0.8 with R = 1. Fuse with the geometric mean at ω = 0.5 and audit consistency.
This is the shape of CI in a real system — the same structure as Stone Soup's covariance-intersection fuser or a MATLAB trackFuser with a CI-style algorithm: ω chosen per fusion call by bounded scalar minimization, correlation-agnostic, safe to call on any pair of incoming tracks.
python — production CI/GCI fuser import numpy as np from scipy.optimize import minimize_scalar def ci_fuse(xa, Pa, xb, Pb, cost='det'): """Covariance-intersection fusion of two track estimates with UNKNOWN cross-covariance. Consistent for any correlation. cost: 'det' (information volume) or 'trace' (total variance).""" Ya, Yb = np.linalg.inv(Pa), np.linalg.inv(Pb) if cost == 'det': f = lambda w: np.linalg.det(np.linalg.inv(w*Ya + (1-w)*Yb)) else: f = lambda w: np.trace(np.linalg.inv(w*Ya + (1-w)*Yb)) w = minimize_scalar(f, bounds=(1e-6, 1-1e-6), method='bounded').x Y = w*Ya + (1-w)*Yb # convex info combination P = np.linalg.inv(Y) x = P @ (w*(Ya @ xa) + (1-w)*(Yb @ xb)) return x, P, w # Two tracks of the same target from different sites; nobody knows P_AB. xa, Pa = np.array([10.6, 0.4]), np.array([[1.0, 0.2], [0.2, 0.5]]) xb, Pb = np.array([9.8, 0.7]), np.array([[1.5, -0.1], [-0.1, 0.3]]) x, P, w = ci_fuse(xa, Pa, xb, Pb) print('omega* =', round(w, 4)) print('fused x =', np.round(x, 4)) print('fused P =') print(np.round(P, 4)) # Production notes: cache omega* as the warm start for the next frame; # fall back to fixed omega = 0.5 on embedded targets (fast CI); and use # exact channel-filter fusion instead wherever the link topology is a # guaranteed tree -- CI is the boundary rule, not the everywhere rule.
Two independent radars, independent noise, independently initialized filters — surely THESE two tracks are uncorrelated? No. The target itself correlates them: both filters are chasing the same random maneuvers.
Expose the mechanism precisely. Each filter's posterior error obeys ei(k|k) = (I − KiHi)(F ei(k−1|k−1) − wk) − Kivi. There is one true target, hence one process-noise sequence wk — and the SAME wk appears in both errors. The gust that pushed the aircraft surprised both filters identically. The independent measurement noises vA, vB contribute nothing to the cross terms, but Q injects fresh correlation every single step.
The recursion that quantifies it:
Even from PAB(0) = 0, the +Q term pumps the cross-covariance up to a steady state. In typical track-fusion regimes the steady-state correlation coefficient sits around 0.2–0.6 — never negligible.
Now pose the fusion problem as pure estimation: given unbiased xA, xB with covariances PA, PB and KNOWN cross-covariance PAB, find the minimum-variance linear combination. Derive it in the scalar case. Minimize Var(w xA + (1−w) xB) = w²PA + (1−w)²PB + 2w(1−w)PAB; set the derivative to zero:
In fusion form, this is the Bar-Shalom–Campo result:
Sanity-check the limits, because that is how you know you own a formula. PAB = 0 recovers standard independent fusion. PAB → PA means B is statistically A plus extra noise — and indeed the weight on B goes to zero: B adds nothing.
Be honest about the catch that motivates the previous chapter: the PAB recursion requires knowing BOTH filters' gains and models at every step. A fusion center rarely has that with vendor black-box trackers; a peer-to-peer network never does. That is exactly the information CI declines to require. BC when you can, CI when you cannot.
Track A (warm) and track B (teal), 1-σ ellipses. Drag ρ: the teal BC fused ellipse grows honestly with correlation, while the red dashed naive ellipse is frozen — naive ignores ρ. The dot cloud is 300 actual fused-error samples drawn with the TRUE correlation and combined with the NAIVE weights: watch it spill outside the red promise as ρ rises. Corner readout: claimed vs actual variance and the overconfidence factor.
Two unbiased track estimates of a scalar state: xA = 10.6 with PA = 1.0, and xB = 9.8 with PB = 1.5, with known cross-covariance PAB = 0.4 (correlation ρ = 0.3266). Fuse with Bar-Shalom–Campo and compare against naive independent fusion.
Channel filters subtract the overlap after the fact. The federated filter is sneakier: ration the shared information out BEFORE anyone filters, so that when you add the locals back together, the overlap sums to exactly one copy.
The architecture: a master filter and N local filters. The classic host is integrated navigation — one local filter per sensor suite (GPS/INS, baro/INS, star tracker; see INS/GNSS coupling). Each local runs a full Kalman filter; the master periodically fuses them by simple information addition. The design question: how can plain addition possibly be legal, given Chapter 3?
The trick is information-sharing factors. Give local i only a fraction βi of the common information, with Σβi = 1. Concretely: local prior covariance Pi(0) = P(0)/βi (inflated — less information), and local process noise Qi = Q/βi (also inflated). Each local is made deliberately underconfident about exactly the parts everyone shares.
The bookkeeping identity for the static case is one line. Local posterior information: Yi = βiY0 + Ii. Sum over i:
The common part was pre-paid in shares; the unique measurement parts add freely. The worked example below runs the Chapter 3 scenario with β = 1/2 each: local priors inflate to variance 8, and plain addition lands on 0.444444 — the centralized answer, no ledger needed.
Extend honestly to dynamics: process noise is ALSO common information — Chapter 6's lesson, the same wk drives every local's target model — hence Qi = Q/βi. Here the story loses exactness. Inflating Q bounds rather than reproduces the true cross-correlations, so dynamic federated fusion is CONSERVATIVE (provably an upper bound on the centralized covariance) rather than exact — the standard result, proved by a CI-style bounding argument.
The operating modes are a real design menu. Fusion-reset (FR): after each fusion the master resets every local to the β-split fused estimate. Best accuracy — but a master fault now poisons everyone; fault tolerance is lost. No-reset (NR): locals never hear back. A GPS spoof corrupts only the GPS local, and the master can exclude it after detection. This fault isolation is WHY aerospace navigation adopted federated filters. Beta choice: βi = 1/N is standard; performance-weighted betas favor better sensors.
A master above two locals. Drag βA: one local's prior ellipse inflates, the other's deflates (Pi = P0/βi) — but the master's summed information bar sits EXACTLY flush against the dashed centralized line for every β. Then spoof sensor B: in NR mode, Exclude B recovers a clean estimate; in FR mode the resets have already pushed the poison into A.
Chapter-3 scenario again: prior N(0, 4), measurements zA = 1.2 and zB = 0.8 with R = 1. Federated with equal shares βA = βB = 1/2: each local receives the prior DEFLATED by its share, then the master fuses by plain addition.
No center, no tree, no ledger — just neighbors whispering averages to neighbors. Remarkably, that is enough: repeated local averaging computes a global sum that no single node could see.
The structural problem first. The centralized information update needs the SUM over all nodes of the increments (Ik, ik) = (HTR−1H, HTR−1z) — a global quantity. In a peer-to-peer network with unknown global topology, nobody can compute a global sum directly. But there is a distributed primitive that gets arbitrarily close: average consensus.
Define it precisely. Each node holds a value ui. Repeatedly, every node replaces its value with a weighted average of itself and its neighbors: u ← Wu. If W is doubly stochastic (every row AND every column sums to 1), the total sum is invariant at every step; if the graph is connected, all values converge to the common average (1/N)Σui. Metropolis weights — Wij = 1/(1 + max(di, dj)) on edges, remainder on the diagonal — achieve double stochasticity using only LOCAL degree information. No node needs the global picture even to build W.
Quantify the speed, because quals will ask. Stack the iteration as u(k) = Wku(0); the disagreement decays as λ2k, where λ2 is the second-largest eigenvalue modulus (SLEM) of W. For the 4-node chain below, SLEM = 0.8047 — about 53 iterations for 10−5 accuracy. Better-connected graphs have smaller SLEM (a larger spectral gap) and converge faster. Topology IS convergence rate.
Four nodes in a chain 1–2–3–4 with Metropolis weights. Node 1 holds value 4 (its local information contribution); the others hold 0. The network average is 1. Iterate u ← Wu and audit conservation, convergence, and rate.
Now assemble the consensus information filter: between measurements, nodes run L consensus iterations on their local increments; each node then updates its posterior with N times the consensus average — because the update needs the sum, not the mean. Two honest catches. You must know N (or estimate it). And with finite L the partially-mixed sum is not the true sum: under-mixed nodes over-weight their own information, and consistency quietly leaks away as L shrinks.
The consistent repair — the modern default — is to run consensus ON THE POSTERIORS with CI-style convex weights (consensus-on-information; Battistelli & Chisci's hybrid CM-CI). Because every consensus step is then a convex information combination, Chapter 5's immunity applies at every iteration: the result is provably consistent for ANY number of iterations L, trading optimality (approached as L grows) for a guarantee that holds even at L = 1.
One hot node holds 4; the rest hold 0. Each Step applies the Metropolis averaging u ← Wu: colors bleed toward uniform, the strip chart funnels every node into the dashed average, and the log inset shows the error falling on a straight line whose slope is log(SLEM). The running sum stays pinned. Add edges (topology button) and watch the SLEM drop — connectivity literally buys convergence speed.
Everything this lesson claimed, running live: four radar nodes, one aircraft, three topologies, three fusion algorithms — and a NEES strip chart that acts as a lie detector.
The arena: four sensor nodes near the corners of a 2D region, one target flying a constant-velocity path with gentle random accelerations. Each node runs a local 4-state information filter on its own noisy position measurements. The noise is anisotropic and oriented toward the node — each local ellipse is elongated differently, so fusion has real geometric value, not just averaging.
Two control axes, and you should predict before you run — this lesson's own method. Topology (chain / tree / loop) determines whether pairwise ledgers can capture all common information. Algorithm (naive add / channel filter / CI) determines what bookkeeping is even attempted. Fill the 3×3 exactness–consistency matrix in your head first; then let the NEES trace grade you.
Experiment 1 — naive on the chain. Even with no cycle, repeated exchanges re-add overlapping posteriors: watch node A's ellipse shrink below the dashed centralized ghost while the NEES trace climbs out of the chi-square band within seconds. Naive is not "fine on simple topologies" — it is wrong everywhere there is repeated exchange.
Experiment 2 — channel filter on chain and tree. The fused ellipse locks onto the centralized ghost, and NEES rides inside the band at its expected value. Then flip to the loop: the same algorithm, same code, begins over-counting via the second path — NEES departs the band slowly but monotonically. The failure is structural, not a bug.
Experiment 3 — CI everywhere. On every topology the CI ellipse is visibly larger than the ghost (the conservatism tax made visible), but the NEES trace stays at or below the band's center: honest on the chain, honest on the loop, honest with dropouts. Then run the killer comparison: enable link dropouts and watch the channel filter's ledger desynchronize even on the tree, while CI does not care.
Node A's fused 95% ellipse (algorithm color) vs the dashed centralized ghost. Right (or below on phones): node A's position NEES on a log scale with the 95% chi-square band [0.05, 7.38] shaded; the last runs persist as faded traces for comparison. Corner readouts: trailing mean NEES, claimed σ vs actual RMSE, messages per fusion round.
You have the machinery. Now sit the exam: eight questions of the kind that open a distributed-estimation quals, each expecting derivation, limits, and judgment — not recitation. Attempt each on paper (or the Teach whiteboard) BEFORE expanding the worked answer. The answers are graded sketches: full credit requires the algebra plus the sanity checks at the limits.
The questions group into four themes: bookkeeping identities (Q1, Q8), correlation mechanics (Q2, Q3), consistency theory (Q4, Q6), and systems judgment (Q5, Q7). If one theme feels soft, its chapter number is in the answer.
Local posteriors: YA = Y0 + IA, YB = Y0 + IB where Ii = HiTRi−1Hi. Naive sum: YA + YB = 2Y0 + IA + IB = (Y0 + IA + IB) + Y0 = Ycentral + Y0. The excess is exactly Y0 — the common information (here, the shared prior). Numerically (Chapter 3): 1.25 + 1.25 = 2.5 versus centralized 2.25; claimed variance 0.4 versus honest 0.4444, actual error variance 0.48, expected NEES 1.2.
Fix 1: subtract the overlap — channel filter, Y = YA + YB − Ycommon; exact, but requires knowing the overlap, i.e. tree topology with reliable full-rate links. Fix 2: convex combination — CI/GCI, Y = ωYA + (1−ω)YB; consistent for ANY unknown overlap on any topology, at the price of conservatism (claims 0.8 at ω = 1/2 where exact is 0.4444).
Seek xF = wxA + (1−w)xB, unbiased for any w. Var = w²PA + (1−w)²PB + 2w(1−w)PAB. Setting d/dw = 0: 2wPA − 2(1−w)PB + 2(1−2w)PAB = 0, giving w* = (PB − PAB)/(PA + PB − 2PAB). Substituting yields PF = PA − (PA − PAB)²/(PA + PB − 2PAB) = (PAPB − PAB²)/(PA + PB − 2PAB).
Limit PAB = 0: PF = PAPB/(PA + PB) — harmonic combination, the standard independent fusion. Limit PAB = PA (with PA ≤ PB): w* = (PB − PA)/(PB − PA) = 1, so xF = xA and PF = PA — correct, because B is then statistically A plus extra noise and contributes nothing new. Worked numbers (Chapter 6): PA = 1, PB = 1.5, PAB = 0.4 gives w* = 0.6471, PF = 0.7882; the naive information weights deliver actual variance 0.792 while claiming 0.6.
Write each filter's posterior error as ei(k|k) = (I − KiHi)ei(k|k−1) − Kivi(k) with ei(k|k−1) = F ei(k−1|k−1) − w(k): there is ONE target, hence ONE process-noise realization w(k) in both errors. Then PAB(k|k) = E[eAeBT] = (I − KAHA)(F PAB(k−1|k−1) FT + Q)(I − KBHB)T.
The measurement noises are independent, so no KARKBT term appears — but Q appears in the cross term because the same w(k) surprised both filters. Even from PAB(0) = 0, the +Q pump drives PAB to a nonzero steady state; classic track-fusion analyses put the steady-state correlation around 0.2–0.6, which Chapter 6's numbers show is enough for a 1.32× overconfidence if ignored. Corollary: "independent sensors" never implies "independent tracks."
GCI/Chernoff fusion: pF ∝ pAwpB1−w, w ∈ [0,1] — the w-weighted geometric mean (log-linear pool). Immunity: suppose both inputs share a common factor, pA = pcqA, pB = pcqB. Then pAwpB1−w = pcw+(1−w)qAwqB1−w = pc1 × (weighted independent parts): the shared factor enters with exponent exactly 1 for EVERY w — double counting is structurally impossible, with no knowledge of what pc is. For Gaussians this reduces to CI: Y = wYA + (1−w)YB, y = wyA + (1−w)yB.
The bill: if the inputs were independent, exact fusion would use exponent 1 on each unique factor, but GCI uses w and 1−w — it under-exploits genuinely new evidence. Chapter 5's numbers: claimed 0.8 at w = 1/2 versus exact 0.4444, with actual error 0.48 — consistent but ~1.8× pessimistic. w is chosen by minimizing det or trace of the fused covariance (theory in sf-11).
Static case: master assigns local i the deflated prior information βiY0 with Σβi = 1 (i.e. Pi(0) = P0/βi). Local posteriors: Yi = βiY0 + Ii. Master fuses by plain addition: ΣYi = (Σβi)Y0 + ΣIi = Y0 + ΣIi = Ycentralized — exact, one line. Numbers (Chapter 7): β = 1/2 each turns prior variance 4 into local priors of variance 8; locals post at 0.8889 each; the sum lands at 0.4444, matching centralized to machine precision.
Dynamic case: process noise is also common information — the same w(k) drives every local's model — so Carlson inflates Qi = Q/βi. But inflation only UPPER-BOUNDS the effect of the cross-correlations that shared Q creates between locals; the fusion is then conservative (guaranteed not overconfident) rather than exact. Modes: fusion-reset (FR) resets locals to β-split fused estimates — better accuracy, but a master fault propagates to all locals; no-reset (NR) keeps locals independent — degraded accuracy, but a spoofed sensor corrupts only its own local and can be excluded, which is why fault-tolerant navigation uses NR.
Nodes run average consensus u ← Wu on their local information increments (Ii, ii) = (HiTRi−1Hi, HiTRi−1zi), with W doubly stochastic (e.g. Metropolis weights, buildable from local degrees). Double stochasticity conserves the sum; connectivity drives all values to the average (1/N)Σ. Since the centralized update needs the SUM, each node scales its converged value by N — which requires knowing N. Convergence is geometric at the SLEM: Chapter 8's chain has SLEM 0.8047, needing ~53 iterations for 10−5.
At L = 2 the sum is only partially mixed: nodes far from information sources hold too little, nodes near their own contributions effectively over-weight themselves, and the ×N scaling converts under-mixing into overconfidence — the filter is NOT consistent. The consistent repair is consensus on POSTERIORS with CI/convex weights (consensus-on-information, Battistelli–Chisci hybrid CM-CI): every iteration is then a convex information combination, Chapter 5's immunity applies at each step, and consistency holds for ANY L — with optimality approached as L grows.
Naive addition: requires conditional independence of everything fused — violated by the cycle (rumors) and even by repeated exchange on a line; NEES diverges; disqualified regardless of cost. Channel filters: exact ONLY on trees with reliable synchronized links; the cycle makes multi-hop common information invisible to per-edge ledgers, and dropouts desynchronize even a tree's ledgers — both preconditions fail, so exactness is unobtainable; a spanning-tree overlay could restore it at the cost of discarding the chord's links and adding protocol machinery. GCI: consistent under arbitrary unknown correlation, any topology, indifferent to dropouts (a missed message just means less tightening this round); cost is conservatism plus a small ω optimization per fusion.
Deployment answer: GCI (or CI on the Gaussian parts) as the default, with channel filters only inside sub-networks whose tree topology is protocol-guaranteed, and periodic centralized audits (or NEES monitoring per sf-21) to measure the conservatism actually being paid.
After the first naive fusion both nodes hold (Y1, y1) with Y1 = YA + YB. Each subsequent mutual exchange adds the partner's identical information: Y(k) = 2Y(k−1), so Y(k) = 2k−1Y1 and claimed variance P(k) = P1/2k−1 → 0. The mean never moves after round one: y doubles in lockstep with Y, so y/Y is constant — no new measurement entered, so the actual error variance stays fixed at its round-one value.
NEES(k) = e²/P(k) = 2k−1 × NEES(1): it DOUBLES every round. With Chapter 3's numbers NEES(1) = 1.2, so ten exchanges reach NEES around 614 — a filter reporting near-certainty with unchanged error. This is the Chapter 0 sim in algebra, and the cleanest oral-exam demonstration that fusion frequency is not accuracy.
No single right answer here — but there are defensible and indefensible positions. Argue with the exactness/consistency/cost triangle, not with vibes.
Strip away the algebra and this was a lesson about one question asked four ways. Common information is the conserved quantity of distributed estimation. Channel filters TRACK it. CI/GCI BOUNDS it. Federated filtering PRE-ALLOCATES it. Consensus DILUTES it into an average. Every future paper you meet in this field is a refinement of one of these four verbs.
| Method | Exact? | Consistent? | Topology needs | Must know | Comm cost | Canonical habitat |
|---|---|---|---|---|---|---|
| Naive addition | Never (repeated exchange) | No | — | Nothing (and it shows) | 1 track/exchange | Bug reports |
| Channel filter | Yes, on trees | Only on trees, reliable links | Spanning tree, full-rate | Per-link shared history | 1 track + ledger upkeep | Decentralized robotics, DDF |
| Bar-Shalom–Campo | Best linear given PAB | Yes, if PAB known | Pairwise | Cross-covariance (both gains) | 1 track + PAB upkeep | Track-fusion centers |
| CI / GCI | No (conservative) | Yes, any correlation | Any graph | Nothing | 1 track + ω search | Loopy / ad-hoc networks |
| Federated (β-split) | Static yes; dynamic conservative | Yes | Master + fixed locals | N and shares up front | Locals→master at fusion rate | Integrated navigation |
| Consensus + CI | No (→ optimal as L→∞) | Yes, any L | Any connected graph | Neighbors' degrees (and N if scaling) | L iterations/timestep | Large sensor networks |
Map the methods to the systems that ship them. Federated filters live in integrated aerospace navigation (INS/GNSS coupling). Track-to-track fusion with BC and CI runs in air-surveillance networks and automotive perception (multimodal driving fusion). GCI over PHD intensities powers distributed multi-target tracking (multi-target RFS). Consensus information filters are the workhorse of large-scale sensor networks. And the channel-filter DDF lineage lives on in decentralized robotics and multi-robot SLAM map merging.
What this lesson deliberately did NOT cover, with pointers. The information-filter algebra itself: sf-09. The CI derivation, ω-optimization theory, and split/inverse CI: sf-11. The architecture taxonomy and JDL levels: sf-02. Track-to-track ASSOCIATION — deciding two tracks are the same object before fusing them: sf-12. The NEES/NIS testing machinery used throughout as our lie detector: sf-21. The single-node predict–update core every network node runs: the Kalman filter. Out-of-sequence and delayed-measurement handling is its own literature — know that it exists.
The research frontier, honestly: learned communication policies for when-to-transmit, distributed fusion under adversarial nodes (Byzantine resilience), event-triggered consensus, and correlation-aware learned fusers. All of it is still argued in the vocabulary this lesson built — common information, consistency, conservatism.
You now know the four disciplines of fusing without double counting. Ask "what do we both already know?" of every network you build.